diff --git a/README.md b/README.md index 6df4adb091..bb7325a6a6 100644 --- a/README.md +++ b/README.md @@ -106,7 +106,7 @@ Snapshot coordinates and repository setup are on the ## Performance **11× faster than 5.3**, and the fastest parser on real-world SQL of any of the parsers -tested, in any language — 19× ahead of `sqlglot[c]` on JSqlParser's own `SELECT` test suite. +tested, in any language — 19× ahead of `sqlglot[c]` on JSqlParser's own `SELECT` test suite. And the community kept sending performance improvements since. Thank you everyone!
@@ -116,7 +116,8 @@ tested, in any language — 19× ahead of `sqlglot[c]` on JSqlParser's own `SELE ```text Benchmark (version) Mode Cnt Score Error Units -JSQLParserBenchmark.parseSQLStatements latest avgt 15 32.525 ± 0.413 ms/op +JSQLParserBenchmark.parseSQLStatements latest avgt 15 21.138 ± 0.557 ms/op <-- Community sponsored improvements! +JSQLParserBenchmark.parseSQLStatements 5.4 avgt 15 32.528 ± 0.666 ms/op JSQLParserBenchmark.parseSQLStatements 5.3 avgt 15 983.459 ± 8.197 ms/op JSQLParserBenchmark.parseSQLStatements 5.1 avgt 15 319.601 ± 4.081 ms/op ``` @@ -142,8 +143,37 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J | **ksqlDB windows** | JOIN `WITHIN`, window `GRACE PERIOD`, and `EMIT CHANGES`/`FINAL` | | **ClickHouse column selection** | `COLUMNS('regexp')` select items with chained `APPLY`, `EXCEPT`, and `REPLACE` transformers | | **DML** | `INSERT` · `UPDATE` · `UPSERT` · `MERGE` · `DELETE` · `TRUNCATE TABLE` | +| **Oracle RETURNING** | Named output binds (`INTO :name`), JDBC output parameters (`INTO ?`), and `BULK COLLECT INTO` | | **DDL** | `CREATE …` · `ALTER …` · `DROP …` | +| **Oracle vector types** | `VECTOR(*, *)` · `VECTOR(*, FLOAT32)` · `VECTOR(3, *)`, including dense and sparse storage formats | +| **PostgreSQL ownership** | `DROP OWNED` · `REASSIGN OWNED` | +| **Two-phase commit** | PostgreSQL `PREPARE TRANSACTION` · `COMMIT PREPARED` · `ROLLBACK PREPARED` · MySQL `XA START`/`END`/`PREPARE`/`COMMIT`/`ROLLBACK`/`RECOVER` | +| **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` | +| **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` | +| **MySQL replication** | `CHANGE REPLICATION SOURCE TO` · `CHANGE REPLICATION FILTER` · `START`/`STOP REPLICA` · `RESET REPLICA` · `RESET BINARY LOGS AND GTIDS` · `PURGE BINARY LOGS` | +| **MySQL data loading** | `LOAD DATA` · `LOAD XML` · `SELECT … INTO OUTFILE` with the same `FIELDS` and `LINES` clauses | +| **MySQL account management** | `CREATE`/`ALTER`/`RENAME USER` · `CREATE ROLE` · `SET ROLE` · `SET DEFAULT ROLE` · `SET PASSWORD` | +| **Tablespaces** | MySQL and PostgreSQL `CREATE TABLESPACE` · `ALTER TABLESPACE` | +| **MySQL spatial reference systems and instance** | `CREATE`/`DROP SPATIAL REFERENCE SYSTEM` · `ALTER INSTANCE` | +| **Routine changes** | `ALTER FUNCTION` · `ALTER PROCEDURE` · `ALTER ROUTINE` · PostgreSQL `ALTER TRIGGER` | +| **MySQL metadata statements** | `SHOW [FULL] COLUMNS`/`FIELDS` · `SHOW INDEX`/`INDEXES`/`KEYS` · `SHOW TABLE STATUS` · `SHOW CREATE TABLE`/`VIEW`/`PROCEDURE`/`FUNCTION`/`TRIGGER`/`EVENT`/`DATABASE`/`USER` · `SHOW [GLOBAL | SESSION] VARIABLES`/`STATUS` · `SHOW [FULL] PROCESSLIST` · `SHOW GRANTS [FOR …]` · `SHOW WARNINGS`/`ERRORS` · `SHOW BINARY LOGS`/`BINLOG EVENTS`/`RELAYLOG EVENTS` · `SHOW ENGINE …` · `SHOW PROFILE` · `SHOW DATABASES`/`TRIGGERS`/`EVENTS`/`OPEN TABLES`/`CHARACTER SET`/`COLLATION` · `SHOW PROCEDURE`/`FUNCTION STATUS`/`CODE` · `SHOW REPLICA STATUS`/`REPLICAS` | +| **MySQL utility statements** | `EXPLAIN`/`DESCRIBE [ANALYZE] FORMAT = …` · `EXPLAIN FOR CONNECTION` · `DESCRIBE t col` · `PREPARE … FROM` · `EXECUTE … USING` · `DROP PREPARE` · `DO` | +| **PostgreSQL administration** | `CREATE`/`ALTER EVENT TRIGGER` · `REINDEX` · `SECURITY LABEL` | +| **PostgreSQL types and rules** | `CREATE TYPE` (shell, composite, enum, range and base types) · `ALTER TYPE` · `CREATE RULE` · `ALTER RULE` | +| **PostgreSQL casts, transforms and conversions** | `CREATE CAST` · `DROP CAST` · `CREATE [OR REPLACE] TRANSFORM` · `DROP TRANSFORM` · `CREATE [DEFAULT] CONVERSION` · `ALTER CONVERSION` | +| **PostgreSQL metadata objects** | `CREATE`/`ALTER [PROCEDURAL] LANGUAGE` · `ALTER LARGE OBJECT … OWNER TO` · `CREATE`/`ALTER TEXT SEARCH DICTIONARY` · `CREATE`/`ALTER TEXT SEARCH PARSER` · `CREATE`/`ALTER TEXT SEARCH TEMPLATE` | +| **PostgreSQL operators and aggregates** | `CREATE`/`ALTER OPERATOR` · `CREATE`/`ALTER OPERATOR CLASS` · `CREATE`/`ALTER OPERATOR FAMILY` · `CREATE`/`ALTER AGGREGATE` | | **Informix constraints** | `ALTER TABLE … ADD CONSTRAINT` with trailing constraint names for primary, unique, foreign and check constraints; enable with `parser.withDialect(Dialect.INFORMIX)` | | **Salesforce SOQL** | `INCLUDES` · `EXCLUDES` | diff --git a/build.gradle b/build.gradle index b7a3112747..d3d57be1d4 100644 --- a/build.gradle +++ b/build.gradle @@ -165,13 +165,13 @@ dependencies { xmlDoclet ('com.manticore-projects.tools:xml-doclet:+'){ changing = true } // enforce latest version of JavaCC - testImplementation('com.manticore-projects.jsqlformatter:javacc-core:[8.1.2.1941,)') - testImplementation('com.manticore-projects.jsqlformatter:javacc-java:[8.1.2.1941,)') + testImplementation('com.manticore-projects.jsqlformatter:javacc-core:[8.1.4.1944,)') + testImplementation('com.manticore-projects.jsqlformatter:javacc-java:[8.1.4.1944,)') jmh 'org.openjdk.jmh:jmh-core:+' jmh 'org.openjdk.jmh:jmh-generator-annprocess:+' - javacc('com.manticore-projects.jsqlformatter:javacc-core:[8.1.2.1941,)') - javacc('com.manticore-projects.jsqlformatter:javacc-java:[8.1.2.1941,)') + javacc('com.manticore-projects.jsqlformatter:javacc-core:[8.1.4.1944,)') + javacc('com.manticore-projects.jsqlformatter:javacc-java:[8.1.4.1944,)') } compileJavacc { @@ -276,7 +276,9 @@ test { jvmArgs = ['-Xss4m', '--add-opens=java.base/java.lang=ALL-UNNAMED'] jacoco { - excludes = ['net/sf/jsqlparser/parser/CCJSqlParserTokenManager'] + // the generated parser exceeds the constant-pool limit once instrumented (#2866) + excludes = ['net/sf/jsqlparser/parser/CCJSqlParserTokenManager', + 'net/sf/jsqlparser/parser/CCJSqlParser'] } } @@ -291,13 +293,23 @@ jacocoTestReport { csv.required = false html.outputLocation = layout.buildDirectory.dir('reports/jacoco') } + // the classes that are not instrumented, see test.jacoco + afterEvaluate { + classDirectories.setFrom(files(classDirectories.files.collect { + fileTree(dir: it, exclude: [ + "**/parser/CCJSqlParserTokenManager.class", + "**/parser/CCJSqlParser.class" + ]) + })) + } } jacocoTestCoverageVerification { - // Jacoco can't handle the TokenManager class + // Jacoco can't handle the TokenManager and the generated parser classes afterEvaluate { classDirectories.setFrom(files(classDirectories.files.collect { fileTree(dir: it, exclude: [ - "**CCJSqlParserTokenManager**" + "**/parser/CCJSqlParserTokenManager.class", + "**/parser/CCJSqlParser.class" ]) })) } diff --git a/src/main/java/net/sf/jsqlparser/expression/AnalyticExpression.java b/src/main/java/net/sf/jsqlparser/expression/AnalyticExpression.java index ce19f49cd9..0f8f56dd65 100644 --- a/src/main/java/net/sf/jsqlparser/expression/AnalyticExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/AnalyticExpression.java @@ -41,6 +41,7 @@ public class AnalyticExpression extends ASTNodeAccessImpl implements Expression private boolean unique = false; private boolean ignoreNullsOutside = false; // IGNORE NULLS outside function parameters private Expression filterExpression = null; + private boolean filterWhereKeyword = true; private List funcOrderBy = null; private String onOverflowTruncate = null; @@ -391,12 +392,22 @@ public String toString() { /** Renders the filter using the caller's expression writer. */ public void appendFilterTo(StringBuilder builder, Consumer expressionPrinter) { if (filterExpression != null) { - builder.append("FILTER (WHERE "); + builder.append(filterWhereKeyword ? "FILTER (WHERE " : "FILTER ("); expressionPrinter.accept(filterExpression); builder.append(')'); } } + /** Whether the FILTER clause has WHERE, which DuckDB allows to leave out. */ + public boolean isFilterWhereKeyword() { + return filterWhereKeyword; + } + + public AnalyticExpression setFilterWhereKeyword(boolean filterWhereKeyword) { + this.filterWhereKeyword = filterWhereKeyword; + return this; + } + public boolean isAllColumns() { return allColumns; } diff --git a/src/main/java/net/sf/jsqlparser/expression/ArrayExpression.java b/src/main/java/net/sf/jsqlparser/expression/ArrayExpression.java index e86f34cad8..74072efe34 100644 --- a/src/main/java/net/sf/jsqlparser/expression/ArrayExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/ArrayExpression.java @@ -17,6 +17,7 @@ public class ArrayExpression extends ASTNodeAccessImpl implements Expression { private Expression indexExpression; private Expression startIndexExpression; private Expression stopIndexExpression; + private Expression stepExpression; public ArrayExpression() { @@ -72,6 +73,19 @@ public void setStopIndexExpression(Expression stopIndexExpression) { this.stopIndexExpression = stopIndexExpression; } + public Expression getStepExpression() { + return stepExpression; + } + + public void setStepExpression(Expression stepExpression) { + this.stepExpression = stepExpression; + } + + public ArrayExpression withStepExpression(Expression stepExpression) { + this.setStepExpression(stepExpression); + return this; + } + @Override public T accept(ExpressionVisitor expressionVisitor, S context) { return expressionVisitor.visit(this, context); @@ -82,11 +96,8 @@ public String toString() { if (indexExpression != null) { return objExpression.toString() + "[" + indexExpression.toString() + "]"; } else { - return objExpression.toString() + "[" + - (startIndexExpression == null ? "" : startIndexExpression.toString()) + - ":" + - (stopIndexExpression == null ? "" : stopIndexExpression.toString()) + - "]"; + return objExpression.toString() + "[" + RangeExpression.toString(startIndexExpression, + stopIndexExpression, stepExpression) + "]"; } } diff --git a/src/main/java/net/sf/jsqlparser/expression/CastExpression.java b/src/main/java/net/sf/jsqlparser/expression/CastExpression.java index 66af39ed50..9c77ef825f 100644 --- a/src/main/java/net/sf/jsqlparser/expression/CastExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/CastExpression.java @@ -9,18 +9,17 @@ */ package net.sf.jsqlparser.expression; -import java.util.Locale; -import net.sf.jsqlparser.parser.ASTNodeAccessImpl; -import net.sf.jsqlparser.statement.create.table.ColDataType; -import net.sf.jsqlparser.statement.create.table.ColumnDefinition; -import net.sf.jsqlparser.statement.select.Select; - import java.util.ArrayList; +import java.util.Locale; import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; import java.util.regex.Matcher; import java.util.regex.Pattern; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.select.Select; public class CastExpression extends ASTNodeAccessImpl implements Expression { private final static Pattern PATTERN = @@ -204,7 +203,7 @@ public String toString() { if (isImplicitCast) { return colDataType + " " + leftExpression; } else if (keyword != null && !keyword.isEmpty()) { - return columnDefinitions.size() > 1 + return !columnDefinitions.isEmpty() ? keyword + "(" + leftExpression + " AS ROW(" + Select.getStringList(columnDefinitions) + ")" + formatStr + ")" : keyword + "(" + leftExpression + " AS " + colDataType.toString() + formatStr diff --git a/src/main/java/net/sf/jsqlparser/expression/ColumnsTransformer.java b/src/main/java/net/sf/jsqlparser/expression/ColumnsTransformer.java index 8fab9330e4..9f471fe16e 100644 --- a/src/main/java/net/sf/jsqlparser/expression/ColumnsTransformer.java +++ b/src/main/java/net/sf/jsqlparser/expression/ColumnsTransformer.java @@ -25,13 +25,17 @@ public class ColumnsTransformer extends ASTNodeAccessImpl { public enum ColumnsTransformerType { - APPLY, EXCEPT, EXCLUDE, REPLACE + APPLY, EXCEPT, EXCLUDE, REPLACE, RENAME } private ColumnsTransformerType type; private Expression applyExpression; private ParenthesedExpressionList exceptColumns; + private StringValue exceptPattern; private List> replaceItems; + private List> renameItems; + private boolean parenthesized = true; + private boolean strict; public ColumnsTransformer(ColumnsTransformerType type) { this.type = type; @@ -61,6 +65,39 @@ public ParenthesedExpressionList getExceptColumns() { public ColumnsTransformer setExceptColumns(ParenthesedExpressionList exceptColumns) { this.exceptColumns = exceptColumns; + if (exceptColumns != null) { + this.exceptPattern = null; + } + return this; + } + + /** + * The re2 pattern of the ClickHouse {@code EXCEPT 'pattern'} form, mutually exclusive with + * {@link #getExceptColumns()}. + */ + public StringValue getExceptPattern() { + return exceptPattern; + } + + public ColumnsTransformer setExceptPattern(StringValue exceptPattern) { + this.exceptPattern = exceptPattern; + if (exceptPattern != null) { + this.exceptColumns = null; + } + return this; + } + + /** + * The {@code STRICT} modifier of ClickHouse {@code EXCEPT}/{@code REPLACE} transformers: named + * columns must exist, otherwise the database rejects the query. Meaningless for {@code APPLY} + * and {@code EXCLUDE}. + */ + public boolean isStrict() { + return strict; + } + + public ColumnsTransformer setStrict(boolean strict) { + this.strict = strict; return this; } @@ -73,6 +110,30 @@ public ColumnsTransformer setReplaceItems(List> replaceItems) { return this; } + /** DuckDB's {@code RENAME (column AS name, ...)}: each item is a column with its new name. */ + public List> getRenameItems() { + return renameItems; + } + + public ColumnsTransformer setRenameItems(List> renameItems) { + this.renameItems = renameItems; + return this; + } + + /** + * Whether the columns or items of an {@code EXCLUDE}, {@code REPLACE} or {@code RENAME} are + * parenthesized; DuckDB also accepts a single one without parentheses, e.g. + * {@code * EXCLUDE i}. + */ + public boolean isParenthesized() { + return parenthesized; + } + + public ColumnsTransformer setParenthesized(boolean parenthesized) { + this.parenthesized = parenthesized; + return this; + } + void collectExpressions(List expressions) { switch (type) { case APPLY: @@ -81,6 +142,13 @@ void collectExpressions(List expressions) { } break; case EXCEPT: + if (exceptPattern != null) { + expressions.add(exceptPattern); + } + if (exceptColumns != null) { + expressions.addAll(exceptColumns); + } + break; case EXCLUDE: if (exceptColumns != null) { expressions.addAll(exceptColumns); @@ -93,6 +161,13 @@ void collectExpressions(List expressions) { } } break; + case RENAME: + if (renameItems != null) { + for (SelectItem item : renameItems) { + expressions.add(item.getExpression()); + } + } + break; default: throw new IllegalStateException("Unhandled ColumnsTransformerType: " + type); } @@ -104,13 +179,26 @@ public StringBuilder appendTo(StringBuilder builder) { builder.append("APPLY(").append(applyExpression).append(")"); break; case EXCEPT: - builder.append("EXCEPT ").append(exceptColumns); + builder.append("EXCEPT").append(strict ? " STRICT" : "").append(" ") + .append(exceptPattern != null ? exceptPattern : exceptColumns); break; case EXCLUDE: - builder.append("EXCLUDE ").append(exceptColumns); + builder.append("EXCLUDE ").append(parenthesized || exceptColumns.size() != 1 + ? exceptColumns + : exceptColumns.get(0)); break; case REPLACE: - builder.append("REPLACE(").append(Select.getStringList(replaceItems)).append(")"); + boolean replaceParenthesized = parenthesized || replaceItems.size() != 1; + builder.append("REPLACE").append(strict ? " STRICT" : "") + .append(replaceParenthesized ? "(" : " ") + .append(Select.getStringList(replaceItems)) + .append(replaceParenthesized ? ")" : ""); + break; + case RENAME: + boolean renameParenthesized = parenthesized || renameItems.size() != 1; + builder.append("RENAME ").append(renameParenthesized ? "(" : "") + .append(Select.getStringList(renameItems)) + .append(renameParenthesized ? ")" : ""); break; default: throw new IllegalStateException("Unhandled ColumnsTransformerType: " + type); diff --git a/src/main/java/net/sf/jsqlparser/expression/DateUnitExpression.java b/src/main/java/net/sf/jsqlparser/expression/DateUnitExpression.java index 61fa514ffc..f3c4adfd4b 100644 --- a/src/main/java/net/sf/jsqlparser/expression/DateUnitExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/DateUnitExpression.java @@ -18,12 +18,16 @@ public class DateUnitExpression extends ASTNodeAccessImpl implements Expression private final DateUnit type; + private final String text; + public DateUnitExpression(DateUnit type) { this.type = Objects.requireNonNull(type); + this.text = type.toString(); } public DateUnitExpression(String DateUnitStr) { this.type = Objects.requireNonNull(DateUnit.from(DateUnitStr)); + this.text = DateUnitStr; } public DateUnit getType() { @@ -38,7 +42,7 @@ public T accept(ExpressionVisitor expressionVisitor, S context) { @Override public String toString() { - return type.toString(); + return text; } public enum DateUnit { diff --git a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java index 69bc473850..4a6b4ef27e 100644 --- a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java +++ b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java @@ -19,6 +19,7 @@ import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor; import net.sf.jsqlparser.expression.operators.arithmetic.Concat; import net.sf.jsqlparser.expression.operators.arithmetic.Division; +import net.sf.jsqlparser.expression.operators.arithmetic.Exponentiation; import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision; import net.sf.jsqlparser.expression.operators.arithmetic.Modulo; import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; @@ -44,6 +45,7 @@ import net.sf.jsqlparser.expression.operators.relational.Intersects; import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression; import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression; import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; import net.sf.jsqlparser.expression.operators.relational.IsUnknownExpression; import net.sf.jsqlparser.expression.operators.relational.IsJsonExpression; @@ -271,6 +273,15 @@ default void visit(Division division) { T visit(IntegerDivision integerDivision, S context); + default T visit(Exponentiation exponentiation, S context) { + visitExpression(exponentiation.getLeftExpression(), context); + return visitExpression(exponentiation.getRightExpression(), context); + } + + default void visit(Exponentiation exponentiation) { + this.visit(exponentiation, null); + } + default void visit(IntegerDivision integerDivision) { this.visit(integerDivision, null); } @@ -385,6 +396,14 @@ default void visit(IsUnknownExpression isUnknownExpression) { this.visit(isUnknownExpression, null); } + default T visit(IsNormalizedExpression isNormalizedExpression, S context) { + return isNormalizedExpression.getLeftExpression().accept(this, context); + } + + default void visit(IsNormalizedExpression isNormalizedExpression) { + this.visit(isNormalizedExpression, null); + } + T visit(LikeExpression likeExpression, S context); default void visit(LikeExpression likeExpression) { @@ -822,6 +841,16 @@ default void visit(LambdaExpression lambdaExpression) { this.visit(lambdaExpression, null); } + default T visit(ListComprehension listComprehension, S context) { + visitExpression(listComprehension.getExpression(), context); + visitExpression(listComprehension.getList(), context); + return visitExpression(listComprehension.getCondition(), context); + } + + default void visit(ListComprehension listComprehension) { + this.visit(listComprehension, null); + } + default T visit(ColumnsExpression columnsExpression, S context) { for (Expression expression : columnsExpression.getAllExpressions()) { if (expression != null) { diff --git a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java index fed7b6f0c9..11b052239f 100644 --- a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java +++ b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java @@ -22,6 +22,7 @@ import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor; import net.sf.jsqlparser.expression.operators.arithmetic.Concat; import net.sf.jsqlparser.expression.operators.arithmetic.Division; +import net.sf.jsqlparser.expression.operators.arithmetic.Exponentiation; import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision; import net.sf.jsqlparser.expression.operators.arithmetic.Modulo; import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; @@ -47,6 +48,7 @@ import net.sf.jsqlparser.expression.operators.relational.Intersects; import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression; import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression; import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; import net.sf.jsqlparser.expression.operators.relational.IsUnknownExpression; import net.sf.jsqlparser.expression.operators.relational.JsonOperator; @@ -113,9 +115,17 @@ public T visit(Function function, S context) { if (function.getParameters() != null) { subExpressions.addAll(function.getParameters()); } + if (function.getNamedParameters() != null) { + subExpressions.addAll(function.getNamedParameters()); + } if (function.getChainedParameters() != null) { subExpressions.addAll(function.getChainedParameters()); } + // an attribute name is not a column reference, only an attribute expression is visited + if (function.getAttribute() instanceof Expression + && function.getAttribute() != function.getAttributeColumn()) { + subExpressions.add((Expression) function.getAttribute()); + } if (function.getKeep() != null) { subExpressions.add(function.getKeep()); } @@ -190,6 +200,11 @@ public T visit(IntegerDivision integerDivision, S context) { return visitBinaryExpression(integerDivision, context); } + @Override + public T visit(Exponentiation exponentiation, S context) { + return visitBinaryExpression(exponentiation, context); + } + @Override public T visit(Multiplication multiplication, S context) { return visitBinaryExpression(multiplication, context); @@ -282,9 +297,15 @@ public T visit(IsUnknownExpression isUnknownExpression, S context) { return isUnknownExpression.getLeftExpression().accept(this, context); } + @Override + public T visit(IsNormalizedExpression isNormalizedExpression, S context) { + return isNormalizedExpression.getLeftExpression().accept(this, context); + } + @Override public T visit(LikeExpression likeExpression, S context) { - return visitBinaryExpression(likeExpression, context); + return visitExpressions(likeExpression, context, likeExpression.getLeftExpression(), + likeExpression.getRightExpression(), likeExpression.getEscape()); } @Override @@ -319,7 +340,11 @@ public T visit(ContainedBy containedBy, S context) { @Override public T visit(Column column, S context) { - return applyExpression(column, context); + T result = applyExpression(column, context); + if (column.getArrayConstructor() != null) { + column.getArrayConstructor().accept(this, context); + } + return result; } @Override @@ -358,12 +383,14 @@ public T visit(ExistsExpression existsExpression, S context) { @Override public T visit(MemberOfExpression memberOfExpression, S context) { - return memberOfExpression.getRightExpression().accept(this, context); + return visitExpressions(memberOfExpression, context, + memberOfExpression.getLeftExpression(), memberOfExpression.getRightExpression()); } @Override public T visit(AnyComparisonExpression anyComparisonExpression, S context) { - return applyExpression(anyComparisonExpression, context); + return visitExpressions(anyComparisonExpression, context, + anyComparisonExpression.getSelect()); } @Override @@ -535,7 +562,10 @@ protected T visitBinaryExpression(BinaryExpression binaryExpression, S conte @Override public T visit(JsonExpression jsonExpr, S context) { - return jsonExpr.getExpression().accept(this, context); + ArrayList subExpressions = new ArrayList<>(); + subExpressions.add(jsonExpr.getExpression()); + subExpressions.addAll(jsonExpr.getIdents()); + return visitExpressions(jsonExpr, context, subExpressions); } @Override @@ -697,6 +727,9 @@ public T visit(ArrayExpression arrayExpression, S context) { if (arrayExpression.getStopIndexExpression() != null) { subExpressions.add(arrayExpression.getStopIndexExpression()); } + if (arrayExpression.getStepExpression() != null) { + subExpressions.add(arrayExpression.getStepExpression()); + } return visitExpressions(arrayExpression, context, subExpressions); } @@ -728,13 +761,28 @@ public T visit(XMLSerializeExpr xmlSerializeExpr, S context) { @Override public T visit(TimezoneExpression timezoneExpression, S context) { - return timezoneExpression.getLeftExpression().accept(this, context); + ArrayList subExpressions = new ArrayList<>(); + subExpressions.add(timezoneExpression.getLeftExpression()); + subExpressions.addAll(timezoneExpression.getTimezoneExpressions()); + return visitExpressions(timezoneExpression, context, subExpressions); } @Override public T visit(JsonAggregateFunction jsonAggregateFunction, S context) { - return visitExpressions(jsonAggregateFunction, context, - jsonAggregateFunction.getExpression(), jsonAggregateFunction.getFilterExpression()); + ArrayList subExpressions = new ArrayList<>(); + subExpressions.add(jsonAggregateFunction.getExpression()); + if (jsonAggregateFunction.getKey() instanceof Expression) { + subExpressions.add((Expression) jsonAggregateFunction.getKey()); + } + if (jsonAggregateFunction.getValue() instanceof Expression) { + subExpressions.add((Expression) jsonAggregateFunction.getValue()); + } + addOrderByExpressions(subExpressions, + jsonAggregateFunction.getExpressionOrderByElements()); + subExpressions.add(jsonAggregateFunction.getFilterExpression()); + subExpressions.addAll(jsonAggregateFunction.getPartitionExpressionList()); + addOrderByExpressions(subExpressions, jsonAggregateFunction.getOrderByElements()); + return visitExpressions(jsonAggregateFunction, context, subExpressions); } @Override @@ -834,13 +882,14 @@ public T visit(TranscodingFunction transcodingFunction, S context) { @Override public T visit(TrimFunction trimFunction, S context) { - return trimFunction.getExpression().accept(this, context); + return visitExpressions(trimFunction, context, trimFunction.getExpression(), + trimFunction.getFromExpression()); } @Override public T visit(RangeExpression rangeExpression, S context) { return visitExpressions(rangeExpression, context, rangeExpression.getStartExpression(), - rangeExpression.getEndExpression()); + rangeExpression.getEndExpression(), rangeExpression.getStepExpression()); } @Override @@ -875,6 +924,12 @@ public T visit(LambdaExpression lambdaExpression, S context) { return lambdaExpression.getExpression().accept(this, context); } + @Override + public T visit(ListComprehension listComprehension, S context) { + return visitExpressions(listComprehension, context, listComprehension.getExpression(), + listComprehension.getList(), listComprehension.getCondition()); + } + @Override public T visit(ColumnsExpression columnsExpression, S context) { return visitExpressions(columnsExpression, context, columnsExpression.getAllExpressions()); diff --git a/src/main/java/net/sf/jsqlparser/expression/Function.java b/src/main/java/net/sf/jsqlparser/expression/Function.java index e411bab60f..0a0ddd86fb 100644 --- a/src/main/java/net/sf/jsqlparser/expression/Function.java +++ b/src/main/java/net/sf/jsqlparser/expression/Function.java @@ -17,6 +17,7 @@ import net.sf.jsqlparser.statement.select.Limit; import net.sf.jsqlparser.statement.select.OrderByElement; +import net.sf.jsqlparser.statement.create.table.ColDataType; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.select.PlainSelect; @@ -59,6 +60,12 @@ public class Function extends ASTNodeAccessImpl implements Expression { */ private List keywordArguments = null; + /** + * The {@code AS type} cast of the argument, as in MySQL's {@code WEIGHT_STRING(str AS CHAR(3))} + * or {@code WEIGHT_STRING(str AS BINARY(4))}. + */ + private ColDataType castType; + /** Column definitions supplied for a record-returning function inside ROWS FROM. */ public List getResultColumnDefinitions() { return resultColumnDefinitions; @@ -83,6 +90,31 @@ public Function(String name, Expression... parameters) { this.parameters = new ExpressionList<>(parameters); } + /** + * Returns the {@code AS type} cast written after the argument, as in MySQL's + * {@code WEIGHT_STRING(str AS CHAR(3))}, or {@code null}. + */ + public ColDataType getCastType() { + return castType; + } + + public void setCastType(ColDataType castType) { + this.castType = castType; + } + + public Function withCastType(ColDataType castType) { + setCastType(castType); + return this; + } + + /** Appends {@code " AS type"} when the argument has a {@link #getCastType() cast type}. */ + public StringBuilder appendCastTypeTo(StringBuilder builder) { + if (castType != null) { + builder.append(" AS ").append(castType); + } + return builder; + } + @Override public T accept(ExpressionVisitor expressionVisitor, S context) { return expressionVisitor.visit(this, context); @@ -385,6 +417,7 @@ public String toString() { } b.append(parameters); + appendCastTypeTo(b); if (havingClause != null) { havingClause.appendTo(b); diff --git a/src/main/java/net/sf/jsqlparser/expression/JsonFunction.java b/src/main/java/net/sf/jsqlparser/expression/JsonFunction.java index dfad9451a0..7331ded7d3 100644 --- a/src/main/java/net/sf/jsqlparser/expression/JsonFunction.java +++ b/src/main/java/net/sf/jsqlparser/expression/JsonFunction.java @@ -12,6 +12,7 @@ import java.util.ArrayList; import java.util.Locale; import java.util.Objects; +import java.util.function.Consumer; import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.create.table.ColDataType; @@ -77,6 +78,11 @@ public void setExpression(Expression expression) { } public StringBuilder append(StringBuilder builder) { + return appendTo(builder, builder::append); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { switch (type) { case ERROR: builder.append("ERROR"); @@ -85,7 +91,12 @@ public StringBuilder append(StringBuilder builder) { builder.append("NULL"); break; case DEFAULT: - builder.append("DEFAULT ").append(expression); + builder.append("DEFAULT "); + if (expression == null) { + builder.append("null"); + } else { + expressionPrinter.accept(expression); + } break; case EMPTY: builder.append("EMPTY "); @@ -389,23 +400,28 @@ public T accept(ExpressionVisitor expressionVisitor, S context) { // avoid countless Builder --> String conversion public StringBuilder append(StringBuilder builder) { + return appendTo(builder, builder::append); + } + + /** Renders structured children through the supplied expression printer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { switch (functionType) { case OBJECT: case POSTGRES_OBJECT: case MYSQL_OBJECT: - appendObject(builder); + appendObject(builder, expressionPrinter); break; case ARRAY: - appendArray(builder); + appendArray(builder, expressionPrinter); break; case VALUE: - appendValue(builder); + appendValue(builder, expressionPrinter); break; case QUERY: - appendQuery(builder); + appendQuery(builder, expressionPrinter); break; case EXISTS: - appendExists(builder); + appendExists(builder, expressionPrinter); break; default: // this should never happen really @@ -413,15 +429,19 @@ public StringBuilder append(StringBuilder builder) { return builder; } - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) public StringBuilder appendObject(StringBuilder builder) { - builder.append("JSON_OBJECT( "); + return appendObject(builder, builder::append); + } + + @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) + public StringBuilder appendObject(StringBuilder builder, + Consumer expressionPrinter) { + builder.append("JSON_OBJECT("); + int start = builder.length(); int i = 0; for (JsonKeyValuePair keyValuePair : keyValuePairs) { - if (i > 0) { - builder.append(", "); - } - keyValuePair.append(builder); + builder.append(i > 0 ? ", " : " "); + keyValuePair.appendTo(builder, expressionPrinter); i++; } @@ -432,7 +452,8 @@ public StringBuilder appendObject(StringBuilder builder) { appendUniqueKeys(builder); appendReturningClause(builder, true); - builder.append(" ) "); + // An empty argument list renders as JSON_OBJECT() + builder.append(builder.length() > start ? " )" : ")"); return builder; } @@ -467,53 +488,66 @@ private void appendUniqueKeys(StringBuilder builder) { } } - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) public StringBuilder appendArray(StringBuilder builder) { - builder.append("JSON_ARRAY( "); + return appendArray(builder, builder::append); + } + + @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) + public StringBuilder appendArray(StringBuilder builder, + Consumer expressionPrinter) { + builder.append("JSON_ARRAY("); int i = 0; for (JsonFunctionExpression expr : expressions) { - if (i > 0) { - builder.append(", "); - } - expr.append(builder); + builder.append(i > 0 ? ", " : " "); + expr.appendTo(builder, expressionPrinter); i++; } appendOnNullType(builder); appendReturningClause(builder, true); - builder.append(") "); + builder.append(')'); return builder; } - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) public StringBuilder appendValue(StringBuilder builder) { + return appendValue(builder, builder::append); + } + + @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) + public StringBuilder appendValue(StringBuilder builder, + Consumer expressionPrinter) { builder.append("JSON_VALUE("); - appendValueOrQueryPrefix(builder); + appendValueOrQueryPrefix(builder, expressionPrinter); if (returningType != null) { builder.append(" RETURNING ").append(returningType); } - appendOnResponseClause(builder, onEmptyBehavior, "EMPTY"); - appendOnResponseClause(builder, onErrorBehavior, "ERROR"); + appendOnResponseClause(builder, onEmptyBehavior, "EMPTY", expressionPrinter); + appendOnResponseClause(builder, onErrorBehavior, "ERROR", expressionPrinter); builder.append(")"); return builder; } - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) public StringBuilder appendQuery(StringBuilder builder) { + return appendQuery(builder, builder::append); + } + + @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) + public StringBuilder appendQuery(StringBuilder builder, + Consumer expressionPrinter) { builder.append("JSON_QUERY("); - appendValueOrQueryPrefix(builder); + appendValueOrQueryPrefix(builder, expressionPrinter); appendReturningClause(builder, true); appendWrapperClause(builder); appendQuotesClause(builder); - appendOnResponseClause(builder, onEmptyBehavior, "EMPTY"); - appendOnResponseClause(builder, onErrorBehavior, "ERROR"); + appendOnResponseClause(builder, onEmptyBehavior, "EMPTY", expressionPrinter); + appendOnResponseClause(builder, onErrorBehavior, "ERROR", expressionPrinter); for (String additionalQueryPathArgument : additionalQueryPathArguments) { builder.append(", ").append(additionalQueryPathArgument); @@ -523,25 +557,31 @@ public StringBuilder appendQuery(StringBuilder builder) { return builder; } - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) public StringBuilder appendExists(StringBuilder builder) { + return appendExists(builder, builder::append); + } + + @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) + public StringBuilder appendExists(StringBuilder builder, + Consumer expressionPrinter) { builder.append("JSON_EXISTS("); - appendValueOrQueryPrefix(builder); - appendOnResponseClause(builder, onErrorBehavior, "ERROR"); + appendValueOrQueryPrefix(builder, expressionPrinter); + appendOnResponseClause(builder, onErrorBehavior, "ERROR", expressionPrinter); builder.append(")"); return builder; } - private void appendValueOrQueryPrefix(StringBuilder builder) { + private void appendValueOrQueryPrefix(StringBuilder builder, + Consumer expressionPrinter) { if (inputExpression != null) { - inputExpression.append(builder); + inputExpression.appendTo(builder, expressionPrinter); } if (jsonPathExpression != null) { if (inputExpression != null) { builder.append(", "); } - builder.append(jsonPathExpression); + expressionPrinter.accept(jsonPathExpression); } if (!passingExpressions.isEmpty()) { @@ -553,16 +593,20 @@ private void appendValueOrQueryPrefix(StringBuilder builder) { } else { comma = true; } - builder.append(passingExpression); + if (passingExpression == null) { + builder.append("null"); + } else { + expressionPrinter.accept(passingExpression); + } } } } private void appendOnResponseClause(StringBuilder builder, JsonOnResponseBehavior behavior, - String clause) { + String clause, Consumer expressionPrinter) { if (behavior != null) { builder.append(" "); - behavior.append(builder); + behavior.appendTo(builder, expressionPrinter); builder.append(" ON ").append(clause); } } diff --git a/src/main/java/net/sf/jsqlparser/expression/JsonFunctionExpression.java b/src/main/java/net/sf/jsqlparser/expression/JsonFunctionExpression.java index 738c09fc2d..b8a7007f5b 100644 --- a/src/main/java/net/sf/jsqlparser/expression/JsonFunctionExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/JsonFunctionExpression.java @@ -12,6 +12,7 @@ import java.io.Serializable; import java.util.Objects; +import java.util.function.Consumer; /** * @author Andreas Reichel @@ -58,7 +59,11 @@ public JsonFunctionExpression withEncoding(String encoding) { } public StringBuilder append(StringBuilder builder) { - builder.append(getExpression()); + return appendTo(builder, builder::append); + } + + public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { + expressionPrinter.accept(getExpression()); if (isUsingFormatJson()) { builder.append(" FORMAT JSON"); if (encoding != null) { diff --git a/src/main/java/net/sf/jsqlparser/expression/JsonKeyValuePair.java b/src/main/java/net/sf/jsqlparser/expression/JsonKeyValuePair.java index 18fb4752d9..bd0ed4dad4 100644 --- a/src/main/java/net/sf/jsqlparser/expression/JsonKeyValuePair.java +++ b/src/main/java/net/sf/jsqlparser/expression/JsonKeyValuePair.java @@ -12,6 +12,7 @@ import java.io.Serializable; import java.util.Objects; +import java.util.function.Consumer; /** * @author Andreas Reichel @@ -153,14 +154,18 @@ public Object getValue() { } public StringBuilder append(StringBuilder builder) { + return appendTo(builder, builder::append); + } + + public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { if (isUsingKeyKeyword() && getSeparator() == JsonKeyValuePairSeparator.VALUE) { builder.append("KEY "); } - builder.append(getKey()); + appendValue(builder, getKey(), expressionPrinter); if (getValue() != null) { builder.append(getSeparator().getSeparatorString()); - builder.append(getValue()); + appendValue(builder, getValue(), expressionPrinter); } if (isUsingFormatJson()) { @@ -173,6 +178,15 @@ public StringBuilder append(StringBuilder builder) { return builder; } + private static void appendValue(StringBuilder builder, Object value, + Consumer expressionPrinter) { + if (value instanceof Expression) { + expressionPrinter.accept((Expression) value); + } else { + builder.append(value); + } + } + @Override public String toString() { return append(new StringBuilder()).toString(); diff --git a/src/main/java/net/sf/jsqlparser/expression/JsonTableFunction.java b/src/main/java/net/sf/jsqlparser/expression/JsonTableFunction.java index 5ee166e6fc..65bb76f5fb 100644 --- a/src/main/java/net/sf/jsqlparser/expression/JsonTableFunction.java +++ b/src/main/java/net/sf/jsqlparser/expression/JsonTableFunction.java @@ -13,6 +13,7 @@ import java.util.ArrayList; import java.util.List; import java.util.Objects; +import java.util.function.Consumer; import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.create.table.ColDataType; @@ -93,7 +94,14 @@ public void collectExpressions(List expressions) { @Override public String toString() { - return valueExpression + " AS " + parameterName; + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + printExpression(builder, valueExpression, expressionPrinter); + return builder.append(" AS ").append(parameterName); } } @@ -305,13 +313,22 @@ public void collectExpressions(List expressions) { @Override public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { if (nestedPlanExpression != null) { - return "(" + nestedPlanExpression + ")"; - } - if (name != null) { - return name; + builder.append("("); + nestedPlanExpression.appendTo(builder, expressionPrinter); + builder.append(")"); + } else if (name != null) { + builder.append(name); + } else if (expression != null) { + expressionPrinter.accept(expression); } - return expression != null ? expression.toString() : ""; + return builder; } } @@ -348,13 +365,28 @@ public void collectExpressions(List expressions) { @Override public String toString() { StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { if (!terms.isEmpty()) { - builder.append(terms.get(0)); + appendTerm(builder, terms.get(0), expressionPrinter); } for (int i = 0; i < operators.size() && i + 1 < terms.size(); i++) { - builder.append(operators.get(i).getDisplay()).append(terms.get(i + 1)); + builder.append(operators.get(i).getDisplay()); + appendTerm(builder, terms.get(i + 1), expressionPrinter); + } + return builder; + } + + private static void appendTerm(StringBuilder builder, JsonTablePlanTerm term, + Consumer expressionPrinter) { + if (term == null) { + builder.append("null"); + } else { + term.appendTo(builder, expressionPrinter); } - return builder.toString(); } } @@ -388,18 +420,36 @@ public void collectExpressions(List expressions) { @Override public String toString() { - StringBuilder builder = new StringBuilder("PLAN"); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + builder.append("PLAN"); if (defaultPlan) { builder.append(" DEFAULT"); } - builder.append(" (").append(planExpression).append(")"); - return builder.toString(); + builder.append(" ("); + if (planExpression == null) { + builder.append("null"); + } else { + planExpression.appendTo(builder, expressionPrinter); + } + builder.append(")"); + return builder; } } public abstract static class JsonTableColumnDefinition extends ASTNodeAccessImpl implements Serializable { public abstract void collectExpressions(List expressions); + + /** Custom column definitions retain their existing SQL renderer by default. */ + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + return builder.append(this); + } } public static class JsonTableNestedColumnDefinition extends JsonTableColumnDefinition { @@ -457,16 +507,28 @@ public void collectExpressions(List expressions) { @Override public String toString() { - StringBuilder builder = new StringBuilder("NESTED"); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + builder.append("NESTED"); if (pathKeyword) { builder.append(" PATH"); } - builder.append(" ").append(pathExpression); + builder.append(" "); + printExpression(builder, pathExpression, expressionPrinter); if (pathName != null) { builder.append(" AS ").append(pathName); } - builder.append(" ").append(columnsClause); - return builder.toString(); + builder.append(" "); + if (columnsClause == null) { + builder.append("null"); + } else { + columnsClause.appendTo(builder, expressionPrinter); + } + return builder; } } @@ -474,6 +536,7 @@ public static class JsonTableValueColumnDefinition extends JsonTableColumnDefini private String columnName; private boolean forOrdinality; private ColDataType dataType; + private String collation; private boolean formatJson; private boolean exists; private boolean onEmptyAfterOnError; @@ -526,6 +589,16 @@ public JsonTableValueColumnDefinition setDataType(ColDataType dataType) { return this; } + /** Returns the column collation, including any identifier quoting, or null if absent. */ + public String getCollation() { + return collation; + } + + public JsonTableValueColumnDefinition setCollation(String collation) { + this.collation = collation; + return this; + } + public boolean isFormatJson() { return formatJson; } @@ -615,17 +688,44 @@ public void collectExpressions(List expressions) { @Override public String toString() { - StringBuilder builder = new StringBuilder(columnName); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + builder.append(columnName); if (forOrdinality) { builder.append(" FOR ORDINALITY"); - return builder.toString(); + return builder; } - if (exists) { - builder.append(" EXISTS"); + appendTypeOptions(builder); + appendPathOptions(builder, expressionPrinter); + if (onEmptyBehavior != null && !onEmptyAfterOnError) { + builder.append(" "); + onEmptyBehavior.appendTo(builder, expressionPrinter); + builder.append(" ON EMPTY"); + } + if (onErrorBehavior != null) { + builder.append(" "); + onErrorBehavior.appendTo(builder, expressionPrinter); + builder.append(" ON ERROR"); } + if (onEmptyBehavior != null && onEmptyAfterOnError) { + builder.append(" "); + onEmptyBehavior.appendTo(builder, expressionPrinter); + builder.append(" ON EMPTY"); + } + return builder; + } + + private void appendTypeOptions(StringBuilder builder) { if (dataType != null) { builder.append(" ").append(dataType); } + if (collation != null) { + builder.append(" COLLATE ").append(collation); + } if (formatJson) { builder.append(" FORMAT JSON"); if (encoding != null) { @@ -637,11 +737,19 @@ public String toString() { builder.append(scalarsType); builder.append(" SCALARS"); } + if (exists) { + builder.append(" EXISTS"); + } + } + + private void appendPathOptions(StringBuilder builder, + Consumer expressionPrinter) { if (wrapperClause != null && wrapperClause.isBeforePathExpression()) { builder.append(" ").append(wrapperClause); } if (pathExpression != null) { - builder.append(" PATH ").append(pathExpression); + builder.append(" PATH "); + expressionPrinter.accept(pathExpression); } if (wrapperClause != null && !wrapperClause.isBeforePathExpression()) { builder.append(" ").append(wrapperClause); @@ -649,16 +757,6 @@ public String toString() { if (quotesClause != null) { builder.append(" ").append(quotesClause); } - if (onEmptyBehavior != null && !onEmptyAfterOnError) { - builder.append(" ").append(onEmptyBehavior).append(" ON EMPTY"); - } - if (onErrorBehavior != null) { - builder.append(" ").append(onErrorBehavior).append(" ON ERROR"); - } - if (onEmptyBehavior != null && onEmptyAfterOnError) { - builder.append(" ").append(onEmptyBehavior).append(" ON EMPTY"); - } - return builder.toString(); } } @@ -685,17 +783,27 @@ public void collectExpressions(List expressions) { @Override public String toString() { - StringBuilder builder = new StringBuilder("COLUMNS ("); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + builder.append("COLUMNS ("); boolean first = true; for (JsonTableColumnDefinition columnDefinition : columnDefinitions) { if (!first) { builder.append(", "); } - builder.append(columnDefinition); + if (columnDefinition == null) { + builder.append("null"); + } else { + columnDefinition.appendTo(builder, expressionPrinter); + } first = false; } builder.append(")"); - return builder.toString(); + return builder; } } @@ -820,17 +928,57 @@ public T accept(ExpressionVisitor expressionVisitor, S context) { @Override public String toString() { - StringBuilder builder = new StringBuilder("JSON_TABLE("); - builder.append(jsonInputExpression); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { + builder.append("JSON_TABLE("); + appendInputAndPath(builder, expressionPrinter); + appendPassingClauses(builder, expressionPrinter); + if (onErrorClause != null && onErrorClause.isBeforeColumns()) { + builder.append(" ").append(onErrorClause); + } + if (parsingTypeClause != null) { + builder.append(" ").append(parsingTypeClause); + } + if (onEmptyClause != null) { + builder.append(" ").append(onEmptyClause); + } + builder.append(" "); + if (columnsClause == null) { + builder.append("null"); + } else { + columnsClause.appendTo(builder, expressionPrinter); + } + if (planClause != null) { + builder.append(" "); + planClause.appendTo(builder, expressionPrinter); + } + if (onErrorClause != null && !onErrorClause.isBeforeColumns()) { + builder.append(" ").append(onErrorClause); + } + builder.append(")"); + return builder; + } + + private void appendInputAndPath(StringBuilder builder, + Consumer expressionPrinter) { + printExpression(builder, jsonInputExpression, expressionPrinter); if (formatJson) { builder.append(" FORMAT JSON"); } if (jsonPathExpression != null) { - builder.append(", ").append(jsonPathExpression); + builder.append(", "); + expressionPrinter.accept(jsonPathExpression); } if (pathName != null) { builder.append(" AS ").append(pathName); } + } + + private void appendPassingClauses(StringBuilder builder, + Consumer expressionPrinter) { if (!passingClauses.isEmpty()) { builder.append(" PASSING "); boolean first = true; @@ -838,27 +986,23 @@ public String toString() { if (!first) { builder.append(", "); } - builder.append(passingClause); + if (passingClause == null) { + builder.append("null"); + } else { + passingClause.appendTo(builder, expressionPrinter); + } first = false; } } - if (onErrorClause != null && onErrorClause.isBeforeColumns()) { - builder.append(" ").append(onErrorClause); - } - if (parsingTypeClause != null) { - builder.append(" ").append(parsingTypeClause); - } - if (onEmptyClause != null) { - builder.append(" ").append(onEmptyClause); - } - builder.append(" ").append(columnsClause); - if (planClause != null) { - builder.append(" ").append(planClause); - } - if (onErrorClause != null && !onErrorClause.isBeforeColumns()) { - builder.append(" ").append(onErrorClause); + } + + private static void printExpression(StringBuilder builder, Expression expression, + Consumer expressionPrinter) { + if (expression == null) { + builder.append("null"); + } else { + expressionPrinter.accept(expression); } - builder.append(")"); - return builder.toString(); } + } diff --git a/src/main/java/net/sf/jsqlparser/expression/LambdaExpression.java b/src/main/java/net/sf/jsqlparser/expression/LambdaExpression.java index 397a4a4320..2b992173f2 100644 --- a/src/main/java/net/sf/jsqlparser/expression/LambdaExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/LambdaExpression.java @@ -22,6 +22,7 @@ public class LambdaExpression extends ASTNodeAccessImpl implements Expression { private List identifiers; private Expression expression; private boolean parenthesized; + private boolean lambdaKeyword; public LambdaExpression(String identifier, Expression expression) { this.identifiers = Collections.singletonList(identifier); @@ -53,6 +54,16 @@ public LambdaExpression setParenthesized(boolean parenthesized) { return this; } + /** Whether it was written with DuckDB's lambda keyword: {@code lambda x, y : expr}. */ + public boolean isLambdaKeyword() { + return lambdaKeyword; + } + + public LambdaExpression setLambdaKeyword(boolean lambdaKeyword) { + this.lambdaKeyword = lambdaKeyword; + return this; + } + public List getIdentifiers() { return identifiers; } @@ -76,6 +87,11 @@ public StringBuilder appendTo(StringBuilder builder) { } public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { + if (lambdaKeyword) { + builder.append("lambda ").append(String.join(", ", identifiers)).append(" : "); + expressionPrinter.accept(expression); + return builder; + } if (identifiers.size() == 1 && !parenthesized) { builder.append(identifiers.get(0)); } else { diff --git a/src/main/java/net/sf/jsqlparser/expression/ListComprehension.java b/src/main/java/net/sf/jsqlparser/expression/ListComprehension.java new file mode 100644 index 0000000000..e65fab8853 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/expression/ListComprehension.java @@ -0,0 +1,98 @@ +/*- + * #%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.expression; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; + +import java.util.List; +import java.util.function.Consumer; + +/** + * DuckDB's list comprehension {@code [expression FOR x[, i] IN list [IF condition]]}, where + * {@code i} is the 1-based index of {@code x}. + * + * @see List + * comprehension + */ +public class ListComprehension extends ASTNodeAccessImpl implements Expression { + private Expression expression; + private List variables; + private Expression list; + private Expression condition; + + public ListComprehension(Expression expression, List variables, Expression list, + Expression condition) { + this.expression = expression; + this.variables = variables; + this.list = list; + this.condition = condition; + } + + public Expression getExpression() { + return expression; + } + + public ListComprehension setExpression(Expression expression) { + this.expression = expression; + return this; + } + + /** The element variable, followed by the index variable if any. */ + public List getVariables() { + return variables; + } + + public ListComprehension setVariables(List variables) { + this.variables = variables; + return this; + } + + public Expression getList() { + return list; + } + + public ListComprehension setList(Expression list) { + this.list = list; + return this; + } + + /** The {@code IF} filter, or {@code null}. */ + public Expression getCondition() { + return condition; + } + + public ListComprehension setCondition(Expression condition) { + this.condition = condition; + return this; + } + + public StringBuilder appendTo(StringBuilder builder, Consumer expressionRenderer) { + builder.append("["); + expressionRenderer.accept(expression); + builder.append(" FOR ").append(String.join(", ", variables)).append(" IN "); + expressionRenderer.accept(list); + if (condition != null) { + builder.append(" IF "); + expressionRenderer.accept(condition); + } + return builder.append("]"); + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + @Override + public T accept(ExpressionVisitor expressionVisitor, S context) { + return expressionVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/expression/MySQLIndexHint.java b/src/main/java/net/sf/jsqlparser/expression/MySQLIndexHint.java index 7360a4b2e5..17044a9fb3 100644 --- a/src/main/java/net/sf/jsqlparser/expression/MySQLIndexHint.java +++ b/src/main/java/net/sf/jsqlparser/expression/MySQLIndexHint.java @@ -12,15 +12,35 @@ import java.io.Serializable; import java.util.List; +/** + * A MySQL index hint after a table reference: + * {@code {USE|IGNORE|FORCE} {INDEX|KEY} [FOR {JOIN|ORDER BY|GROUP BY}] (index_list)}. + *

+ * A table may carry several hints, see {@code Table.getIndexHints()}. {@code USE INDEX ()} has an + * empty index list. + */ public class MySQLIndexHint implements Serializable { private final String action; private final String indexQualifier; + private final Scope scope; private final List indexNames; public MySQLIndexHint(String action, String indexQualifier, List indexNames) { + this(action, indexQualifier, null, indexNames); + } + + /** + * @param action {@code USE}, {@code IGNORE} or {@code FORCE} + * @param indexQualifier {@code INDEX} or {@code KEY} + * @param scope the {@code FOR JOIN|ORDER BY|GROUP BY} scope, or {@code null} for every use + * @param indexNames the index names, empty for {@code USE INDEX ()} + */ + public MySQLIndexHint(String action, String indexQualifier, Scope scope, + List indexNames) { this.action = action; this.indexQualifier = indexQualifier; + this.scope = scope; this.indexNames = indexNames; } @@ -32,22 +52,53 @@ public String getIndexQualifier() { return indexQualifier; } + /** + * Returns the part of the query the hint applies to, or {@code null} when no {@code FOR} clause + * was given. + */ + public Scope getScope() { + return scope; + } + public List getIndexNames() { return indexNames; } - @Override - public String toString() { - // use|ignore|force key|index (index1,...,indexN) - StringBuilder buffer = new StringBuilder(); - buffer.append(" ").append(action).append(" ").append(indexQualifier).append(" ("); + /** Appends {@code " USE INDEX [FOR scope] (i1,i2)"}, with a leading space. */ + public StringBuilder appendTo(StringBuilder builder) { + // use|ignore|force key|index [for join|order by|group by] (index1,...,indexN) + builder.append(" ").append(action).append(" ").append(indexQualifier); + if (scope != null) { + builder.append(" FOR ").append(scope.getKeywords()); + } + builder.append(" ("); for (int i = 0; i < indexNames.size(); i++) { if (i > 0) { - buffer.append(","); + builder.append(","); } - buffer.append(indexNames.get(i)); + builder.append(indexNames.get(i)); + } + return builder.append(")"); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + /** The {@code FOR} clause of an index hint. */ + public enum Scope { + JOIN("JOIN"), ORDER_BY("ORDER BY"), GROUP_BY("GROUP BY"); + + private final String keywords; + + Scope(String keywords) { + this.keywords = keywords; + } + + /** Returns the keywords after {@code FOR}, for example {@code ORDER BY}. */ + public String getKeywords() { + return keywords; } - buffer.append(")"); - return buffer.toString(); } } diff --git a/src/main/java/net/sf/jsqlparser/expression/RangeExpression.java b/src/main/java/net/sf/jsqlparser/expression/RangeExpression.java index dd05827d64..326f5b7da5 100644 --- a/src/main/java/net/sf/jsqlparser/expression/RangeExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/RangeExpression.java @@ -14,6 +14,7 @@ public class RangeExpression extends ASTNodeAccessImpl implements Expression { private Expression startExpression; private Expression endExpression; + private Expression stepExpression; public RangeExpression(Expression startExpression, Expression endExpression) { this.startExpression = startExpression; @@ -38,9 +39,42 @@ public RangeExpression setEndExpression(Expression endExpression) { return this; } + public Expression getStepExpression() { + return stepExpression; + } + + public RangeExpression setStepExpression(Expression stepExpression) { + this.stepExpression = stepExpression; + return this; + } + + public RangeExpression withStepExpression(Expression stepExpression) { + return setStepExpression(stepExpression); + } + + /** + * Renders {@code [start]:[end][:step]}, a missing end before a step as DuckDB's {@code -}. + */ + public static String toString(Expression start, Expression end, Expression step) { + StringBuilder builder = new StringBuilder(); + if (start != null) { + builder.append(start); + } + builder.append(":"); + if (end != null) { + builder.append(end); + } else if (step != null) { + builder.append("-"); + } + if (step != null) { + builder.append(":").append(step); + } + return builder.toString(); + } + @Override public String toString() { - return startExpression + ":" + endExpression; + return toString(startExpression, endExpression, stepExpression); } @Override diff --git a/src/main/java/net/sf/jsqlparser/expression/SignedExpression.java b/src/main/java/net/sf/jsqlparser/expression/SignedExpression.java index 725d449e89..43c92e29b3 100644 --- a/src/main/java/net/sf/jsqlparser/expression/SignedExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/SignedExpression.java @@ -54,7 +54,23 @@ public T accept(ExpressionVisitor expressionVisitor, S context) { @Override public String toString() { - return getSign() + expression.toString(); + String operand = expression.toString(); + return getSign() + (needsSpaceBefore(operand) ? " " : "") + operand; + } + + /** + * Whether the sign must be separated from an operand starting with {@code firstChar}: "- -1" + * must not become the line comment "--1", nor "~ -a" or "~ ~a" a single operator such as "~-" + * or the LIKE operator "~~", as DuckDB and PostgreSQL read a run of signs containing {@code ~}. + */ + public boolean needsSpaceBefore(char firstChar) { + boolean signedOperand = firstChar == '+' || firstChar == '-' || firstChar == '~'; + return sign == '-' && firstChar == '-' || sign == '~' && signedOperand + || firstChar == '~' && (sign == '+' || sign == '-'); + } + + private boolean needsSpaceBefore(String operand) { + return !operand.isEmpty() && needsSpaceBefore(operand.charAt(0)); } public SignedExpression withSign(char sign) { diff --git a/src/main/java/net/sf/jsqlparser/expression/SpannerInterleaveIn.java b/src/main/java/net/sf/jsqlparser/expression/SpannerInterleaveIn.java index 4dcb0aa7f5..dc5e56d208 100644 --- a/src/main/java/net/sf/jsqlparser/expression/SpannerInterleaveIn.java +++ b/src/main/java/net/sf/jsqlparser/expression/SpannerInterleaveIn.java @@ -9,13 +9,13 @@ */ package net.sf.jsqlparser.expression; -import java.util.Locale; -import net.sf.jsqlparser.schema.Table; - +import java.io.Serializable; import java.util.Collections; import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.schema.Table; -public class SpannerInterleaveIn { +public class SpannerInterleaveIn implements Serializable { private Table table; private OnDelete onDelete; diff --git a/src/main/java/net/sf/jsqlparser/expression/StringValue.java b/src/main/java/net/sf/jsqlparser/expression/StringValue.java index 46bf58810a..55f44fee94 100644 --- a/src/main/java/net/sf/jsqlparser/expression/StringValue.java +++ b/src/main/java/net/sf/jsqlparser/expression/StringValue.java @@ -9,6 +9,8 @@ */ package net.sf.jsqlparser.expression; +import java.io.ByteArrayOutputStream; +import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.List; import java.util.Objects; @@ -22,9 +24,35 @@ public final class StringValue extends ASTNodeAccessImpl implements Expression { public static final List ALLOWED_PREFIXES = Arrays.asList("N", "U", "E", "R", "B", "RB", "_utf8", "Q"); + + /** The prefix of a PostgreSQL Unicode escape string, as in {@code U&'\0041'}. */ + private static final String UNICODE_ESCAPE_PREFIX = "U&"; + + /** + * How a backslash in the literal body was read. The parser records the escaping of the + * configuration that lexed the literal; constructed values default to {@link #STANDARD}. + */ + public enum Escaping { + /** Only a doubled quote character is an escape, as in standard SQL. */ + STANDARD, + /** MySQL/MariaDB backslash escapes, for example {@code \n}, {@code \'} and {@code \\}. */ + MYSQL_BACKSLASH, + /** PostgreSQL escape string escapes, for example {@code E'\n'} and {@code E'\x41'}. */ + POSTGRESQL_ESCAPE_STRING, + /** + * PostgreSQL Unicode escapes of a {@code U&'...'} string: the escape character followed by + * four hexadecimal digits or by {@code +} and six, and a doubled escape character. The + * escape character is a backslash unless {@link #getUnicodeEscapeCharacter()} names another + * one. + */ + POSTGRESQL_UNICODE_ESCAPE + } + private String value = ""; private String prefix = null; private String quoteStr = "'"; + private Escaping escaping = Escaping.STANDARD; + private Character unicodeEscapeCharacter = null; public StringValue() { // empty constructor @@ -53,7 +81,18 @@ public StringValue(String escapedValue) { return; } + if (readUnicodeEscapeString(escapedValue)) { + return; + } + if (escapedValue.length() > 2) { + // Databricks raw literal R"..." + if (escapedValue.regionMatches(true, 0, "R\"", 0, 2) && escapedValue.endsWith("\"")) { + prefix = "R"; + quoteStr = "\""; + value = escapedValue.substring(2, escapedValue.length() - 1); + return; + } for (String p : ALLOWED_PREFIXES) { if (escapedValue.length() > p.length() && escapedValue.substring(0, p.length()).equalsIgnoreCase(p) @@ -68,6 +107,46 @@ public StringValue(String escapedValue) { value = escapedValue; } + /** + * Reads {@code U&'body'} with an optional {@code UESCAPE 'c'} clause. Returns false, leaving + * this value unchanged, when the text has another shape. + */ + private boolean readUnicodeEscapeString(String text) { + if (!text.regionMatches(true, 0, UNICODE_ESCAPE_PREFIX + "'", 0, 3)) { + return false; + } + int close = 3; + while (close < text.length()) { + if (text.charAt(close) != '\'') { + close++; + } else if (close + 1 < text.length() && text.charAt(close + 1) == '\'') { + close += 2; + } else { + break; + } + } + if (close >= text.length()) { + return false; + } + String clause = text.substring(close + 1).trim(); + Character escape = null; + if (!clause.isEmpty()) { + if (!clause.regionMatches(true, 0, "UESCAPE", 0, 7)) { + return false; + } + String quoted = clause.substring(7).trim(); + if (quoted.length() != 3 || quoted.charAt(0) != '\'' || quoted.charAt(2) != '\'') { + return false; + } + escape = quoted.charAt(1); + } + prefix = UNICODE_ESCAPE_PREFIX; + value = text.substring(3, close); + escaping = Escaping.POSTGRESQL_UNICODE_ESCAPE; + unicodeEscapeCharacter = escape; + return true; + } + /** * Returns the opening PostgreSQL dollar-quote delimiter, or null if there is none. A tag * follows unquoted identifier rules, excluding dollar signs. This method does not require the @@ -119,19 +198,377 @@ public StringValue setQuoteStr(String quoteStr) { return this; } + public Escaping getEscaping() { + return escaping; + } + + public void setEscaping(Escaping escaping) { + this.escaping = escaping == null ? Escaping.STANDARD : escaping; + } + + public StringValue withEscaping(Escaping escaping) { + setEscaping(escaping); + return this; + } + + /** + * Returns the escape character named by the {@code UESCAPE} clause of a PostgreSQL Unicode + * escape string, or null when the literal has no such clause and the escape character is a + * backslash. + */ + public Character getUnicodeEscapeCharacter() { + return unicodeEscapeCharacter; + } + + /** + * Sets the escape character rendered as {@code UESCAPE 'c'} after the literal; null removes the + * clause. It applies to {@link Escaping#POSTGRESQL_UNICODE_ESCAPE} values, whose + * {@link #getNotExcapedValue()} rejects a character that PostgreSQL rejects. + */ + public void setUnicodeEscapeCharacter(Character unicodeEscapeCharacter) { + this.unicodeEscapeCharacter = unicodeEscapeCharacter; + } + + public StringValue withUnicodeEscapeCharacter(Character unicodeEscapeCharacter) { + setUnicodeEscapeCharacter(unicodeEscapeCharacter); + return this; + } + + /** + * Returns the literal's characters with its escapes resolved: a doubled quote character and, + * depending on {@link #getEscaping()}, backslash or Unicode escape sequences. PostgreSQL octal + * and hexadecimal escapes denote bytes, which are decoded as UTF-8. Dollar-quoted bodies are + * returned unchanged. + * + * @throws IllegalArgumentException if a {@link Escaping#POSTGRESQL_UNICODE_ESCAPE} value has an + * escape that PostgreSQL rejects, or a {@link Escaping#POSTGRESQL_ESCAPE_STRING} value + * has a Unicode escape that PostgreSQL rejects; the parser rejects such literals + */ public String getNotExcapedValue() { if (quoteStr != null && quoteStr.startsWith("$")) { return value; } - StringBuilder buffer = new StringBuilder(value); - int index = 0; - int deletesNum = 0; - while ((index = value.indexOf("''", index)) != -1) { - buffer.deleteCharAt(index - deletesNum); - index += 2; - deletesNum++; + char quote = "\"".equals(quoteStr) ? '"' : '\''; + if (escaping == Escaping.POSTGRESQL_UNICODE_ESCAPE) { + return unescapeUnicode(value, quote, + unicodeEscapeCharacter == null ? '\\' : unicodeEscapeCharacter); + } + Unescaped result = new Unescaped(value.length()); + int i = 0; + while (i < value.length()) { + char c = value.charAt(i); + if (c == '\\' && escaping != Escaping.STANDARD && i + 1 < value.length()) { + i = escaping == Escaping.MYSQL_BACKSLASH + ? appendMySqlEscape(result, value.charAt(i + 1), i + 1) + : appendPostgresEscape(result, value, i + 1); + } else if (c == quote && i + 1 < value.length() && value.charAt(i + 1) == quote) { + result.append(quote); + i += 2; + } else { + result.append(c); + i++; + } + } + return result.toString(); + } + + /** Appends the MySQL escape {@code c} at {@code index} and returns the index after it. */ + private static int appendMySqlEscape(Unescaped result, char c, int index) { + switch (c) { + case '0': + result.append('\0'); + break; + case 'b': + result.append('\b'); + break; + case 'n': + result.append('\n'); + break; + case 'r': + result.append('\r'); + break; + case 't': + result.append('\t'); + break; + case 'Z': + result.append((char) 0x1A); + break; + case '%': + case '_': + // kept with the backslash, so that LIKE patterns still match them literally + result.append('\\'); + result.append(c); + break; + default: + result.append(c); + } + return index + 1; + } + + /** Appends the PostgreSQL escape string escape at {@code index}; returns the next index. */ + private static int appendPostgresEscape(Unescaped result, String text, int index) { + char c = text.charAt(index); + switch (c) { + case 'b': + result.append('\b'); + return index + 1; + case 'f': + result.append('\f'); + return index + 1; + case 'n': + result.append('\n'); + return index + 1; + case 'r': + result.append('\r'); + return index + 1; + case 't': + result.append('\t'); + return index + 1; + case 'x': + return appendByte(result, text, index + 1, 16, 1, 2, c); + case 'u': + return appendCodePoint(result, text, index, 4); + case 'U': + return appendCodePoint(result, text, index, 8); + default: + if (c >= '0' && c <= '7') { + return appendByte(result, text, index, 8, 1, 3, c); + } + result.append(c); + return index + 1; + } + } + + /** + * Appends the byte spelled by {@code min} to {@code max} digits at {@code start}, or + * {@code fallback} when fewer digits follow, and returns the next index. + */ + private static int appendByte(Unescaped result, String text, int start, int radix, int min, + int max, char fallback) { + int end = start; + while (end < text.length() && end - start < max + && Character.digit(text.charAt(end), radix) >= 0) { + end++; + } + if (end - start < min) { + result.append(fallback); + return start; + } + result.appendByte(Integer.parseInt(text.substring(start, end), radix)); + return end; + } + + /** + * Appends the code point spelled by exactly {@code digits} hexadecimal digits after the escape + * letter at {@code index} and returns the next index. As in a Unicode escape string, the code + * point must be valid and a UTF-16 surrogate pair must be written as two consecutive escapes. + */ + private static int appendCodePoint(Unescaped result, String text, int index, int digits) { + int start = index + 1; + int end = start + digits; + long codePoint = parseHex(text, start, end); + if (codePoint < 0) { + throw new IllegalArgumentException("invalid Unicode escape at position " + (index - 1) + + ": Unicode escapes must be \\u followed by 4 or \\U by 8 hexadecimal digits"); + } + if (codePoint == 0 || codePoint > Character.MAX_CODE_POINT) { + throw new IllegalArgumentException( + "invalid Unicode escape value at position " + (index - 1)); + } + result.appendCodePoint((int) codePoint, index - 1); + return end; + } + + /** + * Resolves PostgreSQL Unicode escapes the way the server does: {@code escape} followed by four + * hexadecimal digits, or by {@code +} and six, names a code point, and a UTF-16 surrogate pair + * must be written as two consecutive escapes. A doubled escape or quote character stands for + * itself. + */ + private static String unescapeUnicode(String text, char quote, char escape) { + checkUnicodeEscapeCharacter(escape); + UnicodeUnescaped result = new UnicodeUnescaped(text.length()); + int i = 0; + while (i < text.length()) { + char c = text.charAt(i); + boolean doubled = i + 1 < text.length() && text.charAt(i + 1) == c; + if (c == escape && !doubled) { + i = appendUnicodeEscape(result, text, i, escape); + } else { + result.append(c, i); + i += doubled && (c == escape || c == quote) ? 2 : 1; + } + } + return result.finish(text.length()); + } + + private static void checkUnicodeEscapeCharacter(char escape) { + if (escape > 0x7F || isHexDigit(escape) || "+'\" \t\n\r\f\u000B".indexOf(escape) >= 0) { + throw new IllegalArgumentException("invalid Unicode escape character '" + escape + "'"); + } + } + + /** + * Appends the code point of the escape at {@code position}, {@code escape} followed by four + * hexadecimal digits or by {@code +} and six, and returns the next index. + */ + private static int appendUnicodeEscape(UnicodeUnescaped result, String text, int position, + char escape) { + boolean plus = position + 1 < text.length() && text.charAt(position + 1) == '+'; + int start = plus ? position + 2 : position + 1; + int end = start + (plus ? 6 : 4); + long codePoint = parseHex(text, start, end); + if (codePoint < 0) { + throw new IllegalArgumentException("invalid Unicode escape at position " + position + + ": Unicode escapes must be " + escape + "XXXX or " + escape + "+XXXXXX"); + } + if (codePoint == 0 || codePoint > Character.MAX_CODE_POINT) { + throw new IllegalArgumentException( + "invalid Unicode escape value at position " + position); + } + result.appendCodePoint((int) codePoint, position); + return end; + } + + private static IllegalArgumentException invalidSurrogatePair(int position) { + return new IllegalArgumentException( + "invalid Unicode surrogate pair at position " + position); + } + + private static boolean isHexDigit(char c) { + return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F'; + } + + /** Returns the ASCII hexadecimal number spelled by text[start, end), or -1. */ + private static long parseHex(String text, int start, int end) { + if (end > text.length()) { + return -1; + } + long number = 0; + for (int i = start; i < end; i++) { + char c = text.charAt(i); + if (!isHexDigit(c)) { + return -1; + } + number = number * 16 + Character.digit(c, 16); + } + return number; + } + + /** + * Collects unescaped characters; consecutive escaped bytes are decoded as UTF-8. A UTF-16 + * surrogate pair must be written as two consecutive Unicode escapes, as PostgreSQL requires. + */ + private static final class Unescaped { + private final StringBuilder chars; + private final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + private char highSurrogate; + private int highSurrogatePosition; + + Unescaped(int capacity) { + chars = new StringBuilder(capacity); + } + + void append(char c) { + requireNoPendingSurrogate(); + flushBytes(); + chars.append(c); + } + + /** Appends the code point of the Unicode escape at {@code position}. */ + void appendCodePoint(int codePoint, int position) { + flushBytes(); + if (codePoint >= Character.MIN_LOW_SURROGATE + && codePoint <= Character.MAX_LOW_SURROGATE) { + if (highSurrogate == 0) { + throw invalidSurrogatePair(position); + } + chars.appendCodePoint(Character.toCodePoint(highSurrogate, (char) codePoint)); + highSurrogate = 0; + return; + } + requireNoPendingSurrogate(); + if (codePoint >= Character.MIN_HIGH_SURROGATE + && codePoint <= Character.MAX_HIGH_SURROGATE) { + highSurrogate = (char) codePoint; + highSurrogatePosition = position; + } else { + chars.appendCodePoint(codePoint); + } + } + + void appendByte(int value) { + requireNoPendingSurrogate(); + bytes.write(value); + } + + private void flushBytes() { + if (bytes.size() > 0) { + chars.append(new String(bytes.toByteArray(), StandardCharsets.UTF_8)); + bytes.reset(); + } + } + + private void requireNoPendingSurrogate() { + if (highSurrogate != 0) { + throw invalidSurrogatePair(highSurrogatePosition); + } + } + + @Override + public String toString() { + requireNoPendingSurrogate(); + flushBytes(); + return chars.toString(); + } + } + + /** + * Collects resolved Unicode escapes. A UTF-16 surrogate pair must be written as two consecutive + * escapes, as PostgreSQL requires. + */ + private static final class UnicodeUnescaped { + private final StringBuilder chars; + private char highSurrogate; + + UnicodeUnescaped(int capacity) { + chars = new StringBuilder(capacity); + } + + void append(char c, int position) { + requireNoPendingSurrogate(position); + chars.append(c); + } + + void appendCodePoint(int codePoint, int position) { + if (codePoint >= Character.MIN_LOW_SURROGATE + && codePoint <= Character.MAX_LOW_SURROGATE) { + if (highSurrogate == 0) { + throw invalidSurrogatePair(position); + } + chars.appendCodePoint(Character.toCodePoint(highSurrogate, (char) codePoint)); + highSurrogate = 0; + return; + } + requireNoPendingSurrogate(position); + if (codePoint >= Character.MIN_HIGH_SURROGATE + && codePoint <= Character.MAX_HIGH_SURROGATE) { + highSurrogate = (char) codePoint; + } else { + chars.appendCodePoint(codePoint); + } + } + + String finish(int position) { + requireNoPendingSurrogate(position); + return chars.toString(); + } + + private void requireNoPendingSurrogate(int position) { + if (highSurrogate != 0) { + throw invalidSurrogatePair(position); + } } - return buffer.toString(); } @Override @@ -141,7 +578,10 @@ public T accept(ExpressionVisitor expressionVisitor, S context) { @Override public String toString() { - return (prefix != null ? prefix : "") + quoteStr + value + quoteStr; + String unicodeEscape = unicodeEscapeCharacter != null + ? " UESCAPE '" + unicodeEscapeCharacter + "'" + : ""; + return (prefix != null ? prefix : "") + quoteStr + value + quoteStr + unicodeEscape; } public StringValue withPrefix(String prefix) { diff --git a/src/main/java/net/sf/jsqlparser/expression/TimezoneExpression.java b/src/main/java/net/sf/jsqlparser/expression/TimezoneExpression.java index a67572acea..6959549879 100644 --- a/src/main/java/net/sf/jsqlparser/expression/TimezoneExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/TimezoneExpression.java @@ -14,11 +14,13 @@ import java.util.Arrays; import java.util.List; +import java.util.function.Consumer; public class TimezoneExpression extends ASTNodeAccessImpl implements Expression { private final ExpressionList timezoneExpressions = new ExpressionList<>(); private Expression leftExpression; + private boolean atLocal; public TimezoneExpression() { leftExpression = null; @@ -51,13 +53,37 @@ public void addTimezoneExpression(Expression... timezoneExpr) { this.timezoneExpressions.addAll(Arrays.asList(timezoneExpr)); } - @Override - public String toString() { - StringBuilder returnValue = new StringBuilder(leftExpression.toString()); + /** + * Whether the expression ends with {@code AT LOCAL}, which converts to the session time zone. + * It follows the {@code AT TIME ZONE} conversions of this expression, if there are any. + */ + public boolean isAtLocal() { + return atLocal; + } + + public TimezoneExpression setAtLocal(boolean atLocal) { + this.atLocal = atLocal; + return this; + } + + /** + * Appends the expression, rendering the operand and each time zone through the renderer. + */ + public StringBuilder appendTo(StringBuilder builder, Consumer expressionRenderer) { + expressionRenderer.accept(leftExpression); for (Expression expr : timezoneExpressions) { - returnValue.append(" AT TIME ZONE ").append(expr.toString()); + builder.append(" AT TIME ZONE "); + expressionRenderer.accept(expr); + } + if (atLocal) { + builder.append(" AT LOCAL"); } + return builder; + } - return returnValue.toString(); + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); } } diff --git a/src/main/java/net/sf/jsqlparser/expression/WindowDefinition.java b/src/main/java/net/sf/jsqlparser/expression/WindowDefinition.java index 2996821cf2..cbf6253548 100644 --- a/src/main/java/net/sf/jsqlparser/expression/WindowDefinition.java +++ b/src/main/java/net/sf/jsqlparser/expression/WindowDefinition.java @@ -23,6 +23,7 @@ public class WindowDefinition implements Serializable { final PartitionByClause partitionBy = new PartitionByClause(); WindowElement windowElement = null; private String windowName; + private String baseWindowName; public OrderByClause getOrderBy() { return orderBy; @@ -61,6 +62,31 @@ public void setPartitionExpressionList(ExpressionList partitionExpre partitionBy.setExpressions(partitionExpressionList, brackets); } + /** DuckDB: the window this one extends, as w in OVER (w ORDER BY b), or {@code null}. */ + public String getBaseWindowName() { + return baseWindowName; + } + + public WindowDefinition setBaseWindowName(String baseWindowName) { + this.baseWindowName = baseWindowName; + return this; + } + + /** Appends the base window name, separated from any following part. */ + public void appendBaseWindowNameTo(StringBuilder builder) { + if (baseWindowName != null) { + builder.append(baseWindowName); + boolean more = partitionBy.getPartitionExpressionList() != null + && !partitionBy.getPartitionExpressionList().isEmpty() + || orderBy.getOrderByElements() != null + && !orderBy.getOrderByElements().isEmpty() + || windowElement != null; + if (more) { + builder.append(' '); + } + } + } + public String getWindowName() { return windowName; } @@ -105,6 +131,7 @@ public String toString() { b.append(windowName).append(" AS "); } b.append("("); + appendBaseWindowNameTo(b); partitionBy.toStringPartitionBy(b); orderBy.toStringOrderByElements(b); diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/arithmetic/Exponentiation.java b/src/main/java/net/sf/jsqlparser/expression/operators/arithmetic/Exponentiation.java new file mode 100644 index 0000000000..321e014879 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/expression/operators/arithmetic/Exponentiation.java @@ -0,0 +1,44 @@ +/*- + * #%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.expression.operators.arithmetic; + +import net.sf.jsqlparser.expression.BinaryExpression; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitor; + +/** DuckDB's {@code a ** b}, {@code a} raised to the power {@code b}. */ +public class Exponentiation extends BinaryExpression { + + public Exponentiation() {} + + public Exponentiation(Expression leftExpression, Expression rightExpression) { + super(leftExpression, rightExpression); + } + + @Override + public T accept(ExpressionVisitor expressionVisitor, S context) { + return expressionVisitor.visit(this, context); + } + + @Override + public String getStringExpression() { + return "**"; + } + + @Override + public Exponentiation withLeftExpression(Expression arg0) { + return (Exponentiation) super.withLeftExpression(arg0); + } + + @Override + public Exponentiation withRightExpression(Expression arg0) { + return (Exponentiation) super.withRightExpression(arg0); + } +} diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/relational/EqualsTo.java b/src/main/java/net/sf/jsqlparser/expression/operators/relational/EqualsTo.java index 8f80f1be88..19f238ffbb 100755 --- a/src/main/java/net/sf/jsqlparser/expression/operators/relational/EqualsTo.java +++ b/src/main/java/net/sf/jsqlparser/expression/operators/relational/EqualsTo.java @@ -18,6 +18,11 @@ public EqualsTo() { super("="); } + /** {@code operator} is {@code =} or DuckDB's {@code ==}. */ + public EqualsTo(String operator) { + super(operator); + } + public EqualsTo(Expression left, Expression right) { this(); setLeftExpression(left); diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearch.java b/src/main/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearch.java index 0bf79f0ec8..8c1a8d97ef 100644 --- a/src/main/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearch.java +++ b/src/main/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearch.java @@ -75,13 +75,13 @@ public T accept(ExpressionVisitor expressionVisitor, S context) { @Override public String toString() { // Build a list of matched columns - String columnsListCommaSeperated = ""; + StringBuilder columnsListCommaSeperated = new StringBuilder(); Iterator iterator = this._matchColumns.iterator(); while (iterator.hasNext()) { Column col = iterator.next(); - columnsListCommaSeperated += col.getFullyQualifiedName(); + columnsListCommaSeperated.append(col.getFullyQualifiedName()); if (iterator.hasNext()) { - columnsListCommaSeperated += ","; + columnsListCommaSeperated.append(","); } } diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/relational/IsNormalizedExpression.java b/src/main/java/net/sf/jsqlparser/expression/operators/relational/IsNormalizedExpression.java new file mode 100644 index 0000000000..bd4593480f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/expression/operators/relational/IsNormalizedExpression.java @@ -0,0 +1,112 @@ +/*- + * #%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.expression.operators.relational; + +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitor; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; + +/** + * The Unicode normalization test {@code expression IS [NOT] [NFC | NFD | NFKC | NFKD] NORMALIZED}. + */ +public class IsNormalizedExpression extends ASTNodeAccessImpl implements Expression { + /** The Unicode normalization forms. */ + public enum NormalForm { + NFC, NFD, NFKC, NFKD; + + /** Whether the word names a normalization form, in any case. */ + public static boolean isNormalForm(String word) { + for (NormalForm form : values()) { + if (form.name().equalsIgnoreCase(word)) { + return true; + } + } + return false; + } + } + + private Expression leftExpression; + private boolean not; + private NormalForm normalForm; + + public IsNormalizedExpression() { + // empty constructor + } + + public IsNormalizedExpression(Expression leftExpression) { + this.leftExpression = leftExpression; + } + + public Expression getLeftExpression() { + return leftExpression; + } + + public void setLeftExpression(Expression leftExpression) { + this.leftExpression = leftExpression; + } + + public IsNormalizedExpression withLeftExpression(Expression leftExpression) { + this.setLeftExpression(leftExpression); + return this; + } + + public E getLeftExpression(Class type) { + return type.cast(getLeftExpression()); + } + + public boolean isNot() { + return not; + } + + public void setNot(boolean not) { + this.not = not; + } + + public IsNormalizedExpression withNot(boolean not) { + this.setNot(not); + return this; + } + + /** The normalization form as written, or null when it is omitted (the server tests NFC). */ + public NormalForm getNormalForm() { + return normalForm; + } + + public void setNormalForm(NormalForm normalForm) { + this.normalForm = normalForm; + } + + public IsNormalizedExpression withNormalForm(NormalForm normalForm) { + this.setNormalForm(normalForm); + return this; + } + + @Override + public T accept(ExpressionVisitor expressionVisitor, S context) { + return expressionVisitor.visit(this, context); + } + + /** Appends the test, rendering the operand through the renderer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer expressionRenderer) { + expressionRenderer.accept(leftExpression); + builder.append(not ? " IS NOT " : " IS "); + if (normalForm != null) { + builder.append(normalForm).append(' '); + } + return builder.append("NORMALIZED"); + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/relational/LikeExpression.java b/src/main/java/net/sf/jsqlparser/expression/operators/relational/LikeExpression.java index 92563d7d85..125e38a825 100644 --- a/src/main/java/net/sf/jsqlparser/expression/operators/relational/LikeExpression.java +++ b/src/main/java/net/sf/jsqlparser/expression/operators/relational/LikeExpression.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.expression.operators.relational; import java.util.Locale; +import java.util.regex.Pattern; import net.sf.jsqlparser.expression.BinaryExpression; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.ExpressionVisitor; @@ -18,6 +19,7 @@ public class LikeExpression extends BinaryExpression implements SupportsOldOracl private boolean not = false; private boolean useBinary = false; private Expression escapeExpression = null; + private boolean useOperator = false; private KeyWord likeKeyWord = KeyWord.LIKE; public boolean isNot() { @@ -48,12 +50,64 @@ public String getStringExpression() { return likeKeyWord.toString(); } + /** + * The operator spelling of this condition when it was written as one and has one, e.g. + * {@code !~~} for {@code NOT LIKE}; otherwise {@code null} and the keyword form is used. + */ + public String getLikeOperator() { + if (!useOperator) { + return null; + } + switch (likeKeyWord) { + case LIKE: + return not ? "!~~" : "~~"; + case ILIKE: + return not ? "!~~*" : "~~*"; + case GLOB: + return not ? null : "~~~"; + default: + return null; + } + } + + /** + * Sets the keyword and {@code NOT} from DuckDB's and PostgreSQL's operator spelling: {@code ~~} + * is {@code LIKE}, {@code ~~*} {@code ILIKE}, {@code ~~~} {@code GLOB}, and a leading {@code !} + * negates the first two. The operator is printed while it matches the keyword and {@code NOT}. + */ + public LikeExpression setLikeOperator(String likeOperator) { + if (likeOperator == null) { + throw new IllegalArgumentException("The LIKE operator must not be null"); + } + switch (likeOperator) { + case "~~": + case "!~~": + likeKeyWord = KeyWord.LIKE; + break; + case "~~*": + case "!~~*": + likeKeyWord = KeyWord.ILIKE; + break; + case "~~~": + likeKeyWord = KeyWord.GLOB; + break; + default: + throw new IllegalArgumentException("Unknown LIKE operator: " + likeOperator); + } + this.not = likeOperator.startsWith("!"); + this.useOperator = true; + return this; + } + @Override public String toString() { + String likeOperator = getLikeOperator(); String retval = (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "") - + getLeftExpression() + " " + (not ? "NOT " : "") - + (likeKeyWord == KeyWord.SIMILAR_TO ? "SIMILAR TO" : likeKeyWord) + " " - + (useBinary ? "BINARY " : "") + getRightExpression(); + + getLeftExpression() + " " + + (likeOperator != null ? likeOperator + : (not ? "NOT " : "") + + (likeKeyWord == KeyWord.SIMILAR_TO ? "SIMILAR TO" : likeKeyWord)) + + " " + (useBinary ? "BINARY " : "") + getRightExpression(); if (escapeExpression != null) { retval += " ESCAPE " + escapeExpression; } @@ -121,9 +175,11 @@ public LikeExpression withRightExpression(Expression arg0) { public enum KeyWord { LIKE, ILIKE, RLIKE, REGEXP_LIKE, REGEXP, GLOB, SIMILAR_TO, MATCH_ANY, MATCH_ALL, MATCH_PHRASE, MATCH_PHRASE_PREFIX, MATCH_REGEXP; + private static final Pattern WHITESPACE = Pattern.compile("\\s+"); + public static KeyWord from(String keyword) { return Enum.valueOf(KeyWord.class, - keyword.toUpperCase(Locale.ROOT).replaceAll("\\s+", "_")); + WHITESPACE.matcher(keyword.toUpperCase(Locale.ROOT)).replaceAll("_")); } } diff --git a/src/main/java/net/sf/jsqlparser/parser/ASTNodeAccessImpl.java b/src/main/java/net/sf/jsqlparser/parser/ASTNodeAccessImpl.java index 6ef61996b6..3a1ad53294 100644 --- a/src/main/java/net/sf/jsqlparser/parser/ASTNodeAccessImpl.java +++ b/src/main/java/net/sf/jsqlparser/parser/ASTNodeAccessImpl.java @@ -9,6 +9,9 @@ */ package net.sf.jsqlparser.parser; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; import java.util.Set; import java.util.TreeSet; @@ -26,6 +29,26 @@ public void setASTNode(Node node) { this.node = node; } + /** + * The comments preceding this node's first token, in source order, with the original token + * images. Line comments do not include their line terminator; callers must add a line break + * when prepending them to SQL. Empty for nodes built programmatically, which carry no AST. + */ + public List getLeadingComments() { + Node node = getASTNode(); + if (node == null) { + return new ArrayList<>(); + } + List comments = new ArrayList<>(); + for (Token specialToken = + node.jjtGetFirstToken().specialToken; specialToken != null; specialToken = + specialToken.specialToken) { + comments.add(specialToken.image); + } + Collections.reverse(comments); + return comments; + } + public StringBuilder appendTo(StringBuilder builder) { // don't add spaces around the following punctuation final Set punctuation = new TreeSet<>(Set.of(".", "[", "]")); @@ -48,22 +71,20 @@ public StringBuilder appendTo(StringBuilder builder) { return builder; } + /** + * The nearest enclosing object in the tree, or null when there is none. A node that carries + * only a token range, for an object no grammar rule opens a tree node for, has no parent. + */ public ASTNodeAccess getParent() { - Node parent = (Node) node.jjtGetParent(); - while (parent.jjtGetValue() == null) { - parent = (Node) parent.jjtGetParent(); - } - - return ASTNodeAccess.class.cast(parent.jjtGetValue()); + return getParent(ASTNodeAccess.class); } public T getParent(Class clazz) { - Node parent = (Node) node.jjtGetParent(); - while (parent.jjtGetValue() == null || !clazz.isInstance(parent.jjtGetValue())) { + Node parent = node == null ? null : (Node) node.jjtGetParent(); + while (parent != null && !clazz.isInstance(parent.jjtGetValue())) { parent = (Node) parent.jjtGetParent(); } - - return clazz.cast(parent.jjtGetValue()); + return parent == null ? null : clazz.cast(parent.jjtGetValue()); } @Override diff --git a/src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java b/src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java index a394558459..28d969ed16 100644 --- a/src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java +++ b/src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java @@ -11,6 +11,8 @@ import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.statement.update.UpdateConflictAlgorithm; +import net.sf.jsqlparser.statement.upsert.UpsertType; import java.util.ArrayList; import java.util.Collections; @@ -39,7 +41,8 @@ public enum Dialect { Feature.allowDoubleQuotedStrings), SQLSERVER(AdjacentStringLiterals.OFF, Feature.allowSquareBracketQuotation), POSTGRESQL( AdjacentStringLiterals.NEWLINE, - Feature.allowDollarQuotedStringTags), H2, EXASOL, BIGQUERY( + Feature.allowDollarQuotedStringTags, + Feature.allowDigitSeparators), H2, EXASOL, BIGQUERY( AdjacentStringLiterals.WHITESPACE, Feature.allowDoubleQuotedStrings, Feature.allowHashLineComments, @@ -47,7 +50,7 @@ public enum Dialect { AdjacentStringLiterals.WHITESPACE, Feature.allowDoubleQuotedStrings, Feature.allowBackslashEscapeCharacter), SNOWFLAKE( - Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER, DORIS, COCKROACHDB, TERADATA; + Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER, DORIS, COCKROACHDB, TERADATA, SQLITE; private final Set lexerFeatures; private final AdjacentStringLiterals adjacentStringLiterals; @@ -109,6 +112,21 @@ public P withLegacyMySqlGroupBy(boolean enabled) { return withFeature(Feature.allowLegacyMySqlGroupBy, enabled); } + /** + * Resolves MySQL executable comments against this server version (for example 90702 for 9.7.2). + * Requires the MYSQL dialect. Rendered SQL reflects this version, without conditional wrappers. + * Without an explicit version, conditional executable comments raise a lexical error. + * + * @param version major * 10000 + minor * 100 + patch, from 0 through 999999 + * @return this parser + */ + public P withMySqlServerVersion(int version) { + if (version < 0 || version > 999999) { + throw new IllegalArgumentException("MySQL server version must be between 0 and 999999"); + } + return withFeature(Feature.mySqlServerVersion, (long) version); + } + public P withTimeOut(long timeOutMillSeconds) { return withFeature(Feature.timeOut, timeOutMillSeconds); } @@ -179,6 +197,19 @@ public P withHashLineComments(boolean allowHashLineComments) { return withFeature(Feature.allowHashLineComments, allowHashLineComments); } + public P withBlankLinesAsSeparator(boolean allowBlankLinesAsStatementSeparator) { + return withFeature(Feature.allowBlankLinesAsStatementSeparator, + allowBlankLinesAsStatementSeparator); + } + + public P withDigitSeparators() { + return withFeature(Feature.allowDigitSeparators, true); + } + + public P withDigitSeparators(boolean allowDigitSeparators) { + return withFeature(Feature.allowDigitSeparators, allowDigitSeparators); + } + public P withUnparenthesizedSubSelects() { return withFeature(Feature.allowUnparenthesizedSubSelects, true); } @@ -230,6 +261,42 @@ public Integer getAsInteger(Feature f) { return getConfiguration().getAsInteger(f); } + /** + * The INSERT OR conflict algorithms other than REPLACE are SQLite syntax. + */ + protected UpsertType insertOrType(String algorithm) throws ParseException { + if ("REPLACE".equalsIgnoreCase(algorithm)) { + return UpsertType.INSERT_OR_REPLACE; + } + if (!Dialect.SQLITE.name().equals(getAsString(Feature.dialect))) { + throw new ParseException("INSERT OR " + algorithm + " needs Dialect.SQLITE"); + } + switch (algorithm.toUpperCase()) { + case "IGNORE": + return UpsertType.INSERT_OR_IGNORE; + case "ROLLBACK": + return UpsertType.INSERT_OR_ROLLBACK; + case "ABORT": + return UpsertType.INSERT_OR_ABORT; + case "FAIL": + return UpsertType.INSERT_OR_FAIL; + default: + throw new ParseException("Expected ABORT, FAIL, IGNORE, REPLACE or ROLLBACK"); + } + } + + protected UpdateConflictAlgorithm updateOrAlgorithm(String algorithm) throws ParseException { + if (!Dialect.SQLITE.name().equals(getAsString(Feature.dialect))) { + throw new ParseException("UPDATE OR " + algorithm + " needs Dialect.SQLITE"); + } + for (UpdateConflictAlgorithm conflictAlgorithm : UpdateConflictAlgorithm.values()) { + if (conflictAlgorithm.name().equalsIgnoreCase(algorithm)) { + return conflictAlgorithm; + } + } + throw new ParseException("Expected ABORT, FAIL, IGNORE, REPLACE or ROLLBACK"); + } + public String getAsString(Feature f) { return getConfiguration().getAsString(f); } diff --git a/src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java b/src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java index f187b7da1f..f3bbdc7ac0 100644 --- a/src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java +++ b/src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java @@ -278,50 +278,37 @@ private static ColDataType parseColDataType(String columnDataType, boolean allow } } - @SuppressWarnings("PMD.CyclomaticComplexity") public static Expression parseExpression(String expressionStr, boolean allowPartialParse, Consumer consumer) throws JSQLParserException { if (expressionStr == null || expressionStr.isEmpty()) { return null; } - Expression expression = null; - // first, try to parse fast and simple + // First require a complete simple parse, even when the caller allows a partial result. try { - CCJSqlParser parser = newParser(expressionStr).withAllowComplexParsing(false); - if (consumer != null) { - consumer.accept(parser); - } - try { - expression = parser.Expression(); - if (parser.getNextToken().kind != CCJSqlParserTokenManager.EOF) { - throw new JSQLParserException( - "could only parse partial expression " + expression.toString()); - } - } catch (ParseException ex) { - throw new JSQLParserException(expressionStr, ex); - } - } catch (JSQLParserException ex1) { - // when fast simple parsing fails, try complex parsing but only if it has a chance to - // succeed - CCJSqlParser parser = newParser(expressionStr).withAllowComplexParsing(true); - if (consumer != null) { - consumer.accept(parser); - } - try { - expression = parser.Expression(); - if (!allowPartialParse - && parser.getNextToken().kind != CCJSqlParserTokenManager.EOF) { - throw new JSQLParserException( - "could only parse partial expression " + expression.toString()); - } - } catch (JSQLParserException ex) { - throw ex; - } catch (ParseException ex) { - throw new JSQLParserException(ex); + return parseExpression(expressionStr, false, false, consumer); + } catch (JSQLParserException ex) { + return parseExpression(expressionStr, true, allowPartialParse, consumer); + } + } + + private static Expression parseExpression(String expressionStr, boolean allowComplexParsing, + boolean allowPartialParse, Consumer consumer) throws JSQLParserException { + CCJSqlParser parser = newParser(expressionStr).withAllowComplexParsing(allowComplexParsing); + if (consumer != null) { + consumer.accept(parser); + } + + try { + Expression expression = parser.Expression(); + if (!allowPartialParse && parser.getNextToken().kind != CCJSqlParserTokenManager.EOF) { + throw new JSQLParserException( + "could only parse partial expression " + expression.toString()); } + return expression; + } catch (ParseException ex) { + throw new JSQLParserException(ex); } - return expression; } /** @@ -356,50 +343,9 @@ public static Expression parseCondExpression(String condExpr, boolean allowParti }); } - @SuppressWarnings("PMD.CyclomaticComplexity") public static Expression parseCondExpression(String conditionalExpressionStr, boolean allowPartialParse, Consumer consumer) throws JSQLParserException { - if (conditionalExpressionStr == null || conditionalExpressionStr.isEmpty()) { - return null; - } - - Expression expression = null; - // first, try to parse fast and simple - try { - CCJSqlParser parser = - newParser(conditionalExpressionStr).withAllowComplexParsing(false); - if (consumer != null) { - consumer.accept(parser); - } - try { - expression = parser.Expression(); - if (parser.getNextToken().kind != CCJSqlParserTokenManager.EOF) { - throw new JSQLParserException( - "could only parse partial expression " + expression.toString()); - } - } catch (ParseException ex) { - throw new JSQLParserException(ex); - } - } catch (JSQLParserException ex1) { - CCJSqlParser parser = - newParser(conditionalExpressionStr).withAllowComplexParsing(true); - if (consumer != null) { - consumer.accept(parser); - } - try { - expression = parser.Expression(); - if (!allowPartialParse - && parser.getNextToken().kind != CCJSqlParserTokenManager.EOF) { - throw new JSQLParserException( - "could only parse partial expression " + expression.toString()); - } - } catch (JSQLParserException ex) { - throw ex; - } catch (ParseException ex) { - throw new JSQLParserException(ex); - } - } - return expression; + return parseExpression(conditionalExpressionStr, allowPartialParse, consumer); } /** diff --git a/src/main/java/net/sf/jsqlparser/parser/RangeNode.java b/src/main/java/net/sf/jsqlparser/parser/RangeNode.java new file mode 100644 index 0000000000..9b025a2ebc --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/parser/RangeNode.java @@ -0,0 +1,71 @@ +/*- + * #%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.parser; + +/** + * A node outside the parse tree that records the tokens an object spans. It serves an object no + * grammar rule opens a tree node for, or one whose text runs past its tree node. In that second + * case it stands in for the tree node, answering its parent, children and id, with the wider range. + */ +final class RangeNode extends Node { + private final Node treeNode; + + RangeNode(Token first, Token last, Node treeNode) { + super(CCJSqlParserTreeConstants.JJTEXPRESSION); + this.treeNode = treeNode; + jjtSetFirstToken(first); + jjtSetLastToken(last); + } + + @Override + public Node jjtGetParent() { + return treeNode == null ? null : treeNode.jjtGetParent(); + } + + @Override + public Node[] jjtGetChildren() { + return treeNode == null ? super.jjtGetChildren() : treeNode.jjtGetChildren(); + } + + @Override + public Node jjtGetChild(int i) { + return treeNode == null ? super.jjtGetChild(i) : treeNode.jjtGetChild(i); + } + + @Override + public int jjtGetNumChildren() { + return treeNode == null ? super.jjtGetNumChildren() : treeNode.jjtGetNumChildren(); + } + + @Override + public Object childrenAccept(CCJSqlParserVisitor visitor, Object data) { + return treeNode == null ? super.childrenAccept(visitor, data) + : treeNode.childrenAccept(visitor, data); + } + + @Override + public int getId() { + return treeNode == null ? super.getId() : treeNode.getId(); + } + + @Override + public String toString() { + return treeNode == null ? super.toString() : treeNode.toString(); + } + + @Override + public void dump(String prefix) { + if (treeNode == null) { + super.dump(prefix); + } else { + treeNode.dump(prefix); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/parser/RoutineBodyBoundary.java b/src/main/java/net/sf/jsqlparser/parser/RoutineBodyBoundary.java new file mode 100644 index 0000000000..02b1c0b9c5 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/parser/RoutineBodyBoundary.java @@ -0,0 +1,295 @@ +/*- + * #%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.parser; + +import static net.sf.jsqlparser.parser.CCJSqlParserConstants.*; + +import java.util.ArrayDeque; +import java.util.Deque; + +/** + * Finds the boundary of an opaque routine without interpreting its statements. In particular, + * expression CASE and procedural END qualifiers must not close an enclosing BEGIN block. + */ +final class RoutineBodyBoundary { + private enum Block { + BEGIN, IF, CASE_STATEMENT, CASE_EXPRESSION, LOOP, WHILE, REPEAT + } + + private final Deque blocks = new ArrayDeque<>(); + private int parentheses; + private int previousKind = -1; + private int statementKind = -1; + private boolean hasParameters; + private boolean standardReturns; + private boolean returnTypeName; + private boolean afterDot; + private boolean declarations; + private boolean bodyStarted; + private boolean compoundBody; + private boolean quotedBody; + private boolean completed; + private boolean handlerAction; + private boolean statementStart = true; + + /** + * Tracks a compound statement without a routine header, such as a MySQL trigger body. Its + * tokens belong to the body from the start, as after a routine's parameter list. + */ + static RoutineBodyBoundary forCompoundStatement() { + RoutineBodyBoundary boundary = new RoutineBodyBoundary(); + boundary.hasParameters = true; + return boundary; + } + + boolean endsAt(Token token) throws ParseException { + if (token.kind == EOF) { + if (!blocks.isEmpty()) { + throw new ParseException("Unterminated routine block"); + } + return true; + } + return token.kind == ST_SEMICOLON && parentheses == 0 && blocks.isEmpty() + && !declarations && (hasParameters || quotedBody || completed); + } + + /** + * Whether the routine header, including a return type, is complete and the body has not + * started, which is where MySQL routine characteristics appear. + */ + boolean isBeforeBody() { + return hasParameters && parentheses == 0 && !bodyStarted && !returnTypeName + && !declarations && !quotedBody && !completed; + } + + boolean startsQuotedBody(Token token, Token next) { + return parentheses == 0 && !compoundBody && !quotedBody && token.kind == K_AS + && next.kind == S_CHAR_LITERAL + && (!bodyStarted || statementKind == K_RETURN || statementKind == K_SET); + } + + void quotedBody() { + quotedBody = true; + bodyStarted = true; + declarations = false; + } + + void accept(Token token, Token next) { + int kind = token.kind; + if (kind == OPENING_BRACKET) { + parentheses++; + } else if (kind == CLOSING_BRACKET) { + if (--parentheses == 0 && !bodyStarted) { + hasParameters = true; + } + } else if (parentheses == 0 && !quotedBody && !completed) { + acceptTopLevel(token, next); + } + previousKind = kind; + afterDot = ".".equals(token.image); + } + + private void acceptTopLevel(Token token, Token next) { + if (afterDot) { + return; // Qualified type/column names may use otherwise significant keywords. + } + // END IF/CASE/LOOP/WHILE/REPEAT is one terminator, not another opener. + if (previousKind == K_END && isEndQualifier(token)) { + return; + } + if (!acceptRoutineHeader(token)) { + acceptBodyToken(token, next); + } + } + + private boolean acceptRoutineHeader(Token token) { + int kind = token.kind; + if (kind == K_RETURNS && !bodyStarted) { + standardReturns = true; + returnTypeName = true; + return true; + } + if (returnTypeName) { + returnTypeName = keyword(token, "SETOF"); + return true; + } + if (!compoundBody && (kind == K_AS || kind == K_IS) + && (!bodyStarted || statementKind == K_RETURN && !standardReturns + || statementKind == K_SET)) { + declarations = true; + bodyStarted = false; + return true; + } + return false; + } + + private void acceptBodyToken(Token token, Token next) { + int kind = token.kind; + if (acceptStatementBoundary(kind)) { + return; + } + if (!(hasParameters || declarations || bodyStarted)) { + return; + } + if (handlerAction && isSimpleStatementStart(kind)) { + startStatement(); + } + if (acceptBeginOrCase(kind) || declarations || acceptControlFlow(token)) { + return; + } + acceptStatementToken(token, next); + } + + private boolean acceptStatementBoundary(int kind) { + if (kind == ST_SEMICOLON) { + startStatement(); + return true; + } + if (kind == K_END) { + if (!blocks.isEmpty()) { + Block closed = blocks.pop(); + completed = blocks.isEmpty() && closed != Block.CASE_EXPRESSION; + } else { + // Retain legacy opaque declarations without a parameter list or BEGIN. + completed = true; + } + statementStart = false; + return true; + } + return false; + } + + private boolean acceptBeginOrCase(int kind) { + if (kind == K_BEGIN + && (!bodyStarted || statementStart || statementKind == K_DECLARE)) { + blocks.push(Block.BEGIN); + declarations = false; + compoundBody = true; + bodyStarted = true; + startStatement(); + return true; + } + if (kind == K_CASE) { + boolean statementCase = !declarations && (statementStart || handlerAction); + blocks.push(statementCase ? Block.CASE_STATEMENT : Block.CASE_EXPRESSION); + if (statementCase) { + bodyStarted = true; + compoundBody = true; + handlerAction = false; + } + statementStart = false; + return true; + } + return false; + } + + private boolean acceptControlFlow(Token token) { + int kind = token.kind; + Block block = controlBlock(token); + if ((statementStart || handlerAction) && block != null) { + blocks.push(block); + bodyStarted = true; + compoundBody = true; + handlerAction = false; + statementKind = kind; + statementStart = block == Block.LOOP || block == Block.REPEAT; + return true; + } + if (acceptOracleLoop(kind)) { + return true; + } + if (isStatementBranch(kind)) { + startStatement(); + return true; + } + return false; + } + + private boolean acceptOracleLoop(int kind) { + if (kind == K_LOOP && (statementKind == K_FOR || blocks.peek() == Block.WHILE)) { + // Oracle FOR/WHILE ... LOOP shares the same END LOOP boundary. + if (blocks.peek() != Block.WHILE) { + blocks.push(Block.LOOP); + } + startStatement(); + return true; + } + return false; + } + + private boolean isStatementBranch(int kind) { + return (kind == K_THEN || kind == K_ELSE) && !blocks.isEmpty() + && blocks.peek() != Block.CASE_EXPRESSION + || kind == K_DO && blocks.peek() == Block.WHILE; + } + + private void acceptStatementToken(Token token, Token next) { + int kind = token.kind; + if (isStatementPrefix(token, next)) { + return; + } + if (!bodyStarted) { + // SET may also be a PostgreSQL header option; AS remains recognizable above. + // CHARACTER SET and CHAR SET belong to a MySQL return type. + boolean characterSet = + kind == K_SET && (previousKind == K_CHARACTER || previousKind == K_CHAR); + if (!isSimpleStatementStart(kind) || characterSet) { + return; + } + bodyStarted = true; + } + if (statementStart) { + statementKind = kind; + } + if (statementKind == K_DECLARE && token.kind == K_HANDLER) { + handlerAction = true; + } + statementStart = false; + } + + private boolean isStatementPrefix(Token token, Token next) { + // ATOMIC and a label precede the statement they qualify. + return previousKind == K_BEGIN && keyword(token, "ATOMIC") + || statementStart && (":".equals(next.image) || ":".equals(token.image)); + } + + private static boolean isEndQualifier(Token token) { + return token.kind == K_CASE || controlBlock(token) != null; + } + + private static Block controlBlock(Token token) { + if (token.kind == K_IF) { + return Block.IF; + } + if (token.kind == K_LOOP) { + return Block.LOOP; + } + if (keyword(token, "WHILE")) { + return Block.WHILE; + } + return keyword(token, "REPEAT") ? Block.REPEAT : null; + } + + private void startStatement() { + statementStart = true; + statementKind = -1; + handlerAction = false; + } + + private static boolean keyword(Token token, String keyword) { + return token.kind == S_IDENTIFIER && keyword.equalsIgnoreCase(token.image); + } + + private static boolean isSimpleStatementStart(int kind) { + return kind == K_RETURN || kind == K_SELECT || kind == K_INSERT || kind == K_UPDATE + || kind == K_DELETE || kind == K_REPLACE || kind == K_SET || kind == K_CALL + || kind == K_WITH || kind == K_DO; + } +} diff --git a/src/main/java/net/sf/jsqlparser/parser/SimpleCharStream.java b/src/main/java/net/sf/jsqlparser/parser/SimpleCharStream.java index ca81a8dd11..5b6c5e8259 100644 --- a/src/main/java/net/sf/jsqlparser/parser/SimpleCharStream.java +++ b/src/main/java/net/sf/jsqlparser/parser/SimpleCharStream.java @@ -10,9 +10,10 @@ /* Generated By:JavaCC: Do not edit this line by hand. SimpleCharStream.java Version 8.0.0 */ /* * Warning: this file is maintained by hand on top of the JavaCC template. Among other manual - * adjustments it carries the in-buffer '#' rewrite in BeginToken(), which - * Feature.allowHashLineComments depends on. Never overwrite it with a freshly generated - * SimpleCharStream, that would silently drop the rewrite and break allowHashLineComments. + * adjustments it carries the in-buffer '#' and blank line rewrites in BeginToken(), which + * Feature.allowHashLineComments and Feature.allowBlankLinesAsStatementSeparator depend on. Never + * overwrite it with a freshly generated SimpleCharStream, that would silently drop the rewrites and + * break both features. */ package net.sf.jsqlparser.parser; @@ -47,6 +48,9 @@ public class SimpleCharStream { protected boolean trackLineColumn = true; protected int totalCharsRead = 0; protected int absoluteTokenBegin = 0; + // line, column and absolute position of each match begun since the last positionSpecialTokens() + private int[] matchBegins = new int[24]; + private int matchBeginCount = 0; int bufsize; int available; int tokenBegin; @@ -60,7 +64,12 @@ public class SimpleCharStream { // the `#` in the token image. Wired (with the token manager's // configuration) before parsing, null keeps this inert. static final char HASH_SUBSTITUTION = '\u0001'; + static final char MYSQL_MINUS_SUBSTITUTION = '\u0002'; + static final char MYSQL_COMMENT_ERROR = '\u0003'; FeatureConfiguration featureConfiguration; + private boolean mySqlExecutableComment; + String mySqlCommentError; + boolean mySqlMinusSubstitution; /** * Constructor. @@ -101,6 +110,38 @@ public final int getAbsoluteTokenBegin() { return absoluteTokenBegin; } + /** + * Gives the comments in front of {@code token} the positions where their matches began, from + * the begins recorded since the last call, and forgets those. Comments come through no token + * action, so this is how they get a position. The comments chain backwards from the token while + * the begins are recorded forwards, so one backwards pass pairs them. + */ + public final void positionSpecialTokens(Token token) { + int i = matchBeginCount - 3; + for (Token comment = token.specialToken; comment != null; comment = comment.specialToken) { + while (i >= 0 && (matchBegins[i] != comment.beginLine + || matchBegins[i + 1] != comment.beginColumn)) { + i -= 3; + } + if (i < 0) { + break; + } + comment.absoluteBegin = matchBegins[i + 2]; + comment.absoluteEnd = comment.absoluteBegin + comment.image.length(); + i -= 3; + } + matchBeginCount = 0; + } + + private void recordMatchBegin() { + if (matchBeginCount + 3 > matchBegins.length) { + matchBegins = java.util.Arrays.copyOf(matchBegins, matchBegins.length * 2); + } + matchBegins[matchBeginCount++] = getBeginLine(); + matchBegins[matchBeginCount++] = getBeginColumn(); + matchBegins[matchBeginCount++] = absoluteTokenBegin; + } + protected void ExpandBuff(boolean wrapAround) { final int newSize = bufsize * 2; char[] newbuffer = new char[newSize]; @@ -173,20 +214,138 @@ protected void FillBuff() throws java.io.IOException { * Start. */ public final char BeginToken() throws java.io.IOException { + mySqlMinusSubstitution = false; + if (mySqlCommentError != null) { + // Parser lookahead may catch lexical errors. Keep this failure sticky until ReInit + // rather than allowing a later token request to continue after the rejected marker. + return MYSQL_COMMENT_ERROR; + } tokenBegin = -1; - char c = readChar(); + char c; + try { + c = readChar(); + } catch (java.io.IOException e) { + if (!mySqlExecutableComment) { + throw e; + } + // JavaCC treats exceptions from BeginToken as EOF. Emit a real token whose lexical + // action reports the error, so an unclosed executable comment cannot succeed as SQL. + c = mySqlCommentError("Unterminated MySQL executable comment"); + } tokenBegin = bufpos; absoluteTokenBegin = totalCharsRead; + recordMatchBegin(); if (c == '#' && featureConfiguration != null && featureConfiguration.getAsBoolean(Feature.allowHashLineComments)) { buffer[bufpos] = HASH_SUBSTITUTION; c = HASH_SUBSTITUTION; + } else if ((c == '-' || c == '/' || c == '*') && featureConfiguration != null + && AbstractJSqlParser.Dialect.MYSQL.name() + .equals(featureConfiguration.getValue(Feature.dialect))) { + c = mySqlCommentBoundary(c); + } else if (c == '\n' && featureConfiguration != null + && !featureConfiguration + .getAsBoolean(Feature.allowBlankLinesAsStatementSeparator) + && peekCharacters(2).equals("\n\n")) { + // Blanking the first newline of the run stops ST_SEMICOLON matching "\n\n\n"; + // line and column tracking was already updated when the newline was read. + buffer[bufpos] = ' '; + c = ' '; } return c; } + /** Changes only token boundaries, never characters being scanned inside strings or names. */ + private char mySqlCommentBoundary(char c) throws java.io.IOException { + if (c == '-') { + String following = peekCharacters(2); + if (following.length() == 2 && following.charAt(0) == '-' + && !isMySqlCommentSpace(following.charAt(1))) { + mySqlMinusSubstitution = true; + buffer[bufpos] = MYSQL_MINUS_SUBSTITUTION; + return MYSQL_MINUS_SUBSTITUTION; + } + } else if (c == '*' && mySqlExecutableComment && peekCharacters(1).equals("/")) { + eraseCommentMarker(2); + mySqlExecutableComment = false; + return ' '; + } else if (c == '/') { + String following = peekCharacters(9); + if (following.startsWith("*!")) { + if (mySqlExecutableComment) { + return mySqlCommentError("Nested MySQL executable comments are not supported"); + } + int digits = mySqlCommentVersionLength(following); + if (digits > 0) { + long target = featureConfiguration.getAsLong(Feature.mySqlServerVersion); + if (target < 0 || target > 999999) { + return mySqlCommentError("MySQL conditional executable comments require " + + "withMySqlServerVersion(major * 10000 + minor * 100 + patch)"); + } + int minimum = Integer.parseInt(following.substring(2, 2 + digits)); + if (minimum > target) { + return c; + } + } + eraseCommentMarker(3 + digits); + mySqlExecutableComment = true; + return ' '; + } + } + return c; + } + + private static boolean isMySqlCommentSpace(char c) { + return c <= ' ' || c == '\u007f'; + } + + private static int mySqlCommentVersionLength(String following) { + if (following.length() < 7) { + return 0; + } + for (int i = 2; i < 7; i++) { + if (following.charAt(i) < '0' || following.charAt(i) > '9') { + return 0; + } + } + // MySQL recognizes a sixth digit only when followed by whitespace. Otherwise the + // five-digit prefix is the version and the remaining characters belong to the SQL body. + return following.length() >= 9 && following.charAt(7) >= '0' + && following.charAt(7) <= '9' && (following.charAt(8) == ' ' + || following.charAt(8) >= '\t' && following.charAt(8) <= '\r') + ? 6 + : 5; + } + + private String peekCharacters(int length) { + StringBuilder result = new StringBuilder(length); + try { + for (int i = 0; i < length; i++) { + result.append(readChar()); + } + } catch (java.io.IOException ignored) { + // Only the successfully read characters need to be rewound, including at EOF. + } + backup(result.length()); + return result.toString(); + } + + private void eraseCommentMarker(int length) throws java.io.IOException { + buffer[bufpos] = ' '; + for (int i = 1; i < length; i++) { + readChar(); + buffer[bufpos] = ' '; + } + backup(length - 1); + } + + private char mySqlCommentError(String message) { + mySqlCommentError = message; + return MYSQL_COMMENT_ERROR; + } + protected final void UpdateLineColumn(char c) { column++; @@ -318,6 +477,7 @@ public final void backup(int amount) { * Reinitialise. */ public void ReInit(Provider dstream, int startline, int startcolumn, int buffersize) { + matchBeginCount = 0; inputStream = dstream; line = startline; column = startcolumn - 1; @@ -330,6 +490,8 @@ public void ReInit(Provider dstream, int startline, int startcolumn, int buffers prevCharIsLF = prevCharIsCR = false; tokenBegin = inBuf = maxNextCharInd = 0; bufpos = -1; + mySqlExecutableComment = false; + mySqlCommentError = null; } /** @@ -362,6 +524,8 @@ public String GetImage() { String image = doGetImage(); if (!image.isEmpty() && image.charAt(0) == HASH_SUBSTITUTION) { image = "#" + image.substring(1); + } else if (!image.isEmpty() && image.charAt(0) == MYSQL_MINUS_SUBSTITUTION) { + image = "-" + image.substring(1); } return image; } diff --git a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java index e09ae85535..60f8850dc7 100644 --- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java +++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java @@ -22,14 +22,26 @@ import net.sf.jsqlparser.statement.DeclareStatement; import net.sf.jsqlparser.statement.DescribeStatement; import net.sf.jsqlparser.statement.ExplainStatement; +import net.sf.jsqlparser.statement.PluginStatement; +import net.sf.jsqlparser.statement.PrepareTransactionStatement; import net.sf.jsqlparser.statement.ResetStatement; +import net.sf.jsqlparser.statement.SetConstraintsStatement; import net.sf.jsqlparser.statement.SetStatement; +import net.sf.jsqlparser.statement.SetTransactionStatement; import net.sf.jsqlparser.statement.ShowColumnsStatement; import net.sf.jsqlparser.statement.ShowStatement; +import net.sf.jsqlparser.statement.TableMaintenanceStatement; import net.sf.jsqlparser.statement.UseStatement; +import net.sf.jsqlparser.statement.XaStatement; +import net.sf.jsqlparser.statement.admin.FlushStatement; +import net.sf.jsqlparser.statement.admin.KillStatement; import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterEventTrigger; import net.sf.jsqlparser.statement.alter.sequence.AlterSequence; import net.sf.jsqlparser.statement.analyze.Analyze; +import net.sf.jsqlparser.statement.maintenance.CheckpointStatement; +import net.sf.jsqlparser.statement.maintenance.ClusterStatement; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement; import net.sf.jsqlparser.statement.comment.Comment; import net.sf.jsqlparser.statement.create.database.CreateDatabase; import net.sf.jsqlparser.statement.create.function.CreateFunction; @@ -39,14 +51,26 @@ import net.sf.jsqlparser.statement.create.sequence.CreateSequence; import net.sf.jsqlparser.statement.create.synonym.CreateSynonym; import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger; import net.sf.jsqlparser.statement.create.view.AlterView; import net.sf.jsqlparser.statement.create.view.CreateView; +import net.sf.jsqlparser.statement.cursor.CloseCursorStatement; +import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement; +import net.sf.jsqlparser.statement.cursor.FetchCursorStatement; import net.sf.jsqlparser.statement.delete.Delete; import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.handler.HandlerStatement; +import net.sf.jsqlparser.statement.lock.BackupLockStatement; +import net.sf.jsqlparser.statement.lock.UnlockStatement; import net.sf.jsqlparser.statement.merge.Merge; import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement; +import net.sf.jsqlparser.statement.reindex.Reindex; +import net.sf.jsqlparser.statement.resourcegroup.AlterResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.CreateResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.SetResourceGroup; +import net.sf.jsqlparser.statement.role.ReassignOwned; import net.sf.jsqlparser.statement.select.Fetch; import net.sf.jsqlparser.statement.select.First; import net.sf.jsqlparser.statement.select.KSQLWindow; @@ -59,6 +83,7 @@ import net.sf.jsqlparser.statement.select.TableFunction; import net.sf.jsqlparser.statement.select.Top; import net.sf.jsqlparser.statement.select.UnPivot; +import net.sf.jsqlparser.statement.securitylabel.SecurityLabel; import net.sf.jsqlparser.statement.show.*; import net.sf.jsqlparser.statement.truncate.Truncate; import net.sf.jsqlparser.statement.update.Update; @@ -450,6 +475,31 @@ public enum Feature { */ alterIndex, + /** + * MySQL and PostgreSQL "CREATE TABLESPACE" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.tablespace.CreateTablespace + */ + createTablespace, + /** + * MySQL and PostgreSQL "ALTER TABLESPACE" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterTablespace + */ + alterTablespace, + /** + * MySQL "CREATE SPATIAL REFERENCE SYSTEM" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.spatial.CreateSpatialReferenceSystem + */ + createSpatialReferenceSystem, + /** + * MySQL "ALTER INSTANCE" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterInstance + */ + alterInstance, + /** * SQL "ANALYZE" statement is allowed @@ -458,6 +508,56 @@ public enum Feature { */ analyze, + /** + * MySQL/MariaDB "CHECK TABLE", "CHECKSUM TABLE", "OPTIMIZE TABLE" and "REPAIR TABLE" statements + * are allowed + * + * @see TableMaintenanceStatement + */ + tableMaintenance, + + /** + * MySQL "FLUSH" statement is allowed + * + * @see FlushStatement + */ + flush, + + /** + * MySQL "KILL" statement is allowed + * + * @see KillStatement + */ + kill, + + /** + * MySQL "HANDLER ... OPEN", "HANDLER ... READ" and "HANDLER ... CLOSE" statements are allowed + * + * @see HandlerStatement + */ + handler, + + /** + * PostgreSQL "VACUUM" statement is allowed + * + * @see VacuumStatement + */ + vacuum, + + /** + * PostgreSQL "CLUSTER" statement is allowed + * + * @see ClusterStatement + */ + cluster, + + /** + * PostgreSQL "CHECKPOINT" statement is allowed + * + * @see CheckpointStatement + */ + checkpoint, + /** * SQL "TRUNCATE" statement is allowed * @@ -482,7 +582,19 @@ public enum Feature { */ executeStatementImmediate, + /** + * MySQL "EXECUTE name USING @variable, ..." of a prepared statement is allowed + * + * @see Execute#getUsingVariables() + */ executeUsing, + /** + * "PREPARE" and "DEALLOCATE" of a prepared statement are allowed + * + * @see net.sf.jsqlparser.statement.PrepareStatement + * @see net.sf.jsqlparser.statement.DeallocateStatement + */ + prepare, deallocate, /** * SQL "REPLACE" statement is allowed */ @@ -494,6 +606,24 @@ public enum Feature { * @see Drop */ drop, dropTable, dropIndex, dropView, dropSchema, dropSequence, dropTableIfExists, dropIndexIfExists, dropViewIfExists, dropSchemaIfExists, dropSequenceIfExists, + /** + * Oracle "PURGE" statement is allowed + * + * @see net.sf.jsqlparser.statement.PurgeStatement + */ + purge, + /** + * MySQL/MariaDB "PURGE BINARY LOGS" and MariaDB "PURGE MASTER LOGS" statements are allowed + * + * @see net.sf.jsqlparser.statement.PurgeStatement + */ + purgeBinaryLogs, + /** + * PostgreSQL "REASSIGN OWNED BY ... TO ..." statement is allowed + * + * @see ReassignOwned + */ + reassignOwned, /** * SQL "CREATE DATABASE" statement is allowed @@ -501,6 +631,19 @@ public enum Feature { * @see CreateDatabase */ createDatabase, + /** + * SQL "ALTER DATABASE" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.database.AlterDatabase + */ + alterDatabase, + /** + * "ALTER SESSION" and "ALTER SYSTEM" statements are allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterSession + * @see net.sf.jsqlparser.statement.alter.AlterSystemStatement + */ + alterSession, alterSystem, /** * SQL "CREATE SCHEMA" statement is allowed * @@ -578,13 +721,28 @@ public enum Feature { * * @see CreateSequence */ - createSequence, + createSequence, createAccessMethod, createAccessMethodTable, /** Publication and subscription definitions. */ + createForeignDataWrapper, alterForeignDataWrapper, createServer, alterServer, createUserMapping, alterUserMapping, + /** + * PostgreSQL "IMPORT FOREIGN SCHEMA" statement is allowed + * + * @see net.sf.jsqlparser.statement.foreign.ImportForeignSchema + */ + importForeignSchema, + + createRule, notifyStatement, createTextSearchConfiguration, alterTextSearchConfiguration, createCollation, alterCollation, + createPublication, alterPublication, createSubscription, alterSubscription, /** * Structured type, domain and extension statements. */ createType, alterType, createDomain, alterDomain, createExtension, alterExtension, + /** + * PostgreSQL "CREATE POLICY", "ALTER POLICY", "CREATE STATISTICS" and "ALTER STATISTICS" + * statements are allowed + */ + createPolicy, alterPolicy, createStatistics, alterStatistics, /** * SQL "CREATE SYNONYM" statement is allowed * @@ -595,12 +753,169 @@ public enum Feature { * SQL "CREATE TRIGGER" statement is allowed */ createTrigger, + /** + * MySQL/MariaDB "CREATE EVENT" and "ALTER EVENT" statements are allowed + * + * @see net.sf.jsqlparser.statement.create.event.CreateEvent + * @see net.sf.jsqlparser.statement.create.event.AlterEvent + */ + createEvent, alterEvent, + /** + * PostgreSQL "CREATE EVENT TRIGGER" and "ALTER EVENT TRIGGER" statements are allowed + * + * @see CreateEventTrigger + * @see AlterEventTrigger + */ + createEventTrigger, alterEventTrigger, + /** + * PostgreSQL "REINDEX" statement is allowed; "REINDEX … CONCURRENTLY" additionally requires + * {@link #reindexConcurrently} + * + * @see Reindex + */ + reindex, reindexConcurrently, + /** + * PostgreSQL "SECURITY LABEL" statement is allowed + * + * @see SecurityLabel + */ + securityLabel, /** * SQL "COMMIT" statement is allowed * * @see Commit */ commit, + /** SQL "ROLLBACK" statement is allowed */ + rollback, + /** START TRANSACTION and dialect-specific BEGIN transaction statements. */ + startTransaction, + /** SAVEPOINT statements. */ + savepoint, + /** RELEASE [SAVEPOINT] statements. */ + releaseSavepoint, + /** Explicit AND [NO] CHAIN transaction completion. */ + transactionChain, + /** Isolation level specified directly on BEGIN or START TRANSACTION. */ + transactionIsolationLevel, + /** PostgreSQL [NOT] DEFERRABLE transaction characteristic. */ + transactionDeferrable, + /** MySQL WITH CONSISTENT SNAPSHOT transaction characteristic. */ + transactionConsistentSnapshot, + /** MySQL [NO] RELEASE after COMMIT or ROLLBACK. */ + transactionRelease, + /** PostgreSQL END and ABORT, the alternative spellings of COMMIT and ROLLBACK. */ + transactionEndAbort, + /** + * SET TRANSACTION characteristics + * + * @see SetTransactionStatement + */ + setTransaction, + /** MySQL SET GLOBAL TRANSACTION. */ + setTransactionGlobal, + /** MySQL SET PERSIST TRANSACTION and SET PERSIST_ONLY TRANSACTION. */ + setTransactionPersist, + /** PostgreSQL SET SESSION CHARACTERISTICS AS TRANSACTION. */ + setTransactionSessionCharacteristics, + /** PostgreSQL SET TRANSACTION SNAPSHOT. */ + setTransactionSnapshot, + /** + * SET CONSTRAINTS {ALL | names} {DEFERRED | IMMEDIATE} + * + * @see SetConstraintsStatement + */ + setConstraints, + /** + * PostgreSQL two-phase commit: PREPARE TRANSACTION, COMMIT PREPARED and ROLLBACK PREPARED + * + * @see PrepareTransactionStatement + */ + twoPhaseCommit, + /** + * MySQL and MariaDB XA statements: XA START, END, PREPARE, COMMIT, ROLLBACK and RECOVER + * + * @see XaStatement + */ + xa, + /** + * MySQL and MariaDB INSTALL PLUGIN and UNINSTALL PLUGIN + * + * @see PluginStatement + */ + installPlugin, + /** + * MySQL INSTALL COMPONENT and UNINSTALL COMPONENT + * + * @see PluginStatement + */ + installComponent, + /** + * SQL "LOCK TABLE" statement is allowed + * + * @see net.sf.jsqlparser.statement.lock.LockStatement + */ + lock, + /** + * MySQL/MariaDB "UNLOCK TABLES" statement is allowed + * + * @see UnlockStatement + */ + unlockTables, + /** + * MySQL "LOCK INSTANCE FOR BACKUP" and "UNLOCK INSTANCE" statements are allowed + * + * @see BackupLockStatement + */ + backupLock, + /** + * MySQL "CREATE RESOURCE GROUP" statement is allowed + * + * @see CreateResourceGroup + */ + createResourceGroup, + /** + * MySQL "ALTER RESOURCE GROUP" statement is allowed + * + * @see AlterResourceGroup + */ + alterResourceGroup, + /** + * MySQL "SET RESOURCE GROUP" statement is allowed + * + * @see SetResourceGroup + */ + setResourceGroup, + /** + * MySQL "CHANGE REPLICATION SOURCE TO" statement is allowed + * + * @see net.sf.jsqlparser.statement.replication.ChangeReplicationSourceStatement + */ + changeReplicationSource, + /** + * MySQL "CHANGE REPLICATION FILTER" statement is allowed + * + * @see net.sf.jsqlparser.statement.replication.ChangeReplicationFilterStatement + */ + changeReplicationFilter, + /** + * MySQL "START REPLICA" statement is allowed + * + * @see net.sf.jsqlparser.statement.replication.StartReplicaStatement + */ + startReplica, + /** + * MySQL "STOP REPLICA" statement is allowed + * + * @see net.sf.jsqlparser.statement.replication.StopReplicaStatement + */ + stopReplica, + /** + * MySQL "RESET BINARY LOGS AND GTIDS" and "RESET REPLICA" statements are allowed + * + * @see net.sf.jsqlparser.statement.replication.ResetReplicationStatement + */ + resetReplication, /** * SQL "COMMENT ON" statement is allowed * @@ -623,6 +938,33 @@ public enum Feature { /** Additional structured catalog targets of COMMENT ON. */ commentOnIndex, commentOnSchema, commentOnSequence, commentOnDomain, commentOnType, commentOnMaterializedView, commentOnFunction, commentOnConstraint, + /** COMMENT ON TRIGGER, POLICY or RULE within a table. */ + commentOnTrigger, commentOnPolicy, commentOnRule, + + /** COMMENT ON PROCEDURE, ROUTINE, AGGREGATE or CAST. */ + commentOnProcedure, commentOnRoutine, commentOnAggregate, commentOnCast, + + /** COMMENT ON COLLATION, FOREIGN TABLE or STATISTICS. */ + commentOnCollation, commentOnForeignTable, commentOnStatistics, + + /** COMMENT ON DATABASE, ROLE or TABLESPACE. */ + commentOnDatabase, commentOnRole, commentOnTablespace, + + /** COMMENT ON ACCESS METHOD, EXTENSION, FOREIGN DATA WRAPPER, LANGUAGE or SERVER. */ + commentOnAccessMethod, commentOnExtension, commentOnForeignDataWrapper, commentOnLanguage, commentOnServer, + + /** COMMENT ON EVENT TRIGGER, PUBLICATION or SUBSCRIPTION. */ + commentOnEventTrigger, commentOnPublication, commentOnSubscription, + + /** COMMENT ON OPERATOR, OPERATOR CLASS or OPERATOR FAMILY. */ + commentOnOperator, commentOnOperatorClass, commentOnOperatorFamily, + + /** COMMENT ON CONVERSION, LARGE OBJECT or TRANSFORM. */ + commentOnConversion, commentOnLargeObject, commentOnTransform, + + /** COMMENT ON TEXT SEARCH CONFIGURATION, DICTIONARY, PARSER or TEMPLATE. */ + commentOnTextSearchConfiguration, commentOnTextSearchDictionary, commentOnTextSearchParser, commentOnTextSearchTemplate, + /** * SQL "DESCRIBE" statement is allowed * @@ -659,6 +1001,25 @@ public enum Feature { * @see ShowIndexStatement */ showIndex, + /** + * MySQL/MariaDB "SHOW TABLE STATUS" statement is allowed + * + * @see ShowTableStatusStatement + */ + showTableStatus, + /** + * MySQL/MariaDB "SHOW CREATE" statement is allowed + * + * @see ShowCreateStatement + */ + showCreate, + /** + * The MySQL/MariaDB "SHOW" statements of server settings, state and object lists, such as "SHOW + * VARIABLES", "SHOW GRANTS" or "SHOW BINLOG EVENTS" + * + * @see MySqlShowStatement + */ + mySqlShow, /** * @see UseStatement */ @@ -669,6 +1030,18 @@ public enum Feature { * @see Grant */ grant, revoke, createRole, alterRole, alterDefaultPrivileges, + /** + * MySQL/MariaDB account management: "CREATE USER", "ALTER USER", "RENAME USER", "SET ROLE", + * "SET DEFAULT ROLE" and "SET PASSWORD" + * + * @see net.sf.jsqlparser.statement.create.user.CreateUser + * @see net.sf.jsqlparser.statement.alter.AlterUser + * @see net.sf.jsqlparser.statement.alter.RenameUser + * @see net.sf.jsqlparser.statement.SetRoleStatement + * @see net.sf.jsqlparser.statement.SetDefaultRoleStatement + * @see net.sf.jsqlparser.statement.SetPasswordStatement + */ + createUser, alterUser, renameUser, setRole, setDefaultRole, setPassword, /** * @see Function */ @@ -687,6 +1060,150 @@ public enum Feature { functionalStatement, alterFunction, alterProcedure, createOrAlterRoutine, + /** + * PostgreSQL "ALTER ROUTINE" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterRoutine + */ + alterRoutine, + /** + * PostgreSQL "ALTER TRIGGER" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterTrigger + */ + alterTrigger, + /** + * PostgreSQL "ALTER RULE" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterRule + */ + alterRule, + /** + * PostgreSQL "CREATE CAST" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.cast.CreateCast + */ + createCast, + /** + * PostgreSQL "CREATE TRANSFORM" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.transform.CreateTransform + */ + createTransform, + /** + * PostgreSQL "CREATE CONVERSION" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.conversion.CreateConversion + */ + createConversion, + /** + * PostgreSQL "ALTER CONVERSION" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterConversion + */ + alterConversion, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.language.CreateLanguage + */ + createLanguage, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterLanguage + */ + alterLanguage, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterLargeObject + */ + alterLargeObject, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary + */ + createTextSearchDictionary, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary + */ + alterTextSearchDictionary, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser + */ + createTextSearchParser, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterTextSearchParser + */ + alterTextSearchParser, + /** + * PostgreSQL CREATE metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate + */ + createTextSearchTemplate, + /** + * PostgreSQL ALTER metadata statement is allowed. + * + * @see net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate + */ + alterTextSearchTemplate, + /** + * PostgreSQL "CREATE OPERATOR" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.operator.CreateOperator + */ + createOperator, + /** + * PostgreSQL "CREATE OPERATOR CLASS" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.operator.CreateOperatorClass + */ + createOperatorClass, + /** + * PostgreSQL "CREATE OPERATOR FAMILY" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.operator.CreateOperatorFamily + */ + createOperatorFamily, + /** + * PostgreSQL "CREATE AGGREGATE" statement is allowed + * + * @see net.sf.jsqlparser.statement.create.aggregate.CreateAggregate + */ + createAggregate, + /** + * PostgreSQL "ALTER OPERATOR" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterOperator + */ + alterOperator, + /** + * PostgreSQL "ALTER OPERATOR CLASS" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterOperatorClass + */ + alterOperatorClass, + /** + * PostgreSQL "ALTER OPERATOR FAMILY" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterOperatorFamily + */ + alterOperatorFamily, + /** + * PostgreSQL "ALTER AGGREGATE" statement is allowed + * + * @see net.sf.jsqlparser.statement.alter.AlterAggregate + */ + alterAggregate, /** * SQL block starting with "BEGIN" and ends with "END" statement is allowed * @@ -697,6 +1214,24 @@ public enum Feature { * @see DeclareStatement */ declare, + /** + * PostgreSQL "DECLARE name CURSOR FOR query" statement is allowed + * + * @see DeclareCursorStatement + */ + declareCursor, + /** + * PostgreSQL "FETCH" and "MOVE" statements of a cursor are allowed + * + * @see FetchCursorStatement + */ + fetchCursor, + /** + * PostgreSQL "CLOSE" statement of a cursor is allowed + * + * @see CloseCursorStatement + */ + closeCursor, /** SQL Server local table variables in queries and DML targets. */ tableVariable, @@ -704,12 +1239,32 @@ public enum Feature { * @see SetStatement */ set, + /** PostgreSQL SET configuration_parameter TO value. */ + setAssignmentTo, /** SQL Server SET option [, option] ON | OFF. */ sqlServerSetOptions, /** * @see ResetStatement */ reset, + /** + * PostgreSQL "DISCARD" statement is allowed + * + * @see net.sf.jsqlparser.statement.DiscardStatement + */ + discard, + /** + * PostgreSQL "LISTEN" and "UNLISTEN" statements are allowed + * + * @see net.sf.jsqlparser.statement.notify.ListenStatement + */ + listen, + /** + * MySQL "RESET PERSIST" statement is allowed + * + * @see ResetStatement#isPersist() + */ + resetPersist, /** * @see Pivot */ @@ -794,7 +1349,7 @@ public enum Feature { // MYSQL - mySqlHintStraightJoin, mysqlSqlCacheFlag, mysqlCalcFoundRows, + mySqlHintStraightJoin, mysqlSqlCacheFlag, mysqlCalcFoundRows, mysqlSelectModifiers, // SQLSERVER @@ -816,6 +1371,14 @@ public enum Feature { /** Enables legacy GROUP BY ordering with the MYSQL dialect; disabled by default. */ allowLegacyMySqlGroupBy(false), + /** + * Target MySQL version for executable comments, encoded as major * 10000 + minor * 100 + patch. + * A negative value leaves the version unspecified: conditional comments then fail instead of + * silently discarding SQL. Only used with the MYSQL dialect; unversioned comments need no + * value. + */ + mySqlServerVersion(-1), + // PERFORMANCE /** @@ -863,6 +1426,19 @@ public enum Feature { */ allowHashLineComments(false), + /** + * treats three consecutive newlines as a statement separator (enabled by default). When + * disabled, blank lines are plain whitespace, so a statement containing them is parsed whole + * instead of ending, or failing to parse, at the first run of blank lines + */ + allowBlankLinesAsStatementSeparator(true), + + /** + * allows digit separators in numeric literals, e.g. {@code 1_000_000} (DuckDB, PostgreSQL 16); + * disabled by default, where MySQL reads {@code 2024_01} as an identifier + */ + allowDigitSeparators(false), + /** * allows sub selects without parentheses, e.g. `select * from dual where 1 = select 1` */ @@ -881,10 +1457,40 @@ public enum Feature { imprt, /** - * "EXPORT" + * "EXPORT" and BigQuery "EXPORT DATA" */ export, + /** + * PostgreSQL and DuckDB "COPY", BigQuery and MySQL "LOAD DATA" and MySQL "LOAD XML" statements + * are allowed + * + * @see net.sf.jsqlparser.statement.CopyStatement + * @see net.sf.jsqlparser.statement.load.LoadDataStatement + * @see net.sf.jsqlparser.statement.load.MySqlLoadDataStatement + */ + copy, loadData, + + /** + * DuckDB "ATTACH", "DETACH", "CONNECT", "DISCONNECT", "PRAGMA", "INSTALL", "LOAD", "CREATE + * MACRO" and "CREATE EXTENSION REPOSITORY" statements are allowed + */ + attach, detach, connect, disconnect, pragma, installExtension, loadExtension, createMacro, createExtensionRepository, + + /** + * BigQuery "ASSERT" statement is allowed + * + * @see net.sf.jsqlparser.statement.AssertStatement + */ + assertStatement, + + /** + * "SESSION" statement is allowed + * + * @see net.sf.jsqlparser.statement.SessionStatement + */ + session, + /** * MySQL allows a ',' as a separator between key and value entries. We allow that by default, * but it can be disabled here diff --git a/src/main/java/net/sf/jsqlparser/schema/Column.java b/src/main/java/net/sf/jsqlparser/schema/Column.java index 33240ac52a..3bb06de241 100644 --- a/src/main/java/net/sf/jsqlparser/schema/Column.java +++ b/src/main/java/net/sf/jsqlparser/schema/Column.java @@ -49,10 +49,14 @@ public Column(List nameParts) { } public Column(List nameParts, List delimiters) { - this( - nameParts.size() > 1 ? new Table(nameParts.subList(0, nameParts.size() - 1), - delimiters.subList(0, delimiters.size() - 1)) : null, - nameParts.get(nameParts.size() - 1)); + if (nameParts.size() > 1) { + setTable(new Table(nameParts.subList(0, nameParts.size() - 1), + delimiters.subList(0, delimiters.size() - 1))); + // The final component is already separated from the table name. + setName(nameParts.get(nameParts.size() - 1), false); + } else { + setColumnName(nameParts.get(0)); + } setTableDelimiter(delimiters.isEmpty() ? "." : delimiters.get(delimiters.size() - 1)); } @@ -149,36 +153,25 @@ public void setColumnName(String name) { } public void setName(String name, boolean splitNamesOnDelimiter) { - if (MultiPartName.isQuoted(name) && name.contains(".") && splitNamesOnDelimiter) { - String[] parts = MultiPartName.unquote(name).split("\\."); - switch (parts.length) { - case 3: - this.table = new Table("\"" + parts[0] + "\".\"" + parts[1] + "\""); - this.columnName = "\"" + parts[2] + "\""; - break; - case 2: - this.table = new Table("\"" + parts[0] + "\""); - this.columnName = "\"" + parts[1] + "\""; - break; - case 1: - this.columnName = "\"" + parts[0] + "\""; - break; - default: - throw new RuntimeException("Invalid column name: " + name); + if (name.contains(".") && splitNamesOnDelimiter) { + List parts = splitName(name); + if (parts.size() == 1 && MultiPartName.isQuoted(name)) { + parts.clear(); + for (String identifier : MultiPartName.unquote(name).split("\\.")) { + parts.add("\"" + identifier + "\""); + } } - } else if (name.contains(".") && splitNamesOnDelimiter) { - String[] parts = MultiPartName.unquote(name).split("\\."); - switch (parts.length) { + switch (parts.size()) { case 3: - this.table = new Table(parts[0] + "." + parts[1]); - this.columnName = parts[2]; + this.table = new Table(parts.subList(0, 2)); + this.columnName = parts.get(2); break; case 2: - this.table = new Table(parts[0]); - this.columnName = parts[1]; + this.table = new Table(parts.get(0), false); + this.columnName = parts.get(1); break; case 1: - this.columnName = parts[0]; + this.columnName = parts.get(0); break; default: throw new RuntimeException("Invalid column name: " + name); @@ -188,6 +181,34 @@ public void setName(String name, boolean splitNamesOnDelimiter) { } } + private static List splitName(String name) { + List parts = new ArrayList<>(); + int start = 0; + char quote = 0; + for (int i = 0; i < name.length(); i++) { + char ch = name.charAt(i); + if (quote != 0) { + if (ch == quote) { + if (i + 1 < name.length() && name.charAt(i + 1) == quote) { + i++; + } else { + quote = 0; + } + } + } else if (ch == '"' || ch == '`' || ch == '[') { + quote = ch == '[' ? ']' : ch; + } else if (ch == '.') { + parts.add(name.substring(start, i)); + start = i + 1; + } + } + parts.add(name.substring(start)); + while (!parts.isEmpty() && parts.get(parts.size() - 1).isEmpty()) { + parts.remove(parts.size() - 1); + } + return parts; + } + public String getTableDelimiter() { return tableDelimiter; } diff --git a/src/main/java/net/sf/jsqlparser/schema/MultiPartName.java b/src/main/java/net/sf/jsqlparser/schema/MultiPartName.java index ce954780d7..b49e58384e 100644 --- a/src/main/java/net/sf/jsqlparser/schema/MultiPartName.java +++ b/src/main/java/net/sf/jsqlparser/schema/MultiPartName.java @@ -23,13 +23,34 @@ public interface MultiPartName { * @return the pure identifier without quotes */ static String unquote(String quotedIdentifier) { - return quotedIdentifier != null - ? LEADING_TRAILING_QUOTES_PATTERN.matcher(quotedIdentifier).replaceAll("") - : null; + if (quotedIdentifier == null) { + return null; + } + // same result as LEADING_TRAILING_QUOTES_PATTERN.matcher(..).replaceAll(""), but linear: + // the regex retries its trailing alternative at every offset of a run of quotes + int start = 0; + int end = quotedIdentifier.length(); + while (start < end && isLeadingQuote(quotedIdentifier.charAt(start))) { + start++; + } + while (end > start && isTrailingQuote(quotedIdentifier.charAt(end - 1))) { + end--; + } + return quotedIdentifier.substring(start, end); } static boolean isQuoted(String identifier) { - return identifier != null && LEADING_TRAILING_QUOTES_PATTERN.matcher(identifier).find(); + return identifier != null && !identifier.isEmpty() + && (isLeadingQuote(identifier.charAt(0)) + || isTrailingQuote(identifier.charAt(identifier.length() - 1))); + } + + private static boolean isLeadingQuote(char c) { + return c == '"' || c == '[' || c == '`'; + } + + private static boolean isTrailingQuote(char c) { + return c == '"' || c == ']' || c == '`'; } String getFullyQualifiedName(); diff --git a/src/main/java/net/sf/jsqlparser/schema/Sequence.java b/src/main/java/net/sf/jsqlparser/schema/Sequence.java index efff62a970..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; + 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)); @@ -201,6 +201,7 @@ public static class Parameter implements java.io.Serializable { private final ParameterType option; private Long value; + private Sequence sequenceName; public Parameter(ParameterType option) { this.option = option; @@ -214,6 +215,20 @@ public ParameterType getOption() { return option; } + /** The sequence named by an identity declaration's SEQUENCE NAME option. */ + public Sequence getSequenceName() { + return sequenceName; + } + + public void setSequenceName(Sequence sequenceName) { + this.sequenceName = sequenceName; + } + + public Parameter withSequenceName(Sequence sequenceName) { + setSequenceName(sequenceName); + return this; + } + @Override public String toString() { return formatParameter(); @@ -225,6 +240,8 @@ public void setValue(Long value) { public String formatParameter() { switch (option) { + case SEQUENCE_NAME: + return "SEQUENCE NAME " + sequenceName.getFullyQualifiedName(); case INCREMENT_BY: return prefix("INCREMENT BY"); case INCREMENT: diff --git a/src/main/java/net/sf/jsqlparser/schema/Table.java b/src/main/java/net/sf/jsqlparser/schema/Table.java index 0e23b28a9c..bbf9f4536a 100644 --- a/src/main/java/net/sf/jsqlparser/schema/Table.java +++ b/src/main/java/net/sf/jsqlparser/schema/Table.java @@ -60,7 +60,7 @@ public class Table extends ASTNodeAccessImpl private UnPivot unpivot; - private MySQLIndexHint mysqlHints; + private List mysqlIndexHints; private SQLServerHints sqlServerHints; @@ -411,8 +411,13 @@ public void setUnPivot(UnPivot unpivot) { this.unpivot = unpivot; } + /** + * Returns the first MySQL index hint, or {@code null}. Use {@link #getIndexHints()} for a table + * with several hints. + */ public MySQLIndexHint getIndexHint() { - return mysqlHints; + return mysqlIndexHints == null || mysqlIndexHints.isEmpty() ? null + : mysqlIndexHints.get(0); } public Table withHint(MySQLIndexHint hint) { @@ -420,8 +425,46 @@ public Table withHint(MySQLIndexHint hint) { return this; } + /** + * Replaces the MySQL index hints with the given hint, or removes them for {@code null}. + */ public void setHint(MySQLIndexHint hint) { - this.mysqlHints = hint; + this.mysqlIndexHints = hint == null ? null : new ArrayList<>(Collections.singleton(hint)); + } + + /** + * Returns the MySQL index hints in their order, for example + * {@code USE INDEX (i1) IGNORE INDEX FOR ORDER BY (i2)}, or {@code null} when there are none. + */ + public List getIndexHints() { + return mysqlIndexHints; + } + + public void setIndexHints(List indexHints) { + this.mysqlIndexHints = indexHints; + } + + public Table withIndexHints(List indexHints) { + setIndexHints(indexHints); + return this; + } + + public Table addIndexHint(MySQLIndexHint hint) { + if (mysqlIndexHints == null) { + mysqlIndexHints = new ArrayList<>(); + } + mysqlIndexHints.add(hint); + return this; + } + + /** Appends the MySQL index hints, each with a leading space, in their order. */ + public StringBuilder appendIndexHintsTo(StringBuilder builder) { + if (mysqlIndexHints != null) { + for (MySQLIndexHint hint : mysqlIndexHints) { + hint.appendTo(builder); + } + } + return builder; } public SQLServerHints getSqlServerHints() { @@ -468,9 +511,7 @@ public StringBuilder appendTo(StringBuilder builder) { builder.append(" ").append(unpivot); } - if (mysqlHints != null) { - builder.append(mysqlHints); - } + appendIndexHintsTo(builder); if (sqlServerHints != null) { builder.append(sqlServerHints); diff --git a/src/main/java/net/sf/jsqlparser/schema/TableReference.java b/src/main/java/net/sf/jsqlparser/schema/TableReference.java new file mode 100644 index 0000000000..2d64aa10b1 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/schema/TableReference.java @@ -0,0 +1,115 @@ +/*- + * #%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.schema; + +import java.io.Serializable; + +/** + * A relation target with optional PostgreSQL inheritance scope, shared by LOCK, TRUNCATE and the + * targets of UPDATE, DELETE and MERGE. + */ +public class TableReference implements Serializable { + private Table table; + private boolean only; + private boolean includeDescendants; + private boolean parenthesized; + + public TableReference(Table table) { + this.table = table; + } + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public boolean isOnly() { + return only; + } + + public void setOnly(boolean only) { + this.only = only; + if (only) { + includeDescendants = false; + } else { + parenthesized = false; + } + } + + public boolean isIncludeDescendants() { + return includeDescendants; + } + + public void setIncludeDescendants(boolean includeDescendants) { + this.includeDescendants = includeDescendants; + if (includeDescendants) { + only = false; + parenthesized = false; + } + } + + public boolean isParenthesized() { + return parenthesized; + } + + public void setParenthesized(boolean parenthesized) { + this.parenthesized = parenthesized; + if (parenthesized) { + only = true; + includeDescendants = false; + } + } + + public StringBuilder appendTo(StringBuilder builder) { + if (only) { + builder.append("ONLY "); + } + if (parenthesized) { + builder.append('('); + } + builder.append(table.getFullyQualifiedName()); + if (parenthesized) { + builder.append(')'); + } + if (includeDescendants) { + builder.append(" *"); + } + return builder; + } + + /** + * Appends the target of UPDATE, DELETE or MERGE (PostgreSQL's relation_expr_opt_alias): the + * inheritance scope surrounds the table name and the alias of the table follows it. A target + * without a scope is the table as it renders itself, with its alias and hints. + */ + public StringBuilder appendWithAliasTo(StringBuilder builder) { + if (!only && !includeDescendants || table == null) { + return builder.append(table); + } + appendTo(builder); + if (table.getAlias() != null) { + builder.append(table.getAlias()); + } + return builder; + } + + /** Whether ONLY or * describes the inheritance scope of the table. */ + public boolean hasInheritanceScope() { + return only || includeDescendants; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/AssertStatement.java b/src/main/java/net/sf/jsqlparser/statement/AssertStatement.java index 1e5a742982..58a294bb5f 100644 --- a/src/main/java/net/sf/jsqlparser/statement/AssertStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/AssertStatement.java @@ -11,6 +11,7 @@ import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import java.util.function.Consumer; @@ -22,7 +23,7 @@ * "https://cloud.google.com/bigquery/docs/reference/standard-sql/debugging-statements">Debugging * statements */ -public class AssertStatement implements Statement { +public class AssertStatement extends ASTNodeAccessImpl implements Statement { private Expression expression; private StringValue description; diff --git a/src/main/java/net/sf/jsqlparser/statement/AttachStatement.java b/src/main/java/net/sf/jsqlparser/statement/AttachStatement.java index 7ad71dd546..84726280d1 100644 --- a/src/main/java/net/sf/jsqlparser/statement/AttachStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/AttachStatement.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.select.PlainSelect; import java.util.List; @@ -19,7 +20,7 @@ * * @see ATTACH */ -public class AttachStatement implements Statement { +public class AttachStatement extends ASTNodeAccessImpl implements Statement { private String databasePath; private String alias; private boolean usingDatabaseKeyword; diff --git a/src/main/java/net/sf/jsqlparser/statement/Block.java b/src/main/java/net/sf/jsqlparser/statement/Block.java index f609e58262..a4e822f01b 100644 --- a/src/main/java/net/sf/jsqlparser/statement/Block.java +++ b/src/main/java/net/sf/jsqlparser/statement/Block.java @@ -10,8 +10,9 @@ package net.sf.jsqlparser.statement; import java.util.function.Consumer; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; -public class Block implements Statement { +public class Block extends ASTNodeAccessImpl implements Statement { private boolean hasSemicolonAfterEnd = false; private Statements statements; diff --git a/src/main/java/net/sf/jsqlparser/statement/CascadeBehavior.java b/src/main/java/net/sf/jsqlparser/statement/CascadeBehavior.java new file mode 100644 index 0000000000..a67de27309 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CascadeBehavior.java @@ -0,0 +1,18 @@ +/*- + * #%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; + +/** + * An explicit CASCADE or RESTRICT clause. A null field leaves the clause omitted and preserves the + * database's default behavior for that statement. + */ +public enum CascadeBehavior { + CASCADE, RESTRICT +} diff --git a/src/main/java/net/sf/jsqlparser/statement/CastSignature.java b/src/main/java/net/sf/jsqlparser/statement/CastSignature.java new file mode 100644 index 0000000000..2aeb0bb286 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CastSignature.java @@ -0,0 +1,69 @@ +/*- + * #%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; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.create.table.ColDataType; + +/** + * A PostgreSQL cast, named by the types it converts between: {@code (source_type AS target_type)}, + * as in {@code DROP CAST (text AS integer)}. + */ +public class CastSignature extends ASTNodeAccessImpl { + + private ColDataType sourceType; + private ColDataType targetType; + + public CastSignature() { + // the types are set by the parser or the setters + } + + public CastSignature(ColDataType sourceType, ColDataType targetType) { + this.sourceType = sourceType; + this.targetType = targetType; + } + + public ColDataType getSourceType() { + return sourceType; + } + + public void setSourceType(ColDataType sourceType) { + this.sourceType = sourceType; + } + + public CastSignature withSourceType(ColDataType sourceType) { + setSourceType(sourceType); + return this; + } + + public ColDataType getTargetType() { + return targetType; + } + + public void setTargetType(ColDataType targetType) { + this.targetType = targetType; + } + + public CastSignature withTargetType(ColDataType targetType) { + setTargetType(targetType); + return this; + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + return builder.append('(').append(sourceType).append(" AS ").append(targetType) + .append(')'); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/Commit.java b/src/main/java/net/sf/jsqlparser/statement/Commit.java index 7ce4650536..a0738414d9 100644 --- a/src/main/java/net/sf/jsqlparser/statement/Commit.java +++ b/src/main/java/net/sf/jsqlparser/statement/Commit.java @@ -9,14 +9,72 @@ */ package net.sf.jsqlparser.statement; -public class Commit implements Statement { +import java.util.Objects; + +/** + * COMMIT, or its PostgreSQL spelling END. PostgreSQL {@code COMMIT PREPARED 'id'} commits a + * prepared transaction instead of the current one. + */ +public class Commit extends TransactionCompletionStatement { + /** The keyword that starts the statement; both commit the current transaction. */ + public enum Command { + COMMIT, END + } + + private Command command = Command.COMMIT; + + public Command getCommand() { + return command; + } + + public void setCommand(Command command) { + this.command = Objects.requireNonNull(command, "command"); + } + + public Commit withCommand(Command command) { + setCommand(command); + return this; + } + + public Commit withKeyword(TransactionKeyword keyword) { + setKeyword(keyword); + return this; + } + + public Commit withChain(TransactionChain chain) { + setChain(chain); + return this; + } + + public Commit withRelease(TransactionRelease release) { + setRelease(release); + return this; + } + + /** + * Names the prepared transaction of PostgreSQL {@code COMMIT PREPARED 'id'}; null commits the + * current transaction. + */ + public Commit withPreparedTransaction(TransactionId id) { + setPreparedTransaction(PreparedTransactionKeyword.PREPARED, id); + return this; + } + + @Override + public boolean isPostgresSpelling() { + return command == Command.END; + } + @Override public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); } @Override - public String toString() { - return "COMMIT"; + public StringBuilder appendTo(StringBuilder builder) { + builder.append(command); + appendKeyword(builder); + appendPreparedTransaction(builder); + return appendCompletion(builder); } } diff --git a/src/main/java/net/sf/jsqlparser/statement/ComponentVariable.java b/src/main/java/net/sf/jsqlparser/statement/ComponentVariable.java new file mode 100644 index 0000000000..4c50128e45 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ComponentVariable.java @@ -0,0 +1,112 @@ +/*- + * #%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; + +import java.io.Serializable; +import java.util.Objects; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; + +/** + * One assignment of the {@code SET} clause of MySQL's {@code INSTALL COMPONENT}: + * {@code [GLOBAL | PERSIST] variable {= | :=} value}. The value is an expression, or the word + * {@code ON}, which is read as a column. + * + * @see PluginStatement + */ +public class ComponentVariable implements Serializable { + private SetScope scope = SetScope.NONE; + private String name; + private SetStatement.AssignmentOperator operator = SetStatement.AssignmentOperator.EQUALS; + private Expression value; + + public ComponentVariable(String name, Expression value) { + this.name = Objects.requireNonNull(name, "name"); + this.value = Objects.requireNonNull(value, "value"); + } + + /** {@link SetScope#GLOBAL}, {@link SetScope#PERSIST}, or {@link SetScope#NONE} if not given. */ + public SetScope getScope() { + return scope; + } + + /** + * Sets the scope keyword; null means none. + * + * @throws IllegalArgumentException for a scope other than GLOBAL, PERSIST or NONE + */ + public void setScope(SetScope scope) { + SetScope value = scope == null ? SetScope.NONE : scope; + if (value != SetScope.NONE && value != SetScope.GLOBAL && value != SetScope.PERSIST) { + throw new IllegalArgumentException("INSTALL COMPONENT SET does not accept " + value); + } + this.scope = value; + } + + public ComponentVariable withScope(SetScope scope) { + setScope(scope); + return this; + } + + /** The variable name as written: {@code variable} or {@code component.variable}. */ + public String getName() { + return name; + } + + public void setName(String name) { + this.name = Objects.requireNonNull(name, "name"); + } + + /** {@code =} or {@code :=}. */ + public SetStatement.AssignmentOperator getOperator() { + return operator; + } + + /** + * Sets the assignment operator. + * + * @throws IllegalArgumentException for an operator other than EQUALS or COLON_EQUALS + */ + public void setOperator(SetStatement.AssignmentOperator operator) { + if (operator != SetStatement.AssignmentOperator.EQUALS + && operator != SetStatement.AssignmentOperator.COLON_EQUALS) { + throw new IllegalArgumentException("INSTALL COMPONENT SET assigns with = or :="); + } + this.operator = operator; + } + + public ComponentVariable withOperator(SetStatement.AssignmentOperator operator) { + setOperator(operator); + return this; + } + + public Expression getValue() { + return value; + } + + public void setValue(Expression value) { + this.value = Objects.requireNonNull(value, "value"); + } + + public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { + if (scope != SetScope.NONE) { + builder.append(scope.getKeyword()).append(' '); + } + builder.append(name).append(' ').append(operator.getToken()).append(' '); + expressionPrinter.accept(value); + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ConfigurationParameterChange.java b/src/main/java/net/sf/jsqlparser/statement/ConfigurationParameterChange.java new file mode 100644 index 0000000000..913cace5e6 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/ConfigurationParameterChange.java @@ -0,0 +1,175 @@ +/*- + * #%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; + +import java.io.Serializable; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; + +/** + * A PostgreSQL {@code SET} or {@code RESET} of a configuration parameter, shared by statements that + * store parameter defaults: {@code ALTER ROLE}, {@code ALTER DATABASE} and the routine + * characteristics of {@code ALTER FUNCTION}, {@code ALTER PROCEDURE} and {@code ALTER ROUTINE}: + * + *

+ * SET parameter { TO | = } { value [, ...] | DEFAULT }
+ * SET parameter FROM CURRENT
+ * RESET { parameter | ALL }
+ * 
+ * + * Parameter names keep their SQL spelling, including qualifiers and identifier quotes. + * {@code RESET ALL} uses the parameter name {@code ALL}. + */ +public class ConfigurationParameterChange implements Serializable { + + public enum Action { + SET, RESET + } + + /** What a {@code SET} assigns. Only the selected kind is rendered. */ + public enum ValueKind { + /** The explicit values of {@link #getValues()}. */ + VALUES, + /** {@code TO DEFAULT} or {@code = DEFAULT}. */ + DEFAULT, + /** {@code FROM CURRENT}. */ + FROM_CURRENT + } + + private Action action = Action.SET; + private String parameter; + private ValueKind valueKind = ValueKind.VALUES; + private boolean useEquals; + private ExpressionList values; + + public ConfigurationParameterChange() {} + + public ConfigurationParameterChange(Action action, String parameter) { + this.action = action; + this.parameter = parameter; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = action; + } + + public String getParameter() { + return parameter; + } + + public void setParameter(String parameter) { + this.parameter = parameter; + } + + public ValueKind getValueKind() { + return valueKind; + } + + /** + * Selects what a {@code SET} assigns. The values are retained when another kind is selected. + * + * @param valueKind the assigned value kind + */ + public void setValueKind(ValueKind valueKind) { + this.valueKind = valueKind; + } + + /** + * Whether {@code =} rather than {@code TO} precedes the value. + * + * @return {@code true} for {@code =} + */ + public boolean isUseEquals() { + return useEquals; + } + + public void setUseEquals(boolean useEquals) { + this.useEquals = useEquals; + } + + /** + * The values assigned by {@link ValueKind#VALUES}, as a mutable list. + * + * @return the values, or {@code null} if none were set + */ + public ExpressionList getValues() { + return values; + } + + public void setValues(ExpressionList values) { + this.values = values; + } + + public ConfigurationParameterChange withAction(Action action) { + setAction(action); + return this; + } + + public ConfigurationParameterChange withParameter(String parameter) { + setParameter(parameter); + return this; + } + + public ConfigurationParameterChange withValueKind(ValueKind valueKind) { + setValueKind(valueKind); + return this; + } + + public ConfigurationParameterChange withUseEquals(boolean useEquals) { + setUseEquals(useEquals); + return this; + } + + public ConfigurationParameterChange withValues(ExpressionList values) { + setValues(values); + return this; + } + + /** + * Appends this clause to a builder. + * + * @param builder the target + * @param valueRenderer appends each value, for example through an expression deparser + * @return the builder + */ + public StringBuilder appendTo(StringBuilder builder, Consumer valueRenderer) { + if (action == Action.RESET) { + return builder.append("RESET ").append(parameter); + } + builder.append("SET ").append(parameter); + if (valueKind == ValueKind.FROM_CURRENT) { + return builder.append(" FROM CURRENT"); + } + builder.append(useEquals ? " = " : " TO "); + if (valueKind == ValueKind.DEFAULT) { + return builder.append("DEFAULT"); + } + if (values != null) { + for (int i = 0; i < values.size(); i++) { + if (i > 0) { + builder.append(", "); + } + valueRenderer.accept(values.get(i)); + } + } + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/ConnectStatement.java b/src/main/java/net/sf/jsqlparser/statement/ConnectStatement.java index a5ae350c64..829410b280 100644 --- a/src/main/java/net/sf/jsqlparser/statement/ConnectStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/ConnectStatement.java @@ -9,11 +9,13 @@ */ package net.sf.jsqlparser.statement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; + /** * DuckDB's {@code CONNECT target [AS alias]}, which routes the session's queries to a remote * database. */ -public class ConnectStatement implements Statement { +public class ConnectStatement extends ASTNodeAccessImpl implements Statement { private String target; private String alias; diff --git a/src/main/java/net/sf/jsqlparser/statement/CopyLegacyOption.java b/src/main/java/net/sf/jsqlparser/statement/CopyLegacyOption.java new file mode 100644 index 0000000000..cbeafc4d6f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/CopyLegacyOption.java @@ -0,0 +1,192 @@ +/*- + * #%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; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Column; + +/** + * One option of the COPY option syntax PostgreSQL used before 9.0 and still accepts: a keyword + * without parentheses or commas, such as {@code CSV}, {@code HEADER}, {@code DELIMITER AS ';'} or + * {@code FORCE QUOTE *}. The options follow the file name and the optional {@code WITH} in any + * order, as {@code copy_opt_item} in PostgreSQL's grammar. + * + * @see COPY, section Compatibility + */ +public class CopyLegacyOption extends ASTNodeAccessImpl { + private Kind kind; + private boolean asKeyword; + private StringValue value; + private final List columns = new ArrayList<>(); + private boolean allColumns; + + /** The option keyword, and what it takes after it. */ + public enum Kind { + /** BINARY, the binary format */ + BINARY("BINARY", Argument.NONE), + /** FREEZE */ + FREEZE("FREEZE", Argument.NONE), + /** DELIMITER [AS] 'string' */ + DELIMITER("DELIMITER", Argument.STRING_AFTER_OPTIONAL_AS), + /** NULL [AS] 'string' */ + NULL("NULL", Argument.STRING_AFTER_OPTIONAL_AS), + /** CSV, the CSV format */ + CSV("CSV", Argument.NONE), + /** HEADER */ + HEADER("HEADER", Argument.NONE), + /** QUOTE [AS] 'string' */ + QUOTE("QUOTE", Argument.STRING_AFTER_OPTIONAL_AS), + /** ESCAPE [AS] 'string' */ + ESCAPE("ESCAPE", Argument.STRING_AFTER_OPTIONAL_AS), + /** FORCE QUOTE {column, ... | *} */ + FORCE_QUOTE("FORCE QUOTE", Argument.COLUMNS), + /** FORCE NOT NULL {column, ... | *} */ + FORCE_NOT_NULL("FORCE NOT NULL", Argument.COLUMNS), + /** FORCE NULL {column, ... | *} */ + FORCE_NULL("FORCE NULL", Argument.COLUMNS), + /** ENCODING 'string' */ + ENCODING("ENCODING", Argument.STRING); + + private final String keyword; + private final Argument argument; + + Kind(String keyword, Argument argument) { + this.keyword = keyword; + this.argument = argument; + } + + /** The keywords of the option, such as {@code FORCE NOT NULL}. */ + public String getKeyword() { + return keyword; + } + + /** Whether a string follows the keyword. */ + public boolean takesString() { + return argument == Argument.STRING || argument == Argument.STRING_AFTER_OPTIONAL_AS; + } + + /** Whether {@code AS} may precede the string. */ + public boolean allowsAsKeyword() { + return argument == Argument.STRING_AFTER_OPTIONAL_AS; + } + + /** Whether a column list or {@code *} follows the keyword. */ + public boolean takesColumns() { + return argument == Argument.COLUMNS; + } + } + + private enum Argument { + NONE, STRING, STRING_AFTER_OPTIONAL_AS, COLUMNS + } + + public CopyLegacyOption(Kind kind) { + setKind(kind); + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = Objects.requireNonNull(kind, "kind"); + } + + /** Whether {@code AS} precedes the string, as in {@code DELIMITER AS ','}. */ + public boolean isAsKeyword() { + return asKeyword; + } + + public void setAsKeyword(boolean asKeyword) { + this.asKeyword = asKeyword; + } + + public CopyLegacyOption withAsKeyword(boolean asKeyword) { + setAsKeyword(asKeyword); + return this; + } + + /** The string of DELIMITER, NULL, QUOTE, ESCAPE or ENCODING; null for the other options. */ + public StringValue getValue() { + return value; + } + + public void setValue(StringValue value) { + this.value = value; + } + + public CopyLegacyOption withValue(StringValue value) { + setValue(value); + return this; + } + + /** The columns of a FORCE option; empty for {@code *} and for the other options. */ + public List getColumns() { + return columns; + } + + public void setColumns(Collection columns) { + List replacement = + columns == null ? Collections.emptyList() : new ArrayList<>(columns); + this.columns.clear(); + this.columns.addAll(replacement); + } + + public CopyLegacyOption addColumns(Column... columns) { + Collections.addAll(this.columns, columns); + return this; + } + + public CopyLegacyOption withColumns(Collection columns) { + setColumns(columns); + return this; + } + + /** Whether a FORCE option applies to every column, written {@code *}. */ + public boolean isAllColumns() { + return allColumns; + } + + public void setAllColumns(boolean allColumns) { + this.allColumns = allColumns; + } + + public CopyLegacyOption withAllColumns(boolean allColumns) { + setAllColumns(allColumns); + return this; + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + builder.append(kind.getKeyword()); + if (value != null) { + builder.append(asKeyword ? " AS " : " ").append(value); + } + if (allColumns) { + builder.append(" *"); + } else { + for (int i = 0; i < columns.size(); i++) { + builder.append(i == 0 ? " " : ", ").append(columns.get(i).getFullyQualifiedName()); + } + } + return builder; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/CopyStatement.java b/src/main/java/net/sf/jsqlparser/statement/CopyStatement.java index 0e05b58636..e253143685 100644 --- a/src/main/java/net/sf/jsqlparser/statement/CopyStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/CopyStatement.java @@ -10,22 +10,29 @@ package net.sf.jsqlparser.statement; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.Select; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.List; import java.util.function.Consumer; /** * {@code COPY table [(columns)] FROM path [(options)]} and * {@code COPY {table | (query)} TO path [(options)]}, the bulk import and export statement in - * DuckDB and PostgreSQL. + * DuckDB and PostgreSQL. PostgreSQL also accepts its option syntax from before 9.0, options without + * parentheses such as {@code CSV HEADER} (see {@link #getLegacyOptions()}), and + * {@code COPY BINARY table}. * * @see COPY + * @see PostgreSQL COPY */ -public class CopyStatement implements Statement { +public class CopyStatement extends ASTNodeAccessImpl implements Statement { private Table table; private ExpressionList columns; private Select select; @@ -33,6 +40,8 @@ public class CopyStatement implements Statement { private String path; private List options; private boolean withKeyword; + private boolean binary; + private final List legacyOptions = new ArrayList<>(); public Table getTable() { return table; @@ -100,6 +109,7 @@ public CopyStatement withPath(String path) { return this; } + /** The options in parentheses, each as written; null when the statement has none. */ public List getOptions() { return options; } @@ -127,6 +137,47 @@ public CopyStatement withWithKeyword(boolean withKeyword) { return this; } + /** Whether the table is preceded by BINARY, PostgreSQL's spelling from before 7.3. */ + public boolean isBinary() { + return binary; + } + + public void setBinary(boolean binary) { + this.binary = binary; + } + + public CopyStatement withBinary(boolean binary) { + setBinary(binary); + return this; + } + + /** + * The options of PostgreSQL's syntax from before 9.0, in source order, such as {@code CSV} and + * {@code HEADER} in {@code COPY t TO STDOUT CSV HEADER}; empty when the statement has none. A + * statement has either these options or the options in parentheses. + */ + public List getLegacyOptions() { + return legacyOptions; + } + + public void setLegacyOptions(Collection legacyOptions) { + List replacement = legacyOptions == null + ? Collections.emptyList() + : new ArrayList<>(legacyOptions); + this.legacyOptions.clear(); + this.legacyOptions.addAll(replacement); + } + + public CopyStatement addLegacyOptions(CopyLegacyOption... legacyOptions) { + Collections.addAll(this.legacyOptions, legacyOptions); + return this; + } + + public CopyStatement withLegacyOptions(Collection legacyOptions) { + setLegacyOptions(legacyOptions); + return this; + } + public StringBuilder appendTo(StringBuilder builder) { return appendTo(builder, builder::append); } @@ -139,6 +190,9 @@ public StringBuilder appendTo(StringBuilder builder, Consumer selectPrin if (withKeyword) { builder.append(" WITH"); } + for (CopyLegacyOption legacyOption : legacyOptions) { + legacyOption.appendTo(builder.append(' ')); + } if (options != null && !options.isEmpty()) { builder.append(" ").append(PlainSelect.getStringList(options, true, true)); } diff --git a/src/main/java/net/sf/jsqlparser/statement/CreateFunctionalStatement.java b/src/main/java/net/sf/jsqlparser/statement/CreateFunctionalStatement.java index 0845742e9b..35a4718dd7 100644 --- a/src/main/java/net/sf/jsqlparser/statement/CreateFunctionalStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/CreateFunctionalStatement.java @@ -15,13 +15,14 @@ import java.util.List; import java.util.Optional; import java.util.function.Consumer; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.create.function.FunctionReturnType; import net.sf.jsqlparser.statement.create.table.TableElement; /** * A base for the declaration of function like statements */ -public abstract class CreateFunctionalStatement implements Statement { +public abstract class CreateFunctionalStatement extends ASTNodeAccessImpl implements Statement { private String kind; private boolean orReplace = false; @@ -31,8 +32,10 @@ public enum Operation { } private Operation operation = Operation.CREATE; + private MySqlDefiner definer; private FunctionReturnType returnType; private List routineBodyParts; + private List characteristics = Collections.emptyList(); public Operation getOperation() { return operation; @@ -42,6 +45,19 @@ public void setOperation(Operation operation) { this.operation = operation; } + /** + * The MySQL {@code DEFINER} account, rendered after {@code CREATE [OR REPLACE]}. + * + * @return the definer, or {@code null} + */ + public MySqlDefiner getDefiner() { + return definer; + } + + public void setDefiner(MySqlDefiner definer) { + this.definer = definer; + } + public FunctionReturnType getReturnType() { return returnType; } @@ -85,8 +101,38 @@ public List getFunctionDeclarationParts() { return functionDeclarationParts; } + /** + * Replaces the declaration parts. The {@link #getCharacteristics() characteristics} described + * the replaced parts, so they are cleared. + * + * @param functionDeclarationParts the new parts + */ public void setFunctionDeclarationParts(List functionDeclarationParts) { + setFunctionDeclarationParts(functionDeclarationParts, Collections.emptyList()); + } + + /** + * Replaces the declaration parts together with the characteristics written in them. + * + * @param functionDeclarationParts the new parts, which keep rendering the statement + * @param characteristics the characteristics among the parts, in source order + */ + public void setFunctionDeclarationParts(List functionDeclarationParts, + List characteristics) { this.functionDeclarationParts = functionDeclarationParts; + this.characteristics = List.copyOf(characteristics); + } + + /** + * The MySQL characteristics of {@code CREATE FUNCTION|PROCEDURE}, such as {@code COMMENT}, + * {@code DETERMINISTIC} or {@code SQL SECURITY}, parsed with a MySQL or MariaDB dialect. They + * describe tokens of {@link #getFunctionDeclarationParts()}, which still render the statement, + * so the list is read-only. + * + * @return the characteristics in source order, empty if none were parsed + */ + public List getCharacteristics() { + return characteristics; } /** @@ -96,6 +142,14 @@ public String getKind() { return kind; } + /** + * @return the keywords that name the kind in the statement, which may carry a modifier of + * {@link #getKind()} + */ + protected String getKindKeywords() { + return kind; + } + public void setOrReplace(boolean orReplace) { this.orReplace = orReplace; } @@ -110,7 +164,7 @@ public String formatDeclaration() { private StringBuilder appendDeclarationTo(StringBuilder builder, Consumer printer) { - appendTokens(builder, functionDeclarationParts); + appendTokens(builder, getFunctionDeclarationParts()); if (returnType != null) { builder.append(' '); returnType.appendTo(builder, printer); @@ -139,7 +193,10 @@ public StringBuilder appendTo(StringBuilder builder, Consumer prin if (orReplace && operation == Operation.CREATE) { builder.append("OR REPLACE "); } - builder.append(kind).append(' '); + if (definer != null) { + builder.append("DEFINER = ").append(definer).append(' '); + } + builder.append(getKindKeywords()).append(' '); return appendDeclarationTo(builder, printer); } @@ -160,19 +217,23 @@ public CreateFunctionalStatement withFunctionDeclarationParts( return this; } + /** Appends declaration parts and keeps the {@link #getCharacteristics() characteristics}. */ public CreateFunctionalStatement addFunctionDeclarationParts( String... functionDeclarationParts) { List collection = Optional.ofNullable(getFunctionDeclarationParts()).orElseGet(ArrayList::new); Collections.addAll(collection, functionDeclarationParts); - return this.withFunctionDeclarationParts(collection); + setFunctionDeclarationParts(collection, characteristics); + return this; } + /** Appends declaration parts and keeps the {@link #getCharacteristics() characteristics}. */ public CreateFunctionalStatement addFunctionDeclarationParts( Collection functionDeclarationParts) { List collection = Optional.ofNullable(getFunctionDeclarationParts()).orElseGet(ArrayList::new); collection.addAll(functionDeclarationParts); - return this.withFunctionDeclarationParts(collection); + setFunctionDeclarationParts(collection, characteristics); + return this; } } diff --git a/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java b/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java index 25d375e38b..e4624f7f89 100644 --- a/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java @@ -9,10 +9,17 @@ */ package net.sf.jsqlparser.statement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; + /** - * {@code DEALLOCATE [PREPARE] name}, which drops a statement prepared by {@link PrepareStatement}. + * {@code DEALLOCATE [PREPARE] name}, or MySQL's {@code DROP PREPARE name}, which drops a statement + * prepared by {@link PrepareStatement}. + * + * @see MySQL DEALLOCATE + * PREPARE */ -public class DeallocateStatement implements Statement { +public class DeallocateStatement extends ASTNodeAccessImpl implements Statement { + private Keyword keyword = Keyword.DEALLOCATE; private String name; private boolean usingPrepareKeyword; @@ -35,8 +42,23 @@ public DeallocateStatement withName(String name) { return this; } + /** The leading keyword, {@code DEALLOCATE} unless MySQL's {@code DROP} was written. */ + public Keyword getKeyword() { + return keyword; + } + + public void setKeyword(Keyword keyword) { + this.keyword = keyword == null ? Keyword.DEALLOCATE : keyword; + } + + public DeallocateStatement withKeyword(Keyword keyword) { + setKeyword(keyword); + return this; + } + + /** Whether {@code PREPARE} follows the keyword; {@code DROP} always takes it. */ public boolean isUsingPrepareKeyword() { - return usingPrepareKeyword; + return usingPrepareKeyword || keyword == Keyword.DROP; } public void setUsingPrepareKeyword(boolean usingPrepareKeyword) { @@ -49,8 +71,8 @@ public DeallocateStatement withUsingPrepareKeyword(boolean usingPrepareKeyword) } public StringBuilder appendTo(StringBuilder builder) { - builder.append("DEALLOCATE "); - if (usingPrepareKeyword) { + builder.append(keyword).append(' '); + if (isUsingPrepareKeyword()) { builder.append("PREPARE "); } builder.append(name); @@ -66,4 +88,9 @@ public String toString() { public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); } + + /** The keyword that starts the statement. */ + public enum Keyword { + DEALLOCATE, DROP + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/DeclareStatement.java b/src/main/java/net/sf/jsqlparser/statement/DeclareStatement.java index 27537bc5ff..c189280b54 100644 --- a/src/main/java/net/sf/jsqlparser/statement/DeclareStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/DeclareStatement.java @@ -18,10 +18,11 @@ import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.UserVariable; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.create.table.ColDataType; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; -public final class DeclareStatement implements Statement { +public final class DeclareStatement extends ASTNodeAccessImpl implements Statement { private UserVariable userVariable = null; private DeclareType declareType = DeclareType.TYPE; diff --git a/src/main/java/net/sf/jsqlparser/statement/DefinitionArgument.java b/src/main/java/net/sf/jsqlparser/statement/DefinitionArgument.java new file mode 100644 index 0000000000..cedf241970 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/DefinitionArgument.java @@ -0,0 +1,179 @@ +/*- + * #%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; + +import java.io.Serializable; +import java.util.Objects; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.statement.create.table.ColDataType; + +/** + * The value of a {@link DefinitionElement}: PostgreSQL's {@code def_arg}. The grammar reads a name, + * such as a function or a storage strategy, as a type name, so it is a {@link Kind#TYPE} argument. + */ +public final class DefinitionArgument implements Serializable { + public enum Kind { + /** A type or a name, see {@link #getDataType()}. */ + TYPE, + /** A reserved keyword such as {@code TRUE} or {@code NULL}, see {@link #getKeyword()}. */ + KEYWORD, + /** An operator, see {@link #getOperator()}. */ + OPERATOR, + /** A number with an optional sign, see {@link #getNumber()}. */ + NUMBER, + /** A string constant, see {@link #getString()}. */ + STRING, + /** The keyword {@code NONE}. */ + NONE + } + + private final Kind kind; + private ColDataType dataType; + private boolean setOf; + private boolean typeReference; + private String keyword; + private String operator; + private boolean operatorKeyword; + private Expression number; + private StringValue string; + + private DefinitionArgument(Kind kind) { + this.kind = kind; + } + + public static DefinitionArgument type(ColDataType dataType) { + return type(dataType, false, false); + } + + /** + * A type argument. + * + * @param dataType the type or name + * @param setOf whether {@code SETOF} precedes the type + * @param typeReference whether {@code %TYPE} follows the name of a column + * @return the argument + */ + public static DefinitionArgument type(ColDataType dataType, boolean setOf, + boolean typeReference) { + DefinitionArgument argument = new DefinitionArgument(Kind.TYPE); + argument.dataType = Objects.requireNonNull(dataType); + argument.setOf = setOf; + argument.typeReference = typeReference; + return argument; + } + + public static DefinitionArgument keyword(String keyword) { + DefinitionArgument argument = new DefinitionArgument(Kind.KEYWORD); + argument.keyword = Objects.requireNonNull(keyword); + return argument; + } + + /** + * An operator argument. + * + * @param operator the operator, with its schema when written as {@code OPERATOR(schema.op)} + * @param operatorKeyword whether the operator is written as {@code OPERATOR(...)} + * @return the argument + */ + public static DefinitionArgument operator(String operator, boolean operatorKeyword) { + DefinitionArgument argument = new DefinitionArgument(Kind.OPERATOR); + argument.operator = Objects.requireNonNull(operator); + argument.operatorKeyword = operatorKeyword; + return argument; + } + + public static DefinitionArgument number(Expression number) { + DefinitionArgument argument = new DefinitionArgument(Kind.NUMBER); + argument.number = Objects.requireNonNull(number); + return argument; + } + + public static DefinitionArgument string(StringValue string) { + DefinitionArgument argument = new DefinitionArgument(Kind.STRING); + argument.string = Objects.requireNonNull(string); + return argument; + } + + public static DefinitionArgument none() { + return new DefinitionArgument(Kind.NONE); + } + + public Kind getKind() { + return kind; + } + + /** + * The type of a {@link Kind#TYPE} argument. A plain name, such as the function of + * {@code INPUT = box3_in}, is the type's {@link ColDataType#getDataType() name}. + * + * @return the type, or {@code null} for another kind + */ + public ColDataType getDataType() { + return dataType; + } + + public boolean isSetOf() { + return setOf; + } + + /** + * Whether {@code %TYPE} follows the name, which then names a column. + * + * @return {@code true} for {@code table.column%TYPE} + */ + public boolean isTypeReference() { + return typeReference; + } + + public String getKeyword() { + return keyword; + } + + public String getOperator() { + return operator; + } + + public boolean isOperatorKeyword() { + return operatorKeyword; + } + + /** + * The number of a {@link Kind#NUMBER} argument: a long or double value, inside a signed + * expression when a sign is written. + * + * @return the number, or {@code null} for another kind + */ + public Expression getNumber() { + return number; + } + + public StringValue getString() { + return string; + } + + @Override + public String toString() { + switch (kind) { + case TYPE: + return (setOf ? "SETOF " : "") + dataType + (typeReference ? "%TYPE" : ""); + case KEYWORD: + return keyword; + case OPERATOR: + return operatorKeyword ? "OPERATOR(" + operator + ")" : operator; + case NUMBER: + return number.toString(); + case STRING: + return string.toString(); + default: + return "NONE"; + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/DefinitionElement.java b/src/main/java/net/sf/jsqlparser/statement/DefinitionElement.java new file mode 100644 index 0000000000..22345c48e0 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/DefinitionElement.java @@ -0,0 +1,81 @@ +/*- + * #%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; + +import java.io.Serializable; +import java.util.List; +import java.util.stream.Collectors; + +/** + * One element of a PostgreSQL definition list, {@code name [= value]}, as in + * {@code CREATE TYPE name (INPUT = fn, PASSEDBYVALUE)}, {@code ALTER TYPE name SET (SEND = NONE)}, + * {@code CREATE OPERATOR} or {@code CREATE AGGREGATE}. The name keeps its spelling and quoting. + */ +public class DefinitionElement implements Serializable { + private String name; + private DefinitionArgument argument; + + public DefinitionElement() { + // empty constructor + } + + public DefinitionElement(String name, DefinitionArgument argument) { + this.name = name; + this.argument = argument; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * The value after the equals sign. + * + * @return the argument, or {@code null} for an element without a value + */ + public DefinitionArgument getArgument() { + return argument; + } + + public void setArgument(DefinitionArgument argument) { + this.argument = argument; + } + + /** + * Renders a definition list in parentheses. + * + * @param elements the elements + * @return the list, such as {@code (INPUT = fn, PASSEDBYVALUE)} + */ + public static String toString(List elements) { + return elements.stream().map(Object::toString).collect(Collectors.joining(", ", "(", ")")); + } + + /** + * Finds an element of a definition list by its name, ignoring case. + * + * @param elements the elements + * @param name the name, such as {@code INPUT} + * @return the first element of that name, or {@code null} + */ + public static DefinitionElement find(List elements, String name) { + return elements.stream().filter(element -> name.equalsIgnoreCase(element.getName())) + .findFirst().orElse(null); + } + + @Override + public String toString() { + return argument == null ? name : name + " = " + argument; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java b/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java index 054b648436..ad0cadd549 100644 --- a/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java @@ -9,14 +9,23 @@ */ package net.sf.jsqlparser.statement; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.select.Select; -public class DescribeStatement implements Statement { +/** + * {@code DESCRIBE} or {@code DESC} of a table, or, in DuckDB, of a query's result. + * + * @see MySQL DESCRIBE + */ +public class DescribeStatement extends ASTNodeAccessImpl implements Statement { private Table table; private Select select; private String describeType; + private Expression columnPattern; public DescribeStatement() { // empty constructor @@ -48,10 +57,43 @@ public DescribeStatement withSelect(Select select) { return this; } + /** + * The MySQL column name ({@link net.sf.jsqlparser.schema.Column}) or wildcard string that + * limits the described columns to those it matches, or null. + */ + public Expression getColumnPattern() { + return columnPattern; + } + + public void setColumnPattern(Expression columnPattern) { + this.columnPattern = columnPattern; + } + + public DescribeStatement withColumnPattern(Expression columnPattern) { + setColumnPattern(columnPattern); + return this; + } + @Override public String toString() { - return this.describeType + " " - + (select != null ? select.toString() : table.getFullyQualifiedName()); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append, builder::append).toString(); + } + + /** Shared by SQL rendering and statement deparsers. */ + public StringBuilder appendTo(StringBuilder builder, Consumer selectRenderer) { + builder.append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) { + builder.append(", "); + } + parameters.get(i).appendTo(builder, expressionRenderer); + } + builder.append(") AS "); + if (select != null) { + builder.append("TABLE "); + selectRenderer.accept(select); + } else { + expressionRenderer.accept(expression); + } + return builder; + } + } + + /** + * A macro parameter, optionally typed ({@code a INTEGER}) and carrying a default value + * ({@code b := 5}). + */ public static class Parameter implements Serializable { private final String name; + private final ColDataType type; private final Expression defaultValue; public Parameter(String name) { - this(name, null); + this(name, null, null); } public Parameter(String name, Expression defaultValue) { + this(name, null, defaultValue); + } + + public Parameter(String name, ColDataType type, Expression defaultValue) { this.name = name; + this.type = type; this.defaultValue = defaultValue; } @@ -174,6 +317,10 @@ public String getName() { return name; } + public ColDataType getType() { + return type; + } + public Expression getDefaultValue() { return defaultValue; } @@ -187,6 +334,9 @@ public String toString() { private StringBuilder appendTo(StringBuilder builder, Consumer expressionRenderer) { builder.append(name); + if (type != null) { + builder.append(" ").append(type); + } if (defaultValue != null) { builder.append(" := "); expressionRenderer.accept(defaultValue); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperator.java b/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperator.java new file mode 100644 index 0000000000..3b1e224202 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperator.java @@ -0,0 +1,80 @@ +/*- + * #%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.operator; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.create.table.ExclusionOperator; + +/** + * PostgreSQL {@code CREATE OPERATOR [schema.]op (FUNCTION = fn, LEFTARG = type, ...)}. The operator + * keeps its exact spelling. PostgreSQL checks the names and values of the definition when it runs + * the statement, so they are not restricted. + */ +public class CreateOperator extends ASTNodeAccessImpl implements Statement { + private ExclusionOperator operator; + private List definition = new ArrayList<>(); + + /** + * The operator symbol and its schema, read as in DROP OPERATOR and COMMENT ON OPERATOR. + * + * @return the operator + */ + public ExclusionOperator getOperator() { + return operator; + } + + public void setOperator(ExclusionOperator operator) { + this.operator = operator; + } + + /** + * The definition elements in source order, such as {@code FUNCTION = fn} or {@code HASHES}. + * + * @return the elements + */ + public List getDefinition() { + return definition; + } + + public void setDefinition(List definition) { + this.definition = definition; + } + + /** + * Finds a definition element by its name, ignoring case. + * + * @param name the name, such as {@code COMMUTATOR} + * @return the first element of that name, or {@code null} + */ + public DefinitionElement getDefinitionElement(String name) { + return DefinitionElement.find(definition, name); + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + return builder.append("CREATE OPERATOR ").append(operator.getQualifiedName()).append(' ') + .append(DefinitionElement.toString(definition)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperatorClass.java b/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperatorClass.java new file mode 100644 index 0000000000..68184f208f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperatorClass.java @@ -0,0 +1,116 @@ +/*- + * #%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.operator; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.create.table.ColDataType; + +/** + * PostgreSQL {@code CREATE OPERATOR CLASS name [DEFAULT] FOR TYPE type USING index_method + * [FAMILY family] AS member [, ...]}. Names retain SQL identifier quoting. + */ +public class CreateOperatorClass extends ASTNodeAccessImpl implements Statement { + private String name; + private boolean defaultClass; + private ColDataType dataType; + private String accessMethod; + private String family; + private List items = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * Whether the class is the {@code DEFAULT} operator class of its type. + * + * @return {@code true} when DEFAULT is written + */ + public boolean isDefaultClass() { + return defaultClass; + } + + public void setDefaultClass(boolean defaultClass) { + this.defaultClass = defaultClass; + } + + public ColDataType getDataType() { + return dataType; + } + + public void setDataType(ColDataType dataType) { + this.dataType = dataType; + } + + /** + * The index access method after {@code USING}, such as {@code btree}. + * + * @return the access method + */ + public String getAccessMethod() { + return accessMethod; + } + + public void setAccessMethod(String accessMethod) { + this.accessMethod = accessMethod; + } + + /** + * The operator family the class is added to. + * + * @return the family name, or {@code null} without a FAMILY clause + */ + public String getFamily() { + return family; + } + + public void setFamily(String family) { + this.family = family; + } + + public List getItems() { + return items; + } + + public void setItems(List items) { + this.items = items; + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + builder.append("CREATE OPERATOR CLASS ").append(name); + if (defaultClass) { + builder.append(" DEFAULT"); + } + builder.append(" FOR TYPE ").append(dataType).append(" USING ").append(accessMethod); + if (family != null) { + builder.append(" FAMILY ").append(family); + } + return builder.append(" AS ").append(OperatorClassItem.toString(items)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperatorFamily.java b/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperatorFamily.java new file mode 100644 index 0000000000..a1b5a93e2f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/operator/CreateOperatorFamily.java @@ -0,0 +1,60 @@ +/*- + * #%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.operator; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL {@code CREATE OPERATOR FAMILY name USING index_method}. Names retain SQL identifier + * quoting. + */ +public class CreateOperatorFamily extends ASTNodeAccessImpl implements Statement { + private String name; + private String accessMethod; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** + * The index access method after {@code USING}, such as {@code btree}. + * + * @return the access method + */ + public String getAccessMethod() { + return accessMethod; + } + + public void setAccessMethod(String accessMethod) { + this.accessMethod = accessMethod; + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + return builder.append("CREATE OPERATOR FAMILY ").append(name).append(" USING ") + .append(accessMethod); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/operator/OperatorClassItem.java b/src/main/java/net/sf/jsqlparser/statement/create/operator/OperatorClassItem.java new file mode 100644 index 0000000000..40f9cd0f45 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/operator/OperatorClassItem.java @@ -0,0 +1,191 @@ +/*- + * #%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.operator; + +import java.io.Serializable; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ExclusionOperator; + +/** + * One member of a PostgreSQL operator class or family, as listed by CREATE OPERATOR CLASS and by + * ALTER OPERATOR FAMILY ... ADD or DROP: + *
    + *
  • {@code OPERATOR n op [(left, right)] [FOR SEARCH | FOR ORDER BY sort_family]}
  • + *
  • {@code FUNCTION n [(type [, ...])] fn [(argument [, ...])]}
  • + *
  • {@code STORAGE type}
  • + *
  • {@code OPERATOR n (type [, ...])} and {@code FUNCTION n (type [, ...])}, which name the + * member that ALTER OPERATOR FAMILY ... DROP removes.
  • + *
+ */ +public class OperatorClassItem implements Serializable { + public enum Kind { + OPERATOR, FUNCTION, STORAGE + } + + /** What an operator of an operator class is used for. */ + public enum Purpose { + SEARCH, ORDER_BY + } + + private Kind kind; + private Integer number; + private ExclusionOperator operator; + private List operandTypes; + private Purpose purpose; + private String sortFamily; + private RoutineReference function; + private ColDataType storageType; + + public OperatorClassItem() { + // the parser or the setters fill the item + } + + public OperatorClassItem(Kind kind) { + this.kind = kind; + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = kind; + } + + /** + * The strategy number of an operator or the support number of a function. + * + * @return the number, or {@code null} for {@code STORAGE} + */ + public Integer getNumber() { + return number; + } + + public void setNumber(Integer number) { + this.number = number; + } + + /** + * The operator of an {@code OPERATOR} member. + * + * @return the operator, or {@code null} for another kind and for a member to drop + */ + public ExclusionOperator getOperator() { + return operator; + } + + public void setOperator(ExclusionOperator operator) { + this.operator = operator; + } + + /** + * The operand types in parentheses. After an operator they are its left and right operand type, + * where {@code null} stands for {@code NONE}. + * + * @return the types, or {@code null} when the member has no such list + */ + public List getOperandTypes() { + return operandTypes; + } + + public void setOperandTypes(List operandTypes) { + this.operandTypes = operandTypes; + } + + /** + * The purpose of an operator, {@code FOR SEARCH} or {@code FOR ORDER BY sort_family}. + * + * @return the purpose, or {@code null} when none is written + */ + public Purpose getPurpose() { + return purpose; + } + + public void setPurpose(Purpose purpose) { + this.purpose = purpose; + } + + /** + * The operator family of {@code FOR ORDER BY}. + * + * @return the family name, or {@code null} + */ + public String getSortFamily() { + return sortFamily; + } + + public void setSortFamily(String sortFamily) { + this.sortFamily = sortFamily; + } + + /** + * The function of a {@code FUNCTION} member. Its arguments are {@code null} when the function + * is written without an argument list. + * + * @return the function, or {@code null} for another kind and for a member to drop + */ + public RoutineReference getFunction() { + return function; + } + + public void setFunction(RoutineReference function) { + this.function = function; + } + + public ColDataType getStorageType() { + return storageType; + } + + public void setStorageType(ColDataType storageType) { + this.storageType = storageType; + } + + /** + * Renders a member list. + * + * @param items the members + * @return the members, separated by commas + */ + public static String toString(List items) { + return items.stream().map(Object::toString).collect(Collectors.joining(", ")); + } + + private void appendOperandTypes(StringBuilder builder) { + if (operandTypes != null) { + builder.append(" (").append(operandTypes.stream() + .map(type -> type == null ? "NONE" : type.toString()) + .collect(Collectors.joining(", "))).append(')'); + } + } + + @Override + public String toString() { + if (kind == Kind.STORAGE) { + return "STORAGE " + storageType; + } + StringBuilder builder = new StringBuilder(kind.name()).append(' ').append(number); + if (operator != null) { + builder.append(' ').append(operator.getQualifiedName()); + } + appendOperandTypes(builder); + if (function != null) { + builder.append(' ').append(function); + } + if (purpose == Purpose.SEARCH) { + builder.append(" FOR SEARCH"); + } else if (purpose == Purpose.ORDER_BY) { + builder.append(" FOR ORDER BY ").append(sortFamily); + } + return builder.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/policy/CreatePolicy.java b/src/main/java/net/sf/jsqlparser/statement/create/policy/CreatePolicy.java index 2158e7efad..267c946d95 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/policy/CreatePolicy.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/policy/CreatePolicy.java @@ -10,11 +10,12 @@ package net.sf.jsqlparser.statement.create.policy; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -import java.util.ArrayList; +import java.util.function.Consumer; import java.util.List; /** @@ -24,15 +25,22 @@ * | INSERT | UPDATE | DELETE } ] [ TO { role_name | PUBLIC | CURRENT_ROLE | CURRENT_USER | * SESSION_USER } [, ...] ] [ USING ( using_expression ) ] [ WITH CHECK ( check_expression ) ] */ -public class CreatePolicy implements Statement { +public class CreatePolicy extends ASTNodeAccessImpl implements Statement { private String policyName; private Table table; private PolicyMode policyMode; private PolicyCommand policyCommand; - private List roles = new ArrayList<>(); - private Expression usingExpression; - private Expression withCheckExpression; + private PolicyOptions options = new PolicyOptions(); + + public PolicyOptions getOptions() { + return options; + } + + public CreatePolicy setOptions(PolicyOptions options) { + this.options = java.util.Objects.requireNonNull(options); + return this; + } public String getPolicyName() { return policyName; @@ -118,34 +126,34 @@ public PolicyCommand getEffectivePolicyCommand() { } public List getRoles() { - return roles; + return options.getRoles(); } public CreatePolicy setRoles(List roles) { - this.roles = roles; + options.setRoles(roles); return this; } public CreatePolicy addRole(String role) { - this.roles.add(role); + options.getRoles().add(role); return this; } public Expression getUsingExpression() { - return usingExpression; + return options.getUsingExpression(); } public CreatePolicy setUsingExpression(Expression usingExpression) { - this.usingExpression = usingExpression; + options.setUsingExpression(usingExpression); return this; } public Expression getWithCheckExpression() { - return withCheckExpression; + return options.getWithCheckExpression(); } public CreatePolicy setWithCheckExpression(Expression withCheckExpression) { - this.withCheckExpression = withCheckExpression; + options.setWithCheckExpression(withCheckExpression); return this; } @@ -154,39 +162,22 @@ public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); } - @Override - public String toString() { - StringBuilder builder = new StringBuilder("CREATE POLICY "); - builder.append(policyName); - builder.append(" ON "); - builder.append(table.toString()); + public StringBuilder appendTo(StringBuilder builder, Consumer printer) { + builder.append("CREATE POLICY ").append(policyName).append(" ON ").append(table); if (policyMode != null) { builder.append(" AS ").append(policyMode); } - if (policyCommand != null) { builder.append(" FOR ").append(policyCommand); } + options.appendTo(builder, printer); + return builder; + } - if (roles != null && !roles.isEmpty()) { - builder.append(" TO "); - for (int i = 0; i < roles.size(); i++) { - if (i > 0) { - builder.append(", "); - } - builder.append(roles.get(i)); - } - } - - if (usingExpression != null) { - builder.append(" USING (").append(usingExpression.toString()).append(")"); - } - - if (withCheckExpression != null) { - builder.append(" WITH CHECK (").append(withCheckExpression.toString()).append(")"); - } - - return builder.toString(); + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/policy/PolicyOptions.java b/src/main/java/net/sf/jsqlparser/statement/create/policy/PolicyOptions.java new file mode 100644 index 0000000000..53c9d60879 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/policy/PolicyOptions.java @@ -0,0 +1,75 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2025 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create.policy; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; + +/** Roles and predicates shared by PostgreSQL CREATE and ALTER POLICY. */ +public class PolicyOptions implements Serializable { + private List roles = new ArrayList<>(); + private Expression usingExpression; + private Expression withCheckExpression; + + public List getRoles() { + return roles; + } + + public PolicyOptions setRoles(List roles) { + this.roles = roles; + return this; + } + + public Expression getUsingExpression() { + return usingExpression; + } + + public PolicyOptions setUsingExpression(Expression usingExpression) { + this.usingExpression = usingExpression; + return this; + } + + public Expression getWithCheckExpression() { + return withCheckExpression; + } + + public PolicyOptions setWithCheckExpression(Expression withCheckExpression) { + this.withCheckExpression = withCheckExpression; + return this; + } + + public void visitExpressions(Consumer visitor) { + if (usingExpression != null) { + visitor.accept(usingExpression); + } + if (withCheckExpression != null) { + visitor.accept(withCheckExpression); + } + } + + public void appendTo(StringBuilder sql, Consumer printer) { + if (roles != null && !roles.isEmpty()) { + sql.append(" TO ").append(String.join(", ", roles)); + } + if (usingExpression != null) { + sql.append(" USING ("); + printer.accept(usingExpression); + sql.append(')'); + } + if (withCheckExpression != null) { + sql.append(" WITH CHECK ("); + printer.accept(withCheckExpression); + sql.append(')'); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/publication/CreatePublication.java b/src/main/java/net/sf/jsqlparser/statement/create/publication/CreatePublication.java index b749f11d60..5a8433b28d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/publication/CreatePublication.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/publication/CreatePublication.java @@ -13,10 +13,11 @@ import java.util.List; import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -public class CreatePublication implements Statement { +public class CreatePublication extends ASTNodeAccessImpl implements Statement { private String name; private boolean allTables; private List targets = new ArrayList<>(); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/rule/CreateRule.java b/src/main/java/net/sf/jsqlparser/statement/create/rule/CreateRule.java new file mode 100644 index 0000000000..a9984106cb --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/rule/CreateRule.java @@ -0,0 +1,171 @@ +/*- + * #%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.rule; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL rewrite rule whose actions reuse ordinary statement AST nodes. */ +public class CreateRule extends ASTNodeAccessImpl implements Statement { + public enum Event { + SELECT, INSERT, UPDATE, DELETE + } + public enum Behavior { + ALSO, INSTEAD + } + + private String name; + private boolean orReplace; + private Event event; + private Table table; + private Expression whereExpression; + private Behavior behavior; + private boolean useParentheses; + private List actions = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String value) { + name = value; + } + + public boolean isOrReplace() { + return orReplace; + } + + public void setOrReplace(boolean value) { + orReplace = value; + } + + public Event getEvent() { + return event; + } + + public void setEvent(Event value) { + event = value; + } + + public Table getTable() { + return table; + } + + public void setTable(Table value) { + table = value; + } + + public Expression getWhereExpression() { + return whereExpression; + } + + public void setWhereExpression(Expression value) { + whereExpression = value; + } + + public Behavior getBehavior() { + return behavior; + } + + public void setBehavior(Behavior value) { + behavior = value; + } + + public boolean isUseParentheses() { + return useParentheses; + } + + public void setUseParentheses(boolean value) { + useParentheses = value; + } + + public List getActions() { + return actions; + } + + public void setActions(List value) { + actions = value; + } + + public boolean isNothing() { + return actions.isEmpty() && !useParentheses; + } + + public void setNothing(boolean nothing) { + if (nothing) { + actions.clear(); + useParentheses = false; + } + } + + public void visitExpressions(Consumer visitor) { + if (whereExpression != null) { + visitor.accept(whereExpression); + } + } + + public void visitTables(Consumer visitor) { + if (table != null) { + visitor.accept(table); + } + } + + public StringBuilder appendTo(StringBuilder sql, Consumer expressions, + Consumer statements) { + sql.append("CREATE "); + if (orReplace) { + sql.append("OR REPLACE "); + } + sql.append("RULE ").append(name).append(" AS ON ").append(event).append(" TO ") + .append(table); + if (whereExpression != null) { + sql.append(" WHERE "); + expressions.accept(whereExpression); + } + sql.append(" DO "); + if (behavior != null) { + sql.append(behavior).append(' '); + } + if (isNothing()) { + return sql.append("NOTHING"); + } + boolean grouped = useParentheses || actions.size() != 1; + if (grouped) { + sql.append('('); + } + for (int i = 0; i < actions.size(); i++) { + if (i > 0) { + sql.append("; "); + } + statements.accept(actions.get(i)); + } + if (grouped) { + sql.append(')'); + } + return sql; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + return appendTo(sql, sql::append, sql::append).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java b/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java index f8888132f3..bff382a374 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java @@ -14,13 +14,15 @@ import java.util.Collections; import java.util.List; import java.util.Optional; +import java.util.function.Consumer; import java.util.stream.Collectors; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; import net.sf.jsqlparser.statement.create.database.DatabaseOption; -public class CreateSchema implements Statement { +public class CreateSchema extends ASTNodeAccessImpl implements Statement { private String authorization; private String catalogName = null; @@ -36,7 +38,7 @@ public T accept(StatementVisitor statementVisitor, S context) { } /** - * Add a statement to the schema definition + * Add a schema element, for example a CREATE TABLE or GRANT statement, to the schema definition * * @param statement The statement to be added * @return true if the operation was successful @@ -109,7 +111,8 @@ public void setSchemaPath(List schemaPath) { } /** - * The statements executed as part of the schema creation + * The schema elements created as part of the schema, in source order. Their names are kept as + * written; unqualified names refer to the new schema. * * @return the statements */ @@ -139,7 +142,32 @@ public CreateSchema setIfNotExists(boolean hasIfNotExists) { return this; } + @Override public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + /** + * Appends the schema definition, rendering each schema element with the given writer. + * + * @param builder the target + * @param elementWriter renders one schema element + * @return the target + */ + public StringBuilder appendTo(StringBuilder builder, Consumer elementWriter) { + builder.append(headerSql()); + if (schemaPath != null && !schemaPath.isEmpty()) { + builder.append(" PATH ").append(String.join(", ", schemaPath)); + } + for (Statement statement : statements) { + builder.append(' '); + elementWriter.accept(statement); + } + return builder; + } + + private String headerSql() { String sql = "CREATE SCHEMA"; if (hasIfNotExists) { sql += " IF NOT EXISTS"; diff --git a/src/main/java/net/sf/jsqlparser/statement/create/sequence/CreateSequence.java b/src/main/java/net/sf/jsqlparser/statement/create/sequence/CreateSequence.java index 0d1c2b7f75..f005e3b0d1 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/sequence/CreateSequence.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/sequence/CreateSequence.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.create.sequence; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Sequence; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; @@ -16,9 +17,44 @@ /** * A {@code CREATE SEQUENCE} statement */ -public class CreateSequence implements Statement { +public class CreateSequence extends ASTNodeAccessImpl implements Statement { + + public enum Persistence { + TEMP, TEMPORARY, UNLOGGED, LOCAL_TEMP, LOCAL_TEMPORARY, GLOBAL_TEMP, GLOBAL_TEMPORARY + } public Sequence sequence; + private Persistence persistence; + private boolean ifNotExists; + + public Persistence getPersistence() { + return persistence; + } + + public void setPersistence(Persistence persistence) { + this.persistence = persistence; + } + + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean ifNotExists) { + this.ifNotExists = ifNotExists; + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append("CREATE "); + if (persistence != null) { + builder.append(persistence.name().replace('_', ' ')).append(' '); + } + builder.append("SEQUENCE "); + if (ifNotExists) { + builder.append("IF NOT EXISTS "); + } + return builder.append(sequence); + } + public Sequence getSequence() { return sequence; @@ -35,9 +71,7 @@ public T accept(StatementVisitor statementVisitor, S context) { @Override public String toString() { - String sql; - sql = "CREATE SEQUENCE " + sequence; - return sql; + return appendTo(new StringBuilder()).toString(); } public CreateSequence withSequence(Sequence sequence) { diff --git a/src/main/java/net/sf/jsqlparser/statement/create/server/CreateServer.java b/src/main/java/net/sf/jsqlparser/statement/create/server/CreateServer.java new file mode 100644 index 0000000000..e4ebc4f2ed --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/server/CreateServer.java @@ -0,0 +1,96 @@ +/*- + * #%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.server; + +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.foreign.ForeignDataStatement; +import net.sf.jsqlparser.expression.StringValue; + +public class CreateServer extends ForeignDataStatement { + private String name; + private boolean ifNotExists; + private StringValue type; + private Expression version; + private String foreignDataWrapper; + + public String getName() { + return name; + } + + public void setName(String value) { + name = value; + } + + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean value) { + ifNotExists = value; + } + + public StringValue getType() { + return type; + } + + public void setType(StringValue value) { + type = value; + } + + public Expression getVersion() { + return version; + } + + public void setVersion(Expression value) { + version = value; + } + + public String getForeignDataWrapper() { + return foreignDataWrapper; + } + + public void setForeignDataWrapper(String value) { + foreignDataWrapper = value; + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } + + @Override + public StringBuilder appendTo(StringBuilder sql, Consumer printer) { + sql.append("CREATE SERVER "); + if (ifNotExists) { + sql.append("IF NOT EXISTS "); + } + sql.append(name); + if (type != null) { + sql.append(" TYPE "); + printer.accept(type); + } + if (version != null) { + sql.append(" VERSION "); + printer.accept(version); + } + sql.append(" FOREIGN DATA WRAPPER ").append(foreignDataWrapper); + appendOptionsTo(sql, printer); + return sql; + } + + @Override + public void visitExpressions(Consumer visitor) { + super.visitExpressions(visitor); + visit(type, visitor); + visit(version, visitor); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/spatial/CreateSpatialReferenceSystem.java b/src/main/java/net/sf/jsqlparser/statement/create/spatial/CreateSpatialReferenceSystem.java new file mode 100644 index 0000000000..28e4f6b30e --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/spatial/CreateSpatialReferenceSystem.java @@ -0,0 +1,195 @@ +/*- + * #%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.spatial; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * MySQL {@code CREATE OR REPLACE SPATIAL REFERENCE SYSTEM srid srs_attribute ...} and + * {@code CREATE SPATIAL REFERENCE SYSTEM [IF NOT EXISTS] srid srs_attribute ...}. OR REPLACE and IF + * NOT EXISTS exclude each other. + * + *

+ * The attributes keep their source order. MySQL's grammar takes them in any order and any number; + * the server then reports a repeated attribute and a missing NAME or DEFINITION as errors of their + * own, not as syntax errors, so the parser accepts them. The typed getters return the first + * attribute of their kind. + * + * @see MySQL + * CREATE SPATIAL REFERENCE SYSTEM + */ +public class CreateSpatialReferenceSystem extends ASTNodeAccessImpl implements Statement { + private boolean orReplace; + private boolean ifNotExists; + private Expression srid; + private final List attributes = new ArrayList<>(); + + public CreateSpatialReferenceSystem(Expression srid) { + setSrid(srid); + } + + public boolean isOrReplace() { + return orReplace; + } + + /** + * Sets OR REPLACE. + * + * @throws IllegalArgumentException if the statement has IF NOT EXISTS + */ + public void setOrReplace(boolean orReplace) { + if (orReplace && ifNotExists) { + throw new IllegalArgumentException("OR REPLACE excludes IF NOT EXISTS"); + } + this.orReplace = orReplace; + } + + public CreateSpatialReferenceSystem withOrReplace(boolean orReplace) { + setOrReplace(orReplace); + return this; + } + + public boolean isIfNotExists() { + return ifNotExists; + } + + /** + * Sets IF NOT EXISTS. + * + * @throws IllegalArgumentException if the statement has OR REPLACE + */ + public void setIfNotExists(boolean ifNotExists) { + if (ifNotExists && orReplace) { + throw new IllegalArgumentException("IF NOT EXISTS excludes OR REPLACE"); + } + this.ifNotExists = ifNotExists; + } + + public CreateSpatialReferenceSystem withIfNotExists(boolean ifNotExists) { + setIfNotExists(ifNotExists); + return this; + } + + /** + * The SRID as written: a {@link net.sf.jsqlparser.expression.LongValue}, or a + * {@link net.sf.jsqlparser.expression.HexValue} for {@code 0x...} and {@code X'...'}. + */ + public Expression getSrid() { + return srid; + } + + public final void setSrid(Expression srid) { + this.srid = Objects.requireNonNull(srid, "srid"); + } + + public CreateSpatialReferenceSystem withSrid(Expression srid) { + setSrid(srid); + return this; + } + + /** The mutable attributes in source order. */ + public List getAttributes() { + return attributes; + } + + public void setAttributes(Collection attributes) { + this.attributes.clear(); + if (attributes != null) { + this.attributes.addAll(attributes); + } + } + + public CreateSpatialReferenceSystem withAttributes( + Collection attributes) { + setAttributes(attributes); + return this; + } + + public CreateSpatialReferenceSystem addAttributes( + SpatialReferenceSystemAttribute... attributes) { + Collections.addAll(this.attributes, attributes); + return this; + } + + /** The first attribute of the kind, or null. */ + public SpatialReferenceSystemAttribute getAttribute( + SpatialReferenceSystemAttribute.Kind kind) { + for (SpatialReferenceSystemAttribute attribute : attributes) { + if (attribute.getKind() == kind) { + return attribute; + } + } + return null; + } + + private StringValue getValue(SpatialReferenceSystemAttribute.Kind kind) { + SpatialReferenceSystemAttribute attribute = getAttribute(kind); + return attribute == null ? null : attribute.getValue(); + } + + /** The string of {@code NAME 'srs_name'}, or null. */ + public StringValue getName() { + return getValue(SpatialReferenceSystemAttribute.Kind.NAME); + } + + /** The string of {@code DEFINITION 'definition'}, or null. */ + public StringValue getDefinition() { + return getValue(SpatialReferenceSystemAttribute.Kind.DEFINITION); + } + + /** The organization name of {@code ORGANIZATION 'org_name' IDENTIFIED BY org_id}, or null. */ + public StringValue getOrganization() { + return getValue(SpatialReferenceSystemAttribute.Kind.ORGANIZATION); + } + + /** The number of {@code ORGANIZATION 'org_name' IDENTIFIED BY org_id}, or null. */ + public Expression getOrganizationId() { + SpatialReferenceSystemAttribute attribute = + getAttribute(SpatialReferenceSystemAttribute.Kind.ORGANIZATION); + return attribute == null ? null : attribute.getOrganizationId(); + } + + /** The string of {@code DESCRIPTION 'description'}, or null. */ + public StringValue getDescription() { + return getValue(SpatialReferenceSystemAttribute.Kind.DESCRIPTION); + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append(orReplace ? "CREATE OR REPLACE " : "CREATE ") + .append("SPATIAL REFERENCE SYSTEM "); + if (ifNotExists) { + builder.append("IF NOT EXISTS "); + } + builder.append(srid); + for (SpatialReferenceSystemAttribute attribute : attributes) { + attribute.appendTo(builder.append(' ')); + } + return builder; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/spatial/SpatialReferenceSystemAttribute.java b/src/main/java/net/sf/jsqlparser/statement/create/spatial/SpatialReferenceSystemAttribute.java new file mode 100644 index 0000000000..95002fedf9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/spatial/SpatialReferenceSystemAttribute.java @@ -0,0 +1,110 @@ +/*- + * #%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.spatial; + +import java.util.Objects; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; + +/** + * One attribute of MySQL's {@code CREATE SPATIAL REFERENCE SYSTEM}: {@code NAME 'srs_name'}, + * {@code DEFINITION 'definition'}, {@code ORGANIZATION 'org_name' IDENTIFIED BY org_id} or + * {@code DESCRIPTION 'description'}. + * + * @see CreateSpatialReferenceSystem + */ +public class SpatialReferenceSystemAttribute extends ASTNodeAccessImpl { + /** The keyword that starts the attribute. */ + public enum Kind { + NAME, DEFINITION, ORGANIZATION, DESCRIPTION + } + + private final Kind kind; + private StringValue value; + private Expression organizationId; + + /** + * A NAME, DEFINITION or DESCRIPTION attribute. + * + * @throws IllegalArgumentException for {@link Kind#ORGANIZATION}, which needs an identifier + */ + public SpatialReferenceSystemAttribute(Kind kind, StringValue value) { + this.kind = Objects.requireNonNull(kind, "kind"); + if (kind == Kind.ORGANIZATION) { + throw new IllegalArgumentException("ORGANIZATION requires IDENTIFIED BY"); + } + setValue(value); + } + + /** An {@code ORGANIZATION 'org_name' IDENTIFIED BY org_id} attribute. */ + public SpatialReferenceSystemAttribute(StringValue organization, Expression organizationId) { + this.kind = Kind.ORGANIZATION; + setValue(organization); + this.organizationId = Objects.requireNonNull(organizationId, "organizationId"); + } + + public Kind getKind() { + return kind; + } + + /** The string after the keyword; the organization name for {@link Kind#ORGANIZATION}. */ + public StringValue getValue() { + return value; + } + + public final void setValue(StringValue value) { + this.value = Objects.requireNonNull(value, "value"); + } + + public SpatialReferenceSystemAttribute withValue(StringValue value) { + setValue(value); + return this; + } + + /** + * The number after IDENTIFIED BY as written, a {@link net.sf.jsqlparser.expression.LongValue} + * or a {@link net.sf.jsqlparser.expression.HexValue}; null unless the attribute is an + * {@link Kind#ORGANIZATION}. + */ + public Expression getOrganizationId() { + return organizationId; + } + + /** + * Sets the number after IDENTIFIED BY. + * + * @throws IllegalArgumentException if the attribute is not an ORGANIZATION + */ + public void setOrganizationId(Expression organizationId) { + if (kind != Kind.ORGANIZATION) { + throw new IllegalArgumentException(kind + " takes no IDENTIFIED BY"); + } + this.organizationId = Objects.requireNonNull(organizationId, "organizationId"); + } + + public SpatialReferenceSystemAttribute withOrganizationId(Expression organizationId) { + setOrganizationId(organizationId); + return this; + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append(kind).append(' ').append(value); + if (organizationId != null) { + builder.append(" IDENTIFIED BY ").append(organizationId); + } + return builder; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/statistics/CreateStatistics.java b/src/main/java/net/sf/jsqlparser/statement/create/statistics/CreateStatistics.java new file mode 100644 index 0000000000..df966df81c --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/statistics/CreateStatistics.java @@ -0,0 +1,112 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2025 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create.statistics; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL extended statistics over columns and parenthesized expressions. */ +public class CreateStatistics extends ASTNodeAccessImpl implements Statement { + public enum Kind { + NDISTINCT, DEPENDENCIES, MCV + } + + private String name; + private boolean ifNotExists = false; + private List kinds = new ArrayList<>(); + private ExpressionList expressions = new ExpressionList<>(); + private Table table; + + public String getName() { + return name; + } + + public CreateStatistics setName(String name) { + this.name = name; + return this; + } + + public boolean isIfNotExists() { + return ifNotExists; + } + + public CreateStatistics setIfNotExists(boolean ifNotExists) { + this.ifNotExists = ifNotExists; + return this; + } + + public List getKinds() { + return kinds; + } + + public CreateStatistics setKinds(List kinds) { + this.kinds = kinds; + return this; + } + + public ExpressionList getExpressions() { + return expressions; + } + + public CreateStatistics setExpressions(ExpressionList expressions) { + this.expressions = expressions; + return this; + } + + public Table getTable() { + return table; + } + + public CreateStatistics setTable(Table table) { + this.table = table; + return this; + } + + public StringBuilder appendTo(StringBuilder sql, Consumer printer) { + sql.append("CREATE STATISTICS"); + if (ifNotExists) { + sql.append(" IF NOT EXISTS"); + } + if (name != null) { + sql.append(' ').append(name); + } + if (kinds != null && !kinds.isEmpty()) { + sql.append(" ("); + for (int i = 0; i < kinds.size(); i++) { + if (i > 0) { + sql.append(", "); + } + sql.append(kinds.get(i).name().toLowerCase(java.util.Locale.ROOT)); + } + sql.append(')'); + } + sql.append(" ON "); + printer.accept(expressions); + return sql.append(" FROM ").append(table); + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + return appendTo(sql, sql::append).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/subscription/CreateSubscription.java b/src/main/java/net/sf/jsqlparser/statement/create/subscription/CreateSubscription.java index 75d193e0e4..b67dda66c1 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/subscription/CreateSubscription.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/subscription/CreateSubscription.java @@ -14,10 +14,11 @@ import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -public class CreateSubscription implements Statement { +public class CreateSubscription extends ASTNodeAccessImpl implements Statement { private String name; private StringValue connection; private List publications = new ArrayList<>(); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/synonym/CreateSynonym.java b/src/main/java/net/sf/jsqlparser/statement/create/synonym/CreateSynonym.java index ac7eb2640b..9411ba577b 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/synonym/CreateSynonym.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/synonym/CreateSynonym.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.create.synonym; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Synonym; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; @@ -16,7 +17,7 @@ import java.util.ArrayList; import java.util.List; -public class CreateSynonym implements Statement { +public class CreateSynonym extends ASTNodeAccessImpl implements Statement { public Synonym synonym; private boolean orReplace; diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/CheckConstraint.java b/src/main/java/net/sf/jsqlparser/statement/create/table/CheckConstraint.java index a3047fb422..67a42ba16d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/CheckConstraint.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/CheckConstraint.java @@ -9,7 +9,6 @@ */ package net.sf.jsqlparser.statement.create.table; -import java.util.Collection; import java.util.List; import java.util.function.Consumer; @@ -22,10 +21,15 @@ public class CheckConstraint extends NamedConstraint { private Expression expression; - private Boolean enforced; + private boolean noInherit; public CheckConstraint() { - setKind(Kind.CHECK); + setType("CHECK"); + } + + @Override + public ConstraintKind getKind() { + return ConstraintKind.CHECK; } public Table getTable() { @@ -44,12 +48,34 @@ public void setExpression(Expression expression) { this.expression = expression; } + /** Whether PostgreSQL should keep this CHECK from being inherited by child tables. */ + public boolean isNoInherit() { + return noInherit; + } + + public void setNoInherit(boolean noInherit) { + this.noInherit = noInherit; + } + + public CheckConstraint withNoInherit(boolean noInherit) { + setNoInherit(noInherit); + return this; + } + public Boolean getEnforced() { - return enforced; + return getConstraintAttributes() == null ? null : getConstraintAttributes().getEnforced(); } public void setEnforced(Boolean enforced) { - this.enforced = enforced; + ConstraintAttributes attributes = getConstraintAttributes(); + if (attributes == null) { + if (enforced == null) { + return; + } + attributes = new ConstraintAttributes(); + setConstraintAttributes(attributes); + } + attributes.setEnforced(enforced); } @Override @@ -62,8 +88,8 @@ public void appendTo(StringBuilder b, Consumer expressionPrinter) { expressionPrinter.accept(expression); } b.append(')'); - if (enforced != null) { - b.append(enforced ? " ENFORCED" : " NOT ENFORCED"); + if (noInherit) { + b.append(" NO INHERIT"); } appendConstraintSuffixTo(b); appendConstraintAttributesTo(b); @@ -93,11 +119,6 @@ public CheckConstraint withType(String type) { return (CheckConstraint) super.withType(type); } - @Override - public CheckConstraint withUsing(String using) { - return (CheckConstraint) super.withUsing(using); - } - @Override public CheckConstraint withUseConstraintKeyword(boolean useConstraintKeyword) { return (CheckConstraint) super.withUseConstraintKeyword(useConstraintKeyword); @@ -113,33 +134,4 @@ public CheckConstraint withName(String name) { return (CheckConstraint) super.withName(name); } - @Override - public CheckConstraint withColumnsNames(List list) { - return (CheckConstraint) super.withColumnsNames(list); - } - - @Override - public CheckConstraint withColumns(List columns) { - return (CheckConstraint) super.withColumns(columns); - } - - @Override - public CheckConstraint addColumns(ColumnParams... functionDeclarationParts) { - return (CheckConstraint) super.addColumns(functionDeclarationParts); - } - - @Override - public CheckConstraint addColumns(Collection functionDeclarationParts) { - return (CheckConstraint) super.addColumns(functionDeclarationParts); - } - - @Override - public CheckConstraint withIndexSpec(List idxSpec) { - return (CheckConstraint) super.withIndexSpec(idxSpec); - } - - @Override - public CheckConstraint withIndexKeyword(String indexKeyword) { - return (CheckConstraint) super.withIndexKeyword(indexKeyword); - } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ColDataType.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ColDataType.java index cc82907fe4..ff90bf875d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ColDataType.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ColDataType.java @@ -10,9 +10,9 @@ package net.sf.jsqlparser.statement.create.table; import net.sf.jsqlparser.expression.IntervalQualifier; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.select.PlainSelect; -import java.io.Serializable; import java.math.BigInteger; import java.util.ArrayList; import java.util.Collection; @@ -23,7 +23,7 @@ import static java.util.stream.Collectors.joining; -public class ColDataType implements Serializable { +public class ColDataType extends ASTNodeAccessImpl { public enum Signedness { SIGNED, UNSIGNED @@ -37,12 +37,28 @@ public enum NationalCharacterType { CHAR, VARCHAR } + /** Spelling of a character set clause; MySQL shorthands also select a character set. */ + public enum CharacterSetSyntax { + CHARACTER_SET, CHARSET, ASCII, UNICODE + } + private String dataType; private List argumentsStringList; private String characterSet; - private boolean useCharsetKeyword; + private CharacterSetSyntax characterSetSyntax = CharacterSetSyntax.CHARACTER_SET; private IntervalQualifier intervalQualifier; private List arrayData = new ArrayList(); + private boolean usingArrayKeyword; + + /** ARRAY or ARRAY[n] spelling; arrayData still contains the single dimension. */ + public boolean isUsingArrayKeyword() { + return usingArrayKeyword; + } + + public void setUsingArrayKeyword(boolean usingArrayKeyword) { + this.usingArrayKeyword = usingArrayKeyword; + } + private Signedness signedness; private boolean zerofill; private BigInteger precision; @@ -87,9 +103,10 @@ public static ColDataType fromTypeParameters(String dataType, String precision, private void setNumericTypeParameters(String parameter, Integer scale) { if (parameter != null) { maxPrecision = "MAX".equalsIgnoreCase(parameter); - precision = maxPrecision ? null : new BigInteger(parameter); + // Oracle's NUMBER(*, s) has no precision of its own. + precision = maxPrecision || "*".equals(parameter) ? null : new BigInteger(parameter); this.scale = scale; - dataType += " (" + (maxPrecision ? "MAX" : precision) + dataType += " (" + (maxPrecision ? "MAX" : precision != null ? precision : parameter) + (scale != null ? ", " + scale : "") + ")"; } } @@ -166,21 +183,51 @@ public void setDataType(List list) { dataType = list.stream().collect(joining(".")); } + /** Returns the character set name, resolving ASCII to latin1 and UNICODE to ucs2. */ public String getCharacterSet() { return characterSet; } public void setCharacterSet(String characterSet) { this.characterSet = characterSet; + if (characterSetSyntax == CharacterSetSyntax.ASCII + || characterSetSyntax == CharacterSetSyntax.UNICODE) { + characterSetSyntax = CharacterSetSyntax.CHARACTER_SET; + } + } + + public CharacterSetSyntax getCharacterSetSyntax() { + return characterSetSyntax; + } + + /** + * Selects the clause spelling. ASCII selects latin1 and UNICODE selects ucs2; the explicit + * spellings retain the current character set. Calling {@link #setCharacterSet(String)} after a + * shorthand switches to CHARACTER SET. + */ + public void setCharacterSetSyntax(CharacterSetSyntax characterSetSyntax) { + this.characterSetSyntax = Objects.requireNonNull(characterSetSyntax, "characterSetSyntax"); + if (characterSetSyntax == CharacterSetSyntax.ASCII) { + characterSet = "latin1"; + } else if (characterSetSyntax == CharacterSetSyntax.UNICODE) { + characterSet = "ucs2"; + } + } + + public ColDataType withCharacterSetSyntax(CharacterSetSyntax characterSetSyntax) { + setCharacterSetSyntax(characterSetSyntax); + return this; } /** Whether the character set clause uses MySQL's CHARSET abbreviation. */ public boolean isUseCharsetKeyword() { - return useCharsetKeyword; + return characterSetSyntax == CharacterSetSyntax.CHARSET; } public void setUseCharsetKeyword(boolean useCharsetKeyword) { - this.useCharsetKeyword = useCharsetKeyword; + setCharacterSetSyntax(useCharsetKeyword + ? CharacterSetSyntax.CHARSET + : CharacterSetSyntax.CHARACTER_SET); } public IntervalQualifier getIntervalQualifier() { @@ -284,9 +331,10 @@ public ColDataType withXmlTypeModifier(XmlTypeModifier xmlTypeModifier) { * The first numeric type parameter, e.g. {@code 255} for {@code VARCHAR(255)} or {@code 10} for * {@code DECIMAL(10, 2)}. {@code MAX} is reported as {@link Integer#MAX_VALUE}. Returns * {@code null} when the type carries no numeric parameters, e.g. {@code INT} or - * {@code ENUM('a', 'b')}, or when a numeric length exceeds the integer range. Use - * {@link #getNumericPrecision()} for the full range and {@link #isMaxPrecision()} to - * distinguish MAX from the numeric value 2147483647. + * {@code ENUM('a', 'b')}, when the precision is Oracle's {@code *} as in {@code NUMBER(*, 0)}, + * or when a numeric length exceeds the integer range. Use {@link #getNumericPrecision()} for + * the full range and {@link #isMaxPrecision()} to distinguish MAX from the numeric value + * 2147483647. */ public Integer getPrecision() { return maxPrecision ? Integer.valueOf(Integer.MAX_VALUE) @@ -330,7 +378,13 @@ public void setScale(Integer scale) { @Override public String toString() { StringBuilder arraySpec = new StringBuilder(); + if (usingArrayKeyword && !arrayData.isEmpty()) { + arraySpec.append(" ARRAY"); + } for (Integer item : arrayData) { + if (usingArrayKeyword && item == null) { + continue; + } arraySpec.append("["); if (item != null) { arraySpec.append(item); @@ -348,9 +402,22 @@ public String toString() { : (signedness != null ? " " + signedness : "") + (zerofill ? " ZEROFILL" : "")) + arraySpec.toString() - + (characterSet != null - ? (useCharsetKeyword ? " CHARSET " : " CHARACTER SET ") + characterSet - : ""); + + characterSetClause(); + } + + private String characterSetClause() { + if (characterSet == null) { + return ""; + } + switch (characterSetSyntax) { + case ASCII: + case UNICODE: + return " " + characterSetSyntax; + case CHARSET: + return " CHARSET " + characterSet; + default: + return " CHARACTER SET " + characterSet; + } } public ColDataType withDataType(String dataType) { @@ -447,9 +514,10 @@ public final boolean equals(Object o) { return dataType.equalsIgnoreCase(that.dataType) && Objects.equals(argumentsStringList, that.argumentsStringList) && Objects.equals(characterSet, that.characterSet) - && useCharsetKeyword == that.useCharsetKeyword + && characterSetSyntax == that.characterSetSyntax && Objects.equals(intervalQualifier, that.intervalQualifier) && Objects.equals(arrayData, that.arrayData) + && usingArrayKeyword == that.usingArrayKeyword && signedness == that.signedness && zerofill == that.zerofill && Objects.equals(typeModifiers, that.typeModifiers) @@ -465,9 +533,10 @@ public int hashCode() { .reduce(0, (hash, c) -> 31 * hash + c); result = 31 * result + Objects.hashCode(argumentsStringList); result = 31 * result + Objects.hashCode(characterSet); - result = 31 * result + Boolean.hashCode(useCharsetKeyword); + result = 31 * result + Objects.hashCode(characterSetSyntax); result = 31 * result + Objects.hashCode(intervalQualifier); result = 31 * result + Objects.hashCode(arrayData); + result = 31 * result + Boolean.hashCode(usingArrayKeyword); result = 31 * result + Objects.hashCode(signedness); result = 31 * result + Boolean.hashCode(zerofill); result = 31 * result + Objects.hashCode(typeModifiers); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java index ccede4eb84..bf3d26f583 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnDefinition.java @@ -10,7 +10,6 @@ package net.sf.jsqlparser.statement.create.table; import net.sf.jsqlparser.statement.imprt.ImportColumn; -import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.expression.Expression; import java.io.Serializable; @@ -19,7 +18,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -import java.util.Optional; +import java.util.Objects; import java.util.function.Consumer; /** @@ -29,7 +28,6 @@ public class ColumnDefinition implements ImportColumn, TableElement, Serializabl private String columnName; private ColDataType colDataType; - private List columnSpecs; private List columnOptions; private boolean withOptions; @@ -50,13 +48,14 @@ public ColumnDefinition(String columnName, ColDataType colDataType) { public ColumnDefinition(String columnName, ColDataType colDataType, List columnSpecs) { this(columnName, colDataType); - this.columnSpecs = columnSpecs; + columnOptions = rawOptions(columnSpecs); } /** - * Returns raw specifications, or a token snapshot when structured options are present. Use the - * option API or {@link #addColumnSpecs(Collection)} to append without discarding structured - * expressions, references and constraints. DEFAULT values use the expression's SQL rendering. + * Returns an unmodifiable token snapshot for both raw and structured options, or null when + * options are unset. Use {@link #getColumnOptions()} to edit the nodes, or + * {@link #addColumnSpecs(Collection)} to append without discarding structured expressions, + * references and constraints. DEFAULT values use the expression's SQL rendering. */ public List getColumnSpecs() { if (columnOptions != null) { @@ -64,28 +63,39 @@ public List getColumnSpecs() { for (ColumnOption option : columnOptions) { tokens.addAll(option.getTokens()); } - return tokens; + return Collections.unmodifiableList(tokens); } - return columnSpecs; + return null; } + /** + * Replaces every option with opaque tokens, without parsing them. The supplied list is copied; + * null clears the options, while an empty list stores an explicitly empty option list. + */ public void setColumnSpecs(List list) { - columnSpecs = list; - columnOptions = null; + columnOptions = rawOptions(list); + } + + private static List rawOptions(List list) { + List options = list == null ? null : new ArrayList<>(); + if (list != null && !list.isEmpty()) { + options.add(ColumnOption.raw(new ArrayList<>(list))); + } + return options; } /** - * Returns column options in source order, including defaults, references, generated columns, - * nullability, collation, comments, visibility and MySQL attributes. Unrecognized options - * remain raw. Structured option keywords use canonical capitalization when rendered. + * Returns the mutable option list in source order, or null when options are unset. Opaque + * specifications are included as {@link ColumnOption.Kind#OTHER} nodes. Structured option + * keywords use canonical capitalization when rendered. */ public List getColumnOptions() { return columnOptions; } + /** Copies the list membership while retaining the supplied mutable option nodes. */ public void setColumnOptions(List columnOptions) { - this.columnOptions = columnOptions; - this.columnSpecs = null; + this.columnOptions = columnOptions == null ? null : new ArrayList<>(columnOptions); } public boolean isSerialDefaultValue() { @@ -110,13 +120,12 @@ public ColumnDefinition withColumnOptions(List columnOptions) { } public ColumnDefinition addColumnOptions(ColumnOption... columnOptions) { - List collection = - Optional.ofNullable(getColumnOptions()).orElseGet(ArrayList::new); - if (this.columnOptions == null && columnSpecs != null && !columnSpecs.isEmpty()) { - collection.add(ColumnOption.raw(new ArrayList<>(columnSpecs))); + Objects.requireNonNull(columnOptions, "columnOptions"); + if (this.columnOptions == null) { + this.columnOptions = new ArrayList<>(); } - Collections.addAll(collection, columnOptions); - return withColumnOptions(collection); + Collections.addAll(this.columnOptions, columnOptions); + return this; } public ColDataType getColDataType() { @@ -170,8 +179,6 @@ protected void appendDataTypeAndSpecTo(StringBuilder builder, builder.append(' '); option.appendTo(builder, expressionPrinter); } - } else if (columnSpecs != null && !columnSpecs.isEmpty()) { - builder.append(' ').append(PlainSelect.getStringList(columnSpecs, false, false)); } } @@ -194,15 +201,15 @@ public ColumnDefinition addColumnSpecs(String... columnSpecs) { return addColumnSpecs(Arrays.asList(columnSpecs)); } + /** Appends copied opaque tokens after the existing nodes, preserving their structure. */ public ColumnDefinition addColumnSpecs(Collection columnSpecs) { - if (columnOptions != null) { - if (!columnSpecs.isEmpty()) { - columnOptions.add(ColumnOption.raw(new ArrayList<>(columnSpecs))); - } - return this; + Objects.requireNonNull(columnSpecs, "columnSpecs"); + if (columnOptions == null) { + columnOptions = new ArrayList<>(); } - List collection = Optional.ofNullable(getColumnSpecs()).orElseGet(ArrayList::new); - collection.addAll(columnSpecs); - return this.withColumnSpecs(collection); + if (!columnSpecs.isEmpty()) { + columnOptions.add(ColumnOption.raw(new ArrayList<>(columnSpecs))); + } + return this; } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnOption.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnOption.java index 23f2ef91f3..f0e7fec94f 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnOption.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ColumnOption.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.statement.create.table; import java.io.Serializable; +import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -23,14 +24,157 @@ public class ColumnOption implements Serializable { public enum Kind { - SERIAL_DEFAULT_VALUE, REFERENCE, IDENTITY, CONSTRAINT, DEFAULT, NULLABILITY, COLLATE, COMMENT, ON_UPDATE, GENERATED, AUTO_INCREMENT, VISIBILITY, OTHER + SERIAL_DEFAULT_VALUE, REFERENCE, IDENTITY, CONSTRAINT, DEFAULT, NULLABILITY, COLLATE, COMMENT, ON_UPDATE, GENERATED, AUTO_INCREMENT, VISIBILITY, STORAGE, COMPRESSION, FOREIGN_OPTIONS, SRID, COLUMN_FORMAT, ENGINE_ATTRIBUTE, SECONDARY_ENGINE_ATTRIBUTE, OTHER + } + + /** PostgreSQL storage strategies and MySQL column storage locations. */ + public enum Storage { + PLAIN, EXTERNAL, EXTENDED, MAIN, DEFAULT, DISK, MEMORY + } + + /** MySQL {@code COLUMN_FORMAT} values. */ + public enum ColumnFormat { + FIXED, DYNAMIC, DEFAULT + } + + /** + * Inline key spellings whose legacy tokens are split on spaces. KEY is MySQL's column-level + * synonym for PRIMARY KEY. + */ + private static final List KEY_SPELLINGS = + Arrays.asList("PRIMARY KEY", "UNIQUE KEY", "KEY"); + + private List foreignOptions; + private Long srid; + private ColumnFormat columnFormat; + private StringValue engineAttribute; + private boolean useEquals; + + public List getForeignOptions() { + return foreignOptions; + } + + public void setForeignOptions(List options) { + foreignOptions = options; + kind = Kind.FOREIGN_OPTIONS; + tokens = null; + } + + public static ColumnOption foreignOptions(List options) { + ColumnOption option = new ColumnOption(); + option.setForeignOptions(options); + return option; + } + + private Storage storage; + private String compression; + + public static ColumnOption storage(Storage storage) { + ColumnOption option = new ColumnOption(); + option.kind = Kind.STORAGE; + option.setStorage(storage); + return option; + } + + public Storage getStorage() { + return storage; + } + + public void setStorage(Storage storage) { + this.storage = Objects.requireNonNull(storage, "storage"); + } + + public static ColumnOption compression(String compression) { + ColumnOption option = new ColumnOption(); + option.kind = Kind.COMPRESSION; + option.setCompression(compression); + return option; + } + + public String getCompression() { + return compression; + } + + public void setCompression(String compression) { + this.compression = Objects.requireNonNull(compression, "compression"); + } + + /** Creates a MySQL {@code SRID} option for a spatial column. */ + public static ColumnOption srid(long srid) { + ColumnOption option = new ColumnOption(); + option.kind = Kind.SRID; + option.setSrid(srid); + return option; + } + + /** Returns the spatial reference system identifier of an SRID option, or null. */ + public Long getSrid() { + return srid; + } + + public void setSrid(long srid) { + this.srid = srid; + } + + /** Creates a MySQL {@code COLUMN_FORMAT} option. */ + public static ColumnOption columnFormat(ColumnFormat columnFormat) { + ColumnOption option = new ColumnOption(); + option.kind = Kind.COLUMN_FORMAT; + option.setColumnFormat(columnFormat); + return option; + } + + public ColumnFormat getColumnFormat() { + return columnFormat; + } + + public void setColumnFormat(ColumnFormat columnFormat) { + this.columnFormat = Objects.requireNonNull(columnFormat, "columnFormat"); + } + + /** Creates a MySQL {@code ENGINE_ATTRIBUTE} option with a JSON string literal. */ + public static ColumnOption engineAttribute(StringValue attribute) { + ColumnOption option = new ColumnOption(); + option.kind = Kind.ENGINE_ATTRIBUTE; + option.setEngineAttribute(attribute); + return option; + } + + /** Creates a MySQL {@code SECONDARY_ENGINE_ATTRIBUTE} option with a JSON string literal. */ + public static ColumnOption secondaryEngineAttribute(StringValue attribute) { + ColumnOption option = new ColumnOption(); + option.kind = Kind.SECONDARY_ENGINE_ATTRIBUTE; + option.setEngineAttribute(attribute); + return option; + } + + /** Returns the literal of an ENGINE_ATTRIBUTE or SECONDARY_ENGINE_ATTRIBUTE option, or null. */ + public StringValue getEngineAttribute() { + return engineAttribute; + } + + public void setEngineAttribute(StringValue attribute) { + engineAttribute = Objects.requireNonNull(attribute, "attribute"); + } + + /** Whether an engine attribute is written with the optional equals sign. */ + public boolean isUseEquals() { + return useEquals; + } + + public void setUseEquals(boolean useEquals) { + this.useEquals = useEquals; + } + + private boolean isEngineAttribute() { + return kind == Kind.ENGINE_ATTRIBUTE || kind == Kind.SECONDARY_ENGINE_ATTRIBUTE; } private Kind kind = Kind.OTHER; private List tokens; private ForeignKeyReference foreignKeyReference; private IdentityDefinition identityDefinition; - private Index constraint; + private NamedConstraint constraint; private Expression defaultExpression; private Boolean nullable; private Boolean visible; @@ -135,12 +279,16 @@ public void setGeneratedDefinition(GeneratedColumnDefinition definition) { generatedDefinition = Objects.requireNonNull(definition, "definition"); } - /** Visits expressions of the selected option kind, including comment literals. */ + /** Visits expressions of the selected option kind, including comment and attribute literals. */ public void visitExpressions(Consumer visitor) { - if (kind == Kind.DEFAULT) { + if (kind == Kind.FOREIGN_OPTIONS) { + ForeignDataOption.visitExpressions(foreignOptions, visitor); + } else if (kind == Kind.DEFAULT) { visitor.accept(defaultExpression); } else if (kind == Kind.COMMENT) { visitor.accept(comment); + } else if (isEngineAttribute()) { + visitor.accept(engineAttribute); } else if (kind == Kind.ON_UPDATE) { visitor.accept(onUpdateExpression); } else if (kind == Kind.GENERATED) { @@ -148,7 +296,6 @@ public void visitExpressions(Consumer visitor) { } } - /** Creates a DEFAULT option. Use a NullValue expression for SQL NULL. */ public static ColumnOption defaultValue(Expression expression) { ColumnOption option = new ColumnOption(); @@ -173,7 +320,7 @@ public static ColumnOption identity(IdentityDefinition definition) { return option; } - public static ColumnOption constraint(Index constraint) { + public static ColumnOption constraint(NamedConstraint constraint) { ColumnOption option = new ColumnOption(); option.kind = Kind.CONSTRAINT; option.constraint = constraint; @@ -184,13 +331,36 @@ public IdentityDefinition getIdentityDefinition() { return identityDefinition; } - public Index getConstraint() { + public NamedConstraint getConstraint() { return constraint; } + /** + * Returns the constraint kind explicitly represented by this option, including REFERENCES and + * NOT NULL. Ordinary DEFAULT options remain column options; an explicit DefaultConstraint node + * has kind DEFAULT. Returns OTHER for NULL, unrelated or raw options. No implicit constraints, + * such as NOT NULL implied by a primary key, or catalogue objects are inferred. + */ + public ConstraintKind getConstraintKind() { + switch (kind) { + case CONSTRAINT: + return constraint != null && constraint.getKind() != null ? constraint.getKind() + : ConstraintKind.OTHER; + case REFERENCE: + return foreignKeyReference == null ? ConstraintKind.OTHER + : ConstraintKind.FOREIGN_KEY; + case NULLABILITY: + return Boolean.FALSE.equals(nullable) ? ConstraintKind.NOT_NULL + : ConstraintKind.OTHER; + default: + return ConstraintKind.OTHER; + } + } + + /** Creates an opaque option with its own copy of the supplied tokens, without parsing them. */ public static ColumnOption raw(List tokens) { ColumnOption option = new ColumnOption(); - option.tokens = tokens; + option.setTokens(tokens); return option; } @@ -215,33 +385,75 @@ public Kind getKind() { return kind; } + /** + * Returns an unmodifiable, detached token snapshot for both raw and structured options. An + * unset raw option returns null; an explicitly empty raw option returns an empty snapshot. Use + * {@link #setTokens(List)} to edit an opaque option, or the typed setters and mutable child + * nodes to edit structured options. Later changes to the option do not change this snapshot. + */ public List getTokens() { switch (kind) { case DEFAULT: - return Arrays.asList("DEFAULT", String.valueOf(defaultExpression)); + return Collections.unmodifiableList( + Arrays.asList("DEFAULT", String.valueOf(defaultExpression))); case NULLABILITY: - return nullable ? Collections.singletonList("NULL") : Arrays.asList("NOT", "NULL"); + return nullable ? Collections.singletonList("NULL") + : Collections.unmodifiableList(Arrays.asList("NOT", "NULL")); case COLLATE: - return Arrays.asList("COLLATE", collation); + return Collections.unmodifiableList(Arrays.asList("COLLATE", collation)); case COMMENT: - return Arrays.asList("COMMENT", comment.toString()); + return Collections.unmodifiableList(Arrays.asList("COMMENT", comment.toString())); case ON_UPDATE: - return Arrays.asList("ON", "UPDATE", onUpdateExpression.toString()); + return Collections.unmodifiableList( + Arrays.asList("ON", "UPDATE", onUpdateExpression.toString())); case GENERATED: return generatedDefinition.getTokens(); case CONSTRAINT: - if ("PRIMARY KEY".equals(constraint.toString())) { - return Arrays.asList("PRIMARY", "KEY"); - } - return Collections.singletonList(toString()); + return constraintTokens(); + case SRID: + return Collections.unmodifiableList(Arrays.asList("SRID", String.valueOf(srid))); + case COLUMN_FORMAT: + return Collections.unmodifiableList( + Arrays.asList("COLUMN_FORMAT", columnFormat.name())); + case ENGINE_ATTRIBUTE: + case SECONDARY_ENGINE_ATTRIBUTE: + return Collections.unmodifiableList(useEquals + ? Arrays.asList(kind.name(), "=", engineAttribute.toString()) + : Arrays.asList(kind.name(), engineAttribute.toString())); case OTHER: case SERIAL_DEFAULT_VALUE: - return tokens; + return tokens == null ? null + : Collections.unmodifiableList(new ArrayList<>(tokens)); default: return Collections.singletonList(toString()); } } + private List constraintTokens() { + String sql = constraint.toString(); + if (KEY_SPELLINGS.contains(sql)) { + return Collections.unmodifiableList(Arrays.asList(sql.split(" "))); + } + return Collections.singletonList(sql); + } + + /** + * Replaces the tokens of an opaque {@link Kind#OTHER} option with a copy of the supplied list. + * Null unsets the tokens; an empty list retains an explicitly empty option. Tokens are never + * parsed or classified. To replace a structured option, including SERIAL DEFAULT VALUE, with + * raw text, replace its node in {@link ColumnDefinition#getColumnOptions()} using + * {@link #raw(List)} instead. + * + * @throws IllegalStateException if this is a structured option + */ + public void setTokens(List tokens) { + if (kind != Kind.OTHER) { + throw new IllegalStateException( + "Only opaque options accept tokens; use typed setters or replace the option"); + } + this.tokens = tokens == null ? null : new ArrayList<>(tokens); + } + public ForeignKeyReference getForeignKeyReference() { return foreignKeyReference; } @@ -256,6 +468,26 @@ public String toString() { /** Appends the option using the supplied printer for structured expressions. */ public void appendTo(StringBuilder builder, Consumer expressionPrinter) { switch (kind) { + case FOREIGN_OPTIONS: + ForeignDataOption.appendOptionsTo(builder, foreignOptions, expressionPrinter); + break; + case STORAGE: + builder.append("STORAGE ").append(storage); + break; + case COMPRESSION: + builder.append("COMPRESSION ").append(compression); + break; + case SRID: + builder.append("SRID ").append(srid); + break; + case COLUMN_FORMAT: + builder.append("COLUMN_FORMAT ").append(columnFormat); + break; + case ENGINE_ATTRIBUTE: + case SECONDARY_ENGINE_ATTRIBUTE: + builder.append(kind).append(useEquals ? " = " : " "); + expressionPrinter.accept(engineAttribute); + break; case DEFAULT: builder.append("DEFAULT "); expressionPrinter.accept(defaultExpression); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintAttributes.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintAttributes.java index ca063d6033..7f8b68bd02 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintAttributes.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintAttributes.java @@ -20,6 +20,7 @@ public enum Initially { private Boolean deferrable; private Initially initially; private boolean notValid; + private Boolean enforced; public Boolean getDeferrable() { return deferrable; @@ -45,6 +46,15 @@ public void setNotValid(boolean notValid) { this.notValid = notValid; } + /** Null preserves an omitted ENFORCED clause. */ + public Boolean getEnforced() { + return enforced; + } + + public void setEnforced(Boolean enforced) { + this.enforced = enforced; + } + public void appendTo(StringBuilder sql) { if (deferrable != null) { sql.append(deferrable ? " DEFERRABLE" : " NOT DEFERRABLE"); @@ -52,6 +62,9 @@ public void appendTo(StringBuilder sql) { if (initially != null) { sql.append(" INITIALLY ").append(initially); } + if (enforced != null) { + sql.append(enforced ? " ENFORCED" : " NOT ENFORCED"); + } if (notValid) { sql.append(" NOT VALID"); } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintDeclaration.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintDeclaration.java new file mode 100644 index 0000000000..b76ccf3a4d --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintDeclaration.java @@ -0,0 +1,64 @@ +/*- + * #%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; + +/** + * A view of a constraint declared in a CREATE TABLE definition. Its source nodes remain editable; + * no constraint data is copied. A column declaration retains its owning column rather than + * manufacturing a table constraint or a key-column list. + * + * @see CreateTable#getConstraints() + */ +public final class ConstraintDeclaration { + private final ColumnDefinition column; + private final ColumnOption columnOption; + private final NamedConstraint constraint; + + ConstraintDeclaration(ColumnDefinition column, ColumnOption columnOption) { + this.column = column; + this.columnOption = columnOption; + this.constraint = null; + } + + ConstraintDeclaration(NamedConstraint constraint) { + this.column = null; + this.columnOption = null; + this.constraint = constraint; + } + + /** + * Returns the current kind, or OTHER if it is unknown or an option no longer declares a + * constraint. + */ + public ConstraintKind getKind() { + if (columnOption != null) { + return columnOption.getConstraintKind(); + } + return constraint.getKind() != null ? constraint.getKind() : ConstraintKind.OTHER; + } + + /** Returns the original owning column, or null for a table-level declaration. */ + public ColumnDefinition getColumn() { + return column; + } + + /** Returns the original column option, or null for a table-level declaration. */ + public ColumnOption getColumnOption() { + return columnOption; + } + + /** + * Returns the original constraint node, including a column's nested constraint. REFERENCES and + * nullability column options have no NamedConstraint node; use getColumnOption() for them. + */ + public NamedConstraint getConstraint() { + return columnOption == null ? constraint : columnOption.getConstraint(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintKind.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintKind.java new file mode 100644 index 0000000000..1ea9e55052 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintKind.java @@ -0,0 +1,40 @@ +/*- + * #%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; + +/** The kind of a declared table or column constraint, independent of its supporting index. */ +public enum ConstraintKind { + PRIMARY_KEY, UNIQUE, FOREIGN_KEY, CHECK, EXCLUDE, DEFAULT, NOT_NULL, OTHER; + + public static ConstraintKind fromType(String type) { + if (type == null) { + return OTHER; + } + String normalized = type.trim().toUpperCase(java.util.Locale.ROOT); + switch (normalized.split("\\s+", 2)[0]) { + case "PRIMARY": + return PRIMARY_KEY; + case "UNIQUE": + return UNIQUE; + case "FOREIGN": + return FOREIGN_KEY; + case "CHECK": + return CHECK; + case "EXCLUDE": + return EXCLUDE; + case "DEFAULT": + return DEFAULT; + case "NOT": + return "NOT NULL".equals(normalized) ? NOT_NULL : OTHER; + default: + return OTHER; + } + } +} 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/statement/create/table/CreateTable.java b/src/main/java/net/sf/jsqlparser/statement/create/table/CreateTable.java index 643ce8bc41..d9e9a60295 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/CreateTable.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/CreateTable.java @@ -16,6 +16,7 @@ import java.util.Optional; import net.sf.jsqlparser.expression.SpannerInterleaveIn; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.LikeClause; @@ -23,8 +24,10 @@ import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.Select; -public class CreateTable implements Statement { +public class CreateTable extends ASTNodeAccessImpl implements Statement { + private boolean tableOptionsAfterPartition; + private net.sf.jsqlparser.statement.execute.Execute execute; private Table table; private boolean unlogged = false; private List createOptionsStrings; @@ -33,13 +36,17 @@ public class CreateTable implements Statement { private List columnDefinitions; private List columns; private List indexes; + private List tableConstraints; private List tableElements; private Select select; + private DuplicateHandling duplicateHandling; private Table likeTable; private Table cloneTable; + private List

inherits; private ColDataType ofType; private boolean selectParenthesis; private boolean useAsKeyword = true; + private Boolean withData; private boolean ifNotExists = false; private boolean orReplace = false; private TablePartitioning partitioning; @@ -50,6 +57,50 @@ public class CreateTable implements Statement { private SpannerInterleaveIn interleaveIn = null; + public enum DuplicateHandling { + IGNORE, REPLACE + } + + public boolean isTableOptionsAfterPartition() { + return tableOptionsAfterPartition; + } + + public void setTableOptionsAfterPartition(boolean tableOptionsAfterPartition) { + this.tableOptionsAfterPartition = tableOptionsAfterPartition; + } + + /** Prepared statement source of PostgreSQL CREATE TABLE AS EXECUTE. */ + public net.sf.jsqlparser.statement.execute.Execute getExecute() { + return execute; + } + + public void setExecute(net.sf.jsqlparser.statement.execute.Execute execute) { + this.execute = execute; + select = null; + selectParenthesis = false; + } + + /** The structured SERVER clause, also present in the shared table-options list. */ + public ForeignTableOptions getForeignTableOptions() { + if (tableOptions != null) { + for (TableOption option : tableOptions) { + if (option.getForeignTableOptions() != null) { + return option.getForeignTableOptions(); + } + } + } + return null; + } + + /** MySQL's duplicate-key handling when creating a table from a query; null if omitted. */ + public DuplicateHandling getDuplicateHandling() { + return duplicateHandling; + } + + public void setDuplicateHandling(DuplicateHandling duplicateHandling) { + this.duplicateHandling = duplicateHandling; + } + @Override public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); @@ -143,15 +194,60 @@ public void setCreateOptionsStrings(List createOptionsStrings) { } /** - * @return a list of {@link Index}es (for example "PRIMARY KEY") of this table.
- * Indexes created with column definitions (as in mycol INT PRIMARY KEY) are not - * inserted into this list. When ordered table elements are present, this is a mutable - * view of their indexes. + * Returns index declarations only. Table constraints are available through + * {@link #getTableConstraints()}. When ordered table elements are present, this is a mutable + * view of their indexes. */ public List getIndexes() { return indexes; } + /** + * Returns column and table constraint declarations in source order, including MySQL UNIQUE + * KEY/INDEX declarations, REFERENCES and explicit NOT NULL options. Ordinary DEFAULT column + * options are not classified as constraints; explicit {@link DefaultConstraint} nodes are. + * Index declarations, raw options, and constraints inherited from LIKE, a type or another table + * are not inferred. + * + * The list is an unmodifiable membership snapshot. Each view reads its original editable AST + * nodes; call this method again after inserting or removing declarations or changing a + * nullability option between NULL and NOT NULL. Typed constraint nodes remain included even + * when their kind is OTHER. For legacy construction without ordered table elements, columns + * precede table constraints. + */ + public List getConstraints() { + List declarations = new ArrayList<>(); + if (tableElements != null) { + tableElements.forEach(element -> addConstraints(element, declarations)); + } else { + if (columnDefinitions != null) { + columnDefinitions.forEach(column -> addConstraints(column, declarations)); + } + if (tableConstraints != null) { + tableConstraints.forEach(constraint -> addConstraints(constraint, declarations)); + } + } + return Collections.unmodifiableList(declarations); + } + + private static void addConstraints(TableElement element, + List declarations) { + if (element instanceof ColumnDefinition) { + ColumnDefinition column = (ColumnDefinition) element; + if (column.getColumnOptions() != null) { + for (ColumnOption option : column.getColumnOptions()) { + if (option.getKind() == ColumnOption.Kind.CONSTRAINT + && option.getConstraint() != null + || option.getConstraintKind() != ConstraintKind.OTHER) { + declarations.add(new ConstraintDeclaration(column, option)); + } + } + } + } else if (element instanceof NamedConstraint) { + declarations.add(new ConstraintDeclaration((NamedConstraint) element)); + } + } + public void setIndexes(List list) { if (tableElements == null) { indexes = list; @@ -160,6 +256,23 @@ public void setIndexes(List list) { } } + /** + * Returns table-level constraint definitions, excluding constraints declared within columns. + * When ordered table elements are present, this is a mutable view of their constraints. Use + * {@link #getConstraints()} to inspect both column and table declarations. + */ + public List getTableConstraints() { + return tableConstraints; + } + + public void setTableConstraints(List constraints) { + if (tableElements == null) { + tableConstraints = constraints; + } else { + TableElementList.replace(tableElements, NamedConstraint.class, constraints); + } + } + /** * Returns columns, constraints, and indexes in the order in which they were declared. */ @@ -172,10 +285,12 @@ public void setTableElements(List tableElements) { if (tableElements == null) { columnDefinitions = null; indexes = null; + tableConstraints = null; return; } columnDefinitions = new TableElementList<>(tableElements, ColumnDefinition.class); indexes = new TableElementList<>(tableElements, Index.class); + tableConstraints = new TableElementList<>(tableElements, NamedConstraint.class); } /** Returns table elements of a requested AST type while preserving their declaration order. */ @@ -204,23 +319,49 @@ public void setUseAsKeyword(boolean useAsKeyword) { this.useAsKeyword = useAsKeyword; } + /** Returns null for omission, true for WITH DATA, and false for WITH NO DATA. */ + public Boolean getWithData() { + return withData; + } + + public void setWithData(Boolean withData) { + this.withData = withData; + } + public StringBuilder appendSelectTo(StringBuilder builder, java.util.function.Consumer selectRenderer, + java.util.function.Consumer executeRenderer) { + if (select != null || execute != null) { + if (duplicateHandling != null) { + builder.append(' ').append(duplicateHandling); + } builder.append(useAsKeyword ? " AS " : " "); if (selectParenthesis) { builder.append("("); } - selectRenderer.accept(select); + if (execute != null) { + executeRenderer.accept(execute); + } else { + selectRenderer.accept(select); + } if (selectParenthesis) { builder.append(")"); } + if (withData != null) { + builder.append(withData ? " WITH DATA" : " WITH NO DATA"); + } } return builder; } public void setSelect(Select select, boolean parenthesis) { this.select = select; + this.execute = null; this.selectParenthesis = parenthesis; } @@ -317,6 +458,27 @@ public void setPartitionBound(PartitionBound partitionBound) { this.partitionBound = partitionBound; } + /** PostgreSQL parent tables, in declaration order; null if INHERITS is absent. */ + public List
getInherits() { + return inherits; + } + + public void setInherits(List
inherits) { + this.inherits = inherits; + } + + public CreateTable withInherits(List
inherits) { + setInherits(inherits); + return this; + } + + /** Shared rendering of the structured parent references. */ + public void appendInheritanceTo(StringBuilder builder) { + if (inherits != null) { + builder.append(" INHERITS ").append(PlainSelect.getStringList(inherits, true, true)); + } + } + public boolean isSelectParenthesis() { return selectParenthesis; } @@ -339,6 +501,7 @@ public String toString() { StringBuilder b = new StringBuilder(); appendCreateClause(b); appendColumnDefinitions(b); + appendInheritanceTo(b); if (partitionBound != null) { b.append(" ").append(partitionBound); } @@ -385,25 +548,56 @@ private void appendColumnDefinitions(StringBuilder b) { b.append(" ("); b.append(PlainSelect.getStringList(tableElements, true, false)); b.append(")"); - } else if (columnDefinitions != null && !columnDefinitions.isEmpty()) { - b.append(" ("); - b.append(PlainSelect.getStringList(columnDefinitions, true, false)); - if (indexes != null && !indexes.isEmpty()) { - b.append(", "); - b.append(PlainSelect.getStringList(indexes)); + } else { + List definitions = new ArrayList<>(); + if (columnDefinitions != null) { + definitions.addAll(columnDefinitions); + } + if (tableConstraints != null) { + definitions.addAll(tableConstraints); + } + if (indexes != null) { + definitions.addAll(indexes); + } + if (!definitions.isEmpty()) { + b.append(" ("); + b.append(PlainSelect.getStringList(definitions, true, false)); + b.append(")"); + } + } + } + + public void appendTableOptionsTo(StringBuilder builder, + java.util.function.Consumer expressionPrinter) { + if (tableOptions != null) { + TableOption previous = null; + for (TableOption option : tableOptions) { + // SQLite requires a comma between WITHOUT ROWID and STRICT + builder.append(isSqliteTableOption(previous) && isSqliteTableOption(option) + ? ", " + : " "); + option.appendTo(builder, expressionPrinter); + previous = option; + } + } else { + String options = PlainSelect.getStringList(tableOptionsStrings, false, false); + if (options != null && !options.isEmpty()) { + builder.append(' ').append(options); } - b.append(")"); } } + private static boolean isSqliteTableOption(TableOption option) { + return option != null && (option.getKind() == TableOption.Kind.WITHOUT_ROWID + || option.getKind() == TableOption.Kind.STRICT); + } + private void appendTableOptions(StringBuilder b) { - String options = tableOptions != null - ? PlainSelect.getStringList(tableOptions, false, false) - : PlainSelect.getStringList(tableOptionsStrings, false, false); - if (options != null && options.length() > 0) { - b.append(" ").append(options); + if (partitioning != null && tableOptionsAfterPartition) { + b.append(" ").append(partitioning); } - if (partitioning != null) { + appendTableOptionsTo(b, b::append); + if (partitioning != null && !tableOptionsAfterPartition) { b.append(" ").append(partitioning); } } @@ -498,6 +692,11 @@ public CreateTable withIndexes(List indexes) { return this; } + public CreateTable withTableConstraints(List constraints) { + setTableConstraints(constraints); + return this; + } + public CreateTable withTableElements(List tableElements) { this.setTableElements(tableElements); return this; @@ -556,6 +755,20 @@ public CreateTable addIndexes(Collection indexes) { return this.withIndexes(collection); } + public CreateTable addTableConstraints(NamedConstraint... constraints) { + List collection = + Optional.ofNullable(getTableConstraints()).orElseGet(ArrayList::new); + Collections.addAll(collection, constraints); + return withTableConstraints(collection); + } + + public CreateTable addTableConstraints(Collection constraints) { + List collection = + Optional.ofNullable(getTableConstraints()).orElseGet(ArrayList::new); + collection.addAll(constraints); + return withTableConstraints(collection); + } + public SpannerInterleaveIn getSpannerInterleaveIn() { return interleaveIn; } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/DefaultConstraint.java b/src/main/java/net/sf/jsqlparser/statement/create/table/DefaultConstraint.java index fd6daa82a8..4c123351e5 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/DefaultConstraint.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/DefaultConstraint.java @@ -21,7 +21,12 @@ public class DefaultConstraint extends NamedConstraint { public DefaultConstraint() { setType("DEFAULT"); - setKind(Kind.DEFAULT); + + } + + @Override + public ConstraintKind getKind() { + return ConstraintKind.DEFAULT; } public Expression getExpression() { diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ExcludeConstraint.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ExcludeConstraint.java index f8ed3a836c..d4306ff024 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ExcludeConstraint.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ExcludeConstraint.java @@ -9,21 +9,31 @@ */ package net.sf.jsqlparser.statement.create.table; +import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Objects; import java.util.function.Consumer; - import net.sf.jsqlparser.expression.Expression; -public class ExcludeConstraint extends Index { - +/** + * An exclusion constraint with key elements, supporting-index options and an optional predicate. + */ +public class ExcludeConstraint extends NamedConstraint + implements KeyColumnSource, IndexOptionSource { private Expression expression; + private List columns; + private IndexOptions indexOptions = new IndexOptions(); public ExcludeConstraint() { - setKind(Kind.EXCLUDE); setType("EXCLUDE"); } + @Override + public ConstraintKind getKind() { + return ConstraintKind.EXCLUDE; + } + public Expression getExpression() { return expression; } @@ -32,85 +42,113 @@ public void setExpression(Expression expression) { this.expression = expression; } - @Override - public void appendTo(StringBuilder exclusionStatement, Consumer expressionPrinter) { - if (getName() != null) { - exclusionStatement.append("CONSTRAINT ").append(getName()).append(' '); - } - exclusionStatement.append("EXCLUDE"); - if (getUsing() != null) { - exclusionStatement.append(" USING ").append(getUsing()); - } - if (getColumns() != null) { - exclusionStatement.append(' '); - appendColumnsTo(exclusionStatement, expressionPrinter); - } - appendConstraintOptionsTo(exclusionStatement, expressionPrinter); - if (expression != null) { - exclusionStatement.append(" WHERE ("); - expressionPrinter.accept(expression); - exclusionStatement.append(')'); - } - appendConstraintAttributesTo(exclusionStatement); + public E getExpression(Class type) { + return type.cast(expression); } public ExcludeConstraint withExpression(Expression expression) { - this.setExpression(expression); + setExpression(expression); return this; } - public E getExpression(Class type) { - return type.cast(getExpression()); + @Override + public List getColumns() { + return columns; } @Override - public ExcludeConstraint withName(List name) { - return (ExcludeConstraint) super.withName(name); + public void setColumns(List columns) { + this.columns = columns; } @Override - public ExcludeConstraint withType(String type) { - return (ExcludeConstraint) super.withType(type); + public IndexOptions getIndexOptions() { + return indexOptions; + } + + public void setIndexOptions(IndexOptions options) { + indexOptions = Objects.requireNonNull(options, "indexOptions"); + } + + public ExcludeConstraint withColumns(List columns) { + setColumns(columns); + return this; + } + + public ExcludeConstraint withColumnsNames(List columns) { + setColumnsNames(columns); + return this; + } + + public ExcludeConstraint addColumns(KeyElement... values) { + return addColumns(java.util.Arrays.asList(values)); + } + + public ExcludeConstraint addColumns(Collection values) { + if (columns == null) { + columns = new ArrayList<>(); + } + columns.addAll(values); + return this; } - @Override public ExcludeConstraint withUsing(String using) { - return (ExcludeConstraint) super.withUsing(using); + setUsing(using); + return this; } - @Override - public ExcludeConstraint withColumnsNames(List list) { - return (ExcludeConstraint) super.withColumnsNames(list); + public ExcludeConstraint withIndexSpec(List options) { + setIndexSpec(options); + return this; } - @Override - public ExcludeConstraint withColumns(List columns) { - return (ExcludeConstraint) super.withColumns(columns); + public ExcludeConstraint withClustering(IndexOptions.Clustering clustering) { + setClustering(clustering); + return this; } @Override - public ExcludeConstraint addColumns(ColumnParams... functionDeclarationParts) { - return (ExcludeConstraint) super.addColumns(functionDeclarationParts); + public ExcludeConstraint withType(String type) { + setType(type); + return this; } @Override - public ExcludeConstraint addColumns( - Collection functionDeclarationParts) { - return (ExcludeConstraint) super.addColumns(functionDeclarationParts); + public ExcludeConstraint withName(String name) { + setName(name); + return this; } @Override - public ExcludeConstraint withIndexSpec(List idxSpec) { - return (ExcludeConstraint) super.withIndexSpec(idxSpec); + public ExcludeConstraint withName(List name) { + setName(name); + return this; } @Override - public ExcludeConstraint withName(String name) { - return (ExcludeConstraint) super.withName(name); + public ExcludeConstraint withUseConstraintKeyword(boolean value) { + setUseConstraintKeyword(value); + return this; } @Override - public ExcludeConstraint withIndexKeyword(String indexKeyword) { - return (ExcludeConstraint) super.withIndexKeyword(indexKeyword); + public void appendTo(StringBuilder sql, Consumer expressionPrinter) { + appendConstraintPrefixTo(sql); + sql.append("EXCLUDE"); + if (getUsing() != null) { + sql.append(" USING ").append(getUsing()); + } + if (columns != null) { + sql.append(' '); + appendColumnsTo(sql, expressionPrinter); + } + appendIndexOptionsTo(sql, expressionPrinter); + if (expression != null) { + sql.append(" WHERE ("); + expressionPrinter.accept(expression); + sql.append(')'); + } + appendConstraintSuffixTo(sql); + appendConstraintAttributesTo(sql); } } 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..f2393760f4 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ExclusionOperator.java @@ -0,0 +1,71 @@ +/*- + * #%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(...). COMMENT ON + * OPERATOR and DROP OPERATOR use the same reference without the OPERATOR keyword. + */ +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/ForeignDataOption.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignDataOption.java new file mode 100644 index 0000000000..704a4277d9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignDataOption.java @@ -0,0 +1,121 @@ +/*- + * #%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; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; + +/** + * A foreign table, column or server option; absent action means the implicit ADD form. The value is + * a string constant; MySQL's CREATE SERVER and ALTER SERVER also take a number, as in + * {@code PORT 3306}. + */ +public class ForeignDataOption implements Serializable { + public enum Action { + ADD, SET, DROP + } + + private Action action; + private String name; + private Expression value; + + public ForeignDataOption(String name, StringValue value) { + this.name = name; + this.value = value; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = action; + if (action == Action.DROP) { + value = null; + } + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** The string value, or null if the option has none or has a numeric value. */ + public StringValue getValue() { + return value instanceof StringValue ? (StringValue) value : null; + } + + public void setValue(StringValue value) { + this.value = value; + } + + /** + * The value as written: a {@link StringValue}, or a numeric literal of a MySQL server option. + */ + public Expression getValueExpression() { + return value; + } + + public void setValueExpression(Expression value) { + this.value = value; + } + + public ForeignDataOption withValueExpression(Expression value) { + setValueExpression(value); + return this; + } + + public void appendTo(StringBuilder builder, Consumer expressionPrinter) { + if (action != null) { + builder.append(action).append(' '); + } + builder.append(name); + if (action != Action.DROP && value != null) { + builder.append(' '); + expressionPrinter.accept(value); + } + } + + public static void appendOptionsTo(StringBuilder builder, List options, + Consumer expressionPrinter) { + builder.append("OPTIONS ("); + for (int i = 0; i < options.size(); i++) { + if (i > 0) { + builder.append(", "); + } + options.get(i).appendTo(builder, expressionPrinter); + } + builder.append(')'); + } + + public static void visitExpressions(List options, + Consumer visitor) { + if (options != null) { + for (ForeignDataOption option : options) { + if (option.action != Action.DROP && option.value != null) { + visitor.accept(option.value); + } + } + } + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + appendTo(builder, builder::append); + return builder.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyConstraint.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyConstraint.java new file mode 100644 index 0000000000..2c0254917f --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyConstraint.java @@ -0,0 +1,259 @@ +/*- + * #%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 net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.ReferentialAction; +import net.sf.jsqlparser.statement.ReferentialAction.Action; +import net.sf.jsqlparser.statement.ReferentialAction.Type; +import java.util.Collection; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; + +public class ForeignKeyConstraint extends NamedConstraint implements KeyColumnSource { + private List columns; + private String indexName; + private ForeignKeyReference reference = new ForeignKeyReference(); + + public ForeignKeyConstraint() { + setType("FOREIGN KEY"); + } + + @Override + public ConstraintKind getKind() { + return ConstraintKind.FOREIGN_KEY; + } + + @Override + public List getColumns() { + return columns; + } + + @Override + public void setColumns(List columns) { + this.columns = columns; + } + + public String getIndexName() { + return indexName; + } + + public void setIndexName(String value) { + indexName = value; + } + + /** Returns the mutable reference shared by the structured and legacy accessors. */ + public ForeignKeyReference getReference() { + return reference; + } + + /** + * Replaces the reference. A null value detaches its current table, referenced columns and + * referential actions from reference-only options such as MATCH, preserving the legacy setter + * contract without restoring stale values from before structured edits. + */ + public void setReference(ForeignKeyReference reference) { + if (reference == null) { + ForeignKeyReference detached = new ForeignKeyReference() + .withTable(this.reference.getTable()) + .withReferencedColumnNames(this.reference.getReferencedColumnNames()); + detached.getReferentialActions().addAll(this.reference.getReferentialActions()); + this.reference = detached; + } else { + this.reference = reference; + } + } + + public ForeignKeyReference.MatchType getMatchType() { + return reference.getMatchType(); + } + + public void setMatchType(ForeignKeyReference.MatchType matchType) { + getReference().setMatchType(matchType); + } + + public Table getTable() { + return reference.getTable(); + } + + public void setTable(Table table) { + reference.setTable(table); + } + + public List getReferencedColumnNames() { + return reference.getReferencedColumnNames(); + } + + public void setReferencedColumnNames(List referencedColumnNames) { + reference.setReferencedColumnNames(referencedColumnNames); + } + + /** + * @param type + * @param action + */ + public void setReferentialAction(Type type, Action action) { + reference.setReferentialAction(type, action); + } + + public ForeignKeyConstraint withReferentialAction(Type type, Action action) { + setReferentialAction(type, action); + return this; + } + + /** + * @param type + */ + public void removeReferentialAction(Type type) { + reference.removeReferentialAction(type); + } + + /** + * @param type + * @return + */ + public ReferentialAction getReferentialAction(Type type) { + return reference.getReferentialAction(type); + } + + @Deprecated + public String getOnDeleteReferenceOption() { + ReferentialAction a = getReferentialAction(Type.DELETE); + return a == null ? null : a.getAction().getAction(); + } + + @Deprecated + public void setOnDeleteReferenceOption(String onDeleteReferenceOption) { + if (onDeleteReferenceOption == null) { + removeReferentialAction(Type.DELETE); + } else { + setReferentialAction(Type.DELETE, Action.from(onDeleteReferenceOption)); + } + } + + @Deprecated + public String getOnUpdateReferenceOption() { + ReferentialAction a = getReferentialAction(Type.UPDATE); + return a == null ? null : a.getAction().getAction(); + } + + @Deprecated + public void setOnUpdateReferenceOption(String onUpdateReferenceOption) { + if (onUpdateReferenceOption == null) { + removeReferentialAction(Type.UPDATE); + } else { + setReferentialAction(Type.UPDATE, Action.from(onUpdateReferenceOption)); + } + } + + @Override + public void appendTo(StringBuilder b, Consumer expressionPrinter) { + appendConstraintPrefixTo(b); + b.append(getType()); + if (indexName != null) { + b.append(' ').append(indexName); + } + if (columns != null) { + b.append(' '); + appendColumnsTo(b, expressionPrinter); + } + b.append(' ').append(reference); + appendConstraintSuffixTo(b); + appendConstraintAttributesTo(b); + } + + public ForeignKeyConstraint withTable(Table table) { + this.setTable(table); + return this; + } + + public ForeignKeyConstraint withReferencedColumnNames(List referencedColumnNames) { + this.setReferencedColumnNames(referencedColumnNames); + return this; + } + + public ForeignKeyConstraint withReference(ForeignKeyReference reference) { + setReference(reference); + return this; + } + + public ForeignKeyConstraint withMatchType(ForeignKeyReference.MatchType matchType) { + setMatchType(matchType); + return this; + } + + public ForeignKeyConstraint withOnDeleteReferenceOption(String onDeleteReferenceOption) { + this.setOnDeleteReferenceOption(onDeleteReferenceOption); + return this; + } + + public ForeignKeyConstraint withOnUpdateReferenceOption(String onUpdateReferenceOption) { + this.setOnUpdateReferenceOption(onUpdateReferenceOption); + return this; + } + + public ForeignKeyConstraint addReferencedColumnNames(String... referencedColumnNames) { + reference.addReferencedColumnNames(referencedColumnNames); + return this; + } + + public ForeignKeyConstraint addReferencedColumnNames(Collection referencedColumnNames) { + reference.addReferencedColumnNames(referencedColumnNames); + return this; + } + + @Override + public ForeignKeyConstraint withType(String type) { + return (ForeignKeyConstraint) super.withType(type); + } + + @Override + public ForeignKeyConstraint withUseConstraintKeyword(boolean useConstraintKeyword) { + return (ForeignKeyConstraint) super.withUseConstraintKeyword(useConstraintKeyword); + } + + @Override + public ForeignKeyConstraint withName(List name) { + return (ForeignKeyConstraint) super.withName(name); + } + + @Override + public ForeignKeyConstraint withName(String name) { + return (ForeignKeyConstraint) super.withName(name); + } + + public ForeignKeyConstraint withIndexName(String value) { + setIndexName(value); + return this; + } + + public ForeignKeyConstraint withColumnsNames(List value) { + setColumnsNames(value); + return this; + } + + public ForeignKeyConstraint withColumns(List value) { + setColumns(value); + return this; + } + + public ForeignKeyConstraint addColumns(KeyElement... values) { + return addColumns(java.util.Arrays.asList(values)); + } + + public ForeignKeyConstraint addColumns(Collection values) { + if (columns == null) { + columns = new java.util.ArrayList<>(); + } + columns.addAll(values); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyIndex.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyIndex.java deleted file mode 100644 index 869bf79693..0000000000 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyIndex.java +++ /dev/null @@ -1,287 +0,0 @@ -/*- - * #%L - * JSQLParser library - * %% - * Copyright (C) 2004 - 2019 JSQLParser - * %% - * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 - * #L% - */ -package net.sf.jsqlparser.statement.create.table; - -import net.sf.jsqlparser.schema.Table; -import net.sf.jsqlparser.statement.ReferentialAction; -import net.sf.jsqlparser.statement.ReferentialAction.Action; -import net.sf.jsqlparser.statement.ReferentialAction.Type; -import net.sf.jsqlparser.statement.select.PlainSelect; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.function.Consumer; -import net.sf.jsqlparser.expression.Expression; -import java.util.Optional; -import java.util.Set; - -public class ForeignKeyIndex extends NamedConstraint { - - private Table table; - private List referencedColumnNames; - private Set referentialActions = new LinkedHashSet<>(2); - private ForeignKeyReference reference; - - public ForeignKeyReference getReference() { - if (reference == null) { - reference = new ForeignKeyReference(); - reference.setTable(table); - reference.setReferencedColumnNames(referencedColumnNames); - for (ReferentialAction action : referentialActions) { - reference.setReferentialAction(action.getType(), action.getAction()); - } - } - return reference; - } - - public void setReference(ForeignKeyReference reference) { - this.reference = reference; - if (reference != null) { - table = reference.getTable(); - referencedColumnNames = reference.getReferencedColumnNames(); - referentialActions.clear(); - referentialActions.addAll(reference.getReferentialActions()); - } - } - - public ForeignKeyReference.MatchType getMatchType() { - return reference != null ? reference.getMatchType() : null; - } - - public void setMatchType(ForeignKeyReference.MatchType matchType) { - getReference().setMatchType(matchType); - } - - public Table getTable() { - return reference != null ? reference.getTable() : table; - } - - public void setTable(Table table) { - this.table = table; - if (reference != null) { - reference.setTable(table); - } - } - - public List getReferencedColumnNames() { - return reference != null ? reference.getReferencedColumnNames() : referencedColumnNames; - } - - public void setReferencedColumnNames(List referencedColumnNames) { - this.referencedColumnNames = referencedColumnNames; - if (reference != null) { - reference.setReferencedColumnNames(referencedColumnNames); - } - } - - /** - * @param type - * @param action - */ - public void setReferentialAction(Type type, Action action) { - setReferentialAction(type, action, true); - } - - public ForeignKeyIndex withReferentialAction(Type type, Action action) { - setReferentialAction(type, action); - return this; - } - - /** - * @param type - */ - public void removeReferentialAction(Type type) { - setReferentialAction(type, null, false); - } - - /** - * @param type - * @return - */ - public ReferentialAction getReferentialAction(Type type) { - if (reference != null) { - return reference.getReferentialAction(type); - } - return referentialActions.stream().filter(ra -> type.equals(ra.getType())).findFirst() - .orElse(null); - } - - private void setReferentialAction(Type type, Action action, boolean set) { - ReferentialAction found = getReferentialAction(type); - if (set) { - if (reference != null) { - reference.setReferentialAction(type, action); - return; - } - if (found == null) { - referentialActions.add(new ReferentialAction(type, action)); - } else { - found.setAction(action); - } - } else if (found != null) { - referentialActions.remove(found); - if (reference != null) { - reference.removeReferentialAction(type); - } - } - } - - @Deprecated - public String getOnDeleteReferenceOption() { - ReferentialAction a = getReferentialAction(Type.DELETE); - return a == null ? null : a.getAction().getAction(); - } - - @Deprecated - public void setOnDeleteReferenceOption(String onDeleteReferenceOption) { - if (onDeleteReferenceOption == null) { - removeReferentialAction(Type.DELETE); - } else { - setReferentialAction(Type.DELETE, Action.from(onDeleteReferenceOption)); - } - } - - @Deprecated - public String getOnUpdateReferenceOption() { - ReferentialAction a = getReferentialAction(Type.UPDATE); - return a == null ? null : a.getAction().getAction(); - } - - @Deprecated - public void setOnUpdateReferenceOption(String onUpdateReferenceOption) { - if (onUpdateReferenceOption == null) { - removeReferentialAction(Type.UPDATE); - } else { - setReferentialAction(Type.UPDATE, Action.from(onUpdateReferenceOption)); - } - } - - @Override - public void appendTo(StringBuilder b, Consumer expressionPrinter) { - super.appendTo(b, expressionPrinter); - b.append(' '); - if (reference != null) { - b.append(reference); - } else { - b.append("REFERENCES ").append(table) - .append(PlainSelect.getStringList(getReferencedColumnNames(), true, true)); - referentialActions.forEach(b::append); - } - appendConstraintSuffixTo(b); - appendConstraintAttributesTo(b); - } - - public ForeignKeyIndex withTable(Table table) { - this.setTable(table); - return this; - } - - public ForeignKeyIndex withReferencedColumnNames(List referencedColumnNames) { - this.setReferencedColumnNames(referencedColumnNames); - return this; - } - - public ForeignKeyIndex withReference(ForeignKeyReference reference) { - setReference(reference); - return this; - } - - public ForeignKeyIndex withMatchType(ForeignKeyReference.MatchType matchType) { - setMatchType(matchType); - return this; - } - - public ForeignKeyIndex withOnDeleteReferenceOption(String onDeleteReferenceOption) { - this.setOnDeleteReferenceOption(onDeleteReferenceOption); - return this; - } - - public ForeignKeyIndex withOnUpdateReferenceOption(String onUpdateReferenceOption) { - this.setOnUpdateReferenceOption(onUpdateReferenceOption); - return this; - } - - public ForeignKeyIndex addReferencedColumnNames(String... referencedColumnNames) { - List collection = - Optional.ofNullable(getReferencedColumnNames()).orElseGet(ArrayList::new); - Collections.addAll(collection, referencedColumnNames); - return this.withReferencedColumnNames(collection); - } - - public ForeignKeyIndex addReferencedColumnNames(Collection referencedColumnNames) { - List collection = - Optional.ofNullable(getReferencedColumnNames()).orElseGet(ArrayList::new); - collection.addAll(referencedColumnNames); - return this.withReferencedColumnNames(collection); - } - - @Override - public ForeignKeyIndex withType(String type) { - return (ForeignKeyIndex) super.withType(type); - } - - @Override - public ForeignKeyIndex withUsing(String using) { - return (ForeignKeyIndex) super.withUsing(using); - } - - @Override - public ForeignKeyIndex withIndexName(String indexName) { - return (ForeignKeyIndex) super.withIndexName(indexName); - } - - @Override - public ForeignKeyIndex withUseConstraintKeyword(boolean useConstraintKeyword) { - return (ForeignKeyIndex) super.withUseConstraintKeyword(useConstraintKeyword); - } - - @Override - public ForeignKeyIndex withName(List name) { - return (ForeignKeyIndex) super.withName(name); - } - - @Override - public ForeignKeyIndex withName(String name) { - return (ForeignKeyIndex) super.withName(name); - } - - @Override - public ForeignKeyIndex withColumnsNames(List list) { - return (ForeignKeyIndex) super.withColumnsNames(list); - } - - @Override - public ForeignKeyIndex withColumns(List columns) { - return (ForeignKeyIndex) super.withColumns(columns); - } - - @Override - public ForeignKeyIndex addColumns(ColumnParams... functionDeclarationParts) { - return (ForeignKeyIndex) super.addColumns(functionDeclarationParts); - } - - @Override - public ForeignKeyIndex addColumns(Collection functionDeclarationParts) { - return (ForeignKeyIndex) super.addColumns(functionDeclarationParts); - } - - @Override - public ForeignKeyIndex withIndexSpec(List idxSpec) { - return (ForeignKeyIndex) super.withIndexSpec(idxSpec); - } - - @Override - public ForeignKeyIndex withIndexKeyword(String indexKeyword) { - return (ForeignKeyIndex) super.withIndexKeyword(indexKeyword); - } -} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyReference.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyReference.java index 607a9d0df7..24208db933 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyReference.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignKeyReference.java @@ -21,7 +21,6 @@ import net.sf.jsqlparser.statement.ReferentialAction; import net.sf.jsqlparser.statement.ReferentialAction.Action; import net.sf.jsqlparser.statement.ReferentialAction.Type; -import net.sf.jsqlparser.statement.select.PlainSelect; /** The target and actions of a column- or table-level foreign-key reference. */ public class ForeignKeyReference implements Serializable { @@ -31,10 +30,49 @@ public enum MatchType { } private Table table; + private String constraintName; + + /** Optional name of a column REFERENCES constraint. Table constraints own their name. */ + public String getConstraintName() { + return constraintName; + } + + public void setConstraintName(String constraintName) { + this.constraintName = constraintName; + } + private List referencedColumnNames; private MatchType matchType; + private boolean usingPeriod; + private ConstraintAttributes constraintAttributes; private final Set referentialActions = new LinkedHashSet<>(2); + /** + * Attributes of a column REFERENCES clause; table constraints own their attributes on + * NamedConstraint. + */ + public ConstraintAttributes getConstraintAttributes() { + return constraintAttributes; + } + + public void setConstraintAttributes(ConstraintAttributes constraintAttributes) { + this.constraintAttributes = constraintAttributes; + } + + /** Whether the final explicitly referenced column is prefixed with PERIOD. */ + public boolean isUsingPeriod() { + return usingPeriod; + } + + public void setUsingPeriod(boolean usingPeriod) { + this.usingPeriod = usingPeriod; + } + + public ForeignKeyReference withUsingPeriod(boolean usingPeriod) { + setUsingPeriod(usingPeriod); + return this; + } + public Table getTable() { return table; } @@ -79,10 +117,8 @@ public void setReferentialAction(Type type, Action action) { } public void removeReferentialAction(Type type) { - ReferentialAction current = getReferentialAction(type); - if (current != null) { - referentialActions.remove(current); - } + // Actions are mutable; their hash code can change after insertion into the set. + referentialActions.removeIf(action -> type.equals(action.getType())); } public ForeignKeyReference withTable(Table table) { @@ -122,14 +158,31 @@ public ForeignKeyReference addReferencedColumnNames( @Override public String toString() { - StringBuilder builder = new StringBuilder("REFERENCES ").append(table); + StringBuilder builder = new StringBuilder(); + if (constraintName != null) { + builder.append("CONSTRAINT ").append(constraintName).append(' '); + } + builder.append("REFERENCES ").append(table); if (referencedColumnNames != null) { - builder.append(PlainSelect.getStringList(referencedColumnNames, true, true)); + builder.append('('); + for (int i = 0; i < referencedColumnNames.size(); i++) { + if (i > 0) { + builder.append(", "); + } + if (usingPeriod && i == referencedColumnNames.size() - 1) { + builder.append("PERIOD "); + } + builder.append(referencedColumnNames.get(i)); + } + builder.append(')'); } if (matchType != null) { builder.append(" MATCH ").append(matchType); } referentialActions.forEach(builder::append); + if (constraintAttributes != null) { + constraintAttributes.appendTo(builder); + } return builder.toString(); } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignTableOptions.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignTableOptions.java new file mode 100644 index 0000000000..1ff2017d6d --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ForeignTableOptions.java @@ -0,0 +1,52 @@ +/*- + * #%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; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; + +/** PostgreSQL foreign server and optional table-level FDW options. */ +public class ForeignTableOptions implements Serializable { + private String server; + private List options; + + public String getServer() { + return server; + } + + public void setServer(String server) { + this.server = server; + } + + public List getOptions() { + return options; + } + + public void setOptions(List options) { + this.options = options; + } + + public void appendTo(StringBuilder builder, Consumer expressionPrinter) { + builder.append("SERVER ").append(server); + if (options != null && !options.isEmpty()) { + builder.append(' '); + ForeignDataOption.appendOptionsTo(builder, options, expressionPrinter); + } + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + appendTo(builder, builder::append); + return builder.toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/GeneratedColumnDefinition.java b/src/main/java/net/sf/jsqlparser/statement/create/table/GeneratedColumnDefinition.java index cfc6bce5ad..ac069d6e45 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/GeneratedColumnDefinition.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/GeneratedColumnDefinition.java @@ -11,6 +11,7 @@ import java.io.Serializable; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Objects; import java.util.function.Consumer; @@ -55,6 +56,10 @@ public void setStorage(Storage storage) { this.storage = storage; } + /** + * Returns an unmodifiable token snapshot. Use the setters or edit {@link #getExpression()} to + * change the definition; later changes do not affect previously returned snapshots. + */ public List getTokens() { List tokens = new ArrayList<>(); if (generatedAlways) { @@ -66,22 +71,28 @@ public List getTokens() { if (storage != null) { tokens.add(storage.name()); } - return tokens; + return Collections.unmodifiableList(tokens); } public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { if (generatedAlways) { builder.append("GENERATED ALWAYS "); } - builder.append("AS ("); - expressionPrinter.accept(expression); - builder.append(')'); + appendExpressionTo(builder, expression, expressionPrinter); if (storage != null) { builder.append(' ').append(storage); } return builder; } + /** Prints the common AS (expression) body of declarations and expression replacements. */ + public static StringBuilder appendExpressionTo(StringBuilder builder, Expression expression, + Consumer expressionPrinter) { + builder.append("AS ("); + expressionPrinter.accept(expression); + return builder.append(')'); + } + @Override public String toString() { StringBuilder builder = new StringBuilder(); 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..adde4cd056 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 @@ -9,204 +9,58 @@ */ package net.sf.jsqlparser.statement.create.table; -import static java.util.stream.Collectors.toList; - import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; -import java.util.Optional; +import java.util.Objects; import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.statement.select.PlainSelect; -public class Index implements TableElement, Serializable { - +/** An index declaration, independent of table and column constraints. */ +public class Index implements TableElement, Serializable, KeyColumnSource, IndexOptionSource { public enum Kind { - PRIMARY_KEY, UNIQUE, INDEX, FULLTEXT, SPATIAL, FOREIGN_KEY, CHECK, EXCLUDE, DEFAULT, OTHER - } - - public enum Clustering { - CLUSTERED, NONCLUSTERED + UNIQUE, INDEX, FULLTEXT, SPATIAL, OTHER } private final List name = new ArrayList<>(); private String type; - private String using; - private List columns; - private List idxSpec; - private String commentText; - private String indexKeyword; private Kind kind = Kind.OTHER; - private Clustering clustering; - private Boolean nullsDistinct; - private List includeColumns; - private List
unionTables; + private List storageParameters; + private ColumnOption.Storage tablespaceStorage; + private OnCommitAction onCommitAction; + private StringValue comment; + + public enum Kind { + ENGINE, CHARACTER_SET, COLLATE, COMMENT, AUTO_INCREMENT, STATS_AUTO_RECALC, STATS_PERSISTENT, STATS_SAMPLE_PAGES, UNION, ENCRYPTION, PASSWORD, DATA_DIRECTORY, INDEX_DIRECTORY, SECONDARY_ENGINE, AUTOEXTEND_SIZE, INSERT_METHOD, PACK_KEYS, DELAY_KEY_WRITE, CHECKSUM, CONNECTION, COMPRESSION, STORAGE_PARAMETERS, WITHOUT_OIDS, WITHOUT_ROWID, STRICT, ENGINE_ATTRIBUTE, SECONDARY_ENGINE_ATTRIBUTE, ROW_FORMAT, AVG_ROW_LENGTH, MAX_ROWS, MIN_ROWS, KEY_BLOCK_SIZE, TABLESPACE, FOREIGN_SERVER, ACCESS_METHOD, ON_COMMIT, FILE_BLOCK_SIZE, OTHER + } + + /** + * The action of a temporary table's {@code ON COMMIT} clause. The DEFINITION actions belong to + * Oracle private temporary tables. + */ + public enum OnCommitAction { + PRESERVE_ROWS, DELETE_ROWS, DROP, PRESERVE_DEFINITION, DROP_DEFINITION; + + /** Returns the SQL keywords, for example {@code DELETE ROWS}. */ + @Override + public String toString() { + return name().replace('_', ' '); + } + } + + public ForeignTableOptions getForeignTableOptions() { + return foreignTableOptions; + } + + /** Replaces the current contents with a structured PostgreSQL SERVER clause. */ + public void setForeignTableOptions(ForeignTableOptions options) { + clearContents(); + kind = Kind.FOREIGN_SERVER; + name = "SERVER"; + foreignTableOptions = options; + } + + public static TableOption foreignServer(ForeignTableOptions options) { + TableOption option = new TableOption(); + option.setForeignTableOptions(options); + return option; + } + + public ColumnOption.Storage getTablespaceStorage() { + return tablespaceStorage; + } + + /** + * Sets the TABLESPACE storage modifier. A non-null modifier selects TABLESPACE and discards + * another option's contents; an existing TABLESPACE keeps its name, value and equals spelling. + */ + public void setTablespaceStorage(ColumnOption.Storage storage) { + if (storage != null && storage != ColumnOption.Storage.DISK + && storage != ColumnOption.Storage.MEMORY) { + throw new IllegalArgumentException("TABLESPACE storage must be DISK or MEMORY"); + } + if (storage != null && kind != Kind.TABLESPACE) { + clearContents(); + kind = Kind.TABLESPACE; + name = "TABLESPACE"; + } + tokens = null; + tablespaceStorage = storage; + } + + /** Creates a table access method option such as PostgreSQL's {@code USING heap}. */ + public static TableOption accessMethod(String method) { + return new TableOption(Kind.ACCESS_METHOD, "USING", method, false); + } + + /** Returns the {@code ON COMMIT} action, or null if this option has none. */ + public OnCommitAction getOnCommitAction() { + return onCommitAction; + } + + /** Replaces the current contents with an {@code ON COMMIT} clause. */ + public void setOnCommitAction(OnCommitAction action) { + clearContents(); + kind = Kind.ON_COMMIT; + name = "ON COMMIT"; + onCommitAction = action; + } + + /** Creates an {@code ON COMMIT} option, for example {@code ON COMMIT DROP}. */ + public static TableOption onCommit(OnCommitAction action) { + TableOption option = new TableOption(); + option.setOnCommitAction(action); + return option; + } + + public List getStorageParameters() { + return storageParameters; + } + + public void setStorageParameters(List storageParameters) { + clearContents(); + this.storageParameters = storageParameters; + kind = Kind.STORAGE_PARAMETERS; + name = "WITH"; + } + + /** + * Returns the COMMENT string literal, or null for another kind, opaque tokens or a plain value + * set with {@link #setValue(String)}. {@link StringValue#getNotExcapedValue()} decodes it. + */ + public StringValue getComment() { + return comment; + } + + /** + * Replaces the current contents with a COMMENT string literal and keeps the equals spelling; an + * existing COMMENT also keeps its name. A null literal omits the value. + */ + public void setComment(StringValue comment) { + String commentName = kind == Kind.COMMENT && name != null ? name : "COMMENT"; + boolean equals = useEquals; + clearContents(); + kind = Kind.COMMENT; + name = commentName; + useEquals = equals; + this.comment = comment; + } + + public TableOption withComment(StringValue comment) { + setComment(comment); + return this; + } + + public static TableOption comment(StringValue comment) { + TableOption option = new TableOption(); + option.setComment(comment); + return option; + } + + public void appendTo(StringBuilder builder, + java.util.function.Consumer expressionPrinter) { + if (foreignTableOptions != null) { + foreignTableOptions.appendTo(builder, expressionPrinter); + } else if (storageParameters != null) { + builder.append(name).append(useEquals ? " = " : " "); + IndexOption.appendListTo(builder, storageParameters, expressionPrinter); + } else if (comment != null) { + builder.append(name).append(useEquals ? " = " : " "); + expressionPrinter.accept(comment); + } else { + builder.append(toString()); + } + } + public TableOption() {} @@ -55,10 +205,28 @@ public Kind getKind() { } public void setKind(Kind kind) { + tokens = null; this.kind = kind; + if (kind != Kind.TABLESPACE) { + tablespaceStorage = null; + } + if (kind != Kind.FOREIGN_SERVER) { + foreignTableOptions = null; + } + if (kind != Kind.STORAGE_PARAMETERS) { + storageParameters = null; + } if (kind != Kind.UNION) { unionTables = null; } + if (kind != Kind.ON_COMMIT) { + onCommitAction = null; + } + if (kind != Kind.COMMENT && comment != null) { + // keep the literal's SQL text, as for other scalar values + value = comment.toString(); + comment = null; + } } public String getName() { @@ -66,16 +234,35 @@ public String getName() { } public void setName(String name) { + tokens = null; this.name = name; } public String getValue() { + if (foreignTableOptions != null) { + return foreignTableOptions.toString().substring("SERVER ".length()); + } + if (storageParameters != null) { + return PlainSelect.getStringList(storageParameters, true, true); + } + if (onCommitAction != null) { + return onCommitAction.toString(); + } + if (comment != null) { + return comment.toString(); + } return unionTables == null ? value : PlainSelect.getStringList(unionTables, true, true); } + /** Sets a plain value; it replaces a COMMENT literal without being parsed. */ public void setValue(String value) { + tokens = null; this.value = value; + foreignTableOptions = null; unionTables = null; + storageParameters = null; + onCommitAction = null; + comment = null; } /** Returns the mutable MERGE table sources, including an empty UNION list. */ @@ -85,11 +272,12 @@ public List
getUnionTables() { /** Replaces raw option contents with structured UNION table references. */ public void setUnionTables(List
unionTables) { + boolean equals = useEquals; + clearContents(); this.unionTables = unionTables; kind = Kind.UNION; name = "UNION"; - value = null; - tokens = null; + useEquals = equals; } public TableOption withUnionTables(List
unionTables) { @@ -102,10 +290,14 @@ public boolean isUseEquals() { } public void setUseEquals(boolean useEquals) { + tokens = null; this.useEquals = useEquals; } - /** Returns the original token groups used by the legacy table-options API. */ + /** + * Returns the original, mutable token list for an opaque option, or an unmodifiable snapshot of + * the current structured properties. Editing tokens does not classify or parse them. + */ public List getTokens() { if (tokens != null) { return tokens; @@ -118,17 +310,42 @@ public List getTokens() { result.add("="); } String renderedValue = getValue(); - if (renderedValue != null) { + if (onCommitAction != null) { + // one token per keyword, as in the legacy raw options + Collections.addAll(result, renderedValue.split(" ")); + } else if (renderedValue != null) { result.add(renderedValue); } + if (kind == Kind.TABLESPACE && tablespaceStorage != null) { + result.add("STORAGE"); + result.add(tablespaceStorage.name()); + } return Collections.unmodifiableList(result); } + /** + * Replaces all structured properties with opaque tokens and {@link Kind#OTHER}. Null clears + * opaque tokens without restoring discarded properties; it leaves structured options alone. + */ public void setTokens(List tokens) { - this.tokens = tokens; if (tokens != null) { - unionTables = null; + clearContents(); } + this.tokens = tokens; + } + + private void clearContents() { + kind = Kind.OTHER; + name = null; + value = null; + useEquals = false; + tokens = null; + tablespaceStorage = null; + foreignTableOptions = null; + unionTables = null; + storageParameters = null; + onCommitAction = null; + comment = null; } public TableOption withKind(Kind kind) { @@ -153,10 +370,16 @@ public TableOption withUseEquals(boolean useEquals) { @Override public String toString() { + if (foreignTableOptions != null) { + return foreignTableOptions.toString(); + } if (tokens != null) { return PlainSelect.getStringList(tokens, false, false); } String renderedValue = getValue(); - return name + (renderedValue != null ? (useEquals ? " = " : " ") + renderedValue : ""); + return name + (renderedValue != null ? (useEquals ? " = " : " ") + renderedValue : "") + + (kind == Kind.TABLESPACE && tablespaceStorage != null + ? " STORAGE " + tablespaceStorage + : ""); } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/TablePartitioning.java b/src/main/java/net/sf/jsqlparser/statement/create/table/TablePartitioning.java index 1c96a39ea1..fa99c656a4 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/TablePartitioning.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/TablePartitioning.java @@ -35,6 +35,20 @@ public enum Type { EXPRESSION } + private List keyColumns; + + /** PostgreSQL keys carrying collation/operator-class attributes, otherwise null. */ + public List getKeyColumns() { + return keyColumns; + } + + public void setKeyColumns(List keyColumns) { + if (keyColumns != null) { + clearKeyRepresentation(); + } + this.keyColumns = keyColumns; + } + private Type type; private boolean linear; private boolean columnsSyntax; @@ -83,6 +97,9 @@ public Expression getExpression() { } public void setExpression(Expression expression) { + if (expression != null) { + clearKeyRepresentation(); + } this.expression = expression; } @@ -96,6 +113,9 @@ public ExpressionList getExpressionList() { } public void setExpressionList(ExpressionList expressionList) { + if (expressionList != null) { + clearKeyRepresentation(); + } this.expressionList = expressionList; } @@ -104,9 +124,20 @@ public ExpressionList getColumns() { } public void setColumns(ExpressionList columns) { + if (columns != null) { + clearKeyRepresentation(); + } this.columns = columns; } + /** Selecting a key representation must replace the previously rendered key. */ + private void clearKeyRepresentation() { + keyColumns = null; + expression = null; + expressionList = null; + columns = null; + } + public Integer getAlgorithm() { return algorithm; } @@ -305,7 +336,16 @@ private void appendMethod(StringBuilder builder, Consumer expression if (columnsSyntax) { builder.append(" COLUMNS"); } - if (expression != null) { + if (keyColumns != null) { + builder.append(" ("); + for (int i = 0; i < keyColumns.size(); i++) { + if (i > 0) { + builder.append(", "); + } + keyColumns.get(i).appendTo(builder, expressionPrinter); + } + builder.append(')'); + } else if (expression != null) { builder.append(" ("); expressionPrinter.accept(expression); builder.append(')'); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/tablespace/CreateTablespace.java b/src/main/java/net/sf/jsqlparser/statement/create/tablespace/CreateTablespace.java new file mode 100644 index 0000000000..45901d661e --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/tablespace/CreateTablespace.java @@ -0,0 +1,160 @@ +/*- + * #%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.tablespace; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.TableOption; + +/** + * A MySQL {@code CREATE [UNDO] TABLESPACE} or PostgreSQL {@code CREATE TABLESPACE} statement. The + * parser fills either the PostgreSQL owner, location and parameters, or the MySQL data file and + * options. MySQL options reuse the {@link TableOption} models of the same name, plus + * {@link TableOption.Kind#FILE_BLOCK_SIZE}. + */ +public class CreateTablespace extends ASTNodeAccessImpl implements Statement { + private String name; + private boolean undo; + private String owner; + private StringValue location; + private List parameters; + private StringValue dataFile; + private final List options = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** Whether this is a MySQL {@code CREATE UNDO TABLESPACE} statement. */ + public boolean isUndo() { + return undo; + } + + public void setUndo(boolean undo) { + this.undo = undo; + } + + /** Returns the PostgreSQL {@code OWNER} role, or null when the clause is omitted. */ + public String getOwner() { + return owner; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + /** Returns the PostgreSQL {@code LOCATION} directory. */ + public StringValue getLocation() { + return location; + } + + public void setLocation(StringValue location) { + this.location = location; + } + + /** + * Returns the PostgreSQL {@code WITH (...)} tablespace parameters, or null when the clause is + * omitted. + */ + public List getParameters() { + return parameters; + } + + public void setParameters(List parameters) { + this.parameters = parameters; + } + + /** Returns the MySQL {@code ADD DATAFILE} file name, or null when the clause is omitted. */ + public StringValue getDataFile() { + return dataFile; + } + + public void setDataFile(StringValue dataFile) { + this.dataFile = dataFile; + } + + /** Returns the mutable MySQL options in source order; commas between them are not kept. */ + public List getOptions() { + return options; + } + + public void setOptions(Collection options) { + this.options.clear(); + if (options != null) { + this.options.addAll(options); + } + } + + public CreateTablespace addOptions(TableOption... options) { + Collections.addAll(this.options, options); + return this; + } + + /** Returns the first MySQL option of the given kind. */ + public Optional getOption(TableOption.Kind kind) { + return options.stream().filter(option -> option.getKind() == kind).findFirst(); + } + + public StringBuilder appendTo(StringBuilder builder, Consumer expressionPrinter) { + builder.append(undo ? "CREATE UNDO TABLESPACE " : "CREATE TABLESPACE ").append(name); + if (owner != null) { + builder.append(" OWNER ").append(owner); + } + if (location != null) { + builder.append(" LOCATION ").append(location); + } + if (parameters != null) { + builder.append(" WITH "); + IndexOption.appendListTo(builder, parameters, expressionPrinter); + } + if (dataFile != null) { + builder.append(" ADD DATAFILE ").append(dataFile); + } + for (TableOption option : options) { + builder.append(' '); + option.appendTo(builder, expressionPrinter); + } + return builder; + } + + /** Visits the values of the PostgreSQL tablespace parameters. */ + public void visitExpressions(Consumer visitor) { + if (parameters != null) { + parameters.stream().map(IndexOption::getValue).filter(Objects::nonNull) + .forEach(visitor); + } + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchConfiguration.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchConfiguration.java new file mode 100644 index 0000000000..ae214768bd --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchConfiguration.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.textsearch; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +public class CreateTextSearchConfiguration extends ASTNodeAccessImpl implements Statement { + public enum SourceKind { + PARSER, COPY + } + + private String name; + private SourceKind sourceKind; + private String sourceName; + + public String getName() { + return name; + } + + public void setName(String value) { + name = value; + } + + public SourceKind getSourceKind() { + return sourceKind; + } + + public void setSourceKind(SourceKind value) { + sourceKind = value; + } + + public String getSourceName() { + return sourceName; + } + + public void setSourceName(String value) { + sourceName = value; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH CONFIGURATION ").append(name) + .append(" (").append(sourceKind).append(" = ").append(sourceName).append(')'); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchDictionary.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchDictionary.java new file mode 100644 index 0000000000..f3960fe567 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchDictionary.java @@ -0,0 +1,99 @@ +/*- + * #%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.textsearch; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL CREATE TEXT SEARCH DICTIONARY. Ordered options preserve names, typed values and + * quoting. + */ +public class CreateTextSearchDictionary extends ASTNodeAccessImpl implements Statement { + private String name; + private List options = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateTextSearchDictionary withName(String name) { + setName(name); + return this; + } + + public List getOptions() { + return options; + } + + public void setOptions(List options) { + this.options = options; + } + + public CreateTextSearchDictionary withOptions(List options) { + setOptions(options); + return this; + } + + /** Returns the last matching option, while the complete list retains source order. */ + public DefinitionElement getOption(String name) { + return find(options, name); + } + + /** The TEMPLATE value, represented as PostgreSQL's typed definition argument. */ + public DefinitionArgument getTemplate() { + DefinitionElement template = getOption("TEMPLATE"); + return template == null ? null : template.getArgument(); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH DICTIONARY ").append(name).append(' ') + .append(DefinitionElement.toString(options)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchParser.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchParser.java new file mode 100644 index 0000000000..63d5538dfd --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchParser.java @@ -0,0 +1,113 @@ +/*- + * #%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.textsearch; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL CREATE TEXT SEARCH PARSER. Functions may appear in any order. */ +public class CreateTextSearchParser extends ASTNodeAccessImpl implements Statement { + private String name; + private List functions = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateTextSearchParser withName(String name) { + setName(name); + return this; + } + + public List getFunctions() { + return functions; + } + + public void setFunctions(List functions) { + this.functions = functions; + } + + public CreateTextSearchParser withFunctions(List functions) { + setFunctions(functions); + return this; + } + + /** + * Returns the last matching function; the list retains all typed definitions in source order. + */ + public DefinitionArgument getFunction(String name) { + DefinitionElement function = find(functions, name); + return function == null ? null : function.getArgument(); + } + + public DefinitionArgument getStartFunction() { + return getFunction("START"); + } + + public DefinitionArgument getGetTokenFunction() { + return getFunction("GETTOKEN"); + } + + public DefinitionArgument getEndFunction() { + return getFunction("END"); + } + + public DefinitionArgument getLexTypesFunction() { + return getFunction("LEXTYPES"); + } + + public DefinitionArgument getHeadlineFunction() { + return getFunction("HEADLINE"); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH PARSER ").append(name).append(' ') + .append(DefinitionElement.toString(functions)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchTemplate.java b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchTemplate.java new file mode 100644 index 0000000000..ba5e525306 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/textsearch/CreateTextSearchTemplate.java @@ -0,0 +1,101 @@ +/*- + * #%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.textsearch; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** PostgreSQL CREATE TEXT SEARCH TEMPLATE. Functions may appear in any order. */ +public class CreateTextSearchTemplate extends ASTNodeAccessImpl implements Statement { + private String name; + private List functions = new ArrayList<>(); + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CreateTextSearchTemplate withName(String name) { + setName(name); + return this; + } + + public List getFunctions() { + return functions; + } + + public void setFunctions(List functions) { + this.functions = functions; + } + + public CreateTextSearchTemplate withFunctions(List functions) { + setFunctions(functions); + return this; + } + + /** + * Returns the last matching function; the list retains all typed definitions in source order. + */ + public DefinitionArgument getFunction(String name) { + DefinitionElement function = find(functions, name); + return function == null ? null : function.getArgument(); + } + + public DefinitionArgument getInitFunction() { + return getFunction("INIT"); + } + + public DefinitionArgument getLexizeFunction() { + return getFunction("LEXIZE"); + } + + private static DefinitionElement find(List elements, String name) { + String requested = name.startsWith("\"") + ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + for (int i = elements.size() - 1; i >= 0; i--) { + DefinitionElement element = elements.get(i); + String key = element.getName(); + if (key.startsWith("\"")) { + key = key.substring(1, key.length() - 1).replace("\"\"", "\""); + } else { + key = key.toLowerCase(Locale.ROOT); + } + if (requested.equals(key)) { + return element; + } + } + return null; + } + + public StringBuilder appendTo(StringBuilder sql) { + return sql.append("CREATE TEXT SEARCH TEMPLATE ").append(name).append(' ') + .append(DefinitionElement.toString(functions)); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/transform/CreateTransform.java b/src/main/java/net/sf/jsqlparser/statement/create/transform/CreateTransform.java new file mode 100644 index 0000000000..9de167479c --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/transform/CreateTransform.java @@ -0,0 +1,150 @@ +/*- + * #%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.transform; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.TransformSignature; + +/** + * PostgreSQL + * {@code CREATE [OR REPLACE] TRANSFORM FOR type LANGUAGE lang (FROM SQL WITH FUNCTION f [(args)], TO SQL WITH FUNCTION g [(args)])}. + * The transform is named by the {@link TransformSignature} that {@code DROP TRANSFORM} uses. It has + * one or both of the functions, in either order. + */ +public class CreateTransform extends ASTNodeAccessImpl implements Statement { + private boolean orReplace; + private TransformSignature transform; + private RoutineReference fromSqlFunction; + private RoutineReference toSqlFunction; + private boolean toSqlFirst; + + public boolean isOrReplace() { + return orReplace; + } + + public void setOrReplace(boolean orReplace) { + this.orReplace = orReplace; + } + + public CreateTransform withOrReplace(boolean orReplace) { + setOrReplace(orReplace); + return this; + } + + public TransformSignature getTransform() { + return transform; + } + + public void setTransform(TransformSignature transform) { + this.transform = transform; + } + + public CreateTransform withTransform(TransformSignature transform) { + setTransform(transform); + return this; + } + + /** + * The function of {@code FROM SQL WITH FUNCTION}, which converts the type to the language. + * + * @return the function, or {@code null} without a {@code FROM SQL} item + */ + public RoutineReference getFromSqlFunction() { + return fromSqlFunction; + } + + public void setFromSqlFunction(RoutineReference fromSqlFunction) { + this.fromSqlFunction = fromSqlFunction; + } + + public CreateTransform withFromSqlFunction(RoutineReference fromSqlFunction) { + setFromSqlFunction(fromSqlFunction); + return this; + } + + /** + * The function of {@code TO SQL WITH FUNCTION}, which converts the language's value to the + * type. + * + * @return the function, or {@code null} without a {@code TO SQL} item + */ + public RoutineReference getToSqlFunction() { + return toSqlFunction; + } + + public void setToSqlFunction(RoutineReference toSqlFunction) { + this.toSqlFunction = toSqlFunction; + } + + public CreateTransform withToSqlFunction(RoutineReference toSqlFunction) { + setToSqlFunction(toSqlFunction); + return this; + } + + /** + * Whether the {@code TO SQL} item is written before the {@code FROM SQL} item. It matters only + * when the statement has both. + * + * @return whether {@code TO SQL} comes first + */ + public boolean isToSqlFirst() { + return toSqlFirst; + } + + public void setToSqlFirst(boolean toSqlFirst) { + this.toSqlFirst = toSqlFirst; + } + + public CreateTransform withToSqlFirst(boolean toSqlFirst) { + setToSqlFirst(toSqlFirst); + return this; + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append("CREATE "); + if (orReplace) { + builder.append("OR REPLACE "); + } + builder.append("TRANSFORM "); + transform.appendTo(builder).append(" ("); + String separator = ""; + if (toSqlFirst) { + separator = appendItem(builder, separator, "TO", toSqlFunction); + } + separator = appendItem(builder, separator, "FROM", fromSqlFunction); + if (!toSqlFirst) { + appendItem(builder, separator, "TO", toSqlFunction); + } + return builder.append(')'); + } + + private static String appendItem(StringBuilder builder, String separator, String direction, + RoutineReference function) { + if (function == null) { + return separator; + } + builder.append(separator).append(direction).append(" SQL WITH FUNCTION ") + .append(function); + return ", "; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateEventTrigger.java b/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateEventTrigger.java new file mode 100644 index 0000000000..13f0e5b09a --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateEventTrigger.java @@ -0,0 +1,197 @@ +/*- + * #%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.trigger; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * A PostgreSQL {@code CREATE EVENT TRIGGER} statement. Unlike {@link CreateTrigger}, it fires on a + * database event such as {@code ddl_command_start} rather than on table rows. The function is + * invoked like a {@link CreateTrigger} routine, with the same {@code FUNCTION} or {@code PROCEDURE} + * spelling, but never takes arguments. + */ +public class CreateEventTrigger extends ASTNodeAccessImpl implements Statement { + + private String name; + private String event; + private final List filters = new ArrayList<>(); + private CreateTrigger.ExecuteKeyword executeKeyword = CreateTrigger.ExecuteKeyword.FUNCTION; + private Function function; + + /** A {@code WHEN} condition, for example {@code TAG IN ('CREATE TABLE', 'DROP TABLE')}. */ + public static class Filter implements Serializable { + private String variable; + private final List values = new ArrayList<>(); + + public Filter() { + // empty constructor + } + + public Filter(String variable, Collection values) { + this.variable = variable; + setValues(values); + } + + /** The filter variable as written, for example {@code TAG}. */ + public String getVariable() { + return variable; + } + + public void setVariable(String variable) { + this.variable = variable; + } + + /** The accepted values in source order. */ + public List getValues() { + return Collections.unmodifiableList(values); + } + + public void setValues(Collection values) { + this.values.clear(); + if (values != null) { + this.values.addAll(values); + } + } + + public Filter addValues(StringValue... values) { + Collections.addAll(this.values, values); + return this; + } + + public StringBuilder appendTo(StringBuilder sql, Consumer expressionWriter) { + sql.append(variable).append(" IN ("); + for (int i = 0; i < values.size(); i++) { + if (i > 0) { + sql.append(", "); + } + expressionWriter.accept(values.get(i)); + } + return sql.append(')'); + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + return appendTo(sql, sql::append).toString(); + } + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** The event name as written, for example {@code ddl_command_start} or {@code sql_drop}. */ + public String getEvent() { + return event; + } + + public void setEvent(String event) { + this.event = event; + } + + /** The {@code WHEN} conditions in source order; all of them must match. */ + public List getFilters() { + return Collections.unmodifiableList(filters); + } + + public void setFilters(Collection filters) { + this.filters.clear(); + if (filters != null) { + this.filters.addAll(filters); + } + } + + public CreateEventTrigger addFilters(Filter... filters) { + Collections.addAll(this.filters, filters); + return this; + } + + public CreateTrigger.ExecuteKeyword getExecuteKeyword() { + return executeKeyword; + } + + public void setExecuteKeyword(CreateTrigger.ExecuteKeyword executeKeyword) { + this.executeKeyword = executeKeyword; + } + + /** The invoked function, rendered with its empty argument list. */ + public Function getFunction() { + return function; + } + + public void setFunction(Function function) { + this.function = function; + } + + /** Visits the filter values and the invoked function. */ + public void visitExpressions(Consumer visitor) { + filters.forEach(filter -> filter.getValues().forEach(visitor)); + if (function != null) { + visitor.accept(function); + } + } + + public StringBuilder appendTo(StringBuilder sql, Consumer expressionWriter) { + sql.append("CREATE EVENT TRIGGER ").append(name).append(" ON ").append(event); + for (int i = 0; i < filters.size(); i++) { + sql.append(i == 0 ? " WHEN " : " AND "); + filters.get(i).appendTo(sql, expressionWriter); + } + sql.append(" EXECUTE ").append(executeKeyword).append(' '); + expressionWriter.accept(function); + return sql; + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + return appendTo(sql, sql::append).toString(); + } + + public CreateEventTrigger withName(String name) { + setName(name); + return this; + } + + public CreateEventTrigger withEvent(String event) { + setEvent(event); + return this; + } + + public CreateEventTrigger withExecuteKeyword(CreateTrigger.ExecuteKeyword executeKeyword) { + setExecuteKeyword(executeKeyword); + return this; + } + + public CreateEventTrigger withFunction(Function function) { + setFunction(function); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateTrigger.java b/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateTrigger.java index 4c3b8f3f80..bcda2c8f59 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateTrigger.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateTrigger.java @@ -14,13 +14,14 @@ import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; /** MySQL and PostgreSQL trigger definitions with distinct body and routine-invocation forms. */ -public class CreateTrigger implements Statement { +public class CreateTrigger extends ASTNodeAccessImpl implements Statement { public enum Timing { BEFORE, AFTER, INSTEAD_OF @@ -46,6 +47,7 @@ public enum ExecuteKeyword { private Table trigger; private Timing timing; private boolean orReplace; + private boolean ifNotExists; private boolean constraint; private Table referencedTable; private Orientation orientation; @@ -76,6 +78,19 @@ public void setOrReplace(boolean orReplace) { this.orReplace = orReplace; } + /** + * Whether MySQL's {@code IF NOT EXISTS} follows {@code TRIGGER}. + * + * @return {@code true} if {@code IF NOT EXISTS} is rendered + */ + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean ifNotExists) { + this.ifNotExists = ifNotExists; + } + public boolean isConstraint() { return constraint; } @@ -207,6 +222,14 @@ public void setOtherTrigger(Table otherTrigger) { this.otherTrigger = otherTrigger; } + /** + * The MySQL trigger statement: a single statement, a {@link net.sf.jsqlparser.statement.Block} + * of statements, or an {@link net.sf.jsqlparser.statement.UnsupportedStatement} holding the + * tokens of a compound statement with procedural statements, such as {@code IF} or + * {@code DECLARE}. + * + * @return the body + */ public Statement getBody() { return body; } @@ -307,10 +330,17 @@ public String toString() { private String mysqlSql() { StringBuilder builder = new StringBuilder("CREATE "); + if (orReplace) { + builder.append("OR REPLACE "); + } if (definer != null) { builder.append("DEFINER = ").append(definer).append(" "); } - builder.append("TRIGGER ").append(trigger).append(" ").append(timing).append(" ") + builder.append("TRIGGER "); + if (ifNotExists) { + builder.append("IF NOT EXISTS "); + } + builder.append(trigger).append(" ").append(timing).append(" ") .append(getEvent()).append(" ON ").append(table).append(" FOR EACH ROW "); if (order != null) { builder.append(order).append(" ").append(otherTrigger).append(" "); diff --git a/src/main/java/net/sf/jsqlparser/statement/create/trigger/TriggerDefiner.java b/src/main/java/net/sf/jsqlparser/statement/create/trigger/TriggerDefiner.java index a4ba3e14ec..9f95c53ea5 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/trigger/TriggerDefiner.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/trigger/TriggerDefiner.java @@ -9,45 +9,18 @@ */ package net.sf.jsqlparser.statement.create.trigger; -import java.io.Serializable; import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.statement.MySqlDefiner; -/** Structured account used by a MySQL trigger {@code DEFINER} clause. */ -public class TriggerDefiner implements Serializable { - - private StringValue user; - private StringValue host; - - public StringValue getUser() { - return user; - } - - public void setUser(StringValue user) { - this.user = user; - } - - public StringValue getHost() { - return host; - } - - public void setHost(StringValue host) { - this.host = host; - } - +/** Retains the trigger API while sharing MySQL DEFINER account handling with views. */ +public class TriggerDefiner extends MySqlDefiner { @Override - public String toString() { - StringBuilder builder = new StringBuilder().append(user); - if (host != null) { - builder.append("@").append(host); - } - return builder.toString(); - } - public TriggerDefiner withUser(StringValue user) { setUser(user); return this; } + @Override public TriggerDefiner withHost(StringValue host) { setHost(host); return this; diff --git a/src/main/java/net/sf/jsqlparser/statement/create/type/BaseTypeDefinition.java b/src/main/java/net/sf/jsqlparser/statement/create/type/BaseTypeDefinition.java new file mode 100644 index 0000000000..faaba6e817 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/type/BaseTypeDefinition.java @@ -0,0 +1,53 @@ +/*- + * #%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.type; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.statement.DefinitionElement; + +/** + * Definition of a PostgreSQL base type, {@code CREATE TYPE name (INPUT = fn, OUTPUT = fn, ...)}. + * PostgreSQL only warns about a name it does not know, so the names are not restricted. + */ +public class BaseTypeDefinition implements TypeDefinition { + private List elements = new ArrayList<>(); + + public BaseTypeDefinition() { + // empty constructor + } + + public BaseTypeDefinition(List elements) { + this.elements = elements; + } + + public List getElements() { + return elements; + } + + public void setElements(List elements) { + this.elements = elements; + } + + /** + * Finds an element by its name, ignoring case. + * + * @param name the name, such as {@code INPUT} + * @return the first element of that name, or {@code null} + */ + public DefinitionElement getElement(String name) { + return DefinitionElement.find(elements, name); + } + + @Override + public String toString() { + return DefinitionElement.toString(elements); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/type/CreateType.java b/src/main/java/net/sf/jsqlparser/statement/create/type/CreateType.java index 891c5bdb0c..592f702c2d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/type/CreateType.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/type/CreateType.java @@ -10,10 +10,11 @@ package net.sf.jsqlparser.statement.create.type; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -public class CreateType implements Statement { +public class CreateType extends ASTNodeAccessImpl implements Statement { private String name; private TypeDefinition definition; @@ -40,6 +41,11 @@ public T accept(StatementVisitor visitor, S context) { @Override public String toString() { - return "CREATE TYPE " + name + (definition == null ? "" : " AS " + definition); + if (definition == null) { + return "CREATE TYPE " + name; + } + // only a base type definition follows the name directly + return "CREATE TYPE " + name + (definition instanceof BaseTypeDefinition ? " " : " AS ") + + definition; } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/type/TypeDefinition.java b/src/main/java/net/sf/jsqlparser/statement/create/type/TypeDefinition.java index 274e2f7b09..fa85b9b462 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/type/TypeDefinition.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/type/TypeDefinition.java @@ -11,6 +11,6 @@ import java.io.Serializable; -/** Definition of a composite, enumeration or range type. */ +/** Definition of a composite, enumeration, range or base type. */ public interface TypeDefinition extends Serializable { } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/CreateUser.java b/src/main/java/net/sf/jsqlparser/statement/create/user/CreateUser.java index ce5f16273c..480500d2c2 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/user/CreateUser.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/CreateUser.java @@ -14,14 +14,20 @@ import java.util.Collections; import java.util.List; import java.util.stream.Collectors; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -/** MySQL {@code CREATE USER} statement with structured account and authentication data. */ -public class CreateUser implements Statement { +/** + * MySQL {@code CREATE USER} statement with structured account and authentication data. The + * {@link UserOptions} after the account list are shared with + * {@link net.sf.jsqlparser.statement.alter.AlterUser}. + */ +public class CreateUser extends ASTNodeAccessImpl implements Statement { private boolean ifNotExists; private final List accounts = new ArrayList<>(); + private UserOptions options = new UserOptions(); public boolean isIfNotExists() { return ifNotExists; @@ -42,6 +48,15 @@ public void setAccounts(Collection accounts) { } } + /** The account options after the account list; empty, never null, when none are given. */ + public UserOptions getOptions() { + return options; + } + + public void setOptions(UserOptions options) { + this.options = options != null ? options : new UserOptions(); + } + @Override public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); @@ -49,8 +64,12 @@ public T accept(StatementVisitor statementVisitor, S context) { @Override public String toString() { - return "CREATE USER " + (ifNotExists ? "IF NOT EXISTS " : "") - + accounts.stream().map(Object::toString).collect(Collectors.joining(", ")); + StringBuilder builder = new StringBuilder("CREATE USER "); + if (ifNotExists) { + builder.append("IF NOT EXISTS "); + } + builder.append(accounts.stream().map(Object::toString).collect(Collectors.joining(", "))); + return options.appendTo(builder).toString(); } public CreateUser withIfNotExists(boolean ifNotExists) { @@ -67,4 +86,9 @@ public CreateUser addAccounts(UserAccount... accounts) { Collections.addAll(this.accounts, accounts); return this; } + + public CreateUser withOptions(UserOptions options) { + setOptions(options); + return this; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/PasswordLockOption.java b/src/main/java/net/sf/jsqlparser/statement/create/user/PasswordLockOption.java new file mode 100644 index 0000000000..2124454b70 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/PasswordLockOption.java @@ -0,0 +1,123 @@ +/*- + * #%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.user; + +import java.io.Serializable; + +/** + * A MySQL account password-management or locking option. The option either has no argument, a + * number ({@link #getValue()}) or a keyword ({@link #getSetting()}): + * + *
    + *
  • {@code ACCOUNT LOCK}, {@code ACCOUNT UNLOCK}
  • + *
  • {@code PASSWORD EXPIRE [DEFAULT | NEVER | INTERVAL n DAY]}
  • + *
  • {@code PASSWORD HISTORY {DEFAULT | n}}
  • + *
  • {@code PASSWORD REUSE INTERVAL {DEFAULT | n DAY}}
  • + *
  • {@code PASSWORD REQUIRE CURRENT [DEFAULT | OPTIONAL]}
  • + *
  • {@code FAILED_LOGIN_ATTEMPTS n}
  • + *
  • {@code PASSWORD_LOCK_TIME {n | UNBOUNDED}}
  • + *
+ */ +public class PasswordLockOption implements Serializable { + + public enum Kind { + ACCOUNT_LOCK, ACCOUNT_UNLOCK, PASSWORD_EXPIRE, PASSWORD_HISTORY, PASSWORD_REUSE_INTERVAL, PASSWORD_REQUIRE_CURRENT, FAILED_LOGIN_ATTEMPTS, PASSWORD_LOCK_TIME + } + + /** Keyword arguments of the options. */ + public enum Setting { + DEFAULT, NEVER, OPTIONAL, UNBOUNDED + } + + private Kind kind; + private Long value; + private Setting setting; + + public PasswordLockOption() { + // empty constructor + } + + public PasswordLockOption(Kind kind) { + this.kind = kind; + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = kind; + } + + /** The count or number of days, or null when the option has no numeric argument. */ + public Long getValue() { + return value; + } + + public void setValue(Long value) { + this.value = value; + } + + /** The keyword argument, or null when the option has none. */ + public Setting getSetting() { + return setting; + } + + public void setSetting(Setting setting) { + this.setting = setting; + } + + @Override + public String toString() { + switch (kind) { + case ACCOUNT_LOCK: + return "ACCOUNT LOCK"; + case ACCOUNT_UNLOCK: + return "ACCOUNT UNLOCK"; + case PASSWORD_EXPIRE: + return "PASSWORD EXPIRE" + + (value != null ? " INTERVAL " + value + " DAY" : argument("")); + case PASSWORD_HISTORY: + return "PASSWORD HISTORY" + argument(""); + case PASSWORD_REUSE_INTERVAL: + return "PASSWORD REUSE INTERVAL" + argument(" DAY"); + case PASSWORD_REQUIRE_CURRENT: + return "PASSWORD REQUIRE CURRENT" + argument(""); + case FAILED_LOGIN_ATTEMPTS: + return "FAILED_LOGIN_ATTEMPTS" + argument(""); + case PASSWORD_LOCK_TIME: + return "PASSWORD_LOCK_TIME" + argument(""); + default: + throw new IllegalStateException("Unsupported option: " + kind); + } + } + + private String argument(String unit) { + if (setting != null) { + return " " + setting; + } + return value != null ? " " + value + unit : ""; + } + + public PasswordLockOption withKind(Kind kind) { + setKind(kind); + return this; + } + + public PasswordLockOption withValue(Long value) { + setValue(value); + return this; + } + + public PasswordLockOption withSetting(Setting setting) { + setSetting(setting); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/ResourceLimit.java b/src/main/java/net/sf/jsqlparser/statement/create/user/ResourceLimit.java new file mode 100644 index 0000000000..22ce1e36a4 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/ResourceLimit.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.user; + +import java.io.Serializable; + +/** One limit of the MySQL account {@code WITH} clause, such as {@code MAX_USER_CONNECTIONS 10}. */ +public class ResourceLimit implements Serializable { + + public enum Kind { + MAX_QUERIES_PER_HOUR, MAX_UPDATES_PER_HOUR, MAX_CONNECTIONS_PER_HOUR, MAX_USER_CONNECTIONS + } + + private Kind kind; + private long value; + + public ResourceLimit() { + // empty constructor + } + + public ResourceLimit(Kind kind, long value) { + this.kind = kind; + this.value = value; + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = kind; + } + + public long getValue() { + return value; + } + + public void setValue(long value) { + this.value = value; + } + + @Override + public String toString() { + return kind + " " + value; + } + + public ResourceLimit withKind(Kind kind) { + setKind(kind); + return this; + } + + public ResourceLimit withValue(long value) { + setValue(value); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/RoleSelection.java b/src/main/java/net/sf/jsqlparser/statement/create/user/RoleSelection.java new file mode 100644 index 0000000000..eb78089c30 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/RoleSelection.java @@ -0,0 +1,100 @@ +/*- + * #%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.user; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +/** + * The roles named by MySQL {@code SET ROLE}, {@code SET DEFAULT ROLE}, the {@code DEFAULT ROLE} + * clause of {@code CREATE USER} and {@code ALTER USER}, and {@code GRANT ... AS user WITH ROLE}. + * Role names use the account syntax, so each role is a {@link UserAccount} without authentication. + */ +public class RoleSelection implements Serializable { + + public enum Kind { + /** + * {@code DEFAULT}: the account's default roles, only in {@code SET ROLE} and + * {@code WITH ROLE}. + */ + DEFAULT, + /** {@code NONE}. */ + NONE, + /** {@code ALL}. */ + ALL, + /** {@code ALL EXCEPT role [, role] ...}, only in {@code SET ROLE} and {@code WITH ROLE}. */ + ALL_EXCEPT, + /** {@code role [, role] ...}. */ + ROLES + } + + private Kind kind; + private final List roles = new ArrayList<>(); + + public RoleSelection() { + // empty constructor + } + + public RoleSelection(Kind kind) { + this.kind = kind; + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = kind; + } + + /** Returns the listed roles of {@link Kind#ROLES} and {@link Kind#ALL_EXCEPT}. */ + public List getRoles() { + return Collections.unmodifiableList(roles); + } + + public void setRoles(Collection roles) { + this.roles.clear(); + if (roles != null) { + this.roles.addAll(roles); + } + } + + @Override + public String toString() { + String names = roles.stream().map(Object::toString).collect(Collectors.joining(", ")); + switch (kind) { + case ROLES: + return names; + case ALL_EXCEPT: + return "ALL EXCEPT " + names; + default: + return kind.name(); + } + } + + public RoleSelection withKind(Kind kind) { + setKind(kind); + return this; + } + + public RoleSelection withRoles(Collection roles) { + setRoles(roles); + return this; + } + + public RoleSelection addRoles(UserAccount... roles) { + Collections.addAll(this.roles, roles); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/TlsOption.java b/src/main/java/net/sf/jsqlparser/statement/create/user/TlsOption.java new file mode 100644 index 0000000000..75a967f260 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/TlsOption.java @@ -0,0 +1,99 @@ +/*- + * #%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.user; + +import java.io.Serializable; +import net.sf.jsqlparser.expression.StringValue; + +/** + * One requirement of the MySQL account {@code REQUIRE} clause. {@code REQUIRE NONE} is a single + * {@link Kind#NONE} option; {@code CIPHER}, {@code ISSUER} and {@code SUBJECT} carry a string. + */ +public class TlsOption implements Serializable { + + public enum Kind { + NONE, SSL, X509, CIPHER, ISSUER, SUBJECT; + + /** Whether the option is followed by a string value. */ + public boolean hasValue() { + return this == CIPHER || this == ISSUER || this == SUBJECT; + } + } + + private Kind kind; + private StringValue value; + private boolean andKeyword; + + public TlsOption() { + // empty constructor + } + + public TlsOption(Kind kind) { + this.kind = kind; + } + + public TlsOption(Kind kind, StringValue value) { + this.kind = kind; + this.value = value; + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = kind; + } + + public StringValue getValue() { + return value; + } + + public void setValue(StringValue value) { + this.value = value; + } + + /** Whether {@code AND} is written before this option. */ + public boolean isAndKeyword() { + return andKeyword; + } + + public void setAndKeyword(boolean andKeyword) { + this.andKeyword = andKeyword; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + if (andKeyword) { + builder.append("AND "); + } + builder.append(kind); + if (value != null) { + builder.append(' ').append(value); + } + return builder.toString(); + } + + public TlsOption withKind(Kind kind) { + setKind(kind); + return this; + } + + public TlsOption withValue(StringValue value) { + setValue(value); + return this; + } + + public TlsOption withAndKeyword(boolean andKeyword) { + setAndKeyword(andKeyword); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/UserAccount.java b/src/main/java/net/sf/jsqlparser/statement/create/user/UserAccount.java index e149cb4b77..2606868a6a 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/user/UserAccount.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/UserAccount.java @@ -10,14 +10,27 @@ package net.sf.jsqlparser.statement.create.user; import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; import net.sf.jsqlparser.expression.StringValue; -/** A user and optional host together with its authentication clause. */ +/** + * A user and optional host together with its authentication clause. The current user may be named + * {@code CURRENT_USER} or {@code CURRENT_USER()}. MySQL multi-factor authentication adds the second + * and third factor of {@code CREATE USER ... IDENTIFIED ... AND IDENTIFIED ...} in + * {@link #getAdditionalAuthentications()}, and the factor changes and registration steps of + * {@code ALTER USER} in {@link #getFactorOperations()}. + */ public class UserAccount implements Serializable { private StringValue user; private StringValue host; private UserAuthentication authentication; + private boolean currentUserParentheses; + private final List additionalAuthentications = new ArrayList<>(); + private final List factorOperations = new ArrayList<>(); public StringValue getUser() { return user; @@ -35,6 +48,15 @@ public void setHost(StringValue host) { this.host = host; } + /** Whether the user is written {@code CURRENT_USER()}. */ + public boolean isCurrentUserParentheses() { + return currentUserParentheses; + } + + public void setCurrentUserParentheses(boolean currentUserParentheses) { + this.currentUserParentheses = currentUserParentheses; + } + public UserAuthentication getAuthentication() { return authentication; } @@ -43,15 +65,56 @@ public void setAuthentication(UserAuthentication authentication) { this.authentication = authentication; } + /** + * The authentication of the second and third factor, each written {@code AND IDENTIFIED ...} + * after the first one in {@code CREATE USER}; empty, never null, when none are given. + */ + public List getAdditionalAuthentications() { + return Collections.unmodifiableList(additionalAuthentications); + } + + public void setAdditionalAuthentications( + Collection additionalAuthentications) { + this.additionalAuthentications.clear(); + if (additionalAuthentications != null) { + this.additionalAuthentications.addAll(additionalAuthentications); + } + } + + /** + * The {@code ADD}, {@code MODIFY} and {@code DROP} factor changes, or the single registration + * step, of an {@code ALTER USER} account in source order; empty, never null, when none are + * given. + */ + public List getFactorOperations() { + return Collections.unmodifiableList(factorOperations); + } + + public void setFactorOperations(Collection factorOperations) { + this.factorOperations.clear(); + if (factorOperations != null) { + this.factorOperations.addAll(factorOperations); + } + } + @Override public String toString() { StringBuilder builder = new StringBuilder().append(user); + if (currentUserParentheses) { + builder.append("()"); + } if (host != null) { builder.append("@").append(host); } if (authentication != null) { builder.append(" ").append(authentication); } + for (UserAuthentication additional : additionalAuthentications) { + builder.append(" AND ").append(additional); + } + for (UserFactorOperation operation : factorOperations) { + builder.append(" ").append(operation); + } return builder.toString(); } @@ -65,8 +128,36 @@ public UserAccount withHost(StringValue host) { return this; } + public UserAccount withCurrentUserParentheses(boolean currentUserParentheses) { + setCurrentUserParentheses(currentUserParentheses); + return this; + } + public UserAccount withAuthentication(UserAuthentication authentication) { setAuthentication(authentication); return this; } + + public UserAccount withAdditionalAuthentications( + Collection additionalAuthentications) { + setAdditionalAuthentications(additionalAuthentications); + return this; + } + + public UserAccount addAdditionalAuthentications( + UserAuthentication... additionalAuthentications) { + Collections.addAll(this.additionalAuthentications, additionalAuthentications); + return this; + } + + public UserAccount withFactorOperations( + Collection factorOperations) { + setFactorOperations(factorOperations); + return this; + } + + public UserAccount addFactorOperations(UserFactorOperation... factorOperations) { + Collections.addAll(this.factorOperations, factorOperations); + return this; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/UserAuthentication.java b/src/main/java/net/sf/jsqlparser/statement/create/user/UserAuthentication.java index d05e76af91..d63889ccdb 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/user/UserAuthentication.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/UserAuthentication.java @@ -10,18 +10,37 @@ package net.sf.jsqlparser.statement.create.user; import java.io.Serializable; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.HexValue; import net.sf.jsqlparser.expression.StringValue; -/** Structured authentication clause of a MySQL user account. */ +/** + * Structured authentication clause of a MySQL user account. {@code ALTER USER} adds + * {@code REPLACE 'current'} and {@code RETAIN CURRENT PASSWORD} to a password assignment, and + * {@code DISCARD OLD PASSWORD} as a mode of its own. The plugin name keeps its quote character, as + * in {@code IDENTIFIED WITH 'caching_sha2_password'}, and the hash of {@code AS} may be a + * hexadecimal literal, as SHOW CREATE USER prints it. {@code CREATE USER} may give a passwordless + * plugin a temporary first factor, {@code IDENTIFIED WITH plugin INITIAL AUTHENTICATION IDENTIFIED + * ...}, kept in {@link #getInitialAuthentication()}. + */ public class UserAuthentication implements Serializable { public enum Mode { - BY_PASSWORD, BY_RANDOM_PASSWORD, WITH_PLUGIN, WITH_PLUGIN_BY_PASSWORD, WITH_PLUGIN_BY_RANDOM_PASSWORD, WITH_PLUGIN_AS_STRING + BY_PASSWORD, BY_RANDOM_PASSWORD, WITH_PLUGIN, WITH_PLUGIN_BY_PASSWORD, WITH_PLUGIN_BY_RANDOM_PASSWORD, WITH_PLUGIN_AS_STRING, DISCARD_OLD_PASSWORD; + + /** Whether this mode assigns a new password, which REPLACE and RETAIN may follow. */ + public boolean isPasswordAssignment() { + return this == BY_PASSWORD || this == BY_RANDOM_PASSWORD + || this == WITH_PLUGIN_BY_PASSWORD || this == WITH_PLUGIN_BY_RANDOM_PASSWORD; + } } private Mode mode; - private String plugin; - private StringValue credential; + private StringValue pluginName; + private Expression credential; + private StringValue currentCredential; + private boolean retainCurrentPassword; + private UserAuthentication initialAuthentication; public Mode getMode() { return mode; @@ -31,37 +50,115 @@ public void setMode(Mode mode) { this.mode = mode; } + /** The plugin name without its quotes, or null without {@code IDENTIFIED WITH}. */ public String getPlugin() { - return plugin; + return pluginName == null ? null : pluginName.getValue(); } + /** Sets an unquoted plugin name. */ public void setPlugin(String plugin) { - this.plugin = plugin; + this.pluginName = + plugin == null ? null : new StringValue().withValue(plugin).setQuoteStr(""); + } + + /** The plugin name with its quote character, which is empty for an unquoted name. */ + public StringValue getPluginName() { + return pluginName; + } + + public void setPluginName(StringValue pluginName) { + this.pluginName = pluginName; } + /** + * The password or hash as a string literal, or null when there is none or the hash of + * {@code AS} is a hexadecimal literal; {@link #getCredentialValue()} returns either. + */ public StringValue getCredential() { - return credential; + return credential instanceof StringValue ? (StringValue) credential : null; } public void setCredential(StringValue credential) { this.credential = credential; } + /** The password or hash as written: a {@link StringValue}, or a {@link HexValue} after AS. */ + public Expression getCredentialValue() { + return credential; + } + + public void setCredentialValue(Expression credential) { + if (credential != null && !(credential instanceof StringValue) + && !(credential instanceof HexValue)) { + throw new IllegalArgumentException( + "A credential is a string or hexadecimal literal: " + credential); + } + this.credential = credential; + } + + /** The current password of {@code REPLACE 'current'}, or null when omitted. */ + public StringValue getCurrentCredential() { + return currentCredential; + } + + public void setCurrentCredential(StringValue currentCredential) { + this.currentCredential = currentCredential; + } + + /** Whether {@code RETAIN CURRENT PASSWORD} keeps the replaced password as a secondary one. */ + public boolean isRetainCurrentPassword() { + return retainCurrentPassword; + } + + public void setRetainCurrentPassword(boolean retainCurrentPassword) { + this.retainCurrentPassword = retainCurrentPassword; + } + + /** + * The authentication after {@code INITIAL AUTHENTICATION}, which registers the device of a + * passwordless plugin, or null when omitted. MySQL writes it as {@code IDENTIFIED BY 'auth'}, + * {@code IDENTIFIED BY RANDOM PASSWORD} or {@code IDENTIFIED WITH plugin AS 'hash'}, after + * {@code IDENTIFIED WITH plugin} only. + */ + public UserAuthentication getInitialAuthentication() { + return initialAuthentication; + } + + public void setInitialAuthentication(UserAuthentication initialAuthentication) { + this.initialAuthentication = initialAuthentication; + } + @Override public String toString() { + StringBuilder builder = new StringBuilder(modeToString()); + if (initialAuthentication != null) { + builder.append(" INITIAL AUTHENTICATION ").append(initialAuthentication); + } + if (currentCredential != null) { + builder.append(" REPLACE ").append(currentCredential); + } + if (retainCurrentPassword) { + builder.append(" RETAIN CURRENT PASSWORD"); + } + return builder.toString(); + } + + private String modeToString() { switch (mode) { case BY_PASSWORD: return "IDENTIFIED BY " + credential; case BY_RANDOM_PASSWORD: return "IDENTIFIED BY RANDOM PASSWORD"; case WITH_PLUGIN: - return "IDENTIFIED WITH " + plugin; + return "IDENTIFIED WITH " + pluginName; case WITH_PLUGIN_BY_PASSWORD: - return "IDENTIFIED WITH " + plugin + " BY " + credential; + return "IDENTIFIED WITH " + pluginName + " BY " + credential; case WITH_PLUGIN_BY_RANDOM_PASSWORD: - return "IDENTIFIED WITH " + plugin + " BY RANDOM PASSWORD"; + return "IDENTIFIED WITH " + pluginName + " BY RANDOM PASSWORD"; case WITH_PLUGIN_AS_STRING: - return "IDENTIFIED WITH " + plugin + " AS " + credential; + return "IDENTIFIED WITH " + pluginName + " AS " + credential; + case DISCARD_OLD_PASSWORD: + return "DISCARD OLD PASSWORD"; default: throw new IllegalStateException("Unsupported authentication mode: " + mode); } @@ -77,8 +174,34 @@ public UserAuthentication withPlugin(String plugin) { return this; } + public UserAuthentication withPluginName(StringValue pluginName) { + setPluginName(pluginName); + return this; + } + public UserAuthentication withCredential(StringValue credential) { setCredential(credential); return this; } + + public UserAuthentication withCredentialValue(Expression credential) { + setCredentialValue(credential); + return this; + } + + public UserAuthentication withCurrentCredential(StringValue currentCredential) { + setCurrentCredential(currentCredential); + return this; + } + + public UserAuthentication withRetainCurrentPassword(boolean retainCurrentPassword) { + setRetainCurrentPassword(retainCurrentPassword); + return this; + } + + public UserAuthentication withInitialAuthentication( + UserAuthentication initialAuthentication) { + setInitialAuthentication(initialAuthentication); + return this; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/UserFactorOperation.java b/src/main/java/net/sf/jsqlparser/statement/create/user/UserFactorOperation.java new file mode 100644 index 0000000000..8b4a4eda16 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/UserFactorOperation.java @@ -0,0 +1,140 @@ +/*- + * #%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.user; + +import java.io.Serializable; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.StringValue; + +/** + * One multi-factor authentication change of a MySQL {@code ALTER USER} account: + * {@code ADD factor IDENTIFIED ...}, {@code MODIFY factor IDENTIFIED ...}, {@code DROP factor}, or + * a registration step of a passwordless device, {@code factor INITIATE REGISTRATION}, + * {@code factor FINISH REGISTRATION SET CHALLENGE_RESPONSE AS '...'} and {@code factor UNREGISTER}. + * The factor is written {@code 2 FACTOR} or {@code 3 FACTOR}; the server checks the number when it + * executes the statement. + */ +public class UserFactorOperation implements Serializable { + + public enum Operation { + ADD, MODIFY, DROP, INITIATE_REGISTRATION, FINISH_REGISTRATION, UNREGISTER; + + /** Whether an {@code IDENTIFIED} clause follows the factor, as for ADD and MODIFY. */ + public boolean hasAuthentication() { + return this == ADD || this == MODIFY; + } + + /** Whether this is a registration step, written after the factor. */ + public boolean isRegistration() { + return this == INITIATE_REGISTRATION || this == FINISH_REGISTRATION + || this == UNREGISTER; + } + } + + private Operation operation; + private int factor; + private UserAuthentication authentication; + private Expression challengeResponse; + + public UserFactorOperation() { + // for the fluent setters + } + + public UserFactorOperation(Operation operation, int factor) { + this.operation = operation; + this.factor = factor; + } + + public Operation getOperation() { + return operation; + } + + public void setOperation(Operation operation) { + this.operation = operation; + } + + /** The factor number of {@code n FACTOR}: 2 or 3 in a statement the server executes. */ + public int getFactor() { + return factor; + } + + public void setFactor(int factor) { + this.factor = factor; + } + + /** The authentication of the added or modified factor, or null for the other operations. */ + public UserAuthentication getAuthentication() { + return authentication; + } + + public void setAuthentication(UserAuthentication authentication) { + this.authentication = authentication; + } + + /** + * The value after {@code SET CHALLENGE_RESPONSE AS} of FINISH REGISTRATION: a + * {@link StringValue} or a {@link HexValue}, or null for the other operations. + */ + public Expression getChallengeResponse() { + return challengeResponse; + } + + public void setChallengeResponse(Expression challengeResponse) { + if (challengeResponse != null && !(challengeResponse instanceof StringValue) + && !(challengeResponse instanceof HexValue)) { + throw new IllegalArgumentException( + "A challenge response is a string or hexadecimal literal: " + + challengeResponse); + } + this.challengeResponse = challengeResponse; + } + + @Override + public String toString() { + String factorClause = factor + " FACTOR"; + switch (operation) { + case ADD: + case MODIFY: + return operation + " " + factorClause + " " + authentication; + case DROP: + return "DROP " + factorClause; + case INITIATE_REGISTRATION: + return factorClause + " INITIATE REGISTRATION"; + case FINISH_REGISTRATION: + return factorClause + " FINISH REGISTRATION SET CHALLENGE_RESPONSE AS " + + challengeResponse; + case UNREGISTER: + return factorClause + " UNREGISTER"; + default: + throw new IllegalStateException("Unsupported factor operation: " + operation); + } + } + + public UserFactorOperation withOperation(Operation operation) { + setOperation(operation); + return this; + } + + public UserFactorOperation withFactor(int factor) { + setFactor(factor); + return this; + } + + public UserFactorOperation withAuthentication(UserAuthentication authentication) { + setAuthentication(authentication); + return this; + } + + public UserFactorOperation withChallengeResponse(Expression challengeResponse) { + setChallengeResponse(challengeResponse); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/user/UserOptions.java b/src/main/java/net/sf/jsqlparser/statement/create/user/UserOptions.java new file mode 100644 index 0000000000..84233c83a5 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/user/UserOptions.java @@ -0,0 +1,187 @@ +/*- + * #%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.user; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.expression.StringValue; + +/** + * The account options shared by MySQL {@code CREATE USER} and {@code ALTER USER}, rendered in the + * clause order MySQL requires: + * + *
+ * [DEFAULT ROLE ...] [REQUIRE ...] [WITH resource_limit ...]
+ * [password_or_lock_option ...] [COMMENT '...' | ATTRIBUTE '...']
+ * 
+ * + * Absent clauses are null or empty; nothing is filled in with server defaults. + */ +public class UserOptions implements Serializable { + + private RoleSelection defaultRoles; + private final List tlsOptions = new ArrayList<>(); + private final List resourceLimits = new ArrayList<>(); + private final List passwordLockOptions = new ArrayList<>(); + private StringValue comment; + private StringValue attribute; + + /** + * The {@code DEFAULT ROLE} clause: a role list for {@code CREATE USER}, also {@code NONE} or + * {@code ALL} for {@code ALTER USER}. Null when omitted. + */ + public RoleSelection getDefaultRoles() { + return defaultRoles; + } + + public void setDefaultRoles(RoleSelection defaultRoles) { + this.defaultRoles = defaultRoles; + } + + /** The {@code REQUIRE} options in source order; empty when the clause is omitted. */ + public List getTlsOptions() { + return Collections.unmodifiableList(tlsOptions); + } + + public void setTlsOptions(Collection tlsOptions) { + replace(this.tlsOptions, tlsOptions); + } + + /** The {@code WITH} resource limits in source order; empty when the clause is omitted. */ + public List getResourceLimits() { + return Collections.unmodifiableList(resourceLimits); + } + + public void setResourceLimits(Collection resourceLimits) { + replace(this.resourceLimits, resourceLimits); + } + + /** The password-management and locking options in source order, repetitions included. */ + public List getPasswordLockOptions() { + return Collections.unmodifiableList(passwordLockOptions); + } + + public void setPasswordLockOptions( + Collection passwordLockOptions) { + replace(this.passwordLockOptions, passwordLockOptions); + } + + public StringValue getComment() { + return comment; + } + + public void setComment(StringValue comment) { + this.comment = comment; + } + + /** The {@code ATTRIBUTE} JSON object string, which MySQL accepts instead of a comment. */ + public StringValue getAttribute() { + return attribute; + } + + public void setAttribute(StringValue attribute) { + this.attribute = attribute; + } + + /** Whether no clause is present. */ + public boolean isEmpty() { + return defaultRoles == null && tlsOptions.isEmpty() && resourceLimits.isEmpty() + && passwordLockOptions.isEmpty() && comment == null && attribute == null; + } + + /** Appends each present clause preceded by a space. */ + public StringBuilder appendTo(StringBuilder builder) { + if (defaultRoles != null) { + builder.append(" DEFAULT ROLE ").append(defaultRoles); + } + if (!tlsOptions.isEmpty()) { + builder.append(" REQUIRE ").append(join(tlsOptions)); + } + if (!resourceLimits.isEmpty()) { + builder.append(" WITH ").append(join(resourceLimits)); + } + if (!passwordLockOptions.isEmpty()) { + builder.append(' ').append(join(passwordLockOptions)); + } + if (comment != null) { + builder.append(" COMMENT ").append(comment); + } + if (attribute != null) { + builder.append(" ATTRIBUTE ").append(attribute); + } + return builder; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString().trim(); + } + + public UserOptions withDefaultRoles(RoleSelection defaultRoles) { + setDefaultRoles(defaultRoles); + return this; + } + + public UserOptions withTlsOptions(Collection tlsOptions) { + setTlsOptions(tlsOptions); + return this; + } + + public UserOptions addTlsOptions(TlsOption... tlsOptions) { + Collections.addAll(this.tlsOptions, tlsOptions); + return this; + } + + public UserOptions withResourceLimits(Collection resourceLimits) { + setResourceLimits(resourceLimits); + return this; + } + + public UserOptions addResourceLimits(ResourceLimit... resourceLimits) { + Collections.addAll(this.resourceLimits, resourceLimits); + return this; + } + + public UserOptions withPasswordLockOptions( + Collection passwordLockOptions) { + setPasswordLockOptions(passwordLockOptions); + return this; + } + + public UserOptions addPasswordLockOptions(PasswordLockOption... passwordLockOptions) { + Collections.addAll(this.passwordLockOptions, passwordLockOptions); + return this; + } + + public UserOptions withComment(StringValue comment) { + setComment(comment); + return this; + } + + public UserOptions withAttribute(StringValue attribute) { + setAttribute(attribute); + return this; + } + + private static void replace(List target, Collection source) { + target.clear(); + if (source != null) { + target.addAll(source); + } + } + + private static String join(List items) { + return items.stream().map(Object::toString).collect(Collectors.joining(" ")); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/usermapping/CreateUserMapping.java b/src/main/java/net/sf/jsqlparser/statement/create/usermapping/CreateUserMapping.java new file mode 100644 index 0000000000..5502ddb1ed --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/usermapping/CreateUserMapping.java @@ -0,0 +1,61 @@ +/*- + * #%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.usermapping; + +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.foreign.ForeignDataStatement; + +public class CreateUserMapping extends ForeignDataStatement { + private String user; + private String server; + private boolean ifNotExists; + + public String getUser() { + return user; + } + + public void setUser(String value) { + user = value; + } + + public String getServer() { + return server; + } + + public void setServer(String value) { + server = value; + } + + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean value) { + ifNotExists = value; + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } + + @Override + public StringBuilder appendTo(StringBuilder sql, Consumer printer) { + sql.append("CREATE USER MAPPING "); + if (ifNotExists) { + sql.append("IF NOT EXISTS "); + } + sql.append("FOR ").append(user).append(" SERVER ").append(server); + appendOptionsTo(sql, printer); + return sql; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/view/AlterView.java b/src/main/java/net/sf/jsqlparser/statement/create/view/AlterView.java index 079f70bd37..44430df573 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/view/AlterView.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/view/AlterView.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.create.view; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; @@ -21,7 +22,37 @@ import java.util.List; import java.util.Optional; -public class AlterView implements Statement { +public class AlterView extends ASTNodeAccessImpl implements Statement { + + private MySqlViewOptions mySqlOptions; + + public MySqlViewOptions getMySqlOptions() { + return mySqlOptions; + } + + public void setMySqlOptions(MySqlViewOptions mySqlOptions) { + this.mySqlOptions = mySqlOptions; + } + + public void appendMySqlOptionsTo(StringBuilder builder) { + if (mySqlOptions != null) { + mySqlOptions.appendTo(builder); + } + } + + private CreateView.CheckOption checkOption; + + public CreateView.CheckOption getCheckOption() { + return checkOption; + } + + public void setCheckOption(CreateView.CheckOption checkOption) { + this.checkOption = checkOption; + } + + public void appendCheckOptionTo(StringBuilder sql) { + CreateView.appendCheckOptionTo(sql, checkOption); + } private Table view; private Select select; @@ -68,12 +99,14 @@ public String toString() { } else { sql = new StringBuilder("ALTER "); } + appendMySqlOptionsTo(sql); sql.append("VIEW "); sql.append(view); if (columnNames != null) { sql.append(PlainSelect.getStringList(columnNames, true, true)); } sql.append(" AS ").append(select); + appendCheckOptionTo(sql); return sql.toString(); } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/view/CreateView.java b/src/main/java/net/sf/jsqlparser/statement/create/view/CreateView.java index 3747023fd2..72e83f546d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/view/CreateView.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/view/CreateView.java @@ -13,15 +13,32 @@ import java.util.List; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.IndexOption; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.Select; -public class CreateView implements Statement { +public class CreateView extends ASTNodeAccessImpl implements Statement { + + private MySqlViewOptions mySqlOptions; + + public MySqlViewOptions getMySqlOptions() { + return mySqlOptions; + } + + public void setMySqlOptions(MySqlViewOptions mySqlOptions) { + this.mySqlOptions = mySqlOptions; + } + + public void appendMySqlOptionsTo(StringBuilder builder) { + if (mySqlOptions != null) { + mySqlOptions.appendTo(builder); + } + } private Table view; private Select select; @@ -40,7 +57,7 @@ public class CreateView implements Statement { private boolean ifNotExistsAfterViewName; private List options; private String accessMethod; - private List storageParameters; + private List storageParameters; private String tableSpace; private CheckOption checkOption; private Boolean withData; @@ -83,11 +100,11 @@ public void setAccessMethod(String accessMethod) { this.accessMethod = accessMethod; } - public List getStorageParameters() { + public List getStorageParameters() { return storageParameters; } - public void setStorageParameters(List storageParameters) { + public void setStorageParameters(List storageParameters) { this.storageParameters = storageParameters == null ? null : new ArrayList<>(storageParameters); } @@ -271,6 +288,7 @@ public String toString() { if (isOrReplace()) { sql.append("OR REPLACE "); } + appendMySqlOptionsTo(sql); appendForceOptionIfApplicable(sql); if (secure) { sql.append("SECURE "); @@ -328,7 +346,7 @@ public void appendParametersTo(StringBuilder sql) { } } - public void appendOptionsAfterQueryTo(StringBuilder sql) { + public static void appendCheckOptionTo(StringBuilder sql, CheckOption checkOption) { if (checkOption != null) { sql.append(" WITH "); if (checkOption != CheckOption.DEFAULT) { @@ -336,6 +354,10 @@ public void appendOptionsAfterQueryTo(StringBuilder sql) { } sql.append("CHECK OPTION"); } + } + + public void appendOptionsAfterQueryTo(StringBuilder sql) { + appendCheckOptionTo(sql, checkOption); if (withData != null) { sql.append(withData ? " WITH DATA" : " WITH NO DATA"); } diff --git a/src/main/java/net/sf/jsqlparser/statement/create/view/MySqlViewOptions.java b/src/main/java/net/sf/jsqlparser/statement/create/view/MySqlViewOptions.java new file mode 100644 index 0000000000..e828ddf3f9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/view/MySqlViewOptions.java @@ -0,0 +1,71 @@ +/*- + * #%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.view; + +import java.io.Serializable; +import net.sf.jsqlparser.statement.MySqlDefiner; + +/** Prefix options shared by MySQL CREATE VIEW and ALTER VIEW. */ +public class MySqlViewOptions implements Serializable { + public enum Algorithm { + UNDEFINED, MERGE, TEMPTABLE + } + + public enum Security { + DEFINER, INVOKER + } + + private Algorithm algorithm; + private MySqlDefiner definer; + private Security security; + + public Algorithm getAlgorithm() { + return algorithm; + } + + public void setAlgorithm(Algorithm algorithm) { + this.algorithm = algorithm; + } + + public MySqlDefiner getDefiner() { + return definer; + } + + public void setDefiner(MySqlDefiner definer) { + this.definer = definer; + } + + public Security getSecurity() { + return security; + } + + public void setSecurity(Security security) { + this.security = security; + } + + public void appendTo(StringBuilder builder) { + if (algorithm != null) { + builder.append("ALGORITHM = ").append(algorithm).append(' '); + } + if (definer != null) { + builder.append("DEFINER = ").append(definer).append(' '); + } + if (security != null) { + builder.append("SQL SECURITY ").append(security).append(' '); + } + } + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + appendTo(sql); + return sql.toString().trim(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/CloseCursorStatement.java b/src/main/java/net/sf/jsqlparser/statement/cursor/CloseCursorStatement.java new file mode 100644 index 0000000000..06a5cacb18 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/cursor/CloseCursorStatement.java @@ -0,0 +1,64 @@ +/*- + * #%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.cursor; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL {@code CLOSE {name | ALL}}, which closes one cursor or every open cursor of the + * session.
+ * Examples:
+ * CLOSE c
+ * CLOSE ALL
+ * + * @see PostgreSQL CLOSE + */ +public class CloseCursorStatement extends ASTNodeAccessImpl implements Statement { + private String cursorName; + + /** CLOSE ALL. */ + public CloseCursorStatement() {} + + public CloseCursorStatement(String cursorName) { + this.cursorName = cursorName; + } + + /** Returns null for CLOSE ALL. */ + public String getCursorName() { + return cursorName; + } + + /** A null name makes the statement CLOSE ALL. */ + public void setCursorName(String cursorName) { + this.cursorName = cursorName; + } + + /** Whether the statement is CLOSE ALL, which is when it has no cursor name. */ + public boolean isAll() { + return cursorName == null; + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + return builder.append("CLOSE ").append(isAll() ? "ALL" : cursorName); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/CursorOption.java b/src/main/java/net/sf/jsqlparser/statement/cursor/CursorOption.java new file mode 100644 index 0000000000..dc36372ba5 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/cursor/CursorOption.java @@ -0,0 +1,44 @@ +/*- + * #%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.cursor; + +/** + * An option of PostgreSQL's {@code DECLARE name [options] CURSOR}. PostgreSQL's grammar takes them + * in any order and repeated; the server rejects contradicting ones such as SCROLL and NO SCROLL + * when it runs the statement. + * + * @see PostgreSQL DECLARE + */ +public enum CursorOption { + /** Returns the rows in binary rather than text format. */ + BINARY("BINARY"), + + /** Leaves the visibility of later changes to the implementation. */ + ASENSITIVE("ASENSITIVE"), + + /** Hides later changes; PostgreSQL's cursors are always insensitive. */ + INSENSITIVE("INSENSITIVE"), + + /** Allows fetching backward. */ + SCROLL("SCROLL"), + + /** Forbids fetching backward. */ + NO_SCROLL("NO SCROLL"); + + private final String keyword; + + CursorOption(String keyword) { + this.keyword = keyword; + } + + public String getKeyword() { + return keyword; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/DeclareCursorStatement.java b/src/main/java/net/sf/jsqlparser/statement/cursor/DeclareCursorStatement.java new file mode 100644 index 0000000000..87ca339dcf --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/cursor/DeclareCursorStatement.java @@ -0,0 +1,129 @@ +/*- + * #%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.cursor; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.select.Select; + +/** + * PostgreSQL {@code DECLARE name [BINARY] [ASENSITIVE | INSENSITIVE] [[NO] SCROLL] CURSOR + * [{WITH | WITHOUT} HOLD] FOR query}, which defines a cursor over a SELECT, VALUES or TABLE query. + *
+ * Example:
+ * DECLARE c SCROLL CURSOR WITH HOLD FOR SELECT * FROM t
+ * It is not the SQL Server {@link net.sf.jsqlparser.statement.DeclareStatement DECLARE @variable}. + * + * @see PostgreSQL DECLARE + */ +public class DeclareCursorStatement extends ASTNodeAccessImpl implements Statement { + private String cursorName; + private final List options = new ArrayList<>(); + private Holdability holdability; + private Select query; + + public enum Holdability { + WITH_HOLD("WITH HOLD"), WITHOUT_HOLD("WITHOUT HOLD"); + + private final String keywords; + + Holdability(String keywords) { + this.keywords = keywords; + } + + public String getKeywords() { + return keywords; + } + } + + public DeclareCursorStatement() {} + + public DeclareCursorStatement(String cursorName, Select query) { + this.cursorName = cursorName; + this.query = query; + } + + public String getCursorName() { + return cursorName; + } + + public void setCursorName(String cursorName) { + this.cursorName = cursorName; + } + + /** The options between the name and CURSOR, in their order; the list is live. */ + public List getOptions() { + return options; + } + + public void setOptions(List options) { + this.options.clear(); + if (options != null) { + this.options.addAll(options); + } + } + + public DeclareCursorStatement addOptions(CursorOption... options) { + this.options.addAll(Arrays.asList(options)); + return this; + } + + /** Returns null when neither WITH HOLD nor WITHOUT HOLD is written. */ + public Holdability getHoldability() { + return holdability; + } + + public void setHoldability(Holdability holdability) { + this.holdability = holdability; + } + + public Select getQuery() { + return query; + } + + public void setQuery(Select query) { + this.query = query; + } + + @Override + public StringBuilder appendTo(StringBuilder builder) { + return appendTo(builder, builder::append); + } + + /** Renders the query through the caller's select writer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer
tables; private List usingFromItemList; + private List usingJoins; private List joins; private Expression where; + private String cursorName; private PreferringClause preferringClause; private Limit limit; private OptionClause option; @@ -129,11 +134,46 @@ public Delete withForPortionClause(ForPortionClause forPortionClause) { } public Table getTable() { - return table; + return tableReference.getTable(); } + /** Replaces the target table and keeps the inheritance scope of the target. */ public void setTable(Table name) { - table = name; + tableReference.setTable(name); + } + + /** + * The target as PostgreSQL's relation_expr_opt_alias: the table of {@link #getTable()} with its + * alias, and whether ONLY or * describes its inheritance scope. + */ + public TableReference getTableReference() { + return tableReference; + } + + public void setTableReference(TableReference tableReference) { + this.tableReference = Objects.requireNonNull(tableReference); + } + + public Delete withTableReference(TableReference tableReference) { + this.setTableReference(tableReference); + return this; + } + + /** + * The cursor of {@code WHERE CURRENT OF cursor}, which is written in place of the condition of + * {@link #getWhere()}. + */ + public String getCursorName() { + return cursorName; + } + + public void setCursorName(String cursorName) { + this.cursorName = cursorName; + } + + public Delete withCursorName(String cursorName) { + this.setCursorName(cursorName); + return this; } public Expression getWhere() { @@ -275,29 +315,24 @@ public String toString() { if (hasFrom) { b.append(" FROM"); } - b.append(" ").append(table); + tableReference.appendWithAliasTo(b.append(" ")); if (forPortionClause != null) { b.append(' ').append(forPortionClause); } + appendJoinsTo(b, joins); + if (usingFromItemList != null && !usingFromItemList.isEmpty()) { b.append(" USING "); b.append(usingFromItemList.stream() .map(Object::toString) .collect(joining(", "))); + appendJoinsTo(b, usingJoins); } - if (joins != null) { - for (Join join : joins) { - if (join.isSimple()) { - b.append(", ").append(join); - } else { - b.append(" ").append(join); - } - } - } - - if (where != null) { + if (cursorName != null) { + b.append(" WHERE CURRENT OF ").append(cursorName); + } else if (where != null) { b.append(" WHERE ").append(where); } @@ -541,4 +576,42 @@ public List getUsingFromItemList() { public void setUsingFromItemList(List usingFromItemList) { this.usingFromItemList = usingFromItemList; } + + /** + * Returns the joins after the USING items, as in MySQL's + * {@code DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id} or PostgreSQL's + * {@code DELETE FROM t USING s JOIN u ON s.id = u.id WHERE ...}, or {@code null}. They are + * rendered only when {@link #getUsingFromItemList()} is not empty. {@link #getJoins()} holds + * the joins of the target table, written before USING. + */ + public List getUsingJoins() { + return usingJoins; + } + + public void setUsingJoins(List usingJoins) { + this.usingJoins = usingJoins; + } + + public Delete withUsingJoins(List usingJoins) { + setUsingJoins(usingJoins); + return this; + } + + public Delete addUsingJoins(Join... usingJoins) { + List collection = Optional.ofNullable(getUsingJoins()).orElseGet(ArrayList::new); + Collections.addAll(collection, usingJoins); + return this.withUsingJoins(collection); + } + + private static void appendJoinsTo(StringBuilder b, List joins) { + if (joins != null) { + for (Join join : joins) { + if (join.isSimple()) { + b.append(", ").append(join); + } else { + b.append(" ").append(join); + } + } + } + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/drop/Drop.java b/src/main/java/net/sf/jsqlparser/statement/drop/Drop.java index 7b7e592321..42c914af79 100644 --- a/src/main/java/net/sf/jsqlparser/statement/drop/Drop.java +++ b/src/main/java/net/sf/jsqlparser/statement/drop/Drop.java @@ -17,27 +17,87 @@ import java.util.Locale; import java.util.Map; import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.CastSignature; +import net.sf.jsqlparser.statement.OperatorSignature; +import net.sf.jsqlparser.statement.RoutineReference; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.TransformSignature; +import net.sf.jsqlparser.statement.create.index.AlgorithmOrLockOption; +import net.sf.jsqlparser.statement.create.user.UserAccount; import net.sf.jsqlparser.statement.select.PlainSelect; -public class Drop implements Statement { +public class Drop extends ASTNodeAccessImpl implements Statement { public enum ObjectType { - DATABASE, EVENT, FUNCTION, INDEX, PROCEDURE, SCHEMA, SEQUENCE, SERVER, TABLE, TABLESPACE, TRIGGER, VIEW, OTHER + DATABASE, EVENT, FUNCTION, INDEX, PROCEDURE, SCHEMA, SEQUENCE, SERVER, TABLE, TABLESPACE, TRIGGER, VIEW, FOREIGN_TABLE, FOREIGN_DATA_WRAPPER, AGGREGATE, DOMAIN, EVENT_TRIGGER, GROUP, OWNED, ROLE, ROUTINE, RULE, TYPE, USER, SYNONYM, ACCESS_METHOD, LANGUAGE, OPERATOR_CLASS, OPERATOR_FAMILY, TEXT_SEARCH_CONFIGURATION, TEXT_SEARCH_DICTIONARY, TEXT_SEARCH_PARSER, TEXT_SEARCH_TEMPLATE, CAST, OPERATOR, TRANSFORM, RESOURCE_GROUP, SPATIAL_REFERENCE_SYSTEM, OTHER; + + /** Targets are {@link RoutineReference}s, each with an optional argument signature. */ + public boolean hasRoutineTargets() { + return this == FUNCTION || this == PROCEDURE || this == ROUTINE || this == AGGREGATE; + } + + /** Targets are role or MySQL account names, including the roles of DROP OWNED BY. */ + public boolean hasAccountTargets() { + return this == USER || this == ROLE || this == GROUP || this == OWNED; + } + + /** The target can name the table that owns it with ON. */ + public boolean hasOwnerTable() { + return this == INDEX || this == TRIGGER || this == RULE; + } + + /** The target is named within the index access method given with USING. */ + public boolean hasAccessMethod() { + return this == OPERATOR_CLASS || this == OPERATOR_FAMILY; + } } private String type; private ObjectType objectType = ObjectType.OTHER; private final List
names = new ArrayList<>(); + private final List routines = new ArrayList<>(); + private final List accounts = new ArrayList<>(); + private final List operators = new ArrayList<>(); + private CastSignature cast; + private TransformSignature transform; private List parameters; private Table table; private int tablePosition; + private final List algorithmOrLockOptions = new ArrayList<>(); + private Integer algorithmOrLockPosition; + private CascadeBehavior behavior; private Map> typeToParameters = new HashMap<>(); private boolean ifExists = false; private boolean materialized = false; + private boolean concurrently; + private boolean undo; + private boolean force; + private boolean publicSynonym; + private boolean procedural; + private String accessMethod; + private String engine; + private boolean engineUseEquals; + + /** PostgreSQL DROP INDEX CONCURRENTLY, preceding IF EXISTS and the index name. */ + public boolean isConcurrently() { + return concurrently; + } + + public void setConcurrently(boolean concurrently) { + this.concurrently = concurrently; + } + + public Drop withConcurrently(boolean concurrently) { + setConcurrently(concurrently); + return this; + } + private boolean isUsingTemporary; @@ -54,39 +114,251 @@ public T accept(StatementVisitor statementVisitor, S context) { } public Table getName() { - return names.isEmpty() ? null : names.get(0); + List
current = getNames(); + return current.isEmpty() ? null : current.get(0); } public void setName(Table name) { + useNameTargets(); names.clear(); if (name != null) { names.add(name); } } + /** + * Returns the dropped object names. Routine, account and operator targets return a read-only + * snapshot of their names; edit {@link #getRoutines()}, {@link #getAccounts()} or + * {@link #getOperators()} to change them. A cast or transform has no name. The name of a MySQL + * {@link ObjectType#SPATIAL_REFERENCE_SYSTEM} is its SRID as written. + */ public List
getNames() { + if (!routines.isEmpty()) { + return Collections.unmodifiableList(routines.stream() + .map(routine -> routine.getName() == null ? new Table() + : qualifiedTable(routine.getName())) + .collect(Collectors.toList())); + } + if (!accounts.isEmpty()) { + return Collections.unmodifiableList(accounts.stream() + .map(account -> new Table(account.toString(), false)) + .collect(Collectors.toList())); + } + if (!operators.isEmpty()) { + return Collections.unmodifiableList(operators.stream() + .map(operator -> operator.getOperator() == null ? new Table() + : new Table(operator.getOperator().getSchemaName(), + operator.getOperator().getName())) + .collect(Collectors.toList())); + } return Collections.unmodifiableList(names); } public void setNames(Collection names) { + useNameTargets(); this.names.clear(); if (names != null) { this.names.addAll(names); } } - /** Returns legacy tokens, including ON and its owner. Structured owners produce a snapshot. */ + /** + * Routine targets of DROP FUNCTION, PROCEDURE, ROUTINE and AGGREGATE. A routine without an + * argument list has null arguments; an explicit {@code ()} has an empty list. + */ + public List getRoutines() { + return Collections.unmodifiableList(routines); + } + + /** Replaces the targets with routines, discarding names, accounts and legacy parameters. */ + public void setRoutines(Collection routines) { + clearTargets(); + if (routines != null) { + this.routines.addAll(routines); + } + } + + public Drop withRoutines(Collection routines) { + setRoutines(routines); + return this; + } + + /** Appends routine targets. Name or account targets are discarded first. */ + public Drop addRoutines(RoutineReference... routines) { + if (routines.length > 0 && this.routines.isEmpty()) { + clearTargets(); + } + Collections.addAll(this.routines, routines); + return this; + } + + /** Role or MySQL account targets of DROP USER, ROLE, GROUP and the roles of DROP OWNED BY. */ + public List getAccounts() { + return Collections.unmodifiableList(accounts); + } + + /** Replaces the targets with accounts, discarding names, routines and legacy parameters. */ + public void setAccounts(Collection accounts) { + clearTargets(); + if (accounts != null) { + this.accounts.addAll(accounts); + } + } + + public Drop withAccounts(Collection accounts) { + setAccounts(accounts); + return this; + } + + /** Appends account targets. Name or routine targets are discarded first. */ + public Drop addAccounts(UserAccount... accounts) { + if (accounts.length > 0 && this.accounts.isEmpty()) { + clearTargets(); + } + Collections.addAll(this.accounts, accounts); + return this; + } + + /** + * PostgreSQL DROP OPERATOR targets, each an operator with its operand types. Oracle's + * {@code DROP OPERATOR name} keeps a plain name instead. + */ + public List getOperators() { + return Collections.unmodifiableList(operators); + } + + /** Replaces the targets with operators, discarding all other targets. */ + public void setOperators(Collection operators) { + clearTargets(); + if (operators != null) { + this.operators.addAll(operators); + } + } + + public Drop withOperators(Collection operators) { + setOperators(operators); + return this; + } + + /** Appends operator targets. Other targets are discarded first. */ + public Drop addOperators(OperatorSignature... operators) { + if (operators.length > 0 && this.operators.isEmpty()) { + clearTargets(); + } + Collections.addAll(this.operators, operators); + return this; + } + + /** The target of PostgreSQL DROP CAST, or null for other object types. */ + public CastSignature getCast() { + return cast; + } + + /** Replaces the targets with a cast, discarding all other targets. */ + public void setCast(CastSignature cast) { + clearTargets(); + this.cast = cast; + } + + public Drop withCast(CastSignature cast) { + setCast(cast); + return this; + } + + /** The target of PostgreSQL DROP TRANSFORM, or null for other object types. */ + public TransformSignature getTransform() { + return transform; + } + + /** Replaces the targets with a transform, discarding all other targets. */ + public void setTransform(TransformSignature transform) { + clearTargets(); + this.transform = transform; + } + + public Drop withTransform(TransformSignature transform) { + setTransform(transform); + return this; + } + + private void clearTargets() { + names.clear(); + routines.clear(); + accounts.clear(); + operators.clear(); + cast = null; + transform = null; + typeToParameters = new HashMap<>(); + } + + private boolean hasTypedTargets() { + return !routines.isEmpty() || !accounts.isEmpty() || !operators.isEmpty() || cast != null + || transform != null; + } + + /** + * Converts typed targets to the legacy representation before a legacy edit: the names, and the + * last routine's argument declarations as the single legacy signature. A cast or transform + * leaves no name. + */ + private void useNameTargets() { + if (!hasTypedTargets()) { + return; + } + List
legacyNames = new ArrayList<>(getNames()); + Map> legacyParameters = new HashMap<>(); + getTypeToParameters().forEach((key, value) -> legacyParameters.put(key, + value == null ? null : new ArrayList<>(value))); + clearTargets(); + names.addAll(legacyNames); + typeToParameters = legacyParameters; + } + + /** Splits a routine name at the dots outside quoted identifiers. */ + private static Table qualifiedTable(String name) { + List parts = new ArrayList<>(); + int start = 0; + char closingQuote = 0; + for (int i = 0; i < name.length(); i++) { + char ch = name.charAt(i); + if (closingQuote != 0) { + if (ch == closingQuote) { + closingQuote = 0; + } + } else if (ch == '"' || ch == '`') { + closingQuote = ch; + } else if (ch == '[') { + closingQuote = ']'; + } else if (ch == '.') { + parts.add(name.substring(start, i)); + start = i + 1; + } + } + parts.add(name.substring(start)); + return parts.size() == 1 ? new Table(parts.get(0), false) : new Table(parts); + } + + /** + * Returns the legacy tokens after the targets. With a structured ON table, ALGORITHM or LOCK + * clauses or CASCADE/RESTRICT behavior, this is a snapshot that includes them in source order; + * edit {@link #setTable}, {@link #getAlgorithmOrLockOptions()} or {@link #setBehavior} instead. + */ public List getParameters() { - if (table == null) { + if (table == null && algorithmOrLockOptions.isEmpty() && behavior == null) { return parameters; } - List tokens = parameters == null ? new ArrayList<>() : new ArrayList<>(parameters); - tokens.add(tablePosition, "ON"); - tokens.add(tablePosition + 1, table.toString()); + List tokens = new ArrayList<>(); + appendParameters(tokens::add, table -> tokens.add(table.toString())); + if (behavior != null) { + tokens.add(behavior.name()); + } return tokens; } - /** The table explicitly named by DROP INDEX ... ON, or null when SQL does not name one. */ + /** + * The table named by ON in DROP INDEX, DROP TRIGGER or DROP RULE, or null when SQL does not + * name one. + */ public Table getTable() { return table; } @@ -110,20 +382,145 @@ public Drop withTable(Table table) { return this; } - /** Visits table/view targets and explicit index owners without resolving catalog objects. */ + /** Visits table/view targets and explicit owner tables without resolving catalog objects. */ public void visitTables(Consumer
visitor) { - if (objectType == ObjectType.TABLE || objectType == ObjectType.VIEW) { + if (objectType == ObjectType.TABLE || objectType == ObjectType.VIEW + || objectType == ObjectType.FOREIGN_TABLE) { names.forEach(visitor); - } else if (objectType == ObjectType.INDEX && table != null) { + } else if (objectType.hasOwnerTable() && table != null) { visitor.accept(table); } } - /** Replaces all legacy parameters and clears the structured ON table. */ + /** + * Replaces all legacy parameters and clears the structured ON table, the ALGORITHM and LOCK + * clauses and the CASCADE/RESTRICT behavior. + */ public void setParameters(List list) { parameters = list; table = null; tablePosition = 0; + algorithmOrLockOptions.clear(); + algorithmOrLockPosition = null; + behavior = null; + } + + /** The explicit CASCADE or RESTRICT clause, or null when it is omitted. */ + public CascadeBehavior getBehavior() { + return behavior; + } + + public void setBehavior(CascadeBehavior behavior) { + this.behavior = behavior; + } + + public Drop withBehavior(CascadeBehavior behavior) { + setBehavior(behavior); + return this; + } + + /** MySQL DROP UNDO TABLESPACE. */ + public boolean isUndo() { + return undo; + } + + public void setUndo(boolean undo) { + this.undo = undo; + } + + public Drop withUndo(boolean undo) { + setUndo(undo); + return this; + } + + /** + * PostgreSQL DROP DATABASE ... WITH (FORCE), or Oracle DROP SYNONYM ... FORCE and MySQL DROP + * RESOURCE GROUP ... FORCE. + */ + public boolean isForce() { + return force; + } + + public void setForce(boolean force) { + this.force = force; + } + + public Drop withForce(boolean force) { + setForce(force); + return this; + } + + /** Whether the synonym belongs to the PUBLIC namespace. */ + public boolean isPublicSynonym() { + return publicSynonym; + } + + public void setPublicSynonym(boolean publicSynonym) { + this.publicSynonym = publicSynonym; + } + + public Drop withPublicSynonym(boolean publicSynonym) { + setPublicSynonym(publicSynonym); + return this; + } + + /** Whether a {@link ObjectType#LANGUAGE} is written as PostgreSQL PROCEDURAL LANGUAGE. */ + public boolean isProcedural() { + return procedural; + } + + public void setProcedural(boolean procedural) { + this.procedural = procedural; + } + + public Drop withProcedural(boolean procedural) { + setProcedural(procedural); + return this; + } + + /** + * The index access method of an {@link ObjectType#OPERATOR_CLASS} or + * {@link ObjectType#OPERATOR_FAMILY}, written with USING. + */ + public String getAccessMethod() { + return accessMethod; + } + + public void setAccessMethod(String accessMethod) { + this.accessMethod = accessMethod; + } + + public Drop withAccessMethod(String accessMethod) { + setAccessMethod(accessMethod); + return this; + } + + /** The storage engine of MySQL DROP TABLESPACE ... ENGINE, or null when it is omitted. */ + public String getEngine() { + return engine; + } + + public void setEngine(String engine) { + this.engine = engine; + } + + public Drop withEngine(String engine) { + setEngine(engine); + return this; + } + + /** Whether the ENGINE clause is written with an equals sign. */ + public boolean isEngineUseEquals() { + return engineUseEquals; + } + + public void setEngineUseEquals(boolean engineUseEquals) { + this.engineUseEquals = engineUseEquals; + } + + public Drop withEngineUseEquals(boolean engineUseEquals) { + setEngineUseEquals(engineUseEquals); + return this; } public String getType() { @@ -133,7 +530,7 @@ public String getType() { public void setType(String string) { type = string; try { - objectType = ObjectType.valueOf(string.toUpperCase(Locale.ROOT)); + objectType = ObjectType.valueOf(string.toUpperCase(Locale.ROOT).replace(' ', '_')); } catch (IllegalArgumentException | NullPointerException ignored) { objectType = ObjectType.OTHER; } @@ -146,7 +543,7 @@ public ObjectType getObjectType() { public void setObjectType(ObjectType objectType) { this.objectType = objectType == null ? ObjectType.OTHER : objectType; if (this.objectType != ObjectType.OTHER) { - this.type = this.objectType.name(); + this.type = this.objectType.name().replace('_', ' '); } } @@ -179,11 +576,29 @@ public void setMaterialized(boolean materialized) { this.materialized = materialized; } + /** + * Returns the legacy routine parameters by object type. For routine targets, this is a + * read-only snapshot of the last routine's argument declarations, where the legacy + * single-signature form kept them; edit {@link #getRoutines()} instead. + */ public Map> getTypeToParameters() { - return typeToParameters; + if (routines.isEmpty()) { + return typeToParameters; + } + RoutineReference last = routines.get(routines.size() - 1); + List arguments = null; + if (last.isAllArguments()) { + arguments = Collections.singletonList("*"); + } else if (last.getArguments() != null) { + arguments = Collections.unmodifiableList(last.getArguments().stream() + .map(Object::toString).collect(Collectors.toList())); + } + return Collections.singletonMap( + objectType.hasRoutineTargets() ? objectType.name() : type, arguments); } public void setTypeToParameters(Map> typeToParameters) { + useNameTargets(); this.typeToParameters = typeToParameters; } @@ -201,21 +616,77 @@ public StringBuilder appendTo(StringBuilder builder, Consumer
tablePrinte if (materialized) { builder.append("MATERIALIZED "); } - builder.append(type).append(ifExists ? " IF EXISTS " : " "); - appendNames(builder, tablePrinter); - if ("FUNCTION".equals(type)) { - builder.append(formatFuncParams(getParamsByType("FUNCTION"))); + if (undo) { + builder.append("UNDO "); + } + if (publicSynonym) { + builder.append("PUBLIC "); + } + if (procedural) { + builder.append("PROCEDURAL "); + } + builder.append(type); + if (concurrently) { + builder.append(" CONCURRENTLY"); + } + if (objectType == ObjectType.OWNED) { + builder.append(" BY"); + } + builder.append(ifExists ? " IF EXISTS " : " "); + appendTargets(builder, tablePrinter); + if (accessMethod != null) { + builder.append(" USING ").append(accessMethod); + } + if (force) { + builder.append(objectType == ObjectType.SYNONYM + || objectType == ObjectType.RESOURCE_GROUP ? " FORCE" : " WITH (FORCE)"); + } + if (engine != null) { + builder.append(engineUseEquals ? " ENGINE = " : " ENGINE ").append(engine); + } + appendParameters(token -> builder.append(' ').append(token), table -> { + builder.append(' '); + tablePrinter.accept(table); + }); + if (behavior != null) { + builder.append(' ').append(behavior); } - appendParameters(builder, tablePrinter); return builder; } + private void appendTargets(StringBuilder builder, Consumer
tablePrinter) { + if (!routines.isEmpty()) { + builder.append(routines.stream().map(Object::toString) + .collect(Collectors.joining(", "))); + } else if (!accounts.isEmpty()) { + builder.append(accounts.stream().map(Object::toString) + .collect(Collectors.joining(", "))); + } else if (!operators.isEmpty()) { + for (int i = 0; i < operators.size(); i++) { + if (i > 0) { + builder.append(", "); + } + operators.get(i).appendTo(builder); + } + } else if (cast != null) { + cast.appendTo(builder); + } else if (transform != null) { + transform.appendTo(builder); + } else { + appendNames(builder, tablePrinter); + if ("FUNCTION".equals(type)) { + builder.append(formatFuncParams(getParamsByType("FUNCTION"))); + } + } + } + private void appendNames(StringBuilder builder, Consumer
tablePrinter) { for (int i = 0; i < names.size(); i++) { if (i > 0) { builder.append(", "); } - if (objectType == ObjectType.TABLE || objectType == ObjectType.VIEW) { + if (objectType == ObjectType.TABLE || objectType == ObjectType.VIEW + || objectType == ObjectType.FOREIGN_TABLE) { tablePrinter.accept(names.get(i)); } else { builder.append(names.get(i)); @@ -223,21 +694,27 @@ private void appendNames(StringBuilder builder, Consumer
tablePrinter) { } } - private void appendParameters(StringBuilder builder, Consumer
tablePrinter) { + /** Emits the parameter tokens with ON and the ALGORITHM/LOCK clauses at their positions. */ + private void appendParameters(Consumer tokens, Consumer
onTable) { int size = parameters == null ? 0 : parameters.size(); + int optionPosition = algorithmOrLockPosition == null ? size + : Math.min(algorithmOrLockPosition, size); for (int i = 0; i <= size; i++) { if (table != null && i == tablePosition) { - builder.append(" ON "); - tablePrinter.accept(table); + tokens.accept("ON"); + onTable.accept(table); + } + if (i == optionPosition) { + algorithmOrLockOptions.forEach(option -> option.getTokens().forEach(tokens)); } if (i < size) { - builder.append(' ').append(parameters.get(i)); + tokens.accept(parameters.get(i)); } } } public List getParamsByType(String type) { - return typeToParameters.get(type); + return getTypeToParameters().get(type); } public Drop withIfExists(boolean ifExists) { @@ -266,6 +743,7 @@ public Drop withNames(Collection names) { } public Drop addNames(Table... names) { + useNameTargets(); Collections.addAll(this.names, names); return this; } @@ -284,7 +762,7 @@ public Drop addParameters(String... parameters) { return addParameters(java.util.Arrays.asList(parameters)); } - /** Appends trailing tokens without discarding a structured ON table. */ + /** Appends trailing tokens without discarding a structured ON table or behavior. */ public Drop addParameters(Collection parameters) { if (this.parameters == null) { this.parameters = new ArrayList<>(); @@ -292,4 +770,46 @@ public Drop addParameters(Collection parameters) { this.parameters.addAll(parameters); return this; } + + /** + * Returns the mutable MySQL ALGORITHM and LOCK clauses of DROP INDEX in source order. They + * follow the parameter tokens unless positioned with + * {@link #setAlgorithmOrLockOptions(List, int)}. + */ + public List getAlgorithmOrLockOptions() { + return algorithmOrLockOptions; + } + + /** Copies the list membership and places the clauses after all parameter tokens. */ + public void setAlgorithmOrLockOptions(List options) { + setAlgorithmOrLockOptions(options, -1); + } + + /** + * Copies the list membership and places the clauses before the parameter token at + * {@code parameterPosition}; -1 places them after all parameter tokens. + */ + public void setAlgorithmOrLockOptions(List options, + int parameterPosition) { + int size = parameters == null ? 0 : parameters.size(); + if (parameterPosition < -1 || parameterPosition > size) { + throw new IllegalArgumentException( + "Invalid ALGORITHM/LOCK position: " + parameterPosition); + } + algorithmOrLockOptions.clear(); + if (options != null) { + algorithmOrLockOptions.addAll(options); + } + algorithmOrLockPosition = parameterPosition < 0 ? null : parameterPosition; + } + + public Drop withAlgorithmOrLockOptions(List options) { + setAlgorithmOrLockOptions(options); + return this; + } + + public Drop addAlgorithmOrLockOptions(AlgorithmOrLockOption... options) { + Collections.addAll(algorithmOrLockOptions, options); + return this; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/drop/DropPolicy.java b/src/main/java/net/sf/jsqlparser/statement/drop/DropPolicy.java new file mode 100644 index 0000000000..c276d7e4fc --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/drop/DropPolicy.java @@ -0,0 +1,80 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2025 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.drop; + +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +public class DropPolicy extends ASTNodeAccessImpl implements Statement { + private String policyName; + private net.sf.jsqlparser.schema.Table table; + private boolean ifExists = false; + private CascadeBehavior behavior; + + public String getPolicyName() { + return policyName; + } + + public DropPolicy setPolicyName(String policyName) { + this.policyName = policyName; + return this; + } + + public net.sf.jsqlparser.schema.Table getTable() { + return table; + } + + public DropPolicy setTable(net.sf.jsqlparser.schema.Table table) { + this.table = table; + return this; + } + + public boolean isIfExists() { + return ifExists; + } + + public DropPolicy setIfExists(boolean ifExists) { + this.ifExists = ifExists; + return this; + } + + public CascadeBehavior getBehavior() { + return behavior; + } + + public DropPolicy setBehavior(CascadeBehavior behavior) { + this.behavior = behavior; + return this; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append("DROP POLICY "); + if (ifExists) { + sql.append("IF EXISTS "); + } + sql.append(policyName).append(" ON ").append(table); + if (behavior != null) { + sql.append(' ').append(behavior); + } + return sql; + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/drop/DropUserMapping.java b/src/main/java/net/sf/jsqlparser/statement/drop/DropUserMapping.java new file mode 100644 index 0000000000..a0324e94b8 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/drop/DropUserMapping.java @@ -0,0 +1,66 @@ +/*- + * #%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.drop; + +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL {@code DROP USER MAPPING [IF EXISTS] FOR user SERVER server}. A user mapping has no + * name of its own, so it is identified by the user and the server, as in + * {@link net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping}. + */ +public class DropUserMapping implements Statement { + private String user; + private String server; + private boolean ifExists; + + public String getUser() { + return user; + } + + public void setUser(String value) { + user = value; + } + + public String getServer() { + return server; + } + + public void setServer(String value) { + server = value; + } + + public boolean isIfExists() { + return ifExists; + } + + public void setIfExists(boolean value) { + ifExists = value; + } + + public StringBuilder appendTo(StringBuilder sql) { + sql.append("DROP USER MAPPING "); + if (ifExists) { + sql.append("IF EXISTS "); + } + return sql.append("FOR ").append(user).append(" SERVER ").append(server); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/execute/Execute.java b/src/main/java/net/sf/jsqlparser/statement/execute/Execute.java index cb2d8439f4..7a16384b7c 100644 --- a/src/main/java/net/sf/jsqlparser/statement/execute/Execute.java +++ b/src/main/java/net/sf/jsqlparser/statement/execute/Execute.java @@ -13,18 +13,28 @@ import java.util.StringJoiner; import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.UserVariable; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; import java.util.List; -public class Execute implements Statement { +/** + * A call of a stored procedure or a prepared statement: {@code EXEC}, {@code EXECUTE} or + * {@code CALL} with optional arguments, or MySQL's + * {@code EXECUTE name USING @variable [, @variable] ...}. + * + * @see MySQL EXECUTE + */ +public class Execute extends ASTNodeAccessImpl implements Statement { private ExecType execType = ExecType.EXECUTE; private String name; private ExpressionList exprList; + private ExpressionList usingVariables; public String getName() { return name; @@ -50,6 +60,20 @@ public void setExprList(ExpressionList exprList) { this.exprList = exprList; } + /** The user variables of MySQL's {@code USING} clause, or null without one. */ + public ExpressionList getUsingVariables() { + return usingVariables; + } + + public void setUsingVariables(ExpressionList usingVariables) { + this.usingVariables = usingVariables; + } + + public Execute withUsingVariables(ExpressionList usingVariables) { + this.setUsingVariables(usingVariables); + return this; + } + public ExecType getExecType() { return execType; } @@ -95,6 +119,15 @@ public StringBuilder appendTo(StringBuilder builder, Consumer expres builder.append(')'); } } + if (usingVariables != null && !usingVariables.isEmpty()) { + builder.append(" USING "); + for (int i = 0; i < usingVariables.size(); i++) { + if (i > 0) { + builder.append(", "); + } + expressionPrinter.accept(usingVariables.get(i)); + } + } return builder; } diff --git a/src/main/java/net/sf/jsqlparser/statement/export/Export.java b/src/main/java/net/sf/jsqlparser/statement/export/Export.java index dd6628a20e..2c6934270b 100644 --- a/src/main/java/net/sf/jsqlparser/statement/export/Export.java +++ b/src/main/java/net/sf/jsqlparser/statement/export/Export.java @@ -10,13 +10,14 @@ package net.sf.jsqlparser.statement.export; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; import net.sf.jsqlparser.statement.select.*; -public class Export implements Statement { +public class Export extends ASTNodeAccessImpl implements Statement { private Table table; private ExpressionList columns; private Select select; diff --git a/src/main/java/net/sf/jsqlparser/statement/export/ExportDataStatement.java b/src/main/java/net/sf/jsqlparser/statement/export/ExportDataStatement.java index 512ad0a843..1ea8e8074a 100644 --- a/src/main/java/net/sf/jsqlparser/statement/export/ExportDataStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/export/ExportDataStatement.java @@ -11,6 +11,7 @@ import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; import net.sf.jsqlparser.statement.select.Select; @@ -24,7 +25,7 @@ * "https://cloud.google.com/bigquery/docs/reference/standard-sql/export-statements">Export * statements */ -public class ExportDataStatement implements Statement { +public class ExportDataStatement extends ASTNodeAccessImpl implements Statement { private String connectionName; private ExpressionList options; private Select select; diff --git a/src/main/java/net/sf/jsqlparser/statement/foreign/ForeignDataStatement.java b/src/main/java/net/sf/jsqlparser/statement/foreign/ForeignDataStatement.java new file mode 100644 index 0000000000..2ea9cfedf9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/foreign/ForeignDataStatement.java @@ -0,0 +1,55 @@ +/*- + * #%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.foreign; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; + +/** Shared structured options for PostgreSQL foreign-data DDL. */ +public abstract class ForeignDataStatement extends ASTNodeAccessImpl implements Statement { + private List options; + + public List getOptions() { + return options; + } + + public void setOptions(List options) { + this.options = options; + } + + protected void appendOptionsTo(StringBuilder sql, Consumer printer) { + if (options != null) { + sql.append(' '); + ForeignDataOption.appendOptionsTo(sql, options, printer); + } + } + + public void visitExpressions(Consumer visitor) { + ForeignDataOption.visitExpressions(options, visitor); + } + + protected static void visit(Expression expression, Consumer visitor) { + if (expression != null) { + visitor.accept(expression); + } + } + + public abstract StringBuilder appendTo(StringBuilder sql, Consumer printer); + + @Override + public String toString() { + StringBuilder sql = new StringBuilder(); + return appendTo(sql, sql::append).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/foreign/ImportForeignSchema.java b/src/main/java/net/sf/jsqlparser/statement/foreign/ImportForeignSchema.java new file mode 100644 index 0000000000..5012b6e084 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/foreign/ImportForeignSchema.java @@ -0,0 +1,152 @@ +/*- + * #%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.foreign; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.schema.TableReference; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * PostgreSQL {@code IMPORT FOREIGN SCHEMA remote_schema [{LIMIT TO | EXCEPT} (table [, ...])] FROM + * SERVER server INTO local_schema [OPTIONS (option 'value' [, ...])]}, which creates foreign tables + * in the local schema for the tables of a schema on the foreign server. + * + * @see IMPORT FOREIGN + * SCHEMA + */ +public class ImportForeignSchema extends ForeignDataStatement { + private String remoteSchema; + private Qualification qualification; + private final List tables = new ArrayList<>(); + private String server; + private String localSchema; + + /** How the table list restricts the import. */ + public enum Qualification { + /** Import only the listed tables. */ + LIMIT_TO("LIMIT TO"), + /** Import every table but the listed ones. */ + EXCEPT("EXCEPT"); + + private final String sql; + + Qualification(String sql) { + this.sql = sql; + } + + @Override + public String toString() { + return sql; + } + } + + public String getRemoteSchema() { + return remoteSchema; + } + + public void setRemoteSchema(String remoteSchema) { + this.remoteSchema = remoteSchema; + } + + public ImportForeignSchema withRemoteSchema(String remoteSchema) { + setRemoteSchema(remoteSchema); + return this; + } + + /** The kind of the table list, or null when the whole remote schema is imported. */ + public Qualification getQualification() { + return qualification; + } + + /** + * The tables of the remote schema that LIMIT TO or EXCEPT lists; empty without a qualification. + * The list is a read-only snapshot, change it with {@link #setTables(Qualification, List)}. + */ + public List getTables() { + return List.copyOf(tables); + } + + /** + * Restricts the import to the listed tables or excludes them. + * + * @param qualification the kind of the list, null to import the whole remote schema + * @param tables the listed tables; at least one with a qualification, none without + */ + public void setTables(Qualification qualification, List tables) { + List copy = tables == null ? List.of() : List.copyOf(tables); + if (qualification == null != copy.isEmpty()) { + throw new IllegalArgumentException( + "LIMIT TO and EXCEPT need a table list, and a table list needs one of them"); + } + this.qualification = qualification; + this.tables.clear(); + this.tables.addAll(copy); + } + + public ImportForeignSchema withTables(Qualification qualification, + List tables) { + setTables(qualification, tables); + return this; + } + + public String getServer() { + return server; + } + + public void setServer(String server) { + this.server = server; + } + + public ImportForeignSchema withServer(String server) { + setServer(server); + return this; + } + + public String getLocalSchema() { + return localSchema; + } + + public void setLocalSchema(String localSchema) { + this.localSchema = localSchema; + } + + public ImportForeignSchema withLocalSchema(String localSchema) { + setLocalSchema(localSchema); + return this; + } + + @Override + public T accept(StatementVisitor visitor, S context) { + return visitor.visit(this, context); + } + + @Override + public StringBuilder appendTo(StringBuilder sql, Consumer printer) { + sql.append("IMPORT FOREIGN SCHEMA ").append(Objects.requireNonNull(remoteSchema)); + if (qualification != null) { + sql.append(' ').append(qualification).append(" ("); + for (int i = 0; i < tables.size(); i++) { + if (i > 0) { + sql.append(", "); + } + tables.get(i).appendTo(sql); + } + sql.append(')'); + } + sql.append(" FROM SERVER ").append(Objects.requireNonNull(server)); + sql.append(" INTO ").append(Objects.requireNonNull(localSchema)); + appendOptionsTo(sql, printer); + return sql; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/AlterDefaultPrivileges.java b/src/main/java/net/sf/jsqlparser/statement/grant/AlterDefaultPrivileges.java index 42003ceee8..c726c1a843 100644 --- a/src/main/java/net/sf/jsqlparser/statement/grant/AlterDefaultPrivileges.java +++ b/src/main/java/net/sf/jsqlparser/statement/grant/AlterDefaultPrivileges.java @@ -12,10 +12,11 @@ import java.util.List; import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -public class AlterDefaultPrivileges implements Statement { +public class AlterDefaultPrivileges extends ASTNodeAccessImpl implements Statement { public enum RoleKeyword { ROLE, USER } diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/Grant.java b/src/main/java/net/sf/jsqlparser/statement/grant/Grant.java index a9c43dc267..ab28a2cbfc 100644 --- a/src/main/java/net/sf/jsqlparser/statement/grant/Grant.java +++ b/src/main/java/net/sf/jsqlparser/statement/grant/Grant.java @@ -9,22 +9,24 @@ */ package net.sf.jsqlparser.statement.grant; -import java.util.AbstractList; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.List; -import java.util.Optional; import java.util.function.Consumer; import java.util.stream.Collectors; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.create.user.RoleSelection; -public class Grant implements Statement { +public class Grant extends ASTNodeAccessImpl implements Statement { private PrivilegeClause clause = new PrivilegeClause(); - private GrantOption option; + private final List options = new ArrayList<>(); + private Grantee asUser; + private RoleSelection withRole; public PrivilegeClause getClause() { return clause; @@ -34,12 +36,46 @@ public void setClause(PrivilegeClause clause) { this.clause = clause; } + /** + * The {@code WITH} options as a mutable list: {@code GRANT OPTION}, {@code ADMIN OPTION} or + * PostgreSQL membership options such as {@code INHERIT TRUE, SET FALSE}. + */ + public List getOptions() { + return options; + } + + public void setOptions(Collection options) { + List copy = options == null ? new ArrayList<>() : new ArrayList<>(options); + this.options.clear(); + this.options.addAll(copy); + } + + /** The first {@code WITH} option, or null; see {@link #getOptions()}. */ public GrantOption getOption() { - return option; + return options.isEmpty() ? null : options.get(0); } + /** Replaces all {@code WITH} options with the given option, or removes them for null. */ public void setOption(GrantOption option) { - this.option = option; + setOptions(option == null ? null : Collections.singletonList(option)); + } + + /** The MySQL {@code AS user} account, or null when omitted. */ + public Grantee getAsUser() { + return asUser; + } + + public void setAsUser(Grantee asUser) { + this.asUser = asUser; + } + + /** The MySQL {@code WITH ROLE} selection of the {@code AS user} clause, or null. */ + public RoleSelection getWithRole() { + return withRole; + } + + public void setWithRole(RoleSelection withRole) { + this.withRole = withRole; } public List getPrivilegeItems() { @@ -50,6 +86,7 @@ public void setPrivilegeItems(List privileges) { clause.setPrivileges(privileges); } + /** The target, or null for a role membership. */ public PrivilegeTarget getTarget() { return clause.getTarget(); } @@ -67,14 +104,16 @@ public void setRoles(List roles) { } public String getRole() { - return clause.getRoles().isEmpty() ? null : clause.getRoles().get(0); + return clause.getRoleItems().isEmpty() ? null : clause.getRoles().get(0); } + /** Makes this a membership of the given role, which has neither privileges nor a target. */ public void setRole(String role) { clause.setRoles(new ArrayList<>()); if (role != null) { clause.getRoles().add(role); clause.setPrivileges(null); + clause.setTarget(null); } } @@ -83,32 +122,7 @@ public List getPrivileges() { if (clause.getPrivileges() == null) { return null; } - return new AbstractList() { - @Override - public int size() { - return clause.getPrivileges().size(); - } - - @Override - public String get(int index) { - return clause.getPrivileges().get(index).toString(); - } - - @Override - public String set(int index, String value) { - return clause.getPrivileges().set(index, new Privilege(value)).toString(); - } - - @Override - public void add(int index, String value) { - clause.getPrivileges().add(index, new Privilege(value)); - } - - @Override - public String remove(int index) { - return clause.getPrivileges().remove(index).toString(); - } - }; + return new StringListView<>(() -> clause.getPrivileges(), Privilege::new); } public void setPrivileges(List privileges) { @@ -122,12 +136,22 @@ public void setPrivileges(List privileges) { clause.setPrivileges(items); } + /** + * The first named target as dotted text. MySQL wildcard levels keep their wildcard, for example + * {@code db.*} or {@code *.*}. + */ public String getObjectName() { - if (clause.getTarget().getNames().isEmpty() - || clause.getTarget().getNames().get(0).isEmpty()) { + PrivilegeTarget target = clause.getTarget(); + if (target == null) { return null; } - List parts = clause.getTarget().getNames().get(0); + if (target.getWildcard() != null) { + return target.getTargetText(); + } + if (target.getNames().isEmpty() || target.getNames().get(0).isEmpty()) { + return null; + } + List parts = target.getNames().get(0); return parts.stream().map(part -> part == null ? "" : part) .collect(Collectors.joining(".")); } @@ -136,14 +160,19 @@ public void setObjectName(String objectName) { setObjectName(Collections.singletonList(objectName)); } + /** Names the first target, replacing a MySQL wildcard level. */ public void setObjectName(List objectName) { List parts = new ArrayList<>(objectName); getObjectNameParts().clear(); getObjectNameParts().addAll(parts); + clause.getTarget().setWildcard(null); } /** Mutable parts of the first named target, retained for compatibility. */ public List getObjectNameParts() { + if (clause.getTarget() == null) { + clause.setTarget(new PrivilegeTarget()); + } if (clause.getTarget().getNames().isEmpty()) { clause.getTarget().getNames().add(new ArrayList<>()); } @@ -161,11 +190,18 @@ public void setUsers(List users) { public void appendTo(StringBuilder sql, Consumer visitor) { sql.append("GRANT "); clause.appendTo(sql, false, visitor); - if (option != null) { - sql.append(" WITH ").append(option); + if (!options.isEmpty()) { + sql.append(" WITH ").append( + options.stream().map(Object::toString).collect(Collectors.joining(", "))); + } + if (asUser != null) { + sql.append(" AS ").append(asUser); + if (withRole != null) { + sql.append(" WITH ROLE ").append(withRole); + } } - if (clause.getGrantedBy() != null) { - sql.append(" GRANTED BY ").append(clause.getGrantedBy()); + if (clause.getGrantor() != null) { + sql.append(" GRANTED BY ").append(clause.getGrantor()); } } @@ -222,14 +258,17 @@ public Grant addPrivileges(Collection privileges) { } public Grant addUsers(String... users) { - List collection = Optional.ofNullable(getUsers()).orElseGet(ArrayList::new); - Collections.addAll(collection, users); - return this.withUsers(collection); + return addUsers(Arrays.asList(users)); } public Grant addUsers(Collection users) { - List collection = Optional.ofNullable(getUsers()).orElseGet(ArrayList::new); - collection.addAll(users); - return this.withUsers(collection); + List additions = new ArrayList<>(users); + if (clause.getGranteeItems() == null) { + clause.setGranteeItems(new ArrayList<>()); + } + for (String user : additions) { + clause.getGranteeItems().add(Grantee.valueOf(user)); + } + return this; } } diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/Grantee.java b/src/main/java/net/sf/jsqlparser/statement/grant/Grantee.java new file mode 100644 index 0000000000..a53b020640 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/grant/Grantee.java @@ -0,0 +1,125 @@ +/*- + * #%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.grant; + +import java.io.Serializable; +import java.util.Locale; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.statement.create.user.UserAccount; + +/** + * A role specification in GRANT and REVOKE: a grantee, the PostgreSQL grantor, the MySQL {@code AS} + * user or the MySQL proxied account. + * + *

+ * Named users and roles are held as a {@link UserAccount}: a MySQL account {@code user[@host]}, or + * a PostgreSQL role name without host. + */ +public class Grantee implements Serializable { + + public enum Kind { + /** A named user or role, see {@link Grantee#getAccount()}. */ + ACCOUNT, + /** PostgreSQL {@code GROUP name}, see {@link Grantee#getAccount()}. */ + GROUP, PUBLIC, CURRENT_USER, CURRENT_ROLE, SESSION_USER + } + + private Kind kind; + private UserAccount account; + private boolean currentUserParentheses; + + public Grantee(Kind kind) { + this.kind = kind; + } + + public Grantee(UserAccount account) { + this.kind = Kind.ACCOUNT; + this.account = account; + } + + /** + * Converts the text of the string-based API. Special role names are recognized; any other text + * becomes an account whose user name is kept verbatim. + */ + public static Grantee valueOf(String text) { + String upper = text.trim().toUpperCase(Locale.ROOT); + if (upper.startsWith("GROUP ")) { + return new Grantee(Kind.GROUP) + .withAccount(accountOf(text.trim().substring("GROUP ".length()).trim())); + } + if ("CURRENT_USER()".equals(upper.replace(" ", ""))) { + return new Grantee(Kind.CURRENT_USER).withCurrentUserParentheses(true); + } + for (Kind special : new Kind[] {Kind.PUBLIC, Kind.CURRENT_USER, Kind.CURRENT_ROLE, + Kind.SESSION_USER}) { + if (special.name().equals(upper)) { + return new Grantee(special); + } + } + return new Grantee(accountOf(text)); + } + + /** An account or role name kept as written, without a host. */ + static UserAccount accountOf(String name) { + StringValue user = new StringValue(); + user.setValue(name); + return new UserAccount().withUser(user.setQuoteStr("")); + } + + public Kind getKind() { + return kind; + } + + public void setKind(Kind kind) { + this.kind = kind; + } + + /** The named user or role of an {@link Kind#ACCOUNT} or {@link Kind#GROUP} grantee. */ + public UserAccount getAccount() { + return account; + } + + public void setAccount(UserAccount account) { + this.account = account; + } + + /** Whether MySQL {@code CURRENT_USER()} was written with parentheses. */ + public boolean isCurrentUserParentheses() { + return currentUserParentheses; + } + + public void setCurrentUserParentheses(boolean currentUserParentheses) { + this.currentUserParentheses = currentUserParentheses; + } + + public Grantee withAccount(UserAccount account) { + setAccount(account); + return this; + } + + public Grantee withCurrentUserParentheses(boolean currentUserParentheses) { + setCurrentUserParentheses(currentUserParentheses); + return this; + } + + @Override + public String toString() { + switch (kind) { + case ACCOUNT: + return String.valueOf(account); + case GROUP: + return "GROUP " + account; + case CURRENT_USER: + return currentUserParentheses ? "CURRENT_USER()" : "CURRENT_USER"; + default: + return kind.name(); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/Privilege.java b/src/main/java/net/sf/jsqlparser/statement/grant/Privilege.java index b1f3b461aa..116ae93df9 100644 --- a/src/main/java/net/sf/jsqlparser/statement/grant/Privilege.java +++ b/src/main/java/net/sf/jsqlparser/statement/grant/Privilege.java @@ -15,13 +15,23 @@ import net.sf.jsqlparser.expression.operators.relational.ExpressionList; import net.sf.jsqlparser.schema.Column; +/** + * A privilege of GRANT and REVOKE. Static privileges are {@link Kind} constants, rendered with + * spaces for underscores; MySQL dynamic privileges such as {@code BACKUP_ADMIN} are + * {@link Kind#DYNAMIC} with {@link #getDynamicName()}. + */ public class Privilege implements Serializable { public enum Kind { - ALL, SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER, MAINTAIN, USAGE, CREATE, CONNECT, TEMPORARY, TEMP, EXECUTE, SET, ALTER_SYSTEM, ALTER, DROP + ALL, SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER, MAINTAIN, USAGE, CREATE, CONNECT, TEMPORARY, TEMP, EXECUTE, SET, ALTER_SYSTEM, ALTER, DROP, + // MySQL static privileges + ALTER_ROUTINE, CREATE_ROLE, CREATE_ROUTINE, CREATE_TABLESPACE, CREATE_TEMPORARY_TABLES, CREATE_USER, CREATE_VIEW, DROP_ROLE, EVENT, FILE, GRANT_OPTION, INDEX, LOCK_TABLES, PROCESS, PROXY, RELOAD, REPLICATION_CLIENT, REPLICATION_SLAVE, SHOW_DATABASES, SHOW_VIEW, SHUTDOWN, SUPER, + /** A MySQL dynamic privilege, see {@link Privilege#getDynamicName()}. */ + DYNAMIC } private String legacyName; private Kind kind; + private String dynamicName; private boolean usePrivileges; private ExpressionList columns; @@ -49,21 +59,56 @@ public void setColumns(ExpressionList columns) { this.columns = columns; } + /** The identifier of a {@link Kind#DYNAMIC} privilege, as written. */ + public String getDynamicName() { + return dynamicName; + } + + public void setDynamicName(String dynamicName) { + this.dynamicName = dynamicName; + } + + /** The privilege name as rendered, for example {@code CREATE VIEW} or {@code BACKUP_ADMIN}. */ + public String getName() { + if (kind == null) { + return legacyName; + } + return kind == Kind.DYNAMIC ? dynamicName : kind.name().replace('_', ' '); + } + public Privilege(Kind kind) { this.kind = kind; } - /** Preserves values supplied through the pre-existing string-based Grant API. */ + /** + * Preserves values supplied through the pre-existing string-based Grant API. Names of static + * privileges, such as {@code CREATE VIEW}, become typed; other text is kept as written. + */ public Privilege(String name) { - try { - this.kind = Kind.valueOf(name); - } catch (IllegalArgumentException ex) { + this.kind = staticKind(name); + if (kind == null) { this.legacyName = name; } } + private static Kind staticKind(String name) { + String constant = name.replace(' ', '_'); + for (Kind candidate : Kind.values()) { + if (candidate != Kind.DYNAMIC && candidate.name().equals(constant)) { + return candidate; + } + } + return null; + } + + public static Privilege dynamic(String name) { + Privilege privilege = new Privilege(Kind.DYNAMIC); + privilege.setDynamicName(name); + return privilege; + } + public void appendTo(StringBuilder sql, Consumer visitor) { - sql.append(kind == null ? legacyName : kind.name().replace('_', ' ')); + sql.append(getName()); if (usePrivileges) { sql.append(" PRIVILEGES"); } diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeClause.java b/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeClause.java index 4f517d1229..49f2ddb77f 100644 --- a/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeClause.java +++ b/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeClause.java @@ -11,17 +11,29 @@ import java.io.Serializable; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.function.Consumer; +import java.util.function.Function; +import java.util.stream.Collectors; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.create.user.UserAccount; -/** Shared, editable GRANT/REVOKE payload. Null privileges denote role membership. */ +/** + * Shared, editable GRANT/REVOKE payload. Null privileges denote role membership; role memberships, + * and MySQL {@code REVOKE ALL PRIVILEGES, GRANT OPTION}, have no target. + * + *

+ * Roles, grantees and the grantor are typed. The string accessors {@link #getRoles()}, + * {@link #getGrantees()} and {@link #getGrantedBy()} are derived from them and convert assigned + * text with {@link Grantee#valueOf(String)}. + */ public class PrivilegeClause implements Serializable { private List privileges; - private List grantees; - private String grantedBy; - private List roles = new ArrayList<>(); + private List granteeItems; + private Grantee grantor; + private List roleItems = new ArrayList<>(); private PrivilegeTarget target = new PrivilegeTarget(); public List getPrivileges() { @@ -32,12 +44,25 @@ public void setPrivileges(List privileges) { this.privileges = privileges; } + /** The granted or revoked roles of a role membership, as a mutable list. */ + public List getRoleItems() { + return roleItems; + } + + public void setRoleItems(Collection roleItems) { + this.roleItems = roleItems == null ? new ArrayList<>() : new ArrayList<>(roleItems); + } + + /** Mutable legacy string view of {@link #getRoleItems()}. */ public List getRoles() { - return roles; + return new StringListView<>(() -> roleItems, Grantee::accountOf); } public void setRoles(List roles) { - this.roles = roles; + roleItems = convert(roles, Grantee::accountOf); + if (roleItems == null) { + roleItems = new ArrayList<>(); + } } public PrivilegeTarget getTarget() { @@ -48,25 +73,56 @@ public void setTarget(PrivilegeTarget target) { this.target = target; } + /** The grantees or revokees as a mutable list, or null when unset. */ + public List getGranteeItems() { + return granteeItems; + } + + public void setGranteeItems(Collection granteeItems) { + this.granteeItems = granteeItems == null ? null : new ArrayList<>(granteeItems); + } + + /** Mutable legacy string view of {@link #getGranteeItems()}, or null when unset. */ public List getGrantees() { - return grantees; + return granteeItems == null ? null + : new StringListView<>(() -> granteeItems, Grantee::valueOf); } public void setGrantees(List grantees) { - this.grantees = grantees; + granteeItems = convert(grantees, Grantee::valueOf); + } + + /** The PostgreSQL {@code GRANTED BY} role, or null when omitted. */ + public Grantee getGrantor() { + return grantor; + } + + public void setGrantor(Grantee grantor) { + this.grantor = grantor; } public String getGrantedBy() { - return grantedBy; + return grantor == null ? null : grantor.toString(); } public void setGrantedBy(String grantedBy) { - this.grantedBy = grantedBy; + grantor = grantedBy == null ? null : Grantee.valueOf(grantedBy); + } + + private static List convert(List values, Function parse) { + if (values == null) { + return null; + } + List items = new ArrayList<>(); + for (String value : new ArrayList<>(values)) { + items.add(parse.apply(value)); + } + return items; } public void appendTo(StringBuilder sql, boolean revoke, Consumer visitor) { if (privileges == null) { - sql.append(String.join(", ", roles)); + sql.append(join(roleItems)); } else { for (int i = 0; i < privileges.size(); i++) { if (i > 0) { @@ -74,14 +130,22 @@ public void appendTo(StringBuilder sql, boolean revoke, Consumer vis } privileges.get(i).appendTo(sql, visitor); } - sql.append(" ON ").append(target); + if (target != null) { + sql.append(" ON ").append(target); + } } - sql.append(revoke ? " FROM " : " TO ").append(String.join(", ", grantees)); + sql.append(revoke ? " FROM " : " TO ").append(join(granteeItems)); + } + + private static String join(List items) { + return items.stream().map(Object::toString).collect(Collectors.joining(", ")); } public void visit(Consumer

tables, Consumer expressions) { if (privileges != null) { - target.visitTables(tables); + if (target != null) { + target.visitTables(tables); + } for (Privilege privilege : privileges) { if (privilege.getColumns() != null) { privilege.getColumns().forEach(expressions); diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeTarget.java b/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeTarget.java index a92ac85391..7b815c072f 100644 --- a/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeTarget.java +++ b/src/main/java/net/sf/jsqlparser/statement/grant/PrivilegeTarget.java @@ -17,16 +17,40 @@ import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.RoutineReference; -/** Targets have distinct kinds; a routine signature is not a function invocation. */ +/** + * Targets have distinct kinds; a routine signature is not a function invocation. MySQL privilege + * levels written with {@code *} are a {@link Wildcard}, and the account of MySQL + * {@code PROXY ON user} is an {@link Kind#ACCOUNT} target. + */ public class PrivilegeTarget implements Serializable { public enum Kind { - TABLE, SEQUENCE, DATABASE, DOMAIN, FOREIGN_DATA_WRAPPER, FOREIGN_SERVER, FUNCTION, PROCEDURE, ROUTINE, LANGUAGE, LARGE_OBJECT, PARAMETER, SCHEMA, TABLESPACE, TYPE + TABLE, SEQUENCE, DATABASE, DOMAIN, FOREIGN_DATA_WRAPPER, FOREIGN_SERVER, FUNCTION, PROCEDURE, ROUTINE, LANGUAGE, LARGE_OBJECT, PARAMETER, SCHEMA, TABLESPACE, TYPE, + /** + * The proxied account of MySQL {@code PROXY ON user}, see + * {@link PrivilegeTarget#getAccount()}. + */ + ACCOUNT + } + + /** MySQL privilege levels written with {@code *}. */ + public enum Wildcard { + /** {@code *}: the default database. */ + DEFAULT_DATABASE, + /** {@code *.*}: all databases. */ + GLOBAL, + /** + * {@code db.*}: the database named by the single entry of + * {@link PrivilegeTarget#getNames()}. + */ + DATABASE } private Kind kind = Kind.TABLE; private boolean explicitKind; private boolean allInSchema; private boolean defaultPrivileges; + private Wildcard wildcard; + private Grantee account; private List> names = new ArrayList<>(); private List routines = new ArrayList<>(); @@ -62,6 +86,24 @@ public void setDefaultPrivileges(boolean defaultPrivileges) { this.defaultPrivileges = defaultPrivileges; } + /** The MySQL wildcard privilege level, or null for named targets. */ + public Wildcard getWildcard() { + return wildcard; + } + + public void setWildcard(Wildcard wildcard) { + this.wildcard = wildcard; + } + + /** The proxied account of an {@link Kind#ACCOUNT} target. */ + public Grantee getAccount() { + return account; + } + + public void setAccount(Grantee account) { + this.account = account; + } + public List> getNames() { return names; } @@ -79,7 +121,7 @@ public void setRoutines(List routines) { } public void visitTables(Consumer
visitor) { - if (kind == Kind.TABLE && !allInSchema && !defaultPrivileges) { + if (kind == Kind.TABLE && wildcard == null && !allInSchema && !defaultPrivileges) { for (List name : names) { if (!name.isEmpty()) { visitor.accept(new Table(name)); @@ -88,19 +130,37 @@ public void visitTables(Consumer
visitor) { } } + /** The target names as written after the optional kind, for example {@code db.*}. */ + String getTargetText() { + if (kind == Kind.ACCOUNT) { + return String.valueOf(account); + } + if (wildcard == Wildcard.DEFAULT_DATABASE) { + return "*"; + } + if (wildcard == Wildcard.GLOBAL) { + return "*.*"; + } + String targets = routines.isEmpty() + ? names.stream().map(PrivilegeTarget::joinName).collect(Collectors.joining(", ")) + : routines.stream().map(Object::toString).collect(Collectors.joining(", ")); + return wildcard == Wildcard.DATABASE ? targets + ".*" : targets; + } + + private static String joinName(List name) { + return name.stream().map(part -> part == null ? "" : part) + .collect(Collectors.joining(".")); + } + @Override public String toString() { String type = kind.name().replace('_', ' '); - String targets = routines.isEmpty() - ? names.stream().map(n -> n.stream().map(part -> part == null ? "" : part) - .collect(Collectors.joining("."))).collect(Collectors.joining(", ")) - : routines.stream().map(Object::toString).collect(Collectors.joining(", ")); if (defaultPrivileges) { return type + "S"; } if (allInSchema) { - return "ALL " + type + "S IN SCHEMA " + targets; + return "ALL " + type + "S IN SCHEMA " + getTargetText(); } - return (explicitKind ? type + " " : "") + targets; + return (explicitKind ? type + " " : "") + getTargetText(); } } diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/Revoke.java b/src/main/java/net/sf/jsqlparser/statement/grant/Revoke.java index 157eccc8a0..577ebdd52e 100644 --- a/src/main/java/net/sf/jsqlparser/statement/grant/Revoke.java +++ b/src/main/java/net/sf/jsqlparser/statement/grant/Revoke.java @@ -11,17 +11,17 @@ import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.CascadeBehavior; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -public class Revoke implements Statement { - public enum Behavior { - CASCADE, RESTRICT - } - +public class Revoke extends ASTNodeAccessImpl implements Statement { private PrivilegeClause clause = new PrivilegeClause(); + private boolean ifExists; private GrantOption.Kind optionFor; - private Behavior behavior; + private CascadeBehavior behavior; + private boolean ignoreUnknownUser; public PrivilegeClause getClause() { return clause; @@ -31,6 +31,24 @@ public void setClause(PrivilegeClause clause) { this.clause = clause; } + /** MySQL {@code REVOKE IF EXISTS}. */ + public boolean isIfExists() { + return ifExists; + } + + public void setIfExists(boolean ifExists) { + this.ifExists = ifExists; + } + + /** MySQL {@code IGNORE UNKNOWN USER}. */ + public boolean isIgnoreUnknownUser() { + return ignoreUnknownUser; + } + + public void setIgnoreUnknownUser(boolean ignoreUnknownUser) { + this.ignoreUnknownUser = ignoreUnknownUser; + } + public GrantOption.Kind getOptionFor() { return optionFor; } @@ -39,26 +57,32 @@ public void setOptionFor(GrantOption.Kind optionFor) { this.optionFor = optionFor; } - public Behavior getBehavior() { + public CascadeBehavior getBehavior() { return behavior; } - public void setBehavior(Behavior behavior) { + public void setBehavior(CascadeBehavior behavior) { this.behavior = behavior; } public void appendTo(StringBuilder sql, Consumer visitor) { sql.append("REVOKE "); + if (ifExists) { + sql.append("IF EXISTS "); + } if (optionFor != null) { sql.append(optionFor).append(" OPTION FOR "); } clause.appendTo(sql, true, visitor); - if (clause.getGrantedBy() != null) { - sql.append(" GRANTED BY ").append(clause.getGrantedBy()); + if (clause.getGrantor() != null) { + sql.append(" GRANTED BY ").append(clause.getGrantor()); } if (behavior != null) { sql.append(' ').append(behavior); } + if (ignoreUnknownUser) { + sql.append(" IGNORE UNKNOWN USER"); + } } @Override diff --git a/src/main/java/net/sf/jsqlparser/statement/grant/StringListView.java b/src/main/java/net/sf/jsqlparser/statement/grant/StringListView.java new file mode 100644 index 0000000000..9f220aa0eb --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/grant/StringListView.java @@ -0,0 +1,52 @@ +/*- + * #%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.grant; + +import java.util.AbstractList; +import java.util.List; +import java.util.RandomAccess; +import java.util.function.Function; +import java.util.function.Supplier; + +/** Mutable string view over a typed list, retained for the string-based GRANT/REVOKE API. */ +final class StringListView extends AbstractList implements RandomAccess { + private final Supplier> items; + private final Function parse; + + StringListView(Supplier> items, Function parse) { + this.items = items; + this.parse = parse; + } + + @Override + public int size() { + return items.get().size(); + } + + @Override + public String get(int index) { + return String.valueOf(items.get().get(index)); + } + + @Override + public String set(int index, String value) { + return String.valueOf(items.get().set(index, parse.apply(value))); + } + + @Override + public void add(int index, String value) { + items.get().add(index, parse.apply(value)); + } + + @Override + public String remove(int index) { + return String.valueOf(items.get().remove(index)); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/handler/HandlerStatement.java b/src/main/java/net/sf/jsqlparser/statement/handler/HandlerStatement.java new file mode 100644 index 0000000000..f70be46b35 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/handler/HandlerStatement.java @@ -0,0 +1,277 @@ +/*- + * #%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.handler; + +import java.util.Objects; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.select.Limit; +import net.sf.jsqlparser.statement.select.Offset; + +/** + * MySQL {@code HANDLER}, which opens a table for direct row access, reads rows from it and closes + * it again.
+ * Examples:
+ * HANDLER db.t OPEN AS h
+ * HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3
+ * HANDLER h READ i1 NEXT
+ * HANDLER h READ FIRST
+ * HANDLER h CLOSE
+ *
+ * {@link #getTable()} is the table that OPEN opens, with the handler name as its alias when one is + * given. READ and CLOSE name the handler, which is that alias or the unqualified table name, so + * their {@link #getTable()} holds the handler name rather than a table reference.
+ * A READ through an index either compares the index with a list of key values + * ({@link #getKeyComparison()} and {@link #getKeyValues()}) or moves in index order + * ({@link #getDirection()}). A READ without an index moves in storage order: FIRST or NEXT. + * + * @see MySQL HANDLER + */ +public class HandlerStatement extends ASTNodeAccessImpl implements Statement { + private Action action = Action.OPEN; + private Table table; + private String indexName; + private KeyComparison keyComparison; + private ExpressionList keyValues; + private Direction direction; + private Expression where; + private Limit limit; + private Offset offset; + + public enum Action { + OPEN, READ, CLOSE + } + + /** Where a READ continues: FIRST and NEXT, and through an index also PREV and LAST. */ + public enum Direction { + FIRST, NEXT, PREV, LAST + } + + /** How a READ through an index compares the index with the key values. */ + public enum KeyComparison { + /** {@code =} */ + EQUALS("="), + /** {@code <=} */ + LESS_THAN_OR_EQUALS("<="), + /** {@code >=} */ + GREATER_THAN_OR_EQUALS(">="), + /** {@code <} */ + LESS_THAN("<"), + /** {@code >} */ + GREATER_THAN(">"); + + private final String operator; + + KeyComparison(String operator) { + this.operator = operator; + } + + public String getOperator() { + return operator; + } + } + + public HandlerStatement() { + // empty constructor + } + + public HandlerStatement(Action action, Table table) { + setAction(action); + this.table = table; + } + + public Action getAction() { + return action; + } + + public void setAction(Action action) { + this.action = Objects.requireNonNull(action); + } + + public HandlerStatement withAction(Action action) { + setAction(action); + return this; + } + + /** + * Returns the table that OPEN opens, whose alias is the handler name, or the handler that READ + * and CLOSE use. + */ + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + public HandlerStatement withTable(Table table) { + setTable(table); + return this; + } + + /** Returns the name of the handler: the alias that OPEN gives, or else the table name. */ + public String getHandlerName() { + if (table == null) { + return null; + } + Alias alias = table.getAlias(); + return alias != null ? alias.getName() : table.getName(); + } + + /** Returns the index a READ uses, or null when it reads in storage order. */ + public String getIndexName() { + return indexName; + } + + public void setIndexName(String indexName) { + this.indexName = indexName; + } + + public HandlerStatement withIndexName(String indexName) { + setIndexName(indexName); + return this; + } + + /** Returns how a READ compares the index with {@link #getKeyValues()}, or null. */ + public KeyComparison getKeyComparison() { + return keyComparison; + } + + public void setKeyComparison(KeyComparison keyComparison) { + this.keyComparison = keyComparison; + } + + public HandlerStatement withKeyComparison(KeyComparison keyComparison) { + setKeyComparison(keyComparison); + return this; + } + + /** Returns the parenthesized key values a READ compares the index with, or null. */ + public ExpressionList getKeyValues() { + return keyValues; + } + + public void setKeyValues(ExpressionList keyValues) { + this.keyValues = keyValues; + } + + public HandlerStatement withKeyValues(ExpressionList keyValues) { + setKeyValues(keyValues); + return this; + } + + /** Returns where a READ continues, or null when it compares key values. */ + public Direction getDirection() { + return direction; + } + + public void setDirection(Direction direction) { + this.direction = direction; + } + + public HandlerStatement withDirection(Direction direction) { + setDirection(direction); + return this; + } + + public Expression getWhere() { + return where; + } + + public void setWhere(Expression where) { + this.where = where; + } + + public HandlerStatement withWhere(Expression where) { + setWhere(where); + return this; + } + + public Limit getLimit() { + return limit; + } + + public void setLimit(Limit limit) { + this.limit = limit; + } + + public HandlerStatement withLimit(Limit limit) { + setLimit(limit); + return this; + } + + /** Returns the OFFSET of {@code LIMIT row_count OFFSET offset}, or null. */ + public Offset getOffset() { + return offset; + } + + public void setOffset(Offset offset) { + this.offset = offset; + } + + public HandlerStatement withOffset(Offset offset) { + setOffset(offset); + return this; + } + + /** Shares the statement syntax with deparsers, which render the WHERE and key values. */ + public StringBuilder appendTo(StringBuilder builder, Consumer expressionRenderer) { + builder.append("HANDLER ").append(table.getFullyQualifiedName()).append(' ') + .append(action); + if (action == Action.OPEN) { + if (table.getAlias() != null) { + builder.append(table.getAlias()); + } + } else if (action == Action.READ) { + appendReadTo(builder, expressionRenderer); + } + return builder; + } + + private void appendReadTo(StringBuilder builder, Consumer expressionRenderer) { + if (indexName != null) { + builder.append(' ').append(indexName); + } + if (keyComparison != null) { + builder.append(' ').append(keyComparison.getOperator()).append(' '); + expressionRenderer.accept(keyValues); + } else { + builder.append(' ').append(direction); + } + if (where != null) { + builder.append(" WHERE "); + expressionRenderer.accept(where); + } + if (limit != null) { + builder.append(limit); + } + if (offset != null) { + builder.append(offset); + } + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/insert/Insert.java b/src/main/java/net/sf/jsqlparser/statement/insert/Insert.java index 3541c1022f..6f710fb194 100644 --- a/src/main/java/net/sf/jsqlparser/statement/insert/Insert.java +++ b/src/main/java/net/sf/jsqlparser/statement/insert/Insert.java @@ -11,12 +11,14 @@ import java.util.Arrays; import java.util.Collection; -import java.util.Iterator; import java.util.List; import java.util.Optional; +import java.util.function.Consumer; import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.OracleHint; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Partition; import net.sf.jsqlparser.schema.Table; @@ -26,13 +28,14 @@ import net.sf.jsqlparser.statement.StatementVisitor; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.statement.select.SelectItem; import net.sf.jsqlparser.statement.select.SetOperationList; import net.sf.jsqlparser.statement.select.Values; import net.sf.jsqlparser.statement.select.WithItem; import net.sf.jsqlparser.statement.update.UpdateSet; @SuppressWarnings({"PMD.CyclomaticComplexity"}) -public class Insert implements Statement { +public class Insert extends ASTNodeAccessImpl implements Statement { private Table table; private OracleHint oracleHint = null; @@ -46,7 +49,6 @@ public enum OverridingMode { } private OverridingMode overridingMode = OverridingMode.NONE; - private List duplicateUpdateSets = null; private InsertModifierPriority modifierPriority = null; private boolean modifierIgnore = false; private boolean overwrite = false; @@ -63,12 +65,11 @@ public enum OverridingMode { private boolean oracleMultiInsert = false; private boolean oracleMultiInsertFirst = false; private List oracleMultiInsertBranches; + private InsertConflictAlgorithm conflictAlgorithm = null; + private boolean omitInto = false; public List getDuplicateUpdateSets() { - if (duplicateAction != null) { - return duplicateAction.getUpdateSets(); - } - return duplicateUpdateSets; + return duplicateAction != null ? duplicateAction.getUpdateSets() : null; } public List getSetUpdateSets() { @@ -355,139 +356,212 @@ public void setOracleMultiInsertBranches( } @Override - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"}) public String toString() { - StringBuilder sql = new StringBuilder(); - appendWithItems(sql); - appendInsertPrefix(sql); - if (appendOracleMultiInsert(sql)) { - return sql.toString(); + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append, builder::append, builder::append, + builder::append).toString(); + } + + /** + * Appends the statement in clause order. {@link #toString()} renders every part as text, while + * {@code InsertDeParser} passes renderers that visit the WITH items, queries, expressions and + * RETURNING items, so both produce the same SQL. + * + * @param builder the target + * @param withItemRenderer renders one WITH item + * @param selectRenderer renders the source query and the queries of Oracle's multi-table insert + * @param expressionRenderer renders expressions, including the assignment lists + * @param selectItemRenderer renders one RETURNING item + * @return the builder + */ + public StringBuilder appendTo(StringBuilder builder, Consumer> withItemRenderer, + Consumer selectRenderer, + Consumer expressionRenderer) { + builder.append(oracleMultiInsertFirst ? " FIRST" : " ALL"); + if (oracleMultiInsertBranches != null) { for (OracleMultiInsertBranch branch : oracleMultiInsertBranches) { - appendOracleMultiInsertBranch(sql, branch); + appendOracleMultiInsertBranch(builder, branch, selectRenderer, expressionRenderer); } } if (select != null) { - sql.append(" ").append(select); + builder.append(" "); + selectRenderer.accept(select); } - return true; } - private void appendInsertTargetAndValues(StringBuilder sql) { - if (overwrite) { - sql.append("OVERWRITE "); - } else { - sql.append("INTO "); + private static void appendOracleMultiInsertBranch(StringBuilder builder, + OracleMultiInsertBranch branch, Consumer selectRenderer, + Consumer expressionRenderer) { + if (onlyDefaultValues) { + builder.append(" DEFAULT VALUES"); + } if (select != null) { - sql.append(select); + builder.append(" "); + selectRenderer.accept(select); } - } - - private void appendInsertActions(StringBuilder sql) { if (setUpdateSets != null && !setUpdateSets.isEmpty()) { - sql.append("SET "); - UpdateSet.appendUpdateSetsTo(sql, setUpdateSets); + builder.append(" SET "); + UpdateSet.appendUpdateSetsTo(builder, setUpdateSets, expressionRenderer); if (rowAlias != null) { - sql.append(" ").append(rowAlias); + builder.append(rowAlias); } } + } + private void appendActions(StringBuilder builder, Consumer expressionRenderer) { if (duplicateAction != null) { - sql.append(" ON DUPLICATE KEY UPDATE "); - duplicateAction.appendTo(sql); + builder.append(" ON DUPLICATE KEY UPDATE "); + duplicateAction.appendTo(builder, expressionRenderer); } - if (conflictAction != null) { - sql.append(" ON CONFLICT"); - + builder.append(" ON CONFLICT"); if (conflictTarget != null) { - conflictTarget.appendTo(sql); + conflictTarget.appendTo(builder, expressionRenderer); } - conflictAction.appendTo(sql); + conflictAction.appendTo(builder, expressionRenderer); } + } - if (returningClause != null) { - returningClause.appendTo(sql); + /** Appends {@code (a, b)} with the plain column names, as INSERT column lists allow. */ + static StringBuilder appendColumnNamesTo(StringBuilder builder, List columns) { + builder.append("("); + for (int i = 0; i < columns.size(); i++) { + if (i > 0) { + builder.append(", "); + } + builder.append(columns.get(i).getColumnName()); } + return builder.append(")"); + } + + /** + * Whether the statement is written without the optional INTO, as in SQLite's + * {@code INSERT OR IGNORE t VALUES (1)}. + */ + public boolean isOmitInto() { + return omitInto; + } + + public void setOmitInto(boolean omitInto) { + this.omitInto = omitInto; + } + + public Insert withOmitInto(boolean omitInto) { + this.omitInto = omitInto; + return this; + } + + /** The conflict resolution of {@code INSERT OR ...} and {@code REPLACE}, or null. */ + public InsertConflictAlgorithm getConflictAlgorithm() { + return conflictAlgorithm; + } + + public void setConflictAlgorithm(InsertConflictAlgorithm conflictAlgorithm) { + this.conflictAlgorithm = conflictAlgorithm; + } + + public Insert withConflictAlgorithm(InsertConflictAlgorithm conflictAlgorithm) { + this.conflictAlgorithm = conflictAlgorithm; + return this; } public Insert withWithItemsList(List> withList) { @@ -562,21 +636,4 @@ public Insert withOracleMultiInsertBranches( this.setOracleMultiInsertBranches(oracleMultiInsertBranches); return this; } - - private void appendOracleMultiInsertBranch(StringBuilder sql, - OracleMultiInsertBranch branch) { - if (branch == null || branch.getClauses() == null || branch.getClauses().isEmpty()) { - return; - } - - if (branch.getWhenExpression() != null) { - sql.append(" WHEN ").append(branch.getWhenExpression()).append(" THEN"); - } else if (branch.isElseClause()) { - sql.append(" ELSE"); - } - - for (OracleMultiInsertClause clause : branch.getClauses()) { - sql.append(" ").append(clause); - } - } } diff --git a/src/main/java/net/sf/jsqlparser/statement/insert/InsertBulk.java b/src/main/java/net/sf/jsqlparser/statement/insert/InsertBulk.java index 8464a4fa99..c0fa0d4430 100644 --- a/src/main/java/net/sf/jsqlparser/statement/insert/InsertBulk.java +++ b/src/main/java/net/sf/jsqlparser/statement/insert/InsertBulk.java @@ -13,6 +13,7 @@ import java.util.List; import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; @@ -20,7 +21,7 @@ import net.sf.jsqlparser.statement.select.OrderByElement; /** SQL Server's SQL declaration preceding a separate bulk-load data stream. */ -public class InsertBulk implements Statement { +public class InsertBulk extends ASTNodeAccessImpl implements Statement { private Table table; private List columns = new ArrayList<>(); private List
tablePrinter) { builder.append("REFRESH MATERIALIZED VIEW "); - if (this.refreshMode == null) { - if (concurrently) { - builder.append("CONCURRENTLY "); - } - builder.append(view); - return builder.toString(); + if (concurrently) { + builder.append("CONCURRENTLY "); } - switch (this.refreshMode) { - case WITH_DATA: - if (concurrently) { - builder.append("CONCURRENTLY "); - } - builder.append(view); - builder.append(" WITH DATA"); - break; - case WITH_NO_DATA: - builder.append(view); - if (!concurrently) { - builder.append(" WITH NO DATA"); - } - break; + tablePrinter.accept(view); + if (refreshMode == RefreshMode.WITH_DATA) { + builder.append(" WITH DATA"); + } else if (refreshMode == RefreshMode.WITH_NO_DATA) { + builder.append(" WITH NO DATA"); } - return builder.toString(); + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); } @Override diff --git a/src/main/java/net/sf/jsqlparser/statement/reindex/Reindex.java b/src/main/java/net/sf/jsqlparser/statement/reindex/Reindex.java new file mode 100644 index 0000000000..29d5a179f9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/reindex/Reindex.java @@ -0,0 +1,183 @@ +/*- + * #%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.reindex; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** A PostgreSQL {@code REINDEX} statement. */ +public class Reindex extends ASTNodeAccessImpl implements Statement { + + public enum Target { + INDEX, TABLE, SCHEMA, DATABASE, SYSTEM + } + + private final List
tables = new ArrayList<>(); + private final List patterns = new ArrayList<>(); + private final List rewrites = new ArrayList<>(); + + /** What the list of a filter holds. */ + public enum ValueType { + /** Database names: {@code (d1, d2)} */ + DATABASES, + /** Database-qualified table names: {@code (d1.t1)} */ + TABLES, + /** Quoted patterns of database and table names: {@code ('d%.t%')} */ + PATTERNS, + /** Pairs of database names: {@code ((from_db, to_db))} */ + DATABASE_PAIRS + } + + public enum Kind { + /** Replicate only these databases */ + REPLICATE_DO_DB(ValueType.DATABASES), + /** Skip these databases */ + REPLICATE_IGNORE_DB(ValueType.DATABASES), + /** Replicate only these tables */ + REPLICATE_DO_TABLE(ValueType.TABLES), + /** Skip these tables */ + REPLICATE_IGNORE_TABLE(ValueType.TABLES), + /** Replicate only tables matching these patterns */ + REPLICATE_WILD_DO_TABLE(ValueType.PATTERNS), + /** Skip tables matching these patterns */ + REPLICATE_WILD_IGNORE_TABLE(ValueType.PATTERNS), + /** Apply the changes of one database to another */ + REPLICATE_REWRITE_DB(ValueType.DATABASE_PAIRS); + + private final ValueType valueType; + + Kind(ValueType valueType) { + this.valueType = valueType; + } + + public ValueType getValueType() { + return valueType; + } + } + + /** A pair of {@code REPLICATE_REWRITE_DB}: the source database and its replacement. */ + public static class DatabaseRewrite implements Serializable { + private final String from; + private final String to; + + public DatabaseRewrite(String from, String to) { + this.from = Objects.requireNonNull(from); + this.to = Objects.requireNonNull(to); + } + + public String getFrom() { + return from; + } + + public String getTo() { + return to; + } + + @Override + public String toString() { + return "(" + from + ", " + to + ")"; + } + } + + public ReplicationFilter(Kind kind) { + this.kind = Objects.requireNonNull(kind); + } + + public Kind getKind() { + return kind; + } + + /** The database names of REPLICATE_DO_DB and REPLICATE_IGNORE_DB. */ + public List getDatabases() { + return databases; + } + + /** The tables of REPLICATE_DO_TABLE and REPLICATE_IGNORE_TABLE. */ + public List
getTables() { + return tables; + } + + /** The patterns of REPLICATE_WILD_DO_TABLE and REPLICATE_WILD_IGNORE_TABLE. */ + public List getPatterns() { + return patterns; + } + + /** The pairs of REPLICATE_REWRITE_DB. */ + public List getRewrites() { + return rewrites; + } + + /** The list that {@link Kind#getValueType()} selects. */ + public List getValues() { + switch (kind.getValueType()) { + case DATABASES: + return databases; + case TABLES: + return tables; + case PATTERNS: + return patterns; + default: + return rewrites; + } + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append(kind).append(" = ("); + List values = getValues(); + for (int i = 0; i < values.size(); i++) { + builder.append(i == 0 ? "" : ", ").append(values.get(i)); + } + return builder.append(')'); + } + + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/replication/ReplicationSourceOption.java b/src/main/java/net/sf/jsqlparser/statement/replication/ReplicationSourceOption.java new file mode 100644 index 0000000000..d94cb451ff --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/replication/ReplicationSourceOption.java @@ -0,0 +1,239 @@ +/*- + * #%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.replication; + +import java.math.BigInteger; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.DoubleValue; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.NullValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.create.user.UserAccount; + +/** + * An option of MySQL's {@code CHANGE REPLICATION SOURCE TO}. Its value is a string, a number, + * {@code NULL}, a keyword such as {@code OFF} (held as a {@link Column}) or, for + * {@code IGNORE_SERVER_IDS}, a parenthesized list of server IDs. {@code PRIVILEGE_CHECKS_USER} + * names an account, which {@link #getAccount()} returns, or {@code NULL}. + * + * @see MySQL + * CHANGE REPLICATION SOURCE TO + */ +public class ReplicationSourceOption extends ReplicationOption { + private final UserAccount account; + + /** The values an option takes in the MySQL 8.4 grammar. */ + public enum ValueType { + /** A string literal. */ + STRING, + /** A string literal or {@code NULL}. */ + STRING_OR_NULL, + /** An unsigned integer or decimal literal. */ + NUMBER, + /** The integer literal 0 or 1. */ + ZERO_OR_ONE, + /** A parenthesized, possibly empty list of numbers. */ + NUMBER_LIST, + /** An account or {@code NULL}. */ + ACCOUNT_OR_NULL, + /** {@code STREAM}, {@code ON}, {@code OFF} or {@code GENERATE}. */ + PRIMARY_KEY_CHECK, + /** {@code OFF}, {@code LOCAL} or a UUID string. */ + GTID_ASSIGNMENT, + /** No value at all. */ + NONE; + + /** + * Whether MySQL accepts {@code value} for an option of this type. An account is not an + * expression, so for {@link #ACCOUNT_OR_NULL} only {@code NULL} is checked here. + */ + public boolean accepts(Expression value) { + switch (this) { + case STRING: + return value instanceof StringValue; + case STRING_OR_NULL: + return value instanceof StringValue || value instanceof NullValue; + case NUMBER: + return value instanceof LongValue || value instanceof DoubleValue; + case ZERO_OR_ONE: + return value instanceof LongValue && BigInteger.ONE + .compareTo(((LongValue) value).getBigIntegerValue()) >= 0; + case NUMBER_LIST: + return value instanceof ParenthesedExpressionList; + case ACCOUNT_OR_NULL: + return value instanceof NullValue; + case PRIMARY_KEY_CHECK: + return isKeyword(value, "STREAM", "ON", "OFF", "GENERATE"); + case GTID_ASSIGNMENT: + return value instanceof StringValue || isKeyword(value, "OFF", "LOCAL"); + default: + return value == null; + } + } + + private static boolean isKeyword(Expression value, String... keywords) { + if (!(value instanceof Column)) { + return false; + } + String name = ((Column) value).getColumnName(); + for (String keyword : keywords) { + if (keyword.equalsIgnoreCase(name)) { + return true; + } + } + return false; + } + } + + /** The options of MySQL 8.4; the MASTER_ spellings were removed in 8.4. */ + public enum Kind { + /** The network interface of the replica */ + SOURCE_BIND(ValueType.STRING), + /** The host name or IP address of the source */ + SOURCE_HOST(ValueType.STRING), + /** The replication user account */ + SOURCE_USER(ValueType.STRING), + /** The password of the replication user */ + SOURCE_PASSWORD(ValueType.STRING), + /** The TCP/IP port of the source */ + SOURCE_PORT(ValueType.NUMBER), + /** The account that privilege checks of the applier use, or NULL */ + PRIVILEGE_CHECKS_USER(ValueType.ACCOUNT_OR_NULL), + /** Whether the channel accepts only row-based events */ + REQUIRE_ROW_FORMAT(ValueType.NUMBER), + /** The primary key check of the channel */ + REQUIRE_TABLE_PRIMARY_KEY_CHECK(ValueType.PRIMARY_KEY_CHECK), + /** How anonymous transactions get a GTID */ + ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS(ValueType.GTID_ASSIGNMENT), + /** The binary log file to read from */ + SOURCE_LOG_FILE(ValueType.STRING), + /** The position to read from in the binary log file */ + SOURCE_LOG_POS(ValueType.NUMBER), + /** Whether the replica finds its position by GTID */ + SOURCE_AUTO_POSITION(ValueType.NUMBER), + /** The relay log file the applier starts from */ + RELAY_LOG_FILE(ValueType.STRING), + /** The position the applier starts from in the relay log file */ + RELAY_LOG_POS(ValueType.NUMBER), + /** The heartbeat interval in seconds */ + SOURCE_HEARTBEAT_PERIOD(ValueType.NUMBER), + /** The seconds between reconnection attempts */ + SOURCE_CONNECT_RETRY(ValueType.NUMBER), + /** The number of reconnection attempts */ + SOURCE_RETRY_COUNT(ValueType.NUMBER), + /** Whether the channel fails over to another source */ + SOURCE_CONNECTION_AUTO_FAILOVER(ValueType.ZERO_OR_ONE), + /** The seconds the replica lags behind the source */ + SOURCE_DELAY(ValueType.NUMBER), + /** The permitted compression algorithms */ + SOURCE_COMPRESSION_ALGORITHMS(ValueType.STRING), + /** The zstd compression level */ + SOURCE_ZSTD_COMPRESSION_LEVEL(ValueType.NUMBER), + /** Whether the connection uses SSL */ + SOURCE_SSL(ValueType.NUMBER), + /** The certificate authority file */ + SOURCE_SSL_CA(ValueType.STRING), + /** The directory of certificate authority files */ + SOURCE_SSL_CAPATH(ValueType.STRING), + /** The certificate file */ + SOURCE_SSL_CERT(ValueType.STRING), + /** The certificate revocation list file */ + SOURCE_SSL_CRL(ValueType.STRING), + /** The directory of certificate revocation list files */ + SOURCE_SSL_CRLPATH(ValueType.STRING), + /** The private key file */ + SOURCE_SSL_KEY(ValueType.STRING), + /** The permitted ciphers */ + SOURCE_SSL_CIPHER(ValueType.STRING), + /** Whether the replica verifies the certificate of the source */ + SOURCE_SSL_VERIFY_SERVER_CERT(ValueType.NUMBER), + /** The permitted TLS protocols */ + SOURCE_TLS_VERSION(ValueType.STRING), + /** The permitted TLSv1.3 cipher suites, or NULL */ + SOURCE_TLS_CIPHERSUITES(ValueType.STRING_OR_NULL), + /** The file of the RSA public key of the source */ + SOURCE_PUBLIC_KEY_PATH(ValueType.STRING), + /** Whether the replica requests the RSA public key of the source */ + GET_SOURCE_PUBLIC_KEY(ValueType.NUMBER), + /** The network namespace of the connection */ + NETWORK_NAMESPACE(ValueType.STRING), + /** The server IDs whose events the replica ignores */ + IGNORE_SERVER_IDS(ValueType.NUMBER_LIST), + /** Whether the channel keeps no file names and positions */ + GTID_ONLY(ValueType.ZERO_OR_ONE); + + private final ValueType valueType; + + Kind(ValueType valueType) { + this.valueType = valueType; + } + + public ValueType getValueType() { + return valueType; + } + } + + /** The values of {@code REQUIRE_TABLE_PRIMARY_KEY_CHECK}. */ + public enum PrimaryKeyCheck { + STREAM, ON, OFF, GENERATE + } + + /** The values of {@code ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS}; UUID is a quoted UUID. */ + public enum GtidAssignment { + OFF, LOCAL, UUID + } + + public ReplicationSourceOption(String name, Kind kind, Expression value) { + super(name, kind, value); + this.account = null; + } + + /** {@code PRIVILEGE_CHECKS_USER = account}. */ + public ReplicationSourceOption(String name, UserAccount account) { + super(name, Kind.PRIVILEGE_CHECKS_USER, null); + this.account = account; + } + + /** The account of {@code PRIVILEGE_CHECKS_USER}, null for {@code NULL} and other options. */ + public UserAccount getAccount() { + return account; + } + + public PrimaryKeyCheck getPrimaryKeyCheck() { + return getKind() == Kind.REQUIRE_TABLE_PRIMARY_KEY_CHECK + ? enumValue(PrimaryKeyCheck.class) + : null; + } + + public GtidAssignment getGtidAssignment() { + if (getKind() != Kind.ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS) { + return null; + } + return getValue() instanceof StringValue ? GtidAssignment.UUID + : enumValue(GtidAssignment.class); + } + + @Override + public String getValueText() { + return account != null ? account.toString() : super.getValueText(); + } + + @Override + public void appendTo(StringBuilder sql, Consumer expressions) { + if (account == null) { + super.appendTo(sql, expressions); + } else { + sql.append(getName()).append(" = ").append(account); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/replication/ResetReplicationStatement.java b/src/main/java/net/sf/jsqlparser/statement/replication/ResetReplicationStatement.java new file mode 100644 index 0000000000..4a4d316ba9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/replication/ResetReplicationStatement.java @@ -0,0 +1,142 @@ +/*- + * #%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.replication; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; + +/** + * MySQL {@code RESET reset_option [, reset_option] ...} with the replication options + * {@code BINARY LOGS AND GTIDS [TO n]} and {@code REPLICA [ALL] [FOR CHANNEL 'channel']}. The + * PostgreSQL {@code RESET} of a configuration parameter remains a + * {@link net.sf.jsqlparser.statement.ResetStatement}.
+ * Example:
+ * RESET REPLICA ALL FOR CHANNEL 'c1', BINARY LOGS AND GTIDS TO 1234
+ * + * @see MySQL RESET + * @see MySQL + * RESET BINARY LOGS AND GTIDS + * @see MySQL RESET REPLICA + */ +public class ResetReplicationStatement extends ASTNodeAccessImpl implements Statement { + private List
visitor) { + Table relation = objectType == ObjectType.COLUMN && column != null ? column.getTable() + : objectType != null && objectType.isRelation() ? objectName : null; + if (relation != null) { + visitor.accept(relation); + } + } + + public StringBuilder appendTo(StringBuilder builder, Consumer
relationWriter, + Consumer columnWriter, Consumer labelWriter) { + builder.append("SECURITY LABEL "); + if (provider != null) { + builder.append("FOR ").append(provider).append(' '); + } + builder.append("ON "); + if (objectType == ObjectType.LANGUAGE && procedural) { + builder.append("PROCEDURAL "); + } + builder.append(objectType.getKeyword()).append(' '); + if (objectType == ObjectType.COLUMN) { + columnWriter.accept(column); + } else if (objectType.isRoutine()) { + builder.append(routine); + } else if (objectType == ObjectType.LARGE_OBJECT) { + builder.append(largeObjectOid); + } else if (objectType.isRelation()) { + relationWriter.accept(objectName); + } else { + builder.append(objectName); + } + builder.append(" IS "); + if (label == null) { + builder.append("NULL"); + } else { + labelWriter.accept(label); + } + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append, builder::append, builder::append).toString(); + } + + public SecurityLabel withProvider(String provider) { + setProvider(provider); + return this; + } + + public SecurityLabel withObjectName(ObjectType objectType, Table objectName) { + setObjectName(objectType, objectName); + return this; + } + + public SecurityLabel withColumn(Column column) { + setColumn(column); + return this; + } + + public SecurityLabel withRoutine(ObjectType objectType, RoutineReference routine) { + setRoutine(objectType, routine); + return this; + } + + public SecurityLabel withLargeObjectOid(long largeObjectOid) { + setLargeObjectOid(largeObjectOid); + return this; + } + + public SecurityLabel withLabel(StringValue label) { + setLabel(label); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java index 704c22f254..157582acb0 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapter.java @@ -14,6 +14,7 @@ import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.ExpressionVisitor; import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.Function; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.imprt.Import; @@ -117,7 +118,11 @@ public T visit(LateralSubSelect lateralSubSelect, S context) { @Override public T visit(TableFunction tableFunction, S context) { - + if (tableFunction.getFunctions() != null) { + for (Function function : tableFunction.getFunctions()) { + function.accept(expressionVisitor, context); + } + } return null; } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/GroupByElement.java b/src/main/java/net/sf/jsqlparser/statement/select/GroupByElement.java index b0ba784b7a..f7be412e6d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/GroupByElement.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/GroupByElement.java @@ -33,6 +33,8 @@ public enum SortDirection { private List> groupingSets = new ArrayList<>(); // postgres rollup is an ExpressionList private boolean mysqlWithRollup = false; + private boolean all = false; + private boolean distinct = false; public boolean isUsingBrackets() { return groupByExpressions.isUsingBrackets(); @@ -115,6 +117,12 @@ public String toString() { public void appendTo(StringBuilder builder, Consumer> listRenderer, Consumer expressionRenderer) { builder.append("GROUP BY "); + if (all) { + builder.append("ALL "); + } + if (distinct) { + builder.append("DISTINCT "); + } if (groupByExpressions != null) { if (hasGroupBySortDirections()) { appendOrderedExpressions(builder, expressionRenderer); @@ -200,4 +208,22 @@ public GroupByElement setMysqlWithRollup(boolean mysqlWithRollup) { this.mysqlWithRollup = mysqlWithRollup; return this; } + + public boolean isAll() { + return all; + } + + public GroupByElement setAll(boolean all) { + this.all = all; + return this; + } + + public boolean isDistinct() { + return distinct; + } + + public GroupByElement setDistinct(boolean distinct) { + this.distinct = distinct; + return this; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/Join.java b/src/main/java/net/sf/jsqlparser/statement/select/Join.java index d06a5df1f8..04b7d0eb10 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/Join.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/Join.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.select; +import net.sf.jsqlparser.expression.Alias; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; @@ -25,6 +26,7 @@ public class Join extends ASTNodeAccessImpl { private final LinkedList onExpressions = new LinkedList<>(); private final LinkedList usingColumns = new LinkedList<>(); + private Alias usingAlias; private boolean asOf = false; private boolean outer = false; private boolean right = false; @@ -494,6 +496,23 @@ public Join withUsingColumns(List list) { return this; } + /** + * The alias of the USING columns, as in PostgreSQL's {@code a JOIN b USING (id) AS j}: a table + * alias that exposes only the columns listed in USING. Null when there is none. + */ + public Alias getUsingAlias() { + return usingAlias; + } + + public void setUsingAlias(Alias usingAlias) { + this.usingAlias = usingAlias; + } + + public Join withUsingAlias(Alias usingAlias) { + this.setUsingAlias(usingAlias); + return this; + } + public boolean isWindowJoin() { return joinWindow != null; } @@ -617,11 +636,23 @@ public String toString() { for (Expression onExpression : onExpressions) { builder.append(" ON ").append(onExpression); } + appendUsingTo(builder); + + return builder.toString(); + } + + /** + * Appends {@code USING (columns) [AS alias]} with a leading space, or nothing when the join has + * no USING columns. + */ + public StringBuilder appendUsingTo(StringBuilder builder) { if (!usingColumns.isEmpty()) { builder.append(PlainSelect.getFormattedList(usingColumns, "USING", true, true)); + if (usingAlias != null) { + builder.append(" AS ").append(usingAlias.getName()); + } } - - return builder.toString(); + return builder; } public Join addUsingColumns(Column... usingColumns) { diff --git a/src/main/java/net/sf/jsqlparser/statement/select/JoinHint.java b/src/main/java/net/sf/jsqlparser/statement/select/JoinHint.java index 43083de1cd..d236bc4e9f 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/JoinHint.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/JoinHint.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.select; +import java.io.Serializable; import java.util.Objects; /** @@ -19,7 +20,7 @@ * (Transact-SQL) - Join */ -public class JoinHint { +public class JoinHint implements Serializable { public enum Position { BEFORE_JOIN, AFTER_JOIN } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/Limit.java b/src/main/java/net/sf/jsqlparser/statement/select/Limit.java index ec5923a3f6..87d9729851 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/Limit.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/Limit.java @@ -32,6 +32,8 @@ public class Limit extends ASTNodeAccessImpl { */ private ExpressionList byExpressions; + private String percentUnit; + public Expression getOffset() { return offset; } @@ -72,19 +74,39 @@ public void setLimitNull(boolean b) { } } + /** + * DuckDB's {@code %} or {@code PERCENT} after the row count, which then is a percentage of the + * rows, or {@code null}. + */ + public String getPercentUnit() { + return percentUnit; + } + + public Limit setPercentUnit(String percentUnit) { + this.percentUnit = percentUnit; + return this; + } + + String percentUnitToString() { + if (percentUnit == null) { + return ""; + } + return "%".equals(percentUnit) ? "%" : " " + percentUnit; + } + @Override public String toString() { String retVal = " LIMIT "; if (rowCount instanceof AllValue || rowCount instanceof NullValue) { // no offset allowed - retVal += rowCount; + retVal += rowCount + percentUnitToString(); } else { if (null != offset) { retVal += offset + ", "; } if (null != rowCount) { - retVal += rowCount; + retVal += rowCount + percentUnitToString(); } } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectIntoClause.java b/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectIntoClause.java index 16a0755fc0..dbb0c2dea5 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectIntoClause.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectIntoClause.java @@ -16,6 +16,7 @@ import net.sf.jsqlparser.expression.UserVariable; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.MySqlFileFormat; public class MySqlSelectIntoClause extends ASTNodeAccessImpl implements Serializable { @@ -27,6 +28,10 @@ public enum Type { OUTFILE, DUMPFILE, VARIABLES } + /** + * The spelling of the fields clause, as {@link #getFieldsKeyword()} reports it from + * {@link MySqlFileFormat.FieldsKeyword}. + */ public enum FieldsKeyword { FIELDS, COLUMNS } @@ -36,13 +41,8 @@ public enum FieldsKeyword { private StringValue fileName; private ExpressionList variables; private String characterSet; - private FieldsKeyword fieldsKeyword; - private StringValue fieldsTerminatedBy; - private boolean fieldsOptionallyEnclosed; - private StringValue fieldsEnclosedBy; - private StringValue fieldsEscapedBy; - private StringValue linesStartingBy; - private StringValue linesTerminatedBy; + private boolean useCharsetKeyword; + private MySqlFileFormat fileFormat; public Position getPosition() { return position; @@ -89,69 +89,105 @@ public void setCharacterSet(String characterSet) { this.characterSet = characterSet; } + /** Whether the character set clause is spelled CHARSET rather than CHARACTER SET. */ + public boolean isUseCharsetKeyword() { + return useCharsetKeyword; + } + + public void setUseCharsetKeyword(boolean useCharsetKeyword) { + this.useCharsetKeyword = useCharsetKeyword; + } + + /** + * The FIELDS and LINES clauses of INTO OUTFILE, shared with LOAD DATA. The getters and setters + * of the separate subclauses below read and write this format. + */ + public MySqlFileFormat getFileFormat() { + return fileFormat; + } + + public void setFileFormat(MySqlFileFormat fileFormat) { + this.fileFormat = fileFormat; + } + + public MySqlSelectIntoClause withFileFormat(MySqlFileFormat fileFormat) { + setFileFormat(fileFormat); + return this; + } + + private MySqlFileFormat fileFormat() { + if (fileFormat == null) { + fileFormat = new MySqlFileFormat(); + } + return fileFormat; + } + public FieldsKeyword getFieldsKeyword() { - return fieldsKeyword; + MySqlFileFormat.FieldsKeyword keyword = + fileFormat != null ? fileFormat.getFieldsKeyword() : null; + return keyword != null ? FieldsKeyword.valueOf(keyword.name()) : null; } public void setFieldsKeyword(FieldsKeyword fieldsKeyword) { - this.fieldsKeyword = fieldsKeyword; + fileFormat().setFieldsKeyword(fieldsKeyword != null + ? MySqlFileFormat.FieldsKeyword.valueOf(fieldsKeyword.name()) + : null); } public StringValue getFieldsTerminatedBy() { - return fieldsTerminatedBy; + return fileFormat != null ? fileFormat.getFieldsTerminatedBy() : null; } public void setFieldsTerminatedBy(StringValue fieldsTerminatedBy) { - this.fieldsTerminatedBy = fieldsTerminatedBy; + fileFormat().setFieldsTerminatedBy(fieldsTerminatedBy); } public boolean isFieldsOptionallyEnclosed() { - return fieldsOptionallyEnclosed; + return fileFormat != null && fileFormat.isFieldsOptionallyEnclosed(); } public void setFieldsOptionallyEnclosed(boolean fieldsOptionallyEnclosed) { - this.fieldsOptionallyEnclosed = fieldsOptionallyEnclosed; + fileFormat().setFieldsOptionallyEnclosed(fieldsOptionallyEnclosed); } public StringValue getFieldsEnclosedBy() { - return fieldsEnclosedBy; + return fileFormat != null ? fileFormat.getFieldsEnclosedBy() : null; } public void setFieldsEnclosedBy(StringValue fieldsEnclosedBy) { - this.fieldsEnclosedBy = fieldsEnclosedBy; + fileFormat().setFieldsEnclosedBy(fieldsEnclosedBy); } public StringValue getFieldsEscapedBy() { - return fieldsEscapedBy; + return fileFormat != null ? fileFormat.getFieldsEscapedBy() : null; } public void setFieldsEscapedBy(StringValue fieldsEscapedBy) { - this.fieldsEscapedBy = fieldsEscapedBy; + fileFormat().setFieldsEscapedBy(fieldsEscapedBy); } public StringValue getLinesStartingBy() { - return linesStartingBy; + return fileFormat != null ? fileFormat.getLinesStartingBy() : null; } public void setLinesStartingBy(StringValue linesStartingBy) { - this.linesStartingBy = linesStartingBy; + fileFormat().setLinesStartingBy(linesStartingBy); } public StringValue getLinesTerminatedBy() { - return linesTerminatedBy; + return fileFormat != null ? fileFormat.getLinesTerminatedBy() : null; } public void setLinesTerminatedBy(StringValue linesTerminatedBy) { - this.linesTerminatedBy = linesTerminatedBy; + fileFormat().setLinesTerminatedBy(linesTerminatedBy); } public boolean hasFieldsClause() { - return fieldsKeyword != null || fieldsTerminatedBy != null || fieldsEnclosedBy != null - || fieldsEscapedBy != null; + return fileFormat != null && fileFormat.hasFieldsClause(); } public boolean hasLinesClause() { - return linesStartingBy != null || linesTerminatedBy != null; + return fileFormat != null && fileFormat.hasLinesClause(); } public StringBuilder appendTo(StringBuilder builder) { @@ -168,59 +204,17 @@ public StringBuilder appendTo(StringBuilder builder, Consumer expres return builder; } builder.append(type); - appendFileName(builder); - appendCharacterSet(builder); - appendFieldsClause(builder); - appendLinesClause(builder); - return builder; - } - - private void appendFileName(StringBuilder builder) { if (fileName != null) { builder.append(" ").append(fileName); } - } - - private void appendCharacterSet(StringBuilder builder) { if (characterSet != null) { - builder.append(" CHARACTER SET ").append(characterSet); - } - } - - private void appendFieldsClause(StringBuilder builder) { - if (!hasFieldsClause()) { - return; + builder.append(useCharsetKeyword ? " CHARSET " : " CHARACTER SET ") + .append(characterSet); } - - builder.append(" ").append(fieldsKeyword != null ? fieldsKeyword : FieldsKeyword.FIELDS); - - if (fieldsTerminatedBy != null) { - builder.append(" TERMINATED BY ").append(fieldsTerminatedBy); - } - if (fieldsEnclosedBy != null) { - builder.append(" "); - if (fieldsOptionallyEnclosed) { - builder.append("OPTIONALLY "); - } - builder.append("ENCLOSED BY ").append(fieldsEnclosedBy); - } - if (fieldsEscapedBy != null) { - builder.append(" ESCAPED BY ").append(fieldsEscapedBy); - } - } - - private void appendLinesClause(StringBuilder builder) { - if (!hasLinesClause()) { - return; - } - - builder.append(" LINES"); - if (linesStartingBy != null) { - builder.append(" STARTING BY ").append(linesStartingBy); - } - if (linesTerminatedBy != null) { - builder.append(" TERMINATED BY ").append(linesTerminatedBy); + if (fileFormat != null && !fileFormat.isEmpty()) { + fileFormat.appendTo(builder.append(" ")); } + return builder; } @Override diff --git a/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectModifier.java b/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectModifier.java new file mode 100644 index 0000000000..60262e16e0 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/select/MySqlSelectModifier.java @@ -0,0 +1,18 @@ +/*- + * #%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.select; + +/** + * MySQL SELECT modifiers, in rendering order. SQL_CACHE is retained for older MySQL releases and + * MariaDB. DISTINCT and ALL remain part of the common SELECT grammar. + */ +public enum MySqlSelectModifier { + HIGH_PRIORITY, STRAIGHT_JOIN, SQL_SMALL_RESULT, SQL_BIG_RESULT, SQL_BUFFER_RESULT, SQL_CACHE, SQL_NO_CACHE, SQL_CALC_FOUND_ROWS +} diff --git a/src/main/java/net/sf/jsqlparser/statement/select/OrderByElement.java b/src/main/java/net/sf/jsqlparser/statement/select/OrderByElement.java index 4662150fa5..f412066c83 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/OrderByElement.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/OrderByElement.java @@ -9,12 +9,11 @@ */ package net.sf.jsqlparser.statement.select; -import java.io.Serializable; - import java.util.Locale; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; -public class OrderByElement implements Serializable { +public class OrderByElement extends ASTNodeAccessImpl { private Expression expression; // postgres rollup is an ExpressionList diff --git a/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java b/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java index 58510e04fc..8cc87e7d83 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java @@ -15,9 +15,10 @@ import java.util.Arrays; import java.util.Collection; import java.util.Collections; -import java.util.Iterator; +import java.util.EnumSet; import java.util.List; import java.util.Optional; +import java.util.Set; import net.sf.jsqlparser.expression.Alias; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.OracleHierarchicalExpression; @@ -33,7 +34,7 @@ public class PlainSelect extends Select { private Distinct distinct = null; private BigQuerySelectQualifier bigQuerySelectQualifier = null; private List> selectItems; - private List
intoTables; + private SelectIntoClause intoClause; private MySqlSelectIntoClause mySqlSelectIntoClause; private FromItem fromItem; private List lateralViews; @@ -43,16 +44,16 @@ public class PlainSelect extends Select { private GroupByElement groupBy; private Expression having; private Expression qualify; + private boolean qualifyAfterWindow; private OptimizeFor optimizeFor; private Skip skip; - private boolean mySqlHintStraightJoin; + private final EnumSet mySqlSelectModifiers = + EnumSet.noneOf(MySqlSelectModifier.class); private First first; private Top top; private OracleHierarchicalExpression oracleHierarchical = null; private PreferringClause preferringClause = null; private OracleHint oracleHint = null; - private boolean mySqlSqlCalcFoundRows = false; - private MySqlSqlCacheFlags mySqlCacheFlag = null; private String forXmlPath; private KSQLWindow ksqlWindow = null; private EmitMode emitMode = EmitMode.NONE; @@ -67,7 +68,6 @@ public class PlainSelect extends Select { private boolean isUsingOnly = false; private boolean useWithNoLog = false; private boolean fromFirst = false; - private Table intoTempTable = null; private List settings = null; public enum EmitMode { @@ -141,12 +141,50 @@ public void setFromItem(FromItem item) { fromItem = item; } + /** + * The {@code INTO [persistence] [TABLE] table} clause, either after the select list or, for + * Informix's {@code INTO TEMP table}, at the end of the query. A SELECT has one such clause. + */ + public SelectIntoClause getIntoClause() { + return intoClause; + } + + public void setIntoClause(SelectIntoClause intoClause) { + this.intoClause = intoClause; + } + + public PlainSelect withIntoClause(SelectIntoClause intoClause) { + this.setIntoClause(intoClause); + return this; + } + + private boolean hasIntoClauseAt(SelectIntoClause.Position position) { + return intoClause != null && intoClause.getPosition() == position; + } + + /** + * The tables of the INTO clause after the select list, or null when there is none. This is a + * view of {@link #getIntoClause()}, which also holds the persistence and the TABLE keyword. + */ public List
getIntoTables() { - return intoTables; + return hasIntoClauseAt(SelectIntoClause.Position.BEFORE_FROM) ? intoClause.getTables() + : null; } + /** + * Sets the tables of the INTO clause after the select list, keeping the persistence and the + * TABLE keyword of such a clause. Null removes the clause. + */ public void setIntoTables(List
intoTables) { - this.intoTables = intoTables; + if (intoTables == null) { + if (hasIntoClauseAt(SelectIntoClause.Position.BEFORE_FROM)) { + intoClause = null; + } + } else if (hasIntoClauseAt(SelectIntoClause.Position.BEFORE_FROM)) { + intoClause.setTables(intoTables); + } else { + intoClause = new SelectIntoClause().withTables(intoTables); + } } public MySqlSelectIntoClause getMySqlSelectIntoClause() { @@ -326,12 +364,23 @@ public PlainSelect withUseWithNoLog(boolean useWithNoLog) { return this; } + /** + * The table of an {@code INTO TEMP table} clause at the end of the query, or null when there is + * none. This is a view of {@link #getIntoClause()}. + */ public Table getIntoTempTable() { - return intoTempTable; + return hasIntoClauseAt(SelectIntoClause.Position.TRAILING) ? intoClause.getTable() : null; } + /** Sets an {@code INTO TEMP table} clause at the end of the query. Null removes it. */ public void setIntoTempTable(Table intoTempTable) { - this.intoTempTable = intoTempTable; + if (intoTempTable != null) { + intoClause = new SelectIntoClause(intoTempTable) + .withPosition(SelectIntoClause.Position.TRAILING) + .withPersistence(SelectIntoClause.Persistence.TEMP); + } else if (hasIntoClauseAt(SelectIntoClause.Position.TRAILING)) { + intoClause = null; + } } public PlainSelect withIntoTempTable(Table intoTempTable) { @@ -397,11 +446,11 @@ public void setSkip(Skip skip) { } public boolean getMySqlHintStraightJoin() { - return this.mySqlHintStraightJoin; + return mySqlSelectModifiers.contains(MySqlSelectModifier.STRAIGHT_JOIN); } public void setMySqlHintStraightJoin(boolean mySqlHintStraightJoin) { - this.mySqlHintStraightJoin = mySqlHintStraightJoin; + setMySqlSelectModifier(MySqlSelectModifier.STRAIGHT_JOIN, mySqlHintStraightJoin); } public First getFirst() { @@ -441,6 +490,16 @@ public Expression getQualify() { return qualify; } + /** Whether QUALIFY follows the WINDOW clause, as in DuckDB, rather than preceding it. */ + public boolean isQualifyAfterWindow() { + return qualifyAfterWindow; + } + + public PlainSelect setQualifyAfterWindow(boolean qualifyAfterWindow) { + this.qualifyAfterWindow = qualifyAfterWindow; + return this; + } + public PlainSelect setQualify(Expression qualify) { this.qualify = qualify; return this; @@ -594,7 +653,7 @@ public StringBuilder appendSelectBodyTo(StringBuilder builder) { if (having != null) { builder.append(" HAVING ").append(having); } - if (qualify != null) { + if (qualify != null && !qualifyAfterWindow) { builder.append(" QUALIFY ").append(qualify); } if (windowDefinitions != null) { @@ -602,9 +661,12 @@ public StringBuilder appendSelectBodyTo(StringBuilder builder) { builder.append(windowDefinitions.stream().map(WindowDefinition::toString) .collect(joining(", "))); } + if (qualify != null && qualifyAfterWindow) { + builder.append(" QUALIFY ").append(qualify); + } appendEmitClauseTo(builder); - if (intoTempTable != null) { - builder.append(" INTO TEMP ").append(intoTempTable); + if (hasIntoClauseAt(SelectIntoClause.Position.TRAILING)) { + builder.append(' ').append(intoClause); } if (useWithNoLog) { builder.append(" WITH NO LOG"); @@ -614,17 +676,19 @@ public StringBuilder appendSelectBodyTo(StringBuilder builder) { private void appendSelectClauseTo(StringBuilder builder) { builder.append("SELECT "); + int afterSelect = builder.length(); appendSelectHintsTo(builder); appendSelectQualifiersTo(builder); - appendMySqlSelectFlagsTo(builder); + appendMySqlSelectModifiersTo(builder); builder.append(getStringList(selectItems)); + // PostgreSQL permits SELECT with no target expressions: keep "SELECT + // FROM" instead of doubling the space. + if (builder.length() == afterSelect) { + builder.deleteCharAt(afterSelect - 1); + } } private void appendSelectHintsTo(StringBuilder builder) { - if (this.mySqlHintStraightJoin) { - builder.append("STRAIGHT_JOIN "); - } - if (oracleHint != null) { builder.append(oracleHint).append(" "); } @@ -659,25 +723,54 @@ private void appendSelectQualifiersTo(StringBuilder builder) { } } - private void appendMySqlSelectFlagsTo(StringBuilder builder) { - if (mySqlCacheFlag != null) { - builder.append(mySqlCacheFlag.name()).append(" "); + /** Appends the typed modifiers in MySQL's documented SELECT order. */ + public void appendMySqlSelectModifiersTo(StringBuilder builder) { + for (MySqlSelectModifier modifier : mySqlSelectModifiers) { + builder.append(modifier).append(" "); } + } + + /** Returns the modifiers independently of the selected expressions and aliases. */ + public Set getMySqlSelectModifiers() { + return Collections.unmodifiableSet(mySqlSelectModifiers); + } - if (mySqlSqlCalcFoundRows) { - builder.append("SQL_CALC_FOUND_ROWS").append(" "); + public void setMySqlSelectModifiers(Collection modifiers) { + EnumSet copy = EnumSet.noneOf(MySqlSelectModifier.class); + if (modifiers != null) { + copy.addAll(modifiers); + } + if (copy.contains(MySqlSelectModifier.SQL_CACHE) + && copy.contains(MySqlSelectModifier.SQL_NO_CACHE)) { + throw new IllegalArgumentException("SQL_CACHE and SQL_NO_CACHE cannot be combined"); + } + mySqlSelectModifiers.clear(); + mySqlSelectModifiers.addAll(copy); + } + + public PlainSelect addMySqlSelectModifiers(MySqlSelectModifier... modifiers) { + EnumSet copy = mySqlSelectModifiers.clone(); + Collections.addAll(copy, modifiers); + setMySqlSelectModifiers(copy); + return this; + } + + public PlainSelect withMySqlSelectModifiers(Collection modifiers) { + setMySqlSelectModifiers(modifiers); + return this; + } + + private void setMySqlSelectModifier(MySqlSelectModifier modifier, boolean enabled) { + if (enabled) { + mySqlSelectModifiers.add(modifier); + } else { + mySqlSelectModifiers.remove(modifier); } } private void appendIntoClausesTo(StringBuilder builder) { - if (intoTables != null) { - builder.append(" INTO "); - for (Iterator
iter = intoTables.iterator(); iter.hasNext();) { - builder.append(iter.next().toString()); - if (iter.hasNext()) { - builder.append(", "); - } - } + if (hasIntoClauseAt(SelectIntoClause.Position.BEFORE_FROM)) { + builder.append(' ').append(intoClause); } if (mySqlSelectIntoClause != null @@ -759,19 +852,28 @@ public PlainSelect withMySqlSqlNoCache(MySqlSqlCacheFlags mySqlCacheFlag) { } public boolean getMySqlSqlCalcFoundRows() { - return this.mySqlSqlCalcFoundRows; + return mySqlSelectModifiers.contains(MySqlSelectModifier.SQL_CALC_FOUND_ROWS); } public void setMySqlSqlCalcFoundRows(boolean mySqlCalcFoundRows) { - this.mySqlSqlCalcFoundRows = mySqlCalcFoundRows; + setMySqlSelectModifier(MySqlSelectModifier.SQL_CALC_FOUND_ROWS, mySqlCalcFoundRows); } public MySqlSqlCacheFlags getMySqlSqlCacheFlag() { - return this.mySqlCacheFlag; + if (mySqlSelectModifiers.contains(MySqlSelectModifier.SQL_CACHE)) { + return MySqlSqlCacheFlags.SQL_CACHE; + } + return mySqlSelectModifiers.contains(MySqlSelectModifier.SQL_NO_CACHE) + ? MySqlSqlCacheFlags.SQL_NO_CACHE + : null; } public void setMySqlSqlCacheFlag(MySqlSqlCacheFlags sqlCacheFlag) { - this.mySqlCacheFlag = sqlCacheFlag; + mySqlSelectModifiers.remove(MySqlSelectModifier.SQL_CACHE); + mySqlSelectModifiers.remove(MySqlSelectModifier.SQL_NO_CACHE); + if (sqlCacheFlag != null) { + mySqlSelectModifiers.add(MySqlSelectModifier.valueOf(sqlCacheFlag.name())); + } } public PlainSelect withDistinct(Distinct distinct) { diff --git a/src/main/java/net/sf/jsqlparser/statement/select/SampleClause.java b/src/main/java/net/sf/jsqlparser/statement/select/SampleClause.java index a3c0203dfa..0eb923938c 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/SampleClause.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/SampleClause.java @@ -9,9 +9,10 @@ */ package net.sf.jsqlparser.statement.select; +import java.io.Serializable; import java.util.Locale; -public class SampleClause { +public class SampleClause implements Serializable { private SampleKeyword keyword; private SampleMethod method; private Number percentageArgument; diff --git a/src/main/java/net/sf/jsqlparser/statement/select/Select.java b/src/main/java/net/sf/jsqlparser/statement/select/Select.java index d3750c98ef..cc880b5853 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/Select.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/Select.java @@ -44,6 +44,7 @@ public abstract class Select extends ASTNodeAccessImpl implements Statement, Exp private Wait wait; private boolean noWait = false; private boolean forUpdateBeforeOrderBy = false; + private List additionalForUpdateClauses = null; Alias alias; Pivot pivot; UnPivot unPivot; @@ -131,9 +132,13 @@ public static StringBuilder appendStringListTo(StringBuilder builder, List li builder.append("("); } - int size = list.size(); - for (int i = 0; i < size; i++) { - builder.append(list.get(i)).append(i < size - 1 ? comma : ""); + boolean first = true; + for (Object element : list) { + if (!first) { + builder.append(comma); + } + builder.append(element); + first = false; } if (useBrackets) { @@ -412,6 +417,30 @@ public ForUpdateClause getForUpdate() { return clause; } + /** + * Returns the locking clauses that follow the first one, as in PostgreSQL's + * {@code FOR UPDATE OF t FOR SHARE OF u}, or {@code null} if there are none. The first clause + * is the one {@link #getForMode()}, {@link #getForUpdateTables()}, {@link #getWait()}, + * {@link #isNoWait()} and {@link #isSkipLocked()} describe. + * + * @return the locking clauses after the first one, or {@code null} + */ + public List getAdditionalForUpdateClauses() { + return additionalForUpdateClauses; + } + + public void setAdditionalForUpdateClauses(List additionalForUpdateClauses) { + this.additionalForUpdateClauses = additionalForUpdateClauses; + } + + public Select addAdditionalForUpdateClause(ForUpdateClause forUpdateClause) { + if (additionalForUpdateClauses == null) { + additionalForUpdateClauses = new ArrayList<>(); + } + additionalForUpdateClauses.add(forUpdateClause); + return this; + } + /** * Returns {@code true} when the {@code FOR UPDATE} clause appears before the {@code ORDER BY} * clause in the original SQL (non-standard ordering supported by some databases). @@ -568,6 +597,11 @@ public StringBuilder appendTo(StringBuilder builder) { } else if (isSkipLocked()) { builder.append(" SKIP LOCKED"); } + if (additionalForUpdateClauses != null) { + for (ForUpdateClause forUpdateClause : additionalForUpdateClauses) { + forUpdateClause.appendTo(builder); + } + } } if (forUpdateBeforeOrderBy) { diff --git a/src/main/java/net/sf/jsqlparser/statement/select/SelectIntoClause.java b/src/main/java/net/sf/jsqlparser/statement/select/SelectIntoClause.java new file mode 100644 index 0000000000..c7d713fba1 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/select/SelectIntoClause.java @@ -0,0 +1,157 @@ +/*- + * #%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.select; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.Objects; +import java.util.function.Consumer; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; + +/** + * The table target of a SELECT: {@code INTO [persistence] [TABLE] table}. + * + *

+ * PostgreSQL creates the table with the persistence written before its name, such as + * {@code INTO TEMP t}, {@code INTO LOCAL TEMPORARY TABLE t} or {@code INTO UNLOGGED t}. Other + * products write the plain {@code INTO t} after the select list as well, and Informix writes + * {@code INTO TEMP t} at the end of the query, which is the {@link Position#TRAILING} position. + */ +public class SelectIntoClause extends ASTNodeAccessImpl implements Serializable { + /** Where the clause is written in the SELECT. */ + public enum Position { + BEFORE_FROM, TRAILING + } + + /** The persistence keywords PostgreSQL accepts before the table name. */ + public enum Persistence { + TEMP, TEMPORARY, LOCAL_TEMP, LOCAL_TEMPORARY, GLOBAL_TEMP, GLOBAL_TEMPORARY, UNLOGGED; + + private final String keywords = name().replace('_', ' '); + + /** Reads the keywords as written, for example {@code "LOCAL TEMP"}. */ + public static Persistence from(String keywords) { + return valueOf(keywords.trim().toUpperCase(Locale.ROOT).replaceAll("\\s+", "_")); + } + + public String getKeywords() { + return keywords; + } + + public boolean isTemporary() { + return this != UNLOGGED; + } + } + + private Position position = Position.BEFORE_FROM; + private Persistence persistence; + private boolean tableKeyword; + private List

tables = new ArrayList<>(); + + public SelectIntoClause() { + // empty constructor + } + + public SelectIntoClause(Table table) { + tables.add(Objects.requireNonNull(table, "table")); + } + + public Position getPosition() { + return position; + } + + public void setPosition(Position position) { + this.position = Objects.requireNonNull(position, "position"); + } + + public SelectIntoClause withPosition(Position position) { + setPosition(position); + return this; + } + + /** The persistence written before the table name, or null when there is none. */ + public Persistence getPersistence() { + return persistence; + } + + public void setPersistence(Persistence persistence) { + this.persistence = persistence; + } + + public SelectIntoClause withPersistence(Persistence persistence) { + setPersistence(persistence); + return this; + } + + /** Whether the optional TABLE keyword precedes the table name. */ + public boolean isTableKeyword() { + return tableKeyword; + } + + public void setTableKeyword(boolean tableKeyword) { + this.tableKeyword = tableKeyword; + } + + public SelectIntoClause withTableKeyword(boolean tableKeyword) { + setTableKeyword(tableKeyword); + return this; + } + + /** The first target, which is the only one of a clause that creates a table. */ + public Table getTable() { + return tables.isEmpty() ? null : tables.get(0); + } + + /** The targets in the order written. The list is the clause's own and may be modified. */ + public List
getTables() { + return tables; + } + + public void setTables(List
tables) { + this.tables = Objects.requireNonNull(tables, "tables"); + } + + public SelectIntoClause withTables(List
tables) { + setTables(tables); + return this; + } + + public SelectIntoClause addTable(Table table) { + tables.add(Objects.requireNonNull(table, "table")); + return this; + } + + /** Appends the clause without a leading space, rendering each table through the renderer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer
tableRenderer) { + builder.append("INTO "); + if (persistence != null) { + builder.append(persistence.getKeywords()).append(' '); + } + if (tableKeyword) { + builder.append("TABLE "); + } + for (int i = 0; i < tables.size(); i++) { + if (i > 0) { + builder.append(", "); + } + tableRenderer.accept(tables.get(i)); + } + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/select/SelectVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/select/SelectVisitorAdapter.java index 45a2db3dd5..db2ad75949 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/SelectVisitorAdapter.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/SelectVisitorAdapter.java @@ -64,7 +64,7 @@ public SelectVisitorAdapter(ExpressionVisitor expressionVisitor) { this.expressionVisitor = expressionVisitor; this.pivotVisitor = new PivotVisitorAdapter<>(); this.selectItemVisitor = new SelectItemVisitorAdapter<>(this.expressionVisitor); - this.fromItemVisitor = new FromItemVisitorAdapter<>(); + this.fromItemVisitor = new FromItemVisitorAdapter<>(this, this.expressionVisitor); } @Override @@ -135,16 +135,19 @@ public T visit(ParenthesedSelect select, S context) { unpivot.accept(pivotVisitor, context); } - expressionVisitor.visitLimit(select.getLimit(), context); + visitLimitOffsetFetch(select, context); + return null; + } + private void visitLimitOffsetFetch(Select select, S context) { + expressionVisitor.visitLimit(select.getLimitBy(), context); + expressionVisitor.visitLimit(select.getLimit(), context); if (select.getOffset() != null) { - expressionVisitor.visitExpression(select.getOffset().getOffset(), null); + expressionVisitor.visitExpression(select.getOffset().getOffset(), context); } if (select.getFetch() != null) { - expressionVisitor.visitExpression(select.getFetch().getExpression(), null); + expressionVisitor.visitExpression(select.getFetch().getExpression(), context); } - - return null; } @Override @@ -190,11 +193,7 @@ public T visit(PlainSelect plainSelect, S context) { expressionVisitor.visitExpression(plainSelect.getPreWhere(), context); expressionVisitor.visitExpression(plainSelect.getWhere(), context); - - // if (plainSelect.getOracleHierarchical() != null) { - // //@todo: implement - // } - // + expressionVisitor.visitExpression(plainSelect.getOracleHierarchical(), context); expressionVisitor.visitPreferringClause(plainSelect.getPreferringClause(), context); expressionVisitor.visit(plainSelect.getGroupBy(), context); @@ -219,25 +218,14 @@ public T visit(PlainSelect plainSelect, S context) { } expressionVisitor.visitOrderBy(plainSelect.getOrderByElements(), context); + visitLimitOffsetFetch(plainSelect, context); - // if (plainSelect.getLimitBy() != null) { - // //@todo: implement - // } - // if (plainSelect.getLimit() != null) { - // //@todo: implement - // } - if (plainSelect.getOffset() != null) { - expressionVisitor.visitExpression(plainSelect.getOffset().getOffset(), context); - } if (plainSelect.getMySqlProcedureAnalyse() != null) { expressionVisitor.visitExpression( plainSelect.getMySqlProcedureAnalyse().getMaxElements(), context); expressionVisitor.visitExpression( plainSelect.getMySqlProcedureAnalyse().getMaxMemory(), context); } - if (plainSelect.getFetch() != null) { - expressionVisitor.visitExpression(plainSelect.getFetch().getExpression(), context); - } // if (plainSelect.getForMode() != null) { // //@todo: implement // } @@ -289,9 +277,12 @@ public T visit(FromQuery fromQuery, S context) { @Override public T visit(SetOperationList setOpList, S context) { + visitWithItems(setOpList.getWithItemsList(), context); for (Select select : setOpList.getSelects()) { select.accept(this, context); } + expressionVisitor.visitOrderBy(setOpList.getOrderByElements(), context); + visitLimitOffsetFetch(setOpList, context); return null; } @@ -341,7 +332,11 @@ public T visit(WithItem withItem, S context) { } @Override - public T visit(Values aThis, S context) { + public T visit(Values values, S context) { + visitWithItems(values.getWithItemsList(), context); + expressionVisitor.visitExpressions(values.getExpressions(), context); + expressionVisitor.visitOrderBy(values.getOrderByElements(), context); + visitLimitOffsetFetch(values, context); return null; } @@ -352,6 +347,9 @@ public T visit(LateralSubSelect lateralSubSelect, S context) { @Override public T visit(TableStatement tableStatement, S context) { + visitWithItems(tableStatement.getWithItemsList(), context); + expressionVisitor.visitOrderBy(tableStatement.getOrderByElements(), context); + visitLimitOffsetFetch(tableStatement, context); return null; } } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/TableFunction.java b/src/main/java/net/sf/jsqlparser/statement/select/TableFunction.java index 5be3f50751..1c688de50e 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/TableFunction.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/TableFunction.java @@ -18,6 +18,8 @@ @SuppressWarnings({"PMD.UncommentedEmptyMethodBody"}) public class TableFunction extends Function implements FromItem { + private SampleClause sampleClause; + private String prefix = null; private Alias alias = null; private Pivot pivot = null; @@ -220,12 +222,13 @@ public TableFunction withUnPivot(UnPivot unpivot) { @Override public SampleClause getSampleClause() { - return null; + return sampleClause; } @Override - public FromItem setSampleClause(SampleClause sampleClause) { - return null; + public TableFunction setSampleClause(SampleClause sampleClause) { + this.sampleClause = sampleClause; + return this; } public StringBuilder appendTo(StringBuilder builder) { @@ -263,6 +266,9 @@ public StringBuilder appendTo(StringBuilder builder, Consumer expres builder.append(offsetAlias); } } + if (sampleClause != null) { + sampleClause.appendTo(builder); + } return builder; } diff --git a/src/main/java/net/sf/jsqlparser/statement/select/TableStatement.java b/src/main/java/net/sf/jsqlparser/statement/select/TableStatement.java index 58072fa555..22d2d0cb44 100644 --- a/src/main/java/net/sf/jsqlparser/statement/select/TableStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/select/TableStatement.java @@ -34,23 +34,6 @@ public StringBuilder appendSelectBodyTo(StringBuilder builder) { return builder; } - @SuppressWarnings({"PMD.CyclomaticComplexity"}) - @Override - public StringBuilder appendTo(StringBuilder builder) { - - appendSelectBodyTo(builder); - - builder.append(orderByToString(false, orderByElements)); - - if (limit != null) { - builder.append(limit); - } - if (offset != null) { - builder.append(offset); - } - return builder; - } - @Override public T accept(SelectVisitor selectVisitor, S context) { return selectVisitor.visit(this, context); diff --git a/src/main/java/net/sf/jsqlparser/statement/show/MySqlShowStatement.java b/src/main/java/net/sf/jsqlparser/statement/show/MySqlShowStatement.java new file mode 100644 index 0000000000..0a544b801e --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/show/MySqlShowStatement.java @@ -0,0 +1,756 @@ +/*- + * #%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.show; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.EnumSet; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.statement.select.Limit; +import net.sf.jsqlparser.statement.select.Offset; + +/** + * A MySQL {@code SHOW} statement that reads server settings, state or object lists, such as + * {@code SHOW GLOBAL VARIABLES LIKE 'max%'}, {@code SHOW GRANTS FOR 'app'@'%'}, + * {@code SHOW BINLOG EVENTS IN 'binlog.000001' LIMIT 10}, {@code SHOW ENGINE INNODB STATUS} or + * {@code SHOW PROFILE CPU FOR QUERY 2}. + * + *

+ * {@link #getKind()} tells which statement it is and {@link #getKeyword()} how its keywords were + * spelled. Each {@link Kind} allows a fixed set of {@link Part parts}; setting a part the kind does + * not allow throws {@link IllegalArgumentException}, and {@link #setKind(Kind)} drops the parts the + * new kind does not allow. The table and column statements ({@code SHOW TABLES}, {@code COLUMNS}, + * {@code INDEX}, {@code TABLE STATUS} and {@code CREATE}) have their own classes. + *

+ * + * @see MySQL SHOW statements + */ +public class MySqlShowStatement extends ASTNodeAccessImpl implements Statement { + + private Kind kind; + private String keyword; + private Scope scope; + private boolean full; + private boolean count; + private Table routineName; + private String engineName; + private EngineInfo engineInfo = EngineInfo.STATUS; + private ShowDbSelection dbSelection; + private ShowFilter filter; + private UserAccount account; + private final List usingRoles = new ArrayList<>(); + private StringValue logName; + private Expression position; + private Limit limit; + private Offset offset; + private StringValue channel; + private final List profileTypes = new ArrayList<>(); + private Expression profileQuery; + + public MySqlShowStatement() { + // empty constructor + } + + public MySqlShowStatement(Kind kind) { + setKind(kind); + } + + public Kind getKind() { + return kind; + } + + /** + * Sets the kind, resets the keyword to the kind's first spelling and drops the parts the new + * kind does not allow. + */ + public void setKind(Kind kind) { + this.kind = kind; + this.keyword = null; + if (kind != null) { + for (Part part : Part.values()) { + if (!kind.allows(part)) { + clear(part); + } + } + } + } + + private void clear(Part part) { + switch (part) { + case SCOPE: + scope = null; + break; + case FULL: + full = false; + break; + case COUNT: + count = false; + break; + case ROUTINE: + routineName = null; + break; + case ENGINE: + engineName = null; + engineInfo = EngineInfo.STATUS; + break; + case DATABASE: + dbSelection = null; + break; + case FILTER: + filter = null; + break; + case ACCOUNT: + account = null; + usingRoles.clear(); + break; + default: + clearRangeParts(part); + } + } + + private void clearRangeParts(Part part) { + switch (part) { + case PROFILE: + profileTypes.clear(); + profileQuery = null; + break; + case LOG_NAME: + logName = null; + break; + case POSITION: + position = null; + break; + case LIMIT: + limit = null; + offset = null; + break; + default: + channel = null; + } + } + + /** + * The keywords as written, one of {@code getKind().getKeywords()}, such as {@code SCHEMAS} for + * {@link Kind#DATABASES}; null without a kind. + */ + public String getKeyword() { + if (keyword != null || kind == null) { + return keyword; + } + return kind.getKeywords().get(0); + } + + /** + * Sets the keywords and selects the kind they spell, as {@link #setKind(Kind)} does if the kind + * changes; null resets the keywords to the first spelling of the kind. + * + * @throws IllegalArgumentException if the keywords spell no kind + */ + public void setKeyword(String keyword) { + if (keyword == null) { + this.keyword = null; + return; + } + Kind spelled = Kind.fromKeyword(keyword); + if (spelled != kind) { + setKind(spelled); + } + this.keyword = Kind.normalize(keyword); + } + + private void require(Part part, boolean present) { + if (present && kind != null && !kind.allows(part)) { + throw new IllegalArgumentException( + "SHOW " + getKeyword() + " does not take the " + part + " part"); + } + } + + /** {@code GLOBAL}, {@code SESSION} or {@code LOCAL}, or null if none was written. */ + public Scope getScope() { + return scope; + } + + public void setScope(Scope scope) { + require(Part.SCOPE, scope != null); + this.scope = scope; + } + + /** Whether {@code FULL} was written, as in {@code SHOW FULL PROCESSLIST}. */ + public boolean isFull() { + return full; + } + + public void setFull(boolean full) { + require(Part.FULL, full); + this.full = full; + } + + /** Whether the statement is {@code SHOW COUNT(*) {WARNINGS | ERRORS}}. */ + public boolean isCount() { + return count; + } + + /** Selects the {@code COUNT(*)} form, which takes no limit; {@code true} clears the limit. */ + public void setCount(boolean count) { + require(Part.COUNT, count); + this.count = count; + if (count) { + limit = null; + offset = null; + } + } + + /** The routine of {@code SHOW {PROCEDURE | FUNCTION} CODE name}, or null. */ + public Table getRoutineName() { + return routineName; + } + + public void setRoutineName(Table routineName) { + require(Part.ROUTINE, routineName != null); + this.routineName = routineName; + } + + /** + * The engine of {@code SHOW ENGINE name ...} as written, including the quotes of a quoted name; + * {@code ALL} for every engine. + */ + public String getEngineName() { + return engineName; + } + + public void setEngineName(String engineName) { + require(Part.ENGINE, engineName != null); + this.engineName = engineName; + } + + /** {@code STATUS}, {@code MUTEX} or {@code LOGS} of {@code SHOW ENGINE}; never null. */ + public EngineInfo getEngineInfo() { + return engineInfo; + } + + /** Sets what {@code SHOW ENGINE} shows; null means {@code STATUS}. */ + public void setEngineInfo(EngineInfo engineInfo) { + this.engineInfo = engineInfo == null ? EngineInfo.STATUS : engineInfo; + } + + /** The {@code {FROM | IN} db} clause, or null. */ + public ShowDbSelection getDbSelection() { + return dbSelection; + } + + public void setDbSelection(ShowDbSelection dbSelection) { + require(Part.DATABASE, dbSelection != null); + this.dbSelection = dbSelection; + } + + /** The database of the {@code {FROM | IN} db} clause, or null. */ + public String getDbName() { + return ShowDbSelection.name(dbSelection); + } + + /** The {@code LIKE} or {@code WHERE} filter, or null. */ + public ShowFilter getFilter() { + return filter; + } + + public void setFilter(ShowFilter filter) { + require(Part.FILTER, filter != null); + this.filter = filter; + } + + /** The pattern of a {@code LIKE} filter, or null. */ + public Expression getLikeExpression() { + return ShowFilter.likeExpression(filter); + } + + /** The condition of a {@code WHERE} filter, or null. */ + public Expression getWhereCondition() { + return ShowFilter.whereCondition(filter); + } + + /** + * The account or role of {@code SHOW GRANTS FOR}, without authentication, or null for the + * current account. + */ + public UserAccount getAccount() { + return account; + } + + /** Sets the account of {@code SHOW GRANTS FOR}; null also removes the {@code USING} roles. */ + public void setAccount(UserAccount account) { + require(Part.ACCOUNT, account != null); + if (account == null) { + usingRoles.clear(); + } + this.account = account; + } + + /** The roles of {@code USING}, as a read-only snapshot; empty without {@code USING}. */ + public List getUsingRoles() { + return Collections.unmodifiableList(new ArrayList<>(usingRoles)); + } + + /** Replaces the roles of {@code USING}; null or an empty list removes {@code USING}. */ + public void setUsingRoles(List usingRoles) { + require(Part.ACCOUNT, usingRoles != null && !usingRoles.isEmpty()); + this.usingRoles.clear(); + if (usingRoles != null) { + this.usingRoles.addAll(usingRoles); + } + } + + /** The log file of {@code IN 'log_name'}, or null. */ + public StringValue getLogName() { + return logName; + } + + public void setLogName(StringValue logName) { + require(Part.LOG_NAME, logName != null); + this.logName = logName; + } + + /** The position of {@code FROM pos}, a number literal, or null. */ + public Expression getPosition() { + return position; + } + + public void setPosition(Expression position) { + require(Part.POSITION, position != null); + this.position = position; + } + + /** + * The {@code LIMIT [offset,] row_count} clause, or null. {@code LIMIT row_count OFFSET offset} + * keeps its offset in {@link #getOffset()}. + */ + public Limit getLimit() { + return limit; + } + + /** Sets the limit; a limit clears the {@code COUNT(*)} form. */ + public void setLimit(Limit limit) { + require(Part.LIMIT, limit != null); + this.limit = limit; + if (limit == null) { + offset = null; + } else { + count = false; + } + } + + /** The {@code OFFSET offset} that follows {@code LIMIT row_count}, or null. */ + public Offset getOffset() { + return offset; + } + + /** + * Sets the {@code OFFSET offset} after the limit. + * + * @throws IllegalArgumentException without a limit, or with a {@code LIMIT offset, row_count} + */ + public void setOffset(Offset offset) { + require(Part.LIMIT, offset != null); + if (offset != null && (limit == null || limit.getOffset() != null)) { + throw new IllegalArgumentException("OFFSET needs a LIMIT row_count before it"); + } + this.offset = offset; + } + + /** The channel of {@code FOR CHANNEL 'channel'}, or null. */ + public StringValue getChannel() { + return channel; + } + + public void setChannel(StringValue channel) { + require(Part.CHANNEL, channel != null); + this.channel = channel; + } + + /** The types of {@code SHOW PROFILE type [, type] ...}, as a read-only snapshot. */ + public List getProfileTypes() { + return Collections.unmodifiableList(new ArrayList<>(profileTypes)); + } + + /** Replaces the types of {@code SHOW PROFILE}; null or an empty list removes them. */ + public void setProfileTypes(List profileTypes) { + require(Part.PROFILE, profileTypes != null && !profileTypes.isEmpty()); + this.profileTypes.clear(); + if (profileTypes != null) { + this.profileTypes.addAll(profileTypes); + } + } + + /** The query number of {@code SHOW PROFILE ... FOR QUERY n}, or null. */ + public Expression getProfileQuery() { + return profileQuery; + } + + public void setProfileQuery(Expression profileQuery) { + require(Part.PROFILE, profileQuery != null); + this.profileQuery = profileQuery; + } + + /** Appends the statement, printing its expressions with the given printer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer printer) { + builder.append("SHOW"); + if (scope != null) { + builder.append(' ').append(scope); + } + if (full) { + builder.append(" FULL"); + } + if (count) { + builder.append(" COUNT(*)"); + } + builder.append(' ').append(getKeyword()); + appendObject(builder, printer); + if (ShowDbSelection.isPresent(dbSelection)) { + builder.append(' ').append(dbSelection); + } + if (filter != null) { + filter.appendTo(builder.append(' '), printer); + } + appendAccount(builder); + appendLogRange(builder, printer); + if (channel != null) { + builder.append(" FOR CHANNEL "); + printer.accept(channel); + } + return builder; + } + + private void appendObject(StringBuilder builder, Consumer printer) { + if (kind == Kind.ENGINE) { + builder.append(' ').append(engineName).append(' ').append(engineInfo); + } else if (routineName != null) { + builder.append(' ').append(routineName); + } + for (int i = 0; i < profileTypes.size(); i++) { + builder.append(i == 0 ? " " : ", ").append(profileTypes.get(i)); + } + if (profileQuery != null) { + builder.append(" FOR QUERY "); + printer.accept(profileQuery); + } + } + + private void appendAccount(StringBuilder builder) { + if (account == null) { + return; + } + builder.append(" FOR ").append(account); + for (int i = 0; i < usingRoles.size(); i++) { + builder.append(i == 0 ? " USING " : ", ").append(usingRoles.get(i)); + } + } + + private void appendLogRange(StringBuilder builder, Consumer printer) { + if (logName != null) { + builder.append(" IN "); + printer.accept(logName); + } + if (position != null) { + builder.append(" FROM "); + printer.accept(position); + } + if (limit != null) { + builder.append(" LIMIT "); + if (limit.getOffset() != null) { + printer.accept(limit.getOffset()); + builder.append(", "); + } + printer.accept(limit.getRowCount()); + } + if (offset != null) { + builder.append(" OFFSET "); + printer.accept(offset.getOffset()); + } + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } + + public MySqlShowStatement withKind(Kind kind) { + this.setKind(kind); + return this; + } + + public MySqlShowStatement withKeyword(String keyword) { + this.setKeyword(keyword); + return this; + } + + public MySqlShowStatement withScope(Scope scope) { + this.setScope(scope); + return this; + } + + public MySqlShowStatement withFull(boolean full) { + this.setFull(full); + return this; + } + + public MySqlShowStatement withCount(boolean count) { + this.setCount(count); + return this; + } + + public MySqlShowStatement withRoutineName(Table routineName) { + this.setRoutineName(routineName); + return this; + } + + public MySqlShowStatement withEngineName(String engineName) { + this.setEngineName(engineName); + return this; + } + + public MySqlShowStatement withEngineInfo(EngineInfo engineInfo) { + this.setEngineInfo(engineInfo); + return this; + } + + public MySqlShowStatement withDbSelection(ShowDbSelection dbSelection) { + this.setDbSelection(dbSelection); + return this; + } + + public MySqlShowStatement withFilter(ShowFilter filter) { + this.setFilter(filter); + return this; + } + + public MySqlShowStatement withAccount(UserAccount account) { + this.setAccount(account); + return this; + } + + public MySqlShowStatement withUsingRoles(List usingRoles) { + this.setUsingRoles(usingRoles); + return this; + } + + public MySqlShowStatement withLogName(StringValue logName) { + this.setLogName(logName); + return this; + } + + public MySqlShowStatement withPosition(Expression position) { + this.setPosition(position); + return this; + } + + public MySqlShowStatement withLimit(Limit limit) { + this.setLimit(limit); + return this; + } + + public MySqlShowStatement withOffset(Offset offset) { + this.setOffset(offset); + return this; + } + + public MySqlShowStatement withChannel(StringValue channel) { + this.setChannel(channel); + return this; + } + + public MySqlShowStatement withProfileTypes(List profileTypes) { + this.setProfileTypes(profileTypes); + return this; + } + + public MySqlShowStatement withProfileQuery(Expression profileQuery) { + this.setProfileQuery(profileQuery); + return this; + } + + /** An optional or required part of a {@link MySqlShowStatement}, allowed per {@link Kind}. */ + public enum Part { + /** {@code GLOBAL}, {@code SESSION} or {@code LOCAL} before the keywords. */ + SCOPE, + /** {@code FULL} before the keywords. */ + FULL, + /** {@code COUNT(*)} before the keywords. */ + COUNT, + /** The routine name after {@code PROCEDURE CODE} or {@code FUNCTION CODE}. */ + ROUTINE, + /** + * The engine name and {@code STATUS}, {@code MUTEX} or {@code LOGS} after {@code ENGINE}. + */ + ENGINE, + /** {@code {FROM | IN} db}. */ + DATABASE, + /** {@code LIKE 'pattern'} or {@code WHERE expr}. */ + FILTER, + /** {@code FOR account [USING role [, role] ...]}. */ + ACCOUNT, + /** {@code IN 'log_name'}. */ + LOG_NAME, + /** {@code FROM pos}. */ + POSITION, + /** {@code LIMIT [offset,] row_count} or {@code LIMIT row_count OFFSET offset}. */ + LIMIT, + /** {@code FOR CHANNEL 'channel'}. */ + CHANNEL, + /** The types and {@code FOR QUERY n} of {@code SHOW PROFILE}. */ + PROFILE + } + + /** {@code GLOBAL}, {@code SESSION} or its synonym {@code LOCAL}. */ + public enum Scope { + GLOBAL, SESSION, LOCAL + } + + /** What {@code SHOW ENGINE} shows. */ + public enum EngineInfo { + STATUS, MUTEX, LOGS + } + + /** A type of information of {@code SHOW PROFILE}. */ + public enum ProfileType { + ALL, BLOCK_IO, CONTEXT_SWITCHES, CPU, IPC, MEMORY, PAGE_FAULTS, SOURCE, SWAPS; + + /** The type spelled with the keywords, such as {@code BLOCK IO}, ignoring case. */ + public static ProfileType fromKeyword(String keyword) { + return valueOf(Kind.normalize(keyword).replace(' ', '_')); + } + + @Override + public String toString() { + return name().replace('_', ' '); + } + } + + /** + * The statement. The first keyword spelling is the MySQL 8.4 one; the others are synonyms, or + * the spellings MySQL 8.4 removed ({@code MASTER} and {@code SLAVE}), which the parser reads + * with {@code Dialect.MARIADB} and without a dialect only. + */ + public enum Kind { + VARIABLES(EnumSet.of(Part.SCOPE, Part.FILTER), "VARIABLES"), + + STATUS(EnumSet.of(Part.SCOPE, Part.FILTER), "STATUS"), + + PROCESSLIST(EnumSet.of(Part.FULL), "PROCESSLIST"), + + DATABASES(EnumSet.of(Part.FILTER), "DATABASES", "SCHEMAS"), + + TRIGGERS(EnumSet.of(Part.FULL, Part.DATABASE, Part.FILTER), "TRIGGERS"), + + EVENTS(EnumSet.of(Part.DATABASE, Part.FILTER), "EVENTS"), + + OPEN_TABLES(EnumSet.of(Part.DATABASE, Part.FILTER), "OPEN TABLES"), + + PROCEDURE_STATUS(EnumSet.of(Part.FILTER), "PROCEDURE STATUS"), + + FUNCTION_STATUS(EnumSet.of(Part.FILTER), "FUNCTION STATUS"), + + PROCEDURE_CODE(EnumSet.of(Part.ROUTINE), "PROCEDURE CODE"), + + FUNCTION_CODE(EnumSet.of(Part.ROUTINE), "FUNCTION CODE"), + + CHARACTER_SET(EnumSet.of(Part.FILTER), "CHARACTER SET", "CHARSET", "CHAR SET"), + + COLLATION(EnumSet.of(Part.FILTER), "COLLATION"), + + ENGINES(EnumSet.noneOf(Part.class), "ENGINES", "STORAGE ENGINES"), + + ENGINE(EnumSet.of(Part.ENGINE), "ENGINE"), + + PLUGINS(EnumSet.noneOf(Part.class), "PLUGINS"), + + PRIVILEGES(EnumSet.noneOf(Part.class), "PRIVILEGES"), + + PROFILES(EnumSet.noneOf(Part.class), "PROFILES"), + + PROFILE(EnumSet.of(Part.PROFILE, Part.LIMIT), "PROFILE"), + + GRANTS(EnumSet.of(Part.ACCOUNT), "GRANTS"), + + WARNINGS(EnumSet.of(Part.COUNT, Part.LIMIT), "WARNINGS"), + + ERRORS(EnumSet.of(Part.COUNT, Part.LIMIT), "ERRORS"), + + BINARY_LOGS(EnumSet.noneOf(Part.class), "BINARY LOGS", "MASTER LOGS"), + + BINARY_LOG_STATUS(EnumSet.noneOf(Part.class), "BINARY LOG STATUS", "MASTER STATUS"), + + BINLOG_EVENTS(EnumSet.of(Part.LOG_NAME, Part.POSITION, Part.LIMIT), "BINLOG EVENTS"), + + RELAYLOG_EVENTS(EnumSet.of(Part.LOG_NAME, Part.POSITION, Part.LIMIT, Part.CHANNEL), + "RELAYLOG EVENTS"), + + REPLICAS(EnumSet.noneOf(Part.class), "REPLICAS", "SLAVE HOSTS"), + + REPLICA_STATUS(EnumSet.of(Part.CHANNEL), "REPLICA STATUS", "SLAVE STATUS"); + + private final Set parts; + private final List keywords; + + Kind(Set parts, String... keywords) { + this.parts = Collections.unmodifiableSet(parts); + this.keywords = Collections.unmodifiableList(Arrays.asList(keywords)); + } + + /** Whether statements of this kind may have the part. */ + public boolean allows(Part part) { + return parts.contains(part); + } + + /** The parts statements of this kind may have. */ + public Set getParts() { + return parts; + } + + /** The keyword spellings, the MySQL 8.4 spelling first, single-spaced and upper case. */ + public List getKeywords() { + return keywords; + } + + static String normalize(String keyword) { + return keyword.trim().replaceAll("\\s+", " ").toUpperCase(Locale.ROOT); + } + + /** + * The kind spelled with the keywords, compared case-insensitively. + * + * @throws IllegalArgumentException if no kind is spelled so + */ + public static Kind fromKeyword(String keyword) { + String spelling = normalize(keyword); + for (Kind kind : values()) { + if (kind.keywords.contains(spelling)) { + return kind; + } + } + throw new IllegalArgumentException("Unknown MySQL SHOW keywords: " + keyword); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/show/ShowCreateStatement.java b/src/main/java/net/sf/jsqlparser/statement/show/ShowCreateStatement.java new file mode 100644 index 0000000000..d124fc2301 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/show/ShowCreateStatement.java @@ -0,0 +1,192 @@ +/*- + * #%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.show; + +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.create.user.UserAccount; + +/** + * A MySQL {@code SHOW CREATE} statement, which returns the definition of one object. + * + *
    + *
  • {@code TABLE}, {@code VIEW}, {@code PROCEDURE}, {@code FUNCTION}, {@code TRIGGER} and + * {@code EVENT} name the object with {@link #getName()}.
  • + *
  • {@code DATABASE} (also spelled {@code SCHEMA}) uses {@link #getDatabaseName()} and may carry + * {@code IF NOT EXISTS}.
  • + *
  • {@code USER} uses {@link #getAccount()}, which is {@code CURRENT_USER} for the session + * account.
  • + *
+ * + * @see MySQL SHOW CREATE + * TABLE + */ +public class ShowCreateStatement extends ASTNodeAccessImpl implements Statement { + + public enum ObjectType { + TABLE, VIEW, PROCEDURE, FUNCTION, TRIGGER, EVENT, DATABASE, USER; + + /** Whether objects of this type are named by {@link ShowCreateStatement#getName()}. */ + public boolean isNamedByTable() { + return this != DATABASE && this != USER; + } + } + + private ObjectType objectType; + private boolean schemaKeyword; + private boolean ifNotExists; + private Table name; + private String databaseName; + private UserAccount account; + private boolean currentUserParentheses; + + public ShowCreateStatement() { + // empty constructor + } + + public ShowCreateStatement(ObjectType objectType, Table name) { + this.objectType = objectType; + this.name = name; + } + + public ObjectType getObjectType() { + return objectType; + } + + public void setObjectType(ObjectType objectType) { + this.objectType = objectType; + } + + /** Whether {@code DATABASE} was spelled {@code SCHEMA}. */ + public boolean isSchemaKeyword() { + return schemaKeyword; + } + + public void setSchemaKeyword(boolean schemaKeyword) { + this.schemaKeyword = schemaKeyword; + } + + /** Whether {@code SHOW CREATE DATABASE IF NOT EXISTS} was written. */ + public boolean isIfNotExists() { + return ifNotExists; + } + + public void setIfNotExists(boolean ifNotExists) { + this.ifNotExists = ifNotExists; + } + + /** The table, view, routine, trigger or event name; null for DATABASE and USER. */ + public Table getName() { + return name; + } + + public void setName(Table name) { + this.name = name; + } + + /** The database name of {@code SHOW CREATE DATABASE}; null otherwise. */ + public String getDatabaseName() { + return databaseName; + } + + public void setDatabaseName(String databaseName) { + this.databaseName = databaseName; + } + + /** The account of {@code SHOW CREATE USER}; null otherwise. */ + public UserAccount getAccount() { + return account; + } + + public void setAccount(UserAccount account) { + this.account = account; + } + + /** Whether the account was written as {@code CURRENT_USER()}. */ + public boolean isCurrentUserParentheses() { + return currentUserParentheses; + } + + public void setCurrentUserParentheses(boolean currentUserParentheses) { + this.currentUserParentheses = currentUserParentheses; + } + + /** Whether the account is {@code CURRENT_USER} or {@code CURRENT_USER()}. */ + public boolean isCurrentUser() { + if (account == null || account.getHost() != null || account.getUser() == null) { + return false; + } + StringValue user = account.getUser(); + return "".equals(user.getQuoteStr()) && "CURRENT_USER".equalsIgnoreCase(user.getValue()); + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder("SHOW CREATE "); + if (objectType == ObjectType.DATABASE) { + builder.append(schemaKeyword ? "SCHEMA" : "DATABASE"); + if (ifNotExists) { + builder.append(" IF NOT EXISTS"); + } + builder.append(' ').append(databaseName); + } else if (objectType == ObjectType.USER) { + builder.append("USER ").append(account); + if (currentUserParentheses) { + builder.append("()"); + } + } else { + builder.append(objectType).append(' ').append(name); + } + return builder.toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } + + public ShowCreateStatement withObjectType(ObjectType objectType) { + this.setObjectType(objectType); + return this; + } + + public ShowCreateStatement withSchemaKeyword(boolean schemaKeyword) { + this.setSchemaKeyword(schemaKeyword); + return this; + } + + public ShowCreateStatement withIfNotExists(boolean ifNotExists) { + this.setIfNotExists(ifNotExists); + return this; + } + + public ShowCreateStatement withName(Table name) { + this.setName(name); + return this; + } + + public ShowCreateStatement withDatabaseName(String databaseName) { + this.setDatabaseName(databaseName); + return this; + } + + public ShowCreateStatement withAccount(UserAccount account) { + this.setAccount(account); + return this; + } + + public ShowCreateStatement withCurrentUserParentheses(boolean currentUserParentheses) { + this.setCurrentUserParentheses(currentUserParentheses); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/show/ShowDbSelection.java b/src/main/java/net/sf/jsqlparser/statement/show/ShowDbSelection.java new file mode 100644 index 0000000000..e06d803d02 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/show/ShowDbSelection.java @@ -0,0 +1,107 @@ +/*- + * #%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.show; + +import java.io.Serializable; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; + +/** + * The {@code {FROM | IN} db} clause of a MySQL {@code SHOW} statement, which names a database. + * + *

+ * A selection without a name only keeps the selection mode for a later name; statements do not + * render it. + *

+ */ +public class ShowDbSelection implements Serializable { + + private static final long serialVersionUID = 1L; + + private SelectionMode selectionMode = SelectionMode.FROM; + private String name; + + public ShowDbSelection() { + // empty constructor + } + + /** A {@code FROM name} clause. */ + public ShowDbSelection(String name) { + this.name = name; + } + + public ShowDbSelection(SelectionMode selectionMode, String name) { + setSelectionMode(selectionMode); + this.name = name; + } + + /** The keyword before the database name, {@code FROM} unless {@code IN} was written. */ + public SelectionMode getSelectionMode() { + return selectionMode; + } + + /** Sets the keyword before the database name; null means {@code FROM}. */ + public void setSelectionMode(SelectionMode selectionMode) { + this.selectionMode = selectionMode == null ? SelectionMode.FROM : selectionMode; + } + + /** The database name as written, including any quotes. */ + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + /** Whether the selection has a database name and is rendered. */ + public static boolean isPresent(ShowDbSelection selection) { + return selection != null && selection.name != null; + } + + /** The database name of the selection, or null. */ + public static String name(ShowDbSelection selection) { + return selection == null ? null : selection.name; + } + + /** + * The selection after a legacy selection mode setter: the mode is kept until a name is set. + */ + public static ShowDbSelection updateSelectionMode(ShowDbSelection selection, + SelectionMode selectionMode) { + ShowDbSelection result = selection == null ? new ShowDbSelection() : selection; + result.setSelectionMode(selectionMode); + return result; + } + + /** The selection after a legacy database name setter, keeping the selection mode. */ + public static ShowDbSelection updateName(ShowDbSelection selection, String name) { + if (selection == null && name == null) { + return null; + } + ShowDbSelection result = selection == null ? new ShowDbSelection() : selection; + result.setName(name); + return result; + } + + @Override + public String toString() { + return selectionMode + " " + name; + } + + public ShowDbSelection withSelectionMode(SelectionMode selectionMode) { + this.setSelectionMode(selectionMode); + return this; + } + + public ShowDbSelection withName(String name) { + this.setName(name); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/show/ShowFilter.java b/src/main/java/net/sf/jsqlparser/statement/show/ShowFilter.java new file mode 100644 index 0000000000..b04146cb01 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/show/ShowFilter.java @@ -0,0 +1,115 @@ +/*- + * #%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.show; + +import java.io.Serializable; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; + +/** + * The {@code LIKE 'pattern'} or {@code WHERE expr} filter that ends many MySQL {@code SHOW} + * statements. + * + * @see MySQL extensions to + * SHOW statements + */ +public class ShowFilter implements Serializable { + + private static final long serialVersionUID = 1L; + + public enum Kind { + LIKE, WHERE + } + + private Kind kind = Kind.LIKE; + private Expression expression; + + public ShowFilter() { + // empty constructor + } + + public ShowFilter(Kind kind, Expression expression) { + setKind(kind); + this.expression = expression; + } + + /** A {@code LIKE pattern} filter. */ + public static ShowFilter like(Expression pattern) { + return new ShowFilter(Kind.LIKE, pattern); + } + + /** A {@code WHERE condition} filter. */ + public static ShowFilter where(Expression condition) { + return new ShowFilter(Kind.WHERE, condition); + } + + /** {@code LIKE} or {@code WHERE}; never null. */ + public Kind getKind() { + return kind; + } + + /** Sets the kind; null means {@code LIKE}. */ + public void setKind(Kind kind) { + this.kind = kind == null ? Kind.LIKE : kind; + } + + /** The pattern of a {@code LIKE} filter or the condition of a {@code WHERE} filter. */ + public Expression getExpression() { + return expression; + } + + public void setExpression(Expression expression) { + this.expression = expression; + } + + /** The pattern of a {@code LIKE} filter, or null. */ + public static Expression likeExpression(ShowFilter filter) { + return filter != null && filter.kind == Kind.LIKE ? filter.expression : null; + } + + /** The condition of a {@code WHERE} filter, or null. */ + public static Expression whereCondition(ShowFilter filter) { + return filter != null && filter.kind == Kind.WHERE ? filter.expression : null; + } + + /** + * The filter after a legacy {@code setLikeExpression} or {@code setWhereCondition} call: an + * expression replaces the filter, and null removes a filter of that kind only. + */ + public static ShowFilter replace(ShowFilter filter, Kind kind, Expression expression) { + if (expression != null) { + return new ShowFilter(kind, expression); + } + return filter != null && filter.kind == kind ? null : filter; + } + + /** Appends the filter, printing its expression with the given printer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer printer) { + builder.append(kind).append(' '); + printer.accept(expression); + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + public ShowFilter withKind(Kind kind) { + this.setKind(kind); + return this; + } + + public ShowFilter withExpression(Expression expression) { + this.setExpression(expression); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/show/ShowIndexStatement.java b/src/main/java/net/sf/jsqlparser/statement/show/ShowIndexStatement.java index d6b4bf72d8..bb9d6e9fb8 100644 --- a/src/main/java/net/sf/jsqlparser/statement/show/ShowIndexStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/show/ShowIndexStatement.java @@ -9,36 +9,148 @@ */ package net.sf.jsqlparser.statement.show; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; /** + * A MySQL {@code SHOW [EXTENDED] {INDEX | INDEXES | KEYS} {FROM | IN} table [{FROM | IN} db] + * [WHERE expr]} statement. + * * @author Jayant Kumar Yadav + * @see MySQL SHOW INDEX */ +public class ShowIndexStatement extends ASTNodeAccessImpl implements Statement { -public class ShowIndexStatement implements Statement { + /** The spelling of the statement keyword. */ + public enum Keyword { + INDEX, INDEXES, KEYS + } - private String tableName; + private boolean extended; + private Keyword keyword = Keyword.INDEX; + private SelectionMode tableSelectionMode = SelectionMode.FROM; + private Table table; + private ShowDbSelection dbSelection; + private Expression whereCondition; public ShowIndexStatement() { // empty constructor } public ShowIndexStatement(String tableName) { - this.tableName = tableName; + setTableName(tableName); + } + + public ShowIndexStatement(Table table) { + this.table = table; + } + + public boolean isExtended() { + return extended; + } + + public void setExtended(boolean extended) { + this.extended = extended; + } + + /** {@code INDEX}, {@code INDEXES} or {@code KEYS}, as written; never null. */ + public Keyword getKeyword() { + return keyword; + } + + /** Sets the keyword spelling; null means {@code INDEX}. */ + public void setKeyword(Keyword keyword) { + this.keyword = keyword == null ? Keyword.INDEX : keyword; + } + + /** The keyword before the table name, {@code FROM} unless {@code IN} was written. */ + public SelectionMode getTableSelectionMode() { + return tableSelectionMode; } + /** Sets the keyword before the table name; null means {@code FROM}. */ + public void setTableSelectionMode(SelectionMode tableSelectionMode) { + this.tableSelectionMode = + tableSelectionMode == null ? SelectionMode.FROM : tableSelectionMode; + } + + public Table getTable() { + return table; + } + + public void setTable(Table table) { + this.table = table; + } + + /** The table name as written, including any qualifier; derived from {@link #getTable()}. */ public String getTableName() { - return tableName; + return table == null ? null : table.getFullyQualifiedName(); } public void setTableName(String tableName) { - this.tableName = tableName; + this.table = tableName == null ? null : new Table(tableName); + } + + /** The trailing {@code {FROM | IN} db} clause, which names the database of the table. */ + public ShowDbSelection getDbSelection() { + return dbSelection; + } + + public void setDbSelection(ShowDbSelection dbSelection) { + this.dbSelection = dbSelection; + } + + /** The database of the trailing {@code {FROM | IN} db} clause, or null. */ + public String getDbName() { + return ShowDbSelection.name(dbSelection); + } + + public Expression getWhereCondition() { + return whereCondition; + } + + public void setWhereCondition(Expression whereCondition) { + this.whereCondition = whereCondition; + } + + /** + * The table the statement reads: {@link #getTable()}, or the table in the database of the + * trailing {@code FROM db} clause, which MySQL reads as {@code db.table}. + */ + public Table getQualifiedTable() { + if (table == null || !ShowDbSelection.isPresent(dbSelection)) { + return table; + } + return new Table(dbSelection.getName(), table.getName()); + } + + /** Appends the statement, printing the {@code WHERE} condition with the given printer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer printer) { + builder.append("SHOW"); + if (extended) { + builder.append(" EXTENDED"); + } + builder.append(' ').append(keyword).append(' ').append(tableSelectionMode).append(' ') + .append(table); + if (ShowDbSelection.isPresent(dbSelection)) { + builder.append(' ').append(dbSelection); + } + if (whereCondition != null) { + builder.append(" WHERE "); + printer.accept(whereCondition); + } + return builder; } @Override public String toString() { - return "SHOW INDEX FROM " + tableName; + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); } @Override @@ -50,4 +162,34 @@ public ShowIndexStatement withTableName(String tableName) { this.setTableName(tableName); return this; } + + public ShowIndexStatement withTable(Table table) { + this.setTable(table); + return this; + } + + public ShowIndexStatement withExtended(boolean extended) { + this.setExtended(extended); + return this; + } + + public ShowIndexStatement withKeyword(Keyword keyword) { + this.setKeyword(keyword); + return this; + } + + public ShowIndexStatement withTableSelectionMode(SelectionMode tableSelectionMode) { + this.setTableSelectionMode(tableSelectionMode); + return this; + } + + public ShowIndexStatement withDbSelection(ShowDbSelection dbSelection) { + this.setDbSelection(dbSelection); + return this; + } + + public ShowIndexStatement withWhereCondition(Expression whereCondition) { + this.setWhereCondition(whereCondition); + return this; + } } diff --git a/src/main/java/net/sf/jsqlparser/statement/show/ShowTableStatusStatement.java b/src/main/java/net/sf/jsqlparser/statement/show/ShowTableStatusStatement.java new file mode 100644 index 0000000000..80688c98d5 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/show/ShowTableStatusStatement.java @@ -0,0 +1,136 @@ +/*- + * #%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.show; + +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; + +/** + * A MySQL {@code SHOW TABLE STATUS [{FROM | IN} db] [LIKE 'pattern' | WHERE expr]} statement. + * + * @see MySQL SHOW TABLE + * STATUS + */ +public class ShowTableStatusStatement extends ASTNodeAccessImpl implements Statement { + + private ShowDbSelection dbSelection; + private ShowFilter filter; + + /** The keyword before the database name, {@code FROM} unless {@code IN} was written. */ + public SelectionMode getSelectionMode() { + return dbSelection == null ? SelectionMode.FROM : dbSelection.getSelectionMode(); + } + + /** Sets the keyword before the database name, which is kept until the name is set. */ + public void setSelectionMode(SelectionMode selectionMode) { + dbSelection = ShowDbSelection.updateSelectionMode(dbSelection, selectionMode); + } + + public String getDbName() { + return ShowDbSelection.name(dbSelection); + } + + public void setDbName(String dbName) { + dbSelection = ShowDbSelection.updateName(dbSelection, dbName); + } + + /** The {@code {FROM | IN} db} clause, or null. */ + public ShowDbSelection getDbSelection() { + return dbSelection; + } + + public void setDbSelection(ShowDbSelection dbSelection) { + this.dbSelection = dbSelection; + } + + /** The {@code LIKE} or {@code WHERE} filter, or null. */ + public ShowFilter getFilter() { + return filter; + } + + public void setFilter(ShowFilter filter) { + this.filter = filter; + } + + public Expression getLikeExpression() { + return ShowFilter.likeExpression(filter); + } + + /** Sets a {@code LIKE} filter, which replaces a {@code WHERE} filter; null removes it. */ + public void setLikeExpression(Expression likeExpression) { + filter = ShowFilter.replace(filter, ShowFilter.Kind.LIKE, likeExpression); + } + + public Expression getWhereCondition() { + return ShowFilter.whereCondition(filter); + } + + /** Sets a {@code WHERE} filter, which replaces a {@code LIKE} filter; null removes it. */ + public void setWhereCondition(Expression whereCondition) { + filter = ShowFilter.replace(filter, ShowFilter.Kind.WHERE, whereCondition); + } + + /** Appends the statement, printing the filter expression with the given printer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer printer) { + builder.append("SHOW TABLE STATUS"); + if (ShowDbSelection.isPresent(dbSelection)) { + builder.append(' ').append(dbSelection); + } + if (filter != null) { + filter.appendTo(builder.append(' '), printer); + } + return builder; + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); + } + + @Override + public T accept(StatementVisitor statementVisitor, S context) { + return statementVisitor.visit(this, context); + } + + public ShowTableStatusStatement withSelectionMode(SelectionMode selectionMode) { + this.setSelectionMode(selectionMode); + return this; + } + + public ShowTableStatusStatement withDbName(String dbName) { + this.setDbName(dbName); + return this; + } + + public ShowTableStatusStatement withLikeExpression(Expression likeExpression) { + this.setLikeExpression(likeExpression); + return this; + } + + public ShowTableStatusStatement withWhereCondition(Expression whereCondition) { + this.setWhereCondition(whereCondition); + return this; + } + + public ShowTableStatusStatement withDbSelection(ShowDbSelection dbSelection) { + this.setDbSelection(dbSelection); + return this; + } + + public ShowTableStatusStatement withFilter(ShowFilter filter) { + this.setFilter(filter); + return this; + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/show/ShowTablesStatement.java b/src/main/java/net/sf/jsqlparser/statement/show/ShowTablesStatement.java index d6016d7fb9..d368843690 100644 --- a/src/main/java/net/sf/jsqlparser/statement/show/ShowTablesStatement.java +++ b/src/main/java/net/sf/jsqlparser/statement/show/ShowTablesStatement.java @@ -10,24 +10,30 @@ package net.sf.jsqlparser.statement.show; import java.util.Locale; +import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; import java.util.EnumSet; /** - * A {@code SHOW TABLES} statement + * A {@code SHOW [EXTENDED] [FULL] TABLES [{FROM | IN} db] [LIKE 'pattern' | WHERE expr]} statement. * - * @see MySQL show tables + *

+ * The database and the filter are held by {@link ShowDbSelection} and {@link ShowFilter}, shared + * with the other MySQL {@code SHOW} statements; the separate selection mode, database name, + * {@code LIKE} and {@code WHERE} accessors read and write them. + *

+ * + * @see MySQL show tables */ -public class ShowTablesStatement implements Statement { +public class ShowTablesStatement extends ASTNodeAccessImpl implements Statement { private EnumSet modifiers; - private SelectionMode selectionMode; - private String dbName; - private Expression likeExpression; - private Expression whereCondition; + private ShowDbSelection dbSelection; + private ShowFilter filter; public EnumSet getModifiers() { return modifiers; @@ -37,65 +43,87 @@ public void setModifiers(EnumSet modifiers) { this.modifiers = modifiers; } + /** {@code FROM} or {@code IN}, or null without a database. */ public SelectionMode getSelectionMode() { - return selectionMode; + return dbSelection == null ? null : dbSelection.getSelectionMode(); } + /** Sets the keyword before the database name, which is kept until the name is set. */ public void setSelectionMode(SelectionMode selectionMode) { - this.selectionMode = selectionMode; + if (selectionMode == null && !ShowDbSelection.isPresent(dbSelection)) { + dbSelection = null; + } else { + dbSelection = ShowDbSelection.updateSelectionMode(dbSelection, selectionMode); + } } public String getDbName() { - return dbName; + return ShowDbSelection.name(dbSelection); } public void setDbName(String dbName) { - this.dbName = dbName; + dbSelection = ShowDbSelection.updateName(dbSelection, dbName); + } + + /** The {@code {FROM | IN} db} clause, or null. */ + public ShowDbSelection getDbSelection() { + return dbSelection; + } + + public void setDbSelection(ShowDbSelection dbSelection) { + this.dbSelection = dbSelection; + } + + /** The {@code LIKE} or {@code WHERE} filter, or null. */ + public ShowFilter getFilter() { + return filter; + } + + public void setFilter(ShowFilter filter) { + this.filter = filter; } public Expression getLikeExpression() { - return likeExpression; + return ShowFilter.likeExpression(filter); } + /** Sets a {@code LIKE} filter, which replaces a {@code WHERE} filter; null removes it. */ public void setLikeExpression(Expression likeExpression) { - this.likeExpression = likeExpression; + filter = ShowFilter.replace(filter, ShowFilter.Kind.LIKE, likeExpression); } public Expression getWhereCondition() { - return whereCondition; + return ShowFilter.whereCondition(filter); } + /** Sets a {@code WHERE} filter, which replaces a {@code LIKE} filter; null removes it. */ public void setWhereCondition(Expression whereCondition) { - this.whereCondition = whereCondition; + filter = ShowFilter.replace(filter, ShowFilter.Kind.WHERE, whereCondition); } - @Override - public String toString() { - StringBuilder builder = new StringBuilder(); + /** Appends the statement, printing the filter expression with the given printer. */ + public StringBuilder appendTo(StringBuilder builder, Consumer printer) { builder.append("SHOW"); - - if (modifiers.contains(Modifiers.EXTENDED)) { + if (modifiers != null && modifiers.contains(Modifiers.EXTENDED)) { builder.append(" EXTENDED"); } - if (modifiers.contains(Modifiers.FULL)) { + if (modifiers != null && modifiers.contains(Modifiers.FULL)) { builder.append(" FULL"); } - builder.append(" TABLES"); - - if (dbName != null) { - builder.append(" ").append(selectionMode.name()).append(" ").append(dbName); - } - - if (likeExpression != null) { - builder.append(" ").append("LIKE").append(" ").append(likeExpression); + if (ShowDbSelection.isPresent(dbSelection)) { + builder.append(' ').append(dbSelection); } - - if (whereCondition != null) { - builder.append(" ").append("WHERE").append(" ").append(whereCondition); + if (filter != null) { + filter.appendTo(builder.append(' '), printer); } + return builder; + } - return builder.toString(); + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + return appendTo(builder, builder::append).toString(); } @Override @@ -103,6 +131,25 @@ public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); } + public ShowTablesStatement withModifiers(EnumSet modifiers) { + this.setModifiers(modifiers); + return this; + } + + public ShowTablesStatement withDbSelection(ShowDbSelection dbSelection) { + this.setDbSelection(dbSelection); + return this; + } + + public ShowTablesStatement withFilter(ShowFilter filter) { + this.setFilter(filter); + return this; + } + + /** + * The keyword before a database name in the MySQL {@code SHOW} statements, shared by all of + * them. + */ public enum SelectionMode { FROM, IN; diff --git a/src/main/java/net/sf/jsqlparser/statement/truncate/Truncate.java b/src/main/java/net/sf/jsqlparser/statement/truncate/Truncate.java index 58442d38ee..a046c7fce1 100644 --- a/src/main/java/net/sf/jsqlparser/statement/truncate/Truncate.java +++ b/src/main/java/net/sf/jsqlparser/statement/truncate/Truncate.java @@ -9,113 +9,228 @@ */ package net.sf.jsqlparser.statement.truncate; -import static java.util.stream.Collectors.joining; - +import java.util.AbstractList; +import java.util.ArrayList; import java.util.List; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.schema.TableReference; +import net.sf.jsqlparser.statement.CascadeBehavior; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; -public class Truncate implements Statement { +public class Truncate extends ASTNodeAccessImpl implements Statement { + public enum IdentityOption { + RESTART, CONTINUE + } + + public enum StorageOption { + DROP, DROP_ALL, REUSE + } + + public enum MaterializedViewLogOption { + PRESERVE, PURGE + } - boolean cascade; // to support TRUNCATE TABLE ... CASCADE - boolean tableToken; // to support TRUNCATE without TABLE - boolean only; // to support TRUNCATE with ONLY - private Table table; - private List
tables; + private boolean tableToken; + private boolean only; + private final List targets = new ArrayList<>(); + private IdentityOption identityOption; + private CascadeBehavior dropBehavior; + private StorageOption storageOption; + private MaterializedViewLogOption materializedViewLogOption; @Override public T accept(StatementVisitor statementVisitor, S context) { return statementVisitor.visit(this, context); } - public Table getTable() { - return table; + public List getTargets() { + return targets; } - public List
getTables() { - return tables; + public void setTargets(List references) { + List replacement = new ArrayList<>(references); + targets.clear(); + targets.addAll(replacement); + } + + /** Preserves the legacy parser's singular accessor for the last target. */ + public Table getTable() { + return targets.isEmpty() ? null : targets.get(targets.size() - 1).getTable(); } public void setTable(Table table) { - this.table = table; + if (targets.isEmpty()) { + TableReference target = new TableReference(table); + target.setOnly(only); + targets.add(target); + } else { + targets.get(targets.size() - 1).setTable(table); + } + } + + /** Mutable table projection; replacing a table preserves its target's inheritance scope. */ + public List
getTables() { + return new AbstractList
() { + @Override + public Table get(int index) { + return targets.get(index).getTable(); + } + + @Override + public int size() { + return targets.size(); + } + + @Override + public Table set(int index, Table table) { + Table previous = get(index); + targets.get(index).setTable(table); + return previous; + } + + @Override + public void add(int index, Table table) { + targets.add(index, new TableReference(table)); + } + + @Override + public Table remove(int index) { + return targets.remove(index).getTable(); + } + }; } public void setTables(List
tables) { - this.tables = tables; + List
replacement = tables == null ? new ArrayList<>() : new ArrayList<>(tables); + boolean firstOnly = isOnly(); + targets.clear(); + replacement.forEach(table -> targets.add(new TableReference(table))); + setOnly(firstOnly); } - public boolean getCascade() { - return cascade; + public IdentityOption getIdentityOption() { + return identityOption; } - public void setCascade(boolean c) { - cascade = c; + public void setIdentityOption(IdentityOption option) { + identityOption = option; } - @Override - public String toString() { - StringBuilder sb = new StringBuilder(); - sb.append("TRUNCATE"); - if (tableToken) { - sb.append(" TABLE"); - } - if (only) { - sb.append(" ONLY"); - } - sb.append(" "); - if (tables != null && !tables.isEmpty()) { - sb.append(tables.stream() - .map(Table::toString) - .collect(joining(", "))); - } else { - sb.append(table); - } - if (cascade) { - sb.append(" CASCADE"); - } - return sb.toString(); + public StorageOption getStorageOption() { + return storageOption; + } + + public void setStorageOption(StorageOption storageOption) { + this.storageOption = storageOption; + } + + public Truncate withStorageOption(StorageOption storageOption) { + setStorageOption(storageOption); + return this; + } + + public MaterializedViewLogOption getMaterializedViewLogOption() { + return materializedViewLogOption; + } + + public void setMaterializedViewLogOption(MaterializedViewLogOption option) { + materializedViewLogOption = option; + } + + public Truncate withMaterializedViewLogOption(MaterializedViewLogOption option) { + setMaterializedViewLogOption(option); + return this; + } + + public CascadeBehavior getDropBehavior() { + return dropBehavior; + } + + public void setDropBehavior(CascadeBehavior behavior) { + dropBehavior = behavior; + } + + public boolean getCascade() { + return dropBehavior == CascadeBehavior.CASCADE; + } + + public void setCascade(boolean cascade) { + dropBehavior = cascade ? CascadeBehavior.CASCADE : null; } public boolean isTableToken() { return tableToken; } - public void setTableToken(boolean hasTable) { - this.tableToken = hasTable; + public void setTableToken(boolean tableToken) { + this.tableToken = tableToken; } + /** Legacy ONLY accessor describes the first target. */ public boolean isOnly() { - return only; + return targets.isEmpty() ? only : targets.get(0).isOnly(); } public void setOnly(boolean only) { this.only = only; + if (!targets.isEmpty()) { + targets.get(0).setOnly(only); + } + } + + public StringBuilder appendTo(StringBuilder builder) { + builder.append(tableToken ? "TRUNCATE TABLE " : "TRUNCATE "); + for (int i = 0; i < targets.size(); i++) { + if (i > 0) { + builder.append(", "); + } + targets.get(i).appendTo(builder); + } + if (materializedViewLogOption != null) { + builder.append(' ').append(materializedViewLogOption).append(" MATERIALIZED VIEW LOG"); + } + if (storageOption != null) { + builder.append(' ').append(storageOption == StorageOption.DROP_ALL ? "DROP ALL" + : storageOption.name()).append(" STORAGE"); + } + if (identityOption != null) { + builder.append(' ').append(identityOption).append(" IDENTITY"); + } + if (dropBehavior != null) { + builder.append(' ').append(dropBehavior); + } + return builder; } - public Truncate withTableToken(boolean hasTableToken) { - this.setTableToken(hasTableToken); + @Override + public String toString() { + return appendTo(new StringBuilder()).toString(); + } + + public Truncate withTableToken(boolean value) { + setTableToken(value); return this; } - public Truncate withTable(Table table) { - this.setTable(table); + public Truncate withTable(Table value) { + setTable(value); return this; } - public Truncate withTables(List
tables) { - this.setTables(tables); + public Truncate withTables(List
value) { + setTables(value); return this; } - public Truncate withCascade(boolean cascade) { - this.setCascade(cascade); + public Truncate withCascade(boolean value) { + setCascade(value); return this; } - public Truncate withOnly(boolean only) { - this.setOnly(only); + public Truncate withOnly(boolean value) { + setOnly(value); return this; } } - diff --git a/src/main/java/net/sf/jsqlparser/statement/update/Update.java b/src/main/java/net/sf/jsqlparser/statement/update/Update.java index 8e17df515a..3bb4146a09 100644 --- a/src/main/java/net/sf/jsqlparser/statement/update/Update.java +++ b/src/main/java/net/sf/jsqlparser/statement/update/Update.java @@ -12,8 +12,10 @@ import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.OracleHint; import net.sf.jsqlparser.expression.PreferringClause; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.schema.TableReference; import net.sf.jsqlparser.statement.ForPortionClause; import net.sf.jsqlparser.statement.OutputClause; import net.sf.jsqlparser.statement.ReturningClause; @@ -34,15 +36,17 @@ import java.util.Collections; import java.util.Iterator; import java.util.List; +import java.util.Objects; import java.util.Optional; @SuppressWarnings({"PMD.CyclomaticComplexity"}) -public class Update implements Statement { +public class Update extends ASTNodeAccessImpl implements Statement { private List> withItemsList; - private Table table; + private TableReference tableReference = new TableReference(null); private ForPortionClause forPortionClause; private Expression where; + private String cursorName; private PreferringClause preferringClause; private List updateSets; private FromItem fromItem; @@ -54,6 +58,7 @@ public class Update implements Statement { private Limit limit; private OptionClause option; private ReturningClause returningClause; + private UpdateConflictAlgorithm conflictAlgorithm; private UpdateModifierPriority modifierPriority; private boolean modifierIgnore; @@ -130,11 +135,46 @@ public Update withForPortionClause(ForPortionClause forPortionClause) { } public Table getTable() { - return table; + return tableReference.getTable(); } + /** Replaces the target table and keeps the inheritance scope of the target. */ public void setTable(Table table) { - this.table = table; + tableReference.setTable(table); + } + + /** + * The target as PostgreSQL's relation_expr_opt_alias: the table of {@link #getTable()} with its + * alias, and whether ONLY or * describes its inheritance scope. + */ + public TableReference getTableReference() { + return tableReference; + } + + public void setTableReference(TableReference tableReference) { + this.tableReference = Objects.requireNonNull(tableReference); + } + + public Update withTableReference(TableReference tableReference) { + this.setTableReference(tableReference); + return this; + } + + /** + * The cursor of {@code WHERE CURRENT OF cursor}, which is written in place of the condition of + * {@link #getWhere()}. + */ + public String getCursorName() { + return cursorName; + } + + public void setCursorName(String cursorName) { + this.cursorName = cursorName; + } + + public Update withCursorName(String cursorName) { + this.setCursorName(cursorName); + return this; } public Expression getWhere() { @@ -222,6 +262,7 @@ public Update withFromBeforeSet(boolean fromBeforeSet) { /** Whether the Teradata target names an alias declared in this UPDATE's FROM clause. */ public boolean isTargetTableAlias() { + Table table = getTable(); if (!fromBeforeSet || table == null) { return false; } @@ -234,7 +275,7 @@ public boolean isTargetTableAlias() { private boolean matchesTargetAlias(FromItem source) { return source != null && source.getAlias() != null - && table.getFullyQualifiedName().equalsIgnoreCase(source.getAlias().getName()); + && getTable().getFullyQualifiedName().equalsIgnoreCase(source.getAlias().getName()); } /** Shared FROM rendering for both supported clause positions. */ @@ -343,6 +384,14 @@ public Update setReturningClause(ReturningClause returningClause) { return this; } + public UpdateConflictAlgorithm getConflictAlgorithm() { + return conflictAlgorithm; + } + + public void setConflictAlgorithm(UpdateConflictAlgorithm conflictAlgorithm) { + this.conflictAlgorithm = conflictAlgorithm; + } + public UpdateModifierPriority getModifierPriority() { return modifierPriority; } @@ -380,13 +429,16 @@ public String toString() { if (oracleHint != null) { b.append(oracleHint).append(" "); } + if (conflictAlgorithm != null) { + b.append("OR ").append(conflictAlgorithm.name()).append(" "); + } if (modifierPriority != null) { b.append(modifierPriority.name()).append(" "); } if (modifierIgnore) { b.append("IGNORE "); } - b.append(table); + tableReference.appendWithAliasTo(b); if (forPortionClause != null) { b.append(' ').append(forPortionClause); } @@ -414,7 +466,9 @@ public String toString() { appendFromTo(b); } - if (where != null) { + if (cursorName != null) { + b.append(" WHERE CURRENT OF ").append(cursorName); + } else if (where != null) { b.append(" WHERE "); b.append(where); } @@ -504,6 +558,11 @@ public Update withExpressions(List expressions) { return this; } + public Update withConflictAlgorithm(UpdateConflictAlgorithm conflictAlgorithm) { + this.setConflictAlgorithm(conflictAlgorithm); + return this; + } + public Update withModifierPriority(UpdateModifierPriority modifierPriority) { this.setModifierPriority(modifierPriority); return this; diff --git a/src/main/java/net/sf/jsqlparser/statement/update/UpdateConflictAlgorithm.java b/src/main/java/net/sf/jsqlparser/statement/update/UpdateConflictAlgorithm.java new file mode 100644 index 0000000000..b140024339 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/update/UpdateConflictAlgorithm.java @@ -0,0 +1,23 @@ +/*- + * #%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.update; + +import java.util.Locale; + +/** + * The conflict resolution algorithm of SQLite's {@code UPDATE OR }. + */ +public enum UpdateConflictAlgorithm { + ABORT, FAIL, IGNORE, REPLACE, ROLLBACK; + + public static UpdateConflictAlgorithm from(String algorithm) { + return Enum.valueOf(UpdateConflictAlgorithm.class, algorithm.toUpperCase(Locale.ROOT)); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java b/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java index abfd211924..1483f96277 100644 --- a/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java +++ b/src/main/java/net/sf/jsqlparser/statement/update/UpdateSet.java @@ -18,6 +18,7 @@ import java.io.Serializable; import java.util.Collection; import java.util.Objects; +import java.util.function.Consumer; public class UpdateSet implements Serializable { protected ExpressionList columns = new ExpressionList<>(); @@ -46,6 +47,46 @@ public final static StringBuilder appendUpdateSetsTo(StringBuilder builder, return builder; } + /** + * Appends {@code columns = values, ...}, letting a deparser visit each column and value. With + * {@code builder::append} as the renderer the output equals + * {@link #appendUpdateSetsTo(StringBuilder, Collection)}. + */ + public static StringBuilder appendUpdateSetsTo(StringBuilder builder, + Collection updateSets, Consumer expressionRenderer) { + if (updateSets == null) { + return builder; + } + int j = 0; + for (UpdateSet updateSet : updateSets) { + if (j++ > 0) { + builder.append(", "); + } + appendListTo(builder, updateSet.getColumns(), expressionRenderer); + builder.append(" = "); + appendListTo(builder, updateSet.getValues(), expressionRenderer); + } + return builder; + } + + /** Appends {@code a, b} or {@code (a, b)}, as {@code Select.getStringList} does. */ + private static void appendListTo(StringBuilder builder, ExpressionList list, + Consumer expressionRenderer) { + boolean parenthesed = list instanceof ParenthesedExpressionList; + if (parenthesed) { + builder.append("("); + } + for (int i = 0; i < list.size(); i++) { + if (i > 0) { + builder.append(", "); + } + expressionRenderer.accept(list.get(i)); + } + if (parenthesed) { + builder.append(")"); + } + } + public ExpressionList getColumns() { return columns; } diff --git a/src/main/java/net/sf/jsqlparser/statement/upsert/Upsert.java b/src/main/java/net/sf/jsqlparser/statement/upsert/Upsert.java index c13397569d..f4a0492363 100644 --- a/src/main/java/net/sf/jsqlparser/statement/upsert/Upsert.java +++ b/src/main/java/net/sf/jsqlparser/statement/upsert/Upsert.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.statement.upsert; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccessImpl; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; @@ -27,7 +28,7 @@ import java.util.List; import java.util.Optional; -public class Upsert implements Statement { +public class Upsert extends ASTNodeAccessImpl implements Statement { private Table table; private ExpressionList columns; diff --git a/src/main/java/net/sf/jsqlparser/util/AddAliasesVisitor.java b/src/main/java/net/sf/jsqlparser/util/AddAliasesVisitor.java index e3b1745082..fa3649a658 100644 --- a/src/main/java/net/sf/jsqlparser/util/AddAliasesVisitor.java +++ b/src/main/java/net/sf/jsqlparser/util/AddAliasesVisitor.java @@ -9,8 +9,8 @@ */ package net.sf.jsqlparser.util; -import java.util.LinkedList; -import java.util.List; +import java.util.LinkedHashSet; +import java.util.Set; import java.util.Locale; import net.sf.jsqlparser.expression.Alias; @@ -37,7 +37,7 @@ public class AddAliasesVisitor implements SelectVisitor, SelectItemVisitor { private static final String NOT_SUPPORTED_YET = "Not supported yet."; - private final List aliases = new LinkedList(); + private final Set aliases = new LinkedHashSet(); private boolean firstRun = true; private int counter = 0; private String prefix = "A"; diff --git a/src/main/java/net/sf/jsqlparser/util/ConnectExpressionsVisitor.java b/src/main/java/net/sf/jsqlparser/util/ConnectExpressionsVisitor.java index ca642b7a11..7c97f57972 100644 --- a/src/main/java/net/sf/jsqlparser/util/ConnectExpressionsVisitor.java +++ b/src/main/java/net/sf/jsqlparser/util/ConnectExpressionsVisitor.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.util; +import java.util.Iterator; import java.util.LinkedList; import java.util.List; @@ -70,15 +71,16 @@ public T visit(PlainSelect plainSelect, S context) { } if (itemsExpr.size() > 1) { + Iterator> it = itemsExpr.iterator(); BinaryExpression binExpr = createBinaryExpression(); - binExpr.setLeftExpression(itemsExpr.get(0).getExpression()); - for (int i = 1; i < itemsExpr.size() - 1; i++) { - binExpr.setRightExpression(itemsExpr.get(i).getExpression()); + binExpr.setLeftExpression(it.next().getExpression()); + binExpr.setRightExpression(it.next().getExpression()); + while (it.hasNext()) { BinaryExpression binExpr2 = createBinaryExpression(); binExpr2.setLeftExpression(binExpr); + binExpr2.setRightExpression(it.next().getExpression()); binExpr = binExpr2; } - binExpr.setRightExpression(itemsExpr.get(itemsExpr.size() - 1).getExpression()); SelectItem sei = new SelectItem<>(); sei.setExpression(binExpr); diff --git a/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java b/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java index 153d98002f..5ecac8def7 100644 --- a/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java +++ b/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java @@ -9,6 +9,8 @@ */ package net.sf.jsqlparser.util; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.KeyElement; import java.util.List; import java.util.function.Consumer; import net.sf.jsqlparser.expression.Expression; @@ -22,11 +24,16 @@ import net.sf.jsqlparser.statement.create.table.CheckConstraint; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.alter.AlterForeignDataOptions; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.DefaultConstraint; import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; -import net.sf.jsqlparser.statement.create.table.ForeignKeyIndex; -import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.KeyColumnSource; +import net.sf.jsqlparser.statement.create.table.IndexOptionSource; +import net.sf.jsqlparser.statement.create.table.NotNullConstraint; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.statement.create.table.TableElement; import net.sf.jsqlparser.statement.create.table.TablePartitioning; import net.sf.jsqlparser.statement.create.table.PartitionBound; @@ -40,52 +47,93 @@ public static void visit(CreateIndex createIndex, Consumer expressio accept(createIndex.getTable(), tables); if (createIndex.getIndex() != null) { visit(createIndex.getIndex(), expressions, tables); + } else { + visitOptions(createIndex.getStorageParameters(), expressions); } - visitOptions(createIndex.getStorageParameters(), expressions); accept(createIndex.getWhere(), expressions); } - /** Visits the structured definitions and expressions belonging to a single ALTER action. */ + /** + * Visits expressions and tables contributing to the rendered ALTER action. Inactive metadata is + * retained by the AST's getters but is not visited. + */ public static void visit(AlterExpression action, Consumer expressions, Consumer
tables) { - if (action.getOperation() == AlterOperation.RENAME_TABLE) { - accept(action.getNewTable(), tables); + if (action.hasAddGroupElements()) { + action.getAddGroupElements().forEach(element -> visit(element, expressions, tables)); + return; } - if (action.getColumnSetDefaultList() != null) { - action.getColumnSetDefaultList() - .forEach(column -> accept(column.getDefaultExpression(), expressions)); + if (visitSpecialBody(action, expressions, tables)) { + return; } - if (action.getColDataTypeList() != null) { + if (action.getOperation() == AlterOperation.RENAME_TABLE + && action.getOldIndex() == null + && !(action instanceof net.sf.jsqlparser.statement.alter.AlterExpressionDrop)) { + accept(action.getNewTable(), tables); + } + action.getColumnDefaults() + .forEach(column -> accept(column.getDefaultExpression(), expressions)); + if (action.hasActiveColumnDefinitions()) { action.getColDataTypeList().forEach(column -> visit(column, expressions, tables)); } - if (action.getIndex() != null) { - visit(action.getIndex(), expressions, tables); - } - if (action instanceof AlterExpressionPartition) { - AlterExpressionPartition partition = (AlterExpressionPartition) action; - switch (partition.getOperation()) { - case ATTACH_PARTITION: - accept(partition.getPartitionTable(), tables); - visit(partition.getPartitionBound(), expressions); - break; - case DETACH_PARTITION: - accept(partition.getPartitionTable(), tables); - break; - case EXCHANGE_PARTITION: - accept(partition.getExchangeTable(), tables); - break; - case PARTITION_BY: - visit(partition.getPartitioning(), expressions); - break; - default: - break; - } + TableElement definition = action.getActiveTableDefinition(); + if (action.hasActiveConstraintHeader() && definition instanceof KeyColumnSource) { + visitKeys((KeyColumnSource) definition, expressions); + } else if (definition != null) { + visit(definition, expressions, tables); } - if (action instanceof AlterExpressionPrimaryKey) { + } + + private static boolean visitSpecialBody(AlterExpression action, + Consumer expressions, + Consumer
tables) { + if (action instanceof net.sf.jsqlparser.statement.alter.AlterExpressionOrderBy) { + ((net.sf.jsqlparser.statement.alter.AlterExpressionOrderBy) action).getOrderByElements() + .forEach(element -> accept(element.getExpression(), expressions)); + } else if (action instanceof net.sf.jsqlparser.statement.alter.RelationAlterAction) { + net.sf.jsqlparser.statement.alter.RelationAlterAction relation = + (net.sf.jsqlparser.statement.alter.RelationAlterAction) action; + relation.visitExpressions(expressions); + relation.visitTables(tables); + } else if (action instanceof net.sf.jsqlparser.statement.alter.AlterExpressionTableOption) { + visit(((net.sf.jsqlparser.statement.alter.AlterExpressionTableOption) action) + .getStructuredTableOption(), expressions, tables); + } else if (action instanceof AlterForeignDataOptions) { + ForeignDataOption.visitExpressions(((AlterForeignDataOptions) action).getOptions(), + expressions); + } else if (action instanceof AlterExpressionPartition) { + visitPartitionAction((AlterExpressionPartition) action, expressions, tables); + } else if (action instanceof AlterExpressionPrimaryKey) { AlterExpressionPrimaryKey primaryKey = (AlterExpressionPrimaryKey) action; + visit(primaryKey.getConstraint(), expressions, tables); if (primaryKey.isUsingHash()) { accept(primaryKey.getBucketCount(), expressions); } + } else { + return action instanceof net.sf.jsqlparser.statement.alter.AlterExpressionCharset + || action instanceof net.sf.jsqlparser.statement.alter.AlterConstraintAttributes; + } + return true; + } + + private static void visitPartitionAction(AlterExpressionPartition partition, + Consumer expressions, Consumer
tables) { + switch (partition.getOperation()) { + case ATTACH_PARTITION: + accept(partition.getPartitionTable(), tables); + visit(partition.getPartitionBound(), expressions); + break; + case DETACH_PARTITION: + accept(partition.getPartitionTable(), tables); + break; + case EXCHANGE_PARTITION: + accept(partition.getExchangeTable(), tables); + break; + case PARTITION_BY: + visit(partition.getPartitioning(), expressions); + break; + default: + break; } } @@ -97,16 +145,26 @@ public static void visit(CreateTable table, Consumer expressions, if (table.getColumnDefinitions() != null) { table.getColumnDefinitions().forEach(column -> visit(column, expressions, tables)); } + if (table.getTableConstraints() != null) { + table.getTableConstraints() + .forEach(constraint -> visit(constraint, expressions, tables)); + } if (table.getIndexes() != null) { table.getIndexes().forEach(index -> visit(index, expressions, tables)); } } + if (table.getForeignTableOptions() != null) { + ForeignDataOption.visitExpressions(table.getForeignTableOptions().getOptions(), + expressions); + } if (table.getTableOptions() != null) { - table.getTableOptions().forEach(option -> { - if (option.getUnionTables() != null) { - option.getUnionTables().forEach(source -> accept(source, tables)); - } - }); + table.getTableOptions().forEach(option -> visit(option, expressions, tables)); + } + if (table.getInherits() != null) { + table.getInherits().forEach(parent -> accept(parent, tables)); + } + if (table.getExecute() != null && table.getExecute().getExprList() != null) { + accept(table.getExecute().getExprList(), expressions); } accept(table.getTrailingLikeTable(), tables); accept(table.getPartitionOf(), tables); @@ -114,12 +172,29 @@ public static void visit(CreateTable table, Consumer expressions, visit(table.getPartitionBound(), expressions); } + /** Shared CREATE/ALTER table option traversal, including COMMENT literals. */ + public static void visit(net.sf.jsqlparser.statement.create.table.TableOption option, + Consumer expressions, Consumer
tables) { + if (option != null) { + visitOptions(option.getStorageParameters(), expressions); + accept(option.getComment(), expressions); + if (option.getUnionTables() != null) { + option.getUnionTables().forEach(source -> accept(source, tables)); + } + } + } + /** Visits the active partition key and any subpartition key. Raw bounds remain opaque. */ public static void visit(TablePartitioning partitioning, Consumer expressions) { if (partitioning == null) { return; } - if (partitioning.getExpression() != null) { + if (partitioning.getKeyColumns() != null) { + partitioning.getKeyColumns().forEach(key -> { + accept(key.getExpression(), expressions); + visitOptions(key.getOperatorClassParameters(), expressions); + }); + } else if (partitioning.getExpression() != null) { accept(partitioning.getExpression(), expressions); } else if (partitioning.getExpressionList() != null) { accept(partitioning.getExpressionList(), expressions); @@ -141,48 +216,74 @@ public static void visit(TableElement element, Consumer expressions, if (element instanceof LikeClause) { accept(((LikeClause) element).getTable(), tables); } else if (element instanceof ColumnDefinition) { - ColumnDefinition column = (ColumnDefinition) element; - if (column.getColumnOptions() != null) { - for (ColumnOption option : column.getColumnOptions()) { - option.visitExpressions(expressions); - if (option.getForeignKeyReference() != null) { - accept(option.getForeignKeyReference().getTable(), tables); - } - if (option.getConstraint() != null) { - visit(option.getConstraint(), expressions, tables); - } - } - } - if (column instanceof AlterExpression.ColumnDataType) { - accept(((AlterExpression.ColumnDataType) column).getUsingExpression(), expressions); - } - } else if (element instanceof Index) { - Index index = (Index) element; - if (index.getColumns() != null) { - for (Index.ColumnParams column : index.getColumns()) { - accept(column.getExpression(), expressions); - visitOptions(column.getOperatorClassParameters(), expressions); - } - } - visitOptions(index.getStorageParameters(), expressions); - if (index instanceof CheckConstraint) { - accept(((CheckConstraint) index).getExpression(), expressions); - } - if (index instanceof DefaultConstraint) { - DefaultConstraint constraint = (DefaultConstraint) index; - accept(constraint.getExpression(), expressions); - accept(constraint.getColumn(), expressions); - } - if (index instanceof ExcludeConstraint) { - accept(((ExcludeConstraint) index).getExpression(), expressions); + visitColumn((ColumnDefinition) element, expressions, tables); + } else if (element instanceof NamedConstraint) { + visitConstraint((NamedConstraint) element, expressions, tables); + } + if (element instanceof KeyColumnSource) { + visitKeys((KeyColumnSource) element, expressions); + } + if (element instanceof IndexOptionSource) { + visitOptions(((IndexOptionSource) element).getIndexOptions().getStorageParameters(), + expressions); + } + } + + private static void visitConstraint(NamedConstraint element, Consumer expressions, + Consumer
tables) { + if (element instanceof NotNullConstraint) { + accept(((NotNullConstraint) element).getColumn(), expressions); + } else if (element instanceof CheckConstraint) { + accept(((CheckConstraint) element).getExpression(), expressions); + } else if (element instanceof DefaultConstraint) { + DefaultConstraint constraint = (DefaultConstraint) element; + accept(constraint.getExpression(), expressions); + accept(constraint.getColumn(), expressions); + } else if (element instanceof ExcludeConstraint) { + accept(((ExcludeConstraint) element).getExpression(), expressions); + } else if (element instanceof ForeignKeyConstraint) { + accept(((ForeignKeyConstraint) element).getTable(), tables); + } + } + + private static void visitColumn(ColumnDefinition column, Consumer expressions, + Consumer
tables) { + if (column instanceof AlterExpression.ColumnDataType + && ((AlterExpression.ColumnDataType) column).getIdentityAlterations() != null) { + return; + } + if (column.getColumnOptions() != null) { + for (ColumnOption option : column.getColumnOptions()) { + visitColumnOption(option, expressions, tables); } - if (index instanceof ForeignKeyIndex) { - accept(((ForeignKeyIndex) index).getTable(), tables); + } + if (column instanceof AlterExpression.ColumnDataType) { + accept(((AlterExpression.ColumnDataType) column).getUsingExpression(), expressions); + } + } + + private static void visitColumnOption(ColumnOption option, Consumer expressions, + Consumer
tables) { + option.visitExpressions(expressions); + if (option.getKind() == ColumnOption.Kind.REFERENCE + && option.getForeignKeyReference() != null) { + accept(option.getForeignKeyReference().getTable(), tables); + } + if (option.getKind() == ColumnOption.Kind.CONSTRAINT && option.getConstraint() != null) { + visit(option.getConstraint(), expressions, tables); + } + } + + private static void visitKeys(KeyColumnSource source, Consumer expressions) { + if (source.getColumns() != null) { + for (KeyElement key : source.getColumns()) { + accept(key.getExpression(), expressions); + visitOptions(key.getOperatorClassParameters(), expressions); } } } - private static void visitOptions(List options, Consumer expressions) { + private static void visitOptions(List options, Consumer expressions) { if (options != null) { options.forEach(option -> accept(option.getValue(), expressions)); } diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java index 798234f9a8..b84ed3e0e3 100644 --- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java +++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java @@ -9,38 +9,17 @@ */ package net.sf.jsqlparser.util; -import net.sf.jsqlparser.statement.alter.schema.AlterSchema; -import net.sf.jsqlparser.statement.select.MatchRecognize; -import net.sf.jsqlparser.expression.RowPatternFunction; - -import net.sf.jsqlparser.expression.AliasedExpression; - -import net.sf.jsqlparser.statement.oracle.OracleBlock; -import net.sf.jsqlparser.statement.oracle.OracleAssignment; -import net.sf.jsqlparser.statement.oracle.OracleNullStatement; - -import net.sf.jsqlparser.statement.role.CreateRole; -import net.sf.jsqlparser.statement.role.AlterRole; -import net.sf.jsqlparser.statement.grant.Revoke; -import net.sf.jsqlparser.statement.grant.AlterDefaultPrivileges; -import net.sf.jsqlparser.statement.create.type.CreateType; -import net.sf.jsqlparser.statement.alter.AlterType; -import net.sf.jsqlparser.statement.create.domain.CreateDomain; -import net.sf.jsqlparser.statement.alter.AlterDomain; -import net.sf.jsqlparser.statement.create.extension.CreateExtension; -import net.sf.jsqlparser.statement.alter.AlterExtension; -import net.sf.jsqlparser.statement.create.publication.CreatePublication; -import net.sf.jsqlparser.statement.alter.AlterPublication; -import net.sf.jsqlparser.statement.create.subscription.CreateSubscription; -import net.sf.jsqlparser.statement.alter.AlterSubscription; - import java.util.ArrayList; +import java.util.HashMap; import java.util.HashSet; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.*; +import net.sf.jsqlparser.expression.AliasedExpression; +import net.sf.jsqlparser.expression.RowPatternFunction; import net.sf.jsqlparser.expression.operators.arithmetic.Addition; import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd; import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseLeftShift; @@ -49,6 +28,7 @@ import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor; import net.sf.jsqlparser.expression.operators.arithmetic.Concat; import net.sf.jsqlparser.expression.operators.arithmetic.Division; +import net.sf.jsqlparser.expression.operators.arithmetic.Exponentiation; import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision; import net.sf.jsqlparser.expression.operators.arithmetic.Modulo; import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; @@ -74,9 +54,10 @@ import net.sf.jsqlparser.expression.operators.relational.Intersects; import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression; import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression; +import net.sf.jsqlparser.expression.operators.relational.IsJsonExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression; import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; import net.sf.jsqlparser.expression.operators.relational.IsUnknownExpression; -import net.sf.jsqlparser.expression.operators.relational.IsJsonExpression; import net.sf.jsqlparser.expression.operators.relational.JsonOperator; import net.sf.jsqlparser.expression.operators.relational.LikeExpression; import net.sf.jsqlparser.expression.operators.relational.Matches; @@ -93,58 +74,153 @@ import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.AssertStatement; +import net.sf.jsqlparser.statement.AttachStatement; import net.sf.jsqlparser.statement.Block; import net.sf.jsqlparser.statement.Commit; +import net.sf.jsqlparser.statement.ConnectStatement; +import net.sf.jsqlparser.statement.CopyStatement; import net.sf.jsqlparser.statement.CreateFunctionalStatement; +import net.sf.jsqlparser.statement.DeallocateStatement; import net.sf.jsqlparser.statement.DeclareStatement; import net.sf.jsqlparser.statement.DescribeStatement; +import net.sf.jsqlparser.statement.DiscardStatement; +import net.sf.jsqlparser.statement.DetachStatement; +import net.sf.jsqlparser.statement.DisconnectStatement; import net.sf.jsqlparser.statement.DoStatement; import net.sf.jsqlparser.statement.ExplainStatement; +import net.sf.jsqlparser.statement.ExtensionStatement; import net.sf.jsqlparser.statement.IfElseStatement; import net.sf.jsqlparser.statement.OutputClause; +import net.sf.jsqlparser.statement.PragmaStatement; +import net.sf.jsqlparser.statement.PrepareStatement; +import net.sf.jsqlparser.statement.PluginStatement; +import net.sf.jsqlparser.statement.PrepareTransactionStatement; import net.sf.jsqlparser.statement.PurgeObjectType; import net.sf.jsqlparser.statement.PurgeStatement; +import net.sf.jsqlparser.statement.ReleaseSavepointStatement; import net.sf.jsqlparser.statement.ResetStatement; import net.sf.jsqlparser.statement.ReturningClause; import net.sf.jsqlparser.statement.RollbackStatement; import net.sf.jsqlparser.statement.SavepointStatement; import net.sf.jsqlparser.statement.SessionStatement; +import net.sf.jsqlparser.statement.SetIdentityInsertStatement; +import net.sf.jsqlparser.statement.SetConstraintsStatement; import net.sf.jsqlparser.statement.SetStatement; +import net.sf.jsqlparser.statement.SetDefaultRoleStatement; +import net.sf.jsqlparser.statement.SetPasswordStatement; +import net.sf.jsqlparser.statement.SetRoleStatement; +import net.sf.jsqlparser.statement.SetTransactionStatement; import net.sf.jsqlparser.statement.ShowColumnsStatement; import net.sf.jsqlparser.statement.ShowStatement; +import net.sf.jsqlparser.statement.StartTransaction; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.TableMaintenanceStatement; import net.sf.jsqlparser.statement.Statements; import net.sf.jsqlparser.statement.UnsupportedStatement; import net.sf.jsqlparser.statement.UseStatement; -import net.sf.jsqlparser.statement.SetIdentityInsertStatement; +import net.sf.jsqlparser.statement.XaStatement; import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterCollation; +import net.sf.jsqlparser.statement.alter.AlterRoutine; +import net.sf.jsqlparser.statement.alter.AlterTrigger; +import net.sf.jsqlparser.statement.alter.AlterDomain; +import net.sf.jsqlparser.statement.alter.AlterExtension; +import net.sf.jsqlparser.statement.alter.AlterForeignDataWrapper; +import net.sf.jsqlparser.statement.alter.AlterPolicy; +import net.sf.jsqlparser.statement.alter.AlterPublication; +import net.sf.jsqlparser.statement.alter.AlterRelation; +import net.sf.jsqlparser.statement.create.operator.CreateOperator; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorClass; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorFamily; +import net.sf.jsqlparser.statement.create.aggregate.CreateAggregate; +import net.sf.jsqlparser.statement.alter.AlterOperator; +import net.sf.jsqlparser.statement.alter.AlterOperatorClass; +import net.sf.jsqlparser.statement.alter.AlterOperatorFamily; +import net.sf.jsqlparser.statement.alter.AlterAggregate; +import net.sf.jsqlparser.statement.alter.AlterRule; +import net.sf.jsqlparser.statement.create.cast.CreateCast; +import net.sf.jsqlparser.statement.create.transform.CreateTransform; +import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterConversion; +import net.sf.jsqlparser.statement.alter.AlterServer; import net.sf.jsqlparser.statement.alter.AlterSession; +import net.sf.jsqlparser.statement.alter.AlterStatistics; +import net.sf.jsqlparser.statement.alter.AlterSubscription; +import net.sf.jsqlparser.statement.alter.AlterEventTrigger; +import net.sf.jsqlparser.statement.alter.AlterInstance; import net.sf.jsqlparser.statement.alter.AlterSystemStatement; +import net.sf.jsqlparser.statement.alter.AlterTablespace; +import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; +import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration; +import net.sf.jsqlparser.statement.alter.AlterType; +import net.sf.jsqlparser.statement.alter.AlterUserMapping; import net.sf.jsqlparser.statement.alter.RenameTableStatement; +import net.sf.jsqlparser.statement.alter.AlterUser; +import net.sf.jsqlparser.statement.alter.RenameUser; +import net.sf.jsqlparser.statement.alter.database.AlterDatabase; +import net.sf.jsqlparser.statement.alter.schema.AlterSchema; import net.sf.jsqlparser.statement.alter.sequence.AlterSequence; import net.sf.jsqlparser.statement.analyze.Analyze; import net.sf.jsqlparser.statement.comment.Comment; +import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; +import net.sf.jsqlparser.statement.create.collation.CreateCollation; import net.sf.jsqlparser.statement.create.database.CreateDatabase; +import net.sf.jsqlparser.statement.create.domain.CreateDomain; import net.sf.jsqlparser.statement.create.event.AlterEvent; import net.sf.jsqlparser.statement.create.event.CreateEvent; +import net.sf.jsqlparser.statement.create.extension.CreateExtension; +import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository; +import net.sf.jsqlparser.statement.create.fdw.CreateForeignDataWrapper; +import net.sf.jsqlparser.statement.create.function.CreateFunction; import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.macro.CreateMacro; import net.sf.jsqlparser.statement.create.policy.CreatePolicy; +import net.sf.jsqlparser.statement.create.publication.CreatePublication; +import net.sf.jsqlparser.statement.create.rule.CreateRule; import net.sf.jsqlparser.statement.create.schema.CreateSchema; import net.sf.jsqlparser.statement.create.sequence.CreateSequence; +import net.sf.jsqlparser.statement.create.server.CreateServer; +import net.sf.jsqlparser.statement.create.statistics.CreateStatistics; +import net.sf.jsqlparser.statement.create.subscription.CreateSubscription; import net.sf.jsqlparser.statement.create.synonym.CreateSynonym; import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.spatial.CreateSpatialReferenceSystem; +import net.sf.jsqlparser.statement.create.tablespace.CreateTablespace; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger; import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +import net.sf.jsqlparser.statement.create.type.CreateType; import net.sf.jsqlparser.statement.create.user.CreateUser; +import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping; import net.sf.jsqlparser.statement.create.view.AlterView; import net.sf.jsqlparser.statement.create.view.CreateView; +import net.sf.jsqlparser.statement.cursor.CloseCursorStatement; +import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement; +import net.sf.jsqlparser.statement.cursor.FetchCursorStatement; import net.sf.jsqlparser.statement.delete.Delete; import net.sf.jsqlparser.statement.delete.ParenthesedDelete; import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.statement.drop.DropPolicy; +import net.sf.jsqlparser.statement.drop.DropUserMapping; import net.sf.jsqlparser.statement.execute.Execute; import net.sf.jsqlparser.statement.execute.ExecuteArgument; import net.sf.jsqlparser.statement.export.Export; +import net.sf.jsqlparser.statement.foreign.ImportForeignSchema; +import net.sf.jsqlparser.statement.export.ExportDataStatement; +import net.sf.jsqlparser.statement.grant.AlterDefaultPrivileges; import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.statement.grant.Revoke; import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.InsertBulk; @@ -153,13 +229,35 @@ import net.sf.jsqlparser.statement.insert.OracleMultiInsertBranch; import net.sf.jsqlparser.statement.insert.OracleMultiInsertClause; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; +import net.sf.jsqlparser.statement.load.LoadDataStatement; +import net.sf.jsqlparser.statement.load.MySqlLoadDataStatement; +import net.sf.jsqlparser.statement.admin.FlushStatement; +import net.sf.jsqlparser.statement.admin.KillStatement; +import net.sf.jsqlparser.statement.handler.HandlerStatement; +import net.sf.jsqlparser.statement.lock.BackupLockStatement; import net.sf.jsqlparser.statement.lock.LockStatement; +import net.sf.jsqlparser.statement.lock.UnlockStatement; +import net.sf.jsqlparser.statement.replication.ChangeReplicationFilterStatement; +import net.sf.jsqlparser.statement.replication.ChangeReplicationSourceStatement; +import net.sf.jsqlparser.statement.replication.ReplicationFilter; +import net.sf.jsqlparser.statement.replication.ResetReplicationStatement; +import net.sf.jsqlparser.statement.replication.StartReplicaStatement; +import net.sf.jsqlparser.statement.replication.StopReplicaStatement; +import net.sf.jsqlparser.statement.maintenance.CheckpointStatement; +import net.sf.jsqlparser.statement.maintenance.ClusterStatement; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement; import net.sf.jsqlparser.statement.merge.Merge; import net.sf.jsqlparser.statement.merge.MergeDelete; +import net.sf.jsqlparser.statement.merge.MergeDoNothing; import net.sf.jsqlparser.statement.merge.MergeInsert; import net.sf.jsqlparser.statement.merge.MergeOperation; import net.sf.jsqlparser.statement.merge.MergeOperationVisitor; import net.sf.jsqlparser.statement.merge.MergeUpdate; +import net.sf.jsqlparser.statement.notify.ListenStatement; +import net.sf.jsqlparser.statement.notify.NotifyStatement; +import net.sf.jsqlparser.statement.oracle.OracleAssignment; +import net.sf.jsqlparser.statement.oracle.OracleBlock; +import net.sf.jsqlparser.statement.oracle.OracleNullStatement; import net.sf.jsqlparser.statement.piped.AggregatePipeOperator; import net.sf.jsqlparser.statement.piped.AsPipeOperator; import net.sf.jsqlparser.statement.piped.CallPipeOperator; @@ -181,6 +279,14 @@ import net.sf.jsqlparser.statement.piped.WherePipeOperator; import net.sf.jsqlparser.statement.piped.WindowPipeOperator; import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement; +import net.sf.jsqlparser.statement.reindex.Reindex; +import net.sf.jsqlparser.statement.resourcegroup.AlterResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.CreateResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.SetResourceGroup; +import net.sf.jsqlparser.statement.securitylabel.SecurityLabel; +import net.sf.jsqlparser.statement.role.AlterRole; +import net.sf.jsqlparser.statement.role.CreateRole; +import net.sf.jsqlparser.statement.role.ReassignOwned; import net.sf.jsqlparser.statement.select.AllColumns; import net.sf.jsqlparser.statement.select.AllTableColumns; import net.sf.jsqlparser.statement.select.FromItem; @@ -189,12 +295,13 @@ import net.sf.jsqlparser.statement.select.Join; import net.sf.jsqlparser.statement.select.LateralSubSelect; import net.sf.jsqlparser.statement.select.LateralView; +import net.sf.jsqlparser.statement.select.Limit; +import net.sf.jsqlparser.statement.select.MatchRecognize; import net.sf.jsqlparser.statement.select.OrderByElement; import net.sf.jsqlparser.statement.select.ParenthesedFromItem; import net.sf.jsqlparser.statement.select.ParenthesedSelect; import net.sf.jsqlparser.statement.select.Pivot; import net.sf.jsqlparser.statement.select.PivotQuery; -import net.sf.jsqlparser.statement.select.UnPivotQuery; import net.sf.jsqlparser.statement.select.PivotVisitor; import net.sf.jsqlparser.statement.select.PivotXml; import net.sf.jsqlparser.statement.select.PlainSelect; @@ -204,31 +311,21 @@ import net.sf.jsqlparser.statement.select.SelectVisitor; import net.sf.jsqlparser.statement.select.SetOperationList; import net.sf.jsqlparser.statement.select.TableFunction; -import net.sf.jsqlparser.statement.select.UnPivot; import net.sf.jsqlparser.statement.select.TableStatement; +import net.sf.jsqlparser.statement.select.UnPivot; +import net.sf.jsqlparser.statement.select.UnPivotQuery; import net.sf.jsqlparser.statement.select.Values; import net.sf.jsqlparser.statement.select.WithItem; +import net.sf.jsqlparser.statement.show.MySqlShowStatement; +import net.sf.jsqlparser.statement.show.ShowCreateStatement; import net.sf.jsqlparser.statement.show.ShowIndexStatement; +import net.sf.jsqlparser.statement.show.ShowTableStatusStatement; import net.sf.jsqlparser.statement.show.ShowTablesStatement; import net.sf.jsqlparser.statement.truncate.Truncate; import net.sf.jsqlparser.statement.update.ParenthesedUpdate; import net.sf.jsqlparser.statement.update.Update; import net.sf.jsqlparser.statement.update.UpdateSet; import net.sf.jsqlparser.statement.upsert.Upsert; -import net.sf.jsqlparser.statement.PragmaStatement; -import net.sf.jsqlparser.statement.ExtensionStatement; -import net.sf.jsqlparser.statement.AttachStatement; -import net.sf.jsqlparser.statement.DetachStatement; -import net.sf.jsqlparser.statement.ConnectStatement; -import net.sf.jsqlparser.statement.DisconnectStatement; -import net.sf.jsqlparser.statement.PrepareStatement; -import net.sf.jsqlparser.statement.DeallocateStatement; -import net.sf.jsqlparser.statement.CopyStatement; -import net.sf.jsqlparser.statement.create.macro.CreateMacro; -import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository; -import net.sf.jsqlparser.statement.AssertStatement; -import net.sf.jsqlparser.statement.export.ExportDataStatement; -import net.sf.jsqlparser.statement.load.LoadDataStatement; /** @@ -247,7 +344,10 @@ public class TablesNamesFinder private boolean allowColumnProcessing = false; private Set rowPatternVariables = java.util.Collections.emptySet(); - private List otherItemNames; + private Set otherItemNames; + // the WITH items a table reference resolves to at the current position, counted because a + // nested WITH may repeat a name of an enclosing one + private Map withItemsInScope; public static Set findTables(String sqlStr) throws JSQLParserException { TablesNamesFinder tablesNamesFinder = new TablesNamesFinder<>(); @@ -278,10 +378,6 @@ public Set getTables(Statement statement) { init(false); statement.accept(this, null); - // @todo: assess this carefully, maybe we want to remove more specifically - // only Aliases on WithItems, Parenthesed Selects and Lateral Selects - otherItemNames.forEach(tables::remove); - return tables; } @@ -297,13 +393,9 @@ public Set getTablesOrOtherSources(Statement statement) { @Override public Void visit(Select select, S context) { - List> withItemsList = select.getWithItemsList(); - if (withItemsList != null && !withItemsList.isEmpty()) { - for (WithItem withItem : withItemsList) { - withItem.accept((SelectVisitor) this, context); - } - } + visitWithItems(select.getWithItemsList(), context); select.accept((SelectVisitor) this, context); + leaveWithItems(select.getWithItemsList()); return null; } @@ -331,8 +423,12 @@ public Void visit(TrimFunction trimFunction, S context) { @Override public Void visit(RangeExpression rangeExpression, S context) { - rangeExpression.getStartExpression().accept(this, context); - rangeExpression.getEndExpression().accept(this, context); + for (Expression bound : new Expression[] {rangeExpression.getStartExpression(), + rangeExpression.getEndExpression(), rangeExpression.getStepExpression()}) { + if (bound != null) { + bound.accept(this, context); + } + } return null; } @@ -358,6 +454,56 @@ public Set getTables(Expression expr) { return tables; } + /** + * Visits the WITH items of a query and brings their names into scope, which the caller ends + * with {@link #leaveWithItems(List)} after the query. An item only sees the items before it, so + * a reference to its own or a later name is a table, unless RECURSIVE makes all of them visible + * to each other. The parser sets RECURSIVE on the first item, but it covers the list. + */ + @Override + public Void visitWithItems(List> withItemsList, S context) { + if (withItemsList != null) { + boolean recursive = withItemsList.stream().anyMatch(WithItem::isRecursive); + if (recursive) { + withItemsList.forEach(this::enterWithItem); + } + for (WithItem withItem : withItemsList) { + withItem.accept((SelectVisitor) this, context); + if (!recursive) { + enterWithItem(withItem); + } + } + } + return null; + } + + private void enterWithItem(WithItem withItem) { + if (withItem.getAlias() != null) { + withItemsInScope.merge(withItem.getAlias().getName(), 1, Integer::sum); + } + } + + private void leaveWithItems(List> withItemsList) { + if (withItemsList != null) { + for (WithItem withItem : withItemsList) { + if (withItem.getAlias() != null) { + withItemsInScope.computeIfPresent(withItem.getAlias().getName(), + (name, count) -> count > 1 ? count - 1 : null); + } + } + } + } + + /** + * The target of a DML statement is a table even if a WITH item in scope has the same name. + */ + private void visitTargetTable(Table table, S context) { + Map scope = withItemsInScope; + withItemsInScope = new HashMap<>(); + visit(table, context); + withItemsInScope = scope; + } + @Override public Void visit(WithItem withItem, S context) { if (withItem.getAlias() != null) { @@ -385,12 +531,7 @@ public Void visit(ParenthesedSelect select, S context) { if (select.getAlias() != null) { otherItemNames.add(select.getAlias().getName()); } - List> withItemsList = select.getWithItemsList(); - if (withItemsList != null && !withItemsList.isEmpty()) { - for (WithItem withItem : withItemsList) { - withItem.accept((SelectVisitor) this, context); - } - } + visitWithItems(select.getWithItemsList(), context); select.getSelect().accept((SelectVisitor) this, context); visitOrderBy(select.getOrderByElements(), context); if (select.getPivot() != null) { @@ -406,6 +547,7 @@ public Void visit(ParenthesedSelect select, S context) { if (select.getFetch() != null) { select.getFetch().getExpression().accept(this, context); } + leaveWithItems(select.getWithItemsList()); return null; } @@ -430,6 +572,9 @@ private Void visitPlainSelectBody(PlainSelect plainSelect, S context) { if (plainSelect.getDistinct() != null) { visitSelectItems(plainSelect.getDistinct().getOnSelectItems(), context); } + if (plainSelect.getTop() != null) { + visitExpression(plainSelect.getTop().getExpression(), context); + } visitTables(plainSelect.getIntoTables(), context); visitSelectItems(plainSelect.getSelectItems(), context); @@ -474,6 +619,7 @@ private Void visitPlainSelectBody(PlainSelect plainSelect, S context) { visitSelectPagination(plainSelect, context); visitUpdateSets(plainSelect.getSettings(), context); visitFromItem(plainSelect.getIntoTempTable(), context); + leaveWithItems(plainSelect.getWithItemsList()); return null; } @@ -488,6 +634,7 @@ public Void visit(PivotQuery pivotQuery, S context) { visitLimit(pivotQuery.getLimit(), context); visitSelectPagination(pivotQuery, context); + leaveWithItems(pivotQuery.getWithItemsList()); return null; } @@ -497,6 +644,7 @@ public Void visit(UnPivotQuery unPivotQuery, S context) { visitFromItem(unPivotQuery.getFromItem(), context); visitExpressions(unPivotQuery.getOnExpressions(), context); visitExpressions(unPivotQuery.getValueColumns(), context); + leaveWithItems(unPivotQuery.getWithItemsList()); return null; } @@ -574,7 +722,7 @@ public Void visit(Table table, S context) { String tableWholeName = extractTableName(table); if (table.isTableVariable()) { otherItemNames.add(tableWholeName); - } else if (!otherItemNames.contains(tableWholeName)) { + } else if (!withItemsInScope.containsKey(table.getFullyQualifiedName())) { tables.add(tableWholeName); } if (table.getPivot() != null) { @@ -622,10 +770,14 @@ public Void visit(OverlapsCondition overlapsCondition, S context) { public Void visit(Column tableColumn, S context) { if (allowColumnProcessing && tableColumn.getTable() != null && tableColumn.getTable().getName() != null + && !otherItemNames.contains(extractTableName(tableColumn.getTable())) && !rowPatternVariables.contains( MatchRecognize.normalizeVariableName(tableColumn.getTable().getName()))) { visit(tableColumn.getTable(), context); } + if (tableColumn.getArrayConstructor() != null) { + tableColumn.getArrayConstructor().accept(this, context); + } return null; } @@ -641,6 +793,12 @@ public Void visit(IntegerDivision division, S context) { return null; } + @Override + public Void visit(Exponentiation exponentiation, S context) { + visitBinaryExpression(exponentiation); + return null; + } + @Override public Void visit(DoubleValue doubleValue, S context) { @@ -663,9 +821,32 @@ public Void visit(Function function, S context) { if (exprList != null) { visit(exprList, context); } + exprList = function.getNamedParameters(); + if (exprList != null) { + visit(exprList, context); + } + // an attribute column names a field of the result, only an attribute function is visited + if (function.getAttribute() != function.getAttributeColumn()) { + visitExpression((Expression) function.getAttribute(), context); + } + visitOrderBy(function.getOrderByElements(), context); + visitAggregateModifiers(function.getKeep(), function.getHavingClause(), + function.getKeywordArguments(), function.getLimit(), context); return null; } + private void visitAggregateModifiers(KeepExpression keep, Function.HavingClause having, + List keywordArguments, Limit limit, S context) { + visitExpression(keep, context); + visitExpression(having, context); + if (keywordArguments != null) { + for (Function.KeywordArgument keywordArgument : keywordArguments) { + visitExpression(keywordArgument.getExpression(), context); + } + } + visitLimit(limit, context); + } + @Override public Void visit(GreaterThan greaterThan, S context) { visitBinaryExpression(greaterThan); @@ -701,7 +882,8 @@ public Void visit(ExcludesExpression excludesExpression, S context) { @Override public Void visit(FullTextSearch fullTextSearch, S context) { - + visitExpressions(fullTextSearch.getMatchColumns(), context); + visitExpression(fullTextSearch.getAgainstValue(), context); return null; } @@ -731,7 +913,13 @@ public Void visit(IsJsonExpression expression, S context) { @Override public Void visit(IsUnknownExpression isUnknownExpression, S context) { + isUnknownExpression.getLeftExpression().accept(this, context); + return null; + } + @Override + public Void visit(IsNormalizedExpression isNormalizedExpression, S context) { + isNormalizedExpression.getLeftExpression().accept(this, context); return null; } @@ -744,6 +932,7 @@ public Void visit(JdbcParameter jdbcParameter, S context) { @Override public Void visit(LikeExpression likeExpression, S context) { visitBinaryExpression(likeExpression); + visitExpression(likeExpression.getEscape(), context); return null; } @@ -991,12 +1180,14 @@ public Void visit(AnalyticExpression analytic, S context) { if (analytic.getOffset() != null) { analytic.getOffset().accept(this, context); } - if (analytic.getKeep() != null) { - analytic.getKeep().accept(this, context); - } + visitAggregateModifiers(analytic.getKeep(), analytic.getHavingClause(), + analytic.getKeywordArguments(), analytic.getLimit(), context); if (analytic.getFilterExpression() != null) { analytic.getFilterExpression().accept(this, context); } + if (analytic.getPartitionExpressionList() != null) { + visit(analytic.getPartitionExpressionList(), context); + } if (analytic.getFuncOrderBy() != null) { for (OrderByElement element : analytic.getFuncOrderBy()) { element.getExpression().accept(this, context); @@ -1007,39 +1198,29 @@ public Void visit(AnalyticExpression analytic, S context) { element.getExpression().accept(this, context); } } + visitWindowElement(analytic.getWindowElement(), context); + return null; + } - if (analytic.getWindowElement() != null) { - if (analytic.getWindowElement().getRange() != null) { - if (analytic.getWindowElement().getRange().getStart() != null - && analytic.getWindowElement().getRange().getStart() - .getExpression() != null) { - analytic.getWindowElement().getRange().getStart().getExpression().accept(this, - context); + private void visitWindowElement(WindowElement windowElement, S context) { + if (windowElement != null) { + if (windowElement.getRange() != null) { + if (windowElement.getRange().getStart() != null) { + visitExpression(windowElement.getRange().getStart().getExpression(), context); } - if (analytic.getWindowElement().getRange().getEnd() != null - && analytic.getWindowElement().getRange().getEnd() - .getExpression() != null) { - analytic.getWindowElement().getRange().getEnd().getExpression().accept(this, - context); + if (windowElement.getRange().getEnd() != null) { + visitExpression(windowElement.getRange().getEnd().getExpression(), context); } } - if (analytic.getWindowElement().getOffset() != null - && analytic.getWindowElement().getOffset().getExpression() != null) { - analytic.getWindowElement().getOffset().getExpression().accept(this, context); + if (windowElement.getOffset() != null) { + visitExpression(windowElement.getOffset().getExpression(), context); } - } - return null; } @Override public Void visit(SetOperationList list, S context) { - List> withItemsList = list.getWithItemsList(); - if (withItemsList != null && !withItemsList.isEmpty()) { - for (WithItem withItem : withItemsList) { - withItem.accept((SelectVisitor) this, context); - } - } + visitWithItems(list.getWithItemsList(), context); for (Select selectBody : list.getSelects()) { selectBody.accept((SelectVisitor) this, context); } @@ -1051,6 +1232,7 @@ public Void visit(SetOperationList list, S context) { if (list.getFetch() != null) { list.getFetch().getExpression().accept(this, context); } + leaveWithItems(list.getWithItemsList()); return null; } @@ -1083,7 +1265,9 @@ public void visit(LateralSubSelect lateralSubSelect) { @Override public Void visit(TableStatement tableStatement, S context) { + visitWithItems(tableStatement.getWithItemsList(), context); tableStatement.getTable().accept(this, null); + leaveWithItems(tableStatement.getWithItemsList()); return null; } @@ -1094,18 +1278,20 @@ public void visit(TableStatement tableStatement) { @Override public Void visit(FromQuery fromQuery, S context) { - List> withItemsList = fromQuery.getWithItemsList(); - if (withItemsList != null && !withItemsList.isEmpty()) { - for (WithItem withItem : withItemsList) { - withItem.accept((SelectVisitor) this, context); - } - } + visitWithItems(fromQuery.getWithItemsList(), context); if (fromQuery.getFromItem() != null) { fromQuery.getFromItem().accept(this, context); } + if (fromQuery.getLateralViews() != null) { + for (LateralView lateralView : fromQuery.getLateralViews()) { + lateralView.getGeneratorFunction().accept(this, context); + } + } + visitJoins(fromQuery.getJoins(), context); for (PipeOperator pipeOperator : fromQuery.getPipeOperators()) { pipeOperator.accept(this, null); } + leaveWithItems(fromQuery.getWithItemsList()); return null; } @@ -1275,7 +1461,8 @@ public Void visit(DateUnitExpression dateUnitExpression, S context) { * @param allowColumnProcessing */ protected void init(boolean allowColumnProcessing) { - otherItemNames = new ArrayList(); + otherItemNames = new LinkedHashSet(); + withItemsInScope = new HashMap<>(); tables = new HashSet<>(); this.allowColumnProcessing = allowColumnProcessing; this.rowPatternVariables = java.util.Collections.emptySet(); @@ -1318,6 +1505,9 @@ public Void visit(JsonExpression jsonExpr, S context) { if (jsonExpr.getExpression() != null) { jsonExpr.getExpression().accept(this, context); } + for (Expression ident : jsonExpr.getIdents()) { + visitExpression(ident, context); + } return null; } @@ -1335,16 +1525,23 @@ public Void visit(Intersects intersects, S context) { @Override public Void visit(AllColumns allColumns, S context) { - + visitColumnsTransformers(allColumns, context); return null; } @Override public Void visit(AllTableColumns allTableColumns, S context) { - + visitColumnsTransformers(allTableColumns, context); return null; } + private void visitColumnsTransformers(AllColumns allColumns, S context) { + for (ColumnsTransformer transformer : allColumns.getTransformers()) { + visitExpression(transformer.getApplyExpression(), context); + visitSelectItems(transformer.getReplaceItems(), context); + } + } + @Override public Void visit(FunctionAllColumns functionAllColumns, S context) { functionAllColumns.getFunction().accept(this, context); @@ -1389,30 +1586,28 @@ public Void visit(NumericBind numericBind, S context) { @Override public Void visit(KeepExpression keepExpression, S context) { - + visitOrderBy(keepExpression.getOrderByElements(), context); return null; } @Override public Void visit(MySQLGroupConcat groupConcat, S context) { - + visitExpressions(groupConcat.getExpressionList(), context); + visitOrderBy(groupConcat.getOrderByElements(), context); return null; } @Override public Void visit(Delete delete, S context) { - if (delete.getWithItemsList() != null) { - for (WithItem withItem : delete.getWithItemsList()) { - withItem.accept((SelectVisitor) this, context); - } - } - visit(delete.getTable(), context); + visitWithItems(delete.getWithItemsList(), context); + visitTargetTable(delete.getTable(), context); if (delete.getUsingFromItemList() != null) { for (FromItem usingFromItem : delete.getUsingFromItemList()) { usingFromItem.accept(this, context); } } + visitJoins(delete.getUsingJoins(), context); visitJoins(delete.getJoins(), context); @@ -1426,6 +1621,7 @@ public Void visit(Delete delete, S context) { visitLimit(delete.getLimit(), context); visitOutputClause(delete.getOutputClause(), context); visitReturningClause(delete.getReturningClause(), context); + leaveWithItems(delete.getWithItemsList()); return null; } @@ -1446,14 +1642,10 @@ public Void visit(SessionStatement sessionStatement, S context) { @Override public Void visit(Update update, S context) { - if (update.getWithItemsList() != null) { - for (WithItem withItem : update.getWithItemsList()) { - withItem.accept((SelectVisitor) this, context); - } - } + visitWithItems(update.getWithItemsList(), context); if (!update.isTargetTableAlias()) { - visit(update.getTable(), context); + visitTargetTable(update.getTable(), context); } visitJoins(update.getStartJoins(), context); @@ -1481,6 +1673,7 @@ public Void visit(Update update, S context) { visitLimit(update.getLimit(), context); visitOutputClause(update.getOutputClause(), context); visitReturningClause(update.getReturningClause(), context); + leaveWithItems(update.getWithItemsList()); return null; } @@ -1505,20 +1698,16 @@ public Void visit(Insert insert, S context) { continue; } for (OracleMultiInsertClause clause : branch.getClauses()) { - visit(clause.getTable(), context); + visitTargetTable(clause.getTable(), context); if (clause.getSelect() != null) { visit(clause.getSelect(), context); } } } } else if (insert.getTable() != null) { - visit(insert.getTable(), context); - } - if (insert.getWithItemsList() != null) { - for (WithItem withItem : insert.getWithItemsList()) { - withItem.accept((SelectVisitor) this, context); - } + visitTargetTable(insert.getTable(), context); } + visitWithItems(insert.getWithItemsList(), context); if (insert.getSetUpdateSets() != null) { visitUpdateSets(insert.getSetUpdateSets(), context); } @@ -1536,6 +1725,7 @@ public Void visit(Insert insert, S context) { if (insert.getSelect() != null) { visit(insert.getSelect(), context); } + leaveWithItems(insert.getWithItemsList()); return null; } @@ -1555,9 +1745,17 @@ private void visitInsertAction(InsertConflictAction action, S context) { @Override public Void visitOutputClause(OutputClause outputClause, S context) { - if (outputClause != null && outputClause.getSelectItemList() != null) { - for (SelectItem selectItem : outputClause.getSelectItemList()) { - selectItem.accept(this, context); + if (outputClause != null) { + if (outputClause.getSelectItemList() != null) { + for (SelectItem selectItem : outputClause.getSelectItemList()) { + selectItem.accept(this, context); + } + } + if (outputClause.getOutputTable() != null) { + visit(outputClause.getOutputTable(), context); + } + if (outputClause.getTableVariable() != null) { + outputClause.getTableVariable().accept(this, context); } } return null; @@ -1592,6 +1790,81 @@ public void visit(Analyze analyze) { StatementVisitor.super.visit(analyze); } + @Override + public Void visit(TableMaintenanceStatement statement, S context) { + statement.getTables().forEach(table -> visit(table, context)); + return null; + } + + @Override + public void visit(TableMaintenanceStatement statement) { + StatementVisitor.super.visit(statement); + } + + @Override + public Void visit(FlushStatement flush, S context) { + flush.getTables().forEach(table -> visit(table, context)); + return null; + } + + @Override + public Void visit(KillStatement kill, S context) { + if (kill.getProcesslistId() != null) { + kill.getProcesslistId().accept(this, context); + } + return null; + } + + @Override + public Void visit(HandlerStatement handler, S context) { + if (handler.getAction() == HandlerStatement.Action.OPEN) { + visit(handler.getTable(), context); + } + // READ and CLOSE name a handler, which may be an alias that OPEN gave the table + if (handler.getKeyValues() != null) { + handler.getKeyValues().accept(this, context); + } + if (handler.getWhere() != null) { + handler.getWhere().accept(this, context); + } + return null; + } + + @Override + public Void visit(VacuumStatement vacuum, S context) { + // the column lists name columns of these tables, not tables + vacuum.getTargets().forEach(target -> visit(target.getTable(), context)); + return null; + } + + @Override + public void visit(VacuumStatement vacuum) { + StatementVisitor.super.visit(vacuum); + } + + @Override + public Void visit(ClusterStatement cluster, S context) { + if (cluster.getTable() != null) { + visit(cluster.getTable(), context); + } + return null; + } + + @Override + public void visit(ClusterStatement cluster) { + StatementVisitor.super.visit(cluster); + } + + @Override + public Void visit(CheckpointStatement checkpoint, S context) { + return null; + } + + @Override + public void visit(CheckpointStatement checkpoint) { + StatementVisitor.super.visit(checkpoint); + } + @Override public Void visit(Drop drop, S context) { drop.visitTables(table -> visit(table, context)); @@ -1603,9 +1876,15 @@ public void visit(Drop drop) { StatementVisitor.super.visit(drop); } + @Override + public Void visit(ReassignOwned statement, S context) { + // Role names do not refer to tables. + return null; + } + @Override public Void visit(Truncate truncate, S context) { - visit(truncate.getTable(), context); + truncate.getTables().forEach(table -> visit(table, context)); return null; } @@ -1624,7 +1903,12 @@ public Void visit(CreateIndex createIndex, S context) { @Override public Void visit(DoStatement statement, S context) { - throwUnsupported(statement); + // a code block's table accesses are unknown; MySQL's expressions are visible + if (statement.getSelectItems() == null) { + throwUnsupported(statement); + } else { + statement.visitExpressions(expression -> expression.accept(this, context)); + } return null; } @@ -1642,7 +1926,7 @@ public void visit(CreateIndex createIndex) { @Override public Void visit(CreateSchema createSchema, S context) { - throwUnsupported(createSchema); + createSchema.getStatements().forEach(element -> element.accept(this, context)); return null; } @@ -1672,6 +1956,33 @@ public void visit(CreateUser createUser) { StatementVisitor.super.visit(createUser); } + // Account and role names are not tables. + + @Override + public Void visit(AlterUser alterUser, S context) { + return null; + } + + @Override + public Void visit(RenameUser renameUser, S context) { + return null; + } + + @Override + public Void visit(SetRoleStatement setRole, S context) { + return null; + } + + @Override + public Void visit(SetDefaultRoleStatement setDefaultRole, S context) { + return null; + } + + @Override + public Void visit(SetPasswordStatement setPassword, S context) { + return null; + } + @Override public Void visit(CreateEvent createEvent, S context) { if (createEvent.getBody() != null) { @@ -1716,21 +2027,46 @@ public void visit(CreateTrigger createTrigger) { } @Override - public Void visit(CreateView create, S context) { - visit(create.getView(), null); - if (create.getSelect() != null) { - create.getSelect().accept((SelectVisitor) this, context); - } + public Void visit(CreateEventTrigger statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); return null; } @Override - public void visit(CreateView createView) { - StatementVisitor.super.visit(createView); + public Void visit(AlterEventTrigger statement, S context) { + return null; } @Override - public Void visit(Alter alter, S context) { + public Void visit(Reindex statement, S context) { + if (statement.getTable() != null) { + visit(statement.getTable(), context); + } + return null; + } + + @Override + public Void visit(SecurityLabel statement, S context) { + statement.visitRelations(table -> visit(table, context)); + return null; + } + + @Override + public Void visit(CreateView create, S context) { + visit(create.getView(), null); + if (create.getSelect() != null) { + create.getSelect().accept((SelectVisitor) this, context); + } + return null; + } + + @Override + public void visit(CreateView createView) { + StatementVisitor.super.visit(createView); + } + + @Override + public Void visit(Alter alter, S context) { for (net.sf.jsqlparser.statement.alter.AlterExpression action : alter .getAlterExpressions()) { TableDefinitionTraversal.visit(action, @@ -1789,8 +2125,13 @@ public void visit(Execute execute) { @Override public Void visit(SetStatement setStatement, S context) { - if (setStatement.getOnOffOptions() == null) { - throwUnsupported(setStatement); + for (int i = 0; i < setStatement.getCount(); i++) { + List expressions = setStatement.getExpressions(i); + if (expressions != null) { + for (Expression expression : expressions) { + expression.accept(this, context); + } + } } return null; } @@ -1802,7 +2143,7 @@ public void visit(SetStatement set) { @Override public Void visit(ResetStatement reset, S context) { - throwUnsupported(reset); + // RESET names a configuration parameter or a system variable, never a table return null; } @@ -1813,7 +2154,11 @@ public void visit(ResetStatement reset) { @Override public Void visit(ShowColumnsStatement showColumnsStatement, S context) { - throwUnsupported(showColumnsStatement); + // MySQL: the trailing FROM db names the database of the table + Table table = showColumnsStatement.getQualifiedTable(); + if (table != null) { + visit(table, context); + } return null; } @@ -1824,7 +2169,11 @@ public void visit(ShowColumnsStatement showColumns) { @Override public Void visit(ShowIndexStatement showIndex, S context) { - throwUnsupported(showIndex); + // MySQL: the trailing FROM db names the database of the table + Table table = showIndex.getQualifiedTable(); + if (table != null) { + visit(table, context); + } return null; } @@ -1859,12 +2208,8 @@ public Void visit(HexValue hexValue, S context) { @Override public Void visit(Merge merge, S context) { - visit(merge.getTable(), context); - if (merge.getWithItemsList() != null) { - for (WithItem withItem : merge.getWithItemsList()) { - withItem.accept((SelectVisitor) this, context); - } - } + visitTargetTable(merge.getTable(), context); + visitWithItems(merge.getWithItemsList(), context); if (merge.getFromItem() != null) { merge.getFromItem().accept(this, context); @@ -1879,7 +2224,9 @@ public Void visit(Merge merge, S context) { operation.accept(this, context); } } + visitOutputClause(merge.getOutputClause(), context); visitReturningClause(merge.getReturningClause(), context); + leaveWithItems(merge.getWithItemsList()); return null; } @@ -1891,6 +2238,14 @@ public Void visit(MergeDelete mergeDelete, S context) { return null; } + @Override + public Void visit(MergeDoNothing mergeDoNothing, S context) { + if (mergeDoNothing.getAndPredicate() != null) { + mergeDoNothing.getAndPredicate().accept(this, context); + } + return null; + } + @Override public Void visit(MergeInsert mergeInsert, S context) { if (mergeInsert.getAndPredicate() != null) { @@ -1934,7 +2289,8 @@ public Void visit(OracleHint hint, S context) { public Void visit(TableFunction tableFunction, S context) { if (tableFunction.getFunctions() != null) { for (var function : tableFunction.getFunctions()) { - visit(function, null); + // dispatch dynamically, XMLTABLE and JSON_TABLE are Function subclasses + function.accept(this, context); } } return null; @@ -1947,7 +2303,10 @@ public void visit(TableFunction tableFunction) { @Override public Void visit(AlterView alterView, S context) { - throwUnsupported(alterView); + visit(alterView.getView(), context); + if (alterView.getSelect() != null) { + alterView.getSelect().accept((SelectVisitor) this, context); + } return null; } @@ -1977,6 +2336,58 @@ public Void visit(DateTimeLiteralExpression literal, S context) { return null; } + @Override + public Void visit(StartTransaction statement, S context) { + return null; + } + + @Override + public Void visit(ReleaseSavepointStatement statement, S context) { + return null; + } + + @Override + public Void visit(SetTransactionStatement statement, S context) { + return null; + } + + @Override + public Void visit(SetConstraintsStatement statement, S context) { + // names constraints, not tables + return null; + } + + @Override + public Void visit(PrepareTransactionStatement statement, S context) { + return null; + } + + @Override + public Void visit(XaStatement statement, S context) { + return null; + } + + @Override + public Void visit(CreateResourceGroup statement, S context) { + return null; + } + + @Override + public Void visit(AlterResourceGroup statement, S context) { + return null; + } + + @Override + public Void visit(SetResourceGroup statement, S context) { + return null; + } + + @Override + public Void visit(PluginStatement statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + @Override public Void visit(Commit commit, S context) { return null; @@ -1996,6 +2407,9 @@ public Void visit(Upsert upsert, S context) { if (upsert.getSelect() != null) { visit(upsert.getSelect(), context); } + if (upsert.getDuplicateAction() != null) { + visitInsertAction(upsert.getDuplicateAction(), context); + } return null; } @@ -2075,6 +2489,7 @@ public void visit(Comment comment) { @Override public Void visit(Values values, S context) { + visitWithItems(values.getWithItemsList(), context); values.getExpressions().accept(this, context); visitOrderBy(values.getOrderByElements(), context); visitLimit(values.getLimit(), context); @@ -2084,6 +2499,7 @@ public Void visit(Values values, S context) { if (values.getFetch() != null) { values.getFetch().getExpression().accept(this, context); } + leaveWithItems(values.getWithItemsList()); return null; } @@ -2111,6 +2527,9 @@ public void visit(DescribeStatement describe) { public Void visit(ExplainStatement explainStatement, S context) { if (explainStatement.getStatement() != null) { explainStatement.getStatement().accept((StatementVisitor) this, context); + } else if (explainStatement.getTable() != null) { + // EXPLAIN table describes it, as DESCRIBE table does + explainStatement.getTable().accept(this, context); } return null; } @@ -2149,6 +2568,9 @@ public Void visit(SimilarToExpression expr, S context) { @Override public Void visit(DeclareStatement declareStatement, S context) { + for (DeclareStatement.TypeDefExpr typeDefExpr : declareStatement.getTypeDefExprList()) { + visitExpression(typeDefExpr.getDefaultExpr(), context); + } return null; } @@ -2171,7 +2593,7 @@ public void visit(Grant grant) { @Override public Void visit(ArrayExpression array, S context) { array.getObjExpression().accept(this, context); - if (array.getStartIndexExpression() != null) { + if (array.getIndexExpression() != null) { array.getIndexExpression().accept(this, context); } if (array.getStartIndexExpression() != null) { @@ -2180,6 +2602,9 @@ public Void visit(ArrayExpression array, S context) { if (array.getStopIndexExpression() != null) { array.getStopIndexExpression().accept(this, context); } + if (array.getStepExpression() != null) { + array.getStepExpression().accept(this, context); + } return null; } @@ -2230,7 +2655,11 @@ public void visit(AlterSequence alterSequence) { @Override public Void visit(CreateFunctionalStatement createFunctionalStatement, S context) { - throwUnsupported(createFunctionalStatement); + // a MySQL loadable function names a shared library and no table + if (!(createFunctionalStatement instanceof CreateFunction) + || ((CreateFunction) createFunctionalStatement).getLoadableFunction() == null) { + throwUnsupported(createFunctionalStatement); + } return null; } @@ -2250,6 +2679,43 @@ public void visit(ShowTablesStatement showTables) { StatementVisitor.super.visit(showTables); } + @Override + public Void visit(ShowTableStatusStatement showTableStatus, S context) { + // reads the status of the tables of a database, but names no table + return null; + } + + @Override + public void visit(ShowTableStatusStatement showTableStatus) { + StatementVisitor.super.visit(showTableStatus); + } + + @Override + public Void visit(ShowCreateStatement showCreate, S context) { + ShowCreateStatement.ObjectType type = showCreate.getObjectType(); + if ((type == ShowCreateStatement.ObjectType.TABLE + || type == ShowCreateStatement.ObjectType.VIEW) && showCreate.getName() != null) { + visit(showCreate.getName(), context); + } + return null; + } + + @Override + public void visit(ShowCreateStatement showCreate) { + StatementVisitor.super.visit(showCreate); + } + + @Override + public Void visit(MySqlShowStatement mySqlShow, S context) { + // reads server settings, state or object lists, but names no table + return null; + } + + @Override + public void visit(MySqlShowStatement mySqlShow) { + StatementVisitor.super.visit(mySqlShow); + } + @Override public Void visit(TSQLLeftJoin tsqlLeftJoin, S context) { visitBinaryExpression(tsqlLeftJoin); @@ -2278,6 +2744,16 @@ public Void visit(LambdaExpression lambdaExpression, S context) { return null; } + @Override + public Void visit(ListComprehension listComprehension, S context) { + listComprehension.getExpression().accept(this, context); + listComprehension.getList().accept(this, context); + if (listComprehension.getCondition() != null) { + listComprehension.getCondition().accept(this, context); + } + return null; + } + @Override public Void visit(ColumnsExpression columnsExpression, S context) { for (Expression expression : columnsExpression.getAllExpressions()) { @@ -2354,6 +2830,9 @@ public void visit(CreateSynonym createSynonym) { @Override public Void visit(TimezoneExpression timezoneExpression, S context) { timezoneExpression.getLeftExpression().accept(this, context); + for (Expression timezone : timezoneExpression.getTimezoneExpressions()) { + visitExpression(timezone, context); + } return null; } @@ -2395,11 +2874,21 @@ public Void visit(JsonAggregateFunction expression, S context) { if (expr != null) { expr.accept(this, context); } + if (expression.getKey() instanceof Expression) { + ((Expression) expression.getKey()).accept(this, context); + } + if (expression.getValue() instanceof Expression) { + ((Expression) expression.getValue()).accept(this, context); + } + visitOrderBy(expression.getExpressionOrderByElements(), context); expr = expression.getFilterExpression(); if (expr != null) { expr.accept(this, context); } + visitExpressions(expression.getPartitionExpressionList(), context); + visitOrderBy(expression.getOrderByElements(), context); + visitWindowElement(expression.getWindowElement(), context); return null; } @@ -2484,6 +2973,7 @@ public Void visit(KeyExpression keyExpression, S context) { @Override public Void visit(IfElseStatement ifElseStatement, S context) { + ifElseStatement.getCondition().accept(this, context); ifElseStatement.getIfStatement().accept(this, context); if (ifElseStatement.getElseStatement() != null) { ifElseStatement.getElseStatement().accept(this, context); @@ -2584,6 +3074,17 @@ public Void visit(LoadDataStatement loadDataStatement, S context) { return null; } + @Override + public Void visit(MySqlLoadDataStatement loadData, S context) { + visitTargetTable(loadData.getTable(), context); + if (loadData.getUpdateSets() != null) { + for (UpdateSet updateSet : loadData.getUpdateSets()) { + updateSet.getValues().accept(this, context); + } + } + return null; + } + @Override public void visit(AttachStatement attachStatement) { StatementVisitor.super.visit(attachStatement); @@ -2624,7 +3125,13 @@ public void visit(DisconnectStatement disconnectStatement) { @Override public Void visit(PrepareStatement prepareStatement, S context) { - prepareStatement.getStatement().accept(this, context); + Statement statement = prepareStatement.getStatement(); + if (statement == null) { + // the tables of a statement held in a string or a variable are unknown + throwUnsupported(prepareStatement); + } else { + statement.accept(this, context); + } return null; } @@ -2661,8 +3168,10 @@ public void visit(CopyStatement copyStatement) { @Override public Void visit(CreateMacro createMacro, S context) { - if (createMacro.getSelect() != null) { - createMacro.getSelect().accept((SelectVisitor) this, context); + for (CreateMacro.Overload overload : createMacro.getOverloads()) { + if (overload.getSelect() != null) { + overload.getSelect().accept((SelectVisitor) this, context); + } } return null; } @@ -2688,6 +3197,11 @@ public void visit(LoadDataStatement loadDataStatement) { StatementVisitor.super.visit(loadDataStatement); } + @Override + public void visit(MySqlLoadDataStatement loadData) { + StatementVisitor.super.visit(loadData); + } + @Override public Void visit(PurgeStatement purgeStatement, S context) { if (purgeStatement.getPurgeObjectType() == PurgeObjectType.TABLE) { @@ -2764,6 +3278,65 @@ public void visit(LockStatement lock) { StatementVisitor.super.visit(lock); } + @Override + public Void visit(UnlockStatement unlock, S context) { + // UNLOCK TABLES releases every table lock of the session without naming a table + return null; + } + + @Override + public Void visit(BackupLockStatement backupLock, S context) { + return null; + } + + @Override + public Void visit(ChangeReplicationSourceStatement changeReplicationSource, S context) { + return null; + } + + @Override + public Void visit(ChangeReplicationFilterStatement changeReplicationFilter, S context) { + // the tables that REPLICATE_DO_TABLE and REPLICATE_IGNORE_TABLE name + for (ReplicationFilter filter : changeReplicationFilter.getFilters()) { + filter.getTables().forEach(table -> table.accept(this, context)); + } + return null; + } + + @Override + public Void visit(StartReplicaStatement startReplica, S context) { + return null; + } + + @Override + public Void visit(StopReplicaStatement stopReplica, S context) { + return null; + } + + @Override + public Void visit(ResetReplicationStatement resetReplication, S context) { + return null; + } + + @Override + public Void visit(DeclareCursorStatement declareCursor, S context) { + if (declareCursor.getQuery() != null) { + visit(declareCursor.getQuery(), context); + } + return null; + } + + @Override + public Void visit(FetchCursorStatement fetchCursor, S context) { + // FETCH and MOVE name a cursor, not a table + return null; + } + + @Override + public Void visit(CloseCursorStatement closeCursor, S context) { + return null; + } + @Override public Void visit(CreatePolicy createPolicy, S context) { if (createPolicy.getTable() != null) { @@ -2912,4 +3485,296 @@ public Void visit(OracleNullStatement statement, S context) { return null; } + @Override + public Void visit(AlterRelation statement, S context) { + if (statement.getObjectType() != AlterRelation.ObjectType.INDEX) { + visit(statement.getRelation(), context); + } + statement.getActions().forEach(action -> { + action.visitExpressions(expression -> expression.accept(this, context)); + action.visitTables(table -> visit(table, context)); + }); + return null; + } + + @Override + public Void visit(AlterDatabase statement, S context) { + return null; + } + + @Override + public Void visit(AlterTablespaceMove statement, S context) { + return null; + } + + @Override + public Void visit(CreateTablespace statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(CreateSpatialReferenceSystem statement, S context) { + return null; + } + + @Override + public Void visit(AlterInstance statement, S context) { + return null; + } + + @Override + public Void visit(AlterTablespace statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(AlterPolicy statement, S context) { + visit(statement.getTable(), context); + statement.getOptions().visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(DropPolicy statement, S context) { + visit(statement.getTable(), context); + return null; + } + + @Override + public Void visit(CreateStatistics statement, S context) { + visit(statement.getTable(), context); + statement.getExpressions().accept(this, context); + return null; + } + + @Override + public Void visit(AlterStatistics statement, S context) { + return null; + } + + @Override + public Void visit(CreateForeignDataWrapper statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(AlterForeignDataWrapper statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(CreateServer statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(AlterServer statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(CreateUserMapping statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(AlterUserMapping statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(ImportForeignSchema statement, S context) { + // LIMIT TO and EXCEPT name tables of the remote schema, not relations of this database. + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(DropUserMapping statement, S context) { + // User and server names do not refer to tables. + return null; + } + + @Override + public Void visit(CreateAccessMethod statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchConfiguration statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchConfiguration statement, S context) { + return null; + } + + @Override + public Void visit(CreateRule statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + statement.visitTables(table -> visit(table, context)); + statement.getActions().forEach(action -> action.accept(this, context)); + return null; + } + + @Override + public Void visit(NotifyStatement statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(ListenStatement listen, S context) { + // a notification channel is no table + return null; + } + + @Override + public Void visit(DiscardStatement discard, S context) { + // DISCARD TEMP drops the temporary tables of the session without naming one + return null; + } + + @Override + public Void visit(CreateCollation statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(AlterCollation statement, S context) { + return null; + } + + @Override + public Void visit(AlterRoutine statement, S context) { + statement.visitExpressions(expression -> expression.accept(this, context)); + return null; + } + + @Override + public Void visit(AlterTrigger statement, S context) { + visit(statement.getTable(), context); + return null; + } + + @Override + public Void visit(AlterRule statement, S context) { + visit(statement.getTable(), context); + return null; + } + + @Override + public Void visit(CreateCast statement, S context) { + return null; + } + + @Override + public Void visit(CreateOperator statement, S context) { + return null; + } + + @Override + public Void visit(CreateTransform statement, S context) { + return null; + } + + @Override + public Void visit(CreateOperatorClass statement, S context) { + return null; + } + + @Override + public Void visit(CreateConversion statement, S context) { + return null; + } + + @Override + public Void visit(CreateOperatorFamily statement, S context) { + return null; + } + + @Override + public Void visit(AlterConversion statement, S context) { + return null; + } + + @Override + public Void visit(CreateAggregate statement, S context) { + return null; + } + + @Override + public Void visit(AlterOperator statement, S context) { + return null; + } + + @Override + public Void visit(AlterOperatorClass statement, S context) { + return null; + } + + @Override + public Void visit(AlterOperatorFamily statement, S context) { + return null; + } + + @Override + public Void visit(AlterAggregate statement, S context) { + return null; + } + + @Override + public Void visit(CreateLanguage statement, S context) { + return null; + } + + @Override + public Void visit(AlterLanguage statement, S context) { + return null; + } + + @Override + public Void visit(AlterLargeObject statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchDictionary statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchDictionary statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchParser statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchParser statement, S context) { + return null; + } + + @Override + public Void visit(CreateTextSearchTemplate statement, S context) { + return null; + } + + @Override + public Void visit(AlterTextSearchTemplate statement, S context) { + return null; + } } 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 e162f0ec8a..3164b31ecd 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/AlterDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/AlterDeParser.java @@ -10,13 +10,14 @@ package net.sf.jsqlparser.util.deparser; import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterForeignDataOptions; import net.sf.jsqlparser.expression.ExpressionVisitor; import net.sf.jsqlparser.statement.alter.AlterExpression; import net.sf.jsqlparser.statement.alter.AlterExpressionPartition; import net.sf.jsqlparser.statement.alter.AlterExpressionPrimaryKey; -import net.sf.jsqlparser.statement.alter.AlterOperation; +import net.sf.jsqlparser.statement.alter.RelationAlterAction; import net.sf.jsqlparser.statement.select.PlainSelect; -import java.util.Iterator; +import net.sf.jsqlparser.statement.create.table.IndexOptionSource; public class AlterDeParser extends AbstractDeParser { private final ExpressionVisitor expressionVisitor; @@ -32,24 +33,38 @@ public AlterDeParser(StringBuilder buffer, ExpressionVisitor expr @Override public void deParse(Alter alter) { - builder.append("ALTER TABLE "); - if (alter.isUseOnly()) { - builder.append("ONLY "); - } - if (alter.isUseTableIfExists()) { - builder.append("IF EXISTS "); - } - builder.append(alter.getTable().getFullyQualifiedName()).append(' '); - for (Iterator iterator = alter.getAlterExpressions().iterator(); iterator - .hasNext();) { - deParseAction(iterator.next()); - if (iterator.hasNext()) { - builder.append(", "); + alter.appendTargetTo(builder); + boolean first = true; + for (AlterExpression action : alter.getAlterExpressions()) { + if (!first) { + builder.append(Alter.separatorBefore(action)); } + deParseAction(action); + first = false; } } 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)); + return; + } + if (action instanceof net.sf.jsqlparser.statement.alter.AlterExpressionOrderBy) { + ((net.sf.jsqlparser.statement.alter.AlterExpressionOrderBy) action).appendTo(builder, + expression -> expression.accept(expressionVisitor, null)); + return; + } + if (action instanceof RelationAlterAction) { + ((RelationAlterAction) action).appendTo(builder, + expression -> expression.accept(expressionVisitor, null)); + return; + } if (action instanceof AlterExpressionPartition) { ((AlterExpressionPartition) action).appendTo(builder, expression -> expression.accept(expressionVisitor, null)); @@ -60,10 +75,10 @@ private void deParseAction(AlterExpression action) { expression -> expression.accept(expressionVisitor, null)); return; } - if (action.getOperation() == AlterOperation.ADD && action.getIndex() != null - && action.getConstraintType() == null) { + if (action.hasActiveTableDefinition()) { builder.append(action.getOperation()).append(' '); - new TableElementDeParser(builder, expressionVisitor).deParse(action.getIndex()); + new TableElementDeParser(builder, expressionVisitor).deParse( + action.getConstraint() != null ? action.getConstraint() : action.getIndex()); if (action.getConstraints() != null && !action.getConstraints().isEmpty()) { builder.append(' ') .append(PlainSelect.getStringList(action.getConstraints(), false, false)); @@ -74,14 +89,12 @@ private void deParseAction(AlterExpression action) { deParseTail(action); return; } - if (action.getOperation() == net.sf.jsqlparser.statement.alter.AlterOperation.ALTER - && action.getColumnSetDefaultList() != null - && !action.getColumnSetDefaultList().isEmpty()) { + if (!action.getColumnDefaults().isEmpty()) { action.appendColumnActionTo(builder, expression -> expression.accept(expressionVisitor, null)); return; } - if (action.getColDataTypeList() != null) { + if (action.hasActiveColumnDefinitions()) { action.appendColumnDefinitionsTo(builder, expression -> expression.accept(expressionVisitor, null)); } else { @@ -94,8 +107,11 @@ private void deParseTail(AlterExpression action) { builder.append(' ') .append(PlainSelect.getStringList(action.getParameters(), false, false)); } - if (action.getIndex() != null && action.getIndex().getCommentText() != null) { - builder.append(" COMMENT ").append(action.getIndex().getCommentText()); + IndexOptionSource options = action.getConstraint() instanceof IndexOptionSource + ? (IndexOptionSource) action.getConstraint() + : action.getIndex(); + if (options != null && options.getIndexOptions().getCommentText() != null) { + builder.append(" COMMENT ").append(options.getIndexOptions().getCommentText()); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/AlterSequenceDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/AlterSequenceDeParser.java index b9c743bdce..f857a5caf1 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/AlterSequenceDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/AlterSequenceDeParser.java @@ -26,7 +26,6 @@ public AlterSequenceDeParser(StringBuilder buffer) { @Override public void deParse(AlterSequence statement) { - builder.append("ALTER SEQUENCE "); - builder.append(statement.getSequence()); + statement.appendTo(builder); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/AlterViewDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/AlterViewDeParser.java index 3c1c0bbaa2..514f6f6a07 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/AlterViewDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/AlterViewDeParser.java @@ -37,6 +37,7 @@ public void deParse(AlterView alterView) { } else { builder.append("ALTER "); } + alterView.appendMySqlOptionsTo(builder); builder.append("VIEW ").append(alterView.getView().getFullyQualifiedName()); if (alterView.getColumnNames() != null) { builder.append(PlainSelect.getStringList(alterView.getColumnNames(), true, true)); @@ -44,6 +45,7 @@ public void deParse(AlterView alterView) { builder.append(" AS "); alterView.getSelect().accept(selectVisitor, null); + alterView.appendCheckOptionTo(builder); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/CreatePolicyDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/CreatePolicyDeParser.java index a470990bfa..4d604494ec 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/CreatePolicyDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/CreatePolicyDeParser.java @@ -31,31 +31,6 @@ public CreatePolicyDeParser(ExpressionVisitor expressionVisitor, @Override public void deParse(CreatePolicy createPolicy) { - builder.append("CREATE POLICY ").append(createPolicy.getPolicyName()); - builder.append(" ON ").append(createPolicy.getTable()); - - if (createPolicy.getPolicyMode() != null) { - builder.append(" AS ").append(createPolicy.getPolicyMode()); - } - - if (createPolicy.getPolicyCommand() != null) { - builder.append(" FOR ").append(createPolicy.getPolicyCommand()); - } - - if (createPolicy.getRoles() != null && !createPolicy.getRoles().isEmpty()) { - builder.append(" TO ").append(String.join(", ", createPolicy.getRoles())); - } - - if (createPolicy.getUsingExpression() != null) { - builder.append(" USING ("); - createPolicy.getUsingExpression().accept(expressionVisitor, null); - builder.append(")"); - } - - if (createPolicy.getWithCheckExpression() != null) { - builder.append(" WITH CHECK ("); - createPolicy.getWithCheckExpression().accept(expressionVisitor, null); - builder.append(")"); - } + createPolicy.appendTo(builder, expression -> expression.accept(expressionVisitor, null)); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/CreateSequenceDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/CreateSequenceDeParser.java index d4f4750987..f2b1859dc2 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/CreateSequenceDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/CreateSequenceDeParser.java @@ -26,7 +26,6 @@ public CreateSequenceDeParser(StringBuilder buffer) { @Override public void deParse(CreateSequence statement) { - builder.append("CREATE SEQUENCE "); - builder.append(statement.getSequence()); + statement.appendTo(builder); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/CreateTableDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/CreateTableDeParser.java index 2d26b7a108..5348e4b9ab 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/CreateTableDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/CreateTableDeParser.java @@ -10,11 +10,11 @@ package net.sf.jsqlparser.util.deparser; import java.util.Iterator; +import java.util.ArrayList; +import java.util.List; import net.sf.jsqlparser.schema.Table; -import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.CreateTable; -import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.statement.create.table.TableElement; import net.sf.jsqlparser.statement.select.PlainSelect; @@ -74,38 +74,31 @@ public void deParse(CreateTable createTable) { } builder.append(")"); } - if (createTable.getTableElements() != null) { - builder.append(" ("); - for (Iterator iter = createTable.getTableElements().iterator(); iter - .hasNext();) { - elements.deParse(iter.next()); - if (iter.hasNext()) { - builder.append(", "); - } + List definitions = createTable.getTableElements(); + if (definitions == null) { + definitions = new ArrayList<>(); + if (createTable.getColumnDefinitions() != null) { + definitions.addAll(createTable.getColumnDefinitions()); } - builder.append(")"); - } else if (createTable.getColumnDefinitions() != null) { - builder.append(" ("); - for (Iterator iter = - createTable.getColumnDefinitions().iterator(); iter.hasNext();) { - ColumnDefinition columnDefinition = iter.next(); - elements.deParse(columnDefinition); - - if (iter.hasNext()) { - builder.append(", "); - } + if (createTable.getTableConstraints() != null) { + definitions.addAll(createTable.getTableConstraints()); } - if (createTable.getIndexes() != null) { - for (Index index : createTable.getIndexes()) { + definitions.addAll(createTable.getIndexes()); + } + } + if (createTable.getTableElements() != null || !definitions.isEmpty()) { + builder.append(" ("); + for (Iterator iter = definitions.iterator(); iter.hasNext();) { + elements.deParse(iter.next()); + if (iter.hasNext()) { builder.append(", "); - elements.deParse(index); } } - builder.append(")"); } + createTable.appendInheritanceTo(builder); if (createTable.getPartitionBound() != null) { builder.append(' '); createTable.getPartitionBound().appendTo(builder, @@ -113,11 +106,15 @@ public void deParse(CreateTable createTable) { null)); } - params = PlainSelect.getStringList(createTable.getTableOptionsStrings(), false, false); - if (!"".equals(params)) { - builder.append(' ').append(params); + if (createTable.getPartitioning() != null && createTable.isTableOptionsAfterPartition()) { + builder.append(' '); + createTable.getPartitioning().appendTo(builder, + expression -> expression.accept(statementDeParser.getExpressionDeParser(), + null)); } - if (createTable.getPartitioning() != null) { + createTable.appendTableOptionsTo(builder, + expression -> expression.accept(statementDeParser.getExpressionDeParser(), null)); + if (createTable.getPartitioning() != null && !createTable.isTableOptionsAfterPartition()) { builder.append(' '); createTable.getPartitioning().appendTo(builder, expression -> expression.accept(statementDeParser.getExpressionDeParser(), @@ -128,7 +125,8 @@ public void deParse(CreateTable createTable) { builder.append(' ').append(createTable.getRowMovement().getMode().toString()) .append(" ROW MOVEMENT"); } - createTable.appendSelectTo(builder, select -> select.accept(this.statementDeParser, null)); + createTable.appendQueryTo(builder, select -> select.accept(this.statementDeParser, null), + execute -> execute.accept(this.statementDeParser, null)); if (createTable.getTrailingLikeTable() != null) { builder.append(" LIKE "); if (createTable.isSelectParenthesis()) { diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/CreateViewDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/CreateViewDeParser.java index 432ef52b91..e2c34e5318 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/CreateViewDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/CreateViewDeParser.java @@ -41,6 +41,7 @@ public void deParse(CreateView createView) { if (createView.isOrReplace()) { builder.append("OR REPLACE "); } + createView.appendMySqlOptionsTo(builder); switch (createView.getForce()) { case FORCE: builder.append("FORCE "); diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/DeleteDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/DeleteDeParser.java index 23b3f8f601..5ffa172fff 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/DeleteDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/DeleteDeParser.java @@ -59,8 +59,9 @@ public void deParse(Delete delete) { builder.append(" IGNORE"); } if (delete.getTables() != null && !delete.getTables().isEmpty()) { + // with their aliases, as in Delete.toString() builder.append( - delete.getTables().stream().map(Table::getFullyQualifiedName) + delete.getTables().stream().map(Table::toString) .collect(joining(", ", " ", ""))); } @@ -71,11 +72,12 @@ public void deParse(Delete delete) { if (delete.isHasFrom()) { builder.append(" FROM"); } - builder.append(" ").append(delete.getTable().toString()); + delete.getTableReference().appendWithAliasTo(builder.append(" ")); deparseForPortionClause(delete.getForPortionClause(), expressionVisitor); - sources.deparseUsing(delete.getUsingFromItemList()); + // the target's joins come before USING, as in the grammar sources.deparseJoins(delete.getJoins()); + sources.deparseUsing(delete.getUsingFromItemList(), delete.getUsingJoins()); deparseWhereClause(delete); @@ -98,7 +100,9 @@ public void deParse(Delete delete) { } protected void deparseWhereClause(Delete delete) { - if (delete.getWhere() != null) { + if (delete.getCursorName() != null) { + builder.append(" WHERE CURRENT OF ").append(delete.getCursorName()); + } else if (delete.getWhere() != null) { builder.append(" WHERE "); delete.getWhere().accept(expressionVisitor, null); } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/DmlDeParserSupport.java b/src/main/java/net/sf/jsqlparser/util/deparser/DmlDeParserSupport.java index 13138db4d4..e0c2306527 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/DmlDeParserSupport.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/DmlDeParserSupport.java @@ -70,6 +70,11 @@ void deparseFrom(FromItem item, List joins) { } void deparseUsing(List items) { + deparseUsing(items, null); + } + + /** Renders {@code USING item, ...} followed by the joins of these items. */ + void deparseUsing(List items, List joins) { if (items != null && !items.isEmpty()) { builder.append(" USING "); for (int i = 0; i < items.size(); i++) { @@ -78,6 +83,7 @@ void deparseUsing(List items) { } items.get(i).accept(selects, null); } + deparseJoins(joins); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java index de8e6ad6e1..677e38402b 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java @@ -9,13 +9,12 @@ */ package net.sf.jsqlparser.util.deparser; -import net.sf.jsqlparser.expression.AliasedExpression; - import static java.util.stream.Collectors.joining; import java.util.Iterator; import java.util.List; import java.util.Map; +import net.sf.jsqlparser.expression.AliasedExpression; import net.sf.jsqlparser.expression.AllValue; import net.sf.jsqlparser.expression.AnalyticExpression; import net.sf.jsqlparser.expression.AnalyticType; @@ -42,7 +41,6 @@ import net.sf.jsqlparser.expression.HexValue; import net.sf.jsqlparser.expression.HighExpression; import net.sf.jsqlparser.expression.IntervalExpression; -import net.sf.jsqlparser.expression.RowPatternFunction; import net.sf.jsqlparser.expression.Inverse; import net.sf.jsqlparser.expression.JdbcNamedParameter; import net.sf.jsqlparser.expression.JdbcParameter; @@ -53,9 +51,11 @@ import net.sf.jsqlparser.expression.KeepExpression; import net.sf.jsqlparser.expression.KeyExpression; import net.sf.jsqlparser.expression.LambdaExpression; +import net.sf.jsqlparser.expression.ListComprehension; import net.sf.jsqlparser.expression.LongValue; import net.sf.jsqlparser.expression.LowExpression; import net.sf.jsqlparser.expression.MapExpression; +import net.sf.jsqlparser.expression.MethodCallExpression; import net.sf.jsqlparser.expression.MySQLGroupConcat; import net.sf.jsqlparser.expression.NextValExpression; import net.sf.jsqlparser.expression.NotExpression; @@ -69,7 +69,7 @@ import net.sf.jsqlparser.expression.RangeExpression; import net.sf.jsqlparser.expression.RowConstructor; import net.sf.jsqlparser.expression.RowGetExpression; -import net.sf.jsqlparser.expression.MethodCallExpression; +import net.sf.jsqlparser.expression.RowPatternFunction; import net.sf.jsqlparser.expression.SignedExpression; import net.sf.jsqlparser.expression.StringValue; import net.sf.jsqlparser.expression.StructType; @@ -94,6 +94,7 @@ import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor; import net.sf.jsqlparser.expression.operators.arithmetic.Concat; import net.sf.jsqlparser.expression.operators.arithmetic.Division; +import net.sf.jsqlparser.expression.operators.arithmetic.Exponentiation; import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision; import net.sf.jsqlparser.expression.operators.arithmetic.Modulo; import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; @@ -119,9 +120,10 @@ import net.sf.jsqlparser.expression.operators.relational.Intersects; import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression; import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression; +import net.sf.jsqlparser.expression.operators.relational.IsJsonExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression; import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; import net.sf.jsqlparser.expression.operators.relational.IsUnknownExpression; -import net.sf.jsqlparser.expression.operators.relational.IsJsonExpression; import net.sf.jsqlparser.expression.operators.relational.JsonOperator; import net.sf.jsqlparser.expression.operators.relational.LikeExpression; import net.sf.jsqlparser.expression.operators.relational.Matches; @@ -149,6 +151,7 @@ import net.sf.jsqlparser.statement.select.Select; import net.sf.jsqlparser.statement.select.SelectItem; import net.sf.jsqlparser.statement.select.SelectVisitor; +import net.sf.jsqlparser.statement.select.Values; import net.sf.jsqlparser.statement.select.WithItem; @SuppressWarnings({"PMD.CyclomaticComplexity"}) @@ -225,7 +228,7 @@ public StringBuilder visit(OverlapsCondition overlapsCondition, S context) { @Override public StringBuilder visit(EqualsTo equalsTo, S context) { - deparse(equalsTo, " = ", context); + deparse(equalsTo, " " + equalsTo.getStringExpression() + " ", context); return builder; } @@ -241,6 +244,12 @@ public StringBuilder visit(IntegerDivision division, S context) { return builder; } + @Override + public StringBuilder visit(Exponentiation exponentiation, S context) { + deparse(exponentiation, " ** ", context); + return builder; + } + @Override public StringBuilder visit(DoubleValue doubleValue, S context) { builder.append(doubleValue.toString()); @@ -425,7 +434,12 @@ public StringBuilder visit(FullTextSearch fullTextSearch, S context) { @Override public StringBuilder visit(SignedExpression signedExpression, S context) { builder.append(signedExpression.getSign()); + int operandStart = builder.length(); signedExpression.getExpression().accept(this, context); + if (builder.length() > operandStart + && signedExpression.needsSpaceBefore(builder.charAt(operandStart))) { + builder.insert(operandStart, ' '); + } return builder; } @@ -519,10 +533,14 @@ public StringBuilder visit(LikeExpression likeExpression, S context) { } likeExpression.getLeftExpression().accept(this, context); builder.append(" "); - if (likeExpression.isNot()) { - builder.append("NOT "); + if (likeExpression.getLikeOperator() != null) { + builder.append(likeExpression.getLikeOperator()).append(" "); + } else { + if (likeExpression.isNot()) { + builder.append("NOT "); + } + builder.append(keywordStr).append(" "); } - builder.append(keywordStr).append(" "); if (likeExpression.isUseBinary()) { builder.append("BINARY "); } @@ -591,6 +609,12 @@ public void visit(IsBooleanExpression isBooleanExpression) { visit(isBooleanExpression, null); } + @Override + public StringBuilder visit(IsNormalizedExpression isNormalizedExpression, S context) { + return isNormalizedExpression.appendTo(builder, + expression -> expression.accept(this, context)); + } + public void visit(IsUnknownExpression isUnknownExpression) { visit(isUnknownExpression, null); } @@ -698,6 +722,10 @@ public StringBuilder visit(StringValue stringValue, S context) { } builder.append(stringValue.getQuoteStr()).append(stringValue.getValue()) .append(stringValue.getQuoteStr()); + if (stringValue.getUnicodeEscapeCharacter() != null) { + builder.append(" UESCAPE '").append(stringValue.getUnicodeEscapeCharacter()) + .append('\''); + } return builder; } @@ -726,7 +754,9 @@ protected void deparse(BinaryExpression binaryExpression, @Override public StringBuilder visit(Select select, S context) { if (selectVisitor != null) { - if (select.getWithItemsList() != null) { + // ValuesStatementDeParser owns WITH rendering when using SelectDeParser. + if (select.getWithItemsList() != null + && !(select instanceof Values && selectVisitor instanceof SelectDeParser)) { builder.append("WITH "); for (Iterator> iter = select.getWithItemsList().iterator(); iter .hasNext();) { @@ -841,12 +871,27 @@ public void visit(TrimFunction trimFunction) { @Override public StringBuilder visit(RangeExpression rangeExpression, S context) { - rangeExpression.getStartExpression().accept(this, context); - builder.append(":"); - rangeExpression.getEndExpression().accept(this, context); + appendSlice(rangeExpression.getStartExpression(), rangeExpression.getEndExpression(), + rangeExpression.getStepExpression(), context); return builder; } + private void appendSlice(Expression start, Expression end, Expression step, S context) { + if (start != null) { + start.accept(this, context); + } + builder.append(":"); + if (end != null) { + end.accept(this, context); + } else if (step != null) { + builder.append("-"); + } + if (step != null) { + builder.append(":"); + step.accept(this, context); + } + } + @Override public StringBuilder visit(TernaryExpression ternaryExpression, S context) { ternaryExpression.getCondition().accept(this, context); @@ -929,6 +974,7 @@ public StringBuilder visit(Function function, S context) { if (function.getParameters() != null) { function.getParameters().accept(this, context); } + function.appendCastTypeTo(builder); Function.HavingClause havingClause = function.getHavingClause(); if (havingClause != null) { @@ -1178,7 +1224,7 @@ public StringBuilder visit(CastExpression cast, S context) { cast.getLeftExpression().accept(this, context); builder.append(" AS "); builder.append( - cast.getColumnDefinitions().size() > 1 + !cast.getColumnDefinitions().isEmpty() ? "ROW(" + Select.getStringList(cast.getColumnDefinitions()) + ")" : cast.getColDataType().toString()); builder.append(formatStr); @@ -1312,6 +1358,9 @@ public StringBuilder visit(AnalyticExpression analyticExpression, S context) builder.append(" ").append(analyticExpression.getWindowName()); } else if (analyticExpression.getType() != AnalyticType.WITHIN_GROUP_OVER) { builder.append(" ("); + if (analyticExpression.getWindowDefinition() != null) { + analyticExpression.getWindowDefinition().appendBaseWindowNameTo(builder); + } if (partitionExpressionList != null && !partitionExpressionList.isEmpty()) { @@ -1643,13 +1692,8 @@ public StringBuilder visit(ArrayExpression array, S context) { if (array.getIndexExpression() != null) { array.getIndexExpression().accept(this, context); } else { - if (array.getStartIndexExpression() != null) { - array.getStartIndexExpression().accept(this, context); - } - builder.append(":"); - if (array.getStopIndexExpression() != null) { - array.getStopIndexExpression().accept(this, context); - } + appendSlice(array.getStartIndexExpression(), array.getStopIndexExpression(), + array.getStepExpression(), context); } builder.append("]"); @@ -1717,13 +1761,7 @@ public StringBuilder visit(XMLSerializeExpr expr, S context) { @Override public StringBuilder visit(TimezoneExpression var, S context) { - var.getLeftExpression().accept(this, context); - - for (Expression expr : var.getTimezoneExpressions()) { - builder.append(" AT TIME ZONE "); - expr.accept(this, context); - } - return builder; + return var.appendTo(builder, expression -> expression.accept(this, context)); } @Override @@ -1734,14 +1772,12 @@ public StringBuilder visit(JsonAggregateFunction expression, S context) { @Override public StringBuilder visit(JsonFunction expression, S context) { - expression.append(builder); - return builder; + return expression.appendTo(builder, child -> child.accept(this, context)); } @Override public StringBuilder visit(JsonTableFunction expression, S context) { - builder.append(expression); - return builder; + return expression.appendTo(builder, child -> child.accept(this, context)); } @Override @@ -1856,6 +1892,12 @@ public StringBuilder visit(LambdaExpression lambdaExpression, S context) { return lambdaExpression.appendTo(builder, expression -> expression.accept(this, context)); } + @Override + public StringBuilder visit(ListComprehension listComprehension, S context) { + return listComprehension.appendTo(builder, + expression -> expression.accept(this, context)); + } + @Override public StringBuilder visit(ColumnsExpression columnsExpression, S context) { columnsExpression.getColumns().accept(this, context); @@ -1867,11 +1909,23 @@ public StringBuilder visit(ColumnsExpression columnsExpression, S context) { builder.append(")"); break; case EXCEPT: - builder.append(" EXCEPT "); - transformer.getExceptColumns().accept(this, context); + builder.append(" EXCEPT"); + if (transformer.isStrict()) { + builder.append(" STRICT"); + } + builder.append(" "); + if (transformer.getExceptPattern() != null) { + transformer.getExceptPattern().accept(this, context); + } else { + transformer.getExceptColumns().accept(this, context); + } break; case REPLACE: - builder.append(" REPLACE("); + builder.append(" REPLACE"); + if (transformer.isStrict()) { + builder.append(" STRICT"); + } + builder.append("("); boolean first = true; for (SelectItem item : transformer.getReplaceItems()) { if (!first) { diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/InsertDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/InsertDeParser.java index 7abcbc0c57..2e9e5dbb46 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/InsertDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/InsertDeParser.java @@ -9,15 +9,12 @@ */ package net.sf.jsqlparser.util.deparser; -import java.util.Iterator; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.ExpressionVisitor; -import net.sf.jsqlparser.schema.Column; -import net.sf.jsqlparser.schema.Partition; -import net.sf.jsqlparser.statement.insert.ConflictActionType; import net.sf.jsqlparser.statement.insert.Insert; -import net.sf.jsqlparser.statement.insert.OracleMultiInsertBranch; -import net.sf.jsqlparser.statement.insert.OracleMultiInsertClause; import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.statement.select.SelectItem; import net.sf.jsqlparser.statement.select.SelectVisitor; import net.sf.jsqlparser.statement.select.WithItem; @@ -37,127 +34,24 @@ public InsertDeParser(ExpressionVisitor expressionVisitor, this.selectVisitor = selectVisitor; } + /** + * Renders the statement with {@link Insert#appendTo}, the clause layout shared with + * {@link Insert#toString()}, visiting its WITH items, queries, expressions and RETURNING items. + */ @Override - @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.ExcessiveMethodLength", - "PMD.NPathComplexity"}) public void deParse(Insert insert) { - if (insert.getWithItemsList() != null && !insert.getWithItemsList().isEmpty()) { - builder.append("WITH "); - for (Iterator> iter = insert.getWithItemsList().iterator(); iter - .hasNext();) { - WithItem withItem = iter.next(); - withItem.accept(this.selectVisitor, null); - if (iter.hasNext()) { - builder.append(","); - } - builder.append(" "); - } - } - - builder.append("INSERT "); - if (insert.getModifierPriority() != null) { - builder.append(insert.getModifierPriority()).append(" "); - } - if (insert.getOracleHint() != null) { - builder.append(insert.getOracleHint()).append(" "); - } - if (insert.isModifierIgnore()) { - builder.append("IGNORE "); - } - if (insert.isOracleMultiInsert()) { - builder.append(insert.isOracleMultiInsertFirst() ? "FIRST" : "ALL"); - if (insert.getOracleMultiInsertBranches() != null) { - for (OracleMultiInsertBranch branch : insert.getOracleMultiInsertBranches()) { - appendOracleMultiInsertBranch(branch); - } - } - if (insert.getSelect() != null) { - builder.append(" "); - insert.getSelect().accept(selectVisitor, null); - } - return; - } - if (insert.isOverwrite()) { - builder.append("OVERWRITE "); - } else { - builder.append("INTO "); - } - if (insert.isTableKeyword()) { - builder.append("TABLE "); - } - - builder.append(insert.getTable().toString()); - - if (insert.isOnlyDefaultValues()) { - builder.append(" DEFAULT VALUES"); - } - - if (insert.getColumns() != null) { - builder.append(" ("); - for (Iterator iter = insert.getColumns().iterator(); iter.hasNext();) { - Column column = iter.next(); - builder.append(column.getColumnName()); - if (iter.hasNext()) { - builder.append(", "); - } - } - builder.append(")"); - } - - if (insert.getColumnMatching() != null) { - builder.append(" ").append(insert.getColumnMatching()); - } - - if (insert.isOverriding()) { - builder.append(" OVERRIDING ").append(insert.getOverridingMode()).append(" VALUE"); - } - - if (insert.getPartitions() != null) { - builder.append(" PARTITION ("); - Partition.appendPartitionsTo(builder, insert.getPartitions()); - builder.append(")"); - } - - if (insert.getOutputClause() != null) { - builder.append(insert.getOutputClause().toString()); - } - - if (insert.getSelect() != null) { - builder.append(" "); - Select select = insert.getSelect(); - select.accept(selectVisitor, null); - } - - if (insert.getSetUpdateSets() != null) { - builder.append(" SET "); - deparseUpdateSets(insert.getSetUpdateSets(), builder, expressionVisitor); - if (insert.getRowAlias() != null) { - builder.append(" ").append(insert.getRowAlias()); - } - } - - if (insert.getDuplicateAction() != null) { - builder.append(" ON DUPLICATE KEY UPDATE "); - if (ConflictActionType.DO_UPDATE - .equals(insert.getDuplicateAction().getConflictActionType())) { - deparseUpdateSets(insert.getDuplicateUpdateSets(), builder, expressionVisitor); - } else { - insert.getDuplicateAction().appendTo(builder); - } - } - - // @todo: Accept some Visitors for the involved Expressions - if (insert.getConflictAction() != null) { - builder.append(" ON CONFLICT"); - - if (insert.getConflictTarget() != null) { - insert.getConflictTarget().appendTo(builder, - expression -> expression.accept(expressionVisitor, null)); - } - insert.getConflictAction().appendTo(builder); - } - - deparseReturningClause(insert.getReturningClause(), expressionVisitor); + Consumer> withItems = selectVisitor == null ? builder::append + : withItem -> withItem.accept(selectVisitor, null); + Consumer
tablePrinter; + public RefreshMaterializedViewStatementDeParser(StringBuilder buffer) { super(buffer); + this.tablePrinter = table -> builder.append(table); + } + + public RefreshMaterializedViewStatementDeParser(StringBuilder buffer, + Consumer
tablePrinter) { + super(buffer); + this.tablePrinter = tablePrinter; } - @SuppressWarnings("PMD.SwitchStmtsShouldHaveDefault") @Override public void deParse(RefreshMaterializedViewStatement view) { - builder.append("REFRESH MATERIALIZED VIEW "); - if (view.getRefreshMode() == null) { - if (view.isConcurrently()) { - builder.append("CONCURRENTLY "); - } - builder.append(view.getView()); - return; - } - switch (view.getRefreshMode()) { - case WITH_DATA: - if (view.isConcurrently()) { - builder.append("CONCURRENTLY "); - } - builder.append(view.getView()); - builder.append(" WITH DATA"); - break; - case WITH_NO_DATA: - builder.append(view.getView()); - if (view.isConcurrently()) { - builder.append(" WITH NO DATA"); - } - break; - } + view.appendTo(builder, tablePrinter); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ResetStatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ResetStatementDeParser.java index 22eaca518e..b65eabfccf 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/ResetStatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/ResetStatementDeParser.java @@ -24,8 +24,7 @@ public ResetStatementDeParser(ExpressionVisitor expressionVisitor @Override public void deParse(ResetStatement set) { - builder.append("RESET "); - builder.append(set.getName()); + set.appendTo(builder); } public ExpressionVisitor getExpressionVisitor() { diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java index 658a2fe15e..47ea406c22 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java @@ -21,7 +21,6 @@ import net.sf.jsqlparser.expression.Alias; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.ExpressionVisitor; -import net.sf.jsqlparser.expression.MySQLIndexHint; import net.sf.jsqlparser.expression.OracleHint; import net.sf.jsqlparser.expression.SQLServerHints; import net.sf.jsqlparser.expression.WindowDefinition; @@ -51,6 +50,7 @@ import net.sf.jsqlparser.statement.select.Distinct; import net.sf.jsqlparser.statement.select.Fetch; import net.sf.jsqlparser.statement.select.First; +import net.sf.jsqlparser.statement.select.ForUpdateClause; import net.sf.jsqlparser.statement.select.FromItem; import net.sf.jsqlparser.statement.select.FromItemVisitor; import net.sf.jsqlparser.statement.select.InterpolateElement; @@ -71,6 +71,7 @@ import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.SampleClause; import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.statement.select.SelectIntoClause; import net.sf.jsqlparser.statement.select.SelectItem; import net.sf.jsqlparser.statement.select.SelectItemVisitor; import net.sf.jsqlparser.statement.select.SelectVisitor; @@ -233,7 +234,7 @@ public StringBuilder visit(PlainSelect plainSelect, S context) { builder.append(" HAVING "); plainSelect.getHaving().accept(expressionVisitor, context); } - if (plainSelect.getQualify() != null) { + if (plainSelect.getQualify() != null && !plainSelect.isQualifyAfterWindow()) { builder.append(" QUALIFY "); plainSelect.getQualify().accept(expressionVisitor, context); } @@ -242,6 +243,10 @@ public StringBuilder visit(PlainSelect plainSelect, S context) { builder.append(plainSelect.getWindowDefinitions().stream() .map(WindowDefinition::toString).collect(joining(", "))); } + if (plainSelect.getQualify() != null && plainSelect.isQualifyAfterWindow()) { + builder.append(" QUALIFY "); + plainSelect.getQualify().accept(expressionVisitor, context); + } Alias alias = plainSelect.getAlias(); if (alias != null) { builder.append(alias); @@ -309,6 +314,12 @@ public StringBuilder visit(PlainSelect plainSelect, S context) { } else if (plainSelect.isSkipLocked()) { builder.append(" SKIP LOCKED"); } + if (plainSelect.getAdditionalForUpdateClauses() != null) { + for (ForUpdateClause forUpdateClause : plainSelect + .getAdditionalForUpdateClauses()) { + forUpdateClause.appendTo(builder); + } + } } if (plainSelect.isForUpdateBeforeOrderBy()) { @@ -325,9 +336,7 @@ public StringBuilder visit(PlainSelect plainSelect, S context) { if (plainSelect.getForXmlPath() != null) { builder.append(" FOR XML PATH(").append(plainSelect.getForXmlPath()).append(")"); } - if (plainSelect.getIntoTempTable() != null) { - builder.append(" INTO TEMP ").append(plainSelect.getIntoTempTable()); - } + deparseIntoClause(plainSelect, SelectIntoClause.Position.TRAILING, context); if (plainSelect.isUseWithNoLog()) { builder.append(" WITH NO LOG"); } @@ -340,10 +349,6 @@ public StringBuilder visit(PlainSelect plainSelect, S context) { private void deparseSelectClause(PlainSelect plainSelect, S context) { builder.append("SELECT "); - if (plainSelect.getMySqlHintStraightJoin()) { - builder.append("STRAIGHT_JOIN "); - } - OracleHint hint = plainSelect.getOracleHint(); if (hint != null) { builder.append(hint).append(" "); @@ -377,26 +382,18 @@ private void deparseSelectClause(PlainSelect plainSelect, S context) { visit(top); } - if (plainSelect.getMySqlSqlCacheFlag() != null) { - builder.append(plainSelect.getMySqlSqlCacheFlag().name()).append(" "); - } - - if (plainSelect.getMySqlSqlCalcFoundRows()) { - builder.append("SQL_CALC_FOUND_ROWS").append(" "); - } + plainSelect.appendMySqlSelectModifiersTo(builder); + int beforeItems = builder.length(); deparseSelectItemsClause(plainSelect.getSelectItems()); - - if (plainSelect.getIntoTables() != null) { - builder.append(" INTO "); - for (Iterator
iter = plainSelect.getIntoTables().iterator(); iter.hasNext();) { - visit(iter.next(), context); - if (iter.hasNext()) { - builder.append(", "); - } - } + // PostgreSQL permits SELECT with no target expressions: keep "SELECT + // FROM" instead of doubling the space. + if (builder.length() == beforeItems && builder.charAt(beforeItems - 1) == ' ') { + builder.deleteCharAt(beforeItems - 1); } + deparseIntoClause(plainSelect, SelectIntoClause.Position.BEFORE_FROM, context); + deparseMySqlSelectInto(plainSelect, MySqlSelectIntoClause.Position.BEFORE_FROM, context); } @@ -647,10 +644,7 @@ public StringBuilder visit(Table table, S context) { if (unpivot != null) { unpivot.accept(this, context); } - MySQLIndexHint indexHint = table.getIndexHint(); - if (indexHint != null) { - builder.append(indexHint); - } + table.appendIndexHintsTo(builder); SQLServerHints sqlServerHints = table.getSqlServerHints(); if (sqlServerHints != null) { builder.append(sqlServerHints); @@ -760,6 +754,15 @@ private void deparseMySqlSelectInto(PlainSelect select, } } + private void deparseIntoClause(PlainSelect select, SelectIntoClause.Position position, + S context) { + SelectIntoClause into = select.getIntoClause(); + if (into != null && into.getPosition() == position) { + builder.append(' '); + into.appendTo(builder, table -> visit(table, context)); + } + } + @SuppressWarnings({"PMD.CyclomaticComplexity"}) public void deparseJoin(Join join) { if (join.isGlobal()) { @@ -794,18 +797,7 @@ public void deparseJoin(Join join) { builder.append(" ON "); onExpression.accept(expressionVisitor, null); } - if (!join.getUsingColumns().isEmpty()) { - builder.append(" USING ("); - for (Iterator iterator = join.getUsingColumns().iterator(); iterator - .hasNext();) { - Column column = iterator.next(); - builder.append(column.toString()); - if (iterator.hasNext()) { - builder.append(", "); - } - } - builder.append(")"); - } + join.appendUsingTo(builder); } @@ -944,7 +936,7 @@ public StringBuilder visit(ParenthesedFromItem fromItem, S context) { @Override public StringBuilder visit(Values values, S context) { - new ValuesStatementDeParser(expressionVisitor, builder).deParse(values); + new ValuesStatementDeParser(expressionVisitor, this, builder).deParse(values, context); return builder; } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ShowColumnsStatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ShowColumnsStatementDeParser.java index 9fc744010a..1bc8534a53 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/ShowColumnsStatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/ShowColumnsStatementDeParser.java @@ -19,6 +19,6 @@ public ShowColumnsStatementDeParser(StringBuilder buffer) { @Override public void deParse(ShowColumnsStatement show) { - builder.append("SHOW COLUMNS FROM ").append(show.getTableName()); + builder.append(show); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ShowIndexStatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ShowIndexStatementDeParser.java index 1d81d5af6d..97fec7f2ba 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/ShowIndexStatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/ShowIndexStatementDeParser.java @@ -23,7 +23,7 @@ public ShowIndexStatementDeParser(StringBuilder buffer) { @Override public void deParse(ShowIndexStatement show) { - builder.append("SHOW INDEX FROM ").append(show.getTableName()); + show.appendTo(builder, builder::append); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java index 4e82f77daf..6a3bacfcc4 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java @@ -9,6 +9,54 @@ */ package net.sf.jsqlparser.util.deparser; +import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; + +import net.sf.jsqlparser.statement.create.fdw.CreateForeignDataWrapper; +import net.sf.jsqlparser.statement.alter.AlterForeignDataWrapper; +import net.sf.jsqlparser.statement.create.server.CreateServer; +import net.sf.jsqlparser.statement.alter.AlterServer; +import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping; +import net.sf.jsqlparser.statement.alter.AlterUserMapping; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.rule.CreateRule; +import net.sf.jsqlparser.statement.notify.ListenStatement; +import net.sf.jsqlparser.statement.notify.NotifyStatement; +import net.sf.jsqlparser.statement.create.collation.CreateCollation; +import net.sf.jsqlparser.statement.alter.AlterCollation; +import net.sf.jsqlparser.statement.alter.AlterRoutine; +import net.sf.jsqlparser.statement.alter.AlterTrigger; +import net.sf.jsqlparser.statement.alter.AlterPolicy; +import net.sf.jsqlparser.statement.drop.DropPolicy; +import net.sf.jsqlparser.statement.drop.DropUserMapping; +import net.sf.jsqlparser.statement.create.statistics.CreateStatistics; +import net.sf.jsqlparser.statement.alter.AlterStatistics; +import net.sf.jsqlparser.statement.alter.AlterRelation; +import net.sf.jsqlparser.statement.create.operator.CreateOperator; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorClass; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorFamily; +import net.sf.jsqlparser.statement.create.aggregate.CreateAggregate; +import net.sf.jsqlparser.statement.alter.AlterOperator; +import net.sf.jsqlparser.statement.alter.AlterOperatorClass; +import net.sf.jsqlparser.statement.alter.AlterOperatorFamily; +import net.sf.jsqlparser.statement.alter.AlterAggregate; +import net.sf.jsqlparser.statement.alter.AlterRule; +import net.sf.jsqlparser.statement.create.cast.CreateCast; +import net.sf.jsqlparser.statement.create.transform.CreateTransform; +import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterConversion; +import net.sf.jsqlparser.statement.alter.AlterTablespace; +import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; +import net.sf.jsqlparser.statement.alter.database.AlterDatabase; import net.sf.jsqlparser.statement.alter.schema.AlterSchema; import net.sf.jsqlparser.statement.oracle.OracleBlock; import net.sf.jsqlparser.statement.oracle.OracleAssignment; @@ -16,6 +64,7 @@ import net.sf.jsqlparser.statement.role.CreateRole; import net.sf.jsqlparser.statement.role.AlterRole; +import net.sf.jsqlparser.statement.role.ReassignOwned; import net.sf.jsqlparser.statement.grant.Revoke; import net.sf.jsqlparser.statement.grant.AlterDefaultPrivileges; import net.sf.jsqlparser.statement.create.type.CreateType; @@ -31,14 +80,15 @@ import java.lang.reflect.InvocationTargetException; import java.util.List; -import java.util.stream.Collectors; -import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Block; import net.sf.jsqlparser.statement.Commit; +import net.sf.jsqlparser.statement.StartTransaction; +import net.sf.jsqlparser.statement.ReleaseSavepointStatement; import net.sf.jsqlparser.statement.CreateFunctionalStatement; import net.sf.jsqlparser.statement.DeclareStatement; import net.sf.jsqlparser.statement.DescribeStatement; +import net.sf.jsqlparser.statement.DiscardStatement; import net.sf.jsqlparser.statement.DoStatement; import net.sf.jsqlparser.statement.ExplainStatement; import net.sf.jsqlparser.statement.IfElseStatement; @@ -47,7 +97,12 @@ import net.sf.jsqlparser.statement.RollbackStatement; import net.sf.jsqlparser.statement.SavepointStatement; import net.sf.jsqlparser.statement.SessionStatement; +import net.sf.jsqlparser.statement.SetConstraintsStatement; import net.sf.jsqlparser.statement.SetStatement; +import net.sf.jsqlparser.statement.SetDefaultRoleStatement; +import net.sf.jsqlparser.statement.SetPasswordStatement; +import net.sf.jsqlparser.statement.SetRoleStatement; +import net.sf.jsqlparser.statement.SetTransactionStatement; import net.sf.jsqlparser.statement.ShowColumnsStatement; import net.sf.jsqlparser.statement.ShowStatement; import net.sf.jsqlparser.statement.Statement; @@ -55,11 +110,17 @@ import net.sf.jsqlparser.statement.Statements; import net.sf.jsqlparser.statement.UnsupportedStatement; import net.sf.jsqlparser.statement.UseStatement; +import net.sf.jsqlparser.statement.XaStatement; import net.sf.jsqlparser.statement.SetIdentityInsertStatement; +import net.sf.jsqlparser.statement.TableMaintenanceStatement; import net.sf.jsqlparser.statement.alter.Alter; import net.sf.jsqlparser.statement.alter.AlterSession; +import net.sf.jsqlparser.statement.alter.AlterEventTrigger; +import net.sf.jsqlparser.statement.alter.AlterInstance; import net.sf.jsqlparser.statement.alter.AlterSystemStatement; import net.sf.jsqlparser.statement.alter.RenameTableStatement; +import net.sf.jsqlparser.statement.alter.AlterUser; +import net.sf.jsqlparser.statement.alter.RenameUser; import net.sf.jsqlparser.statement.alter.sequence.AlterSequence; import net.sf.jsqlparser.statement.analyze.Analyze; import net.sf.jsqlparser.statement.comment.Comment; @@ -72,6 +133,9 @@ import net.sf.jsqlparser.statement.create.sequence.CreateSequence; import net.sf.jsqlparser.statement.create.synonym.CreateSynonym; import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.spatial.CreateSpatialReferenceSystem; +import net.sf.jsqlparser.statement.create.tablespace.CreateTablespace; +import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger; import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; import net.sf.jsqlparser.statement.create.user.CreateUser; import net.sf.jsqlparser.statement.create.view.AlterView; @@ -81,18 +145,40 @@ import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; import net.sf.jsqlparser.statement.export.Export; +import net.sf.jsqlparser.statement.foreign.ImportForeignSchema; import net.sf.jsqlparser.statement.grant.Grant; import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.InsertBulk; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; +import net.sf.jsqlparser.statement.admin.FlushStatement; +import net.sf.jsqlparser.statement.admin.KillStatement; +import net.sf.jsqlparser.statement.handler.HandlerStatement; +import net.sf.jsqlparser.statement.lock.BackupLockStatement; import net.sf.jsqlparser.statement.lock.LockStatement; +import net.sf.jsqlparser.statement.lock.UnlockStatement; +import net.sf.jsqlparser.statement.replication.ChangeReplicationFilterStatement; +import net.sf.jsqlparser.statement.replication.ChangeReplicationSourceStatement; +import net.sf.jsqlparser.statement.replication.ResetReplicationStatement; +import net.sf.jsqlparser.statement.replication.StartReplicaStatement; +import net.sf.jsqlparser.statement.replication.StopReplicaStatement; +import net.sf.jsqlparser.statement.maintenance.CheckpointStatement; +import net.sf.jsqlparser.statement.maintenance.ClusterStatement; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement; import net.sf.jsqlparser.statement.merge.Merge; import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement; +import net.sf.jsqlparser.statement.reindex.Reindex; +import net.sf.jsqlparser.statement.resourcegroup.AlterResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.CreateResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.SetResourceGroup; +import net.sf.jsqlparser.statement.securitylabel.SecurityLabel; import net.sf.jsqlparser.statement.select.Select; import net.sf.jsqlparser.statement.select.SelectVisitor; import net.sf.jsqlparser.statement.select.WithItem; +import net.sf.jsqlparser.statement.show.MySqlShowStatement; +import net.sf.jsqlparser.statement.show.ShowCreateStatement; import net.sf.jsqlparser.statement.show.ShowIndexStatement; +import net.sf.jsqlparser.statement.show.ShowTableStatusStatement; import net.sf.jsqlparser.statement.show.ShowTablesStatement; import net.sf.jsqlparser.statement.truncate.Truncate; import net.sf.jsqlparser.statement.update.ParenthesedUpdate; @@ -105,13 +191,19 @@ import net.sf.jsqlparser.statement.ConnectStatement; import net.sf.jsqlparser.statement.DisconnectStatement; import net.sf.jsqlparser.statement.PrepareStatement; +import net.sf.jsqlparser.statement.PluginStatement; +import net.sf.jsqlparser.statement.PrepareTransactionStatement; import net.sf.jsqlparser.statement.DeallocateStatement; import net.sf.jsqlparser.statement.CopyStatement; import net.sf.jsqlparser.statement.create.macro.CreateMacro; import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository; +import net.sf.jsqlparser.statement.cursor.CloseCursorStatement; +import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement; +import net.sf.jsqlparser.statement.cursor.FetchCursorStatement; import net.sf.jsqlparser.statement.AssertStatement; import net.sf.jsqlparser.statement.export.ExportDataStatement; import net.sf.jsqlparser.statement.load.LoadDataStatement; +import net.sf.jsqlparser.statement.load.MySqlLoadDataStatement; public class StatementDeParser extends AbstractDeParser implements StatementVisitor { @@ -171,7 +263,8 @@ public StringBuilder visit(CreateIndex createIndex, S context) { @Override public StringBuilder visit(DoStatement statement, S context) { - return statement.appendTo(builder, code -> code.accept(expressionDeParser, context)); + return statement.appendTo(builder, code -> code.accept(expressionDeParser, context), + item -> item.accept(selectDeParser, context)); } @Override @@ -194,6 +287,30 @@ public StringBuilder visit(CreateTrigger createTrigger, S context) { return builder; } + @Override + public StringBuilder visit(CreateEventTrigger statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterEventTrigger statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(Reindex statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(SecurityLabel statement, S context) { + return statement.appendTo(builder, + table -> table.accept(selectDeParser, context), + column -> column.accept(expressionDeParser, context), + label -> label.accept(expressionDeParser, context)); + } + @Override public StringBuilder visit(CreateView createView, S context) { CreateViewDeParser createViewDeParser = new CreateViewDeParser(builder, selectDeParser); @@ -204,7 +321,9 @@ public StringBuilder visit(CreateView createView, S context) { @Override public StringBuilder visit(RefreshMaterializedViewStatement materializedViewStatement, S context) { - new RefreshMaterializedViewStatementDeParser(builder).deParse(materializedViewStatement); + selectDeParser.setBuilder(builder); + new RefreshMaterializedViewStatementDeParser(builder, + table -> table.accept(selectDeParser, context)).deParse(materializedViewStatement); return builder; } @@ -231,6 +350,12 @@ public StringBuilder visit(Drop drop, S context) { return builder; } + @Override + public StringBuilder visit(ReassignOwned statement, S context) { + builder.append(statement); + return builder; + } + @Override public StringBuilder visit(Insert insert, S context) { InsertDeParser insertDeParser = @@ -294,26 +419,7 @@ public StringBuilder visit(Select select, S context) { @Override public StringBuilder visit(Truncate truncate, S context) { - builder.append("TRUNCATE"); - if (truncate.isTableToken()) { - builder.append(" TABLE"); - } - if (truncate.isOnly()) { - builder.append(" ONLY"); - } - builder.append(" "); - if (truncate.getTables() != null && !truncate.getTables().isEmpty()) { - builder.append(truncate.getTables().stream() - .map(Table::toString) - .collect(Collectors.joining(", "))); - } else { - builder.append(truncate.getTable()); - } - if (truncate.getCascade()) { - builder.append(" CASCADE"); - } - - return builder; + return truncate.appendTo(builder); } @Override @@ -325,11 +431,48 @@ public StringBuilder visit(Update update, S context) { return builder; } + @Override public StringBuilder visit(Analyze analyzer, S context) { - builder.append(analyzer); + return analyzer.appendTo(builder); + } + + @Override + public StringBuilder visit(TableMaintenanceStatement statement, S context) { + builder.append(statement); return builder; } + @Override + public StringBuilder visit(FlushStatement flush, S context) { + return flush.appendTo(builder); + } + + @Override + public StringBuilder visit(KillStatement kill, S context) { + return kill.appendTo(builder, id -> id.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(HandlerStatement handler, S context) { + return handler.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(VacuumStatement vacuum, S context) { + return vacuum.appendTo(builder); + } + + @Override + public StringBuilder visit(ClusterStatement cluster, S context) { + return cluster.appendTo(builder); + } + + @Override + public StringBuilder visit(CheckpointStatement checkpoint, S context) { + return checkpoint.appendTo(builder); + } + @Override public StringBuilder visit(Alter alter, S context) { AlterDeParser alterDeParser = new AlterDeParser(builder, expressionDeParser); @@ -386,14 +529,63 @@ public StringBuilder visit(SavepointStatement savepointStatement, S context) @Override public StringBuilder visit(RollbackStatement rollbackStatement, S context) { - builder.append(rollbackStatement.toString()); - return builder; + return rollbackStatement.appendTo(builder); + } + + @Override + public StringBuilder visit(StartTransaction statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(ReleaseSavepointStatement statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(SetTransactionStatement statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(SetConstraintsStatement statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(PrepareTransactionStatement statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(XaStatement statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateResourceGroup statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterResourceGroup statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(SetResourceGroup statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(PluginStatement statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); } @Override public StringBuilder visit(Commit commit, S context) { - builder.append(commit.toString()); - return builder; + return commit.appendTo(builder); } @Override @@ -417,22 +609,40 @@ public StringBuilder visit(UseStatement use, S context) { @Override public StringBuilder visit(ShowColumnsStatement show, S context) { - new ShowColumnsStatementDeParser(builder).deParse(show); - return builder; + return show.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); } @Override public StringBuilder visit(ShowIndexStatement showIndexes, S context) { - new ShowIndexStatementDeParser(builder).deParse(showIndexes); - return builder; + return showIndexes.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); } @Override public StringBuilder visit(ShowTablesStatement showTables, S context) { - new ShowTablesStatementDeparser(builder).deParse(showTables); + return showTables.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(ShowTableStatusStatement showTableStatus, S context) { + return showTableStatus.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(ShowCreateStatement showCreate, S context) { + builder.append(showCreate); return builder; } + @Override + public StringBuilder visit(MySqlShowStatement mySqlShow, S context) { + return mySqlShow.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + @Override public StringBuilder visit(Block block, S context) { return block.appendTo(builder, statements -> statements.accept(this, context)); @@ -448,28 +658,14 @@ public StringBuilder visit(Comment comment, S context) { @Override public StringBuilder visit(DescribeStatement describe, S context) { - builder.append(describe.getDescribeType()); - builder.append(" "); - if (describe.getSelect() != null) { - describe.getSelect().accept(this, context); - } else { - builder.append(describe.getTable()); - } - return builder; + return describe.appendTo(builder, select -> select.accept(this, context), + expression -> expression.accept(expressionDeParser, context)); } @Override public StringBuilder visit(ExplainStatement explainStatement, S context) { - builder.append(explainStatement.getKeyword()); - if (explainStatement.getTable() != null) { - builder.append(" ").append(explainStatement.getTable()); - } else { - explainStatement.appendOptionsTo(builder).append(" "); - } - if (explainStatement.getStatement() != null) { - explainStatement.getStatement().accept(this, context); - } - return builder; + return explainStatement.appendTo(builder, statement -> statement.accept(this, context), + expression -> expression.accept(expressionDeParser, context)); } @Override @@ -492,8 +688,7 @@ public StringBuilder visit(Grant grant, S context) { @Override public StringBuilder visit(CreateSchema aThis, S context) { - builder.append(aThis.toString()); - return builder; + return aThis.appendTo(builder, element -> element.accept(this, context)); } @Override @@ -508,6 +703,35 @@ public StringBuilder visit(CreateUser createUser, S context) { return builder; } + @Override + public StringBuilder visit(AlterUser alterUser, S context) { + builder.append(alterUser); + return builder; + } + + @Override + public StringBuilder visit(RenameUser renameUser, S context) { + builder.append(renameUser); + return builder; + } + + @Override + public StringBuilder visit(SetRoleStatement setRole, S context) { + builder.append(setRole); + return builder; + } + + @Override + public StringBuilder visit(SetDefaultRoleStatement setDefaultRole, S context) { + builder.append(setDefaultRole); + return builder; + } + + @Override + public StringBuilder visit(SetPasswordStatement setPassword, S context) { + return setPassword.appendTo(builder, e -> e.accept(expressionDeParser, context)); + } + @Override public StringBuilder visit(CreateEvent createEvent, S context) { builder.append(createEvent); @@ -616,7 +840,8 @@ public StringBuilder visit(DisconnectStatement disconnectStatement, S contex @Override public StringBuilder visit(PrepareStatement prepareStatement, S context) { - prepareStatement.appendTo(builder, statement -> statement.accept(this, context)); + prepareStatement.appendTo(builder, statement -> statement.accept(this, context), + expression -> expression.accept(expressionDeParser, context)); return builder; } @@ -649,14 +874,21 @@ public StringBuilder visit(CreateExtensionRepository createExtensionReposito @Override public StringBuilder visit(LoadDataStatement loadDataStatement, S context) { - loadDataStatement.appendTo(builder); + loadDataStatement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); return builder; } + @Override + public StringBuilder visit(MySqlLoadDataStatement loadData, S context) { + return loadData.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + @Override public StringBuilder visit(PurgeStatement purgeStatement, S context) { - purgeStatement.appendTo(builder); - return builder; + return purgeStatement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); } @Override @@ -697,6 +929,61 @@ public StringBuilder visit(LockStatement lock, S context) { return builder; } + @Override + public StringBuilder visit(UnlockStatement unlock, S context) { + return unlock.appendTo(builder); + } + + @Override + public StringBuilder visit(BackupLockStatement backupLock, S context) { + return backupLock.appendTo(builder); + } + + @Override + public StringBuilder visit(ChangeReplicationSourceStatement changeReplicationSource, + S context) { + return changeReplicationSource.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(ChangeReplicationFilterStatement changeReplicationFilter, + S context) { + return changeReplicationFilter.appendTo(builder); + } + + @Override + public StringBuilder visit(StartReplicaStatement startReplica, S context) { + return startReplica.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(StopReplicaStatement stopReplica, S context) { + return stopReplica.appendTo(builder); + } + + @Override + public StringBuilder visit(ResetReplicationStatement resetReplication, S context) { + return resetReplication.appendTo(builder); + } + + @Override + public StringBuilder visit(DeclareCursorStatement declareCursor, S context) { + return declareCursor.appendTo(builder, + query -> query.accept((SelectVisitor) selectDeParser, context)); + } + + @Override + public StringBuilder visit(FetchCursorStatement fetchCursor, S context) { + return fetchCursor.appendTo(builder); + } + + @Override + public StringBuilder visit(CloseCursorStatement closeCursor, S context) { + return closeCursor.appendTo(builder); + } + @Override public StringBuilder visit(CreatePolicy createPolicy, S context) { new CreatePolicyDeParser(expressionDeParser, builder).deParse(createPolicy); @@ -809,4 +1096,282 @@ public StringBuilder visit(OracleNullStatement statement, S context) { return builder.append("NULL"); } + @Override + public StringBuilder visit(AlterRelation statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterDatabase statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterTablespaceMove statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTablespace statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(CreateSpatialReferenceSystem statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterInstance statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTablespace statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterPolicy statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(DropPolicy statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateStatistics statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterStatistics statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateForeignDataWrapper statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterForeignDataWrapper statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(CreateServer statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterServer statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(CreateUserMapping statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterUserMapping statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(ImportForeignSchema statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(DropUserMapping statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateAccessMethod statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTextSearchConfiguration statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchConfiguration statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateRule statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context), + action -> action.accept(this, context)); + } + + @Override + public StringBuilder visit(NotifyStatement statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(ListenStatement listen, S context) { + return listen.appendTo(builder); + } + + @Override + public StringBuilder visit(DiscardStatement discard, S context) { + return discard.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateCollation statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterCollation statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterRoutine statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(AlterTrigger statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterRule statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateCast statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateOperator statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTransform statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateOperatorClass statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateConversion statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateOperatorFamily statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterConversion statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateAggregate statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterOperator statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterOperatorClass statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterOperatorFamily statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterAggregate statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateLanguage statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterLanguage statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterLargeObject statement, S context) { + return statement.appendTo(builder, + expression -> expression.accept(expressionDeParser, context)); + } + + @Override + public StringBuilder visit(CreateTextSearchDictionary statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchDictionary statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTextSearchParser statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchParser statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(CreateTextSearchTemplate statement, S context) { + return statement.appendTo(builder); + } + + @Override + public StringBuilder visit(AlterTextSearchTemplate statement, S context) { + return statement.appendTo(builder); + } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/TableElementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/TableElementDeParser.java index d0f3860345..d417f4c4a6 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/TableElementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/TableElementDeParser.java @@ -12,6 +12,7 @@ import net.sf.jsqlparser.expression.ExpressionVisitor; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.statement.create.table.TableElement; /** Deparses table elements while preserving expression visitor customization. */ @@ -29,6 +30,9 @@ public void deParse(TableElement element) { if (element instanceof Index) { ((Index) element).appendTo(builder, expression -> expression.accept(expressionVisitor, null)); + } else if (element instanceof NamedConstraint) { + ((NamedConstraint) element).appendTo(builder, + expression -> expression.accept(expressionVisitor, null)); } else if (element instanceof ColumnDefinition) { ((ColumnDefinition) element).appendTo(builder, expression -> expression.accept(expressionVisitor, null)); diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/TableStatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/TableStatementDeParser.java index 663cd1f04c..8789ab7e23 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/TableStatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/TableStatementDeParser.java @@ -13,6 +13,8 @@ import net.sf.jsqlparser.statement.piped.FromQuery; import net.sf.jsqlparser.statement.select.*; +import java.util.List; + /** * @author jxnu-liguobin */ @@ -84,18 +86,39 @@ public StringBuilder visit(LateralSubSelect lateralSubSelect, S context) { @Override public StringBuilder visit(TableStatement tableStatement, S context) { + List> withItemsList = tableStatement.getWithItemsList(); + if (withItemsList != null && !withItemsList.isEmpty()) { + SelectDeParser selectDeParser = new SelectDeParser(expressionVisitor, builder); + builder.append("WITH "); + for (int i = 0; i < withItemsList.size(); i++) { + if (i > 0) { + builder.append(", "); + } + withItemsList.get(i).accept((SelectVisitor) selectDeParser, context); + } + builder.append(" "); + } tableStatement.appendSelectBodyTo(builder); if (tableStatement.getOrderByElements() != null) { new OrderByDeParser(expressionVisitor, builder) .deParse(tableStatement.getOrderByElements()); } + if (tableStatement.getOption() != null) { + builder.append(tableStatement.getOption()); + } if (tableStatement.getLimit() != null) { new LimitDeparser(expressionVisitor, builder).deParse(tableStatement.getLimit()); } if (tableStatement.getOffset() != null) { deparse(tableStatement.getOffset()); } + if (tableStatement.getFetch() != null) { + builder.append(tableStatement.getFetch()); + } + if (tableStatement.getIsolation() != null) { + builder.append(tableStatement.getIsolation()); + } // TODO UNION diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java index 8c6b3ab490..96e2f99563 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java @@ -49,13 +49,16 @@ public void deParse(Update update) { if (update.getOracleHint() != null) { builder.append(update.getOracleHint()).append(" "); } + if (update.getConflictAlgorithm() != null) { + builder.append("OR ").append(update.getConflictAlgorithm()).append(" "); + } if (update.getModifierPriority() != null) { builder.append(update.getModifierPriority()).append(" "); } if (update.isModifierIgnore()) { builder.append("IGNORE "); } - builder.append(update.getTable()); + update.getTableReference().appendWithAliasTo(builder); deparseForPortionClause(update.getForPortionClause(), expressionVisitor); if (update.getStartJoins() != null) { sources.deparseJoins(update.getStartJoins()); @@ -95,7 +98,9 @@ public void deParse(Update update) { } protected void deparseWhereClause(Update update) { - if (update.getWhere() != null) { + if (update.getCursorName() != null) { + builder.append(" WHERE CURRENT OF ").append(update.getCursorName()); + } else if (update.getWhere() != null) { builder.append(" WHERE "); update.getWhere().accept(expressionVisitor, null); } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/UpsertDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/UpsertDeParser.java index 218ca1db30..9048a2cc3a 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/UpsertDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/UpsertDeParser.java @@ -10,7 +10,6 @@ package net.sf.jsqlparser.util.deparser; import net.sf.jsqlparser.expression.ExpressionVisitor; -import net.sf.jsqlparser.statement.insert.ConflictActionType; import net.sf.jsqlparser.statement.select.SelectVisitor; import net.sf.jsqlparser.statement.upsert.Upsert; @@ -67,6 +66,7 @@ public void deParse(Upsert upsert) { deparseUpdateSets(upsert.getUpdateSets(), builder, expressionVisitor); } else { if (upsert.getColumns() != null) { + builder.append(" "); upsert.getColumns().accept(expressionVisitor, null); } @@ -78,16 +78,12 @@ public void deParse(Upsert upsert) { builder.append(" "); upsert.getSelect().accept((SelectVisitor) selectVisitor, null); } + } - if (upsert.getDuplicateAction() != null) { - builder.append(" ON DUPLICATE KEY UPDATE "); - if (ConflictActionType.DO_UPDATE - .equals(upsert.getDuplicateAction().getConflictActionType())) { - deparseUpdateSets(upsert.getDuplicateUpdateSets(), builder, expressionVisitor); - } else { - upsert.getDuplicateAction().appendTo(builder); - } - } + if (upsert.getDuplicateAction() != null) { + builder.append(" ON DUPLICATE KEY UPDATE "); + upsert.getDuplicateAction().appendTo(builder, + expression -> expression.accept(expressionVisitor, null)); } } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ValuesStatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ValuesStatementDeParser.java index eb39481d0b..1f921d12e9 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/ValuesStatementDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/ValuesStatementDeParser.java @@ -15,19 +15,33 @@ public class ValuesStatementDeParser extends AbstractDeParser { private final ExpressionVisitor expressionVisitor; + private final SelectDeParser selectDeParser; public ValuesStatementDeParser(ExpressionVisitor expressionVisitor, StringBuilder buffer) { + this(expressionVisitor, null, buffer); + } + + public ValuesStatementDeParser(ExpressionVisitor expressionVisitor, + SelectDeParser selectDeParser, StringBuilder buffer) { super(buffer); this.expressionVisitor = expressionVisitor; + this.selectDeParser = selectDeParser; } @Override public void deParse(Values values) { + deParse(values, null); + } + + public void deParse(Values values, S context) { + new DmlDeParserSupport(expressionVisitor, selectDeParser, builder) + .deparseWithItems(values.getWithItemsList(), context); builder.append("VALUES "); - values.getExpressions().accept(expressionVisitor, null); + values.getExpressions().accept(expressionVisitor, context); if (values.getAlias() != null) { - builder.append(" ").append(values.getAlias()); + // the alias renders its own leading space, as in Values.toString() + builder.append(values.getAlias()); } } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java index 08e137e54f..15b655a100 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java @@ -101,19 +101,43 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS * all "CREATE" {@link Feature}'s */ public static final FeaturesAllowed CREATE = new FeaturesAllowed("CREATE", Feature.createIndex, + Feature.createTextSearchConfiguration, + Feature.createLanguage, Feature.createTextSearchDictionary, + Feature.createTextSearchParser, Feature.createTextSearchTemplate, + Feature.createRule, + Feature.createCollation, + Feature.createCast, Feature.createTransform, Feature.createConversion, + Feature.createOperator, Feature.createOperatorClass, Feature.createOperatorFamily, + Feature.createAggregate, Feature.createSchema, Feature.createSequence, Feature.createTable, + Feature.createForeignDataWrapper, Feature.createServer, Feature.createUserMapping, + Feature.createAccessMethod, Feature.createAccessMethodTable, + Feature.createTablespace, Feature.createTableUnlogged, Feature.createTableCreateOptionStrings, Feature.createTableTableOptionStrings, Feature.createTableIfNotExists, Feature.createTableRowMovement, Feature.createTableFromSelect, - Feature.createTrigger, + Feature.createTrigger, Feature.createEventTrigger, Feature.createEvent, + Feature.createPolicy, Feature.createStatistics, Feature.createView).unmodifyable(); /** * all "ALTER" {@link Feature}'s */ public static final FeaturesAllowed ALTER = new FeaturesAllowed("ALTER", Feature.alterTable, Feature.alterSequence, - Feature.alterView, Feature.alterIndex, Feature.alterSchema) + Feature.alterTextSearchConfiguration, + Feature.alterLanguage, Feature.alterLargeObject, + Feature.alterTextSearchDictionary, Feature.alterTextSearchParser, + Feature.alterTextSearchTemplate, + Feature.alterCollation, Feature.alterRule, + Feature.alterConversion, + Feature.alterOperator, Feature.alterOperatorClass, + Feature.alterOperatorFamily, Feature.alterAggregate, + Feature.alterTablespace, + Feature.alterEventTrigger, Feature.alterEvent, + Feature.alterPolicy, Feature.alterStatistics, + Feature.alterView, Feature.alterIndex, Feature.alterSchema, + Feature.alterForeignDataWrapper, Feature.alterServer, Feature.alterUserMapping) .unmodifyable(); /** * all "DROP" {@link Feature}'s @@ -157,13 +181,15 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS * all DML {@link Feature}'s */ public static final FeaturesAllowed DML = - new FeaturesAllowed("DML").add(SELECT, INSERT, UPDATE, DELETE, MERGE) + new FeaturesAllowed("DML", Feature.notifyStatement) + .add(SELECT, INSERT, UPDATE, DELETE, MERGE) .unmodifyable(); /** * all DDL {@link Feature}'s */ public static final FeaturesAllowed DDL = - new FeaturesAllowed("DDL").add(CREATE, ALTER, DROP).unmodifyable(); + new FeaturesAllowed("DDL", Feature.importForeignSchema).add(CREATE, ALTER, DROP) + .unmodifyable(); private static final String SEPERATOR = " + "; private Set names = new LinkedHashSet<>(); private Set features = new HashSet<>(); diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/H2Version.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/H2Version.java index 3984e7fe69..a81012872b 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/H2Version.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/H2Version.java @@ -24,17 +24,13 @@ */ public enum H2Version implements Version { V_1_4_200("1.4.200", - EnumSet.of( - // supported if used with jdbc + EnumSet.of(// supported if used with jdbc Feature.jdbcParameter, - Feature.jdbcNamedParameter, - // expressions - Feature.exprLike, - // http://h2database.com/html/commands.html#select + Feature.jdbcNamedParameter, // expressions + Feature.exprLike, // http://h2database.com/html/commands.html#select Feature.select, Feature.selectGroupBy, Feature.function, - Feature.selectHaving, - // https://h2database.com/html/grammar.html?#table_expression + Feature.selectHaving, // https://h2database.com/html/grammar.html?#table_expression // https://h2database.com/html/grammar.html?#join_specification Feature.join, Feature.joinSimple, @@ -71,42 +67,30 @@ public enum H2Version implements Version { Feature.setOperationMinus, // http://h2database.com/html/commands.html#create_sequence - Feature.createSequence, - // http://h2database.com/html/commands.html#alter_sequence - Feature.alterSequence, - // http://h2database.com/html/commands.html#create_schema - Feature.createSchema, - // http://h2database.com/html/commands.html#create_index - Feature.createIndex, - // http://h2database.com/html/commands.html#create_table + Feature.createSequence, // http://h2database.com/html/commands.html#alter_sequence + Feature.alterSequence, // http://h2database.com/html/commands.html#create_schema + Feature.createSchema, // http://h2database.com/html/commands.html#create_index + Feature.createIndex, // http://h2database.com/html/commands.html#create_table Feature.createTable, Feature.createTableCreateOptionStrings, Feature.createTableTableOptionStrings, Feature.createTableFromSelect, - Feature.createTableIfNotExists, - // http://h2database.com/html/commands.html#create_view + Feature.createTableIfNotExists, // http://h2database.com/html/commands.html#create_view Feature.createView, - Feature.createViewForce, Feature.createOrReplaceView, - // http://h2database.com/html/commands.html#alter_view_rename + Feature.createViewForce, Feature.createOrReplaceView, // http://h2database.com/html/commands.html#alter_view_rename // Feature.alterView, // http://h2database.com/html/commands.html#select - Feature.top, - // http://www.h2database.com/html/advanced.html?search=limit#result_sets + Feature.top, // http://www.h2database.com/html/advanced.html?search=limit#result_sets Feature.fetch, Feature.fetchFirst, // http://www.h2database.com/html/commands.html?highlight=DISTINCT&search=SELECT#firstFound - Feature.distinct, - // http://www.h2database.com/html/commands.html?highlight=DISTINCT%20ON&search=SELECT#firstFound - Feature.distinctOn, - // http://h2database.com/html/commands.html#insert + Feature.distinct, // http://www.h2database.com/html/commands.html?highlight=DISTINCT%20ON&search=SELECT#firstFound + Feature.distinctOn, // http://h2database.com/html/commands.html#insert Feature.insert, Feature.insertValues, Feature.values, - Feature.insertFromSelect, - // http://h2database.com/html/commands.html#update - Feature.update, - // http://h2database.com/html/commands.html#delete - Feature.delete, - // http://h2database.com/html/commands.html#truncate_table + Feature.insertFromSelect, // http://h2database.com/html/commands.html#update + Feature.update, // http://h2database.com/html/commands.html#delete + Feature.delete, // http://h2database.com/html/commands.html#truncate_table Feature.truncate, // http://www.h2database.com/html/commands.html#execute_immediate @@ -114,30 +98,23 @@ public enum H2Version implements Version { // http://h2database.com/html/commands.html#drop_table // http://h2database.com/html/commands.html#drop_index - Feature.drop, - // http://h2database.com/html/commands.html#drop_table - Feature.dropTable, - // http://h2database.com/html/commands.html#drop_index - Feature.dropIndex, - // http://h2database.com/html/commands.html#drop_view - Feature.dropView, - // http://h2database.com/html/commands.html#drop_schema - Feature.dropSchema, - // http://h2database.com/html/commands.html#drop_sequence + Feature.drop, // http://h2database.com/html/commands.html#drop_table + Feature.dropTable, // http://h2database.com/html/commands.html#drop_index + Feature.dropIndex, // http://h2database.com/html/commands.html#drop_view + Feature.dropView, // http://h2database.com/html/commands.html#drop_schema + Feature.dropSchema, // http://h2database.com/html/commands.html#drop_sequence Feature.dropSequence, Feature.dropTableIfExists, Feature.dropIndexIfExists, Feature.dropViewIfExists, - Feature.dropSchemaIfExists, Feature.dropSequenceIfExists, - // http://h2database.com/html/commands.html#alter_table_add + Feature.dropSchemaIfExists, Feature.dropSequenceIfExists, // http://h2database.com/html/commands.html#alter_table_add // http://h2database.com/html/commands.html#alter_table_add_constraint // ... - Feature.alterTable, - // http://www.h2database.com/html/commands.html#explain - Feature.explain, - // http://www.h2database.com/html/commands.html#grant_right + Feature.alterTable, // http://www.h2database.com/html/commands.html#explain + Feature.explain, // http://www.h2database.com/html/commands.html#grant_right // http://www.h2database.com/html/commands.html#grant_role - Feature.grant, - // http://h2database.com/html/commands.html#commit - Feature.commit)); + Feature.grant, // http://h2database.com/html/commands.html#commit + // http://h2database.com/html/commands.html#rollback + // http://h2database.com/html/commands.html#savepoint + Feature.commit, Feature.rollback, Feature.savepoint)); private Set features; private String versionString; diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/MariaDbVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/MariaDbVersion.java index 0d322863cc..6dad285fe5 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/MariaDbVersion.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/MariaDbVersion.java @@ -28,7 +28,8 @@ public enum MariaDbVersion implements Version { Feature.jdbcParameter, Feature.jdbcNamedParameter, // expressions Feature.exprLike, // https://mariadb.com/kb/en/select/ - Feature.select, + Feature.select, // https://mariadb.com/kb/en/selectinto/ + Feature.selectInto, Feature.selectGroupBy, Feature.function, Feature.selectHaving, Feature.limit, Feature.limitOffset, Feature.offset, Feature.offsetParam, @@ -79,9 +80,37 @@ public enum MariaDbVersion implements Version { // https://mariadb.com/kb/en/truncate-table/ Feature.truncate, + // https://mariadb.com/kb/en/table-statements/ + Feature.analyze, Feature.tableMaintenance, + + // https://mariadb.com/kb/en/lock-tables/ + Feature.lock, Feature.unlockTables, + + // https://mariadb.com/kb/en/purge-binary-logs/ + Feature.purgeBinaryLogs, + + // https://mariadb.com/kb/en/load-data-infile/ + // https://mariadb.com/kb/en/load-xml/ + Feature.loadData, + + // https://mariadb.com/kb/en/account-management-sql-statements/ + Feature.createRole, Feature.createUser, Feature.alterUser, Feature.renameUser, + Feature.setRole, + Feature.setDefaultRole, Feature.setPassword, + // https://mariadb.com/kb/en/call/ Feature.execute, Feature.executeCall, + // https://mariadb.com/kb/en/prepare-statement/ + // https://mariadb.com/kb/en/execute-statement/ + Feature.prepare, Feature.executeExecute, Feature.executeUsing, + + // https://mariadb.com/kb/en/deallocate-drop-prepare/ + Feature.deallocate, + + // https://mariadb.com/kb/en/do/ + Feature.doStatement, + // https://mariadb.com/kb/en/drop/ Feature.drop, // https://mariadb.com/kb/en/drop-index/ Feature.dropIndex, // https://mariadb.com/kb/en/drop-table/ @@ -113,18 +142,39 @@ public enum MariaDbVersion implements Version { Feature.createSchema, // https://mariadb.com/kb/en/create-trigger/ Feature.createTrigger, + // https://mariadb.com/kb/en/create-event/ + // https://mariadb.com/kb/en/alter-event/ + Feature.createEvent, Feature.alterEvent, + + // https://mariadb.com/kb/en/create-database/ + // https://mariadb.com/kb/en/alter-database/ + Feature.createDatabase, Feature.alterDatabase, + + // https://mariadb.com/kb/en/alter-function/ + // https://mariadb.com/kb/en/alter-procedure/ + Feature.alterFunction, Feature.alterProcedure, + // https://mariadb.com/kb/en/describe/ Feature.describe, // https://mariadb.com/kb/en/explain/ Feature.explain, // https://mariadb.com/kb/en/show/ Feature.show, // https://mariadb.com/kb/en/show-tables/ Feature.showTables, // https://mariadb.com/kb/en/show-columns/ Feature.showColumns, // https://mariadb.com/kb/en/show-index/ - Feature.showIndex, // https://mariadb.com/kb/en/use/ + Feature.showIndex, // https://mariadb.com/kb/en/show-table-status/ + Feature.showTableStatus, // https://mariadb.com/kb/en/show-create-table/ + Feature.showCreate, // https://mariadb.com/kb/en/show/ + Feature.mySqlShow, // https://mariadb.com/kb/en/use/ Feature.use, // https://mariadb.com/kb/en/grant/ - Feature.grant, // https://mariadb.com/kb/en/commit/ - Feature.commit, // https://mariadb.com/kb/en/optimizer-hints/ + Feature.grant, // https://mariadb.com/kb/en/revoke/ + Feature.revoke, // https://mariadb.com/kb/en/commit/ + Feature.commit, // https://mariadb.com/kb/en/rollback/ + Feature.rollback, // https://mariadb.com/kb/en/savepoint/ + Feature.savepoint, // https://mariadb.com/kb/en/xa-transactions/ + Feature.xa, // https://mariadb.com/kb/en/create-server/ + Feature.createServer, Feature.alterServer, // https://mariadb.com/kb/en/install-plugin/ + Feature.installPlugin, // https://mariadb.com/kb/en/optimizer-hints/ Feature.mySqlHintStraightJoin, - Feature.mysqlCalcFoundRows, + Feature.mysqlSelectModifiers, Feature.mysqlCalcFoundRows, Feature.mysqlSqlCacheFlag)), ORACLE_MODE("oracle_mode", V10_5_4.copy().add(Feature.selectUnique).getFeatures()); diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/MySqlVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/MySqlVersion.java index cd6c2c038b..9dd7de8f95 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/MySqlVersion.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/MySqlVersion.java @@ -24,14 +24,12 @@ */ public enum MySqlVersion implements Version { V8_0("8.0", - EnumSet.of( - // supported if used with jdbc + EnumSet.of(// supported if used with jdbc Feature.jdbcParameter, - Feature.jdbcNamedParameter, - // expressions - Feature.exprLike, - // https://dev.mysql.com/doc/refman/8.0/en/select.html - Feature.select, + Feature.jdbcNamedParameter, // expressions + Feature.exprLike, // https://dev.mysql.com/doc/refman/8.0/en/select.html + Feature.select, // https://dev.mysql.com/doc/refman/8.0/en/select-into.html + Feature.selectInto, Feature.selectGroupBy, Feature.selectHaving, Feature.limit, Feature.limitOffset, Feature.offset, Feature.offsetParam, Feature.orderBy, @@ -42,8 +40,7 @@ public enum MySqlVersion implements Version { Feature.selectForShare, Feature.distinct, - Feature.setOperation, - // https://dev.mysql.com/doc/refman/8.0/en/union.html + Feature.setOperation, // https://dev.mysql.com/doc/refman/8.0/en/union.html Feature.setOperationUnion, // https://dev.mysql.com/doc/refman/8.0/en/with.html#common-table-expressions @@ -79,64 +76,124 @@ public enum MySqlVersion implements Version { // https://dev.mysql.com/doc/refman/8.0/en/truncate-table.html Feature.truncate, + // https://dev.mysql.com/doc/refman/8.0/en/table-maintenance-statements.html + Feature.analyze, Feature.tableMaintenance, + + // https://dev.mysql.com/doc/refman/8.0/en/flush.html + // https://dev.mysql.com/doc/refman/8.0/en/kill.html + // https://dev.mysql.com/doc/refman/8.0/en/reset-persist.html + Feature.flush, Feature.kill, Feature.resetPersist, + + // https://dev.mysql.com/doc/refman/8.0/en/handler.html + Feature.handler, + + // https://dev.mysql.com/doc/refman/8.0/en/lock-tables.html + Feature.lock, Feature.unlockTables, + + // https://dev.mysql.com/doc/refman/8.0/en/lock-instance-for-backup.html + Feature.backupLock, + + // https://dev.mysql.com/doc/refman/8.0/en/resource-groups.html + Feature.createResourceGroup, Feature.alterResourceGroup, + Feature.setResourceGroup, + + // https://dev.mysql.com/doc/refman/8.4/en/replication-statements.html + Feature.purgeBinaryLogs, Feature.resetReplication, + Feature.changeReplicationSource, Feature.changeReplicationFilter, + Feature.startReplica, Feature.stopReplica, + + // https://dev.mysql.com/doc/refman/8.0/en/load-data.html + // https://dev.mysql.com/doc/refman/8.0/en/load-xml.html + Feature.loadData, + + // https://dev.mysql.com/doc/refman/8.0/en/account-management-statements.html + Feature.createRole, Feature.createUser, Feature.alterUser, Feature.renameUser, + Feature.setRole, + Feature.setDefaultRole, Feature.setPassword, + // https://dev.mysql.com/doc/refman/8.0/en/call.html Feature.execute, Feature.executeCall, - Feature.drop, - // https://dev.mysql.com/doc/refman/8.0/en/drop-table.html - Feature.dropTable, - // https://dev.mysql.com/doc/refman/8.0/en/drop-index.html - Feature.dropIndex, - // https://dev.mysql.com/doc/refman/8.0/en/drop-view.html - Feature.dropView, - // https://dev.mysql.com/doc/refman/8.0/en/drop-database.html + // https://dev.mysql.com/doc/refman/8.4/en/sql-prepared-statements.html + Feature.prepare, Feature.executeExecute, Feature.executeUsing, + + // https://dev.mysql.com/doc/refman/8.0/en/deallocate-prepare.html + Feature.deallocate, + + // https://dev.mysql.com/doc/refman/8.4/en/do.html + Feature.doStatement, + + Feature.drop, // https://dev.mysql.com/doc/refman/8.0/en/drop-table.html + Feature.dropTable, // https://dev.mysql.com/doc/refman/8.0/en/drop-index.html + Feature.dropIndex, // https://dev.mysql.com/doc/refman/8.0/en/drop-view.html + Feature.dropView, // https://dev.mysql.com/doc/refman/8.0/en/drop-database.html Feature.dropSchema, Feature.dropTableIfExists, Feature.dropViewIfExists, Feature.dropSchemaIfExists, Feature.dropSequenceIfExists, // https://dev.mysql.com/doc/refman/8.0/en/alter-table.html - Feature.alterTable, - // https://dev.mysql.com/doc/refman/8.0/en/alter-view.html + Feature.alterTable, // https://dev.mysql.com/doc/refman/8.0/en/alter-view.html Feature.alterView, + // https://dev.mysql.com/doc/refman/8.0/en/create-tablespace.html + Feature.createTablespace, // https://dev.mysql.com/doc/refman/8.0/en/alter-tablespace.html + Feature.alterTablespace, + + // https://dev.mysql.com/doc/refman/8.0/en/create-spatial-reference-system.html + Feature.createSpatialReferenceSystem, + + // https://dev.mysql.com/doc/refman/8.0/en/alter-instance.html + Feature.alterInstance, + // https://dev.mysql.com/doc/refman/8.0/en/create-database.html - Feature.createSchema, - // https://dev.mysql.com/doc/refman/8.0/en/create-view.html + // https://dev.mysql.com/doc/refman/8.0/en/alter-database.html + Feature.createDatabase, Feature.alterDatabase, + + // https://dev.mysql.com/doc/refman/8.0/en/alter-function.html + // https://dev.mysql.com/doc/refman/8.0/en/alter-procedure.html + Feature.alterFunction, Feature.alterProcedure, + + // https://dev.mysql.com/doc/refman/8.0/en/create-database.html + Feature.createSchema, // https://dev.mysql.com/doc/refman/8.0/en/create-view.html Feature.createView, Feature.createViewWithComment, - Feature.createOrReplaceView, - // https://dev.mysql.com/doc/refman/8.0/en/create-table.html + Feature.createOrReplaceView, // https://dev.mysql.com/doc/refman/8.0/en/create-table.html Feature.createTable, Feature.createTableCreateOptionStrings, Feature.createTableTableOptionStrings, - Feature.createTableFromSelect, Feature.createTableIfNotExists, - // https://dev.mysql.com/doc/refman/8.0/en/create-index.html - Feature.createIndex, - // https://dev.mysql.com/doc/refman/8.0/en/create-trigger.html + Feature.createTableFromSelect, Feature.createTableIfNotExists, // https://dev.mysql.com/doc/refman/8.0/en/create-index.html + Feature.createIndex, // https://dev.mysql.com/doc/refman/8.0/en/create-trigger.html Feature.createTrigger, + // https://dev.mysql.com/doc/refman/8.0/en/create-event.html + // https://dev.mysql.com/doc/refman/8.0/en/alter-event.html + Feature.createEvent, Feature.alterEvent, + // https://dev.mysql.com/doc/refman/8.0/en/describe.html Feature.describe, - Feature.desc, - // https://dev.mysql.com/doc/refman/8.0/en/explain.html - Feature.explain, - // https://dev.mysql.com/doc/refman/8.0/en/show.html - Feature.show, - // https://dev.mysql.com/doc/refman/8.0/en/show-tables.html - Feature.showTables, - // https://dev.mysql.com/doc/refman/8.0/en/show-columns.html - Feature.showColumns, - // https://dev.mysql.com/doc/refman/8.0/en/show-index.html - Feature.showIndex, - // https://dev.mysql.com/doc/refman/8.0/en/grant.html - Feature.grant, - // https://dev.mysql.com/doc/refman/8.0/en/use.html - Feature.use, - // https://dev.mysql.com/doc/refman/8.0/en/commit.html - Feature.commit, - // + Feature.desc, // https://dev.mysql.com/doc/refman/8.0/en/explain.html + Feature.explain, // https://dev.mysql.com/doc/refman/8.0/en/show.html + Feature.show, // https://dev.mysql.com/doc/refman/8.0/en/show-tables.html + Feature.showTables, // https://dev.mysql.com/doc/refman/8.0/en/show-columns.html + Feature.showColumns, // https://dev.mysql.com/doc/refman/8.0/en/show-index.html + Feature.showIndex, // https://dev.mysql.com/doc/refman/8.0/en/show-table-status.html + Feature.showTableStatus, // https://dev.mysql.com/doc/refman/8.0/en/show-create-table.html + Feature.showCreate, // https://dev.mysql.com/doc/refman/8.4/en/show.html + Feature.mySqlShow, // https://dev.mysql.com/doc/refman/8.0/en/grant.html + Feature.grant, // https://dev.mysql.com/doc/refman/8.0/en/revoke.html + Feature.revoke, // https://dev.mysql.com/doc/refman/8.0/en/use.html + Feature.use, // https://dev.mysql.com/doc/refman/8.0/en/commit.html + Feature.commit, Feature.rollback, Feature.startTransaction, + Feature.savepoint, Feature.releaseSavepoint, + Feature.transactionChain, Feature.transactionConsistentSnapshot, + Feature.transactionRelease, // https://dev.mysql.com/doc/refman/8.4/en/set-transaction.html + Feature.setTransaction, Feature.setTransactionGlobal, + Feature.setTransactionPersist, // https://dev.mysql.com/doc/refman/8.4/en/xa-statements.html + Feature.xa, // https://dev.mysql.com/doc/refman/8.4/en/create-server.html + Feature.createServer, Feature.alterServer, // https://dev.mysql.com/doc/refman/8.4/en/component-statements.html + Feature.installPlugin, Feature.installComponent, // Feature.mySqlHintStraightJoin, Feature.mysqlSqlCacheFlag, - Feature.mysqlCalcFoundRows)); + Feature.mysqlSelectModifiers, Feature.mysqlCalcFoundRows)); private Set features; private String versionString; diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/OracleVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/OracleVersion.java index 8d94ab72c1..6a607bb066 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/OracleVersion.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/OracleVersion.java @@ -123,7 +123,17 @@ public enum OracleVersion implements Version { Feature.createTrigger, // https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/CREATE-SCHEMA.html Feature.createSchema, - Feature.commit, + Feature.commit, Feature.rollback, Feature.savepoint, + + // https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/LOCK-TABLE.html + Feature.lock, + + // https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/ALTER-SESSION.html + // https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/ALTER-SYSTEM.html + Feature.alterSession, Feature.alterSystem, + + // https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/PURGE.html + Feature.purge, // https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/COMMENT.html Feature.comment, Feature.commentOnTable, Feature.commentOnColumn, diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java index e5a9b43f13..e788634e8c 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java @@ -30,7 +30,9 @@ public enum PostgresqlVersion implements Version { Feature.doStatement, Feature.exprLike, Feature.exprSimilarTo, // https://www.postgresql.org/docs/current/sql-select.html - Feature.select, + Feature.select, // https://www.postgresql.org/docs/current/sql-selectinto.html + Feature.selectInto, + Feature.tableStatement, Feature.selectGroupBy, Feature.function, Feature.tableFunction, Feature.lateralSubSelect, Feature.selectHaving, // https://www.postgresql.org/docs/current/queries-table-expressions.html#QUERIES-GROUPING-SETS @@ -94,9 +96,52 @@ public enum PostgresqlVersion implements Version { Feature.commentOnDomain, Feature.commentOnType, Feature.commentOnMaterializedView, Feature.commentOnFunction, Feature.commentOnConstraint, + Feature.commentOnTrigger, Feature.commentOnPolicy, Feature.commentOnRule, + Feature.commentOnProcedure, Feature.commentOnRoutine, + Feature.commentOnAggregate, Feature.commentOnCast, + Feature.commentOnCollation, Feature.commentOnForeignTable, + Feature.commentOnStatistics, Feature.commentOnDatabase, Feature.commentOnRole, + Feature.commentOnTablespace, Feature.commentOnAccessMethod, + Feature.commentOnExtension, Feature.commentOnForeignDataWrapper, + Feature.commentOnLanguage, Feature.commentOnServer, + Feature.commentOnEventTrigger, Feature.commentOnPublication, + Feature.commentOnSubscription, + Feature.commentOnOperator, Feature.commentOnOperatorClass, + Feature.commentOnOperatorFamily, Feature.commentOnConversion, + Feature.commentOnLargeObject, Feature.commentOnTransform, + Feature.commentOnTextSearchConfiguration, + Feature.commentOnTextSearchDictionary, Feature.commentOnTextSearchParser, + Feature.commentOnTextSearchTemplate, // https://www.postgresql.org/docs/current/sql-createsequence.html Feature.createSequence, + Feature.createAccessMethod, + Feature.createTablespace, Feature.alterTablespace, + Feature.createForeignDataWrapper, Feature.alterForeignDataWrapper, + Feature.createServer, Feature.alterServer, Feature.createUserMapping, + Feature.alterUserMapping, // https://www.postgresql.org/docs/current/sql-importforeignschema.html + Feature.importForeignSchema, + Feature.createTextSearchConfiguration, Feature.alterTextSearchConfiguration, + Feature.createRule, Feature.notifyStatement, + Feature.createCollation, Feature.alterCollation, + + // https://www.postgresql.org/docs/current/sql-createcast.html + // https://www.postgresql.org/docs/current/sql-createtransform.html + // https://www.postgresql.org/docs/current/sql-createconversion.html + // https://www.postgresql.org/docs/current/sql-alterconversion.html + Feature.createCast, Feature.createTransform, Feature.createConversion, + Feature.createLanguage, Feature.alterLanguage, Feature.alterLargeObject, + Feature.createTextSearchDictionary, Feature.alterTextSearchDictionary, + Feature.createTextSearchParser, Feature.alterTextSearchParser, + Feature.createTextSearchTemplate, Feature.alterTextSearchTemplate, + Feature.alterConversion, // https://www.postgresql.org/docs/current/sql-createoperator.html + // https://www.postgresql.org/docs/current/sql-createopclass.html + // https://www.postgresql.org/docs/current/sql-createopfamily.html + // https://www.postgresql.org/docs/current/sql-createaggregate.html + Feature.createOperator, Feature.alterOperator, + Feature.createOperatorClass, Feature.alterOperatorClass, + Feature.createOperatorFamily, Feature.alterOperatorFamily, + Feature.createAggregate, Feature.alterAggregate, Feature.createPublication, Feature.alterPublication, Feature.createSubscription, Feature.alterSubscription, Feature.createType, Feature.alterType, @@ -112,6 +157,43 @@ public enum PostgresqlVersion implements Version { Feature.createViewMaterialized, // https://www.postgresql.org/docs/current/sql-alterview.html // Feature.alterView, + // https://www.postgresql.org/docs/current/sql-createdatabase.html + // https://www.postgresql.org/docs/current/sql-alterdatabase.html + Feature.createDatabase, Feature.alterDatabase, + + // https://www.postgresql.org/docs/current/sql-altersystem.html + Feature.alterSystem, + + // https://www.postgresql.org/docs/current/sql-createpolicy.html + // https://www.postgresql.org/docs/current/sql-createstatistics.html + Feature.createPolicy, Feature.alterPolicy, Feature.createStatistics, + Feature.alterStatistics, + + // https://www.postgresql.org/docs/current/sql-copy.html + // https://www.postgresql.org/docs/current/sql-prepare.html + // https://www.postgresql.org/docs/current/sql-lock.html + Feature.copy, Feature.prepare, Feature.deallocate, Feature.lock, + + // https://www.postgresql.org/docs/current/sql-show.html + // https://www.postgresql.org/docs/current/sql-discard.html + // https://www.postgresql.org/docs/current/sql-listen.html + // https://www.postgresql.org/docs/current/sql-unlisten.html + Feature.show, Feature.discard, Feature.listen, + + // https://www.postgresql.org/docs/current/sql-declare.html + // https://www.postgresql.org/docs/current/sql-fetch.html + // https://www.postgresql.org/docs/current/sql-move.html + // https://www.postgresql.org/docs/current/sql-close.html + Feature.declareCursor, Feature.fetchCursor, Feature.closeCursor, + + // https://www.postgresql.org/docs/current/sql-alterfunction.html + // https://www.postgresql.org/docs/current/sql-alterprocedure.html + // https://www.postgresql.org/docs/current/sql-alterroutine.html + // https://www.postgresql.org/docs/current/sql-altertrigger.html + // https://www.postgresql.org/docs/current/sql-alterrule.html + Feature.alterFunction, Feature.alterProcedure, Feature.alterRoutine, + Feature.alterTrigger, Feature.alterRule, + // https://www.postgresql.org/docs/16/sql-refreshmaterializedview.html Feature.refreshMaterializedView, Feature.refreshMaterializedWithNoDataView, @@ -130,6 +212,12 @@ public enum PostgresqlVersion implements Version { Feature.deleteReturningExpressionList, // https://www.postgresql.org/docs/current/sql-truncate.html Feature.truncate, + // https://www.postgresql.org/docs/current/sql-analyze.html + Feature.analyze, // https://www.postgresql.org/docs/current/sql-vacuum.html + Feature.vacuum, // https://www.postgresql.org/docs/current/sql-cluster.html + Feature.cluster, // https://www.postgresql.org/docs/current/sql-checkpoint.html + Feature.checkpoint, + // https://www.postgresql.org/docs/current/sql-call.html Feature.execute, Feature.executeCall, @@ -140,19 +228,37 @@ public enum PostgresqlVersion implements Version { Feature.dropSchema, // https://www.postgresql.org/docs/current/sql-dropsequence.html Feature.dropSequence, Feature.dropTableIfExists, Feature.dropIndexIfExists, Feature.dropViewIfExists, - Feature.dropSchemaIfExists, Feature.dropSequenceIfExists, + Feature.dropSchemaIfExists, Feature.dropSequenceIfExists, // https://www.postgresql.org/docs/current/sql-reassign-owned.html + Feature.reassignOwned, // https://www.postgresql.org/docs/current/sql-altertable.html Feature.alterTable, // https://www.postgresql.org/docs/current/using-explain.html Feature.explain, // https://www.postgresql.org/docs/current/sql-grant.html Feature.grant, Feature.revoke, Feature.createRole, Feature.alterRole, - Feature.alterDefaultPrivileges, Feature.createTrigger, // https://www.postgresql.org/docs/current/sql-set.html - Feature.set, // https://www.postgresql.org/docs/current/sql-reset.html + Feature.alterDefaultPrivileges, Feature.createTrigger, // https://www.postgresql.org/docs/current/sql-createeventtrigger.html + Feature.createEventTrigger, Feature.alterEventTrigger, // https://www.postgresql.org/docs/current/sql-reindex.html + Feature.reindex, // https://www.postgresql.org/docs/current/sql-security-label.html + Feature.securityLabel, // https://www.postgresql.org/docs/current/sql-set.html + Feature.set, Feature.setAssignmentTo, // https://www.postgresql.org/docs/current/sql-reset.html Feature.reset, // https://www.postgresql.org/docs/current/sql-commit.html - Feature.commit)), V11("11", V10.copy().getFeatures()), V12("12", - V11.copy().getFeatures()), V13("13", - V12.copy().getFeatures()), V14("14", V13.copy().getFeatures()); + Feature.commit, Feature.rollback, Feature.startTransaction, + Feature.savepoint, Feature.releaseSavepoint, + Feature.transactionIsolationLevel, Feature.transactionDeferrable, + Feature.transactionEndAbort, // https://www.postgresql.org/docs/current/sql-set-transaction.html + Feature.setTransaction, Feature.setTransactionSessionCharacteristics, + Feature.setTransactionSnapshot, // https://www.postgresql.org/docs/current/sql-set-constraints.html + Feature.setConstraints, // https://www.postgresql.org/docs/current/sql-prepare-transaction.html + Feature.twoPhaseCommit)), V11("11", + V10.copy().getFeatures()), V12("12", + V11.copy() + .add(Feature.createAccessMethodTable, + Feature.reindexConcurrently, + Feature.transactionChain) + .getFeatures()), V13( + "13", + V12.copy().getFeatures()), V14("14", + V13.copy().getFeatures()); private Set features; private String versionString; diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/SqlServerVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/SqlServerVersion.java index e7c11c9a7b..f028037341 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/feature/SqlServerVersion.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/SqlServerVersion.java @@ -106,7 +106,8 @@ public enum SqlServerVersion implements Version { Feature.createTrigger, // https://docs.microsoft.com/en-us/sql/t-sql/statements/merge-transact-sql?view=sql-server-ver15 Feature.merge, // https://docs.microsoft.com/en-us/sql/t-sql/statements/grant-transact-sql?view=sql-server-ver15 Feature.grant, // https://docs.microsoft.com/en-us/sql/t-sql/language-elements/commit-transaction-transact-sql?view=sql-server-ver15 - Feature.commit, // special sql-server features + Feature.commit, // https://docs.microsoft.com/en-us/sql/t-sql/language-elements/rollback-transaction-transact-sql?view=sql-server-ver15 + Feature.rollback, // special sql-server features // https://docs.microsoft.com/en-us/sql/relational-databases/xml/for-xml-sql-server?view=sql-server-ver15 Feature.selectForXmlPath, Feature.use, Feature.setIdentityInsert, Feature.allowSquareBracketQuotation, // diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/AbstractValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/AbstractValidator.java index 4955783764..4bb2dcf1bb 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/AbstractValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/AbstractValidator.java @@ -14,6 +14,7 @@ import net.sf.jsqlparser.statement.update.UpdateSet; import net.sf.jsqlparser.statement.select.Select; import net.sf.jsqlparser.statement.select.SelectVisitor; +import net.sf.jsqlparser.statement.select.WithItem; import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.statement.select.FromItem; import net.sf.jsqlparser.statement.select.OrderByElement; @@ -174,6 +175,11 @@ protected void validateOptionalExpressions(List expression (o, v) -> o.accept(v, null)); } + protected void validateOptionalWithItems(List> withItems) { + validateOptionalList(withItems, () -> getValidator(SelectValidator.class), + (w, v) -> w.accept((SelectVisitor) v, null)); + } + protected void validateOptionalFromItems(FromItem... fromItems) { validateOptionalFromItems(Arrays.asList(fromItems)); } 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..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 @@ -12,6 +12,7 @@ import static java.util.stream.Collectors.toList; import java.util.EnumSet; +import java.util.List; import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.statement.alter.Alter; import net.sf.jsqlparser.statement.alter.AlterExpression; @@ -19,7 +20,16 @@ import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDropNotNull; 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.alter.ColumnPosition; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.KeyColumnSource; +import net.sf.jsqlparser.statement.create.table.KeyElement; +import net.sf.jsqlparser.statement.create.table.ConstraintUsingIndex; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.TableElement; import net.sf.jsqlparser.util.TableDefinitionTraversal; import net.sf.jsqlparser.util.validation.ValidationCapability; import net.sf.jsqlparser.util.validation.ValidationUtil; @@ -42,6 +52,7 @@ public void validate(Alter alter) { public void validate(Alter alter, AlterExpression e) { TableDefinitionTraversal.visit(e, this::validateOptionalExpression, this::validateOptionalFromItem); + TableElement definition = e.getActiveTableDefinition(); for (ValidationCapability c : getCapabilities()) { validateOptionalColumnName(c, e.getColumnOldName()); @@ -57,47 +68,107 @@ public void validate(Alter alter, AlterExpression e) { ColumnSetNotNull::getColumnName)); } - if (e.getColDataTypeList() != null) { + if (e.hasActiveColumnDefinitions()) { boolean validateForExist = !EnumSet.of(AlterOperation.ADD).contains(e.getOperation()); validateOptionalColumnNames(c, ValidationUtil.map(e.getColDataTypeList(), ColumnDataType::getColumnName), validateForExist, NamedObject.table); + validateOptionalColumnNames(c, precedingColumnNames(e), NamedObject.table); } validateOptionalName(c, NamedObject.constraint, e.getConstraintName()); - if (e.getPkColumns() != null) { - validateOptionalColumnNames(c, e.getPkColumns()); + validateOptionalName(c, NamedObject.constraint, e.getNewConstraintName(), null, false, + NamedObject.table); + if (hasActiveDropColumns(e)) { + validateOptionalColumnNames(c, e.getDropColumns()); } - if (e.getFkColumns() != null) { - validateName(c, NamedObject.table, e.getFkSourceTable()); - validateOptionalColumnNames(c, e.getFkColumns()); - validateOptionalColumnNames(c, e.getFkSourceColumns()); + if (e.hasAddGroupElements()) { + for (TableElement element : e.getAddGroupElements()) { + validateConstraint(c, element); + validateIndex(c, e, element); + } + } else { + validateConstraint(c, definition); + validateIndex(c, e, definition); } + } + } - if (e.getUk()) { - validateName(c, NamedObject.uniqueConstraint, e.getUkName()); - validateOptionalColumnNames(c, e.getUkColumns(), NamedObject.uniqueConstraint); + private void validateConstraint(ValidationCapability capability, TableElement definition) { + if (!(definition instanceof NamedConstraint)) { + return; + } + NamedConstraint constraint = (NamedConstraint) definition; + validateOptionalName(capability, NamedObject.constraint, constraint.getName(), null, false, + NamedObject.table); + if (constraint instanceof ForeignKeyConstraint) { + validateOptionalColumnNames(capability, + ((ForeignKeyConstraint) constraint).getReferencedColumnNames()); + } + if (constraint instanceof KeyConstraint && constraint.getKind() == ConstraintKind.UNIQUE) { + validateOptionalName(capability, NamedObject.uniqueConstraint, + ((KeyConstraint) constraint).getIndexName(), null, false, NamedObject.table); + } + if (constraint instanceof ConstraintUsingIndex) { + validateName(capability, NamedObject.index, + ((ConstraintUsingIndex) constraint).getExistingIndexName()); + } + if (constraint instanceof KeyColumnSource) { + KeyColumnSource keys = (KeyColumnSource) constraint; + if (keys.getColumns() != null) { + validateOptionalColumnNames(capability, keys.getColumns().stream() + .filter(key -> !key.isExpression()).map(KeyElement::getColumnName) + .collect(toList()), NamedObject.constraint); } + } + } - if (e.getIndex() instanceof DefaultConstraint) { - validateOptionalName(c, NamedObject.constraint, e.getIndex().getName(), null, false, - NamedObject.table); - } else if (e.getIndex() != null) { - validateName(c, NamedObject.index, e.getIndex().getName()); - if (e.getIndex().getColumns() != null) { - validateOptionalColumnNames(c, - e.getIndex().getColumns().stream() - .filter(cp -> !cp.isExpression()) - .map(cp -> cp.getColumnName()) - .collect(toList()), - NamedObject.index); - } - } + private boolean hasActiveDropColumns(AlterExpression expression) { + if (expression.getOperation() == null || expression.getDropColumns() == null) { + return false; + } + switch (expression.getOperation()) { + case DROP: + return expression.getColumnName() == null && !expression.getDropColumns().isEmpty(); + case DROP_UNIQUE: + return true; + case DROP_FOREIGN_KEY: + return expression.getConstraintName() == null; + default: + return false; } } + private void validateIndex(ValidationCapability capability, AlterExpression expression, + TableElement definition) { + 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) { + return; + } + if (rename && expression.getOldIndex() != null) { + validateName(capability, NamedObject.index, expression.getOldIndex().getName()); + } + boolean introducedName = expression.getOperation() == AlterOperation.ADD || rename; + validateOptionalName(capability, NamedObject.index, index.getName(), null, !introducedName); + if (definition == index && index.getColumns() != null) { + validateOptionalColumnNames(capability, index.getColumns().stream() + .filter(key -> !key.isExpression()).map(KeyElement::getColumnName) + .collect(toList()), NamedObject.index); + } + } + /** Returns the existing columns named by AFTER positions. */ + private static List precedingColumnNames(AlterExpression expression) { + return expression.getColDataTypeList().stream().map(ColumnDataType::getPosition) + .filter(position -> position != null + && position.getKind() == ColumnPosition.Kind.AFTER) + .map(ColumnPosition::getColumnName).collect(toList()); + } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/ClusterValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/ClusterValidator.java new file mode 100644 index 0000000000..de3e495a35 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/ClusterValidator.java @@ -0,0 +1,28 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.maintenance.ClusterStatement; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; + +public class ClusterValidator extends AbstractValidator { + @Override + public void validate(ClusterStatement cluster) { + for (ValidationCapability c : getCapabilities()) { + validateFeature(c, Feature.cluster); + if (cluster.getTable() != null) { + validateName(c, NamedObject.table, cluster.getTable().getFullyQualifiedName(), + true); + } + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/CommentValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/CommentValidator.java index b5ad37f8bb..dcffd3e4a1 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/CommentValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/CommentValidator.java @@ -46,6 +46,68 @@ private static Feature targetFeature(CommentTarget.Kind kind) { return Feature.commentOnFunction; case CONSTRAINT: return Feature.commentOnConstraint; + case TRIGGER: + return Feature.commentOnTrigger; + case POLICY: + return Feature.commentOnPolicy; + case RULE: + return Feature.commentOnRule; + case PROCEDURE: + return Feature.commentOnProcedure; + case ROUTINE: + return Feature.commentOnRoutine; + case AGGREGATE: + return Feature.commentOnAggregate; + case CAST: + return Feature.commentOnCast; + case COLLATION: + return Feature.commentOnCollation; + case FOREIGN_TABLE: + return Feature.commentOnForeignTable; + case STATISTICS: + return Feature.commentOnStatistics; + case DATABASE: + return Feature.commentOnDatabase; + case ROLE: + return Feature.commentOnRole; + case TABLESPACE: + return Feature.commentOnTablespace; + case ACCESS_METHOD: + return Feature.commentOnAccessMethod; + case EXTENSION: + return Feature.commentOnExtension; + case FOREIGN_DATA_WRAPPER: + return Feature.commentOnForeignDataWrapper; + case LANGUAGE: + return Feature.commentOnLanguage; + case SERVER: + return Feature.commentOnServer; + case EVENT_TRIGGER: + return Feature.commentOnEventTrigger; + case PUBLICATION: + return Feature.commentOnPublication; + case SUBSCRIPTION: + return Feature.commentOnSubscription; + case OPERATOR: + return Feature.commentOnOperator; + case OPERATOR_CLASS: + return Feature.commentOnOperatorClass; + case OPERATOR_FAMILY: + return Feature.commentOnOperatorFamily; + case CONVERSION: + return Feature.commentOnConversion; + case LARGE_OBJECT: + return Feature.commentOnLargeObject; + case TRANSFORM: + return Feature.commentOnTransform; + case TEXT_SEARCH_CONFIGURATION: + return Feature.commentOnTextSearchConfiguration; + case TEXT_SEARCH_DICTIONARY: + return Feature.commentOnTextSearchDictionary; + case TEXT_SEARCH_PARSER: + return Feature.commentOnTextSearchParser; + case TEXT_SEARCH_TEMPLATE: + return Feature.commentOnTextSearchTemplate; default: throw new IllegalArgumentException("Unknown COMMENT target: " + kind); } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateIndexValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateIndexValidator.java index 2a6a5b447a..5d247036d2 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateIndexValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateIndexValidator.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.util.validation.validator; +import net.sf.jsqlparser.statement.create.table.KeyElement; import static java.util.stream.Collectors.toList; import net.sf.jsqlparser.parser.feature.Feature; @@ -34,7 +35,7 @@ public void validate(CreateIndex createIndex) { validateOptionalColumnNames(c, index.getColumns().stream() .filter(cp -> !cp.isExpression()) - .map(Index.ColumnParams::getColumnName) + .map(KeyElement::getColumnName) .collect(toList()), NamedObject.table); } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateTableValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateTableValidator.java index caead25b6b..32d5c24966 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateTableValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/CreateTableValidator.java @@ -12,6 +12,8 @@ import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.ConstraintDeclaration; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.util.TableDefinitionTraversal; import net.sf.jsqlparser.util.validation.ValidationCapability; import net.sf.jsqlparser.util.validation.metadata.NamedObject; @@ -40,6 +42,16 @@ public void validate(CreateTable createTable) { validateName(c, NamedObject.index, i.getName()); } } + for (ConstraintDeclaration declaration : createTable.getConstraints()) { + NamedConstraint constraint = declaration.getConstraint(); + String name = constraint != null ? constraint.getName() + : declaration.getColumnOption().getForeignKeyReference() != null + ? declaration.getColumnOption().getForeignKeyReference() + .getConstraintName() + : null; + validateOptionalName(c, NamedObject.constraint, name, null, false, + NamedObject.table); + } validateName(c, NamedObject.table, createTable.getTable().getFullyQualifiedName(), false); } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/DeleteValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/DeleteValidator.java index d030b9f309..176f65ce3b 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/DeleteValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/DeleteValidator.java @@ -33,6 +33,8 @@ public void validate(Delete delete) { Feature.deleteReturningExpressionList); } + validateOptionalWithItems(delete.getWithItemsList()); + SelectValidator v = getValidator(SelectValidator.class); delete.getTable().accept(v, null); @@ -45,6 +47,7 @@ public void validate(Delete delete) { validateOptionalOrderByElements(delete.getOrderByElements()); v.validateOptionalJoins(delete.getJoins()); + v.validateOptionalJoins(delete.getUsingJoins()); if (delete.getLimit() != null) { getValidator(LimitValidator.class).validate(delete.getLimit()); diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/ExecuteValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/ExecuteValidator.java index 968bd13b15..2b9ec640b5 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/ExecuteValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/ExecuteValidator.java @@ -31,10 +31,12 @@ public void validate(Execute execute) { Feature.executeExecute); validateFeature(c, ExecType.EXEC.equals(execute.getExecType()), Feature.executeExec); validateFeature(c, ExecType.CALL.equals(execute.getExecType()), Feature.executeCall); + validateFeature(c, execute.getUsingVariables() != null, Feature.executeUsing); validateName(NamedObject.procedure, execute.getName()); } validateOptionalExpression(execute.getExprList()); + validateOptionalExpression(execute.getUsingVariables()); } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/ExpressionValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/ExpressionValidator.java index 2e20fd69a1..53c3f4848a 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/ExpressionValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/ExpressionValidator.java @@ -48,6 +48,7 @@ import net.sf.jsqlparser.expression.KeepExpression; import net.sf.jsqlparser.expression.KeyExpression; import net.sf.jsqlparser.expression.LambdaExpression; +import net.sf.jsqlparser.expression.ListComprehension; import net.sf.jsqlparser.expression.LongValue; import net.sf.jsqlparser.expression.LowExpression; import net.sf.jsqlparser.expression.MapExpression; @@ -90,6 +91,7 @@ import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor; import net.sf.jsqlparser.expression.operators.arithmetic.Concat; import net.sf.jsqlparser.expression.operators.arithmetic.Division; +import net.sf.jsqlparser.expression.operators.arithmetic.Exponentiation; import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision; import net.sf.jsqlparser.expression.operators.arithmetic.Modulo; import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; @@ -115,6 +117,7 @@ import net.sf.jsqlparser.expression.operators.relational.Intersects; import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression; import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression; import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; import net.sf.jsqlparser.expression.operators.relational.IsUnknownExpression; import net.sf.jsqlparser.expression.operators.relational.JsonOperator; @@ -199,6 +202,12 @@ public Void visit(IntegerDivision division, S context) { return null; } + @Override + public Void visit(Exponentiation exponentiation, S context) { + visitBinaryExpression(exponentiation, " ** "); + return null; + } + @Override public Void visit(DoubleValue doubleValue, S context) { // nothing to validate @@ -315,6 +324,12 @@ public Void visit(IsUnknownExpression isUnknownExpression, S context) { return null; } + @Override + public Void visit(IsNormalizedExpression isNormalizedExpression, S context) { + isNormalizedExpression.getLeftExpression().accept(this, context); + return null; + } + @Override public Void visit(JdbcParameter jdbcParameter, S context) { validateFeature(Feature.jdbcParameter); @@ -1034,6 +1049,9 @@ public Void visit(ArrayExpression array, S context) { if (array.getStopIndexExpression() != null) { array.getStopIndexExpression().accept(this, context); } + if (array.getStepExpression() != null) { + array.getStepExpression().accept(this, context); + } return null; } @@ -1200,8 +1218,12 @@ public Void visit(TrimFunction trimFunction, S context) { @Override public Void visit(RangeExpression rangeExpression, S context) { - rangeExpression.getStartExpression().accept(this, context); - rangeExpression.getEndExpression().accept(this, context); + for (Expression bound : new Expression[] {rangeExpression.getStartExpression(), + rangeExpression.getEndExpression(), rangeExpression.getStepExpression()}) { + if (bound != null) { + bound.accept(this, context); + } + } return null; } @@ -1243,6 +1265,16 @@ public Void visit(LambdaExpression lambdaExpression, S context) { return null; } + @Override + public Void visit(ListComprehension listComprehension, S context) { + listComprehension.getExpression().accept(this, context); + listComprehension.getList().accept(this, context); + if (listComprehension.getCondition() != null) { + listComprehension.getCondition().accept(this, context); + } + return null; + } + @Override public Void visit(ColumnsExpression columnsExpression, S context) { for (Expression expression : columnsExpression.getAllExpressions()) { diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/GrantValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/GrantValidator.java index c37f214ad1..952163a67a 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/GrantValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/GrantValidator.java @@ -23,10 +23,15 @@ public class GrantValidator extends AbstractValidator { public void validate(Grant grant) { for (ValidationCapability c : getCapabilities()) { validateFeature(c, Feature.grant); - if (isNotEmpty(grant.getUsers())) { - grant.getUsers().forEach(u -> validateName(NamedObject.user, u)); + // PUBLIC and CURRENT_USER are not names + if (isNotEmpty(grant.getClause().getGranteeItems())) { + grant.getClause().getGranteeItems().stream() + .filter(grantee -> grantee.getAccount() != null) + .forEach(grantee -> validateName(NamedObject.user, + grantee.getAccount().toString())); } - grant.getRoles().forEach(role -> validateName(NamedObject.role, role)); + grant.getClause().getRoleItems() + .forEach(role -> validateName(NamedObject.role, role.toString())); grant.getClause().visit(this::validateOptionalFromItem, this::validateOptionalExpression); diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/InsertValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/InsertValidator.java index 717e10bf0d..943507e1a4 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/InsertValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/InsertValidator.java @@ -13,6 +13,7 @@ import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.OracleMultiInsertBranch; import net.sf.jsqlparser.statement.insert.OracleMultiInsertClause; +import net.sf.jsqlparser.statement.select.SelectVisitor; import net.sf.jsqlparser.statement.select.Values; import net.sf.jsqlparser.statement.update.UpdateSet; import net.sf.jsqlparser.util.validation.ValidationCapability; @@ -43,6 +44,8 @@ public void validate(Insert insert) { Feature.insertReturningExpressionList); } + validateOptionalWithItems(insert.getWithItemsList()); + if (insert.isOracleMultiInsert() && insert.getOracleMultiInsertBranches() != null) { ExpressionValidator v = getValidator(ExpressionValidator.class); for (OracleMultiInsertBranch branch : insert.getOracleMultiInsertBranches()) { @@ -70,6 +73,9 @@ public void validate(Insert insert) { if (insert.getSelect() instanceof Values) { insert.getSelect().accept(getValidator(StatementValidator.class), null); validateOptionalExpressions(insert.getValues().getExpressions()); + } else if (insert.getSelect() != null) { + insert.getSelect().accept( + (SelectVisitor) getValidator(SelectValidator.class), null); } if (insert.getSetUpdateSets() != null) { diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/LimitValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/LimitValidator.java index 7089d67e6d..8d001d88da 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/LimitValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/LimitValidator.java @@ -27,5 +27,8 @@ public void validate(Limit limit) { validateFeature(c, limit.isLimitAll(), Feature.limitAll); validateOptionalFeature(c, limit.getOffset(), Feature.limitOffset); } + + validateOptionalExpression(limit.getRowCount()); + validateOptionalExpression(limit.getOffset()); } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/MergeValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/MergeValidator.java index ab5dfa9b1d..d9ca48bdb8 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/MergeValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/MergeValidator.java @@ -26,6 +26,7 @@ public void validate(Merge merge) { for (ValidationCapability c : getCapabilities()) { validateFeature(c, Feature.merge); } + validateOptionalWithItems(merge.getWithItemsList()); if (merge.getReturningClause() != null) { SelectValidator validator = getValidator(SelectValidator.class); merge.getReturningClause().forEach(item -> item.accept(validator, null)); @@ -80,4 +81,10 @@ public Void visit(MergeInsert mergeInsert, S context) { public void visit(MergeInsert mergeInsert) { visit(mergeInsert, null); } + + @Override + public Void visit(MergeDoNothing mergeDoNothing, S context) { + validateOptionalExpression(mergeDoNothing.getAndPredicate()); + return null; + } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/MySqlShowStatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/MySqlShowStatementValidator.java new file mode 100644 index 0000000000..07b6b8d9a9 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/MySqlShowStatementValidator.java @@ -0,0 +1,31 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.show.MySqlShowStatement; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; + +public class MySqlShowStatementValidator extends AbstractValidator { + + @Override + public void validate(MySqlShowStatement show) { + for (ValidationCapability c : getCapabilities()) { + validateFeature(c, Feature.mySqlShow); + validateOptionalName(c, NamedObject.database, show.getDbName()); + if (show.getKind() == MySqlShowStatement.Kind.PROCEDURE_CODE + && show.getRoutineName() != null) { + validateName(c, NamedObject.procedure, + show.getRoutineName().getFullyQualifiedName()); + } + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/ResetStatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/ResetStatementValidator.java index 3a4efb95b6..83d3b80cb7 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/ResetStatementValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/ResetStatementValidator.java @@ -18,7 +18,7 @@ public class ResetStatementValidator extends AbstractValidator { @Override public void validate(ResetStatement reset) { for (ValidationCapability c : getCapabilities()) { - validateFeature(c, Feature.reset); + validateFeature(c, reset.isPersist() ? Feature.resetPersist : Feature.reset); } } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java index 8b593f14b4..2223d28ca9 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java @@ -15,6 +15,7 @@ import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.MySQLIndexHint; import net.sf.jsqlparser.expression.SQLServerHints; +import net.sf.jsqlparser.expression.WindowDefinition; import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.imprt.Import; @@ -22,6 +23,7 @@ import net.sf.jsqlparser.statement.select.ExceptOp; import net.sf.jsqlparser.statement.select.Fetch; import net.sf.jsqlparser.statement.select.ForMode; +import net.sf.jsqlparser.statement.select.ForUpdateClause; import net.sf.jsqlparser.statement.select.FromItemVisitor; import net.sf.jsqlparser.statement.select.InterpolateElement; import net.sf.jsqlparser.statement.select.IntersectOp; @@ -29,6 +31,7 @@ import net.sf.jsqlparser.statement.select.LateralSubSelect; import net.sf.jsqlparser.statement.select.MinusOp; import net.sf.jsqlparser.statement.select.MySqlSelectIntoClause; +import net.sf.jsqlparser.statement.select.MySqlSelectModifier; import net.sf.jsqlparser.statement.select.Offset; import net.sf.jsqlparser.statement.select.OptionClause; import net.sf.jsqlparser.statement.select.OptionHint; @@ -107,7 +110,15 @@ public Void visit(PlainSelect plainSelect, S context) { validateFeature(c, plainSelect.getMySqlSqlCacheFlag() != null, Feature.mysqlSqlCacheFlag); validateFeature(c, plainSelect.getMySqlSqlCalcFoundRows(), Feature.mysqlCalcFoundRows); - validateOptionalFeature(c, plainSelect.getIntoTables(), Feature.selectInto); + validateFeature(c, plainSelect.getMySqlSelectModifiers().stream() + .anyMatch(modifier -> modifier == MySqlSelectModifier.HIGH_PRIORITY + || modifier == MySqlSelectModifier.SQL_SMALL_RESULT + || modifier == MySqlSelectModifier.SQL_BIG_RESULT + || modifier == MySqlSelectModifier.SQL_BUFFER_RESULT), + Feature.mysqlSelectModifiers); + validateOptionalFeature(c, plainSelect.getIntoClause(), Feature.selectInto); + validateOptionalFeature(c, plainSelect.getMySqlSelectIntoClause(), + Feature.selectInto); validateOptionalFeature(c, plainSelect.getKsqlWindow(), Feature.kSqlWindow); validateFeature(c, isNotEmpty(plainSelect.getOrderByElements()) && plainSelect.isOracleSiblings(), @@ -132,6 +143,29 @@ public Void visit(PlainSelect plainSelect, S context) { validateOptionalFeature(c, plainSelect.getWait(), Feature.selectForUpdateWait); validateFeature(c, plainSelect.isNoWait(), Feature.selectForUpdateNoWait); validateFeature(c, plainSelect.isSkipLocked(), Feature.selectForUpdateSkipLocked); + + if (plainSelect.getAdditionalForUpdateClauses() != null) { + for (ForUpdateClause forUpdateClause : plainSelect + .getAdditionalForUpdateClauses()) { + validateFeature(c, forUpdateClause.getMode() == ForMode.KEY_SHARE, + Feature.selectForKeyShare); + validateFeature(c, forUpdateClause.getMode() == ForMode.NO_KEY_UPDATE, + Feature.selectForNoKeyUpdate); + validateFeature(c, forUpdateClause.getMode() == ForMode.SHARE, + Feature.selectForShare); + if (forUpdateClause.getTables() != null) { + forUpdateClause.getTables() + .forEach(t -> validateOptionalFeature(c, t, + Feature.selectForUpdateOfTable)); + } + validateOptionalFeature(c, forUpdateClause.getWait(), + Feature.selectForUpdateWait); + validateFeature(c, forUpdateClause.isNoWait(), + Feature.selectForUpdateNoWait); + validateFeature(c, forUpdateClause.isSkipLocked(), + Feature.selectForUpdateSkipLocked); + } + } } validateOptionalFeature(c, plainSelect.getForXmlPath(), Feature.selectForXmlPath); @@ -142,10 +176,17 @@ public Void visit(PlainSelect plainSelect, S context) { validateOptionalFromItems(plainSelect.getIntoTables()); validateOptionalJoins(plainSelect.getJoins()); - // to correctly recognize aliased tables - // @todo: fix this properly, I don't understand functional syntax - // validateOptionalList(plainSelect.getSelectItems(), () -> this, SelectItem::accept, - // context); + // after the FROM items, to correctly recognize aliased tables + if (plainSelect.getDistinct() != null + && isNotEmpty(plainSelect.getDistinct().getOnSelectItems())) { + plainSelect.getDistinct().getOnSelectItems() + .forEach(item -> item.accept(this, context)); + } + validateOptional(plainSelect.getTop(), + top -> validateOptionalExpression(top.getExpression())); + if (isNotEmpty(plainSelect.getSelectItems())) { + plainSelect.getSelectItems().forEach(item -> item.accept(this, context)); + } validateOptionalExpression(plainSelect.getPreWhere()); validateOptionalExpression(plainSelect.getWhere()); @@ -158,6 +199,13 @@ public Void visit(PlainSelect plainSelect, S context) { } validateOptionalExpression(plainSelect.getHaving()); + validateOptionalExpression(plainSelect.getQualify()); + if (isNotEmpty(plainSelect.getWindowDefinitions())) { + for (WindowDefinition windowDefinition : plainSelect.getWindowDefinitions()) { + validateOptionalExpressions(windowDefinition.getPartitionExpressionList()); + validateOptionalOrderByElements(windowDefinition.getOrderByElements()); + } + } validateOptionalOrderByElements(plainSelect.getOrderByElements()); validateOptionalInterpolate(plainSelect.getInterpolate()); validateOptionalOption(plainSelect.getOption()); @@ -276,9 +324,12 @@ public Void visit(Table table, S context) { validateOptional(table.getPivot(), p -> p.accept(this, context)); validateOptional(table.getUnPivot(), up -> up.accept(this, context)); - MySQLIndexHint indexHint = table.getIndexHint(); - if (indexHint != null && isNotEmpty(indexHint.getIndexNames())) { - indexHint.getIndexNames().forEach(i -> validateName(NamedObject.index, i)); + if (table.getIndexHints() != null) { + for (MySQLIndexHint indexHint : table.getIndexHints()) { + if (isNotEmpty(indexHint.getIndexNames())) { + indexHint.getIndexNames().forEach(i -> validateName(NamedObject.index, i)); + } + } } SQLServerHints sqlServerHints = table.getSqlServerHints(); if (sqlServerHints != null) { @@ -322,6 +373,8 @@ public void validateOffset(Offset offset) { validateFeature(c, Feature.offset); validateOptionalFeature(c, offset.getOffsetParam(), Feature.offsetParam); } + + validateOptionalExpression(offset.getOffset()); } public void validateFetch(Fetch fetch) { @@ -331,7 +384,7 @@ public void validateFetch(Fetch fetch) { validateFeature(c, !fetch.isFetchParamFirst(), Feature.fetchNext); } - validateOptionalExpression(fetch.getFetchJdbcParameter()); + validateOptionalExpression(fetch.getExpression()); } public void validateOptionalJoins(List joins) { @@ -450,6 +503,10 @@ public Void visit(LateralSubSelect lateralSubSelect, S context) { @Override public Void visit(TableStatement tableStatement, S context) { + if (isNotEmpty(tableStatement.getWithItemsList())) { + tableStatement.getWithItemsList() + .forEach(withItem -> withItem.accept((SelectVisitor) this, context)); + } getValidator(TableStatementValidator.class).validate(tableStatement); return null; } @@ -457,6 +514,7 @@ public Void visit(TableStatement tableStatement, S context) { @Override public Void visit(TableFunction tableFunction, S context) { validateFeature(Feature.tableFunction); + validateOptionalExpressions(tableFunction.getFunctions()); validateOptional(tableFunction.getPivot(), p -> p.accept(this, context)); validateOptional(tableFunction.getUnPivot(), up -> up.accept(this, context)); @@ -471,13 +529,17 @@ public Void visit(ParenthesedFromItem parenthesis, S context) { @Override public Void visit(Values values, S context) { + if (isNotEmpty(values.getWithItemsList())) { + values.getWithItemsList() + .forEach(withItem -> withItem.accept((SelectVisitor) this, context)); + } getValidator(ValuesStatementValidator.class).validate(values); return null; } @Override public Void visit(Import imprt, S context) { - // TODO: not yet implemented + validateFeature(Feature.imprt); return null; } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidator.java index ee2e7b6c3e..d62ced8a19 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidator.java @@ -26,6 +26,11 @@ public void validate(SetStatement set) { if (set.getOnOffOptions() != null) { validateFeature(c, Feature.sqlServerSetOptions); } + for (int i = 0; i < set.getCount(); i++) { + if (set.getAssignmentOperator(i) == SetStatement.AssignmentOperator.TO) { + validateFeature(c, Feature.setAssignmentTo); + } + } } for (int i = 0; i < set.getCount(); i++) { validateOptionalExpressions(set.getExpressions(i)); diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidator.java index e917d9e8ce..d1c0b7f7e9 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidator.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.util.validation.validator; import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.ShowColumnsStatement; import net.sf.jsqlparser.util.validation.metadata.NamedObject; @@ -20,6 +21,9 @@ public class ShowColumnsStatementValidator extends AbstractValidator { + + @Override + public void validate(ShowCreateStatement show) { + for (ValidationCapability c : getCapabilities()) { + validateFeature(c, Feature.showCreate); + NamedObject namedObject = namedObject(show.getObjectType()); + if (namedObject == NamedObject.database) { + validateOptionalName(c, namedObject, show.getDatabaseName()); + } else if (namedObject != null && show.getName() != null) { + validateName(c, namedObject, show.getName().getFullyQualifiedName()); + } + } + } + + /** The metadata kind checked for the shown object, or null if there is none. */ + private static NamedObject namedObject(ShowCreateStatement.ObjectType type) { + if (type == null) { + return null; + } + switch (type) { + case TABLE: + return NamedObject.table; + case VIEW: + return NamedObject.view; + case PROCEDURE: + return NamedObject.procedure; + case DATABASE: + return NamedObject.database; + default: + // functions, triggers, events and accounts are not looked up + return null; + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidator.java index 8a35faffb3..004abf5e00 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidator.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.util.validation.validator; import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.show.ShowIndexStatement; import net.sf.jsqlparser.util.validation.metadata.NamedObject; @@ -21,6 +22,9 @@ public class ShowIndexStatementValidator extends AbstractValidator { + + @Override + public void validate(ShowTableStatusStatement show) { + for (ValidationCapability c : getCapabilities()) { + validateFeature(c, Feature.showTableStatus); + validateOptionalName(c, NamedObject.database, show.getDbName()); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java index 0b8d2765d5..3adb413584 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java @@ -9,6 +9,54 @@ */ package net.sf.jsqlparser.util.validation.validator; +import net.sf.jsqlparser.statement.alter.AlterRelation; +import net.sf.jsqlparser.statement.create.operator.CreateOperator; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorClass; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorFamily; +import net.sf.jsqlparser.statement.create.aggregate.CreateAggregate; +import net.sf.jsqlparser.statement.alter.AlterOperator; +import net.sf.jsqlparser.statement.alter.AlterOperatorClass; +import net.sf.jsqlparser.statement.alter.AlterOperatorFamily; +import net.sf.jsqlparser.statement.alter.AlterAggregate; +import net.sf.jsqlparser.statement.alter.AlterRule; +import net.sf.jsqlparser.statement.create.cast.CreateCast; +import net.sf.jsqlparser.statement.create.transform.CreateTransform; +import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; +import net.sf.jsqlparser.statement.alter.AlterConversion; +import net.sf.jsqlparser.statement.alter.AlterTablespace; +import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; +import net.sf.jsqlparser.statement.alter.AlterPolicy; +import net.sf.jsqlparser.statement.alter.AlterStatistics; +import net.sf.jsqlparser.statement.drop.DropPolicy; +import net.sf.jsqlparser.statement.drop.DropUserMapping; +import net.sf.jsqlparser.statement.create.statistics.CreateStatistics; + +import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; + +import net.sf.jsqlparser.statement.create.fdw.CreateForeignDataWrapper; +import net.sf.jsqlparser.statement.alter.AlterForeignDataWrapper; +import net.sf.jsqlparser.statement.create.server.CreateServer; +import net.sf.jsqlparser.statement.alter.AlterServer; +import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping; +import net.sf.jsqlparser.statement.alter.AlterUserMapping; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.rule.CreateRule; +import net.sf.jsqlparser.statement.notify.ListenStatement; +import net.sf.jsqlparser.statement.notify.NotifyStatement; +import net.sf.jsqlparser.statement.create.collation.CreateCollation; +import net.sf.jsqlparser.statement.alter.AlterCollation; +import net.sf.jsqlparser.statement.alter.AlterRoutine; +import net.sf.jsqlparser.statement.alter.AlterTrigger; import net.sf.jsqlparser.statement.alter.schema.AlterSchema; import net.sf.jsqlparser.statement.oracle.OracleBlock; import net.sf.jsqlparser.statement.oracle.OracleAssignment; @@ -16,6 +64,7 @@ import net.sf.jsqlparser.statement.role.CreateRole; import net.sf.jsqlparser.statement.role.AlterRole; +import net.sf.jsqlparser.statement.role.ReassignOwned; import net.sf.jsqlparser.statement.role.RoleOption; import net.sf.jsqlparser.statement.grant.Revoke; import net.sf.jsqlparser.statement.grant.AlterDefaultPrivileges; @@ -35,10 +84,13 @@ import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.statement.Block; import net.sf.jsqlparser.statement.Commit; +import net.sf.jsqlparser.statement.StartTransaction; +import net.sf.jsqlparser.statement.ReleaseSavepointStatement; import net.sf.jsqlparser.statement.CreateFunctionalStatement; import net.sf.jsqlparser.statement.DoStatement; import net.sf.jsqlparser.statement.DeclareStatement; import net.sf.jsqlparser.statement.DescribeStatement; +import net.sf.jsqlparser.statement.DiscardStatement; import net.sf.jsqlparser.statement.ExplainStatement; import net.sf.jsqlparser.statement.IfElseStatement; import net.sf.jsqlparser.statement.PurgeStatement; @@ -46,7 +98,12 @@ import net.sf.jsqlparser.statement.RollbackStatement; import net.sf.jsqlparser.statement.SavepointStatement; import net.sf.jsqlparser.statement.SessionStatement; +import net.sf.jsqlparser.statement.SetConstraintsStatement; import net.sf.jsqlparser.statement.SetStatement; +import net.sf.jsqlparser.statement.SetDefaultRoleStatement; +import net.sf.jsqlparser.statement.SetPasswordStatement; +import net.sf.jsqlparser.statement.SetRoleStatement; +import net.sf.jsqlparser.statement.SetTransactionStatement; import net.sf.jsqlparser.statement.ShowColumnsStatement; import net.sf.jsqlparser.statement.ShowStatement; import net.sf.jsqlparser.statement.Statement; @@ -54,15 +111,25 @@ import net.sf.jsqlparser.statement.Statements; import net.sf.jsqlparser.statement.UnsupportedStatement; import net.sf.jsqlparser.statement.UseStatement; +import net.sf.jsqlparser.statement.XaStatement; import net.sf.jsqlparser.statement.SetIdentityInsertStatement; +import net.sf.jsqlparser.statement.SetScope; +import net.sf.jsqlparser.statement.TableMaintenanceStatement; +import net.sf.jsqlparser.statement.TransactionCompletionStatement; +import net.sf.jsqlparser.statement.TransactionMode; import net.sf.jsqlparser.statement.alter.Alter; import net.sf.jsqlparser.statement.alter.AlterSession; +import net.sf.jsqlparser.statement.alter.AlterEventTrigger; +import net.sf.jsqlparser.statement.alter.AlterInstance; import net.sf.jsqlparser.statement.alter.AlterSystemStatement; import net.sf.jsqlparser.statement.alter.RenameTableStatement; +import net.sf.jsqlparser.statement.alter.AlterUser; +import net.sf.jsqlparser.statement.alter.RenameUser; import net.sf.jsqlparser.statement.alter.sequence.AlterSequence; import net.sf.jsqlparser.statement.analyze.Analyze; import net.sf.jsqlparser.statement.comment.Comment; import net.sf.jsqlparser.statement.create.database.CreateDatabase; +import net.sf.jsqlparser.statement.alter.database.AlterDatabase; import net.sf.jsqlparser.statement.create.event.AlterEvent; import net.sf.jsqlparser.statement.create.event.CreateEvent; import net.sf.jsqlparser.statement.create.function.CreateFunction; @@ -73,6 +140,9 @@ import net.sf.jsqlparser.statement.create.sequence.CreateSequence; import net.sf.jsqlparser.statement.create.synonym.CreateSynonym; import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.spatial.CreateSpatialReferenceSystem; +import net.sf.jsqlparser.statement.create.tablespace.CreateTablespace; +import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger; import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; import net.sf.jsqlparser.statement.create.user.CreateUser; import net.sf.jsqlparser.statement.create.view.AlterView; @@ -82,22 +152,45 @@ import net.sf.jsqlparser.statement.drop.Drop; import net.sf.jsqlparser.statement.execute.Execute; import net.sf.jsqlparser.statement.export.Export; +import net.sf.jsqlparser.statement.foreign.ImportForeignSchema; import net.sf.jsqlparser.statement.grant.Grant; import net.sf.jsqlparser.statement.imprt.Import; import net.sf.jsqlparser.statement.insert.Insert; import net.sf.jsqlparser.statement.insert.InsertBulk; import net.sf.jsqlparser.statement.insert.ParenthesedInsert; +import net.sf.jsqlparser.statement.admin.FlushStatement; +import net.sf.jsqlparser.statement.admin.KillStatement; +import net.sf.jsqlparser.statement.handler.HandlerStatement; +import net.sf.jsqlparser.statement.lock.BackupLockStatement; import net.sf.jsqlparser.statement.lock.LockStatement; +import net.sf.jsqlparser.statement.lock.UnlockStatement; +import net.sf.jsqlparser.statement.replication.ChangeReplicationFilterStatement; +import net.sf.jsqlparser.statement.replication.ChangeReplicationSourceStatement; +import net.sf.jsqlparser.statement.replication.ResetReplicationStatement; +import net.sf.jsqlparser.statement.replication.StartReplicaStatement; +import net.sf.jsqlparser.statement.replication.StopReplicaStatement; +import net.sf.jsqlparser.statement.maintenance.CheckpointStatement; +import net.sf.jsqlparser.statement.maintenance.ClusterStatement; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement; import net.sf.jsqlparser.statement.merge.Merge; import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement; +import net.sf.jsqlparser.statement.reindex.Reindex; +import net.sf.jsqlparser.statement.resourcegroup.AlterResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.CreateResourceGroup; +import net.sf.jsqlparser.statement.resourcegroup.SetResourceGroup; +import net.sf.jsqlparser.statement.securitylabel.SecurityLabel; import net.sf.jsqlparser.statement.select.Select; import net.sf.jsqlparser.statement.select.SelectVisitor; +import net.sf.jsqlparser.statement.show.MySqlShowStatement; +import net.sf.jsqlparser.statement.show.ShowCreateStatement; import net.sf.jsqlparser.statement.show.ShowIndexStatement; +import net.sf.jsqlparser.statement.show.ShowTableStatusStatement; import net.sf.jsqlparser.statement.show.ShowTablesStatement; import net.sf.jsqlparser.statement.truncate.Truncate; import net.sf.jsqlparser.statement.update.ParenthesedUpdate; import net.sf.jsqlparser.statement.update.Update; import net.sf.jsqlparser.statement.upsert.Upsert; +import net.sf.jsqlparser.util.validation.ValidationUtil; import net.sf.jsqlparser.util.validation.metadata.NamedObject; import net.sf.jsqlparser.statement.PragmaStatement; import net.sf.jsqlparser.statement.ExtensionStatement; @@ -106,13 +199,21 @@ import net.sf.jsqlparser.statement.ConnectStatement; import net.sf.jsqlparser.statement.DisconnectStatement; import net.sf.jsqlparser.statement.PrepareStatement; +import net.sf.jsqlparser.statement.PluginStatement; +import net.sf.jsqlparser.statement.PrepareTransactionStatement; import net.sf.jsqlparser.statement.DeallocateStatement; import net.sf.jsqlparser.statement.CopyStatement; import net.sf.jsqlparser.statement.create.macro.CreateMacro; import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository; +import net.sf.jsqlparser.statement.cursor.CloseCursorStatement; +import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement; +import net.sf.jsqlparser.statement.cursor.FetchCursorStatement; import net.sf.jsqlparser.statement.AssertStatement; import net.sf.jsqlparser.statement.export.ExportDataStatement; import net.sf.jsqlparser.statement.load.LoadDataStatement; +import net.sf.jsqlparser.statement.load.MySqlLoadDataStatement; + +import java.util.List; /** * @author gitmotte @@ -133,9 +234,7 @@ public Void visit(CreateTable createTable, S context) { @Override public Void visit(CreateTrigger createTrigger, S context) { - if (createTrigger.getRoutine() != null) { - validateFeature(Feature.createTrigger); - } + validateFeature(Feature.createTrigger); createTrigger.visit(this::validateOptionalFromItem, this::validateOptionalExpression); if (createTrigger.getBody() != null) { @@ -144,6 +243,52 @@ public Void visit(CreateTrigger createTrigger, S context) { return null; } + @Override + public Void visit(CreateEventTrigger statement, S context) { + // the filter values are tags and the function is declared, not called + validateFeature(Feature.createEventTrigger); + return null; + } + + @Override + public Void visit(AlterEventTrigger statement, S context) { + validateFeature(Feature.alterEventTrigger); + return null; + } + + @Override + public Void visit(Reindex statement, S context) { + validateFeature(Feature.reindex); + if (statement.isConcurrently() || statement.getOptions().stream() + .anyMatch(option -> option.getName() == Reindex.Option.Name.CONCURRENTLY)) { + validateFeature(Feature.reindexConcurrently); + } + if (statement.getName() != null) { + validateName(reindexedObject(statement.getTarget()), + statement.getName().getFullyQualifiedName()); + } + return null; + } + + private static NamedObject reindexedObject(Reindex.Target target) { + switch (target) { + case INDEX: + return NamedObject.index; + case TABLE: + return NamedObject.table; + case SCHEMA: + return NamedObject.schema; + default: + return NamedObject.database; + } + } + + @Override + public Void visit(SecurityLabel statement, S context) { + validateFeature(Feature.securityLabel); + return null; + } + @Override public Void visit(CreateView createView, S context) { getValidator(CreateViewValidator.class).validate(createView); @@ -175,6 +320,7 @@ public Void visit(ParenthesedDelete delete, S context) { @Override public Void visit(SessionStatement sessionStatement, S context) { + validateFeature(Feature.session); return null; } @@ -185,6 +331,12 @@ public Void visit(Drop drop, S context) { return null; } + @Override + public Void visit(ReassignOwned statement, S context) { + validateFeature(Feature.reassignOwned); + return null; + } + @Override public Void visit(Insert insert, S context) { getValidator(InsertValidator.class).validate(insert); @@ -208,7 +360,7 @@ public Void visit(Select select, S context) { @Override public Void visit(Truncate truncate, S context) { validateFeature(Feature.truncate); - validateOptionalFromItem(truncate.getTable()); + truncate.getTables().forEach(this::validateOptionalFromItem); return null; } @@ -231,6 +383,7 @@ public Void visit(Alter alter, S context) { @Override public Void visit(AlterEvent alterEvent, S context) { + validateFeature(Feature.alterEvent); if (alterEvent.getBody() != null) { alterEvent.getBody().accept(this, context); } @@ -252,6 +405,9 @@ public Void visit(Execute execute, S context) { @Override public Void visit(DoStatement statement, S context) { validateFeature(Feature.doStatement); + if (statement.getSelectItems() != null) { + statement.visitExpressions(this::validateOptionalExpression); + } return null; } @@ -279,12 +435,129 @@ public Void visit(Merge merge, S context) { return null; } + @Override + public Void visit(StartTransaction statement, S context) { + validateFeature(Feature.startTransaction); + validateTransactionModes(statement.getModes(), statement.getModeContext()); + return null; + } + + /** + * Checks the mode features of BEGIN, START TRANSACTION and SET TRANSACTION. An isolation level + * is a feature of BEGIN and START TRANSACTION only, since SET TRANSACTION exists to set it. + */ + private void validateTransactionModes(List modes, + TransactionMode.Context context) { + for (TransactionMode mode : modes) { + if (mode.isIsolationLevel()) { + if (context != TransactionMode.Context.SET_TRANSACTION) { + validateFeature(Feature.transactionIsolationLevel); + } + } else if (mode.isDeferrability()) { + validateFeature(Feature.transactionDeferrable); + } else if (mode == TransactionMode.WITH_CONSISTENT_SNAPSHOT) { + validateFeature(Feature.transactionConsistentSnapshot); + } + } + } + + @Override + public Void visit(ReleaseSavepointStatement statement, S context) { + validateFeature(Feature.releaseSavepoint); + return null; + } + + @Override + public Void visit(SetTransactionStatement statement, S context) { + validateFeature(Feature.setTransaction); + if (statement.getScope() == SetScope.GLOBAL) { + validateFeature(Feature.setTransactionGlobal); + } else if (statement.getScope() == SetScope.PERSIST + || statement.getScope() == SetScope.PERSIST_ONLY) { + validateFeature(Feature.setTransactionPersist); + } + if (statement.isSessionCharacteristics()) { + validateFeature(Feature.setTransactionSessionCharacteristics); + } + if (statement.getSnapshotId() != null) { + validateFeature(Feature.setTransactionSnapshot); + } + validateTransactionModes(statement.getModes(), TransactionMode.Context.SET_TRANSACTION); + return null; + } + + @Override + public Void visit(SetConstraintsStatement statement, S context) { + validateFeature(Feature.setConstraints); + return null; + } + + @Override + public Void visit(PrepareTransactionStatement statement, S context) { + validateFeature(Feature.twoPhaseCommit); + return null; + } + + @Override + public Void visit(XaStatement statement, S context) { + validateFeature(Feature.xa); + return null; + } + + @Override + public Void visit(CreateResourceGroup statement, S context) { + validateFeature(Feature.createResourceGroup); + return null; + } + + @Override + public Void visit(AlterResourceGroup statement, S context) { + validateFeature(Feature.alterResourceGroup); + return null; + } + + @Override + public Void visit(SetResourceGroup statement, S context) { + validateFeature(Feature.setResourceGroup); + return null; + } + + @Override + public Void visit(PluginStatement statement, S context) { + validateFeature(statement.getObjectType() == PluginStatement.ObjectType.COMPONENT + ? Feature.installComponent + : Feature.installPlugin); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + @Override public Void visit(Commit commit, S context) { validateFeature(Feature.commit); + validateTransactionCompletion(commit); return null; } + /** + * Checks the clauses shared by COMMIT and ROLLBACK and their END and ABORT spellings. Oracle's + * ROLLBACK FORCE has no feature of its own. + */ + private void validateTransactionCompletion(TransactionCompletionStatement statement) { + if (statement + .getPreparedTransactionKeyword() == TransactionCompletionStatement.PreparedTransactionKeyword.PREPARED) { + validateFeature(Feature.twoPhaseCommit); + } + if (statement.isPostgresSpelling()) { + validateFeature(Feature.transactionEndAbort); + } + if (statement.getChain() != null) { + validateFeature(Feature.transactionChain); + } + if (statement.getRelease() != null) { + validateFeature(Feature.transactionRelease); + } + } + @Override public Void visit(Upsert upsert, S context) { getValidator(UpsertValidator.class).validate(upsert); @@ -327,6 +600,24 @@ public Void visit(ShowTablesStatement showTables, S context) { return null; } + @Override + public Void visit(ShowTableStatusStatement showTableStatus, S context) { + getValidator(ShowTableStatusStatementValidator.class).validate(showTableStatus); + return null; + } + + @Override + public Void visit(ShowCreateStatement showCreate, S context) { + getValidator(ShowCreateStatementValidator.class).validate(showCreate); + return null; + } + + @Override + public Void visit(MySqlShowStatement mySqlShow, S context) { + getValidator(MySqlShowStatementValidator.class).validate(mySqlShow); + return null; + } + @Override public Void visit(Block block, S context) { validateFeature(Feature.block); @@ -384,13 +675,56 @@ public Void visit(CreateDatabase aThis, S context) { return null; } + @Override + public Void visit(AlterDatabase statement, S context) { + validateFeature(Feature.alterDatabase); + if (statement.getParameterChange() != null + && statement.getParameterChange().getValues() != null) { + statement.getParameterChange().getValues().forEach(this::validateOptionalExpression); + } + return null; + } + @Override public Void visit(CreateUser createUser, S context) { + validateFeature(Feature.createUser); + return null; + } + + @Override + public Void visit(AlterUser alterUser, S context) { + validateFeature(Feature.alterUser); + return null; + } + + @Override + public Void visit(RenameUser renameUser, S context) { + validateFeature(Feature.renameUser); + return null; + } + + @Override + public Void visit(SetRoleStatement setRole, S context) { + validateFeature(Feature.setRole); + return null; + } + + @Override + public Void visit(SetDefaultRoleStatement setDefaultRole, S context) { + validateFeature(Feature.setDefaultRole); + return null; + } + + @Override + public Void visit(SetPasswordStatement setPassword, S context) { + validateFeature(Feature.setPassword); + validateOptionalExpression(setPassword.getPassword()); return null; } @Override public Void visit(CreateEvent createEvent, S context) { + validateFeature(Feature.createEvent); if (createEvent.getBody() != null) { createEvent.getBody().accept(this, context); } @@ -454,21 +788,78 @@ public Void visit(Analyze analyze, S context) { return null; } + @Override + public Void visit(TableMaintenanceStatement statement, S context) { + getValidator(TableMaintenanceValidator.class).validate(statement); + return null; + } + + @Override + public Void visit(FlushStatement flush, S context) { + validateFeature(Feature.flush); + for (Table table : flush.getTables()) { + validateName(NamedObject.table, table.getFullyQualifiedName()); + } + return null; + } + + @Override + public Void visit(KillStatement kill, S context) { + validateFeature(Feature.kill); + validateOptionalExpression(kill.getProcesslistId()); + return null; + } + + @Override + public Void visit(HandlerStatement handler, S context) { + validateFeature(Feature.handler); + if (handler.getAction() == HandlerStatement.Action.OPEN) { + Table table = handler.getTable(); + validateNameWithAlias(NamedObject.table, table.getFullyQualifiedName(), + ValidationUtil.getAlias(table.getAlias())); + } + validateOptionalExpression(handler.getKeyValues()); + validateOptionalExpression(handler.getWhere()); + return null; + } + + @Override + public Void visit(VacuumStatement vacuum, S context) { + getValidator(VacuumValidator.class).validate(vacuum); + return null; + } + + @Override + public Void visit(ClusterStatement cluster, S context) { + getValidator(ClusterValidator.class).validate(cluster); + return null; + } + + @Override + public Void visit(CheckpointStatement checkpoint, S context) { + validateFeature(Feature.checkpoint); + return null; + } + @Override public Void visit(SavepointStatement savepointStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.savepoint); return null; } @Override public Void visit(RollbackStatement rollbackStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.rollback); + if (rollbackStatement.getSavepointName() != null) { + validateFeature(Feature.savepoint); + } + validateTransactionCompletion(rollbackStatement); return null; } @Override public Void visit(AlterSession alterSession, S context) { - // TODO: not yet implemented + validateFeature(Feature.alterSession); return null; } @@ -482,127 +873,210 @@ public Void visit(IfElseStatement ifElseStatement, S context) { } public Void visit(RenameTableStatement renameTableStatement, S context) { - // TODO: not yet implemented + // the same operation as ALTER TABLE ... RENAME TO + validateFeature(Feature.alterTable); return null; } @Override public Void visit(PragmaStatement pragmaStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.pragma); return null; } @Override public Void visit(AssertStatement assertStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.assertStatement); return null; } @Override public Void visit(ExtensionStatement extensionStatement, S context) { - // TODO: not yet implemented + validateFeature(extensionStatement.getOperation() == ExtensionStatement.Operation.LOAD + ? Feature.loadExtension + : Feature.installExtension); return null; } @Override public Void visit(ExportDataStatement exportDataStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.export); return null; } @Override public Void visit(AttachStatement attachStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.attach); return null; } @Override public Void visit(DetachStatement detachStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.detach); return null; } @Override public Void visit(ConnectStatement connectStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.connect); return null; } @Override public Void visit(DisconnectStatement disconnectStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.disconnect); return null; } @Override public Void visit(PrepareStatement prepareStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.prepare); + validateOptionalExpression(prepareStatement.getSource()); return null; } @Override public Void visit(DeallocateStatement deallocateStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.deallocate); return null; } @Override public Void visit(CopyStatement copyStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.copy); return null; } @Override public Void visit(CreateMacro createMacro, S context) { - // TODO: not yet implemented + validateFeature(Feature.createMacro); return null; } @Override public Void visit(CreateExtensionRepository createExtensionRepository, S context) { - // TODO: not yet implemented + validateFeature(Feature.createExtensionRepository); return null; } @Override public Void visit(LoadDataStatement loadDataStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.loadData); + return null; + } + + @Override + public Void visit(MySqlLoadDataStatement loadData, S context) { + validateFeature(Feature.loadData); + validateOptionalFromItem(loadData.getTable()); + validateOptionalExpressions(loadData.getColumns()); + validateOptionalUpdateSets(loadData.getUpdateSets()); return null; } @Override public Void visit(PurgeStatement purgeStatement, S context) { - // TODO: not yet implemented + validateFeature(purgeStatement.getLogBound() != null ? Feature.purgeBinaryLogs + : Feature.purge); return null; } @Override public Void visit(AlterSystemStatement alterSystemStatement, S context) { - // TODO: not yet implemented + validateFeature(Feature.alterSystem); return null; } @Override public Void visit(UnsupportedStatement unsupportedStatement, S context) { - + // its tokens are not modelled, so nothing inside it can be validated + validateFeature(Feature.allowUnsupportedStatements); return null; } @Override public Void visit(Import imprt, S context) { - // TODO: not yet implemented + validateFeature(Feature.imprt); return null; } @Override public Void visit(Export export, S context) { - // TODO: not yet implemented + validateFeature(Feature.export); return null; } @Override public Void visit(LockStatement lock, S context) { - // TODO: not yet implemented + validateFeature(Feature.lock); + for (LockStatement.Target target : lock.getTargets()) { + Table table = target.getTable(); + validateNameWithAlias(NamedObject.table, table.getFullyQualifiedName(), + ValidationUtil.getAlias(table.getAlias())); + } + return null; + } + + @Override + public Void visit(UnlockStatement unlock, S context) { + validateFeature(Feature.unlockTables); + return null; + } + + @Override + public Void visit(BackupLockStatement backupLock, S context) { + validateFeature(Feature.backupLock); + return null; + } + + @Override + public Void visit(ChangeReplicationSourceStatement changeReplicationSource, S context) { + validateFeature(Feature.changeReplicationSource); + return null; + } + + @Override + public Void visit(ChangeReplicationFilterStatement changeReplicationFilter, S context) { + validateFeature(Feature.changeReplicationFilter); + return null; + } + + @Override + public Void visit(StartReplicaStatement startReplica, S context) { + validateFeature(Feature.startReplica); + return null; + } + + @Override + public Void visit(StopReplicaStatement stopReplica, S context) { + validateFeature(Feature.stopReplica); + return null; + } + + @Override + public Void visit(ResetReplicationStatement resetReplication, S context) { + validateFeature(Feature.resetReplication); + return null; + } + + @Override + public Void visit(DeclareCursorStatement declareCursor, S context) { + validateFeature(Feature.declareCursor); + if (declareCursor.getQuery() != null) { + visit(declareCursor.getQuery(), context); + } + return null; + } + + @Override + public Void visit(FetchCursorStatement fetchCursor, S context) { + validateFeature(Feature.fetchCursor); + return null; + } + + @Override + public Void visit(CloseCursorStatement closeCursor, S context) { + validateFeature(Feature.closeCursor); return null; } @@ -638,6 +1112,10 @@ public void visit(Drop drop) { visit(drop, null); } + public void visit(ReassignOwned statement) { + visit(statement, null); + } + public void visit(Insert insert) { visit(insert, null); } @@ -710,6 +1188,21 @@ public void visit(ShowTablesStatement showTables) { visit(showTables, null); } + @Override + public void visit(ShowTableStatusStatement showTableStatus) { + visit(showTableStatus, null); + } + + @Override + public void visit(ShowCreateStatement showCreate) { + visit(showCreate, null); + } + + @Override + public void visit(MySqlShowStatement mySqlShow) { + visit(mySqlShow, null); + } + public void visit(Block block) { visit(block, null); } @@ -742,6 +1235,26 @@ public void visit(CreateUser createUser) { visit(createUser, null); } + public void visit(AlterUser alterUser) { + visit(alterUser, null); + } + + public void visit(RenameUser renameUser) { + visit(renameUser, null); + } + + public void visit(SetRoleStatement setRole) { + visit(setRole, null); + } + + public void visit(SetDefaultRoleStatement setDefaultRole) { + visit(setDefaultRole, null); + } + + public void visit(SetPasswordStatement setPassword) { + visit(setPassword, null); + } + public void visit(CreateEvent createEvent) { visit(createEvent, null); } @@ -766,6 +1279,26 @@ public void visit(Analyze analyze) { visit(analyze, null); } + @Override + public void visit(TableMaintenanceStatement statement) { + visit(statement, null); + } + + @Override + public void visit(VacuumStatement vacuum) { + visit(vacuum, null); + } + + @Override + public void visit(ClusterStatement cluster) { + visit(cluster, null); + } + + @Override + public void visit(CheckpointStatement checkpoint) { + visit(checkpoint, null); + } + public void visit(SavepointStatement savepointStatement) { visit(savepointStatement, null); } @@ -842,6 +1375,10 @@ public void visit(LoadDataStatement loadDataStatement) { visit(loadDataStatement, null); } + public void visit(MySqlLoadDataStatement loadData) { + visit(loadData, null); + } + public void visit(PurgeStatement purgeStatement) { visit(purgeStatement, null); } @@ -864,6 +1401,7 @@ public void visit(Export export) { @Override public Void visit(CreatePolicy createPolicy, S context) { + validateFeature(Feature.createPolicy); validateOptionalFromItem(createPolicy.getTable()); validateOptionalExpression(createPolicy.getUsingExpression()); validateOptionalExpression(createPolicy.getWithCheckExpression()); @@ -1024,4 +1562,356 @@ public Void visit(OracleNullStatement statement, S context) { return null; } + + @Override + public Void visit(CreateForeignDataWrapper statement, S context) { + validateFeature(Feature.createForeignDataWrapper); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(AlterForeignDataWrapper statement, S context) { + validateFeature(Feature.alterForeignDataWrapper); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(CreateServer statement, S context) { + validateFeature(Feature.createServer); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(AlterServer statement, S context) { + validateFeature(Feature.alterServer); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(CreateUserMapping statement, S context) { + validateFeature(Feature.createUserMapping); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(AlterUserMapping statement, S context) { + validateFeature(Feature.alterUserMapping); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(ImportForeignSchema statement, S context) { + validateFeature(Feature.importForeignSchema); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(DropUserMapping statement, S context) { + validateFeature(Feature.drop); + return null; + } + + @Override + public Void visit(CreateAccessMethod statement, S context) { + validateFeature(Feature.createAccessMethod); + if (statement.getType() == CreateAccessMethod.Type.TABLE) { + validateFeature(Feature.createAccessMethodTable); + } + return null; + } + + @Override + public Void visit(CreateTextSearchConfiguration statement, S context) { + validateFeature(Feature.createTextSearchConfiguration); + return null; + } + + @Override + public Void visit(AlterTextSearchConfiguration statement, S context) { + validateFeature(Feature.alterTextSearchConfiguration); + return null; + } + + @Override + public Void visit(CreateRule statement, S context) { + validateFeature(Feature.createRule); + statement.visitExpressions(this::validateOptionalExpression); + statement.visitTables(this::validateOptionalFromItem); + statement.getActions().forEach(action -> action.accept(this, context)); + return null; + } + + @Override + public Void visit(NotifyStatement statement, S context) { + validateFeature(Feature.notifyStatement); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(ListenStatement listen, S context) { + validateFeature(Feature.listen); + return null; + } + + @Override + public Void visit(DiscardStatement discard, S context) { + validateFeature(Feature.discard); + return null; + } + + @Override + public Void visit(CreateCollation statement, S context) { + validateFeature(Feature.createCollation); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(AlterCollation statement, S context) { + validateFeature(Feature.alterCollation); + return null; + } + + @Override + public Void visit(AlterRoutine statement, S context) { + switch (statement.getRoutineType()) { + case PROCEDURE: + validateFeature(Feature.alterProcedure); + break; + case ROUTINE: + validateFeature(Feature.alterRoutine); + break; + default: + validateFeature(Feature.alterFunction); + } + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(AlterTrigger statement, S context) { + validateFeature(Feature.alterTrigger); + validateOptionalFromItem(statement.getTable()); + return null; + } + + @Override + public Void visit(AlterRelation statement, S context) { + boolean index = statement.getObjectType() == AlterRelation.ObjectType.INDEX; + validateFeature(index ? Feature.alterIndex : Feature.alterView); + if (!index) { + validateOptionalFromItem(statement.getRelation()); + } + statement.getActions().forEach(action -> { + action.visitExpressions(this::validateOptionalExpression); + action.visitTables(this::validateOptionalFromItem); + }); + return null; + } + + @Override + public Void visit(CreateTablespace statement, S context) { + validateFeature(Feature.createTablespace); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(CreateSpatialReferenceSystem statement, S context) { + validateFeature(Feature.createSpatialReferenceSystem); + return null; + } + + @Override + public Void visit(AlterInstance statement, S context) { + validateFeature(Feature.alterInstance); + return null; + } + + @Override + public Void visit(AlterTablespace statement, S context) { + validateFeature(Feature.alterTablespace); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(AlterTablespaceMove statement, S context) { + validateFeature(Feature.alterTablespace); + return null; + } + + @Override + public Void visit(AlterPolicy statement, S context) { + validateFeature(Feature.alterPolicy); + validateOptionalFromItem(statement.getTable()); + if (statement.getNewName() == null) { + statement.getOptions().visitExpressions(this::validateOptionalExpression); + } + return null; + } + + @Override + public Void visit(DropPolicy statement, S context) { + validateFeature(Feature.drop); + validateOptionalFromItem(statement.getTable()); + return null; + } + + @Override + public Void visit(CreateStatistics statement, S context) { + validateFeature(Feature.createStatistics); + validateOptionalFromItem(statement.getTable()); + validateOptionalExpression(statement.getExpressions()); + return null; + } + + @Override + public Void visit(AlterStatistics statement, S context) { + validateFeature(Feature.alterStatistics); + return null; + } + + + @Override + public Void visit(AlterRule statement, S context) { + validateFeature(Feature.alterRule); + validateOptionalFromItem(statement.getTable()); + return null; + } + + @Override + public Void visit(CreateCast statement, S context) { + validateFeature(Feature.createCast); + return null; + } + + @Override + public Void visit(CreateOperator statement, S context) { + validateFeature(Feature.createOperator); + return null; + } + + @Override + public Void visit(CreateTransform statement, S context) { + validateFeature(Feature.createTransform); + return null; + } + + @Override + public Void visit(CreateOperatorClass statement, S context) { + validateFeature(Feature.createOperatorClass); + return null; + } + + @Override + public Void visit(CreateConversion statement, S context) { + validateFeature(Feature.createConversion); + return null; + } + + @Override + public Void visit(CreateOperatorFamily statement, S context) { + validateFeature(Feature.createOperatorFamily); + return null; + } + + @Override + public Void visit(AlterConversion statement, S context) { + validateFeature(Feature.alterConversion); + return null; + } + + @Override + public Void visit(CreateAggregate statement, S context) { + validateFeature(Feature.createAggregate); + return null; + } + + @Override + public Void visit(AlterOperator statement, S context) { + validateFeature(Feature.alterOperator); + return null; + } + + @Override + public Void visit(AlterOperatorClass statement, S context) { + validateFeature(Feature.alterOperatorClass); + return null; + } + + @Override + public Void visit(AlterOperatorFamily statement, S context) { + validateFeature(Feature.alterOperatorFamily); + return null; + } + + @Override + public Void visit(AlterAggregate statement, S context) { + validateFeature(Feature.alterAggregate); + return null; + } + + @Override + public Void visit(CreateLanguage statement, S context) { + validateFeature(Feature.createLanguage); + return null; + } + + @Override + public Void visit(AlterLanguage statement, S context) { + validateFeature(Feature.alterLanguage); + return null; + } + + @Override + public Void visit(AlterLargeObject statement, S context) { + validateFeature(Feature.alterLargeObject); + statement.visitExpressions(this::validateOptionalExpression); + return null; + } + + @Override + public Void visit(CreateTextSearchDictionary statement, S context) { + validateFeature(Feature.createTextSearchDictionary); + return null; + } + + @Override + public Void visit(AlterTextSearchDictionary statement, S context) { + validateFeature(Feature.alterTextSearchDictionary); + return null; + } + + @Override + public Void visit(CreateTextSearchParser statement, S context) { + validateFeature(Feature.createTextSearchParser); + return null; + } + + @Override + public Void visit(AlterTextSearchParser statement, S context) { + validateFeature(Feature.alterTextSearchParser); + return null; + } + + @Override + public Void visit(CreateTextSearchTemplate statement, S context) { + validateFeature(Feature.createTextSearchTemplate); + return null; + } + + @Override + public Void visit(AlterTextSearchTemplate statement, S context) { + validateFeature(Feature.alterTextSearchTemplate); + return null; + } } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java new file mode 100644 index 0000000000..7f022612e1 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java @@ -0,0 +1,26 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.TableMaintenanceStatement; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; + +public class TableMaintenanceValidator extends AbstractValidator { + @Override + public void validate(TableMaintenanceStatement statement) { + for (ValidationCapability c : getCapabilities()) { + validateFeature(c, Feature.tableMaintenance); + statement.getTables().forEach(table -> validateName(c, NamedObject.table, + table.getFullyQualifiedName(), true)); + } + } +} diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/UpdateValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/UpdateValidator.java index b7695b3d42..ae9ac519f8 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/UpdateValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/UpdateValidator.java @@ -32,6 +32,8 @@ public void validate(Update update) { Feature.updateReturning); } + validateOptionalWithItems(update.getWithItemsList()); + if (!update.isTargetTableAlias()) { validateOptionalFromItem(update.getTable()); } diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/VacuumValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/VacuumValidator.java new file mode 100644 index 0000000000..656ed348c4 --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/VacuumValidator.java @@ -0,0 +1,26 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; + +public class VacuumValidator extends AbstractValidator { + @Override + public void validate(VacuumStatement vacuum) { + for (ValidationCapability c : getCapabilities()) { + validateFeature(c, Feature.vacuum); + vacuum.getTargets().forEach(target -> validateName(c, NamedObject.table, + target.getTable().getFullyQualifiedName(), true)); + } + } +} diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 1411612de7..08ae097a63 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -48,8 +48,28 @@ import net.sf.jsqlparser.expression.operators.relational.*; import net.sf.jsqlparser.schema.*; import net.sf.jsqlparser.statement.*; import net.sf.jsqlparser.statement.analyze.*; +import net.sf.jsqlparser.statement.maintenance.*; import net.sf.jsqlparser.statement.alter.*; +import net.sf.jsqlparser.statement.create.fdw.*; +import net.sf.jsqlparser.statement.create.server.CreateServer; +import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; +import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.create.rule.CreateRule; +import net.sf.jsqlparser.statement.notify.NotifyStatement; +import net.sf.jsqlparser.statement.notify.ListenStatement; +import net.sf.jsqlparser.statement.create.collation.CreateCollation; +import net.sf.jsqlparser.statement.create.cast.CreateCast; +import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.transform.CreateTransform; +import net.sf.jsqlparser.statement.create.aggregate.CreateAggregate; +import net.sf.jsqlparser.statement.create.operator.*; import net.sf.jsqlparser.statement.alter.schema.AlterSchema; +import net.sf.jsqlparser.statement.alter.database.AlterDatabase; import net.sf.jsqlparser.statement.alter.sequence.*; import net.sf.jsqlparser.statement.comment.*; import net.sf.jsqlparser.statement.create.database.*; @@ -62,12 +82,15 @@ import net.sf.jsqlparser.statement.create.event.*; import net.sf.jsqlparser.statement.create.function.*; import net.sf.jsqlparser.statement.create.index.*; import net.sf.jsqlparser.statement.create.macro.*; +import net.sf.jsqlparser.statement.create.spatial.*; +import net.sf.jsqlparser.statement.create.statistics.CreateStatistics; import net.sf.jsqlparser.statement.create.policy.*; import net.sf.jsqlparser.statement.create.procedure.*; import net.sf.jsqlparser.statement.create.schema.*; import net.sf.jsqlparser.statement.create.synonym.*; import net.sf.jsqlparser.statement.create.sequence.*; import net.sf.jsqlparser.statement.create.table.*; +import net.sf.jsqlparser.statement.create.tablespace.CreateTablespace; import net.sf.jsqlparser.statement.create.trigger.*; import net.sf.jsqlparser.statement.create.user.*; import net.sf.jsqlparser.statement.create.view.*; @@ -79,6 +102,9 @@ import net.sf.jsqlparser.statement.execute.*; import net.sf.jsqlparser.statement.piped.*; import net.sf.jsqlparser.statement.select.*; import net.sf.jsqlparser.statement.refresh.*; +import net.sf.jsqlparser.statement.reindex.Reindex; +import net.sf.jsqlparser.statement.resourcegroup.*; +import net.sf.jsqlparser.statement.securitylabel.SecurityLabel; import net.sf.jsqlparser.statement.show.*; import net.sf.jsqlparser.statement.truncate.*; import net.sf.jsqlparser.statement.update.*; @@ -86,9 +112,18 @@ import net.sf.jsqlparser.statement.upsert.*; import net.sf.jsqlparser.statement.merge.*; import net.sf.jsqlparser.statement.grant.*; import net.sf.jsqlparser.statement.role.*; +import net.sf.jsqlparser.statement.foreign.ImportForeignSchema; import net.sf.jsqlparser.statement.imprt.*; import net.sf.jsqlparser.statement.export.*; import net.sf.jsqlparser.statement.lock.*; +import net.sf.jsqlparser.statement.admin.*; +import net.sf.jsqlparser.statement.handler.HandlerStatement; +import net.sf.jsqlparser.statement.replication.*; +import net.sf.jsqlparser.statement.cursor.CloseCursorStatement; +import net.sf.jsqlparser.statement.cursor.CursorOption; +import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement; +import net.sf.jsqlparser.statement.cursor.FetchCursorStatement; +import net.sf.jsqlparser.statement.cursor.FetchDirection; import java.util.*; import java.util.AbstractMap.SimpleEntry; import java.util.concurrent.CancellationException; @@ -130,9 +165,160 @@ public class CCJSqlParser extends AbstractJSqlParser { // then-branch closes the ternary and must not be taken as the JSON path operator private int ternaryThenBranchDepth = 0; + // depth of open CREATE SCHEMA elements: GRANT there starts the next element, never an alias + private int schemaElementDepth = 0; + + // Keep this routing check aligned with SingleStatement, including aliases and dialect gates. + // It does not validate syntax that the grammar captures as opaque. + private boolean isStatementStartAhead() { + Token next = getToken(1); + switch (next.kind) { + case K_SELECT: case K_WITH: case K_VALUES: case K_VALUE: case K_FROM: + case K_PIVOT: case K_UNPIVOT: case OPENING_BRACKET: + case K_INSERT: case K_UPDATE: case K_DELETE: case K_MERGE: + case K_UPSERT: case K_REPLACE: case K_ALTER: case K_RENAME: + case K_CREATE: case K_DROP: case K_ANALYZE: case K_TRUNCATE: + case K_EXEC: case K_EXECUTE: case K_CALL: case K_SET: case K_RESET: + case K_SHOW: case K_REFRESH: case K_USE: case K_BEGIN: case K_START: + case K_SAVEPOINT: case K_ROLLBACK: case K_COMMIT: case K_COMMENT: + case K_DESCRIBE: case K_DESC: case K_EXPLAIN: case K_SUMMARIZE: case K_DECLARE: case K_GRANT: + case K_PRAGMA: case K_INSTALL: case K_LOAD: case K_FORCE: + case K_ATTACH: case K_DETACH: case K_CONNECT: case K_DISCONNECT: + case K_PREPARE: case K_DEALLOCATE: case K_COPY: case K_ASSERT: + case K_PURGE: case K_SESSION: case K_BRANCH: case K_LOCK: case K_IF: case K_TABLE: + return true; + case K_DO: + return isDoStatementAhead(); + case K_CHANGE: + return isChangeReplicationAhead(); + case K_STOP: + return isReplicaThreadStatementAhead(K_STOP); + case K_SECURITY: + return "LABEL".equalsIgnoreCase(getToken(2).image); + case K_REINDEX: + return isReindexAhead(); + case K_DISCARD: + return isDiscardAhead(); + case K_LISTEN: case K_UNLISTEN: + return isListenAhead(); + case K_VACUUM: case K_ANALYSE: case K_CLUSTER: case K_CHECKPOINT: + return isPostgreSqlMaintenanceAhead(); + case K_UNLOCK: + return isUnlockTablesAhead() || isBackupLockAhead(); + case K_END: + return isEndTransactionAhead(); + case K_CHECK: case K_CHECKSUM: case K_OPTIMIZE: case K_REPAIR: + return isTableMaintenanceAhead(); + case K_FLUSH: + return isFlushAhead(); + case K_KILL: + return isKillAhead(); + case K_HANDLER: + return isHandlerAhead(); + case K_FETCH: case K_MOVE: case K_CLOSE: + return isCursorStatementAhead(); + case K_IMPORT: case K_EXPORT: + return Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) + || next.kind == K_EXPORT && getToken(2).kind == K_DATA + || isImportForeignSchemaAhead(); + default: + return "NOTIFY".equalsIgnoreCase(next.image) + || "REASSIGN".equalsIgnoreCase(next.image) + || "REVOKE".equalsIgnoreCase(next.image) + || "RELEASE".equalsIgnoreCase(next.image) + || isAbortTransactionAhead() || isXaStatementAhead() + || isPluginStatementAhead(); + } + } + + private boolean isInformixIsolationLevel(Token token) { + return "DIRTY".equalsIgnoreCase(token.image) || "COMMITTED".equalsIgnoreCase(token.image) + || "CURSOR".equalsIgnoreCase(token.image) || token.kind == K_REPEATABLE; + } + + private boolean isOpaqueStatementAhead() { + int kind = getToken(1).kind; + return kind != EOF && kind != ST_SEMICOLON && kind != K_END && !isStatementStartAhead(); + } + + private void captureOpaqueStatements(Statements statements) throws ParseException { + while (getAsBoolean(Feature.allowUnsupportedStatements) && isOpaqueStatementAhead()) { + statements.add(UnsupportedStatement()); + while (getToken(1).kind == ST_SEMICOLON) { + getNextToken(); + } + } + } + + private void requireStatementBoundary() throws ParseException { + int kind = getToken(1).kind; + if (kind != EOF && kind != ST_SEMICOLON + && (kind == K_FROM || kind == K_PIVOT || kind == K_UNPIVOT || !isStatementStartAhead())) { + throw new ParseException("Unexpected token after a supported statement: " + getToken(1).image); + } + } + + // depth of DuckDB MAP keys: the following ":" separates a key from its value // and must not be taken as the JSON path operator private int mapKeyDepth = 0; + /** + * Set while the zone of AT TIME ZONE is about to be read: the zone is a primary expression + * that leaves a following AT TIME ZONE or AT LOCAL to the expression it converts. + */ + private boolean timezoneOperandAhead = false; + + // opening brackets of the enclosing subscripts: a ":" at the top level of a subscript + // separates the bounds of a slice such as l[1:3] and is not the JSON path operator + private final Deque subscriptOpenings = new ArrayDeque(); + + /** + * Whether the pending ":" is at the top level of the innermost subscript, i.e. not nested + * in brackets, braces, parentheses or a CASE expression opened inside that subscript. + */ + private boolean isSliceColonAhead() { + Token colon = getToken(1); + return !subscriptOpenings.isEmpty() && ":".equals(colon.image) + && TokenNesting.isTopLevelFrom(subscriptOpenings.peek().next, colon); + } + + /** + * Token nesting checks shared by the lookaheads above and below. A nested class keeps its + * branches out of CCJSqlParser.class, whose constant pool is close to what JaCoCo can still + * instrument. + */ + private static final class TokenNesting { + private TokenNesting() {} + + /** + * Whether the target is not nested in brackets, braces, parentheses or a CASE expression + * opened from the first token on. + */ + static boolean isTopLevelFrom(Token first, Token target) { + int depth = 0; + for (Token t = first; t != null && t != target; t = t.next) { + if (t.kind == K_CASE || "(".equals(t.image) || "[".equals(t.image) + || "{".equals(t.image)) { + depth++; + } else if (t.kind == K_END || ")".equals(t.image) || "]".equals(t.image) + || "}".equals(t.image)) { + depth--; + } + } + return depth == 0; + } + } + + // first tokens of the enclosing column DEFAULT values: a COLLATE at their top level is the + // column's own attribute, as in MySQL's column_attribute and PostgreSQL's ColQualList + private final Deque columnDefaultStarts = new ArrayDeque(); + + /** Whether the pending COLLATE follows an unparenthesized column DEFAULT value. */ + private boolean isColumnCollateAhead() { + Token collate = getToken(1); + return !columnDefaultStarts.isEmpty() && collate.kind == K_COLLATE + && TokenNesting.isTopLevelFrom(columnDefaultStarts.peek(), collate); + } private Expression createOutputArgument(Expression argument) throws ParseException { Expression value = argument; @@ -161,12 +347,109 @@ public class CCJSqlParser extends AbstractJSqlParser { */ private void linkAST(ASTNodeAccess access, Node node, Expression leftExpression) { linkAST(access, node); - if (leftExpression instanceof ASTNodeAccess) { - Node leftNode = ((ASTNodeAccess) leftExpression).getASTNode(); - if (leftNode != null && leftNode.jjtGetFirstToken() != null) { - node.jjtSetFirstToken(leftNode.jjtGetFirstToken()); + node.jjtSetFirstToken(firstToken(leftExpression, node.jjtGetFirstToken())); + } + + /** + * Links an object no production opens a node for to a {@link RangeNode} spanning its tokens + * from {@code first} to the last one consumed. + */ + private void linkAST(ASTNodeAccess access, Token first) { + linkAST(access, first, getToken(0)); + } + + private void linkAST(ASTNodeAccess access, Token first, Token last) { + linkAST(access, new RangeNode(first, last, null)); + } + + private static Token firstToken(ASTNodeAccess operand, Token fallback) { + Node node = operand == null ? null : operand.getASTNode(); + return node != null && node.jjtGetFirstToken() != null ? node.jjtGetFirstToken() : fallback; + } + + /** Links a list the grammar assembles itself to the range from its first element to its last. */ + private > T linkElements(T list) { + if (list != null && !list.isEmpty() && list.getASTNode() == null) { + Node first = list.get(0).getASTNode(); + Node last = list.get(list.size() - 1).getASTNode(); + if (first != null && last != null) { + linkAST(list, first.jjtGetFirstToken(), last.jjtGetLastToken()); + } + } + return list; + } + + /** + * Links the zones of a TimezoneExpression. One zone is its own range. Several zones span from + * the AT of the first one, since the text between two zones is not a list separator. + */ + private void linkTimezones(TimezoneExpression expression, Token firstAt) { + // the field behind this getter is an ExpressionList + ExpressionList zones = (ExpressionList) expression.getTimezoneExpressions(); + Node last = zones.size() > 1 ? zones.get(zones.size() - 1).getASTNode() : null; + if (last != null && firstAt != null && zones.getASTNode() == null) { + linkAST(zones, firstAt, last.jjtGetLastToken()); + } else { + linkElements(zones); + } + } + + /** Links an object built from the single token just consumed, such as a name, to that token. */ + private T linkToLastToken(T access) { + linkAST(access, getToken(0), getToken(0)); + return access; + } + + private T linked(T access, Token first) { + linkAST(access, first); + return access; + } + + /** + * Widens an object's range to text it has taken in beyond its node, from {@code first} or to + * {@code last} where given. A tree node keeps its own range, and the object moves to a + * {@link RangeNode} over the wider one. + */ + private void widen(Object access, Token first, Token last) { + Node node = access instanceof ASTNodeAccess ? ((ASTNodeAccess) access).getASTNode() : null; + if (node == null) { + return; + } + Token from = first != null ? first : node.jjtGetFirstToken(); + Token to = last != null ? last : node.jjtGetLastToken(); + if (node instanceof RangeNode) { + node.jjtSetFirstToken(from); + node.jjtSetLastToken(to); + } else { + linkAST((ASTNodeAccess) access, new RangeNode(from, to, node)); + } + } + + /** Links a statement that no other rule linked to the range from {@code first} on. */ + private void linkStatement(Statement statement, Token first) { + if (statement instanceof ASTNodeAccess) { + linkASTIfMissing((ASTNodeAccess) statement, first); + } + } + + /** + * The last token of the qualifier in a dotted name running from {@code first} to {@code name}, + * which is the token two before {@code name}. Null when the name has no qualifier. + */ + private static Token qualifierLast(Token first, Token name) { + for (Token token = first; token != null && token != name; token = token.next) { + if (token.next != null && token.next.next == name) { + return token; } } + return null; + } + + /** Like {@link #linkAST(ASTNodeAccess, Token)}, for an object a production may already have linked. */ + private void linkASTIfMissing(ASTNodeAccess access, Token first) { + if (access != null && access.getASTNode() == null) { + linkAST(access, first); + } } public Node getASTRoot() { @@ -174,9 +457,245 @@ public class CCJSqlParser extends AbstractJSqlParser { } private boolean isMySqlDatabaseOptionAhead() { - int offset = getToken(1).kind == K_DEFAULT ? 2 : 1; - int kind = getToken(offset).kind; - return kind == K_CHARACTER || kind == K_COLLATE || kind == K_ENCRYPTION; + return isMySqlDatabaseOptionAhead(1); + } + + private boolean isMySqlDatabaseOptionAhead(int offset) { + int start = getToken(offset).kind == K_DEFAULT ? offset + 1 : offset; + Token token = getToken(start); + return token.kind == K_CHARACTER || token.kind == K_COLLATE || token.kind == K_ENCRYPTION + || token.kind == K_CHAR && getToken(start + 1).kind == K_SET + || token.kind == S_IDENTIFIER && "CHARSET".equalsIgnoreCase(token.image); + } + + /** + * Whether MySQL's ALTER DATABASE omits the database name before its options. CHARSET can also + * be a database name, so it starts an option only when "=" follows, or when its value ends the + * statement or precedes another option. + */ + private boolean isAlterDatabaseNameOmitted() { + Token first = getToken(1); + if (first.kind == K_READ) { + return true; + } + if (!isMySqlDatabaseOptionAhead(1)) { + return false; + } + if (first.kind != S_IDENTIFIER || "=".equals(getToken(2).image)) { + return true; + } + Token afterValue = getToken(3); + return afterValue.kind == EOF || afterValue.kind == ST_SEMICOLON || afterValue.kind == K_READ + || isMySqlDatabaseOptionAhead(3); + } + + /** Whether a PostgreSQL CREATE/ALTER DATABASE option name starts at the offset. */ + private boolean isPostgreSqlDatabaseOptionAhead(int offset) { + Token token = getToken(offset); + if (token.kind == K_ENCODING || token.kind == K_TABLESPACE) { + return true; + } + if (token.kind != S_IDENTIFIER) { + return false; + } + String name = token.image.toUpperCase(Locale.ROOT); + if ("CONNECTION".equals(name)) { + return getToken(offset + 1).kind == K_LIMIT; + } + return Arrays.asList("OWNER", "TEMPLATE", "STRATEGY", "LOCALE", "LC_COLLATE", "LC_CTYPE", + "BUILTIN_LOCALE", "ICU_LOCALE", "ICU_RULES", "LOCALE_PROVIDER", "COLLATION_VERSION", + "ALLOW_CONNECTIONS", "IS_TEMPLATE", "OID").contains(name); + } + + /** Whether the words, matched without case, start at the offset. */ + private boolean isWordSequenceAhead(int offset, String... words) { + for (int i = 0; i < words.length; i++) { + Token token = getToken(offset + i); + if (token.kind == EOF || !words[i].equalsIgnoreCase(token.image)) { + return false; + } + } + return true; + } + + private boolean isSignedNumberAhead(int offset) { + Token token = getToken(offset); + if ("+".equals(token.image) || "-".equals(token.image)) { + token = getToken(offset + 1); + } + return token.kind == S_LONG || token.kind == S_DOUBLE; + } + + /** + * Whether ALTER FUNCTION, PROCEDURE or ROUTINE has a PostgreSQL or MySQL alteration after the + * routine name and optional signature. Other forms, such as SQL Server routine definitions, + * remain unsupported statements. + */ + private boolean isAlterRoutineAhead() { + Token token = getToken(1); + if (token.kind != K_FUNCTION && token.kind != K_PROCEDURE && !isKeywordAhead("ROUTINE")) { + return false; + } + int offset = 3; + while (".".equals(getToken(offset).image)) { + offset += 2; + } + if (getToken(offset).kind == OPENING_BRACKET) { + for (int depth = 0; ; offset++) { + int kind = getToken(offset).kind; + if (kind == EOF || kind == ST_SEMICOLON) { + return false; + } + depth += kind == OPENING_BRACKET ? 1 : kind == CLOSING_BRACKET ? -1 : 0; + if (depth == 0) { + offset++; + break; + } + } + } + Token next = getToken(offset + 1); + return getToken(offset).kind == K_RENAME && next.kind == K_TO + || isWordSequenceAhead(offset, "OWNER", "TO") + || getToken(offset).kind == K_SET && next.kind == K_SCHEMA + || isExtensionDependencyAhead(offset) + || isPostgreSqlRoutineCharacteristicAhead(offset) + || isMySqlRoutineCharacteristicAhead(offset); + } + + /** Whether PostgreSQL's [NO] DEPENDS ON EXTENSION starts at the offset. */ + private boolean isExtensionDependencyAhead(int offset) { + return isWordSequenceAhead(getToken(offset).kind == K_NO ? offset + 1 : offset, + "DEPENDS", "ON", "EXTENSION"); + } + + /** + * Whether a PostgreSQL characteristic of ALTER FUNCTION, PROCEDURE or ROUTINE starts at the + * offset. SET without TO, = or FROM after the parameter name is SET SCHEMA instead. + */ + private boolean isPostgreSqlRoutineCharacteristicAhead(int offset) { + Token token = getToken(offset); + switch (token.kind) { + case K_SET: + Token assignment = getToken(offset + 2); + while (".".equals(assignment.image)) { + assignment = nextWithItemToken(nextWithItemToken(assignment)); + } + return assignment.kind == K_TO || "=".equals(assignment.image) + || assignment.kind == K_FROM; + case K_RESET: + case K_VOLATILE: + case K_STRICT: + return true; + case K_ROWS: + return isSignedNumberAhead(offset + 1); + case K_NOT: + return isWordSequenceAhead(offset + 1, "LEAKPROOF"); + case K_RETURNS: + return isWordSequenceAhead(offset + 1, "NULL", "ON", "NULL", "INPUT"); + case K_PARALLEL: + return isWordSequenceAhead(offset + 1, "UNSAFE") + || isWordSequenceAhead(offset + 1, "RESTRICTED") + || isWordSequenceAhead(offset + 1, "SAFE"); + case K_SECURITY: + return isRoutineSecurityAhead(offset + 1); + case S_IDENTIFIER: + break; + default: + return false; + } + switch (token.image.toUpperCase(Locale.ROOT)) { + case "IMMUTABLE": + case "STABLE": + case "LEAKPROOF": + return true; + case "CALLED": + return isWordSequenceAhead(offset + 1, "ON", "NULL", "INPUT"); + case "EXTERNAL": + return getToken(offset + 1).kind == K_SECURITY && isRoutineSecurityAhead(offset + 2); + case "COST": + return isSignedNumberAhead(offset + 1); + case "SUPPORT": + int kind = getToken(offset + 1).kind; + return kind != EOF && kind != ST_SEMICOLON; + default: + return false; + } + } + + /** Whether a MySQL characteristic of CREATE FUNCTION or PROCEDURE starts here. */ + private boolean isMySqlCreateRoutineCharacteristicAhead() { + return isMySqlRoutineCharacteristicAhead(1) || isWordSequenceAhead(1, "DETERMINISTIC") + || isWordSequenceAhead(1, "NOT", "DETERMINISTIC"); + } + + /** Whether a MySQL characteristic of ALTER FUNCTION or PROCEDURE starts at the offset. */ + private boolean isMySqlRoutineCharacteristicAhead(int offset) { + if (getToken(offset).kind == K_COMMENT) { + return getToken(offset + 1).kind == S_CHAR_LITERAL; + } + return isWordSequenceAhead(offset, "LANGUAGE", "SQL") + || isWordSequenceAhead(offset, "CONTAINS", "SQL") + || isWordSequenceAhead(offset, "NO", "SQL") + || isWordSequenceAhead(offset, "READS", "SQL", "DATA") + || isWordSequenceAhead(offset, "MODIFIES", "SQL", "DATA") + || isWordSequenceAhead(offset, "SQL", "SECURITY") && isRoutineSecurityAhead(offset + 2); + } + + private boolean isRoutineSecurityAhead(int offset) { + return isWordSequenceAhead(offset, "DEFINER") || isWordSequenceAhead(offset, "INVOKER"); + } + + /** + * Whether a MySQL compound statement starts here: BEGIN ... END or a flow control statement, + * where BEGIN, LOOP, REPEAT and WHILE may have a label. + */ + private boolean isMySqlCompoundStatementAhead() { + boolean labeled = getToken(1).kind == S_IDENTIFIER && ":".equals(getToken(2).image); + Token token = getToken(labeled ? 3 : 1); + if (token.kind == K_BEGIN || token.kind == K_LOOP + || isWordSequenceAhead(labeled ? 3 : 1, "REPEAT") + || isWordSequenceAhead(labeled ? 3 : 1, "WHILE")) { + return true; + } + return !labeled && (token.kind == K_IF || token.kind == K_CASE); + } + + /** + * Whether BEGIN ... END holds only SQL statements, each ending with a semicolon, and ends the + * enclosing statement. CASE ... END inside a statement is an expression. + */ + private boolean isStatementBlockAhead() { + if (getToken(1).kind != K_BEGIN) { + return false; + } + boolean statementStart = true; + boolean statements = false; + int caseDepth = 0; + for (Token token = getToken(2); ; token = nextWithItemToken(token)) { + if (token.kind == EOF) { + return false; + } else if (token.kind == ST_SEMICOLON) { + statementStart = true; + } else if (statementStart) { + if (token.kind == K_END) { + int next = nextWithItemToken(token).kind; + return statements && (next == ST_SEMICOLON || next == EOF); + } + switch (token.kind) { + case K_SELECT: case K_INSERT: case K_UPDATE: case K_DELETE: case K_REPLACE: + case K_SET: case K_CALL: case K_WITH: + break; + default: + return false; + } + statementStart = false; + statements = true; + } else if (token.kind == K_CASE) { + caseDepth++; + } else if (token.kind == K_END && caseDepth-- == 0) { + return false; + } + } } private static class ObjectNames { @@ -262,6 +781,12 @@ public class CCJSqlParser extends AbstractJSqlParser { } } + /** DuckDB's and PostgreSQL's {@code ~~}, {@code ~~*}, {@code !~~}, {@code !~~*} and {@code ~~~}. */ + protected static boolean isLikeOperator(Token token) { + return token.image != null + && (token.image.startsWith("~~") || token.image.startsWith("!~~")); + } + protected static boolean isComparisonOperator(Token token) { if (token.image == null || token.image.isEmpty()) { return false; @@ -270,12 +795,13 @@ public class CCJSqlParser extends AbstractJSqlParser { case '>': // >, >= case '=': // =, =* but not => Oracle/PostgreSQL named parameter syntax return !token.image.equals("=>"); - case '~': // ~, ~* - return true; + case '~': // ~, ~* but not the ~~ LIKE operators + return !token.image.startsWith("~~"); case '<': // <, <=, <>, <@, <->, <#>, <=>, <& return true; case '*': return token.image.equals("*="); - case '!': return token.image.startsWith("!~") || token.image.startsWith("!="); + case '!': return (token.image.startsWith("!~") && !token.image.startsWith("!~~")) + || token.image.startsWith("!="); case '@': return token.image.equals("@@") || token.image.equals("@>"); case '?': return true; // ?, ?|, ?& case '-': return true; // -, -# @@ -299,8 +825,7 @@ public class CCJSqlParser extends AbstractJSqlParser { try { int depth = 0; Token prev = null; - for (int i = 2; ; i++) { - Token t = getToken(i); + for (Token t = getToken(2); ; t = nextWithItemToken(t)) { if (t == null || t.kind == EOF) { return false; } @@ -394,6 +919,27 @@ public class CCJSqlParser extends AbstractJSqlParser { } } + /** + * Whether PRIOR starts Oracle's hierarchical operator, as in PRIOR id or PRIOR (a), rather + * than naming a column, as in prior = 1, prior IS NULL or ORDER BY prior DESC. + */ + private boolean isPriorOperatorAhead() { + if (getToken(1).kind != K_PRIOR) { + return false; + } + int kind = getToken(2).kind; + switch (kind) { + case OPENING_BRACKET: case S_IDENTIFIER: case S_QUOTED_IDENTIFIER: case DATA_TYPE: + case S_LONG: case S_DOUBLE: case S_CHAR_LITERAL: + return true; + case K_ASC: case K_DESC: case K_NULLS: + return false; + default: + return kind >= MIN_NON_RESERVED_WORD && kind <= MAX_NON_RESERVED_WORD + && !isConditionKeywordAhead(2); + } + } + /** * Scans ahead through a dotted identifier chain and checks if '(' follows. * Distinguishes function calls like func(), schema.func(), a.b.c.func() @@ -443,8 +989,7 @@ public class CCJSqlParser extends AbstractJSqlParser { // CHAIN_CACHE_THRESHOLD delimiter/part pairs (only in the non-filling pass). private int isFunctionAheadWalk(boolean fill) { try { - int i = 1; - Token t = getToken(i); + Token t = getToken(1); // JDBC escape function: {fn ...} — must check for FN keyword if (t.image.equals("{")) { @@ -453,8 +998,7 @@ public class CCJSqlParser extends AbstractJSqlParser { // Optional APPROXIMATE keyword if (t.kind == K_APPROXIMATE) { - i++; - t = getToken(i); + t = getToken(2); } // Exclude tokens that have their own dedicated branches @@ -469,32 +1013,31 @@ public class CCJSqlParser extends AbstractJSqlParser { || t.kind == CLOSING_BRACKET || t.kind == EOF || "[".equals(t.image)) { return 0; } - i++; - - // Walk through dotted name chain + // Walk through dotted name chain, following the token chain directly; + // repeated getToken(i) calls rescan from the start each time int delimiters = 0; List chainParts = fill ? new ArrayList() : null; + t = nextWithItemToken(t); while (true) { - t = getToken(i); if (t.image.equals(".") || t.image.equals("..") || t.image.equals("...") || t.image.equals(":")) { if (!fill && ++delimiters > CHAIN_CACHE_THRESHOLD) { return LONG_CHAIN; } + Token part = nextWithItemToken(t); // skip delimiter if (fill) { - chainParts.add(getToken(i + 1)); + chainParts.add(part); } - i++; // skip delimiter - i++; // skip next name part + t = nextWithItemToken(part); // skip next name part } else { break; } } // Must be followed by (, and not by the Oracle join syntax column(+) - boolean result = getToken(i).kind == OPENING_BRACKET - && !(getToken(i + 1).image.equals("+") - && getToken(i + 2).kind == CLOSING_BRACKET); + boolean result = t.kind == OPENING_BRACKET + && !(nextWithItemToken(t).image.equals("+") + && nextWithItemToken(nextWithItemToken(t)).kind == CLOSING_BRACKET); // Each eligible chain part would walk the same remaining suffix and // obtain the same answer, so memoize them all in one pass. @@ -533,24 +1076,28 @@ public class CCJSqlParser extends AbstractJSqlParser { /** * Pratt arithmetic operator precedence loop. - * Handles: *, /, %, ^, DIV (prec=6) and +, -, ||, |, &, <<, >> (prec=5) + * Handles: ^, ** (prec=7), *, /, %, DIV (prec=6), +, -, || (prec=5) and |, &, #, <<, >> (prec=4) * Called only in real-parse mode (not syntactic-LOOKAHEAD mode) so action * blocks execute correctly. Safe now that no syntactic production LOOKAHEADs * scan through arithmetic expressions. */ /** * Pratt boolean operator precedence loop. - * Handles OR (prec=2), XOR (prec=3), AND/&& (prec=4). + * Handles OR (prec=2), XOR (prec=3 under MySQL, else 2), AND/&& (prec=4). * Safe to use now that no syntactic production LOOKAHEADs scan through expressions. */ - protected Expression prattExpressionRest(Expression left, int minPrec) throws ParseException { + protected Expression prattExpressionRest(Expression left, Token first, int minPrec) throws ParseException { while (!interrupted) { Token t = getToken(1); int op = t.kind; boolean ternary = "?".equals(t.image) && isTernaryAhead(); int prec; if (op == K_AND || op == OP_DOUBLEAND) prec = 4; - else if (op == K_XOR || op == K_OR) prec = 2; + // MySQL puts XOR between AND and OR; other dialects keep one + // left-associative level for OR and XOR. + else if (op == K_XOR) + prec = Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) ? 3 : 2; + else if (op == K_OR) prec = 2; else if (ternary) prec = 2; else break; if (prec < minPrec) break; @@ -562,7 +1109,8 @@ public class CCJSqlParser extends AbstractJSqlParser { Expression thenExpression; ternaryThenBranchDepth++; try { - thenExpression = prattExpressionRest(Condition(), 2); + Token thenFirst = getToken(1); + thenExpression = prattExpressionRest(Condition(), thenFirst, 2); } finally { ternaryThenBranchDepth--; } @@ -570,13 +1118,16 @@ public class CCJSqlParser extends AbstractJSqlParser { throw new ParseException("Expected ':' closing the ternary conditional operator"); } jj_consume_token(getToken(1).kind, getToken(1).image); - Expression elseExpression = prattExpressionRest(Condition(), 2); + Token elseFirst = getToken(1); + Expression elseExpression = prattExpressionRest(Condition(), elseFirst, 2); left = new TernaryExpression(left, thenExpression, elseExpression); + linkAST(left, first); continue; } jj_consume_token(op, getToken(1).image); // +1 makes OR/AND/XOR left-associative - Expression right = prattExpressionRest(Condition(), prec + 1); + Token rightFirst = getToken(1); + Expression right = prattExpressionRest(Condition(), rightFirst, prec + 1); if (op == K_AND) { left = new AndExpression(left, right); } else if (op == OP_DOUBLEAND) { @@ -587,17 +1138,103 @@ public class CCJSqlParser extends AbstractJSqlParser { } else { left = new OrExpression(left, right); } + linkAST(left, first); } return left; } + /** + * Whether the token after the ":" of a JSON path is a word that is no identifier token, i.e. a + * keyword, which names the path element all the same. A word followed by "(" stays a function. + */ + private boolean isKeywordJsonPathName() { + Token colon = getToken(0); + return colon != null && ":".equals(colon.image) && isKeywordWord(1); + } + + /** + * Whether the token at the given position is a word that is no identifier token, i.e. a keyword, + * and not the name of a function call. + */ + private boolean isKeywordWord(int position) { + Token word = getToken(position); + if (word.image == null || word.kind == S_IDENTIFIER || word.kind == S_QUOTED_IDENTIFIER + || "(".equals(getToken(position + 1).image)) { + return false; + } + String image = word.image; + if (image.isEmpty() || (!Character.isLetter(image.charAt(0)) && image.charAt(0) != '_')) { + return false; + } + for (int i = 1; i < image.length(); i++) { + if (!Character.isLetterOrDigit(image.charAt(i)) && image.charAt(i) != '_') { + return false; + } + } + return true; + } + + /** + * Whether the path after the ":" of a JSON path, which starts with an identifier, goes on with a + * keyword after a ".", e.g. v:a.output or v:a[0].b.from. The expression parser would read such a + * path as a qualified column name, which does not take a keyword as a part. + */ + private boolean isJsonPathWithKeywordAfterDot() { + Token colon = getToken(0); + if (colon == null || !":".equals(colon.image)) { + return false; + } + Token first = getToken(1); + if (first.kind != S_IDENTIFIER && first.kind != S_QUOTED_IDENTIFIER) { + return false; + } + int position = 2; + while (true) { + Token token = getToken(position); + if (".".equals(token.image)) { + if (isKeywordWord(position + 1)) { + return true; + } + Token name = getToken(position + 1); + if (name.kind != S_IDENTIFIER && name.kind != S_QUOTED_IDENTIFIER) { + return false; + } + position += 2; + } else if ("[".equals(token.image)) { + int depth = 0; + do { + token = getToken(position); + if ("[".equals(token.image)) { + depth++; + } else if ("]".equals(token.image)) { + depth--; + } else if (token.kind == EOF) { + return false; + } + position++; + } while (depth > 0); + } else { + return false; + } + } + } + private boolean isPostgreSqlJsonAccess(Token token) { return ("->".equals(token.image) || "->>".equals(token.image) || "#>".equals(token.image) || "#>>".equals(token.image)) && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)); } - protected Expression prattArithRest(Expression left, int minPrec) throws ParseException { + /** + * Whether the ABSENT ON NULL or RETURNING clause of JSON_ARRAY or JSON_OBJECT starts here, + * rather than an element: ABSENT is a non-reserved word and RETURNING may name a column. + */ + private boolean isJsonConstructorClauseAhead() { + int kind = getToken(1).kind; + return kind == K_RETURNING || kind == K_ABSENT && getToken(2).kind == K_ON; + } + + protected Expression prattArithRest(Expression left, Token first, int minPrec) throws ParseException { while (!interrupted) { Token t = getToken(1); int op = t.kind; @@ -611,15 +1248,32 @@ public class CCJSqlParser extends AbstractJSqlParser { if (jsonAccess || op == OP_JSON_PATH_DELETE || op == OP_JSON_PATH_EXISTS || (op == OP_CONCAT && Dialect.POSTGRESQL.name() .equals(getAsString(Feature.dialect)))) prec = 4; - else if (op == OP_SLASH || op == OP_CARET || op == K_DIV) prec = 6; - else if (op == S_HASH_OPERATOR) prec = 5; - else if (op == OP_CONCAT || op == OP_PIPE - || op == OP_LSHIFT || op == OP_RSHIFT) prec = 5; + else if (op == OP_SLASH || op == K_DIV) prec = 6; + // ^ binds tighter than * / %, both as PostgreSQL's power and as MySQL's XOR + else if (op == OP_CARET || op == OP_POWER) prec = 7; + else if (op == OP_CONCAT + || (op == OP_PIPE && getToken(2).kind == OP_PIPE)) prec = 5; + // the bitwise operators bind looser than + and -, as in PostgreSQL, MySQL and SQLite + else if (op == S_HASH_OPERATOR || op == OP_LSHIFT + || op == OP_RSHIFT) prec = 4; + // PostgreSQL distance operators share the left-associative tier below + and -. + else if (op == OP_COSINESIMILARITY) prec = 4; + else if (op == OP_PIPE) { + // MySQL tiers bitwise: <<, >> above & above |. Other dialects + // (PostgreSQL, SQLite, ...) keep one left-associative level. + prec = Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) ? 2 : 4; + } else { // Handle unnamed tokens by image String img = t.image; + // DuckDB's LIMIT 10%: the % ends the row count instead of starting a modulo + if (t == limitPercentToken) break; if ("*".equals(img) || "%".equals(img)) prec = 6; - else if ("+".equals(img) || "-".equals(img) || "&".equals(img)) prec = 5; + else if ("+".equals(img) || "-".equals(img)) prec = 5; + else if ("&".equals(img)) { + prec = Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) ? 3 : 4; + } + else if ("<->".equals(img) || "<#>".equals(img)) prec = 4; else break; // not an arithmetic operator } @@ -629,13 +1283,18 @@ public class CCJSqlParser extends AbstractJSqlParser { if (op == OP_PIPE && getToken(2).kind == OP_PIPE) { jj_consume_token(OP_PIPE, getToken(1).image); jj_consume_token(OP_PIPE, getToken(1).image); - Expression right = prattArithRest(PrimaryExpression(), prec + 1); + Token rightFirst = getToken(1); + Expression right = prattArithRest(PrimaryExpression(), rightFirst, prec + 1); Concat r = new Concat(); r.setLeftExpression(left); r.setRightExpression(right); left = r; + linkAST(left, first); continue; } jj_consume_token(op, getToken(1).image); - Expression right = prattArithRest(PrimaryExpression(), prec + 1); + Token rightFirst = getToken(1); + Expression right = prattArithRest(PrimaryExpression(), rightFirst, prec + 1); + // a JSON access chain extends the JsonExpression it started, which already has a node + boolean extended = jsonAccess && left instanceof JsonExpression; if (jsonAccess) { JsonExpression access = left instanceof JsonExpression @@ -650,10 +1309,12 @@ public class CCJSqlParser extends AbstractJSqlParser { else if (op == S_HASH_OPERATOR) { Intersects r = new Intersects(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if (op == OP_CARET) { net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if (op == K_DIV) { IntegerDivision r = new IntegerDivision(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } + else if (op == OP_POWER) { left = new Exponentiation(left, right); } else if (op == OP_CONCAT) { Concat r = new Concat(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if (op == OP_PIPE) { BitwiseOr r = new BitwiseOr(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if (op == OP_LSHIFT) { BitwiseLeftShift r = new BitwiseLeftShift(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if (op == OP_RSHIFT) { BitwiseRightShift r = new BitwiseRightShift(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } + else if (op == OP_COSINESIMILARITY) { CosineSimilarity r = new CosineSimilarity(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else { String img = t.image; if ("*".equals(img)) { Multiplication r = new Multiplication(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } @@ -661,6 +1322,12 @@ public class CCJSqlParser extends AbstractJSqlParser { else if ("-".equals(img)) { Subtraction r = new Subtraction(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if ("%".equals(img)) { Modulo r = new Modulo(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } else if ("&".equals(img)) { BitwiseAnd r = new BitwiseAnd(); r.setLeftExpression(left); r.setRightExpression(right); left = r; } + else if ("<->".equals(img) || "<#>".equals(img)) { GeometryDistance r = new GeometryDistance(img); r.setLeftExpression(left); r.setRightExpression(right); left = r; } + } + if (extended) { + widen(left, first, getToken(0)); + } else { + linkAST(left, first); } } return left; @@ -676,10 +1343,10 @@ public class CCJSqlParser extends AbstractJSqlParser { // Direct subquery: ( SELECT/WITH/PIVOT ) → ParenthesedSelect handles it // ( VALUES ) can be ParenthesedFromItem(Values) or ParenthesedSelect; // ParenthesedFromItem is checked first so Values-as-FROM-item works - if (k2 == K_SELECT || k2 == K_WITH || k2 == K_PIVOT) return false; + if (k2 == K_SELECT || k2 == K_WITH || k2 == K_PIVOT || k2 == K_FROM) return false; + if (k2 == K_TABLE && isTableQueryAhead(2)) return false; // ( ( SELECT ) UNION ( SELECT ) ) → isNestedSetOperationAhead handles it // Other (( patterns: ( (SELECT...) JOIN ... ) or ( (table) ) → ParenthesedFromItem - if (k2 == K_LATERAL) return false; // handled by LateralSubSelect if (k2 == CLOSING_BRACKET) return false; // empty "()" is not valid // EXASOL: ( IMPORT ... ) is a SubImport; handled at the outer FromItem level // by LOOKAHEAD(2, Dialect.EXASOL...) SubImport() - must NOT go into ParenthesedFromItem @@ -696,38 +1363,47 @@ public class CCJSqlParser extends AbstractJSqlParser { if (getToken(1).kind != OPENING_BRACKET) return false; if (getToken(2).kind != OPENING_BRACKET) return false; // Skip any run of opening brackets: ( ( ( ... ( SELECT - int i = 3; - while (getToken(i).kind == OPENING_BRACKET) i++; - int k = getToken(i).kind; - if (k != K_SELECT && k != K_WITH && k != K_VALUES) return false; - // Scan forward counting brackets to find the matching ) for token(2) - // We are now inside all the opening brackets; depth = number of brackets skipped - 1 - // (token(1) is the outer one, token(2..i-1) are the inner ones we scanned) - int depth = i - 2; // brackets from position 2 to i-1 inclusive - i++; - while (i <= 500) { - Token t; try { t = getToken(i); } catch (TokenMgrException e) { return false; } - if (t == null || t.kind == 0) return false; - if (t.kind == OPENING_BRACKET) depth++; - else if (t.kind == CLOSING_BRACKET) { - if (--depth == 0) break; - } - i++; - } - if (i > 500) return false; - // Token at position i+1 follows the innermost closing ) - Token next; try { next = getToken(i + 1); } catch (TokenMgrException e) { return false; } + Token innerOpen = getToken(2); + Token t = innerOpen; + while (t.kind == OPENING_BRACKET) t = nextWithItemToken(t); + if (t.kind != K_SELECT && t.kind != K_WITH && t.kind != K_VALUES) return false; + // Follow the token chain directly; repeated getToken(i) calls rescan from the start each time + Token next = skipBalancedBracketGroup(innerOpen); if (next == null) return false; return next.kind == K_UNION || next.kind == K_INTERSECT || next.kind == K_EXCEPT || next.kind == K_MINUS; } catch (TokenMgrException e) { return false; } } + /** + * Whether the TABLE at {@code offset} starts DuckDB's TABLE t query rather than naming a + * column, as in (table = 'x'): a table name follows, and then the end of the query. + */ + private boolean isTableQueryAhead(int offset) { + Token token = getToken(offset); + do { + token = nextWithItemToken(token); + if (!isIdentifierishNameToken(token)) { + return false; + } + token = nextWithItemToken(token); + } while (".".equals(token.image)); + switch (token.kind) { + case CLOSING_BRACKET: case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS: + case K_ORDER: case K_LIMIT: case K_OFFSET: case K_FETCH: + return true; + default: + return false; + } + } + protected boolean isParenthesedSelectAhead() { try { if (getToken(1).kind != OPENING_BRACKET) return false; int k = getToken(2).kind; - return k == K_SELECT || k == K_WITH || k == K_VALUES; + // DuckDB's (FROM t ...) and (TABLE t ...) + return k == K_SELECT || k == K_WITH || k == K_VALUES || k == K_FROM + || k == K_TABLE && isTableQueryAhead(2); } catch (TokenMgrException e) { return false; } @@ -747,12 +1423,12 @@ public class CCJSqlParser extends AbstractJSqlParser { switch (t.kind) { case S_IDENTIFIER: case S_QUOTED_IDENTIFIER: case DATA_TYPE: case K_DATETIMELITERAL: case K_DATE_LITERAL: - case K_ALL: case K_ANY: case K_CASEWHEN: case K_CONNECT: case K_CREATE: - case K_DEFAULT: case K_GLOBAL: case K_GROUP: case K_GROUPING: case K_IF: + case K_ALL: case K_ANY: case K_BETWEEN: case K_CASEWHEN: case K_CONNECT: case K_CREATE: + case K_DEFAULT: case K_FULL: case K_GLOBAL: case K_GROUP: case K_GROUPING: case K_IF: case K_IIF: case K_IGNORE: case K_IN: case K_INTERVAL: case K_LEFT: - case K_LIMIT: case K_NEXTVAL: case K_OFFSET: case K_ON: case K_OPTIMIZE: - case K_ORDER: case K_PROCEDURE: case K_PUBLIC: case K_QUALIFY: case K_RIGHT: - case K_FILE: case K_SET: case K_SOME: case K_START: case K_TABLES: + case K_LIMIT: case K_NEXTVAL: case K_OFFSET: case K_ON: case K_ONLY: case K_OPTIMIZE: + case K_ORDER: case K_PROCEDURE: case K_PUBLIC: case K_QUALIFY: case K_RETURNING: + case K_RIGHT: case K_SET: case K_SOME: case K_START: case K_TABLES: case K_TOP: case K_VALUE: case K_VALUES: return true; default: @@ -898,12 +1574,8 @@ public class CCJSqlParser extends AbstractJSqlParser { * everywhere else, e.g. f(content). */ private void consumeXmlLeadingKeyword(Function function) { - String name = function.getName(); - if (name == null) { - return; - } - name = name.toUpperCase(java.util.Locale.ROOT); - if (!"XMLPARSE".equals(name) && !"XMLELEMENT".equals(name) && !"XMLFOREST".equals(name)) { + if (!hasUnqualifiedName(function, "XMLPARSE") && !hasUnqualifiedName(function, "XMLELEMENT") + && !hasUnqualifiedName(function, "XMLFOREST")) { return; } Token token = getToken(1); @@ -923,8 +1595,55 @@ public class CCJSqlParser extends AbstractJSqlParser { function.setExtraKeyword(getNextToken().image); } - private void normalizeOdbcTimestampInterval(Function function) { - if (!function.isEscaped() || function.getMultipartName().size() != 1 + // Matches the single name part, since getName() joins the parts into a new string on each call. + private static boolean hasUnqualifiedName(Function function, String name) { + List nameParts = function.getMultipartName(); + return nameParts != null && nameParts.size() == 1 && name.equalsIgnoreCase(nameParts.get(0)); + } + + /** + * An unquoted YEAR, MONTH, DAY, HOUR, MINUTE or SECOND passed on its own as a function argument, as in + * DATEADD(day, 1, d), is a date unit. Anywhere else it is an ordinary identifier, so it is parsed as a + * Column and only converted here, once it is known to be a whole argument. + */ + private void normalizeDateUnitArguments(Function function) { + ExpressionList parameters = function.getParameters(); + if (parameters == null || parameters instanceof ParenthesedExpressionList) { + return; + } + ExpressionList normalized = null; + for (int i = 0; i < parameters.size(); i++) { + if (!isDateUnitColumn(parameters.get(i))) { + continue; + } + Column column = (Column) parameters.get(i); + DateUnitExpression unit = new DateUnitExpression(column.getColumnName()); + linkAST(unit, column.getASTNode()); + if (normalized == null) { + normalized = new ExpressionList(parameters); + normalized.setASTNode(parameters.getASTNode()); + } + normalized.set(i, unit); + } + if (normalized != null) { + function.setParameters(normalized); + } + } + + private static boolean isDateUnitColumn(Expression expression) { + if (!(expression instanceof Column)) { + return false; + } + Node node = ((Column) expression).getASTNode(); + if (node == null) { + return false; + } + Token first = node.jjtGetFirstToken(); + return first != null && first == node.jjtGetLastToken() && first.kind == K_DATE_LITERAL; + } + + private void normalizeOdbcTimestampInterval(Function function) { + if (!function.isEscaped() || function.getMultipartName().size() != 1 || !("TIMESTAMPADD".equalsIgnoreCase(function.getName()) || "TIMESTAMPDIFF".equalsIgnoreCase(function.getName()))) { return; @@ -951,6 +1670,39 @@ public class CCJSqlParser extends AbstractJSqlParser { } } + /** + * Whether MySQL's {@code TABLE name} follows an INSERT target, so that TABLE starts the + * source query instead of naming an alias of the target. + */ + private boolean isInsertTableSourceAhead() { + if (getToken(1).kind != K_TABLE) { + return false; + } + int kind = getToken(2).kind; + if (kind == S_IDENTIFIER || kind == S_QUOTED_IDENTIFIER) { + return true; + } + return kind >= MIN_NON_RESERVED_WORD && kind <= MAX_NON_RESERVED_WORD + && kind != K_OVERRIDING && kind != K_BY && kind != K_TABLE; + } + + /** Whether {@code AS CHAR(} or {@code AS BINARY(} follows a function argument. */ + private boolean isFunctionCastTypeAhead() { + int type = getToken(2).kind; + return getToken(1).kind == K_AS && (type == K_CHAR || type == K_BINARY) + && getToken(3).kind == OPENING_BRACKET; + } + + /** + * Whether a function takes MySQL's {@code AS CHAR(n)} or {@code AS BINARY(n)} cast: only + * {@code WEIGHT_STRING} does, after its single argument. + */ + private static boolean isWeightStringCall(Function function, ExpressionList arguments) { + return "WEIGHT_STRING".equalsIgnoreCase(function.getName()) && arguments != null + && arguments.size() == 1 && !function.isDistinct() && !function.isAllColumns() + && !function.isUnique(); + } + private boolean isKeywordArgumentAhead() { Token t = getToken(1); if (t.kind == EOF || t.image.equals(")")) return false; @@ -1010,32 +1762,30 @@ public class CCJSqlParser extends AbstractJSqlParser { // Returns 1 for true, 0 for false, or LONG_CHAIN when the walk exceeded // CHAIN_CACHE_THRESHOLD delimiter/part pairs (only in the non-filling pass). private int isAllTableColumnsWalk(boolean fill) { - int i = 1; - Token t = getToken(i); + Token last = getToken(1); // Must start with a name-like token - if (t.kind == S_LONG || t.kind == S_DOUBLE || t.kind == S_HEX - || t.kind == S_CHAR_LITERAL || t.kind == OPENING_BRACKET - || t.kind == CLOSING_BRACKET || t.kind == EOF) { + if (last.kind == S_LONG || last.kind == S_DOUBLE || last.kind == S_HEX + || last.kind == S_CHAR_LITERAL || last.kind == OPENING_BRACKET + || last.kind == CLOSING_BRACKET || last.kind == EOF) { return 0; } - i++; - // Walk through dotted name chain + // Walk through dotted name chain, following the token chain directly; + // repeated getToken(i) calls rescan from the start each time int delimiters = 0; List chainParts = fill ? new ArrayList() : null; while (true) { - t = getToken(i); + Token t = nextWithItemToken(last); if (t.image.equals(".") || t.image.equals("..") || t.image.equals("...")) { if (!fill && ++delimiters > CHAIN_CACHE_THRESHOLD) { return LONG_CHAIN; } + last = nextWithItemToken(t); // skip delimiter, take next part (could be "*") if (fill) { - chainParts.add(getToken(i + 1)); + chainParts.add(last); } - i++; // skip delimiter - i++; // skip next part (could be "*") } else { break; } @@ -1043,8 +1793,7 @@ public class CCJSqlParser extends AbstractJSqlParser { // It's AllTableColumns if the chain ended on "*" // i.e., the last name part we skipped over was "*" - // Back up: the last token consumed was at (i-1) - boolean result = getToken(i - 1).image.equals("*"); + boolean result = last.image.equals("*"); // Each chain part that would pass the name-like guard walks the same // remaining suffix and obtains the same answer. @@ -1127,7 +1876,7 @@ public class CCJSqlParser extends AbstractJSqlParser { switch (kind) { case K_JOIN: case K_FOR: case K_ORDER: case K_UNION: case K_EXCEPT: case K_INTERSECT: - case K_USE: case K_OPTIMIZE: case K_FORCE: case K_UNKNOWN: + case K_USE: case K_OPTIMIZE: return true; default: return false; @@ -1149,6 +1898,42 @@ public class CCJSqlParser extends AbstractJSqlParser { } } + /** + * Both named-parameter forms match only a single-token name (or K_OUTER) directly followed + * by their assignment token; the 2-token lookahead fails for anything else, so this first + * check is equivalent to running that scan. + */ + private boolean isNamedParameterAssignmentAhead() { + int kind = getToken(2).kind; + return kind == K_ORACLE_NAMED_PARAMETER_ASSIGNMENT + || kind == K_POSTGRES_NAMED_PARAMETER_ASSIGNMENT; + } + + /** Distinguish EXISTS identifiers from predicates before suffixes and clause boundaries. */ + private boolean isExistsIdentifierAhead() { + if (getToken(1).kind != K_EXISTS) { + return false; + } + if ((ternaryThenBranchDepth > 0 || mapKeyDepth > 0) + && ":".equals(getToken(2).image)) { + return true; + } + int kind = getToken(2).kind; + if (kind == OPENING_BRACKET) { + return "+".equals(getToken(3).image) && getToken(4).kind == CLOSING_BRACKET; + } + if (kind == K_LIMIT || kind == K_OFFSET) { + Token value = getToken(3); + return value.kind == S_LONG || value.kind == S_DOUBLE || value.kind == S_PARAMETER + || value.kind == K_ALL || value.kind == K_NULL + || "?".equals(value.image) || ":".equals(value.image) + || "&".equals(value.image); + } + return isConditionKeywordAhead(2) + || kind == K_ORDER && (getToken(3).kind == K_BY || getToken(3).kind == K_SIBLINGS) + || kind == K_GROUP && getToken(3).kind == K_BY; + } + /** * Follower-based disambiguation for reserved keywords in ambiguous * positions (implicit alias, clause boundary, after parenthesised @@ -1190,6 +1975,10 @@ public class CCJSqlParser extends AbstractJSqlParser { case K_RIGHT: return nextKind != K_JOIN && nextKind != K_OUTER && nextKind != K_SEMI && nextKind != K_ANTI && nextKind != K_ARRAY_LITERAL; + case K_FULL: return nextKind != K_JOIN && nextKind != K_OUTER + && nextKind != K_SEMI && nextKind != K_ANTI + && nextKind != K_ANY && nextKind != K_ALL + && nextKind != K_ARRAY_LITERAL; case K_ARRAY_LITERAL: return nextKind != K_JOIN; case K_ALL: return nextKind != K_JOIN; @@ -1208,9 +1997,9 @@ public class CCJSqlParser extends AbstractJSqlParser { case K_NEXTVAL: return nextKind != K_VALUE; // IGNORE: blocks NULLS (IGNORE NULLS), FROM (DELETE IGNORE FROM), - // INDEX (IGNORE INDEX hint) + // INDEX and KEY (IGNORE INDEX and IGNORE KEY hints) case K_IGNORE: return nextKind != K_NULLS && nextKind != K_FROM - && nextKind != K_INDEX; + && nextKind != K_INDEX && nextKind != K_KEY; // GLOBAL: blocks IN (GLOBAL IN), TEMPORARY, JOIN (GLOBAL JOIN) case K_GLOBAL: return nextKind != K_IN && nextKind != K_TEMPORARY @@ -1221,10 +2010,13 @@ public class CCJSqlParser extends AbstractJSqlParser { case K_LIMIT: case K_OFFSET: return false; - // VALUE/VALUES: safe as alias when not starting VALUES(...) + // VALUE/VALUES: safe as alias when not starting VALUES(...), nor MySQL's + // VALUES ROW(...), which only VALUES starts case K_VALUE: case K_VALUES: return nextKind != OPENING_BRACKET && nextKind != S_IDENTIFIER - && nextKind != S_QUOTED_IDENTIFIER && nextKind != S_CHAR_LITERAL; + && nextKind != S_QUOTED_IDENTIFIER && nextKind != S_CHAR_LITERAL + && !(kind == K_VALUES && nextKind == K_ROW + && getToken(3).kind == OPENING_BRACKET); default: return false; @@ -1255,8 +2047,12 @@ public class CCJSqlParser extends AbstractJSqlParser { return true; } + if (getToken(1).kind == K_ONLY && isRelationOnlyAhead(prev)) { + return false; + } + // ── 2. After delimiters and operators: expression position ───── - // With K_FROM/K_SELECT/K_CURRENT removed from RelObjectName's + // With K_FROM/K_SELECT removed from RelObjectName's // token list, accepting all remaining keywords after these // delimiters and operators is safe. if (!prev.image.isEmpty()) { @@ -1317,6 +2113,10 @@ public class CCJSqlParser extends AbstractJSqlParser { // Set operators case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS: + // TABLE and COLUMN are always followed by the object name, as in + // CREATE TABLE value (...) or ADD COLUMN offset INT + case K_TABLE: case K_COLUMN: + // DDL / utility keywords (never identifiers) case K_FOREIGN: case K_CONSTRAINT: case K_UNIQUE: case K_CHECK: case K_FORCE: @@ -1333,28 +2133,77 @@ public class CCJSqlParser extends AbstractJSqlParser { return isReservedKeywordSafeByFollower(); } + /** + * Whether ONLY is PostgreSQL's prefix of a relation name, as in DELETE FROM ONLY t, + * JOIN ONLY t or FROM a, ONLY b, rather than a table or column named only. + */ + private boolean isRelationOnlyAhead(Token prev) { + return RelationOptions.isOnlyAhead(prev, getToken(2).kind); + } + + /** + * Whether the target of UPDATE, DELETE or MERGE carries PostgreSQL's inheritance scope: ONLY + * before the table name or * after it. MySQL and MariaDB have no ONLY there. + */ + private boolean isScopedDmlTargetAhead() { + if (getToken(1).kind == K_ONLY) { + return !isMySqlDialect() && isRelationOnlyAhead(getToken(0)); + } + int i = 2; + while (".".equals(getToken(i).image)) { + i += 2; + } + return "*".equals(getToken(i).image) && !"*".equals(getToken(i - 1).image); + } + + /** + * The targets of (columns) = source, when the source is an expression other than a + * parenthesized list or sub-select: one or more columns, array elements or fields. + */ + private static void requireUpdateSetTargets(ExpressionList targets) throws ParseException { + boolean valid = !targets.isEmpty(); + for (Object target : targets) { + valid &= target instanceof Column || target instanceof ArrayExpression + || target instanceof RowGetExpression; + } + requireSyntax(valid, "A SET column list names one or more columns"); + } + + /** WHERE CURRENT OF cursor, the positioned form of UPDATE and DELETE. */ + private boolean isWhereCurrentOfAhead() { + return getToken(1).kind == K_WHERE && getToken(2).kind == K_CURRENT + && getToken(3).kind == K_OF; + } + /** * DuckDB's FROM-first query: a FROM clause followed by query clauses the pipe syntax cannot * consume. Scanning stops at a pipe operator or the end of the statement, and clause keywords * nested in brackets (a sub-select, for instance) do not count. */ private boolean isFromFirstSelectAhead() { - if (getToken(1).kind != K_FROM) { + Token token = getToken(1); + if (token.kind != K_FROM) { return false; } int depth = 0; - for (int i = 2;; i++) { - Token token = getToken(i); - if (token == null || token.kind == EOF || ";".equals(token.image) - || "|>".equals(token.image)) { + while (true) { + token = nextWithItemToken(token); + if (token.kind == EOF || ";".equals(token.image) || "|>".equals(token.image)) { return false; } if ("(".equals(token.image)) { depth++; } else if (")".equals(token.image)) { - depth--; + // the end of the parenthesized query this FROM starts + if (--depth < 0) { + return false; + } } else if (depth == 0) { switch (token.kind) { + case K_UNION: + case K_EXCEPT: + case K_INTERSECT: + case K_MINUS: case K_SELECT: case K_WHERE: case K_GROUP: @@ -1381,6 +2230,114 @@ public class CCJSqlParser extends AbstractJSqlParser { return getToken(offset).kind == K_MACRO; } + /** + * DuckDB's FUNCTION alias of MACRO: FUNCTION [IF NOT EXISTS] name (parameters) AS body, where + * AS directly follows the parameters, the body is not a string and no LANGUAGE or OPTIONS + * clause follows it, unlike other dialects' CREATE FUNCTION (RETURNS ..., PostgreSQL's + * AS $tag$ ... $tag$ LANGUAGE ..., BigQuery's AS (expr) OPTIONS (...)). + */ + private boolean isCreateFunctionMacroAhead() { + int offset = 1; + int kind = getToken(offset).kind; + if (kind == K_TEMP || kind == K_TEMPORARY) { + offset++; + } + if (getToken(offset).kind != K_FUNCTION) { + return false; + } + // IF NOT EXISTS and a qualified name, at most 8 tokens, up to the parameter list + int nameEnd = offset + 8; + offset++; + while (getToken(offset).kind != OPENING_BRACKET) { + kind = getToken(offset).kind; + if (offset > nameEnd || kind == EOF || kind == ST_SEMICOLON) { + return false; + } + offset++; + } + int depth = 0; + do { + kind = getToken(offset).kind; + if (kind == OPENING_BRACKET) { + depth++; + } else if (kind == CLOSING_BRACKET) { + depth--; + } else if (kind == EOF) { + return false; + } + offset++; + } while (depth > 0); + if (getToken(offset).kind != K_AS) { + return false; + } + Token body = getToken(offset + 1); + if (body.kind == S_CHAR_LITERAL || body.kind == S_DOLLAR_QUOTED_STRING + || body.image.length() > 1 && body.image.startsWith("$") && body.image.endsWith("$")) { + return false; + } + // no LANGUAGE or OPTIONS clause outside parentheses up to the end of the statement + depth = 0; + for (offset++;; offset++) { + Token token = getToken(offset); + if (token.kind == EOF || depth == 0 && token.kind == ST_SEMICOLON) { + return true; + } + if (token.kind == OPENING_BRACKET) { + depth++; + } else if (token.kind == CLOSING_BRACKET) { + depth--; + } else if (depth == 0 && ("LANGUAGE".equalsIgnoreCase(token.image) + || "OPTIONS".equalsIgnoreCase(token.image))) { + return false; + } + } + } + + // the % of DuckDB's LIMIT 10% in the LIMIT clause being parsed, which ends its row count + private Token limitPercentToken = null; + + /** + * Finds the % that ends the row count of the LIMIT clause starting after the current token: + * at its top level and directly followed by the end of the clause, as in LIMIT 10% OFFSET 2. + */ + private Token findLimitPercentToken() { + int depth = 0; + for (Token token = nextWithItemToken(getToken(0));; token = nextWithItemToken(token)) { + if (token.kind == EOF || token.kind == ST_SEMICOLON) { + return null; + } + if ("(".equals(token.image) || "[".equals(token.image)) { + depth++; + } else if (")".equals(token.image) || "]".equals(token.image)) { + if (--depth < 0) { + return null; + } + } else if (depth == 0 && "%".equals(token.image) + && isLimitClauseEnd(nextWithItemToken(token))) { + return token; + } + } + } + + /** Whether the token ends a LIMIT clause; OFFSET and FETCH only when they start a clause. */ + private boolean isLimitClauseEnd(Token token) { + switch (token.kind) { + case EOF: case ST_SEMICOLON: case CLOSING_BRACKET: + case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS: + return true; + case K_OFFSET: + // not a column named offset, as in LIMIT a % offset + 1 + Token value = nextWithItemToken(token); + return value.kind == S_LONG || value.kind == OPENING_BRACKET + || "?".equals(value.image) || ":".equals(value.image); + case K_FETCH: + Token next = nextWithItemToken(token); + return next.kind == K_FIRST || next.kind == K_NEXT; + default: + return false; + } + } + /** DuckDB sampling methods, which are ordinary identifiers except for SYSTEM/BERNOULLI. */ private boolean isSampleMethod(Token token) { return token.kind == K_SYSTEM || token.kind == K_BERNOULLI @@ -1440,6 +2397,39 @@ public class CCJSqlParser extends AbstractJSqlParser { return isKeywordAhead("MATCH_RECOGNIZE") && getToken(2).kind == OPENING_BRACKET; } + /** + * The conflict resolution of SQLite's INSERT OR <algorithm>. Every algorithm needs + * Dialect.SQLITE, as ABORT, FAIL, IGNORE and ROLLBACK are SQLite's own wording; without a + * dialect the Upsert() production keeps the historic reading of INSERT OR REPLACE. + */ + private InsertConflictAlgorithm insertOrAlgorithm(String algorithm) throws ParseException { + if (!"REPLACE".equalsIgnoreCase(algorithm) + && !Dialect.SQLITE.name().equals(getAsString(Feature.dialect))) { + throw new ParseException("INSERT OR " + algorithm + " needs Dialect.SQLITE"); + } + try { + return InsertConflictAlgorithm.fromAlgorithm(algorithm); + } catch (IllegalArgumentException e) { + throw new ParseException(e.getMessage()); + } + } + + /** + * Whether INSERT OR <algorithm> follows, the prefix that the plain Insert() production reads + * and that keeps ON CONFLICT, RETURNING, DEFAULT VALUES and the table aliases. It is read with + * Dialect.SQLITE only; without a dialect Upsert() keeps the historic INSERT OR REPLACE reading. + */ + private boolean isInsertOrPrefixAhead() { + return getToken(1).kind == K_INSERT + && getToken(2).kind == K_OR + && Dialect.SQLITE.name().equals(getAsString(Feature.dialect)); + } + + private boolean isCreateTableQueryPrefix() { + int kind = getToken(1).kind; + return kind == K_AS || kind == K_TABLE || kind == K_IGNORE || kind == K_REPLACE; + } + private boolean isRowPatternPrimaryAhead() { Token next = getToken(1); return next.kind == OPENING_BRACKET || next.kind == OP_CARET @@ -1449,8 +2439,174 @@ public class CCJSqlParser extends AbstractJSqlParser { || next.kind >= MIN_NON_RESERVED_WORD && next.kind <= MAX_NON_RESERVED_WORD; } + private static boolean isSliceDelimiter(Token token) { + return ":".equals(token.image) || "]".equals(token.image) || ",".equals(token.image); + } + + /** Whether a {@code [} opens DuckDB's {@code [expr FOR x IN list]}: FOR at its top level. */ + private boolean isListComprehensionAhead() { + Token token = getToken(1); + if (!"[".equals(token.image)) { + return false; + } + int depth = 0; + for (;; token = nextWithItemToken(token)) { + if (token.kind == EOF || ";".equals(token.image)) { + return false; + } + if ("(".equals(token.image) || "[".equals(token.image) || "{".equals(token.image)) { + depth++; + } else if (")".equals(token.image) || "]".equals(token.image) + || "}".equals(token.image)) { + if (--depth == 0) { + return false; + } + } else if (depth == 1 && token.kind == K_FOR) { + return true; + } + } + } + + /** + * Whether the pending "," ends a select item list, as DuckDB allows: it is followed by a + * closing parenthesis or by a clause that cannot be read as a column such as limit or "group". + */ + private boolean isTrailingSelectItemCommaAhead() { + if (!",".equals(getToken(1).image)) { + return false; + } + Token next = getToken(2); + int following = getToken(3).kind; + switch (next.kind) { + case CLOSING_BRACKET: + case K_FROM: case K_WHERE: case K_HAVING: case K_WINDOW: case K_INTO: + case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS: + return true; + case K_GROUP: case K_ORDER: + // not a column named group aliased by: SELECT a, group by FROM t + int afterBy = getToken(4).kind; + return following == K_BY && afterBy != K_FROM && afterBy != EOF + && afterBy != CLOSING_BRACKET && afterBy != ST_SEMICOLON + && !",".equals(getToken(4).image); + case K_LIMIT: case K_OFFSET: + return following == S_LONG || "?".equals(getToken(3).image); + default: + return false; + } + } + + /** + * Whether the REPLACE at {@code offset} is DuckDB's unparenthesized {@code REPLACE expr AS name}: + * an AS follows at the top level before the end of the select item, so that a star aliased + * "replace" keeps parsing. With {@code offset} 0, the REPLACE has been consumed. + */ + private boolean isUnparenthesizedReplaceAhead(int offset) { + Token token = getToken(offset); + if (offset > 0 && token.kind != K_REPLACE) { + return false; + } + int depth = 0; + while (true) { + token = nextWithItemToken(token); + if (token.kind == EOF || ";".equals(token.image)) { + return false; + } + if ("(".equals(token.image) || "[".equals(token.image) || "{".equals(token.image)) { + depth++; + } else if (")".equals(token.image) || "]".equals(token.image) + || "}".equals(token.image)) { + if (--depth < 0) { + return false; + } + } else if (depth == 0) { + if (token.kind == K_AS) { + return true; + } + if (token.kind == K_FROM || ",".equals(token.image)) { + return false; + } + } + } + } + + private boolean isUnparenthesizedReplaceAhead() { + return isUnparenthesizedReplaceAhead(1); + } + + /** + * Whether DuckDB's {@code RENAME (column AS name, ...)} or {@code RENAME column AS name} + * follows, every column being renamed with AS, so that a star aliased "rename" keeps parsing. + */ + private boolean isRenameAhead() { + Token token = getToken(1); + if (token.kind != K_RENAME) { + return false; + } + token = nextWithItemToken(token); + boolean parenthesized = "(".equals(token.image); + if (parenthesized) { + token = nextWithItemToken(token); + } + while (true) { + // column [. column]* AS name + while (true) { + if (!isIdentifierishNameToken(token)) { + return false; + } + token = nextWithItemToken(token); + if (!".".equals(token.image)) { + break; + } + token = nextWithItemToken(token); + } + if (token.kind != K_AS) { + return false; + } + token = nextWithItemToken(token); + if (!isIdentifierishNameToken(token)) { + return false; + } + token = nextWithItemToken(token); + if (!parenthesized) { + return true; + } + if (")".equals(token.image)) { + return true; + } + if (!",".equals(token.image)) { + return false; + } + token = nextWithItemToken(token); + } + } + + /** DuckDB's unparenthesized REPLACE and RENAME name their single item: * RENAME i AS x. */ + private static void requireTransformerAlias(SelectItem item) throws ParseException { + if (item.getAlias() == null) { + throw new ParseException("Expected AS and a name after " + item); + } + } + + /** Whether a window specification starts with the name of the window it extends. */ + private boolean isBaseWindowNameAhead() { + Token token = getToken(1); + switch (token.kind) { + case K_PARTITION: case K_ORDER: case K_ROWS: case K_RANGE: case K_GROUPS: + return false; + default: + return isIdentifierishNameToken(token); + } + } + + private boolean isBulkCollectIntoAhead() { + return "BULK".equalsIgnoreCase(getToken(1).image) + && "COLLECT".equalsIgnoreCase(getToken(2).image) + && getToken(3).kind == K_INTO; + } + private boolean isAliasAhead() { - if (isAsOfJoinAhead() || isSemiAntiJoinAhead() || isApproxNearestAhead()) { + if (isAsOfJoinAhead() || isSemiAntiJoinAhead() || isApproxNearestAhead() + || isBulkCollectIntoAhead()) { return false; } Token t = getToken(1); @@ -1459,6 +2615,13 @@ public class CCJSqlParser extends AbstractJSqlParser { // AS always starts an alias if (kind == K_AS) return true; + // SAMPLE followed by a size or BLOCK starts a sampling clause. + if (kind == K_SAMPLE && (getToken(2).kind == OPENING_BRACKET + || getToken(2).kind == K_BLOCK || getToken(2).kind == S_LONG + || getToken(2).kind == S_DOUBLE)) { + return false; + } + // String-literal alias: SELECT col 'myAlias' if (kind == S_CHAR_LITERAL) return true; @@ -1473,13 +2636,28 @@ public class CCJSqlParser extends AbstractJSqlParser { return false; } + // ClickHouse's PREWHERE and SETTINGS clauses, not aliases + if (kind == K_PREWHERE || kind == K_SETTINGS) { + return false; + } + + // MySQL's FORCE INDEX|KEY (...) index hint, not an alias + if (kind == K_FORCE && (getToken(2).kind == K_INDEX || getToken(2).kind == K_KEY)) { + return false; + } + + // GRANT after a CREATE SCHEMA element starts the next element + if (kind == K_GRANT && schemaElementDepth > 0) { + return false; + } + // For reserved keywords in alias position, skip the structural- // keyword whitelist and go directly to follower disambiguation. // Only check keywords that are actually in RelObjectName's token // alternatives — don't fire for brackets, operators, literals, etc. switch (kind) { case K_ALL: case K_ARRAY_LITERAL: case K_ANY: case K_CASEWHEN: case K_CONNECT: - case K_CREATE: case K_DEFAULT: + case K_CREATE: case K_DEFAULT: case K_FULL: case K_GLOBAL: case K_GROUP: case K_GROUPING: case K_IF: case K_IIF: case K_IGNORE: case K_IN: case K_INTERVAL: case K_LEFT: case K_LIMIT: case K_NEXTVAL: case K_OFFSET: @@ -1507,6 +2685,10 @@ public class CCJSqlParser extends AbstractJSqlParser { return false; } + private static void requireSyntax(boolean valid, String message) throws ParseException { + if (!valid) { throw new ParseException(message); } + } + private static void requireTypeDdlSyntax(boolean valid, String message) throws ParseException { if (!valid) { throw new ParseException(message); } } @@ -1520,681 +2702,3445 @@ public class CCJSqlParser extends AbstractJSqlParser { if (!valid) { throw new ParseException(message); } } + private static void requireDeleteSyntax(boolean valid, String message) throws ParseException { + if (!valid) { throw new ParseException(message); } + } + private static > E replicationEnum(Class type, String value) throws ParseException { try { return Enum.valueOf(type, MultiPartName.unquote(value).toUpperCase(Locale.ROOT)); } catch (IllegalArgumentException exception) { throw new ParseException("Unknown " + type.getSimpleName() + ": " + value); } } - private boolean isKeywordAhead(String keyword) { - Token token = getToken(1); - return token.image != null && keyword.equalsIgnoreCase(token.image); + /** + * MySQL's replication statements parse without a dialect and with MySQL's. MariaDB spells + * them differently (CHANGE MASTER, connection names, MASTER_ options) and keeps today's + * readings, except for PURGE BINARY LOGS, which it shares. + */ + private boolean isMySqlReplicationDialect() { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.MYSQL.name().equals(dialect); } - private boolean isXmlTypeName(String name) { - return "XML".equalsIgnoreCase(name) || "[XML]".equalsIgnoreCase(name) - || "\"XML\"".equalsIgnoreCase(name); + private static boolean isWord(Token token, String word) { + return token.kind == S_IDENTIFIER && word.equalsIgnoreCase(token.image); } - private boolean isMySqlStatisticsOptionAhead() { - String name = getToken(1).image; - return "STATS_AUTO_RECALC".equalsIgnoreCase(name) - || "STATS_PERSISTENT".equalsIgnoreCase(name) - || "STATS_SAMPLE_PAGES".equalsIgnoreCase(name); + /** START REPLICA or STOP REPLICA, as {@code kind} says. */ + private boolean isReplicaThreadStatementAhead(int kind) { + return getToken(1).kind == kind && isWord(getToken(2), "REPLICA") && isMySqlReplicationDialect(); } - private boolean isMySqlTableOptionAhead() { - int kind = getToken(1).kind; - if (kind == K_ENGINE || kind == K_COLLATE || kind == K_COMMENT - || kind == K_AUTO_INCREMENT || kind == K_UNION - || isMySqlStatisticsOptionAhead()) { - return true; - } - if (kind == K_CHARACTER && getToken(2).kind == K_SET - || kind == K_CHAR && getToken(2).kind == K_SET) { - return true; + /** CHANGE REPLICATION SOURCE TO or CHANGE REPLICATION FILTER. */ + private boolean isChangeReplicationAhead() { + Token third = getToken(3); + return getToken(1).kind == K_CHANGE && isWord(getToken(2), "REPLICATION") + && (isWord(third, "SOURCE") && getToken(4).kind == K_TO || third.kind == K_FILTER) + && isMySqlReplicationDialect(); + } + + /** + * RESET BINARY LOGS AND GTIDS or RESET REPLICA. Without a dialect, a bare RESET REPLICA keeps + * its reading as the PostgreSQL RESET of a parameter named replica; ALL, FOR CHANNEL or a + * further reset option after it is MySQL's. + */ + private boolean isResetReplicationAhead() { + if (getToken(1).kind != K_RESET || !isMySqlReplicationDialect()) { + return false; } - if (kind == S_IDENTIFIER && "CHARSET".equalsIgnoreCase(getToken(1).image)) { - return true; + if (getToken(2).kind == K_BINARY) { + return isWord(getToken(3), "LOGS"); } - if (kind != K_DEFAULT) { + int next = getToken(3).kind; + return isWord(getToken(2), "REPLICA") && (getAsString(Feature.dialect) != null + || next == K_ALL || next == K_FOR || next == K_COMMA); + } + + /** + * BINARY LOGS after PURGE, and MariaDB's MASTER LOGS, which MySQL 8.4 removed. PURGE is + * already consumed here. + */ + private boolean isPurgeLogsAhead() { + if (!isWord(getToken(2), "LOGS")) { return false; } - int secondKind = getToken(2).kind; - return secondKind == K_CHARACTER || secondKind == K_CHAR || secondKind == K_COLLATE - || secondKind == S_IDENTIFIER - && "CHARSET".equalsIgnoreCase(getToken(2).image); + boolean mariaDb = Dialect.MARIADB.name().equals(getAsString(Feature.dialect)); + return getToken(1).kind == K_BINARY && (mariaDb || isMySqlReplicationDialect()) + || isWord(getToken(1), "MASTER") && mariaDb; } - private boolean isTableIndexAhead() { - switch (getToken(1).kind) { - case K_PRIMARY: - case K_UNIQUE: - case K_INDEX: - case K_KEY: - case K_FULLTEXT: - case K_SPATIAL: - return true; - default: - return false; - } + /** A MySQL text string: a plain single-quoted literal, without a prefix. */ + private StringValue replicationString(Token token) throws ParseException { + requireReplicationSyntax(token.image.startsWith("'"), "Expected a quoted string: " + token.image); + return stringValue(token); + } + + /** PRIVILEGE_CHECKS_USER takes user[@host]; CURRENT_USER is reserved in MySQL. */ + private static UserAccount requirePrivilegeChecksAccount(UserAccount account) throws ParseException { + StringValue user = account.getUser(); + requireReplicationSyntax(!account.isCurrentUserParentheses() + && !("".equals(user.getQuoteStr()) && "CURRENT_USER".equalsIgnoreCase(user.getValue())), + "PRIVILEGE_CHECKS_USER takes an account name"); + return account; } /** - * True when the pending {@code ON} opens the ON CONFLICT clause of the enclosing - * INSERT rather than another trailing join condition: after a join, the trailing - * ON expressions of Issue #1302 and the INSERT clause claim the same ON token. - * The clause shapes are ON CONFLICT DO, ON CONFLICT ON CONSTRAINT and - * ON CONFLICT ( target ) [ WHERE ] DO, so the parenthesized target has to be - * separated from an expression by scanning past its balanced brackets. + * DuckDB's lambda x, y : expr. LAMBDA stays a plain identifier, so a column, type or alias + * named lambda keeps parsing: only LAMBDA followed by names separated by commas and a ":" is + * a lambda. */ - private boolean isInsertOnConflictAhead() { - if (getToken(1).kind != K_ON || getToken(2).kind != K_CONFLICT) { - return false; - } - Token t = getToken(3); - if (t.kind == K_DO) { - return true; - } - if (t.kind == K_ON) { - return getToken(4).kind == K_CONSTRAINT; - } - if (!"(".equals(t.image)) { + private boolean isDuckDBLambdaAhead() { + if (getToken(1).kind != S_IDENTIFIER || !isKeywordAhead("LAMBDA")) { return false; } - int depth = 1; - int i = 4; - while (depth > 0) { - t = getToken(i++); - if (t == null || t.kind == EOF) { + int offset = 2; + while (true) { + int kind = getToken(offset).kind; + if (kind != S_IDENTIFIER && kind != S_QUOTED_IDENTIFIER && kind != DATA_TYPE + && (kind < MIN_NON_RESERVED_WORD || kind > MAX_NON_RESERVED_WORD)) { return false; } - if ("(".equals(t.image)) { - depth++; - } else if (")".equals(t.image)) { - depth--; + String next = getToken(offset + 1).image; + if (":".equals(next)) { + return true; } + if (!",".equals(next)) { + return false; + } + offset += 2; } - t = getToken(i); - if (t.kind == K_DO) { - return true; - } - if (t.kind != K_WHERE) { + } + + private boolean isKeywordAhead(String keyword) { + Token token = getToken(1); + return token.kind != EOF && token.image != null && keyword.equalsIgnoreCase(token.image); + } + + /** Whether the token at the position is an identifier spelled as one of the words. */ + private boolean isAnyWordAt(int position, String... words) { + Token token = getToken(position); + if (token.kind != S_IDENTIFIER) { return false; } - // the index predicate ends where the conflict action's DO begins - depth = 0; - for (i++; ; i++) { - t = getToken(i); - if (t == null || t.kind == EOF) { - return false; - } - if ("(".equals(t.image)) { - depth++; - } else if (")".equals(t.image)) { - depth--; - } else if (t.kind == K_DO && depth == 0) { + for (String word : words) { + if (word.equalsIgnoreCase(token.image)) { return true; } } + return false; } - private static void requireAccessSyntax(boolean condition, String message) throws ParseException { - if (!condition) { throw new ParseException(message); } + /** The MySQL server SHOW statements are read with Dialect.MYSQL or MARIADB, or without one. */ + private boolean isMySqlShowDialect() { + return getAsString(Feature.dialect) == null || isMySqlDialect(); } - private static > E accessEnum(Class type, String value) throws ParseException { - try { return Enum.valueOf(type, value.toUpperCase(Locale.ROOT)); } - catch (IllegalArgumentException ex) { throw new ParseException("Invalid " + type.getSimpleName() + ": " + value); } + /** + * MySQL 8.4 removed SHOW MASTER STATUS, MASTER LOGS, SLAVE STATUS and SLAVE HOSTS, so they are + * read with Dialect.MARIADB or without a dialect only. + */ + private boolean isLegacyMySqlShowDialect() { + return !Dialect.MYSQL.name().equals(getAsString(Feature.dialect)); } - private boolean isRoleOptionAhead(int offset) { - if (getToken(offset).kind == EOF) { return false; } - String word = getToken(offset).image.toUpperCase(Locale.ROOT); - return Arrays.asList("SUPERUSER", "NOSUPERUSER", "CREATEDB", "NOCREATEDB", "CREATEROLE", "NOCREATEROLE", - "INHERIT", "NOINHERIT", "LOGIN", "NOLOGIN", "REPLICATION", "NOREPLICATION", "BYPASSRLS", "NOBYPASSRLS", - "CONNECTION", "ENCRYPTED", "PASSWORD", "VALID", "IN", "ROLE", "USER", "ADMIN", "SYSID").contains(word); + /** [GLOBAL | SESSION | LOCAL] VARIABLES or STATUS follows. */ + private boolean isShowVariablesAhead() { + int kind = getToken(1).kind; + return isAnyWordAt(kind == K_GLOBAL || kind == K_SESSION || kind == K_LOCAL ? 2 : 1, + "VARIABLES", "STATUS"); } - private boolean isPostgreSqlRoleAhead() { - if (isAccessKeywordAhead("ROLE") || isAccessKeywordAhead("GROUP")) { return true; } - return isAccessKeywordAhead("USER") && !"MAPPING".equalsIgnoreCase(getToken(2).image) - && (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - || "WITH".equalsIgnoreCase(getToken(3).image) || isRoleOptionAhead(3)); + /** + * A MySQL text string: '...' or "..." without a prefix or introducer. The lexer reads "..." as + * a string with a MySQL dialect and as a quoted identifier without one. + */ + private boolean isMySqlTextStringAt(int position) { + Token token = getToken(position); + char quote = token.image == null || token.image.isEmpty() ? ' ' : token.image.charAt(0); + return token.kind == S_CHAR_LITERAL && (quote == '\'' || quote == '"') + || token.kind == S_QUOTED_IDENTIFIER && quote == '"'; } - private boolean isAccessKeywordAhead(String word) { - return getToken(1).kind != EOF && isKeywordAhead(word); + /** + * Whether the lookahead of a SHOW statement has scanned the WHERE of its filter: a WHERE lies + * between the last consumed token and the scan position. + */ + private boolean isShowWhereScanned() { + Token scanned = getToken(1); + for (Token t = token.next; t != null && t != scanned; t = t.next) { + if (t.kind == K_WHERE) { + return true; + } + } + return false; } - private boolean isAccessTargetKindAhead() { - Token next = getToken(2); - return next.kind != EOF && next.kind != K_TO && next.kind != K_FROM - && !",".equals(next.image) && !".".equals(next.image) - && isAccessTargetKindAhead(1); + /** COUNT(*) with the parenthesis right after COUNT, as the MySQL lexer requires. */ + private boolean isShowCountAhead() { + Token count = getToken(1); + Token parenthesis = getToken(2); + return count.kind == K_COUNT && "(".equals(parenthesis.image) + && parenthesis.beginLine == count.endLine + && parenthesis.beginColumn == count.endColumn + 1; } - private boolean isAccessTargetKindAhead(int offset) { - return Arrays.asList("TABLE", "SEQUENCE", "DATABASE", "DOMAIN", "FOREIGN", "FUNCTION", "PROCEDURE", - "ROUTINE", "LANGUAGE", "LARGE", "PARAMETER", "SCHEMA", "TABLESPACE", "TYPE") - .contains(getToken(offset).image.toUpperCase(Locale.ROOT)); + /** FOR CHANNEL 'channel' follows. */ + private boolean isShowChannelAhead() { + return getToken(1).kind == K_FOR && isAnyWordAt(2, "CHANNEL") && isMySqlTextStringAt(3); } - private boolean isObjectPrivilegeAhead() { - int depth = 0; - for (int i = 1; ; i++) { - Token token = getToken(i); - if (token.kind == EOF || ";".equals(token.image)) { return false; } - if ("(".equals(token.image)) { depth++; } - else if (")".equals(token.image)) { depth--; } - else if (depth == 0) { - if (token.kind == K_ON) { return true; } - if (token.kind == K_TO || token.kind == K_FROM) { return false; } - } + /** + * Whether a MySQL CHECK, CHECKSUM, OPTIMIZE or REPAIR TABLE statement starts here. TABLE or + * TABLES must follow, so other uses of these words are unaffected. + */ + private boolean isTableMaintenanceAhead() { + int kind = getToken(1).kind; + if (kind != K_CHECK && kind != K_CHECKSUM && kind != K_OPTIMIZE && kind != K_REPAIR) { + return false; + } + int offset = 2; + int modifier = getToken(2).kind; + if ((kind == K_OPTIMIZE || kind == K_REPAIR) + && (modifier == K_NO_WRITE_TO_BINLOG || modifier == K_LOCAL)) { + offset = 3; } + int table = getToken(offset).kind; + return table == K_TABLE || table == K_TABLES; } - private boolean isPostgreSqlTriggerAhead() { - if (getToken(1).kind == K_CONSTRAINT) { return true; } - if (getToken(1).kind != K_TRIGGER) { return false; } - for (int i = 2; ; i++) { - Token token = getToken(i); - if (token.kind == EOF || ";".equals(token.image) || token.kind == K_BEGIN) { return false; } - if (token.kind == K_EXECUTE && (getToken(i + 1).kind == K_FUNCTION || getToken(i + 1).kind == K_PROCEDURE)) { return true; } - // DuckDB 2.0 uses the standard header with a statement body instead of EXECUTE - if ("REFERENCING".equalsIgnoreCase(token.image) || token.kind == K_STATEMENT) { return true; } - } + /** MySQL's table and backup locks parse without a dialect and in the dialects that have them. */ + private boolean isMySqlLockDialect(boolean mariaDb) { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.MYSQL.name().equals(dialect) + || mariaDb && Dialect.MARIADB.name().equals(dialect); } - // In these dialects -> always denotes JSON access, even after a comma or parentheses. - private boolean isJsonArrowDialect() { - return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - || isMySqlDialect(); + /** + * Whether the words after LOCK are MySQL's TABLE or TABLES, a table name, an optional alias and + * a lock type. No PostgreSQL or Oracle LOCK continues a table name with an alias or with READ, + * WRITE or LOW_PRIORITY, so their readings, including a table named tables and ONLY t, stay + * unchanged. MySQL has no ONLY keyword here, so ONLY counts as a name. + */ + private boolean isMySqlLockTablesAhead() { + int kind = getToken(1).kind; + if (kind != K_TABLE && kind != K_TABLES || !isMySqlLockDialect(true)) { + return false; + } + int offset = 2; + while (isIdentifierishNameToken(getToken(offset)) && ".".equals(getToken(offset + 1).image)) { + offset += 2; + } + if (!isIdentifierishNameToken(getToken(offset))) { + return false; + } + Token next = getToken(offset + 1); + return next.kind == K_AS || isMySqlLockTypeAhead(offset + 1) + || isIdentifierishNameToken(next) && isMySqlLockTypeAhead(offset + 2); } - private boolean isMySqlDialect() { - String dialect = getAsString(Feature.dialect); - return Dialect.MYSQL.name().equals(dialect) || Dialect.MARIADB.name().equals(dialect); + private boolean isMySqlLockTypeAhead(int offset) { + Token token = getToken(offset); + return token.kind == K_READ || token.kind == K_LOW_PRIORITY + || token.kind == S_IDENTIFIER && "WRITE".equalsIgnoreCase(token.image); } - private boolean isMySqlSelectIntoAhead() { - if (getToken(1).kind != K_INTO) { return false; } + private boolean isUnlockTablesAhead() { int kind = getToken(2).kind; - return kind == K_OUTFILE || kind == K_DUMPFILE - || isMySqlDialect() && (kind == S_AT_IDENTIFIER || kind == K_AT_SIGN); + return getToken(1).kind == K_UNLOCK && (kind == K_TABLE || kind == K_TABLES) + && isMySqlLockDialect(true); } - private static UserVariable requireMySqlIntoVariable(UserVariable variable) throws ParseException { - if (variable.isDoubleAdd()) { - throw new ParseException("INTO requires a user variable with a single @ prefix"); - } - return variable; + /** MySQL's LOCK INSTANCE FOR BACKUP or UNLOCK INSTANCE, which MariaDB does not have. */ + private boolean isBackupLockAhead() { + int kind = getToken(1).kind; + boolean instance = getToken(2).kind == S_IDENTIFIER && "INSTANCE".equalsIgnoreCase(getToken(2).image); + return instance && (kind == K_UNLOCK || kind == K_LOCK && getToken(3).kind == K_FOR) + && isMySqlLockDialect(false); } - private ExplainStatement.OptionType postgresqlExplainOptionType(String name) throws ParseException { - try { - return ExplainStatement.OptionType.from(name); - } catch (IllegalArgumentException ex) { - throw new ParseException("Unknown PostgreSQL EXPLAIN option: " + name); - } + /** MySQL's FLUSH, KILL, HANDLER and RESET PERSIST parse without a dialect and with MySQL's. */ + private boolean isMySqlServerAdminDialect() { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.MYSQL.name().equals(dialect); } - private void validatePostgresqlExplain(ExplainStatement explain) throws ParseException { - if (explain.getTable() != null) { - throw new ParseException("PostgreSQL EXPLAIN requires a statement"); + /** + * Whether MySQL FLUSH starts here: FLUSH, an optional NO_WRITE_TO_BINLOG or LOCAL, and then + * TABLE, TABLES or the first word of a flush option. Other FLUSH forms, such as the FLUSH + * HOSTS that MySQL 8.4 removed, remain unsupported statements. + */ + private boolean isFlushAhead() { + if (getToken(1).kind != K_FLUSH || !isMySqlServerAdminDialect()) { + return false; } - int previous = -1; - for (ExplainStatement.Option option : explain.getOptionList()) { - ExplainStatement.OptionType type = option.getType(); - String value = option.getValue(); - if (!explain.isParenthesizedOptions()) { - int position = type == ExplainStatement.OptionType.ANALYZE ? 0 - : type == ExplainStatement.OptionType.VERBOSE ? 1 : -1; - if (position <= previous || value != null) { - throw new ParseException("PostgreSQL EXPLAIN options require parentheses"); - } - previous = position; - } else { - boolean valid; - switch (type) { - case FORMAT: - valid = value != null && value.matches("(?i)TEXT|XML|JSON|YAML"); - break; - case SERIALIZE: - valid = value == null || value.matches("(?i)NONE|TEXT|BINARY"); - break; - case PLAN: case PLAN_FOR: - valid = false; - break; - default: - valid = value == null || value.matches("(?i)TRUE|FALSE|ON|OFF|0|1"); - } - if (!valid) { - throw new ParseException("Invalid PostgreSQL EXPLAIN option: " + option.formatOption()); - } + int modifier = getToken(2).kind; + Token next = getToken(modifier == K_NO_WRITE_TO_BINLOG || modifier == K_LOCAL ? 3 : 2); + if (next.kind == K_TABLE || next.kind == K_TABLES) { + return true; + } + if (next.kind != S_IDENTIFIER && next.kind != K_BINARY && next.kind != K_ENGINE + && next.kind != K_ERROR) { + return false; + } + for (FlushOption.Kind kind : FlushOption.Kind.values()) { + if (kind.getKeyword().split(" ")[0].equalsIgnoreCase(next.image)) { + return true; } } + return false; } - private void requireDdlSyntax(boolean valid, String message) throws ParseException { - if (!valid) { - throw new ParseException(message); - } + /** Whether MySQL KILL [CONNECTION | QUERY] processlist_id starts here. */ + private boolean isKillAhead() { + int next = getToken(2).kind; + return getToken(1).kind == K_KILL && next != EOF && next != ST_SEMICOLON + && isMySqlServerAdminDialect(); } - private LikeClause.OptionKind likeOptionKind(String name) throws ParseException { - try { - return LikeClause.OptionKind.valueOf(name.toUpperCase(Locale.ROOT)); - } catch (IllegalArgumentException ex) { - throw new ParseException("Unknown LIKE option: " + name); + /** Whether MySQL HANDLER starts here: a table or handler name, then OPEN, READ or CLOSE. */ + private boolean isHandlerAhead() { + if (getToken(1).kind != K_HANDLER || !isMySqlServerAdminDialect()) { + return false; } + int offset = 2; + while (isIdentifierishNameToken(getToken(offset)) && ".".equals(getToken(offset + 1).image)) { + offset += 2; + } + int action = getToken(offset + 1).kind; + return isIdentifierishNameToken(getToken(offset)) + && (action == K_OPEN || action == K_READ || action == K_CLOSE); } - private boolean isIdentityAlterationAhead() { - int first = getToken(1).kind; - int second = getToken(2).kind; - if ((first == K_ADD || first == K_SET) - && "GENERATED".equalsIgnoreCase(getToken(2).image)) { - return true; + /** + * Whether HANDLER ... READ continues with an index name: a comparison or FIRST, NEXT, PREV or + * LAST follows the name. Otherwise FIRST or NEXT reads in storage order. + */ + private boolean isHandlerIndexAhead() { + Token next = getToken(2); + switch (next.kind) { + case K_FIRST: case K_NEXT: case K_LAST: + case OP_GREATERTHANEQUALS: case OP_MINORTHANEQUALS: + return isIdentifierishNameToken(getToken(1)); + default: + return isIdentifierishNameToken(getToken(1)) && ("=".equals(next.image) + || "<".equals(next.image) || ">".equals(next.image) + || next.kind == S_IDENTIFIER && "PREV".equalsIgnoreCase(next.image)); } - if (first == K_RESTART || (first == K_DROP && second == K_IDENTITY)) { + } + + /** + * Whether MySQL RESET PERSIST starts here. Without a dialect only a variable name, which may + * have a component prefix, or IF EXISTS after PERSIST tells it from PostgreSQL's RESET of a + * parameter named persist, which a bare RESET PERSIST keeps. + */ + private boolean isResetPersistAhead() { + if (getToken(1).kind != K_RESET || !isWordSequenceAhead(2, "PERSIST")) { + return false; + } + String dialect = getAsString(Feature.dialect); + if (Dialect.MYSQL.name().equals(dialect)) { return true; } - if (first == K_SET) { - switch (second) { - case K_INCREMENT: case K_START: case K_MINVALUE: case K_MAXVALUE: - case K_NO: case K_CACHE: case K_CYCLE: - return true; - default: - return false; + Token next = getToken(3); + int end = getToken(4).kind; + return dialect == null && (next.kind == K_IF && end == K_EXISTS + || isIdentifierishNameToken(next) + && (end == EOF || end == ST_SEMICOLON || ".".equals(getToken(4).image))); + } + + /** Whether one of the expressions holds a subquery. */ + private static boolean containsSubquery(Expression... expressions) { + boolean[] found = new boolean[1]; + ExpressionVisitorAdapter finder = new ExpressionVisitorAdapter() { + @Override + public Void visit(Select select, S context) { + found[0] = true; + return null; + } + }; + for (Expression expression : expressions) { + if (expression != null) { + expression.accept(finder, null); } } - return false; + return found[0]; } - /** Attaches the structured index and populates the remaining legacy constraint metadata. */ - private static void setAlterTableIndex(AlterExpression alterExp, Index index) { - alterExp.setIndex(index); - if (index.getKind() == Index.Kind.UNIQUE) { - alterExp.setUkName(index instanceof NamedConstraint - ? ((NamedConstraint) index).getIndexName() : index.getName()); - alterExp.setUk(index.getType().toUpperCase(Locale.ROOT).contains("KEY")); - alterExp.setUkTypeSpecified(index.getIndexKeyword() != null); - // Named constraints render their own options; only legacy indexes need projection. - for (String option : index instanceof NamedConstraint ? Collections.emptyList() - : new ArrayList(index.getIndexSpec())) { - if (option.toUpperCase(Locale.ROOT).startsWith("USING ")) { - alterExp.addParameters("USING"); - alterExp.addParameters(option.substring("USING ".length())); - index.getIndexSpec().remove(option); - } else if (option.toUpperCase(Locale.ROOT).startsWith("COMMENT ")) { - index.setCommentText(option.substring("COMMENT ".length())); - index.getIndexSpec().remove(option); - } - } - } - if (index instanceof ForeignKeyIndex) { - ForeignKeyIndex foreignKey = (ForeignKeyIndex) index; - alterExp.setFkColumns(foreignKey.getColumnsNames()); - if (foreignKey.getTable() != null) { - alterExp.setFkSourceSchema(foreignKey.getTable().getSchemaName()); - alterExp.setFkSourceTable(foreignKey.getTable().getName()); - } - alterExp.setFkSourceColumns(foreignKey.getReferencedColumnNames()); - for (ReferentialAction.Type type : ReferentialAction.Type.values()) { - ReferentialAction action = foreignKey.getReferentialAction(type); - if (action != null) { - alterExp.setReferentialAction(action.getType(), action.getAction()); - } - } + private static FlushOption.Kind flushOptionKind(String keyword) throws ParseException { + FlushOption.Kind kind = FlushOption.Kind.fromKeyword(keyword); + if (kind == null) { + throw new ParseException("Unknown FLUSH option: " + keyword); } + return kind; } - private void requireNoDropIndexOwner(Table owner) throws ParseException { - if (owner != null) { - throw new ParseException("Duplicate DROP INDEX ON clause"); + /** MySQL statements that MariaDB does not have are read with the MySQL dialect or none. */ + private boolean isMySqlOnlyStatementDialect(boolean orNone) { + String dialect = getAsString(Feature.dialect); + return orNone && dialect == null || Dialect.MYSQL.name().equals(dialect); + } + + /** + * Whether MySQL's SPATIAL REFERENCE SYSTEM follows CREATE or DROP. The MySQL dialect has no + * other statement that continues with SPATIAL but CREATE SPATIAL INDEX, so there a misspelled + * object type is an error; without a dialect only the three words select the statement. + */ + private boolean isSpatialReferenceSystemAhead() { + if (getToken(1).kind != K_SPATIAL) { + return false; } + return isMySqlOnlyStatementDialect(false) && getToken(2).kind != K_INDEX + || isMySqlOnlyStatementDialect(true) && isWordAt(2, "REFERENCE") + && getToken(3).kind == K_SYSTEM; } - private static boolean hasStructuredColumnOption(List options) { - for (ColumnOption option : options) { - if (option.getKind() != ColumnOption.Kind.OTHER) { - return true; - } + /** + * Whether MySQL's ALTER INSTANCE follows ALTER. Without a dialect, one of its actions must + * follow; other text stays an unsupported statement. + */ + private boolean isAlterInstanceAhead() { + if (!isWordAt(1, "INSTANCE")) { + return false; } - return false; + int action = getToken(2).kind; + return isMySqlOnlyStatementDialect(false) + || isMySqlOnlyStatementDialect(true) && (action == K_ENABLE || action == K_DISABLE + || isWordAt(2, "ROTATE") || isWordAt(2, "RELOAD")); } - /** Builds names from lexer-separated components without reinterpreting PostgreSQL dots. */ - protected Table createTable(List names) { - return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && names.size() == 1 - ? new Table(names.get(0), false) : new Table(names); + private boolean isSpatialReferenceSystemAttributeAhead() { + return getToken(1).kind == K_NAME || isKeywordAhead("DEFINITION") + || isKeywordAhead("ORGANIZATION") || isKeywordAhead("DESCRIPTION"); } - protected Column createColumn(List names, List delimiters) { - if (!Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { - return new Column(names, delimiters); - } - Column column = new Column(); - column.setName(names.get(names.size() - 1), false); - if (names.size() > 1) { - column.setTable(createTable(names.subList(0, names.size() - 1))); - } - column.setTableDelimiter(delimiters.isEmpty() ? "." : delimiters.get(delimiters.size() - 1)); - return column; + /** + * Whether MySQL reads the token as a plain string: quoted with ' or ", without a prefix such + * as N or _utf8. A double-quoted token is a string in MySQL's default SQL mode. + */ + private static boolean isMySqlTextString(Token token) { + return token.image.startsWith("'") || token.image.startsWith("\""); } - protected Column createColumn(String name) { - return createColumn(Collections.singletonList(name), Collections.emptyList()); + /** + * The number MySQL reads as an SRID or an organization's identifier: an unsigned integer up to + * 2^64 - 1, 0x... with a lower-case x, or X'...' with whole bytes. The server checks the range + * of the value when it runs the statement. + */ + private Expression spatialReferenceSystemNumber(Token token) throws ParseException { + boolean valid; + if (token.kind == S_HEX) { + valid = token.image.matches("[Xx]'([0-9A-Fa-f]{2})*'|0x[0-9A-Fa-f]+"); + } else { + valid = token.image.matches("[0-9]+") + && new java.math.BigInteger(token.image).bitLength() <= 64; + } + requireDdlSyntax(valid, "Expected an unsigned integer: " + token.image); + Expression number = token.kind == S_HEX ? new HexValue(token.image) + : new LongValue(token.image); + linkAST((ASTNodeAccess) number, token, token); + return number; } /** - * Lightweight lookahead for SpecialStringFunctionWithNamedParameters: - * scans forward from the current position (just past the opening '(') - * looking for FROM, IN, or PLACING at bracket nesting depth 0. - * - * This replaces an expensive syntactic LOOKAHEAD(NamedExpressionListExprFirst()) - * that caused exponential backtracking with deeply nested expressions. + * The word of ALTER INSTANCE that MySQL reads as an identifier and compares with a fixed name: + * plain or in backticks, and where {@code text} is set also a string. */ - protected boolean isNamedExprListAhead() { - int depth = 0; - for (int i = 1; ; i++) { - Token t = getToken(i); - if (t.kind == EOF) { - return false; - } - if (t.kind == OPENING_BRACKET) { - depth++; - } else if (t.kind == CLOSING_BRACKET) { - if (depth == 0) { - return false; - } - depth--; - } else if (depth == 0) { - if (t.kind == K_FROM || t.kind == K_IN || t.kind == K_PLACING) { - return true; - } - if (t.image.equals(",")) { - return false; - } - } + private static String alterInstanceWord(Token token, boolean text) throws ParseException { + String image = token.image; + if (token.kind == S_IDENTIFIER) { + return image; + } + if (image.startsWith("`")) { + return image.substring(1, image.length() - 1).replace("``", "`"); } + if (text && isMySqlTextString(token)) { + return new StringValue(image).getValue(); + } + throw new ParseException("Unexpected " + image + " in ALTER INSTANCE"); } /** - * Semantic lookahead for the adjacent string literal concatenation in PrimaryExpression: - * true when Feature.adjacentStringLiterals is on and the next token is a string literal - * meeting the mode's separation rule (WHITESPACE: any, NEWLINE: a newline between the - * tokens, detected through the token line numbers). + * Whether MySQL's LOAD {DATA | XML} [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE starts here, + * without a dialect or in MySQL and MariaDB. BigQuery's LOAD DATA continues with INTO or + * OVERWRITE and DuckDB's or PostgreSQL's LOAD with a name, so their readings, including an + * extension named xml, stay unchanged. */ - protected boolean isAdjacentStringConcat() { - String mode = getAsString(Feature.adjacentStringLiterals); - if (mode == null || AdjacentStringLiterals.OFF.name().equals(mode)) { + private boolean isMySqlLoadDataAhead() { + int format = getToken(2).kind; + String dialect = getAsString(Feature.dialect); + if (getToken(1).kind != K_LOAD || format != K_DATA && format != K_XML + || dialect != null && !isMySqlDialect()) { return false; } - if (getToken(1).kind != S_CHAR_LITERAL) { - return false; + int offset = 3; + if (getToken(offset).kind == K_LOW_PRIORITY || isWordAt(offset, "CONCURRENT")) { + offset++; } - if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - && (StringValue.getDollarQuoteDelimiter(getToken(0).image) != null - || !getToken(1).image.startsWith("'"))) { - return false; + if (getToken(offset).kind == K_LOCAL) { + offset++; } - return AdjacentStringLiterals.WHITESPACE.name().equals(mode) - || getToken(1).beginLine > getToken(0).endLine; + return isWordAt(offset, "INFILE"); + } + + private boolean isMySqlCharacterSetClauseAhead() { + return getToken(1).kind == K_CHARACTER && getToken(2).kind == K_SET + || isWordAt(1, "CHARSET"); } /** - * Checks if the next token can start a condition suffix - * (comparison, IN, BETWEEN, LIKE, IS NULL, etc.) - * - * Used as the entry guard for the entire optional condition-suffix block - * in Condition(), eliminating choice conflicts. + * The number of MySQL's IGNORE number {LINES | ROWS}. MySQL reads it as an integer of at most + * 2147483647, leading zeros aside, and reports a larger one as a syntax error. */ - protected boolean isConditionSuffixAhead() { - Token t = getToken(1); - // Inline isComparisonOperatorAhead for single getToken(1) call - if (t.kind == OPENING_BRACKET && getToken(2).image.equals("+")) { - return isComparisonOperator(getToken(4)); + private static Long mySqlIgnoreCount(Token token) throws ParseException { + String digits = token.image.replaceFirst("^0+(?=.)", ""); + if (digits.length() > 10 || Long.parseLong(digits) > Integer.MAX_VALUE) { + throw new ParseException("IGNORE takes a number of at most 2147483647"); } - // ClickHouse ternary `cond ? then : else` — the `?` must not be taken as the - // PostgreSQL JSON operator, it is consumed by prattExpressionRest instead - if ("?".equals(t.image) && isTernaryAhead()) return false; - if (isComparisonOperator(t)) return true; - switch (t.kind) { - // Each suffix's start token: - case K_OVERLAPS: // OVERLAPS - case K_IN: // IN - case K_GLOBAL: // GLOBAL ... IN - case K_EXCLUDES: // EXCLUDES (...) - case K_INCLUDES: // INCLUDES (...) - case K_BETWEEN: // BETWEEN - case K_MEMBER: // MEMBER OF - case K_IS: // IS [NOT] NULL / TRUE / FALSE / UNKNOWN / DISTINCT - case K_ISNULL: // ISNULL - case K_NOTNULL: // NOTNULL - case K_LIKE: // LIKE - case K_ILIKE: // ILIKE - case K_RLIKE: // RLIKE - case K_REGEXP_LIKE: // REGEXP_LIKE - case K_REGEXP: // REGEXP - case K_GLOB: // GLOB (DuckDB/SQLite) - case K_SIMILAR_TO: // SIMILAR TO (in LikeExpression) - case K_SIMILAR: // SIMILAR TO (in SimilarToExpression) - case K_MATCH_ANY: // MATCH_ANY - case K_MATCH_ALL: // MATCH_ALL - case K_MATCH_PHRASE: // MATCH_PHRASE - case K_MATCH_PHRASE_PREFIX: // MATCH_PHRASE_PREFIX - case K_MATCH_REGEXP: // MATCH_REGEXP - return true; - case K_NOT: // NOT IN / NOT BETWEEN / NOT LIKE / NOT ISNULL / NOT SIMILAR - // A column's NOT NULL constraint starts after its DEFAULT expression. - return getToken(2).kind != K_NULL; - // Oracle (+) before IN: col(+) IN (...) - case OPENING_BRACKET: - return getToken(2).image.equals("+"); - default: - return false; + return Long.valueOf(digits); + } + + private boolean isBigQueryWithConnectionAhead() { + return getToken(1).kind == K_WITH && "CONNECTION".equalsIgnoreCase(getToken(2).image); + } + + /** + * Whether NO_WRITE_TO_BINLOG or LOCAL modifies a MySQL partition operation. Followed by a + * comma, INTO or the end of the statement, the word remains a partition name. + */ + private boolean isPartitionBinlogModifierAhead() { + int kind = getToken(1).kind; + if (kind != K_NO_WRITE_TO_BINLOG && kind != K_LOCAL) { + return false; } + Token next = getToken(2); + return next.kind != EOF && next.kind != ST_SEMICOLON && next.kind != K_INTO + && !",".equals(next.image); } - private boolean isLargeObjectTypeAhead() { - int offset = 1; - if (isKeywordAhead("NATIONAL")) { - offset++; - if (!"CHARACTER".equalsIgnoreCase(getToken(offset).image)) { - return false; - } + /** Whether a PostgreSQL REINDEX statement starts here; REINDEX stays an identifier elsewhere. */ + private boolean isReindexAhead() { + if (getToken(1).kind != K_REINDEX) { + return false; } - String name = getToken(offset).image; - return ("CHARACTER".equalsIgnoreCase(name) || "CHAR".equalsIgnoreCase(name) - || "NCHAR".equalsIgnoreCase(name) || "BINARY".equalsIgnoreCase(name)) - && "LARGE".equalsIgnoreCase(getToken(offset + 1).image) - && "OBJECT".equalsIgnoreCase(getToken(offset + 2).image); + int next = getToken(2).kind; + return next == K_INDEX || next == K_TABLE || next == K_SCHEMA || next == K_DATABASE + || next == K_SYSTEM || "(".equals(getToken(2).image); + } + + /** The PostgreSQL forms of VACUUM, ANALYZE and CLUSTER: with that dialect or without one. */ + private boolean isPostgreSqlMaintenanceDialect() { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.POSTGRESQL.name().equals(dialect); } /** - * Extracts the numeric precision embedded in a DT_ZONE token image such as - * "TIMESTAMP(3) WITH TIME ZONE", or null when the image carries no parameter. + * PostgreSQL's utility forms that other products lack, such as DISCARD, LISTEN, the SHOW and + * RESET names of several words and COPY's option syntax from before 9.0: read with that + * dialect and without one, never with another dialect. */ - private static Integer zonedTypePrecision(String image) { - int open = image.indexOf('('); - if (open < 0) { - return null; + private boolean isPostgreSqlUtilityDialect() { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.POSTGRESQL.name().equals(dialect); + } + + /** + * Whether PostgreSQL's DISCARD starts here. The PostgreSQL dialect always reads DISCARD as the + * statement; without a dialect one of its targets must follow, so that other uses of the word + * stay unsupported statements. + */ + private boolean isDiscardAhead() { + if (getToken(1).kind != K_DISCARD || !isPostgreSqlUtilityDialect()) { + return false; } - return Integer.valueOf(image.substring(open + 1, image.indexOf(')', open)).trim()); + Token target = getToken(2); + return getAsString(Feature.dialect) != null || target.kind == K_ALL + || target.kind == K_TEMP || target.kind == K_TEMPORARY + || "PLANS".equalsIgnoreCase(target.image) || "SEQUENCES".equalsIgnoreCase(target.image); } -} + /** + * Whether PostgreSQL's IMPORT FOREIGN SCHEMA starts here. The EXASOL dialect keeps IMPORT for + * its own statement, which FOREIGN cannot continue. + */ + private boolean isImportForeignSchemaAhead() { + return getToken(1).kind == K_IMPORT && getToken(2).kind == K_FOREIGN + && isPostgreSqlUtilityDialect(); + } -PARSER_END(CCJSqlParser) + /** + * Whether PostgreSQL's LISTEN or UNLISTEN starts here. The PostgreSQL dialect always reads the + * words as the statements; without a dialect a channel, or * after UNLISTEN, must follow. + */ + private boolean isListenAhead() { + int kind = getToken(1).kind; + if (kind != K_LISTEN && kind != K_UNLISTEN || !isPostgreSqlUtilityDialect()) { + return false; + } + Token channel = getToken(2); + return getAsString(Feature.dialect) != null || isIdentifierishNameToken(channel) + || kind == K_UNLISTEN && "*".equals(channel.image); + } -TOKEN_MGR_DECLS : { - public FeatureConfiguration configuration = new FeatureConfiguration(); + /** The name SET, RESET and SHOW give the configuration parameter written TIME ZONE. */ + private static final String TIME_ZONE_PARAMETER = "Time Zone"; + /** Whether TIME ZONE follows, the configuration parameter SET, RESET and SHOW name in two words. */ + private boolean isTimeZoneParameterAhead() { + Token time = getToken(1); + return time.kind == K_DATETIMELITERAL && "TIME".equalsIgnoreCase(time.image) + && getToken(2).kind == K_ZONE; + } - // Identify the index of the quoting/escaping tokens - public int charLiteralIndex = -1; - public int squaredBracketOpenIndex = -1; - { - for (int i=0;i") ) { - charLiteralIndex = i; - break; - } - } - for (int i=0;i= 0; i--) { - if (s.charAt(i) == '\\' && s.charAt(i + 1) == '\'' && s.charAt(i + 2) == '\'') { - return i; - } - } - return -1; + /** Whether a configuration parameter named in several words follows. */ + private boolean isConfigurationParameterPhraseAhead() { + return isTimeZoneParameterAhead() || isTransactionIsolationLevelParameterAhead() + || isSessionAuthorizationParameterAhead(); } - private RowPatternTokenContext rowPatternContext; + /** + * Whether BINARY starts PostgreSQL's COPY BINARY table, its spelling from before 7.3, rather + * than naming a table called binary. + */ + private boolean isCopyBinaryAhead() { + Token next = getToken(2); + return getToken(1).kind == K_BINARY && isPostgreSqlUtilityDialect() + && next.kind != K_FROM && next.kind != K_TO && isIdentifierishNameToken(next); + } - public void CommonTokenAction(Token t) - { - t.absoluteBegin = getCurrentTokenAbsolutePosition(); - t.absoluteEnd = t.absoluteBegin + t.image.length(); - // Track the lexical region independently of parser lookahead: nested SELECT - // disambiguation can fetch PATTERN tokens before its production is entered. - if (rowPatternContext == null && t.kind == S_IDENTIFIER - && "MATCH_RECOGNIZE".equalsIgnoreCase(t.image) - && AbstractJSqlParser.Dialect.BIGQUERY.name().equals(configuration.getValue(Feature.dialect))) { - rowPatternContext = new RowPatternTokenContext(); + /** Whether an option of PostgreSQL's COPY syntax from before 9.0, as copy_opt_item, follows. */ + private boolean isCopyLegacyOptionAhead() { + if (!isPostgreSqlUtilityDialect()) { + return false; } - if (rowPatternContext != null) { - rowPatternContext.accept(t); - if (rowPatternContext.isIdle()) { rowPatternContext = null; } + Token token = getToken(1); + switch (token.kind) { + case K_BINARY: case K_DELIMITER: case K_NULL: case K_CSV: case K_ESCAPE: case K_ENCODING: + return true; + case K_FORCE: + Token next = getToken(2); + return next.kind == K_NOT || next.kind == K_NULL || isCopyLegacyWord(next, "QUOTE"); + default: + return isCopyLegacyWord(token, "FREEZE") || isCopyLegacyWord(token, "HEADER") + || isCopyLegacyWord(token, "QUOTE"); } - } + } - public int getCurrentTokenAbsolutePosition() - { - if (input_stream instanceof SimpleCharStream) - return ((SimpleCharStream)input_stream).getAbsoluteTokenBegin(); - return -1; - } + private static boolean isCopyLegacyWord(Token token, String word) { + return token.kind == S_IDENTIFIER && word.equalsIgnoreCase(token.image); + } - /** Scans a literal in linear time without tokenizing or rebuilding its whitespace. */ - public void consumeDollarQuotedString(String closingQuote) { - int[] prefix = new int[closingQuote.length()]; - for (int i = 1, matched = 0; i < closingQuote.length(); i++) { - while (matched > 0 && closingQuote.charAt(i) != closingQuote.charAt(matched)) { - matched = prefix[matched - 1]; + /** + * PostgreSQL 18's reserved keywords. Its grammar takes none of them as the name or the word + * value of a utility option, except ANALYZE and ANALYSE as names. + */ + private static final Set POSTGRESQL_RESERVED_KEYWORDS = new HashSet(Arrays.asList( + "ALL", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", + "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", "END", "EXCEPT", "FALSE", + "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP", "HAVING", "IN", "INITIALLY", + "INTERSECT", "INTO", "LATERAL", "LEADING", "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", + "NULL", "OFFSET", "ON", "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "REFERENCES", + "RETURNING", "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "SYSTEM_USER", "TABLE", "THEN", + "TO", "TRAILING", "TRUE", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", "WHEN", "WHERE", + "WINDOW", "WITH")); + + /** + * PostgreSQL 18's type and function name keywords. Like its reserved keywords, its grammar + * takes none of them as a column identifier (ColId). + */ + private static final Set POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS = new HashSet(Arrays.asList( + "AUTHORIZATION", "BINARY", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", + "FREEZE", "FULL", "ILIKE", "INNER", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL", + "NOTNULL", "OUTER", "OVERLAPS", "RIGHT", "SIMILAR", "TABLESAMPLE", "VERBOSE")); + + /** + * PostgreSQL 18's column name keywords that are not a type name by themselves, so its grammar + * takes none of them as the single word of a definition value. NONE is one more, but a + * definition value takes it as the keyword it is. + */ + private static final Set POSTGRESQL_NON_TYPE_COL_NAME_KEYWORDS = new HashSet(Arrays.asList( + "BETWEEN", "COALESCE", "EXISTS", "EXTRACT", "GREATEST", "GROUPING", "INOUT", "JSON_ARRAY", + "JSON_ARRAYAGG", "JSON_EXISTS", "JSON_OBJECT", "JSON_OBJECTAGG", "JSON_QUERY", + "JSON_SCALAR", "JSON_SERIALIZE", "JSON_TABLE", "JSON_VALUE", "LEAST", "MERGE_ACTION", + "NATIONAL", "NORMALIZE", "NULLIF", "OUT", "OVERLAY", "POSITION", "PRECISION", "ROW", + "SETOF", "SUBSTRING", "TREAT", "TRIM", "VALUES", "XMLATTRIBUTES", "XMLCONCAT", + "XMLELEMENT", "XMLEXISTS", "XMLFOREST", "XMLNAMESPACES", "XMLPARSE", "XMLPI", "XMLROOT", + "XMLSERIALIZE", "XMLTABLE")); + + /** + * PostgreSQL 18's unreserved keywords and its column name keywords that are type names: the + * keywords that are in none of the sets above. + */ + private static final Set POSTGRESQL_OTHER_KEYWORDS = new HashSet(Arrays.asList( + "ABORT", "ABSENT", "ABSOLUTE", "ACCESS", "ACTION", "ADD", "ADMIN", "AFTER", + "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASENSITIVE", "ASSERTION", "ASSIGNMENT", + "AT", "ATOMIC", "ATTACH", "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN", "BIGINT", + "BIT", "BOOLEAN", "BREADTH", "BY", "CACHE", "CALL", "CALLED", "CASCADE", "CASCADED", + "CATALOG", "CHAIN", "CHAR", "CHARACTER", "CHARACTERISTICS", "CHECKPOINT", "CLASS", + "CLOSE", "CLUSTER", "COLUMNS", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", + "COMPRESSION", "CONDITIONAL", "CONFIGURATION", "CONFLICT", "CONNECTION", + "CONSTRAINTS", "CONTENT", "CONTINUE", "CONVERSION", "COPY", "COST", "CSV", "CUBE", + "CURRENT", "CURSOR", "CYCLE", "DATA", "DATABASE", "DAY", "DEALLOCATE", "DEC", + "DECIMAL", "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE", "DELIMITER", + "DELIMITERS", "DEPENDS", "DEPTH", "DETACH", "DICTIONARY", "DISABLE", "DISCARD", + "DOCUMENT", "DOMAIN", "DOUBLE", "DROP", "EACH", "EMPTY", "ENABLE", "ENCODING", + "ENCRYPTED", "ENFORCED", "ENUM", "ERROR", "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", + "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXPRESSION", "EXTENSION", "EXTERNAL", "FAMILY", + "FILTER", "FINALIZE", "FIRST", "FLOAT", "FOLLOWING", "FORCE", "FORMAT", "FORWARD", + "FUNCTION", "FUNCTIONS", "GENERATED", "GLOBAL", "GRANTED", "GROUPS", "HANDLER", + "HEADER", "HOLD", "HOUR", "IDENTITY", "IF", "IMMEDIATE", "IMMUTABLE", "IMPLICIT", + "IMPORT", "INCLUDE", "INCLUDING", "INCREMENT", "INDENT", "INDEX", "INDEXES", + "INHERIT", "INHERITS", "INLINE", "INPUT", "INSENSITIVE", "INSERT", "INSTEAD", "INT", + "INTEGER", "INTERVAL", "INVOKER", "ISOLATION", "JSON", "KEEP", "KEY", "KEYS", + "LABEL", "LANGUAGE", "LARGE", "LAST", "LEAKPROOF", "LEVEL", "LISTEN", "LOAD", + "LOCAL", "LOCATION", "LOCK", "LOCKED", "LOGGED", "MAPPING", "MATCH", "MATCHED", + "MATERIALIZED", "MAXVALUE", "MERGE", "METHOD", "MINUTE", "MINVALUE", "MODE", + "MONTH", "MOVE", "NAME", "NAMES", "NCHAR", "NESTED", "NEW", "NEXT", "NFC", "NFD", + "NFKC", "NFKD", "NO", "NONE", "NORMALIZED", "NOTHING", "NOTIFY", "NOWAIT", "NULLS", + "NUMERIC", "OBJECT", "OBJECTS", "OF", "OFF", "OIDS", "OLD", "OMIT", "OPERATOR", + "OPTION", "OPTIONS", "ORDINALITY", "OTHERS", "OVER", "OVERRIDING", "OWNED", "OWNER", + "PARALLEL", "PARAMETER", "PARSER", "PARTIAL", "PARTITION", "PASSING", "PASSWORD", + "PATH", "PERIOD", "PLAN", "PLANS", "POLICY", "PRECEDING", "PREPARE", "PREPARED", + "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROCEDURES", + "PROGRAM", "PUBLICATION", "QUOTE", "QUOTES", "RANGE", "READ", "REAL", "REASSIGN", + "RECURSIVE", "REF", "REFERENCING", "REFRESH", "REINDEX", "RELATIVE", "RELEASE", + "RENAME", "REPEATABLE", "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", + "RETURN", "RETURNS", "REVOKE", "ROLE", "ROLLBACK", "ROLLUP", "ROUTINE", "ROUTINES", + "ROWS", "RULE", "SAVEPOINT", "SCALAR", "SCHEMA", "SCHEMAS", "SCROLL", "SEARCH", + "SECOND", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER", "SESSION", + "SET", "SETS", "SHARE", "SHOW", "SIMPLE", "SKIP", "SMALLINT", "SNAPSHOT", "SOURCE", + "SQL", "STABLE", "STANDALONE", "START", "STATEMENT", "STATISTICS", "STDIN", + "STDOUT", "STORAGE", "STORED", "STRICT", "STRING", "STRIP", "SUBSCRIPTION", + "SUPPORT", "SYSID", "SYSTEM", "TABLES", "TABLESPACE", "TARGET", "TEMP", "TEMPLATE", + "TEMPORARY", "TEXT", "TIES", "TIME", "TIMESTAMP", "TRANSACTION", "TRANSFORM", + "TRIGGER", "TRUNCATE", "TRUSTED", "TYPE", "TYPES", "UESCAPE", "UNBOUNDED", + "UNCOMMITTED", "UNCONDITIONAL", "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", + "UNTIL", "UPDATE", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VALUE", "VARCHAR", + "VARYING", "VERSION", "VIEW", "VIEWS", "VIRTUAL", "VOLATILE", "WHITESPACE", + "WITHIN", "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML", "YEAR", "YES", "ZONE")); + + /** Whether the word is a keyword of PostgreSQL 18, of any kind. A quoted identifier is none. */ + private static boolean isPostgreSqlKeyword(String word) { + String upper = word.toUpperCase(Locale.ROOT); + return POSTGRESQL_RESERVED_KEYWORDS.contains(upper) + || POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS.contains(upper) + || POSTGRESQL_NON_TYPE_COL_NAME_KEYWORDS.contains(upper) + || POSTGRESQL_OTHER_KEYWORDS.contains(upper); + } + + /** + * Checks an operator name the way PostgreSQL's lexer delimits one. A name of several characters + * ends in + or - only if it has one of ~ ! @ # % ^ & | ` ?, since the lexer otherwise leaves + * the sign to the next token; "=>" is not an operator, and a name has at most 63 characters. + */ + private static void requirePostgreSqlOperatorName(String name) throws ParseException { + char last = name.charAt(name.length() - 1); + boolean signLeftOver = name.length() > 1 && (last == '+' || last == '-') + && !name.matches(".*[~!@#%^&|`?].*"); + if (signLeftOver || "=>".equals(name) || name.length() > 63) { + throw new ParseException("PostgreSQL does not take " + name + " as an operator name"); + } + } + + /** Whether OPERATOR is followed by CLASS or FAMILY as a keyword, not as the schema of an operator. */ + private boolean isOperatorClassOrFamilyAhead() { + return ("CLASS".equalsIgnoreCase(getToken(2).image) || "FAMILY".equalsIgnoreCase(getToken(2).image)) + && !".".equals(getToken(3).image); + } + + /** + * Whether CREATE or ALTER is followed by a PostgreSQL operator, operator class or operator + * family. Without the PostgreSQL dialect, an operator is known by its symbol, because Oracle + * names its operators with identifiers, as in CREATE OPERATOR name BINDING (...). + */ + private boolean isPostgreSqlOperatorDdlAhead() { + if (!isKeywordAhead("OPERATOR")) { + return false; + } + if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + return true; + } + if (isOperatorClassOrFamilyAhead()) { + // an Oracle operator may be named class or family + String next = getToken(3).image; + return !"BINDING".equalsIgnoreCase(next) && !"COMPILE".equalsIgnoreCase(next) + && !"BINDING".equalsIgnoreCase(getToken(4).image); + } + return isOperatorNameAhead(2); + } + + /** Whether an operator symbol follows at the offset, possibly after schema names and dots. */ + private boolean isOperatorNameAhead(int offset) { + int name = offset; + while (".".equals(getToken(name + 1).image)) { + name += 2; + } + return DropLookahead.isOperatorSymbol(getToken(name)); + } + + /** + * Whether CREATE is followed by a PostgreSQL aggregate. Without the PostgreSQL dialect, MySQL's + * CREATE AGGREGATE FUNCTION and SQL Server's CREATE AGGREGATE name (@parameter type) are not. + */ + private boolean isPostgreSqlCreateAggregateAhead() { + if (getToken(1).kind != K_AGGREGATE) { + return false; + } + if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + return true; + } + int name = 2; + while (".".equals(getToken(name + 1).image)) { + name += 2; + } + String parameter = getToken(name + 2).image; + return getToken(2).kind != K_FUNCTION && (parameter == null || !parameter.startsWith("@")); + } + + /** + * Whether an aggregate name is followed by the definition of the old CREATE AGGREGATE form, + * "(" name "=", and not by an argument signature. + */ + private boolean isOldAggregateDefinitionAhead() { + int name = 1; + while (".".equals(getToken(name + 1).image)) { + name += 2; + } + return getToken(name + 1).kind == OPENING_BRACKET && "=".equals(getToken(name + 3).image); + } + + /** PostgreSQL's aggr_args: an aggregate signature is "*" or has at least one argument. */ + private static boolean isAggregateSignature(RoutineReference aggregate) { + return aggregate.getArguments() != null && (aggregate.isAllArguments() + || !aggregate.getArguments().isEmpty() || aggregate.getOrderByArguments() != null); + } + + /** + * PostgreSQL's old_aggr_definition: every element has a value, and its name is an identifier, + * which no keyword is. + */ + private void requireOldAggregateDefinition(List definition) throws ParseException { + for (DefinitionElement element : definition) { + requireDdlSyntax(element.getArgument() != null && !isPostgreSqlKeyword(element.getName()), + "PostgreSQL expects an identifier and a value: " + element); + } + } + + /** PostgreSQL's Iconst: the strategy or support number of an operator class member. */ + private int operatorClassNumber(Token token) throws ParseException { + try { + return Integer.parseInt(token.image); + } catch (NumberFormatException exception) { + throw new ParseException("Expected an integer: " + token.image); + } + } + + /** Whether the token is an identifier or a keyword: a word PostgreSQL takes as a label. */ + private static boolean isPostgreSqlWord(Token token) { + return token.kind == S_IDENTIFIER || token.kind == S_QUOTED_IDENTIFIER || token.kind == DATA_TYPE + || token.kind != EOF && token.kind != S_CHAR_LITERAL && token.image != null + && token.image.matches("[A-Za-z_][A-Za-z0-9_$]*"); + } + + /** Whether "()" occurs in the tokens from first to last, as in the type modifiers of f(). */ + private static boolean hasEmptyParentheses(Token first, Token last) { + for (Token token = first; token != last && token.next != null; token = token.next) { + if (token.kind == OPENING_BRACKET && token.next.kind == CLOSING_BRACKET) { + return true; } - if (closingQuote.charAt(i) == closingQuote.charAt(matched)) { - matched++; + } + return false; + } + + /** Whether a definition list follows: a parenthesis, a label and then "=", "," or ")". */ + private boolean isDefinitionAhead() { + String next = getToken(3).image; + return getToken(1).kind == OPENING_BRACKET && isPostgreSqlWord(getToken(2)) + && ("=".equals(next) || ",".equals(next) || ")".equals(next)); + } + + /** Whether the value of a definition element is one word, which no type rule needs to read. */ + private boolean isDefinitionWordValueAhead() { + String next = getToken(2).image; + return isPostgreSqlWord(getToken(1)) && (",".equals(next) || ")".equals(next)); + } + + /** + * The one-word value of a definition element: NONE, a reserved keyword, or a name, which + * PostgreSQL reads as a type name. + */ + private DefinitionArgument definitionWordValue(Token token) throws ParseException { + String upper = token.image.toUpperCase(Locale.ROOT); + if (token.kind == K_NONE) { + return DefinitionArgument.none(); + } + if (POSTGRESQL_RESERVED_KEYWORDS.contains(upper)) { + return DefinitionArgument.keyword(token.image); + } + requireDdlSyntax(!POSTGRESQL_NON_TYPE_COL_NAME_KEYWORDS.contains(upper), + "PostgreSQL does not take " + token.image + " as a definition value"); + return DefinitionArgument.type(linkToLastToken(new ColDataType(token.image))); + } + + /** Rejects an unquoted utility option name or word value that PostgreSQL reserves. */ + private void requireUtilityOptionWord(String word, boolean name) throws ParseException { + String upper = word.toUpperCase(Locale.ROOT); + requireDdlSyntax(!POSTGRESQL_RESERVED_KEYWORDS.contains(upper) + || name && ("ANALYZE".equals(upper) || "ANALYSE".equals(upper)), + "PostgreSQL reserves " + word + " in utility options"); + } + + /** Rejects an unquoted name that PostgreSQL does not take as a column or channel name. */ + private void requirePostgreSqlColId(String name) throws ParseException { + String upper = name.toUpperCase(Locale.ROOT); + requireDdlSyntax(!POSTGRESQL_RESERVED_KEYWORDS.contains(upper) + && !POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS.contains(upper), + "PostgreSQL does not take " + name + " as a name here"); + } + + /** Whether a PostgreSQL identifier in double quotes follows, not one in brackets or backticks. */ + private boolean isDoubleQuotedIdentifierAhead() { + Token token = getToken(1); + return token.kind == S_QUOTED_IDENTIFIER && token.image.startsWith("\""); + } + + /** + * Whether a PostgreSQL VACUUM, CLUSTER or CHECKPOINT statement, or ANALYZE spelled ANALYSE, + * starts here. The PostgreSQL dialect always reads these words as statements, and other + * dialects never do. Without a dialect the next tokens must take the PostgreSQL form, so that + * other products' variants such as SQLite's VACUUM INTO or SQL Server's CHECKPOINT 10 stay + * unsupported statements. + */ + private boolean isPostgreSqlMaintenanceAhead() { + int kind = getToken(1).kind; + if (kind != K_VACUUM && kind != K_ANALYSE && kind != K_CLUSTER && kind != K_CHECKPOINT + || !isPostgreSqlMaintenanceDialect()) { + return false; + } + Token next = getToken(2); + if (getAsString(Feature.dialect) != null || next.kind == EOF || next.kind == ST_SEMICOLON) { + return true; + } + return kind != K_CHECKPOINT && isPostgreSqlMaintenanceFormAhead(kind, next); + } + + /** Whether the token after VACUUM, ANALYSE or CLUSTER starts the PostgreSQL form. */ + private boolean isPostgreSqlMaintenanceFormAhead(int kind, Token next) { + if (next.kind == OPENING_BRACKET || next.kind == K_VERBOSE) { + return true; + } + boolean targets = kind != K_CLUSTER; + if (targets && next.kind == K_ONLY) { + return true; + } + if (kind == K_VACUUM && (next.kind == K_FULL || next.kind == K_ANALYZE + || next.kind == K_ANALYSE || "FREEZE".equalsIgnoreCase(next.image))) { + return true; + } + return isIdentifierishNameToken(next) && isMaintenanceTableEnd(getToken(3), targets); + } + + /** + * Whether the token can follow the first part of a VACUUM, ANALYZE or CLUSTER table name, or + * the index name of CLUSTER index ON table. + */ + private static boolean isMaintenanceTableEnd(Token token, boolean withColumns) { + if (token.kind == EOF || token.kind == ST_SEMICOLON || ".".equals(token.image)) { + return true; + } + return withColumns ? token.kind == OPENING_BRACKET || ",".equals(token.image) + || "*".equals(token.image) : token.kind == K_USING || token.kind == K_ON; + } + + /** The direction words of FETCH and MOVE that the grammar has no token for. */ + private static final Set FETCH_DIRECTION_WORDS = new HashSet(Arrays.asList( + "ABSOLUTE", "RELATIVE", "FORWARD", "BACKWARD")); + + /** The cursor options of DECLARE that the grammar has no token for. */ + private static final Set CURSOR_OPTION_WORDS = new HashSet(Arrays.asList( + "SCROLL", "ASENSITIVE", "INSENSITIVE")); + + /** + * Whether a PostgreSQL FETCH, MOVE or CLOSE statement starts here. The PostgreSQL dialect + * always reads these words as cursor statements, and other dialects never do. Without a + * dialect the whole statement must take the PostgreSQL form, so that other products' variants + * such as FETCH NEXT FROM c INTO @x or CLOSE GLOBAL c stay unsupported statements. + */ + private boolean isCursorStatementAhead() { + int kind = getToken(1).kind; + if (kind != K_FETCH && kind != K_MOVE && kind != K_CLOSE) { + return false; + } + String dialect = getAsString(Feature.dialect); + if (dialect != null) { + return Dialect.POSTGRESQL.name().equals(dialect); + } + int offset = 2; + if (kind == K_CLOSE && getToken(offset).kind == K_ALL) { + return isCursorStatementEnd(getToken(offset + 1)); + } + if (kind != K_CLOSE) { + offset = skipFetchDirection(offset); + if (offset < 0) { + return false; + } + if (getToken(offset).kind == K_FROM || getToken(offset).kind == K_IN) { + offset++; } - prefix[i] = matched; } - try { - int matched = 0; - while (matched < closingQuote.length()) { - char ch = input_stream.readChar(); - while (matched > 0 && ch != closingQuote.charAt(matched)) { - matched = prefix[matched - 1]; - } - if (ch == closingQuote.charAt(matched)) { - matched++; - } + return isCursorNameToken(getToken(offset)) && isCursorStatementEnd(getToken(offset + 1)); + } + + private static boolean isCursorStatementEnd(Token token) { + return token.kind == EOF || token.kind == ST_SEMICOLON; + } + + /** Whether the token can name a cursor: PostgreSQL takes any column identifier (ColId). */ + private static boolean isCursorNameToken(Token token) { + if (!isIdentifierishNameToken(token)) { + return false; + } + String word = token.image.toUpperCase(Locale.ROOT); + return !POSTGRESQL_RESERVED_KEYWORDS.contains(word) + && !POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS.contains(word); + } + + /** + * Whether a FETCH or MOVE direction starts at the offset. As in PostgreSQL's grammar, a + * direction word right before the end of the statement is the cursor name, as in FETCH next. + */ + private boolean isFetchDirectionAt(int offset) { + Token token = getToken(offset); + if (token.kind == K_ALL || isFetchCountAt(offset)) { + return true; + } + boolean word = token.kind == K_NEXT || token.kind == K_PRIOR || token.kind == K_FIRST + || token.kind == K_LAST || token.kind == S_IDENTIFIER + && FETCH_DIRECTION_WORDS.contains(token.image.toUpperCase(Locale.ROOT)); + return word && !isCursorStatementEnd(getToken(offset + 1)); + } + + /** Whether a FETCH or MOVE count, an integer with an optional sign, starts at the offset. */ + private boolean isFetchCountAt(int offset) { + Token token = getToken(offset); + return token.kind == S_LONG || ("+".equals(token.image) || "-".equals(token.image)) + && getToken(offset + 1).kind == S_LONG; + } + + private int skipFetchCount(int offset) { + return getToken(offset).kind == S_LONG ? offset + 1 : offset + 2; + } + + /** + * The offset after the FETCH or MOVE direction at the offset, the offset itself without a + * direction, or -1 when ABSOLUTE or RELATIVE lacks its count. + */ + private int skipFetchDirection(int offset) { + if (!isFetchDirectionAt(offset)) { + return offset; + } + if (getToken(offset).kind == K_ALL) { + return offset + 1; + } + if (isFetchCountAt(offset)) { + return skipFetchCount(offset); + } + String word = getToken(offset).image.toUpperCase(Locale.ROOT); + int next = offset + 1; + if ("ABSOLUTE".equals(word) || "RELATIVE".equals(word)) { + return isFetchCountAt(next) ? skipFetchCount(next) : -1; + } + if ("FORWARD".equals(word) || "BACKWARD".equals(word)) { + if (getToken(next).kind == K_ALL) { + return next + 1; + } + if (isFetchCountAt(next)) { + return skipFetchCount(next); } - } catch (java.io.IOException e) { - reportError(Math.max(closingQuote.length(), input_stream.GetImage().length())); } + return next; } - /** Rewinds any identifier suffix consumed by longest-match lexing before scanning the body. */ - private void consumeDollarQuotedToken(Token token, String delimiter) { - input_stream.backup(token.image.length() - delimiter.length()); - consumeDollarQuotedString(delimiter); - token.image = input_stream.GetImage(); - token.kind = charLiteralIndex; - token.endLine = input_stream.getEndLine(); - token.endColumn = input_stream.getEndColumn(); + /** + * A FETCH or MOVE count. PostgreSQL's grammar takes a 32-bit integer; a larger one is a + * numeric constant there and a syntax error. + */ + private Long fetchCount(Token sign, Token digits) throws ParseException { + String value = digits.image.replaceFirst("^0+(?=.)", ""); + requireDdlSyntax(value.length() < 10 || value.length() == 10 && value.compareTo("2147483647") <= 0, + "A FETCH or MOVE count must be a 32-bit integer: " + digits.image); + long count = Long.parseLong(value); + return sign != null && "-".equals(sign.image) ? -count : count; } - /** Splits a longest-match identifier without losing token positions. */ - private void truncateIdentifierToken(Token token, int length) { - input_stream.backup(token.image.length() - length); - token.image = token.image.substring(0, length); - token.endLine = input_stream.getEndLine(); - token.endColumn = input_stream.getEndColumn(); + /** + * Whether a PostgreSQL DECLARE ... CURSOR starts here rather than the SQL Server DECLARE of a + * variable. The PostgreSQL dialect reads every DECLARE of a name as a cursor; without a dialect + * the name, the cursor options and CURSOR must follow. Other dialects keep their readings. + */ + private boolean isDeclareCursorAhead() { + if (getToken(1).kind != K_DECLARE || getToken(2).kind == S_AT_IDENTIFIER) { + return false; + } + String dialect = getAsString(Feature.dialect); + if (dialect != null) { + return Dialect.POSTGRESQL.name().equals(dialect); + } + int offset = 3; + while (isCursorOptionAt(offset)) { + offset += getToken(offset).kind == K_NO ? 2 : 1; + } + Token cursor = getToken(offset); + return isCursorNameToken(getToken(2)) && cursor.kind == S_IDENTIFIER + && "CURSOR".equalsIgnoreCase(cursor.image); + } + + /** Whether a DECLARE cursor option starts at the offset: BINARY, [NO] SCROLL or a sensitivity. */ + private boolean isCursorOptionAt(int offset) { + Token token = getToken(offset); + if (token.kind == K_BINARY) { + return true; + } + if (token.kind == K_NO) { + Token next = getToken(offset + 1); + return next.kind == S_IDENTIFIER && "SCROLL".equalsIgnoreCase(next.image); + } + return token.kind == S_IDENTIFIER + && CURSOR_OPTION_WORDS.contains(token.image.toUpperCase(Locale.ROOT)); } /** - * Consumes the body of a block comment after the opening delimiter has been matched, - * honouring nesting, up to and including the outermost closing delimiter. Then backs - * up 2 characters so the MULTI_LINE_COMMENT rule matches the closing delimiter and - * terminates the MORE chain. + * Whether VERBOSE is the PostgreSQL option of ANALYZE. Without a dialect a table name must + * follow, so ANALYZE verbose still analyzes a table named verbose; other dialects keep that + * reading. */ - void consumeBlockCommentBody() { - int nesting = 1; - char prev = 0; - try { - while (nesting > 0) { - char c = input_stream.readChar(); - if (prev == '/' && c == '*') { - nesting++; - prev = 0; - } else if (prev == '*' && c == '/') { - nesting--; - prev = 0; - } else { - prev = c; - } + private boolean isAnalyzeVerboseAhead() { + if (getToken(1).kind != K_VERBOSE || !isPostgreSqlMaintenanceDialect()) { + return false; + } + Token next = getToken(2); + return getAsString(Feature.dialect) != null || next.kind == K_ONLY + || isIdentifierishNameToken(next) && isMaintenanceTableEnd(getToken(3), true); + } + + /** + * MySQL's modifier, TABLE keyword and histogram clause, which carries the bucket count, the + * update mode and the JSON data, require tables and exclude the PostgreSQL options and target + * forms; other dialects require tables. + */ + private void requireAnalyzeForm(Analyze analyze) throws ParseException { + boolean mySqlForm = analyze.getModifier() != null || analyze.isTableKeyword() + || analyze.getHistogramAction() != null; + requireDdlSyntax(!mySqlForm || analyze.getCommand() == Analyze.Command.ANALYZE, + "MySQL ANALYZE clauses require the ANALYZE spelling"); + requireDdlSyntax(!analyze.getTargets().isEmpty() + || !mySqlForm && isPostgreSqlMaintenanceDialect(), "ANALYZE requires a table"); + boolean postgreSqlForm = !analyze.getOptions().isEmpty(); + for (MaintenanceTarget target : analyze.getTargets()) { + postgreSqlForm |= !target.isPlainTable(); + } + requireDdlSyntax(!mySqlForm || !postgreSqlForm, + "MySQL ANALYZE clauses cannot be combined with PostgreSQL options or targets"); + } + + /** Whether the next tokens spell an option accepted by this table maintenance operation. */ + private boolean isTableMaintenanceOptionAhead(TableMaintenanceStatement.Operation operation) { + Token token = getToken(1); + TableMaintenanceStatement.Option option = null; + if (token.kind == K_FOR) { + Token next = getToken(2); + if (next.kind == S_IDENTIFIER && "UPGRADE".equalsIgnoreCase(next.image)) { + option = TableMaintenanceStatement.Option.FOR_UPGRADE; } - input_stream.backup(2); - } catch (java.io.IOException e) { - // Unterminated comment: leave the stream at EOF and let the token - // manager raise the lexical error from IN_BLOCK_COMMENT. + } else if (token.kind == K_QUICK) { + option = TableMaintenanceStatement.Option.QUICK; + } else if (token.kind == K_EXTENDED) { + option = TableMaintenanceStatement.Option.EXTENDED; + } else if (token.kind == S_IDENTIFIER) { + option = TableMaintenanceStatement.Option.fromKeyword(token.image); } + return option != null && operation.allows(option); } -} -SKIP: -{ - -} + private boolean isXmlTypeName(String name) { + return "XML".equalsIgnoreCase(name) || "[XML]".equalsIgnoreCase(name) + || "\"XML\"".equalsIgnoreCase(name); + } -// Sentinel: start of non-reserved keyword range (for O(1) identifier checks) -SKIP: -{ - -} + private boolean isPostgreSqlConstraintAttributeAhead() { + return isPostgreSqlConstraintAttributeAhead(1); + } -/** - * Non-reserved SQL keywords usable as unquoted identifiers. - * Tokens are declared inline to get consecutive kind values between - * MIN_NON_RESERVED_WORD and MAX_NON_RESERVED_WORD sentinels. - */ -String NonReservedWord() : + private boolean isPostgreSqlConstraintAttributeAhead(int offset) { + int kind = getToken(offset).kind; + int next = getToken(offset + 1).kind; + return kind == K_DEFERRABLE || kind == K_ENFORCED + || "INITIALLY".equalsIgnoreCase(getToken(offset).image) + || kind == K_NOT && (next == K_DEFERRABLE || next == K_ENFORCED + || "VALID".equalsIgnoreCase(getToken(offset + 1).image)); + } + + /** EXCLUDE starts an exclusion constraint only before USING, its elements or WHERE. */ + private boolean isExcludeConstraintAhead() { + int next = getToken(2).kind; + return getToken(1).kind == K_EXCLUDE + && (next == K_USING || next == OPENING_BRACKET || next == K_WHERE); + } + + private boolean isMySqlStatisticsOptionAhead() { + String name = getToken(1).image; + return "STATS_AUTO_RECALC".equalsIgnoreCase(name) + || "STATS_PERSISTENT".equalsIgnoreCase(name) + || "STATS_SAMPLE_PAGES".equalsIgnoreCase(name); + } + + private boolean isMySqlEngineAttributeAhead() { + return isKeywordAhead("ENGINE_ATTRIBUTE") || isKeywordAhead("SECONDARY_ENGINE_ATTRIBUTE"); + } + + private boolean isMySqlAdditionalTableOptionAhead() { + String name = getToken(1).image.toUpperCase(Locale.ROOT); + return Arrays.asList("SECONDARY_ENGINE", "AUTOEXTEND_SIZE", "INSERT_METHOD", "PACK_KEYS", + "DELAY_KEY_WRITE", "CHECKSUM", "CONNECTION", "COMPRESSION").contains(name); + } + + private boolean isMySqlNumericTableOptionAhead() { + return getToken(1).kind == K_KEY_BLOCK_SIZE || isKeywordAhead("AVG_ROW_LENGTH") + || isKeywordAhead("MAX_ROWS") || isKeywordAhead("MIN_ROWS"); + } + + /** + * PARTITION BY or REMOVE PARTITIONING: the MySQL partition options that may end the ALTER TABLE + * action list without a comma. A column definition does not take them as column options. + */ + private boolean isTrailingPartitionOptionAhead() { + return getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY + || getToken(1).kind == K_REMOVE && getToken(2).kind == K_PARTITIONING; + } + + private boolean isMySqlTableOptionAction(AlterExpression action) { + return action instanceof AlterExpressionTableOption + && ((AlterExpressionTableOption) action).getStructuredTableOption() != null + || action instanceof AlterExpressionCharset + && action.getConvertType() != AlterExpression.ConvertType.CONVERT_TO; + } + + private boolean isMySqlScalarTableOptionAhead() { + int kind = getToken(1).kind; + return isMySqlNumericTableOptionAhead() || isMySqlAdditionalTableOptionAhead() || isMySqlEngineAttributeAhead() || kind == K_ENCRYPTION || kind == K_PASSWORD || kind == K_AUTO_INCREMENT + || (kind == K_DATA || kind == K_INDEX) && getToken(2).kind == K_DIRECTORY; + } + + private boolean isMySqlTableOptionAhead() { + int kind = getToken(1).kind; + if (kind == K_ENGINE || kind == K_COLLATE || kind == K_COMMENT || kind == K_TABLESPACE + || isMySqlScalarTableOptionAhead() || kind == K_UNION + || isMySqlStatisticsOptionAhead() || isKeywordAhead("ROW_FORMAT")) { + return true; + } + if (kind == K_CHARACTER && getToken(2).kind == K_SET + || kind == K_CHAR && getToken(2).kind == K_SET) { + return true; + } + if (kind == S_IDENTIFIER && "CHARSET".equalsIgnoreCase(getToken(1).image)) { + return true; + } + if (kind != K_DEFAULT) { + return false; + } + int secondKind = getToken(2).kind; + return secondKind == K_CHARACTER || secondKind == K_CHAR || secondKind == K_COLLATE + || secondKind == S_IDENTIFIER + && "CHARSET".equalsIgnoreCase(getToken(2).image); + } + + private boolean isTableIndexAhead() { + switch (getToken(1).kind) { + case K_PRIMARY: + case K_UNIQUE: + case K_INDEX: + case K_KEY: + case K_FULLTEXT: + case K_SPATIAL: + return true; + default: + return false; + } + } + + /** + * Decides whether an ALTER TABLE ADD table constraint needs the table-constraint production + * shared with CREATE TABLE in dialects that otherwise keep the generic ALTER representation. A + * nested class keeps its branches out of CCJSqlParser.class, whose constant pool is close to + * what JaCoCo can still instrument. + */ + private static final class AlterConstraintLookahead { + private AlterConstraintLookahead() {} + + /** + * Whether the action starting at {@code first} is an unnamed CHECK, a FOREIGN KEY, + * EXCLUDE, or uses a constraint attribute (INITIALLY IMMEDIATE|DEFERRED, NOT VALID, or + * ENFORCED outside CHECK) before the end of the action. + */ + static boolean needsSharedTableConstraint(Token first, CCJSqlParserTokenManager source) { + Token second = next(first, source); + Token body = first.kind == K_CONSTRAINT ? next(second, source) : first; + if (isSharedOnlyConstraint(first, second, body, source)) { + return true; + } + return (first.kind == K_CONSTRAINT || first.kind == K_PRIMARY + || first.kind == K_UNIQUE) + && hasConstraintAttribute(first, body.kind == K_CHECK, source); + } + + /** An unnamed CHECK, a FOREIGN KEY or an EXCLUDE constraint. */ + private static boolean isSharedOnlyConstraint(Token first, Token second, Token body, + CCJSqlParserTokenManager source) { + return first.kind == K_CHECK && second.kind == OPENING_BRACKET + || first.kind == K_FOREIGN || isExcludeConstraint(body, source); + } + + /** Whether a constraint attribute follows at the top level before the end of the action. */ + private static boolean hasConstraintAttribute(Token first, boolean check, + CCJSqlParserTokenManager source) { + int depth = 0; + for (Token token = first; token.kind != EOF; token = next(token, source)) { + if (token.kind == OPENING_BRACKET) { + depth++; + } else if (token.kind == CLOSING_BRACKET) { + if (depth-- == 0) { + return false; + } + } else if (depth == 0) { + if (token.kind == ST_SEMICOLON || token.kind == K_COMMA) { + return false; + } + if (isConstraintAttribute(token, next(token, source), check)) { + return true; + } + } + } + return false; + } + + private static boolean isConstraintAttribute(Token token, Token next, boolean check) { + if ("INITIALLY".equalsIgnoreCase(token.image)) { + return "IMMEDIATE".equalsIgnoreCase(next.image) + || "DEFERRED".equalsIgnoreCase(next.image); + } + return token.kind == K_NOT && "VALID".equalsIgnoreCase(next.image) + || token.kind == K_ENFORCED && !check; + } + + /** EXCLUDE starts an exclusion constraint only before USING, its elements or WHERE. */ + private static boolean isExcludeConstraint(Token token, CCJSqlParserTokenManager source) { + int following = next(token, source).kind; + return token.kind == K_EXCLUDE && (following == K_USING + || following == OPENING_BRACKET || following == K_WHERE); + } + + private static Token next(Token token, CCJSqlParserTokenManager source) { + if (token.next == null) { + token.next = source.getNextToken(); + } + return token.next; + } + } + + /** + * True when an IS after a condition opens a postfix test + * (IS [NOT] TRUE/FALSE/UNKNOWN/NULL/JSON/NORMALIZED) rather than IS DISTINCT FROM or + * another comparison form, which has a right-hand operand of its own. + */ + private boolean isPostfixIsTestAhead() { + if (getToken(1).kind != K_IS) { + return false; + } + int offset = getToken(2).kind == K_NOT ? 3 : 2; + switch (getToken(offset).kind) { + case K_TRUE: + case K_FALSE: + case K_UNKNOWN: + case K_NULL: + case K_JSON: + return true; + default: + return isIsNormalizedAhead(); + } + } + + /** + * True when the item after a comma inside a T-SQL/Snowflake ADD list is + * another column definition or table constraint rather than the start of a + * new alter action, which the enclosing productions handle. + */ + private boolean isAlterAddListItemAhead() { + switch (getToken(1).kind) { + case K_CONSTRAINT: + case K_CHECK: + case K_PRIMARY: + case K_UNIQUE: + case K_FOREIGN: + return true; + case K_ADD: + case K_ALTER: + case K_CHANGE: + case K_MODIFY: + case K_DROP: + case K_FORCE: + case K_NO: + case K_ENABLE: + case K_DISABLE: + case K_ALGORITHM: + case K_LOCK: + case K_CONVERT: + case K_PARTITION: + case K_ORDER: + return false; + default: + return true; } + } + + /** + * True when the pending {@code ON} opens the ON CONFLICT clause of the enclosing + * INSERT rather than another trailing join condition: after a join, the trailing + * ON expressions of Issue #1302 and the INSERT clause claim the same ON token. + * The clause shapes are ON CONFLICT DO, ON CONFLICT ON CONSTRAINT and + * ON CONFLICT ( target ) [ WHERE ] DO, so the parenthesized target has to be + * separated from an expression by scanning past its balanced brackets. + */ + private boolean isInsertOnConflictAhead() { + if (getToken(1).kind != K_ON || getToken(2).kind != K_CONFLICT) { + return false; + } + Token t = getToken(3); + if (t.kind == K_DO) { + return true; + } + if (t.kind == K_ON) { + return getToken(4).kind == K_CONSTRAINT; + } + if (!"(".equals(t.image)) { + return false; + } + int depth = 1; + while (depth > 0) { + t = nextWithItemToken(t); + if (t == null || t.kind == EOF) { + return false; + } + if ("(".equals(t.image)) { + depth++; + } else if (")".equals(t.image)) { + depth--; + } + } + t = nextWithItemToken(t); + if (t.kind == K_DO) { + return true; + } + if (t.kind != K_WHERE) { + return false; + } + // the index predicate ends where the conflict action's DO begins + depth = 0; + while (true) { + t = nextWithItemToken(t); + if (t == null || t.kind == EOF) { + return false; + } + if ("(".equals(t.image)) { + depth++; + } else if (")".equals(t.image)) { + depth--; + } else if (t.kind == K_DO && depth == 0) { + return true; + } + } + } + + private static void requireAccessSyntax(boolean condition, String message) throws ParseException { + if (!condition) { throw new ParseException(message); } + } + + /** MySQL role lists name roles with role_ident, which does not take CURRENT_USER(). */ + private static List requireRoleNames(List roles) throws ParseException { + for (UserAccount role : roles) { + requireAccessSyntax(!role.isCurrentUserParentheses(), "A role list does not take CURRENT_USER()"); + } + return roles; + } + + private static > E accessEnum(Class type, String value) throws ParseException { + try { return Enum.valueOf(type, value.toUpperCase(Locale.ROOT)); } + catch (IllegalArgumentException ex) { throw new ParseException("Invalid " + type.getSimpleName() + ": " + value); } + } + + private boolean isRoleOptionAhead(int offset) { + if (getToken(offset).kind == EOF) { return false; } + String word = getToken(offset).image.toUpperCase(Locale.ROOT); + return Arrays.asList("SUPERUSER", "NOSUPERUSER", "CREATEDB", "NOCREATEDB", "CREATEROLE", "NOCREATEROLE", + "INHERIT", "NOINHERIT", "LOGIN", "NOLOGIN", "REPLICATION", "NOREPLICATION", "BYPASSRLS", "NOBYPASSRLS", + "CONNECTION", "ENCRYPTED", "PASSWORD", "VALID", "IN", "ROLE", "USER", "ADMIN", "SYSID").contains(word); + } + + private boolean isPostgreSqlRoleAhead() { + if (isAccessKeywordAhead("ROLE") || isAccessKeywordAhead("GROUP")) { return true; } + return isAccessKeywordAhead("USER") && !"MAPPING".equalsIgnoreCase(getToken(2).image) + && (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + || !isMySqlUserOptionAhead(3) + && ("WITH".equalsIgnoreCase(getToken(3).image) || isRoleOptionAhead(3))); + } + + /** + * Whether a MySQL CREATE/ALTER USER clause starts at the offset: authentication, a further + * factor after AND, a factor change or registration step, DEFAULT ROLE, REQUIRE, WITH resource limits, password and locking options, COMMENT or ATTRIBUTE. PostgreSQL + * role attributes such as WITH LOGIN or PASSWORD 'x' do not match. + */ + private boolean isMySqlUserOptionAhead(int offset) { + Token token = getToken(offset); + switch (token.kind) { + case K_IDENTIFIED: + case K_DISCARD: + return true; + case K_AND: + return getToken(offset + 1).kind == K_IDENTIFIED; + case K_ADD: + case K_MODIFY: + case K_DROP: + return isMySqlFactorAhead(offset + 1); + case S_LONG: + return isMySqlFactorAhead(offset); + case K_COMMENT: + return getToken(offset + 1).kind == S_CHAR_LITERAL; + case K_DEFAULT: + return "ROLE".equalsIgnoreCase(getToken(offset + 1).image); + case K_WITH: + return isMySqlResourceLimitAhead(offset + 1); + default: + return isMySqlPasswordLockOptionAhead(offset) || token.kind == S_IDENTIFIER + && ("REQUIRE".equalsIgnoreCase(token.image) + || "ATTRIBUTE".equalsIgnoreCase(token.image)); + } + } + + /** Whether a multi-factor authentication factor, n FACTOR, starts at the offset. */ + private boolean isMySqlFactorAhead(int offset) { + return getToken(offset).kind == S_LONG + && "FACTOR".equalsIgnoreCase(getToken(offset + 1).image); + } + + /** Whether ADD, MODIFY or DROP of a multi-factor authentication factor is next. */ + private boolean isMySqlFactorChangeAhead() { + int kind = getToken(1).kind; + return (kind == K_ADD || kind == K_MODIFY || kind == K_DROP) && isMySqlFactorAhead(2); + } + + /** The number of n FACTOR, which the MySQL grammar reads as an integer of at most 31 bits. */ + private static int factorNumber(Token token) throws ParseException { + try { + return Integer.parseInt(token.image); + } catch (NumberFormatException exception) { + throw new ParseException("Invalid authentication factor: " + token.image); + } + } + + private boolean isMySqlResourceLimitAhead(int offset) { + Token token = getToken(offset); + return token.kind == S_IDENTIFIER && getToken(offset + 1).kind == S_LONG + && Arrays.asList("MAX_QUERIES_PER_HOUR", "MAX_UPDATES_PER_HOUR", + "MAX_CONNECTIONS_PER_HOUR", "MAX_USER_CONNECTIONS") + .contains(token.image.toUpperCase(Locale.ROOT)); + } + + private boolean isMySqlPasswordLockOptionAhead(int offset) { + Token token = getToken(offset); + Token next = getToken(offset + 1); + if (token.kind == K_PASSWORD) { + return next.kind == K_HISTORY || next.kind == S_IDENTIFIER + && Arrays.asList("EXPIRE", "REUSE", "REQUIRE") + .contains(next.image.toUpperCase(Locale.ROOT)); + } + if (token.kind != S_IDENTIFIER) { + return false; + } + String word = token.image.toUpperCase(Locale.ROOT); + return "ACCOUNT".equals(word) + && (next.kind == K_LOCK || "UNLOCK".equalsIgnoreCase(next.image)) + || "FAILED_LOGIN_ATTEMPTS".equals(word) || "PASSWORD_LOCK_TIME".equals(word); + } + + private boolean isMySqlTlsOptionAhead() { + int offset = getToken(1).kind == K_AND ? 2 : 1; + Token token = getToken(offset); + return token.kind == S_IDENTIFIER && Arrays.asList("SSL", "X509", "CIPHER", "ISSUER", + "SUBJECT").contains(token.image.toUpperCase(Locale.ROOT)); + } + + /** An unsupported CREATE statement that keeps OR REPLACE, which Create() has already read. */ + private static UnsupportedStatement unsupportedCreate(boolean orReplace, List rest) { + List declarations = new ArrayList(); + if (orReplace) { + declarations.add("OR"); + declarations.add("REPLACE"); + } + declarations.addAll(rest); + return new UnsupportedStatement("CREATE", declarations); + } + + /** + * Whether CREATE is followed by a MySQL loadable function: + * [AGGREGATE] FUNCTION [IF NOT EXISTS] name RETURNS type SONAME 'library'. With the MySQL + * dialect, AGGREGATE or a function name directly followed by RETURNS selects it, since a stored + * function has a parameter list there. With MariaDB, which also has stored aggregate functions, + * or without a dialect, the whole statement must have that shape. + */ + private boolean isLoadableFunctionAhead() { + String dialect = getAsString(Feature.dialect); + if (dialect != null && !isMySqlDialect()) { return false; } + boolean mysql = Dialect.MYSQL.name().equals(dialect); + int i = 1; + if (getToken(i).kind == K_AGGREGATE) { + if (mysql) { return true; } + i++; + } + if (getToken(i++).kind != K_FUNCTION) { return false; } + if (getToken(i).kind == K_IF && getToken(i + 1).kind == K_NOT && getToken(i + 2).kind == K_EXISTS) { i += 3; } + i++; + if (mysql) { + while (".".equals(getToken(i).image)) { i += 2; } + return getToken(i).kind == K_RETURNS; + } + int end = getToken(i + 4).kind; + return getToken(i).kind == K_RETURNS && LoadableFunction.ReturnType.from(getToken(i + 1).image) != null + && "SONAME".equalsIgnoreCase(getToken(i + 2).image) + && (getToken(i + 3).kind == S_CHAR_LITERAL || getToken(i + 3).kind == S_QUOTED_IDENTIFIER) + && (end == EOF || end == ST_SEMICOLON); + } + + /** + * Whether MySQL's WITH | WITHOUT VALIDATION modifier of ALTER TABLE starts here. With the MySQL + * dialect, WITH or WITHOUT selects it, as no other action starts with them. With MariaDB or + * without a dialect, it must be the whole item of the action list. + */ + private boolean isAlterValidationModifierAhead() { + int kind = getToken(1).kind; + if (kind != K_WITH && kind != K_WITHOUT) { return false; } + String dialect = getAsString(Feature.dialect); + if (Dialect.MYSQL.name().equals(dialect)) { return true; } + if (dialect != null && !isMySqlDialect() || getToken(2).kind != K_VALIDATION) { return false; } + Token next = getToken(3); + return next.kind == EOF || next.kind == ST_SEMICOLON || ",".equals(next.image) + || next.kind == K_PARTITION && getToken(4).kind == K_BY + || next.kind == K_REMOVE && getToken(4).kind == K_PARTITIONING; + } + + /** + * Whether a WITH | WITHOUT VALIDATION modifier follows, after a comma, a command that MySQL + * accepts only at the end of the action list: a partition management command, DISCARD or + * IMPORT TABLESPACE, PARTITION BY or REMOVE PARTITIONING. Checked with the MySQL dialect. + */ + private boolean isMisplacedAlterValidationModifier(AlterExpression previous, AlterExpression action) { + if (action.getOperation() != AlterOperation.VALIDATION + || !Dialect.MYSQL.name().equals(getAsString(Feature.dialect))) { + return false; + } + AlterOperation operation = previous.getOperation(); + return operation == AlterOperation.DISCARD_TABLESPACE || operation == AlterOperation.IMPORT_TABLESPACE + || operation.name().endsWith("_PARTITION") || Alter.isTrailingPartitionOption(previous); + } + + /** + * Whether a CREATE statement names none of TABLE, INDEX, VIEW and POLICY before it ends. Every + * remaining CREATE form needs one of them, and CREATE TABLE and CREATE INDEX accept any leading + * words as modifiers, so such a statement would fail there instead of reaching the fallback. + */ + private boolean isUnknownCreateAhead() { + for (int i = 1; ; i++) { + int kind = getToken(i).kind; + if (kind == EOF || kind == ST_SEMICOLON) { return true; } + if (kind == K_TABLE || kind == K_INDEX || kind == K_VIEW || kind == K_POLICY) { return false; } + } + } + + /** + * Whether ALTER USER uses MySQL account syntax rather than the PostgreSQL alias of ALTER ROLE, + * which names one unquoted role followed by an action: IF EXISTS, USER(), CURRENT_USER(), a + * quoted name, a host, an account list, no action at all, or a MySQL account clause. + */ + private boolean isMySqlAlterUserAhead() { + if (getToken(1).kind != K_USER) { return false; } + Token name = getToken(2); + if (name.kind == K_IF || name.kind == S_CHAR_LITERAL + || (name.kind == K_USER || "CURRENT_USER".equalsIgnoreCase(name.image)) + && "(".equals(getToken(3).image) + || isMySqlAccountHostAhead(2, false)) { + return true; + } + Token next = getToken(3); + return ",".equals(next.image) || next.kind == EOF || next.kind == ST_SEMICOLON + || isMySqlUserOptionAhead(3); + } + + /** + * Whether CREATE ROLE uses MySQL syntax: IF NOT EXISTS, a quoted name, a host or a list. An + * unquoted name@host, which PostgreSQL reads as one role name, counts only in the MySQL and + * MariaDB dialects. + */ + private boolean isMySqlCreateRoleAhead() { + if (!isAccessKeywordAhead("ROLE")) { return false; } + Token name = getToken(2); + return name.kind == K_IF || name.kind == S_CHAR_LITERAL + || isMySqlAccountHostAhead(2, isMySqlDialect()) || ",".equals(getToken(3).image); + } + + /** + * Whether the account name at the offset has a host that only MySQL accepts: @ before the host, + * a user@ identifier before a quoted host or an @host identifier after a quoted user. An unquoted + * user@host, which the lexer reads as one identifier, counts only when merged is set. + */ + private boolean isMySqlAccountHostAhead(int offset, boolean merged) { + return isMySqlAccountHost(getToken(offset), merged); + } + + private boolean isMySqlAccountHost(Token name, boolean merged) { + if (name.kind == S_IDENTIFIER && name.image.indexOf('@') > 0) { + return merged || name.image.endsWith("@"); + } + Token next = nextWithItemToken(name); + return next.kind == K_AT_SIGN + || next.kind == S_AT_IDENTIFIER && !next.image.startsWith("@@"); + } + + /** + * Whether a MySQL SET ROLE statement starts here. The MySQL and MariaDB dialects type every + * form; elsewhere only ALL EXCEPT and role names with a quoted user or host do, so that + * SET ROLE name and SET ROLE NONE remain the SetStatement that PostgreSQL uses. + */ + private boolean isMySqlSetRoleAhead() { + if (getToken(1).kind != K_SET || getToken(2).kind != S_IDENTIFIER + || !"ROLE".equalsIgnoreCase(getToken(2).image)) { + return false; + } + Token next = getToken(3); + if (next.kind == EOF || next.kind == ST_SEMICOLON || next.kind == K_TO + || "=".equals(next.image) || ":=".equals(next.image) || ".".equals(next.image)) { + return false; + } + if (isMySqlDialect()) { return true; } + if (next.kind == K_ALL) { return getToken(4).kind == K_EXCEPT; } + // role [@ host] [, role [@ host]] ... + for (Token role = next; ; role = nextWithItemToken(nextWithItemToken(role))) { + if (isMySqlAccountHost(role, false)) { return true; } + if (!",".equals(nextWithItemToken(role).image)) { return false; } + } + } + + /** + * Whether a MySQL SET PASSWORD statement starts here: always with FOR, otherwise only in the + * MySQL and MariaDB dialects, where SET PASSWORD = 'x' is not a variable assignment. + */ + private boolean isMySqlSetPasswordAhead() { + if (getToken(1).kind != K_SET || getToken(2).kind != K_PASSWORD) { return false; } + Token next = getToken(3); + return next.kind == K_FOR + || isMySqlDialect() && ("=".equals(next.image) || next.kind == K_TO); + } + + private boolean isAccessKeywordAhead(String word) { + return getToken(1).kind != EOF && isKeywordAhead(word); + } + + private boolean isAccessTargetKindAhead() { + Token next = getToken(2); + return next.kind != EOF && next.kind != K_TO && next.kind != K_FROM + && !",".equals(next.image) && !".".equals(next.image) + && isAccessTargetKindAhead(1); + } + + private boolean isAccessTargetKindAhead(int offset) { + return Arrays.asList("TABLE", "SEQUENCE", "DATABASE", "DOMAIN", "FOREIGN", "FUNCTION", "PROCEDURE", + "ROUTINE", "LANGUAGE", "LARGE", "PARAMETER", "SCHEMA", "TABLESPACE", "TYPE") + .contains(getToken(offset).image.toUpperCase(Locale.ROOT)); + } + + private boolean isObjectPrivilegeAhead() { + int depth = 0; + for (Token token = getToken(1); ; token = nextWithItemToken(token)) { + if (token.kind == EOF || ";".equals(token.image)) { return false; } + if ("(".equals(token.image)) { depth++; } + else if (")".equals(token.image)) { depth--; } + else if (depth == 0) { + if (token.kind == K_ON) { return true; } + if (token.kind == K_TO || token.kind == K_FROM) { return false; } + } + } + } + + /** MySQL {@code REVOKE ALL [PRIVILEGES], GRANT OPTION FROM ...}, which has no ON clause. */ + private boolean isAccessAllGrantOptionAhead() { + if (getToken(1).kind != K_ALL) { return false; } + int i = "PRIVILEGES".equalsIgnoreCase(getToken(2).image) ? 3 : 2; + return ",".equals(getToken(i).image) && getToken(i + 1).kind == K_GRANT + && getToken(i + 2).kind == K_OPTION && getToken(i + 3).kind == K_FROM; + } + + /** PUBLIC, CURRENT_USER, CURRENT_ROLE or SESSION_USER, unless used as the user of user@host. */ + private boolean isAccessSpecialGranteeAhead() { + Token token = getToken(1); + int next = getToken(2).kind; + return (token.kind == K_PUBLIC || token.kind == S_IDENTIFIER) + && next != K_AT_SIGN && next != S_AT_IDENTIFIER + && Arrays.asList("PUBLIC", "CURRENT_USER", "CURRENT_ROLE", "SESSION_USER") + .contains(token.image.toUpperCase(Locale.ROOT)); + } + + /** Privileges take only GRANT OPTION; role memberships take distinct ADMIN, INHERIT and SET options. */ + private static boolean isValidAccessGrantOptions(PrivilegeClause clause, List options) { + if (clause.getPrivileges() != null) { + return options.size() == 1 && options.get(0).getKind() == GrantOption.Kind.GRANT + && options.get(0).getValue() == GrantOption.Value.OPTION; + } + EnumSet kinds = EnumSet.noneOf(GrantOption.Kind.class); + for (GrantOption option : options) { + if (option.getKind() == GrantOption.Kind.GRANT || !kinds.add(option.getKind())) { return false; } + } + return true; + } + + private boolean isPostgreSqlTriggerAhead() { + if (getToken(1).kind == K_CONSTRAINT) { return true; } + if (getToken(1).kind != K_TRIGGER) { return false; } + for (Token token = getToken(2); ; token = nextWithItemToken(token)) { + if (token.kind == EOF || ";".equals(token.image) || token.kind == K_BEGIN) { return false; } + if (token.kind == K_EXECUTE && (nextWithItemToken(token).kind == K_FUNCTION || nextWithItemToken(token).kind == K_PROCEDURE)) { return true; } + // DuckDB 2.0 uses the standard header with a statement body instead of EXECUTE + if ("REFERENCING".equalsIgnoreCase(token.image) || token.kind == K_STATEMENT) { return true; } + } + } + + /** + * Whether EVENT TRIGGER starts a PostgreSQL event trigger rather than a MySQL event named + * trigger: the trigger name is followed by ON in CREATE and by an action keyword in ALTER. + */ + private boolean isPostgreSqlEventTriggerAhead(boolean alter) { + if (getToken(1).kind != K_EVENT || getToken(2).kind != K_TRIGGER + || ".".equals(getToken(3).image)) { + return false; + } + Token next = getToken(4); + if (!alter) { + return next.kind == K_ON; + } + return next.kind == K_ENABLE || next.kind == K_DISABLE || next.kind == K_RENAME + || next.kind == S_IDENTIFIER && "OWNER".equalsIgnoreCase(next.image); + } + + // In these dialects -> always denotes JSON access, even after a comma or parentheses. + private boolean isJsonArrowDialect() { + return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + || isMySqlDialect(); + } + + private boolean isMySqlDialect() { + String dialect = getAsString(Feature.dialect); + return Dialect.MYSQL.name().equals(dialect) || Dialect.MARIADB.name().equals(dialect); + } + + /** MySQL's EXPLAIN, PREPARE, EXECUTE, DROP PREPARE and DO: MySQL, MariaDB or no dialect. */ + private boolean isMySqlUtilityDialect() { + return getAsString(Feature.dialect) == null || isMySqlDialect(); + } + + /** + * Whether MySQL's EXPLAIN syntax starts here: EXPLAIN, DESCRIBE or DESC before FORMAT =, INTO, + * FOR or a REPLACE statement, each optionally after ANALYZE. DESCRIBE and DESC also start it + * before ANALYZE and a query, or before another explainable statement. EXPLAIN SELECT, + * EXPLAIN ANALYZE SELECT, EXPLAIN table, DESCRIBE SELECT and DESCRIBE table keep their + * readings. + */ + private boolean isMySqlExplainAhead() { + int keyword = getToken(1).kind; + if (keyword != K_EXPLAIN && keyword != K_DESCRIBE && keyword != K_DESC + || !isMySqlUtilityDialect()) { + return false; + } + boolean analyze = getToken(2).kind == K_ANALYZE; + int offset = analyze ? 3 : 2; + Token after = getToken(offset + 1); + // a word that ends the statement or a qualified name names a table to describe + boolean statement = after.kind != EOF && after.kind != ST_SEMICOLON + && !".".equals(after.image); + switch (getToken(offset).kind) { + case K_FORMAT: + return "=".equals(after.image); + case K_INTO: case K_FOR: + return true; + case K_REPLACE: + return statement; + case K_TABLE: + // without a dialect, DESCRIBE TABLE t could also be Snowflake's DESCRIBE of a table + return keyword != K_EXPLAIN && statement && (analyze || isMySqlDialect()); + case K_INSERT: case K_UPDATE: case K_DELETE: case K_VALUES: + return keyword != K_EXPLAIN && statement; + case K_SELECT: case K_WITH: case OPENING_BRACKET: + return keyword != K_EXPLAIN && analyze; + default: + return false; + } + } + + /** + * Whether a MySQL column name or wildcard string follows the table of DESCRIBE or EXPLAIN. It + * ends the statement, and a statement keyword on the next line starts the next statement. + * Without a dialect, DESCRIBE x y could also be Snowflake's DESCRIBE of an object kind. + */ + private boolean isDescribeColumnAhead() { + int end = getToken(2).kind; + return isMySqlDialect() && (end == EOF || end == ST_SEMICOLON) + && (getToken(1).beginLine == getToken(0).endLine || !isStatementStartAhead()); + } + + /** + * Whether DO starts PostgreSQL's code block or MySQL's expression list. Without a dialect, a + * string or LANGUAGE after DO could start either, so only other expressions start MySQL's DO. + */ + private boolean isDoStatementAhead() { + if (getToken(1).kind != K_DO) { + return false; + } + String dialect = getAsString(Feature.dialect); + if (dialect == null) { + Token next = getToken(2); + return next.kind != S_CHAR_LITERAL && !"LANGUAGE".equalsIgnoreCase(next.image); + } + return Dialect.POSTGRESQL.name().equals(dialect) || isMySqlDialect(); + } + + /** MySQL's EXPLAIN formats. The server rejects other names while it parses the statement. */ + private ExplainStatement.Option mySqlExplainFormat(Token token) throws ParseException { + String name = token.image; + if (token.kind == S_CHAR_LITERAL || token.kind == S_QUOTED_IDENTIFIER) { + char quote = name.charAt(0); + name = quote == '\'' || quote == '"' || quote == '`' + ? name.substring(1, name.length() - 1) : ""; + } + ExplainStatement.Format format = ExplainStatement.Format.find(name); + if (format != ExplainStatement.Format.TRADITIONAL && format != ExplainStatement.Format.JSON + && format != ExplainStatement.Format.TREE) { + throw new ParseException("Unknown EXPLAIN format name: " + token.image); + } + return new ExplainStatement.Option(ExplainStatement.OptionType.FORMAT) + .withValue(format.name()).withUseEqual(true); + } + + /** + * Whether a MySQL INSTALL or UNINSTALL PLUGIN or COMPONENT statement starts here; read with the + * MySQL and MariaDB dialects or none. UNINSTALL is not a token. With those dialects every + * INSTALL is this statement and FORCE INSTALL is an error. Without a dialect, INSTALL plugin + * and INSTALL component stay DuckDB extension names unless SONAME or a component URN follows. + */ + private boolean isPluginStatementAhead() { + boolean install = getToken(1).kind == K_INSTALL; + boolean plugin = isWordAt(2, "PLUGIN"); + boolean object = plugin || isWordAt(2, "COMPONENT"); + if (getAsString(Feature.dialect) != null) { + return isMySqlDialect() && (install || object && isWordAt(1, "UNINSTALL") + || getToken(1).kind == K_FORCE && getToken(2).kind == K_INSTALL); + } + if (!object) { + return false; + } + return install + ? (plugin ? isWordAt(4, "SONAME") : getToken(3).kind == S_CHAR_LITERAL) + : isWordAt(1, "UNINSTALL"); + } + + /** Whether the literal is MySQL's TEXT_STRING_sys: a quoted string without a prefix. */ + private static boolean isMySqlTextString(StringValue value) { + return value.getPrefix() == null && value.getQuoteStr() != null + && !value.getQuoteStr().startsWith("$"); + } + + /** The string after SONAME or a component URN. */ + private StringValue mySqlTextString(Token token) throws ParseException { + StringValue value = stringValue(token); + requireDdlSyntax(isMySqlTextString(value), "Expected a string literal but found " + token.image); + return value; + } + + /** + * Whether the name is one MySQL does not read as a variable of INSTALL COMPONENT ... SET: an + * unquoted scope keyword on its own, or GLOBAL, LOCAL or SESSION as the qualifier, quoted or + * not. + */ + private static boolean isComponentVariableScopeWord(String name, boolean qualifier) { + switch ((qualifier ? MultiPartName.unquote(name) : name).toUpperCase(Locale.ROOT)) { + case "GLOBAL": case "LOCAL": case "SESSION": + return true; + case "PERSIST": case "PERSIST_ONLY": + return !qualifier; + default: + return false; + } + } + + /** + * Checks the value of INSTALL COMPONENT ... SET, an expression that starts at {@code first}: + * MySQL takes neither the words DEFAULT and ALL nor a subquery, which SELECT, or TABLE, VALUES + * or WITH after a parenthesis, starts. + */ + private void requireComponentVariableValue(Token first) throws ParseException { + Token last = getToken(0); + requireDdlSyntax(first.kind != K_DEFAULT && first.kind != K_ALL + || first != last && first.next.kind == OPENING_BRACKET, + "Expected a value but found " + first.image); + boolean afterParenthesis = false; + for (Token token = first; token != last.next; token = token.next) { + int kind = token.kind; + requireDdlSyntax(kind != K_SELECT + && !(afterParenthesis && (kind == K_TABLE || kind == K_VALUES || kind == K_WITH)), + "INSTALL COMPONENT ... SET does not accept a subquery"); + afterParenthesis = kind == OPENING_BRACKET; + } + } + + /** Whether CREATE SERVER and ALTER SERVER take MySQL's quoted names and numeric option values. */ + private boolean isMySqlServerSyntaxAllowed() { + return getAsString(Feature.dialect) == null || isMySqlDialect(); + } + + /** + * Checks the options of CREATE SERVER and ALTER SERVER. A numeric value is MySQL's, read with + * the MySQL and MariaDB dialects or none. With the MySQL dialect the options are exactly its + * server_option: USER, HOST, DATABASE, OWNER, PASSWORD or SOCKET with a string, or PORT with a + * number. + */ + private void requireServerOptions(List options) throws ParseException { + boolean mySql = Dialect.MYSQL.name().equals(getAsString(Feature.dialect)); + for (ForeignDataOption option : options) { + boolean numeric = option.getValueExpression() != null && option.getValue() == null; + requireDdlSyntax(!numeric || isMySqlServerSyntaxAllowed(), "Option values are string constants"); + if (mySql) { + requireDdlSyntax(option.getAction() == null, "MySQL server options do not allow ADD, SET or DROP"); + requireDdlSyntax(isMySqlServerOption(option, numeric), + "Unknown MySQL server option or value: " + option); + } + } + } + + private static boolean isMySqlServerOption(ForeignDataOption option, boolean numeric) { + switch (option.getName().toUpperCase(Locale.ROOT)) { + case "USER": case "HOST": case "DATABASE": case "OWNER": case "PASSWORD": case "SOCKET": + return !numeric && isMySqlTextString(option.getValue()); + case "PORT": + return numeric && (!(option.getValueExpression() instanceof HexValue) + || isXaHexPart(option.getValueExpression().toString())); + default: + return false; + } + } + + /** + * Whether ALTER TABLE DROP names a MySQL FOREIGN KEY or CHECK constraint. The default + * configuration accepts both like MySQL; MariaDB has no DROP CHECK. A parenthesized FOREIGN KEY + * column list keeps the legacy form, and other dialects use DROP CONSTRAINT. + */ + private boolean isNamedConstraintDropAhead() { + String dialect = getAsString(Feature.dialect); + boolean namedForeignKey = getToken(1).kind == K_FOREIGN && getToken(2).kind == K_KEY + && getToken(3).kind != OPENING_BRACKET; + if (dialect == null || Dialect.MYSQL.name().equals(dialect)) { + return namedForeignKey || getToken(1).kind == K_CHECK; + } + return Dialect.MARIADB.name().equals(dialect) && namedForeignKey; + } + + private boolean isBeginTransactionAhead() { + String dialect = getAsString(Feature.dialect); + if (getToken(1).kind != K_BEGIN || !(isMySqlDialect() + || Dialect.POSTGRESQL.name().equals(dialect))) { return false; } + Token next = getToken(2); + return next.kind == EOF || next.kind == ST_SEMICOLON || next.kind == K_WORK + || next.kind == K_READ || next.kind == K_DEFERRABLE || next.kind == K_NOT + || "TRANSACTION".equalsIgnoreCase(next.image) + || "ISOLATION".equalsIgnoreCase(next.image); + } + + private boolean isTransactionModeAhead() { + return isTransactionModeAt(1); + } + + private boolean isTransactionModeAt(int offset) { + Token token = getToken(offset); + return token.kind == S_IDENTIFIER && "ISOLATION".equalsIgnoreCase(token.image) + || token.kind == K_READ || token.kind == K_DEFERRABLE + || token.kind == K_NOT && getToken(offset + 1).kind == K_DEFERRABLE + || token.kind == K_WITH && "CONSISTENT".equalsIgnoreCase(getToken(offset + 1).image); + } + + /** + * Whether SET starts transaction characteristics rather than assigning a variable such as + * transaction_isolation: [scope] TRANSACTION followed by a mode or SNAPSHOT 'id', or [scope] + * SESSION CHARACTERISTICS AS TRANSACTION. requireSetTransactionSyntax() checks the scope. + */ + private boolean isSetTransactionAhead() { + if (getToken(1).kind != K_SET) { + return false; + } + if (isSessionCharacteristicsAt(2)) { + return true; + } + int offset = isSetTransactionScopeAt(2) ? 3 : 2; + return offset == 3 && isSessionCharacteristicsAt(3) + || isWordAt(offset, "TRANSACTION") && (isTransactionModeAt(offset + 1) + || isWordAt(offset + 1, "SNAPSHOT") && getToken(offset + 2).kind == S_CHAR_LITERAL); + } + + /** Whether a SET scope keyword of MySQL or PostgreSQL stands at {@code offset}. */ + private boolean isSetTransactionScopeAt(int offset) { + int kind = getToken(offset).kind; + return kind == K_GLOBAL || kind == K_SESSION || kind == K_LOCAL + || isWordAt(offset, "PERSIST") || isWordAt(offset, "PERSIST_ONLY"); + } + + /** Whether PostgreSQL's SESSION CHARACTERISTICS AS TRANSACTION starts at {@code offset}. */ + private boolean isSessionCharacteristicsAt(int offset) { + return getToken(offset).kind == K_SESSION && isWordAt(offset + 1, "CHARACTERISTICS") + && getToken(offset + 2).kind == K_AS && isWordAt(offset + 3, "TRANSACTION"); + } + + private boolean isWordAt(int offset, String word) { + Token token = getToken(offset); + return token.kind == S_IDENTIFIER && word.equalsIgnoreCase(token.image); + } + + /** Whether SET CONSTRAINTS names constraint timing rather than assigning a variable. */ + private boolean isSetConstraintsAhead() { + if (getToken(1).kind != K_SET || getToken(2).kind != K_CONSTRAINTS) { + return false; + } + Token next = getToken(3); + return next.kind != EOF && next.kind != ST_SEMICOLON && next.kind != K_TO + && !"=".equals(next.image) && !":=".equals(next.image) && !".".equals(next.image) + && !",".equals(next.image); + } + + /** + * Whether a PostgreSQL END commits here. Only the PostgreSQL dialect reads END as a statement, + * and only when [WORK | TRANSACTION], AND [NO] CHAIN or the statement end follows; blocks stop + * their statement lists at END first. + */ + private boolean isEndTransactionAhead() { + return getToken(1).kind == K_END + && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && isTransactionCompletionTailAt(2); + } + + /** Whether a PostgreSQL ABORT rolls back here; read with the PostgreSQL dialect or none. */ + private boolean isAbortTransactionAhead() { + String dialect = getAsString(Feature.dialect); + return isWordAt(1, "ABORT") && (dialect == null || Dialect.POSTGRESQL.name().equals(dialect)) + && isTransactionCompletionTailAt(2); + } + + /** + * Whether PostgreSQL PREPARE TRANSACTION 'id' starts here; read with the PostgreSQL dialect or + * none. The string literal tells it from PREPARE transaction AS statement, which prepares a + * statement named transaction. + */ + private boolean isPrepareTransactionAhead() { + return getToken(1).kind == K_PREPARE && isWordAt(2, "TRANSACTION") + && getToken(3).kind == S_CHAR_LITERAL && isPostgreSqlTwoPhaseDialect(); + } + + /** Whether PostgreSQL's PREPARED 'id' follows COMMIT or ROLLBACK. */ + private boolean isPreparedTransactionAhead() { + return isWordAt(1, "PREPARED") && isPostgreSqlTwoPhaseDialect(); + } + + private boolean isPostgreSqlTwoPhaseDialect() { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.POSTGRESQL.name().equals(dialect); + } + + /** + * Whether the words RESOURCE GROUP of a MySQL resource group statement are at the offset. Read + * with the MySQL dialect or none; MariaDB and the other products have no resource groups. + */ + private boolean isResourceGroupAt(int offset) { + String dialect = getAsString(Feature.dialect); + return isWordAt(offset, "RESOURCE") && getToken(offset + 1).kind == K_GROUP + && (dialect == null || Dialect.MYSQL.name().equals(dialect)); + } + + /** + * Whether DROP names a MySQL resource group. Without a dialect, DROP RESOURCE GROUP on its own + * keeps dropping an object called GROUP. + */ + private boolean isDropResourceGroupAhead() { + int next = getToken(3).kind; + return isResourceGroupAt(1) + && (getAsString(Feature.dialect) != null || next != EOF && next != ST_SEMICOLON); + } + + /** Whether MySQL CREATE, ALTER or SET RESOURCE GROUP starts here. */ + private boolean isResourceGroupStatementAhead() { + int kind = getToken(1).kind; + return (kind == K_CREATE || kind == K_ALTER || kind == K_SET) && isResourceGroupAt(2); + } + + /** A group name; MySQL reserves FORCE, the word that may follow the name. */ + private String resourceGroupName(String name) throws ParseException { + requireDdlSyntax(!"FORCE".equalsIgnoreCase(name), "Expected a resource group name"); + return name; + } + + /** + * A number that MySQL's lexer reads as NUM, as a CPU number and a thread priority must be: + * digits up to 2147483647. + */ + private int resourceGroupNumber(Token token) throws ParseException { + if (token.image.matches("[0-9]+")) { + java.math.BigInteger number = new java.math.BigInteger(token.image); + if (number.bitLength() < Integer.SIZE) { + return number.intValue(); + } + } + throw new ParseException("Expected an integer up to 2147483647 but found " + token.image); + } + + /** A thread ID: MySQL takes an unsigned integer of up to 64 bits. */ + private LongValue resourceGroupThreadId(Token token) throws ParseException { + requireDdlSyntax(token.image.matches("[0-9]+") + && new java.math.BigInteger(token.image).bitLength() <= Long.SIZE, + "Expected a thread ID but found " + token.image); + return linkToLastToken(new LongValue(token.image)); + } + + /** + * Whether a MySQL XA statement starts here: XA followed by its action. Read with the MySQL and + * MariaDB dialects or none; XA stays an identifier elsewhere. + */ + private boolean isXaStatementAhead() { + if (!isWordAt(1, "XA") || getAsString(Feature.dialect) != null && !isMySqlDialect()) { + return false; + } + int action = getToken(2).kind; + return action == K_START || action == K_BEGIN || action == K_END || action == K_PREPARE + || action == K_COMMIT || action == K_ROLLBACK || isWordAt(2, "RECOVER"); + } + + /** + * Whether PostgreSQL reads the literal as a string constant: '...', E'...', U&'...' or a + * dollar-quoted string, not N'...', B'...' or another product's prefix. + */ + private static boolean isPostgreSqlStringConstant(StringValue value) { + String prefix = value.getPrefix(); + return !"\"".equals(value.getQuoteStr()) && (prefix == null + || "E".equalsIgnoreCase(prefix) || "U&".equalsIgnoreCase(prefix)); + } + + /** + * Whether a MySQL XA gtrid or bqual string is a text_string: a quoted string without a prefix, + * or a bit-value literal B'0101'. MySQL rejects N'...', _charset'...' and the others. + */ + private static boolean isXaStringPart(StringValue value) { + String prefix = value.getPrefix(); + String quote = value.getQuoteStr(); + if (prefix == null) { + return "'".equals(quote) || "\"".equals(quote); + } + return "B".equalsIgnoreCase(prefix) && value.getValue().matches("[01]*"); + } + + /** + * Whether a hexadecimal literal is one MySQL reads: X'...' with whole bytes, or 0x... with a + * lower-case x. + */ + private static boolean isXaHexPart(String image) { + return image.matches("[Xx]'([0-9A-Fa-f]{2})*'") || image.matches("0x[0-9A-Fa-f]+"); + } + + /** + * The unsigned formatID of an XA xid. MySQL's grammar rejects a value above LONG_MAX, MariaDB's + * one above INT32_MAX. + */ + private long xaFormatId(Token token) throws ParseException { + long limit = Dialect.MARIADB.name().equals(getAsString(Feature.dialect)) + ? Integer.MAX_VALUE + : Long.MAX_VALUE; + try { + long formatId = Long.parseLong(token.image); + if (formatId <= limit) { + return formatId; + } + } catch (NumberFormatException e) { + // out of range, reported below + } + throw new ParseException("XA formatID out of range: " + token.image); + } + + private boolean isTransactionCompletionTailAt(int offset) { + Token token = getToken(offset); + return token.kind == EOF || token.kind == ST_SEMICOLON || token.kind == K_WORK + || token.kind == K_AND || isWordAt(offset, "TRANSACTION"); + } + + /** + * Whether MySQL [NO] RELEASE completes this COMMIT or ROLLBACK. RELEASE SAVEPOINT and RELEASE + * name remain separate statements, and PostgreSQL has no RELEASE completion. + */ + private boolean isTransactionReleaseAhead() { + int offset = getToken(1).kind == K_NO ? 2 : 1; + if (getToken(offset).kind != K_RELEASE + || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + return false; + } + int next = getToken(offset + 1).kind; + return next != K_SAVEPOINT && next != S_IDENTIFIER && next != S_QUOTED_IDENTIFIER; + } + + /** Rules shared by COMMIT, ROLLBACK and their END and ABORT spellings. */ + private void requireTransactionCompletionSyntax(TransactionCompletionStatement statement) + throws ParseException { + TransactionRelease release = statement.getRelease(); + requireDdlSyntax(release == null || !statement.isPostgresSpelling(), + "END and ABORT do not accept RELEASE"); + requireDdlSyntax(statement.getChain() != TransactionChain.CHAIN + || release != TransactionRelease.RELEASE, "AND CHAIN cannot be combined with RELEASE"); + requireDdlSyntax(statement.getPreparedTransactionKeyword() + != TransactionCompletionStatement.PreparedTransactionKeyword.PREPARED + || !statement.isPostgresSpelling(), "END and ABORT do not accept PREPARED"); + } + + /** + * Dialect rules of the modes of BEGIN, START TRANSACTION and SET TRANSACTION. Only START + * TRANSACTION accepts WITH CONSISTENT SNAPSHOT, and PostgreSQL does not. + */ + private void requireTransactionModes(List modes, TransactionMode.Context context) + throws ParseException { + requireDdlSyntax(context == TransactionMode.Context.START_TRANSACTION + || !modes.contains(TransactionMode.WITH_CONSISTENT_SNAPSHOT), + "Only START TRANSACTION accepts WITH CONSISTENT SNAPSHOT"); + if (isMySqlDialect()) { + requireMySqlTransactionModes(modes, context); + } else if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + requireDdlSyntax(!modes.contains(TransactionMode.WITH_CONSISTENT_SNAPSHOT), + "PostgreSQL does not accept WITH CONSISTENT SNAPSHOT"); + } + } + + /** + * MySQL: BEGIN takes no modes, START TRANSACTION no isolation level, SET TRANSACTION at most one + * isolation level and one access mode, and none of them DEFERRABLE. + */ + private void requireMySqlTransactionModes(List modes, + TransactionMode.Context context) throws ParseException { + requireDdlSyntax(context != TransactionMode.Context.BEGIN || modes.isEmpty(), + "MySQL BEGIN does not accept transaction characteristics"); + int isolationLevels = 0; + int accessModes = 0; + for (TransactionMode mode : modes) { + requireDdlSyntax(!mode.isDeferrability(), "MySQL does not accept DEFERRABLE transactions"); + isolationLevels += mode.isIsolationLevel() ? 1 : 0; + accessModes += mode.isAccessMode() ? 1 : 0; + } + if (context == TransactionMode.Context.SET_TRANSACTION) { + requireDdlSyntax(isolationLevels <= 1 && accessModes <= 1, + "MySQL SET TRANSACTION accepts one isolation level and one access mode"); + } else { + requireDdlSyntax(isolationLevels == 0, + "MySQL START TRANSACTION does not accept ISOLATION LEVEL"); + requireDdlSyntax(!Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + || !modes.contains(TransactionMode.READ_ONLY) + || !modes.contains(TransactionMode.READ_WRITE), + "MySQL transactions cannot specify both READ ONLY and READ WRITE"); + } + } + + /** + * Dialect rules of the SET TRANSACTION forms; requireTransactionModes() checks the modes. MySQL + * accepts GLOBAL, SESSION, LOCAL, PERSIST and PERSIST_ONLY before TRANSACTION modes, MariaDB + * GLOBAL, SESSION and LOCAL. PostgreSQL accepts SESSION and LOCAL before each of its forms, + * including the PostgreSQL-only SESSION CHARACTERISTICS and SNAPSHOT. + */ + private void requireSetTransactionSyntax(SetTransactionStatement statement) throws ParseException { + SetScope scope = statement.getScope(); + boolean snapshot = statement.getSnapshotId() != null; + boolean postgresForm = snapshot || statement.isSessionCharacteristics(); + boolean postgresScope = scope == SetScope.NONE || scope == SetScope.SESSION || scope == SetScope.LOCAL; + requireDdlSyntax(!snapshot || !statement.isSessionCharacteristics(), + "SESSION CHARACTERISTICS does not accept SNAPSHOT"); + requireDdlSyntax(!postgresForm || postgresScope, + "SESSION CHARACTERISTICS and SNAPSHOT accept only SESSION or LOCAL"); + if (isMySqlDialect()) { + requireDdlSyntax(!postgresForm, "MySQL does not accept SESSION CHARACTERISTICS or SNAPSHOT"); + requireDdlSyntax(!Dialect.MARIADB.name().equals(getAsString(Feature.dialect)) + || scope != SetScope.PERSIST && scope != SetScope.PERSIST_ONLY, + "MariaDB does not accept PERSIST or PERSIST_ONLY"); + } else if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + requireDdlSyntax(postgresScope, "PostgreSQL accepts only SESSION or LOCAL before TRANSACTION"); + } + } + + private boolean isMySqlSelectModifierAhead() { + Token token = getToken(1); + // These existing modifiers remain available without a dialect preset. + if (token.kind == K_STRAIGHT || token.kind == K_SQL_CACHE + || token.kind == K_SQL_CALC_FOUND_ROWS) { + return true; + } + // Keep qualified names, aliases and standalone identifier expressions intact. + int next = getToken(2).kind; + if (next == K_AS || next == K_FROM || next == EOF || next == ST_SEMICOLON + || ".".equals(getToken(2).image) || ",".equals(getToken(2).image) + || ")".equals(getToken(2).image)) { + return false; + } + // SQL_NO_CACHE is a non-reserved word, so it is a modifier only before a select item. + if (token.kind == K_SQL_NO_CACHE) { + return true; + } + if (getAsString(Feature.dialect) != null && !isMySqlDialect()) { + return false; + } + return token.kind == K_HIGH_PRIORITY || token.kind == S_IDENTIFIER + && ("SQL_SMALL_RESULT".equalsIgnoreCase(token.image) + || "SQL_BIG_RESULT".equalsIgnoreCase(token.image) + || "SQL_BUFFER_RESULT".equalsIgnoreCase(token.image)); + } + + /** Recognizes PostgreSQL's language form without taking other products' opaque LANGUAGE DDL. */ + private boolean isCreateLanguageAhead() { + if (isPostgreSqlDialect() && isAnyWordAt(1, "TRUSTED", "PROCEDURAL", "LANGUAGE")) { + return true; + } + int offset = isWordAt(1, "TRUSTED") ? 2 : 1; + if (isWordAt(offset, "PROCEDURAL")) { + offset++; + } + if (!isWordAt(offset, "LANGUAGE")) { + return false; + } + int following = getToken(offset + 2).kind; + return following == EOF || following == ST_SEMICOLON || following == K_HANDLER; + } + + private boolean isAlterLanguageAhead() { + int offset = isWordAt(1, "PROCEDURAL") ? 2 : 1; + return isWordAt(offset, "LANGUAGE") && (isPostgreSqlDialect() + || getToken(offset + 2).kind == K_RENAME || isWordAt(offset + 2, "OWNER")); + } + + private boolean isTextSearchMetadataAhead() { + return getToken(1).kind == K_TEXT_LITERAL && getToken(2).kind == K_SEARCH + && (getToken(3).kind == K_PARSER || isAnyWordAt(3, "DICTIONARY", "TEMPLATE")); + } + + /** Quoted definition keys retain case in PostgreSQL; unquoted keys are folded to lower case. */ + private static String textSearchDefinitionKey(DefinitionElement element) { + String name = element.getName(); + return name.startsWith("\"") ? name.substring(1, name.length() - 1).replace("\"\"", "\"") + : name.toLowerCase(Locale.ROOT); + } + + private void requireTextSearchDictionary(List options) throws ParseException { + int templates = 0; + for (DefinitionElement option : options) { + requireDdlSyntax(option.getArgument() != null, "CREATE dictionary options require a value"); + if ("template".equals(textSearchDefinitionKey(option))) { + templates++; + } + } + requireDdlSyntax(templates > 0, "CREATE TEXT SEARCH DICTIONARY requires TEMPLATE"); + } + + private void requireTextSearchFunctions(List functions, boolean parser) + throws ParseException { + Set required = new HashSet(parser + ? Arrays.asList("start", "gettoken", "end", "lextypes") : Arrays.asList("lexize")); + Set seen = new HashSet(); + for (DefinitionElement function : functions) { + String name = textSearchDefinitionKey(function); + requireDdlSyntax(required.contains(name) || (parser ? "headline" : "init").equals(name), + "Unknown text-search function: " + function.getName()); + requireDdlSyntax(function.getArgument() != null, "Text-search functions require a value"); + seen.add(name); + } + requireDdlSyntax(seen.containsAll(required), "Missing required text-search functions"); + } + + /** Whether the dialect is PostgreSQL: forms the server rejects are then not read. */ + private boolean isPostgreSqlDialect() { + return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)); + } + + /** + * With the PostgreSQL dialect, rejects an unquoted word its grammar does not take as the first + * part of a name, or as a role: a role may be a type or function name keyword, CURRENT_ROLE, + * CURRENT_USER or SESSION_USER. Other dialects keep the names they read today. + */ + private void requireConversionName(String name, boolean role) throws ParseException { + if (!isPostgreSqlDialect()) { + return; + } + int dot = name.indexOf('.'); + String upper = (dot < 0 ? name : name.substring(0, dot)).toUpperCase(Locale.ROOT); + boolean valid = role + ? !POSTGRESQL_RESERVED_KEYWORDS.contains(upper) || "CURRENT_ROLE".equals(upper) + || "CURRENT_USER".equals(upper) || "SESSION_USER".equals(upper) + : !POSTGRESQL_RESERVED_KEYWORDS.contains(upper) + && !POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS.contains(upper); + requireDdlSyntax(valid, "PostgreSQL does not take " + name + " as a name here"); + } + + /** + * Whether CREATE [OR REPLACE] is followed by a PostgreSQL cast, transform or conversion + * definition. PostgreSQL reads CAST, TRANSFORM, CONVERSION and DEFAULT there as nothing else. + * Other products start different statements with these words, such as CREATE CAST (a AS b) + * WITH SPECIFIC FUNCTION f or CREATE TRANSFORM FOR type group (...), so in another dialect + * and without one the statement must also have PostgreSQL's form: CAST (...) WITH FUNCTION, + * WITH INOUT or WITHOUT FUNCTION, TRANSFORM FOR type LANGUAGE, or [DEFAULT] CONVERSION name + * FOR, with OR REPLACE only before TRANSFORM. + */ + private boolean isCastDdlAhead() { + Token next = getToken(1); + boolean postgreSql = isPostgreSqlDialect(); + boolean orReplace = getToken(0).kind == K_REPLACE; + if (next.kind == K_CAST) { + return postgreSql || !orReplace && isCastMethodAhead(); + } + if (isKeywordAhead("TRANSFORM")) { + return postgreSql || getToken(2).kind == K_FOR && isTransformLanguageAhead(); + } + int offset = next.kind == K_DEFAULT ? 2 : 1; + if (!"CONVERSION".equalsIgnoreCase(getToken(offset).image)) { + return postgreSql && next.kind == K_DEFAULT; + } + return postgreSql || !orReplace && getToken(qualifiedNameEnd(offset + 1) + 1).kind == K_FOR; + } + + /** Whether CAST (...) is followed by WITH FUNCTION, WITH INOUT or WITHOUT FUNCTION. */ + private boolean isCastMethodAhead() { + if (getToken(2).kind != OPENING_BRACKET) { + return false; + } + int depth = 1; + int offset = 3; + for (; depth > 0; offset++) { + int kind = getToken(offset).kind; + if (kind == EOF || kind == ST_SEMICOLON) { + return false; + } + depth += kind == OPENING_BRACKET ? 1 : kind == CLOSING_BRACKET ? -1 : 0; + } + Token method = getToken(offset); + Token next = getToken(offset + 1); + return method.kind == K_WITH && (next.kind == K_FUNCTION || "INOUT".equalsIgnoreCase(next.image)) + || method.kind == K_WITHOUT && next.kind == K_FUNCTION; + } + + /** Whether LANGUAGE follows the type of TRANSFORM FOR, outside the type's parentheses. */ + private boolean isTransformLanguageAhead() { + int depth = 0; + for (int offset = 3; ; offset++) { + Token token = getToken(offset); + if (token.kind == EOF || token.kind == ST_SEMICOLON) { + return false; + } + depth += token.kind == OPENING_BRACKET ? 1 : token.kind == CLOSING_BRACKET ? -1 : 0; + if (depth == 0 && "LANGUAGE".equalsIgnoreCase(token.image)) { + return offset > 3; + } + } + } + + /** The offset of the last part of the dotted name that starts at the offset. */ + private int qualifiedNameEnd(int offset) { + int end = offset; + while (".".equals(getToken(end + 1).image)) { + end += 2; + } + return end; + } + + /** + * Whether ALTER is followed by CONVERSION, and in another dialect than PostgreSQL also by a + * name and one of PostgreSQL's actions: RENAME, OWNER or SET. + */ + private boolean isAlterConversionAhead() { + if (!isKeywordAhead("CONVERSION")) { + return false; + } + Token action = getToken(qualifiedNameEnd(2) + 1); + return isPostgreSqlDialect() || action.kind == K_RENAME || action.kind == K_SET + || "OWNER".equalsIgnoreCase(action.image); + } + + /** + * PostgreSQL's persistence and TABLE keywords of SELECT INTO are read with that dialect and + * without one, never with another dialect. + */ + private boolean isPostgreSqlSelectIntoDialect() { + return getAsString(Feature.dialect) == null || isPostgreSqlDialect(); + } + + /** + * Whether IS [NOT] [NFC | NFD | NFKC | NFKD] NORMALIZED follows. The form names and NORMALIZED + * are identifiers everywhere else. + */ + private boolean isIsNormalizedAhead() { + if (getToken(1).kind != K_IS) { + return false; + } + int offset = getToken(2).kind == K_NOT ? 3 : 2; + if (isWordAt(offset, "NORMALIZED")) { + return true; + } + Token form = getToken(offset); + return form.kind == S_IDENTIFIER && IsNormalizedExpression.NormalForm.isNormalForm(form.image) + && isWordAt(offset + 1, "NORMALIZED"); + } + + /** + * Whether the arguments of XMLELEMENT continue with XMLATTRIBUTES(...) after the element name, + * the only place where the attribute list with its AS names is allowed. PostgreSQL requires + * the NAME keyword before the element name. + */ + private boolean isXmlElementAttributesAhead(Function function) { + return hasUnqualifiedName(function, "XMLELEMENT") && ",".equals(getToken(2).image) + && isWordAt(3, "XMLATTRIBUTES") && getToken(4).kind == OPENING_BRACKET + && (!isPostgreSqlDialect() || "NAME".equalsIgnoreCase(function.getExtraKeyword())); + } + + private static boolean hasUnqualifiedColumns(List columns) { + for (Column column : columns) { + if (column.getTable() != null) { + return false; + } + } + return true; + } + + private boolean isMySqlSelectIntoAhead() { + if (getToken(1).kind != K_INTO) { return false; } + int kind = getToken(2).kind; + return kind == K_OUTFILE || kind == K_DUMPFILE + || isMySqlDialect() && (kind == S_AT_IDENTIFIER || kind == K_AT_SIGN); + } + + private static UserVariable requireMySqlIntoVariable(UserVariable variable) throws ParseException { + if (variable.isDoubleAdd()) { + throw new ParseException("A user variable with a single @ prefix is required"); + } + return variable; + } + + private ExplainStatement.OptionType postgresqlExplainOptionType(String name) throws ParseException { + try { + return ExplainStatement.OptionType.from(name); + } catch (IllegalArgumentException ex) { + throw new ParseException("Unknown PostgreSQL EXPLAIN option: " + name); + } + } + + private void validatePostgresqlExplain(ExplainStatement explain) throws ParseException { + if (explain.getTable() != null) { + throw new ParseException("PostgreSQL EXPLAIN requires a statement"); + } + int previous = -1; + for (ExplainStatement.Option option : explain.getOptionList()) { + ExplainStatement.OptionType type = option.getType(); + String value = option.getValue(); + if (!explain.isParenthesizedOptions()) { + int position = type == ExplainStatement.OptionType.ANALYZE ? 0 + : type == ExplainStatement.OptionType.VERBOSE ? 1 : -1; + if (position <= previous || value != null) { + throw new ParseException("PostgreSQL EXPLAIN options require parentheses"); + } + previous = position; + } else { + boolean valid; + switch (type) { + case FORMAT: + valid = value != null && value.matches("(?i)TEXT|XML|JSON|YAML"); + break; + case SERIALIZE: + valid = value == null || value.matches("(?i)NONE|TEXT|BINARY"); + break; + case PLAN: case PLAN_FOR: + valid = false; + break; + default: + valid = value == null || value.matches("(?i)TRUE|FALSE|ON|OFF|0|1"); + } + if (!valid) { + throw new ParseException("Invalid PostgreSQL EXPLAIN option: " + option.formatOption()); + } + } + } + } + + private void requireDdlSyntax(boolean valid, String message) throws ParseException { + if (!valid) { + throw new ParseException(message); + } + } + + private LikeClause.OptionKind likeOptionKind(String name) throws ParseException { + try { + return LikeClause.OptionKind.valueOf(name.toUpperCase(Locale.ROOT)); + } catch (IllegalArgumentException ex) { + throw new ParseException("Unknown LIKE option: " + name); + } + } + + private boolean isPostgreSqlRelationActionAhead() { + Token first = getToken(1); + if ((first.kind == K_ENABLE || first.kind == K_DISABLE) + && ("RULE".equalsIgnoreCase(getToken(2).image) + || (getToken(2).kind == K_ALWAYS || "REPLICA".equalsIgnoreCase(getToken(2).image)) + && "RULE".equalsIgnoreCase(getToken(3).image))) { return true; } + int columnActionOffset = getToken(2).kind == K_COLUMN ? 4 : 3; + if (first.kind == K_ALTER && getToken(columnActionOffset).kind == K_SET + && "EXPRESSION".equalsIgnoreCase(getToken(columnActionOffset + 1).image)) { + return true; + } + // VALIDATE CONSTRAINT starts no other ALTER TABLE action in any dialect. + if (first.kind == K_VALIDATE && getToken(2).kind == K_CONSTRAINT) { return true; } + if (!Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { return false; } + if (first.kind == K_VALIDATE || first.kind == K_RESET || isKeywordAhead("INHERIT") + || isKeywordAhead("REPLICA") || isKeywordAhead("OWNER") || isKeywordAhead("CLUSTER") + || first.kind == K_OF || first.kind == K_NOT && getToken(2).kind == K_OF + || (first.kind == K_ENABLE || first.kind == K_DISABLE) + && (getToken(2).kind == K_TRIGGER || getToken(2).kind == K_ALWAYS + || "REPLICA".equalsIgnoreCase(getToken(2).image))) { return true; } + if (first.kind == K_NO) { return "INHERIT".equalsIgnoreCase(getToken(2).image); } + if (first.kind == K_SET) { + return getToken(2).kind == OPENING_BRACKET || getToken(2).kind == K_SCHEMA + || getToken(2).kind == K_TABLESPACE || "ACCESS".equalsIgnoreCase(getToken(2).image) + || getToken(2).kind == K_WITHOUT || getToken(2).kind == K_UNLOGGED + || "LOGGED".equalsIgnoreCase(getToken(2).image); + } + if (first.kind != K_ALTER) { return false; } + if (getToken(2).kind == K_CONSTRAINT) { + return "INHERIT".equalsIgnoreCase(getToken(4).image) + || getToken(4).kind == K_NO && "INHERIT".equalsIgnoreCase(getToken(5).image); + } + int offset = getToken(2).kind == K_COLUMN ? 4 : 3; + return getToken(offset).kind == K_RESET + || getToken(offset).kind == K_DROP && "EXPRESSION".equalsIgnoreCase(getToken(offset + 1).image) + || getToken(offset).kind == K_SET && (getToken(offset + 1).kind == OPENING_BRACKET + || getToken(offset + 1).kind == K_STORAGE + || "COMPRESSION".equalsIgnoreCase(getToken(offset + 1).image) + || "STATISTICS".equalsIgnoreCase(getToken(offset + 1).image)); + } + + private void validateRelationAction(AlterRelation.ObjectType type, RelationAlterAction action) throws ParseException { + RelationAlterAction.Kind kind = action.getKind(); + EnumSet allowed = EnumSet.of(RelationAlterAction.Kind.RENAME, + RelationAlterAction.Kind.SET_OPTIONS, RelationAlterAction.Kind.RESET_OPTIONS, + RelationAlterAction.Kind.ALTER_COLUMN); + if (type == AlterRelation.ObjectType.INDEX) { + allowed.addAll(EnumSet.of(RelationAlterAction.Kind.SET_TABLESPACE, + RelationAlterAction.Kind.ATTACH_PARTITION, RelationAlterAction.Kind.DEPENDS_ON_EXTENSION)); + } else { + allowed.addAll(EnumSet.of(RelationAlterAction.Kind.RENAME_COLUMN, + RelationAlterAction.Kind.OWNER, RelationAlterAction.Kind.SET_SCHEMA)); + if (type == AlterRelation.ObjectType.MATERIALIZED_VIEW) { + allowed.addAll(EnumSet.of(RelationAlterAction.Kind.SET_TABLESPACE, + RelationAlterAction.Kind.SET_ACCESS_METHOD, RelationAlterAction.Kind.DEPENDS_ON_EXTENSION, + RelationAlterAction.Kind.CLUSTER_ON, RelationAlterAction.Kind.SET_WITHOUT_CLUSTER)); + } + } + requireDdlSyntax(allowed.contains(kind), "Unsupported " + type + " action: " + kind); + if (kind == RelationAlterAction.Kind.ALTER_COLUMN) { + RelationAlterAction.ColumnAction column = action.getColumnAction(); + if (type == AlterRelation.ObjectType.INDEX) { + requireDdlSyntax(action.getColumnNumber() != null + && column == RelationAlterAction.ColumnAction.SET_STATISTICS, + "ALTER INDEX column actions require an ordinal and SET STATISTICS"); + } else { + requireDdlSyntax(action.getColumnNumber() == null, "Expected a column name"); + boolean defaults = column == RelationAlterAction.ColumnAction.SET_DEFAULT + || column == RelationAlterAction.ColumnAction.DROP_DEFAULT; + requireDdlSyntax(type == AlterRelation.ObjectType.VIEW ? defaults + : column == RelationAlterAction.ColumnAction.SET_STATISTICS + || column == RelationAlterAction.ColumnAction.SET_STORAGE + || column == RelationAlterAction.ColumnAction.SET_COMPRESSION + || column == RelationAlterAction.ColumnAction.SET_OPTIONS + || column == RelationAlterAction.ColumnAction.RESET_OPTIONS, + "Unsupported view column action: " + column); + } + } + } + + /** Whether a MySQL tablespace option, which reuses a table option model, starts here. */ + private boolean isMySqlTablespaceOptionAhead(int offset) { + Token token = getToken(offset); + if (token.kind == K_ENGINE || token.kind == K_ENCRYPTION) { + return true; + } + return token.kind == S_IDENTIFIER && ("AUTOEXTEND_SIZE".equalsIgnoreCase(token.image) + || "FILE_BLOCK_SIZE".equalsIgnoreCase(token.image) + || "ENGINE_ATTRIBUTE".equalsIgnoreCase(token.image)); + } + + /** Only CREATE TABLESPACE sets FILE_BLOCK_SIZE, and undo tablespaces accept only ENGINE. */ + private TableOption validateTablespaceOption(TableOption option, boolean create, boolean undo) + throws ParseException { + TableOption.Kind kind = option.getKind(); + requireDdlSyntax(kind == TableOption.Kind.ENGINE + || !undo && (create || kind != TableOption.Kind.FILE_BLOCK_SIZE), + (create ? "CREATE " : "ALTER ") + (undo ? "UNDO " : "") + "TABLESPACE does not accept " + + option.getName()); + return option; + } + + private boolean isIdentityAlterationAhead() { + int first = getToken(1).kind; + int second = getToken(2).kind; + if ((first == K_ADD || first == K_SET) + && "GENERATED".equalsIgnoreCase(getToken(2).image)) { + return true; + } + if (first == K_RESTART || (first == K_DROP && second == K_IDENTITY)) { + return true; + } + if (first == K_SET) { + switch (second) { + case K_INCREMENT: case K_START: case K_MINVALUE: case K_MAXVALUE: + case K_NO: case K_CACHE: case K_CYCLE: + return true; + default: + return false; + } + } + return false; + } + + /** Attaches the definition to its own AST slot and populates remaining legacy metadata. */ + private void setAlterTableElement(AlterExpression alterExp, TableElement element) { + if (element instanceof Index) { + alterExp.setIndex((Index) element); + return; + } + NamedConstraint constraint = (NamedConstraint) element; + alterExp.setConstraint(constraint); + if (constraint instanceof KeyConstraint && constraint.getKind() == ConstraintKind.UNIQUE) { + KeyConstraint key = (KeyConstraint) constraint; + // Preserve generic ALTER's historical placement of USING and COMMENT options. + if (!Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + && !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + for (IndexSpecOption option : new ArrayList(key.getSpecOptions())) { + if (option.getKind() == IndexSpecOption.Kind.INDEX_TYPE) { + alterExp.addParameters("USING", option.getValue()); + key.getSpecOptions().remove(option); + } else if (option.getKind() == IndexSpecOption.Kind.COMMENT) { + key.setCommentText(option.getValue()); + key.getSpecOptions().remove(option); + } + } + } + } + } + + /** Keeps relation-option branches out of the generated parser's nearly full constant pool. */ + private static final class RelationOptions { + private RelationOptions() {} + + static LockStatement.Target lockTarget(TableReference reference) { + LockStatement.Target target = new LockStatement.Target(reference.getTable()); + target.setOnly(reference.isOnly()); + target.setIncludeDescendants(reference.isIncludeDescendants()); + target.setParenthesized(reference.isParenthesized()); + return target; + } + + static boolean isOnlyAhead(Token prev, int next) { + boolean name = next == S_IDENTIFIER || next == S_QUOTED_IDENTIFIER || next == OPENING_BRACKET; + switch (prev.kind) { + case K_FROM: case K_JOIN: case K_UPDATE: case K_INTO: case K_USING: + return name || next >= MIN_NON_RESERVED_WORD && next <= MAX_NON_RESERVED_WORD; + case K_COMMA: + // a column definition continues with its type, as in (a INT, only INT) + return name; + default: + return false; + } + } + + static void apply(Truncate truncate, String log, String storage, + String identity, String behavior) { + if (log != null) { + truncate.setMaterializedViewLogOption(Truncate.MaterializedViewLogOption.valueOf(log)); + } + if (storage != null) { + truncate.setStorageOption(Truncate.StorageOption.valueOf(storage)); + } + if (identity != null) { + truncate.setIdentityOption(Truncate.IdentityOption.valueOf(identity)); + } + if (behavior != null) { + truncate.setDropBehavior(CascadeBehavior.valueOf(behavior)); + } + } + } + + private void requireNoDropOwnerTable(Table owner) throws ParseException { + if (owner != null) { + throw new ParseException("Duplicate ON clause in DROP"); + } + } + + /** Keeps DROP lookahead branches out of the generated parser's nearly full constant pool. */ + private static final class DropLookahead { + private DropLookahead() {} + + /** SQL Server DDL triggers name a scope rather than an owning table. */ + static boolean isOwnerTable(Drop drop, Table name) { + String text = name.getFullyQualifiedName(); + boolean triggerScope = drop.getObjectType() == Drop.ObjectType.TRIGGER + && ("DATABASE".equalsIgnoreCase(text) || "ALL".equalsIgnoreCase(text)); + return drop.getObjectType().hasOwnerTable() && !triggerScope; + } + + static boolean isForceAhead(Drop drop, Token first, Token second, Token third) { + return (drop.getObjectType() == Drop.ObjectType.SYNONYM + || drop.getObjectType() == Drop.ObjectType.RESOURCE_GROUP) && first.kind == K_FORCE + || drop.getObjectType() == Drop.ObjectType.DATABASE + && (first.kind == K_WITH && "(".equals(second.image) && third.kind == K_FORCE + || "(".equals(first.image) && second.kind == K_FORCE); + } + + /** + * A PostgreSQL operator, possibly after a schema and a dot, is spelled with the characters + * of PostgreSQL's operator tokens, unlike the name of an Oracle operator. + */ + static boolean isOperatorAhead(Token first, Token second, Token third) { + return isOperatorSymbol(first) || ".".equals(second.image) && isOperatorSymbol(third); + } + + // an identifier such as #tmp may start with an operator character too + private static boolean isOperatorSymbol(Token token) { + return token.kind != S_IDENTIFIER && token.kind != S_QUOTED_IDENTIFIER + && token.image != null && !token.image.isEmpty() + && "+-*/<>=~!@#%^&|?".indexOf(token.image.charAt(0)) >= 0; + } + + /** MySQL DROP RESOURCE GROUP names one group by a plain identifier, without IF EXISTS. */ + static boolean isResourceGroupTarget(Drop drop) { + if (drop.isIfExists() || drop.isMaterialized() || drop.getNames().size() != 1) { + return false; + } + Table name = drop.getNames().get(0); + return name.getSchemaName() == null && !name.getName().startsWith("'") + && !"FORCE".equalsIgnoreCase(name.getName()); + } + + /** The targets are a cast, a transform or operators, named by their types. */ + static boolean hasSignatureTargets(Drop drop) { + return drop.getCast() != null || drop.getTransform() != null + || !drop.getOperators().isEmpty(); + } + } + + /** Builds names from lexer-separated components without reinterpreting PostgreSQL dots. */ + protected Table createTable(List names) { + return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && names.size() == 1 + ? new Table(names.get(0), false) : new Table(names); + } + + protected Column createColumn(List names, List delimiters) { + if (!Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + return new Column(names, delimiters); + } + Column column = new Column(); + column.setName(names.get(names.size() - 1), false); + if (names.size() > 1) { + column.setTable(createTable(names.subList(0, names.size() - 1))); + } + column.setTableDelimiter(delimiters.isEmpty() ? "." : delimiters.get(delimiters.size() - 1)); + return column; + } + + protected Column createColumn(String name) { + return createColumn(Collections.singletonList(name), Collections.emptyList()); + } + + /** + * Lightweight lookahead for SpecialStringFunctionWithNamedParameters: + * scans forward from the current position (just past the opening '(') + * looking for FROM, IN, or PLACING at bracket nesting depth 0. + * + * This replaces an expensive syntactic LOOKAHEAD(NamedExpressionListExprFirst()) + * that caused exponential backtracking with deeply nested expressions. + */ + protected boolean isNamedExprListAhead() { + int depth = 0; + for (Token t = getToken(1); ; t = nextWithItemToken(t)) { + if (t.kind == EOF) { + return false; + } + if (t.kind == OPENING_BRACKET) { + depth++; + } else if (t.kind == CLOSING_BRACKET) { + if (depth == 0) { + return false; + } + depth--; + } else if (depth == 0) { + if (t.kind == K_FROM || t.kind == K_IN || t.kind == K_PLACING) { + return true; + } + if (t.image.equals(",")) { + return false; + } + } + } + } + + /** + * Creates a string literal that remembers how this configuration lexed its backslashes. A + * PostgreSQL escape string with a Unicode escape that the server rejects is rejected as well. + */ + private StringValue stringValue(Token token) throws ParseException { + StringValue value = unlinkedStringValue(token); + linkAST(value, token, token); + return value; + } + + private StringValue unlinkedStringValue(Token token) throws ParseException { + StringValue value = new StringValue(token.image); + // a U&'...' string brings its own escaping + if (value.getQuoteStr() == null || value.getQuoteStr().startsWith("$") + || value.getEscaping() == StringValue.Escaping.POSTGRESQL_UNICODE_ESCAPE) { + return value; + } + String dialect = getAsString(Feature.dialect); + boolean backslashes = getAsBoolean(Feature.allowBackslashEscapeCharacter); + if (Dialect.POSTGRESQL.name().equals(dialect)) { + if (backslashes || "E".equalsIgnoreCase(value.getPrefix())) { + value.setEscaping(StringValue.Escaping.POSTGRESQL_ESCAPE_STRING); + try { + value.getNotExcapedValue(); + } catch (IllegalArgumentException e) { + throw new ParseException("Invalid escape string " + token.image + ": " + + e.getMessage()); + } + } + } else if (backslashes && (dialect == null || isMySqlDialect())) { + value.setEscaping(StringValue.Escaping.MYSQL_BACKSLASH); + } + return value; + } + + /** + * Semantic lookahead for the adjacent string literal concatenation in PrimaryExpression: + * true when Feature.adjacentStringLiterals is on and the next token is a string literal + * meeting the mode's separation rule (WHITESPACE: any, NEWLINE: a newline between the + * tokens, detected through the token line numbers). + */ + protected boolean isAdjacentStringConcat() { + String mode = getAsString(Feature.adjacentStringLiterals); + if (mode == null || AdjacentStringLiterals.OFF.name().equals(mode)) { + return false; + } + if (getToken(1).kind != S_CHAR_LITERAL) { + return false; + } + if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && (StringValue.getDollarQuoteDelimiter(getToken(0).image) != null + || !getToken(1).image.startsWith("'"))) { + return false; + } + return AdjacentStringLiterals.WHITESPACE.name().equals(mode) + || getToken(1).beginLine > getToken(0).endLine; + } + + /** + * Checks if the next token can start a condition suffix + * (comparison, IN, BETWEEN, LIKE, IS NULL, etc.) + * + * Used as the entry guard for the entire optional condition-suffix block + * in Condition(), eliminating choice conflicts. + */ + protected boolean isConditionSuffixAhead() { + Token t = getToken(1); + if (isLikeOperator(t)) return true; + // Inline isComparisonOperatorAhead for single getToken(1) call + if (t.kind == OPENING_BRACKET && getToken(2).image.equals("+")) { + return isComparisonOperator(getToken(4)); + } + // ClickHouse ternary `cond ? then : else` — the `?` must not be taken as the + // PostgreSQL JSON operator, it is consumed by prattExpressionRest instead + if ("?".equals(t.image) && isTernaryAhead()) return false; + if (isComparisonOperator(t)) return true; + return isConditionKeywordAhead(1); + } + + private boolean isConditionKeywordAhead(int offset) { + switch (getToken(offset).kind) { + // Each suffix's start token: + case K_OVERLAPS: // OVERLAPS + case K_IN: // IN + case K_GLOBAL: // GLOBAL ... IN + case K_EXCLUDES: // EXCLUDES (...) + case K_INCLUDES: // INCLUDES (...) + case K_BETWEEN: // BETWEEN + case K_MEMBER: // MEMBER OF + case K_IS: // IS [NOT] NULL / TRUE / FALSE / UNKNOWN / DISTINCT + case K_ISNULL: // ISNULL + case K_NOTNULL: // NOTNULL + case K_LIKE: // LIKE + case K_ILIKE: // ILIKE + case K_RLIKE: // RLIKE + case K_REGEXP_LIKE: // REGEXP_LIKE + case K_REGEXP: // REGEXP + case K_GLOB: // GLOB (DuckDB/SQLite) + case K_SIMILAR_TO: // SIMILAR TO (in LikeExpression) + case K_SIMILAR: // SIMILAR TO (in SimilarToExpression) + case K_MATCH_ANY: // MATCH_ANY + case K_MATCH_ALL: // MATCH_ALL + case K_MATCH_PHRASE: // MATCH_PHRASE + case K_MATCH_PHRASE_PREFIX: // MATCH_PHRASE_PREFIX + case K_MATCH_REGEXP: // MATCH_REGEXP + return true; + case K_NOT: // NOT IN / NOT BETWEEN / NOT LIKE / NOT ISNULL / NOT SIMILAR + // A column's NOT NULL constraint starts after its DEFAULT expression. + return getToken(offset + 1).kind != K_NULL; + // Oracle (+) before IN: col(+) IN (...) + case OPENING_BRACKET: + return getToken(offset + 1).image.equals("+"); + default: + return false; + } + } + + private boolean isLargeObjectTypeAhead() { + int offset = 1; + if (isKeywordAhead("NATIONAL")) { + offset++; + if (!"CHARACTER".equalsIgnoreCase(getToken(offset).image)) { + return false; + } + } + String name = getToken(offset).image; + return ("CHARACTER".equalsIgnoreCase(name) || "CHAR".equalsIgnoreCase(name) + || "NCHAR".equalsIgnoreCase(name) || "BINARY".equalsIgnoreCase(name)) + && "LARGE".equalsIgnoreCase(getToken(offset + 1).image) + && "OBJECT".equalsIgnoreCase(getToken(offset + 2).image); + } + + /** + * Extracts the numeric precision embedded in a DT_ZONE token image such as + * "TIMESTAMP(3) WITH TIME ZONE", or null when the image carries no parameter. + */ + private static Integer zonedTypePrecision(String image) { + int open = image.indexOf('('); + if (open < 0) { + return null; + } + return Integer.valueOf(image.substring(open + 1, image.indexOf(')', open)).trim()); + } + +} + +PARSER_END(CCJSqlParser) + +TOKEN_MGR_DECLS : { + public FeatureConfiguration configuration = new FeatureConfiguration(); + + + // Identify the index of the quoting/escaping tokens + public int charLiteralIndex = -1; + public int squaredBracketOpenIndex = -1; + { + for (int i=0;i") ) { + charLiteralIndex = i; + break; + } + } + for (int i=0;i 1 && (s.charAt(0) == 'q' || s.charAt(0) == 'Q') && s.charAt(1) == '\'' + || isUnicodeEscapeString(s)) { + return -1; + } + return closingQuote(s, s.indexOf('\''), '\'', backslashEscapes); + } + + private static boolean isUnicodeEscapeString(String s) { + return s.regionMatches(true, 0, "U&'", 0, 3); + } + + // A PostgreSQL Unicode escape string U&'...' [UESCAPE 'c'] is one literal with + // Dialect.POSTGRESQL, which rejects invalid escapes as the server does. Other dialects keep + // reading the identifier U followed by the & operator. + private void lexUnicodeEscapeString(Token token) { + if (!AbstractJSqlParser.Dialect.POSTGRESQL.name().equals(configuration.getValue(Feature.dialect))) { + truncateIdentifierToken(token, 1); + token.kind = S_IDENTIFIER; + return; + } + try { + new StringValue(token.image).getNotExcapedValue(); + } catch (IllegalArgumentException e) { + // Rewind so that every later attempt to read past the literal fails as well + input_stream.backup(token.image.length()); + throw new TokenMgrException("Lexical error at line " + token.beginLine + ", column " + + token.beginColumn + ". Invalid Unicode escape string " + token.image + ": " + + e.getMessage(), TokenMgrException.LEXICAL_ERROR); + } + } + + private RowPatternTokenContext rowPatternContext; + + private void reportMySqlCommentError() { + throw new TokenMgrException(input_stream.mySqlCommentError == null + ? "Unexpected control character" : input_stream.mySqlCommentError, + TokenMgrException.LEXICAL_ERROR); + } + + public void CommonTokenAction(Token t) + { + t.absoluteBegin = getCurrentTokenAbsolutePosition(); + t.absoluteEnd = t.absoluteBegin + t.image.length(); + positionComments(t); + lastToken = t; + // Track the lexical region independently of parser lookahead: nested SELECT + // disambiguation can fetch PATTERN tokens before its production is entered. + if (rowPatternContext == null && t.kind == S_IDENTIFIER + && "MATCH_RECOGNIZE".equalsIgnoreCase(t.image) + && AbstractJSqlParser.Dialect.BIGQUERY.name().equals(configuration.getValue(Feature.dialect))) { + rowPatternContext = new RowPatternTokenContext(); + } + if (rowPatternContext != null) { + rowPatternContext.accept(t); + if (rowPatternContext.isIdle()) { rowPatternContext = null; } + } + } + + // the last token handed out with a token action, whose successor is the first end-of-file token + private Token lastToken; + + /** + * Gives the comments before the end of input their positions. The end-of-file token gets no + * token action, and it is the first one after the last token that does which holds them. + */ + public void positionTrailingComments() { + if (lastToken != null && lastToken.next != null && lastToken.next.kind == EOF) { + positionComments(lastToken.next); + } + } + + /** Gives the comments in front of a token their positions. */ + public void positionComments(Token t) { + if (input_stream instanceof SimpleCharStream) { + ((SimpleCharStream) input_stream).positionSpecialTokens(t); + } + } + + public int getCurrentTokenAbsolutePosition() + { + if (input_stream instanceof SimpleCharStream) + return ((SimpleCharStream)input_stream).getAbsoluteTokenBegin(); + return -1; + } + + /** Scans a literal in linear time without tokenizing or rebuilding its whitespace. */ + public void consumeDollarQuotedString(String closingQuote) { + int[] prefix = new int[closingQuote.length()]; + for (int i = 1, matched = 0; i < closingQuote.length(); i++) { + while (matched > 0 && closingQuote.charAt(i) != closingQuote.charAt(matched)) { + matched = prefix[matched - 1]; + } + if (closingQuote.charAt(i) == closingQuote.charAt(matched)) { + matched++; + } + prefix[i] = matched; + } + try { + int matched = 0; + while (matched < closingQuote.length()) { + char ch = input_stream.readChar(); + while (matched > 0 && ch != closingQuote.charAt(matched)) { + matched = prefix[matched - 1]; + } + if (ch == closingQuote.charAt(matched)) { + matched++; + } + } + } catch (java.io.IOException e) { + reportError(Math.max(closingQuote.length(), input_stream.GetImage().length())); + } + } + + /** Rewinds any identifier suffix consumed by longest-match lexing before scanning the body. */ + private void consumeDollarQuotedToken(Token token, String delimiter) { + input_stream.backup(token.image.length() - delimiter.length()); + consumeDollarQuotedString(delimiter); + token.image = input_stream.GetImage(); + token.kind = charLiteralIndex; + token.endLine = input_stream.getEndLine(); + token.endColumn = input_stream.getEndColumn(); + } + + /** + * DuckDB's and PostgreSQL's digit separators, as in {@code 1_000_000}. Under + * Feature.allowDigitSeparators they are dropped from the image. Otherwise the token is + * lexed as without separators: the longer of the number before the first {@code _} and the + * identifier starting there, so that MySQL's {@code 2024_01} stays an identifier. + */ + private void lexDigitSeparators(Token token) { + int separator = token.image.indexOf('_'); + if (separator < 0) { + return; + } + if (input_stream.featureConfiguration != null + && Boolean.TRUE.equals(configuration.getValue(Feature.allowDigitSeparators))) { + token.image = token.image.replace("_", ""); + return; + } + int identifierLength = 0; + while (identifierLength < token.image.length() + && (Character.isLetterOrDigit(token.image.charAt(identifierLength)) + || token.image.charAt(identifierLength) == '_')) { + identifierLength++; + } + if (identifierLength > separator) { + truncateIdentifierToken(token, identifierLength); + token.kind = S_IDENTIFIER; + } else { + truncateIdentifierToken(token, separator); + token.kind = token.image.indexOf('.') >= 0 || token.image.indexOf('e') >= 0 + || token.image.indexOf('E') >= 0 ? S_DOUBLE : S_LONG; + } + } + + /** Splits a longest-match identifier without losing token positions. */ + private void truncateIdentifierToken(Token token, int length) { + input_stream.backup(token.image.length() - length); + token.image = token.image.substring(0, length); + token.endLine = input_stream.getEndLine(); + token.endColumn = input_stream.getEndColumn(); + } + + /** + * Consumes the body of a block comment after the opening delimiter has been matched, + * honouring nesting, up to and including the outermost closing delimiter. Then backs + * up 2 characters so the MULTI_LINE_COMMENT rule matches the closing delimiter and + * terminates the MORE chain. + */ + void consumeBlockCommentBody() { + int nesting = 1; + char prev = 0; + try { + while (nesting > 0) { + char c = input_stream.readChar(); + if (prev == '/' && c == '*') { + nesting++; + prev = 0; + } else if (prev == '*' && c == '/') { + nesting--; + prev = 0; + } else { + prev = c; + } + } + input_stream.backup(2); + } catch (java.io.IOException e) { + // Unterminated comment: leave the stream at EOF and let the token + // manager raise the lexical error from IN_BLOCK_COMMENT. + } + } +} + +SKIP: +{ + +} + +// Sentinel: start of non-reserved keyword range (for O(1) identifier checks) +SKIP: +{ + +} + +/** + * Non-reserved SQL keywords usable as unquoted identifiers. + * Tokens are declared inline to get consecutive kind values between + * MIN_NON_RESERVED_WORD and MAX_NON_RESERVED_WORD sentinels. + * + * The words are split over two productions: the lookahead routine JavaCC generates for one + * choice of all of them exceeds the JVM's 8000 byte limit for JIT compiled methods + * (-XX:HugeMethodLimit) and would always run interpreted. + */ +String NonReservedWord() : +{ String word; } +{ + ( word=NonReservedWordPart1() | word=NonReservedWordPart2() ) + { return word; } +} + +String NonReservedWordPart1() : { Token tk = null; } { ( - tk= + tk= + | tk= | tk= | tk= | tk= @@ -2250,9 +6196,11 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2270,6 +6218,8 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= + | tk= | tk= | tk= | tk= @@ -2313,6 +6263,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2325,9 +6276,13 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= + | tk= | tk= | tk= | tk= + | tk= + | tk= | tk= | tk= | tk= @@ -2336,6 +6291,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2344,6 +6300,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2352,6 +6309,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2386,6 +6344,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2396,7 +6355,15 @@ String NonReservedWord() : | tk= | tk= | tk= - | tk= + ) + { return tk.image; } +} + +String NonReservedWordPart2() : +{ Token tk = null; } +{ + ( + tk= | tk= | tk= | tk= @@ -2416,6 +6383,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2433,6 +6401,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2466,8 +6435,10 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2476,6 +6447,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2484,15 +6456,18 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2511,9 +6486,11 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2522,6 +6499,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2532,11 +6510,14 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2571,7 +6552,11 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= + | tk= | tk= + | tk= + | tk= | tk= | tk= | tk= @@ -2580,9 +6565,11 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2598,6 +6585,7 @@ String NonReservedWord() : | tk= | tk= | tk= + | tk= | tk= | tk= | tk= @@ -2605,17248 +6593,25335 @@ String NonReservedWord() : | tk= | tk= ) - { return tk.image; } + { return tk.image; } +} + +// Sentinel: end of non-reserved keyword range +SKIP: +{ + +} + +TOKEN: /* Reserved SQL Keywords and structural tokens */ +{ + +| +| +| +| +| +| +| +| /* H2 casewhen function */ +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| /* Salesforce SOQL */ +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| /* Salesforce SOQL */ +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| "> +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| +| | +| +| +| +| (" ")+ ) > +} + +TOKEN : /* Statement Separators */ +{ + +} + +TOKEN : /* Operators */ +{ + " ()* "="> +| "> +| )* "="> +| )* ">"> +| )* "="> +| +| +| +| +| +| +| >"> +| +| +| +| { + if (!input_stream.mySqlMinusSubstitution) { + input_stream.mySqlCommentError = "Unexpected control character"; + reportMySqlCommentError(); + } + matchedToken.kind = OP_MINUS; + matchedToken.image = "-"; + } +| { + reportMySqlCommentError(); + } +| +| "> +| +} + +TOKEN : /* Date/Time with time zones */ +{ + ()* ("(" ")")? ()* ( | ) (()+ )? ()+ "TIME" ()+ > +} + +TOKEN : /* Data Types */ +{ + // Dedicated keyword tokens (e.g. K_BINARY/K_CHAR) are consumed by DataType(). + // Repeating them here cannot match DATA_TYPE and causes unreachable-token warnings. + | | | + | | | | | | + | | | | | + | | | | + | | | + ) > + + | <#TYPE_BIT: "BISTRING"> + | <#TYPE_BLOB: "BLOB" | "BYTEA" | "VARBINARY" > + | <#TYPE_BOOLEAN: "BOOL" > + | <#TYPE_CLOB: "CLOB"> + | <#TYPE_ENUM: "ENUM" > + | <#TYPE_MAP: "MAP" > + | <#TYPE_DECIMAL: "DECIMAL" | "NUMBER" | "NUMERIC" > + | <#TYPE_TINYINT: "TINYINT" | "INT1" > + | <#TYPE_SMALLINT: "SMALLINT" | "INT2" | "SHORT" > + | <#TYPE_INTEGER: ( "INTEGER" | "INT" | "INT4" ) > + | <#TYPE_BIGINT: "BIGINT" | "INT8" | "LONG" > + | <#TYPE_HUGEINT: "HUGEINT" > + | <#TYPE_UTINYINT: "UTINYINT" > + | <#TYPE_USMALLINT: "USMALLINT" > + | <#TYPE_UINTEGER: "UINTEGER" > + | <#TYPE_UBIGINT: "UBIGINT" > + | <#TYPE_UHUGEINT: "UHUGEINT" > + | <#TYPE_REAL: "REAL" | "FLOAT4" | "FLOAT"> + | <#TYPE_DOUBLE: "DOUBLE" | "PRECISION" | "FLOAT8" | "FLOAT64"> + | <#TYPE_VARCHAR: "NVARCHAR" | "VARCHAR" | "NCHAR" | "BPCHAR" | "TEXT" | "STRING" | "VARYING"> + | <#TYPE_TIME: "TIMETZ" > + | <#TYPE_TIMESTAMP: "TIMESTAMP_NS" | "TIMESTAMP_MS" | "TIMESTAMP_S" > + + | <#TYPE_UUID: "UUID"> +} + +TOKEN : /* Numeric Constants */ +{ + < S_DOUBLE: (()? "." ( ["e","E"] (["+", "-"])? )? + | + "." (["e","E"] (["+", "-"])? )? + | + ["e","E"] (["+", "-"])? + )> { lexDigitSeparators(matchedToken); } + | < S_LONG: ( )+ ( "_" ( )+ )* > { lexDigitSeparators(matchedToken); } + | < #DIGIT: ["0" - "9"] > + | < S_HEX: ("X" ( (" ")* )* | "0x" ( )+ ) > + | < #QUOTED_HEX: "'" ( )* "'" > + | < #HEX_VALUE: ["0"-"9","A"-"F", " "] > + | < #HEX_DIGIT: ["0"-"9","A"-"F"] > +} + +SPECIAL_TOKEN: +{ + < LINE_COMMENT: ("--" | "//") (~["\r","\n"])*> +} + +// MySQL `#` line comment (#2499), flag-gated. Under +// Feature.allowHashLineComments the stream rewrites a token-start `#` to +// SimpleCharStream.HASH_SUBSTITUTION, a character no other rule starts with, +// so this production wins the match for every `#` form (`# c`, `#c`, `#>`, +// ...) without touching the identifier and JSON-operator lexing of the +// default mode. The action restores the `#` in the token image; unquoted +// identifiers end at their first `#` via the S_IDENTIFIER action, which +// re-lexes the remainder as this comment. +SPECIAL_TOKEN: +{ + < HASH_LINE_COMMENT: "\u0001" (~["\r","\n"])*> +} + +// Nested block comments: /* ... /* ... */ ... */ +// +// The body is consumed manually in the MORE action below because JavaCC 8 +// discards actions attached to SPECIAL_TOKEN and SKIP rules: it emits +// SkipLexicalActions() with an empty switch. Only TOKEN and MORE actions +// survive code generation. Do not move this action onto the rule below. +// +// consumeBlockCommentBody() scans past the whole comment, honouring nesting, +// then backs up 2 chars so re-matches the outermost "*/" +// and closes the MORE chain. No character past the comment is ever consumed, +// so there is nothing to push back and no dependency on what follows. +MORE: +{ + "/*" { consumeBlockCommentBody(); } : IN_BLOCK_COMMENT +} + + SPECIAL_TOKEN: +{ + : DEFAULT +} + +TOKEN: +{ + +| + + { + if (rowPatternContext != null && rowPatternContext.isInPattern()) { + truncateIdentifierToken(matchedToken, 1); + matchedToken.kind = S_IDENTIFIER; + } else { + consumeDollarQuotedToken(matchedToken, matchedToken.image); + } + } +| +// Bare `#` as a binary operator (PostgreSQL bitwise XOR / geometric +// intersection). Declared before to win the length tie on a +// lone `#`; `#temp`-style identifiers and `#>` / `#>>` keep their usual +// lexing by longest match (#1197, #1695). + +| + ()*) | "$" | ("$" ()*)> +{ + if (rowPatternContext != null && rowPatternContext.isInPattern()) { + int dollar = matchedToken.image.indexOf('$'); + if (dollar >= 0) { truncateIdentifierToken(matchedToken, Math.max(1, dollar)); } + } + if (matchedToken.image.charAt(0) == '$' + && Boolean.TRUE.equals(configuration.getValue(Feature.allowDollarQuotedStringTags))) { + String delimiter = StringValue.getDollarQuoteDelimiter(matchedToken.image); + if (delimiter != null) { + consumeDollarQuotedToken(matchedToken, delimiter); + } + } + // MySQL `#` line comments (#2499): under the flag an unquoted identifier + // ends at its first `#`, the rest of the line becomes a comment via the + // stream-level substitution (real MySQL reads `42#24` as `42` plus + // comment too). Quoted identifiers and strings keep their `#`. + // the wiring check keeps the flag lookup off the hot path of parses + // that never opted in (the stream is only wired through the feature + // consumers / withConfiguration); getValue avoids the String-based + // getAsBoolean roundtrip + if (matchedToken.kind == S_IDENTIFIER && input_stream.featureConfiguration != null + && Boolean.TRUE.equals(configuration.getValue(Feature.allowHashLineComments))) { + int hashIndex = matchedToken.image.indexOf('#'); + if (hashIndex > 0) { + truncateIdentifierToken(matchedToken, hashIndex); + } + } + // PostgreSQL does not allow # or @ in unquoted identifiers. Re-lex them as + // operators, including #>, #>>, #- and @?, when touching the left operand. + if (matchedToken.kind == S_IDENTIFIER + && AbstractJSqlParser.Dialect.POSTGRESQL.name().equals(configuration.getValue(Feature.dialect))) { + int hashIndex = matchedToken.image.indexOf('#'); + int atIndex = matchedToken.image.indexOf('@'); + int operatorIndex = hashIndex < 0 ? atIndex + : atIndex < 0 ? hashIndex : Math.min(hashIndex, atIndex); + if (operatorIndex > 0) { + truncateIdentifierToken(matchedToken, operatorIndex); + } else if (hashIndex == 0) { + truncateIdentifierToken(matchedToken, 1); + matchedToken.kind = S_HASH_OPERATOR; + } + } +} +| <#LETTER: + | | [ "#", "_" ] // Not SQL:2016 compliant! + > +| <#PART_LETTER_NO_DOLLAR: | | [ "#", "_" , "@" ] > +| <#PART_LETTER: | | [ "$" , "#", "_" , "@" ] > +| ()? > +{ + // same truncation as S_IDENTIFIER: `@@#name` ends at the `#` under + // allowHashLineComments, the rest of the line becomes the comment + // the wiring check keeps the flag lookup off the hot path of parses + // that never opted in (the stream is only wired through the feature + // consumers / withConfiguration); getValue avoids the String-based + // getAsBoolean roundtrip + if (input_stream.featureConfiguration != null + && Boolean.TRUE.equals(configuration.getValue(Feature.allowHashLineComments))) { + int hashIndex = matchedToken.image.indexOf('#'); + if (hashIndex > 0) { + truncateIdentifierToken(matchedToken, hashIndex); + } + } +} + +// Unicode characters and categories are defined here: https://www.unicode.org/Public/UNIDATA/UnicodeData.txt +// SQL:2016 states: +// An is any character in the Unicode General Category classes “Lu”, “Ll”, “Lt”, “Lm”, “Lo”, or “Nl”. +// An is U+00B7, “Middle Dot”, or any character in the Unicode General Category classes “Mn”, “Mc”, “Nd”, “Pc”, or “Cf”. + +// unicode_identifier_start +| <#UnicodeIdentifierStart: ("\u00B7" | | | | | | |) > +| <#Ll: ["a"-"z","µ","ß"-"ö","ø"-"ÿ","ā","ă","ą","ć","ĉ","ċ","č","ď","đ","ē","ĕ","ė","ę","ě","ĝ","ğ","ġ","ģ","ĥ","ħ","ĩ","ī","ĭ","į","ı","ij","ĵ","ķ"-"ĸ","ĺ","ļ","ľ","ŀ","ł","ń","ņ","ň"-"ʼn","ŋ","ō","ŏ","ő","œ","ŕ","ŗ","ř","ś","ŝ","ş","š","ţ","ť","ŧ","ũ","ū","ŭ","ů","ű","ų","ŵ","ŷ","ź","ż","ž"-"ƀ","ƃ","ƅ","ƈ","ƌ"-"ƍ","ƒ","ƕ","ƙ"-"ƛ","ƞ","ơ","ƣ","ƥ","ƨ","ƪ"-"ƫ","ƭ","ư","ƴ","ƶ","ƹ"-"ƺ","ƽ"-"ƿ","dž","lj","nj","ǎ","ǐ","ǒ","ǔ","ǖ","ǘ","ǚ","ǜ"-"ǝ","ǟ","ǡ","ǣ","ǥ","ǧ","ǩ","ǫ","ǭ","ǯ"-"ǰ","dz","ǵ","ǹ","ǻ","ǽ","ǿ","ȁ","ȃ","ȅ","ȇ","ȉ","ȋ","ȍ","ȏ","ȑ","ȓ","ȕ","ȗ","ș","ț","ȝ","ȟ","ȡ","ȣ","ȥ","ȧ","ȩ","ȫ","ȭ","ȯ","ȱ","ȳ"-"ȹ","ȼ","ȿ"-"ɀ","ɂ","ɇ","ɉ","ɋ","ɍ","ɏ"-"ʓ","ʕ"-"ʯ","ͱ","ͳ","ͷ","ͻ"-"ͽ","ΐ","ά"-"ώ","ϐ"-"ϑ","ϕ"-"ϗ","ϙ","ϛ","ϝ","ϟ","ϡ","ϣ","ϥ","ϧ","ϩ","ϫ","ϭ","ϯ"-"ϳ","ϵ","ϸ","ϻ"-"ϼ","а"-"џ","ѡ","ѣ","ѥ","ѧ","ѩ","ѫ","ѭ","ѯ","ѱ","ѳ","ѵ","ѷ","ѹ","ѻ","ѽ","ѿ","ҁ","ҋ","ҍ","ҏ","ґ","ғ","ҕ","җ","ҙ","қ","ҝ","ҟ","ҡ","ң","ҥ","ҧ","ҩ","ҫ","ҭ","ү","ұ","ҳ","ҵ","ҷ","ҹ","һ","ҽ","ҿ","ӂ","ӄ","ӆ","ӈ","ӊ","ӌ","ӎ"-"ӏ","ӑ","ӓ","ӕ","ӗ","ә","ӛ","ӝ","ӟ","ӡ","ӣ","ӥ","ӧ","ө","ӫ","ӭ","ӯ","ӱ","ӳ","ӵ","ӷ","ӹ","ӻ","ӽ","ӿ","ԁ","ԃ","ԅ","ԇ","ԉ","ԋ","ԍ","ԏ","ԑ","ԓ","ԕ","ԗ","ԙ","ԛ","ԝ","ԟ","ԡ","ԣ","ԥ","ԧ","ԩ","ԫ","ԭ","ԯ","ՠ"-"ֈ","ა"-"ჺ","ჽ"-"ჿ","ᏸ"-"ᏽ","ᲀ"-"ᲈ","ᴀ"-"ᴫ","ᵫ"-"ᵷ","ᵹ"-"ᶚ","ḁ","ḃ","ḅ","ḇ","ḉ","ḋ","ḍ","ḏ","ḑ","ḓ","ḕ","ḗ","ḙ","ḛ","ḝ","ḟ","ḡ","ḣ","ḥ","ḧ","ḩ","ḫ","ḭ","ḯ","ḱ","ḳ","ḵ","ḷ","ḹ","ḻ","ḽ","ḿ","ṁ","ṃ","ṅ","ṇ","ṉ","ṋ","ṍ","ṏ","ṑ","ṓ","ṕ","ṗ","ṙ","ṛ","ṝ","ṟ","ṡ","ṣ","ṥ","ṧ","ṩ","ṫ","ṭ","ṯ","ṱ","ṳ","ṵ","ṷ","ṹ","ṻ","ṽ","ṿ","ẁ","ẃ","ẅ","ẇ","ẉ","ẋ","ẍ","ẏ","ẑ","ẓ","ẕ"-"ẝ","ẟ","ạ","ả","ấ","ầ","ẩ","ẫ","ậ","ắ","ằ","ẳ","ẵ","ặ","ẹ","ẻ","ẽ","ế","ề","ể","ễ","ệ","ỉ","ị","ọ","ỏ","ố","ồ","ổ","ỗ","ộ","ớ","ờ","ở","ỡ","ợ","ụ","ủ","ứ","ừ","ử","ữ","ự","ỳ","ỵ","ỷ","ỹ","ỻ","ỽ","ỿ"-"ἇ","ἐ"-"ἕ","ἠ"-"ἧ","ἰ"-"ἷ","ὀ"-"ὅ","ὐ"-"ὗ","ὠ"-"ὧ","ὰ"-"ώ","ᾀ"-"ᾇ","ᾐ"-"ᾗ","ᾠ"-"ᾧ","ᾰ"-"ᾴ","ᾶ"-"ᾷ","ι","ῂ"-"ῄ","ῆ"-"ῇ","ῐ"-"ΐ","ῖ"-"ῗ","ῠ"-"ῧ","ῲ"-"ῴ","ῶ"-"ῷ","ℊ","ℎ"-"ℏ","ℓ","ℯ","ℴ","ℹ","ℼ"-"ℽ","ⅆ"-"ⅉ","ⅎ","ↄ","ⰰ"-"ⱟ","ⱡ","ⱥ"-"ⱦ","ⱨ","ⱪ","ⱬ","ⱱ","ⱳ"-"ⱴ","ⱶ"-"ⱻ","ⲁ","ⲃ","ⲅ","ⲇ","ⲉ","ⲋ","ⲍ","ⲏ","ⲑ","ⲓ","ⲕ","ⲗ","ⲙ","ⲛ","ⲝ","ⲟ","ⲡ","ⲣ","ⲥ","ⲧ","ⲩ","ⲫ","ⲭ","ⲯ","ⲱ","ⲳ","ⲵ","ⲷ","ⲹ","ⲻ","ⲽ","ⲿ","ⳁ","ⳃ","ⳅ","ⳇ","ⳉ","ⳋ","ⳍ","ⳏ","ⳑ","ⳓ","ⳕ","ⳗ","ⳙ","ⳛ","ⳝ","ⳟ","ⳡ","ⳣ"-"ⳤ","ⳬ","ⳮ","ⳳ","ⴀ"-"ⴥ","ⴧ","ⴭ","ꙁ","ꙃ","ꙅ","ꙇ","ꙉ","ꙋ","ꙍ","ꙏ","ꙑ","ꙓ","ꙕ","ꙗ","ꙙ","ꙛ","ꙝ","ꙟ","ꙡ","ꙣ","ꙥ","ꙧ","ꙩ","ꙫ","ꙭ","ꚁ","ꚃ","ꚅ","ꚇ","ꚉ","ꚋ","ꚍ","ꚏ","ꚑ","ꚓ","ꚕ","ꚗ","ꚙ","ꚛ","ꜣ","ꜥ","ꜧ","ꜩ","ꜫ","ꜭ","ꜯ"-"ꜱ","ꜳ","ꜵ","ꜷ","ꜹ","ꜻ","ꜽ","ꜿ","ꝁ","ꝃ","ꝅ","ꝇ","ꝉ","ꝋ","ꝍ","ꝏ","ꝑ","ꝓ","ꝕ","ꝗ","ꝙ","ꝛ","ꝝ","ꝟ","ꝡ","ꝣ","ꝥ","ꝧ","ꝩ","ꝫ","ꝭ","ꝯ","ꝱ"-"ꝸ","ꝺ","ꝼ","ꝿ","ꞁ","ꞃ","ꞅ","ꞇ","ꞌ","ꞎ","ꞑ","ꞓ"-"ꞕ","ꞗ","ꞙ","ꞛ","ꞝ","ꞟ","ꞡ","ꞣ","ꞥ","ꞧ","ꞩ","ꞯ","ꞵ","ꞷ","ꞹ","ꞻ","ꞽ","ꞿ","ꟁ","ꟃ","ꟈ","ꟊ","ꟑ","ꟓ","ꟕ","ꟗ","ꟙ","ꟶ","ꟺ","ꬰ"-"ꭚ","ꭠ"-"ꭨ","ꭰ"-"ꮿ","ff"-"st","ﬓ"-"ﬗ","a"-"z"]> +| <#Lm: ["ʰ"-"ˁ","ˆ"-"ˑ","ˠ"-"ˤ","ˬ","ˮ","ʹ","ͺ","ՙ","ـ","ۥ"-"ۦ","ߴ"-"ߵ","ߺ","ࠚ","ࠤ","ࠨ","ࣉ","ॱ","ๆ","ໆ","ჼ","ៗ","ᡃ","ᪧ","ᱸ"-"ᱽ","ᴬ"-"ᵪ","ᵸ","ᶛ"-"ᶿ","ⁱ","ⁿ","ₐ"-"ₜ","ⱼ"-"ⱽ","ⵯ","ⸯ","々","〱"-"〵","〻","ゝ"-"ゞ","ー"-"ヾ","ꀕ","ꓸ"-"ꓽ","ꘌ","ꙿ","ꚜ"-"ꚝ","ꜗ"-"ꜟ","ꝰ","ꞈ","ꟲ"-"ꟴ","ꟸ"-"ꟹ","ꧏ","ꧦ","ꩰ","ꫝ","ꫳ"-"ꫴ","ꭜ"-"ꭟ","ꭩ","ー","゙"-"゚"]> +| <#Lo: ["ª","º","ƻ","ǀ"-"ǃ","ʔ","א"-"ת","ׯ"-"ײ","ؠ"-"ؿ","ف"-"ي","ٮ"-"ٯ","ٱ"-"ۓ","ە","ۮ"-"ۯ","ۺ"-"ۼ","ۿ","ܐ","ܒ"-"ܯ","ݍ"-"ޥ","ޱ","ߊ"-"ߪ","ࠀ"-"ࠕ","ࡀ"-"ࡘ","ࡠ"-"ࡪ","ࡰ"-"ࢇ","ࢉ"-"ࢎ","ࢠ"-"ࣈ","ऄ"-"ह","ऽ","ॐ","क़"-"ॡ","ॲ"-"ঀ","অ"-"ঌ","এ"-"ঐ","ও"-"ন","প"-"র","ল","শ"-"হ","ঽ","ৎ","ড়"-"ঢ়","য়"-"ৡ","ৰ"-"ৱ","ৼ","ਅ"-"ਊ","ਏ"-"ਐ","ਓ"-"ਨ","ਪ"-"ਰ","ਲ"-"ਲ਼","ਵ"-"ਸ਼","ਸ"-"ਹ","ਖ਼"-"ੜ","ਫ਼","ੲ"-"ੴ","અ"-"ઍ","એ"-"ઑ","ઓ"-"ન","પ"-"ર","લ"-"ળ","વ"-"હ","ઽ","ૐ","ૠ"-"ૡ","ૹ","ଅ"-"ଌ","ଏ"-"ଐ","ଓ"-"ନ","ପ"-"ର","ଲ"-"ଳ","ଵ"-"ହ","ଽ","ଡ଼"-"ଢ଼","ୟ"-"ୡ","ୱ","ஃ","அ"-"ஊ","எ"-"ஐ","ஒ"-"க","ங"-"ச","ஜ","ஞ"-"ட","ண"-"த","ந"-"ப","ம"-"ஹ","ௐ","అ"-"ఌ","ఎ"-"ఐ","ఒ"-"న","ప"-"హ","ఽ","ౘ"-"ౚ","ౝ","ౠ"-"ౡ","ಀ","ಅ"-"ಌ","ಎ"-"ಐ","ಒ"-"ನ","ಪ"-"ಳ","ವ"-"ಹ","ಽ","ೝ"-"ೞ","ೠ"-"ೡ","ೱ"-"ೲ","ഄ"-"ഌ","എ"-"ഐ","ഒ"-"ഺ","ഽ","ൎ","ൔ"-"ൖ","ൟ"-"ൡ","ൺ"-"ൿ","අ"-"ඖ","ක"-"න","ඳ"-"ර","ල","ව"-"ෆ","ก"-"ะ","า"-"ำ","เ"-"ๅ","ກ"-"ຂ","ຄ","ຆ"-"ຊ","ຌ"-"ຣ","ລ","ວ"-"ະ","າ"-"ຳ","ຽ","ເ"-"ໄ","ໜ"-"ໟ","ༀ","ཀ"-"ཇ","ཉ"-"ཬ","ྈ"-"ྌ","က"-"ဪ","ဿ","ၐ"-"ၕ","ၚ"-"ၝ","ၡ","ၥ"-"ၦ","ၮ"-"ၰ","ၵ"-"ႁ","ႎ","ᄀ"-"ቈ","ቊ"-"ቍ","ቐ"-"ቖ","ቘ","ቚ"-"ቝ","በ"-"ኈ","ኊ"-"ኍ","ነ"-"ኰ","ኲ"-"ኵ","ኸ"-"ኾ","ዀ","ዂ"-"ዅ","ወ"-"ዖ","ዘ"-"ጐ","ጒ"-"ጕ","ጘ"-"ፚ","ᎀ"-"ᎏ","ᐁ"-"ᙬ","ᙯ"-"ᙿ","ᚁ"-"ᚚ","ᚠ"-"ᛪ","ᛱ"-"ᛸ","ᜀ"-"ᜑ","ᜟ"-"ᜱ","ᝀ"-"ᝑ","ᝠ"-"ᝬ","ᝮ"-"ᝰ","ក"-"ឳ","ៜ","ᠠ"-"ᡂ","ᡄ"-"ᡸ","ᢀ"-"ᢄ","ᢇ"-"ᢨ","ᢪ","ᢰ"-"ᣵ","ᤀ"-"ᤞ","ᥐ"-"ᥭ","ᥰ"-"ᥴ","ᦀ"-"ᦫ","ᦰ"-"ᧉ","ᨀ"-"ᨖ","ᨠ"-"ᩔ","ᬅ"-"ᬳ","ᭅ"-"ᭌ","ᮃ"-"ᮠ","ᮮ"-"ᮯ","ᮺ"-"ᯥ","ᰀ"-"ᰣ","ᱍ"-"ᱏ","ᱚ"-"ᱷ","ᳩ"-"ᳬ","ᳮ"-"ᳳ","ᳵ"-"ᳶ","ᳺ","ℵ"-"ℸ","ⴰ"-"ⵧ","ⶀ"-"ⶖ","ⶠ"-"ⶦ","ⶨ"-"ⶮ","ⶰ"-"ⶶ","ⶸ"-"ⶾ","ⷀ"-"ⷆ","ⷈ"-"ⷎ","ⷐ"-"ⷖ","ⷘ"-"ⷞ","〆","〼","ぁ"-"ゖ","ゟ","ァ"-"ヺ","ヿ","ㄅ"-"ㄯ","ㄱ"-"ㆎ","ㆠ"-"ㆿ","ㇰ"-"ㇿ","䶿","鿿"-"ꀔ","ꀖ"-"ꒌ","ꓐ"-"ꓷ","ꔀ"-"ꘋ","ꘐ"-"ꘟ","ꘪ"-"ꘫ","ꙮ","ꚠ"-"ꛥ","ꞏ","ꟷ","ꟻ"-"ꠁ","ꠃ"-"ꠅ","ꠇ"-"ꠊ","ꠌ"-"ꠢ","ꡀ"-"ꡳ","ꢂ"-"ꢳ","ꣲ"-"ꣷ","ꣻ","ꣽ"-"ꣾ","ꤊ"-"ꤥ","ꤰ"-"ꥆ","ꥠ"-"ꥼ","ꦄ"-"ꦲ","ꧠ"-"ꧤ","ꧧ"-"ꧯ","ꧺ"-"ꧾ","ꨀ"-"ꨨ","ꩀ"-"ꩂ","ꩄ"-"ꩋ","ꩠ"-"ꩯ","ꩱ"-"ꩶ","ꩺ","ꩾ"-"ꪯ","ꪱ","ꪵ"-"ꪶ","ꪹ"-"ꪽ","ꫀ","ꫂ","ꫛ"-"ꫜ","ꫠ"-"ꫪ","ꫲ","ꬁ"-"ꬆ","ꬉ"-"ꬎ","ꬑ"-"ꬖ","ꬠ"-"ꬦ","ꬨ"-"ꬮ","ꯀ"-"ꯢ","힣","ힰ"-"ퟆ","ퟋ"-"ퟻ","豈"-"舘","並"-"龎","יִ","ײַ"-"ﬨ","שׁ"-"זּ","טּ"-"לּ","מּ","נּ"-"סּ","ףּ"-"פּ","צּ"-"ﮱ","ﯓ"-"ﴽ","ﵐ"-"ﶏ","ﶒ"-"ﷇ","ﷰ"-"ﷻ","ﹰ"-"ﹴ","ﹶ"-"ﻼ","ヲ"-"ッ","ア"-"ン","ᅠ"-"ᄒ","ᅡ"-"ᅦ","ᅧ"-"ᅬ","ᅭ"-"ᅲ","ᅳ"-"ᅵ"]> +| <#Lt: ["Dž","Lj","Nj","Dz","ᾈ"-"ᾏ","ᾘ"-"ᾟ","ᾨ"-"ᾯ","ᾼ","ῌ","ῼ"]> +| <#Lu: ["A"-"Z","À"-"Ö","Ø"-"Þ","Ā","Ă","Ą","Ć","Ĉ","Ċ","Č","Ď","Đ","Ē","Ĕ","Ė","Ę","Ě","Ĝ","Ğ","Ġ","Ģ","Ĥ","Ħ","Ĩ","Ī","Ĭ","Į","İ","IJ","Ĵ","Ķ","Ĺ","Ļ","Ľ","Ŀ","Ł","Ń","Ņ","Ň","Ŋ","Ō","Ŏ","Ő","Œ","Ŕ","Ŗ","Ř","Ś","Ŝ","Ş","Š","Ţ","Ť","Ŧ","Ũ","Ū","Ŭ","Ů","Ű","Ų","Ŵ","Ŷ","Ÿ"-"Ź","Ż","Ž","Ɓ"-"Ƃ","Ƅ","Ɔ"-"Ƈ","Ɖ"-"Ƌ","Ǝ"-"Ƒ","Ɠ"-"Ɣ","Ɩ"-"Ƙ","Ɯ"-"Ɲ","Ɵ"-"Ơ","Ƣ","Ƥ","Ʀ"-"Ƨ","Ʃ","Ƭ","Ʈ"-"Ư","Ʊ"-"Ƴ","Ƶ","Ʒ"-"Ƹ","Ƽ","DŽ","LJ","NJ","Ǎ","Ǐ","Ǒ","Ǔ","Ǖ","Ǘ","Ǚ","Ǜ","Ǟ","Ǡ","Ǣ","Ǥ","Ǧ","Ǩ","Ǫ","Ǭ","Ǯ","DZ","Ǵ","Ƕ"-"Ǹ","Ǻ","Ǽ","Ǿ","Ȁ","Ȃ","Ȅ","Ȇ","Ȉ","Ȋ","Ȍ","Ȏ","Ȑ","Ȓ","Ȕ","Ȗ","Ș","Ț","Ȝ","Ȟ","Ƞ","Ȣ","Ȥ","Ȧ","Ȩ","Ȫ","Ȭ","Ȯ","Ȱ","Ȳ","Ⱥ"-"Ȼ","Ƚ"-"Ⱦ","Ɂ","Ƀ"-"Ɇ","Ɉ","Ɋ","Ɍ","Ɏ","Ͱ","Ͳ","Ͷ","Ϳ","Ά","Έ"-"Ί","Ό","Ύ"-"Ώ","Α"-"Ρ","Σ"-"Ϋ","Ϗ","ϒ"-"ϔ","Ϙ","Ϛ","Ϝ","Ϟ","Ϡ","Ϣ","Ϥ","Ϧ","Ϩ","Ϫ","Ϭ","Ϯ","ϴ","Ϸ","Ϲ"-"Ϻ","Ͻ"-"Я","Ѡ","Ѣ","Ѥ","Ѧ","Ѩ","Ѫ","Ѭ","Ѯ","Ѱ","Ѳ","Ѵ","Ѷ","Ѹ","Ѻ","Ѽ","Ѿ","Ҁ","Ҋ","Ҍ","Ҏ","Ґ","Ғ","Ҕ","Җ","Ҙ","Қ","Ҝ","Ҟ","Ҡ","Ң","Ҥ","Ҧ","Ҩ","Ҫ","Ҭ","Ү","Ұ","Ҳ","Ҵ","Ҷ","Ҹ","Һ","Ҽ","Ҿ","Ӏ"-"Ӂ","Ӄ","Ӆ","Ӈ","Ӊ","Ӌ","Ӎ","Ӑ","Ӓ","Ӕ","Ӗ","Ә","Ӛ","Ӝ","Ӟ","Ӡ","Ӣ","Ӥ","Ӧ","Ө","Ӫ","Ӭ","Ӯ","Ӱ","Ӳ","Ӵ","Ӷ","Ӹ","Ӻ","Ӽ","Ӿ","Ԁ","Ԃ","Ԅ","Ԇ","Ԉ","Ԋ","Ԍ","Ԏ","Ԑ","Ԓ","Ԕ","Ԗ","Ԙ","Ԛ","Ԝ","Ԟ","Ԡ","Ԣ","Ԥ","Ԧ","Ԩ","Ԫ","Ԭ","Ԯ","Ա"-"Ֆ","Ⴀ"-"Ⴥ","Ⴧ","Ⴭ","Ꭰ"-"Ᏽ","Ა"-"Ჺ","Ჽ"-"Ჿ","Ḁ","Ḃ","Ḅ","Ḇ","Ḉ","Ḋ","Ḍ","Ḏ","Ḑ","Ḓ","Ḕ","Ḗ","Ḙ","Ḛ","Ḝ","Ḟ","Ḡ","Ḣ","Ḥ","Ḧ","Ḩ","Ḫ","Ḭ","Ḯ","Ḱ","Ḳ","Ḵ","Ḷ","Ḹ","Ḻ","Ḽ","Ḿ","Ṁ","Ṃ","Ṅ","Ṇ","Ṉ","Ṋ","Ṍ","Ṏ","Ṑ","Ṓ","Ṕ","Ṗ","Ṙ","Ṛ","Ṝ","Ṟ","Ṡ","Ṣ","Ṥ","Ṧ","Ṩ","Ṫ","Ṭ","Ṯ","Ṱ","Ṳ","Ṵ","Ṷ","Ṹ","Ṻ","Ṽ","Ṿ","Ẁ","Ẃ","Ẅ","Ẇ","Ẉ","Ẋ","Ẍ","Ẏ","Ẑ","Ẓ","Ẕ","ẞ","Ạ","Ả","Ấ","Ầ","Ẩ","Ẫ","Ậ","Ắ","Ằ","Ẳ","Ẵ","Ặ","Ẹ","Ẻ","Ẽ","Ế","Ề","Ể","Ễ","Ệ","Ỉ","Ị","Ọ","Ỏ","Ố","Ồ","Ổ","Ỗ","Ộ","Ớ","Ờ","Ở","Ỡ","Ợ","Ụ","Ủ","Ứ","Ừ","Ử","Ữ","Ự","Ỳ","Ỵ","Ỷ","Ỹ","Ỻ","Ỽ","Ỿ","Ἀ"-"Ἇ","Ἐ"-"Ἕ","Ἠ"-"Ἧ","Ἰ"-"Ἷ","Ὀ"-"Ὅ","Ὑ","Ὓ","Ὕ","Ὗ","Ὠ"-"Ὧ","Ᾰ"-"Ά","Ὲ"-"Ή","Ῐ"-"Ί","Ῠ"-"Ῥ","Ὸ"-"Ώ","ℂ","ℇ","ℋ"-"ℍ","ℐ"-"ℒ","ℕ","ℙ"-"ℝ","ℤ","Ω","ℨ","K"-"ℭ","ℰ"-"ℳ","ℾ"-"ℿ","ⅅ","Ↄ","Ⰰ"-"Ⱟ","Ⱡ","Ɫ"-"Ɽ","Ⱨ","Ⱪ","Ⱬ","Ɑ"-"Ɒ","Ⱳ","Ⱶ","Ȿ"-"Ⲁ","Ⲃ","Ⲅ","Ⲇ","Ⲉ","Ⲋ","Ⲍ","Ⲏ","Ⲑ","Ⲓ","Ⲕ","Ⲗ","Ⲙ","Ⲛ","Ⲝ","Ⲟ","Ⲡ","Ⲣ","Ⲥ","Ⲧ","Ⲩ","Ⲫ","Ⲭ","Ⲯ","Ⲱ","Ⲳ","Ⲵ","Ⲷ","Ⲹ","Ⲻ","Ⲽ","Ⲿ","Ⳁ","Ⳃ","Ⳅ","Ⳇ","Ⳉ","Ⳋ","Ⳍ","Ⳏ","Ⳑ","Ⳓ","Ⳕ","Ⳗ","Ⳙ","Ⳛ","Ⳝ","Ⳟ","Ⳡ","Ⳣ","Ⳬ","Ⳮ","Ⳳ","Ꙁ","Ꙃ","Ꙅ","Ꙇ","Ꙉ","Ꙋ","Ꙍ","Ꙏ","Ꙑ","Ꙓ","Ꙕ","Ꙗ","Ꙙ","Ꙛ","Ꙝ","Ꙟ","Ꙡ","Ꙣ","Ꙥ","Ꙧ","Ꙩ","Ꙫ","Ꙭ","Ꚁ","Ꚃ","Ꚅ","Ꚇ","Ꚉ","Ꚋ","Ꚍ","Ꚏ","Ꚑ","Ꚓ","Ꚕ","Ꚗ","Ꚙ","Ꚛ","Ꜣ","Ꜥ","Ꜧ","Ꜩ","Ꜫ","Ꜭ","Ꜯ","Ꜳ","Ꜵ","Ꜷ","Ꜹ","Ꜻ","Ꜽ","Ꜿ","Ꝁ","Ꝃ","Ꝅ","Ꝇ","Ꝉ","Ꝋ","Ꝍ","Ꝏ","Ꝑ","Ꝓ","Ꝕ","Ꝗ","Ꝙ","Ꝛ","Ꝝ","Ꝟ","Ꝡ","Ꝣ","Ꝥ","Ꝧ","Ꝩ","Ꝫ","Ꝭ","Ꝯ","Ꝺ","Ꝼ","Ᵹ"-"Ꝿ","Ꞁ","Ꞃ","Ꞅ","Ꞇ","Ꞌ","Ɥ","Ꞑ","Ꞓ","Ꞗ","Ꞙ","Ꞛ","Ꞝ","Ꞟ","Ꞡ","Ꞣ","Ꞥ","Ꞧ","Ꞩ","Ɦ"-"Ɪ","Ʞ"-"Ꞵ","Ꞷ","Ꞹ","Ꞻ","Ꞽ","Ꞿ","Ꟁ","Ꟃ","Ꞔ"-"Ꟈ","Ꟊ","Ꟑ","Ꟗ","Ꟙ","Ꟶ","A"-"Z"]> +| <#Nl: ["ᛮ"-"ᛰ","Ⅰ"-"ↂ","ↅ"-"ↈ","〇","〡"-"〩","〸"-"〺","ꛦ"-"ꛯ"]> + +// unicode_identifier_extend +| <#UnicodeIdentifierExtend: (|||||)> +| <#Cf: ["­","؀"-"؅","؜","۝","܏","࢐"-"࢑","࣢","᠎","​"-"‏","‪"-"‮","⁠"-"⁤","⁦"-"","",""-""]> +| <#Mc: ["ः","ऻ","ा"-"ी","ॉ"-"ौ","ॎ"-"ॏ","ং"-"ঃ","া"-"ী","ে"-"ৈ","ো"-"ৌ","ৗ","ਃ","ਾ"-"ੀ","ઃ","ા"-"ી","ૉ","ો"-"ૌ","ଂ"-"ଃ","ା","ୀ","େ"-"ୈ","ୋ"-"ୌ","ୗ","ா"-"ி","ு"-"ூ","ெ"-"ை","ொ"-"ௌ","ௗ","ఁ"-"ః","ు"-"ౄ","ಂ"-"ಃ","ಾ","ೀ"-"ೄ","ೇ"-"ೈ","ೊ"-"ೋ","ೕ"-"ೖ","ೳ","ം"-"ഃ","ാ"-"ീ","െ"-"ൈ","ൊ"-"ൌ","ൗ","ං"-"ඃ","ා"-"ෑ","ෘ"-"ෟ","ෲ"-"ෳ","༾"-"༿","ཿ","ါ"-"ာ","ေ","း","ျ"-"ြ","ၖ"-"ၗ","ၢ"-"ၤ","ၧ"-"ၭ","ႃ"-"ႄ","ႇ"-"ႌ","ႏ","ႚ"-"ႜ","᜕","᜴","ា","ើ"-"ៅ","ះ"-"ៈ","ᤣ"-"ᤦ","ᤩ"-"ᤫ","ᤰ"-"ᤱ","ᤳ"-"ᤸ","ᨙ"-"ᨚ","ᩕ","ᩗ","ᩡ","ᩣ"-"ᩤ","ᩭ"-"ᩲ","ᬄ","ᬵ","ᬻ","ᬽ"-"ᭁ","ᭃ"-"᭄","ᮂ","ᮡ","ᮦ"-"ᮧ","᮪","ᯧ","ᯪ"-"ᯬ","ᯮ","᯲"-"᯳","ᰤ"-"ᰫ","ᰴ"-"ᰵ","᳡","᳷","〮"-"〯","ꠣ"-"ꠤ","ꠧ","ꢀ"-"ꢁ","ꢴ"-"ꣃ","ꥒ"-"꥓","ꦃ","ꦴ"-"ꦵ","ꦺ"-"ꦻ","ꦾ"-"꧀","ꨯ"-"ꨰ","ꨳ"-"ꨴ","ꩍ","ꩻ","ꩽ","ꫫ","ꫮ"-"ꫯ","ꫵ","ꯣ"-"ꯤ","ꯦ"-"ꯧ","ꯩ"-"ꯪ","꯬"]> +| <#Mn: ["̀"-"ͯ","҃"-"҇","֑"-"ֽ","ֿ","ׁ"-"ׂ","ׄ"-"ׅ","ׇ","ؐ"-"ؚ","ً"-"ٟ","ٰ","ۖ"-"ۜ","۟"-"ۤ","ۧ"-"ۨ","۪"-"ۭ","ܑ","ܰ"-"݊","ަ"-"ް","߫"-"߳","߽","ࠖ"-"࠙","ࠛ"-"ࠣ","ࠥ"-"ࠧ","ࠩ"-"࠭","࡙"-"࡛","࢘"-"࢟","࣊"-"࣡","ࣣ"-"ं","ऺ","़","ु"-"ै","्","॑"-"ॗ","ॢ"-"ॣ","ঁ","়","ু"-"ৄ","্","ৢ"-"ৣ","৾","ਁ"-"ਂ","਼","ੁ"-"ੂ","ੇ"-"ੈ","ੋ"-"੍","ੑ","ੰ"-"ੱ","ੵ","ઁ"-"ં","઼","ુ"-"ૅ","ે"-"ૈ","્","ૢ"-"ૣ","ૺ"-"૿","ଁ","଼","ି","ୁ"-"ୄ","୍","୕"-"ୖ","ୢ"-"ୣ","ஂ","ீ","்","ఀ","ఄ","఼","ా"-"ీ","ె"-"ై","ొ"-"్","ౕ"-"ౖ","ౢ"-"ౣ","ಁ","಼","ಿ","ೆ","ೌ"-"್","ೢ"-"ೣ","ഀ"-"ഁ","഻"-"഼","ു"-"ൄ","്","ൢ"-"ൣ","ඁ","්","ි"-"ු","ූ","ั","ิ"-"ฺ","็"-"๎","ັ","ິ"-"ຼ","່"-"໎","༘"-"༙","༵","༷","༹","ཱ"-"ཾ","ྀ"-"྄","྆"-"྇","ྍ"-"ྗ","ྙ"-"ྼ","࿆","ိ"-"ူ","ဲ"-"့","္"-"်","ွ"-"ှ","ၘ"-"ၙ","ၞ"-"ၠ","ၱ"-"ၴ","ႂ","ႅ"-"ႆ","ႍ","ႝ","፝"-"፟","ᜒ"-"᜔","ᜲ"-"ᜳ","ᝒ"-"ᝓ","ᝲ"-"ᝳ","឴"-"឵","ិ"-"ួ","ំ","៉"-"៓","៝","᠋"-"᠍","᠏","ᢅ"-"ᢆ","ᢩ","ᤠ"-"ᤢ","ᤧ"-"ᤨ","ᤲ","᤹"-"᤻","ᨗ"-"ᨘ","ᨛ","ᩖ","ᩘ"-"ᩞ","᩠","ᩢ","ᩥ"-"ᩬ","ᩳ"-"᩼","᩿","᪰"-"᪽","ᪿ"-"ᫎ","ᬀ"-"ᬃ","᬴","ᬶ"-"ᬺ","ᬼ","ᭂ","᭫"-"᭳","ᮀ"-"ᮁ","ᮢ"-"ᮥ","ᮨ"-"ᮩ","᮫"-"ᮭ","᯦","ᯨ"-"ᯩ","ᯭ","ᯯ"-"ᯱ","ᰬ"-"ᰳ","ᰶ"-"᰷","᳐"-"᳒","᳔"-"᳠","᳢"-"᳨","᳭","᳴","᳸"-"᳹","᷀"-"᷿","⃐"-"⃜","⃡","⃥"-"⃰","⳯"-"⳱","⵿","ⷠ"-"ⷿ","〪"-"〭","゙"-"゚","꙯","ꙴ"-"꙽","ꚞ"-"ꚟ","꛰"-"꛱","ꠂ","꠆","ꠋ","ꠥ"-"ꠦ","꠬","꣄"-"ꣅ","꣠"-"꣱","ꣿ","ꤦ"-"꤭","ꥇ"-"ꥑ","ꦀ"-"ꦂ","꦳","ꦶ"-"ꦹ","ꦼ"-"ꦽ","ꧥ","ꨩ"-"ꨮ","ꨱ"-"ꨲ","ꨵ"-"ꨶ","ꩃ","ꩌ","ꩼ","ꪰ","ꪲ"-"ꪴ","ꪷ"-"ꪸ","ꪾ"-"꪿","꫁","ꫬ"-"ꫭ","꫶","ꯥ","ꯨ","꯭","ﬞ","︀"-"️","︠"-"︯"]> +| <#Nd: ["0"-"9","٠"-"٩","۰"-"۹","߀"-"߉","०"-"९","০"-"৯","੦"-"੯","૦"-"૯","୦"-"୯","௦"-"௯","౦"-"౯","೦"-"೯","൦"-"൯","෦"-"෯","๐"-"๙","໐"-"໙","༠"-"༩","၀"-"၉","႐"-"႙","០"-"៩","᠐"-"᠙","᥆"-"᥏","᧐"-"᧙","᪀"-"᪉","᪐"-"᪙","᭐"-"᭙","᮰"-"᮹","᱀"-"᱉","᱐"-"᱙","꘠"-"꘩","꣐"-"꣙","꤀"-"꤉","꧐"-"꧙","꧰"-"꧹","꩐"-"꩙","꯰"-"꯹","0"-"9"]> +| <#Pc: ["‿"-"⁀","⁔","︳"-"︴","﹍"-"﹏","_"]> + +// CJK Unified Ideographs block according to https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) +| <#CJK: ["\uAC00"-"\uD7A3", "\u4E00"-"\u9FFF"]> + +| < S_CHAR_LITERAL: ( + (["U","E","N","R","B"]|"RB"|"_utf8")? + ( + // Backslash escapes and doubled quotes; trimmed below to the rules in effect + ("'" ( "\\" ~[] | "''" | ~["'", "\\"] )* "'") | ("'" ("''" | ~["'"])* "'") + // Alternative Oracle Escape Modes, up to the first closing delimiter + // followed by a quote: a body cannot contain that pair, so the longest + // match stops there and cannot run on to a later literal + | ("q'{" ( ~["}"] | ("}")+ ~["}", "'"] )* ("}")+ "'") + | ("q'(" ( ~[")"] | (")")+ ~[")", "'"] )* (")")+ "'") + | ("q'[" ( ~["]"] | ("]")+ ~["]", "'"] )* ("]")+ "'") + | ("q''" ( ~["'"] | "'" ~["'"] )* "''") + // | ("q'\\" (~[])* "\\'") <--- Does not work + ) + // PostgreSQL Unicode escape string with an optional UESCAPE clause, see + // lexUnicodeEscapeString(). Backslashes do not escape its quotes. + | "U&'" ("''" | ~["'"])* "'" + ( ([" ", "\t", "\r", "\n"])* "UESCAPE" ([" ", "\t", "\r", "\n"])* "'" ~["'"] "'" )? + // Databricks raw literal, see below + | "R\"" (~["\""])* "\"" + ) > + { + // A Databricks raw literal R'...' or R"..." has no escapes at all: it ends at the first + // closing quote, also after a backslash. + boolean databricks = AbstractJSqlParser.Dialect.DATABRICKS.name().equals(configuration.getValue(Feature.dialect)); + if (matchedToken.image.regionMatches(true, 0, "R\"", 0, 2)) { + // Other dialects read the identifier R before a quoted name + if (!databricks) { + truncateIdentifierToken(matchedToken, 1); + matchedToken.kind = S_IDENTIFIER; + } + } else { + // The longest match may run past the closing quote of the active rules. A backslash + // escapes the next character only with backslash escapes or in a PostgreSQL E'' string; + // otherwise the literal ends at the first quote that is not doubled, so LIKE ... ESCAPE '\\' + // still works. + boolean backslashEscapes = configuration.getAsBoolean(Feature.allowBackslashEscapeCharacter) + || (AbstractJSqlParser.Dialect.POSTGRESQL.name().equals(configuration.getValue(Feature.dialect)) + && matchedToken.image.regionMatches(true, 0, "E'", 0, 2)); + int end = databricks && matchedToken.image.regionMatches(true, 0, "R'", 0, 2) + ? matchedToken.image.indexOf('\'', 2) + 1 + : closingSingleQuote(matchedToken.image, backslashEscapes); + if (end > 0 && end < matchedToken.image.length()) { + matchedToken.image = image.substring(0, end); + input_stream.backup(image.length() - end); + } + if (isUnicodeEscapeString(matchedToken.image)) { + lexUnicodeEscapeString(matchedToken); + } + } + } +| < S_QUOTED_IDENTIFIER: "\"" ( "\"\"" | ~["\""])* "\"" + // MySQL double-quoted string with backslash escapes; trimmed below when not enabled + | "\"" ( "\"\"" | "\\" ~[] | ~["\"","\\"])* "\"" + | ("`" ("``" | ~["`"])* "`") | ( "[" (~["]"])* "]" ) > + { + if ( matchedToken.image.charAt(0) == '"' ) { + // Both alternatives above compete for the longest match. Keep the closing quote of + // the active quoting rules: a backslash escapes the next character only in + // double-quoted strings with backslash escapes, as in MySQL. + int end = closingQuote(matchedToken.image, 0, '"', + configuration.getAsBoolean(Feature.allowDoubleQuotedStrings) + && configuration.getAsBoolean(Feature.allowBackslashEscapeCharacter)); + if (end > 0 && end < matchedToken.image.length()) { + matchedToken.image = image.substring(0, end); + input_stream.backup(image.length() - end); + } + } + if ( !configuration.getAsBoolean(Feature.allowSquareBracketQuotation) + && matchedToken.image.charAt(0) == '[' ) { + + matchedToken.image = "["; + // `squaredBracketOpenIndex` defined in TokenManagerDeclaration above + matchedToken.kind = squaredBracketOpenIndex; + input_stream.backup(image.length() - 1); + } + if ( configuration.getAsBoolean(Feature.allowDoubleQuotedStrings) + && matchedToken.image.charAt(0) == '"' ) { + // `charLiteralIndex` defined in TokenManagerDeclaration above + matchedToken.kind = charLiteralIndex; + } + } +} + +/** + * Parses identifiers including standard SQL identifiers, quoted identifiers, and specific keywords. + * + * This is used in cases where certain SQL keywords (like NAME, NEXT, VALUE, etc.) can appear + * as identifiers (e.g., table names, column names) depending on the SQL dialect or context. + * + * Supported tokens: + * - : Standard unquoted SQL identifier + * - : Quoted identifier (e.g., `identifier` or "identifier") + * - , , , , , , : Specific keywords treated as identifiers + * + * @return Token representing the identifier or keyword used as identifier + */ +Token KeywordOrIdentifier(): +{ + Token tk; +} +{ + ( + tk = + | tk = + | tk = + | tk = + | tk = + | tk = + | tk = + | tk = + | tk = + | tk = + | tk = + ) + { return tk; } +} + +Statement Statement() #Statement: +{ + IfElseStatement ifElseStatement = null; + Statement stm = null; + Statement stm2 = null; + Expression condition; + Token ifFirst = null; +} +{ + ( + try { + ( + { ifFirst = getToken(0); } condition=Condition() + ( stm = SingleStatement() | stm = Block() ) { ifElseStatement = new IfElseStatement(condition, stm); linkAST(ifElseStatement, ifFirst); } + [ LOOKAHEAD(2) + [ { ifElseStatement.setUsingSemicolonForIfStatement(true); } ] + ( stm2 = SingleStatement() | stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); widen(ifElseStatement, null, getToken(0)); } + ] + + [ + LOOKAHEAD(2) + { if (stm2!=null) + ifElseStatement.setUsingSemicolonForElseStatement(true); + else if (ifElseStatement!=null) + ifElseStatement.setUsingSemicolonForIfStatement(true); + widen(ifElseStatement, null, getToken(0)); + } + ] + + ) + | + ( + (stm = SingleStatement() + | stm = Block()) + + ( )* + ) + | + LOOKAHEAD( { stm==null && getAsBoolean(Feature.allowUnsupportedStatements) && isOpaqueStatementAhead() } ) + stm = UnsupportedStatement() ( )* + } catch (ParseException ex) { + if ( errorRecovery ) { + ifElseStatement = null; + parseErrors.add(ex); + error_skipto(ST_SEMICOLON); + stm = null; + } else { + throw ex; + } + } + + ) + + { + token_source.positionTrailingComments(); + return ifElseStatement!=null ? ifElseStatement : stm; + } +} + +Statement SingleStatement() : +{ + Statement stm = null; + List> with = null; + Token first = getToken(1); +} +{ + ( + LOOKAHEAD({ Dialect.ORACLE.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_DECLARE || getToken(1).kind == K_BEGIN) }) + stm = OracleBlock() + | + LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && ((getToken(1).kind == K_ALTER && (getToken(2).kind == K_FUNCTION || getToken(2).kind == K_PROCEDURE)) + || (getToken(1).kind == K_CREATE && (getToken(2).kind == K_FUNCTION || getToken(2).kind == K_PROCEDURE + || (getToken(2).kind == K_OR && getToken(3).kind == K_ALTER + && (getToken(4).kind == K_FUNCTION || getToken(4).kind == K_PROCEDURE))))) }) + stm = SqlServerRoutine() + | + LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_INSERT && "BULK".equalsIgnoreCase(getToken(2).image) }) + stm = InsertBulk() + | + LOOKAHEAD(3) ( + [ LOOKAHEAD(2) with=WithList() ] + ( + stm = SelectWithWithItems( with ) { if (with != null) { widen(stm, first, null); } } + | + stm = InsertWithWithItems( with ) + | + stm = UpdateWithWithItems( with ) + | + stm = DeleteWithWithItems( with ) + | + stm = Merge( with ) + ) + ) + | + stm = Select() + | + // SQLite's INSERT OR takes the plain Insert() production, so that it keeps + // ON CONFLICT, RETURNING, DEFAULT VALUES and the table aliases; REPLACE stays an Upsert + LOOKAHEAD({ isInsertOrPrefixAhead() }) stm = Insert() + | + LOOKAHEAD(3) stm = Upsert() + | + LOOKAHEAD({ isResourceGroupStatementAhead() }) stm = ResourceGroupStatement() + | + LOOKAHEAD(2) stm = Alter() + | + LOOKAHEAD({ getToken(1).kind == K_RENAME && getToken(2).kind == K_USER + && getToken(3).kind != K_TO && !".".equals(getToken(3).image) }) + stm = RenameUser() + | + // @todo: merge this into the ALTER TABLE statement + stm = RenameTableStatement() + | + stm = Create() + | + LOOKAHEAD( ) stm = DropPolicy() + | + LOOKAHEAD({ getToken(1).kind == K_DROP && getToken(2).kind == K_USER + && "MAPPING".equalsIgnoreCase(getToken(3).image) + && (getToken(4).kind == K_FOR || getToken(4).kind == K_IF) }) + stm = DropUserMapping() + | + LOOKAHEAD({ getToken(1).kind == K_DEALLOCATE || (getToken(1).kind == K_DROP + && getToken(2).kind == K_PREPARE && isMySqlUtilityDialect()) }) + stm = DeallocateStatement() + | + stm = Drop() + | + LOOKAHEAD({ getToken(1).kind == K_REASSIGN && "OWNED".equalsIgnoreCase(getToken(2).image) }) + stm = ReassignOwned() + | + LOOKAHEAD({ getToken(1).kind == K_ANALYZE + || getToken(1).kind == K_ANALYSE && isPostgreSqlMaintenanceAhead() }) + stm = Analyze() + | + LOOKAHEAD({ isPostgreSqlMaintenanceAhead() }) stm = PostgreSqlMaintenance() + | + LOOKAHEAD({ isTableMaintenanceAhead() }) stm = TableMaintenanceStatement() + | + LOOKAHEAD({ isFlushAhead() }) stm = FlushStatement() + | + LOOKAHEAD({ isKillAhead() }) stm = KillStatement() + | + LOOKAHEAD({ isHandlerAhead() }) stm = HandlerStatement() + | + LOOKAHEAD({ isReindexAhead() }) stm = Reindex() + | + LOOKAHEAD({ getToken(1).kind == K_SECURITY && "LABEL".equalsIgnoreCase(getToken(2).image) }) + stm = SecurityLabel() + | + // https://dev.mysql.com/doc/refman/8.4/en/replication-statements.html + LOOKAHEAD({ isReplicaThreadStatementAhead(K_START) }) stm = StartReplicaStatement() + | + LOOKAHEAD({ isReplicaThreadStatementAhead(K_STOP) }) stm = StopReplicaStatement() + | + LOOKAHEAD({ isChangeReplicationAhead() }) stm = ChangeReplicationStatement() + | + LOOKAHEAD({ isResetReplicationAhead() }) stm = ResetReplicationStatement() + | + stm = Truncate() + | + stm = Execute() + | + LOOKAHEAD({ isDoStatementAhead() }) stm = DoStatement() + | + LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_SET && getToken(2).kind == S_IDENTIFIER + && "IDENTITY_INSERT".equalsIgnoreCase(getToken(2).image) + && !"=".equals(getToken(3).image) && !".".equals(getToken(3).image) }) + stm = SetIdentityInsert() + | + LOOKAHEAD({ getAsBoolean(Feature.allowUnsupportedStatements) + && getToken(1).kind == K_SET && getToken(2).kind == S_IDENTIFIER + && !"=".equals(getToken(3).image) && !".".equals(getToken(3).image) + && !":=".equals(getToken(3).image) + && ("IDENTITY_INSERT".equalsIgnoreCase(getToken(2).image) + || "ISOLATION".equalsIgnoreCase(getToken(2).image) + && (isInformixIsolationLevel(getToken(3)) + || getToken(3).kind == K_TO && isInformixIsolationLevel(getToken(4)))) }) + stm = OpaqueSetStatement() + | + LOOKAHEAD({ isMySqlSetRoleAhead() }) stm = SetRoleStatement() + | + LOOKAHEAD({ getToken(1).kind == K_SET && getToken(2).kind == K_DEFAULT + && "ROLE".equalsIgnoreCase(getToken(3).image) }) + stm = SetDefaultRoleStatement() + | + LOOKAHEAD({ isMySqlSetPasswordAhead() }) stm = SetPasswordStatement() + | + LOOKAHEAD({ isSetTransactionAhead() }) stm = SetTransactionStatement() + | + LOOKAHEAD({ isSetConstraintsAhead() }) stm = SetConstraintsStatement() + | + stm = Set() + | + LOOKAHEAD({ isResetPersistAhead() }) stm = ResetPersist() + | + stm = Reset() + | + stm = Show() + | + stm = RefreshMaterializedView() + | + stm = Use() + | + LOOKAHEAD({ isBeginTransactionAhead() + || getToken(1).kind == K_START && "TRANSACTION".equalsIgnoreCase(getToken(2).image) }) + stm = StartTransaction() + | + LOOKAHEAD({ isKeywordAhead("RELEASE") }) stm = ReleaseSavepointStatement() + | + stm = SavepointStatement() + | + LOOKAHEAD({ isPrepareTransactionAhead() }) stm = PrepareTransactionStatement() + | + LOOKAHEAD({ isXaStatementAhead() }) stm = XaStatement() + | + LOOKAHEAD({ getToken(1).kind == K_ROLLBACK || isAbortTransactionAhead() }) + stm = RollbackStatement() + | + LOOKAHEAD({ getToken(1).kind == K_COMMIT || isEndTransactionAhead() }) stm = Commit() + | + stm = Comment() + | + LOOKAHEAD({ isListenAhead() }) stm = ListenStatement() + | + LOOKAHEAD({ isDiscardAhead() }) stm = DiscardStatement() + | + LOOKAHEAD({ isKeywordAhead("NOTIFY") }) stm = NotifyStatement() + | + LOOKAHEAD({ isMySqlExplainAhead() }) stm = MySqlExplain() + | + stm = Describe() + | + stm = Explain() + | + LOOKAHEAD({ isDeclareCursorAhead() }) stm = DeclareCursorStatement() + | + LOOKAHEAD({ isCursorStatementAhead() }) + ( stm = FetchCursorStatement() | stm = CloseCursorStatement() ) + | + stm = Declare() + | + stm = Grant() + | + LOOKAHEAD({ isKeywordAhead("REVOKE") }) stm = Revoke(false) + | + LOOKAHEAD({ getToken(1).kind == K_PRAGMA }) stm = PragmaStatement() + | + LOOKAHEAD({ isMySqlLoadDataAhead() }) stm = MySqlLoadDataStatement() + | + LOOKAHEAD({ isPluginStatementAhead() }) stm = PluginStatement() + | + LOOKAHEAD({ getToken(1).kind == K_INSTALL + || (getToken(1).kind == K_LOAD && getToken(2).kind != K_DATA) + || (getToken(1).kind == K_FORCE && getToken(2).kind == K_INSTALL) }) + stm = ExtensionStatement() + | + LOOKAHEAD({ getToken(1).kind == K_ATTACH }) stm = AttachStatement() + | + LOOKAHEAD({ getToken(1).kind == K_DETACH }) stm = DetachStatement() + | + LOOKAHEAD({ getToken(1).kind == K_CONNECT && getToken(2).kind != K_BY }) + stm = ConnectStatement() + | + LOOKAHEAD({ getToken(1).kind == K_DISCONNECT && getToken(2).kind != K_SESSION }) + stm = DisconnectStatement() + | + LOOKAHEAD({ getToken(1).kind == K_PREPARE }) stm = PrepareStatement() + | + LOOKAHEAD({ getToken(1).kind == K_COPY }) stm = CopyStatement() + | + LOOKAHEAD({ getToken(1).kind == K_ASSERT }) stm = AssertStatement() + | + LOOKAHEAD({ getToken(1).kind == K_EXPORT && getToken(2).kind == K_DATA }) stm = ExportDataStatement() + | + LOOKAHEAD({ getToken(1).kind == K_LOAD && getToken(2).kind == K_DATA }) stm = LoadDataStatement() + | + stm = PurgeStatement() + | + stm = SessionStatement() + | + LOOKAHEAD({ isBackupLockAhead() }) stm = BackupLockStatement() + | + LOOKAHEAD({ isUnlockTablesAhead() }) stm = UnlockStatement() + | + stm = LockStatement() + | + LOOKAHEAD({ isImportForeignSchemaAhead() }) stm = ImportForeignSchema() + | + LOOKAHEAD({ Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) ( stm = Import() | stm = Export() ) + ) + { + linkStatement(stm, first); + return stm; + } +} + +OracleBlock OracleBlock(): +{ + OracleBlock block = new OracleBlock(); + OracleBlock.VariableDeclaration declaration; + OracleBlock.ExceptionHandler handler; + Statements statements; +} +{ + [ declaration=OracleVariableDeclaration() { block.getDeclarations().add(declaration); } + ( LOOKAHEAD({ getToken(1).kind != K_BEGIN }) + declaration=OracleVariableDeclaration() { block.getDeclarations().add(declaration); } )* ] + statements=OracleBlockStatements() { block.setStatements(statements); } + [ LOOKAHEAD({ isKeywordAhead("EXCEPTION") }) AccessKeyword("EXCEPTION") + handler=OracleExceptionHandler() { block.getExceptionHandlers().add(handler); } + ( handler=OracleExceptionHandler() { block.getExceptionHandlers().add(handler); } )* ] + + { block.setSemicolonAfterEnd(true); return block; } +} + +OracleBlock.VariableDeclaration OracleVariableDeclaration(): +{ + OracleBlock.VariableDeclaration declaration = new OracleBlock.VariableDeclaration(); + String name; ColDataType dataType; Expression initializer; +} +{ + name=RelObjectName() { declaration.setName(name); } + [ LOOKAHEAD({ isKeywordAhead("CONSTANT") }) AccessKeyword("CONSTANT") { declaration.setConstant(true); } ] + dataType=ColDataType() { declaration.setDataType(dataType); } + [ { declaration.setNotNull(true); } ] + [ ( ":=" | { declaration.setInitializerOperator("DEFAULT"); } ) + initializer=Expression() { declaration.setInitializer(initializer); } ] + + { requireDdlSyntax((!declaration.isConstant() && !declaration.isNotNull()) || declaration.getInitializer() != null, + "A CONSTANT or NOT NULL variable requires an initializer"); return declaration; } +} + +Statements OracleBlockStatements(): +{ Statements statements = new Statements(); Statement statement; } +{ + statement=OracleBlockStatement() { statements.add(statement); } + ( LOOKAHEAD({ getToken(1).kind != K_END && getToken(1).kind != K_WHEN && !isKeywordAhead("EXCEPTION") }) + statement=OracleBlockStatement() { statements.add(statement); } )* + { return statements; } +} + +Statement OracleBlockStatement(): +{ Statement statement; Expression target; Expression value; Token first = getToken(1); } +{ + ( + LOOKAHEAD({ getToken(1).kind == K_DECLARE || getToken(1).kind == K_BEGIN }) statement=OracleBlock() + | LOOKAHEAD(Column() ":=") target=Column() ":=" value=Expression() + { statement = new OracleAssignment(target, value); } + | LOOKAHEAD(JdbcNamedParameter() ":=") target=JdbcNamedParameter() ":=" value=Expression() + { statement = new OracleAssignment(target, value); } + | { statement = new OracleNullStatement(); } + | LOOKAHEAD(ColumnIdentifier() ("(" | )) + statement=OracleImplicitCall() + | statement=SingleStatement() + ) + { linkStatement(statement, first); return statement; } +} + +Execute OracleImplicitCall(): +{ Execute call = new Execute(); ObjectNames name; ExpressionList arguments; } +{ + name=ColumnIdentifier() { call.setName(name.getNames()); call.setExecType(Execute.ExecType.IMPLICIT); + requireDdlSyntax(!Arrays.asList("RAISE", "RETURN", "GOTO", "EXIT", "CONTINUE", "LOOP", "WHILE", "FOR") + .contains(call.getName().toUpperCase(java.util.Locale.ROOT)), "Unsupported PL/SQL control statement"); } + [ LOOKAHEAD(1, "(") arguments=ExpressionList() { call.setExprList(arguments); } ] + { return call; } +} + +OracleBlock.ExceptionHandler OracleExceptionHandler(): +{ OracleBlock.ExceptionHandler handler = new OracleBlock.ExceptionHandler(); String name; Statements body; } +{ + name=TypeDdlName() { handler.getExceptions().add(name); } + ( name=TypeDdlName() { handler.getExceptions().add(name); } )* + body=OracleBlockStatements() { handler.setStatements(body); return handler; } +} + +/** + * PostgreSQL's DO [LANGUAGE name] code [LANGUAGE name], or MySQL's DO expr [, expr] ..., which + * MySQL reads as a select list. + */ +DoStatement DoStatement(): +{ + DoStatement statement = new DoStatement(); + String language; + Token code; + List> items; +} +{ + + ( + LOOKAHEAD({ !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + items=SelectItemsList() { statement.setSelectItems(items); } + | + ( + LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) + AccessKeyword("LANGUAGE") language=RelObjectName() code= + { statement.setLanguage(language); statement.setLanguageBeforeCode(true); } + | + code= + [ LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) AccessKeyword("LANGUAGE") + language=RelObjectName() { statement.setLanguage(language); } ] + ) + { statement.setCode(stringValue(code)); } + ) + { return statement; } +} + +Block Block() #Block : { + Block block; +} +{ + block = BeginEndBlock() + [LOOKAHEAD(2) { block.setSemicolonAfterEnd(true); widen(block, null, getToken(0)); } ] + { + return block; + } +} + +/** BEGIN, statements and END; unlike Block(), it leaves a following semicolon to the caller. */ +Block BeginEndBlock(): { + Statements stmts = new Statements(); + List list = new ArrayList(); + Statement stm; + Block block = new Block(); + Token first = getToken(1); +} +{ + + ()* + ( + stm = SingleStatement() + | stm = Block() + ) + + { list.add(stm); } + + ( + // END closes the block, even where PostgreSQL could read it as a statement + LOOKAHEAD(1, { getToken(1).kind != K_END }) + ( + ( + stm = SingleStatement() + | stm = Block() + ) + + { list.add(stm); } + ) + )* + + { + stmts.setStatements(list); + block.setStatements(stmts); + } + + + { + linkAST(block, first); + return block; + } +} + +Statements Statements() #Statements: { + Statements stmts = new Statements(); + IfElseStatement ifElseStatement = null; + Statement stm = null; + Statement stm2 = null; + Token ifFirst = null; + Expression condition; +} +{ + { + // Opaque roots can be first; capture them before known grammar lookahead. + while (getToken(1).kind == ST_SEMICOLON) { + getNextToken(); + } + captureOpaqueStatements(stmts); + if (getToken(1).kind == EOF) { + getNextToken(); + return stmts; + } + } + ( + ( + ( )* + { + captureOpaqueStatements(stmts); + if (getToken(1).kind == EOF) { + getNextToken(); + return stmts; + } + } + + try { + ( + { ifFirst = getToken(0); } condition=Condition() + ( stm = SingleStatement() | stm = Block() ) { ifElseStatement = new IfElseStatement(condition, stm); linkAST(ifElseStatement, ifFirst); } + [ LOOKAHEAD(2) + [ { ifElseStatement.setUsingSemicolonForIfStatement(true); } ] + ( stm2 = SingleStatement() | stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); widen(ifElseStatement, null, getToken(0)); } + ] + + { requireStatementBoundary(); stmts.add( ifElseStatement ); } + + [ + LOOKAHEAD(2) + { if (stm2!=null) + ifElseStatement.setUsingSemicolonForElseStatement(true); + else if (ifElseStatement!=null) + ifElseStatement.setUsingSemicolonForIfStatement(true); + widen(ifElseStatement, null, getToken(0)); + } + ] + ) + | + ( + (stm = SingleStatement() + | stm = Block()) + + ( | ) + ) + { + stmts.add(stm); stm=null; + } + + } catch (ParseException ex) { + if ( errorRecovery ) { + parseErrors.add(ex); + error_skipto(ST_SEMICOLON); + stmts.add( null ); + } else { + throw ex; + } + } + + ) + + ( LOOKAHEAD(2) + ( )* + { + captureOpaqueStatements(stmts); + if (getToken(1).kind == EOF) { + getNextToken(); + return stmts; + } + } + try { + ( + { ifFirst = getToken(0); } condition=Condition() + ( stm = SingleStatement() | stm = Block() ) { ifElseStatement = new IfElseStatement(condition, stm); linkAST(ifElseStatement, ifFirst); } + [ LOOKAHEAD(2) + [ { ifElseStatement.setUsingSemicolonForIfStatement(true); } ] + ( stm2 = SingleStatement() | stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); widen(ifElseStatement, null, getToken(0)); } + ] + + { requireStatementBoundary(); stmts.add( ifElseStatement ); } + ) + | + ( + stm = SingleStatement() + | stm = Block() + ) { requireStatementBoundary(); stmts.add(stm); stm=null; } + } catch (ParseException ex) { + if ( errorRecovery ) { + parseErrors.add(ex); + error_skipto(ST_SEMICOLON); + stmts.add( null ); + } else { + throw ex; + } + } + + ( LOOKAHEAD(2) { if (stm2!=null) + ifElseStatement.setUsingSemicolonForElseStatement(true); + else if (ifElseStatement!=null) + ifElseStatement.setUsingSemicolonForIfStatement(true); + widen(ifElseStatement, null, getToken(0)); + } )* + + )* + + [ + LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) && isOpaqueStatementAhead() } ) + stm = UnsupportedStatement() + { + if (!( (UnsupportedStatement) stm).isEmpty()) { + stmts.add( stm ); + } + } + ] + + )* + + + { + token_source.positionTrailingComments(); + return stmts; + } +} + +JAVACODE +UnsupportedStatement captureStatementTokens(Token statementStart) { + List tokenImages = new ArrayList(); + Token statementEnd = getToken(0); + for (Token t = statementStart.next; ; t = t.next) { + tokenImages.add(t.image); + if (t == statementEnd) { + break; + } + } + UnsupportedStatement statement = new UnsupportedStatement(tokenImages); + linkAST(statement, statementStart.next, statementEnd); + return statement; +} + +JAVACODE +List error_skipto(int kind) { + ArrayList tokenImages = new ArrayList(); + ParseException e = generateParseException("test"); + Token t; + do { + t = getNextToken(); + if (t.kind != kind && t.kind != EOF) { + tokenImages.add(t.image); + } + } while (t.kind != kind && t.kind != EOF); + return tokenImages; +} + +LockStatement LockStatement(): { + LockStatement statement = new LockStatement(); + LockStatement.Target target; + LockMode mode; +} { + + ( + // https://dev.mysql.com/doc/refman/8.4/en/lock-tables.html + LOOKAHEAD({ isMySqlLockTablesAhead() }) + ( | { statement.setTablesKeyword(true); } ) + target=MySqlLockTarget() { statement.getTargets().add(target); } + ( "," target=MySqlLockTarget() { statement.getTargets().add(target); } )* + // https://mariadb.com/kb/en/lock-tables/ + [ + LOOKAHEAD({ Dialect.MARIADB.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_NOWAIT || getToken(1).kind == K_WAIT) }) + LockWait(statement) + ] + | + { statement.setUseTableKeyword(false); } + [ LOOKAHEAD(1, ) { statement.setUseTableKeyword(true); } ] + target=LockTarget() { statement.getTargets().add(target); } + ( "," target=LockTarget() { statement.getTargets().add(target); } )* + [ mode=TableLockMode() { statement.setLockMode(mode); } ] + [ LockWait(statement) ] + ) + { return statement; } +} + +void LockWait(LockStatement statement): +{ Token waitSeconds; } +{ + { statement.setNoWait(true); } + | waitSeconds= { statement.setWaitSeconds(Long.valueOf(waitSeconds.image)); } +} + +/** A MySQL LOCK TABLES target: tbl_name [[AS] alias] lock_type. */ +LockStatement.Target MySqlLockTarget(): +{ + Table table; + Token only; + Alias alias; + TableLockType lockType; +} +{ + ( + // MySQL has no ONLY here, so it names a table, as in SELECT * FROM only + LOOKAHEAD({ getToken(1).kind == K_ONLY && !".".equals(getToken(2).image) }) + only= { table = linkToLastToken(createTable(Arrays.asList(only.image))); } + | + table=Table() + ) + [ + LOOKAHEAD({ getToken(1).kind == K_AS || !isMySqlLockTypeAhead(1) && isMySqlLockTypeAhead(2) }) + alias=Alias() { table.setAlias(alias); } + ] + lockType=MySqlTableLockType() + { return new LockStatement.Target(table).withLockType(lockType); } +} + +TableLockType MySqlTableLockType(): +{ TableLockType lockType; } +{ + ( + { lockType = TableLockType.READ; } [ { lockType = TableLockType.READ_LOCAL; } ] + | + ContextualKeyword("WRITE") { lockType = TableLockType.LOW_PRIORITY_WRITE; } + | + ContextualKeyword("WRITE") { lockType = TableLockType.WRITE; } + [ + LOOKAHEAD({ Dialect.MARIADB.name().equals(getAsString(Feature.dialect)) + && isKeywordAhead("CONCURRENT") }) + ContextualKeyword("CONCURRENT") { lockType = TableLockType.WRITE_CONCURRENT; } + ] + ) + { return lockType; } +} + +// https://dev.mysql.com/doc/refman/8.4/en/lock-tables.html +UnlockStatement UnlockStatement(): +{ UnlockStatement statement = new UnlockStatement(); } +{ + ( { statement.setTablesKeyword(false); } | ) + { return statement; } +} + +// https://dev.mysql.com/doc/refman/8.4/en/lock-instance-for-backup.html +BackupLockStatement BackupLockStatement(): +{ BackupLockStatement statement = new BackupLockStatement(); } +{ + ( + ContextualKeyword("INSTANCE") ContextualKeyword("BACKUP") + | + ContextualKeyword("INSTANCE") { statement.setAction(BackupLockStatement.Action.UNLOCK); } + ) + { return statement; } +} + +/** + * MySQL ALTER INSTANCE, after ALTER. MySQL reads INNODB, BINLOG and REDO_LOG as identifiers that + * it compares with these names, and the engine of ROTATE also as a string. + */ +// https://dev.mysql.com/doc/refman/8.4/en/alter-instance.html +AlterInstance AlterInstance(): +{ + AlterInstance statement; + Token word; + String name; + String channel; +} +{ + ContextualKeyword("INSTANCE") + ( + ( + { statement = new AlterInstance(AlterInstance.Action.ENABLE_INNODB_REDO_LOG); } + | + { statement = new AlterInstance(AlterInstance.Action.DISABLE_INNODB_REDO_LOG); } + ) + word=AlterInstanceWord() + { requireDdlSyntax("INNODB".equalsIgnoreCase(alterInstanceWord(word, false)), "Expected INNODB but found " + word.image); } + word=AlterInstanceWord() + { requireDdlSyntax("REDO_LOG".equalsIgnoreCase(alterInstanceWord(word, false)), "Expected REDO_LOG but found " + word.image); } + | + LOOKAHEAD({ isKeywordAhead("ROTATE") }) ContextualKeyword("ROTATE") word=AlterInstanceWord() + { + name = alterInstanceWord(word, true); + requireDdlSyntax("INNODB".equalsIgnoreCase(name) || "BINLOG".equalsIgnoreCase(name), + "Expected INNODB or BINLOG but found " + word.image); + statement = new AlterInstance("INNODB".equalsIgnoreCase(name) + ? AlterInstance.Action.ROTATE_INNODB_MASTER_KEY + : AlterInstance.Action.ROTATE_BINLOG_MASTER_KEY); + } + ContextualKeyword("MASTER") + | + ContextualKeyword("RELOAD") + ( + LOOKAHEAD({ isKeywordAhead("KEYRING") }) ContextualKeyword("KEYRING") + { statement = new AlterInstance(AlterInstance.Action.RELOAD_KEYRING); } + | + ContextualKeyword("TLS") { statement = new AlterInstance(AlterInstance.Action.RELOAD_TLS); } + [ + ContextualKeyword("CHANNEL") channel=RelObjectName() + { + // a double-quoted name is a string in MySQL, which takes an identifier here + requireDdlSyntax(!channel.startsWith("\"") && !channel.startsWith("["), + "Expected a channel name but found " + channel); + statement.setChannel(channel); + } + ] + [ { statement.setNoRollbackOnError(true); } ] + ) + ) + { return statement; } +} + +Token AlterInstanceWord(): +{ Token token; } +{ + ( token= | token= | token= ) + { return token; } +} + +/** + * MySQL CREATE [OR REPLACE] SPATIAL REFERENCE SYSTEM [IF NOT EXISTS] srid srs_attribute ..., + * after CREATE [OR REPLACE]. The attributes come in any order; the server, not its grammar, reports + * a repeated or a missing one. + */ +// https://dev.mysql.com/doc/refman/8.4/en/create-spatial-reference-system.html +CreateSpatialReferenceSystem CreateSpatialReferenceSystem(boolean orReplace): +{ + CreateSpatialReferenceSystem statement; + boolean ifNotExists = false; + Expression srid; + SpatialReferenceSystemAttribute attribute; +} +{ + ContextualKeyword("REFERENCE") + [ + + { requireDdlSyntax(!orReplace, "CREATE OR REPLACE SPATIAL REFERENCE SYSTEM does not take IF NOT EXISTS"); ifNotExists = true; } + ] + srid=SpatialReferenceSystemNumber() + { + statement = new CreateSpatialReferenceSystem(srid).withOrReplace(orReplace) + .withIfNotExists(ifNotExists); + } + ( + LOOKAHEAD({ isSpatialReferenceSystemAttributeAhead() }) + attribute=SpatialReferenceSystemAttribute() { statement.addAttributes(attribute); } + )* + { return statement; } +} + +SpatialReferenceSystemAttribute SpatialReferenceSystemAttribute(): +{ + Token first = getToken(1); + SpatialReferenceSystemAttribute attribute; + StringValue value; + Expression organizationId; +} +{ + ( + value=SpatialReferenceSystemString() + { attribute = new SpatialReferenceSystemAttribute(SpatialReferenceSystemAttribute.Kind.NAME, value); } + | + LOOKAHEAD({ isKeywordAhead("DEFINITION") }) + ContextualKeyword("DEFINITION") value=SpatialReferenceSystemString() + { attribute = new SpatialReferenceSystemAttribute(SpatialReferenceSystemAttribute.Kind.DEFINITION, value); } + | + LOOKAHEAD({ isKeywordAhead("DESCRIPTION") }) + ContextualKeyword("DESCRIPTION") value=SpatialReferenceSystemString() + { attribute = new SpatialReferenceSystemAttribute(SpatialReferenceSystemAttribute.Kind.DESCRIPTION, value); } + | + ContextualKeyword("ORGANIZATION") value=SpatialReferenceSystemString() + organizationId=SpatialReferenceSystemNumber() + { attribute = new SpatialReferenceSystemAttribute(value, organizationId); } + ) + { return linked(attribute, first); } +} + +/** A plain MySQL string; the grammar takes no prefix and no adjacent strings here. */ +StringValue SpatialReferenceSystemString(): +{ Token token; } +{ + ( token= | token= ) + { + requireDdlSyntax(isMySqlTextString(token), "Expected a string but found " + token.image); + return stringValue(token); + } +} + +/** The SRID, or the identifier an organization gives the system, as written. */ +Expression SpatialReferenceSystemNumber(): +{ Token token; } +{ + ( token= | token= ) + { return spatialReferenceSystemNumber(token); } +} + +LockStatement.Target LockTarget(): +{ TableReference reference; } +{ + reference=RelationTarget() + { + return RelationOptions.lockTarget(reference); + } +} + +/** Shared PostgreSQL relation_expr target, including ONLY (qualified_name). */ +TableReference RelationTarget(): +{ + Table table; + boolean only = false; + boolean descendants = false; + boolean parenthesized = false; + TableReference target; +} +{ + [ LOOKAHEAD(2) { only = true; } ] + ( "(" table=Table() ")" { parenthesized = true; } | table=Table() ) + [ "*" { descendants = true; } ] + { + requireDdlSyntax(!only || !descendants, "ONLY and * cannot describe the same relation target"); + requireDdlSyntax(!parenthesized || only, "Parenthesized relation targets require ONLY"); + target = new TableReference(table); + target.setOnly(only); + target.setIncludeDescendants(descendants); + target.setParenthesized(parenthesized); + return target; + } +} + +LockMode TableLockMode(): { + LockMode mode; +} { + ( + ( { mode = LockMode.RowShare; } + | { mode = LockMode.RowExclusive; } ) + | { mode = LockMode.Share; } + [ { mode = LockMode.ShareRowExclusive; } + | { mode = LockMode.ShareUpdate; } + [ { mode = LockMode.ShareUpdateExclusive; } ] ] + | { mode = LockMode.Exclusive; } + | AccessKeyword("ACCESS") ( { mode = LockMode.AccessShare; } + | { mode = LockMode.AccessExclusive; } ) + ) + { return mode; } +} + +LikeClause LikeClause(): { + LikeClause likeClause = new LikeClause(); + Table table; + List> columnsList; + boolean including; + String option; +} { + + table = Table() { likeClause.setTable(table); } + [ LOOKAHEAD(2) "(" columnsList = ColumnSelectItemsList() ")" { likeClause.setColumnsList(columnsList); }] + ( + ( + { including = true; } + | { including = false; } + ) + option=RelObjectName() + { + likeClause.addOption(likeOptionKind(option), including); + } + )* + + { + return likeClause; + } +} + +Export Export() #Export: { + Export export = new Export(); + Table table; + ParenthesedExpressionList columns; + ParenthesedSelect select; + ExportIntoItem exportIntoItem; +} { + + ( + table = Table() { export.setTable(table); } + [ columns = ParenthesedColumnList() { export.setColumns(columns); } ] + | select = ParenthesedSelect() { export.setSelect(select); } + ) + + + exportIntoItem = ExportIntoItem() { export.setExportIntoItem(exportIntoItem); } + + { + return export; + } +} + +Import Import() #Import: { + Import impt = new Import(); + Table table; + ParenthesedExpressionList columns; + List importColumns; + ImportFromItem fromItem; +} { + + [ + + ( + table = Table() { impt.setTable(table); } + [ columns = ParenthesedColumnList() { impt.setColumns(columns); } ] + | importColumns = ImportColumns() { impt.setImportColumns(importColumns); } + ) + ] + + + fromItem = ImportFromItem() { impt.setFromItem(fromItem); } + + { + return impt; + } +} + +Import SubImport() #SubImport: { + Import impt = new Import(); + List importColumns; + ImportFromItem fromItem; +} { + "(" + + [ importColumns = ImportColumns() { impt.setImportColumns(importColumns); } ] + + + fromItem = ImportFromItem() { impt.setFromItem(fromItem); } + ")" + + { + return impt; + } +} + +List ImportColumns(): { + ImportColumn importColumn; + List importColumns = new ArrayList(); +} { + "(" + ( + importColumn = ColumnDefinition() + | importColumn = LikeClause() + ) + { importColumns.add(importColumn); } + + ( + "," + ( + importColumn = ColumnDefinition() + | importColumn = LikeClause() + ) + { importColumns.add(importColumn); } + )* + ")" + + { + return importColumns; + } +} + +ExportIntoItem ExportIntoItem(): { + ExportIntoItem exportIntoItem; + ErrorClause errorClause; +} { + ( + exportIntoItem = DBMSDestination() + | exportIntoItem = FileDestination() + | exportIntoItem = ScriptSourceDestination() + ) + [ LOOKAHEAD(2) errorClause = ErrorClause() { exportIntoItem.setErrorClause(errorClause); } ] + + { + return exportIntoItem; + } +} + +ImportFromItem ImportFromItem(): { + ImportFromItem importFromItem; + ErrorClause errorClause; +} { + ( + importFromItem = DBMSSource() + | importFromItem = FileSource() + | importFromItem = ScriptSourceDestination() + ) + [ LOOKAHEAD(2) errorClause = ErrorClause() { importFromItem.setErrorClause(errorClause); } ] + + { + return importFromItem; + } +} + +DBMSDestination DBMSDestination() #DBMSDestination: { + DBMSDestination dbmsDestination = new DBMSDestination(); + DBMSType dbmsType; + ConnectionDefinition connectionDefinition; + Table table; + ExpressionList columns; + StringValue statement; + List dbmsTableDestinationOptions; +} { + dbmsType = DBMSType() { dbmsDestination.setDestinationType(dbmsType); } + + connectionDefinition = ConnectionDefinition() { dbmsDestination.setConnectionDefinition(connectionDefinition); } + + ( + table = Table() { dbmsDestination.setTable(table); } + [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsDestination.setColumns(columns); } ] + [ LOOKAHEAD(2) dbmsTableDestinationOptions = DBMSTableDestinationOptionList() { dbmsDestination.setDBMSTableDestinationOptions(dbmsTableDestinationOptions); } ] + | statement = ImportExportStatement() { dbmsDestination.setStatement(statement); } + ) + + { + return dbmsDestination; + } +} + +DBMSTableDestinationOption DBMSTableDestinationOption(): { + DBMSTableDestinationOption dbmsTableDestinationOption; + + Token token; + Token token2; + Token token3; +} { + ( + ( + token = + | token = + ) { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image); } + | token = token2 = token3 = { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image + " " + token2.image, stringValue(token3)); } + ) + + { + return dbmsTableDestinationOption; + } +} + +List DBMSTableDestinationOptionList(): { + List dbmsTableDestinationOptions = new ArrayList(); + DBMSTableDestinationOption dbmsTableDestinationOption; +} { + ( LOOKAHEAD(2) dbmsTableDestinationOption = DBMSTableDestinationOption() { dbmsTableDestinationOptions.add(dbmsTableDestinationOption); } )+ + { + return dbmsTableDestinationOptions; + } +} + +DBMSSource DBMSSource() #DBMSSource: { + DBMSSource dbmsSource = new DBMSSource(); + DBMSType dbmsType; + ConnectionDefinition connectionDefinition; + Table table; + ExpressionList columns; + List statements; +} { + dbmsType = DBMSType() { dbmsSource.setSourceType(dbmsType); } + + connectionDefinition = ConnectionDefinition() { dbmsSource.setConnectionDefinition(connectionDefinition); } + + ( + table = Table() { dbmsSource.setTable(table); } + [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsSource.setColumns(columns); } ] + | statements = ImportExportStatementsList() { dbmsSource.setStatements(statements); } + ) + { + return dbmsSource; + } +} + +DBMSType DBMSType(): { + DBMSType dbmsType; + Token tk1; + Token tk2 = null; +} { + ( + tk1= + | tk1= + | tk1= + [ "=" tk2=] + ) { dbmsType = new DBMSType(tk1.image, tk2 == null ? null : tk2.image); } + { + return dbmsType; + } +} + +FileType FileType(): { + FileType fileType; + Token tk; +} { + ( + tk= + | tk= + ) { fileType = new FileType(tk.image); } + { + return fileType; + } +} + +StringValue ImportExportStatement() #ImportExportStatement: { + StringValue statement; +} { + token = + { + statement = stringValue(token); + linkAST(statement, jjtThis); + return statement; + } +} + +List ImportExportStatementsList(): { + List statements = new ArrayList(); + StringValue statement; +} { + ( statement = ImportExportStatement() { statements.add(statement); } )+ + + { + return statements; + } +} + +StringValue File() #File: { + Token token; +} { + token = + { + StringValue file = stringValue(token); + linkAST(file, jjtThis); + return file; + } +} + +List FileList(): { + List files = new ArrayList(); + StringValue file; +} { + ( file = File() { files.add(file); } )+ + { + return files; + } +} + +ConnectionFileDefinition ConnectionFileDefinition(): { + ConnectionDefinition connectionDefinition = null; + List files; +} { + connectionDefinition = ConnectionOrCloudConnectionDefinition() + files = FileList() + { + return new ConnectionFileDefinition(connectionDefinition, files); + } +} + +List ConnectionFileDefinitionList(): { + List connectionFileDefinitions = new ArrayList(); + ConnectionFileDefinition connectionFileDefinition; +} { + ( LOOKAHEAD(2) connectionFileDefinition = ConnectionFileDefinition() { connectionFileDefinitions.add(connectionFileDefinition); } )+ + { + return connectionFileDefinitions; + } +} + +CSVColumn CSVDestinationColumn(): { + CSVColumn csvColumn; + + Token token; + Token token2; +} { + ( + LOOKAHEAD(2) + token= ".." token2= { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); } + | token= { csvColumn = new CSVColumn(Long.valueOf(token.image)); } + [ "=" token = { csvColumn.setFormat(stringValue(token)); }] + [ + + "=" + ( + token= + | token= + | token= + ) + { csvColumn.setDelimit(token.image); } + ] + ) + { + return csvColumn; + } +} + +List CSVDestinationColumnList(): { + List csvColumns = new ArrayList(); + CSVColumn csvColumn; +} { + csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } + ( "," csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } )* + { + return csvColumns; + } +} + +CSVColumn CSVSourceColumn(): { + CSVColumn csvColumn; + + Token token; + Token token2; +} { + ( + LOOKAHEAD(2) + token= ".." token2= { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); } + | token= { csvColumn = new CSVColumn(Long.valueOf(token.image)); } + [ "=" token = { csvColumn.setFormat(stringValue(token)); }] + ) + { + return csvColumn; + } +} + +List CSVSourceColumnList(): { + List csvColumns = new ArrayList(); + CSVColumn csvColumn; +} { + csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } + ( "," csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } )* + { + return csvColumns; + } +} + +FBVColumn FBVDestinationColumn(): { + FBVColumn fbvColumn; + + Token token; + Token token2; +} { + ( + token= "=" token2= { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); } + | ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, stringValue(token2)); } + | token= "=" ( token2= | token2= ) { fbvColumn = new FBVColumn(token.image, token2.image); } + ) + { + return fbvColumn; + } +} + +List FBVDestinationColumnList(): { + List fbvColumns = new ArrayList(); + FBVColumn fbvColumn; + boolean precedesComma; +} { + fbvColumn = FBVDestinationColumn() { fbvColumns.add(fbvColumn); } + ( + { precedesComma = false; } + ["," { precedesComma = true; }] + fbvColumn = FBVDestinationColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); } + )* + { + return fbvColumns; + } +} + +FBVColumn FBVSourceColumn(): { + FBVColumn fbvColumn; + + Token token; + Token token2; +} { + ( + ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); } + | ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, stringValue(token2)); } + | token= "=" ( token2= | token2= ) { fbvColumn = new FBVColumn(token.image, token2.image); } + ) + { + return fbvColumn; + } +} + +List FBVSourceColumnList(): { + List fbvColumns = new ArrayList(); + FBVColumn fbvColumn; + boolean precedesComma; +} { + fbvColumn = FBVSourceColumn() { fbvColumns.add(fbvColumn); } + ( + { precedesComma = false; } + ["," { precedesComma = true; }] + fbvColumn = FBVSourceColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); } + )* + { + return fbvColumns; + } +} + +FileOption FileDestinationOption(): { + FileOption fileOption; + + Token token; + Token token2; + Token token3; +} { + ( + ( token= | token= ) { fileOption = new FileOption(token.image); } + | token= token2= token3= { fileOption = new FileOption(token.image + " " + token2.image + " " + token3.image); } + | ( token= | token= | token= ) "=" token2= { fileOption = new FileOption(token.image, stringValue(token2)); } + | ( + token= token2= "=" token3= + | token= ( token2= | token2= ) "=" token3= + ) + { fileOption = new FileOption(token.image + " " + token2.image, stringValue(token3)); } + | token= "=" ( token2= | token2= | token2= ) { fileOption = new FileOption(token.image, token2.image); } + ) + { + return fileOption; + } +} + +List FileDestinationOptionList(): { + List fileOptions = new ArrayList(); + FileOption fileOption; +} { + ( LOOKAHEAD(2) fileOption = FileDestinationOption() { fileOptions.add(fileOption); } )+ + { + return fileOptions; + } +} + +FileOption FileSourceOption(): { + FileOption fileOption; + + Token token; + Token token2; + Token token3; +} { + ( + ( token= | token= | token= ) { fileOption = new FileOption(token.image); } + | ( + ( token= | token= ) "=" token2= { fileOption = new FileOption(token.image, stringValue(token2)); } + | token= "=" token2= { fileOption = new FileOption(token.image, new LongValue(token2.image)); } + ) + | LOOKAHEAD(2) + ( + token= token2= "=" token3= + | token= ( token2= | token2= ) "=" token3= + ) + { fileOption = new FileOption(token.image + " " + token2.image, stringValue(token3)); } + | token= token2= "=" token3= + { fileOption = new FileOption(token.image + " " + token2.image, new LongValue(token3.image)); } + ) + { + return fileOption; + } +} + +List FileSourceOptionList(): { + List fileOptions = new ArrayList(); + FileOption fileOption; +} { + ( LOOKAHEAD(2) fileOption = FileSourceOption() { fileOptions.add(fileOption); } )+ + { + return fileOptions; + } +} + +FileDestination FileDestination() #FileDestination: { + FileDestination fileDestination = new FileDestination(); + FileType fileType; + List connectionFileDefinitions; + List files; + List csvColumns; + List fbvColumns; + List fileOptions; + CertificateVerification certificateVerification; +} { + ( + fileType = FileType() { fileDestination.setDestinationType(fileType); } + connectionFileDefinitions = ConnectionFileDefinitionList() { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); } + | { fileDestination.setLocal(true); } + [ { fileDestination.setSecure(true); }] + + fileType = FileType() { fileDestination.setDestinationType(fileType); } + files = FileList() + { + connectionFileDefinitions = new ArrayList(); + connectionFileDefinitions.add(new ConnectionFileDefinition(files)); + } + ) + { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); } + + [ + LOOKAHEAD(2) + "(" + ( + csvColumns = CSVDestinationColumnList() { fileDestination.setCSVColumns(csvColumns); } + | fbvColumns = FBVDestinationColumnList() { fileDestination.setFBVColumns(fbvColumns); } + ) + ")" + ] + + [ LOOKAHEAD(2) fileOptions = FileDestinationOptionList() { fileDestination.setFileOptions(fileOptions); } ] + + [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileDestination.setCertificateVerification(certificateVerification); } ] + + { + return fileDestination; + } +} + +FileSource FileSource() #FileSource: { + FileSource fileSource = new FileSource(); + FileType fileType; + List connectionFileDefinitions; + List files; + List csvColumns; + List fbvColumns; + List fileOptions; + CertificateVerification certificateVerification; +} { + ( + fileType = FileType() { fileSource.setSourceType(fileType); } + connectionFileDefinitions = ConnectionFileDefinitionList() { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); } + | { fileSource.setLocal(true); } + [ { fileSource.setSecure(true); }] + + fileType = FileType() { fileSource.setSourceType(fileType); } + files = FileList() + { + connectionFileDefinitions = new ArrayList(); + connectionFileDefinitions.add(new ConnectionFileDefinition(files)); + } + ) + { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); } + + [ + LOOKAHEAD(2) + "(" + ( + csvColumns = CSVSourceColumnList() { fileSource.setCSVColumns(csvColumns); } + | fbvColumns = FBVSourceColumnList() { fileSource.setFBVColumns(fbvColumns); } + ) + ")" + ] + + [ LOOKAHEAD(2) fileOptions = FileSourceOptionList() { fileSource.setFileOptions(fileOptions); } ] + + [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileSource.setCertificateVerification(certificateVerification); } ] + + { + return fileSource; + } +} + +CertificateVerification CertificateVerification(): { + CertificateVerification certificateVerification = new CertificateVerification(); + Token token; +} { + ( + ( + { certificateVerification.setIgnoreCertificate(true); } + | { certificateVerification.setVerifyCertificate(true); } + ) + + [ + LOOKAHEAD(2) + + token = { certificateVerification.setPublicKey(stringValue(token)); } + ] + | + token = { certificateVerification.setPublicKey(stringValue(token)); } + ) + { + return certificateVerification; + } +} + +ScriptSourceDestination ScriptSourceDestination(): { + ScriptSourceDestination scriptSourceDestination = new ScriptSourceDestination(); + ConnectionDefinition connectionDefinition; + Table script; + String property; + StringValue value; + + Token token; +} { + + script = Table() { scriptSourceDestination.setScript(script); } + + [ LOOKAHEAD(2) connectionDefinition = ConnectionDefinition() { scriptSourceDestination.setConnectionDefinition(connectionDefinition); } ] + + [ + LOOKAHEAD(2) + { + List properties = new ArrayList(); + List values = new ArrayList(); + scriptSourceDestination.setProperties(properties); + scriptSourceDestination.setValues(values); + } + + + ( + LOOKAHEAD(2) + property = RelObjectName() "=" token = { value = stringValue(token); } + { + properties.add(property); + values.add(value); + } + )+ + ] + + { + return scriptSourceDestination; + } +} + +UserIdentification UserIdentification(): { + UserIdentification userIdentification = new UserIdentification(); + Token token; +} { + + token= { userIdentification.setUser(stringValue(token)); } + + token= { userIdentification.setPassword(stringValue(token)); } + + { + return userIdentification; + } +} + +ConnectionDefinition ConnectionDefinition(): { + ConnectionDefinition connectionDefinition = new ConnectionDefinition(); + String connectionObjectName; + UserIdentification userIdentification; + CertificateVerification certificateVerification; + + Token token; +} { + + ( + connectionObjectName = RelObjectName() { connectionDefinition.setConnectionObjectName(connectionObjectName); } + | token= { connectionDefinition.setConnectionDefinition(stringValue(token)); } + ) + + [ LOOKAHEAD(2) userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ] + + [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { connectionDefinition.setCertificateVerification(certificateVerification); } ] + + { + return connectionDefinition; + } +} + +ConnectionDefinition CloudConnectionDefinition(): { + CloudConnectionDefinition connectionDefinition = new CloudConnectionDefinition(); + String connectionObjectName; + UserIdentification userIdentification; + + Token token; + Token token2; +} { + + ( + token = { connectionDefinition.setStorage(token.image); } + | token = token2 = { connectionDefinition.setStorage(token.image + " " + token2.image); } + ) + + ( + connectionObjectName = RelObjectName() { connectionDefinition.setConnectionObjectName(connectionObjectName); } + | token = { connectionDefinition.setConnectionDefinition(stringValue(token)); } + ) + + [ userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ] + + { + return connectionDefinition; + } +} + +ConnectionDefinition ConnectionOrCloudConnectionDefinition(): { + ConnectionDefinition connectionDefinition; +} { + ( + LOOKAHEAD(2) connectionDefinition = CloudConnectionDefinition() + | connectionDefinition = ConnectionDefinition() + ) + { + return connectionDefinition; + } +} + +ErrorClause ErrorClause(): { + ErrorClause errorClause = new ErrorClause(); + ErrorDestination errorDestination; + Expression expression; + RejectClause rejectClause; + + Token token; +} { + ( + + errorDestination = ErrorDestination() { errorClause.setErrorDestination(errorDestination); } + [ + LOOKAHEAD(2) + "(" + expression = Expression() { errorClause.setExpression(expression); } + ")" + ] + [ + LOOKAHEAD(2) + ( + { errorClause.setReplace(true); } + | { errorClause.setTruncate(true); } + ) + ] + [ LOOKAHEAD(2) rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } ] + | rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } + ) + + { + return errorClause; + } +} + +RejectClause RejectClause(): { + RejectClause rejectClause = new RejectClause(); +} { + + ( + token= { rejectClause.setLimit(new LongValue(token.image)); } + | + ) + + [ LOOKAHEAD(2) { rejectClause.setErrors(true); } ] + + { + return rejectClause; + } +} + +ErrorDestination ErrorDestination(): { + ErrorDestination errorDestination; +} { + ( + LOOKAHEAD(2) errorDestination = CSVFileDestination() + | errorDestination = Table() + ) + + { + return errorDestination; + } +} + +CSVFileDestination CSVFileDestination(): { + CSVFileDestination csvFileDestination = new CSVFileDestination(); + ConnectionDefinition connectionDefinition; + StringValue file; +} { + ( + + connectionDefinition = ConnectionOrCloudConnectionDefinition() { csvFileDestination.setConnectionDefinition(connectionDefinition); } + | { csvFileDestination.setLocal(true); } + [ { csvFileDestination.setSecure(true); } ] + + ) + + file = File() { csvFileDestination.setFile(file); } + + { + return csvFileDestination; + } +} + +DeclareStatement Declare(): { + UserVariable userVariable; + ColDataType colDataType; + Expression defaultExpr = null; + DeclareStatement stmt = new DeclareStatement(); + String typeName; + String columnName; + ColumnDefinition colDef; +} { + userVariable = UserVariable() + ( + LOOKAHEAD(2) ( + "(" colDef = ColumnDefinition() + { + stmt.withUserVariable(userVariable) + .withDeclareType(DeclareType.TABLE) + .addColumnDefinition(colDef); + } + ("," colDef = ColumnDefinition() { stmt.addColumnDefinition(colDef); })* ")" + ) + | + typeName = RelObjectName() + { + stmt.withUserVariable(userVariable) + .withDeclareType(DeclareType.AS) + .withTypeName(typeName); + } + | + (colDataType = ColDataType() ["=" defaultExpr = Expression()] + { + stmt.withDeclareType(DeclareType.TYPE) + .addType(userVariable, colDataType, defaultExpr); + } + ("," userVariable = UserVariable() colDataType = ColDataType() { defaultExpr = null; } + ["=" defaultExpr = Expression()] { stmt.addType(userVariable, colDataType, defaultExpr); } )* + ) + ) + { + return stmt; + } +} + +// https://www.postgresql.org/docs/18/sql-declare.html +DeclareCursorStatement DeclareCursorStatement(): +{ + DeclareCursorStatement statement = new DeclareCursorStatement(); + String name; + CursorOption option; + Select query; +} +{ + name=CursorName() { statement.setCursorName(name); } + ( LOOKAHEAD({ isCursorOptionAt(1) }) option=CursorOption() { statement.getOptions().add(option); } )* + ContextualKeyword("CURSOR") + [ + ContextualKeyword("HOLD") + { statement.setHoldability(DeclareCursorStatement.Holdability.WITH_HOLD); } + | + ContextualKeyword("HOLD") + { statement.setHoldability(DeclareCursorStatement.Holdability.WITHOUT_HOLD); } + ] + query=Select() { statement.setQuery(query); } + { return statement; } +} + +/** Only used where isCursorOptionAt(1) holds, which limits the identifier to the option words. */ +CursorOption CursorOption(): +{ Token token; CursorOption option; } +{ + ( + { option = CursorOption.BINARY; } + | + ContextualKeyword("SCROLL") { option = CursorOption.NO_SCROLL; } + | + token= { option = CursorOption.valueOf(token.image.toUpperCase(Locale.ROOT)); } + ) + { return option; } +} + +/** A cursor name: any name but the words PostgreSQL reserves or keeps for types and functions. */ +String CursorName(): +{ Token token = getToken(1); String name; } +{ + name=RelObjectName() + { + requireDdlSyntax(isCursorNameToken(token), "Invalid cursor name: " + token.image); + return name; + } +} + +// https://www.postgresql.org/docs/18/sql-fetch.html +// https://www.postgresql.org/docs/18/sql-move.html +FetchCursorStatement FetchCursorStatement(): +{ + FetchCursorStatement statement = new FetchCursorStatement(); + String name; +} +{ + ( | { statement.setKind(FetchCursorStatement.Kind.MOVE); } ) + [ LOOKAHEAD({ isFetchDirectionAt(1) }) FetchCursorDirection(statement) ] + [ + LOOKAHEAD({ getToken(1).kind == K_FROM || getToken(1).kind == K_IN }) + ( + { statement.setFromKeyword(FetchCursorStatement.FromKeyword.FROM); } + | + { statement.setFromKeyword(FetchCursorStatement.FromKeyword.IN); } + ) + ] + name=CursorName() { statement.setCursorName(name); } + { return statement; } +} + +/** Only used where isFetchDirectionAt(1) holds. */ +void FetchCursorDirection(FetchCursorStatement statement): +{ Token token; Long count; } +{ + ( + { statement.setDirection(FetchDirection.NEXT); } + | + { statement.setDirection(FetchDirection.PRIOR); } + | + { statement.setDirection(FetchDirection.FIRST); } + | + { statement.setDirection(FetchDirection.LAST); } + | + { statement.setAll(true); } + | + count=FetchCount() { statement.setCount(count); } + | + // ABSOLUTE n or RELATIVE n + LOOKAHEAD({ isKeywordAhead("ABSOLUTE") || isKeywordAhead("RELATIVE") }) + token= count=FetchCount() + { + statement.setDirection(FetchDirection.valueOf(token.image.toUpperCase(Locale.ROOT))); + statement.setCount(count); + } + | + // FORWARD or BACKWARD [n | ALL] + token= + { statement.setDirection(FetchDirection.valueOf(token.image.toUpperCase(Locale.ROOT))); } + [ + LOOKAHEAD({ getToken(1).kind == K_ALL || isFetchCountAt(1) }) + ( { statement.setAll(true); } | count=FetchCount() { statement.setCount(count); } ) + ] + ) +} + +Long FetchCount(): +{ Token sign = null; Token digits; } +{ + [ sign="+" | sign="-" ] digits= + { return fetchCount(sign, digits); } +} + +// https://www.postgresql.org/docs/18/sql-close.html +CloseCursorStatement CloseCursorStatement(): +{ + CloseCursorStatement statement = new CloseCursorStatement(); + String name; +} +{ + + ( + LOOKAHEAD({ getToken(1).kind == K_ALL }) + | + name=CursorName() { statement.setCursorName(name); } + ) + { return statement; } +} + +SessionStatement SessionStatement(): +{ + SessionStatement sessionsStatement; + Token actionToken; + Token idToken = null; + String id = null; +} +{ + ( | ) + ( + actionToken = + | + actionToken = + | + actionToken = + | + actionToken = + | + actionToken = + ) + + [ + ( + idToken = + | + idToken = + | + idToken = + | + idToken = + ) { id = idToken.image; } + + ( + "." + ( + idToken = + | + idToken = + | + idToken = + | + idToken = + ) { id += "." + idToken.image; } + )? + ] + { + sessionsStatement = id!=null + ? new SessionStatement(actionToken.image, id) + : new SessionStatement(actionToken.image); + } + + // options + [ + LOOKAHEAD(2) + ( idToken = | idToken = ) + "=" + ( actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = ) + { sessionsStatement.putOption(idToken.image, actionToken.image ); } + + ( + "," + ( idToken = | idToken = ) + "=" + ( actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = ) + { sessionsStatement.putOption(idToken.image, actionToken.image ); } + )* + ] + + { + //linkAST(sessionsStatement,jjtThis); + return sessionsStatement; + } +} + +/** Preserves existing opaque SET forms while requiring their complete syntax. */ +private UnsupportedStatement OpaqueSetStatement(): { + Token statementStart = getToken(0); + SetIdentityInsertStatement identityInsert; + boolean repeatableRead = false; +} +{ + ( + LOOKAHEAD({ "IDENTITY_INSERT".equalsIgnoreCase(getToken(2).image) }) + identityInsert = SetIdentityInsert() + | + AccessKeyword("ISOLATION") [ ] + ( + LOOKAHEAD({ isKeywordAhead("DIRTY") }) AccessKeyword("DIRTY") + [ LOOKAHEAD({ getToken(1).kind == K_WITH && "WARNING".equalsIgnoreCase(getToken(2).image) }) + AccessKeyword("WARNING") ] + | LOOKAHEAD({ isKeywordAhead("COMMITTED") }) AccessKeyword("COMMITTED") + [ AccessKeyword("COMMITTED") ] + | LOOKAHEAD({ isKeywordAhead("CURSOR") }) AccessKeyword("CURSOR") AccessKeyword("STABILITY") + | { repeatableRead = true; } + ) + [ LOOKAHEAD({ isKeywordAhead("RETAIN") }) AccessKeyword("RETAIN") AccessKeyword("LOCKS") + { requireAccessSyntax(!repeatableRead, "REPEATABLE READ cannot retain update locks"); } ] + ) + { return captureStatementTokens(statementStart); } +} + +SetStatement Set(): { + SetStatement set; +} +{ + + ( + LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == S_IDENTIFIER + && SetStatement.OnOffOption.fromName(getToken(1).image) != null + && !"=".equals(getToken(2).image) && !".".equals(getToken(2).image) }) + set=SqlServerSetOnOffOptions() + | set=SetAssignments() + ) + { return set; } +} + +SetStatement SetAssignments(): { + SetStatement set = new SetStatement(); + Expression exp; + Token tk = null; +} +{ + [LOOKAHEAD(3) (tk = | tk = ) { set.setScope(SetScope.fromKeyword(tk.image)); } ] + SetAssignment(set) + ( + "," + ( LOOKAHEAD(3) SetAssignment(set) + | exp=Expression() { set.getExpressions(set.getCount() - 1).add(exp); widen(set.getExpressions(set.getCount() - 1), null, getToken(0)); } ) + )* + { return set; } +} + +/** The first and subsequent assignments use identical names and operators. */ +void SetAssignment(SetStatement set): +{ + Object name; + Expression expression; + SetStatement.AssignmentOperator operator = SetStatement.AssignmentOperator.NONE; +} +{ + ( + LOOKAHEAD({ (getToken(1).kind == K_CHARACTER && getToken(2).kind == K_SET) + || (isKeywordAhead("CHARSET") && !"=".equals(getToken(2).image) + && !":=".equals(getToken(2).image)) }) SetCharacterSet(set) + | + ( LOOKAHEAD({ isTimeZoneParameterAhead() }) name=ConfigurationParameterName() + | name=UserVariable() + | name=IdentifierChain() ) + [ "=" { operator = SetStatement.AssignmentOperator.EQUALS; } + | ":=" { operator = SetStatement.AssignmentOperator.COLON_EQUALS; } + | LOOKAHEAD({ getToken(1).kind == K_TO && (getAsString(Feature.dialect) == null + || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) }) + { operator = SetStatement.AssignmentOperator.TO; } ] + expression=SetAssignmentValue() + { + if (operator == SetStatement.AssignmentOperator.TO + && (name instanceof UserVariable || TIME_ZONE_PARAMETER.equals(name))) { + throw new ParseException("SET TO requires a configuration parameter name"); + } + set.add(name, linkElements(new ExpressionList(expression)), operator); + } + ) + { + for (int i = 0; i < set.getCount(); i++) { + if (set.getAssignmentOperator(i) == SetStatement.AssignmentOperator.TO + && set.getCount() != 1) { + throw new ParseException("SET TO accepts one configuration parameter with a value list"); + } + } + } +} + +/** ON is a setting value even when the preceding separator is TO. */ +Expression SetAssignmentValue(): +{ + Token value; + Expression expression; +} +{ + ( LOOKAHEAD({ getToken(1).kind == K_ON && getToken(0).kind == K_TO }) + value= { expression = linkToLastToken(new Column(value.image)); } + | expression=Expression() ) + { return expression; } +} + +/** Character set selection has a single name or DEFAULT, not an arbitrary expression. */ +void SetCharacterSet(SetStatement set): +{ + String name; + Token value; + Expression expression; +} +{ + ( { name = "CHARACTER SET"; } + | { name = "CHARSET"; } ) + ( value= { expression = stringValue(value); } + | (value= | value= | value=) + { expression = linkToLastToken(new Column(value.image)); } ) + { set.add(name, linkElements(new ExpressionList(expression)), false); } +} + +SetStatement SqlServerSetOnOffOptions(): { + SetStatement set = new SetStatement(); + List options = new ArrayList(); + SetStatement.OnOffOption option; + Token name; + boolean on; +} +{ + name= + { + option = accessEnum(SetStatement.OnOffOption.class, name.image); + options.add(option); + } + ( + "," name= + { + option = accessEnum(SetStatement.OnOffOption.class, name.image); + options.add(option); + } + )* + ( { on = true; } | { on = false; } ) + { + set.setOnOffOptions(new SetStatement.OnOffOptions(options, on)); + return set; + } +} + +ResetStatement Reset(): { + String name; + ResetStatement reset; + Token all; +} +{ + ( name = ConfigurationParameterName() | all = {name = all.image; } ) + { reset = new ResetStatement(name); return reset; } +} + +/** + * A configuration parameter as SET, RESET and SHOW name it. TIME ZONE is the parameter "Time Zone". + * PostgreSQL's RESET and SHOW also take the SQL standard's TRANSACTION ISOLATION LEVEL and SESSION + * AUTHORIZATION, which are read with Dialect.POSTGRESQL and without a dialect. SET enters this + * production only for TIME ZONE, since its other phrases set a transaction mode or the session + * user instead of a parameter. + */ +String ConfigurationParameterName(): +{ String name; } +{ + ( + LOOKAHEAD({ isTimeZoneParameterAhead() }) + { name = TIME_ZONE_PARAMETER; } + | + LOOKAHEAD({ isTransactionIsolationLevelParameterAhead() }) + ContextualKeyword("TRANSACTION") ContextualKeyword("ISOLATION") + { name = "TRANSACTION ISOLATION LEVEL"; } + | + LOOKAHEAD({ isSessionAuthorizationParameterAhead() }) + { name = "SESSION AUTHORIZATION"; } + | + name = RelObjectName() + ) + { return name; } +} + +// https://dev.mysql.com/doc/refman/8.4/en/reset-persist.html +ResetStatement ResetPersist(): +{ + ResetStatement reset = new ResetStatement((String) null).withPersist(true); + String name; + String part; + Token prefix; +} +{ + ContextualKeyword("PERSIST") + [ + // MySQL reserves IF, so IF without EXISTS starts the next statement + LOOKAHEAD({ getToken(1).kind == K_IF ? getToken(2).kind == K_EXISTS + : isIdentifierishNameToken(getToken(1)) }) + [ LOOKAHEAD(2) { reset.setIfExists(true); } ] + // MySQL's persisted_variable_ident: ident, ident.ident or DEFAULT.ident + ( + LOOKAHEAD(2) prefix= "." part=RelObjectName() { name = prefix.image + "." + part; } + | + LOOKAHEAD({ getToken(1).kind != K_DEFAULT }) + name=RelObjectName() [ "." part=RelObjectName() { name = name + "." + part; } ] + ) + { reset.setName(name); } + ] + { return reset; } +} + +RenameTableStatement RenameTableStatement(): { + RenameTableStatement renameTableStatement; + Table oldName; + Table newName; + boolean usingTableKeyword=false; + boolean usesIfExistsKeyword=false; + String waitDirective = ""; + Token token; +} +{ + + [ LOOKAHEAD(2) { usingTableKeyword = true; } ] + [ LOOKAHEAD(2) { usesIfExistsKeyword = true; } ] + oldName = Table() + [ ( + token= { waitDirective = "WAIT " + token.image; } + | + { waitDirective = "NOWAIT"; } + ) ] + + newName = Table() + + { + renameTableStatement = new RenameTableStatement(oldName, newName, usingTableKeyword, usesIfExistsKeyword, waitDirective); + } + + ( + "," + oldName = Table() + + newName = Table() + { + renameTableStatement.addTableNames(oldName, newName); + } + )* + + { + return renameTableStatement; + } +} + +/** + * DuckDB's CREATE [OR REPLACE] [TEMPORARY] {MACRO | FUNCTION} [IF NOT EXISTS] name + * (parameters) AS [TABLE] body [, (parameters) AS [TABLE] body ...]. + */ +CreateMacro CreateMacro(boolean isUsingOrReplace) #CreateMacro: +{ + CreateMacro createMacro = new CreateMacro(); + List overloads = new ArrayList(); + ObjectNames name; + CreateMacro.Overload overload; +} +{ + { createMacro.setOrReplace(isUsingOrReplace); } + [ ( | ) { createMacro.setTemporary(true); } ] + ( | { createMacro.setFunctionKeyword(true); } ) + [ LOOKAHEAD(3) { createMacro.setIfNotExists(true); } ] + name=RelObjectNames() { createMacro.setName(String.join(".", name.getNames())); } + overload=MacroOverload() { overloads.add(overload); } + ( LOOKAHEAD(2) "," overload=MacroOverload() { overloads.add(overload); } )* + { createMacro.setOverloads(overloads); } + { return createMacro; } +} + +/** + * One (parameters) AS [TABLE] body of a DuckDB macro, a parameter being name [type] [:= default]. + */ +CreateMacro.Overload MacroOverload(): +{ + CreateMacro.Overload overload = new CreateMacro.Overload(); + List parameters = new ArrayList(); + CreateMacro.Parameter parameter; + Expression expression; + Select select; +} +{ + "(" + [ + parameter=MacroParameter() { parameters.add(parameter); } + ( "," parameter=MacroParameter() { parameters.add(parameter); } )* + ] + ")" { overload.setParameters(parameters); } + + ( + LOOKAHEAD(2) select=Select() { overload.setSelect(select); } + | + expression=Expression() { overload.setExpression(expression); } + ) + { return overload; } +} + +CreateMacro.Parameter MacroParameter(): +{ + String name; + ColDataType type = null; + Expression defaultValue = null; +} +{ + name=RelObjectName() + [ LOOKAHEAD({ getToken(1).kind != K_COMMA && getToken(1).kind != CLOSING_BRACKET && !":=".equals(getToken(1).image) }) type=ColDataType() ] + [ ":=" defaultValue=Expression() ] + { return new CreateMacro.Parameter(name, type, defaultValue); } +} + +/** + * One option of PostgreSQL's COPY syntax from before 9.0, as copy_opt_item in its grammar. The + * options follow each other without commas, in any order. + */ +CopyLegacyOption CopyLegacyOption(): +{ + Token first = getToken(1); + CopyLegacyOption option; +} +{ + ( + { option = new CopyLegacyOption(CopyLegacyOption.Kind.BINARY); } + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.CSV); } + | + LOOKAHEAD({ isKeywordAhead("FREEZE") }) ContextualKeyword("FREEZE") + { option = new CopyLegacyOption(CopyLegacyOption.Kind.FREEZE); } + | + LOOKAHEAD({ isKeywordAhead("HEADER") }) ContextualKeyword("HEADER") + { option = new CopyLegacyOption(CopyLegacyOption.Kind.HEADER); } + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.DELIMITER); } + CopyLegacyOptionString(option) + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.NULL); } + CopyLegacyOptionString(option) + | + LOOKAHEAD({ isKeywordAhead("QUOTE") }) ContextualKeyword("QUOTE") + { option = new CopyLegacyOption(CopyLegacyOption.Kind.QUOTE); } + CopyLegacyOptionString(option) + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.ESCAPE); } + CopyLegacyOptionString(option) + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.ENCODING); } + CopyLegacyOptionString(option) + | + + ( + LOOKAHEAD({ isKeywordAhead("QUOTE") }) ContextualKeyword("QUOTE") + { option = new CopyLegacyOption(CopyLegacyOption.Kind.FORCE_QUOTE); } + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.FORCE_NOT_NULL); } + | + { option = new CopyLegacyOption(CopyLegacyOption.Kind.FORCE_NULL); } + ) + CopyLegacyOptionColumns(option) + ) + { return linked(option, first); } +} + +/** The string of a COPY option from before 9.0; AS may precede it except after ENCODING. */ +void CopyLegacyOptionString(CopyLegacyOption option): +{ Token token; } +{ + [ { option.setAsKeyword(true); } ] + token= + { + requireDdlSyntax(!option.isAsKeyword() || option.getKind().allowsAsKeyword(), + option.getKind().getKeyword() + " takes no AS"); + option.setValue(stringValue(token)); + } +} + +/** The columns of COPY's FORCE QUOTE, FORCE NOT NULL and FORCE NULL from before 9.0: names or *. */ +void CopyLegacyOptionColumns(CopyLegacyOption option): +{ String column; } +{ + "*" { option.setAllColumns(true); } + | + column=CopyLegacyColumnName() { option.addColumns(linkToLastToken(new Column(column))); } + ( "," column=CopyLegacyColumnName() { option.addColumns(linkToLastToken(new Column(column))); } )* +} + +/** A column of a COPY FORCE option, a PostgreSQL ColId without qualifier. */ +String CopyLegacyColumnName(): +{ String name; } +{ + name=RelObjectName() { requirePostgreSqlColId(name); return name; } +} + +/** + * DuckDB's COPY table [(columns)] FROM path [(options)] and + * COPY {table | (query)} TO path [(options)]. PostgreSQL's COPY [BINARY] table and its options + * from before 9.0, written without parentheses, are read with Dialect.POSTGRESQL and without a + * dialect. + */ +CopyStatement CopyStatement() #CopyStatement: +{ + CopyStatement copyStatement = new CopyStatement(); + ExpressionList columns = null; + List options = new ArrayList(); + String option; + CopyLegacyOption legacyOption; + Select select; + Table table; + Token token; +} +{ + + ( + LOOKAHEAD(2) "(" select=Select() ")" { copyStatement.setSelect(select); } + | + [ LOOKAHEAD({ isCopyBinaryAhead() }) { copyStatement.setBinary(true); } ] + table=Table() { copyStatement.setTable(table); } + [ LOOKAHEAD(2) "(" columns=ColumnList() ")" { copyStatement.setColumns(columns); } ] + ) + ( + { copyStatement.setFrom(true); } + | + + ) + ( + token= { copyStatement.setPath(token.image); } + | + token= { copyStatement.setPath(token.image); } + ) + [ LOOKAHEAD({ getToken(1).kind == K_WITH }) + { copyStatement.setWithKeyword(true); } ] + ( + LOOKAHEAD(2) "(" option=DatabaseOption() { options.add(option); } + ( "," option=DatabaseOption() { options.add(option); } )* + ")" { + if (copyStatement.isWithKeyword() + || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + requireDdlSyntax(!options.contains(""), "Expected a COPY option"); + } + copyStatement.setOptions(options); + } + | + ( LOOKAHEAD({ isCopyLegacyOptionAhead() }) + legacyOption=CopyLegacyOption() { copyStatement.addLegacyOptions(legacyOption); } )* + ) + { return copyStatement; } +} + +/** + * PREPARE name AS statement, storing a parameterised statement for later EXECUTE, or MySQL's + * PREPARE name FROM {'text' | @variable}. + */ +PrepareStatement PrepareStatement() #PrepareStatement: +{ + PrepareStatement prepareStatement = new PrepareStatement(); + ObjectNames name; + Statement statement; + List parameterTypes = new ArrayList(); + ColDataType parameterType; + Token text; + Expression source; +} +{ + name=RelObjectNames() + { prepareStatement.setName(String.join(".", name.getNames())); } + ( + LOOKAHEAD({ getToken(1).kind == K_FROM && isMySqlUtilityDialect() }) + + ( text= { source = stringValue(text); } | source=MySqlIntoVariable() ) + { prepareStatement.setSource(source); } + | + [ "(" parameterType=PrepareParameterType() { parameterTypes.add(parameterType); } + ( "," parameterType=PrepareParameterType() { parameterTypes.add(parameterType); } )* + ")" { prepareStatement.setParameterTypes(parameterTypes); } ] + statement=SingleStatement() { prepareStatement.setStatement(statement); } + ) + { return prepareStatement; } +} + +/** PostgreSQL UNKNOWN leaves a parameter type to be inferred from the prepared statement. */ +ColDataType PrepareParameterType(): +{ ColDataType type; Token token; } +{ + ( token= { type = linkToLastToken(new ColDataType(token.image)); } + | type=ColDataType() ) + { return type; } +} + +/** + * DEALLOCATE [PREPARE] name, or MySQL's DROP PREPARE name. + */ +DeallocateStatement DeallocateStatement() #DeallocateStatement: +{ + DeallocateStatement deallocateStatement = new DeallocateStatement(); + ObjectNames name; +} +{ + ( + + [ LOOKAHEAD(2) { deallocateStatement.setUsingPrepareKeyword(true); } ] + | + { deallocateStatement.setKeyword(DeallocateStatement.Keyword.DROP); } + ) + name=RelObjectNames() { deallocateStatement.setName(String.join(".", name.getNames())); } + { return deallocateStatement; } +} + +/** + * DuckDB's CONNECT target [AS alias], routing the session to a remote database. + */ +ConnectStatement ConnectStatement() #ConnectStatement: +{ + ConnectStatement connectStatement = new ConnectStatement(); + ObjectNames name; + Token token; +} +{ + + ( + token= { connectStatement.setTarget(token.image); } + | + name=RelObjectNames() { connectStatement.setTarget(String.join(".", name.getNames())); } + ) + [ name=RelObjectNames() { connectStatement.setAlias(String.join(".", name.getNames())); } ] + { return connectStatement; } +} + +/** + * DuckDB's DISCONNECT [name]. + */ +DisconnectStatement DisconnectStatement() #DisconnectStatement: +{ + DisconnectStatement disconnectStatement = new DisconnectStatement(); + ObjectNames name; +} +{ + + [ + LOOKAHEAD(2) + name=RelObjectNames() { disconnectStatement.setName(String.join(".", name.getNames())); } + ] + { return disconnectStatement; } +} + +/** + * DuckDB's ATTACH [DATABASE] [IF NOT EXISTS] path [AS alias] [(options)]. + */ +AttachStatement AttachStatement() #AttachStatement: +{ + AttachStatement attachStatement = new AttachStatement(); + List options = new ArrayList(); + String option; + ObjectNames name; + Token token; +} +{ + + // greedy: DATABASE right after ATTACH is the keyword, not the database name + [ LOOKAHEAD(2) { attachStatement.setUsingDatabaseKeyword(true); } ] + [ LOOKAHEAD(2) { attachStatement.setIfNotExists(true); } ] + ( + token= { attachStatement.setDatabasePath(token.image); } + | + name=RelObjectNames() { attachStatement.setDatabasePath(String.join(".", name.getNames())); } + ) + [ name=RelObjectNames() { attachStatement.setAlias(String.join(".", name.getNames())); } ] + [ + LOOKAHEAD(2) "(" option=DatabaseOption() { options.add(option); } + ( "," option=DatabaseOption() { options.add(option); } )* + ")" { attachStatement.setOptions(options); } + ] + { return attachStatement; } +} + +/** + * One ATTACH or COPY option, such as READ_ONLY, TYPE SQLITE or FORMAT PARQUET. Option names and + * values are free-form keywords, so the tokens are collected verbatim up to the next comma or the + * closing bracket. + */ +JAVACODE +String DatabaseOption() { + StringBuilder builder = new StringBuilder(); + int depth = 0; + while (true) { + Token token = getToken(1); + if (token == null || token.kind == EOF) { + break; + } + if (depth == 0 && (",".equals(token.image) || ")".equals(token.image))) { + break; + } + if ("(".equals(token.image)) { + depth++; + } else if (")".equals(token.image)) { + depth--; + } + getNextToken(); + if (builder.length() > 0) { + builder.append(" "); + } + builder.append(token.image); + } + return builder.toString(); +} + +/** + * DuckDB's DETACH [DATABASE] [IF EXISTS] name. + */ +DetachStatement DetachStatement() #DetachStatement: +{ + DetachStatement detachStatement = new DetachStatement(); + ObjectNames name; +} +{ + + // greedy: DATABASE right after DETACH is the keyword, not the database name + [ LOOKAHEAD(2) { detachStatement.setUsingDatabaseKeyword(true); } ] + [ LOOKAHEAD(2) { detachStatement.setIfExists(true); } ] + name=RelObjectNames() { detachStatement.setDatabaseName(String.join(".", name.getNames())); } + { return detachStatement; } +} + +/** + * MySQL INSTALL PLUGIN name SONAME 'library', UNINSTALL PLUGIN name, + * INSTALL COMPONENT 'urn'[, ...] [SET [GLOBAL | PERSIST] variable = value[, ...]] and + * UNINSTALL COMPONENT 'urn'[, ...]. isPluginStatementAhead() routes here. + */ +PluginStatement PluginStatement(): +{ + PluginStatement statement; + PluginStatement.Action action; + String name; + Token token; + ComponentVariable variable; +} +{ + ( + { action = PluginStatement.Action.INSTALL; } + | + // The action keeps the JAVACODE call from being the lookahead's first unit. + LOOKAHEAD({ isWordAt(1, "UNINSTALL") }) { action = PluginStatement.Action.UNINSTALL; } + consumeTransactionWord() + ) + ( + LOOKAHEAD({ isKeywordAhead("PLUGIN") }) ContextualKeyword("PLUGIN") + { statement = new PluginStatement(action, PluginStatement.ObjectType.PLUGIN); } + name=RelObjectName() { statement.setPluginName(name); } + [ LOOKAHEAD({ isKeywordAhead("SONAME") }) ContextualKeyword("SONAME") token= + { statement.setLibrary(mySqlTextString(token)); } ] + { + requireDdlSyntax((action == PluginStatement.Action.INSTALL) == (statement.getLibrary() != null), + "INSTALL PLUGIN names a library after SONAME, UNINSTALL PLUGIN does not"); + } + | + ContextualKeyword("COMPONENT") + { + statement = new PluginStatement(action, PluginStatement.ObjectType.COMPONENT); + requireDdlSyntax(!Dialect.MARIADB.name().equals(getAsString(Feature.dialect)), + "MariaDB has no components"); + } + token= { statement.addComponents(mySqlTextString(token)); } + ( "," token= { statement.addComponents(mySqlTextString(token)); } )* + [ + LOOKAHEAD(1) { requireDdlSyntax(action == PluginStatement.Action.INSTALL, "UNINSTALL COMPONENT does not accept SET"); } + variable=ComponentVariable() { statement.addVariables(variable); } + ( "," variable=ComponentVariable() { statement.addVariables(variable); } )* + ] + ) + { return statement; } +} + +/** One assignment of INSTALL COMPONENT ... SET: [GLOBAL | PERSIST] name[.name] {= | :=} {expr | ON}. */ +ComponentVariable ComponentVariable(): +{ + SetScope scope = SetScope.NONE; + String name; + String member = null; + SetStatement.AssignmentOperator operator; + Expression value; + Token first; +} +{ + // persist.variable is a name + [ LOOKAHEAD({ (getToken(1).kind == K_GLOBAL || isKeywordAhead("PERSIST")) && !".".equals(getToken(2).image) }) + ( { scope = SetScope.GLOBAL; } | ContextualKeyword("PERSIST") { scope = SetScope.PERSIST; } ) ] + ( + LOOKAHEAD(1) "." member=RelObjectName() { name = "DEFAULT"; } + | + name=RelObjectName() [ "." member=RelObjectName() ] + { requireDdlSyntax(!isComponentVariableScopeWord(name, member != null), "Expected a variable name but found " + name); } + ) + ( "=" { operator = SetStatement.AssignmentOperator.EQUALS; } + | ":=" { operator = SetStatement.AssignmentOperator.COLON_EQUALS; } ) + ( LOOKAHEAD({ getToken(1).kind == K_ON }) { value = linkToLastToken(new Column("ON")); } + | { first = getToken(1); } value=Expression() { requireComponentVariableValue(first); } ) + { + return new ComponentVariable(member == null ? name : name + "." + member, value) + .withScope(scope).withOperator(operator); + } +} + +/** + * DuckDB's [FORCE] INSTALL extension [FROM repository] and LOAD extension. + */ +ExtensionStatement ExtensionStatement() #ExtensionStatement: +{ + ExtensionStatement extensionStatement = new ExtensionStatement(); + ObjectNames name; + Token token; +} +{ + [ { extensionStatement.setForce(true); } ] + ( + { extensionStatement.setOperation(ExtensionStatement.Operation.INSTALL); } + | + { extensionStatement.setOperation(ExtensionStatement.Operation.LOAD); } + ) + ( + token= { extensionStatement.setExtensionName(token.image); } + | + name=RelObjectNames() { extensionStatement.setExtensionName(String.join(".", name.getNames())); } + ) + [ + LOOKAHEAD(2) + ( + token= { extensionStatement.setRepository(token.image); } + | + name=RelObjectNames() { extensionStatement.setRepository(String.join(".", name.getNames())); } + ) + ] + { return extensionStatement; } +} + +/** + * DuckDB/SQLite PRAGMA name [(arguments) | = value]. + */ +PragmaStatement PragmaStatement() #PragmaStatement: +{ + PragmaStatement pragmaStatement = new PragmaStatement(); + ObjectNames name; + ExpressionList parameters; + Expression value; +} +{ + name=RelObjectNames() + { pragmaStatement.setName(String.join(".", name.getNames())); } + // greedy: parentheses right after the pragma name are its arguments + [ + LOOKAHEAD(2) + ( + "(" parameters=ExpressionList() ")" { pragmaStatement.setParameters(parameters); } + | + "=" value=SimpleExpression() { pragmaStatement.setValue(value); } + ) + ] + { return pragmaStatement; } +} + +/** + * BigQuery's LOAD DATA {INTO | OVERWRITE} table [(column_definitions)] [OPTIONS (option_list)] + * FROM FILES (file_options) [WITH PARTITION COLUMNS] [WITH CONNECTION connection]. + */ +LoadDataStatement LoadDataStatement() #LoadDataStatement: +{ + LoadDataStatement loadDataStatement = new LoadDataStatement(); + List columnDefinitions = new ArrayList(); + ColumnDefinition columnDefinition; + ExpressionList options; + String connectionName; + Table table; +} +{ + + ( | { loadDataStatement.setOverwrite(true); } ) + table=Table() { loadDataStatement.setTable(table); } + [ + LOOKAHEAD(2) "(" + columnDefinition=ColumnDefinition() { columnDefinitions.add(columnDefinition); } + ( "," columnDefinition=ColumnDefinition() { columnDefinitions.add(columnDefinition); } )* + ")" { loadDataStatement.setColumnDefinitions(columnDefinitions); } + ] + [ + LOOKAHEAD({ isKeywordAhead("OPTIONS") }) + "(" options=ExpressionList() ")" { loadDataStatement.setOptions(options); } + ] + + LOOKAHEAD({ isKeywordAhead("FILES") }) + "(" options=ExpressionList() ")" { loadDataStatement.setFileOptions(options); } + [ + LOOKAHEAD(2) + { loadDataStatement.setWithPartitionColumns(true); } + ] + [ + LOOKAHEAD({ isBigQueryWithConnectionAhead() }) + connectionName=BigQueryWithConnection() { loadDataStatement.setConnectionName(connectionName); } + ] + { return loadDataStatement; } +} + +/** BigQuery's WITH CONNECTION connection_name of LOAD DATA and EXPORT DATA. */ +String BigQueryWithConnection(): +{ ObjectNames connectionName; } +{ + ContextualKeyword("CONNECTION") connectionName=RelObjectNames() + { return String.join(".", connectionName.getNames()); } +} + +/** + * MySQL's LOAD {DATA | XML} [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name' + * [REPLACE | IGNORE] INTO TABLE tbl_name [PARTITION (names)] [CHARACTER SET charset_name] + * [ROWS IDENTIFIED BY 'tag'] [FIELDS ...] [LINES ...] [IGNORE number {LINES | ROWS}] + * [(col_name_or_user_var, ...)] [SET col_name = {expr | DEFAULT}, ...]. One grammar serves + * DATA and XML, as in the server. + * + * https://dev.mysql.com/doc/refman/8.4/en/load-data.html + * https://dev.mysql.com/doc/refman/8.4/en/load-xml.html + */ +MySqlLoadDataStatement MySqlLoadDataStatement(): +{ + MySqlLoadDataStatement statement = new MySqlLoadDataStatement(); + Token token; + Table table; + List partitions; + boolean charsetKeyword; + MySqlFileFormat fileFormat; + ExpressionList columns; + List updateSets; +} +{ + ( | { statement.setFormat(MySqlLoadDataStatement.Format.XML); } ) + [ + { statement.setLockOption(MySqlLoadDataStatement.LockOption.LOW_PRIORITY); } + | + LOOKAHEAD({ isKeywordAhead("CONCURRENT") }) ContextualKeyword("CONCURRENT") + { statement.setLockOption(MySqlLoadDataStatement.LockOption.CONCURRENT); } + ] + [ { statement.setLocal(true); } ] + ContextualKeyword("INFILE") token= { statement.setFileName(stringValue(token)); } + [ + { statement.setDuplicateHandling(CreateTable.DuplicateHandling.REPLACE); } + | + { statement.setDuplicateHandling(CreateTable.DuplicateHandling.IGNORE); } + ] + table=Table() { statement.setTable(table); } + [ "(" partitions=PartitionNamesList() ")" { statement.setPartitions(partitions); } ] + [ + LOOKAHEAD({ isMySqlCharacterSetClauseAhead() }) + charsetKeyword=MySqlCharacterSetKeyword() token=CharacterSetName() + { statement.setCharacterSet(token.image); statement.setUseCharsetKeyword(charsetKeyword); } + ] + [ token= { statement.setRowsIdentifiedBy(stringValue(token)); } ] + [ fileFormat=MySqlFileFormat() { statement.setFileFormat(fileFormat); } ] + [ + token= { statement.setIgnoreCount(mySqlIgnoreCount(token)); } + ( | { statement.setIgnoreUnit(MySqlLoadDataStatement.IgnoreUnit.ROWS); } ) + ] + [ LOOKAHEAD(1, "(") columns=MySqlLoadDataColumns() { statement.setColumns(columns); } ] + [ LOOKAHEAD(1, ) updateSets=MySqlLoadDataSets() { statement.setUpdateSets(updateSets); } ] + { return statement; } +} + +/** The column list of LOAD DATA: column names and user variables, possibly none. */ +ExpressionList MySqlLoadDataColumns(): +{ + ExpressionList columns = new ExpressionList(); + Expression column; +} +{ + "(" + [ + ( column=MySqlIntoVariable() | column=Column() ) { columns.add(column); } + ( "," ( column=MySqlIntoVariable() | column=Column() ) { columns.add(column); } )* + ] + ")" + { return linkElements(columns); } +} + +/** The SET clause of LOAD DATA: each assignment sets one column to an expression or DEFAULT. */ +List MySqlLoadDataSets(): +{ + List updateSets = new ArrayList(); + UpdateSet updateSet; + Column column; + Expression value; +} +{ + column=Column() "=" value=Expression() + { + updateSet = new UpdateSet(column, value); + linkElements(updateSet.getColumns()); + linkElements(updateSet.getValues()); + updateSets.add(updateSet); + } + ( + "," column=Column() "=" value=Expression() + { + updateSet = new UpdateSet(column, value); + linkElements(updateSet.getColumns()); + linkElements(updateSet.getValues()); + updateSets.add(updateSet); + } + )* + { return updateSets; } +} + +/** MySQL's CHARACTER SET or CHARSET before a character set name: true for CHARSET. */ +boolean MySqlCharacterSetKeyword(): +{ boolean charsetKeyword = false; } +{ + ( | ContextualKeyword("CHARSET") { charsetKeyword = true; } ) + { return charsetKeyword; } +} + +/** + * The FIELDS (or COLUMNS) and LINES clauses of MySQL's LOAD DATA and SELECT ... INTO OUTFILE. + * Each clause takes at least one subclause, in any order and possibly repeated, as in the + * server's grammar; the last value of a subclause wins. + */ +MySqlFileFormat MySqlFileFormat(): +{ + MySqlFileFormat fileFormat = new MySqlFileFormat(); + Token first = getToken(1); +} +{ + ( + ( + { fileFormat.setFieldsKeyword(MySqlFileFormat.FieldsKeyword.FIELDS); } + | + { fileFormat.setFieldsKeyword(MySqlFileFormat.FieldsKeyword.COLUMNS); } + ) + ( LOOKAHEAD(1) MySqlFieldsSubclause(fileFormat) )+ + [ LOOKAHEAD(1, ) MySqlLinesClause(fileFormat) ] + | + MySqlLinesClause(fileFormat) + ) + { linkAST(fileFormat, first); return fileFormat; } +} + +void MySqlFieldsSubclause(MySqlFileFormat fileFormat): +{ Token token; } +{ + ( + token= { fileFormat.setFieldsTerminatedBy(stringValue(token)); } + | + // OPTIONALLY stays set when a later ENCLOSED BY replaces the character, as in the server + token= + { fileFormat.setFieldsOptionallyEnclosed(true); fileFormat.setFieldsEnclosedBy(stringValue(token)); } + | + token= { fileFormat.setFieldsEnclosedBy(stringValue(token)); } + | + token= { fileFormat.setFieldsEscapedBy(stringValue(token)); } + ) +} + +void MySqlLinesClause(MySqlFileFormat fileFormat): +{ Token token; } +{ + + ( + LOOKAHEAD(1) + ( + token= { fileFormat.setLinesStartingBy(stringValue(token)); } + | + token= { fileFormat.setLinesTerminatedBy(stringValue(token)); } + ) + )+ +} + +/** + * BigQuery's EXPORT DATA [WITH CONNECTION connection] OPTIONS (option_list) AS query. + */ +ExportDataStatement ExportDataStatement() #ExportDataStatement: +{ + ExportDataStatement exportDataStatement = new ExportDataStatement(); + ExpressionList options; + String connectionName; + Select select; +} +{ + + [ + LOOKAHEAD({ isBigQueryWithConnectionAhead() }) + connectionName=BigQueryWithConnection() { exportDataStatement.setConnectionName(connectionName); } + ] + [ + LOOKAHEAD({ isKeywordAhead("OPTIONS") }) + "(" options=ExpressionList() ")" + { exportDataStatement.setOptions(options); } + ] + select=Select() { exportDataStatement.setSelect(select); } + { return exportDataStatement; } +} + +/** + * BigQuery's ASSERT expression [AS description] debugging statement. + */ +AssertStatement AssertStatement() #AssertStatement: +{ + AssertStatement assertStatement = new AssertStatement(); + Expression expression; + Token token; +} +{ + expression=Expression() { assertStatement.setExpression(expression); } + [ token= + { assertStatement.setDescription(stringValue(token)); } ] + { return assertStatement; } +} + +PurgeStatement PurgeStatement(): { + PurgeStatement purgeStatement = null; + Table table; + Index index; + String tableSpaceName; + String userName = null; + PurgeObjectType logs; + Token logName; + Expression before; +} +{ + + ( + // https://dev.mysql.com/doc/refman/8.4/en/purge-binary-logs.html + LOOKAHEAD({ isPurgeLogsAhead() }) + ( { logs = PurgeObjectType.BINARY_LOGS; } + | ContextualKeyword("MASTER") { logs = PurgeObjectType.MASTER_LOGS; } ) + ContextualKeyword("LOGS") + ( + logName= + { purgeStatement = new PurgeStatement(logs, PurgeStatement.LogBound.TO, replicationString(logName)); } + | + before=Expression() + { + requireReplicationSyntax(!containsSubquery(before), "PURGE BINARY LOGS BEFORE takes no subquery"); + purgeStatement = new PurgeStatement(logs, PurgeStatement.LogBound.BEFORE, before); + } + ) + | + table=Table() { purgeStatement = new PurgeStatement(table); } + | + index=Index() { purgeStatement = new PurgeStatement(index); } + | + { purgeStatement = new PurgeStatement(PurgeObjectType.RECYCLEBIN); } + | + { purgeStatement = new PurgeStatement(PurgeObjectType.DBA_RECYCLEBIN); } + | + // the names take non-reserved keywords such as STOP, which were plain identifiers before + tableSpaceName=RelObjectName() [ userName=RelObjectName() ] { + purgeStatement = new PurgeStatement(PurgeObjectType.TABLESPACE, tableSpaceName, userName); + } + ) + + { + return purgeStatement; + } +} + +/** FOR CHANNEL 'channel' of MySQL's replication statements; the channel is a string. */ +StringValue ReplicationChannel(): +{ Token token; } +{ + ContextualKeyword("CHANNEL") token= + { return replicationString(token); } +} + +/** IO_THREAD and SQL_THREAD of START REPLICA and STOP REPLICA. */ +void ReplicaThreads(List threads): +{ Token token; } +{ + token= { threads.add(replicationEnum(ReplicaThread.class, token.image)); } + ( "," token= { threads.add(replicationEnum(ReplicaThread.class, token.image)); } )* +} + +/** + * A value of a MySQL replication option: a string, an unsigned number, NULL, or one of the + * keywords ON, OFF, LOCAL, STREAM and GENERATE, which are kept as a Column like ON in + * ReplicationOptionValue(). The option checks which of them it takes. + */ +Expression MySqlReplicationValue(): +{ Token token; Expression value; } +{ + ( + token= { value = replicationString(token); } + | token= { value = linkToLastToken(new LongValue(token.image)); } + | token= { value = linkToLastToken(new DoubleValue(token.image)); } + | { value = linkToLastToken(new NullValue()); } + | ( token= | token= | token= | token= ) + { value = linkToLastToken(new Column(token.image)); } + | LOOKAHEAD({ isKeywordAhead("GENERATE") }) token= + { value = linkToLastToken(new Column(token.image)); } + ) + { return value; } +} + +/** The server IDs of IGNORE_SERVER_IDS = (id [, id] ...), which may be empty. */ +ParenthesedExpressionList ReplicationServerIds(): +{ ParenthesedExpressionList ids = new ParenthesedExpressionList(); Token open; Token token; } +{ + open="(" + [ + ( token= { ids.add(linkToLastToken(new LongValue(token.image))); } + | token= { ids.add(linkToLastToken(new DoubleValue(token.image))); } ) + ( "," + ( token= { ids.add(linkToLastToken(new LongValue(token.image))); } + | token= { ids.add(linkToLastToken(new DoubleValue(token.image))); } ) )* + ] + ")" + { linkAST(ids, open); return ids; } +} + +// https://dev.mysql.com/doc/refman/8.4/en/change-replication-source-to.html +ReplicationSourceOption ReplicationSourceOption(): +{ Token name; Expression value = null; UserAccount account = null; ReplicationSourceOption.Kind kind; } +{ + ( + LOOKAHEAD({ isKeywordAhead("PRIVILEGE_CHECKS_USER") }) + name= "=" + ( { value = linkToLastToken(new NullValue()); } + | account=MySqlAccountName() { requirePrivilegeChecksAccount(account); } ) + | + LOOKAHEAD({ isKeywordAhead("IGNORE_SERVER_IDS") }) + name= "=" value=ReplicationServerIds() + | + name= "=" value=MySqlReplicationValue() + ) + { + kind = replicationEnum(ReplicationSourceOption.Kind.class, name.image); + if (account != null) { + return new ReplicationSourceOption(name.image, account); + } + requireReplicationSyntax(kind.getValueType().accepts(value), + "Unexpected value for " + name.image + ": " + value); + return new ReplicationSourceOption(name.image, kind, value); + } +} + +/** A database name of a replication filter. */ +String ReplicationFilterDatabase(): +{ String name; } +{ + name=RelObjectName() { return name; } +} + +/** A table of a replication filter, which names its database. */ +Table ReplicationFilterTable(): +{ Token first = getToken(1); String database; String name; Table table; } +{ + database=RelObjectName() "." name=RelObjectName() + { + table = createTable(Arrays.asList(database, name)); + linkAST(table, first); + return table; + } +} + +// https://dev.mysql.com/doc/refman/8.4/en/change-replication-filter.html +ReplicationFilter ReplicationFilter(): +{ Token name; Token token; ReplicationFilter filter; Table table; String from; String to; } +{ + name= { filter = new ReplicationFilter(replicationEnum(ReplicationFilter.Kind.class, name.image)); } + "=" "(" + [ + "(" from=ReplicationFilterDatabase() "," to=ReplicationFilterDatabase() ")" + { filter.getRewrites().add(new ReplicationFilter.DatabaseRewrite(from, to)); } + ( "," "(" from=ReplicationFilterDatabase() "," to=ReplicationFilterDatabase() ")" + { filter.getRewrites().add(new ReplicationFilter.DatabaseRewrite(from, to)); } )* + | + token= { filter.getPatterns().add(replicationString(token)); } + ( "," token= { filter.getPatterns().add(replicationString(token)); } )* + | + LOOKAHEAD(2) table=ReplicationFilterTable() { filter.getTables().add(table); } + ( "," table=ReplicationFilterTable() { filter.getTables().add(table); } )* + | + from=ReplicationFilterDatabase() { filter.getDatabases().add(from); } + ( "," from=ReplicationFilterDatabase() { filter.getDatabases().add(from); } )* + ] + ")" + { + requireReplicationSyntax(filter.getValues().size() == filter.getDatabases().size() + + filter.getTables().size() + filter.getPatterns().size() + filter.getRewrites().size(), + "Unexpected list for " + name.image); + return filter; + } +} + +Statement ChangeReplicationStatement(): +{ + ChangeReplicationSourceStatement source = new ChangeReplicationSourceStatement(); + ChangeReplicationFilterStatement filters = new ChangeReplicationFilterStatement(); + ReplicationSourceOption option; + ReplicationFilter filter; + StringValue channel; + Statement result; +} +{ + ContextualKeyword("REPLICATION") + ( + ContextualKeyword("SOURCE") + option=ReplicationSourceOption() { source.getOptions().add(option); } + ( "," option=ReplicationSourceOption() { source.getOptions().add(option); } )* + [ channel=ReplicationChannel() { source.setChannel(channel); } ] + { result = source; } + | + + filter=ReplicationFilter() { filters.getFilters().add(filter); } + ( "," filter=ReplicationFilter() { filters.getFilters().add(filter); } )* + [ channel=ReplicationChannel() { filters.setChannel(channel); } ] + { result = filters; } + ) + { return result; } +} + +/** A condition of START REPLICA ... UNTIL. */ +ReplicaUntilOption ReplicaUntilOption(): +{ Token name; Expression value = null; ReplicaUntilOption.Kind kind; } +{ + name= { kind = replicationEnum(ReplicaUntilOption.Kind.class, name.image); } + [ "=" value=MySqlReplicationValue() ] + { + requireReplicationSyntax(kind.getValueType().accepts(value), + "Unexpected value for " + name.image + ": " + value); + return new ReplicaUntilOption(name.image, kind, value); + } +} + +// https://dev.mysql.com/doc/refman/8.4/en/start-replica.html +StartReplicaStatement StartReplicaStatement(): +{ StartReplicaStatement statement = new StartReplicaStatement(); ReplicaUntilOption until; Token token; StringValue channel; } +{ + ContextualKeyword("REPLICA") + [ LOOKAHEAD({ isKeywordAhead("IO_THREAD") || isKeywordAhead("SQL_THREAD") }) ReplicaThreads(statement.getThreads()) ] + [ + LOOKAHEAD({ isKeywordAhead("UNTIL") }) ContextualKeyword("UNTIL") + until=ReplicaUntilOption() { statement.getUntilOptions().add(until); } + ( + "," until=ReplicaUntilOption() + { + requireReplicationSyntax(until.getKind().isLogCoordinate(), + "Only a log file or position may follow another UNTIL condition"); + statement.getUntilOptions().add(until); + } + )* + ] + [ "=" token= { statement.setUser(replicationString(token)); } ] + [ "=" token= { statement.setPassword(replicationString(token)); } ] + [ LOOKAHEAD({ isKeywordAhead("DEFAULT_AUTH") }) ContextualKeyword("DEFAULT_AUTH") "=" + token= { statement.setDefaultAuth(replicationString(token)); } ] + [ LOOKAHEAD({ isKeywordAhead("PLUGIN_DIR") }) ContextualKeyword("PLUGIN_DIR") "=" + token= { statement.setPluginDir(replicationString(token)); } ] + [ channel=ReplicationChannel() { statement.setChannel(channel); } ] + { return statement; } +} + +// https://dev.mysql.com/doc/refman/8.4/en/stop-replica.html +StopReplicaStatement StopReplicaStatement(): +{ StopReplicaStatement statement = new StopReplicaStatement(); StringValue channel; } +{ + ContextualKeyword("REPLICA") + [ LOOKAHEAD({ isKeywordAhead("IO_THREAD") || isKeywordAhead("SQL_THREAD") }) ReplicaThreads(statement.getThreads()) ] + [ channel=ReplicationChannel() { statement.setChannel(channel); } ] + { return statement; } +} + +/** A reset_option of MySQL's RESET: BINARY LOGS AND GTIDS [TO n] or REPLICA [ALL] [FOR CHANNEL c]. */ +ResetReplicationStatement.Option ResetReplicationOption(): +{ ResetReplicationStatement.Option option; Token token; StringValue channel; } +{ + ( + ContextualKeyword("LOGS") ContextualKeyword("GTIDS") + { option = new ResetReplicationStatement.Option(ResetReplicationStatement.Kind.BINARY_LOGS_AND_GTIDS); } + [ token= { option.setBinaryLogIndex(linkToLastToken(new LongValue(token.image))); } ] + | + ContextualKeyword("REPLICA") + { option = new ResetReplicationStatement.Option(ResetReplicationStatement.Kind.REPLICA); } + [ { option.setAll(true); } ] + [ channel=ReplicationChannel() { option.setChannel(channel); } ] + ) + { return option; } +} + +// https://dev.mysql.com/doc/refman/8.4/en/reset.html +ResetReplicationStatement ResetReplicationStatement(): +{ ResetReplicationStatement statement = new ResetReplicationStatement(); ResetReplicationStatement.Option option; } +{ + option=ResetReplicationOption() { statement.getOptions().add(option); } + ( "," option=ResetReplicationOption() { statement.getOptions().add(option); } )* + { return statement; } +} + +DescribeStatement Describe(): { + Table table; + Select select; + DescribeStatement stmt = new DescribeStatement(); + Token tk = null; + Expression pattern; +} { + (tk= | tk=) + ( + // DuckDB describes the result of a query, not only a table + LOOKAHEAD({ getToken(1).kind == K_SELECT || getToken(1).kind == K_WITH + || getToken(1).kind == K_FROM || getToken(1).kind == OPENING_BRACKET }) + select = Select() { stmt.setDescribeType(tk.image).setSelect(select); } + | + table = Table() { stmt.setDescribeType(tk.image).setTable(table); } + [ LOOKAHEAD(DescribeColumnPattern(), { isDescribeColumnAhead() }) + pattern=DescribeColumnPattern() { stmt.setColumnPattern(pattern); } ] + ) + { + return stmt; + } +} + +/** MySQL's column name or wildcard string after the table of DESCRIBE or EXPLAIN. */ +Expression DescribeColumnPattern(): +{ + Token token; + String name; + Expression pattern; +} +{ + ( + token= { pattern = stringValue(token); } + | + token= { pattern = linkToLastToken(new HexValue(token.image)); } + | + name=RelObjectName() { pattern = linkToLastToken(new Column(name)); } + ) + { return pattern; } +} + +/** + * MySQL's EXPLAIN, also spelled DESCRIBE or DESC: ANALYZE [FORMAT = name], or + * [FORMAT = name] [INTO @variable], then FOR CONNECTION id or + * [FOR {SCHEMA | DATABASE} name] and the explained statement. + */ +ExplainStatement MySqlExplain(): +{ + Token keyword; + ExplainStatement explain; + List options = new ArrayList(); + ExplainStatement.Option option; + UserVariable variable; + Token token; + Expression connection; + String schema; + Statement statement; +} +{ + ( keyword= | keyword= | keyword= ) + { explain = new ExplainStatement(keyword.image); } + ( + + { options.add(new ExplainStatement.Option(ExplainStatement.OptionType.ANALYZE)); } + [ option=MySqlExplainFormat() { options.add(option); } ] + | + [ option=MySqlExplainFormat() { options.add(option); } ] + [ variable=MySqlIntoVariable() { explain.setIntoVariable(variable); } ] + ) + { explain.setOptionList(options); } + ( + LOOKAHEAD({ getToken(1).kind == K_FOR && "CONNECTION".equalsIgnoreCase(getToken(2).image) }) + AccessKeyword("CONNECTION") + ( token= { connection = new LongValue(token.image); } + | token= { connection = new HexValue(token.image); } ) + { explain.setConnectionId(linkToLastToken(connection)); } + | + [ + ( { explain.setSchemaKeyword(true); } | ) + ( schema=RelObjectName() | token= { schema = token.image; } ) + { explain.setSchemaName(schema); } + ] + statement=ExplainableStatement() { explain.setStatement(statement); } + ) + { return explain; } +} + +/** MySQL's FORMAT = name, with the name unquoted or quoted. */ +ExplainStatement.Option MySqlExplainFormat(): +{ + Token token; +} +{ + "=" + ( token= | token= | token= | token= ) + { return mySqlExplainFormat(token); } +} + +/** The statement EXPLAIN explains: a query or a DML statement. */ +Statement ExplainableStatement(): +{ + List> with = null; + Statement statement; + Token first = getToken(1); +} +{ + ( + LOOKAHEAD({ getToken(1).kind == K_REPLACE && isMySqlUtilityDialect() }) + statement = Upsert() + | + [ LOOKAHEAD(2) with=WithList() ] + ( + statement = SelectWithWithItems( with ) { if (with != null) { widen(statement, first, null); } } + | statement = InsertWithWithItems( with ) + | statement = UpdateWithWithItems( with ) + | statement = DeleteWithWithItems( with ) + | statement = Merge( with ) + ) + ) + { + linkStatement(statement, first); + return statement; + } +} + +ExplainStatement Explain(): +{ + Token tk; + Statement statement; + Table table; + List options; + ExplainStatement es; + boolean parenthesized = false; + Expression pattern; +} +{ + ( tk= | tk = ) + ( + LOOKAHEAD(3)( + ( + LOOKAHEAD(2) "(" options = PostgresqlExplainOptions() ")" { parenthesized = true; } + | options = ExplainStatementOptions() + ) + statement = ExplainableStatement() + { + es = new ExplainStatement(tk.image, statement, options); + es.setParenthesizedOptions(parenthesized); + } + ) + | + ( + table=Table( ) { es = new ExplainStatement(tk.image, table); } + [ LOOKAHEAD(DescribeColumnPattern(), { isDescribeColumnAhead() }) + pattern=DescribeColumnPattern() + { + requireDdlSyntax(tk.kind == K_EXPLAIN, "SUMMARIZE takes no column"); + es.setColumnPattern(pattern); + } ] + ) + ) + { + if (parenthesized || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + validatePostgresqlExplain(es); + } + return es; + } +} + +List PostgresqlExplainOptions(): +{ + List options = new ArrayList(); + ExplainStatement.Option option; +} +{ + option = PostgresqlExplainOption() { options.add(option); } + ( "," option = PostgresqlExplainOption() { options.add(option); } )* + { return options; } +} + +/** An element of the shared utility option list, kept in the EXPLAIN option model. */ +ExplainStatement.Option PostgresqlExplainOption(): +{ + UtilityOption option; +} +{ + option = UtilityOption() + { + return new ExplainStatement.Option(postgresqlExplainOptionType(option.getName())) + .withValue(option.getValue()); + } +} + +/** + * Boolean values in the legacy unparenthesized syntax. + */ +String ExplainOptionBoolean(): +{ + Token tk = null; +} +{ + [( tk= | tk= | tk= | tk= )] + { + return tk != null ? tk.image : null; + } +} + +/** + * Preserve the optional format in the legacy unparenthesized syntax. + */ +String ExplainFormatOption(): +{ + Token tk = null; +} +{ + [( tk= | tk= | tk= )] + { + return tk != null ? tk.image : null; + } +} + +/** + * Options for explain, see https://www.postgresql.org/docs/9.1/sql-explain.html + */ +List ExplainStatementOptions(): +{ + List options = new ArrayList(); + ExplainStatement.Option option = null; + Token token = null; + String value = null; +} +{ + ( + ( value=ExplainOptionBoolean() + { + option = new ExplainStatement.Option(ExplainStatement.OptionType.ANALYZE); + option.setValue(value); + options.add(option); + } + ) + | + ( value=ExplainOptionBoolean() + { + option = new ExplainStatement.Option(ExplainStatement.OptionType.BUFFERS); + option.setValue(value); + options.add(option); + } + ) + | + ( value=ExplainOptionBoolean() + { + option = new ExplainStatement.Option(ExplainStatement.OptionType.COSTS); + option.setValue(value); + options.add(option); + } + ) + | + ( value=ExplainOptionBoolean() + { + option = new ExplainStatement.Option(ExplainStatement.OptionType.VERBOSE); + option.setValue(value); + options.add(option); + } + ) + | + ( value=ExplainFormatOption() + { + option = new ExplainStatement.Option(ExplainStatement.OptionType.FORMAT); + option.setValue(value); + options.add(option); + } + ) + | + ( + { option = new ExplainStatement.Option(ExplainStatement.OptionType.PLAN); } + [ { option = new ExplainStatement.Option(ExplainStatement.OptionType.PLAN_FOR); } ] + + value=ExplainFormatOption() + { + option.setValue(value); + options.add(option); + } + ) + )* //zero or many times those productions + { + return options; + } +} + +SetIdentityInsertStatement SetIdentityInsert(): { + Table table; + boolean on; +} +{ + AccessKeyword("IDENTITY_INSERT") table=Table() + { + requireAccessSyntax(table.getNameParts().size() <= 3, + "IDENTITY_INSERT requires a table name with at most three parts"); + } + ( { on = true; } | { on = false; } ) + { + return new SetIdentityInsertStatement(table, on); + } +} + +UseStatement Use(): { + String name; + boolean hasSchemaKeyword = false; +} +{ + [ LOOKAHEAD(2) { hasSchemaKeyword = true; } ] name = RelObjectName() + { + return new UseStatement(name, hasSchemaKeyword); + } +} + +Statement Show(): +{ + Statement statement; + List captureRest; + String name; + Token first; +} +{ + { first = getToken(1); } + ( + // A typed form must span the whole statement; other dialects' trailing clauses + // (e.g. Snowflake IN SCHEMA s, ClickHouse FORMAT f) still fall back to captureRest(). + LOOKAHEAD(ShowColumns() ShowStatementEnd()) statement = ShowColumns() + | + LOOKAHEAD(ShowIndex() ShowStatementEnd()) statement = ShowIndex() + | + LOOKAHEAD(2) statement = ShowTables() + | + LOOKAHEAD(ShowTableStatus() ShowStatementEnd(), + { getToken(1).kind == K_TABLE && "STATUS".equalsIgnoreCase(getToken(2).image) }) + statement = ShowTableStatus() + | + LOOKAHEAD(ShowCreate() ShowStatementEnd()) statement = ShowCreate() + | + // PostgreSQL's SHOW TIME ZONE, TRANSACTION ISOLATION LEVEL and SESSION AUTHORIZATION + LOOKAHEAD(ConfigurationParameterName() ShowStatementEnd(), + { isConfigurationParameterPhraseAhead() && isPostgreSqlUtilityDialect() }) + name = ConfigurationParameterName() { statement = new ShowStatement(name); } + | + LOOKAHEAD(MySqlShow() ShowStatementEnd(), { isMySqlShowDialect() }) + statement = MySqlShow() + { + if (getAsString(Feature.dialect) == null && token == first) { + // without a dialect, a single word stays a ShowStatement as before + statement = new ShowStatement(first.image); + } + } + | + // any of the RDBMS specific SHOW syntax + captureRest = captureRest() + { + if (captureRest.size()==1) { + statement = new ShowStatement(captureRest.get(0)); + } else { + statement = new UnsupportedStatement("SHOW", captureRest); + } + } + ) + { + return statement; + } +} + +/** + * Only used inside the SHOW lookaheads: a typed SHOW statement ends at a semicolon, the input end, + * the ELSE or END of an enclosing IF or block, or the start of the next statement, as in + * Statements(). A lookahead that has entered a WHERE filter ends there too: it sees the first + * condition only, because prattExpressionRest() reads the rest of the expression. + */ +void ShowStatementEnd(): +{} +{ + + | + + | + + | + + | + LOOKAHEAD({ isShowWhereScanned() || getToken(1).kind != K_FROM && getToken(1).kind != K_PIVOT + && getToken(1).kind != K_UNPIVOT && isStatementStartAhead() }) {} +} + +/** The {FROM | IN} db clause of the MySQL SHOW statements. */ +ShowDbSelection ShowDbSelection(): +{ + ShowDbSelection selection = new ShowDbSelection(); + String name; +} +{ + ( | { selection.setSelectionMode(ShowTablesStatement.SelectionMode.IN); } ) + name = RelObjectName() { selection.setName(name); } + { + return selection; + } +} + +/** + * The LIKE 'pattern' or WHERE expr filter of the MySQL SHOW statements. MySQL and MariaDB take a + * string literal as the pattern; without a dialect any simple expression is read, as before. + */ +ShowFilter ShowFilter(): +{ + ShowFilter filter; + Expression expression; +} +{ + ( + + ( + LOOKAHEAD({ isMySqlDialect() }) expression = ShowTextString() + | + LOOKAHEAD({ !isMySqlDialect() }) expression = SimpleExpression() + ) + { filter = ShowFilter.like(expression); } + | + expression = Expression() { filter = ShowFilter.where(expression); } + ) + { + return filter; + } +} + +/** A MySQL text string, '...' or "...", where the server takes no other expression. */ +StringValue ShowTextString(): +{ + Token token; + StringValue value; +} +{ + ( + LOOKAHEAD({ getToken(1).kind == S_CHAR_LITERAL && isMySqlTextStringAt(1) }) + token = { value = stringValue(token); } + | + LOOKAHEAD({ getToken(1).kind == S_QUOTED_IDENTIFIER && isMySqlTextStringAt(1) }) + token = + { + value = linkToLastToken(new StringValue() + .withValue(token.image.substring(1, token.image.length() - 1)).setQuoteStr("\"")); + } + ) + { + return value; + } +} + +/** + * LIMIT [offset,] row_count or LIMIT row_count OFFSET offset of SHOW WARNINGS, ERRORS, PROFILE and + * BINLOG or RELAYLOG EVENTS. + */ +void ShowLimit(MySqlShowStatement statement): +{ + Limit limit = new Limit(); + Offset offset = null; + Token first; + Token last; + Expression rowCount; + Expression second; +} +{ + { first = getToken(0); } + rowCount = ShowLimitOption() { limit.setRowCount(rowCount); last = getToken(0); } + [ + "," second = ShowLimitOption() + { limit.setOffset(rowCount); limit.setRowCount(second); last = getToken(0); } + | + second = ShowLimitOption() { offset = new Offset().withOffset(second); } + ] + { + linkAST(limit, first, last); + statement.setLimit(limit); + statement.setOffset(offset); + } +} + +/** A limit value: an unsigned integer, a name (a stored program variable) or a ? parameter. */ +Expression ShowLimitOption(): +{ + Token token = getToken(1); + String name; + JdbcParameter parameter; + Expression expression; +} +{ + ( + token = { expression = linkToLastToken(new LongValue(token.image)); } + | + parameter = JdbcParameter() { expression = linked(parameter, token); } + | + LOOKAHEAD({ !isMySqlTextStringAt(1) }) name = RelObjectName() + { expression = linkToLastToken(new Column(name)); } + ) + { + return expression; + } +} + +/** FOR CHANNEL 'channel', checked by the caller's lookahead. */ +StringValue ShowChannel(): +{ + StringValue channel; +} +{ + channel = ShowTextString() + { + return channel; + } +} + +// https://dev.mysql.com/doc/refman/8.4/en/show-columns.html +ShowColumnsStatement ShowColumns(): { + ShowColumnsStatement statement = new ShowColumnsStatement(); + Table table; + ShowDbSelection dbSelection; + ShowFilter filter; +} +{ + [ { statement.setExtended(true); } ] + [ { statement.setFull(true); } ] + ( | { statement.setFieldsKeyword(true); } ) + ( + + | + { statement.setTableSelectionMode(ShowTablesStatement.SelectionMode.IN); } + ) + table = Table() { statement.setTable(table); } + [ LOOKAHEAD(2) dbSelection = ShowDbSelection() { statement.setDbSelection(dbSelection); } ] + [ filter = ShowFilter() { statement.setFilter(filter); } ] + { + return statement; + } +} + +// https://dev.mysql.com/doc/refman/8.4/en/show-table-status.html +ShowTableStatusStatement ShowTableStatus(): { + ShowTableStatusStatement statement = new ShowTableStatusStatement(); + ShowDbSelection dbSelection; + ShowFilter filter; +} +{ + ContextualKeyword("STATUS") + [ LOOKAHEAD(2) dbSelection = ShowDbSelection() { statement.setDbSelection(dbSelection); } ] + [ filter = ShowFilter() { statement.setFilter(filter); } ] + { + return statement; + } +} + +/** + * MySQL SHOW CREATE {TABLE | VIEW | PROCEDURE | FUNCTION | TRIGGER | EVENT} name, + * SHOW CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db and SHOW CREATE USER account. + */ +ShowCreateStatement ShowCreate(): { + ShowCreateStatement statement = new ShowCreateStatement(); + Table name; + String databaseName; + String currentUser; + UserAccount account = new UserAccount(); +} +{ + + ( + ( + { statement.setObjectType(ShowCreateStatement.ObjectType.TABLE); } + | + { statement.setObjectType(ShowCreateStatement.ObjectType.VIEW); } + | + { statement.setObjectType(ShowCreateStatement.ObjectType.PROCEDURE); } + | + { statement.setObjectType(ShowCreateStatement.ObjectType.FUNCTION); } + | + { statement.setObjectType(ShowCreateStatement.ObjectType.TRIGGER); } + | + { statement.setObjectType(ShowCreateStatement.ObjectType.EVENT); } + ) + name = Table() { statement.setName(name); } + | + ( | { statement.setSchemaKeyword(true); } ) + { statement.setObjectType(ShowCreateStatement.ObjectType.DATABASE); } + [ LOOKAHEAD(3) { statement.setIfNotExists(true); } ] + databaseName = RelObjectName() { statement.setDatabaseName(databaseName); } + | + { statement.setObjectType(ShowCreateStatement.ObjectType.USER); } + ( + LOOKAHEAD({ isKeywordAhead("CURRENT_USER") }) currentUser = RelObjectName() + { account.setUser(linkToLastToken(new StringValue(currentUser).setQuoteStr(""))); } + [ LOOKAHEAD(2) "(" ")" { statement.setCurrentUserParentheses(true); } ] + | + account = MySqlAccountName() + ) + { statement.setAccount(account); } + ) + { + return statement; + } +} + +// https://dev.mysql.com/doc/refman/8.4/en/show-index.html +ShowIndexStatement ShowIndex(): { + ShowIndexStatement statement = new ShowIndexStatement(); + Table table; + ShowDbSelection dbSelection; + Expression condition; +} +{ + [ { statement.setExtended(true); } ] + ( + + | + { statement.setKeyword(ShowIndexStatement.Keyword.KEYS); } + | + LOOKAHEAD({ isAnyWordAt(1, "INDEXES") }) + { statement.setKeyword(ShowIndexStatement.Keyword.INDEXES); } + ) + ( + + | + { statement.setTableSelectionMode(ShowTablesStatement.SelectionMode.IN); } + ) + table = Table() { statement.setTable(table); } + [ LOOKAHEAD(2) dbSelection = ShowDbSelection() { statement.setDbSelection(dbSelection); } ] + [ condition = Expression() { statement.setWhereCondition(condition); } ] + { + return statement; + } +} + +/** + * The MySQL SHOW statements of MySqlShowStatement. Each alternative is chosen by its leading + * keywords, so a SHOW statement of another form fails the caller's lookahead at once. + */ +MySqlShowStatement MySqlShow(): +{ + MySqlShowStatement statement = new MySqlShowStatement(); + MySqlShowStatement.Scope scope = null; + boolean full = false; + Token token; + StringValue channel; + ShowDbSelection dbSelection; + ShowFilter filter; +} +{ + ( + // [GLOBAL | SESSION | LOCAL] {VARIABLES | STATUS} [LIKE 'pattern' | WHERE expr] + LOOKAHEAD({ isShowVariablesAhead() }) + [ + { scope = MySqlShowStatement.Scope.GLOBAL; } + | + { scope = MySqlShowStatement.Scope.SESSION; } + | + { scope = MySqlShowStatement.Scope.LOCAL; } + ] + token = { statement.setKeyword(token.image); statement.setScope(scope); } + [ filter = ShowFilter() { statement.setFilter(filter); } ] + | + // [FULL] PROCESSLIST + LOOKAHEAD({ isAnyWordAt(getToken(1).kind == K_FULL ? 2 : 1, "PROCESSLIST") }) + [ { full = true; } ] + { statement.setKeyword("PROCESSLIST"); statement.setFull(full); } + | + // {DATABASES | SCHEMAS | CHARSET | COLLATION} [LIKE 'pattern' | WHERE expr] + LOOKAHEAD({ isAnyWordAt(1, "DATABASES", "SCHEMAS", "CHARSET", "COLLATION") }) + token = { statement.setKeyword(token.image); } + [ filter = ShowFilter() { statement.setFilter(filter); } ] + | + // {CHARACTER | CHAR} SET [LIKE 'pattern' | WHERE expr] + LOOKAHEAD({ (getToken(1).kind == K_CHARACTER || "CHAR".equalsIgnoreCase(getToken(1).image)) + && getToken(2).kind == K_SET }) + ( + { statement.setKeyword("CHARACTER SET"); } + | + ( | ) { statement.setKeyword("CHAR SET"); } + ) + + [ filter = ShowFilter() { statement.setFilter(filter); } ] + | + // {PROCEDURE | FUNCTION} STATUS [LIKE 'pattern' | WHERE expr] and {PROCEDURE | FUNCTION} CODE name + LOOKAHEAD({ (getToken(1).kind == K_PROCEDURE || getToken(1).kind == K_FUNCTION) + && isAnyWordAt(2, "STATUS", "CODE") }) + ( token = | token = ) + ( + LOOKAHEAD({ isAnyWordAt(1, "STATUS") }) + { statement.setKeyword(token.image + " STATUS"); } + [ filter = ShowFilter() { statement.setFilter(filter); } ] + | + { statement.setKeyword(token.image + " CODE"); } + ShowRoutineName(statement) + ) + | + // {[FULL] TRIGGERS | EVENTS | OPEN TABLES} [{FROM | IN} db] [LIKE 'pattern' | WHERE expr] + LOOKAHEAD({ isAnyWordAt(1, "TRIGGERS", "EVENTS") + || getToken(1).kind == K_FULL && isAnyWordAt(2, "TRIGGERS") + || getToken(1).kind == K_OPEN && getToken(2).kind == K_TABLES }) + ( + { statement.setKeyword("OPEN TABLES"); } + | + [ { full = true; } ] + token = { statement.setKeyword(token.image); statement.setFull(full); } + ) + [ LOOKAHEAD(2) dbSelection = ShowDbSelection() { statement.setDbSelection(dbSelection); } ] + [ filter = ShowFilter() { statement.setFilter(filter); } ] + | + // ENGINES, PLUGINS, PRIVILEGES, PROFILES, REPLICAS + LOOKAHEAD({ isAnyWordAt(1, "ENGINES", "PLUGINS", "PRIVILEGES", "PROFILES", "REPLICAS") }) + token = { statement.setKeyword(token.image); } + | + // STORAGE ENGINES + LOOKAHEAD({ getToken(1).kind == K_STORAGE && isAnyWordAt(2, "ENGINES") }) + { statement.setKeyword("STORAGE ENGINES"); } + | + // BINARY LOGS and BINARY LOG STATUS + LOOKAHEAD({ getToken(1).kind == K_BINARY && (isAnyWordAt(2, "LOGS") + || getToken(2).kind == K_LOG && isAnyWordAt(3, "STATUS")) }) + + ( + { statement.setKeyword("BINARY LOG STATUS"); } + | + { statement.setKeyword("BINARY LOGS"); } + ) + | + // MASTER LOGS and MASTER STATUS, the spellings before MySQL 8.4 + LOOKAHEAD({ isLegacyMySqlShowDialect() && isAnyWordAt(1, "MASTER") + && isAnyWordAt(2, "LOGS", "STATUS") }) + token = { statement.setKeyword("MASTER " + token.image); } + | + // SLAVE HOSTS, the spelling of REPLICAS before MySQL 8.4 + LOOKAHEAD({ isLegacyMySqlShowDialect() && getToken(1).kind == K_SLAVE && isAnyWordAt(2, "HOSTS") }) + { statement.setKeyword("SLAVE HOSTS"); } + | + // REPLICA STATUS [FOR CHANNEL 'channel']; SLAVE STATUS is the spelling before MySQL 8.4 + LOOKAHEAD({ (isLegacyMySqlShowDialect() && getToken(1).kind == K_SLAVE || isAnyWordAt(1, "REPLICA")) + && isAnyWordAt(2, "STATUS") }) + ( token = | token = ) + { statement.setKeyword(token.image + " STATUS"); } + [ LOOKAHEAD({ isShowChannelAhead() }) channel = ShowChannel() { statement.setChannel(channel); } ] + | + // GRANTS [FOR account [USING role [, role] ...]] + LOOKAHEAD({ isAnyWordAt(1, "GRANTS") }) + { statement.setKeyword("GRANTS"); } + [ ShowGrantsAccount(statement) ] + | + // {WARNINGS | ERRORS} [LIMIT ...] + LOOKAHEAD({ getToken(1).kind == K_ERRORS || isAnyWordAt(1, "WARNINGS") }) + ( { statement.setKeyword("ERRORS"); } | { statement.setKeyword("WARNINGS"); } ) + [ ShowLimit(statement) ] + | + // COUNT(*) {WARNINGS | ERRORS} + LOOKAHEAD({ isShowCountAhead() }) + "(" "*" ")" + ( + { statement.setKeyword("ERRORS"); } + | + LOOKAHEAD({ isAnyWordAt(1, "WARNINGS") }) { statement.setKeyword("WARNINGS"); } + ) + { statement.setCount(true); } + | + // {BINLOG | RELAYLOG} EVENTS [IN 'log_name'] [FROM pos] [LIMIT ...] [FOR CHANNEL 'channel'], + // the channel only for RELAYLOG + LOOKAHEAD({ isAnyWordAt(1, "BINLOG", "RELAYLOG") && isAnyWordAt(2, "EVENTS") }) + ( + LOOKAHEAD({ isAnyWordAt(1, "BINLOG") }) + { statement.setKeyword("BINLOG EVENTS"); } + ShowLogRange(statement) + | + { statement.setKeyword("RELAYLOG EVENTS"); } + ShowLogRange(statement) + [ LOOKAHEAD({ isShowChannelAhead() }) channel = ShowChannel() { statement.setChannel(channel); } ] + ) + | + // ENGINE {engine_name | ALL} {STATUS | MUTEX | LOGS} + LOOKAHEAD({ getToken(1).kind == K_ENGINE }) + { statement.setKeyword("ENGINE"); } + ShowEngine(statement) + | + // PROFILE [type [, type] ...] [FOR QUERY n] [LIMIT ...] + LOOKAHEAD({ isAnyWordAt(1, "PROFILE") }) + { statement.setKeyword("PROFILE"); } + ShowProfile(statement) + ) + { + return statement; + } +} + +/** The routine of SHOW {PROCEDURE | FUNCTION} CODE: name or db.name. */ +void ShowRoutineName(MySqlShowStatement statement): +{ + Token first = getToken(1); + String name; + String routine = null; + Table table; +} +{ + name = RelObjectName() [ "." routine = RelObjectName() ] + { + table = routine == null ? new Table(name) : new Table(name, routine); + linkAST(table, first); + statement.setRoutineName(table); + } +} + +/** {engine_name | ALL} {STATUS | MUTEX | LOGS} of SHOW ENGINE; the engine is a name or a string. */ +void ShowEngine(MySqlShowStatement statement): +{ + Token token; + String name; +} +{ + ( + LOOKAHEAD({ getToken(1).kind == S_CHAR_LITERAL && isMySqlTextStringAt(1) }) + token = { name = token.image; } + | + // RelObjectName() also reads ALL, which shows every engine + LOOKAHEAD({ getToken(1).kind != S_CHAR_LITERAL }) name = RelObjectName() + ) + { statement.setEngineName(name); } + ( + LOOKAHEAD({ isAnyWordAt(1, "STATUS") }) + { statement.setEngineInfo(MySqlShowStatement.EngineInfo.STATUS); } + | + LOOKAHEAD({ isAnyWordAt(1, "MUTEX") }) + { statement.setEngineInfo(MySqlShowStatement.EngineInfo.MUTEX); } + | + LOOKAHEAD({ isAnyWordAt(1, "LOGS") }) + { statement.setEngineInfo(MySqlShowStatement.EngineInfo.LOGS); } + ) +} + +/** [type [, type] ...] [FOR QUERY n] [LIMIT ...] of SHOW PROFILE. */ +void ShowProfile(MySqlShowStatement statement): +{ + List types = new ArrayList(); + MySqlShowStatement.ProfileType type; + Token token; +} +{ + [ + type = ShowProfileType() { types.add(type); } + ( "," type = ShowProfileType() { types.add(type); } )* + { statement.setProfileTypes(types); } + ] + [ + LOOKAHEAD(2) token = + { statement.setProfileQuery(linkToLastToken(new LongValue(token.image))); } + ] + [ ShowLimit(statement) ] +} + +MySqlShowStatement.ProfileType ShowProfileType(): +{ + Token token; + Token second = null; +} +{ + ( + token = + | + LOOKAHEAD({ getToken(1).kind == K_BLOCK && isAnyWordAt(2, "IO") }) + token = second = + | + LOOKAHEAD({ isAnyWordAt(1, "CONTEXT") && isAnyWordAt(2, "SWITCHES") + || isAnyWordAt(1, "PAGE") && isAnyWordAt(2, "FAULTS") }) + token = second = + | + LOOKAHEAD({ isAnyWordAt(1, "CPU", "IPC", "MEMORY", "SOURCE", "SWAPS") }) + token = + ) + { + return MySqlShowStatement.ProfileType + .fromKeyword(second == null ? token.image : token.image + " " + second.image); + } +} + +/** FOR account [USING role [, role] ...] of SHOW GRANTS, read like the accounts of CREATE USER. */ +void ShowGrantsAccount(MySqlShowStatement statement): +{ + UserAccount account; + List roles; +} +{ + account = MySqlAccountName() { statement.setAccount(account); } + [ roles = MySqlAccountNameList() { statement.setUsingRoles(roles); } ] +} + +/** [IN 'log_name'] [FROM pos] [LIMIT ...] of SHOW BINLOG and RELAYLOG EVENTS. */ +void ShowLogRange(MySqlShowStatement statement): +{ + Token token; + StringValue logName; +} +{ + [ logName = ShowTextString() { statement.setLogName(logName); } ] + [ + LOOKAHEAD(2) + ( + token = { statement.setPosition(linkToLastToken(new LongValue(token.image))); } + | + token = { statement.setPosition(linkToLastToken(new DoubleValue(token.image))); } + ) + ] + [ ShowLimit(statement) ] +} + +Statement RefreshMaterializedView(): { + Table view = null; + boolean concurrently = false; + RefreshMode refreshMode = null; + List captureRest; +} +{ + + [ LOOKAHEAD(2) { concurrently = true; } ] + view = Table() + [ + { refreshMode = RefreshMode.WITH_DATA; } + [ + { refreshMode = RefreshMode.WITH_NO_DATA; } + ] + + ] + captureRest = captureRest() + { + if (concurrently && refreshMode == RefreshMode.WITH_NO_DATA) { + return new UnsupportedStatement("REFRESH", captureRest); + } else { + return new RefreshMaterializedViewStatement(view, concurrently, refreshMode); + } + } +} +// https://dev.mysql.com/doc/refman/8.4/en/show-tables.html +ShowTablesStatement ShowTables(): { + ShowTablesStatement statement = new ShowTablesStatement(); + EnumSet modifiers = EnumSet.noneOf(ShowTablesStatement.Modifiers.class); + ShowDbSelection dbSelection; + ShowFilter filter; +} +{ + [ { modifiers.add(ShowTablesStatement.Modifiers.EXTENDED); } ] + [ { modifiers.add(ShowTablesStatement.Modifiers.FULL); } ] + { statement.setModifiers(modifiers); } + [ LOOKAHEAD(2) dbSelection = ShowDbSelection() { statement.setDbSelection(dbSelection); } ] + [ filter = ShowFilter() { statement.setFilter(filter); } ] + { + return statement; + } } -// Sentinel: end of non-reserved keyword range -SKIP: +Values Values(): { + ExpressionList expressions; + Token first = getToken(1); +} { + ( | ) + expressions = ExpressionList() + + { + Values values = new Values(expressions); + linkAST(values, first); + return values; + } +} + +ReturningClause ReturningClause(): { - + Token keyword; + List outputAliases = null; + List> selectItems; + Object dataItem; + List dataItems = null; + boolean bulkCollect = false; +} +{ + ( keyword= | keyword= ) + [ LOOKAHEAD(2) outputAliases = ReturningOutputAliasList() ] + selectItems = SelectItemsList() + + [ + LOOKAHEAD({ getToken(1).kind == K_INTO || isBulkCollectIntoAhead() }) + [ LOOKAHEAD({ isBulkCollectIntoAhead() }) + ContextualKeyword("BULK") ContextualKeyword("COLLECT") { bulkCollect = true; } + ] + + dataItem = ReturningIntoTarget() + { dataItems = new ArrayList(); dataItems.add(dataItem); } + + ( + "," + dataItem = ReturningIntoTarget() { dataItems.add(dataItem); } + )* + ] + + { + return new ReturningClause(keyword.image, selectItems, outputAliases, dataItems) + .setBulkCollect(bulkCollect); + } } -TOKEN: /* Reserved SQL Keywords and structural tokens */ +Object ReturningIntoTarget(): { - -| -| -| -| -| -| -| -| -| /* H2 casewhen function */ -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| /* Salesforce SOQL */ -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| /* Salesforce SOQL */ -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| "> -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| -| | -| -| -| -| (" ")+ ) > + Object target; +} +{ + ( target=JdbcNamedParameter() | target=JdbcParameter() + | target=Table() | target=UserVariable() ) + { return target; } +} + +ReturningReferenceType ReturningReferenceKind(): +{ + String refName; + ReturningReferenceType refType; +} +{ + refName = RelObjectName() + { + refType = ReturningReferenceType.from(refName); + if (refType == ReturningReferenceType.OLD) { + return ReturningReferenceType.OLD; + } else if (refType == ReturningReferenceType.NEW) { + return ReturningReferenceType.NEW; + } + throw new ParseException("Expected OLD or NEW but found: " + refName); + } +} + +ReturningOutputAlias ReturningOutputAliasDefinition(): +{ + ReturningReferenceType refType; + String aliasName; +} +{ + refType = ReturningReferenceKind() + + aliasName = RelObjectName() + { + return new ReturningOutputAlias(refType, aliasName); + } +} + +List ReturningOutputAliasList(): +{ + List outputAliases = new ArrayList(); + ReturningOutputAlias outputAlias; +} +{ + "(" + outputAlias = ReturningOutputAliasDefinition() { outputAliases.add(outputAlias); } + ( + "," + outputAlias = ReturningOutputAliasDefinition() { outputAliases.add(outputAlias); } + )* + ")" + { + return outputAliases; + } +} + +Update UpdateWithWithItems( List> withItems ): +{ + Update update; +} +{ + update = Update() { update.setWithItemsList( withItems ); + return update; +} +} + +Update Update(): +{ + Update update = new Update(); + TableReference target; + List indexHints; + ForPortionClause forPortionClause; + List startJoins = null; + List> with = null; + List updateSets; + Expression where = null; + String cursorName; + PreferringClause preferringClause = null; + Limit limit = null; + OptionClause optionClause = null; + List orderByElements; + boolean useColumnsBrackets = false; + ReturningClause returningClause; + Token tk = null; + UpdateModifierPriority modifierPriority = null; + boolean modifierIgnore = false; + String algorithm; + + OutputClause outputClause = null; +} +{ + { update.setOracleHint(getOracleHint()); } + // SQLite: UPDATE OR ; ABORT and FAIL are not keywords of the parser + [ algorithm=RelObjectName() + { update.setConflictAlgorithm(updateOrAlgorithm(algorithm)); } ] + [ LOOKAHEAD(2) { modifierPriority = UpdateModifierPriority.LOW_PRIORITY; }] + [ LOOKAHEAD(2) { modifierIgnore = true; }] + target=DmlTarget() { update.setTableReference(target); } + [ LOOKAHEAD(2) indexHints=MySQLIndexHints() { target.getTable().setIndexHints(indexHints); } ] + [ forPortionClause=ForPortionClause() { update.setForPortionClause(forPortionClause); } ] + [ startJoins=JoinsList() ] + [ LOOKAHEAD(, { Dialect.TERADATA.name().equals(getAsString(Feature.dialect)) }) + UpdateFromClause(update) { update.setFromBeforeSet(true); } ] + updateSets = UpdateSets() { update.setUpdateSets(updateSets); } + + [ outputClause = OutputClause() {update.setOutputClause(outputClause); } ] + + [ LOOKAHEAD(2, { !Dialect.TERADATA.name().equals(getAsString(Feature.dialect)) }) + UpdateFromClause(update) ] + + [ + LOOKAHEAD({ isWhereCurrentOfAhead() }) + cursorName=WhereCurrentOfClause() { update.setCursorName(cursorName); } + | + where=WhereClause() { update.setWhere(where); } + ] + [ preferringClause=PreferringClause() { update.setPreferringClause(preferringClause); } ] + + [ orderByElements = OrderByElements() { update.setOrderByElements(orderByElements); } ] + [ limit = PlainLimit() { update.setLimit(limit); } ] + [ LOOKAHEAD(2) optionClause = OptionClause() { update.setOption(optionClause); } ] + [ returningClause = ReturningClause() { update.setReturningClause(returningClause); } ] + + { + return update.withWithItemsList(with) + .withStartJoins(startJoins) + .withModifierPriority(modifierPriority) + .withModifierIgnore(modifierIgnore); + } } -TOKEN : /* Statement Separators */ +/** Shared structured interval for application-time UPDATE and DELETE. */ +ForPortionClause ForPortionClause() #ForPortionClause: { - + String periodName; + Expression fromExpression; + Expression toExpression; + ForPortionClause clause; +} +{ + AccessKeyword("PORTION") periodName=RelObjectName() + fromExpression=Expression() toExpression=Expression() + { + clause = new ForPortionClause(periodName, fromExpression, toExpression); + linkAST(clause, jjtThis); + return clause; + } } -TOKEN : /* Operators */ +void UpdateFromClause(Update update): { - " ()* "="> -| "> -| )* "="> -| )* ">"> -| )* "="> -| -| -| -| -| -| >"> -| -| -| -| "> -| + FromItem fromItem; + List joins = null; +} +{ + fromItem=FromItem() + [ LOOKAHEAD(2) joins=JoinsList() ] + { update.setFromItem(fromItem); update.setJoins(joins); } } -TOKEN : /* Date/Time with time zones */ +List UpdateSets(): { - ()* ("(" ")")? ()* ( | ) (()+ )? ()+ "TIME" ()+ > + ArrayList updateSets = new ArrayList(); + UpdateSet updateSet; +} +{ + updateSet=UpdateSet() { updateSets.add(updateSet); } + ( LOOKAHEAD(2) "," updateSet=UpdateSet() { updateSets.add(updateSet); } )* + { + return updateSets; + } } -TOKEN : /* Data Types */ +/** + * One assignment of a SET list: column = value, or (columns) = source. PostgreSQL's set_clause + * takes any expression as the source of a column list, such as ROW(...) or a sub-select. + */ +UpdateSet UpdateSet(): { - // Dedicated keyword tokens (e.g. K_BINARY/K_CHAR) are consumed by DataType(). - // Repeating them here cannot match DATA_TYPE and causes unreachable-token warnings. - | | | - | | | | | | - | | | | | - | | | | - | | | - ) > + UpdateSet updateSet; + Column tableColumn; + Expression valueExpression; + ExpressionList columns; + ExpressionList values; +} +{ + ( + tableColumn=Column() "=" valueExpression=Expression() + { + updateSet = new UpdateSet(tableColumn, valueExpression); + linkElements(updateSet.getColumns()); + linkElements(updateSet.getValues()); + } + | + ( + { updateSet = new UpdateSet(); } + columns = ParenthesedExpressionList() { updateSet.setColumns(columns); } + "=" + ( + LOOKAHEAD(3) valueExpression = ParenthesedSelect() { updateSet.setValues(linkElements(new ExpressionList(valueExpression))); } + | + LOOKAHEAD("(") values = ParenthesedExpressionList() { updateSet.setValues(values); } + | + valueExpression = Expression() + { + requireUpdateSetTargets(columns); + updateSet.setValues(linkElements(new ExpressionList(valueExpression))); + } + ) + ) + ) + { + return updateSet; + } +} - | <#TYPE_BIT: "BISTRING"> - | <#TYPE_BLOB: "BLOB" | "BYTEA" | "VARBINARY" > - | <#TYPE_BOOLEAN: "BOOL" > - | <#TYPE_CLOB: "CLOB"> - | <#TYPE_ENUM: "ENUM" > - | <#TYPE_MAP: "MAP" > - | <#TYPE_DECIMAL: "DECIMAL" | "NUMBER" | "NUMERIC" > - | <#TYPE_TINYINT: "TINYINT" | "INT1" > - | <#TYPE_SMALLINT: "SMALLINT" | "INT2" | "SHORT" > - | <#TYPE_INTEGER: ( "INTEGER" | "INT" | "INT4" ) > - | <#TYPE_BIGINT: "BIGINT" | "INT8" | "LONG" > - | <#TYPE_HUGEINT: "HUGEINT" > - | <#TYPE_UTINYINT: "UTINYINT" > - | <#TYPE_USMALLINT: "USMALLINT" > - | <#TYPE_UINTEGER: "UINTEGER" > - | <#TYPE_UBIGINT: "UBIGINT" > - | <#TYPE_UHUGEINT: "UHUGEINT" > - | <#TYPE_REAL: "REAL" | "FLOAT4" | "FLOAT"> - | <#TYPE_DOUBLE: "DOUBLE" | "PRECISION" | "FLOAT8" | "FLOAT64"> - | <#TYPE_VARCHAR: "NVARCHAR" | "VARCHAR" | "NCHAR" | "BPCHAR" | "TEXT" | "STRING" | "VARYING"> - | <#TYPE_TIME: "TIMETZ" > - | <#TYPE_TIMESTAMP: "TIMESTAMP_NS" | "TIMESTAMP_MS" | "TIMESTAMP_S" > +/** WHERE CURRENT OF cursor_name; returns the cursor name. */ +String WhereCurrentOfClause(): +{ + String cursorName; +} +{ + cursorName=RelObjectName() + { return cursorName; } +} - | <#TYPE_UUID: "UUID"> +/** + * The target of UPDATE, DELETE and MERGE: PostgreSQL's relation_expr_opt_alias with ONLY or * + * around the table name, or a table with its alias and hints. + */ +TableReference DmlTarget(): +{ + TableReference target; + Table table; + Alias alias; +} +{ + ( + LOOKAHEAD({ isScopedDmlTargetAhead() }) + target=RelationTarget() + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { target.getTable().setAlias(alias); } ] + | + table=TableWithAlias() { target = new TableReference(table); } + ) + { return target; } } -TOKEN : /* Numeric Constants */ +List Partitions(): { - < S_DOUBLE: (()? "." ( ["e","E"] (["+", "-"])? )? - | - "." (["e","E"] (["+", "-"])? )? - | - ["e","E"] (["+", "-"])? - )> - | < S_LONG: ( )+ > - | < #DIGIT: ["0" - "9"] > - | < S_HEX: ("X" ("'" ( )* "'" (" ")*)+ | "0x" ( )+ ) > - | < #HEX_VALUE: ["0"-"9","A"-"F", " "] > - | < #HEX_DIGIT: ["0"-"9","A"-"F"] > + List partitions = new ArrayList(); + Column tableColumn; + Expression valueExpression = null; } +{ + ( + ( + tableColumn=Column() [ "=" valueExpression=Expression() ] + { partitions.add( new Partition (tableColumn, valueExpression)); } + ) + ) -SPECIAL_TOKEN: + ( + LOOKAHEAD(2) ( + "," + tableColumn=Column() { valueExpression = null; } [ "=" valueExpression=Expression() ] + { partitions.add( new Partition (tableColumn, valueExpression)); } + ) + )* + + { + return partitions; + } +} + +InsertBulk InsertBulk(): { - < LINE_COMMENT: ("--" | "//") (~["\r","\n"])*> + InsertBulk statement = new InsertBulk(); + Table table; + ColumnDefinition column; + InsertBulk.Option option; + Set kinds = EnumSet.noneOf(InsertBulk.Option.Kind.class); +} +{ + AccessKeyword("BULK") table=Table() { statement.setTable(table); } + "(" column=InsertBulkColumn() { statement.getColumns().add(column); } + ( "," column=InsertBulkColumn() { statement.getColumns().add(column); } )* ")" + // LOOKAHEAD(2) is required, not cosmetic: Statements() permits two statements to be + // adjacent without a separator, so FIRST(SingleStatement) -- including -- is in + // the FOLLOW set of every statement tail. `WITH (` cannot start a CTE, so two tokens + // separate the INSERT BULK option list from a following WITH statement. + [ LOOKAHEAD(2) "(" option=InsertBulkOption() { + statement.getOptions().add(option); kinds.add(option.getKind()); + } + ( "," option=InsertBulkOption() { + requireDdlSyntax(kinds.add(option.getKind()), "Duplicate INSERT BULK option"); + statement.getOptions().add(option); + } )* ")" ] + { return statement; } } -// MySQL `#` line comment (#2499), flag-gated. Under -// Feature.allowHashLineComments the stream rewrites a token-start `#` to -// SimpleCharStream.HASH_SUBSTITUTION, a character no other rule starts with, -// so this production wins the match for every `#` form (`# c`, `#c`, `#>`, -// ...) without touching the identifier and JSON-operator lexing of the -// default mode. The action restores the `#` in the token image; unquoted -// identifiers end at their first `#` via the S_IDENTIFIER action, which -// re-lexes the remainder as this comment. -SPECIAL_TOKEN: +ColumnDefinition InsertBulkColumn(): { - < HASH_LINE_COMMENT: "\u0001" (~["\r","\n"])*> + String name; + String collation; + ColDataType type; + ColumnDefinition column; +} +{ + name=RelObjectName() type=ColDataType() { column = new ColumnDefinition(name, type); } + [ collation=RelObjectName() { column.setColumnSpecs(Arrays.asList("COLLATE", collation)); } ] + { return column; } +} + +InsertBulk.Option InsertBulkOption(): +{ + String name; + Token value; + Column column; + Token direction; + OrderByElement order; + InsertBulk.Option option; +} +{ + ( + // RelObjectName() below accepts as an identifier (isReservedKeywordAsIdentifier() + // returns true for ORDER unless BY or SIBLINGS follows), so ORDER is a genuine common + // prefix of the first and the last alternative. The option form always has "(" after it. + LOOKAHEAD( "(") + { option = new InsertBulk.Option(InsertBulk.Option.Kind.ORDER); } + "(" column=Column() { + order = new OrderByElement().withExpression(column); + option.getOrderByElements().add(order); + } + [ (direction= | direction=) { order.setAsc(direction.kind == K_ASC); order.setAscDescPresent(true); } ] + { linkAST(order, firstToken(column, getToken(0))); } + ( "," column=Column() { + order = new OrderByElement().withExpression(column); + option.getOrderByElements().add(order); + } + [ (direction= | direction=) { order.setAsc(direction.kind == K_ASC); order.setAscDescPresent(true); } ] + { linkAST(order, firstToken(column, getToken(0))); } + )* ")" + | + LOOKAHEAD({ isKeywordAhead("ROWS_PER_BATCH") }) AccessKeyword("ROWS_PER_BATCH") "=" value= + { option = new InsertBulk.Option(InsertBulk.Option.Kind.ROWS_PER_BATCH); option.setValue(new LongValue(value.image)); } + | + name=RelObjectName() { + option = new InsertBulk.Option(typeDdlEnum(InsertBulk.Option.Kind.class, name)); + requireDdlSyntax(option.getKind() != InsertBulk.Option.Kind.ORDER + && option.getKind() != InsertBulk.Option.Kind.ROWS_PER_BATCH, "Missing INSERT BULK option value"); + } + ) + { return option; } } -// Nested block comments: /* ... /* ... */ ... */ -// -// The body is consumed manually in the MORE action below because JavaCC 8 -// discards actions attached to SPECIAL_TOKEN and SKIP rules: it emits -// SkipLexicalActions() with an empty switch. Only TOKEN and MORE actions -// survive code generation. Do not move this action onto the rule below. -// -// consumeBlockCommentBody() scans past the whole comment, honouring nesting, -// then backs up 2 chars so re-matches the outermost "*/" -// and closes the MORE chain. No character past the comment is ever consumed, -// so there is nothing to push back and no dependency on what follows. -MORE: +Insert InsertWithWithItems( List> withItems ): { - "/*" { consumeBlockCommentBody(); } : IN_BLOCK_COMMENT + Insert insert; } - - SPECIAL_TOKEN: { - : DEFAULT + insert = Insert() { insert.setWithItemsList( withItems ); + return insert; +} } -TOKEN: -{ - -| - - { - if (rowPatternContext != null && rowPatternContext.isInPattern()) { - truncateIdentifierToken(matchedToken, 1); - matchedToken.kind = S_IDENTIFIER; - } else { - consumeDollarQuotedToken(matchedToken, matchedToken.image); - } - } -| -// Bare `#` as a binary operator (PostgreSQL bitwise XOR / geometric -// intersection). Declared before to win the length tie on a -// lone `#`; `#temp`-style identifiers and `#>` / `#>>` keep their usual -// lexing by longest match (#1197, #1695). - -| - ()*) | "$" | ("$" ()*)> +Insert Insert(): { - if (rowPatternContext != null && rowPatternContext.isInPattern()) { - int dollar = matchedToken.image.indexOf('$'); - if (dollar >= 0) { truncateIdentifierToken(matchedToken, Math.max(1, dollar)); } - } - if (matchedToken.image.charAt(0) == '$' - && Boolean.TRUE.equals(configuration.getValue(Feature.allowDollarQuotedStringTags))) { - String delimiter = StringValue.getDollarQuoteDelimiter(matchedToken.image); - if (delimiter != null) { - consumeDollarQuotedToken(matchedToken, delimiter); - } - } - // MySQL `#` line comments (#2499): under the flag an unquoted identifier - // ends at its first `#`, the rest of the line becomes a comment via the - // stream-level substitution (real MySQL reads `42#24` as `42` plus - // comment too). Quoted identifiers and strings keep their `#`. - // the wiring check keeps the flag lookup off the hot path of parses - // that never opted in (the stream is only wired through the feature - // consumers / withConfiguration); getValue avoids the String-based - // getAsBoolean roundtrip - if (matchedToken.kind == S_IDENTIFIER && input_stream.featureConfiguration != null - && Boolean.TRUE.equals(configuration.getValue(Feature.allowHashLineComments))) { - int hashIndex = matchedToken.image.indexOf('#'); - if (hashIndex > 0) { - truncateIdentifierToken(matchedToken, hashIndex); - } - } - // PostgreSQL does not allow # or @ in unquoted identifiers. Re-lex them as - // operators, including #>, #>>, #- and @?, when touching the left operand. - if (matchedToken.kind == S_IDENTIFIER - && AbstractJSqlParser.Dialect.POSTGRESQL.name().equals(configuration.getValue(Feature.dialect))) { - int hashIndex = matchedToken.image.indexOf('#'); - int atIndex = matchedToken.image.indexOf('@'); - int operatorIndex = hashIndex < 0 ? atIndex - : atIndex < 0 ? hashIndex : Math.min(hashIndex, atIndex); - if (operatorIndex > 0) { - truncateIdentifierToken(matchedToken, operatorIndex); - } else if (hashIndex == 0) { - truncateIdentifierToken(matchedToken, 1); - matchedToken.kind = S_HASH_OPERATOR; - } - } + Insert insert = new Insert(); + Table table = null; + List> with = null; + Column tableColumn = null; + ExpressionList columns = null; + List partitions = new ArrayList(); + Expression exp = null; + ReturningClause returningClause; + Select select = null; + Token tk = null; + InsertModifierPriority modifierPriority = null; + boolean modifierIgnore = false; + + List updateSets; + List duplicateUpdateSets; + + String name = null; + boolean useAs = false; + boolean useSet = false; + Alias rowAlias = null; + OutputClause outputClause = null; + + InsertConflictTarget conflictTarget = null; + InsertConflictAction conflictAction = null; + + InsertDuplicateAction duplicateAction = null; + Token multiInsertToken = null; + List oracleMultiInsertBranches = new ArrayList(); + OracleMultiInsertClause oracleMultiInsertClause = null; + OracleMultiInsertBranch oracleMultiInsertBranch = null; + String algorithm; } -| <#LETTER: - | | [ "#", "_" ] // Not SQL:2016 compliant! - > -| <#PART_LETTER_NO_DOLLAR: | | [ "#", "_" , "@" ] > -| <#PART_LETTER: | | [ "$" , "#", "_" , "@" ] > -| ()? > { - // same truncation as S_IDENTIFIER: `@@#name` ends at the `#` under - // allowHashLineComments, the rest of the line becomes the comment - // the wiring check keeps the flag lookup off the hot path of parses - // that never opted in (the stream is only wired through the feature - // consumers / withConfiguration); getValue avoids the String-based - // getAsBoolean roundtrip - if (input_stream.featureConfiguration != null - && Boolean.TRUE.equals(configuration.getValue(Feature.allowHashLineComments))) { - int hashIndex = matchedToken.image.indexOf('#'); - if (hashIndex > 0) { - truncateIdentifierToken(matchedToken, hashIndex); + ( + + // SQLite: INSERT OR . ABORT and FAIL are not keywords of the parser, so the + // word is read as a name and the algorithm is checked in AbstractJSqlParser + [ LOOKAHEAD({ getToken(1).kind == K_OR }) + algorithm=RelObjectName() + { insert.setConflictAlgorithm(insertOrAlgorithm(algorithm)); } ] + ) + { insert.setOracleHint(getOracleHint()); } + + [ + LOOKAHEAD(2) (tk = | tk = | tk = ) + { + if (tk!=null) + modifierPriority = InsertModifierPriority.from(tk.image); } + ] + [ LOOKAHEAD(2) { modifierIgnore = true; }] + { + // SQLite takes the target of INSERT OR ... without the INTO, as in INSERT OR IGNORE t + insert.setOmitInto(insert.getConflictAlgorithm() != null + && getToken(1).kind != K_INTO && getToken(1).kind != K_OVERWRITE); } -} + ( + LOOKAHEAD(2, ( | ) ( | )) + ( + (multiInsertToken = | multiInsertToken = ) { + insert.setOracleMultiInsert(true); + insert.setOracleMultiInsertFirst(multiInsertToken.kind == K_FIRST); + } + ( + { + oracleMultiInsertBranch = new OracleMultiInsertBranch(); + } + oracleMultiInsertClause = OracleMultiInsertClause() { + oracleMultiInsertBranch.addClause(oracleMultiInsertClause); + table = oracleMultiInsertClause.getTable(); + } + ( + oracleMultiInsertClause = OracleMultiInsertClause() { + oracleMultiInsertBranch.addClause(oracleMultiInsertClause); + } + )* + { + oracleMultiInsertBranches.add(oracleMultiInsertBranch); + } + | + ( + ( + oracleMultiInsertBranch = OracleMultiInsertWhenBranch() { + if (table == null && !oracleMultiInsertBranch.getClauses().isEmpty()) { + table = oracleMultiInsertBranch.getClauses().get(0).getTable(); + } + oracleMultiInsertBranches.add(oracleMultiInsertBranch); + } + )+ + [ + oracleMultiInsertBranch = OracleMultiInsertElseBranch() { + if (table == null && !oracleMultiInsertBranch.getClauses().isEmpty()) { + table = oracleMultiInsertBranch.getClauses().get(0).getTable(); + } + oracleMultiInsertBranches.add(oracleMultiInsertBranch); + } + ] + ) + ) + select = Select() { + insert.setOracleMultiInsertBranches(oracleMultiInsertBranches); + } + ) + | + ( + [ LOOKAHEAD(2) ( + { insert.setOverwrite(true); insert.setTableKeyword(true); } + | [ LOOKAHEAD(2) { insert.setTableKeyword(true); }] + ) + ] table=TableReference() + [ LOOKAHEAD(2) "(" partitions=Partitions() ")" ] -// Unicode characters and categories are defined here: https://www.unicode.org/Public/UNIDATA/UnicodeData.txt -// SQL:2016 states: -// An is any character in the Unicode General Category classes “Lu”, “Ll”, “Lt”, “Lm”, “Lo”, or “Nl”. -// An is U+00B7, “Middle Dot”, or any character in the Unicode General Category classes “Mn”, “Mc”, “Nd”, “Pc”, or “Cf”. + [ LOOKAHEAD({ isAliasAhead() && !isColumnMatchingAhead() && !isInsertTableSourceAhead() + && !(getToken(1).kind == K_OVERRIDING + && (getToken(2).kind == K_SYSTEM || getToken(2).kind == K_USER)) }) + [ { useAs = true; } ] name=RelObjectName() { table.setAlias(new Alias(name,useAs)); }] -// unicode_identifier_start -| <#UnicodeIdentifierStart: ("\u00B7" | | | | | | |) > -| <#Ll: ["a"-"z","µ","ß"-"ö","ø"-"ÿ","ā","ă","ą","ć","ĉ","ċ","č","ď","đ","ē","ĕ","ė","ę","ě","ĝ","ğ","ġ","ģ","ĥ","ħ","ĩ","ī","ĭ","į","ı","ij","ĵ","ķ"-"ĸ","ĺ","ļ","ľ","ŀ","ł","ń","ņ","ň"-"ʼn","ŋ","ō","ŏ","ő","œ","ŕ","ŗ","ř","ś","ŝ","ş","š","ţ","ť","ŧ","ũ","ū","ŭ","ů","ű","ų","ŵ","ŷ","ź","ż","ž"-"ƀ","ƃ","ƅ","ƈ","ƌ"-"ƍ","ƒ","ƕ","ƙ"-"ƛ","ƞ","ơ","ƣ","ƥ","ƨ","ƪ"-"ƫ","ƭ","ư","ƴ","ƶ","ƹ"-"ƺ","ƽ"-"ƿ","dž","lj","nj","ǎ","ǐ","ǒ","ǔ","ǖ","ǘ","ǚ","ǜ"-"ǝ","ǟ","ǡ","ǣ","ǥ","ǧ","ǩ","ǫ","ǭ","ǯ"-"ǰ","dz","ǵ","ǹ","ǻ","ǽ","ǿ","ȁ","ȃ","ȅ","ȇ","ȉ","ȋ","ȍ","ȏ","ȑ","ȓ","ȕ","ȗ","ș","ț","ȝ","ȟ","ȡ","ȣ","ȥ","ȧ","ȩ","ȫ","ȭ","ȯ","ȱ","ȳ"-"ȹ","ȼ","ȿ"-"ɀ","ɂ","ɇ","ɉ","ɋ","ɍ","ɏ"-"ʓ","ʕ"-"ʯ","ͱ","ͳ","ͷ","ͻ"-"ͽ","ΐ","ά"-"ώ","ϐ"-"ϑ","ϕ"-"ϗ","ϙ","ϛ","ϝ","ϟ","ϡ","ϣ","ϥ","ϧ","ϩ","ϫ","ϭ","ϯ"-"ϳ","ϵ","ϸ","ϻ"-"ϼ","а"-"џ","ѡ","ѣ","ѥ","ѧ","ѩ","ѫ","ѭ","ѯ","ѱ","ѳ","ѵ","ѷ","ѹ","ѻ","ѽ","ѿ","ҁ","ҋ","ҍ","ҏ","ґ","ғ","ҕ","җ","ҙ","қ","ҝ","ҟ","ҡ","ң","ҥ","ҧ","ҩ","ҫ","ҭ","ү","ұ","ҳ","ҵ","ҷ","ҹ","һ","ҽ","ҿ","ӂ","ӄ","ӆ","ӈ","ӊ","ӌ","ӎ"-"ӏ","ӑ","ӓ","ӕ","ӗ","ә","ӛ","ӝ","ӟ","ӡ","ӣ","ӥ","ӧ","ө","ӫ","ӭ","ӯ","ӱ","ӳ","ӵ","ӷ","ӹ","ӻ","ӽ","ӿ","ԁ","ԃ","ԅ","ԇ","ԉ","ԋ","ԍ","ԏ","ԑ","ԓ","ԕ","ԗ","ԙ","ԛ","ԝ","ԟ","ԡ","ԣ","ԥ","ԧ","ԩ","ԫ","ԭ","ԯ","ՠ"-"ֈ","ა"-"ჺ","ჽ"-"ჿ","ᏸ"-"ᏽ","ᲀ"-"ᲈ","ᴀ"-"ᴫ","ᵫ"-"ᵷ","ᵹ"-"ᶚ","ḁ","ḃ","ḅ","ḇ","ḉ","ḋ","ḍ","ḏ","ḑ","ḓ","ḕ","ḗ","ḙ","ḛ","ḝ","ḟ","ḡ","ḣ","ḥ","ḧ","ḩ","ḫ","ḭ","ḯ","ḱ","ḳ","ḵ","ḷ","ḹ","ḻ","ḽ","ḿ","ṁ","ṃ","ṅ","ṇ","ṉ","ṋ","ṍ","ṏ","ṑ","ṓ","ṕ","ṗ","ṙ","ṛ","ṝ","ṟ","ṡ","ṣ","ṥ","ṧ","ṩ","ṫ","ṭ","ṯ","ṱ","ṳ","ṵ","ṷ","ṹ","ṻ","ṽ","ṿ","ẁ","ẃ","ẅ","ẇ","ẉ","ẋ","ẍ","ẏ","ẑ","ẓ","ẕ"-"ẝ","ẟ","ạ","ả","ấ","ầ","ẩ","ẫ","ậ","ắ","ằ","ẳ","ẵ","ặ","ẹ","ẻ","ẽ","ế","ề","ể","ễ","ệ","ỉ","ị","ọ","ỏ","ố","ồ","ổ","ỗ","ộ","ớ","ờ","ở","ỡ","ợ","ụ","ủ","ứ","ừ","ử","ữ","ự","ỳ","ỵ","ỷ","ỹ","ỻ","ỽ","ỿ"-"ἇ","ἐ"-"ἕ","ἠ"-"ἧ","ἰ"-"ἷ","ὀ"-"ὅ","ὐ"-"ὗ","ὠ"-"ὧ","ὰ"-"ώ","ᾀ"-"ᾇ","ᾐ"-"ᾗ","ᾠ"-"ᾧ","ᾰ"-"ᾴ","ᾶ"-"ᾷ","ι","ῂ"-"ῄ","ῆ"-"ῇ","ῐ"-"ΐ","ῖ"-"ῗ","ῠ"-"ῧ","ῲ"-"ῴ","ῶ"-"ῷ","ℊ","ℎ"-"ℏ","ℓ","ℯ","ℴ","ℹ","ℼ"-"ℽ","ⅆ"-"ⅉ","ⅎ","ↄ","ⰰ"-"ⱟ","ⱡ","ⱥ"-"ⱦ","ⱨ","ⱪ","ⱬ","ⱱ","ⱳ"-"ⱴ","ⱶ"-"ⱻ","ⲁ","ⲃ","ⲅ","ⲇ","ⲉ","ⲋ","ⲍ","ⲏ","ⲑ","ⲓ","ⲕ","ⲗ","ⲙ","ⲛ","ⲝ","ⲟ","ⲡ","ⲣ","ⲥ","ⲧ","ⲩ","ⲫ","ⲭ","ⲯ","ⲱ","ⲳ","ⲵ","ⲷ","ⲹ","ⲻ","ⲽ","ⲿ","ⳁ","ⳃ","ⳅ","ⳇ","ⳉ","ⳋ","ⳍ","ⳏ","ⳑ","ⳓ","ⳕ","ⳗ","ⳙ","ⳛ","ⳝ","ⳟ","ⳡ","ⳣ"-"ⳤ","ⳬ","ⳮ","ⳳ","ⴀ"-"ⴥ","ⴧ","ⴭ","ꙁ","ꙃ","ꙅ","ꙇ","ꙉ","ꙋ","ꙍ","ꙏ","ꙑ","ꙓ","ꙕ","ꙗ","ꙙ","ꙛ","ꙝ","ꙟ","ꙡ","ꙣ","ꙥ","ꙧ","ꙩ","ꙫ","ꙭ","ꚁ","ꚃ","ꚅ","ꚇ","ꚉ","ꚋ","ꚍ","ꚏ","ꚑ","ꚓ","ꚕ","ꚗ","ꚙ","ꚛ","ꜣ","ꜥ","ꜧ","ꜩ","ꜫ","ꜭ","ꜯ"-"ꜱ","ꜳ","ꜵ","ꜷ","ꜹ","ꜻ","ꜽ","ꜿ","ꝁ","ꝃ","ꝅ","ꝇ","ꝉ","ꝋ","ꝍ","ꝏ","ꝑ","ꝓ","ꝕ","ꝗ","ꝙ","ꝛ","ꝝ","ꝟ","ꝡ","ꝣ","ꝥ","ꝧ","ꝩ","ꝫ","ꝭ","ꝯ","ꝱ"-"ꝸ","ꝺ","ꝼ","ꝿ","ꞁ","ꞃ","ꞅ","ꞇ","ꞌ","ꞎ","ꞑ","ꞓ"-"ꞕ","ꞗ","ꞙ","ꞛ","ꞝ","ꞟ","ꞡ","ꞣ","ꞥ","ꞧ","ꞩ","ꞯ","ꞵ","ꞷ","ꞹ","ꞻ","ꞽ","ꞿ","ꟁ","ꟃ","ꟈ","ꟊ","ꟑ","ꟓ","ꟕ","ꟗ","ꟙ","ꟶ","ꟺ","ꬰ"-"ꭚ","ꭠ"-"ꭨ","ꭰ"-"ꮿ","ff"-"st","ﬓ"-"ﬗ","a"-"z"]> -| <#Lm: ["ʰ"-"ˁ","ˆ"-"ˑ","ˠ"-"ˤ","ˬ","ˮ","ʹ","ͺ","ՙ","ـ","ۥ"-"ۦ","ߴ"-"ߵ","ߺ","ࠚ","ࠤ","ࠨ","ࣉ","ॱ","ๆ","ໆ","ჼ","ៗ","ᡃ","ᪧ","ᱸ"-"ᱽ","ᴬ"-"ᵪ","ᵸ","ᶛ"-"ᶿ","ⁱ","ⁿ","ₐ"-"ₜ","ⱼ"-"ⱽ","ⵯ","ⸯ","々","〱"-"〵","〻","ゝ"-"ゞ","ー"-"ヾ","ꀕ","ꓸ"-"ꓽ","ꘌ","ꙿ","ꚜ"-"ꚝ","ꜗ"-"ꜟ","ꝰ","ꞈ","ꟲ"-"ꟴ","ꟸ"-"ꟹ","ꧏ","ꧦ","ꩰ","ꫝ","ꫳ"-"ꫴ","ꭜ"-"ꭟ","ꭩ","ー","゙"-"゚"]> -| <#Lo: ["ª","º","ƻ","ǀ"-"ǃ","ʔ","א"-"ת","ׯ"-"ײ","ؠ"-"ؿ","ف"-"ي","ٮ"-"ٯ","ٱ"-"ۓ","ە","ۮ"-"ۯ","ۺ"-"ۼ","ۿ","ܐ","ܒ"-"ܯ","ݍ"-"ޥ","ޱ","ߊ"-"ߪ","ࠀ"-"ࠕ","ࡀ"-"ࡘ","ࡠ"-"ࡪ","ࡰ"-"ࢇ","ࢉ"-"ࢎ","ࢠ"-"ࣈ","ऄ"-"ह","ऽ","ॐ","क़"-"ॡ","ॲ"-"ঀ","অ"-"ঌ","এ"-"ঐ","ও"-"ন","প"-"র","ল","শ"-"হ","ঽ","ৎ","ড়"-"ঢ়","য়"-"ৡ","ৰ"-"ৱ","ৼ","ਅ"-"ਊ","ਏ"-"ਐ","ਓ"-"ਨ","ਪ"-"ਰ","ਲ"-"ਲ਼","ਵ"-"ਸ਼","ਸ"-"ਹ","ਖ਼"-"ੜ","ਫ਼","ੲ"-"ੴ","અ"-"ઍ","એ"-"ઑ","ઓ"-"ન","પ"-"ર","લ"-"ળ","વ"-"હ","ઽ","ૐ","ૠ"-"ૡ","ૹ","ଅ"-"ଌ","ଏ"-"ଐ","ଓ"-"ନ","ପ"-"ର","ଲ"-"ଳ","ଵ"-"ହ","ଽ","ଡ଼"-"ଢ଼","ୟ"-"ୡ","ୱ","ஃ","அ"-"ஊ","எ"-"ஐ","ஒ"-"க","ங"-"ச","ஜ","ஞ"-"ட","ண"-"த","ந"-"ப","ம"-"ஹ","ௐ","అ"-"ఌ","ఎ"-"ఐ","ఒ"-"న","ప"-"హ","ఽ","ౘ"-"ౚ","ౝ","ౠ"-"ౡ","ಀ","ಅ"-"ಌ","ಎ"-"ಐ","ಒ"-"ನ","ಪ"-"ಳ","ವ"-"ಹ","ಽ","ೝ"-"ೞ","ೠ"-"ೡ","ೱ"-"ೲ","ഄ"-"ഌ","എ"-"ഐ","ഒ"-"ഺ","ഽ","ൎ","ൔ"-"ൖ","ൟ"-"ൡ","ൺ"-"ൿ","අ"-"ඖ","ක"-"න","ඳ"-"ර","ල","ව"-"ෆ","ก"-"ะ","า"-"ำ","เ"-"ๅ","ກ"-"ຂ","ຄ","ຆ"-"ຊ","ຌ"-"ຣ","ລ","ວ"-"ະ","າ"-"ຳ","ຽ","ເ"-"ໄ","ໜ"-"ໟ","ༀ","ཀ"-"ཇ","ཉ"-"ཬ","ྈ"-"ྌ","က"-"ဪ","ဿ","ၐ"-"ၕ","ၚ"-"ၝ","ၡ","ၥ"-"ၦ","ၮ"-"ၰ","ၵ"-"ႁ","ႎ","ᄀ"-"ቈ","ቊ"-"ቍ","ቐ"-"ቖ","ቘ","ቚ"-"ቝ","በ"-"ኈ","ኊ"-"ኍ","ነ"-"ኰ","ኲ"-"ኵ","ኸ"-"ኾ","ዀ","ዂ"-"ዅ","ወ"-"ዖ","ዘ"-"ጐ","ጒ"-"ጕ","ጘ"-"ፚ","ᎀ"-"ᎏ","ᐁ"-"ᙬ","ᙯ"-"ᙿ","ᚁ"-"ᚚ","ᚠ"-"ᛪ","ᛱ"-"ᛸ","ᜀ"-"ᜑ","ᜟ"-"ᜱ","ᝀ"-"ᝑ","ᝠ"-"ᝬ","ᝮ"-"ᝰ","ក"-"ឳ","ៜ","ᠠ"-"ᡂ","ᡄ"-"ᡸ","ᢀ"-"ᢄ","ᢇ"-"ᢨ","ᢪ","ᢰ"-"ᣵ","ᤀ"-"ᤞ","ᥐ"-"ᥭ","ᥰ"-"ᥴ","ᦀ"-"ᦫ","ᦰ"-"ᧉ","ᨀ"-"ᨖ","ᨠ"-"ᩔ","ᬅ"-"ᬳ","ᭅ"-"ᭌ","ᮃ"-"ᮠ","ᮮ"-"ᮯ","ᮺ"-"ᯥ","ᰀ"-"ᰣ","ᱍ"-"ᱏ","ᱚ"-"ᱷ","ᳩ"-"ᳬ","ᳮ"-"ᳳ","ᳵ"-"ᳶ","ᳺ","ℵ"-"ℸ","ⴰ"-"ⵧ","ⶀ"-"ⶖ","ⶠ"-"ⶦ","ⶨ"-"ⶮ","ⶰ"-"ⶶ","ⶸ"-"ⶾ","ⷀ"-"ⷆ","ⷈ"-"ⷎ","ⷐ"-"ⷖ","ⷘ"-"ⷞ","〆","〼","ぁ"-"ゖ","ゟ","ァ"-"ヺ","ヿ","ㄅ"-"ㄯ","ㄱ"-"ㆎ","ㆠ"-"ㆿ","ㇰ"-"ㇿ","䶿","鿿"-"ꀔ","ꀖ"-"ꒌ","ꓐ"-"ꓷ","ꔀ"-"ꘋ","ꘐ"-"ꘟ","ꘪ"-"ꘫ","ꙮ","ꚠ"-"ꛥ","ꞏ","ꟷ","ꟻ"-"ꠁ","ꠃ"-"ꠅ","ꠇ"-"ꠊ","ꠌ"-"ꠢ","ꡀ"-"ꡳ","ꢂ"-"ꢳ","ꣲ"-"ꣷ","ꣻ","ꣽ"-"ꣾ","ꤊ"-"ꤥ","ꤰ"-"ꥆ","ꥠ"-"ꥼ","ꦄ"-"ꦲ","ꧠ"-"ꧤ","ꧧ"-"ꧯ","ꧺ"-"ꧾ","ꨀ"-"ꨨ","ꩀ"-"ꩂ","ꩄ"-"ꩋ","ꩠ"-"ꩯ","ꩱ"-"ꩶ","ꩺ","ꩾ"-"ꪯ","ꪱ","ꪵ"-"ꪶ","ꪹ"-"ꪽ","ꫀ","ꫂ","ꫛ"-"ꫜ","ꫠ"-"ꫪ","ꫲ","ꬁ"-"ꬆ","ꬉ"-"ꬎ","ꬑ"-"ꬖ","ꬠ"-"ꬦ","ꬨ"-"ꬮ","ꯀ"-"ꯢ","힣","ힰ"-"ퟆ","ퟋ"-"ퟻ","豈"-"舘","並"-"龎","יִ","ײַ"-"ﬨ","שׁ"-"זּ","טּ"-"לּ","מּ","נּ"-"סּ","ףּ"-"פּ","צּ"-"ﮱ","ﯓ"-"ﴽ","ﵐ"-"ﶏ","ﶒ"-"ﷇ","ﷰ"-"ﷻ","ﹰ"-"ﹴ","ﹶ"-"ﻼ","ヲ"-"ッ","ア"-"ン","ᅠ"-"ᄒ","ᅡ"-"ᅦ","ᅧ"-"ᅬ","ᅭ"-"ᅲ","ᅳ"-"ᅵ"]> -| <#Lt: ["Dž","Lj","Nj","Dz","ᾈ"-"ᾏ","ᾘ"-"ᾟ","ᾨ"-"ᾯ","ᾼ","ῌ","ῼ"]> -| <#Lu: ["A"-"Z","À"-"Ö","Ø"-"Þ","Ā","Ă","Ą","Ć","Ĉ","Ċ","Č","Ď","Đ","Ē","Ĕ","Ė","Ę","Ě","Ĝ","Ğ","Ġ","Ģ","Ĥ","Ħ","Ĩ","Ī","Ĭ","Į","İ","IJ","Ĵ","Ķ","Ĺ","Ļ","Ľ","Ŀ","Ł","Ń","Ņ","Ň","Ŋ","Ō","Ŏ","Ő","Œ","Ŕ","Ŗ","Ř","Ś","Ŝ","Ş","Š","Ţ","Ť","Ŧ","Ũ","Ū","Ŭ","Ů","Ű","Ų","Ŵ","Ŷ","Ÿ"-"Ź","Ż","Ž","Ɓ"-"Ƃ","Ƅ","Ɔ"-"Ƈ","Ɖ"-"Ƌ","Ǝ"-"Ƒ","Ɠ"-"Ɣ","Ɩ"-"Ƙ","Ɯ"-"Ɲ","Ɵ"-"Ơ","Ƣ","Ƥ","Ʀ"-"Ƨ","Ʃ","Ƭ","Ʈ"-"Ư","Ʊ"-"Ƴ","Ƶ","Ʒ"-"Ƹ","Ƽ","DŽ","LJ","NJ","Ǎ","Ǐ","Ǒ","Ǔ","Ǖ","Ǘ","Ǚ","Ǜ","Ǟ","Ǡ","Ǣ","Ǥ","Ǧ","Ǩ","Ǫ","Ǭ","Ǯ","DZ","Ǵ","Ƕ"-"Ǹ","Ǻ","Ǽ","Ǿ","Ȁ","Ȃ","Ȅ","Ȇ","Ȉ","Ȋ","Ȍ","Ȏ","Ȑ","Ȓ","Ȕ","Ȗ","Ș","Ț","Ȝ","Ȟ","Ƞ","Ȣ","Ȥ","Ȧ","Ȩ","Ȫ","Ȭ","Ȯ","Ȱ","Ȳ","Ⱥ"-"Ȼ","Ƚ"-"Ⱦ","Ɂ","Ƀ"-"Ɇ","Ɉ","Ɋ","Ɍ","Ɏ","Ͱ","Ͳ","Ͷ","Ϳ","Ά","Έ"-"Ί","Ό","Ύ"-"Ώ","Α"-"Ρ","Σ"-"Ϋ","Ϗ","ϒ"-"ϔ","Ϙ","Ϛ","Ϝ","Ϟ","Ϡ","Ϣ","Ϥ","Ϧ","Ϩ","Ϫ","Ϭ","Ϯ","ϴ","Ϸ","Ϲ"-"Ϻ","Ͻ"-"Я","Ѡ","Ѣ","Ѥ","Ѧ","Ѩ","Ѫ","Ѭ","Ѯ","Ѱ","Ѳ","Ѵ","Ѷ","Ѹ","Ѻ","Ѽ","Ѿ","Ҁ","Ҋ","Ҍ","Ҏ","Ґ","Ғ","Ҕ","Җ","Ҙ","Қ","Ҝ","Ҟ","Ҡ","Ң","Ҥ","Ҧ","Ҩ","Ҫ","Ҭ","Ү","Ұ","Ҳ","Ҵ","Ҷ","Ҹ","Һ","Ҽ","Ҿ","Ӏ"-"Ӂ","Ӄ","Ӆ","Ӈ","Ӊ","Ӌ","Ӎ","Ӑ","Ӓ","Ӕ","Ӗ","Ә","Ӛ","Ӝ","Ӟ","Ӡ","Ӣ","Ӥ","Ӧ","Ө","Ӫ","Ӭ","Ӯ","Ӱ","Ӳ","Ӵ","Ӷ","Ӹ","Ӻ","Ӽ","Ӿ","Ԁ","Ԃ","Ԅ","Ԇ","Ԉ","Ԋ","Ԍ","Ԏ","Ԑ","Ԓ","Ԕ","Ԗ","Ԙ","Ԛ","Ԝ","Ԟ","Ԡ","Ԣ","Ԥ","Ԧ","Ԩ","Ԫ","Ԭ","Ԯ","Ա"-"Ֆ","Ⴀ"-"Ⴥ","Ⴧ","Ⴭ","Ꭰ"-"Ᏽ","Ა"-"Ჺ","Ჽ"-"Ჿ","Ḁ","Ḃ","Ḅ","Ḇ","Ḉ","Ḋ","Ḍ","Ḏ","Ḑ","Ḓ","Ḕ","Ḗ","Ḙ","Ḛ","Ḝ","Ḟ","Ḡ","Ḣ","Ḥ","Ḧ","Ḩ","Ḫ","Ḭ","Ḯ","Ḱ","Ḳ","Ḵ","Ḷ","Ḹ","Ḻ","Ḽ","Ḿ","Ṁ","Ṃ","Ṅ","Ṇ","Ṉ","Ṋ","Ṍ","Ṏ","Ṑ","Ṓ","Ṕ","Ṗ","Ṙ","Ṛ","Ṝ","Ṟ","Ṡ","Ṣ","Ṥ","Ṧ","Ṩ","Ṫ","Ṭ","Ṯ","Ṱ","Ṳ","Ṵ","Ṷ","Ṹ","Ṻ","Ṽ","Ṿ","Ẁ","Ẃ","Ẅ","Ẇ","Ẉ","Ẋ","Ẍ","Ẏ","Ẑ","Ẓ","Ẕ","ẞ","Ạ","Ả","Ấ","Ầ","Ẩ","Ẫ","Ậ","Ắ","Ằ","Ẳ","Ẵ","Ặ","Ẹ","Ẻ","Ẽ","Ế","Ề","Ể","Ễ","Ệ","Ỉ","Ị","Ọ","Ỏ","Ố","Ồ","Ổ","Ỗ","Ộ","Ớ","Ờ","Ở","Ỡ","Ợ","Ụ","Ủ","Ứ","Ừ","Ử","Ữ","Ự","Ỳ","Ỵ","Ỷ","Ỹ","Ỻ","Ỽ","Ỿ","Ἀ"-"Ἇ","Ἐ"-"Ἕ","Ἠ"-"Ἧ","Ἰ"-"Ἷ","Ὀ"-"Ὅ","Ὑ","Ὓ","Ὕ","Ὗ","Ὠ"-"Ὧ","Ᾰ"-"Ά","Ὲ"-"Ή","Ῐ"-"Ί","Ῠ"-"Ῥ","Ὸ"-"Ώ","ℂ","ℇ","ℋ"-"ℍ","ℐ"-"ℒ","ℕ","ℙ"-"ℝ","ℤ","Ω","ℨ","K"-"ℭ","ℰ"-"ℳ","ℾ"-"ℿ","ⅅ","Ↄ","Ⰰ"-"Ⱟ","Ⱡ","Ɫ"-"Ɽ","Ⱨ","Ⱪ","Ⱬ","Ɑ"-"Ɒ","Ⱳ","Ⱶ","Ȿ"-"Ⲁ","Ⲃ","Ⲅ","Ⲇ","Ⲉ","Ⲋ","Ⲍ","Ⲏ","Ⲑ","Ⲓ","Ⲕ","Ⲗ","Ⲙ","Ⲛ","Ⲝ","Ⲟ","Ⲡ","Ⲣ","Ⲥ","Ⲧ","Ⲩ","Ⲫ","Ⲭ","Ⲯ","Ⲱ","Ⲳ","Ⲵ","Ⲷ","Ⲹ","Ⲻ","Ⲽ","Ⲿ","Ⳁ","Ⳃ","Ⳅ","Ⳇ","Ⳉ","Ⳋ","Ⳍ","Ⳏ","Ⳑ","Ⳓ","Ⳕ","Ⳗ","Ⳙ","Ⳛ","Ⳝ","Ⳟ","Ⳡ","Ⳣ","Ⳬ","Ⳮ","Ⳳ","Ꙁ","Ꙃ","Ꙅ","Ꙇ","Ꙉ","Ꙋ","Ꙍ","Ꙏ","Ꙑ","Ꙓ","Ꙕ","Ꙗ","Ꙙ","Ꙛ","Ꙝ","Ꙟ","Ꙡ","Ꙣ","Ꙥ","Ꙧ","Ꙩ","Ꙫ","Ꙭ","Ꚁ","Ꚃ","Ꚅ","Ꚇ","Ꚉ","Ꚋ","Ꚍ","Ꚏ","Ꚑ","Ꚓ","Ꚕ","Ꚗ","Ꚙ","Ꚛ","Ꜣ","Ꜥ","Ꜧ","Ꜩ","Ꜫ","Ꜭ","Ꜯ","Ꜳ","Ꜵ","Ꜷ","Ꜹ","Ꜻ","Ꜽ","Ꜿ","Ꝁ","Ꝃ","Ꝅ","Ꝇ","Ꝉ","Ꝋ","Ꝍ","Ꝏ","Ꝑ","Ꝓ","Ꝕ","Ꝗ","Ꝙ","Ꝛ","Ꝝ","Ꝟ","Ꝡ","Ꝣ","Ꝥ","Ꝧ","Ꝩ","Ꝫ","Ꝭ","Ꝯ","Ꝺ","Ꝼ","Ᵹ"-"Ꝿ","Ꞁ","Ꞃ","Ꞅ","Ꞇ","Ꞌ","Ɥ","Ꞑ","Ꞓ","Ꞗ","Ꞙ","Ꞛ","Ꞝ","Ꞟ","Ꞡ","Ꞣ","Ꞥ","Ꞧ","Ꞩ","Ɦ"-"Ɪ","Ʞ"-"Ꞵ","Ꞷ","Ꞹ","Ꞻ","Ꞽ","Ꞿ","Ꟁ","Ꟃ","Ꞔ"-"Ꟈ","Ꟊ","Ꟑ","Ꟗ","Ꟙ","Ꟶ","A"-"Z"]> -| <#Nl: ["ᛮ"-"ᛰ","Ⅰ"-"ↂ","ↅ"-"ↈ","〇","〡"-"〩","〸"-"〺","ꛦ"-"ꛯ"]> + [ LOOKAHEAD(2) columns=InsertColumnList() ] -// unicode_identifier_extend -| <#UnicodeIdentifierExtend: (|||||)> -| <#Cf: ["­","؀"-"؅","؜","۝","܏","࢐"-"࢑","࣢","᠎","​"-"‏","‪"-"‮","⁠"-"⁤","⁦"-"","",""-""]> -| <#Mc: ["ः","ऻ","ा"-"ी","ॉ"-"ौ","ॎ"-"ॏ","ং"-"ঃ","া"-"ী","ে"-"ৈ","ো"-"ৌ","ৗ","ਃ","ਾ"-"ੀ","ઃ","ા"-"ી","ૉ","ો"-"ૌ","ଂ"-"ଃ","ା","ୀ","େ"-"ୈ","ୋ"-"ୌ","ୗ","ா"-"ி","ு"-"ூ","ெ"-"ை","ொ"-"ௌ","ௗ","ఁ"-"ః","ు"-"ౄ","ಂ"-"ಃ","ಾ","ೀ"-"ೄ","ೇ"-"ೈ","ೊ"-"ೋ","ೕ"-"ೖ","ೳ","ം"-"ഃ","ാ"-"ീ","െ"-"ൈ","ൊ"-"ൌ","ൗ","ං"-"ඃ","ා"-"ෑ","ෘ"-"ෟ","ෲ"-"ෳ","༾"-"༿","ཿ","ါ"-"ာ","ေ","း","ျ"-"ြ","ၖ"-"ၗ","ၢ"-"ၤ","ၧ"-"ၭ","ႃ"-"ႄ","ႇ"-"ႌ","ႏ","ႚ"-"ႜ","᜕","᜴","ា","ើ"-"ៅ","ះ"-"ៈ","ᤣ"-"ᤦ","ᤩ"-"ᤫ","ᤰ"-"ᤱ","ᤳ"-"ᤸ","ᨙ"-"ᨚ","ᩕ","ᩗ","ᩡ","ᩣ"-"ᩤ","ᩭ"-"ᩲ","ᬄ","ᬵ","ᬻ","ᬽ"-"ᭁ","ᭃ"-"᭄","ᮂ","ᮡ","ᮦ"-"ᮧ","᮪","ᯧ","ᯪ"-"ᯬ","ᯮ","᯲"-"᯳","ᰤ"-"ᰫ","ᰴ"-"ᰵ","᳡","᳷","〮"-"〯","ꠣ"-"ꠤ","ꠧ","ꢀ"-"ꢁ","ꢴ"-"ꣃ","ꥒ"-"꥓","ꦃ","ꦴ"-"ꦵ","ꦺ"-"ꦻ","ꦾ"-"꧀","ꨯ"-"ꨰ","ꨳ"-"ꨴ","ꩍ","ꩻ","ꩽ","ꫫ","ꫮ"-"ꫯ","ꫵ","ꯣ"-"ꯤ","ꯦ"-"ꯧ","ꯩ"-"ꯪ","꯬"]> -| <#Mn: ["̀"-"ͯ","҃"-"҇","֑"-"ֽ","ֿ","ׁ"-"ׂ","ׄ"-"ׅ","ׇ","ؐ"-"ؚ","ً"-"ٟ","ٰ","ۖ"-"ۜ","۟"-"ۤ","ۧ"-"ۨ","۪"-"ۭ","ܑ","ܰ"-"݊","ަ"-"ް","߫"-"߳","߽","ࠖ"-"࠙","ࠛ"-"ࠣ","ࠥ"-"ࠧ","ࠩ"-"࠭","࡙"-"࡛","࢘"-"࢟","࣊"-"࣡","ࣣ"-"ं","ऺ","़","ु"-"ै","्","॑"-"ॗ","ॢ"-"ॣ","ঁ","়","ু"-"ৄ","্","ৢ"-"ৣ","৾","ਁ"-"ਂ","਼","ੁ"-"ੂ","ੇ"-"ੈ","ੋ"-"੍","ੑ","ੰ"-"ੱ","ੵ","ઁ"-"ં","઼","ુ"-"ૅ","ે"-"ૈ","્","ૢ"-"ૣ","ૺ"-"૿","ଁ","଼","ି","ୁ"-"ୄ","୍","୕"-"ୖ","ୢ"-"ୣ","ஂ","ீ","்","ఀ","ఄ","఼","ా"-"ీ","ె"-"ై","ొ"-"్","ౕ"-"ౖ","ౢ"-"ౣ","ಁ","಼","ಿ","ೆ","ೌ"-"್","ೢ"-"ೣ","ഀ"-"ഁ","഻"-"഼","ു"-"ൄ","്","ൢ"-"ൣ","ඁ","්","ි"-"ු","ූ","ั","ิ"-"ฺ","็"-"๎","ັ","ິ"-"ຼ","່"-"໎","༘"-"༙","༵","༷","༹","ཱ"-"ཾ","ྀ"-"྄","྆"-"྇","ྍ"-"ྗ","ྙ"-"ྼ","࿆","ိ"-"ူ","ဲ"-"့","္"-"်","ွ"-"ှ","ၘ"-"ၙ","ၞ"-"ၠ","ၱ"-"ၴ","ႂ","ႅ"-"ႆ","ႍ","ႝ","፝"-"፟","ᜒ"-"᜔","ᜲ"-"ᜳ","ᝒ"-"ᝓ","ᝲ"-"ᝳ","឴"-"឵","ិ"-"ួ","ំ","៉"-"៓","៝","᠋"-"᠍","᠏","ᢅ"-"ᢆ","ᢩ","ᤠ"-"ᤢ","ᤧ"-"ᤨ","ᤲ","᤹"-"᤻","ᨗ"-"ᨘ","ᨛ","ᩖ","ᩘ"-"ᩞ","᩠","ᩢ","ᩥ"-"ᩬ","ᩳ"-"᩼","᩿","᪰"-"᪽","ᪿ"-"ᫎ","ᬀ"-"ᬃ","᬴","ᬶ"-"ᬺ","ᬼ","ᭂ","᭫"-"᭳","ᮀ"-"ᮁ","ᮢ"-"ᮥ","ᮨ"-"ᮩ","᮫"-"ᮭ","᯦","ᯨ"-"ᯩ","ᯭ","ᯯ"-"ᯱ","ᰬ"-"ᰳ","ᰶ"-"᰷","᳐"-"᳒","᳔"-"᳠","᳢"-"᳨","᳭","᳴","᳸"-"᳹","᷀"-"᷿","⃐"-"⃜","⃡","⃥"-"⃰","⳯"-"⳱","⵿","ⷠ"-"ⷿ","〪"-"〭","゙"-"゚","꙯","ꙴ"-"꙽","ꚞ"-"ꚟ","꛰"-"꛱","ꠂ","꠆","ꠋ","ꠥ"-"ꠦ","꠬","꣄"-"ꣅ","꣠"-"꣱","ꣿ","ꤦ"-"꤭","ꥇ"-"ꥑ","ꦀ"-"ꦂ","꦳","ꦶ"-"ꦹ","ꦼ"-"ꦽ","ꧥ","ꨩ"-"ꨮ","ꨱ"-"ꨲ","ꨵ"-"ꨶ","ꩃ","ꩌ","ꩼ","ꪰ","ꪲ"-"ꪴ","ꪷ"-"ꪸ","ꪾ"-"꪿","꫁","ꫬ"-"ꫭ","꫶","ꯥ","ꯨ","꯭","ﬞ","︀"-"️","︠"-"︯"]> -| <#Nd: ["0"-"9","٠"-"٩","۰"-"۹","߀"-"߉","०"-"९","০"-"৯","੦"-"੯","૦"-"૯","୦"-"୯","௦"-"௯","౦"-"౯","೦"-"೯","൦"-"൯","෦"-"෯","๐"-"๙","໐"-"໙","༠"-"༩","၀"-"၉","႐"-"႙","០"-"៩","᠐"-"᠙","᥆"-"᥏","᧐"-"᧙","᪀"-"᪉","᪐"-"᪙","᭐"-"᭙","᮰"-"᮹","᱀"-"᱉","᱐"-"᱙","꘠"-"꘩","꣐"-"꣙","꤀"-"꤉","꧐"-"꧙","꧰"-"꧹","꩐"-"꩙","꯰"-"꯹","0"-"9"]> -| <#Pc: ["‿"-"⁀","⁔","︳"-"︴","﹍"-"﹏","_"]> + // DuckDB: INSERT INTO tbl BY NAME|POSITION SELECT ... + [ + LOOKAHEAD({ isColumnMatchingAhead() }) + + ( + { insert.setColumnMatching(Insert.ColumnMatching.BY_NAME); } + | + // POSITION is lexed as a string-function name + + { insert.setColumnMatching(Insert.ColumnMatching.BY_POSITION); } + ) + ] -// CJK Unified Ideographs block according to https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) -| <#CJK: ["\uAC00"-"\uD7A3", "\u4E00"-"\u9FFF"]> + [ LOOKAHEAD(2) + ( { insert.setOverridingMode(Insert.OverridingMode.SYSTEM); } + | { insert.setOverridingMode(Insert.OverridingMode.USER); } ) ] -| < #SPECIAL_ESC: "\\'" > /* Allowing this will break LIKE ... ESCAPE ... */ -| < #ESC: "\\" ["n","t","b","r","f","\\","\""] > -| < S_CHAR_LITERAL: ( - (["U","E","N","R","B"]|"RB"|"_utf8")? - ( - ("'" ( | | ~["'", "\\"] )* "'") | ("'" ("''" | ~["'"])* "'") - // Alternative Oracle Escape Modes - | ("q'{" (~[])* "}'") - | ("q'(" (~[])* ")'") - | ("q'[" (~[])* "]'") - | ("q''" (~[])* "''") - // | ("q'\\" (~[])* "\\'") <--- Does not work - ) - ) > - { - // contains the token and always the longest match is returned - // So when Backslash is explicitly not allowed as an Escape Character and a is found - // which contains the , then we will need to - // 1) break the at close it with a "'" - // 2) continue tokenizing after that with a new or any other Token - boolean allowEscape = configuration.getAsBoolean(Feature.allowBackslashEscapeCharacter) - || (AbstractJSqlParser.Dialect.POSTGRESQL.name().equals(configuration.getValue(Feature.dialect)) - && matchedToken.image.regionMatches(true, 0, "E'", 0, 2)); - String img = matchedToken.image; - int pos; - if (!allowEscape) { - pos = indexOfSequence(img, "\\'"); - if (pos > 0) { - matchedToken.image = image.substring( 0, image.indexOf("\\'") + 1 ) + "'"; - // `charLiteralIndex` defined in TokenManagerDeclaration above - matchedToken.kind = charLiteralIndex; - input_stream.backup(image.length() - matchedToken.image.length()); - } + [ outputClause = OutputClause() { insert.setOutputClause(outputClause); } ] + + ( + { insert.setOnlyDefaultValues(true); } + | + ( + updateSets = UpdateSets() { insert.withSetUpdateSets(updateSets); useSet = true; } + ) + | + select = Select() + ) + + [ LOOKAHEAD({ isAliasAhead() && (select instanceof Values || useSet) }) rowAlias = Alias() { + if (select instanceof Values) { + select.setAlias(rowAlias); } else { - pos = lastIndexOfSequence(img, "\\''"); - if (pos > 0) { - matchedToken.image = image.substring( 0, image.lastIndexOf("\\'") + 3); - // `charLiteralIndex` defined in TokenManagerDeclaration above - matchedToken.kind = charLiteralIndex; - input_stream.backup(image.length() - matchedToken.image.length() ); - } + insert.setRowAlias(rowAlias); } - } -| < S_QUOTED_IDENTIFIER: "\"" ( "\"\"" | ~["\n","\r","\""])* "\"" | ("`" ("``" | ~["\n","\r","`"])* "`") | ( "[" (~["\n","\r","]"])* "]" ) > - { - if ( !configuration.getAsBoolean(Feature.allowSquareBracketQuotation) - && matchedToken.image.charAt(0) == '[' ) { + } ] - matchedToken.image = "["; - // `squaredBracketOpenIndex` defined in TokenManagerDeclaration above - matchedToken.kind = squaredBracketOpenIndex; - input_stream.backup(image.length() - 1); + [ LOOKAHEAD(2) + duplicateAction = InsertDuplicateAction() { insert.setDuplicateAction(duplicateAction); } + ] + + [ + + [ conflictTarget = InsertConflictTarget() ] + conflictAction = InsertConflictAction() { insert.withConflictTarget(conflictTarget).setConflictAction(conflictAction); } + ] + + [ returningClause = ReturningClause() { insert.setReturningClause(returningClause); } ] + ) + ) + + { + if (columns != null) { + insert.setColumns(columns); } - if ( configuration.getAsBoolean(Feature.allowDoubleQuotedStrings) - && matchedToken.image.charAt(0) == '"' ) { - // `charLiteralIndex` defined in TokenManagerDeclaration above - matchedToken.kind = charLiteralIndex; + if (!partitions.isEmpty()) { + insert.setPartitions(partitions); } + return insert.withWithItemsList(with) + .withSelect(select) + .withTable(table) + .withModifierPriority(modifierPriority) + .withModifierIgnore(modifierIgnore); } } /** - * Parses identifiers including standard SQL identifiers, quoted identifiers, and specific keywords. - * - * This is used in cases where certain SQL keywords (like NAME, NEXT, VALUE, etc.) can appear - * as identifiers (e.g., table names, column names) depending on the SQL dialect or context. - * - * Supported tokens: - * - : Standard unquoted SQL identifier - * - : Quoted identifier (e.g., `identifier` or "identifier") - * - , , , , , , : Specific keywords treated as identifiers - * - * @return Token representing the identifier or keyword used as identifier + * The target column list of INSERT and REPLACE, without its parentheses. MySQL accepts an empty + * list, as in INSERT INTO t () VALUES (). */ -Token KeywordOrIdentifier(): +ExpressionList InsertColumnList(): { - Token tk; + ExpressionList columns = new ExpressionList(); } { - ( - tk = - | tk = - | tk = - | tk = - | tk = - | tk = - | tk = - | tk = - | tk = - | tk = - ) - { return tk; } + "(" [ columns = ColumnList() ] ")" + { + return columns; + } } -Statement Statement() #Statement: +/** {@link #InsertColumnList()} with its parentheses, as REPLACE keeps it. */ +ParenthesedExpressionList ParenthesedInsertColumnList(): { - IfElseStatement ifElseStatement = null; - Statement stm = null; - Statement stm2 = null; - Expression condition; + ExpressionList columns; + Token first = getToken(1); } { - ( - try { - ( - condition=Condition() - ( stm = SingleStatement() | stm = Block() ) { ifElseStatement = new IfElseStatement(condition, stm); } - [ LOOKAHEAD(2) - [ { ifElseStatement.setUsingSemicolonForIfStatement(true); } ] - ( stm2 = SingleStatement() | stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); } - ] - - [ - LOOKAHEAD(2) - { if (stm2!=null) - ifElseStatement.setUsingSemicolonForElseStatement(true); - else if (ifElseStatement!=null) - ifElseStatement.setUsingSemicolonForIfStatement(true); - } - ] - ) - | - ( - (stm = SingleStatement() - | stm = Block()) - - ( | ) - ) - | - LOOKAHEAD( { stm==null && getAsBoolean(Feature.allowUnsupportedStatements) } ) stm = UnsupportedStatement() - } catch (ParseException ex) { - if ( getAsBoolean(Feature.allowUnsupportedStatements) ) { - stm = new UnsupportedStatement( stm.toString(), error_skipto(ST_SEMICOLON) ); - } else if ( errorRecovery ) { - parseErrors.add(ex); - error_skipto(ST_SEMICOLON); - stm = null; - } else { - throw ex; - } - } - - ) - - { - return ifElseStatement!=null ? ifElseStatement : stm; - } + columns = InsertColumnList() + { + ParenthesedExpressionList result = new ParenthesedExpressionList(columns); + linkAST(result, first); + return result; + } } -Statement SingleStatement() : +OracleMultiInsertClause OracleMultiInsertClause(): { - Statement stm = null; - List> with = null; + OracleMultiInsertClause clause = new OracleMultiInsertClause(); + Table clauseTable = null; + ExpressionList clauseColumns = new ExpressionList(); + Select clauseSelect = null; } { - ( - LOOKAHEAD({ Dialect.ORACLE.name().equals(getAsString(Feature.dialect)) - && (getToken(1).kind == K_DECLARE || getToken(1).kind == K_BEGIN) }) - stm = OracleBlock() - | - LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && ((getToken(1).kind == K_ALTER && (getToken(2).kind == K_FUNCTION || getToken(2).kind == K_PROCEDURE)) - || (getToken(1).kind == K_CREATE && (getToken(2).kind == K_FUNCTION || getToken(2).kind == K_PROCEDURE - || (getToken(2).kind == K_OR && getToken(3).kind == K_ALTER - && (getToken(4).kind == K_FUNCTION || getToken(4).kind == K_PROCEDURE))))) }) - stm = SqlServerRoutine() - | - LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind == K_INSERT && "BULK".equalsIgnoreCase(getToken(2).image) }) - stm = InsertBulk() - | - LOOKAHEAD(3) ( - [ LOOKAHEAD(2) with=WithList() ] - ( - stm = SelectWithWithItems( with ) - | - stm = InsertWithWithItems( with ) - | - stm = UpdateWithWithItems( with ) - | - stm = DeleteWithWithItems( with ) - | - stm = Merge( with ) - ) - ) - | - stm = Select() - | - stm = TableStatement() - | - LOOKAHEAD(3) stm = Upsert() - | - LOOKAHEAD(2) stm = Alter() - | - // @todo: merge this into the ALTER TABLE statement - stm = RenameTableStatement() - | - stm = Create() - | - stm = Drop() - | - stm = Analyze() - | - stm = Truncate() - | - stm = Execute() - | - LOOKAHEAD({ getToken(1).kind == K_DO && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) - stm = DoStatement() - | - LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind == K_SET && getToken(2).kind == S_IDENTIFIER - && "IDENTITY_INSERT".equalsIgnoreCase(getToken(2).image) - && !"=".equals(getToken(3).image) && !".".equals(getToken(3).image) }) - stm = SetIdentityInsert() - | - stm = Set() - | - stm = Reset() - | - stm = Show() - | - stm = RefreshMaterializedView() - | - stm = Use() - | - stm = SavepointStatement() - | - stm = RollbackStatement() - | - stm = Commit() - | - stm = Comment() - | - stm = Describe() - | - stm = Explain() - | - stm = Declare() - | - stm = Grant() - | - LOOKAHEAD({ isKeywordAhead("REVOKE") }) stm = Revoke(false) - | - LOOKAHEAD({ getToken(1).kind == K_PRAGMA }) stm = PragmaStatement() - | - LOOKAHEAD({ getToken(1).kind == K_INSTALL - || (getToken(1).kind == K_LOAD && getToken(2).kind != K_DATA) - || (getToken(1).kind == K_FORCE && getToken(2).kind == K_INSTALL) }) - stm = ExtensionStatement() - | - LOOKAHEAD({ getToken(1).kind == K_ATTACH }) stm = AttachStatement() - | - LOOKAHEAD({ getToken(1).kind == K_DETACH }) stm = DetachStatement() - | - LOOKAHEAD({ getToken(1).kind == K_CONNECT && getToken(2).kind != K_BY }) - stm = ConnectStatement() - | - LOOKAHEAD({ getToken(1).kind == K_DISCONNECT && getToken(2).kind != K_SESSION }) - stm = DisconnectStatement() - | - LOOKAHEAD({ getToken(1).kind == K_PREPARE }) stm = PrepareStatement() - | - LOOKAHEAD({ getToken(1).kind == K_DEALLOCATE }) stm = DeallocateStatement() - | - LOOKAHEAD({ getToken(1).kind == K_COPY }) stm = CopyStatement() - | - LOOKAHEAD({ getToken(1).kind == K_ASSERT }) stm = AssertStatement() - | - LOOKAHEAD({ getToken(1).kind == K_EXPORT && getToken(2).kind == K_DATA }) stm = ExportDataStatement() - | - LOOKAHEAD({ getToken(1).kind == K_LOAD && getToken(2).kind == K_DATA }) stm = LoadDataStatement() - | - stm = PurgeStatement() - | - stm = SessionStatement() - | - stm = LockStatement() - | - LOOKAHEAD({ Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) ( stm = Import() | stm = Export() ) - ) - { return stm; } + clauseTable=Table() + [ LOOKAHEAD(2) "(" clauseColumns=ColumnList() ")" ] + clauseSelect = Select() + { + if (!clauseColumns.isEmpty()) { + clause.setColumns(clauseColumns); + } + return clause.withTable(clauseTable).withSelect(clauseSelect); + } +} + +OracleMultiInsertBranch OracleMultiInsertWhenBranch(): +{ + Expression whenExpression = null; + List clauses = null; +} +{ + whenExpression = Expression() + clauses = OracleMultiInsertClauseList() + { + return new OracleMultiInsertBranch() + .withWhenExpression(whenExpression) + .withClauses(clauses); + } } -OracleBlock OracleBlock(): +OracleMultiInsertBranch OracleMultiInsertElseBranch(): { - OracleBlock block = new OracleBlock(); - OracleBlock.VariableDeclaration declaration; - OracleBlock.ExceptionHandler handler; - Statements statements; + List clauses = null; } { - [ declaration=OracleVariableDeclaration() { block.getDeclarations().add(declaration); } - ( LOOKAHEAD({ getToken(1).kind != K_BEGIN }) - declaration=OracleVariableDeclaration() { block.getDeclarations().add(declaration); } )* ] - statements=OracleBlockStatements() { block.setStatements(statements); } - [ LOOKAHEAD({ isKeywordAhead("EXCEPTION") }) AccessKeyword("EXCEPTION") - handler=OracleExceptionHandler() { block.getExceptionHandlers().add(handler); } - ( handler=OracleExceptionHandler() { block.getExceptionHandlers().add(handler); } )* ] - - { block.setSemicolonAfterEnd(true); return block; } + + clauses = OracleMultiInsertClauseList() + { + return new OracleMultiInsertBranch() + .withElseClause(true) + .withClauses(clauses); + } } -OracleBlock.VariableDeclaration OracleVariableDeclaration(): +List OracleMultiInsertClauseList(): { - OracleBlock.VariableDeclaration declaration = new OracleBlock.VariableDeclaration(); - String name; ColDataType dataType; Expression initializer; + List clauses = new ArrayList(); + OracleMultiInsertClause clause = null; } { - name=RelObjectName() { declaration.setName(name); } - [ LOOKAHEAD({ isKeywordAhead("CONSTANT") }) AccessKeyword("CONSTANT") { declaration.setConstant(true); } ] - dataType=ColDataType() { declaration.setDataType(dataType); } - [ { declaration.setNotNull(true); } ] - [ ( ":=" | { declaration.setInitializerOperator("DEFAULT"); } ) - initializer=Expression() { declaration.setInitializer(initializer); } ] - - { requireDdlSyntax((!declaration.isConstant() && !declaration.isNotNull()) || declaration.getInitializer() != null, - "A CONSTANT or NOT NULL variable requires an initializer"); return declaration; } + clause = OracleMultiInsertClause() { + clauses.add(clause); + } + ( + clause = OracleMultiInsertClause() { + clauses.add(clause); + } + )* + { + return clauses; + } } -Statements OracleBlockStatements(): -{ Statements statements = new Statements(); Statement statement; } +InsertConflictTarget InsertConflictTarget(): { - statement=OracleBlockStatement() { statements.add(statement); } - ( LOOKAHEAD({ getToken(1).kind != K_END && getToken(1).kind != K_WHEN && !isKeywordAhead("EXCEPTION") }) - statement=OracleBlockStatement() { statements.add(statement); } )* - { return statements; } + InsertConflictTarget target = new InsertConflictTarget(); + List elements = new ArrayList(); + KeyElement element; + Expression whereExpression; + String constraintName; +} +{ + ( + "(" element=InsertConflictIndexElement() { elements.add(element); } + ( "," element=InsertConflictIndexElement() { elements.add(element); } )* ")" + { target.setIndexElements(elements); } + [ whereExpression=WhereClause() { target.setWhereExpression(whereExpression); } ] + | + constraintName=RelObjectNameExt() + { target.setConstraintName(constraintName); } + ) + { return target; } } -Statement OracleBlockStatement(): -{ Statement statement; Expression target; Expression value; } +KeyElement InsertConflictIndexElement(): +{ + KeyElement element; + String name; + Expression expression; + ObjectNames collation; + ObjectNames operatorClass; +} { ( - LOOKAHEAD({ getToken(1).kind == K_DECLARE || getToken(1).kind == K_BEGIN }) statement=OracleBlock() - | LOOKAHEAD(Column() ":=") target=Column() ":=" value=Expression() - { statement = new OracleAssignment(target, value); } - | LOOKAHEAD(JdbcNamedParameter() ":=") target=JdbcNamedParameter() ":=" value=Expression() - { statement = new OracleAssignment(target, value); } - | { statement = new OracleNullStatement(); } - | LOOKAHEAD(ColumnIdentifier() ("(" | )) - statement=OracleImplicitCall() - | statement=SingleStatement() + LOOKAHEAD({ isFunctionAhead() }) expression=Function() + { element = new KeyElement(expression).withExpressionParenthesized(false); } + | name=RelObjectNameExt() { element = new KeyElement(name); } + | "(" expression=Expression() ")" { element = new KeyElement(expression); } ) - { return statement; } + [ LOOKAHEAD(2) collation=RelObjectNames() + { element.setCollation(createTable(collation.getNames()).getFullyQualifiedName()); } ] + [ LOOKAHEAD(2) operatorClass=RelObjectNames() { element.setOperatorClass(createTable(operatorClass.getNames()).getFullyQualifiedName()); } ] + { return element; } } -Execute OracleImplicitCall(): -{ Execute call = new Execute(); ObjectNames name; ExpressionList arguments; } +InsertConflictAction InsertConflictAction(): { - name=ColumnIdentifier() { call.setName(name.getNames()); call.setExecType(Execute.ExecType.IMPLICIT); - requireDdlSyntax(!Arrays.asList("RAISE", "RETURN", "GOTO", "EXIT", "CONTINUE", "LOOP", "WHILE", "FOR") - .contains(call.getName().toUpperCase(java.util.Locale.ROOT)), "Unsupported PL/SQL control statement"); } - [ LOOKAHEAD("(") arguments=ExpressionList() { call.setExprList(arguments); } ] - { return call; } + InsertConflictAction conflictAction; + Expression whereExpression = null; + List updateSets; +} +{ + ( + LOOKAHEAD(2) ( + { conflictAction = new InsertConflictAction( ConflictActionType.DO_NOTHING ); } + ) + | + ( + { conflictAction = new InsertConflictAction( ConflictActionType.DO_UPDATE ); } + updateSets = UpdateSets() { conflictAction.setUpdateSets(updateSets); } + [ whereExpression = WhereClause() ] + ) + ) + + { return conflictAction + .withWhereExpression(whereExpression); } } -OracleBlock.ExceptionHandler OracleExceptionHandler(): -{ OracleBlock.ExceptionHandler handler = new OracleBlock.ExceptionHandler(); String name; Statements body; } +InsertDuplicateAction InsertDuplicateAction(): { - name=TypeDdlName() { handler.getExceptions().add(name); } - ( name=TypeDdlName() { handler.getExceptions().add(name); } )* - body=OracleBlockStatements() { handler.setStatements(body); return handler; } + InsertDuplicateAction duplicateAction; + Expression whereExpression = null; + List updateSets; +} +{ + ( + LOOKAHEAD(2) ( + { duplicateAction = new InsertDuplicateAction( ConflictActionType.NOTHING ); } + ) + | + ( + { duplicateAction = new InsertDuplicateAction( ConflictActionType.DO_UPDATE ); } + updateSets = UpdateSets() { duplicateAction.setUpdateSets(updateSets); } + [ whereExpression = WhereClause() ] + ) + ) + + { return duplicateAction + .withWhereExpression(whereExpression); } } -DoStatement DoStatement(): + +OutputClause OutputClause(): { - DoStatement statement = new DoStatement(); - String language; - Token code; + List> selectItemList = null; + UserVariable tableVariable = null; + Table outputTable = null; + List columnList = null; } { - + + selectItemList = SelectItemsList() + [ + ( + tableVariable = UserVariable() + | + outputTable = Table() + ) + [ + LOOKAHEAD(2) columnList = ColumnsNamesList() + ] + ] + + { + return new OutputClause(selectItemList, tableVariable, outputTable, columnList); + } +} + +Upsert Upsert(): +{ + Upsert upsert = new Upsert(); + String algorithm; + Table table = null; + ExpressionList columns; + List updateSets; + + Select select = null; + List duplicateUpdateSets; + InsertDuplicateAction duplicateAction = null; + Token tk = null; +} +{ + ( + { upsert.setUpsertType(UpsertType.UPSERT); } + | + { upsert.setUpsertType(UpsertType.REPLACE); } + | + ( + + // ABORT and FAIL are not keywords of the parser + algorithm=RelObjectName() + { upsert.setUpsertType(insertOrType(algorithm)); } + ) + ) + [ LOOKAHEAD(2) { upsert.setUsingInto(true); } ] + + table=Table() { upsert.setTable(table); } + + [ LOOKAHEAD(2) columns = ParenthesedInsertColumnList() { upsert.setColumns(columns); } ] ( - LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) - AccessKeyword("LANGUAGE") language=RelObjectName() code= - { statement.setLanguage(language); statement.setLanguageBeforeCode(true); } + ( + + updateSets = UpdateSets() { upsert.setUpdateSets(updateSets); } + ) | - code= - [ LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) AccessKeyword("LANGUAGE") - language=RelObjectName() { statement.setLanguage(language); } ] + ( + select = Select() { upsert.setSelect(select); } + ) ) - { statement.setCode(new StringValue(code.image)); return statement; } + + [ + + duplicateAction = InsertDuplicateAction() { upsert.setDuplicateAction(duplicateAction); } + ] + + { + return upsert; + } +} + +Delete DeleteWithWithItems( List> withItems ): +{ + Delete delete; +} +{ + delete = Delete() { delete.setWithItemsList( withItems ); + return delete; +} } -Block Block() #Block : { - Statements stmts = new Statements(); - List list = new ArrayList(); - Statement stm; - Block block = new Block(); +Delete Delete(): +{ + Delete delete = new Delete(); + Table table = null; + TableReference target; + String cursorName; + ForPortionClause forPortionClause; + List
tables = new ArrayList
(); + List> with = null; + FromItem usingFromItem = null; + List usingFromItemList = new ArrayList(); + List usingJoins = null; + List joins = null; + Expression where = null; + PreferringClause preferringClause = null; + Limit limit = null; + OptionClause optionClause = null; + List orderByElements; + boolean hasFrom = false; + Token tk = null; + DeleteModifierPriority modifierPriority = null; + boolean modifierIgnore = false; + boolean modifierQuick = false; + + ReturningClause returningClause; + OutputClause outputClause; } { - - ()* - ( - stm = SingleStatement() - | stm = Block() - ) - - { list.add(stm); } - - ( - ( - ( - stm = SingleStatement() - | stm = Block() - ) - - { list.add(stm); } - ) - )* + { delete.setOracleHint(getOracleHint()); } + [ LOOKAHEAD(2) { modifierPriority = DeleteModifierPriority.LOW_PRIORITY; }] + [ LOOKAHEAD(2) { modifierQuick = true; }] + [ LOOKAHEAD(2) { modifierIgnore = true; }] + [LOOKAHEAD(4) (table=TableWithAlias() { tables.add(table); } + ("," table=TableWithAlias() { tables.add(table); } )* + [ outputClause = OutputClause() {delete.setOutputClause(outputClause); } ] + | ) { hasFrom = true; }] - { - stmts.setStatements(list); - block.setStatements(stmts); - } + [ LOOKAHEAD(3) target=DmlTarget() { delete.setTableReference(target); table = target.getTable(); } + [ forPortionClause=ForPortionClause() { delete.setForPortionClause(forPortionClause); } ] + [ LOOKAHEAD(2) joins=JoinsList() ] ] + [ usingFromItem=FromItem() { usingFromItemList.add(usingFromItem); } + ( LOOKAHEAD(2) "," usingFromItem=FromItem() { usingFromItemList.add(usingFromItem); } )* + // MySQL's table references and PostgreSQL's from items may join further tables + [ LOOKAHEAD(2) usingJoins=JoinsList() { delete.setUsingJoins(usingJoins); } ] + ] + [ + LOOKAHEAD({ isWhereCurrentOfAhead() }) + cursorName=WhereCurrentOfClause() { delete.setCursorName(cursorName); } + | + where=WhereClause() { delete.setWhere(where); } + ] + [preferringClause=PreferringClause() { delete.setPreferringClause(preferringClause);} ] + [orderByElements = OrderByElements() { delete.setOrderByElements(orderByElements); } ] + [limit=PlainLimit() {delete.setLimit(limit); } ] + [ LOOKAHEAD(2) optionClause = OptionClause() { delete.setOption(optionClause); } ] - [LOOKAHEAD(2) { block.setSemicolonAfterEnd(true); } ] + [ returningClause = ReturningClause() { delete.setReturningClause(returningClause); } ] { - return block; + if (joins != null && joins.size() > 0) { + delete.setJoins(joins); + } + requireDeleteSyntax(table != null || !tables.isEmpty(), + "DELETE requires a target table"); + return delete.withWithItemsList(with) + .withTables(tables) + .withTable(table) + .withHasFrom(hasFrom) + .withUsingFromItemList(usingFromItemList) + .withModifierPriority(modifierPriority) + .withModifierIgnore(modifierIgnore) + .withModifierQuick(modifierQuick); } } -Statements Statements() #Statements: { - Statements stmts = new Statements(); - IfElseStatement ifElseStatement = null; - Statement stm = null; - Statement stm2 = null; +Statement Merge( List> with ) : { + Merge merge = new Merge(); + TableReference target; + FromItem fromItem; Expression condition; + List operations; + OutputClause outputClause; + ReturningClause returningClause; + OptionClause optionClause = null; } { - ( - ( - ( )* - - // todo: allow also first statement to be an `UnsupportedStatement` - try { - ( - condition=Condition() - ( stm = SingleStatement() | stm = Block() ) { ifElseStatement = new IfElseStatement(condition, stm); } - [ LOOKAHEAD(2) - [ { ifElseStatement.setUsingSemicolonForIfStatement(true); } ] - ( stm2 = SingleStatement() | stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); } - ] - - { stmts.add( ifElseStatement ); } - - [ - LOOKAHEAD(2) - { if (stm2!=null) - ifElseStatement.setUsingSemicolonForElseStatement(true); - else if (ifElseStatement!=null) - ifElseStatement.setUsingSemicolonForIfStatement(true); - } - ] - ) - | - ( - (stm = SingleStatement() - | stm = Block()) - - ( | ) - ) - { - stmts.add(stm); stm=null; - } - - } catch (ParseException ex) { - if ( getAsBoolean(Feature.allowUnsupportedStatements) ) { - UnsupportedStatement unsupportedStatement = new UnsupportedStatement( stm!=null ? stm.toString() : "", error_skipto(ST_SEMICOLON) ); - if (!unsupportedStatement.isEmpty()) { - stmts.add( unsupportedStatement ); - } - } else if ( errorRecovery ) { - parseErrors.add(ex); - error_skipto(ST_SEMICOLON); - stmts.add( null ); - } else { - throw ex; - } - } - - ) + { merge.setOracleHint(getOracleHint()); } target=DmlTarget() { merge.setTableReference(target); } + fromItem = FromItem() { merge.setFromItem(fromItem); } + condition = Expression() { merge.setOnCondition(condition); } - ( LOOKAHEAD(2) - ( )* - try { - ( - condition=Condition() - ( stm = SingleStatement() | stm = Block() ) { ifElseStatement = new IfElseStatement(condition, stm); } - [ LOOKAHEAD(2) - [ { ifElseStatement.setUsingSemicolonForIfStatement(true); } ] - ( stm2 = SingleStatement() | stm2 = Block() ) { ifElseStatement.setElseStatement(stm2); } - ] + operations = MergeOperations() { merge.setOperations(operations); } - { stmts.add( ifElseStatement ); } - ) - | - ( - stm = SingleStatement() - | stm = Block() - ) { stmts.add(stm); stm=null; } - } catch (ParseException ex) { - if ( getAsBoolean(Feature.allowUnsupportedStatements) ) { - UnsupportedStatement unsupportedStatement = new UnsupportedStatement( stm!=null ? stm.toString() : "" , error_skipto(ST_SEMICOLON) ); - if (!unsupportedStatement.isEmpty()) { - stmts.add( unsupportedStatement ); - } - } else if ( errorRecovery ) { - parseErrors.add(ex); - error_skipto(ST_SEMICOLON); - stmts.add( null ); - } else { - throw ex; - } - } + [ returningClause = ReturningClause() { merge.setReturningClause(returningClause); } ] - ( LOOKAHEAD(2) { if (stm2!=null) - ifElseStatement.setUsingSemicolonForElseStatement(true); - else if (ifElseStatement!=null) - ifElseStatement.setUsingSemicolonForIfStatement(true); - } )* + [ outputClause = OutputClause() { merge.setOutputClause(outputClause); } ] - )* + [ LOOKAHEAD(2) optionClause = OptionClause() { merge.setOption(optionClause); } ] - [ - LOOKAHEAD( { getAsBoolean(Feature.allowUnsupportedStatements) } ) - stm = UnsupportedStatement() - { - if (!( (UnsupportedStatement) stm).isEmpty()) { - stmts.add( stm ); - } - } - ] + { return merge.withWithItemsList(with); } +} +List MergeOperations() : { + List operationsList = new ArrayList(); + MergeOperation operation; +} +{ + ( + LOOKAHEAD(2) operation = MergeWhenMatched() { operationsList.add(operation); } + | + operation = MergeWhenNotMatched() { operationsList.add(operation); } )* - - - { - return stmts; - } + { return operationsList; } } -JAVACODE -List error_skipto(int kind) { - ArrayList tokenImages = new ArrayList(); - ParseException e = generateParseException("test"); - Token t; - do { - t = getNextToken(); - if (t.kind != kind && t.kind != EOF) { - tokenImages.add(t.image); - } - } while (t.kind != kind && t.kind != EOF); - return tokenImages; +MergeOperation MergeWhenMatched() : { + Expression predicate = null; + MergeOperation operation; } - -LockStatement LockStatement(): { - LockStatement statement = new LockStatement(); - LockStatement.Target target; - LockMode mode; - Token waitSeconds; -} { - - { statement.setUseTableKeyword(false); } - [ LOOKAHEAD() { statement.setUseTableKeyword(true); } ] - target=LockTarget() { statement.getTargets().add(target); } - ( "," target=LockTarget() { statement.getTargets().add(target); } )* - [ mode=TableLockMode() { statement.setLockMode(mode); } ] - [ { statement.setNoWait(true); } - | waitSeconds= { statement.setWaitSeconds(Long.valueOf(waitSeconds.image)); } ] - { return statement; } +{ + + [ predicate = Expression() ] + + ( + operation = MergeDeleteClause(predicate) | operation = MergeUpdateClause(predicate) + | + // PostgreSQL + { operation = new MergeDoNothing().withAndPredicate(predicate); } + ) + { return operation; } } -LockStatement.Target LockTarget(): { - Table table; - boolean only = false; - boolean descendants = false; - LockStatement.Target target; -} { - [ { only = true; } ] table=Table() [ "*" { descendants = true; } ] - { - requireDdlSyntax(!only || !descendants, "ONLY and * cannot describe the same lock target"); - target = new LockStatement.Target(table); - target.setScope(only ? LockStatement.Scope.ONLY - : descendants ? LockStatement.Scope.INCLUDING_DESCENDANTS : LockStatement.Scope.DEFAULT); - return target; - } +MergeOperation MergeDeleteClause(Expression predicate) : { + MergeDelete md = new MergeDelete().withAndPredicate(predicate); +} +{ + { return md; } } -LockMode TableLockMode(): { - LockMode mode; -} { - ( - ( { mode = LockMode.RowShare; } - | { mode = LockMode.RowExclusive; } ) - | { mode = LockMode.Share; } - [ { mode = LockMode.ShareRowExclusive; } - | { mode = LockMode.ShareUpdate; } - [ { mode = LockMode.ShareUpdateExclusive; } ] ] - | { mode = LockMode.Exclusive; } - | AccessKeyword("ACCESS") ( { mode = LockMode.AccessShare; } - | { mode = LockMode.AccessExclusive; } ) - ) - { return mode; } +MergeOperation MergeUpdateClause(Expression predicate) : { + MergeUpdate mu = new MergeUpdate().withAndPredicate(predicate); + List updateSets; + Expression condition; +} +{ + updateSets = UpdateSets() { mu.setUpdateSets(updateSets); } + [ condition = Expression() { mu.setWhereCondition(condition); }] + [ LOOKAHEAD(2) condition = Expression() { mu.setDeleteWhereCondition(condition); } ] + { return mu; } } -LikeClause LikeClause(): { - LikeClause likeClause = new LikeClause(); - Table table; - List> columnsList; - boolean including; - String option; -} { - - table = Table() { likeClause.setTable(table); } - [ LOOKAHEAD(2) "(" columnsList = ColumnSelectItemsList() ")" { likeClause.setColumnsList(columnsList); }] +MergeInsert MergeInsertClause(Expression predicate) : { + MergeInsert mi = new MergeInsert(); + ExpressionList columns; + ExpressionList expList; + Expression condition; + Token open; +} +{ + ( - ( - { including = true; } - | { including = false; } - ) - option=RelObjectName() + // PostgreSQL's merge_insert: without a column list or OVERRIDING + + | + [ open="(" columns = ColumnList() ")" + { + ParenthesedExpressionList insertColumns = new ParenthesedExpressionList(columns); + linkAST(insertColumns, open); + mi.setColumns(insertColumns); + } + ] + [ + ( { mi.setOverridingMode(Insert.OverridingMode.SYSTEM); } + | { mi.setOverridingMode(Insert.OverridingMode.USER); } ) ] + open="(" expList = SimpleExpressionList() ")" { - likeClause.addOption(likeOptionKind(option), including); + ParenthesedExpressionList insertValues = new ParenthesedExpressionList(expList); + linkAST(insertValues, open); + mi.setValues(insertValues); } - )* + + [ condition = Expression() { mi.setWhereCondition(condition); } ] + ) { - return likeClause; + mi.setAndPredicate(predicate); + return mi; } } -Export Export() #Export: { - Export export = new Export(); - Table table; - ParenthesedExpressionList columns; - ParenthesedSelect select; - ExportIntoItem exportIntoItem; -} { - +MergeOperation MergeWhenNotMatched() : { + MergeOperation operation; + Expression predicate = null; + MergeSide side = null; + Token sideToken; +} +{ + + [ sideToken = { + side = MergeSide.fromImage(sideToken.image); + } ] + [ predicate = Expression() ] + ( - table = Table() { export.setTable(table); } - [ columns = ParenthesedColumnList() { export.setColumns(columns); } ] - | select = ParenthesedSelect() { export.setSelect(select); } + operation = MergeInsertClause(predicate) { ((MergeInsert) operation).setSide(side); } + | + operation = MergeUpdateClause(predicate) { ((MergeUpdate) operation).setSide(side); } + | + operation = MergeDeleteClause(predicate) { ((MergeDelete) operation).setSide(side); } + | + // PostgreSQL: allowed for the source and the target side alike + + { operation = new MergeDoNothing(MergeWhen.ofNotMatched(side)).withAndPredicate(predicate); } ) - - - exportIntoItem = ExportIntoItem() { export.setExportIntoItem(exportIntoItem); } - - { - return export; - } + { return MergeSide.validatePairing(side, operation); } } -Import Import() #Import: { - Import impt = new Import(); - Table table; - ParenthesedExpressionList columns; - List importColumns; - ImportFromItem fromItem; +// table names seem to allow ":" delimiters, e.g. for Informix see #1134 +ObjectNames RelObjectNames() : { + String token = null; + Token delimiter = null; + List data = new ArrayList(); + List delimiters = new ArrayList(); } { - - [ - - ( - table = Table() { impt.setTable(table); } - [ columns = ParenthesedColumnList() { impt.setColumns(columns); } ] - | importColumns = ImportColumns() { impt.setImportColumns(importColumns); } + token = RelObjectName() { data.add(token); } + ( + LOOKAHEAD (2) ( + ( delimiter = "..." { delimiters.add("."); data.add(null); delimiters.add("."); data.add(null); delimiters.add("."); } ) + | + ( delimiter = ".." { delimiters.add("."); data.add(null); delimiters.add("."); } ) + | + ( ( delimiter = "." | delimiter = ":" ) { delimiters.add(delimiter.image); } ) ) - ] - - fromItem = ImportFromItem() { impt.setFromItem(fromItem); } + token = RelObjectNameExt() { data.add(token); } + ) * - { - return impt; - } + { return new ObjectNames(data, delimiters); } } -Import SubImport() #SubImport: { - Import impt = new Import(); - List importColumns; - ImportFromItem fromItem; +// column names do not allow ":" delimeters as those represent JSON `GET` operators +ObjectNames ColumnIdentifier() : { + String token = null; + Token delimiter = null; + List data = new ArrayList(); + List delimiters = new ArrayList(); } { - "(" - - [ importColumns = ImportColumns() { impt.setImportColumns(importColumns); } ] + token = RelObjectName() { data.add(token); } + ( + LOOKAHEAD (2) ( + ( delimiter = "..." { delimiters.add("."); data.add(null); delimiters.add("."); data.add(null); delimiters.add("."); } ) + | + ( delimiter = ".." { delimiters.add("."); data.add(null); delimiters.add("."); } ) + | + ( delimiter = "." { delimiters.add(delimiter.image); } ) + ) - - fromItem = ImportFromItem() { impt.setFromItem(fromItem); } - ")" + token = RelObjectNameExt() { data.add(token); } + ) * - { - return impt; - } + { return new ObjectNames(data, delimiters); } } -List ImportColumns(): { - ImportColumn importColumn; - List importColumns = new ArrayList(); -} { - "(" - ( - importColumn = ColumnDefinition() - | importColumn = LikeClause() - ) - { importColumns.add(importColumn); } - - ( - "," - ( - importColumn = ColumnDefinition() - | importColumn = LikeClause() - ) - { importColumns.add(importColumn); } - )* - ")" +// See: http://technet.microsoft.com/en-us/library/ms187879%28v=sql.105%29.aspx +Column Column() #Column : +{ + ObjectNames data = null; + ArrayConstructor arrayConstructor = null; + Token tk = null; + Token first = getToken(1); + Token name; +} +{ + data = ColumnIdentifier() { name = getToken(0); } + [ LOOKAHEAD(2) tk= ] + // @todo: we better should return a SEQUENCE instead of a COLUMN + [ LOOKAHEAD(2) "." { data.getNames().add("nextval"); name = getToken(0); } ] + [ LOOKAHEAD(2) arrayConstructor = Subscript() ] { - return importColumns; + Column col = createColumn(data.getNames(), data.getDelimiters()); + if (tk != null) { col.withCommentText(tk.image); } + if (arrayConstructor!=null) { + col.setArrayConstructor(arrayConstructor); + } + Token qualifierLast = qualifierLast(first, name); + if (col.getTable() != null && qualifierLast != null) { + linkAST(col.getTable(), first, qualifierLast); + } + linkAST(col,jjtThis); + return col; } } -ExportIntoItem ExportIntoItem(): { - ExportIntoItem exportIntoItem; - ErrorClause errorClause; -} { +/* + * Unified identifier production for SQL object names. + * + * Accepts base identifier tokens (S_IDENTIFIER, S_QUOTED_IDENTIFIER, DATA_TYPE, + * date literals), any non-reserved keyword, and — guarded by the semantic + * check isReservedKeywordAsIdentifier() — reserved keywords that can serve as + * unquoted identifiers in the current parser position. + * + * NOTE: K_FROM and K_SELECT are deliberately NOT included here + * to avoid FIRST-set pollution in JavaCC's choice resolution. They are only + * valid as identifiers in dotted-name continuations (after '.'), named + * parameters (after ':'), index columns, constraint names, and similar + * restricted contexts. Those call sites add the two tokens inline. + */ +String RelObjectName() : +{ Token tk = null; String result = null; } +{ ( - exportIntoItem = DBMSDestination() - | exportIntoItem = FileDestination() - | exportIntoItem = ScriptSourceDestination() + /* ── Base identifier tokens ─────────────────────────────────────── */ + tk= + | tk= + | tk= + | tk= + | tk= + + /* ── Non-reserved keywords (range-guarded) ──────────────────────── */ + | LOOKAHEAD({ getToken(1).kind >= MIN_NON_RESERVED_WORD + && getToken(1).kind <= MAX_NON_RESERVED_WORD }) + result = NonReservedWord() + + /* ── Reserved keywords usable as identifiers (context-guarded) ─── */ + | LOOKAHEAD({ isReservedKeywordAsIdentifier() }) + ( tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= ) ) - [ LOOKAHEAD(2) errorClause = ErrorClause() { exportIntoItem.setErrorClause(errorClause); } ] + { return result != null ? result : tk.image; } +} - { - return exportIntoItem; - } +/* + * Extended version of RelObjectName that additionally accepts FROM and SELECT + * as unquoted identifiers. + * + * These two tokens are kept OUT of RelObjectName() to avoid polluting + * JavaCC's FIRST-set computation (which would cause choice conflicts in + * expression parsing, subselect detection, etc.). + * + * Used only in specific contexts where the old grammar's RelObjectNameExt2 + * was called: dotted-name continuations, index/constraint names, type names, + * named-parameter identifier chains, and join table references. + */ +String RelObjectNameExt() : +{ Token tk = null; String result = null; } +{ + ( result = RelObjectName() | tk= | tk= ) + { return tk != null ? tk.image : result; } } -ImportFromItem ImportFromItem(): { - ImportFromItem importFromItem; - ErrorClause errorClause; -} { +Table Table() #TableName : +{ + //String serverName = null, databaseName = null, schemaName = null, tableName = null; + ObjectNames data = null; + Token fileNameToken = null; + Table table; + String timeTravelStr = null; +} +{ ( - importFromItem = DBMSSource() - | importFromItem = FileSource() - | importFromItem = ScriptSourceDestination() + data = RelObjectNames() [ LOOKAHEAD(2) timeTravelStr = TimeTravelBeforeAlias() ] + { + table = createTable(data.getNames()); + table.setTimeTravel(timeTravelStr); + } + | + fileNameToken = + { + // don't split name parts + table = new Table(fileNameToken.image, false); + } ) - [ LOOKAHEAD(2) errorClause = ErrorClause() { importFromItem.setErrorClause(errorClause); } ] { - return importFromItem; + linkAST(table,jjtThis); + return table; } } -DBMSDestination DBMSDestination() #DBMSDestination: { - DBMSDestination dbmsDestination = new DBMSDestination(); - DBMSType dbmsType; - ConnectionDefinition connectionDefinition; +/** A table source or DML target; catalog-only DDL continues to use Table(). */ +Table TableReference() #void : +{ Table table; - ExpressionList columns; - StringValue statement; - List dbmsTableDestinationOptions; -} { - dbmsType = DBMSType() { dbmsDestination.setDestinationType(dbmsType); } +} +{ + ( table=TableVariable() | table=Table() ) + { return table; } +} - connectionDefinition = ConnectionDefinition() { dbmsDestination.setConnectionDefinition(connectionDefinition); } +Table TableVariable() #TableName : +{ + Token variable; + Table table; +} +{ + variable= + { + requireAccessSyntax(!variable.image.startsWith("@@"), + "A table variable must be a local variable"); + table = new Table(variable.image, false).withTableVariable(true); + linkAST(table, jjtThis); + return table; + } +} + +Table TableWithAlias(): +{ + Table table = null; + Alias alias = null; + SQLServerHints sqlServerHints; +} +{ + table=TableReference() + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { table.setAlias(alias); }] + [ LOOKAHEAD( "(") sqlServerHints=SQLServerHints() { table.setSqlServerHints(sqlServerHints); } ] + { return table; } +} +Number Number(): +{ + Token token; + Number number; +} +{ ( - LOOKAHEAD(3) - table = Table() { dbmsDestination.setTable(table); } - [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsDestination.setColumns(columns); } ] - [ LOOKAHEAD(2) dbmsTableDestinationOptions = DBMSTableDestinationOptionList() { dbmsDestination.setDBMSTableDestinationOptions(dbmsTableDestinationOptions); } ] - | statement = ImportExportStatement() { dbmsDestination.setStatement(statement); } + token = { number = Double.valueOf(token.image); } + | + token = { number = Long.valueOf(token.image); } ) { - return dbmsDestination; + return number; } } -DBMSTableDestinationOption DBMSTableDestinationOption(): { - DBMSTableDestinationOption dbmsTableDestinationOption; - +SampleClause SampleClause(): +{ Token token; - Token token2; - Token token3; -} { + SampleClause sampleClause; + String keyword; + String method=null; + Number percentageArgument; + String percentageUnit = null; + boolean argumentInBrackets = true; + Number offsetArgument = null; + Number repeatArgument=null; + Number seedArgument=null; + boolean methodInBrackets = false; +} +{ ( ( - token = - | token = - ) { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image); } - | token = token2 = token3 = { dbmsTableDestinationOption = new DBMSTableDestinationOption(token.image + " " + token2.image, new StringValue(token3.image)); } + // Oracle + token= { keyword = token.image; } + [ token= { method = token.image; } ] + ) + | + ( + // SQL:2016 compliant; DuckDB: the method is optional and may be reservoir + token = { keyword = token.image; } + [ + LOOKAHEAD({ isSampleMethod(getToken(1)) }) + ( token = | token = | token = ) + { method = token.image; } + ] + ) + | + ( + // Duck DB: the method is optional and may follow the sample size instead + { keyword = "USING SAMPLE"; } + [ + LOOKAHEAD({ isSampleMethod(getToken(1)) }) + ( token = | token = | token = ) + { method = token.image; } + ] + ) + ) + + ( + "(" percentageArgument = Number() + [ + "%" { percentageUnit="%"; } + | + { percentageUnit="PERCENT"; } + | + { percentageUnit="ROWS"; } + ] + ")" + + [ LOOKAHEAD(2) "(" repeatArgument = Number() ")" ] + + [ LOOKAHEAD(2) "(" seedArgument = Number() ")" ] + | + percentageArgument = Number() { argumentInBrackets = false; } + // greedy: a unit directly after the sample size always belongs to the clause + [ + LOOKAHEAD(1) + ( + "%" { percentageUnit="%"; } + | + { percentageUnit="PERCENT"; } + | + { percentageUnit="ROWS"; } + ) + ] + // ClickHouse's SAMPLE k OFFSET m; after DuckDB's TABLESAMPLE n, OFFSET belongs to the query + [ LOOKAHEAD(2, { !"TABLESAMPLE".equalsIgnoreCase(keyword) }) offsetArgument = Number() ] ) + // DuckDB: USING SAMPLE 10 PERCENT (bernoulli[, seed]) + [ + LOOKAHEAD({ method == null && getToken(1).kind == OPENING_BRACKET + && isSampleMethod(getToken(2)) }) + "(" ( token = | token = | token = ) + { method = token.image; methodInBrackets = true; } + [ "," seedArgument = Number() ] + ")" + ] + { - return dbmsTableDestinationOption; + sampleClause = new SampleClause(keyword, method, percentageArgument, percentageUnit, repeatArgument, seedArgument); + sampleClause.setArgumentInBrackets(argumentInBrackets); + sampleClause.setMethodInBrackets(methodInBrackets); + sampleClause.setOffsetArgument(offsetArgument); + return sampleClause; } } -List DBMSTableDestinationOptionList(): { - List dbmsTableDestinationOptions = new ArrayList(); - DBMSTableDestinationOption dbmsTableDestinationOption; -} { - ( LOOKAHEAD(2) dbmsTableDestinationOption = DBMSTableDestinationOption() { dbmsTableDestinationOptions.add(dbmsTableDestinationOption); } )+ - { - return dbmsTableDestinationOptions; - } +Select SelectWithWithItems( List> withItems): +{ + Select select; +} +{ + select = Select() { select.setWithItemsList( withItems ); + return select; +} } -DBMSSource DBMSSource() #DBMSSource: { - DBMSSource dbmsSource = new DBMSSource(); - DBMSType dbmsType; - ConnectionDefinition connectionDefinition; - Table table; - ExpressionList columns; - List statements; -} { - dbmsType = DBMSType() { dbmsSource.setSourceType(dbmsType); } +Select Select() #Select: +{ + Select select = null; + List> with = null; + List orderByElements = null; + List interpolateElements = null; + OptionClause optionClause = null; + Limit limit = null; + Offset offset = null; + Fetch fetch = null; + WithIsolation withIsolation = null; + Alias alias = null; +} +{ + [ with=WithList() ] + ( + LOOKAHEAD(3, { !isFromFirstSelectAhead() }) select = FromQuery() + | + ( + ( + LOOKAHEAD({ isFromFirstSelectAhead() }) select = FromFirstSelect() + | + // DuckDB's TABLE t, also as a set operation operand + LOOKAHEAD({ getToken(1).kind == K_TABLE }) select = TableStatement() + | + LOOKAHEAD(2) select = PivotQuery() + | + LOOKAHEAD(2) select = UnPivotQuery() + | + LOOKAHEAD(3) select = PlainSelect() + | + LOOKAHEAD(3) select = Values() + | + LOOKAHEAD(3) select = ParenthesedSelect() [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() {select.setAlias(alias);} ] + ) + [ LOOKAHEAD(2) select = FromQueryFromSelect(select) ] + [ LOOKAHEAD(2) select = SetOperationList(select) ] - connectionDefinition = ConnectionDefinition() { dbmsSource.setConnectionDefinition(connectionDefinition); } + [ LOOKAHEAD( ) orderByElements = OrderByElements() { select.setOrderByElements(orderByElements); } ] + [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { select.setInterpolate(interpolateElements); } ] + [ LOOKAHEAD(2, { !(select instanceof Values) }) optionClause = OptionClause() { select.setOption(optionClause); } ] - ( - table = Table() { dbmsSource.setTable(table); } - [ LOOKAHEAD(2) columns = ParenthesedColumnList() { dbmsSource.setColumns(columns); } ] - | statements = ImportExportStatementsList() { dbmsSource.setStatements(statements); } + [ LOOKAHEAD(1, ) limit=LimitWithOffset() {select.setLimit(limit);} ] + [ LOOKAHEAD(1, ) offset = Offset() { select.setOffset(offset);} ] + [ LOOKAHEAD(1, ) fetch = Fetch() { select.setFetch(fetch);} ] + [ LOOKAHEAD( ) withIsolation = WithIsolation() { select.setIsolation(withIsolation);} ] + ) ) { - return dbmsSource; + linkAST(select, jjtThis); + return select.withWithItemsList(with); } } -DBMSType DBMSType(): { - DBMSType dbmsType; - Token tk1; - Token tk2 = null; -} { - ( - tk1= - | tk1= - | tk1= - [ "=" tk2=] - ) { dbmsType = new DBMSType(tk1.image, tk2 == null ? null : tk2.image); } - { - return dbmsType; - } +/** + * DuckDB's FROM-first query: FROM tbl [SELECT ...] [WHERE ...] [GROUP BY ...] [HAVING ...] + * [QUALIFY ...] [ORDER BY ...] [LIMIT ...] [OFFSET ...]. Without a SELECT clause all columns + * are returned. + */ +PlainSelect FromFirstSelect() #FromFirstSelect: +{ + PlainSelect plainSelect = new PlainSelect(); + List> selectItems = null; + FromItem fromItem; + List joins = null; + Expression where = null; + GroupByElement groupBy = null; + Expression having = null; + Expression qualify = null; + List orderByElements = null; + Limit limit = null; + Offset offset = null; } - -FileType FileType(): { - FileType fileType; - Token tk; -} { - ( - tk= - | tk= - ) { fileType = new FileType(tk.image); } +{ + fromItem=FromItem() { - return fileType; + plainSelect.setFromItem(fromItem); + plainSelect.setFromFirst(true); } -} - -StringValue ImportExportStatement() #ImportExportStatement: { - StringValue statement; -} { - token = + [ LOOKAHEAD(2) joins=JoinsList() { plainSelect.setJoins(joins); } ] + // greedy: a SELECT right after the FROM clause belongs to this query + [ + LOOKAHEAD(2) + + [ LOOKAHEAD(2) ( | { plainSelect.setDistinct(new Distinct()); } ) ] + selectItems=SelectItemsList() { plainSelect.setSelectItems(selectItems); } + ] + [ LOOKAHEAD(2) where=WhereClause() { plainSelect.setWhere(where); } ] + [ LOOKAHEAD(2) groupBy=GroupByColumnReferences() { plainSelect.setGroupByElement(groupBy); } ] + [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); } ] + [ LOOKAHEAD(2) qualify=Qualify() { plainSelect.setQualify(qualify); } ] + [ LOOKAHEAD( ) orderByElements=OrderByElements() + { plainSelect.setOrderByElements(orderByElements); } ] + [ LOOKAHEAD(1, ) limit=LimitWithOffset() { plainSelect.setLimit(limit); } ] + [ LOOKAHEAD(1, ) offset=Offset() { plainSelect.setOffset(offset); } ] { - statement = new StringValue(token.image); - linkAST(statement, jjtThis); - return statement; + linkAST(plainSelect, jjtThis); + return plainSelect; } } -List ImportExportStatementsList(): { - List statements = new ArrayList(); - StringValue statement; -} { - ( statement = ImportExportStatement() { statements.add(statement); } )+ - - { - return statements; - } +FromQuery FromQuery() #FromQuery: +{ + FromQuery fromQuery; + FromItem fromItem; + List lateralViews = null; + List joins = null; + PipeOperator pipeOperator; } +{ + fromItem = FromItem() { fromQuery = new FromQuery(fromItem); } + [ LOOKAHEAD(2) lateralViews=LateralViews() { fromQuery.setLateralViews(lateralViews); } ] + [ LOOKAHEAD(2) joins=JoinsList() { fromQuery.setJoins(joins); } ] + ( + LOOKAHEAD(2) "|>" pipeOperator = PipeOperator() { fromQuery.add(pipeOperator); } + )* -StringValue File() #File: { - Token token; -} { - token = { - StringValue file = new StringValue(token.image); - linkAST(file, jjtThis); - return file; + return fromQuery; } } -List FileList(): { - List files = new ArrayList(); - StringValue file; -} { - ( file = File() { files.add(file); } )+ - { - return files; - } +FromQuery FromQueryFromSelect(Select select): +{ + FromQuery fromQuery; + FromItem fromItem; + PipeOperator pipeOperator; } - -ConnectionFileDefinition ConnectionFileDefinition(): { - ConnectionDefinition connectionDefinition = null; - List files; -} { - connectionDefinition = ConnectionOrCloudConnectionDefinition() - files = FileList() +{ + "|>" pipeOperator = PipeOperator() { - return new ConnectionFileDefinition(connectionDefinition, files); + fromQuery = new FromQuery(select, false); + fromQuery.add(pipeOperator); } -} + ( + LOOKAHEAD(2) "|>" pipeOperator = PipeOperator() + { fromQuery.add(pipeOperator); } + )* -List ConnectionFileDefinitionList(): { - List connectionFileDefinitions = new ArrayList(); - ConnectionFileDefinition connectionFileDefinition; -} { - ( LOOKAHEAD(2) connectionFileDefinition = ConnectionFileDefinition() { connectionFileDefinitions.add(connectionFileDefinition); } )+ { - return connectionFileDefinitions; + return fromQuery; } } -CSVColumn CSVDestinationColumn(): { - CSVColumn csvColumn; - - Token token; - Token token2; -} { +PipeOperator PipeOperator() #PipeOperator: +{ + PipeOperator operator; +} +{ ( - LOOKAHEAD(2) - token= ".." token2= { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); } - | token= { csvColumn = new CSVColumn(Long.valueOf(token.image)); } - [ "=" token = { csvColumn.setFormat(new StringValue(token.image)); }] - [ - - "=" - ( - token= - | token= - | token= - ) - { csvColumn.setDelimit(token.image); } - ] + // SELECT covers also EXTEND, WINDOW and RENAME + operator = SelectPipeOperator() + | + operator = SetPipeOperator() + | + operator = DropPipeOperator() + | + LOOKAHEAD(2) operator = AsPipeOperator() + | + operator = WherePipeOperator() + | + operator = LimitPipeOperator() + | + LOOKAHEAD(2) operator = AggregatePipeOperator() + | + operator = OrderByPipeOperator() + | + // covers UNION, INTERSET, EXCEPT + operator = SetOperationPipeOperator() + | + operator = JoinPipeOperator() + | + operator = CallPipeOperator() + | + operator = TableSamplePipeOperator() + | + operator = PivotPipeOperator() + | + operator = UnPivotPipeOperator() ) { - return csvColumn; + return operator; } } -List CSVDestinationColumnList(): { - List csvColumns = new ArrayList(); - CSVColumn csvColumn; -} { - csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } - ( "," csvColumn = CSVDestinationColumn() { csvColumns.add(csvColumn); } )* - { - return csvColumns; - } +SelectPipeOperator SelectPipeOperator(): +{ + Token operatorKeyToken; + Token modifierToken = null; + SelectPipeOperator selectPipeOperator; + SelectItem selectItem; } - -CSVColumn CSVSourceColumn(): { - CSVColumn csvColumn; - - Token token; - Token token2; -} { +{ ( - LOOKAHEAD(2) - token= ".." token2= { csvColumn = new CSVColumn(Long.valueOf(token.image), Long.valueOf(token2.image)); } - | token= { csvColumn = new CSVColumn(Long.valueOf(token.image)); } - [ "=" token = { csvColumn.setFormat(new StringValue(token.image)); }] + ( operatorKeyToken = [ LOOKAHEAD(2) ( modifierToken= | modifierToken= ) ] ) + | + operatorKeyToken = + | + operatorKeyToken = + | + operatorKeyToken = ) + selectItem = SelectItem() + { selectPipeOperator = new SelectPipeOperator(operatorKeyToken.image, selectItem, modifierToken !=null ? modifierToken.image : null); } + + ( LOOKAHEAD(2) "," selectItem = SelectItem() { selectPipeOperator.add(selectItem); } )* + { - return csvColumn; + return selectPipeOperator; } } -List CSVSourceColumnList(): { - List csvColumns = new ArrayList(); - CSVColumn csvColumn; -} { - csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } - ( "," csvColumn = CSVSourceColumn() { csvColumns.add(csvColumn); } )* +WherePipeOperator WherePipeOperator(): +{ + WherePipeOperator wherePipeOperator; + Expression expression; +} +{ + expression = Expression() { - return csvColumns; + wherePipeOperator = new WherePipeOperator(expression); + return wherePipeOperator; } } -FBVColumn FBVDestinationColumn(): { - FBVColumn fbvColumn; +String OrderSuffix(): +{ + Token token =null; + String orderSuffix = null; +} +{ + ( token = | token = ) { orderSuffix = token.image; } + [ LOOKAHEAD(2) ( token = | token = ) { orderSuffix += " NULLS " + token.image; } ] - Token token; - Token token2; -} { - ( - token= "=" token2= { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); } - | ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new StringValue(token2.image)); } - | token= "=" ( token2= | token2= ) { fbvColumn = new FBVColumn(token.image, token2.image); } - ) { - return fbvColumn; + return orderSuffix; } } -List FBVDestinationColumnList(): { - List fbvColumns = new ArrayList(); - FBVColumn fbvColumn; - boolean precedesComma; -} { - fbvColumn = FBVDestinationColumn() { fbvColumns.add(fbvColumn); } - ( - { precedesComma = false; } - ["," { precedesComma = true; }] - fbvColumn = FBVDestinationColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); } - )* - { - return fbvColumns; - } +AggregatePipeOperator AggregatePipeOperator(): +{ + AggregatePipeOperator aggregatePipeOperator; + SelectItem selectItem; + Token token =null; + String orderSuffix = null; } +{ + + selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] + { aggregatePipeOperator = new AggregatePipeOperator(selectItem, orderSuffix); orderSuffix=null; } -FBVColumn FBVSourceColumn(): { - FBVColumn fbvColumn; + ( LOOKAHEAD(2) "," selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] + { aggregatePipeOperator.add(selectItem, orderSuffix); orderSuffix=null; } )* + + [ + LOOKAHEAD(2) [ { aggregatePipeOperator.setShorthandOrdering(true); } ] + selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] + { aggregatePipeOperator.addGroupItem(selectItem, orderSuffix); orderSuffix=null; } + + ( + LOOKAHEAD(2) "," selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] + { aggregatePipeOperator.addGroupItem(selectItem, orderSuffix); orderSuffix=null; } + )* + ] - Token token; - Token token2; -} { - ( - ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new LongValue(token2.image)); } - | ( token= | token= ) "=" token2= { fbvColumn = new FBVColumn(token.image, new StringValue(token2.image)); } - | token= "=" ( token2= | token2= ) { fbvColumn = new FBVColumn(token.image, token2.image); } - ) { - return fbvColumn; + return aggregatePipeOperator; } } -List FBVSourceColumnList(): { - List fbvColumns = new ArrayList(); - FBVColumn fbvColumn; - boolean precedesComma; -} { - fbvColumn = FBVSourceColumn() { fbvColumns.add(fbvColumn); } - ( - { precedesComma = false; } - ["," { precedesComma = true; }] - fbvColumn = FBVSourceColumn() { fbvColumn.setPrecedesComma(precedesComma); fbvColumns.add(fbvColumn); } - )* +OrderByPipeOperator OrderByPipeOperator(): +{ + OrderByPipeOperator orderByPipeOperator; + List orderByElements; +} +{ + orderByElements = OrderByElements() { - return fbvColumns; + orderByPipeOperator = new OrderByPipeOperator(orderByElements); + return orderByPipeOperator; } } -FileOption FileDestinationOption(): { - FileOption fileOption; - - Token token; - Token token2; - Token token3; -} { - ( - ( token= | token= ) { fileOption = new FileOption(token.image); } - | token= token2= token3= { fileOption = new FileOption(token.image + " " + token2.image + " " + token3.image); } - | ( token= | token= | token= ) "=" token2= { fileOption = new FileOption(token.image, new StringValue(token2.image)); } - | ( - token= token2= "=" token3= - | token= ( token2= | token2= ) "=" token3= - ) - { fileOption = new FileOption(token.image + " " + token2.image, new StringValue(token3.image)); } - | token= "=" ( token2= | token2= | token2= ) { fileOption = new FileOption(token.image, token2.image); } - ) +AsPipeOperator AsPipeOperator(): +{ + AsPipeOperator asPipeOperator; + Alias alias; +} +{ + alias = Alias() { - return fileOption; + asPipeOperator = new AsPipeOperator( alias.withUseAs(true) ); + return asPipeOperator; } } -List FileDestinationOptionList(): { - List fileOptions = new ArrayList(); - FileOption fileOption; -} { - ( LOOKAHEAD(2) fileOption = FileDestinationOption() { fileOptions.add(fileOption); } )+ +JoinPipeOperator JoinPipeOperator(): +{ + JoinPipeOperator joinPipeOperator; + Join join; +} +{ + join = JoinerExpression() { - return fileOptions; + joinPipeOperator = new JoinPipeOperator(join); + return joinPipeOperator; } } -FileOption FileSourceOption(): { - FileOption fileOption; - - Token token; - Token token2; - Token token3; -} { - ( - ( token= | token= | token= ) { fileOption = new FileOption(token.image); } - | ( - ( token= | token= ) "=" token2= { fileOption = new FileOption(token.image, new StringValue(token2.image)); } - | token= "=" token2= { fileOption = new FileOption(token.image, new LongValue(token2.image)); } - ) - | LOOKAHEAD(2) - ( - token= token2= "=" token3= - | token= ( token2= | token2= ) "=" token3= - ) - { fileOption = new FileOption(token.image + " " + token2.image, new StringValue(token3.image)); } - | token= token2= "=" token3= - { fileOption = new FileOption(token.image + " " + token2.image, new LongValue(token3.image)); } - ) +SetPipeOperator SetPipeOperator(): +{ + SetPipeOperator setPipeOperator; + List updateSets; +} +{ + updateSets = UpdateSets() { - return fileOption; + setPipeOperator = new SetPipeOperator(updateSets); + return setPipeOperator; } } -List FileSourceOptionList(): { - List fileOptions = new ArrayList(); - FileOption fileOption; -} { - ( LOOKAHEAD(2) fileOption = FileSourceOption() { fileOptions.add(fileOption); } )+ +DropPipeOperator DropPipeOperator(): +{ + DropPipeOperator dropPipeOperator; + ExpressionList columns; +} +{ + columns = ColumnList() { - return fileOptions; + dropPipeOperator = new DropPipeOperator(columns); + return dropPipeOperator; } } -FileDestination FileDestination() #FileDestination: { - FileDestination fileDestination = new FileDestination(); - FileType fileType; - List connectionFileDefinitions; - List files; - List csvColumns; - List fbvColumns; - List fileOptions; - CertificateVerification certificateVerification; -} { - ( - fileType = FileType() { fileDestination.setDestinationType(fileType); } - connectionFileDefinitions = ConnectionFileDefinitionList() { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); } - | { fileDestination.setLocal(true); } - [ { fileDestination.setSecure(true); }] - - fileType = FileType() { fileDestination.setDestinationType(fileType); } - files = FileList() - { - connectionFileDefinitions = new ArrayList(); - connectionFileDefinitions.add(new ConnectionFileDefinition(files)); - } - ) - { fileDestination.setConnectionFileDefinitions(connectionFileDefinitions); } - - [ - LOOKAHEAD(2) - "(" - ( - csvColumns = CSVDestinationColumnList() { fileDestination.setCSVColumns(csvColumns); } - | fbvColumns = FBVDestinationColumnList() { fileDestination.setFBVColumns(fbvColumns); } - ) - ")" - ] - - [ LOOKAHEAD(2) fileOptions = FileDestinationOptionList() { fileDestination.setFileOptions(fileOptions); } ] - - [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileDestination.setCertificateVerification(certificateVerification); } ] - - { - return fileDestination; - } +LimitPipeOperator LimitPipeOperator(): +{ + LimitPipeOperator limitPipeOperator; + Expression expression; } +{ + expression = Expression() { limitPipeOperator = new LimitPipeOperator(expression); } + [ LOOKAHEAD(2) expression = Expression() { limitPipeOperator.setOffsetExpression(expression); } ] -FileSource FileSource() #FileSource: { - FileSource fileSource = new FileSource(); - FileType fileType; - List connectionFileDefinitions; - List files; - List csvColumns; - List fbvColumns; - List fileOptions; - CertificateVerification certificateVerification; -} { - ( - fileType = FileType() { fileSource.setSourceType(fileType); } - connectionFileDefinitions = ConnectionFileDefinitionList() { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); } - | { fileSource.setLocal(true); } - [ { fileSource.setSecure(true); }] - - fileType = FileType() { fileSource.setSourceType(fileType); } - files = FileList() - { - connectionFileDefinitions = new ArrayList(); - connectionFileDefinitions.add(new ConnectionFileDefinition(files)); - } - ) - { fileSource.setConnectionFileDefinitions(connectionFileDefinitions); } - - [ - LOOKAHEAD(2) - "(" - ( - csvColumns = CSVSourceColumnList() { fileSource.setCSVColumns(csvColumns); } - | fbvColumns = FBVSourceColumnList() { fileSource.setFBVColumns(fbvColumns); } - ) - ")" - ] - - [ LOOKAHEAD(2) fileOptions = FileSourceOptionList() { fileSource.setFileOptions(fileOptions); } ] - - [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { fileSource.setCertificateVerification(certificateVerification); } ] - - { - return fileSource; - } + { + return limitPipeOperator; + } } -CertificateVerification CertificateVerification(): { - CertificateVerification certificateVerification = new CertificateVerification(); - Token token; -} { +// see https://manticore-projects.com/SQL2016Parser/syntax_snapshot.html#corresponding-spec +String SetOperationModifier(): +{ + Token tk; + String modifier = ""; + String identifier; +} +{ ( - ( - { certificateVerification.setIgnoreCertificate(true); } - | { certificateVerification.setVerifyCertificate(true); } - ) - - [ - LOOKAHEAD(2) - - token = { certificateVerification.setPublicKey(new StringValue(token.image)); } - ] - | - token = { certificateVerification.setPublicKey(new StringValue(token.image)); } + LOOKAHEAD(2) ( + [ ( tk= | tk="DISTINCT") { modifier+=tk.image; } ] + { modifier+= " BY NAME"; } + [ + LOOKAHEAD({ isKeywordAhead("MATCHING") }) + ContextualKeyword("MATCHING") { modifier+= " MATCHING"; } + "(" + identifier = RelObjectName() { modifier+="(" + identifier; } + ("," identifier = RelObjectName() { modifier+=", " + identifier; })* + ")" { modifier+=")"; } + ] + ) + | + ( + [ { modifier+= " STRICT"; } ] + { modifier+= " CORRESPONDING"; } + [ (tk= | tk="DISTINCT") { modifier+=tk.image; } ] + [ + { modifier+= " BY"; }[ (tk= | tk="DISTINCT") { modifier+=tk.image; } ] + "(" + identifier = RelObjectName() { modifier+="(" + identifier; } + ("," identifier = RelObjectName() { modifier+=", " + identifier;})* + ")" { modifier+=")"; } + ] + ) + | + ( tk= | tk= ) { modifier+=tk.image; } ) { - return certificateVerification; + return modifier; } } -ScriptSourceDestination ScriptSourceDestination(): { - ScriptSourceDestination scriptSourceDestination = new ScriptSourceDestination(); - ConnectionDefinition connectionDefinition; - Table script; - String property; - StringValue value; - - Token token; -} { - - script = Table() { scriptSourceDestination.setScript(script); } - - [ LOOKAHEAD(2) connectionDefinition = ConnectionDefinition() { scriptSourceDestination.setConnectionDefinition(connectionDefinition); } ] - - [ - LOOKAHEAD(2) - { - List properties = new ArrayList(); - List values = new ArrayList(); - scriptSourceDestination.setProperties(properties); - scriptSourceDestination.setValues(values); - } - - +SetOperationPipeOperator SetOperationPipeOperator(): +{ + SetOperationPipeOperator setOperationPipeOperator = null; + SetOperationType setOperationType; + String modifier = null; + ParenthesedSelect select; +} +{ + ( ( - LOOKAHEAD(2) - property = RelObjectName() "=" token = { value = new StringValue(token.image); } - { - properties.add(property); - values.add(value); - } - )+ - ] + [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.UNION; } + select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType, modifier); } + ) + | + ( + [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.INTERSECT; } + select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType, modifier); } + ) + | + ( + [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.EXCEPT; } + select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType, modifier); } + ) + ) + + ( + LOOKAHEAD(2) "," select = ParenthesedSelect() { setOperationPipeOperator.add(select); } + )* { - return scriptSourceDestination; + return setOperationPipeOperator; } } -UserIdentification UserIdentification(): { - UserIdentification userIdentification = new UserIdentification(); - Token token; -} { - - token= { userIdentification.setUser(new StringValue(token.image)); } - - token= { userIdentification.setPassword(new StringValue(token.image)); } +CallPipeOperator CallPipeOperator(): +{ + TableFunction tableFunction; + Alias alias=null; +} +{ + tableFunction = TableFunction() [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] { - return userIdentification; + return new CallPipeOperator(tableFunction, alias); } } -ConnectionDefinition ConnectionDefinition(): { - ConnectionDefinition connectionDefinition = new ConnectionDefinition(); - String connectionObjectName; - UserIdentification userIdentification; - CertificateVerification certificateVerification; - - Token token; -} { - - ( - connectionObjectName = RelObjectName() { connectionDefinition.setConnectionObjectName(connectionObjectName); } - | token= { connectionDefinition.setConnectionDefinition(new StringValue(token.image)); } - ) - - [ LOOKAHEAD(2) userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ] - - [ LOOKAHEAD(2) certificateVerification = CertificateVerification() { connectionDefinition.setCertificateVerification(certificateVerification); } ] - { - return connectionDefinition; - } +TableSamplePipeOperator TableSamplePipeOperator(): +{ + Token token; } - -ConnectionDefinition CloudConnectionDefinition(): { - CloudConnectionDefinition connectionDefinition = new CloudConnectionDefinition(); - String connectionObjectName; - UserIdentification userIdentification; - - Token token; - Token token2; -} { - - ( - token = { connectionDefinition.setStorage(token.image); } - | token = token2 = { connectionDefinition.setStorage(token.image + " " + token2.image); } - ) - - ( - connectionObjectName = RelObjectName() { connectionDefinition.setConnectionObjectName(connectionObjectName); } - | token = { connectionDefinition.setConnectionDefinition(new StringValue(token.image)); } - ) - - [ userIdentification = UserIdentification() { connectionDefinition.setUserIdentification(userIdentification); } ] - - { - return connectionDefinition; - } +{ + "(" ( token= | token= ) ")" + { + return new TableSamplePipeOperator( token.image ); + } } -ConnectionDefinition ConnectionOrCloudConnectionDefinition(): { - ConnectionDefinition connectionDefinition; -} { - ( - LOOKAHEAD(2) connectionDefinition = CloudConnectionDefinition() - | connectionDefinition = ConnectionDefinition() - ) +PivotPipeOperator PivotPipeOperator(): +{ + Function aggregateExpression; + Column inputColumn; + List> pivotColumns; + Alias alias = null; +} +{ + "(" aggregateExpression=Function() + inputColumn=Column() + "(" pivotColumns = SelectItemsList() ")" + ")" + [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] { - return connectionDefinition; + return new PivotPipeOperator(aggregateExpression, inputColumn, pivotColumns, alias); } } -ErrorClause ErrorClause(): { - ErrorClause errorClause = new ErrorClause(); - ErrorDestination errorDestination; - Expression expression; - RejectClause rejectClause; - - Token token; -} { - ( - - errorDestination = ErrorDestination() { errorClause.setErrorDestination(errorDestination); } - [ - LOOKAHEAD(2) - "(" - expression = Expression() { errorClause.setExpression(expression); } - ")" - ] - [ - LOOKAHEAD(2) - ( - { errorClause.setReplace(true); } - | { errorClause.setTruncate(true); } - ) - ] - [ LOOKAHEAD(2) rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } ] - | rejectClause = RejectClause() { errorClause.setRejectClause(rejectClause); } - ) - - { - return errorClause; - } +UnPivotPipeOperator UnPivotPipeOperator(): +{ + Column valuesColumn; + Column nameColumn; + List> pivotColumns; + Alias alias = null; +} +{ + "(" valuesColumn=Column() + nameColumn=Column() + "(" pivotColumns = SelectItemsList() ")" + ")" + [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] + { + return new UnPivotPipeOperator(valuesColumn, nameColumn, pivotColumns, alias); + } } -RejectClause RejectClause(): { - RejectClause rejectClause = new RejectClause(); -} { - - ( - token= { rejectClause.setLimit(new LongValue(token.image)); } - | - ) - - [ LOOKAHEAD(2) { rejectClause.setErrors(true); } ] +TableStatement TableStatement(): +{ + Table table = null; + List orderByElements = null; + Limit limit = null; + Offset offset = null; + TableStatement tableStatement = new TableStatement(); +}{ + + table = Table() + { tableStatement.setTable(table); } + [ LOOKAHEAD( ) orderByElements = OrderByElements() { tableStatement.setOrderByElements(orderByElements); } ] + [ LOOKAHEAD(1, ) limit = LimitWithOffset() { tableStatement.setLimit(limit);} ] + [ LOOKAHEAD(1, ) offset = Offset() { tableStatement.setOffset(offset);} ] + { return tableStatement; } + /* Support operationList */ +} +ParenthesedSelect ParenthesedSelect() #ParenthesedSelect: +{ + ParenthesedSelect parenthesedSelect = new ParenthesedSelect(); + Select select; +} +{ + "(" + select = Select() + ")" { - return rejectClause; + linkAST(parenthesedSelect,jjtThis); + return parenthesedSelect.withSelect(select); } } -ErrorDestination ErrorDestination(): { - ErrorDestination errorDestination; -} { - ( - LOOKAHEAD(2) errorDestination = CSVFileDestination() - | errorDestination = Table() - ) - +ParenthesedInsert ParenthesedInsert() #ParenthesedInsert: +{ + ParenthesedInsert parenthesedInsert = new ParenthesedInsert(); + Insert insert; + Token open = getToken(1); + Token statementFirst; +} +{ + "(" { statementFirst = getToken(1); } + insert = Insert() { linkStatement(insert, statementFirst); } + ")" { - return errorDestination; + return linked(parenthesedInsert.withInsert(insert), open); } } -CSVFileDestination CSVFileDestination(): { - CSVFileDestination csvFileDestination = new CSVFileDestination(); - ConnectionDefinition connectionDefinition; - StringValue file; -} { - ( - - connectionDefinition = ConnectionOrCloudConnectionDefinition() { csvFileDestination.setConnectionDefinition(connectionDefinition); } - | { csvFileDestination.setLocal(true); } - [ { csvFileDestination.setSecure(true); } ] - - ) - - file = File() { csvFileDestination.setFile(file); } - +ParenthesedUpdate ParenthesedUpdate() #ParenthesedUpdate: +{ + ParenthesedUpdate parenthesedUpdate = new ParenthesedUpdate(); + Update update; + Token open = getToken(1); + Token statementFirst; +} +{ + "(" { statementFirst = getToken(1); } + update = Update() { linkStatement(update, statementFirst); } + ")" { - return csvFileDestination; + return linked(parenthesedUpdate.withUpdate(update), open); } } -DeclareStatement Declare(): { - UserVariable userVariable; - ColDataType colDataType; - Expression defaultExpr = null; - DeclareStatement stmt = new DeclareStatement(); - String typeName; - String columnName; - ColumnDefinition colDef; -} { - userVariable = UserVariable() - ( - LOOKAHEAD(2) ( - "(" colDef = ColumnDefinition() - { - stmt.withUserVariable(userVariable) - .withDeclareType(DeclareType.TABLE) - .addColumnDefinition(colDef); - } - ("," colDef = ColumnDefinition() { stmt.addColumnDefinition(colDef); })* ")" - ) - | - typeName = RelObjectName() - { - stmt.withUserVariable(userVariable) - .withDeclareType(DeclareType.AS) - .withTypeName(typeName); - } - | - (colDataType = ColDataType() ["=" defaultExpr = Expression()] - { - stmt.withDeclareType(DeclareType.TYPE) - .addType(userVariable, colDataType, defaultExpr); - } - ("," userVariable = UserVariable() colDataType = ColDataType() { defaultExpr = null; } - ["=" defaultExpr = Expression()] { stmt.addType(userVariable, colDataType, defaultExpr); } )* - ) - ) +ParenthesedDelete ParenthesedDelete() #ParenthesedDelete: +{ + ParenthesedDelete parenthesedDelete = new ParenthesedDelete(); + Delete delete; + Token open = getToken(1); + Token statementFirst; +} +{ + "(" { statementFirst = getToken(1); } + delete = Delete() { linkStatement(delete, statementFirst); } + ")" { - return stmt; + return linked(parenthesedDelete.withDelete(delete), open); } } -SessionStatement SessionStatement(): +LateralView LateralView() #LateralView: { - SessionStatement sessionsStatement; - Token actionToken; - Token idToken = null; - String id = null; + boolean useOuter = false; + Function generatorFunction = null; + String tableName = null; + String columnName = null; + Alias tableAlias = null; + Alias columnAlias = null; } { - ( | ) - ( - actionToken = - | - actionToken = - | - actionToken = - | - actionToken = - | - actionToken = - ) + [ { useOuter=true; } ] + generatorFunction = Function() + [ LOOKAHEAD(2) + tableName=RelObjectName() + { + tableAlias = new Alias(tableName, false); + } + ] + columnName = RelObjectName() { columnAlias = new Alias(columnName, true); } + // Spark SQL supports multiple Alias Columns: https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select-lateral-view.html + // we simulate this by setting the alias name to null and then just adding the columns [ + LOOKAHEAD(2) "," { columnAlias.setName(null); columnAlias.addAliasColumns( columnName); } + columnName = RelObjectName() { columnAlias.addAliasColumns( columnName); } ( - idToken = - | - idToken = - | - idToken = - | - idToken = - ) { id = idToken.image; } - - ( - "." - ( - idToken = - | - idToken = - | - idToken = - | - idToken = - ) { id += "." + idToken.image; } - )? + LOOKAHEAD(2) "," columnName = RelObjectName() { columnAlias.addAliasColumns( columnName); } + )* ] { - sessionsStatement = id!=null - ? new SessionStatement(actionToken.image, id) - : new SessionStatement(actionToken.image); + return new LateralView( + useOuter + , generatorFunction + , tableAlias + , columnAlias + ); } +} - // options - [ - LOOKAHEAD(2) - ( idToken = | idToken = ) - "=" - ( actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = ) - { sessionsStatement.putOption(idToken.image, actionToken.image ); } +/** SELECT modifiers are contextual here so other dialects retain identifier spellings. */ +void MySqlSelectModifier(PlainSelect select): +{ + Token token; + MySqlSelectModifier modifier; +} +{ + ( LOOKAHEAD({ getToken(1).kind == K_HIGH_PRIORITY && isMySqlSelectModifierAhead() }) token= + | token= + | token= | token= + | LOOKAHEAD({ getToken(1).kind == K_SQL_NO_CACHE && isMySqlSelectModifierAhead() }) token= + | LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && isMySqlSelectModifierAhead() }) token= ) + { + modifier = MySqlSelectModifier.valueOf(token.image.toUpperCase(Locale.ROOT)); + if ((modifier == MySqlSelectModifier.SQL_CACHE + && select.getMySqlSqlCacheFlag() == MySqlSqlCacheFlags.SQL_NO_CACHE) + || (modifier == MySqlSelectModifier.SQL_NO_CACHE + && select.getMySqlSqlCacheFlag() == MySqlSqlCacheFlags.SQL_CACHE)) { + throw new ParseException("SQL_CACHE and SQL_NO_CACHE cannot be combined"); + } + select.addMySqlSelectModifiers(modifier); + } +} - ( - "," - ( idToken = | idToken = ) - "=" - ( actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = | actionToken = ) - { sessionsStatement.putOption(idToken.image, actionToken.image ); } - )* +ForUpdateClause AdditionalForUpdateClause(): +{ + ForUpdateClause clause = new ForUpdateClause(); + List
tables = new ArrayList
(); + Table table; + Wait wait; +} +{ + + ( + { clause.setMode(ForMode.UPDATE); } + | { clause.setMode(ForMode.SHARE); } + | ( { clause.setMode(ForMode.NO_KEY_UPDATE); }) + | ( { clause.setMode(ForMode.KEY_SHARE); }) + ) + [ LOOKAHEAD(2) + table = Table() { tables.add(table); } + ( LOOKAHEAD(2) "," table = Table() { tables.add(table); } )* + { clause.setTables(tables); } ] - + [ LOOKAHEAD(1, ) wait = Wait() { clause.setWait(wait); } ] + [ LOOKAHEAD(2) ( { clause.setNoWait(true); } + | { clause.setSkipLocked(true); }) ] { - //linkAST(sessionsStatement,jjtThis); - return sessionsStatement; + return clause; } } -SetStatement Set(): { - SetStatement set; +ForClause ForClause() #ForClause: +{ + Token token = null; + ForClause forClause = new ForClause(); } { - + ( - LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind == S_IDENTIFIER - && SetStatement.OnOffOption.fromName(getToken(1).image) != null - && !"=".equals(getToken(2).image) && !".".equals(getToken(2).image) }) - set=SqlServerSetOnOffOptions() - | set=SetAssignments() + token = + | + token = + ( + ( + ( [ LOOKAHEAD(2) "(" ")" ] | ) + ( + LOOKAHEAD(2) "," + ( + + | + | [ LOOKAHEAD(2) "(" ")" ] + | + | [ LOOKAHEAD(2) "(" ")" ] + | [ LOOKAHEAD(2) ( | ) ] + ) + )* + ) + | + ( + + ( + LOOKAHEAD(2) "," + ( + + | + | [ LOOKAHEAD(2) "(" ")" ] + | + ) + )* + ) + | + ( + [ LOOKAHEAD(2) "(" ")" ] + ( + LOOKAHEAD(2) "," + ( + + | + | [ LOOKAHEAD(2) "(" ")" ] + | [ LOOKAHEAD(2) ( | ) ] + ) + )* + ) + ) + | + ( + token = ( | ) + ( + LOOKAHEAD(2) "," + ( + [ LOOKAHEAD(2) "(" ")" ] + | + | + ) + )* + ) ) - { return set; } + { + forClause.setForOption(token.image); + linkAST(forClause,jjtThis); + return forClause; + } } -SetStatement SetAssignments(): { - SetStatement set = new SetStatement(); - Expression exp; - Token tk = null; -} -{ - [LOOKAHEAD(3) (tk = | tk = ) { set.setEffectParameter(tk.image); } ] - SetAssignment(set) - ( - "," - ( LOOKAHEAD(3) SetAssignment(set) - | exp=Expression() { set.getExpressions(set.getCount() - 1).add(exp); } ) - )* - { return set; } -} -/** The first and subsequent assignments use identical names and operators. */ -void SetAssignment(SetStatement set): +List LateralViews(): { - Object name; - Expression expression; - SetStatement.AssignmentOperator operator = SetStatement.AssignmentOperator.NONE; + ArrayList lateralViews = new ArrayList(); + LateralView lateralView = null; } { - ( - LOOKAHEAD({ (getToken(1).kind == K_CHARACTER && getToken(2).kind == K_SET) - || (isKeywordAhead("CHARSET") && !"=".equals(getToken(2).image) - && !":=".equals(getToken(2).image)) }) SetCharacterSet(set) - | - ( LOOKAHEAD(2) { name = "Time Zone"; } - | name=UserVariable() - | name=IdentifierChain() ) - [ "=" { operator = SetStatement.AssignmentOperator.EQUALS; } - | ":=" { operator = SetStatement.AssignmentOperator.COLON_EQUALS; } ] - expression=Expression() - { set.add(name, new ExpressionList(expression), operator); } - ) + lateralView = LateralView() { lateralViews.add(lateralView); } + ( LOOKAHEAD(2) lateralView = LateralView() { lateralViews.add(lateralView); } )* + + { + return lateralViews; + } } -/** Character set selection has a single name or DEFAULT, not an arbitrary expression. */ -void SetCharacterSet(SetStatement set): +LateralSubSelect LateralSubSelect() #LateralSubSelect: { - String name; - Token value; - Expression expression; + LateralSubSelect lateralSubSelect = new LateralSubSelect();; + Select select; } { - ( { name = "CHARACTER SET"; } - | { name = "CHARSET"; } ) - ( value= { expression = new StringValue(value.image); } - | (value= | value= | value=) - { expression = new Column(value.image); } ) - { set.add(name, new ExpressionList(expression), false); } + "(" select = Select() ")" { lateralSubSelect.withSelect(select).setPrefix("LATERAL"); } + { + linkAST(lateralSubSelect,jjtThis); + return lateralSubSelect; + } } -SetStatement SqlServerSetOnOffOptions(): { - SetStatement set = new SetStatement(); - List options = new ArrayList(); - SetStatement.OnOffOption option; - Token name; - boolean on; +PlainSelect PlainSelect() #PlainSelect: +{ + PlainSelect plainSelect = new PlainSelect(); + List> selectItems = null; + FromItem fromItem = null; + List lateralViews = null; + List joins = null; + List> distinctOn = null; + Expression preWhere = null; + Expression where = null; + ForClause forClause = null; + OptionClause optionClause = null; + List orderByElements; + List interpolateElements = null; + GroupByElement groupBy = null; + Expression having = null; + Expression qualify; + Limit limitBy = null; + Limit limit = null; + Offset offset = null; + Fetch fetch = null; + WithIsolation withIsolation = null; + OptimizeFor optimize = null; + Top top = null; + Skip skip = null; + First first = null; + OracleHierarchicalExpression oracleHierarchicalQueryClause = null; + PreferringClause preferringClause = null; + ExpressionList expressionList = null; + Token partitionFirst = null; + SelectIntoClause intoClause = null; + MySqlSelectIntoClause mySqlSelectIntoClause = null; + MySqlProcedureAnalyse mySqlProcedureAnalyse = null; + Table updateTable = null; + List
updateTables = new ArrayList
(); + ForUpdateClause additionalForUpdateClause; + Wait wait = null; + Token token; + KSQLWindow ksqlWindow = null; + boolean noWait = false; + String windowName = null; + WindowDefinition winDef; + List settings = null; + Distinct distinct; + boolean all = false; } { - name= + + + [ LOOKAHEAD(2) { plainSelect.setMySqlHintStraightJoin(true); } ] + + { plainSelect.setOracleHint(getOracleHint()); } + + [ LOOKAHEAD(2) skip = Skip() { plainSelect.setSkip(skip); } ] + + [ LOOKAHEAD(2) first = First() { plainSelect.setFirst(first); } ] + + // Redshift allows TOP before DISTINCT + // https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_list.html + // @Todo: reflect the order when de-parsing + [ LOOKAHEAD(2) top = Top() { plainSelect.setTop(top); } ] + + ( LOOKAHEAD({ isMySqlSelectModifierAhead() }) MySqlSelectModifier(plainSelect) )* + + [ LOOKAHEAD(2) + ( + { all = true; } + | + ( + { distinct = new Distinct(); plainSelect.setDistinct(distinct); } + [ LOOKAHEAD(2) "ON" "(" distinctOn=SelectItemsList() { plainSelect.getDistinct().setOnSelectItems(distinctOn); } ")" ] + ) + | + { distinct = new Distinct(); distinct.setUseDistinctRow(true); plainSelect.setDistinct(distinct); } + | + { distinct = new Distinct(true); plainSelect.setDistinct(distinct); } + ) + ] + + ( LOOKAHEAD({ isMySqlSelectModifierAhead() }) MySqlSelectModifier(plainSelect) )* { - option = accessEnum(SetStatement.OnOffOption.class, name.image); - options.add(option); + if ((all || plainSelect.getDistinct() != null) + && (getToken(1).kind == K_ALL || getToken(1).kind == K_DISTINCT + || getToken(1).kind == K_DISTINCTROW || getToken(1).kind == K_UNIQUE)) { + throw new ParseException("SELECT cannot combine ALL and DISTINCT qualifiers"); + } } + + [ LOOKAHEAD( ( | )) + + ( + { plainSelect.setBigQuerySelectQualifier( PlainSelect.BigQuerySelectQualifier.AS_STRUCT ); } + | + { plainSelect.setBigQuerySelectQualifier( PlainSelect.BigQuerySelectQualifier.AS_VALUE ); } + ) + ] + + [ LOOKAHEAD(2) top = Top() { plainSelect.setTop(top); } ] + ( - "," name= + // PostgreSQL allows SELECT with no target expressions. + LOOKAHEAD({ isPostgreSqlDialect() + && (getToken(1).kind == K_FROM || getToken(1).kind == K_INTO) }) + { selectItems = new ArrayList>(); } + | + selectItems=SelectItemsList() + ) + + [ LOOKAHEAD(1, ) + ( + LOOKAHEAD({ isMySqlSelectIntoAhead() }) + mySqlSelectIntoClause = MySqlSelectIntoClause(MySqlSelectIntoClause.Position.BEFORE_FROM) + { plainSelect.setMySqlSelectIntoClause(mySqlSelectIntoClause); } + | + intoClause = IntoClause() { plainSelect.setIntoClause(intoClause); } + ) + ] + [ LOOKAHEAD(2) fromItem=FromItem() + [ LOOKAHEAD(2) lateralViews=LateralViews() ] + [ LOOKAHEAD(2) joins=JoinsList() ] + ] + [ LOOKAHEAD(3) { plainSelect.setUsingOnly(true); } fromItem=FromItem() + [ LOOKAHEAD(2) lateralViews=LateralViews() ] + [ LOOKAHEAD(2) joins=JoinsList() ] + ] + + // Clickhouse FINAL as shown at https://clickhouse.com/docs/en/operations/settings/settings#final + [ LOOKAHEAD(2) { plainSelect.setUsingFinal(true); } ] + + [ LOOKAHEAD(2) ksqlWindow=KSQLWindowClause() { plainSelect.setKsqlWindow(ksqlWindow); } ] + [ LOOKAHEAD(2) preWhere=PreWhereClause() { plainSelect.setPreWhere(preWhere); }] + [ LOOKAHEAD(2) where=WhereClause() { plainSelect.setWhere(where); }] + [ LOOKAHEAD(2) oracleHierarchicalQueryClause=OracleHierarchicalQueryClause() { plainSelect.setOracleHierarchical(oracleHierarchicalQueryClause); } ] + [ LOOKAHEAD(2) preferringClause=PreferringClause() { plainSelect.setPreferringClause(preferringClause); } + [LOOKAHEAD(2) partitionFirst= + expressionList=ComplexExpressionList() + { + preferringClause.setPartitionExpressionList(expressionList, false); + linkAST(preferringClause.getPartitionBy(), partitionFirst); + } + ] + ] + // Oracle supports "HAVING" before "GROUP BY", we will simply parse that but won't pay special attention to the order + [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); }] + [ LOOKAHEAD(2) groupBy=GroupByColumnReferences() { plainSelect.setGroupByElement(groupBy); }] + [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); }] + [ LOOKAHEAD(2) qualify=Qualify() {plainSelect.setQualify(qualify); }] + [ LOOKAHEAD( ) orderByElements = OrderByElements() { plainSelect.setOracleSiblings(true); plainSelect.setOrderByElements(orderByElements); } ] + [ LOOKAHEAD(2) + windowName = RelObjectName() winDef = windowDefinition() { List winDefs = new ArrayList(); winDefs.add(winDef.withWindowName(windowName)); } + ( LOOKAHEAD(2) "," windowName = RelObjectName() winDef = windowDefinition() { winDefs.add(winDef.withWindowName(windowName)); } )* + { plainSelect.setWindowDefinitions(winDefs); } + // DuckDB: QUALIFY after WINDOW + [ LOOKAHEAD(2, { plainSelect.getQualify() == null }) qualify=Qualify() + { plainSelect.setQualify(qualify); plainSelect.setQualifyAfterWindow(true); } ] + ] + [ LOOKAHEAD( ) orderByElements = OrderByElements() { plainSelect.setOrderByElements(orderByElements); } ] + [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { plainSelect.setInterpolate(interpolateElements); } ] + [ LOOKAHEAD(2) forClause = ForClause() {plainSelect.setForClause(forClause);} ] + [ LOOKAHEAD(2) optionClause = OptionClause() { plainSelect.setOption(optionClause); } ] + [ LOOKAHEAD(2) + ( { plainSelect.setEmitMode(PlainSelect.EmitMode.CHANGES); } + | { plainSelect.setEmitMode(PlainSelect.EmitMode.FINAL); } ) ] + // Parse the LIMIT row count once (this accepts a parenthesized subquery too), then + // optionally attach ClickHouse's `LIMIT ... BY ...`. Checking BY right after the limit + // expression avoids a numeric LOOKAHEAD, which cannot see past a long parenthesized + // subquery and would wrongly commit to LIMIT BY (issue #2359). + [ LOOKAHEAD(1, ) limit = LimitWithOffset() + [ LOOKAHEAD(1, ) expressionList = ExpressionList() { limit.setByExpressions(expressionList); widen(limit, null, getToken(0)); } ] { - option = accessEnum(SetStatement.OnOffOption.class, name.image); - options.add(option); + if (limit.getByExpressions() != null) { + plainSelect.setLimitBy(limit); + } else { + plainSelect.setLimit(limit); + } + } ] + [ LOOKAHEAD(1, ) offset = Offset() { plainSelect.setOffset(offset); } ] + [ LOOKAHEAD(, { limit==null }) limit = LimitWithOffset() { plainSelect.setLimit(limit); } ] + [ LOOKAHEAD( ) + mySqlProcedureAnalyse = MySqlProcedureAnalyse() + { plainSelect.setMySqlProcedureAnalyse(mySqlProcedureAnalyse); } + ] + [ LOOKAHEAD(1, ) fetch = Fetch() { plainSelect.setFetch(fetch); } ] + [ LOOKAHEAD( ) withIsolation = WithIsolation() { plainSelect.setIsolation(withIsolation); } ] + [ LOOKAHEAD(2) + + ( + { plainSelect.setForMode(ForMode.UPDATE); } + | { plainSelect.setForMode(ForMode.SHARE); } + | ( { plainSelect.setForMode(ForMode.NO_KEY_UPDATE); }) + | ( { plainSelect.setForMode(ForMode.KEY_SHARE); }) + | ( { plainSelect.setForMode(ForMode.READ_ONLY); }) + | ( { plainSelect.setForMode(ForMode.FETCH_ONLY); }) + ) + [ LOOKAHEAD(2) + updateTable = Table() { updateTables.add(updateTable); } + ( LOOKAHEAD(2) "," updateTable = Table() { updateTables.add(updateTable); } )* + { plainSelect.setForUpdateTables(updateTables); } + ] + [ LOOKAHEAD(1, ) wait = Wait() { plainSelect.setWait(wait); } ] + [ LOOKAHEAD(2) ( { plainSelect.setNoWait(true); } + | { plainSelect.setSkipLocked(true); }) ] + // PostgreSQL: more locking clauses, e.g. FOR UPDATE OF t FOR SHARE OF u + ( LOOKAHEAD( ( | | | )) + additionalForUpdateClause = AdditionalForUpdateClause() + { plainSelect.addAdditionalForUpdateClause(additionalForUpdateClause); } + )* + [ LOOKAHEAD( ) orderByElements = OrderByElements() + { plainSelect.setOrderByElements(orderByElements); plainSelect.setForUpdateBeforeOrderBy(true); } + ] + [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { plainSelect.setInterpolate(interpolateElements); } ] + ] + [ LOOKAHEAD({ isMySqlSelectIntoAhead() }) + { + if (mySqlSelectIntoClause != null || intoClause != null) { + throw new ParseException("Only one INTO clause is allowed per SELECT"); + } + } + mySqlSelectIntoClause = MySqlSelectIntoClause(MySqlSelectIntoClause.Position.TRAILING) + { plainSelect.setMySqlSelectIntoClause(mySqlSelectIntoClause); } + ] + [ LOOKAHEAD(2) settings = UpdateSets() { plainSelect.setSettings(settings); } ] + [ LOOKAHEAD(1, ) optimize = OptimizeFor() { plainSelect.setOptimizeFor(optimize); } ] + // Informix writes INTO TEMP table at the end of the query, which PostgreSQL rejects + [ LOOKAHEAD( , { !isPostgreSqlDialect() }) + { + if (mySqlSelectIntoClause != null || intoClause != null) { + throw new ParseException("Only one INTO clause is allowed per SELECT"); + } } - )* - ( { on = true; } | { on = false; } ) + intoClause = TrailingIntoTempClause() { plainSelect.setIntoClause(intoClause); } + ] + [ LOOKAHEAD(3) { plainSelect.setUseWithNoLog(true); } ] { - set.setOnOffOptions(new SetStatement.OnOffOptions(options, on)); - return set; + plainSelect.setSelectItems(selectItems); + plainSelect.setFromItem(fromItem); + if ( lateralViews!=null && lateralViews.size()>0 ) { + plainSelect.setLateralViews( lateralViews ); + } + if ( joins!=null && joins.size()>0 ) { + plainSelect.setJoins( joins ); + } + linkAST(plainSelect,jjtThis); + return plainSelect; } } -ResetStatement Reset(): { - String name; - ResetStatement reset; - Token all; -} -{ - ( LOOKAHEAD(2) {name = "Time Zone"; } | name = RelObjectName() | all = {name = all.image; } ) - { reset = new ResetStatement(name); return reset; } -} - -RenameTableStatement RenameTableStatement(): { - RenameTableStatement renameTableStatement; - Table oldName; - Table newName; - boolean usingTableKeyword=false; - boolean usesIfExistsKeyword=false; - String waitDirective = ""; - Token token; +Select SetOperationList(Select select) #SetOperationList: { + SetOperationList list = new SetOperationList(); + List orderByElements = null; + List interpolateElements = null; + Limit limit = null; + Offset offset = null; + Fetch fetch = null; + WithIsolation withIsolation = null; + List(); + List operations = new ArrayList(); + String modifier = null; } { - - [ LOOKAHEAD(2) { usingTableKeyword = true; } ] - [ LOOKAHEAD(2) { usesIfExistsKeyword = true; } ] - oldName = Table() - [ ( - token= { waitDirective = "WAIT " + token.image; } - | - { waitDirective = "NOWAIT"; } - ) ] - - newName = Table() { - renameTableStatement = new RenameTableStatement(oldName, newName, usingTableKeyword, usesIfExistsKeyword, waitDirective); + selects.add(select); } - ( - "," - oldName = Table() - - newName = Table() + ( LOOKAHEAD(2) { modifier = null; } ( + ( + [ modifier=SetOperationModifier() ] { UnionOp union = new UnionOp(modifier); linkAST(union,jjtThis); operations.add(union); } + + ) + | + ( + [ modifier=SetOperationModifier() ] { IntersectOp intersect = new IntersectOp(modifier); linkAST(intersect,jjtThis); operations.add(intersect); } + ) + | + ( + [ modifier=SetOperationModifier() ] { MinusOp minus = new MinusOp(modifier); linkAST(minus,jjtThis); operations.add(minus); } + ) + | + ( + [ modifier=SetOperationModifier() ] { ExceptOp except = new ExceptOp(modifier); linkAST(except,jjtThis); operations.add(except); } + ) + + ) + + ( + LOOKAHEAD({ getToken(1).kind == K_FROM }) select = FromFirstSelect() + | + LOOKAHEAD({ getToken(1).kind == K_TABLE }) select = TableStatement() + | + select = PlainSelect() + | + select = Values() + | + select = ParenthesedSelect() + ) { - renameTableStatement.addTableNames(oldName, newName); + selects.add(select); } - )* + )+ + + [ LOOKAHEAD(2) orderByElements=OrderByElements() {list.setOrderByElements(orderByElements);} ] + [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { list.setInterpolate(interpolateElements); } ] + [ LOOKAHEAD(1, ) limit = LimitWithOffset() { list.setLimit(limit); } ] + [ LOOKAHEAD(1, ) offset = Offset() { list.setOffset(offset); } ] + [ LOOKAHEAD(, { limit==null }) limit = LimitWithOffset() { list.setLimit(limit); } ] + [ LOOKAHEAD(1, ) fetch = Fetch() { list.setFetch(fetch); } ] + [ LOOKAHEAD( ) withIsolation = WithIsolation() { list.setIsolation(withIsolation); } ] { - return renameTableStatement; + if ( selects.get(selects.size()-1) instanceof PlainSelect ) { + PlainSelect ps = (PlainSelect)selects.get(selects.size()-1); + if (ps.getOrderByElements() != null) { + list.setOrderByElements(ps.getOrderByElements()); + ps.setOrderByElements(null); + } + if (ps.getLimit() != null) { + list.setLimit(ps.getLimit()); + ps.setLimit(null); + } + if (ps.getOffset() != null) { + list.setOffset(ps.getOffset()); + ps.setOffset(null); + } + if (ps.getInterpolate() != null) { + list.setInterpolate(ps.getInterpolate()); + ps.setInterpolate(null); + } + if (ps.getOption() != null) { + list.setOption(ps.getOption()); + ps.setOption(null); + } + if (ps.getFetch() != null) { + list.setFetch(ps.getFetch()); + ps.setFetch(null); + } + if (ps.getIsolation() != null) { + list.setIsolation(ps.getIsolation()); + ps.setIsolation(null); + } + } else if (selects.get(selects.size() - 1) instanceof TableStatement) { + TableStatement table = (TableStatement) selects.get(selects.size() - 1); + if (table.getOrderByElements() != null) { + list.setOrderByElements(table.getOrderByElements()); + table.setOrderByElements(null); + } + if (table.getLimit() != null) { + list.setLimit(table.getLimit()); + table.setLimit(null); + } + if (table.getOffset() != null) { + list.setOffset(table.getOffset()); + table.setOffset(null); + } + } + list.setBracketsOpsAndSelects(selects,operations); + return list; } } -/** - * DuckDB's CREATE [OR REPLACE] [TEMPORARY] MACRO name (parameters) AS [TABLE] body. - */ -CreateMacro CreateMacro(boolean isUsingOrReplace) #CreateMacro: +List> WithList(): { - CreateMacro createMacro = new CreateMacro(); - List parameters = new ArrayList(); - ObjectNames name; - Expression expression; - Select select; - String parameterName; - Expression defaultValue; + List> withItemsList = new ArrayList>(); + WithItem with = null; +} +{ + with=WithItem() { withItemsList.add(with); } + ( "," with=WithItem() { withItemsList.add(with); } )* + + { return withItemsList; } +} + +WithItem WithItem() #WithItem: +{ + boolean recursive = false; + boolean materialized = false; + boolean usingNot = false; + String name = null; + List> selectItems = null; + WithFunctionDeclaration withFunctionDeclaration = null; + ParenthesedStatement statement = null; + Expression expr = null; + WithSearchClause withSearchClause = null; + WithCycleClause withCycleClause = null; + ExpressionList usingKeyExpressions = null; + WithItem withItem; } { - { createMacro.setOrReplace(isUsingOrReplace); } - [ ( | ) { createMacro.setTemporary(true); } ] - name=RelObjectNames() { createMacro.setName(String.join(".", name.getNames())); } - "(" - [ - parameterName=RelObjectName() { defaultValue = null; } - [ ":=" defaultValue=Expression() ] - { parameters.add(new CreateMacro.Parameter(parameterName, defaultValue)); } - ( - "," parameterName=RelObjectName() { defaultValue = null; } - [ ":=" defaultValue=Expression() ] - { parameters.add(new CreateMacro.Parameter(parameterName, defaultValue)); } - )* - ] - ")" { createMacro.setParameters(parameters); } - ( - LOOKAHEAD(2) select=Select() { createMacro.setSelect(select); } - | - expression=Expression() { createMacro.setExpression(expression); } - ) - { return createMacro; } + LOOKAHEAD(2) + withFunctionDeclaration = WithFunctionDeclaration() + { + withItem = new WithItem().withWithFunctionDeclaration(withFunctionDeclaration); + } + | + LOOKAHEAD({ !isWithExpressionAliasAhead() }) + ( + [ LOOKAHEAD(2) { recursive = true; } ] + name=RelObjectName() + [ "(" selectItems=SelectItemsList() ")" ] + // DuckDB 2.0: WITH RECURSIVE tbl (a, b) USING KEY (a, avg(b)) AS (...) + [ LOOKAHEAD(2) "(" usingKeyExpressions=ExpressionList() ")" ] + + [ LOOKAHEAD(2) [ { usingNot = true; } ] { materialized = true; } ] + ( + LOOKAHEAD(2) statement = ParenthesedSelect() + | + LOOKAHEAD(2) statement = ParenthesedInsert() + | + LOOKAHEAD(2) statement = ParenthesedUpdate() + | + LOOKAHEAD(2) statement = ParenthesedDelete() + ) + { + withItem = new WithItem(statement, new Alias(name, false)) + .withRecursive(recursive, usingNot, materialized) + .withWithItemList(selectItems); + withItem.setUsingKeyExpressions(usingKeyExpressions); + } + ) + | + ( + // ClickHouse style expression alias: WITH AS + expr = WithItemExpression() + + name = RelObjectName() + { + withItem = new WithItem().withExpression(expr).withAlias(new Alias(name, false)); + } + ) + ) + [ withSearchClause = WithSearchClause() { withItem.setSearchClause(withSearchClause); } ] + [ withCycleClause = WithCycleClause() { withItem.setCycleClause(withCycleClause); } ] + { + return withItem; + } } -/** - * DuckDB's COPY table [(columns)] FROM path [(options)] and - * COPY {table | (query)} TO path [(options)]. - */ -CopyStatement CopyStatement() #CopyStatement: +Expression WithItemExpression(): { - CopyStatement copyStatement = new CopyStatement(); - ExpressionList columns = null; - List options = new ArrayList(); - String option; - Select select; - Table table; - Token token; + LambdaExpression lambdaExpression; + Expression expr; + Token open; } { - ( - LOOKAHEAD(2) "(" select=Select() ")" { copyStatement.setSelect(select); } + // unparenthesized parameter, e.g. x -> x * 2 + LOOKAHEAD( RelObjectName() "->" ) + expr = LambdaExpression() | - table=Table() { copyStatement.setTable(table); } - [ LOOKAHEAD(2) "(" columns=ColumnList() ")" { copyStatement.setColumns(columns); } ] - ) - ( - { copyStatement.setFrom(true); } + // parenthesized parameter list, e.g. (value) -> value + 1 + LOOKAHEAD( ParenthesedColumnList() "->" ) + expr = LambdaExpression() | - - ) - ( - token= { copyStatement.setPath(token.image); } + // whole lambda wrapped in parentheses, e.g. (x -> x * 2) + LOOKAHEAD( "(" ( RelObjectName() | ParenthesedColumnList() ) "->" ) + open="(" lambdaExpression = LambdaExpression() ")" + { expr = new ParenthesedExpressionList(lambdaExpression); linkAST(expr, open); } | - token= { copyStatement.setPath(token.image); } + expr = Expression() ) - [ LOOKAHEAD({ getToken(1).kind == K_WITH }) - { copyStatement.setWithKeyword(true); } ] - [ - LOOKAHEAD(2) "(" option=DatabaseOption() { options.add(option); } - ( "," option=DatabaseOption() { options.add(option); } )* - ")" { - if (copyStatement.isWithKeyword() - || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { - requireDdlSyntax(!options.contains(""), "Expected a COPY option"); - } - copyStatement.setOptions(options); - } - ] - { return copyStatement; } + { return expr; } } -/** - * PREPARE name AS statement, storing a parameterised statement for later EXECUTE. - */ -PrepareStatement PrepareStatement() #PrepareStatement: +WithSearchClause WithSearchClause() #WithSearchClause: { - PrepareStatement prepareStatement = new PrepareStatement(); - ObjectNames name; - Statement statement; - List parameterTypes = new ArrayList(); - ColDataType parameterType; + Token orderingToken; + ExpressionList searchColumns = new ExpressionList(); + Column searchColumn = null; + String sequenceColumnName; } { - name=RelObjectNames() - { prepareStatement.setName(String.join(".", name.getNames())); } - [ "(" parameterType=PrepareParameterType() { parameterTypes.add(parameterType); } - ( "," parameterType=PrepareParameterType() { parameterTypes.add(parameterType); } )* - ")" { prepareStatement.setParameterTypes(parameterTypes); } ] - statement=SingleStatement() { prepareStatement.setStatement(statement); } - { return prepareStatement; } + + ( orderingToken= | orderingToken= ) + + + searchColumn = Column() { searchColumns.add(searchColumn); } + ( "," searchColumn = Column() { searchColumns.add(searchColumn); } )* + + sequenceColumnName = RelObjectName() + { + linkElements(searchColumns); + return new WithSearchClause( + "BREADTH".equalsIgnoreCase(orderingToken.image) + ? WithSearchClause.SearchOrder.BREADTH + : WithSearchClause.SearchOrder.DEPTH, + searchColumns, sequenceColumnName); + } } -/** PostgreSQL UNKNOWN leaves a parameter type to be inferred from the prepared statement. */ -ColDataType PrepareParameterType(): -{ ColDataType type; Token token; } +WithCycleClause WithCycleClause() #WithCycleClause: { - ( token= { type = new ColDataType(token.image); } - | type=ColDataType() ) - { return type; } + WithCycleClause cycle = new WithCycleClause(); + ExpressionList columns = new ExpressionList(); + String name; + Expression value; +} +{ + + name=RelObjectName() { columns.add(linkToLastToken(createColumn(name))); } + ( "," name=RelObjectName() { columns.add(linkToLastToken(createColumn(name))); } )* + { linkElements(columns); } + name=RelObjectName() { cycle.setMarkColumnName(name); } + [ value=Expression() { cycle.setMarkValue(value); } + value=Expression() { cycle.setMarkDefault(value); } ] + name=RelObjectName() { cycle.setPathColumnName(name); } + { return cycle.withCycleColumns(columns); } } -/** - * DEALLOCATE [PREPARE] name. - */ -DeallocateStatement DeallocateStatement() #DeallocateStatement: +WithFunctionDeclaration WithFunctionDeclaration() #WithFunctionDeclaration: { - DeallocateStatement deallocateStatement = new DeallocateStatement(); - ObjectNames name; + String functionName; + List parameters = new ArrayList(); + String returnType; + Expression returnExpression; + WithFunctionParameter parameter; } { - - [ LOOKAHEAD(2) { deallocateStatement.setUsingPrepareKeyword(true); } ] - name=RelObjectNames() { deallocateStatement.setName(String.join(".", name.getNames())); } - { return deallocateStatement; } + functionName = RelObjectName() + "(" + [ parameter=WithFunctionParameter() { parameters.add(parameter); } + ( "," parameter=WithFunctionParameter() { parameters.add(parameter); } )* + ] + ")" + returnType = RelObjectName() + returnExpression = Expression() + { + return new WithFunctionDeclaration(functionName, parameters, returnType, returnExpression); + } } -/** - * DuckDB's CONNECT target [AS alias], routing the session to a remote database. - */ -ConnectStatement ConnectStatement() #ConnectStatement: +WithFunctionParameter WithFunctionParameter() #WithFunctionParameter: { - ConnectStatement connectStatement = new ConnectStatement(); - ObjectNames name; - Token token; + String name; + String type = null; + String arrayType = null; } { - + name = RelObjectName() ( - token= { connectStatement.setTarget(token.image); } + LOOKAHEAD(2) "<" arrayType = RelObjectName() ">" | - name=RelObjectNames() { connectStatement.setTarget(String.join(".", name.getNames())); } + type = RelObjectName() ) - [ name=RelObjectNames() { connectStatement.setAlias(String.join(".", name.getNames())); } ] - { return connectStatement; } + { + if (arrayType != null) { + type = "ARRAY<" + arrayType + ">"; + } + return new WithFunctionParameter(name, type); + } } -/** - * DuckDB's DISCONNECT [name]. - */ -DisconnectStatement DisconnectStatement() #DisconnectStatement: +List> ColumnSelectItemsList(): { - DisconnectStatement disconnectStatement = new DisconnectStatement(); - ObjectNames name; + List> selectItemsList = null; + SelectItem selectItem = null; } { - - [ - LOOKAHEAD(2) - name=RelObjectNames() { disconnectStatement.setName(String.join(".", name.getNames())); } - ] - { return disconnectStatement; } + selectItem=SelectItem() { selectItemsList = new ArrayList>(); selectItemsList.add(selectItem); } + ( + LOOKAHEAD(2) "," selectItem=SelectItem() + { + selectItemsList.add(selectItem); + } + )* + + { return selectItemsList; } } -/** - * DuckDB's ATTACH [DATABASE] [IF NOT EXISTS] path [AS alias] [(options)]. - */ -AttachStatement AttachStatement() #AttachStatement: +List> SelectItemsList(): { - AttachStatement attachStatement = new AttachStatement(); - List options = new ArrayList(); - String option; - ObjectNames name; - Token token; + List> selectItemsList = null; + SelectItem selectItem = null; } { - - // greedy: DATABASE right after ATTACH is the keyword, not the database name - [ LOOKAHEAD(2) { attachStatement.setUsingDatabaseKeyword(true); } ] - [ LOOKAHEAD(2) { attachStatement.setIfNotExists(true); } ] + selectItem=SelectItem() { selectItemsList = new ArrayList>(); selectItemsList.add(selectItem); } ( - token= { attachStatement.setDatabasePath(token.image); } - | - name=RelObjectNames() { attachStatement.setDatabasePath(String.join(".", name.getNames())); } - ) - [ name=RelObjectNames() { attachStatement.setAlias(String.join(".", name.getNames())); } ] - [ - LOOKAHEAD(2) "(" option=DatabaseOption() { options.add(option); } - ( "," option=DatabaseOption() { options.add(option); } )* - ")" { attachStatement.setOptions(options); } - ] - { return attachStatement; } -} - -/** - * One ATTACH or COPY option, such as READ_ONLY, TYPE SQLITE or FORMAT PARQUET. Option names and - * values are free-form keywords, so the tokens are collected verbatim up to the next comma or the - * closing bracket. - */ -JAVACODE -String DatabaseOption() { - StringBuilder builder = new StringBuilder(); - int depth = 0; - while (true) { - Token token = getToken(1); - if (token == null || token.kind == EOF) { - break; - } - if (depth == 0 && (",".equals(token.image) || ")".equals(token.image))) { - break; - } - if ("(".equals(token.image)) { - depth++; - } else if (")".equals(token.image)) { - depth--; - } - getNextToken(); - if (builder.length() > 0) { - builder.append(" "); + LOOKAHEAD(2, { !isTrailingSelectItemCommaAhead() }) "," selectItem=SelectItem() + { + selectItemsList.add(selectItem); } - builder.append(token.image); - } - return builder.toString(); -} + )* + // DuckDB's trailing comma: SELECT a, b, FROM t + [ LOOKAHEAD({ isTrailingSelectItemCommaAhead() }) "," ] -/** - * DuckDB's DETACH [DATABASE] [IF EXISTS] name. - */ -DetachStatement DetachStatement() #DetachStatement: -{ - DetachStatement detachStatement = new DetachStatement(); - ObjectNames name; -} -{ - - // greedy: DATABASE right after DETACH is the keyword, not the database name - [ LOOKAHEAD(2) { detachStatement.setUsingDatabaseKeyword(true); } ] - [ LOOKAHEAD(2) { detachStatement.setIfExists(true); } ] - name=RelObjectNames() { detachStatement.setDatabaseName(String.join(".", name.getNames())); } - { return detachStatement; } + { return selectItemsList; } } -/** - * DuckDB's [FORCE] INSTALL extension [FROM repository] and LOAD extension. - */ -ExtensionStatement ExtensionStatement() #ExtensionStatement: +FunctionAllColumns FunctionAllColumns() #FunctionAllColumns: { - ExtensionStatement extensionStatement = new ExtensionStatement(); - ObjectNames name; - Token token; + Function function; } { - [ { extensionStatement.setForce(true); } ] - ( - { extensionStatement.setOperation(ExtensionStatement.Operation.INSTALL); } - | - { extensionStatement.setOperation(ExtensionStatement.Operation.LOAD); } - ) - ( - token= { extensionStatement.setExtensionName(token.image); } - | - name=RelObjectNames() { extensionStatement.setExtensionName(String.join(".", name.getNames())); } - ) - [ - LOOKAHEAD(2) - ( - token= { extensionStatement.setRepository(token.image); } - | - name=RelObjectNames() { extensionStatement.setRepository(String.join(".", name.getNames())); } - ) - ] - { return extensionStatement; } + "(" ( "(" )* function=Function() ")" ( ")" )* "." "*" + { + return new FunctionAllColumns(function); + } } -/** - * DuckDB/SQLite PRAGMA name [(arguments) | = value]. - */ -PragmaStatement PragmaStatement() #PragmaStatement: +SelectItem SelectItem() #SelectItem: { - PragmaStatement pragmaStatement = new PragmaStatement(); - ObjectNames name; - ExpressionList parameters; - Expression value; + Expression expression; + Alias alias = null; } { - name=RelObjectNames() - { pragmaStatement.setName(String.join(".", name.getNames())); } - // greedy: parentheses right after the pragma name are its arguments - [ - LOOKAHEAD(2) - ( - "(" parameters=ExpressionList() ")" { pragmaStatement.setParameters(parameters); } - | - "=" value=SimpleExpression() { pragmaStatement.setValue(value); } - ) - ] - { return pragmaStatement; } + expression = SelectItemExpression() + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ] + { + SelectItem selectItem = new SelectItem(expression, alias); + linkAST(selectItem,jjtThis); + return selectItem; + } } /** - * BigQuery's LOAD DATA {INTO | OVERWRITE} table [(column_definitions)] [OPTIONS (option_list)] - * FROM FILES (file_options) [WITH PARTITION COLUMNS] [WITH CONNECTION connection]. + * Recognizes a transformer without consuming it. APPLY(functionName) intentionally takes + * precedence over its ambiguous alias-column reading. Other aliases use the existing Alias + * grammar, including typed columns, at every transformer boundary. Only the transformer + * prefix is probed: expression bodies are parsed normally by the Pratt parser. */ -LoadDataStatement LoadDataStatement() #LoadDataStatement: -{ - LoadDataStatement loadDataStatement = new LoadDataStatement(); - List columnDefinitions = new ArrayList(); - ColumnDefinition columnDefinition; - ExpressionList options; - ObjectNames connectionName; - Table table; -} +boolean ColumnsTransformerAhead() #void: +{} { - - ( | { loadDataStatement.setOverwrite(true); } ) - table=Table() { loadDataStatement.setTable(table); } - [ - LOOKAHEAD(2) "(" - columnDefinition=ColumnDefinition() { columnDefinitions.add(columnDefinition); } - ( "," columnDefinition=ColumnDefinition() { columnDefinitions.add(columnDefinition); } )* - ")" { loadDataStatement.setColumnDefinitions(columnDefinitions); } - ] - [ - LOOKAHEAD({ isKeywordAhead("OPTIONS") }) - "(" options=ExpressionList() ")" { loadDataStatement.setOptions(options); } - ] - - LOOKAHEAD({ isKeywordAhead("FILES") }) - "(" options=ExpressionList() ")" { loadDataStatement.setFileOptions(options); } - [ - LOOKAHEAD(2) - { loadDataStatement.setWithPartitionColumns(true); } - ] - [ - LOOKAHEAD({ getToken(1).kind == K_WITH && "CONNECTION".equalsIgnoreCase(getToken(2).image) }) - connectionName=RelObjectNames() - { loadDataStatement.setConnectionName(String.join(".", connectionName.getNames())); } - ] - { return loadDataStatement; } + LOOKAHEAD( "(" RelObjectName() ")" ) { return true; } + | LOOKAHEAD( ( | ) AliasColumns() ) { return false; } + | LOOKAHEAD( "(" | [ ] "(" + | [ ] ( ParenthesedColumnList() | ) + | ParenthesedColumnList() ) + { return true; } + | { return false; } } /** - * BigQuery's EXPORT DATA [WITH CONNECTION connection] OPTIONS (option_list) AS query. + * Recognizes a transformer after the AllColumns-Pattern '*'. + * + * This differs from ColumnsTransformerAhead() in one point: after '*' an alias is not a + * meaningful reading of REPLACE, so REPLACE (col) stays a transformer here whereas + * APPLY (col1, col2) remains an alias. Reusing the COLUMNS(...) rules verbatim would turn + * '* REPLACE (x)' into an alias. */ -ExportDataStatement ExportDataStatement() #ExportDataStatement: -{ - ExportDataStatement exportDataStatement = new ExportDataStatement(); - ExpressionList options; - ObjectNames connectionName; - Select select; -} +boolean AllColumnsTransformerAhead() #void: +{} { - - [ - LOOKAHEAD({ getToken(1).kind == K_WITH && "CONNECTION".equalsIgnoreCase(getToken(2).image) }) - connectionName=RelObjectNames() - { exportDataStatement.setConnectionName(String.join(".", connectionName.getNames())); } - ] - [ - LOOKAHEAD({ isKeywordAhead("OPTIONS") }) - "(" options=ExpressionList() ")" - { exportDataStatement.setOptions(options); } - ] - select=Select() { exportDataStatement.setSelect(select); } - { return exportDataStatement; } + LOOKAHEAD( "(" RelObjectName() ")" ) { return true; } + | LOOKAHEAD( AliasColumns() ) { return false; } + | LOOKAHEAD( "(" | [ ] "(" + | [ ] ( ParenthesedColumnList() | ) + | ParenthesedColumnList() ) + { return true; } + // DuckDB: * EXCLUDE i, * REPLACE expr AS i, * RENAME [(]i AS x[)] + | LOOKAHEAD( Column() ) { return true; } + | LOOKAHEAD({ isUnparenthesizedReplaceAhead() || isRenameAhead() }) { return true; } + | { return false; } } /** - * BigQuery's ASSERT expression [AS description] debugging statement. + * Keeps transformer consumption visible to enclosing syntactic lookaheads. The normal + * expression is parsed first; only a direct COLUMNS function can acquire transformers. + * The conditional node encloses both the matcher and its transformers, but adds no AST + * parent for ordinary expressions or alias-column lists. */ -AssertStatement AssertStatement() #AssertStatement: +Expression SelectItemExpression() #ColumnsExpression(transformers != null): { - AssertStatement assertStatement = new AssertStatement(); Expression expression; - Token token; -} -{ - expression=Expression() { assertStatement.setExpression(expression); } - [ token= - { assertStatement.setDescription(new StringValue(token.image)); } ] - { return assertStatement; } -} - -PurgeStatement PurgeStatement(): { - PurgeStatement purgeStatement = null; - Table table; - Index index; - Token tableSpaceToken; - Token userToken = null; + ColumnsTransformer transformer; + List transformers = null; + Token first; } { - + // @fixme: Oracle's SEQUENCE.nextval is parsed as COLUMN with a name part nextval + // @todo: parse a proper SEQUENCE instead of a COLUMN + { first = getToken(1); } ( - table=Table() { purgeStatement = new PurgeStatement(table); } + LOOKAHEAD({ isPriorOperatorAhead() }) expression = ConnectByPriorOperator() { linkASTIfMissing(expression, first); } | - index=Index() { purgeStatement = new PurgeStatement(index); } - | - { purgeStatement = new PurgeStatement(PurgeObjectType.RECYCLEBIN); } - | - { purgeStatement = new PurgeStatement(PurgeObjectType.DBA_RECYCLEBIN); } - | - tableSpaceToken= [ userToken= ] { - purgeStatement = new PurgeStatement( - PurgeObjectType.TABLESPACE - , tableSpaceToken.image - , userToken!=null ? userToken.image : null); - } + ( expression = Condition() { expression = prattExpressionRest(expression, first, 2); } ) ) - - { - return purgeStatement; - } -} - -DescribeStatement Describe(): { - Table table; - Select select; - DescribeStatement stmt = new DescribeStatement(); - Token tk = null; -} { - (tk= | tk=) ( - // DuckDB describes the result of a query, not only a table - LOOKAHEAD({ getToken(1).kind == K_SELECT || getToken(1).kind == K_WITH - || getToken(1).kind == K_FROM || getToken(1).kind == OPENING_BRACKET }) - select = Select() { stmt.setDescribeType(tk.image).setSelect(select); } - | - table = Table() { stmt.setDescribeType(tk.image).setTable(table); } - ) + LOOKAHEAD( "(" | [ ] "(" + | [ ] ( ParenthesedColumnList() | ) ) + { + if (!(expression instanceof Function)) { + break; + } + Function function = (Function) expression; + if (!"COLUMNS".equalsIgnoreCase(function.getName()) || function.isEscaped() + || function.getAttribute() != null || function.getChainedParameters() != null + || function.getKeep() != null || function.isIgnoreNullsOutside() + || !ColumnsTransformerAhead()) { + break; + } + } + transformer = ColumnsTransformer() + { + if (transformers == null) { + transformers = new ArrayList(); + } + transformers.add(transformer); + } + )* { - return stmt; + if (transformers == null) { + return expression; + } + ColumnsExpression columnsExpression = new ColumnsExpression(expression, transformers); + linkAST(columnsExpression, jjtThis); + return columnsExpression; } } -ExplainStatement Explain(): +/** + * Parses a single ClickHouse transformer: APPLY(expression), EXCEPT [STRICT] (columns) + * or a pattern, REPLACE [STRICT] (selectItems). ClickHouse parses these in a loop, so + * they may repeat and combine in any order. + */ +ColumnsTransformer ColumnsTransformer(): { + Expression applyExpression; + ParenthesedExpressionList exceptColumns = null; + StringValue exceptPattern = null; + List> replaceItems; + SelectItem item; + Column column; + ColumnsTransformer transformer; Token tk; - Statement statement; - List> with = null; - Table table; - List options; - ExplainStatement es; - boolean parenthesized = false; + boolean strict; + Token first = getToken(1); } { - ( tk= | tk = ) ( - LOOKAHEAD(3)( - ( - LOOKAHEAD(2) "(" options = PostgresqlExplainOptions() ")" { parenthesized = true; } - | options = ExplainStatementOptions() - ) - ( - [ LOOKAHEAD(2) with=WithList() ] - ( - statement = SelectWithWithItems( with ) - | statement = InsertWithWithItems( with ) - | statement = UpdateWithWithItems( with ) - | statement = DeleteWithWithItems( with ) - | statement = Merge( with ) - ) - ) - { - es = new ExplainStatement(tk.image, statement, options); - es.setParenthesizedOptions(parenthesized); - } - ) - | - ( - table=Table( ) { es = new ExplainStatement(tk.image, table); } - ) - ) - { - if (parenthesized || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { - validatePostgresqlExplain(es); - } - return es; - } + "(" + ( + LOOKAHEAD( RelObjectName() "->" ) applyExpression = LambdaExpression() + | + applyExpression = Expression() + ) + ")" + { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.APPLY) + .setApplyExpression(applyExpression); } + + | + { strict = false; } + [ { strict = true; } ] + ( + exceptColumns = ParenthesedColumnList() + | + tk= { exceptPattern = stringValue(tk); } + ) + { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.EXCEPT) + .setStrict(strict); + if (exceptPattern != null) { + transformer.setExceptPattern(exceptPattern); + } else { + transformer.setExceptColumns(exceptColumns); + } } + + | + { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.EXCLUDE); } + ( + exceptColumns = ParenthesedColumnList() + | + column = Column() + { + exceptColumns = linkElements(new ParenthesedExpressionList(column)); + transformer.setParenthesized(false); + } + ) + { transformer.setExceptColumns(exceptColumns); } + + | + { strict = false; } + [ LOOKAHEAD({ getToken(1).kind == K_STRICT && "(".equals(getToken(2).image) }) + { strict = true; } ] + { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.REPLACE) + .setStrict(strict); } + ( + LOOKAHEAD({ "(".equals(getToken(1).image) && !isUnparenthesizedReplaceAhead(0) }) + "(" replaceItems = SelectItemsList() ")" + | + item = SelectItem() + { + requireTransformerAlias(item); + replaceItems = new ArrayList>(); + replaceItems.add(item); + transformer.setParenthesized(false); + } + ) + { transformer.setReplaceItems(replaceItems); } + + | + { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.RENAME); } + ( + LOOKAHEAD(1, "(") "(" replaceItems = SelectItemsList() ")" + | + item = SelectItem() + { + requireTransformerAlias(item); + replaceItems = new ArrayList>(); + replaceItems.add(item); + transformer.setParenthesized(false); + } + ) + { transformer.setRenameItems(replaceItems); } + ) + { linkAST(transformer, first); return transformer; } } -List PostgresqlExplainOptions(): +/** + * Parses the AllColumns-Pattern '*'. + * + * If the allowAdditions is true, it parses additional Keywords. + */ +AllColumns AllColumns(boolean allowAdditions): { - List options = new ArrayList(); - ExplainStatement.Option option; + ColumnsTransformer transformer; + List transformers = null; } { - option = PostgresqlExplainOption() { options.add(option); } - ( "," option = PostgresqlExplainOption() { options.add(option); } )* - { return options; } -} + "*" + // BigData allows EXCEPT, DuckDB allows EXCLUDE and RENAME, ClickHouse allows APPLY; + // they may repeat and combine in any order + ( + // AllColumnsTransformerAhead() tells DuckDB's REPLACE and RENAME from an alias of the star + LOOKAHEAD( "(" | | + | [ ] ( ParenthesedColumnList() | ) + | ( ParenthesedColumnList() | Column() ) ) + { + if (!allowAdditions || !AllColumnsTransformerAhead()) { + break; + } + } + transformer = ColumnsTransformer() + { + if (transformers == null) { + transformers = new ArrayList(); + } + transformers.add(transformer); + } + )* -ExplainStatement.Option PostgresqlExplainOption(): -{ - Token name; - Token value = null; -} -{ - ( name = | name = | name = - | name = | name = | name = - | name = ) - [ ( value = | value = | value = | value = - | value = | value = | value = | value = - | value = | value = | value = | value = ) ] { - return new ExplainStatement.Option(postgresqlExplainOptionType(name.image)) - .withValue(value == null ? null : value.image); + return new AllColumns(transformers); } } /** - * Boolean values in the legacy unparenthesized syntax. + * Parses the AllTableColumns-Pattern 'table.*' + * + * If the allowAdditions is true, it parses additional Keywords. */ -String ExplainOptionBoolean(): +AllTableColumns AllTableColumns(boolean allowAdditions): { - Token tk = null; + Table table = null; + AllColumns allColumns; } { - [( tk= | tk= | tk= | tk= )] - { - return tk != null ? tk.image : null; - } -} + table=Table() "." allColumns=AllColumns(allowAdditions) + { + return new AllTableColumns(table, allColumns); + } -/** - * Preserve the optional format in the legacy unparenthesized syntax. - */ -String ExplainFormatOption(): -{ - Token tk = null; -} -{ - [( tk= | tk= | tk= )] - { - return tk != null ? tk.image : null; - } } -/** - * Options for explain, see https://www.postgresql.org/docs/9.1/sql-explain.html - */ -List ExplainStatementOptions(): -{ - List options = new ArrayList(); - ExplainStatement.Option option = null; +Alias Alias(): +{ String name = ""; Token token = null; - String value = null; + boolean useAs = false; + Alias alias; + List aliasColumns; } { - ( - ( value=ExplainOptionBoolean() - { - option = new ExplainStatement.Option(ExplainStatement.OptionType.ANALYZE); - option.setValue(value); - options.add(option); - } - ) - | - ( value=ExplainOptionBoolean() - { - option = new ExplainStatement.Option(ExplainStatement.OptionType.BUFFERS); - option.setValue(value); - options.add(option); - } - ) - | - ( value=ExplainOptionBoolean() - { - option = new ExplainStatement.Option(ExplainStatement.OptionType.COSTS); - option.setValue(value); - options.add(option); - } - ) - | - ( value=ExplainOptionBoolean() - { - option = new ExplainStatement.Option(ExplainStatement.OptionType.VERBOSE); - option.setValue(value); - options.add(option); - } - ) - | - ( value=ExplainFormatOption() - { - option = new ExplainStatement.Option(ExplainStatement.OptionType.FORMAT); - option.setValue(value); - options.add(option); - } - ) - | ( - { option = new ExplainStatement.Option(ExplainStatement.OptionType.PLAN); } - [ { option = new ExplainStatement.Option(ExplainStatement.OptionType.PLAN_FOR); } ] + LOOKAHEAD(3) ( + // Aliases with AS and Columns, but optional identifier: + // SELECT fun(x) AS (a,b,c) + // SELECT fun(x) AS T(a,b,c) + + [ LOOKAHEAD(2) name=RelObjectName() ] + { alias = new Alias(name, true ); } - value=ExplainFormatOption() - { - option.setValue(value); - options.add(option); - } + aliasColumns = AliasColumns() { alias.setAliasColumns(aliasColumns); } + + ) + | + ( + // Aliases with identifier but optional AS and Columns: + // SELECT fun(x) AS T + // SELECT fun(x) T + // SELECT fun(x) T(a,b,c) + + [ { useAs = true; } ] + ( name=RelObjectName() | token= { name=token.image; } ) + { alias = new Alias(name,useAs); } + + [ LOOKAHEAD(2) aliasColumns = AliasColumns() { alias.setAliasColumns(aliasColumns); } ] + + ) ) - )* //zero or many times those productions - { - return options; - } + { return alias; } } -SetIdentityInsertStatement SetIdentityInsert(): { - Table table; - boolean on; -} +List AliasColumns(): { - AccessKeyword("IDENTITY_INSERT") table=Table() - { - requireAccessSyntax(table.getNameParts().size() <= 3, - "IDENTITY_INSERT requires a table name with at most three parts"); - } - ( { on = true; } | { on = false; } ) - { - return new SetIdentityInsertStatement(table, on); - } -} - -UseStatement Use(): { + List columns = new ArrayList(); String name; - boolean hasSchemaKeyword = false; + ColDataType type = null; } { - [ LOOKAHEAD(2) { hasSchemaKeyword = true; } ] name = RelObjectName() - { - return new UseStatement(name, hasSchemaKeyword); - } + "(" name = RelObjectName() [ type = ColDataType() ] + { columns.add(new Alias.AliasColumn(name, type)); } + ( + "," { type = null; } name = RelObjectName() [ type = ColDataType() ] + { columns.add(new Alias.AliasColumn(name, type)); } + )* + ")" + { return columns; } } -Statement Show(): -{ - Statement statement; - List captureRest; +void SQLServerHint(SQLServerHints hints) : { + String str; + Token keyword; } { - - ( - LOOKAHEAD(2) statement = ShowColumns() - | - LOOKAHEAD(2) statement = ShowIndex() + "(" str = RelObjectName() ")" { hints.setIndexName(str); } | - LOOKAHEAD(2) statement = ShowTables() + { hints.withNoLock(); } | - // any of the RDBMS specific SHOW syntax - captureRest = captureRest() + ( keyword= | keyword= ) { - if (captureRest.size()==1) { - statement = new ShowStatement(captureRest.get(0)); - } else { - statement = new UnsupportedStatement("SHOW", captureRest); + try { + hints.getLockHints().add(SQLServerHints.LockHint.valueOf(keyword.image.toUpperCase(Locale.ROOT))); + } catch (IllegalArgumentException exception) { + throw new ParseException("Unsupported SQL Server locking hint: " + keyword.image); } } - ) - { - return statement; - } } -ShowColumnsStatement ShowColumns(): { - String tableName; +SQLServerHints SQLServerHints() : { + SQLServerHints hints = new SQLServerHints(); +} +{ + "(" + SQLServerHint(hints) ("," SQLServerHint(hints) )* + ")" + { return hints; } +} + +MySQLIndexHint MySQLIndexHint(): +{ + Token actionToken = null; + Token indexToken = null; + MySQLIndexHint.Scope scope = null; + String indexName = null; + List indexNameList = new ArrayList(); +} +{ + ( + actionToken = + | actionToken = + | actionToken = + | actionToken = + ) + + ( + indexToken = + | indexToken = + ) + + [ + + ( + { scope = MySQLIndexHint.Scope.JOIN; } + | { scope = MySQLIndexHint.Scope.ORDER_BY; } + | { scope = MySQLIndexHint.Scope.GROUP_BY; } + ) + ] + + "(" + [ + indexName = RelObjectName() { indexNameList.add(indexName); } + ("," indexName= RelObjectName() { indexNameList.add(indexName); })* + ] + ")" + { + // only USE INDEX () may name no index + requireSyntax(!indexNameList.isEmpty() || actionToken.kind == K_USE, + actionToken.image + " " + indexToken.image + " requires at least one index name"); + return new MySQLIndexHint(actionToken.image, indexToken.image, scope, indexNameList); + } +} + +List MySQLIndexHints(): +{ + List hints = new ArrayList(); + MySQLIndexHint hint; } { - tableName = RelObjectName() - { - return new ShowColumnsStatement(tableName); - } + hint = MySQLIndexHint() { hints.add(hint); } + ( LOOKAHEAD(2) hint = MySQLIndexHint() { hints.add(hint); } )* + { + return hints; + } } -ShowIndexStatement ShowIndex(): { - String tableName; +SelectItem FunctionItem(): +{ + Alias alias = null; + Function function; + Token first = getToken(1); } { - tableName = RelObjectName() + function=Function() + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ] { - return new ShowIndexStatement(tableName); + SelectItem item = new SelectItem(function, alias); + linkAST(item, first); + return item; } } -Statement RefreshMaterializedView(): { - Table view = null; - boolean concurrently = false; - RefreshMode refreshMode = null; - List captureRest; -} +ExpressionList PivotForColumns(): { - - [ LOOKAHEAD(2) { concurrently = true; } ] - view = Table() - [ - { refreshMode = RefreshMode.WITH_DATA; } - [ - { refreshMode = RefreshMode.WITH_NO_DATA; } - ] - - ] - captureRest = captureRest() - { - if (concurrently && refreshMode == RefreshMode.WITH_NO_DATA) { - return new UnsupportedStatement("REFRESH", captureRest); - } else { - return new RefreshMaterializedViewStatement(view, concurrently, refreshMode); - } - } -} -// https://dev.mysql.com/doc/refman/8.0/en/show-tables.html -ShowTablesStatement ShowTables(): { - ShowTablesStatement showTablesStatement; - EnumSet modifiers = EnumSet.noneOf(ShowTablesStatement.Modifiers.class); - ShowTablesStatement.SelectionMode selectionMode = null; - String dbName = null; - Expression likeExpression = null; - Expression whereCondition = null; + ExpressionList columns; + Column column; } { - [ { modifiers.add(ShowTablesStatement.Modifiers.EXTENDED); } ] - [ { modifiers.add(ShowTablesStatement.Modifiers.FULL); } ] - - [ - LOOKAHEAD(2) ( - { selectionMode = ShowTablesStatement.SelectionMode.FROM; } + ( + columns = ParenthesedColumnList() | - { selectionMode = ShowTablesStatement.SelectionMode.IN; } + column = Column() { columns = linkElements(new ExpressionList(column)); } ) - dbName = RelObjectName() - ] - [ ( likeExpression = SimpleExpression() | whereCondition = Expression()) ] - { - showTablesStatement = new ShowTablesStatement(); - showTablesStatement.setModifiers(modifiers); - showTablesStatement.setSelectionMode(selectionMode); - showTablesStatement.setDbName(dbName); - showTablesStatement.setLikeExpression(likeExpression); - showTablesStatement.setWhereCondition(whereCondition); - return showTablesStatement; - } -} - -Values Values(): { - ExpressionList expressions; -} { - ( | ) - expressions = ExpressionList() - - { - return new Values(expressions); - } + { return columns; } } -ReturningClause ReturningClause(): +List> PivotFunctionItems(): { - Token keyword; - List outputAliases = null; - List> selectItems; - Object dataItem; - List dataItems = null; + List> functionItems = new ArrayList>(); + SelectItem item; } { - ( keyword= | keyword= ) - [ LOOKAHEAD(2) outputAliases = ReturningOutputAliasList() ] - selectItems = SelectItemsList() - - [ - - ( dataItem = Table() | dataItem = UserVariable() ) - { dataItems = new ArrayList(); dataItems.add(dataItem); } - - ( - "," - ( dataItem = Table() | dataItem = UserVariable() ) { dataItems.add(dataItem); } - )* - ] - - { - return new ReturningClause(keyword.image, selectItems, outputAliases, dataItems); - } + item = FunctionItem() {functionItems.add(item);} + ( LOOKAHEAD(2) "," item = FunctionItem() {functionItems.add(item);} )* + { return functionItems; } } -ReturningReferenceType ReturningReferenceKind(): +/** + * DuckDB's simplified UNPIVOT statement: + * UNPIVOT tbl ON columns [INTO NAME name VALUE values]. + */ +UnPivotQuery UnPivotQuery(): { - String refName; - ReturningReferenceType refType; + UnPivotQuery unPivotQuery = new UnPivotQuery(); + ExpressionList onExpressions; + ExpressionList valueColumns; + FromItem fromItem; + String nameColumn; } { - refName = RelObjectName() - { - refType = ReturningReferenceType.from(refName); - if (refType == ReturningReferenceType.OLD) { - return ReturningReferenceType.OLD; - } else if (refType == ReturningReferenceType.NEW) { - return ReturningReferenceType.NEW; - } - throw new ParseException("Expected OLD or NEW but found: " + refName); - } + fromItem=FromItem() { unPivotQuery.setFromItem(fromItem); } + onExpressions=ExpressionList() { unPivotQuery.setOnExpressions(onExpressions); } + // greedy: INTO after the ON list belongs to this UNPIVOT + [ + LOOKAHEAD(2) + nameColumn=RelObjectName() { unPivotQuery.setNameColumn(nameColumn); } + valueColumns=ColumnList() { unPivotQuery.setValueColumns(valueColumns); } + ] + { return unPivotQuery; } } -ReturningOutputAlias ReturningOutputAliasDefinition(): +PivotQuery PivotQuery(): { - ReturningReferenceType refType; - String aliasName; + PivotQuery pivotQuery = new PivotQuery(); + FromItem fromItem; + ExpressionList onExpressions = null; + List> usingItems = null; + ExpressionList groupByExpressions = null; } { - refType = ReturningReferenceKind() - - aliasName = RelObjectName() + fromItem = FromItem() + ( + onExpressions = ExpressionList() + [ LOOKAHEAD(2) usingItems = PivotFunctionItems() ] + [ LOOKAHEAD(2) groupByExpressions = ExpressionList() ] + | + usingItems = PivotFunctionItems() + [ LOOKAHEAD(2) groupByExpressions = ExpressionList() ] + | + groupByExpressions = ExpressionList() + ) { - return new ReturningOutputAlias(refType, aliasName); + pivotQuery.setFromItem(fromItem); + pivotQuery.setOnExpressions(onExpressions); + pivotQuery.setUsingItems(usingItems); + pivotQuery.setGroupByExpressions(groupByExpressions); + return pivotQuery; } } -List ReturningOutputAliasList(): +SelectItem> ExpressionListItem(): { - List outputAliases = new ArrayList(); - ReturningOutputAlias outputAlias; + ExpressionList expressionList; + Alias alias = null; + Token first = getToken(1); } { - "(" - outputAlias = ReturningOutputAliasDefinition() { outputAliases.add(outputAlias); } - ( - "," - outputAlias = ReturningOutputAliasDefinition() { outputAliases.add(outputAlias); } - )* - ")" + expressionList=ParenthesedExpressionList() + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ] { - return outputAliases; + SelectItem> item = new SelectItem>(expressionList, alias); + linkAST(item, first); + return item; } } -Update UpdateWithWithItems( List> withItems ): +List>> PivotMultiInItems(): { - Update update; + List>> retval = new ArrayList>>(); + SelectItem> item; } { - update = Update() { update.setWithItemsList( withItems ); - return update; -} + item = ExpressionListItem() {retval.add(item);} + ("," item = ExpressionListItem() {retval.add(item);} )* + { return retval; } } -Update Update(): +Pivot Pivot(): { - Update update = new Update(); - Table table = null; - ForPortionClause forPortionClause; - List startJoins = null; - List> with = null; - List updateSets; - Expression where = null; - PreferringClause preferringClause = null; - Limit limit = null; - OptionClause optionClause = null; - List orderByElements; - boolean useColumnsBrackets = false; - ReturningClause returningClause; - Token tk = null; - UpdateModifierPriority modifierPriority = null; - boolean modifierIgnore = false; - - OutputClause outputClause = null; + Pivot retval = new Pivot(); + List> functionItems; + ExpressionList forColumns; + List> singleInItems = null; + List>> multiInItems = null; + Alias alias = null; } { - { update.setOracleHint(getOracleHint()); } - [ LOOKAHEAD(2) { modifierPriority = UpdateModifierPriority.LOW_PRIORITY; }] - [ LOOKAHEAD(2) { modifierIgnore = true; }] - table=TableWithAliasAndMysqlIndexHint() - [ forPortionClause=ForPortionClause() { update.setForPortionClause(forPortionClause); } ] - [ startJoins=JoinsList() ] - [ LOOKAHEAD(, { Dialect.TERADATA.name().equals(getAsString(Feature.dialect)) }) - UpdateFromClause(update) { update.setFromBeforeSet(true); } ] - updateSets = UpdateSets() { update.setUpdateSets(updateSets); } - - [ outputClause = OutputClause() {update.setOutputClause(outputClause); } ] - - [ LOOKAHEAD(2, { !Dialect.TERADATA.name().equals(getAsString(Feature.dialect)) }) - UpdateFromClause(update) ] - - [ where=WhereClause() { update.setWhere(where); } ] - [ preferringClause=PreferringClause() { update.setPreferringClause(preferringClause); } ] - - [ orderByElements = OrderByElements() { update.setOrderByElements(orderByElements); } ] - [ limit = PlainLimit() { update.setLimit(limit); } ] - [ LOOKAHEAD(2) optionClause = OptionClause() { update.setOption(optionClause); } ] - [ returningClause = ReturningClause() { update.setReturningClause(returningClause); } ] - + "(" functionItems = PivotFunctionItems() + forColumns = PivotForColumns() + "(" + (LOOKAHEAD(3) singleInItems = SelectItemsList() + | multiInItems = PivotMultiInItems() ) + ")" + ")" + [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] { - return update.withWithItemsList(with) - .withTable(table) - .withStartJoins(startJoins) - .withModifierPriority(modifierPriority) - .withModifierIgnore(modifierIgnore); + retval.setFunctionItems(functionItems); + retval.setForColumns(forColumns); + retval.setSingleInItems(singleInItems); + retval.setMultiInItems(multiInItems); + retval.setAlias(alias); + return retval; } } -/** Shared structured interval for application-time UPDATE and DELETE. */ -ForPortionClause ForPortionClause() #ForPortionClause: +PivotXml PivotXml(): { - String periodName; - Expression fromExpression; - Expression toExpression; - ForPortionClause clause; + PivotXml retval = new PivotXml(); + List> functionItems; + ExpressionList forColumns; + List> singleInItems = null; + List>> multiInItems = null; + Select inSelect = null; } { - AccessKeyword("PORTION") periodName=RelObjectName() - fromExpression=Expression() toExpression=Expression() + "(" functionItems = PivotFunctionItems() + forColumns = PivotForColumns() + "(" + ( + LOOKAHEAD(2) { retval.setInAny(true); } | + LOOKAHEAD(1) inSelect = Select() | + LOOKAHEAD(2) singleInItems =SelectItemsList() | + multiInItems = PivotMultiInItems() + ) + ")" + ")" { - clause = new ForPortionClause(periodName, fromExpression, toExpression); - linkAST(clause, jjtThis); - return clause; + retval.setFunctionItems(functionItems); + retval.setForColumns(forColumns); + retval.setSingleInItems(singleInItems); + retval.setMultiInItems(multiInItems); + retval.setInSelect(inSelect); + return retval; } } -void UpdateFromClause(Update update): +UnPivot UnPivot(): { - FromItem fromItem; - List joins = null; + UnPivot retval = new UnPivot(); + ExpressionList unpivotClause; + ExpressionList unpivotForClause; + List> unpivotInClause; + Alias alias = null; } { - fromItem=FromItem() - [ LOOKAHEAD(2) joins=JoinsList() ] - { update.setFromItem(fromItem); update.setJoins(joins); } + + [ ( { retval.setIncludeNulls(true); } + | { retval.setIncludeNulls(false); } ) ] + "(" unpivotClause = PivotForColumns() + unpivotForClause = PivotForColumns() + "(" + unpivotInClause = SelectItemsList() + ")" + ")" + [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] + { + retval.setUnPivotClause(unpivotClause); + retval.setUnPivotForClause(unpivotForClause); + retval.setUnPivotInClause(unpivotInClause); + retval.setAlias(alias); + return retval; + } } -List UpdateSets(): +/** + * INTO after the select list. PostgreSQL (gram.y into_clause) creates one table and accepts a + * persistence and the TABLE keyword before its name: + * INTO [ [LOCAL | GLOBAL] {TEMPORARY | TEMP} | UNLOGGED ] [TABLE] table. + * A persistence word that no name follows is the table name itself, as in INTO temp FROM t. + * The list of targets is what other products and procedural languages write. + */ +SelectIntoClause IntoClause(): { - ArrayList updateSets = new ArrayList(); - UpdateSet updateSet; - Column tableColumn; - Expression valueExpression; - - ExpressionList columns; - ExpressionListvalues; + SelectIntoClause clause = new SelectIntoClause(); + Table table; + Token first; + Token scope = null; + Token persistence; } { - ( - ( - tableColumn=Column() "=" valueExpression=Expression() - { updateSets.add( new UpdateSet (tableColumn, valueExpression)); } - ) - | + first= + [ + LOOKAHEAD(( | [ | ] ( | ) ) + ( | RelObjectName() ), { isPostgreSqlSelectIntoDialect() }) ( - { updateSet = new UpdateSet(); updateSets.add(updateSet); } - columns = ParenthesedExpressionList() { updateSet.setColumns(columns); } - "=" - ( - LOOKAHEAD(3) valueExpression = ParenthesedSelect() { updateSet.setValues( new ExpressionList(valueExpression)); } - | - values = ParenthesedExpressionList() { updateSet.setValues(values); } - ) - ) - ) - - ( - LOOKAHEAD(2) ( - "," - tableColumn=Column() "=" valueExpression=Expression() - { updateSets.add( new UpdateSet (tableColumn, valueExpression)); } + { clause.setPersistence(SelectIntoClause.Persistence.UNLOGGED); } | - ( - { updateSet = new UpdateSet(); updateSets.add(updateSet); } - columns = ParenthesedExpressionList() { updateSet.setColumns(columns); } - "=" - ( - LOOKAHEAD(3) valueExpression = ParenthesedSelect() { updateSet.setValues( new ExpressionList(valueExpression)); } - | - values = ParenthesedExpressionList() { updateSet.setValues(values); } - ) - ) + [ scope= | scope= ] + ( persistence= | persistence= ) { + clause.setPersistence(SelectIntoClause.Persistence.from( + (scope == null ? "" : scope.image + " ") + persistence.image)); + } ) - )* - + ] + [ + LOOKAHEAD( RelObjectName(), { isPostgreSqlSelectIntoDialect() }) + { clause.setTableKeyword(true); } + | + // TABLE is reserved in PostgreSQL, so that it never names the table there + LOOKAHEAD(, { isPostgreSqlDialect() }) + { clause.setTableKeyword(true); } + ] + table=Table() { clause.addTable(table); } + ( LOOKAHEAD(2) "," table=Table() { clause.addTable(table); } )* { - return updateSets; + requireSyntax(clause.getTables().size() == 1 || !isPostgreSqlDialect() + && clause.getPersistence() == null && !clause.isTableKeyword(), + "SELECT INTO creates a single table"); + linkAST(clause, first); + return clause; } } -List Partitions(): +/** Informix: INTO TEMP table at the end of the query. */ +SelectIntoClause TrailingIntoTempClause(): { - List partitions = new ArrayList(); - Column tableColumn; - Expression valueExpression = null; + Table table; + Token first; } { - ( - ( - tableColumn=Column() [ "=" valueExpression=Expression() ] - { partitions.add( new Partition (tableColumn, valueExpression)); } - ) - ) - - ( - LOOKAHEAD(2) ( - "," - tableColumn=Column() { valueExpression = null; } [ "=" valueExpression=Expression() ] - { partitions.add( new Partition (tableColumn, valueExpression)); } - ) - )* - + first= table=Table() { - return partitions; + return linked(new SelectIntoClause(table) + .withPosition(SelectIntoClause.Position.TRAILING) + .withPersistence(SelectIntoClause.Persistence.TEMP), first); } } -InsertBulk InsertBulk(): +MySqlSelectIntoClause MySqlSelectIntoClause(MySqlSelectIntoClause.Position position): { - InsertBulk statement = new InsertBulk(); - Table table; - ColumnDefinition column; - InsertBulk.Option option; - Set kinds = EnumSet.noneOf(InsertBulk.Option.Kind.class); + MySqlSelectIntoClause intoClause = new MySqlSelectIntoClause().withPosition(position); + Token first = getToken(1); + Token token; + ExpressionList variables = new ExpressionList(); + UserVariable variable; } { - AccessKeyword("BULK") table=Table() { statement.setTable(table); } - "(" column=InsertBulkColumn() { statement.getColumns().add(column); } - ( "," column=InsertBulkColumn() { statement.getColumns().add(column); } )* ")" - // LOOKAHEAD(2) is required, not cosmetic: Statements() permits two statements to be - // adjacent without a separator, so FIRST(SingleStatement) -- including -- is in - // the FOLLOW set of every statement tail. `WITH (` cannot start a CTE, so two tokens - // separate the INSERT BULK option list from a following WITH statement. - [ LOOKAHEAD(2) "(" option=InsertBulkOption() { - statement.getOptions().add(option); kinds.add(option.getKind()); - } - ( "," option=InsertBulkOption() { - requireDdlSyntax(kinds.add(option.getKind()), "Duplicate INSERT BULK option"); - statement.getOptions().add(option); - } )* ")" ] - { return statement; } + + ( + { intoClause.setType(MySqlSelectIntoClause.Type.OUTFILE); } + token= { intoClause.setFileName(stringValue(token)); } + MySqlSelectIntoOutfileTail(intoClause) + | + { intoClause.setType(MySqlSelectIntoClause.Type.DUMPFILE); } + token= { intoClause.setFileName(stringValue(token)); } + | + LOOKAHEAD({ isMySqlDialect() }) + variable=MySqlIntoVariable() { variables.add(variable); } + // Same shape as IntoClause() above: a PlainSelect can be followed by "," (subselect in + // an expression list), so the repetition needs two tokens to decide. + ( LOOKAHEAD(2) "," variable=MySqlIntoVariable() { variables.add(variable); } )* + { intoClause.setType(MySqlSelectIntoClause.Type.VARIABLES); intoClause.setVariables(linkElements(variables)); } + ) + { + linkAST(intoClause, first); + return intoClause; + } } -ColumnDefinition InsertBulkColumn(): +/** + * A MySQL user variable with one @ before its name, quoted or not, as SELECT ... INTO, + * EXPLAIN ... INTO, EXECUTE ... USING and PREPARE ... FROM take it. + */ +UserVariable MySqlIntoVariable(): { - String name; - String collation; - ColDataType type; - ColumnDefinition column; + UserVariable variable; + Token at; + Token name; } { - name=RelObjectName() type=ColDataType() { column = new ColumnDefinition(name, type); } - [ collation=RelObjectName() { column.setColumnSpecs(Arrays.asList("COLLATE", collation)); } ] - { return column; } + ( + variable=UserVariable() + | + at= (name= | name=) + { variable = new UserVariable("@" + name.image); linkAST(variable, at, name); } + ) + { return requireMySqlIntoVariable(variable); } } -InsertBulk.Option InsertBulkOption(): +MySqlProcedureAnalyse MySqlProcedureAnalyse(): { - String name; - Token value; - Column column; - Token direction; - OrderByElement order; - InsertBulk.Option option; + MySqlProcedureAnalyse procedureAnalyse = new MySqlProcedureAnalyse(); + Token maxElements = null; + Token maxMemory = null; + Token first = getToken(1); } { - ( - // RelObjectName() below accepts as an identifier (isReservedKeywordAsIdentifier() - // returns true for ORDER unless BY or SIBLINGS follows), so ORDER is a genuine common - // prefix of the first and the last alternative. The option form always has "(" after it. - LOOKAHEAD( "(") - { option = new InsertBulk.Option(InsertBulk.Option.Kind.ORDER); } - "(" column=Column() { - order = new OrderByElement().withExpression(column); - option.getOrderByElements().add(order); + "(" + [ + maxElements= + [ "," maxMemory= ] + ] + ")" + { + if (maxElements != null) { + procedureAnalyse.setMaxElements(new LongValue(maxElements.image)); + linkAST(procedureAnalyse.getMaxElements(), maxElements, maxElements); } - [ (direction= | direction=) { order.setAsc(direction.kind == K_ASC); order.setAscDescPresent(true); } ] - ( "," column=Column() { - order = new OrderByElement().withExpression(column); - option.getOrderByElements().add(order); - } - [ (direction= | direction=) { order.setAsc(direction.kind == K_ASC); order.setAscDescPresent(true); } ] - )* ")" - | - LOOKAHEAD({ isKeywordAhead("ROWS_PER_BATCH") }) AccessKeyword("ROWS_PER_BATCH") "=" value= - { option = new InsertBulk.Option(InsertBulk.Option.Kind.ROWS_PER_BATCH); option.setValue(new LongValue(value.image)); } - | - name=RelObjectName() { - option = new InsertBulk.Option(typeDdlEnum(InsertBulk.Option.Kind.class, name)); - requireDdlSyntax(option.getKind() != InsertBulk.Option.Kind.ORDER - && option.getKind() != InsertBulk.Option.Kind.ROWS_PER_BATCH, "Missing INSERT BULK option value"); + if (maxMemory != null) { + procedureAnalyse.setMaxMemory(new LongValue(maxMemory.image)); + linkAST(procedureAnalyse.getMaxMemory(), maxMemory, maxMemory); } - ) - { return option; } + linkAST(procedureAnalyse, first); + return procedureAnalyse; + } } -Insert InsertWithWithItems( List> withItems ): +/** + * The rest of INTO OUTFILE 'file_name': [CHARACTER SET charset_name] and the FIELDS and LINES + * clauses that LOAD DATA shares. + */ +void MySqlSelectIntoOutfileTail(MySqlSelectIntoClause intoClause): { - Insert insert; + Token token; + boolean charsetKeyword; + MySqlFileFormat fileFormat; } { - insert = Insert() { insert.setWithItemsList( withItems ); - return insert; -} + [ + LOOKAHEAD({ isMySqlCharacterSetClauseAhead() }) + charsetKeyword=MySqlCharacterSetKeyword() token=CharacterSetName() + { intoClause.setCharacterSet(token.image); intoClause.setUseCharsetKeyword(charsetKeyword); } + ] + [ + LOOKAHEAD(1, ( | | )) + fileFormat=MySqlFileFormat() { intoClause.setFileFormat(fileFormat); } + ] } -Insert Insert(): +FromItem ParenthesedFromItem(): { - Insert insert = new Insert(); - Table table = null; - List> with = null; - Column tableColumn = null; - ExpressionList columns = new ExpressionList(); - List partitions = new ArrayList(); - Expression exp = null; - ReturningClause returningClause; - Select select = null; - Token tk = null; - InsertModifierPriority modifierPriority = null; - boolean modifierIgnore = false; - - List updateSets; - List duplicateUpdateSets; + ParenthesedFromItem ParenthesedFromItem = new ParenthesedFromItem(); + FromItem fromItem; + List joins = null; +} +{ + "(" + fromItem = FromItem() + [ joins=JoinsList() ] + ")" - String name = null; - boolean useAs = false; - boolean useSet = false; - Alias rowAlias = null; - OutputClause outputClause = null; + { + return ParenthesedFromItem.withFromItem(fromItem).withJoins(joins); + } +} - InsertConflictTarget conflictTarget = null; - InsertConflictAction conflictAction = null; +FromItem FromItem() #FromItem: +{ + FromItem fromItem = null; + FromItem fromItem2 = null; + SampleClause sampleClause; + Pivot pivot = null; + UnPivot unpivot = null; + Alias alias = null; + List indexHints = null; + SQLServerHints sqlServerHints = null; + Select select; - InsertDuplicateAction duplicateAction = null; - Token multiInsertToken = null; - List oracleMultiInsertBranches = new ArrayList(); - OracleMultiInsertClause oracleMultiInsertClause = null; - OracleMultiInsertBranch oracleMultiInsertBranch = null; + String timeTravelStr = null; } { - { insert.setOracleHint(getOracleHint()); } + ( + LOOKAHEAD(3, { !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem = Values() + | + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("JSON_TABLE") + && getToken(2).kind == OPENING_BRACKET + }) fromItem=TableFunction() + | + LOOKAHEAD({ + getToken(1).kind == K_LATERAL + && getToken(2).kind == S_IDENTIFIER + && getToken(2).image.equalsIgnoreCase("JSON_TABLE") + && getToken(3).kind == OPENING_BRACKET + }) fromItem=TableFunction() + | + LOOKAHEAD({ + (getToken(1).kind == K_ROWS + && getToken(2).kind == K_FROM + && getToken(3).kind == OPENING_BRACKET) + || (isFunctionAhead() && getToken(1).kind != K_LATERAL) + || (getToken(1).kind == K_LATERAL && getToken(2).kind != OPENING_BRACKET) }) + fromItem=TableFunction() + | + LOOKAHEAD(3) fromItem=TableReference() + | + LOOKAHEAD({ isNestedSetOperationAhead() }) ( + fromItem=ParenthesedSelect() + [ LOOKAHEAD(2) pivot=Pivot() { fromItem.setPivot(pivot); } ] + [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] + ) + | + LOOKAHEAD({ isParenthesedFromItemAhead() }) fromItem = ParenthesedFromItem() + | + LOOKAHEAD(3, { !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) ( + fromItem=ParenthesedSelect() + [ LOOKAHEAD(2) pivot=Pivot() { fromItem.setPivot(pivot); } ] + [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] + ) + | + fromItem=LateralSubSelect() + | + LOOKAHEAD(2, { Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) fromItem=SubImport() { fromItem = new ParenthesedFromItem(fromItem); } + | + LOOKAHEAD({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem=Select() + ) + [ LOOKAHEAD({ !isMatchRecognizeAhead() && isAliasAhead() }) alias=Alias() { fromItem.setAlias(alias); } ] [ - LOOKAHEAD(2) (tk = | tk = | tk = ) - { - if (tk!=null) - modifierPriority = InsertModifierPriority.from(tk.image); - } + // BigQuery: UNNEST(array) AS alias WITH OFFSET AS offsetAlias + LOOKAHEAD(2, { fromItem instanceof TableFunction }) + { ((TableFunction) fromItem).setWithOffset(true); } + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() + { ((TableFunction) fromItem).setOffsetAlias(alias); } ] + ] + [ + LOOKAHEAD(2, {fromItem instanceof Table }) timeTravelStr = TimeTravelAfterAlias() + { ((Table) fromItem).setTimeTravelStrAfterAlias(timeTravelStr); } ] - [ LOOKAHEAD(2) { modifierIgnore = true; }] ( - LOOKAHEAD(2, ( | ) ( | )) + LOOKAHEAD({ isMatchRecognizeAhead() }) fromItem=MatchRecognize(fromItem) + [ LOOKAHEAD(2) ( LOOKAHEAD(2) pivot=PivotXml() | pivot=Pivot() ) { fromItem.setPivot(pivot); } ] + [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] + [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { fromItem.setAlias(alias); } ] + [ LOOKAHEAD(2) sampleClause=SampleClause() { fromItem.setSampleClause(sampleClause); } ] + | + [ LOOKAHEAD(2) sampleClause = SampleClause() { fromItem.setSampleClause(sampleClause); } ] + [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] + [ LOOKAHEAD(2) ( LOOKAHEAD(2) pivot=PivotXml() | pivot=Pivot() ) { fromItem.setPivot(pivot); } ] + ) + [ + LOOKAHEAD(2) ( - (multiInsertToken = | multiInsertToken = ) { - insert.setOracleMultiInsert(true); - insert.setOracleMultiInsertFirst(multiInsertToken.kind == K_FIRST); + indexHints = MySQLIndexHints() { + if (fromItem instanceof Table) + ((Table) fromItem).setIndexHints(indexHints); } - ( - { - oracleMultiInsertBranch = new OracleMultiInsertBranch(); - } - oracleMultiInsertClause = OracleMultiInsertClause() { - oracleMultiInsertBranch.addClause(oracleMultiInsertClause); - table = oracleMultiInsertClause.getTable(); - } - ( - oracleMultiInsertClause = OracleMultiInsertClause() { - oracleMultiInsertBranch.addClause(oracleMultiInsertClause); - } - )* - { - oracleMultiInsertBranches.add(oracleMultiInsertBranch); - } - | - ( - ( - oracleMultiInsertBranch = OracleMultiInsertWhenBranch() { - if (table == null && !oracleMultiInsertBranch.getClauses().isEmpty()) { - table = oracleMultiInsertBranch.getClauses().get(0).getTable(); - } - oracleMultiInsertBranches.add(oracleMultiInsertBranch); - } - )+ - [ - oracleMultiInsertBranch = OracleMultiInsertElseBranch() { - if (table == null && !oracleMultiInsertBranch.getClauses().isEmpty()) { - table = oracleMultiInsertBranch.getClauses().get(0).getTable(); - } - oracleMultiInsertBranches.add(oracleMultiInsertBranch); - } - ] - ) - ) - select = Select() { - insert.setOracleMultiInsertBranches(oracleMultiInsertBranches); + | + sqlServerHints = SQLServerHints() { + if (fromItem instanceof Table) + ((Table) fromItem).setSqlServerHints(sqlServerHints); } ) - | - ( - [ LOOKAHEAD(2) ( - { insert.setOverwrite(true); insert.setTableKeyword(true); } - | [ LOOKAHEAD(2) { insert.setTableKeyword(true); }] - ) - ] table=TableReference() - [ LOOKAHEAD(2) "(" partitions=Partitions() ")" ] - - [ LOOKAHEAD({ isAliasAhead() && !isColumnMatchingAhead() - && !(getToken(1).kind == K_OVERRIDING - && (getToken(2).kind == K_SYSTEM || getToken(2).kind == K_USER)) }) - [ { useAs = true; } ] name=RelObjectName() { table.setAlias(new Alias(name,useAs)); }] - - [ LOOKAHEAD(2) "(" columns=ColumnList() ")" ] - - // DuckDB: INSERT INTO tbl BY NAME|POSITION SELECT ... - [ - LOOKAHEAD({ isColumnMatchingAhead() }) - - ( - { insert.setColumnMatching(Insert.ColumnMatching.BY_NAME); } - | - // POSITION is lexed as a string-function name - - { insert.setColumnMatching(Insert.ColumnMatching.BY_POSITION); } - ) - ] - - [ LOOKAHEAD(2) - ( { insert.setOverridingMode(Insert.OverridingMode.SYSTEM); } - | { insert.setOverridingMode(Insert.OverridingMode.USER); } ) ] - - [ outputClause = OutputClause() { insert.setOutputClause(outputClause); } ] - - ( - { insert.setOnlyDefaultValues(true); } - | - ( - updateSets = UpdateSets() { insert.withSetUpdateSets(updateSets); useSet = true; } - ) - | - select = Select() - ) - - [ LOOKAHEAD({ isAliasAhead() && (select instanceof Values || useSet) }) rowAlias = Alias() { - if (select instanceof Values) { - select.setAlias(rowAlias); - } else { - insert.setRowAlias(rowAlias); - } - } ] + ] + { + linkAST(fromItem,jjtThis); + return fromItem; + } +} - [ LOOKAHEAD(2) - duplicateAction = InsertDuplicateAction() { insert.setDuplicateAction(duplicateAction); } - ] +MatchRecognize MatchRecognize(FromItem input) #MatchRecognize: +{ + MatchRecognize result = new MatchRecognize(input); + ExpressionList partition; + List ordering; + List> measures; + MatchRecognize.Definition definition; + MatchRecognize.Subset subset; + RowPattern pattern; + MatchRecognize.Options options = null; + String variable; + Token value; +} +{ + ContextualKeyword("MATCH_RECOGNIZE") "(" + [ partition=SimpleExpressionList() { result.setPartitionBy(partition); } ] + [ LOOKAHEAD(2) ordering=OrderByElements() { result.setOrderByElements(ordering); } ] + [ LOOKAHEAD({ isKeywordAhead("MEASURES") }) ContextualKeyword("MEASURES") measures=SelectItemsList() + { + for (SelectItem measure : measures) { + if (measure.getAlias() == null) { throw new ParseException("MATCH_RECOGNIZE measures require an alias"); } + } + result.setMeasures(measures); + } + ] + [ + LOOKAHEAD({ isKeywordAhead("ONE") || getToken(1).kind == K_ALL }) + ( LOOKAHEAD({ isKeywordAhead("ONE") }) ContextualKeyword("ONE") ContextualKeyword("PER") + { result.setRowsPerMatch(MatchRecognize.RowsPerMatch.ONE); } + | ContextualKeyword("PER") + { result.setRowsPerMatch(MatchRecognize.RowsPerMatch.ALL); } [ - - [ conflictTarget = InsertConflictTarget() ] - conflictAction = InsertConflictAction() { insert.withConflictTarget(conflictTarget).setConflictAction(conflictAction); } - ] - - [ returningClause = ReturningClause() { insert.setReturningClause(returningClause); } ] + ContextualKeyword("MATCHES") + { result.setEmptyMatchMode(MatchRecognize.EmptyMatchMode.SHOW); } + | LOOKAHEAD({ isKeywordAhead("OMIT") }) ContextualKeyword("OMIT") ContextualKeyword("MATCHES") + { result.setEmptyMatchMode(MatchRecognize.EmptyMatchMode.OMIT); } + | ContextualKeyword("UNMATCHED") + { result.setEmptyMatchMode(MatchRecognize.EmptyMatchMode.WITH_UNMATCHED); } + ] ) - ) - + ] + [ LOOKAHEAD({ isKeywordAhead("AFTER") }) ContextualKeyword("AFTER") + ( LOOKAHEAD({ isKeywordAhead("PAST") }) ContextualKeyword("PAST") + { result.setSkipMode(MatchRecognize.SkipMode.PAST_LAST_ROW); } + | + ( LOOKAHEAD(2) { result.setSkipMode(MatchRecognize.SkipMode.TO_NEXT_ROW); } + | { result.setSkipMode(MatchRecognize.SkipMode.TO_VARIABLE); } + [ LOOKAHEAD({ (getToken(1).kind == K_FIRST || getToken(1).kind == K_LAST) + && !("PATTERN".equalsIgnoreCase(getToken(2).image) && getToken(3).kind == OPENING_BRACKET) }) + ( { result.setSkipMode(MatchRecognize.SkipMode.TO_FIRST); } + | { result.setSkipMode(MatchRecognize.SkipMode.TO_LAST); } ) ] + variable=RelObjectName() { result.setSkipVariable(variable); } + ) + ) + ] + ContextualKeyword("PATTERN") "(" pattern=RowPattern(0) ")" { result.setPattern(pattern); } + [ LOOKAHEAD({ isKeywordAhead("SUBSET") }) ContextualKeyword("SUBSET") subset=MatchRecognizeSubset() + { result.getSubsets().add(subset); } + ( LOOKAHEAD(2) "," subset=MatchRecognizeSubset() { result.getSubsets().add(subset); } )* + ] + ContextualKeyword("DEFINE") definition=MatchRecognizeDefinition() { result.getDefinitions().add(definition); } + ( LOOKAHEAD(2) "," definition=MatchRecognizeDefinition() { result.getDefinitions().add(definition); } )* + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) ContextualKeyword("OPTIONS") "(" + { options = new MatchRecognize.Options(); } + [ LOOKAHEAD({ isKeywordAhead("use_longest_match") }) ContextualKeyword("use_longest_match") "=" + ( value= | value= ) { options.setUseLongestMatch(value.kind == K_TRUE); } + ] + ")" { result.setOptions(options); } + ] + ")" { - if (!columns.isEmpty()) { - insert.setColumns(columns); - } - if (!partitions.isEmpty()) { - insert.setPartitions(partitions); + if (Dialect.BIGQUERY.name().equals(getAsString(Feature.dialect))) { + if (result.getOrderByElements().isEmpty() || result.getMeasures().isEmpty()) { + throw new ParseException("BigQuery MATCH_RECOGNIZE requires ORDER BY and MEASURES"); + } + if (result.getRowsPerMatch() != null || result.getSkipVariable() != null || !result.getSubsets().isEmpty()) { + throw new ParseException("BigQuery does not support ROWS PER MATCH, SKIP TO a variable or SUBSET"); + } } - return insert.withWithItemsList(with) - .withSelect(select) - .withTable(table) - .withModifierPriority(modifierPriority) - .withModifierIgnore(modifierIgnore); + linkAST(result, jjtThis); return result; } } -OracleMultiInsertClause OracleMultiInsertClause(): +MatchRecognize.Subset MatchRecognizeSubset() #MatchRecognizeSubset: { - OracleMultiInsertClause clause = new OracleMultiInsertClause(); - Table clauseTable = null; - ExpressionList clauseColumns = new ExpressionList(); - Select clauseSelect = null; + String name; + String variable; + List variables = new ArrayList(); } { - clauseTable=Table() - [ LOOKAHEAD(2) "(" clauseColumns=ColumnList() ")" ] - clauseSelect = Select() + name=RelObjectName() "=" "(" variable=RelObjectName() { variables.add(variable); } + ( "," variable=RelObjectName() { variables.add(variable); } )* ")" { - if (!clauseColumns.isEmpty()) { - clause.setColumns(clauseColumns); - } - return clause.withTable(clauseTable).withSelect(clauseSelect); + MatchRecognize.Subset result = new MatchRecognize.Subset(name, variables); + linkAST(result, jjtThis); return result; } } -OracleMultiInsertBranch OracleMultiInsertWhenBranch(): +MatchRecognize.Definition MatchRecognizeDefinition() #MatchRecognizeDefinition: { - Expression whenExpression = null; - List clauses = null; + String name; + Expression expression; } { - whenExpression = Expression() - clauses = OracleMultiInsertClauseList() + name=RelObjectName() expression=Expression() { - return new OracleMultiInsertBranch() - .withWhenExpression(whenExpression) - .withClauses(clauses); + MatchRecognize.Definition result = new MatchRecognize.Definition(name, expression); + linkAST(result, jjtThis); + return result; } } -OracleMultiInsertBranch OracleMultiInsertElseBranch(): +RowPattern RowPattern(int depth) #RowPattern: { - List clauses = null; + List alternatives = new ArrayList(); + RowPattern pattern; + Token separator; } { - - clauses = OracleMultiInsertClauseList() { - return new OracleMultiInsertBranch() - .withElseClause(true) - .withClauses(clauses); + if (depth > getAsLong(Feature.allowedNestingDepth)) { + throw new ParseException("Row pattern exceeds the allowed nesting depth"); + } + } + ( + LOOKAHEAD({ Dialect.SNOWFLAKE.name().equals(getAsString(Feature.dialect)) }) + pattern=SnowflakeRowPatternSequence(depth) { alternatives.add(pattern); } + | + pattern=RowPatternSequence(depth) { alternatives.add(pattern); } + ( ( separator= | separator= ) + { if (separator.kind == OP_CONCAT) { alternatives.add(new RowPattern.Empty()); } } + pattern=RowPatternSequence(depth) { alternatives.add(pattern); } + )* + ) + { + RowPattern result = alternatives.size() == 1 ? alternatives.get(0) + : new RowPattern.Operation(RowPattern.Operation.Type.ALTERNATION, alternatives); + linkAST(result, jjtThis); + return result; } } -List OracleMultiInsertClauseList(): +RowPattern SnowflakeRowPatternSequence(int depth) #SnowflakeRowPatternSequence: { - List clauses = new ArrayList(); - OracleMultiInsertClause clause = null; + List patterns = new ArrayList(); + RowPattern pattern; } { - clause = OracleMultiInsertClause() { - clauses.add(clause); - } - ( - clause = OracleMultiInsertClause() { - clauses.add(clause); - } - )* + ( LOOKAHEAD({ isRowPatternPrimaryAhead() }) pattern=SnowflakeRowPatternAlternative(depth) { patterns.add(pattern); } )* { - return clauses; + RowPattern result = patterns.isEmpty() ? new RowPattern.Empty() + : patterns.size() == 1 ? patterns.get(0) + : new RowPattern.Operation(RowPattern.Operation.Type.SEQUENCE, patterns); + linkAST(result, jjtThis); return result; } } -InsertConflictTarget InsertConflictTarget(): +RowPattern SnowflakeRowPatternAlternative(int depth) #SnowflakeRowPatternAlternative: { - InsertConflictTarget target = new InsertConflictTarget(); - List elements = new ArrayList(); - Index.ColumnParams element; - Expression whereExpression; - String constraintName; + List patterns = new ArrayList(); + RowPattern pattern; } { - ( - "(" element=InsertConflictIndexElement() { elements.add(element); } - ( "," element=InsertConflictIndexElement() { elements.add(element); } )* ")" - { target.setIndexElements(elements); } - [ whereExpression=WhereClause() { target.setWhereExpression(whereExpression); } ] - | - constraintName=RelObjectNameExt() - { target.setConstraintName(constraintName); } - ) - { return target; } + pattern=RowPatternFactor(depth) { patterns.add(pattern); } + ( pattern=RowPatternFactor(depth) { patterns.add(pattern); } )* + { + RowPattern result = patterns.size() == 1 ? patterns.get(0) + : new RowPattern.Operation(RowPattern.Operation.Type.ALTERNATION, patterns); + linkAST(result, jjtThis); return result; + } } -Index.ColumnParams InsertConflictIndexElement(): +RowPattern RowPatternSequence(int depth): { - Index.ColumnParams element; - String name; - Expression expression; - ObjectNames collation; - ObjectNames operatorClass; + List patterns = new ArrayList(); + RowPattern pattern; + Token first = getToken(1); } { - ( - LOOKAHEAD({ isFunctionAhead() }) expression=Function() - { element = new Index.ColumnParams(expression).withExpressionParenthesized(false); } - | name=RelObjectNameExt() { element = new Index.ColumnParams(name); } - | "(" expression=Expression() ")" { element = new Index.ColumnParams(expression); } - ) - [ LOOKAHEAD(2) collation=RelObjectNames() - { element.setCollation(createTable(collation.getNames()).getFullyQualifiedName()); } ] - [ LOOKAHEAD(2) operatorClass=RelObjectNames() { element.setOperatorClass(createTable(operatorClass.getNames()).getFullyQualifiedName()); } ] - { return element; } + ( LOOKAHEAD({ isRowPatternPrimaryAhead() }) pattern=RowPatternFactor(depth) { patterns.add(pattern); } )* + { + if (patterns.isEmpty()) { return new RowPattern.Empty(); } + if (patterns.size() == 1) { return patterns.get(0); } + RowPattern result = new RowPattern.Operation(RowPattern.Operation.Type.SEQUENCE, patterns); + linkAST(result, first); + return result; + } } -InsertConflictAction InsertConflictAction(): +RowPattern RowPatternFactor(int depth) #RowPatternFactor: { - InsertConflictAction conflictAction; - Expression whereExpression = null; - List updateSets; + RowPattern pattern; + String name; + List permutations = new ArrayList(); + Token first = getToken(1); } { ( - LOOKAHEAD(2) ( - { conflictAction = new InsertConflictAction( ConflictActionType.DO_NOTHING ); } - ) - | - ( - { conflictAction = new InsertConflictAction( ConflictActionType.DO_UPDATE ); } - updateSets = UpdateSets() { conflictAction.setUpdateSets(updateSets); } - [ whereExpression = WhereClause() ] - ) + LOOKAHEAD({ isKeywordAhead("PERMUTE") && getToken(2).kind == OPENING_BRACKET }) + ContextualKeyword("PERMUTE") "(" + pattern=RowPattern(depth + 1) { permutations.add(pattern); } + ( "," pattern=RowPattern(depth + 1) { permutations.add(pattern); } )* ")" + { pattern = new RowPattern.Permute(permutations); } + | "{" "-" pattern=RowPattern(depth + 1) "-" "}" { pattern = new RowPattern.Exclusion(pattern); } + | { pattern = new RowPattern.Anchor(RowPattern.Anchor.Type.START); } + | LOOKAHEAD({ "$".equals(getToken(1).image) }) + { pattern = new RowPattern.Anchor(RowPattern.Anchor.Type.END); } + | "(" pattern=RowPattern(depth + 1) ")" { pattern = new RowPattern.Group(pattern); } + | name=RelObjectName() { pattern = new RowPattern.Variable(name); } ) - - { return conflictAction - .withWhereExpression(whereExpression); } + { + if (Dialect.BIGQUERY.name().equals(getAsString(Feature.dialect)) + && (pattern instanceof RowPattern.Permute || pattern instanceof RowPattern.Exclusion)) { + throw new ParseException("BigQuery does not support PERMUTE or row pattern exclusion"); + } + } + [ LOOKAHEAD({ !(pattern instanceof RowPattern.Anchor) + && ("?".equals(getToken(1).image) || "*".equals(getToken(1).image) + || "+".equals(getToken(1).image) || getToken(1).kind == OPENING_CURLY_BRACKET) }) + { linkAST(pattern, first); } + pattern=RowPatternQuantifier(pattern) + ] + { linkAST(pattern, jjtThis); return pattern; } } -InsertDuplicateAction InsertDuplicateAction(): +RowPattern RowPatternQuantifier(RowPattern pattern) #RowPatternQuantifier: { - InsertDuplicateAction duplicateAction; - Expression whereExpression = null; - List updateSets; + RowPattern.Quantified result; + Expression lower = null; + Expression upper = null; + boolean range = false; } { ( - LOOKAHEAD(2) ( - { duplicateAction = new InsertDuplicateAction( ConflictActionType.NOTHING ); } - ) - | - ( - { duplicateAction = new InsertDuplicateAction( ConflictActionType.DO_UPDATE ); } - updateSets = UpdateSets() { duplicateAction.setUpdateSets(updateSets); } - [ whereExpression = WhereClause() ] - ) + "*" { result = new RowPattern.Quantified(pattern, RowPattern.Quantified.Type.ZERO_OR_MORE); } + | "+" { result = new RowPattern.Quantified(pattern, RowPattern.Quantified.Type.ONE_OR_MORE); } + | "?" { result = new RowPattern.Quantified(pattern, RowPattern.Quantified.Type.OPTIONAL); } + | "{" [ LOOKAHEAD({ !",".equals(getToken(1).image) }) lower=RowPatternBound() ] + [ "," { range = true; } [ LOOKAHEAD({ getToken(1).kind != CLOSING_CURLY_BRACKET }) upper=RowPatternBound() ] ] "}" + { + if (lower == null && upper == null) { throw new ParseException("Row pattern quantifier requires a bound"); } + result = new RowPattern.Quantified(pattern, range ? RowPattern.Quantified.Type.RANGE : RowPattern.Quantified.Type.EXACT) + .setLowerBound(lower).setUpperBound(upper); + } ) - - { return duplicateAction - .withWhereExpression(whereExpression); } + [ LOOKAHEAD({ (result.getType() != RowPattern.Quantified.Type.EXACT + || !Dialect.BIGQUERY.name().equals(getAsString(Feature.dialect))) && "?".equals(getToken(1).image) }) "?" { result.setReluctant(true); } ] + { linkAST(result, jjtThis); return result; } } - -OutputClause OutputClause(): +Expression RowPatternBound(): { - List> selectItemList = null; - UserVariable tableVariable = null; - Table outputTable = null; - List columnList = null; + Token value; + Expression result; + Token first = getToken(1); } { - - selectItemList = SelectItemsList() - [ - ( - tableVariable = UserVariable() - | - outputTable = Table() - ) - [ - LOOKAHEAD(2) columnList = ColumnsNamesList() - ] - ] + ( value= { result = new LongValue(value.image); } + | "?" { result = new JdbcParameter(++jdbcParameterIndex, false, "?"); } + | result=UserVariable() + ) + { linkASTIfMissing(result, first); return result; } +} +List JoinsList(): +{ + List joinsList = new ArrayList(); + Join join = null; +} +{ + ( LOOKAHEAD(2) join=JoinerExpression() { joinsList.add(join); } )+ { - return new OutputClause(selectItemList, tableVariable, outputTable, columnList); + return joinsList; } } -Upsert Upsert(): +JoinHint JoinHint(): { - Upsert upsert = new Upsert(); - Table table = null; - ExpressionList columns; - List updateSets; - - Select select = null; - List duplicateUpdateSets; - InsertDuplicateAction duplicateAction = null; - Token tk = null; + Token token; } { ( - { upsert.setUpsertType(UpsertType.UPSERT); } + token = | - { upsert.setUpsertType(UpsertType.REPLACE); } + token = | - ( - { upsert.setUpsertType(UpsertType.INSERT_OR_REPLACE); } - ) - ) - [ LOOKAHEAD(2) { upsert.setUsingInto(true); } ] - - table=Table() { upsert.setTable(table); } - - [ LOOKAHEAD(2) columns = ParenthesedColumnList() { upsert.setColumns(columns); } ] - ( - ( - - updateSets = UpdateSets() { upsert.setUpdateSets(updateSets); } - ) + token = | - ( - select = Select() { upsert.setSelect(select); } - ) + token = ) - - [ - - duplicateAction = InsertDuplicateAction() { upsert.setDuplicateAction(duplicateAction); } - ] - { - return upsert; + return new JoinHint(token.image); } } -Delete DeleteWithWithItems( List> withItems ): +JoinHint DorisJoinHint(): { - Delete delete; + Token token; } { - delete = Delete() { delete.setWithItemsList( withItems ); - return delete; -} + "[" + ( + LOOKAHEAD({ isKeywordAhead("SHUFFLE") }) token= + | + LOOKAHEAD({ isKeywordAhead("BROADCAST") }) token= + ) + "]" + { return new JoinHint(token.image, JoinHint.Position.AFTER_JOIN); } } -Delete Delete(): +Join JoinerExpression() #JoinerExpression: { - Delete delete = new Delete(); - Table table = null; - ForPortionClause forPortionClause; - List
tables = new ArrayList
(); - List> with = null; - FromItem usingFromItem = null; - List usingFromItemList = new ArrayList(); - List joins = null; - Expression where = null; - PreferringClause preferringClause = null; - Limit limit = null; - OptionClause optionClause = null; - List orderByElements; - boolean hasFrom = false; + Join join = new Join(); + FromItem right = null; + Expression onExpression = null; + Column tableColumn; + List columns = null; + KSQLJoinWindow joinWindow = null; + JoinHint joinHint = null; Token tk = null; - DeleteModifierPriority modifierPriority = null; - boolean modifierIgnore = false; - boolean modifierQuick = false; - - ReturningClause returningClause; - OutputClause outputClause; -} -{ - { delete.setOracleHint(getOracleHint()); } - [ LOOKAHEAD(2) { modifierPriority = DeleteModifierPriority.LOW_PRIORITY; }] - [ LOOKAHEAD(2) { modifierQuick = true; }] - [ LOOKAHEAD(2) { modifierIgnore = true; }] - [LOOKAHEAD(4) (table=TableWithAlias() { tables.add(table); } - ("," table=TableWithAlias() { tables.add(table); } )* - [ outputClause = OutputClause() {delete.setOutputClause(outputClause); } ] - | ) { hasFrom = true; }] - - [ LOOKAHEAD(3) table=TableWithAlias() - [ forPortionClause=ForPortionClause() { delete.setForPortionClause(forPortionClause); } ] - [ LOOKAHEAD(2) joins=JoinsList() ] ] - [ usingFromItem=FromItem() { usingFromItemList.add(usingFromItem); } - ("," usingFromItem=FromItem() { usingFromItemList.add(usingFromItem); } )*] - [where=WhereClause() { delete.setWhere(where); } ] - [preferringClause=PreferringClause() { delete.setPreferringClause(preferringClause);} ] - [orderByElements = OrderByElements() { delete.setOrderByElements(orderByElements); } ] - [limit=PlainLimit() {delete.setLimit(limit); } ] - [ LOOKAHEAD(2) optionClause = OptionClause() { delete.setOption(optionClause); } ] - - [ returningClause = ReturningClause() { delete.setReturningClause(returningClause); } ] - { - if (joins != null && joins.size() > 0) { - delete.setJoins(joins); - } - return delete.withWithItemsList(with) - .withTables(tables) - .withTable(table) - .withHasFrom(hasFrom) - .withUsingFromItemList(usingFromItemList) - .withModifierPriority(modifierPriority) - .withModifierIgnore(modifierIgnore) - .withModifierQuick(modifierQuick); - } -} - -Statement Merge( List> with ) : { - Merge merge = new Merge(); - Table table; - FromItem fromItem; - Expression condition; - List operations; - OutputClause outputClause; - ReturningClause returningClause; - OptionClause optionClause = null; + String usingAlias; } { - { merge.setOracleHint(getOracleHint()); } table=TableWithAlias() { merge.setTable(table); } - fromItem = FromItem() { merge.setFromItem(fromItem); } - condition = Expression() { merge.setOnCondition(condition); } - - operations = MergeOperations() { merge.setOperations(operations); } - - [ returningClause = ReturningClause() { merge.setReturningClause(returningClause); } ] - - [ outputClause = OutputClause() { merge.setOutputClause(outputClause); } ] + [ LOOKAHEAD({ isAsOfJoinAhead() }) { join.setAsOf(true); } ] + [ { join.setGlobal(true); } ] + [ { join.setAny(true); } | { join.setAll(true); } ] + [ { join.setNatural(true); } ] - [ LOOKAHEAD(2) optionClause = OptionClause() { merge.setOption(optionClause); } ] + [ + ( + { join.setLeft(true); } [ { join.setSemi(true); } | { join.setAnti(true); } | { join.setOuter(true); } | { join.setAny(true); } | { join.setAll(true); } ] + | + ( + { join.setRight(true); } + | + { join.setFull(true); } + ) [ { join.setSemi(true); } | { join.setAnti(true); } | { join.setOuter(true); } | { join.setAny(true); } | { join.setAll(true); } ] + | + { join.setInner(true); } + | + // DuckDB allows SEMI/ANTI without a LEFT prefix + LOOKAHEAD({ isSemiAntiJoinAhead() }) + ( { join.setSemi(true); } | { join.setAnti(true); } ) + ) + | + { join.setCross(true); } + | + { join.setOuter(true); } + ] - { return merge.withWithItemsList(with); } -} + [ { join.setArray(true); } ] -List MergeOperations() : { - List operationsList = new ArrayList(); - MergeOperation operation; -} -{ ( - LOOKAHEAD(2) operation = MergeWhenMatched() { operationsList.add(operation); } + ( + [ joinHint=JoinHint() {join.setJoinHint(joinHint); } ] + + [ LOOKAHEAD("[", { Dialect.DORIS.name().equals(getAsString(Feature.dialect)) }) + { + if (joinHint != null) { + throw new ParseException("Only one join hint is allowed per JOIN"); + } + } + joinHint=DorisJoinHint() { join.setJoinHint(joinHint); } + ] + [ { join.setFetch(true); } ] + ) | - operation = MergeWhenNotMatched() { operationsList.add(operation); } - )* - { return operationsList; } + "," { join.setSimple(true); } ( { join.setOuter(true); } )? + | + { join.setStraight(true); } + | + {join.setApply(true); } + ) + + right=FromItem() + + // DuckDB 2.0: JOIN products APPROX NEAREST 2 BY SIMILARITY array_cosine_similarity(...) + [ + LOOKAHEAD({ isApproxNearestAhead() }) + tk= { join.setApproxNearest(Long.valueOf(tk.image)); } + onExpression=Expression() { join.setSimilarity(onExpression); } + ] + [ + LOOKAHEAD(2) ( + [ joinWindow = KSQLJoinWindowClause() {join.setJoinWindow(joinWindow);} ] + ( onExpression=Expression() { join.addOnExpression(onExpression); } + ( LOOKAHEAD({ getToken(1).kind == K_ON && !isInsertOnConflictAhead() }) onExpression=Expression() { join.addOnExpression(onExpression); } )* + ) + | + ( + "(" tableColumn=Column() { columns = new ArrayList(); columns.add(tableColumn); } + ( "," tableColumn=Column() { columns.add(tableColumn); } ) * + ")" { join.setUsingColumns(columns); } + // PostgreSQL join_using_alias: a qualified join only, AS is required + [ LOOKAHEAD(2) usingAlias=RelObjectName() { + requireSyntax(!join.isNatural() && !join.isCross() + && !join.isSimple() && hasUnqualifiedColumns(columns), + "An alias of the USING columns requires a qualified join" + + " and plain column names"); + join.setUsingAlias(new Alias(usingAlias, true)); + } ] + ) + ) + ] + { + linkAST(join,jjtThis); + join.setFromItem(right); + return join; + } + } -MergeOperation MergeWhenMatched() : { - Expression predicate = null; - MergeOperation operation; +/** Shared duration parsing for JOIN, aggregation windows, and grace periods. */ +KSQLWindow.Duration KSQLDuration(): +{ + Token value; + Token unit; } { - - [ predicate = Expression() ] - - ( - operation = MergeDeleteClause(predicate) | operation = MergeUpdateClause(predicate) - ) - { return operation; } + value= ( unit= | unit= ) + { return new KSQLWindow.Duration(Long.parseLong(value.image), KSQLWindow.TimeUnit.from(unit.image)); } } -MergeOperation MergeDeleteClause(Expression predicate) : { - MergeDelete md = new MergeDelete().withAndPredicate(predicate); +KSQLWindow.Duration KSQLGracePeriod(): +{ + KSQLWindow.Duration duration; } { - { return md; } + AccessKeyword("GRACE") AccessKeyword("PERIOD") duration=KSQLDuration() + { return duration; } } -MergeOperation MergeUpdateClause(Expression predicate) : { - MergeUpdate mu = new MergeUpdate().withAndPredicate(predicate); - List updateSets; - Expression condition; +KSQLJoinWindow KSQLJoinWindowClause(): +{ + KSQLJoinWindow window; + KSQLWindow.Duration duration; } { - updateSets = UpdateSets() { mu.setUpdateSets(updateSets); } - [ condition = Expression() { mu.setWhereCondition(condition); }] - [ LOOKAHEAD(2) condition = Expression() { mu.setDeleteWhereCondition(condition); } ] - { return mu; } + ( + "(" window=JoinWindow() ")" + | + duration=KSQLDuration() { + window = new KSQLJoinWindow().withDuration(duration.getValue()) + .withTimeUnit(duration.getTimeUnit()).withUsingBrackets(false); + } + ) + [ LOOKAHEAD({ isKeywordAhead("GRACE") }) duration=KSQLGracePeriod() { window.setGracePeriod(duration); } ] + { return window; } } -MergeInsert MergeInsertClause(Expression predicate) : { - MergeInsert mi = new MergeInsert(); - ExpressionList columns; - ExpressionList expList; - Expression condition; +KSQLJoinWindow JoinWindow(): +{ + KSQLJoinWindow window = new KSQLJoinWindow(); + KSQLWindow.Duration before; + KSQLWindow.Duration after = null; } { - - [ "(" columns = ColumnList() ")" - { - mi.setColumns( new ParenthesedExpressionList(columns) ); - } - ] - "(" expList = SimpleExpressionList() ")" - { - mi.setValues( new ParenthesedExpressionList(expList) ); - } - - [ condition = Expression() { mi.setWhereCondition(condition); } ] - + before=KSQLDuration() + [ "," after=KSQLDuration() ] { - mi.setAndPredicate(predicate); - return mi; + if (after == null) { + window.setDuration(before.getValue()); + window.setTimeUnit(before.getTimeUnit()); + } else { + window.setBeforeDuration(before.getValue()); + window.setBeforeTimeUnit(before.getTimeUnit()); + window.setAfterDuration(after.getValue()); + window.setAfterTimeUnit(after.getTimeUnit()); + window.setBeforeAfterWindow(true); + } + return window; } } -MergeOperation MergeWhenNotMatched() : { - MergeOperation operation; - Expression predicate = null; - MergeSide side = null; - Token sideToken; +KSQLWindow KSQLWindowClause(): +{ + KSQLWindow window = new KSQLWindow(); + KSQLWindow.Duration size; + KSQLWindow.Duration advance; + KSQLWindow.Duration grace; } { - - [ sideToken = { - side = MergeSide.fromImage(sideToken.image); - } ] - [ predicate = Expression() ] - + ( - operation = MergeInsertClause(predicate) { ((MergeInsert) operation).setSide(side); } + "(" size=KSQLDuration() + "," advance=KSQLDuration() { + window.setHoppingWindow(true); + window.setAdvanceDuration(advance.getValue()); + window.setAdvanceTimeUnit(advance.getTimeUnit()); + } | - operation = MergeUpdateClause(predicate) { ((MergeUpdate) operation).setSide(side); } + "(" size=KSQLDuration() { window.setSessionWindow(true); } | - operation = MergeDeleteClause(predicate) { ((MergeDelete) operation).setSide(side); } + "(" size=KSQLDuration() { window.setTumblingWindow(true); } ) - { return MergeSide.validatePairing(side, operation); } + [ "," grace=KSQLGracePeriod() { window.setGracePeriod(grace); } ] + ")" + { + window.setSizeDuration(size.getValue()); + window.setSizeTimeUnit(size.getTimeUnit()); + return window; + } } -// table names seem to allow ":" delimiters, e.g. for Informix see #1134 -ObjectNames RelObjectNames() : { - String token = null; - Token delimiter = null; - List data = new ArrayList(); - List delimiters = new ArrayList(); -} { - token = RelObjectName() { data.add(token); } - ( - LOOKAHEAD (2) ( - ( delimiter = "..." { delimiters.add("."); data.add(null); delimiters.add("."); data.add(null); delimiters.add("."); } ) - | - ( delimiter = ".." { delimiters.add("."); data.add(null); delimiters.add("."); } ) - | - ( ( delimiter = "." | delimiter = ":" ) { delimiters.add(delimiter.image); } ) - ) - - token = RelObjectNameExt() { data.add(token); } - ) * - - { return new ObjectNames(data, delimiters); } +Expression WhereClause(): +{ + Expression retval = null; } - -// column names do not allow ":" delimeters as those represent JSON `GET` operators -ObjectNames ColumnIdentifier() : { - String token = null; - Token delimiter = null; - List data = new ArrayList(); - List delimiters = new ArrayList(); -} { - token = RelObjectName() { data.add(token); } - ( - LOOKAHEAD (2) ( - ( delimiter = "..." { delimiters.add("."); data.add(null); delimiters.add("."); data.add(null); delimiters.add("."); } ) - | - ( delimiter = ".." { delimiters.add("."); data.add(null); delimiters.add("."); } ) - | - ( delimiter = "." { delimiters.add(delimiter.image); } ) - ) - - token = RelObjectNameExt() { data.add(token); } - ) * - - { return new ObjectNames(data, delimiters); } +{ + retval=Expression() + { return retval; } } -// See: http://technet.microsoft.com/en-us/library/ms187879%28v=sql.105%29.aspx -Column Column() #Column : +Expression PreWhereClause(): { - ObjectNames data = null; - ArrayConstructor arrayConstructor = null; - Token tk = null; + Expression retval = null; } { - data = ColumnIdentifier() - [ LOOKAHEAD(2) tk= ] - // @todo: we better should return a SEQUENCE instead of a COLUMN - [ LOOKAHEAD(2) "." { data.getNames().add("nextval"); } ] + retval=Expression() + { return retval; } +} - [ LOOKAHEAD(2) arrayConstructor = ArrayConstructor(false) ] +OracleHierarchicalExpression OracleHierarchicalQueryClause(): +{ + OracleHierarchicalExpression result = new OracleHierarchicalExpression(); + Expression expr; + Token first = getToken(1); +} +{ + ( + ( + expr=XorExpression() {result.setStartExpression(expr);} + [ { result.setNoCycle(true); } ] expr=XorExpression() + { + result.setConnectExpression(expr); + } + ) + | + ( + [ { result.setNoCycle(true); } ] expr=XorExpression() + { + result.setConnectExpression(expr); + result.setConnectFirst(true); + } + [ LOOKAHEAD(2) expr=XorExpression() {result.setStartExpression(expr);} ] + ) + ) { - Column col = createColumn(data.getNames(), data.getDelimiters()); - if (tk != null) { col.withCommentText(tk.image); } - if (arrayConstructor!=null) { - col.setArrayConstructor(arrayConstructor); - } - linkAST(col,jjtThis); - return col; + linkAST(result, first); + return result; } } -/* - * Unified identifier production for SQL object names. - * - * Accepts base identifier tokens (S_IDENTIFIER, S_QUOTED_IDENTIFIER, DATA_TYPE, - * date literals), any non-reserved keyword, and — guarded by the semantic - * check isReservedKeywordAsIdentifier() — reserved keywords that can serve as - * unquoted identifiers in the current parser position. - * - * NOTE: K_FROM, K_SELECT, and K_CURRENT are deliberately NOT included here - * to avoid FIRST-set pollution in JavaCC's choice resolution. They are only - * valid as identifiers in dotted-name continuations (after '.'), named - * parameters (after ':'), index columns, constraint names, and similar - * restricted contexts. Those call sites add the three tokens inline. - */ -String RelObjectName() : -{ Token tk = null; String result = null; } +PreferringClause PreferringClause(): { - ( - /* ── Base identifier tokens ─────────────────────────────────────── */ - tk= - | tk= - | tk= - | tk= - | tk= - - /* ── Non-reserved keywords (range-guarded) ──────────────────────── */ - | LOOKAHEAD({ getToken(1).kind >= MIN_NON_RESERVED_WORD - && getToken(1).kind <= MAX_NON_RESERVED_WORD }) - result = NonReservedWord() + Expression result = null; +} +{ + + result=PreferenceTerm() - /* ── Reserved keywords usable as identifiers (context-guarded) ─── */ - | LOOKAHEAD({ isReservedKeywordAsIdentifier() }) - ( tk= | tk= | tk= | tk= - | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= ) - ) - { return result != null ? result : tk.image; } + { + PreferringClause preferring = new PreferringClause(result); + return preferring; + } } -/* - * Extended version of RelObjectName that additionally accepts FROM, SELECT, - * and CURRENT as unquoted identifiers. - * - * These three tokens are kept OUT of RelObjectName() to avoid polluting - * JavaCC's FIRST-set computation (which would cause choice conflicts in - * expression parsing, subselect detection, etc.). - * - * Used only in specific contexts where the old grammar's RelObjectNameExt2 - * was called: dotted-name continuations, index/constraint names, type names, - * named-parameter identifier chains, and join table references. - */ -String RelObjectNameExt() : -{ Token tk = null; String result = null; } +Expression PreferenceTerm(): { - ( result = RelObjectName() | tk= | tk= | tk= ) - { return tk != null ? tk.image : result; } + Expression retval = null; +} +{ + // recursively build preferenceterm inside Plus + // like Expression -> XorExpression -> OrExpression -> ... + + retval=Plus() + + { + return retval; + } } -Table Table() #TableName : +Expression Plus(): { - //String serverName = null, databaseName = null, schemaName = null, tableName = null; - ObjectNames data = null; - Token fileNameToken = null; - Table table; - String timeTravelStr = null; + Expression left, right, result; } { + left=PriorTo() { result = left; } ( - data = RelObjectNames() [ LOOKAHEAD(2) timeTravelStr = TimeTravelBeforeAlias() ] - { - table = createTable(data.getNames()); - table.setTimeTravel(timeTravelStr); - } - | - fileNameToken = + LOOKAHEAD(2) + + right=PriorTo() { - // don't split name parts - table = new Table(fileNameToken.image, false); + result = new Plus(left, right); + left = result; } - ) - + )* { - linkAST(table,jjtThis); - return table; + return result; } } -/** A table source or DML target; catalog-only DDL continues to use Table(). */ -Table TableReference() #void : +Expression PriorTo(): { - Table table; + Expression left, right, result; + Token first = getToken(1); + Token open; } { - ( table=TableVariable() | table=Table() ) - { return table; } + ( + LOOKAHEAD(3) left=PreferenceTermTerminal() + | + open="(" left=PreferenceTerm() ")" { left = new ParenthesedExpressionList(left); linkAST(left, open); } + ) + { result = left; } + + ( + LOOKAHEAD(2) + ( + LOOKAHEAD(3) right=PreferenceTermTerminal() + | + open="(" right=PreferenceTerm() ")" { left = new ParenthesedExpressionList(right); linkAST(left, open); } + ) + { + result = new PriorTo(left, right); + linkAST(result, first); + left = result; + } + )* + { + return result; + } } -Table TableVariable() #TableName : +Expression PreferenceTermTerminal(): { - Token variable; - Table table; + Expression retval; } { - variable= + ( + LOOKAHEAD(2) retval=HighExpression() + | + LOOKAHEAD(2) retval=LowExpression() + | + LOOKAHEAD(2) retval=Inverse() + | + retval=Condition() + ) + { - requireAccessSyntax(!variable.image.startsWith("@@"), - "A table variable must be a local variable"); - table = new Table(variable.image, false).withTableVariable(true); - linkAST(table, jjtThis); - return table; + return retval; } } -Table TableWithAlias(): +Expression HighExpression() #HighExpression: { - Table table = null; - Alias alias = null; - SQLServerHints sqlServerHints; + Expression result; } { - table=TableReference() - [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { table.setAlias(alias); }] - [ LOOKAHEAD( "(") sqlServerHints=SQLServerHints() { table.setSqlServerHints(sqlServerHints); } ] - { return table; } + + result=Expression() + + { + HighExpression high = new HighExpression(result); + linkAST(high,jjtThis); + return high; + } } -Table TableWithAliasAndMysqlIndexHint(): +Expression LowExpression() #LowExpression: { - Table table = null; - MySQLIndexHint indexHint = null; + Expression result; } { - table=TableWithAlias() - [ LOOKAHEAD(2) indexHint=MySQLIndexHint() { table.setHint(indexHint); } ] - { return table; } + + result=Expression() + + { + LowExpression low = new LowExpression(result); + linkAST(low,jjtThis); + return low; + } } -Number Number(): +Expression Inverse() #Inverse: { - Token token; - Number number; + Expression result; } { - ( - token = { number = Double.valueOf(token.image); } - | - token = { number = Long.valueOf(token.image); } - ) + + "(" result=PreferenceTerm() ")" { - return number; + Inverse inverse = new Inverse(result); + linkAST(inverse,jjtThis); + return inverse; } } -SampleClause SampleClause(): +GroupByElement GroupByColumnReferences(): { + Expression columnReference; + GroupByElement groupBy = new GroupByElement(); + Expression expr; + ExpressionList list; Token token; - SampleClause sampleClause; - String keyword; - String method=null; - Number percentageArgument; - String percentageUnit = null; - boolean argumentInBrackets = true; - Number offsetArgument = null; - Number repeatArgument=null; - Number seedArgument=null; - boolean methodInBrackets = false; } { + + // PostgreSQL: GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] + [ LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_ALL || getToken(1).kind == K_DISTINCT) }) + ( { groupBy.setAll(true); } | { groupBy.setDistinct(true); } ) + ] ( - ( - // Oracle - token= { keyword = token.image; } - [ token= { method = token.image; } ] - ) - | - ( - // SQL:2016 compliant - token = { keyword = token.image; } - ( token = | token = ) { method = token.image; } + LOOKAHEAD(2) ( + + "(" + list = GroupingSet() { groupBy.addGroupingSet(list); } + ( LOOKAHEAD(2) "," list = GroupingSet() { groupBy.addGroupingSet(list); })* + ")" ) | ( - // Duck DB: the method is optional and may follow the sample size instead - { keyword = "USING SAMPLE"; } - [ - LOOKAHEAD({ isSampleMethod(getToken(1)) }) - ( token = | token = | token = ) - { method = token.image; } - ] - ) - ) - - ( - "(" percentageArgument = Number() - [ - "%" { percentageUnit="%"; } - | - { percentageUnit="PERCENT"; } - | - { percentageUnit="ROWS"; } - ] - ")" - - [ LOOKAHEAD(2) "(" repeatArgument = Number() ")" ] - - [ LOOKAHEAD(2) "(" seedArgument = Number() ")" ] - | - percentageArgument = Number() { argumentInBrackets = false; } - // greedy: a unit directly after the sample size always belongs to the clause - [ - LOOKAHEAD(1) ( - "%" { percentageUnit="%"; } - | - { percentageUnit="PERCENT"; } + LOOKAHEAD({ getAsBoolean(Feature.allowLegacyMySqlGroupBy) + && "MYSQL".equals(getAsString(Feature.dialect)) }) + LegacyMySqlGroupByExpressions(groupBy) | - { percentageUnit="ROWS"; } + list = ExpressionList() { groupBy.setGroupByExpressions(list); } ) - ] - [ LOOKAHEAD(2) offsetArgument = Number() ] + ( + LOOKAHEAD(2) + "(" + list = GroupingSet() { groupBy.addGroupingSet(list); } + ( LOOKAHEAD(2) "," list = GroupingSet() { groupBy.addGroupingSet(list); })* + ")" + )? + [ LOOKAHEAD(2) { groupBy.setMysqlWithRollup(true); } ] + ) ) - - // DuckDB: USING SAMPLE 10 PERCENT (bernoulli[, seed]) - [ - LOOKAHEAD({ method == null && getToken(1).kind == OPENING_BRACKET - && isSampleMethod(getToken(2)) }) - "(" ( token = | token = | token = ) - { method = token.image; methodInBrackets = true; } - [ "," seedArgument = Number() ] - ")" - ] - { - sampleClause = new SampleClause(keyword, method, percentageArgument, percentageUnit, repeatArgument, seedArgument); - sampleClause.setArgumentInBrackets(argumentInBrackets); - sampleClause.setMethodInBrackets(methodInBrackets); - sampleClause.setOffsetArgument(offsetArgument); - return sampleClause; + return groupBy; } } -Select SelectWithWithItems( List> withItems): +void LegacyMySqlGroupByExpressions(GroupByElement groupBy): +{} { - Select select; + LegacyMySqlGroupByExpression(groupBy) + ( LOOKAHEAD(2) "," LegacyMySqlGroupByExpression(groupBy) )* +} + +void LegacyMySqlGroupByExpression(GroupByElement groupBy): +{ + Expression expression; + Token direction; } { - select = Select() { select.setWithItemsList( withItems ); - return select; -} + expression = Expression() { groupBy.getGroupByExpressionList().add(expression); } + [ LOOKAHEAD(2) (direction= | direction=) { + groupBy.setGroupBySortDirection(groupBy.getGroupByExpressionList().size() - 1, + direction.kind == K_ASC ? GroupByElement.SortDirection.ASC + : GroupByElement.SortDirection.DESC); + } ] } -Select Select() #Select: +ExpressionList GroupingSet(): { - Select select = null; - List> with = null; - List orderByElements = null; - List interpolateElements = null; - OptionClause optionClause = null; - Limit limit = null; - Offset offset = null; - Fetch fetch = null; - WithIsolation withIsolation = null; - Alias alias = null; + ExpressionList list; + Expression expression; } { - [ with=WithList() ] ( - LOOKAHEAD({ isFromFirstSelectAhead() }) select = FromFirstSelect() - | - LOOKAHEAD(3) select = FromQuery() + LOOKAHEAD(2) list = ParenthesedExpressionList() | - ( - ( - LOOKAHEAD(2) select = PivotQuery() - | - LOOKAHEAD(2) select = UnPivotQuery() - | - LOOKAHEAD(3) select = PlainSelect() - | - LOOKAHEAD(3) select = Values() - | - LOOKAHEAD(3) select = ParenthesedSelect() [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() {select.setAlias(alias);} ] - ) - [ LOOKAHEAD(2) select = FromQueryFromSelect(select) ] - [ LOOKAHEAD(2) select = SetOperationList(select) ] - - [ LOOKAHEAD( ) orderByElements = OrderByElements() { select.setOrderByElements(orderByElements); } ] - [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { select.setInterpolate(interpolateElements); } ] - [ LOOKAHEAD(2, { !(select instanceof Values) }) optionClause = OptionClause() { select.setOption(optionClause); } ] - - [ LOOKAHEAD() limit=LimitWithOffset() {select.setLimit(limit);} ] - [ LOOKAHEAD() offset = Offset() { select.setOffset(offset);} ] - [ LOOKAHEAD() fetch = Fetch() { select.setFetch(fetch);} ] - [ LOOKAHEAD( ) withIsolation = WithIsolation() { select.setIsolation(withIsolation);} ] - ) + expression = SimpleExpression() { list = linkElements(new ExpressionList(expression)); } ) { - linkAST(select, jjtThis); - return select.withWithItemsList(with); + return list; } } -/** - * DuckDB's FROM-first query: FROM tbl [SELECT ...] [WHERE ...] [GROUP BY ...] [HAVING ...] - * [QUALIFY ...] [ORDER BY ...] [LIMIT ...] [OFFSET ...]. Without a SELECT clause all columns - * are returned. - */ -PlainSelect FromFirstSelect() #FromFirstSelect: +Expression Having(): { - PlainSelect plainSelect = new PlainSelect(); - List> selectItems = null; - FromItem fromItem; - List joins = null; - Expression where = null; - GroupByElement groupBy = null; Expression having = null; - Expression qualify = null; - List orderByElements = null; - Limit limit = null; - Offset offset = null; } { - fromItem=FromItem() - { - plainSelect.setFromItem(fromItem); - plainSelect.setFromFirst(true); - } - [ LOOKAHEAD(2) joins=JoinsList() { plainSelect.setJoins(joins); } ] - // greedy: a SELECT right after the FROM clause belongs to this query - [ - LOOKAHEAD(2) - - [ LOOKAHEAD(2) ( | { plainSelect.setDistinct(new Distinct()); } ) ] - selectItems=SelectItemsList() { plainSelect.setSelectItems(selectItems); } - ] - [ LOOKAHEAD(2) where=WhereClause() { plainSelect.setWhere(where); } ] - [ LOOKAHEAD(2) groupBy=GroupByColumnReferences() { plainSelect.setGroupByElement(groupBy); } ] - [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); } ] - [ LOOKAHEAD(2) qualify=Qualify() { plainSelect.setQualify(qualify); } ] - [ LOOKAHEAD( ) orderByElements=OrderByElements() - { plainSelect.setOrderByElements(orderByElements); } ] - [ LOOKAHEAD() limit=LimitWithOffset() { plainSelect.setLimit(limit); } ] - [ LOOKAHEAD() offset=Offset() { plainSelect.setOffset(offset); } ] + having=Expression() { - linkAST(plainSelect, jjtThis); - return plainSelect; + return having; } } -FromQuery FromQuery() #FromQuery: +Expression Qualify(): { - FromQuery fromQuery; - FromItem fromItem; - List lateralViews = null; - List joins = null; - PipeOperator pipeOperator; + Expression qualify = null; } { - fromItem = FromItem() { fromQuery = new FromQuery(fromItem); } - [ LOOKAHEAD(2) lateralViews=LateralViews() { fromQuery.setLateralViews(lateralViews); } ] - [ LOOKAHEAD(2) joins=JoinsList() { fromQuery.setJoins(joins); } ] - ( - LOOKAHEAD(2) "|>" pipeOperator = PipeOperator() { fromQuery.add(pipeOperator); } - )* - + qualify=Expression() { - return fromQuery; + return qualify; } } -FromQuery FromQueryFromSelect(Select select): +List OrderByElements(): { - FromQuery fromQuery; - FromItem fromItem; - PipeOperator pipeOperator; + List orderByList = new ArrayList(); + OrderByElement orderByElement = null; } { - "|>" pipeOperator = PipeOperator() - { - fromQuery = new FromQuery(select, false); - fromQuery.add(pipeOperator); - } - ( - LOOKAHEAD(2) "|>" pipeOperator = PipeOperator() - { fromQuery.add(pipeOperator); } - )* - + [ ] orderByElement=OrderByElement() { orderByList.add(orderByElement); } + ( LOOKAHEAD(2) "," orderByElement=OrderByElement() { orderByList.add(orderByElement); } )* { - return fromQuery; + return orderByList; } } -PipeOperator PipeOperator() #PipeOperator: +OrderByElement OrderByElement(): { - PipeOperator operator; + OrderByElement orderByElement = new OrderByElement(); + Expression columnReference = null; + Token collateToken = null; + WithFill withFill = null; + Token first = getToken(1); } { - ( - // SELECT covers also EXTEND, WINDOW and RENAME - operator = SelectPipeOperator() - | - operator = SetPipeOperator() - | - operator = DropPipeOperator() - | - LOOKAHEAD(2) operator = AsPipeOperator() - | - operator = WherePipeOperator() - | - operator = LimitPipeOperator() - | - LOOKAHEAD(2) operator = AggregatePipeOperator() - | - operator = OrderByPipeOperator() - | - // covers UNION, INTERSET, EXCEPT - operator = SetOperationPipeOperator() - | - operator = JoinPipeOperator() - | - operator = CallPipeOperator() - | - operator = TableSamplePipeOperator() - | - operator = PivotPipeOperator() - | - operator = UnPivotPipeOperator() - ) + columnReference = Expression() + [ LOOKAHEAD(1, ) (collateToken= | collateToken=) { columnReference = new CollateExpression(columnReference, collateToken.image); } ] + [ LOOKAHEAD(2) ( | ( { orderByElement.setAsc(false); } )) { orderByElement.setAscDescPresent(true); } ] + [ LOOKAHEAD(2) + [ LOOKAHEAD(2) ( + { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_FIRST); } + | + { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_LAST); } + ) + ] + ] + [ LOOKAHEAD(2) withFill = WithFill() { orderByElement.setWithFill(withFill); } ] + [ LOOKAHEAD(2) { orderByElement.setMysqlWithRollup(true); } ] { - return operator; + orderByElement.setExpression(columnReference); + linkAST(orderByElement, first); + return orderByElement; } } -SelectPipeOperator SelectPipeOperator(): +WithFill WithFill(): { - Token operatorKeyToken; - Token modifierToken = null; - SelectPipeOperator selectPipeOperator; - SelectItem selectItem; + WithFill withFill = new WithFill(); + Expression fillExpression = null; } { - ( - ( operatorKeyToken = [ LOOKAHEAD(2) ( modifierToken= | modifierToken= ) ] ) - | - operatorKeyToken = - | - operatorKeyToken = - | - operatorKeyToken = - ) - selectItem = SelectItem() - { selectPipeOperator = new SelectPipeOperator(operatorKeyToken.image, selectItem, modifierToken !=null ? modifierToken.image : null); } + + [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setFrom(fillExpression); } ] + [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setTo(fillExpression); } ] + [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setStep(fillExpression); } ] + [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setStaleness(fillExpression); } ] + { return withFill; } +} - ( LOOKAHEAD(2) "," selectItem = SelectItem() { selectPipeOperator.add(selectItem); } )* +List InterpolateClause(): +{ + List interpolateElements = new ArrayList(); + InterpolateElement interpolateElement = null; +} +{ + + [ LOOKAHEAD(2) "(" + [ interpolateElement = InterpolateElement() { interpolateElements.add(interpolateElement); } + ( "," interpolateElement = InterpolateElement() { interpolateElements.add(interpolateElement); } )* + ] + ")" ] + { return interpolateElements; } +} - { - return selectPipeOperator; - } +InterpolateElement InterpolateElement(): +{ + InterpolateElement interpolateElement = new InterpolateElement(); + Column column = null; + Expression expression = null; +} +{ + column = Column() { interpolateElement.setColumn(column); } + [ expression = Expression() { interpolateElement.setExpression(expression); } ] + { return interpolateElement; } } -WherePipeOperator WherePipeOperator(): +Expression OptionHintParameter(): { - WherePipeOperator wherePipeOperator; - Expression expression; + UserVariable userVariable = null; + Expression parameter = null; } { - expression = Expression() - { - wherePipeOperator = new WherePipeOperator(expression); - return wherePipeOperator; - } + ( + LOOKAHEAD({ getToken(1).kind == S_AT_IDENTIFIER && getToken(2).kind == K_UNKNOWN }) + userVariable = UserVariable() + { + return new Column(userVariable + " UNKNOWN"); + } + | + parameter = Expression() { return parameter; } + ) } -String OrderSuffix(): +OptionClause OptionClause(): { - Token token =null; - String orderSuffix = null; + OptionClause optionClause = new OptionClause(); + OptionHint optionHint = null; } { - ( token = | token = ) { orderSuffix = token.image; } - [ LOOKAHEAD(2) ( token = | token = ) { orderSuffix += " NULLS " + token.image; } ] - - { - return orderSuffix; - } + "(" optionHint = OptionHint() { optionClause.addOptionHint(optionHint); } + ( "," optionHint = OptionHint() { optionClause.addOptionHint(optionHint); } )* + ")" + { return optionClause; } } -AggregatePipeOperator AggregatePipeOperator(): +OptionHint OptionHint(): { - AggregatePipeOperator aggregatePipeOperator; - SelectItem selectItem; - Token token =null; - String orderSuffix = null; + OptionHint optionHint = new OptionHint(); + String name = null; + Expression value = null; + Expression parameter = null; } { - - selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] - { aggregatePipeOperator = new AggregatePipeOperator(selectItem, orderSuffix); orderSuffix=null; } - - ( LOOKAHEAD(2) "," selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] - { aggregatePipeOperator.add(selectItem, orderSuffix); orderSuffix=null; } )* - + name = OptionHintName() { optionHint.setName(name); } [ - LOOKAHEAD(2) [ { aggregatePipeOperator.setShorthandOrdering(true); } ] - selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] - { aggregatePipeOperator.addGroupItem(selectItem, orderSuffix); orderSuffix=null; } - ( - LOOKAHEAD(2) "," selectItem = SelectItem() [ LOOKAHEAD(2) orderSuffix = OrderSuffix() ] - { aggregatePipeOperator.addGroupItem(selectItem, orderSuffix); orderSuffix=null; } - )* + LOOKAHEAD(1, "=") "=" value = Expression() { optionHint.setValue(value); optionHint.setUseEquals(true); } + | + LOOKAHEAD(1, "(") "(" parameter = OptionHintParameter() { optionHint.addParameter(parameter); } + ( "," parameter = OptionHintParameter() { optionHint.addParameter(parameter); } )* + ")" + | + LOOKAHEAD({ isOptionHintValueAhead() }) value = Expression() { optionHint.setValue(value); } + ) ] - - { - return aggregatePipeOperator; - } + { return optionHint; } } -OrderByPipeOperator OrderByPipeOperator(): +String OptionHintName(): { - OrderByPipeOperator orderByPipeOperator; - List orderByElements; + Token tk = null; + String word = null; + StringBuilder name = new StringBuilder(); } { - orderByElements = OrderByElements() - { - orderByPipeOperator = new OrderByPipeOperator(orderByElements); - return orderByPipeOperator; - } + ( + LOOKAHEAD({ isOptionHintWordAhead() }) + ( tk= | word = NonReservedWord() + | tk= | tk= | tk= + | tk= | tk= | tk= + | tk= | tk= ) + { + if (name.length() > 0) { name.append(' '); } + name.append(tk != null ? tk.image : word); + tk = null; + word = null; + } + )+ + { return name.toString(); } } -AsPipeOperator AsPipeOperator(): -{ - AsPipeOperator asPipeOperator; - Alias alias; +JdbcParameter JdbcParameter() : { + Token tk; + JdbcParameter retval; } { - alias = Alias() - { - asPipeOperator = new AsPipeOperator( alias.withUseAs(true) ); - return asPipeOperator; - } + ( tk="?" | tk= ) + { retval = new JdbcParameter(++jdbcParameterIndex, false, tk.image); } + + [ LOOKAHEAD(2) token = { retval.setUseFixedIndex(true); retval.setIndex(Integer.valueOf(token.image)); } ] + + { return retval; } } -JoinPipeOperator JoinPipeOperator(): + +Limit LimitWithOffset() #LimitWithOffset: { - JoinPipeOperator joinPipeOperator; - Join join; + Limit limit = new Limit(); + Expression firstExpression; + Expression secondExpression; } { - join = JoinerExpression() + + { Token outerLimitPercentToken = limitPercentToken; } + try { + { limitPercentToken = findLimitPercentToken(); } + ( + LOOKAHEAD(3) firstExpression = ParenthesedSelect() + | + firstExpression = Expression() + ) + } finally { + limitPercentToken = outerLimitPercentToken; + } + ( + // MySQL: LIMIT offset, row_count + "," + secondExpression = Expression() + { + limit.setOffset(firstExpression); + limit.setRowCount(secondExpression); + } + | + // PostgreSQL: LIMIT row_count; DuckDB: LIMIT 10% or LIMIT 10 PERCENT + { + limit.setRowCount(firstExpression); + } + [ + LOOKAHEAD({ getToken(1).kind == K_PERCENT + || "%".equals(getToken(1).image) && isLimitClauseEnd(getToken(2)) }) + ( "%" { limit.setPercentUnit("%"); } | { limit.setPercentUnit("PERCENT"); } ) + ] + ) { - joinPipeOperator = new JoinPipeOperator(join); - return joinPipeOperator; + linkAST(limit, jjtThis); + return limit; } } -SetPipeOperator SetPipeOperator(): +Limit PlainLimit() #PlainLimit: { - SetPipeOperator setPipeOperator; - List updateSets; + Limit limit = new Limit(); + Expression rowCountExpression; } { - updateSets = UpdateSets() + // mysql-postgresql-> LIMIT (row_count | ALL | NULL) + + ( + LOOKAHEAD(3) rowCountExpression = ParenthesedSelect() + | + rowCountExpression = Expression() + ) { - setPipeOperator = new SetPipeOperator(updateSets); - return setPipeOperator; + limit.setRowCount(rowCountExpression); + linkAST(limit,jjtThis); + return limit; } } -DropPipeOperator DropPipeOperator(): +Offset Offset(): { - DropPipeOperator dropPipeOperator; - ExpressionList columns; + Offset offset = new Offset(); + Expression offsetExpression; } { - columns = ColumnList() + ( + // postgresql-> OFFSET offset + // sqlserver-oracle-> OFFSET offset (ROW | ROWS) + + offsetExpression=Expression() { offset.setOffset( offsetExpression ); } + + [ LOOKAHEAD(2) ( { offset.setOffsetParam("ROWS"); } | { offset.setOffsetParam("ROW"); })] + + ) { - dropPipeOperator = new DropPipeOperator(columns); - return dropPipeOperator; + return offset; } } -LimitPipeOperator LimitPipeOperator(): +Fetch Fetch(): { - LimitPipeOperator limitPipeOperator; + Fetch fetch = new Fetch(); + Token token = null; Expression expression; + List fetchParameters = new ArrayList(); } { - expression = Expression() { limitPipeOperator = new LimitPipeOperator(expression); } - [ LOOKAHEAD(2) expression = Expression() { limitPipeOperator.setOffsetExpression(expression); } ] + ( + LOOKAHEAD(3) ( + ( { fetch.setFetchParamFirst(true); } | ) + ( + { fetch.addFetchParameter("ROWS"); } + | + { fetch.addFetchParameter("ROW"); } + ) + ( + { fetch.addFetchParameter("ONLY"); } + | + { fetch.addFetchParameter("WITH TIES"); } + ) + ) + | + ( + ( { fetch.setFetchParamFirst(true); } | ) + + // Expression is optional according to https://www.h2database.com/html/commands.html#select + expression = Expression() { fetch.setExpression(expression); } + [ { fetch.addFetchParameter("PERCENT"); } ] + ( + ( + { fetch.addFetchParameter("ROWS"); } + | + { fetch.addFetchParameter("ROW"); } + ) + ( + { fetch.addFetchParameter("ONLY"); } + | + { fetch.addFetchParameter("WITH TIES"); } + ) + ) + ) + ) { - return limitPipeOperator; + return fetch; } } -// see https://manticore-projects.com/SQL2016Parser/syntax_snapshot.html#corresponding-spec -String SetOperationModifier(): +WithIsolation WithIsolation(): { - Token tk; - String modifier = ""; - String identifier; + WithIsolation withIsolation = new WithIsolation(); + Token token = null; + JdbcParameter jdbc; } { - ( - LOOKAHEAD(2) ( - [ ( tk= | tk="DISTINCT") { modifier+=tk.image; } ] - { modifier+= " BY NAME"; } - [ - LOOKAHEAD({ isKeywordAhead("MATCHING") }) - ContextualKeyword("MATCHING") { modifier+= " MATCHING"; } - "(" - identifier = RelObjectName() { modifier+="(" + identifier; } - ("," identifier = RelObjectName() { modifier+=", " + identifier; })* - ")" { modifier+=")"; } - ] - ) - | - ( - [ { modifier+= " STRICT"; } ] - { modifier+= " CORRESPONDING"; } - [ (tk= | tk="DISTINCT") { modifier+=tk.image; } ] - [ - { modifier+= " BY"; }[ (tk= | tk="DISTINCT") { modifier+=tk.image; } ] - "(" - identifier = RelObjectName() { modifier+="(" + identifier; } - ("," identifier = RelObjectName() { modifier+=", " + identifier;})* - ")" { modifier+=")"; } - ] - ) - | - ( tk= | tk= ) { modifier+=tk.image; } - ) + + token= + { withIsolation.setIsolation(token.image); + return withIsolation; + } +} + +OptimizeFor OptimizeFor(): +{ + Token token; + LongValue value; +} +{ + token= { - return modifier; + value = new LongValue(token.image); + return new OptimizeFor(value.getValue()); } } -SetOperationPipeOperator SetOperationPipeOperator(): +// according to http://technet.microsoft.com/en-us/library/ms189463.aspx +Top Top() #Top: { - SetOperationPipeOperator setOperationPipeOperator = null; - SetOperationType setOperationType; - String modifier = null; - ParenthesedSelect select; + Top top = new Top(); + Token token = null; + Expression expr = null; + JdbcParameter jdbc = null; } { + ( - ( - [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.UNION; } - select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType, modifier); } - ) + token= { top.setExpression(new LongValue(token.image)); } | - ( - [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.INTERSECT; } - select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType, modifier); } - ) + jdbc = JdbcParameter() { top.setExpression(jdbc); } | - ( - [ modifier=SetOperationModifier() ] { setOperationType = SetOperationType.EXCEPT; } - select = ParenthesedSelect() { setOperationPipeOperator = new SetOperationPipeOperator(select, setOperationType, modifier); } - ) + ":" { top.setExpression(new JdbcNamedParameter()); } + [ LOOKAHEAD(2) token = { ((JdbcNamedParameter)top.getExpression()).setName(token.image); } ] + | + "(" + expr=SimpleExpression() + { + top.setExpression(expr); + top.setParenthesis(true); + } + ")" ) - - ( - LOOKAHEAD(2) "," select = ParenthesedSelect() { setOperationPipeOperator.add(select); } - )* - + [ LOOKAHEAD(2) { top.setPercentage(true); } ] + [ LOOKAHEAD(2) { top.setWithTies(true); } ] { - return setOperationPipeOperator; + linkAST(top,jjtThis); + return top; } } -CallPipeOperator CallPipeOperator(): +// according to http://www-01.ibm.com/support/knowledgecenter/SSGU8G_12.1.0/com.ibm.sqls.doc/ids_sqs_0156.htm +Skip Skip(): { - TableFunction tableFunction; - Alias alias=null; + Skip skip = new Skip(); + Token token = null; + JdbcParameter jdbc; } { - tableFunction = TableFunction() [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] - + + ( + token= { skip.setRowCount(Long.parseLong(token.image)); } + | + token= { skip.setVariable(token.image); } + | + jdbc = JdbcParameter() { skip.setJdbcParameter(jdbc); } + ) { - return new CallPipeOperator(tableFunction, alias); + return skip; } } +JAVACODE +OracleHint getOracleHint() { + OracleHint hint = null; + Token tok = getToken(1); + // Retrieve first comment (if any) prior next token + if (tok.specialToken != null) { + tok = tok.specialToken; + while (tok.specialToken != null) tok = tok.specialToken; + // Check if it matches Hint pattern? + if (OracleHint.isHintMatch(tok.image)) { + hint = new OracleHint(); + hint.setComment(tok.image); + linkAST(hint, tok, tok); + } + } + return hint; +} -TableSamplePipeOperator TableSamplePipeOperator(): +First First(): { - Token token; + First first = new First(); + Token token = null; + JdbcParameter jdbc; } { - "(" ( token= | token= ) ")" + ( + { first.setKeyword(First.Keyword.FIRST); } + | + { first.setKeyword(First.Keyword.LIMIT); } + ) + ( + token= { first.setRowCount(Long.parseLong(token.image)); } + | + token= { first.setVariable(token.image); } + | + jdbc = JdbcParameter() { first.setJdbcParameter(jdbc); } + ) { - return new TableSamplePipeOperator( token.image ); + return first; } } -PivotPipeOperator PivotPipeOperator(): + +Expression Expression() #Expression : { - Function aggregateExpression; - Column inputColumn; - List> pivotColumns; - Alias alias = null; + Expression expression = null; + Token first; } { - "(" aggregateExpression=Function() - inputColumn=Column() - "(" pivotColumns = SelectItemsList() ")" - ")" - [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] + { first = getToken(1); } + expression=Condition() + { expression = prattExpressionRest(expression, first, 2); } { - return new PivotPipeOperator(aggregateExpression, inputColumn, pivotColumns, alias); + linkAST(expression,jjtThis); + return expression; } } -UnPivotPipeOperator UnPivotPipeOperator(): +Expression XorExpression(): { - Column valuesColumn; - Column nameColumn; - List> pivotColumns; - Alias alias = null; + Expression result; + Expression right; + Token first = getToken(1); } { - "(" valuesColumn=Column() - nameColumn=Column() - "(" pivotColumns = SelectItemsList() ")" - ")" - [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] - { - return new UnPivotPipeOperator(valuesColumn, nameColumn, pivotColumns, alias); - } + result=AndChain() + ( + LOOKAHEAD(2) + ( + right=AndChain() { result = new OrExpression(result, right); linkAST(result, first); } + | + right=AndChain() { result = new XorExpression(result, right); linkAST(result, first); } + ) + )* + { return result; } } -TableStatement TableStatement(): +/** AND — higher precedence than OR/XOR */ +Expression AndChain(): { - Table table = null; - List orderByElements = null; - Limit limit = null; - Offset offset = null; - TableStatement tableStatement = new TableStatement(); -}{ - - table = Table() - { tableStatement.setTable(table); } - [ LOOKAHEAD( ) orderByElements = OrderByElements() { tableStatement.setOrderByElements(orderByElements); } ] - [ LOOKAHEAD() limit = LimitWithOffset() { tableStatement.setLimit(limit);} ] - [ LOOKAHEAD() offset = Offset() { tableStatement.setOffset(offset);} ] - { return tableStatement; } - /* Support operationList */ + Expression result; + Expression right; + Token first = getToken(1); +} +{ + result=Condition() + ( + LOOKAHEAD(2) + ( + right=Condition() {{ + AndExpression a = new AndExpression(result, right); result = a; + linkAST(result, first); + }} + | + right=Condition() {{ + AndExpression a = new AndExpression(result, right); + a.setUseOperator(true); result = a; + linkAST(result, first); + }} + ) + )* + { return result; } } -ParenthesedSelect ParenthesedSelect() #ParenthesedSelect: +Expression Condition(): { - ParenthesedSelect parenthesedSelect = new ParenthesedSelect(); - Select select; + Expression result; + Expression left; + // Leading NOT / ! prefixes, leftmost token wraps outermost (issue #1170). + Deque notTokens = null; + int oraclePrior = EqualsTo.NO_ORACLE_PRIOR; + int oracleJoin = EqualsTo.NO_ORACLE_JOIN; + Token prior = null; } { - "(" - select = Select() - ")" - { - linkAST(parenthesedSelect,jjtThis); - return parenthesedSelect.withSelect(select); + ( + LOOKAHEAD({ getToken(1).kind == K_NOT || "!".equals(getToken(1).image) }) + ( | "!" ) + { + if (notTokens == null) { + notTokens = new ArrayDeque(); + } + notTokens.addFirst(getToken(0)); + } + )* + ( + LOOKAHEAD( JdbcNamedParameter() ":", { + getToken(1).kind == K_EXISTS && ":".equals(getToken(2).image) + && (ternaryThenBranchDepth > 0 || mapKeyDepth > 0) }) + result=ExistsExpression() + | + LOOKAHEAD(2, { !isExistsIdentifierAhead() }) + result=ExistsExpression() + | + // last alternative of the choice: entering it and letting the productions + // themselves reject is equivalent to scanning first, so skip the deep + // lookahead simulation (this path runs for every plain condition) + LOOKAHEAD({ !interrupted }) + // A choice rather than [...], so that enclosing syntactic lookaheads honour the guard + ( LOOKAHEAD({ isPriorOperatorAhead() }) { oraclePrior = EqualsTo.ORACLE_PRIOR_START; prior = getToken(0); } | {} ) + left=SimpleExpression() { result = left; } + + // Consume Oracle (+) once, before dispatching + [ + LOOKAHEAD("(" "+" ")", { getToken(1).kind == OPENING_BRACKET }) + "(" "+" ")" + { + oracleJoin = EqualsTo.ORACLE_JOIN_RIGHT; + if (left instanceof Column) { + ((Column) left).setOldOracleJoinSyntax(oracleJoin); widen(left, null, getToken(0)); + } + } + ] + + // Single guard: only enter if next token can start a condition suffix + [ + LOOKAHEAD({ isConditionSuffixAhead() }) + ( + LOOKAHEAD({ isComparisonOperatorAhead() }) + result = RegularConditionRHS(left, oracleJoin) + | LOOKAHEAD(2) result = OverlapsCondition(left) + | LOOKAHEAD(3) result=InExpression(left) + | LOOKAHEAD(3) result=ExcludesExpression(left) + | LOOKAHEAD(3) result=IncludesExpression(left) + | LOOKAHEAD(2) result=Between(left) + | LOOKAHEAD(2) result = MemberOfExpression(left) + | LOOKAHEAD({ isIsNormalizedAhead() }) result=IsNormalizedExpression(left) + | LOOKAHEAD(3) result=IsNullExpression(left) + | LOOKAHEAD(3) result=IsBooleanExpression(left) + | LOOKAHEAD(3) result=IsJsonExpression(left) + | LOOKAHEAD(3) result=IsUnknownExpression(left) + | LOOKAHEAD(2) result=LikeExpression(left) + | LOOKAHEAD(3) result=IsDistinctExpression(left) + | result=SimilarToExpression(left) + ) + // SQL:2016 6.39: a boolean test applies to any boolean primary, + // so postfix IS predicates chain onto a comparison or predicate + // result: "a > 0 IS TRUE", "a IS NULL IS NOT TRUE". + ( + LOOKAHEAD({ isPostfixIsTestAhead() }) + ( + LOOKAHEAD({ isIsNormalizedAhead() }) result=IsNormalizedExpression(result) + | LOOKAHEAD(3) result=IsBooleanExpression(result) + | LOOKAHEAD(3) result=IsUnknownExpression(result) + | LOOKAHEAD(3) result=IsNullExpression(result) + | LOOKAHEAD(3) result=IsJsonExpression(result) + ) + )* + ] + ) + { + if (oraclePrior == EqualsTo.ORACLE_PRIOR_START + && result instanceof SupportsOldOracleJoinSyntax) { + ((SupportsOldOracleJoinSyntax) result).setOraclePriorPosition(oraclePrior); + widen(result, prior, null); + } + while (notTokens != null && !notTokens.isEmpty()) { + Token notToken = notTokens.pollFirst(); + result = new NotExpression(result, "!".equals(notToken.image)); + linkAST(result, notToken); + } + return result; } } -ParenthesedInsert ParenthesedInsert() #ParenthesedInsert: +Expression RegularConditionRHS(Expression leftExpression, int oracleJoinRight) #RegularCondition: { - ParenthesedInsert parenthesedInsert = new ParenthesedInsert(); - Insert insert; + Expression result = null; + Expression rightExpression; + int oracleJoin = EqualsTo.NO_ORACLE_JOIN; + int oraclePrior = EqualsTo.NO_ORACLE_PRIOR; + Token token; } { - "(" - insert = Insert() - ")" + // Only consume (+) here if it wasn't already consumed by Condition + [ LOOKAHEAD("(" "+" ")") "(" "+" ")" { oracleJoin = EqualsTo.ORACLE_JOIN_RIGHT; } ] + + ( + LOOKAHEAD(2) + ">" { result = new GreaterThan(); } + | "<" { result = new MinorThan(); } + | "=" { result = new EqualsTo(); } + | "==" { result = new EqualsTo("=="); } + | token= { result = new GreaterThanEquals(token.image); } + | token= { result = new MinorThanEquals(token.image); } + | token= { result = new NotEqualsTo(token.image); } + | token= { result = new NotEqualsTo(token.image); } + | token= { result = new NotEqualsTo(token.image); } + | "*=" { result = new TSQLLeftJoin(); } + | "=*" { result = new TSQLRightJoin(); } + | token= { result = new DoubleAnd(); } + | token= { result = new Contains(); } + | token= { result = new ContainedBy(); } + | "@@" { result = new Matches(); } + | "~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASESENSITIVE); } + | "~*" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASEINSENSITIVE); } + | "!~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.NOT_MATCH_CASESENSITIVE); } + | "!~*" { result = new RegExpMatchOperator(RegExpMatchOperatorType.NOT_MATCH_CASEINSENSITIVE); } + | "@>" { result = new JsonOperator("@>"); } + | "<@" { result = new JsonOperator("<@"); } + | "?" { result = new JsonOperator("?"); } + | "?|" { result = new JsonOperator("?|"); } + | "?&" { result = new JsonOperator("?&"); } + | { result = new JsonOperator("||"); } + | "-" { result = new JsonOperator("-"); } + | "-#" { result = new JsonOperator("-#"); } + ) + + ( LOOKAHEAD({ isPriorOperatorAhead() }) rightExpression=ComparisonItem() { oraclePrior = EqualsTo.ORACLE_PRIOR_END; } + | rightExpression=ComparisonItem() ) + + [ LOOKAHEAD(2) "(" "+" ")" { oracleJoin = EqualsTo.ORACLE_JOIN_LEFT; } ] + { - return parenthesedInsert.withInsert(insert); + BinaryExpression regCond = (BinaryExpression) result; + regCond.setLeftExpression(leftExpression); + regCond.setRightExpression(rightExpression); + + if (oracleJoin > 0) + ((SupportsOldOracleJoinSyntax) result).setOldOracleJoinSyntax(oracleJoin); + + if (oraclePrior != EqualsTo.NO_ORACLE_PRIOR) + ((SupportsOldOracleJoinSyntax) result).setOraclePriorPosition(oraclePrior); } -} -ParenthesedUpdate ParenthesedUpdate() #ParenthesedUpdate: -{ - ParenthesedUpdate parenthesedUpdate = new ParenthesedUpdate(); - Update update; -} -{ - "(" - update = Update() - ")" { - return parenthesedUpdate.withUpdate(update); + linkAST(result, jjtThis, leftExpression); + return result; } } -ParenthesedDelete ParenthesedDelete() #ParenthesedDelete: +Expression OverlapsCondition(Expression leftExpression): { - ParenthesedDelete parenthesedDelete = new ParenthesedDelete(); - Delete delete; + ExpressionList right; + Token operator = getToken(1); } { - "(" - delete = Delete() - ")" + + right = ParenthesedExpressionList() { - return parenthesedDelete.withDelete(delete); + ExpressionList left; + if (leftExpression instanceof ExpressionList) { + left = (ExpressionList) leftExpression; + } else { + left = linkElements(new ExpressionList(leftExpression)); + } + OverlapsCondition result = new OverlapsCondition(left, right); + linkAST(result, firstToken(leftExpression, operator)); + return result; } } -LateralView LateralView() #LateralView: +Expression SQLCondition(): { - boolean useOuter = false; - Function generatorFunction = null; - String tableName = null; - String columnName = null; - Alias tableAlias = null; - Alias columnAlias = null; + Expression result; + Expression left; } { - [ { useOuter=true; } ] - generatorFunction = Function() - [ LOOKAHEAD(2) - tableName=RelObjectName() - { - tableAlias = new Alias(tableName, false); - } - ] - columnName = RelObjectName() { columnAlias = new Alias(columnName, true); } - - // Spark SQL supports multiple Alias Columns: https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select-lateral-view.html - // we simulate this by setting the alias name to null and then just adding the columns - [ - LOOKAHEAD(2) "," { columnAlias.setName(null); columnAlias.addAliasColumns( columnName); } - columnName = RelObjectName() { columnAlias.addAliasColumns( columnName); } - ( - LOOKAHEAD(2) "," columnName = RelObjectName() { columnAlias.addAliasColumns( columnName); } - )* - ] - { - return new LateralView( - useOuter - , generatorFunction - , tableAlias - , columnAlias - ); - } + ( + LOOKAHEAD( JdbcNamedParameter() ":", { + getToken(1).kind == K_EXISTS && ":".equals(getToken(2).image) + && (ternaryThenBranchDepth > 0 || mapKeyDepth > 0) }) + result=ExistsExpression() + | + LOOKAHEAD(2, { !isExistsIdentifierAhead() }) + result=ExistsExpression() + | + // last alternative of the choice: skip the redundant lookahead simulation + LOOKAHEAD({ !interrupted }) + left = SimpleExpression() { result = left; } + [ + LOOKAHEAD(2) ( + LOOKAHEAD({ getToken(1).kind == K_OVERLAPS }) result=OverlapsCondition(left) + | + LOOKAHEAD(3, {!interrupted}) result=InExpression(left) + | + LOOKAHEAD(3) result=ExcludesExpression(left) + | + LOOKAHEAD(3) result=IncludesExpression(left) + | + LOOKAHEAD(2) result=Between(left) + | + result = MemberOfExpression(left) + | + LOOKAHEAD({ isIsNormalizedAhead() }) result=IsNormalizedExpression(left) + | + LOOKAHEAD(3) result=IsNullExpression(left) + | + LOOKAHEAD(3) result=IsBooleanExpression(left) + | + LOOKAHEAD(3) result=IsJsonExpression(left) + | LOOKAHEAD(3) result=IsUnknownExpression(left) + | + LOOKAHEAD(2) result=LikeExpression(left) + | + LOOKAHEAD(3) result=IsDistinctExpression(left) + | + result=SimilarToExpression(left) + ) + ] + ) + { return result; } } -ForClause ForClause() #ForClause: +Expression InExpression(Expression leftExpression) #InExpression : { - Token token = null; - ForClause forClause = new ForClause(); + Token token; + int oldOracleJoin = 0; + boolean usingNot = false; + boolean usingGlobal = false; + Expression rightExpression; } { - + [ "(" "+" ")" { oldOracleJoin=EqualsTo.ORACLE_JOIN_RIGHT; } ] + + [ { usingGlobal=true; } ] + [ { usingNot=true; } ] + ( - token = + LOOKAHEAD(2) token= { rightExpression = stringValue(token); } | - token = - ( - ( - ( [ LOOKAHEAD(2) "(" ")" ] | ) - ( - LOOKAHEAD(2) "," - ( - - | - | [ LOOKAHEAD(2) "(" ")" ] - | - | [ LOOKAHEAD(2) "(" ")" ] - | [ LOOKAHEAD(2) ( | ) ] - ) - )* - ) - | - ( - - ( - LOOKAHEAD(2) "," - ( - - | - | [ LOOKAHEAD(2) "(" ")" ] - | - ) - )* - ) - | - ( - [ LOOKAHEAD(2) "(" ")" ] - ( - LOOKAHEAD(2) "," - ( - - | - | [ LOOKAHEAD(2) "(" ")" ] - | [ LOOKAHEAD(2) ( | ) ] - ) - )* - ) - ) + LOOKAHEAD({ isNestedSetOperationAhead() }) rightExpression = ParenthesedSelect() | - ( - token = ( | ) - ( - LOOKAHEAD(2) "," - ( - [ LOOKAHEAD(2) "(" ")" ] - | - | - ) - )* - ) + rightExpression = PrimaryExpression() ) { - forClause.setForOption(token.image); - linkAST(forClause,jjtThis); - return forClause; + InExpression inExpression = new InExpression(leftExpression, rightExpression) + .withOldOracleJoinSyntax(oldOracleJoin) + .withNot(usingNot) + .setGlobal(usingGlobal); + linkAST(inExpression, jjtThis, leftExpression); + return inExpression; } } - -List LateralViews(): +Expression IncludesExpression(Expression leftExpression) #IncludesExpression : { - ArrayList lateralViews = new ArrayList(); - LateralView lateralView = null; + Token token; + Expression rightExpression; } { - lateralView = LateralView() { lateralViews.add(lateralView); } - ( LOOKAHEAD(2) lateralView = LateralView() { lateralViews.add(lateralView); } )* - + (rightExpression = ParenthesedExpressionList()) { - return lateralViews; + IncludesExpression includesExpression = new IncludesExpression(leftExpression, rightExpression); + + linkAST(includesExpression, jjtThis, leftExpression); + return includesExpression; } } -LateralSubSelect LateralSubSelect() #LateralSubSelect: +Expression ExcludesExpression(Expression leftExpression) #ExcludesExpression : { - LateralSubSelect lateralSubSelect = new LateralSubSelect();; - Select select; + Token token; + Expression rightExpression; } { - "(" select = Select() ")" { lateralSubSelect.withSelect(select).setPrefix("LATERAL"); } + (rightExpression = ParenthesedExpressionList()) { - linkAST(lateralSubSelect,jjtThis); - return lateralSubSelect; + ExcludesExpression excludesExpression = new ExcludesExpression(leftExpression, rightExpression); + + linkAST(excludesExpression, jjtThis, leftExpression); + return excludesExpression; } } -PlainSelect PlainSelect() #PlainSelect: +Expression Between(Expression leftExpression) : { - PlainSelect plainSelect = new PlainSelect(); - List> selectItems = null; - FromItem fromItem = null; - List lateralViews = null; - List joins = null; - List> distinctOn = null; - Expression preWhere = null; - Expression where = null; - ForClause forClause = null; - OptionClause optionClause = null; - List orderByElements; - List interpolateElements = null; - GroupByElement groupBy = null; - Expression having = null; - Expression qualify; - Limit limitBy = null; - Limit limit = null; - Offset offset = null; - Fetch fetch = null; - WithIsolation withIsolation = null; - OptimizeFor optimize = null; - Top top = null; - Skip skip = null; - First first = null; - OracleHierarchicalExpression oracleHierarchicalQueryClause = null; - PreferringClause preferringClause = null; - ExpressionList expressionList = null; - boolean partitionByBrackets = false; - List
intoTables = null; - MySqlSelectIntoClause mySqlSelectIntoClause = null; - MySqlProcedureAnalyse mySqlProcedureAnalyse = null; - Table updateTable = null; - List
updateTables = new ArrayList
(); - Wait wait = null; - boolean mySqlSqlCalcFoundRows = false; - Token token; - KSQLWindow ksqlWindow = null; - boolean noWait = false; - String windowName = null; - WindowDefinition winDef; - Table intoTempTable = null; - List settings = null; - Distinct distinct; + Between result = new Between(); + Token operator = getToken(1); + Expression betweenExpressionStart = null; + Expression betweenExpressionEnd = null; } { - - - [ { plainSelect.setMySqlHintStraightJoin(true); } ] - - { plainSelect.setOracleHint(getOracleHint()); } - - [ LOOKAHEAD(2) skip = Skip() { plainSelect.setSkip(skip); } ] - - [ LOOKAHEAD(2) first = First() { plainSelect.setFirst(first); } ] - - // Redshift allows TOP before DISTINCT - // https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_list.html - // @Todo: reflect the order when de-parsing - [ LOOKAHEAD(2) top = Top() { plainSelect.setTop(top); } ] - - [ LOOKAHEAD(2) - ( - - | - ( - { distinct = new Distinct(); plainSelect.setDistinct(distinct); } - [ LOOKAHEAD(2) "ON" "(" distinctOn=SelectItemsList() { plainSelect.getDistinct().setOnSelectItems(distinctOn); } ")" ] - ) - | - { distinct = new Distinct(); distinct.setUseDistinctRow(true); plainSelect.setDistinct(distinct); } - | - { distinct = new Distinct(true); plainSelect.setDistinct(distinct); } - | - { plainSelect.setMySqlSqlCalcFoundRows(true); } - | - { plainSelect.setMySqlSqlCacheFlag(MySqlSqlCacheFlags.SQL_NO_CACHE); } - | - { plainSelect.setMySqlSqlCacheFlag(MySqlSqlCacheFlags.SQL_CACHE); } - ) - ] - - [ - + [ { result.setNot(true); }] + + [ + LOOKAHEAD(2) ( + { result.setUsingSymmetric(true); } + | + { result.setUsingAsymmetric(true); } + ) + ] ( - { plainSelect.setBigQuerySelectQualifier( PlainSelect.BigQuerySelectQualifier.AS_STRUCT ); } + LOOKAHEAD({ isParenthesedSelectAhead() }) betweenExpressionStart = ParenthesedSelect() | - { plainSelect.setBigQuerySelectQualifier( PlainSelect.BigQuerySelectQualifier.AS_VALUE ); } + betweenExpressionStart = SimpleExpression() + [ + LOOKAHEAD({ isComparisonOperatorAhead() }) + betweenExpressionStart = RegularConditionRHS(betweenExpressionStart, EqualsTo.NO_ORACLE_JOIN) + ] + [ + LOOKAHEAD("(" "+" ")") + "(" "+" ")" + { + if (betweenExpressionStart instanceof Column) { + ((Column) betweenExpressionStart).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); widen(betweenExpressionStart, null, getToken(0)); + } + } + ] ) - ] - [ LOOKAHEAD(2) top = Top() { plainSelect.setTop(top); } ] - - selectItems=SelectItemsList() - - [ LOOKAHEAD() + ( - LOOKAHEAD({ isMySqlSelectIntoAhead() }) - mySqlSelectIntoClause = MySqlSelectIntoClause(MySqlSelectIntoClause.Position.BEFORE_FROM) - { plainSelect.setMySqlSelectIntoClause(mySqlSelectIntoClause); } + LOOKAHEAD({ isParenthesedSelectAhead() }) betweenExpressionEnd = ParenthesedSelect() | - intoTables = IntoClause() { plainSelect.setIntoTables(intoTables); } + betweenExpressionEnd = SimpleExpression() + [ + LOOKAHEAD({ isComparisonOperatorAhead() }) + betweenExpressionEnd = RegularConditionRHS(betweenExpressionEnd, EqualsTo.NO_ORACLE_JOIN) + ] + [ + LOOKAHEAD("(" "+" ")") + "(" "+" ")" + { + if (betweenExpressionEnd instanceof Column) { + ((Column) betweenExpressionEnd).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); widen(betweenExpressionEnd, null, getToken(0)); + } + } + ] ) - ] - [ LOOKAHEAD(2) fromItem=FromItem() - [ LOOKAHEAD(2) lateralViews=LateralViews() ] - [ LOOKAHEAD(2) joins=JoinsList() ] - ] - [ LOOKAHEAD(3) { plainSelect.setUsingOnly(true); } fromItem=FromItem() - [ LOOKAHEAD(2) lateralViews=LateralViews() ] - [ LOOKAHEAD(2) joins=JoinsList() ] - ] - // Clickhouse FINAL as shown at https://clickhouse.com/docs/en/operations/settings/settings#final - [ LOOKAHEAD(2) { plainSelect.setUsingFinal(true); } ] + { + result.setLeftExpression(leftExpression); + result.setBetweenExpressionStart(betweenExpressionStart); + result.setBetweenExpressionEnd(betweenExpressionEnd); + linkAST(result, firstToken(leftExpression, operator)); + return result; + } +} - [ LOOKAHEAD(2) ksqlWindow=KSQLWindowClause() { plainSelect.setKsqlWindow(ksqlWindow); } ] - [ LOOKAHEAD(2) preWhere=PreWhereClause() { plainSelect.setPreWhere(preWhere); }] - [ LOOKAHEAD(2) where=WhereClause() { plainSelect.setWhere(where); }] - [ LOOKAHEAD(2) oracleHierarchicalQueryClause=OracleHierarchicalQueryClause() { plainSelect.setOracleHierarchical(oracleHierarchicalQueryClause); } ] - [ LOOKAHEAD(2) preferringClause=PreferringClause() { plainSelect.setPreferringClause(preferringClause); } - [LOOKAHEAD(2) - ( - LOOKAHEAD(2) expressionList=ComplexExpressionList() - | - "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" - ) - { - preferringClause.setPartitionExpressionList(expressionList, partitionByBrackets); - } - ] - ] - // Oracle supports "HAVING" before "GROUP BY", we will simply parse that but won't pay special attention to the order - [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); }] - [ LOOKAHEAD(2) groupBy=GroupByColumnReferences() { plainSelect.setGroupByElement(groupBy); }] - [ LOOKAHEAD(2) having=Having() { plainSelect.setHaving(having); }] - [ LOOKAHEAD(2) qualify=Qualify() {plainSelect.setQualify(qualify); }] - [ LOOKAHEAD( ) orderByElements = OrderByElements() { plainSelect.setOracleSiblings(true); plainSelect.setOrderByElements(orderByElements); } ] - [ LOOKAHEAD(2) - windowName = RelObjectName() winDef = windowDefinition() { List winDefs = new ArrayList(); winDefs.add(winDef.withWindowName(windowName)); } - ( LOOKAHEAD(2) "," windowName = RelObjectName() winDef = windowDefinition() { winDefs.add(winDef.withWindowName(windowName)); } )* - { plainSelect.setWindowDefinitions(winDefs); } - ] - [ LOOKAHEAD( ) orderByElements = OrderByElements() { plainSelect.setOrderByElements(orderByElements); } ] - [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { plainSelect.setInterpolate(interpolateElements); } ] - [ LOOKAHEAD(2) forClause = ForClause() {plainSelect.setForClause(forClause);} ] - [ LOOKAHEAD(2) optionClause = OptionClause() { plainSelect.setOption(optionClause); } ] - [ LOOKAHEAD(2) - ( { plainSelect.setEmitMode(PlainSelect.EmitMode.CHANGES); } - | { plainSelect.setEmitMode(PlainSelect.EmitMode.FINAL); } ) ] - // Parse the LIMIT row count once (this accepts a parenthesized subquery too), then - // optionally attach ClickHouse's `LIMIT ... BY ...`. Checking BY right after the limit - // expression avoids a numeric LOOKAHEAD, which cannot see past a long parenthesized - // subquery and would wrongly commit to LIMIT BY (issue #2359). - [ LOOKAHEAD() limit = LimitWithOffset() - [ LOOKAHEAD() expressionList = ExpressionList() { limit.setByExpressions(expressionList); } ] +Expression LikeExpression(Expression leftExpression) #LikeExpression: +{ + LikeExpression result = new LikeExpression(); + Expression rightExpression = null; + Expression escape; + Token token; +} +{ + ( + ( + token = "~~" | token = "~~*" | token = "~~~" | token = "!~~" | token = "!~~*" + ) { result.setLikeOperator(token.image); } + | + [ { result.setNot(true); } ] + ( + token = + | token = + | token = + | token = + | token = + | token = + | token = + | token = + | token = + | token = + | token = + | token = + ) { result.setLikeKeyWord( LikeExpression.KeyWord.from(token.image)); } + ) + [ LOOKAHEAD(2) {result.setUseBinary(true); } ] + rightExpression=SimpleExpression() + [ + LOOKAHEAD("(" "+" ")") + "(" "+" ")" { - if (limit.getByExpressions() != null) { - plainSelect.setLimitBy(limit); - } else { - plainSelect.setLimit(limit); + if (rightExpression instanceof Column) { + ((Column) rightExpression).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); widen(rightExpression, null, getToken(0)); } - } ] - [ LOOKAHEAD() offset = Offset() { plainSelect.setOffset(offset); } ] - [ LOOKAHEAD(, { limit==null }) limit = LimitWithOffset() { plainSelect.setLimit(limit); } ] - [ LOOKAHEAD( ) - mySqlProcedureAnalyse = MySqlProcedureAnalyse() - { plainSelect.setMySqlProcedureAnalyse(mySqlProcedureAnalyse); } - ] - [ LOOKAHEAD() fetch = Fetch() { plainSelect.setFetch(fetch); } ] - [ LOOKAHEAD( ) withIsolation = WithIsolation() { plainSelect.setIsolation(withIsolation); } ] - [ LOOKAHEAD(2) - - ( - { plainSelect.setForMode(ForMode.UPDATE); } - | { plainSelect.setForMode(ForMode.SHARE); } - | ( { plainSelect.setForMode(ForMode.NO_KEY_UPDATE); }) - | ( { plainSelect.setForMode(ForMode.KEY_SHARE); }) - | ( { plainSelect.setForMode(ForMode.READ_ONLY); }) - | ( { plainSelect.setForMode(ForMode.FETCH_ONLY); }) - ) - [ LOOKAHEAD(2) - updateTable = Table() { updateTables.add(updateTable); } - ( LOOKAHEAD(2) "," updateTable = Table() { updateTables.add(updateTable); } )* - { plainSelect.setForUpdateTables(updateTables); } - ] - [ LOOKAHEAD() wait = Wait() { plainSelect.setWait(wait); } ] - [ LOOKAHEAD(2) ( { plainSelect.setNoWait(true); } - | { plainSelect.setSkipLocked(true); }) ] - [ LOOKAHEAD( ) orderByElements = OrderByElements() - { plainSelect.setOrderByElements(orderByElements); plainSelect.setForUpdateBeforeOrderBy(true); } - ] - [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { plainSelect.setInterpolate(interpolateElements); } ] + } ] - [ LOOKAHEAD({ isMySqlSelectIntoAhead() }) + [ LOOKAHEAD(2) + ( + LOOKAHEAD(2) token = { result.setEscape( stringValue(token) ); } + | + escape=Expression() { result.setEscape(escape); } + ) + ] + { + result.setLeftExpression(leftExpression); + result.setRightExpression(rightExpression); + linkAST(result, jjtThis, leftExpression); + return result; + } +} + +Expression SimilarToExpression(Expression leftExpression) #SimilarToExpression: +{ + SimilarToExpression result = new SimilarToExpression(); + Expression rightExpression = null; +} +{ + [ { result.setNot(true); } ] + + rightExpression=SimpleExpression() + [ + LOOKAHEAD("(" "+" ")") + "(" "+" ")" { - if (mySqlSelectIntoClause != null || intoTables != null) { - throw new ParseException("Only one INTO clause is allowed per SELECT"); + if (rightExpression instanceof Column) { + ((Column) rightExpression).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); widen(rightExpression, null, getToken(0)); } } - mySqlSelectIntoClause = MySqlSelectIntoClause(MySqlSelectIntoClause.Position.TRAILING) - { plainSelect.setMySqlSelectIntoClause(mySqlSelectIntoClause); } ] - [ LOOKAHEAD(2) settings = UpdateSets() { plainSelect.setSettings(settings); } ] - [ LOOKAHEAD() optimize = OptimizeFor() { plainSelect.setOptimizeFor(optimize); } ] - [ LOOKAHEAD(3) intoTempTable = Table() { plainSelect.setIntoTempTable(intoTempTable);} ] - [ LOOKAHEAD(3) { plainSelect.setUseWithNoLog(true); } ] + [ LOOKAHEAD(2) token= { result.setEscape((stringValue(token)).getValue()); }] { - plainSelect.setSelectItems(selectItems); - plainSelect.setFromItem(fromItem); - if ( lateralViews!=null && lateralViews.size()>0 ) { - plainSelect.setLateralViews( lateralViews ); - } - if ( joins!=null && joins.size()>0 ) { - plainSelect.setJoins( joins ); - } - linkAST(plainSelect,jjtThis); - return plainSelect; + result.setLeftExpression(leftExpression); + result.setRightExpression(rightExpression); + linkAST(result, jjtThis, leftExpression); + return result; } } -Select SetOperationList(Select select) #SetOperationList: { - SetOperationList list = new SetOperationList(); - List orderByElements = null; - List interpolateElements = null; - Limit limit = null; - Offset offset = null; - Fetch fetch = null; - WithIsolation withIsolation = null; - List(); - List operations = new ArrayList(); - String modifier = null; +Expression IsDistinctExpression(Expression leftExpression) #IsDistinctExpression: +{ + IsDistinctExpression result = new IsDistinctExpression(); + Expression rightExpression = null; } { - + [ { result.setNot(true); } ] + rightExpression=SimpleExpression() { - selects.add(select); + result.setLeftExpression(leftExpression); + result.setRightExpression(rightExpression); + linkAST(result, jjtThis, leftExpression); + return result; } +} - ( LOOKAHEAD(2) { modifier = null; } ( - ( - [ modifier=SetOperationModifier() ] { UnionOp union = new UnionOp(modifier); linkAST(union,jjtThis); operations.add(union); } - - ) - | - ( - [ modifier=SetOperationModifier() ] { IntersectOp intersect = new IntersectOp(modifier); linkAST(intersect,jjtThis); operations.add(intersect); } - ) - | - ( - [ modifier=SetOperationModifier() ] { MinusOp minus = new MinusOp(modifier); linkAST(minus,jjtThis); operations.add(minus); } - ) - | - ( - [ modifier=SetOperationModifier() ] { ExceptOp except = new ExceptOp(modifier); linkAST(except,jjtThis); operations.add(except); } - ) - - ) +Expression IsNullExpression(Expression leftExpression): +{ + IsNullExpression result = new IsNullExpression(); + Token operator = getToken(1); +} +{ + ( + [ { result.setNot(true); } ] { result.setUseIsNull(true); } + | { result.setUseIsNull(true); result.setUseNotNull(true); } + | [ { result.setNot(true); } ] + ) + { + result.setLeftExpression(leftExpression); + linkAST(result, firstToken(leftExpression, operator)); + return result; + } +} +Expression IsBooleanExpression(Expression leftExpression): +{ + IsBooleanExpression result = new IsBooleanExpression(); + Token operator = getToken(1); +} +{ ( - select = PlainSelect() - | - select = Values() - | - select = ParenthesedSelect() + [ { result.setNot(true); } ] ( { result.setIsTrue(true); } | { result.setIsTrue(false); }) ) - { - selects.add(select); - } - )+ - - [ LOOKAHEAD(2) orderByElements=OrderByElements() {list.setOrderByElements(orderByElements);} ] - [ LOOKAHEAD(2) interpolateElements = InterpolateClause() { list.setInterpolate(interpolateElements); } ] - [ LOOKAHEAD() limit = LimitWithOffset() { list.setLimit(limit); } ] - [ LOOKAHEAD() offset = Offset() { list.setOffset(offset); } ] - [ LOOKAHEAD(, { limit==null }) limit = LimitWithOffset() { list.setLimit(limit); } ] - [ LOOKAHEAD() fetch = Fetch() { list.setFetch(fetch); } ] - [ LOOKAHEAD( ) withIsolation = WithIsolation() { list.setIsolation(withIsolation); } ] { - if ( selects.get(selects.size()-1) instanceof PlainSelect ) { - PlainSelect ps = (PlainSelect)selects.get(selects.size()-1); - if (ps.getOrderByElements() != null) { - list.setOrderByElements(ps.getOrderByElements()); - list.setLimit(ps.getLimit()); - list.setOffset(ps.getOffset()); - ps.setOrderByElements(null); - ps.setLimit(null); - ps.setOffset(null); - } - if (ps.getInterpolate() != null) { - list.setInterpolate(ps.getInterpolate()); - ps.setInterpolate(null); - } - if (ps.getOption() != null) { - list.setOption(ps.getOption()); - ps.setOption(null); - } - if (ps.getFetch() != null) { - list.setFetch(ps.getFetch()); - ps.setFetch(null); - } - if (ps.getIsolation() != null) { - list.setIsolation(ps.getIsolation()); - ps.setIsolation(null); - } - } - list.setBracketsOpsAndSelects(selects,operations); - return list; + result.setLeftExpression(leftExpression); + linkAST(result, firstToken(leftExpression, operator)); + return result; } } -List> WithList(): +Expression IsJsonExpression(Expression leftExpression): { - List> withItemsList = new ArrayList>(); - WithItem with = null; + IsJsonExpression result = new IsJsonExpression(); + Token type; } { - with=WithItem() { withItemsList.add(with); } - ( "," with=WithItem() { withItemsList.add(with); } )* + [ { result.setNot(true); } ] + [ LOOKAHEAD({ isKeywordAhead("VALUE") || isKeywordAhead("SCALAR") + || isKeywordAhead("ARRAY") || isKeywordAhead("OBJECT") }) + ( type= | type= | type= | type= ) + { result.setType(IsJsonExpression.Type.valueOf(type.image.toUpperCase(Locale.ROOT))); } ] + [ LOOKAHEAD(2) ( { result.setUniqueKeys(IsJsonExpression.UniqueKeys.WITH); } + | { result.setUniqueKeys(IsJsonExpression.UniqueKeys.WITHOUT); } ) + { result.setUseKeysKeyword(false); } + [ LOOKAHEAD(1, ) { result.setUseKeysKeyword(true); } ] ] + { result.setLeftExpression(leftExpression); return result; } +} - { return withItemsList; } +Expression IsNormalizedExpression(Expression leftExpression): +{ + IsNormalizedExpression result = new IsNormalizedExpression(); + Token operator = getToken(1); + Token form; +} +{ + [ { result.setNot(true); } ] + [ LOOKAHEAD({ !isKeywordAhead("NORMALIZED") }) form= { + result.setNormalForm(IsNormalizedExpression.NormalForm.valueOf( + form.image.toUpperCase(Locale.ROOT))); + } ] + ContextualKeyword("NORMALIZED") + { + result.setLeftExpression(leftExpression); + linkAST(result, firstToken(leftExpression, operator)); + return result; + } } -WithItem WithItem() #WithItem: +Expression IsUnknownExpression(Expression leftExpression): { - boolean recursive = false; - boolean materialized = false; - boolean usingNot = false; - String name = null; - List> selectItems = null; - WithFunctionDeclaration withFunctionDeclaration = null; - ParenthesedStatement statement = null; - Expression expr = null; - WithSearchClause withSearchClause = null; - WithCycleClause withCycleClause = null; - ExpressionList usingKeyExpressions = null; - WithItem withItem; + IsUnknownExpression result = new IsUnknownExpression(); + Token operator = getToken(1); } { - ( - LOOKAHEAD(2) - withFunctionDeclaration = WithFunctionDeclaration() - { - withItem = new WithItem().withWithFunctionDeclaration(withFunctionDeclaration); - } - | - LOOKAHEAD({ !isWithExpressionAliasAhead() }) - ( - [ LOOKAHEAD(2) { recursive = true; } ] - name=RelObjectName() - [ "(" selectItems=SelectItemsList() ")" ] - // DuckDB 2.0: WITH RECURSIVE tbl (a, b) USING KEY (a, avg(b)) AS (...) - [ LOOKAHEAD(2) "(" usingKeyExpressions=ExpressionList() ")" ] - - [ LOOKAHEAD(2) [ { usingNot = true; } ] { materialized = true; } ] - ( - LOOKAHEAD(2) statement = ParenthesedSelect() - | - LOOKAHEAD(2) statement = ParenthesedInsert() - | - LOOKAHEAD(2) statement = ParenthesedUpdate() - | - LOOKAHEAD(2) statement = ParenthesedDelete() - ) - { - withItem = new WithItem(statement, new Alias(name, false)) - .withRecursive(recursive, usingNot, materialized) - .withWithItemList(selectItems); - withItem.setUsingKeyExpressions(usingKeyExpressions); - } - ) - | - ( - // ClickHouse style expression alias: WITH AS - expr = WithItemExpression() - - name = RelObjectName() - { - withItem = new WithItem().withExpression(expr).withAlias(new Alias(name, false)); - } - ) - ) - [ withSearchClause = WithSearchClause() { withItem.setSearchClause(withSearchClause); } ] - [ withCycleClause = WithCycleClause() { withItem.setCycleClause(withCycleClause); } ] - { - return withItem; - } + ( + [ { result.setNot(true); } ] + ) + + { + result.setLeftExpression(leftExpression); + linkAST(result, firstToken(leftExpression, operator)); + return result; + } } -Expression WithItemExpression(): +Expression ExistsExpression(): { - LambdaExpression lambdaExpression; - Expression expr; + ExistsExpression result = new ExistsExpression(); + Expression rightExpression = null; + Token first = getToken(1); } { - ( - // unparenthesized parameter, e.g. x -> x * 2 - LOOKAHEAD( RelObjectName() "->" ) - expr = LambdaExpression() - | - // parenthesized parameter list, e.g. (value) -> value + 1 - LOOKAHEAD( ParenthesedColumnList() "->" ) - expr = LambdaExpression() - | - // whole lambda wrapped in parentheses, e.g. (x -> x * 2) - LOOKAHEAD( "(" ( RelObjectName() | ParenthesedColumnList() ) "->" ) - "(" lambdaExpression = LambdaExpression() ")" - { expr = new ParenthesedExpressionList(lambdaExpression); } - | - expr = Expression() - ) - { return expr; } + rightExpression=SimpleExpression() + { + result.setRightExpression(rightExpression); + linkAST(result, first); + return result; + } } -WithSearchClause WithSearchClause() #WithSearchClause: +Expression MemberOfExpression(Expression leftExpression): { - Token orderingToken; - ExpressionList searchColumns = new ExpressionList(); - Column searchColumn = null; - String sequenceColumnName; + MemberOfExpression result; + Expression rightExpression = null; + Token operator = getToken(1); } { - - ( orderingToken= | orderingToken= ) - - - searchColumn = Column() { searchColumns.add(searchColumn); } - ( "," searchColumn = Column() { searchColumns.add(searchColumn); } )* - - sequenceColumnName = RelObjectName() + rightExpression=Expression() { - return new WithSearchClause( - "BREADTH".equalsIgnoreCase(orderingToken.image) - ? WithSearchClause.SearchOrder.BREADTH - : WithSearchClause.SearchOrder.DEPTH, - searchColumns, sequenceColumnName); + result = new MemberOfExpression(leftExpression, rightExpression); + linkAST(result, firstToken(leftExpression, operator)); + return result; } } -WithCycleClause WithCycleClause() #WithCycleClause: +ExpressionList ExpressionList() #ExpressionList: { - WithCycleClause cycle = new WithCycleClause(); - ExpressionList columns = new ExpressionList(); - String name; - Expression value; + ExpressionList expressionList; + Token first = getToken(1); } { - - name=RelObjectName() { columns.add(createColumn(name)); } - ( "," name=RelObjectName() { columns.add(createColumn(name)); } )* - name=RelObjectName() { cycle.setMarkColumnName(name); } - [ value=Expression() { cycle.setMarkValue(value); } - value=Expression() { cycle.setMarkDefault(value); } ] - name=RelObjectName() { cycle.setPathColumnName(name); } - { return cycle.withCycleColumns(columns); } + // ComplexExpressionList() parses every list form, "()" and bracketed operands such as + // "( 1 + a ) / ( 1 + b )" included. + expressionList = ComplexExpressionList() + { + // Avoid redundant ExpressionLists containing only one ParenthesedExpressionList + // return the Parenthesed Sub ExpressionList instead + // Same for ParenthesedExpressionList containing only 1 ExpressionList + + if ( expressionList.size() == 1 && expressionList.get(0) instanceof ExpressionList ) { + ExpressionList subList = (ExpressionList) expressionList.get(0); + if (expressionList instanceof ParenthesedExpressionList) { + if (!(subList instanceof ParenthesedExpressionList)) { + expressionList = new ParenthesedExpressionList(subList); + } + } else if (subList instanceof ParenthesedExpressionList) { + expressionList = new ParenthesedExpressionList(subList); + } else { + expressionList = subList; + } + } + linkASTIfMissing(expressionList, first); + return expressionList; + } } -WithFunctionDeclaration WithFunctionDeclaration() #WithFunctionDeclaration: +ParenthesedExpressionList ParenthesedExpressionList(): { - String functionName; - List parameters = new ArrayList(); - String returnType; - Expression returnExpression; - WithFunctionParameter parameter; + ExpressionList expressions=new ExpressionList(); + Token first = getToken(1); } { - functionName = RelObjectName() "(" - [ parameter=WithFunctionParameter() { parameters.add(parameter); } - ( "," parameter=WithFunctionParameter() { parameters.add(parameter); } )* - ] + [ LOOKAHEAD({ getToken(1).kind != CLOSING_BRACKET }) expressions = ComplexExpressionList() ] ")" - returnType = RelObjectName() - returnExpression = Expression() { - return new WithFunctionDeclaration(functionName, parameters, returnType, returnExpression); + ParenthesedExpressionList result = new ParenthesedExpressionList(expressions); + linkAST(result, first); + return result; } } -WithFunctionParameter WithFunctionParameter() #WithFunctionParameter: +ExpressionList SimpleExpressionList(): { - String name; - String type = null; - String arrayType = null; + ExpressionList columns; + ExpressionList expressions = new ExpressionList(); + Expression expr; + Token first = getToken(1); } { - name = RelObjectName() + expr=SimpleExpression() { expressions.add(expr); } ( - LOOKAHEAD(2) "<" arrayType = RelObjectName() ">" - | - type = RelObjectName() - ) - { - if (arrayType != null) { - type = "ARRAY<" + arrayType + ">"; + LOOKAHEAD({ !interrupted && getToken(1).kind == K_COMMA }) "," + ( + LOOKAHEAD( RelObjectName() "->", { !isJsonArrowDialect() } ) expr=LambdaExpression() + | + LOOKAHEAD({ !interrupted }) expr=SimpleExpression() + ) + { + expressions.add(expr); } - return new WithFunctionParameter(name, type); + )* + { + linkAST(expressions, first); + return expressions; } } -List> ColumnSelectItemsList(): + +ExpressionList ColumnList(): { - List> selectItemsList = null; - SelectItem selectItem = null; + ExpressionList expressions = new ExpressionList(); + Column expr; + Token first = getToken(1); } { - selectItem=SelectItem() { selectItemsList = new ArrayList>(); selectItemsList.add(selectItem); } - ( - LOOKAHEAD(2) "," selectItem=SelectItem() - { - selectItemsList.add(selectItem); - } - )* + expr=Column() { expressions.add(expr); } + ( LOOKAHEAD(2) "," expr=Column() { expressions.add(expr); } )* + { + linkAST(expressions, first); + return expressions; + } +} - { return selectItemsList; } +ParenthesedExpressionList ParenthesedColumnList(): +{ + ExpressionList expressions; + Token first = getToken(1); +} +{ + "(" expressions = ColumnList() ")" + { + ParenthesedExpressionList result = new ParenthesedExpressionList(expressions); + linkAST(result, first); + return result; + } } -List> SelectItemsList(): +ExpressionList ComplexExpressionList(): { - List> selectItemsList = null; - SelectItem selectItem = null; + ExpressionList columns; + ExpressionList expressions = new ExpressionList(); + Expression expr; + Token first = getToken(1); } { - selectItem=SelectItem() { selectItemsList = new ArrayList>(); selectItemsList.add(selectItem); } ( - LOOKAHEAD(2) "," selectItem=SelectItem() - { - selectItemsList.add(selectItem); - } + LOOKAHEAD(2, { isNamedParameterAssignmentAhead() }) expr=OracleNamedFunctionParameter() + | + LOOKAHEAD(2, { isNamedParameterAssignmentAhead() }) expr=PostgresNamedFunctionParameter() + | + // The semantic lookahead makes JavaCC enter Expression() with no scan of its first token. + LOOKAHEAD({ !interrupted }) expr=Expression() + ) + { + expressions.add(expr); + } + + ( + LOOKAHEAD({ !interrupted && getToken(1).kind == K_COMMA }) "," + ( + LOOKAHEAD(2, { isNamedParameterAssignmentAhead() }) expr=OracleNamedFunctionParameter() + | + LOOKAHEAD(2, { isNamedParameterAssignmentAhead() }) expr=PostgresNamedFunctionParameter() + | + LOOKAHEAD( RelObjectName() "->", { !isJsonArrowDialect() } ) expr=LambdaExpression() + | + LOOKAHEAD({ !interrupted }) expr=Expression() + ) { expressions.add(expr); } )* - { return selectItemsList; } + { + linkAST(expressions, first); + return expressions; + } } -FunctionAllColumns FunctionAllColumns() #FunctionAllColumns: +// @Todo: Refactor this with proper SQL:2016 functions according to https://manticore-projects.com/SQL2016Parser/syntax.html#character-value-function +// substring(expr1 from expr2) +// substring(expr1 from expr2 for expr3) +// trim(expr1 from expr2) <-- Superceded by TrimFunction() below +// position(expr1 in expr2) +// overlay(expr1 placing expr2 from expr3) +// overlay(expr1 placing expr2 from expr3 for expr4) +// expr1 has already been consumed +NamedExpressionList NamedExpressionListExprFirst(): { - Function function; + NamedExpressionList retval = new NamedExpressionList(); + List expressions = new ArrayList(); + List names = new ArrayList(); + Expression expr1 = null; + Expression expr2 = null; + Expression expr3 = null; + Expression expr4 = null; + Token tk2 = null; + Token tk3 = null; + Token tk4 = null; } { - "(" ( "(" )* function=Function() ")" ( ")" )* "." "*" + expr1=SimpleExpression() + (tk2=|tk2=|tk2=) + { + names.add(""); + expressions.add(expr1); + names.add(tk2.image); + } + ( + expr2=SimpleExpression() { expressions.add(expr2);} + ( + (tk3=|tk3=) + expr3=SimpleExpression() {names.add(tk3.image); expressions.add(expr3);} + ( + (tk4=) + expr4=SimpleExpression() {names.add(tk4.image); expressions.add(expr4);} + )? + )? + ) + { - return new FunctionAllColumns(function); + retval.setNames(names); + retval.setExpressions(expressions); + return retval; } } -SelectItem SelectItem() #SelectItem: +Expression ComparisonItem() : { - Expression expression; - Alias alias = null; + Expression retval = null; } { - expression = SelectItemExpression() - [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ] + ( + LOOKAHEAD(6, { getToken(1).kind == K_ANY || getToken(1).kind == K_SOME || getToken(1).kind == K_ALL }) retval=AnyComparisonExpression() + | + LOOKAHEAD({ getToken(1).kind == K_ROW }) retval=RowConstructor() + | + retval=SimpleExpression() + ) + + { + return retval; + } +} + +Expression AnyComparisonExpression() : +{ + AnyType anyType; + Select select; + Token first = getToken(1); +} +{ + ( + { anyType = AnyType.ANY; } + | + { anyType = AnyType.SOME; } + | + { anyType = AnyType.ALL; } + ) + select = ParenthesedSelect() { - SelectItem selectItem = new SelectItem(expression, alias); - linkAST(selectItem,jjtThis); - return selectItem; + AnyComparisonExpression result = new AnyComparisonExpression(anyType, select); + linkAST(result, first); + return result; } } -/** - * Recognizes a transformer without consuming it. APPLY(functionName) intentionally takes - * precedence over its ambiguous alias-column reading. Other aliases use the existing Alias - * grammar, including typed columns, at every transformer boundary. Only the transformer - * prefix is probed: expression bodies are parsed normally by the Pratt parser. - */ -boolean ColumnsTransformerAhead() #void: -{} +Expression SimpleExpression(): { - LOOKAHEAD( "(" RelObjectName() ")" ) { return true; } - | LOOKAHEAD( ( | ) AliasColumns() ) { return false; } - | LOOKAHEAD( "(" | "(" - | ( | ) ParenthesedColumnList() ) - { return true; } - | { return false; } + Expression retval = null; + UserVariable user = null; + Token operation = null; + Token first; } - -/** - * Recognizes a transformer after the AllColumns-Pattern '*'. - * - * This differs from ColumnsTransformerAhead() in one point: after '*' an alias is not a - * meaningful reading of REPLACE, so REPLACE (col) stays a transformer here whereas - * APPLY (col1, col2) remains an alias. Reusing the COLUMNS(...) rules verbatim would turn - * '* REPLACE (x)' into an alias. - */ -boolean AllColumnsTransformerAhead() #void: -{} { - LOOKAHEAD( "(" RelObjectName() ")" ) { return true; } - | LOOKAHEAD( AliasColumns() ) { return false; } - | LOOKAHEAD( "(" | "(" - | ( | ) ParenthesedColumnList() ) - { return true; } - | { return false; } + [ LOOKAHEAD( 5, { getToken(1).kind == S_AT_IDENTIFIER } ) user = UserVariable() ( operation = "=" | operation = ":=" ) ] + { first = getToken(1); } + retval=PrimaryExpression() + // PostgreSQL path operators bind below arithmetic and above comparisons. + // MySQL also gives | and & their own tiers below <<, >>, so the loop's + // entry floor drops to 2 there instead of the shared bitwise level 4. + { + int arithFloor = Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) ? 2 : 4; + retval = prattArithRest(retval, first, arithFloor); + } + { + if (user != null) { + VariableAssignment assignment = new VariableAssignment(); + assignment.setVariable(user); + assignment.setOperation(operation.image); + assignment.setExpression(retval); + linkAST(assignment, firstToken(user, first)); + return assignment; + } else + return retval; + } } -/** - * Keeps transformer consumption visible to enclosing syntactic lookaheads. The normal - * expression is parsed first; only a direct COLUMNS function can acquire transformers. - * The conditional node encloses both the matcher and its transformers, but adds no AST - * parent for ordinary expressions or alias-column lists. - */ -Expression SelectItemExpression() #ColumnsExpression(transformers != null): +StringValue CharacterSetIntroducedString(): { - Expression expression; - ColumnsTransformer transformer; - List transformers = null; + Token introducer; + Token literal; } { - // @fixme: Oracle's SEQUENCE.nextval is parsed as COLUMN with a name part nextval - // @todo: parse a proper SEQUENCE instead of a COLUMN - ( - LOOKAHEAD(3) expression = ConnectByPriorOperator() - | - ( expression = Condition() { expression = prattExpressionRest(expression, 2); } ) - ) - ( - LOOKAHEAD( "(" | "(" | ParenthesedColumnList() ) - { - if (!(expression instanceof Function)) { - break; - } - Function function = (Function) expression; - if (!"COLUMNS".equalsIgnoreCase(function.getName()) || function.isEscaped() - || function.getAttribute() != null || function.getChainedParameters() != null - || function.getKeep() != null || function.isIgnoreNullsOutside() - || !ColumnsTransformerAhead()) { - break; - } - } - transformer = ColumnsTransformer() - { - if (transformers == null) { - transformers = new ArrayList(); - } - transformers.add(transformer); - } - )* + introducer= literal= { - if (transformers == null) { - return expression; - } - ColumnsExpression columnsExpression = new ColumnsExpression(expression, transformers); - linkAST(columnsExpression, jjtThis); - return columnsExpression; + StringValue result = stringValue(literal).withPrefix(introducer.image); + linkAST(result, introducer, literal); + return result; } } -/** - * Parses a single ClickHouse transformer: APPLY(expression), EXCEPT (columns) or - * REPLACE (selectItems). ClickHouse parses these in a loop, so they may repeat - * and combine in any order. - */ -ColumnsTransformer ColumnsTransformer(): +/** Multiplicative/bitwise-shift — higher precedence */ +Expression MulChain(): { - Expression applyExpression; - ParenthesedExpressionList exceptColumns; - List> replaceItems; - ColumnsTransformer transformer; - Token tk; + Expression retval; + Expression right; } { + retval=PrimaryExpression() ( - "(" - ( - LOOKAHEAD( RelObjectName() "->" ) applyExpression = LambdaExpression() - | - applyExpression = Expression() - ) - ")" - { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.APPLY) - .setApplyExpression(applyExpression); } - - | ( tk= | tk= ) exceptColumns = ParenthesedColumnList() - { transformer = new ColumnsTransformer( - tk.kind == K_EXCLUDE - ? ColumnsTransformer.ColumnsTransformerType.EXCLUDE - : ColumnsTransformer.ColumnsTransformerType.EXCEPT) - .setExceptColumns(exceptColumns); } - - | "(" replaceItems = SelectItemsList() ")" - { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.REPLACE) - .setReplaceItems(replaceItems); } - ) - { return transformer; } + LOOKAHEAD(2) + ( + "*" right=PrimaryExpression() {{ Multiplication r = new Multiplication(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=PrimaryExpression() {{ Division r = new Division(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + "%" right=PrimaryExpression() {{ Modulo r = new Modulo(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=PrimaryExpression() {{ net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=PrimaryExpression() {{ IntegerDivision r = new IntegerDivision(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + ) + )* + { return retval; } } -/** - * Parses the AllColumns-Pattern '*'. - * - * If the allowAdditions is true, it parses additional Keywords. - */ -AllColumns AllColumns(boolean allowAdditions): +/** Additive/concat/bitwise — lower precedence */ +Expression AddChain(): { - ColumnsTransformer transformer; - List transformers = null; + Expression retval; + Expression right; } { - "*" - // BigData allows EXCEPT, DuckDB allows EXCLUDE, ClickHouse allows APPLY; - // they may repeat and combine in any order + retval=MulChain() ( - LOOKAHEAD( "(" | "(" - | ( | ) ParenthesedColumnList() ) - { - if (!allowAdditions || !AllColumnsTransformerAhead()) { - break; - } - } - transformer = ColumnsTransformer() - { - if (transformers == null) { - transformers = new ArrayList(); - } - transformers.add(transformer); - } + LOOKAHEAD(2) + ( + "+" right=MulChain() {{ Addition r = new Addition(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + "-" right=MulChain() {{ Subtraction r = new Subtraction(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=MulChain() {{ Concat r = new Concat(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + LOOKAHEAD(2) right=MulChain() {{ Concat r = new Concat(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=MulChain() {{ BitwiseOr r = new BitwiseOr(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + "&" right=MulChain() {{ BitwiseAnd r = new BitwiseAnd(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=MulChain() {{ BitwiseLeftShift r = new BitwiseLeftShift(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + | + right=MulChain() {{ BitwiseRightShift r = new BitwiseRightShift(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} + ) )* + { return retval; } +} + +Expression ArrayExpression(Expression obj): { + Expression expr; +} { + expr = ArraySubscript(obj) + ( LOOKAHEAD(2) expr = ArraySubscript(expr) )* + { return expr; } +} +ArrayExpression ArraySubscript(Expression obj): { + Expression idxExpr = null; + RangeExpression slice = null; + Token opening; +} { + opening="[" + try { + { subscriptOpenings.push(opening); } + [ LOOKAHEAD(3, { !":".equals(getToken(1).image) }) idxExpr = ArrayIndexExpression() ] + [ slice = SliceTail(idxExpr) ] + } finally { + subscriptOpenings.pop(); + } + "]" { - return new AllColumns(transformers); + ArrayExpression result = slice == null + ? new ArrayExpression(obj, idxExpr, null, null) + : new ArrayExpression(obj, null, slice.getStartExpression(), + slice.getEndExpression()).withStepExpression(slice.getStepExpression()); + linkAST(result, firstToken(obj, opening)); + return result; } } /** - * Parses the AllTableColumns-Pattern 'table.*' - * - * If the allowAdditions is true, it parses additional Keywords. + * The rest of a slice after its optional start: {@code :[stop][:[step]]}. As in DuckDB, a + * {@code -} stop before a step stands for the end of the list, as in {@code l[1:-:2]}. */ -AllTableColumns AllTableColumns(boolean allowAdditions): -{ - Table table = null; - AllColumns allColumns; -} -{ - table=Table() "." allColumns=AllColumns(allowAdditions) +RangeExpression SliceTail(Expression start): { + Expression stop = null; + Expression step = null; + Token colon = getToken(1); +} { + ":" + [ + LOOKAHEAD("-" ":") "-" + | + LOOKAHEAD({ !isSliceDelimiter(getToken(1)) }) stop = Expression() + ] + [ + ":" [ LOOKAHEAD({ !isSliceDelimiter(getToken(1)) }) step = Expression() ] + ] { - return new AllTableColumns(table, allColumns); + RangeExpression result = new RangeExpression(start, stop).withStepExpression(step); + linkAST(result, firstToken(start, colon)); + return result; } - -} - -Alias Alias(): -{ String name = ""; - Token token = null; - boolean useAs = false; - Alias alias; - List aliasColumns; } -{ - ( - LOOKAHEAD(3) ( - // Aliases with AS and Columns, but optional identifier: - // SELECT fun(x) AS (a,b,c) - // SELECT fun(x) AS T(a,b,c) - - [ LOOKAHEAD(2) name=RelObjectName() ] - { alias = new Alias(name, true ); } - - aliasColumns = AliasColumns() { alias.setAliasColumns(aliasColumns); } - - ) - | - ( - // Aliases with identifier but optional AS and Columns: - // SELECT fun(x) AS T - // SELECT fun(x) T - // SELECT fun(x) T(a,b,c) - - [ { useAs = true; } ] - ( name=RelObjectName() | token= { name=token.image; } ) - { alias = new Alias(name,useAs); } - [ LOOKAHEAD(2) aliasColumns = AliasColumns() { alias.setAliasColumns(aliasColumns); } ] - - ) - ) - { return alias; } +/** A subscript of a column, such as {@code col[1]}, {@code col[1, 2]} or {@code col[1:3]}. */ +ArrayConstructor Subscript() : { + ExpressionList expList = new ExpressionList(); + Expression exp; + Token opening; +} { + opening="[" + try { + { subscriptOpenings.push(opening); } + [ + exp=SubscriptElement() { expList.add(exp); } + ( "," exp=SubscriptElement() { expList.add(exp); } )* + ] + } finally { + subscriptOpenings.pop(); + } + "]" + { + ArrayConstructor result = new ArrayConstructor(linkElements(expList), false); + linkAST(result, opening); + return result; + } } -List AliasColumns(): +Expression SubscriptElement(): { - List columns = new ArrayList(); - String name; - ColDataType type = null; + Expression expression = null; } { - "(" name = RelObjectName() [ type = ColDataType() ] - { columns.add(new Alias.AliasColumn(name, type)); } ( - "," { type = null; } name = RelObjectName() [ type = ColDataType() ] - { columns.add(new Alias.AliasColumn(name, type)); } - )* - ")" - { return columns; } + LOOKAHEAD({ ":".equals(getToken(1).image) }) expression=SliceTail(null) + | + expression=Expression() [ expression=SliceTail(expression) ] + ) + { return expression; } } -void SQLServerHint(SQLServerHints hints) : { - String str; - Token keyword; +/** + * Array subscript index. BigQuery addresses array elements positionally with + * OFFSET(n), ORDINAL(n), SAFE_OFFSET(n) and SAFE_ORDINAL(n). Only OFFSET needs + * an explicit rule here, the others are plain identifiers and parse as functions. + */ +Expression ArrayIndexExpression() : +{ + Token token; + Expression expr; } { - "(" str = RelObjectName() ")" { hints.setIndexName(str); } - | - { hints.withNoLock(); } - | - ( keyword= | keyword= ) + ( + LOOKAHEAD(2) token = "(" expr = SimpleExpression() ")" { - try { - hints.getLockHints().add(SQLServerHints.LockHint.valueOf(keyword.image.toUpperCase(Locale.ROOT))); - } catch (IllegalArgumentException exception) { - throw new ParseException("Unsupported SQL Server locking hint: " + keyword.image); - } + Function offset = new Function() + .withName(token.image) + .withParameters(linkElements(new ExpressionList(expr))); + linkAST(offset, token); + return offset; } + | + expr = SimpleExpression() { return expr; } + ) } -SQLServerHints SQLServerHints() : { - SQLServerHints hints = new SQLServerHints(); +Expression NavigationStep(Expression base): +{ + Expression step = null; + String nm = null; + Function method; } { - "(" - SQLServerHint(hints) ("," SQLServerHint(hints) )* - ")" - { return hints; } + ( + "." + ( + LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) && isFunctionAhead() }) + method=Function() { step = new MethodCallExpression(base, method); } + | + nm=RelObjectNameExt() { step = new RowGetExpression(base, nm); } + ) + | + step = ArrayExpression(base) + ) + { return step; } } -MySQLIndexHint MySQLIndexHint(): +StringValue CharacterLiteral(boolean link): { - Token actionToken = null; - Token indexToken = null; - String indexName = null; - List indexNameList = new ArrayList(); + Token literal; + StringValue value; + Token first = getToken(1); } { - ( - actionToken = - | actionToken = - | actionToken = - | actionToken = - ) - - ( - indexToken = - | indexToken = - ) - - "(" - indexName = RelObjectName() { indexNameList.add(indexName); } - ("," indexName= RelObjectName() { indexNameList.add(indexName); })* - ")" - { - return new MySQLIndexHint(actionToken.image, indexToken.image, indexNameList); - } + literal= { value = unlinkedStringValue(literal); } + ( LOOKAHEAD({ isAdjacentStringConcat() }) + literal= + { value.setValue(value.getValue() + unlinkedStringValue(literal).getValue()); } + )* + { + // a primary expression links the literal itself, with its own tree node + if (link) { + linkAST(value, first); + } + return value; + } } -SelectItem FunctionItem(): +Expression PrimaryExpression() #PrimaryExpression: { - Alias alias = null; - Function function; + Expression retval = null; + Expression nxt = null; + Expression expression = null; + CastExpression castExpr = null; + TimezoneExpression timezoneExpr = null; + Expression timezoneRightExpr = null; + Token token = null; + Token sign = null; + Token innerSign; + List innerSigns = null; + ColDataType type = null; + boolean not = false; + boolean exclamationMarkNot = false; + boolean dateExpressionAllowed = true; + Token coreFirst = null; + ExpressionList list; + + List> jsonIdents = null; + boolean timezoneOperand; + Token atToken; + Token timezoneFirst = null; } { - function=Function() - [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ] - { return new SelectItem(function, alias); } -} + { timezoneOperand = timezoneOperandAhead; timezoneOperandAhead = false; } + [ { not=true; } | "!" { not=true; exclamationMarkNot=true; } ] + [ + ( sign="+" | sign="-" | sign="~" ) + // DuckDB's chained signs, e.g. - -1 or +-+1 + ( + LOOKAHEAD(1) ( innerSign="+" | innerSign="-" | innerSign="~" ) + { + if (innerSigns == null) { + innerSigns = new ArrayList(); + } + innerSigns.add(innerSign); + } + )* + ] + { coreFirst = getToken(1); } + ( + { retval = new NullValue(); } + + | LOOKAHEAD({!interrupted && isCaseExpressionAhead()}) retval=CaseWhenExpression() + + | LOOKAHEAD(2, {!interrupted}) retval=CharacterPrimary() + + | LOOKAHEAD({ !interrupted && getToken(1).kind == DATA_TYPE + && "MAP".equalsIgnoreCase(getToken(1).image) + && getToken(2).kind == OPENING_CURLY_BRACKET }) retval=MapExpression() + + | LOOKAHEAD({!interrupted && isImplicitCastAhead()}) retval=ImplicitCast() + + | retval = JdbcParameter() + + | LOOKAHEAD(2) retval =JdbcNamedParameter() + + | LOOKAHEAD(3) retval=UserVariable() + + | LOOKAHEAD(2, {!interrupted}) retval=NumericBind() + + | LOOKAHEAD(4 , {!interrupted}) retval=ExtractExpression() + + | LOOKAHEAD({ getToken(1).kind == K_XMLSERIALIZE && getToken(2).kind == OPENING_BRACKET }) + retval=XMLSerializeExpr() + + | LOOKAHEAD(3, { !interrupted}) retval = JsonFunction() + + | LOOKAHEAD(3, { !interrupted}) retval = JsonAggregateFunction() + + | LOOKAHEAD(3, { !interrupted}) retval = FullTextSearch() + + | LOOKAHEAD(2, {!interrupted}) retval= CastExpression() + + | LOOKAHEAD({ !interrupted && (isKeywordAhead("RUNNING") || getToken(1).kind == K_FINAL) + && getToken(3).kind == OPENING_BRACKET }) retval=RowPatternFunction() + + | LOOKAHEAD({ !interrupted && isFunctionAhead() }) + retval = Function() [ LOOKAHEAD(2) retval = AnalyticExpression( (Function) retval ) ] + + | LOOKAHEAD(2, {!interrupted}) retval = IntervalExpression() { dateExpressionAllowed = false; } + + | token= { retval = new DoubleValue(token.image); } + + | token= { retval = new LongValue(token.image); } + + | token= { retval = new HexValue(token.image); } + + | LOOKAHEAD(3) retval=AllColumns(true) + + | LOOKAHEAD({ !interrupted && isAllTableColumnsAhead() }) + retval=AllTableColumns(true) + + // See issue #2207 + // there is a huge! performance deterioration from this production + //| LOOKAHEAD(FunctionAllColumns()) retval=FunctionAllColumns() + + // support timestamp expressions; current.x is a qualified column + | LOOKAHEAD({ !interrupted && (getToken(1).kind == K_TIME_KEY_EXPR + || getToken(1).kind == K_CURRENT && !".".equals(getToken(2).image)) }) + (token= | token=) { retval = new TimeKeyExpression(token.image); } + + | LOOKAHEAD(2, {!interrupted}) retval=DateTimeLiteralExpression() + + | LOOKAHEAD(3 , {!interrupted}) retval=StructType() + + | LOOKAHEAD(3, {!interrupted}) [ "<" type=ColDataType() ">" ] retval=ArrayConstructor(true) { if (type!=null) ((ArrayConstructor) retval).setDataType(type); } + + | LOOKAHEAD({ !interrupted && isListComprehensionAhead() }) retval=ListComprehension() + + | LOOKAHEAD(1, {!interrupted}) retval=ArrayConstructor(false) + + | LOOKAHEAD(2, {!interrupted}) retval = NextValExpression() + + | retval=ConnectByRootOperator() + + | LOOKAHEAD({ isPriorOperatorAhead() }) retval=ConnectByPriorOperator() + + | LOOKAHEAD(2, { !interrupted && getToken(1).kind == K_KEY && getToken(2).kind != OPENING_BRACKET }) retval=KeyExpression() + + | LOOKAHEAD({ !interrupted && getToken(1).kind == K_ALL }) { retval = new AllValue(); } + + | LOOKAHEAD({ !interrupted && isCharacterSetIntroducedStringAhead() }) + retval=CharacterSetIntroducedString() + + // DuckDB's lambda x, y : expr, before Column() which would take LAMBDA as a column name + | LOOKAHEAD({ !interrupted && isDuckDBLambdaAhead() }) retval=DuckDBLambdaExpression() + + | LOOKAHEAD(2, {!interrupted}) retval=Column() + [ + LOOKAHEAD( "(" "+" ")" ("," | ")") ) + "(" "+" ")" { ((Column) retval).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); widen(retval, null, getToken(0)); } + ] + + | LOOKAHEAD({ !interrupted && (getToken(1).kind == K_TRUE || getToken(1).kind == K_FALSE) }) + (token= | token=) { retval = new BooleanValue(token.image); } + + | retval=CharacterLiteral(false) + + | "{d" token= "}" { retval = new DateValue(token.image); } + + | "{t" token= "}" { retval = new TimeValue(token.image); } + + | "{ts" token= "}" { retval = new TimestampValue(token.image); } + + | LOOKAHEAD({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) && !interrupted + && (getToken(1).kind == K_SELECT || getToken(1).kind == K_WITH || getToken(1).kind == K_VALUES + || (getToken(1).kind == OPENING_BRACKET && (getToken(2).kind == K_SELECT || getToken(2).kind == K_WITH || getToken(2).kind == K_VALUES))) }) retval=Select() + + | LOOKAHEAD({ !getAsBoolean(Feature.allowUnparenthesizedSubSelects) && !interrupted && isParenthesedSelectAhead() }) retval=ParenthesedSelect() + + | LOOKAHEAD({ !interrupted && isNestedSetOperationAhead() }) retval=ParenthesedSelect() + + | + ( + list=ParenthesedExpressionList() + // Mutli-Variable Lambda Expression, e. g. + // SELECT map_filter(my_column, (k,v) -> v.my_inner_column = 'some_value') + // First-arg form (issue #2195): array_map((x,y,z) -> x + y, ...) + ( + LOOKAHEAD(2, { !isJsonArrowDialect() }) "->" + retval = Expression() + { + retval = LambdaExpression.from(list, retval); + } + | + { + if (list.size() == 1) { + retval = new ParenthesedExpressionList( (Expression) list.getExpressions().get(0)); + } else { + retval = list; + } + } + ) + + // PostgreSQL composite row expansion: (function()).* + // Re-enables FunctionAllColumns, which was disabled in #2207 due to the + // performance toll of a speculative syntactic lookahead. A bounded + // semantic follower check instead reads the already-parsed retval and + // peeks the next two tokens, avoiding any speculative production. + [ LOOKAHEAD( { isFunctionAllColumnsAhead(retval) } ) + "." "*" + { retval = new FunctionAllColumns(unwrapParenthesedFunction(retval)); } ] -ExpressionList PivotForColumns(): -{ - ExpressionList columns; - Column column; -} -{ - ( - columns = ParenthesedColumnList() - | - column = Column() { columns = new ExpressionList(column); } + // Share field and method navigation with the other primary expressions. + ( LOOKAHEAD(1, ".") { linkASTIfMissing(retval, coreFirst); } nxt=NavigationStep(retval) { retval = nxt; } )* + ) ) - { return columns; } -} -List> PivotFunctionItems(): -{ - List> functionItems = new ArrayList>(); - SelectItem item; -} -{ - item = FunctionItem() {functionItems.add(item);} - ( LOOKAHEAD(2) "," item = FunctionItem() {functionItems.add(item);} )* - { return functionItems; } -} + [ + LOOKAHEAD(2, { !isColumnCollateAhead() }) { linkASTIfMissing(retval, coreFirst); } + (token= | token= | token=) { retval = new CollateExpression(retval, token.image); } + ] -/** - * DuckDB's simplified UNPIVOT statement: - * UNPIVOT tbl ON columns [INTO NAME name VALUE values]. - */ -UnPivotQuery UnPivotQuery(): -{ - UnPivotQuery unPivotQuery = new UnPivotQuery(); - ExpressionList onExpressions; - ExpressionList valueColumns; - FromItem fromItem; - String nameColumn; -} -{ - fromItem=FromItem() { unPivotQuery.setFromItem(fromItem); } - onExpressions=ExpressionList() { unPivotQuery.setOnExpressions(onExpressions); } - // greedy: INTO after the ON list belongs to this UNPIVOT [ - LOOKAHEAD(2) - nameColumn=RelObjectName() { unPivotQuery.setNameColumn(nameColumn); } - valueColumns=ColumnList() { unPivotQuery.setValueColumns(valueColumns); } + LOOKAHEAD(2, { dateExpressionAllowed } ) { linkASTIfMissing(retval, coreFirst); } retval = IntervalExpressionWithoutInterval(retval) ] - { return unPivotQuery; } -} -PivotQuery PivotQuery(): -{ - PivotQuery pivotQuery = new PivotQuery(); - FromItem fromItem; - ExpressionList onExpressions = null; - List> usingItems = null; - ExpressionList groupByExpressions = null; -} -{ - fromItem = FromItem() + [ LOOKAHEAD(2) { linkASTIfMissing(retval, coreFirst); } retval = ArrayExpression(retval) ] + + // navigation chains, e.g. Redshift SUPER col[0].field[1].sub: field accesses + // and subscripts may alternate freely after the primary expression ( - onExpressions = ExpressionList() - [ LOOKAHEAD(2) usingItems = PivotFunctionItems() ] - [ LOOKAHEAD(2) groupByExpressions = ExpressionList() ] - | - usingItems = PivotFunctionItems() - [ LOOKAHEAD(2) groupByExpressions = ExpressionList() ] - | - groupByExpressions = ExpressionList() - ) + LOOKAHEAD(2) { linkASTIfMissing(retval, coreFirst); } nxt = NavigationStep(retval) { retval = nxt; } + )* + + ( LOOKAHEAD(2) { linkASTIfMissing(retval, coreFirst); } "::" type=ColDataType() { + castExpr = new CastExpression(); + castExpr.setUseCastKeyword(false); + castExpr.setLeftExpression(retval); + castExpr.setColDataType(type); + retval=castExpr; + } + )* + + // Check for JSON operands + [ + LOOKAHEAD(2, { !isPostgreSqlJsonAccess(getToken(1)) + && ((ternaryThenBranchDepth == 0 && mapKeyDepth == 0 && !isSliceColonAhead()) + || !":".equals(getToken(1).image)) }) { linkASTIfMissing(retval, coreFirst); } ( + LOOKAHEAD(2) ( + token="->" + | + token=":" + | + token="->>" + | + token="#>" + | + token="#>>" + ) + + expression=JsonPathElement() + { + if (jsonIdents == null) { + jsonIdents = new ArrayList>(); + } + jsonIdents.add(new AbstractMap.SimpleEntry(expression, token.image )); + } + )+ + retval = JsonExpression(retval, jsonIdents) + ] + + // AT TIME ZONE zone and AT LOCAL chain from left to right: one TimezoneExpression holds a run + // of zones and an AT LOCAL that ends it, and a conversion after AT LOCAL wraps that expression + ( LOOKAHEAD(2, { !timezoneOperand }) { linkASTIfMissing(retval, coreFirst); } atToken= + ( + { timezoneOperandAhead = true; } + timezoneRightExpr=PrimaryExpression() { + if (timezoneExpr == null || timezoneExpr.isAtLocal()) { + timezoneExpr = new TimezoneExpression().setLeftExpression(retval); + retval = timezoneExpr; + timezoneFirst = atToken; + } + timezoneExpr.addTimezoneExpression(timezoneRightExpr); + // a run that was linked before this zone takes it in + widen(timezoneExpr, null, getToken(0)); + } + | + { + if (timezoneExpr == null || timezoneExpr.isAtLocal()) { + timezoneExpr = new TimezoneExpression().setLeftExpression(retval); + retval = timezoneExpr; + } + timezoneExpr.setAtLocal(true); + widen(timezoneExpr, null, getToken(0)); + linkTimezones(timezoneExpr, timezoneFirst); + } + // a cast applies to the converted value: ts AT LOCAL::date + ( LOOKAHEAD(2) { linkASTIfMissing(retval, coreFirst); } "::" type=ColDataType() { + castExpr = new CastExpression(); + castExpr.setUseCastKeyword(false); + castExpr.setLeftExpression(retval); + castExpr.setColDataType(type); + retval = castExpr; + timezoneExpr = null; + } + )* + ) + )* + { - pivotQuery.setFromItem(fromItem); - pivotQuery.setOnExpressions(onExpressions); - pivotQuery.setUsingItems(usingItems); - pivotQuery.setGroupByExpressions(groupByExpressions); - return pivotQuery; + if (timezoneExpr != null) { + linkTimezones(timezoneExpr, timezoneFirst); + } + // each value gets a range node only once something wraps it, the outermost takes jjtThis + Token valueFirst = coreFirst; + if (innerSigns != null) { + for (int i = innerSigns.size() - 1; i >= 0; i--) { + linkASTIfMissing(retval, valueFirst); + retval = new SignedExpression(innerSigns.get(i).image.charAt(0), retval); + valueFirst = innerSigns.get(i); + } + } + if (sign != null) { + linkASTIfMissing(retval, valueFirst); + retval = new SignedExpression(sign.image.charAt(0), retval); + valueFirst = sign; + } + if (not) { + linkASTIfMissing(retval, valueFirst); + retval = new NotExpression(retval, exclamationMarkNot); + } + linkAST(retval, jjtThis); + return retval; } } -SelectItem> ExpressionListItem(): -{ - ExpressionList expressionList; - Alias alias = null; -} -{ - expressionList=ParenthesedExpressionList() - [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() ] - { return new SelectItem>(expressionList, alias); } -} +/* https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/hierarchical_query_clause.html -List>> PivotMultiInItems(): -{ - List>> retval = new ArrayList>>(); - SelectItem> item; + { CONNECT BY [ NOCYCLE ] condition [ START WITH condition ] + | START WITH condition CONNECT BY [ NOCYCLE ] condition + } + */ + +ConnectByRootOperator ConnectByRootOperator() #ConnectByRootOperator: { + Expression expression; } { - item = ExpressionListItem() {retval.add(item);} - ("," item = ExpressionListItem() {retval.add(item);} )* - { return retval; } + expression = Expression() + { + return new ConnectByRootOperator(expression); + } } -Pivot Pivot(): -{ - Pivot retval = new Pivot(); - List> functionItems; - ExpressionList forColumns; - List> singleInItems = null; - List>> multiInItems = null; - Alias alias = null; +ConnectByPriorOperator ConnectByPriorOperator() #ConnectByPriorOperator: { + Expression expression; } { - "(" functionItems = PivotFunctionItems() - forColumns = PivotForColumns() - "(" - (LOOKAHEAD(3) singleInItems = SelectItemsList() - | multiInItems = PivotMultiInItems() ) - ")" - ")" - [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] + expression = Expression() { - retval.setFunctionItems(functionItems); - retval.setForColumns(forColumns); - retval.setSingleInItems(singleInItems); - retval.setMultiInItems(multiInItems); - retval.setAlias(alias); - return retval; + return new ConnectByPriorOperator(expression); } } -PivotXml PivotXml(): -{ - PivotXml retval = new PivotXml(); - List> functionItems; - ExpressionList forColumns; - List> singleInItems = null; - List>> multiInItems = null; - Select inSelect = null; +KeyExpression KeyExpression() #KeyExpression: { + Expression expression; } { - "(" functionItems = PivotFunctionItems() - forColumns = PivotForColumns() - "(" - ( - LOOKAHEAD(2) { retval.setInAny(true); } | - LOOKAHEAD(1) inSelect = Select() | - LOOKAHEAD(2) singleInItems =SelectItemsList() | - multiInItems = PivotMultiInItems() - ) - ")" - ")" + expression = Expression() { - retval.setFunctionItems(functionItems); - retval.setForColumns(forColumns); - retval.setSingleInItems(singleInItems); - retval.setMultiInItems(multiInItems); - retval.setInSelect(inSelect); - return retval; + return new KeyExpression(expression); } } -UnPivot UnPivot(): -{ - UnPivot retval = new UnPivot(); - ExpressionList unpivotClause; - ExpressionList unpivotForClause; - List> unpivotInClause; - Alias alias = null; + +NextValExpression NextValExpression() : { + ObjectNames data = null; + Token token; } { - - [ ( { retval.setIncludeNulls(true); } - | { retval.setIncludeNulls(false); } ) ] - "(" unpivotClause = PivotForColumns() - unpivotForClause = PivotForColumns() - "(" - unpivotInClause = SelectItemsList() - ")" - ")" - [ LOOKAHEAD({ isAliasAhead() }) alias = Alias() ] + token= data = RelObjectNames() { - retval.setUnPivotClause(unpivotClause); - retval.setUnPivotForClause(unpivotForClause); - retval.setUnPivotInClause(unpivotInClause); - retval.setAlias(alias); - return retval; + return new NextValExpression(data.getNames(), token.image); } } -List
IntoClause(): -{ - List
tables = new ArrayList
(); - Table table; +JdbcNamedParameter JdbcNamedParameter() : { + JdbcNamedParameter parameter = new JdbcNamedParameter(); + String name; + String namePart; } { - table=Table() { tables.add(table); } ( LOOKAHEAD(2) "," table=Table() { tables.add(table); } )* + (":" | "&" { parameter.setParameterCharacter("&"); } ) + name=IdentifierChain() { - return tables; + parameter.setName(name); + return parameter; } } -MySqlSelectIntoClause MySqlSelectIntoClause(MySqlSelectIntoClause.Position position): -{ - MySqlSelectIntoClause intoClause = new MySqlSelectIntoClause().withPosition(position); - Token token; - ExpressionList variables = new ExpressionList(); - UserVariable variable; +OracleNamedFunctionParameter OracleNamedFunctionParameter() : { + Token token = null; + String name = null; + Expression expression; } { - - ( - { intoClause.setType(MySqlSelectIntoClause.Type.OUTFILE); } - token= { intoClause.setFileName(new StringValue(token.image)); } - MySqlSelectIntoOutfileTail(intoClause) - | - { intoClause.setType(MySqlSelectIntoClause.Type.DUMPFILE); } - token= { intoClause.setFileName(new StringValue(token.image)); } - | - LOOKAHEAD({ isMySqlDialect() }) - variable=MySqlIntoVariable() { variables.add(variable); } - // Same shape as IntoClause() above: a PlainSelect can be followed by "," (subselect in - // an expression list), so the repetition needs two tokens to decide. - ( LOOKAHEAD(2) "," variable=MySqlIntoVariable() { variables.add(variable); } )* - { intoClause.setType(MySqlSelectIntoClause.Type.VARIABLES); intoClause.setVariables(variables); } - ) + ( name=RelObjectNameExt() | token= ) + + expression=Expression() { - return intoClause; + return new OracleNamedFunctionParameter(name != null ? name : token.image, expression); } } -UserVariable MySqlIntoVariable(): -{ - UserVariable variable; - Token name; +PostgresNamedFunctionParameter PostgresNamedFunctionParameter() : { + Token token = null; + String name = null; + Expression expression; } { - ( - variable=UserVariable() - | - (name= | name=) - { variable = new UserVariable("@" + name.image); } - ) - { return requireMySqlIntoVariable(variable); } + ( name=RelObjectNameExt() | token= ) + + expression=Expression() + { + return new PostgresNamedFunctionParameter(name != null ? name : token.image, expression); + } } -MySqlProcedureAnalyse MySqlProcedureAnalyse(): -{ - MySqlProcedureAnalyse procedureAnalyse = new MySqlProcedureAnalyse(); - Token maxElements = null; - Token maxMemory = null; +UserVariable UserVariable() : { + Token tk; + String varName; } { - "(" - [ - maxElements= - [ "," maxMemory= ] - ] - ")" + tk = varName=IdentifierChain2(tk.image) { - if (maxElements != null) { - procedureAnalyse.setMaxElements(new LongValue(maxElements.image)); - } - if (maxMemory != null) { - procedureAnalyse.setMaxMemory(new LongValue(maxMemory.image)); - } - return procedureAnalyse; + UserVariable result = new UserVariable(varName); + linkAST(result, tk); + return result; } } -void MySqlSelectIntoOutfileTail(MySqlSelectIntoClause intoClause): -{ +NumericBind NumericBind() : { + NumericBind var = new NumericBind(); Token token; } { - ( - LOOKAHEAD( ) - - (token= | token=) - { intoClause.setCharacterSet(token.image); } - ( - LOOKAHEAD(( | )) - MySqlSelectIntoFieldsClause(intoClause) - [ LOOKAHEAD() MySqlSelectIntoLinesClause(intoClause) ] - | - LOOKAHEAD() - MySqlSelectIntoLinesClause(intoClause) - | - { } - ) - | - LOOKAHEAD(( | )) - MySqlSelectIntoFieldsClause(intoClause) - [ LOOKAHEAD() MySqlSelectIntoLinesClause(intoClause) ] - | - LOOKAHEAD() - MySqlSelectIntoLinesClause(intoClause) - | - { } - ) + ":" token= + { + var.setBindId(Integer.valueOf(token.image)); + return var; + } } -void MySqlSelectIntoFieldsClause(MySqlSelectIntoClause intoClause): -{ - Token token; +DateTimeLiteralExpression DateTimeLiteralExpression() : { + DateTimeLiteralExpression expr = new DateTimeLiteralExpression(); + Token t; } { - ( - { intoClause.setFieldsKeyword(MySqlSelectIntoClause.FieldsKeyword.FIELDS); } - | { intoClause.setFieldsKeyword(MySqlSelectIntoClause.FieldsKeyword.COLUMNS); } - ) - ( - LOOKAHEAD( ) - token= - { intoClause.setFieldsTerminatedBy(new StringValue(token.image)); } - ( - LOOKAHEAD(( | )) - [ { intoClause.setFieldsOptionallyEnclosed(true); } ] - token= - { intoClause.setFieldsEnclosedBy(new StringValue(token.image)); } - [ LOOKAHEAD( ) - token= - { intoClause.setFieldsEscapedBy(new StringValue(token.image)); } - ] - | - LOOKAHEAD( ) - token= - { intoClause.setFieldsEscapedBy(new StringValue(token.image)); } - | - { } - ) - | - LOOKAHEAD(( | )) - [ { intoClause.setFieldsOptionallyEnclosed(true); } ] - token= - { intoClause.setFieldsEnclosedBy(new StringValue(token.image)); } - [ LOOKAHEAD( ) - token= - { intoClause.setFieldsEscapedBy(new StringValue(token.image)); } - ] - | - LOOKAHEAD( ) - token= - { intoClause.setFieldsEscapedBy(new StringValue(token.image)); } - | - { } - ) + t= + { + expr.setType(DateTimeLiteralExpression.DateTime.from(t.image)); + } + + ( t= | t= ) + { + expr.setValue(t.image); + return expr; + } } -void MySqlSelectIntoLinesClause(MySqlSelectIntoClause intoClause): +RangeExpression RangeExpression(Expression startExpression): { - Token token; + Expression endExpression; + Token colon = getToken(1); } { - - ( - LOOKAHEAD( ) - token= - { intoClause.setLinesStartingBy(new StringValue(token.image)); } - [ LOOKAHEAD( ) - token= - { intoClause.setLinesTerminatedBy(new StringValue(token.image)); } - ] - | - LOOKAHEAD( ) - token= - { intoClause.setLinesTerminatedBy(new StringValue(token.image)); } - | - { } - ) + ":" endExpression = Expression() + { + RangeExpression result = new RangeExpression(startExpression, endExpression); + linkAST(result, firstToken(startExpression, colon)); + return result; + } } -FromItem ParenthesedFromItem(): -{ - ParenthesedFromItem ParenthesedFromItem = new ParenthesedFromItem(); - FromItem fromItem; - List joins = null; +/** DuckDB's list comprehension {@code [expr FOR x[, i] IN list [IF condition]]}. */ +ListComprehension ListComprehension() : { + Expression expression; + List variables = new ArrayList(); + String variable; + Expression list; + Expression condition = null; +} { + "[" + expression=Expression() + variable=RelObjectName() { variables.add(variable); } + [ "," variable=RelObjectName() { variables.add(variable); } ] + list=Expression() + [ condition=Expression() ] + "]" + { return new ListComprehension(expression, variables, list, condition); } } -{ - "(" - fromItem = FromItem() - [ joins=JoinsList() ] - ")" +ArrayConstructor ArrayConstructor(boolean arrayKeyword) : { + ExpressionList expList = new ExpressionList(); + Expression exp; + Token first = getToken(1); +} { + "[" + [ + exp=ArrayElement() { expList.add(exp); } + ( "," exp=ArrayElement() { expList.add(exp); } )* + ] + "]" { - return ParenthesedFromItem.withFromItem(fromItem).withJoins(joins); + ArrayConstructor result = new ArrayConstructor(linkElements(expList), arrayKeyword); + // after ARRAY, the caller links the constructor from that keyword + if (!arrayKeyword) { + linkAST(result, first); + } + return result; } } -FromItem FromItem() #FromItem: +Expression ArrayElement(): { - FromItem fromItem = null; - FromItem fromItem2 = null; - SampleClause sampleClause; - Pivot pivot = null; - UnPivot unpivot = null; - Alias alias = null; - MySQLIndexHint indexHint = null; - SQLServerHints sqlServerHints = null; - Select select; - - String timeTravelStr = null; + Expression expression; } { - ( - LOOKAHEAD(3, { !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem = Values() - | - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("JSON_TABLE") - && getToken(2).kind == OPENING_BRACKET - }) fromItem=TableFunction() - | - LOOKAHEAD({ - getToken(1).kind == K_LATERAL - && getToken(2).kind == S_IDENTIFIER - && getToken(2).image.equalsIgnoreCase("JSON_TABLE") - && getToken(3).kind == OPENING_BRACKET - }) fromItem=TableFunction() - | - LOOKAHEAD({ - (getToken(1).kind == K_ROWS - && getToken(2).kind == K_FROM - && getToken(3).kind == OPENING_BRACKET) - || (isFunctionAhead() && getToken(1).kind != K_LATERAL) - || (getToken(1).kind == K_LATERAL && getToken(2).kind != OPENING_BRACKET) }) - fromItem=TableFunction() - | - LOOKAHEAD(3) fromItem=TableReference() - | - LOOKAHEAD({ isNestedSetOperationAhead() }) ( - fromItem=ParenthesedSelect() - [ LOOKAHEAD(2) pivot=Pivot() { fromItem.setPivot(pivot); } ] - [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] - ) - | - LOOKAHEAD({ isParenthesedFromItemAhead() }) fromItem = ParenthesedFromItem() - | - LOOKAHEAD(3, { !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) ( - fromItem=ParenthesedSelect() - [ LOOKAHEAD(2) pivot=Pivot() { fromItem.setPivot(pivot); } ] - [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] - ) - | - fromItem=LateralSubSelect() - | - LOOKAHEAD(2, { Dialect.EXASOL.name().equals(getAsString(Feature.dialect)) }) fromItem=SubImport() { fromItem = new ParenthesedFromItem(fromItem); } - | - LOOKAHEAD({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) fromItem=Select() - ) + expression=Expression() [ expression=RangeExpression(expression) ] + { return expression; } +} - [ LOOKAHEAD({ !isMatchRecognizeAhead() && isAliasAhead() }) alias=Alias() { fromItem.setAlias(alias); } ] - [ - // BigQuery: UNNEST(array) AS alias WITH OFFSET AS offsetAlias - LOOKAHEAD(2, { fromItem instanceof TableFunction }) - { ((TableFunction) fromItem).setWithOffset(true); } - [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() - { ((TableFunction) fromItem).setOffsetAlias(alias); } ] - ] - [ - LOOKAHEAD(2, {fromItem instanceof Table }) timeTravelStr = TimeTravelAfterAlias() - { ((Table) fromItem).setTimeTravelStrAfterAlias(timeTravelStr); } - ] - ( - LOOKAHEAD({ isMatchRecognizeAhead() }) fromItem=MatchRecognize(fromItem) - [ LOOKAHEAD(2) ( LOOKAHEAD(2) pivot=PivotXml() | pivot=Pivot() ) { fromItem.setPivot(pivot); } ] - [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] - [ LOOKAHEAD({ isAliasAhead() }) alias=Alias() { fromItem.setAlias(alias); } ] - [ LOOKAHEAD(2) sampleClause=SampleClause() { fromItem.setSampleClause(sampleClause); } ] - | - [ LOOKAHEAD(2) sampleClause = SampleClause() { fromItem.setSampleClause(sampleClause); } ] - [ LOOKAHEAD(2) unpivot=UnPivot() { fromItem.setUnPivot(unpivot); } ] - [ LOOKAHEAD(2) ( LOOKAHEAD(2) pivot=PivotXml() | pivot=Pivot() ) { fromItem.setPivot(pivot); } ] - ) +MapExpression MapExpression() #MapExpression: +{ + MapExpression mapExpression = new MapExpression(); + Expression key; + Expression value; +} +{ + [ - LOOKAHEAD(2) + key = MapKeyExpression() value = Expression() + { mapExpression.addEntry(key, value); } ( - indexHint = MySQLIndexHint() { - if (fromItem instanceof Table) - ((Table) fromItem).setHint(indexHint); - } - | - sqlServerHints = SQLServerHints() { - if (fromItem instanceof Table) - ((Table) fromItem).setSqlServerHints(sqlServerHints); - } - ) + "," key = MapKeyExpression() value = Expression() + { mapExpression.addEntry(key, value); } + )* ] + { - linkAST(fromItem,jjtThis); - return fromItem; + linkAST(mapExpression, jjtThis); + return mapExpression; } } +Expression MapKeyExpression(): +{ + Expression key; +} +{ + try { + { mapKeyDepth++; } + key = Expression() + } finally { + mapKeyDepth--; + } + { return key; } +} -MatchRecognize MatchRecognize(FromItem input) #MatchRecognize: +List> StructParameters(): { - MatchRecognize result = new MatchRecognize(input); - ExpressionList partition; - List ordering; - List> measures; - MatchRecognize.Definition definition; - MatchRecognize.Subset subset; - RowPattern pattern; - MatchRecognize.Options options = null; - String variable; - Token value; + String parameterName = ""; + ColDataType parameterType = null; + AbstractMap.SimpleEntry parameter = null; + List> parameters = new ArrayList>(); } { - ContextualKeyword("MATCH_RECOGNIZE") "(" - [ partition=SimpleExpressionList() { result.setPartitionBy(partition); } ] - [ LOOKAHEAD(2) ordering=OrderByElements() { result.setOrderByElements(ordering); } ] - [ LOOKAHEAD({ isKeywordAhead("MEASURES") }) ContextualKeyword("MEASURES") measures=SelectItemsList() + [ LOOKAHEAD(2) parameterName = RelObjectName() ] + parameterType = ColDataType() + { + parameters.add( new AbstractMap.SimpleEntry(parameterName, parameterType) ); + } + + ( + "," { parameterName=""; } + + [ LOOKAHEAD(2) parameterName = RelObjectName() ] + parameterType = ColDataType() { - for (SelectItem measure : measures) { - if (measure.getAlias() == null) { throw new ParseException("MATCH_RECOGNIZE measures require an alias"); } - } - result.setMeasures(measures); + parameters.add( new AbstractMap.SimpleEntry(parameterName, parameterType) ); } - ] - [ - LOOKAHEAD({ isKeywordAhead("ONE") || getToken(1).kind == K_ALL }) - ( LOOKAHEAD({ isKeywordAhead("ONE") }) ContextualKeyword("ONE") ContextualKeyword("PER") - { result.setRowsPerMatch(MatchRecognize.RowsPerMatch.ONE); } - | ContextualKeyword("PER") - { result.setRowsPerMatch(MatchRecognize.RowsPerMatch.ALL); } - [ - ContextualKeyword("MATCHES") - { result.setEmptyMatchMode(MatchRecognize.EmptyMatchMode.SHOW); } - | LOOKAHEAD({ isKeywordAhead("OMIT") }) ContextualKeyword("OMIT") ContextualKeyword("MATCHES") - { result.setEmptyMatchMode(MatchRecognize.EmptyMatchMode.OMIT); } - | ContextualKeyword("UNMATCHED") - { result.setEmptyMatchMode(MatchRecognize.EmptyMatchMode.WITH_UNMATCHED); } - ] + )* + + { + return parameters; + } +} + +StructType StructType() #StruckType: +{ + StructType.Dialect dialect = StructType.Dialect.BIG_QUERY; + Token tk1; + String keyword = ""; + List> parameters = null; + List> arguments = null; + String id = null; + Expression expression = null; + StructType type; +} +{ + ( + LOOKAHEAD(4) ( + tk1= { keyword = tk1.image; } + "<" parameters = StructParameters() ">" + "(" arguments = SelectItemsList() ")" ) - ] - [ LOOKAHEAD({ isKeywordAhead("AFTER") }) ContextualKeyword("AFTER") - ( LOOKAHEAD({ isKeywordAhead("PAST") }) ContextualKeyword("PAST") - { result.setSkipMode(MatchRecognize.SkipMode.PAST_LAST_ROW); } - | - ( LOOKAHEAD(2) { result.setSkipMode(MatchRecognize.SkipMode.TO_NEXT_ROW); } - | { result.setSkipMode(MatchRecognize.SkipMode.TO_VARIABLE); } - [ LOOKAHEAD({ (getToken(1).kind == K_FIRST || getToken(1).kind == K_LAST) - && !("PATTERN".equalsIgnoreCase(getToken(2).image) && getToken(3).kind == OPENING_BRACKET) }) - ( { result.setSkipMode(MatchRecognize.SkipMode.TO_FIRST); } - | { result.setSkipMode(MatchRecognize.SkipMode.TO_LAST); } ) ] - variable=RelObjectName() { result.setSkipVariable(variable); } - ) + | + ( + tk1= { keyword = tk1.image; } + "(" arguments = SelectItemsList() ")" ) - ] - ContextualKeyword("PATTERN") "(" pattern=RowPattern(0) ")" { result.setPattern(pattern); } - [ LOOKAHEAD({ isKeywordAhead("SUBSET") }) ContextualKeyword("SUBSET") subset=MatchRecognizeSubset() - { result.getSubsets().add(subset); } - ( LOOKAHEAD(2) "," subset=MatchRecognizeSubset() { result.getSubsets().add(subset); } )* - ] - ContextualKeyword("DEFINE") definition=MatchRecognizeDefinition() { result.getDefinitions().add(definition); } - ( LOOKAHEAD(2) "," definition=MatchRecognizeDefinition() { result.getDefinitions().add(definition); } )* - [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) ContextualKeyword("OPTIONS") "(" - { options = new MatchRecognize.Options(); } - [ LOOKAHEAD({ isKeywordAhead("use_longest_match") }) ContextualKeyword("use_longest_match") "=" - ( value= | value= ) { options.setUseLongestMatch(value.kind == K_TRUE); } - ] - ")" { result.setOptions(options); } - ] - ")" + | + ( + { arguments= new ArrayList>(); dialect = StructType.Dialect.DUCKDB;} + ( id = RelObjectNameExt() | tk1= { id = tk1.image; } ) + expression = Expression() { arguments.add( new SelectItem( expression, id) ); } + + ( + "," + ( id = RelObjectNameExt() | tk1= { id = tk1.image; } ) + expression = Expression() { arguments.add( new SelectItem( expression, id) ); } + )* + + + ( + LOOKAHEAD(2) "::" "(" parameters = StructParameters() ")" + )* + ) + ) { - if (Dialect.BIGQUERY.name().equals(getAsString(Feature.dialect))) { - if (result.getOrderByElements().isEmpty() || result.getMeasures().isEmpty()) { - throw new ParseException("BigQuery MATCH_RECOGNIZE requires ORDER BY and MEASURES"); - } - if (result.getRowsPerMatch() != null || result.getSkipVariable() != null || !result.getSubsets().isEmpty()) { - throw new ParseException("BigQuery does not support ROWS PER MATCH, SKIP TO a variable or SUBSET"); - } - } - linkAST(result, jjtThis); return result; + type = new StructType(dialect, keyword, parameters, arguments); + linkAST(type,jjtThis); + return type; } } -MatchRecognize.Subset MatchRecognizeSubset() #MatchRecognizeSubset: +/** + * The element after a ":" in a JSON path (Snowflake, Databricks). A path name is mandatory there, + * so any word is a name, reserved or not: v:from::INT, v:select, v:output.x[0]. + */ +Expression JsonPathElement() #void: +{ Expression element; } { - String name; - String variable; - List variables = new ArrayList(); + ( + LOOKAHEAD({ isKeywordJsonPathName() || isJsonPathWithKeywordAfterDot() }) element=JsonPathKeyword() + | + LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) element=Expression() + | + element=SimpleExpression() + ) + { return element; } +} + +/** + * A keyword used as a JSON path name. The token is taken as it is, as no token kind in the grammar + * stands for "any keyword", then the path name continues like a primary expression: further + * navigation steps, casts and the arithmetic tier SimpleExpression() also applies. + */ +Expression JsonPathKeyword() #void: +{ + Token first = getToken(1); + Token keyword; + Expression element; + Expression step; + ColDataType type; + CastExpression cast; } { - name=RelObjectName() "=" "(" variable=RelObjectName() { variables.add(variable); } - ( "," variable=RelObjectName() { variables.add(variable); } )* ")" { - MatchRecognize.Subset result = new MatchRecognize.Subset(name, variables); - linkAST(result, jjtThis); return result; + keyword = getNextToken(); + element = linkToLastToken(new Column(keyword.image)); + } + ( LOOKAHEAD(2) step=JsonPathStep(element) { element = linked(step, first); } )* + ( + LOOKAHEAD(2) "::" type=ColDataType() { + cast = new CastExpression(); + cast.setUseCastKeyword(false); + cast.setLeftExpression(element); + cast.setColDataType(type); + element = linked(cast, first); + } + )* + { + int arithFloor = Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) ? 2 : 4; + return prattArithRest(element, first, arithFloor); } } -MatchRecognize.Definition MatchRecognizeDefinition() #MatchRecognizeDefinition: +/** + * A navigation step within a JSON path, where a keyword after a "." names a path element as well: + * v:a.output, v:a[0].from. + */ +Expression JsonPathStep(Expression base) #void: +{ Expression step; } { - String name; - Expression expression; + ( + LOOKAHEAD({ ".".equals(getToken(1).image) && isKeywordWord(2) }) "." { + step = new RowGetExpression(base, getNextToken().image); + } + | + step=NavigationStep(base) + ) + { return step; } +} + +JsonExpression JsonExpression(Expression expr, List> idents) : { + JsonExpression result = new JsonExpression(expr, idents); + Expression expression; + Token token=null; + ColDataType type = null; + CastExpression castExpr = null; } { - name=RelObjectName() expression=Expression() + + // chaining JSON Expressions, e.g. + // '{"obj":{"field": "value"}}'::JSON -> 'obj'::TEXT ->> 'field'::TEXT + ( + LOOKAHEAD(2, {!interrupted} ) ( + LOOKAHEAD(2) ( + "::" type=ColDataType() + { + castExpr = new CastExpression(); + castExpr.setUseCastKeyword(false); + castExpr.setLeftExpression(result); + castExpr.setColDataType(type); + expr=castExpr; + } + ) + )+ + { + result = new JsonExpression(expr); + } + + ( + LOOKAHEAD(2, { !isPostgreSqlJsonAccess(getToken(1)) + && ((ternaryThenBranchDepth == 0 && mapKeyDepth == 0 && !isSliceColonAhead()) + || !":".equals(getToken(1).image)) }) ( + token="->" + | + token=":" + | + token="->>" + | + token="#>" + | + token="#>>" + ) + + expression=JsonPathElement() + { + result.addIdent( expression, token.image ); + } + )* + )* + { - MatchRecognize.Definition result = new MatchRecognize.Definition(name, expression); - linkAST(result, jjtThis); + result.setExpression(expr); return result; } } -RowPattern RowPattern(int depth) #RowPattern: -{ - List alternatives = new ArrayList(); - RowPattern pattern; - Token separator; +JsonKeyValuePair JsonKeyValuePair(boolean isFirstEntry) : { + Token keyToken; + + boolean usingKeyKeyword = false; + boolean usingFormatJason = false; + String encoding = null; + boolean isWildcard = false; + + Object key = null; + Expression expression = null; + JsonFunctionExpression functionExpression; + + JsonKeyValuePairSeparator kvSeparator = JsonKeyValuePairSeparator.NOT_USED; } { - { - if (depth > getAsLong(Feature.allowedNestingDepth)) { - throw new ParseException("Row pattern exceeds the allowed nesting depth"); - } - } ( - LOOKAHEAD({ Dialect.SNOWFLAKE.name().equals(getAsString(Feature.dialect)) }) - pattern=SnowflakeRowPatternSequence(depth) { alternatives.add(pattern); } + // lookahead because key is a valid column name + LOOKAHEAD(2) ( + { usingKeyKeyword = true; } + ( + keyToken = { key = keyToken.image; } | + key = Column() + ) + ) | - pattern=RowPatternSequence(depth) { alternatives.add(pattern); } - ( ( separator= | separator= ) - { if (separator.kind == OP_CONCAT) { alternatives.add(new RowPattern.Empty()); } } - pattern=RowPatternSequence(depth) { alternatives.add(pattern); } - )* + LOOKAHEAD(16) key = AllTableColumns(false) { isWildcard = true; } + | + LOOKAHEAD(2) key = AllColumns(false) { isWildcard = true; } + | + LOOKAHEAD(2) key = Column() + | + LOOKAHEAD({getAsBoolean(Feature.allowExpressionAsJsonObjectKey)}) key = Expression() + | + keyToken = { key = keyToken.image; } ) - { - RowPattern result = alternatives.size() == 1 ? alternatives.get(0) - : new RowPattern.Operation(RowPattern.Operation.Type.ALTERNATION, alternatives); - linkAST(result, jjtThis); - return result; - } -} -RowPattern SnowflakeRowPatternSequence(int depth) #SnowflakeRowPatternSequence: -{ - List patterns = new ArrayList(); - RowPattern pattern; -} -{ - ( LOOKAHEAD({ isRowPatternPrimaryAhead() }) pattern=SnowflakeRowPatternAlternative(depth) { patterns.add(pattern); } )* + // Optional Separator + Value - Is not allowed with * or t1.* + [ LOOKAHEAD(1, { !isWildcard } ) + ( + { kvSeparator = JsonKeyValuePairSeparator.VALUE; } + | + { kvSeparator = JsonKeyValuePairSeparator.COLON; } + | + LOOKAHEAD({getAsBoolean(Feature.allowCommaAsKeyValueSeparator)}) { kvSeparator = JsonKeyValuePairSeparator.COMMA; } + ) + expression = Expression() + ] + + // Optional: FORMAT JSON [ ENCODING ... ] - Is not allowed with * or t1.* + [ + LOOKAHEAD(1, { !isWildcard } ) { usingFormatJason = true; } + [ encoding = JsonEncoding() ] + ] { - RowPattern result = patterns.isEmpty() ? new RowPattern.Empty() - : patterns.size() == 1 ? patterns.get(0) - : new RowPattern.Operation(RowPattern.Operation.Type.SEQUENCE, patterns); - linkAST(result, jjtThis); return result; - } + final JsonKeyValuePair keyValuePair = new JsonKeyValuePair( key, expression, usingKeyKeyword, kvSeparator ); + keyValuePair.setUsingFormatJson( usingFormatJason ); + keyValuePair.setEncoding(encoding); + return keyValuePair; + } } -RowPattern SnowflakeRowPatternAlternative(int depth) #SnowflakeRowPatternAlternative: -{ - List patterns = new ArrayList(); - RowPattern pattern; +JsonFunction JsonObjectBody() : { + JsonFunction result = new JsonFunction(JsonFunctionType.OBJECT); + + JsonKeyValuePair keyValuePair; + ColDataType dataType; + String encoding; } { - pattern=RowPatternFactor(depth) { patterns.add(pattern); } - ( pattern=RowPatternFactor(depth) { patterns.add(pattern); } )* + ( "(" + ( + // First Element + LOOKAHEAD(2, { !isJsonConstructorClauseAhead() }) + keyValuePair = JsonKeyValuePair(true) { result.add(keyValuePair);} + + // Next Elements + ( + keyValuePair = JsonKeyValuePair(false) { result.add(keyValuePair); } + )* + )? + [ + ( { result.setOnNullType( JsonAggregateOnNullType.NULL ); } ) + | + ( { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } ) + ] + [ { result.setStrict(true); } ] + [ + ( { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); } ) + | + ( { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); } ) + ] + [ + dataType = ColDataType() { result.setReturningType(dataType); } + [ + { result.setReturningFormatJson(true); } + [ encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ] + ] + ] + ")" ) { - RowPattern result = patterns.size() == 1 ? patterns.get(0) - : new RowPattern.Operation(RowPattern.Operation.Type.ALTERNATION, patterns); - linkAST(result, jjtThis); return result; + return result; } } -RowPattern RowPatternSequence(int depth): -{ - List patterns = new ArrayList(); - RowPattern pattern; +JsonFunction JsonArrayBody() : { + JsonFunction result = new JsonFunction(JsonFunctionType.ARRAY); + + Expression expression = null; + JsonFunctionExpression functionExpression; + ColDataType dataType; + String encoding; } { - ( LOOKAHEAD({ isRowPatternPrimaryAhead() }) pattern=RowPatternFactor(depth) { patterns.add(pattern); } )* + ( "(" + ( + LOOKAHEAD(2) ( + { result.setOnNullType( JsonAggregateOnNullType.NULL ); } + ) + | + LOOKAHEAD(1, { !isJsonConstructorClauseAhead() }) + expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); } + + [ + LOOKAHEAD(2) { functionExpression.setUsingFormatJson( true ); } + [ LOOKAHEAD(2) encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ] + ] + ( + "," + expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); } + [ + LOOKAHEAD(2) { functionExpression.setUsingFormatJson( true ); } + [ LOOKAHEAD(2) encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ] + ] + )* + )* + + [ + { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } + ] + [ + dataType = ColDataType() { result.setReturningType(dataType); } + [ + { result.setReturningFormatJson(true); } + [ encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ] + ] + ] + ")" ) { - if (patterns.isEmpty()) { return new RowPattern.Empty(); } - return patterns.size() == 1 ? patterns.get(0) - : new RowPattern.Operation(RowPattern.Operation.Type.SEQUENCE, patterns); + return result; } } -RowPattern RowPatternFactor(int depth) #RowPatternFactor: -{ - RowPattern pattern; - String name; - List permutations = new ArrayList(); +void JsonKeyword(String expectedKeyword) : { + Token token; } { - ( - LOOKAHEAD({ isKeywordAhead("PERMUTE") && getToken(2).kind == OPENING_BRACKET }) - ContextualKeyword("PERMUTE") "(" - pattern=RowPattern(depth + 1) { permutations.add(pattern); } - ( "," pattern=RowPattern(depth + 1) { permutations.add(pattern); } )* ")" - { pattern = new RowPattern.Permute(permutations); } - | "{" "-" pattern=RowPattern(depth + 1) "-" "}" { pattern = new RowPattern.Exclusion(pattern); } - | { pattern = new RowPattern.Anchor(RowPattern.Anchor.Type.START); } - | LOOKAHEAD({ "$".equals(getToken(1).image) }) - { pattern = new RowPattern.Anchor(RowPattern.Anchor.Type.END); } - | "(" pattern=RowPattern(depth + 1) ")" { pattern = new RowPattern.Group(pattern); } - | name=RelObjectName() { pattern = new RowPattern.Variable(name); } - ) + token = { - if (Dialect.BIGQUERY.name().equals(getAsString(Feature.dialect)) - && (pattern instanceof RowPattern.Permute || pattern instanceof RowPattern.Exclusion)) { - throw new ParseException("BigQuery does not support PERMUTE or row pattern exclusion"); + if (!token.image.equalsIgnoreCase(expectedKeyword)) { + throw new ParseException( + "Expected keyword " + expectedKeyword + " but found " + token.image); } } - [ LOOKAHEAD({ !(pattern instanceof RowPattern.Anchor) - && ("?".equals(getToken(1).image) || "*".equals(getToken(1).image) - || "+".equals(getToken(1).image) || getToken(1).kind == OPENING_CURLY_BRACKET) }) - pattern=RowPatternQuantifier(pattern) - ] - { linkAST(pattern, jjtThis); return pattern; } } -RowPattern RowPatternQuantifier(RowPattern pattern) #RowPatternQuantifier: -{ - RowPattern.Quantified result; - Expression lower = null; - Expression upper = null; - boolean range = false; -} -{ - ( - "*" { result = new RowPattern.Quantified(pattern, RowPattern.Quantified.Type.ZERO_OR_MORE); } - | "+" { result = new RowPattern.Quantified(pattern, RowPattern.Quantified.Type.ONE_OR_MORE); } - | "?" { result = new RowPattern.Quantified(pattern, RowPattern.Quantified.Type.OPTIONAL); } - | "{" [ LOOKAHEAD({ !",".equals(getToken(1).image) }) lower=RowPatternBound() ] - [ "," { range = true; } [ LOOKAHEAD({ getToken(1).kind != CLOSING_CURLY_BRACKET }) upper=RowPatternBound() ] ] "}" - { - if (lower == null && upper == null) { throw new ParseException("Row pattern quantifier requires a bound"); } - result = new RowPattern.Quantified(pattern, range ? RowPattern.Quantified.Type.RANGE : RowPattern.Quantified.Type.EXACT) - .setLowerBound(lower).setUpperBound(upper); - } - ) - [ LOOKAHEAD({ (result.getType() != RowPattern.Quantified.Type.EXACT - || !Dialect.BIGQUERY.name().equals(getAsString(Feature.dialect))) && "?".equals(getToken(1).image) }) "?" { result.setReluctant(true); } ] - { linkAST(result, jjtThis); return result; } +String JsonEncoding() : { + Token token; } - -Expression RowPatternBound(): { - Token value; - Expression result; + token = + { + if (token.image.equalsIgnoreCase("UTF8")) { + return "UTF8"; + } else if (token.image.equalsIgnoreCase("UTF16")) { + return "UTF16"; + } else if (token.image.equalsIgnoreCase("UTF32")) { + return "UTF32"; + } + throw new ParseException( + "Expected ENCODING value UTF8, UTF16 or UTF32 but found " + token.image); + } +} + +JsonFunctionExpression JsonValueOrQueryInputExpression() : { + Expression expression; + JsonFunctionExpression functionExpression; + String encoding; } { - ( value= { result = new LongValue(value.image); } - | "?" { result = new JdbcParameter(++jdbcParameterIndex, false, "?"); } - | result=UserVariable() - ) - { return result; } + expression = Expression() { functionExpression = new JsonFunctionExpression(expression); } + [ + { functionExpression.setUsingFormatJson(true); } + [ encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ] + ] + { + return functionExpression; + } } -List JoinsList(): -{ - List joinsList = new ArrayList(); - Join join = null; +JsonFunction.JsonOnResponseBehavior JsonValueOnResponseBehavior() : { + JsonFunction.JsonOnResponseBehavior behavior; + Expression expression; } { - ( LOOKAHEAD(2) join=JoinerExpression() { joinsList.add(join); } )+ + ( + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.ERROR); + } + | + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.NULL); + } + | + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.EMPTY); + } + | + expression = Expression() + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.DEFAULT, expression); + } + ) { - return joinsList; + return behavior; } } -JoinHint JoinHint(): -{ +JsonFunction.JsonOnResponseBehavior JsonQueryOnResponseBehavior() : { + JsonFunction.JsonOnResponseBehavior behavior = null; Token token; } { ( - token = + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.ERROR); + } | - token = + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.NULL); + } | - token = + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.TRUE); + } | - token = + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.FALSE); + } + | + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.EMPTY); + } + [ + ( + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.EMPTY_ARRAY); + } + | + JsonKeyword("OBJECT") + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.EMPTY_OBJECT); + } + ) + ] ) { - return new JoinHint(token.image); + return behavior; } } -JoinHint DorisJoinHint(): -{ - Token token; +JsonFunction.JsonOnResponseBehavior JsonExistsOnResponseBehavior() : { + JsonFunction.JsonOnResponseBehavior behavior = null; } { - "[" ( - LOOKAHEAD({ isKeywordAhead("SHUFFLE") }) token= + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.TRUE); + } | - LOOKAHEAD({ isKeywordAhead("BROADCAST") }) token= + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.FALSE); + } + | + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.UNKNOWN); + } + | + + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.ERROR); + } ) - "]" - { return new JoinHint(token.image, JoinHint.Position.AFTER_JOIN); } + { + return behavior; + } } -Join JoinerExpression() #JoinerExpression: +JsonFunction JsonExistsBody() : { + JsonFunction result = new JsonFunction(JsonFunctionType.EXISTS); + JsonFunctionExpression inputExpression; + Expression expression; + JsonFunction.JsonOnResponseBehavior behavior; +} { - Join join = new Join(); - FromItem right = null; - Expression onExpression = null; - Column tableColumn; - List columns = null; - KSQLJoinWindow joinWindow = null; - JoinHint joinHint = null; - Token tk = null; + "(" + inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); } + "," + expression = Expression() { result.setJsonPathExpression(expression); } + + [ + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) + JsonKeyword("PASSING") + expression = Expression() { result.addPassingExpression(expression); } + ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )* + ] + + [ + LOOKAHEAD( JsonExistsOnResponseBehavior() ) + behavior = JsonExistsOnResponseBehavior() + + { result.setOnErrorBehavior(behavior); } + ] + ")" + { + return result; + } +} + +JsonFunction JsonValueBody() : { + JsonFunction result = new JsonFunction(JsonFunctionType.VALUE); + JsonFunctionExpression inputExpression; + Expression expression; + ColDataType dataType; + JsonFunction.JsonOnResponseBehavior behavior; } { - [ LOOKAHEAD({ isAsOfJoinAhead() }) { join.setAsOf(true); } ] - [ { join.setGlobal(true); } ] - [ { join.setAny(true); } | { join.setAll(true); } ] - [ { join.setNatural(true); } ] + "(" + inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); } + "," + expression = Expression() { result.setJsonPathExpression(expression); } [ - ( - { join.setLeft(true); } [ { join.setSemi(true); } | { join.setAnti(true); } | { join.setOuter(true); } | { join.setAny(true); } | { join.setAll(true); } ] - | - ( - { join.setRight(true); } - | - { join.setFull(true); } - ) [ { join.setSemi(true); } | { join.setAnti(true); } | { join.setOuter(true); } | { join.setAny(true); } | { join.setAll(true); } ] - | - { join.setInner(true); } - | - // DuckDB allows SEMI/ANTI without a LEFT prefix - LOOKAHEAD({ isSemiAntiJoinAhead() }) - ( { join.setSemi(true); } | { join.setAnti(true); } ) - ) - | - { join.setCross(true); } - | - { join.setOuter(true); } + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) + JsonKeyword("PASSING") + expression = Expression() { result.addPassingExpression(expression); } + ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )* + ] + + [ dataType = ColDataType() { result.setReturningType(dataType); } ] + + [ + LOOKAHEAD( JsonValueOnResponseBehavior() ) + behavior = JsonValueOnResponseBehavior() + + { result.setOnEmptyBehavior(behavior); } + ] + + [ + LOOKAHEAD( JsonValueOnResponseBehavior() ) + behavior = JsonValueOnResponseBehavior() + + { result.setOnErrorBehavior(behavior); } + ] + ")" + { + return result; + } +} + +JsonFunction JsonQueryBody() : { + JsonFunction result = new JsonFunction(JsonFunctionType.QUERY); + JsonFunctionExpression inputExpression; + Expression expression; + ColDataType dataType; + JsonFunction.JsonOnResponseBehavior behavior; + Token token; + String encoding; + ColDataType additionalReturningType; + boolean additionalReturningFormatJson; + String additionalReturningEncoding; + JsonFunction.JsonWrapperType additionalWrapperType; + JsonFunction.JsonWrapperMode additionalWrapperMode; + boolean additionalWrapperArray; + JsonFunction.JsonQuotesType additionalQuotesType; + boolean additionalQuotesOnScalarString; + JsonFunction.JsonOnResponseBehavior additionalOnEmptyBehavior; + JsonFunction.JsonOnResponseBehavior additionalOnErrorBehavior; + StringBuilder additionalBuilder; + boolean hasPassingClause = false; +} +{ + "(" + inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); } + "," + expression = Expression() { result.setJsonPathExpression(expression); } + + [ + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) + JsonKeyword("PASSING") { hasPassingClause = true; } + expression = Expression() { result.addPassingExpression(expression); } + ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )* ] - [ { join.setArray(true); } ] + [ + dataType = ColDataType() { result.setReturningType(dataType); } + [ + { result.setReturningFormatJson(true); } + [ encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ] + ] + ] - ( + [ ( - [ joinHint=JoinHint() {join.setJoinHint(joinHint); } ] - - [ LOOKAHEAD("[", { Dialect.DORIS.name().equals(getAsString(Feature.dialect)) }) + { result.setWrapperType(JsonFunction.JsonWrapperType.WITHOUT); } + [ { result.setWrapperArray(true); } ] + JsonKeyword("WRAPPER") + | + { result.setWrapperType(JsonFunction.JsonWrapperType.WITH); } + [ + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && (getToken(1).image.equalsIgnoreCase("CONDITIONAL") + || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL")) + }) + token = { - if (joinHint != null) { - throw new ParseException("Only one join hint is allowed per JOIN"); + if (token.image.equalsIgnoreCase("CONDITIONAL")) { + result.setWrapperMode(JsonFunction.JsonWrapperMode.CONDITIONAL); + } else { + result.setWrapperMode(JsonFunction.JsonWrapperMode.UNCONDITIONAL); } } - joinHint=DorisJoinHint() { join.setJoinHint(joinHint); } ] - [ { join.setFetch(true); } ] + [ { result.setWrapperArray(true); } ] + JsonKeyword("WRAPPER") ) - | - "," { join.setSimple(true); } ( { join.setOuter(true); } )? - | - { join.setStraight(true); } - | - {join.setApply(true); } - ) - - right=FromItem() + ] - // DuckDB 2.0: JOIN products APPROX NEAREST 2 BY SIMILARITY array_cosine_similarity(...) [ - LOOKAHEAD({ isApproxNearestAhead() }) - tk= { join.setApproxNearest(Long.valueOf(tk.image)); } - onExpression=Expression() { join.setSimilarity(onExpression); } + LOOKAHEAD({ + getToken(1).kind == K_KEEP + || (getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("OMIT")) + }) + ( + { result.setQuotesType(JsonFunction.JsonQuotesType.KEEP); } + | + JsonKeyword("OMIT") { result.setQuotesType(JsonFunction.JsonQuotesType.OMIT); } + ) + JsonKeyword("QUOTES") + [ + JsonKeyword("SCALAR") + { result.setQuotesOnScalarString(true); } + ] ] + [ - LOOKAHEAD(2) ( - [ joinWindow = KSQLJoinWindowClause() {join.setJoinWindow(joinWindow);} ] - ( onExpression=Expression() { join.addOnExpression(onExpression); } - ( LOOKAHEAD({ getToken(1).kind == K_ON && !isInsertOnConflictAhead() }) onExpression=Expression() { join.addOnExpression(onExpression); } )* - ) - | - ( - "(" tableColumn=Column() { columns = new ArrayList(); columns.add(tableColumn); } - ( "," tableColumn=Column() { columns.add(tableColumn); } ) * - ")" { join.setUsingColumns(columns); } - ) - ) + LOOKAHEAD( JsonQueryOnResponseBehavior() ) + behavior = JsonQueryOnResponseBehavior() + + { result.setOnEmptyBehavior(behavior); } ] - { - linkAST(join,jjtThis); - join.setFromItem(right); - return join; - } - -} - -/** Shared duration parsing for JOIN, aggregation windows, and grace periods. */ -KSQLWindow.Duration KSQLDuration(): -{ - Token value; - Token unit; -} -{ - value= ( unit= | unit= ) - { return new KSQLWindow.Duration(Long.parseLong(value.image), KSQLWindow.TimeUnit.from(unit.image)); } -} -KSQLWindow.Duration KSQLGracePeriod(): -{ - KSQLWindow.Duration duration; -} -{ - AccessKeyword("GRACE") AccessKeyword("PERIOD") duration=KSQLDuration() - { return duration; } -} + [ + LOOKAHEAD( JsonQueryOnResponseBehavior() ) + behavior = JsonQueryOnResponseBehavior() + + { result.setOnErrorBehavior(behavior); } + ] -KSQLJoinWindow KSQLJoinWindowClause(): -{ - KSQLJoinWindow window; - KSQLWindow.Duration duration; -} -{ ( - "(" window=JoinWindow() ")" - | - duration=KSQLDuration() { - window = new KSQLJoinWindow().withDuration(duration.getValue()) - .withTimeUnit(duration.getTimeUnit()).withUsingBrackets(false); + LOOKAHEAD(2, { !hasPassingClause }) + "," + { + additionalReturningType = null; + additionalReturningFormatJson = false; + additionalReturningEncoding = null; + additionalWrapperType = null; + additionalWrapperMode = null; + additionalWrapperArray = false; + additionalQuotesType = null; + additionalQuotesOnScalarString = false; + additionalOnEmptyBehavior = null; + additionalOnErrorBehavior = null; } - ) - [ LOOKAHEAD({ isKeywordAhead("GRACE") }) duration=KSQLGracePeriod() { window.setGracePeriod(duration); } ] - { return window; } -} - -KSQLJoinWindow JoinWindow(): -{ - KSQLJoinWindow window = new KSQLJoinWindow(); - KSQLWindow.Duration before; - KSQLWindow.Duration after = null; -} -{ - before=KSQLDuration() - [ "," after=KSQLDuration() ] - { - if (after == null) { - window.setDuration(before.getValue()); - window.setTimeUnit(before.getTimeUnit()); - } else { - window.setBeforeDuration(before.getValue()); - window.setBeforeTimeUnit(before.getTimeUnit()); - window.setAfterDuration(after.getValue()); - window.setAfterTimeUnit(after.getTimeUnit()); - window.setBeforeAfterWindow(true); + expression = Expression() + [ + additionalReturningType = ColDataType() + [ + { additionalReturningFormatJson = true; } + [ additionalReturningEncoding = JsonEncoding() ] + ] + ] + [ + ( + + { additionalWrapperType = JsonFunction.JsonWrapperType.WITHOUT; } + [ { additionalWrapperArray = true; } ] + JsonKeyword("WRAPPER") + | + + { additionalWrapperType = JsonFunction.JsonWrapperType.WITH; } + [ + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && (getToken(1).image.equalsIgnoreCase("CONDITIONAL") + || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL")) + }) + token = + { + if (token.image.equalsIgnoreCase("CONDITIONAL")) { + additionalWrapperMode = JsonFunction.JsonWrapperMode.CONDITIONAL; + } else { + additionalWrapperMode = JsonFunction.JsonWrapperMode.UNCONDITIONAL; + } + } + ] + [ { additionalWrapperArray = true; } ] + JsonKeyword("WRAPPER") + ) + ] + [ + LOOKAHEAD({ + getToken(1).kind == K_KEEP + || (getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("OMIT")) + }) + ( + { additionalQuotesType = JsonFunction.JsonQuotesType.KEEP; } + | + JsonKeyword("OMIT") { additionalQuotesType = JsonFunction.JsonQuotesType.OMIT; } + ) + JsonKeyword("QUOTES") + [ + JsonKeyword("SCALAR") { additionalQuotesOnScalarString = true; } + ] + ] + [ + LOOKAHEAD( JsonQueryOnResponseBehavior() ) + additionalOnEmptyBehavior = JsonQueryOnResponseBehavior() + + ] + [ + LOOKAHEAD( JsonQueryOnResponseBehavior() ) + additionalOnErrorBehavior = JsonQueryOnResponseBehavior() + + ] + { + additionalBuilder = new StringBuilder(); + additionalBuilder.append(expression); + if (additionalReturningType != null) { + additionalBuilder.append(" RETURNING ").append(additionalReturningType); + if (additionalReturningFormatJson) { + additionalBuilder.append(" FORMAT JSON"); + if (additionalReturningEncoding != null) { + additionalBuilder.append(" ENCODING ").append(additionalReturningEncoding); + } + } + } + if (additionalWrapperType != null) { + additionalBuilder.append(" ").append(additionalWrapperType); + if (additionalWrapperMode != null) { + additionalBuilder.append(" ").append(additionalWrapperMode); + } + if (additionalWrapperArray) { + additionalBuilder.append(" ARRAY"); + } + additionalBuilder.append(" WRAPPER"); + } + if (additionalQuotesType != null) { + additionalBuilder.append(" ").append(additionalQuotesType).append(" QUOTES"); + if (additionalQuotesOnScalarString) { + additionalBuilder.append(" ON SCALAR STRING"); + } + } + if (additionalOnEmptyBehavior != null) { + additionalBuilder.append(" ").append(additionalOnEmptyBehavior).append(" ON EMPTY"); + } + if (additionalOnErrorBehavior != null) { + additionalBuilder.append(" ").append(additionalOnErrorBehavior).append(" ON ERROR"); + } + result.addAdditionalQueryPathArgument(additionalBuilder.toString()); } - return window; + )* + ")" + { + return result; } } -KSQLWindow KSQLWindowClause(): -{ - KSQLWindow window = new KSQLWindow(); - KSQLWindow.Duration size; - KSQLWindow.Duration advance; - KSQLWindow.Duration grace; +JsonFunction JsonFunction() : { + JsonFunction result; } { - ( - "(" size=KSQLDuration() - "," advance=KSQLDuration() { - window.setHoppingWindow(true); - window.setAdvanceDuration(advance.getValue()); - window.setAdvanceTimeUnit(advance.getTimeUnit()); - } - | - "(" size=KSQLDuration() { window.setSessionWindow(true); } - | - "(" size=KSQLDuration() { window.setTumblingWindow(true); } + ( result = JsonObjectBody() ) + | + ( result = JsonArrayBody() ) + | + ( + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("JSON_VALUE") + }) + JsonKeyword("JSON_VALUE") + result = JsonValueBody() + ) + | + ( + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("JSON_QUERY") + }) + JsonKeyword("JSON_QUERY") + result = JsonQueryBody() + ) + | + ( + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("JSON_EXISTS") + }) + JsonKeyword("JSON_EXISTS") + result = JsonExistsBody() + ) ) - [ "," grace=KSQLGracePeriod() { window.setGracePeriod(grace); } ] - ")" { - window.setSizeDuration(size.getValue()); - window.setSizeTimeUnit(size.getTimeUnit()); - return window; + return result; } } -Expression WhereClause(): -{ - Expression retval = null; -} -{ - retval=Expression() - { return retval; } -} - -Expression PreWhereClause(): -{ - Expression retval = null; -} -{ - retval=Expression() - { return retval; } -} +JsonAggregateFunction JsonAggregateFunction() : { + JsonAggregateFunction result = new JsonAggregateFunction(); + Token token; + Object key; + Expression expression; + List expressionOrderByList = null; -OracleHierarchicalExpression OracleHierarchicalQueryClause(): -{ - OracleHierarchicalExpression result = new OracleHierarchicalExpression(); - Expression expr; + Expression filter; + ExpressionList expressionList = null; + List olist = null; + WindowElement windowElement = null; + Token partitionFirst = null; + Token partitionLast = null; } { ( ( - expr=XorExpression() {result.setStartExpression(expr);} - [ { result.setNoCycle(true); } ] expr=XorExpression() - { - result.setConnectExpression(expr); - } - ) - | - ( - [ { result.setNoCycle(true); } ] expr=XorExpression() + ( + "(" { result.setType( JsonFunctionType.OBJECT ); } + ( + LOOKAHEAD(2) ( + "KEY" { result.setUsingKeyKeyword( true ); } + ( + ( token = | token = | token = | token = | token = ) + { + key = token.image; + } + | + key = Column() + ) + ) + | + ( token = | token = | token = | token = | token = ) + { + key = token.image; + } + | + key = Column() + ) { - result.setConnectExpression(expr); - result.setConnectFirst(true); + result.setKey( key ); } - [ LOOKAHEAD(2) expr=XorExpression() {result.setStartExpression(expr);} ] - ) - ) - { - return result; - } -} -PreferringClause PreferringClause(): -{ - Expression result = null; -} -{ - - result=PreferenceTerm() + ( ":" | "," { result.setType( JsonFunctionType.MYSQL_OBJECT ); } | "VALUE" {result.setUsingValueKeyword( true ); } ) + expression = Expression() { result.setValue( expression ); } - { - PreferringClause preferring = new PreferringClause(result); - return preferring; - } -} + [ { result.setUsingFormatJson( true ); } ] -Expression PreferenceTerm(): -{ - Expression retval = null; -} -{ - // recursively build preferenceterm inside Plus - // like Expression -> XorExpression -> OrExpression -> ... + [ + LOOKAHEAD(2) ( + { result.setOnNullType( JsonAggregateOnNullType.NULL ); } + ) + | + ( + { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } + ) + ] - retval=Plus() + [ + ( + { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); } + ) + | + ( + { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); } + ) + ] + ")" + ) + | + ( + + "(" { result.setType( JsonFunctionType.ARRAY ); } + expression=Expression() { result.setExpression( expression ); } + [ { result.setUsingFormatJson( true ); } ] + [ expressionOrderByList = OrderByElements() { result.setExpressionOrderByElements( expressionOrderByList ); } ] - { - return retval; - } -} + [ + LOOKAHEAD(2) ( + { result.setOnNullType( JsonAggregateOnNullType.NULL ); } + ) + | + ( + { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } + ) + ] + + ")" + ) + ) + + // -- Filter + [ LOOKAHEAD(2) "(" { result.setAnalyticType(AnalyticType.FILTER_ONLY); } filter = Expression() { result.setFilterExpression( filter ); } ")" ] + + // -- OVER + [ LOOKAHEAD(2) + {result.setAnalyticType(AnalyticType.OVER);} + "(" + [partitionFirst= + expressionList=ComplexExpressionList() + { partitionLast = getToken(0); } + ] + [olist=OrderByElements() ] + [windowElement = WindowElement() ] + { + result.setPartitionExpressionList(expressionList, false); + if (partitionFirst != null) { + linkAST(result.getPartitionExpressionList(), partitionFirst, partitionLast); + } + result.setOrderByElements(olist); + result.setWindowElement(windowElement); + } + ")" + ] + ) -Expression Plus(): -{ - Expression left, right, result; -} -{ - left=PriorTo() { result = left; } - ( - LOOKAHEAD(2) - - right=PriorTo() - { - result = new Plus(left, right); - left = result; - } - )* { return result; } } -Expression PriorTo(): -{ - Expression left, right, result; +IntervalExpression IntervalExpression() : { + IntervalExpression interval = new IntervalExpression(); + Token token = null; + Expression expr = null; + boolean signed = false; + IntervalQualifier qualifier = null; } { + + ( - LOOKAHEAD(3) left=PreferenceTermTerminal() + + LOOKAHEAD(3) ( + [ "-" {signed=true;}] + (token= | token=) + ) | - "(" left=PreferenceTerm() ")" { left = new ParenthesedExpressionList(left); } + LOOKAHEAD(2) token= + | + expr = Expression() ) - { result = left; } - - ( - LOOKAHEAD(2) + { + if (expr != null) { + if (signed) expr = new SignedExpression('-', expr); + interval.setExpression(expr); + } else { + interval.setParameter((signed?"-":"") + token.image); + } + } + [ + // The entry decision for this optional block has to be stated explicitly: + // also starts whatever follows IntervalExpression() at its call sites (an alias, for + // instance), so one token of lookahead cannot decide whether to enter. + LOOKAHEAD({ getToken(1).kind == K_DATE_LITERAL || getToken(1).kind == S_IDENTIFIER }) ( - LOOKAHEAD(3) right=PreferenceTermTerminal() + // Standard qualifier (field [TO field] [(precision)]) such as DAY or DAY TO SECOND. + LOOKAHEAD({ getToken(1).kind == K_DATE_LITERAL }) qualifier = IntervalQualifier() { interval.setIntervalQualifier(qualifier); } | - "(" right=PreferenceTerm() ")" { left = new ParenthesedExpressionList(right); } + // Non-standard single identifier field (e.g. MySQL `INTERVAL 1 foo`), kept for + // backwards compatibility. + token = { interval.setIntervalType(token.image); } ) - { - result = new PriorTo(left, right); - left = result; - } - )* + ] { - return result; + return interval; } } -Expression PreferenceTermTerminal(): -{ - Expression retval; +IntervalExpression IntervalExpressionWithoutInterval(Expression expr) : { + IntervalExpression interval; + IntervalQualifier qualifier = null; + boolean signed = false; } { - ( - LOOKAHEAD(2) retval=HighExpression() - | - LOOKAHEAD(2) retval=LowExpression() - | - LOOKAHEAD(2) retval=Inverse() - | - retval=Condition() - ) - { - return retval; + interval = new IntervalExpression(false); + interval.setExpression(expr); + } + qualifier = IntervalQualifier() + { + interval.setIntervalQualifier(qualifier); + return interval; } } -Expression HighExpression() #HighExpression: -{ - Expression result; +/** + * Parses an SQL interval qualifier, e.g. {@code DAY}, {@code DAY TO SECOND}, + * {@code DAY(9) TO SECOND} or {@code SECOND(2, 4)}, as defined by the SQL standard. + * Shared by {@link IntervalExpression} (DML interval literals) and by {@code ColDataType} + * (DDL {@code INTERVAL} column / cast target types). + */ +IntervalQualifier IntervalQualifier() : { + Token field = null; + Token toField = null; + Token leadingPrecision = null; + Token fractionalPrecision = null; + Token trailingFractionalPrecision = null; } { - - result=Expression() - + field = + [ + LOOKAHEAD(2) "(" leadingPrecision = + [ "," fractionalPrecision = ] + ")" + ] + [ + LOOKAHEAD(2) toField = + [ LOOKAHEAD(2) "(" trailingFractionalPrecision = ")" ] + ] { - HighExpression high = new HighExpression(result); - linkAST(high,jjtThis); - return high; + // SECOND(2, 4) TO SECOND(3) specifies fractional seconds precision for both the leading + // and the trailing field. Reject such contradictory input instead of silently dropping one + // of the values. The rejection is placed last so the production does not complete normally + // and JavaCC does not append an unreachable "missing return" guard. + if (fractionalPrecision == null || trailingFractionalPrecision == null) { + return new IntervalQualifier( + field != null ? field.image : null, + leadingPrecision != null ? Integer.valueOf(leadingPrecision.image) : null, + toField != null ? toField.image : null, + trailingFractionalPrecision != null + ? Integer.valueOf(trailingFractionalPrecision.image) + : (fractionalPrecision != null + ? Integer.valueOf(fractionalPrecision.image) : null)); + } + throw new ParseException( + "Invalid interval qualifier: fractional seconds precision is specified for both" + + " the leading field and the trailing field"); } } -Expression LowExpression() #LowExpression: -{ - Expression result; +KeepExpression KeepExpression() : { + KeepExpression keep = new KeepExpression(); + Token token; + List list; + Token first = getToken(1); } { - - result=Expression() + "(" token = ( { keep.setFirst(true); } | { keep.setFirst(false); }) + list = OrderByElements() ")" { - LowExpression low = new LowExpression(result); - linkAST(low,jjtThis); - return low; + keep.setName(token.image); + keep.setOrderByElements(list); + linkAST(keep, first); + return keep; } } -Expression Inverse() #Inverse: -{ - Expression result; + +void windowFun(AnalyticExpression retval):{ + ExpressionList expressionList = null; + Token partitionFirst = null; + Token partitionLast = null; + String windowName = null; + WindowDefinition winDef; +} { + ( + {retval.setType(AnalyticType.OVER);} + | + {retval.setType(AnalyticType.WITHIN_GROUP);} + ) + + ( + windowName = RelObjectName() { retval.setWindowName(windowName); } + | + winDef = windowDefinition() + { + if (winDef.getBaseWindowName() != null && retval.getType() != AnalyticType.OVER) { + throw new ParseException("Only an OVER window may extend a named window"); + } + retval.setWindowDefinition(winDef); + } + + [ + LOOKAHEAD(2) "(" + [ partitionFirst= + expressionList=ComplexExpressionList() + { partitionLast = getToken(0); } + ] + ")" { + winDef.setPartitionExpressionList(expressionList, false); + if (partitionFirst != null) { + linkAST(winDef.getPartitionBy(), partitionFirst, partitionLast); + } + retval.setType(AnalyticType.WITHIN_GROUP_OVER); + } + ] + ) } -{ - - "(" result=PreferenceTerm() ")" +WindowDefinition windowDefinition() : { + ExpressionList expressionList = null; + List olist = null; + WindowElement windowElement = null; + Token partitionFirst = null; + Token partitionLast = null; + WindowDefinition winDef = new WindowDefinition(); + String baseWindowName; +} { + "(" + // DuckDB: (w ORDER BY b) extends the named window w. A choice, not an optional, so that + // lookahead scans through a window specification keep the check + ( + LOOKAHEAD({ isBaseWindowNameAhead() }) baseWindowName=RelObjectName() + { winDef.setBaseWindowName(baseWindowName); } + | + {} + ) + [partitionFirst= + expressionList=ComplexExpressionList() + { partitionLast = getToken(0); } + ] + [olist=OrderByElements() ] + [windowElement = WindowElement() ] { - Inverse inverse = new Inverse(result); - linkAST(inverse,jjtThis); - return inverse; + winDef.setPartitionExpressionList(expressionList, false); + if (partitionFirst != null) { + linkAST(winDef.getPartitionBy(), partitionFirst, partitionLast); + } + winDef.setOrderByElements(olist); + winDef.setWindowElement(windowElement); } + ")" + { return winDef; } } -GroupByElement GroupByColumnReferences(): +AnalyticExpression AnalyticExpression(Function function) : { - Expression columnReference; - GroupByElement groupBy = new GroupByElement(); - Expression expr; - ExpressionList list; - Token token; + AnalyticExpression retval = new AnalyticExpression(function); + Expression filter = null; } { - ( - LOOKAHEAD(2) ( - - "(" - list = GroupingSet() { groupBy.addGroupingSet(list); } - ( LOOKAHEAD(2) "," list = GroupingSet() { groupBy.addGroupingSet(list); })* - ")" - ) - | ( - ( - LOOKAHEAD({ getAsBoolean(Feature.allowLegacyMySqlGroupBy) - && "MYSQL".equals(getAsString(Feature.dialect)) }) - LegacyMySqlGroupByExpressions(groupBy) - | - list = ExpressionList() { groupBy.setGroupByExpressions(list); } - ) - ( - LOOKAHEAD(2) - "(" - list = GroupingSet() { groupBy.addGroupingSet(list); } - ( LOOKAHEAD(2) "," list = GroupingSet() { groupBy.addGroupingSet(list); })* - ")" - )? - [ LOOKAHEAD(2) { groupBy.setMysqlWithRollup(true); } ] + filter=AggregateFilter(retval) { retval.setType(AnalyticType.FILTER_ONLY); } + [ LOOKAHEAD(2) windowFun(retval) ] + { + if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && (retval.getType() == AnalyticType.WITHIN_GROUP + || retval.getType() == AnalyticType.WITHIN_GROUP_OVER)) { + throw new ParseException("FILTER must follow WITHIN GROUP"); + } + } ) + | windowFun(retval) + [ LOOKAHEAD({ retval.getType() == AnalyticType.WITHIN_GROUP + && getToken(1).kind == K_FILTER }) filter=AggregateFilter(retval) ] ) { - return groupBy; + retval.setFilterExpression(filter); + if (true) { return retval; } } } -void LegacyMySqlGroupByExpressions(GroupByElement groupBy): -{} -{ - LegacyMySqlGroupByExpression(groupBy) - ( LOOKAHEAD(2) "," LegacyMySqlGroupByExpression(groupBy) )* -} - -void LegacyMySqlGroupByExpression(GroupByElement groupBy): -{ - Expression expression; - Token direction; -} -{ - expression = Expression() { groupBy.getGroupByExpressionList().add(expression); } - [ LOOKAHEAD(2) (direction= | direction=) { - groupBy.setGroupBySortDirection(groupBy.getGroupByExpressionList().size() - 1, - direction.kind == K_ASC ? GroupByElement.SortDirection.ASC - : GroupByElement.SortDirection.DESC); - } ] -} - -ExpressionList GroupingSet(): -{ - ExpressionList list; - Expression expression; -} +/** + * Shared FILTER predicate for ordinary, window, and ordered-set aggregates. DuckDB also accepts + * it without WHERE, FILTER (x > 1), but PostgreSQL does not. + */ +Expression AggregateFilter(AnalyticExpression analyticExpression): +{ Expression filter; } { + "(" ( - LOOKAHEAD(2) list = ParenthesedExpressionList() + | - expression = SimpleExpression() { list = new ExpressionList(expression); } + LOOKAHEAD({ !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + { analyticExpression.setFilterWhereKeyword(false); } ) - { - return list; - } + filter=Expression() ")" + { return filter; } } -Expression Having(): +WindowElement WindowElement(): { - Expression having = null; + WindowElement windowElement = new WindowElement(); + WindowRange range = new WindowRange(); + WindowOffset offset = null; + WindowElement.Exclusion exclusion = null; } { - having=Expression() + ( { windowElement.setType(WindowElement.Type.ROWS); } + | { windowElement.setType(WindowElement.Type.RANGE); } + | { windowElement.setType(WindowElement.Type.GROUPS); }) + ( LOOKAHEAD(1) ( + { windowElement.setRange(range); } + offset = WindowOffset() { range.setStart(offset); } + offset = WindowOffset() { range.setEnd(offset); } + ) + | + offset = WindowOffset() { windowElement.setOffset(offset); } + ) + [ exclusion = FrameExclusion() { windowElement.setExclusion(exclusion); } ] + { - return having; + return windowElement; } } -Expression Qualify(): +WindowElement.Exclusion FrameExclusion(): { - Expression qualify = null; + WindowElement.Exclusion exclusion = null; } { - qualify=Expression() - { - return qualify; - } + + ( + + { exclusion = WindowElement.Exclusion.CURRENT_ROW; } + | + + { exclusion = WindowElement.Exclusion.GROUP; } + | + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("TIES") + }) + + { exclusion = WindowElement.Exclusion.TIES; } + | + + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("OTHERS") + }) + + { exclusion = WindowElement.Exclusion.NO_OTHERS; } + ) + { return exclusion; } } -List OrderByElements(): +WindowOffset WindowOffset(): { - List orderByList = new ArrayList(); - OrderByElement orderByElement = null; + WindowOffset offset = new WindowOffset(); + Expression expr = null; } { - [ ] orderByElement=OrderByElement() { orderByList.add(orderByElement); } - ( LOOKAHEAD(2) "," orderByElement=OrderByElement() { orderByList.add(orderByElement); } )* + ( + LOOKAHEAD(2) ( + ( { offset.setType(WindowOffset.Type.PRECEDING); } | + { offset.setType(WindowOffset.Type.FOLLOWING); } ) + ) + | + LOOKAHEAD(2) ( { offset.setType(WindowOffset.Type.CURRENT); } ) + | + ( expr = SimpleExpression() { + offset.setType(WindowOffset.Type.EXPR); + offset.setExpression(expr); + } + ( { offset.setType(WindowOffset.Type.PRECEDING); } | { offset.setType(WindowOffset.Type.FOLLOWING); } ) + ) + ) + { - return orderByList; + return offset; } } -OrderByElement OrderByElement(): +ExtractExpression ExtractExpression() : { - OrderByElement orderByElement = new OrderByElement(); - Expression columnReference = null; - Token collateToken = null; - WithFill withFill = null; + ExtractExpression retval = new ExtractExpression(); + String fieldName = null; + Token token = null; + Expression expr = null; } { - columnReference = Expression() - [ LOOKAHEAD() (collateToken= | collateToken=) { columnReference = new CollateExpression(columnReference, collateToken.image); } ] - [ LOOKAHEAD(2) ( | ( { orderByElement.setAsc(false); } )) { orderByElement.setAscDescPresent(true); } ] - [ LOOKAHEAD(2) - [ LOOKAHEAD(2) ( - { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_FIRST); } - | - { orderByElement.setNullOrdering(OrderByElement.NullOrdering.NULLS_LAST); } - ) - ] - ] - [ LOOKAHEAD(2) withFill = WithFill() { orderByElement.setWithFill(withFill); } ] - [ LOOKAHEAD(2) { orderByElement.setMysqlWithRollup(true); } ] + + "(" + ( fieldName=RelObjectName() { retval.setName(fieldName); } | token= { retval.setName(token.image); } ) + + expr=SimpleExpression() { retval.setExpression(expr); } + ")" { - orderByElement.setExpression(columnReference); - return orderByElement; + return retval; } } -WithFill WithFill(): -{ - WithFill withFill = new WithFill(); - Expression fillExpression = null; -} +CastExpression ImplicitCast() #ImplicitCast: { - - [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setFrom(fillExpression); } ] - [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setTo(fillExpression); } ] - [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setStep(fillExpression); } ] - [ LOOKAHEAD(2) fillExpression = Expression() { withFill.setStaleness(fillExpression); } ] - { return withFill; } -} + ColDataType colDataType; + Token tk1; + Token tk2; -List InterpolateClause(): -{ - List interpolateElements = new ArrayList(); - InterpolateElement interpolateElement = null; + int precision = -1; + int scale = -1; + Token first = getToken(1); } { - - [ LOOKAHEAD(2) "(" - [ interpolateElement = InterpolateElement() { interpolateElements.add(interpolateElement); } - ( "," interpolateElement = InterpolateElement() { interpolateElements.add(interpolateElement); } )* - ] - ")" ] - { return interpolateElements; } + colDataType = DataType() + ( + tk2 = + | + tk2 = + | + tk2 = + ) + { + CastExpression castExpression = new CastExpression(colDataType, tk2.image); + linkAST(castExpression.getLeftExpression(), tk2, tk2); + linkAST(castExpression, first); + return castExpression; + } } -InterpolateElement InterpolateElement(): +CastExpression CastExpression(): { - InterpolateElement interpolateElement = new InterpolateElement(); - Column column = null; + Token keyword; + CastExpression retval; + ColumnDefinition columnDefinition; + ColDataType type; Expression expression = null; -} -{ - column = Column() { interpolateElement.setColumn(column); } - [ expression = Expression() { interpolateElement.setExpression(expression); } ] - { return interpolateElement; } -} - -Expression OptionHintParameter(): -{ - UserVariable userVariable = null; - Expression parameter = null; + boolean useCastKeyword; + Token formatCharLiteral; } { ( - LOOKAHEAD({ getToken(1).kind == S_AT_IDENTIFIER && getToken(2).kind == K_UNKNOWN }) - userVariable = UserVariable() - { - return new Column(userVariable + " UNKNOWN"); - } + keyword= | - parameter = Expression() { return parameter; } + keyword= + | + keyword= + | + keyword= + ) + { + retval = new CastExpression(keyword.image); + } + "(" + expression=SimpleExpression() + { retval.setUseCastKeyword(true); } + ( + LOOKAHEAD(2) ( + + "(" + columnDefinition=ColumnDefinition() { retval.addColumnDefinition(columnDefinition); } + ( "," columnDefinition=ColumnDefinition() { retval.addColumnDefinition(columnDefinition); } )* + ")" + ) + | + ( + type=ColDataType() { + // Preserve the established MySQL CAST type-name API outside PostgreSQL mode. + if (!Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && type.isUsingArrayKeyword() && type.getArrayData().size() == 1 + && type.getArrayData().get(0) == null) { + type.setUsingArrayKeyword(false); + type.getArrayData().clear(); + type.setDataType(type.getDataType() + " ARRAY"); + } + retval.setColDataType(type); + } + // MySQL casts to an array of the given type when a multi-valued index key part is + // defined, e.g. CAST(data->'$.zips' AS UNSIGNED ARRAY). ARRAY reads as a further + // word of the type, the way INT UNSIGNED already does. + [ { type.setDataType(type.getDataType() + " ARRAY"); } ] + ) ) -} -OptionClause OptionClause(): -{ - OptionClause optionClause = new OptionClause(); - OptionHint optionHint = null; -} -{ - "(" optionHint = OptionHint() { optionClause.addOptionHint(optionHint); } - ( "," optionHint = OptionHint() { optionClause.addOptionHint(optionHint); } )* + // BigQuery FORMAT clause + // https://cloud.google.com/bigquery/docs/reference/standard-sql/conversion_functions#cast_as_date + [ formatCharLiteral= { retval.setFormat(formatCharLiteral.image); } ] + ")" - { return optionClause; } + + { + retval.setLeftExpression(expression); + return retval; + } } -OptionHint OptionHint(): +Expression CaseWhenExpression() #CaseWhenExpression: { - OptionHint optionHint = new OptionHint(); - String name = null; - Expression value = null; - Expression parameter = null; + CaseExpression caseExp = new CaseExpression(); + Expression switchExp = null; + WhenClause clause; + List whenClauses = new ArrayList(); + Expression elseExp = null; } { - name = OptionHintName() { optionHint.setName(name); } + { caseCounter++; } + [ LOOKAHEAD(2) switchExp=Expression() ] + ( clause=WhenThenSearchCondition() { whenClauses.add(clause); } )+ [ + ( - LOOKAHEAD("=") "=" value = Expression() { optionHint.setValue(value); optionHint.setUseEquals(true); } - | - LOOKAHEAD("(") "(" parameter = OptionHintParameter() { optionHint.addParameter(parameter); } - ( "," parameter = OptionHintParameter() { optionHint.addParameter(parameter); } )* - ")" - | - LOOKAHEAD({ isOptionHintValueAhead() }) value = Expression() { optionHint.setValue(value); } + LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) elseExp=Expression() + | elseExp=SimpleExpression() ) ] - { return optionHint; } + { caseCounter--; } + { + caseExp.setSwitchExpression(switchExp); + caseExp.setWhenClauses(whenClauses); + caseExp.setElseExpression(elseExp); + return caseExp; + } } -String OptionHintName(): +WhenClause WhenThenSearchCondition(): { - Token tk = null; - String word = null; - StringBuilder name = new StringBuilder(); + WhenClause whenThen = new WhenClause(); + Expression whenExp; + Expression thenExp; + Token first = getToken(1); } { + whenExp=Expression() + ( - LOOKAHEAD({ isOptionHintWordAhead() }) - ( tk= | word = NonReservedWord() - | tk= | tk= | tk= - | tk= | tk= | tk= - | tk= | tk= | tk= | tk= ) - { - if (name.length() > 0) { name.append(' '); } - name.append(tk != null ? tk.image : word); - tk = null; - word = null; - } - )+ - { return name.toString(); } + LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) thenExp=Expression() + | + thenExp=SimpleExpression() + ) + { + whenThen.setWhenExpression(whenExp); + whenThen.setThenExpression(thenExp); + linkAST(whenThen, first); + return whenThen; + } } -JdbcParameter JdbcParameter() : { - Token tk; - JdbcParameter retval; +RowConstructor RowConstructor(): { + Token token; + ParenthesedExpressionList expressions; +} { + token= + expressions = ParenthesedExpressionList() + { + return new RowConstructor(token.image, expressions); + } } -{ - ( tk="?" | tk= ) - { retval = new JdbcParameter(++jdbcParameterIndex, false, tk.image); } - - [ LOOKAHEAD(2) token = { retval.setUseFixedIndex(true); retval.setIndex(Integer.valueOf(token.image)); } ] - { return retval; } +/** +TODO: VariableExpression should be a standalone class with more operations available. +*/ +EqualsTo VariableExpression(): { + Expression left; + Expression right; +} { + left = UserVariable() "=" right = SimpleExpression() + { + EqualsTo equals = new EqualsTo(); + equals.setLeftExpression(left); + equals.setRightExpression(right); + return equals; + } } - -Limit LimitWithOffset() #LimitWithOffset: -{ - Limit limit = new Limit(); - Expression firstExpression; - Expression secondExpression; +Execute Execute(): { + ObjectNames funcName; + ExpressionList expressionList; + Execute execute = new Execute(); + ExpressionList variables = new ExpressionList(); + UserVariable variable; } { - - ( - LOOKAHEAD(3) firstExpression = ParenthesedSelect() - | - firstExpression = Expression() - ) - ( - // MySQL: LIMIT offset, row_count - "," - secondExpression = Expression() + ( { execute.setExecType(Execute.ExecType.EXEC); } + | { execute.setExecType(Execute.ExecType.EXECUTE); } + | { execute.setExecType(Execute.ExecType.CALL); } ) + + // A colon starts a bind argument here; it must not join the procedure name. + funcName=ColumnIdentifier() { execute.setName(funcName.getNames()); } + [ + // MySQL's EXECUTE name USING @variable [, @variable] ... + LOOKAHEAD({ getToken(1).kind == K_USING && isMySqlUtilityDialect() }) + variable=MySqlIntoVariable() { variables.add(variable); } + ( LOOKAHEAD(2) "," variable=MySqlIntoVariable() { variables.add(variable); } )* { - limit.setOffset(firstExpression); - limit.setRowCount(secondExpression); + requireDdlSyntax(execute.getExecType() == Execute.ExecType.EXECUTE, + "Only EXECUTE takes a USING clause"); + execute.setUsingVariables(linkElements(variables)); } | - // PostgreSQL: LIMIT row_count - { - limit.setRowCount(firstExpression); - } - ) - { - linkAST(limit, jjtThis); - return limit; - } + LOOKAHEAD(2) expressionList=ExecuteArguments() { execute.setExprList(expressionList); } + ] + { return execute; } } -Limit PlainLimit() #PlainLimit: -{ - Limit limit = new Limit(); - Expression rowCountExpression; +ExpressionList ExecuteArguments(): { + ExpressionList arguments = new ExpressionList(); + Expression argument; } { - // mysql-postgresql-> LIMIT (row_count | ALL | NULL) - ( - LOOKAHEAD(3) rowCountExpression = ParenthesedSelect() - | - rowCountExpression = Expression() + LOOKAHEAD(1, "(") arguments=ExpressionList() + | + argument=ExecuteArgument() { arguments.add(argument); } + ( LOOKAHEAD(2) "," argument=ExecuteArgument() { arguments.add(argument); } )* ) - { - limit.setRowCount(rowCountExpression); - linkAST(limit,jjtThis); - return limit; - } + { return linkElements(arguments); } } -Offset Offset(): -{ - Offset offset = new Offset(); - Expression offsetExpression; +Expression ExecuteArgument(): { + Expression argument; + boolean output = false; } { - ( - // postgresql-> OFFSET offset - // sqlserver-oracle-> OFFSET offset (ROW | ROWS) - - offsetExpression=Expression() { offset.setOffset( offsetExpression ); } + argument=Expression() + [ + LOOKAHEAD({ isAccessKeywordAhead("OUTPUT") || isAccessKeywordAhead("OUT") }) + ( | AccessKeyword("OUT") ) + { output = true; } + ] + { return output ? createOutputArgument(argument) : argument; } - [ LOOKAHEAD(2) ( { offset.setOffsetParam("ROWS"); } | { offset.setOffsetParam("ROW"); })] +} +FullTextSearch FullTextSearch() : { + Token searchModifier; + Expression againstValue; + FullTextSearch fs = new FullTextSearch(); + ExpressionList matchedColumns; +} +{ + "(" matchedColumns=ColumnList() ")" + "(" + againstValue=SimpleExpression() { fs.setAgainstValue(againstValue); } + [ + ( + searchModifier="IN NATURAL LANGUAGE MODE" + | searchModifier="IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION" + | searchModifier="IN BOOLEAN MODE" + | searchModifier="WITH QUERY EXPANSION" ) + { fs.setSearchModifier(searchModifier.image); } + ] + ")" { - return offset; + fs.setMatchColumns(matchedColumns); + return fs; } } -Fetch Fetch(): +LambdaExpression LambdaExpression() #LambdaExpression: { - Fetch fetch = new Fetch(); - Token token = null; + ExpressionList columns; + String s; Expression expression; - List fetchParameters = new ArrayList(); + LambdaExpression lambdaExpression; } { ( - LOOKAHEAD(3) ( - ( { fetch.setFetchParamFirst(true); } | ) - ( - { fetch.addFetchParameter("ROWS"); } - | - { fetch.addFetchParameter("ROW"); } - ) - ( - { fetch.addFetchParameter("ONLY"); } - | - { fetch.addFetchParameter("WITH TIES"); } - ) - ) + columns = ParenthesedColumnList() | - ( - ( { fetch.setFetchParamFirst(true); } | ) - - // Expression is optional according to https://www.h2database.com/html/commands.html#select - expression = Expression() { fetch.setExpression(expression); } - [ { fetch.addFetchParameter("PERCENT"); } ] - ( - ( - { fetch.addFetchParameter("ROWS"); } - | - { fetch.addFetchParameter("ROW"); } - ) - - ( - { fetch.addFetchParameter("ONLY"); } - | - { fetch.addFetchParameter("WITH TIES"); } - ) - ) - ) + s = RelObjectName() { columns = linkElements(new ExpressionList(linkToLastToken(createColumn(s)))); } ) + + "->" + expression = Expression() { - return fetch; + lambdaExpression = LambdaExpression.from(columns, expression); + linkAST(lambdaExpression,jjtThis); + return lambdaExpression; } } -WithIsolation WithIsolation(): +/** + * DuckDB's lambda syntax, lambda x, y : expr, equivalent to (x, y) -> expr. + */ +LambdaExpression DuckDBLambdaExpression() #LambdaExpression: { - WithIsolation withIsolation = new WithIsolation(); - Token token = null; - JdbcParameter jdbc; + List identifiers = new ArrayList(); + String s; + Expression expression; + LambdaExpression lambdaExpression; } { - - token= - { withIsolation.setIsolation(token.image); - return withIsolation; + s = RelObjectName() { identifiers.add(s); } + ( "," s = RelObjectName() { identifiers.add(s); } )* + ":" + expression = Expression() + { + lambdaExpression = new LambdaExpression(identifiers, expression).setLambdaKeyword(true); + linkAST(lambdaExpression,jjtThis); + return lambdaExpression; } } -OptimizeFor OptimizeFor(): +RowPatternFunction RowPatternFunction() #RowPatternFunction: { - Token token; - LongValue value; + RowPatternFunction.EvaluationMode mode; + Function function; } { - token= + ( LOOKAHEAD({ isKeywordAhead("RUNNING") }) ContextualKeyword("RUNNING") + { mode = RowPatternFunction.EvaluationMode.RUNNING; } + | { mode = RowPatternFunction.EvaluationMode.FINAL; } + ) + function=Function() { - value = new LongValue(token.image); - return new OptimizeFor(value.getValue()); + RowPatternFunction result = new RowPatternFunction(mode, function); + linkAST(result, jjtThis); return result; } } -// according to http://technet.microsoft.com/en-us/library/ms189463.aspx -Top Top() #Top: +Function Function() #Function: { - Top top = new Top(); - Token token = null; - Expression expr = null; - JdbcParameter jdbc = null; + Function function; } { - ( - token= { top.setExpression(new LongValue(token.image)); } - | - jdbc = JdbcParameter() { top.setExpression(jdbc); } - | - ":" { top.setExpression(new JdbcNamedParameter()); } - [ LOOKAHEAD(2) token = { ((JdbcNamedParameter)top.getExpression()).setName(token.image); } ] - | - "(" - expr=SimpleExpression() - { - top.setExpression(expr); - top.setParenthesis(true); - } - ")" + "{" function = InternalFunction(true) "}" + { normalizeOdbcTimestampInterval(function); } + | LOOKAHEAD(3) function = SpecialStringFunctionWithNamedParameters() + | function = InternalFunction(false) ) - [ LOOKAHEAD(2) { top.setPercentage(true); } ] - [ LOOKAHEAD(2) { top.setWithTies(true); } ] { - linkAST(top,jjtThis); - return top; + normalizeDateUnitArguments(function); + linkAST(function,jjtThis); + return function; } } -// according to http://www-01.ibm.com/support/knowledgecenter/SSGU8G_12.1.0/com.ibm.sqls.doc/ids_sqs_0156.htm -Skip Skip(): +Function SpecialStringFunctionWithNamedParameters() : { - Skip skip = new Skip(); - Token token = null; - JdbcParameter jdbc; + Token funcName; + NamedExpressionList namedExpressionList = null; + ExpressionList expressionList = null; + List orderByList; + Token open; } { - - ( - token= { skip.setRowCount(Long.parseLong(token.image)); } - | - token= { skip.setVariable(token.image); } - | - jdbc = JdbcParameter() { skip.setJdbcParameter(jdbc); } - ) + funcName = + + open="(" + ( + LOOKAHEAD( { isNamedExprListAhead() } ) namedExpressionList = NamedExpressionListExprFirst() + | + expressionList=ExpressionList() + ) + ")" + { - return skip; + if (namedExpressionList != null) { + linkAST(namedExpressionList, open); + } + return linked(new Function() + .withName(funcName.image) + .withNamedParameters(namedExpressionList) + .withParameters(expressionList), funcName); } } JAVACODE -OracleHint getOracleHint() { - OracleHint hint = null; - Token tok = getToken(1); - // Retrieve first comment (if any) prior next token - if (tok.specialToken != null) { - tok = tok.specialToken; - while (tok.specialToken != null) tok = tok.specialToken; - // Check if it matches Hint pattern? - if (OracleHint.isHintMatch(tok.image)) { - hint = new OracleHint(); - hint.setComment(tok.image); +List consumeKeywordArguments() { + List args = null; + while (isKeywordArgumentAhead()) { + String name = getNextToken().image; + ExpressionList exprList = SimpleExpressionList(); + if (args == null) { + args = new ArrayList(); + } + Expression value = exprList.size() == 1 + ? (Expression) exprList.get(0) + : exprList; + args.add(new Function.KeywordArgument(name, value)); } - } - return hint; + return args; } -First First(): +Function InternalFunction(boolean escaped): { - First first = new First(); - Token token = null; - JdbcParameter jdbc; + Token prefixToken = null; + Function retval = new Function(); + ObjectNames funcName; + ExpressionList expressionList = null; + ExpressionList chainedExpressionList = null; + KeepExpression keep = null; + Expression expr = null; + Expression attributeExpression = null; + Column attributeColumn = null; + Token attributeToken = null; + Limit limit; + List orderByList = null; + List keywordArgs = null; + ColDataType castType = null; } { - ( - { first.setKeyword(First.Keyword.FIRST); } - | - { first.setKeyword(First.Keyword.LIMIT); } - ) - ( - token= { first.setRowCount(Long.parseLong(token.image)); } - | - token= { first.setVariable(token.image); } + [ LOOKAHEAD(2) prefixToken = ] + funcName = RelObjectNames() { if (prefixToken!=null) funcName.getNames().add(0, prefixToken.image ); retval.setName(funcName.getNames()); } + + "(" { consumeXmlLeadingKeyword(retval); } + [ + LOOKAHEAD(2) [ + LOOKAHEAD(2) ( + { retval.setDistinct(true); } + | { retval.setAllColumns(true); } + | { retval.setUnique(true); } + ) + ] + ( + LOOKAHEAD(3) expressionList = FunctionArgumentList(retval) + + | + // The probe above is syntactic and cannot see through the Pratt operator + // loop, so it fails on arguments such as "( 1 + a ) / ( 1 + b )" and used + // to fall through to Select(), reporting "Encountered ... + // was expecting ". Select() is only reachable here for a bare + // sub-select, so decide on that instead. + LOOKAHEAD({ !isUnparenthesizedSelectAhead() }) expressionList = FunctionArgumentList(retval) + + | + LOOKAHEAD({ !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) expr = Select() { expressionList = linkElements(new ExpressionList(expr)); } + ) + ] + + // MySQL: WEIGHT_STRING(str AS CHAR(n)) and WEIGHT_STRING(str AS BINARY(n)) + [ + LOOKAHEAD({ isFunctionCastTypeAhead() }) castType = WeightStringCastType() + { + requireSyntax(isWeightStringCall(retval, expressionList), + "AS " + castType + " is only supported after the argument of WEIGHT_STRING"); + retval.setCastType(castType); + } + ] + + [ + ( + expr = Expression() { retval.setHavingClause( "MIN", expr ); } + | + expr = Expression() { retval.setHavingClause( "MAX", expr ); } + ) + ] + + [ + ( + { retval.setNullHandling(Function.NullHandling.IGNORE_NULLS); } + ) | - jdbc = JdbcParameter() { first.setJdbcParameter(jdbc); } - ) + ( + { retval.setNullHandling(Function.NullHandling.RESPECT_NULLS); } + ) + ] + + // BigQuery orders aggregate arguments after the null handling: + // ARRAY_AGG(expr [IGNORE NULLS] [ORDER BY key] [LIMIT n]) + [ + LOOKAHEAD(2) orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } + ] + + [ + limit = PlainLimit() { retval.setLimit(limit); } + ] + { - return first; + keywordArgs = consumeKeywordArguments(); } -} + ")" -Expression Expression() #Expression : + [ + LOOKAHEAD(2) "(" chainedExpressionList = ExpressionList() ")" + ] + + + [ + LOOKAHEAD(2) + ( + LOOKAHEAD({ getToken(1).kind == S_DOUBLE + && getToken(1).image.matches("\\.[0-9]+") }) + attributeToken= { + retval.setAttribute(new LongValue(attributeToken.image.substring(1))); + } + | + "." ( + // tricky lookahead since we do need to support the following constructs + // schema.f1().f2() - Function with Function Column + // schema.f1().f2.f3 - Function with Attribute Column + LOOKAHEAD( 6 ) attributeExpression=Function() { retval.setAttribute(attributeExpression); } + | + attributeColumn=Column() { retval.setAttribute(attributeColumn); } + ) + ) + ] + + [ LOOKAHEAD(2) ( + ( + + { + retval.setNullHandling(Function.NullHandling.IGNORE_NULLS); + retval.setIgnoreNullsOutside(true); + } + ) + | + ( + + { + retval.setNullHandling(Function.NullHandling.RESPECT_NULLS); + retval.setIgnoreNullsOutside(true); + } + ) + ) + ] + + [ LOOKAHEAD(2) keep = KeepExpression() ] + + { + retval.setEscaped(escaped); + retval.setParameters(expressionList); + retval.setChainedParameters(chainedExpressionList); + retval.setName(funcName.getNames()); + retval.setKeep(keep); + retval.setKeywordArguments(keywordArgs); + return retval; + } +} + +/** + * Argument list of a Function, extracted from InternalFunction() so that it can be + * reached from more than one lookahead guard without duplicating the expansion. + */ +ExpressionList FunctionArgumentList(Function retval): { - Expression expression = null; + ExpressionList expressionList = null; + List orderByList; + String onOverflowTruncate = null; + Token overflowToken = null; + Token extraKeywordToken; } { - expression=Condition() - { expression = prattExpressionRest(expression, 2); } + { if (hasUnqualifiedName(retval, "XMLFOREST")) { return XmlForestArguments(); } } + { if (isXmlElementAttributesAhead(retval)) { return XmlElementArguments(); } } + [ LOOKAHEAD(2) extraKeywordToken = { retval.setExtraKeyword(extraKeywordToken.image); } ] + expressionList=ExpressionList() + // explicit lookahead: InternalFunction accepts ORDER BY after IGNORE NULLS too + [ LOOKAHEAD(2) orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } ] + + // https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/LISTAGG.html + [ + ( overflowToken= | overflowToken= ) { onOverflowTruncate=overflowToken.image; } + [ + overflowToken = { onOverflowTruncate+= " " + overflowToken.image; } + [ ( overflowToken= | overflowToken= ) { onOverflowTruncate+=" " + overflowToken.image + " COUNT"; }] + ] + ] { retval.setOnOverflowTruncate(onOverflowTruncate); } + { - linkAST(expression,jjtThis); - return expression; + return expressionList; } } -Expression XorExpression(): -{ - Expression result; - Expression right; -} -{ - result=AndChain() - ( - LOOKAHEAD(2) - ( - right=AndChain() { result = new OrExpression(result, right); } - | - right=AndChain() { result = new XorExpression(result, right); } - ) - )* - { return result; } -} - -/** AND — higher precedence than OR/XOR */ -Expression AndChain(): +/** XMLFOREST keeps expressions in the ordinary function parameter list. */ +ExpressionList XmlForestArguments(): { - Expression result; - Expression right; + ExpressionList arguments = new ExpressionList(); + Expression expression; } { - result=Condition() - ( - LOOKAHEAD(2) - ( - right=Condition() {{ - AndExpression a = new AndExpression(result, right); result = a; - }} - | - right=Condition() {{ - AndExpression a = new AndExpression(result, right); - a.setUseOperator(true); result = a; - }} - ) - )* - { return result; } + expression=XmlForestArgument() { arguments.add(expression); } + ( "," expression=XmlForestArgument() { arguments.add(expression); } )* + { return linkElements(arguments); } } -Expression Condition(): +/** + * XMLELEMENT(NAME name, XMLATTRIBUTES(value [AS name], ...) [, content, ...]): the attribute list + * is the argument after the element name and is kept as a function over aliased expressions. + */ +ExpressionList XmlElementArguments(): { - Expression result; - Expression left; - // Leading NOT / ! prefixes, leftmost token wraps outermost (issue #1170). - final Deque exclamationMarks = new ArrayDeque(); - int oraclePrior = EqualsTo.NO_ORACLE_PRIOR; - int oracleJoin = EqualsTo.NO_ORACLE_JOIN; + ExpressionList arguments = new ExpressionList(); + Expression expression; + String name; } { ( - LOOKAHEAD({ getToken(1).kind == K_NOT || "!".equals(getToken(1).image) }) - ( { exclamationMarks.addFirst(Boolean.FALSE); } | "!" { exclamationMarks.addFirst(Boolean.TRUE); } ) - )* - ( - result=ExistsExpression() + // PostgreSQL: the element name is an identifier, not a value + LOOKAHEAD({ isPostgreSqlDialect() }) + name=RelObjectName() { expression = linkToLastToken(new Column(name)); } | - [ LOOKAHEAD(2, { getToken(1).kind == K_PRIOR }) { oraclePrior = EqualsTo.ORACLE_PRIOR_START; } ] - left=SimpleExpression() { result = left; } - - // Consume Oracle (+) once, before dispatching - [ - LOOKAHEAD("(" "+" ")", { getToken(1).kind == OPENING_BRACKET }) - "(" "+" ")" - { - oracleJoin = EqualsTo.ORACLE_JOIN_RIGHT; - if (left instanceof Column) { - ((Column) left).setOldOracleJoinSyntax(oracleJoin); - } - } - ] - - // Single guard: only enter if next token can start a condition suffix - [ - LOOKAHEAD({ isConditionSuffixAhead() }) - ( - LOOKAHEAD({ isComparisonOperatorAhead() }) - result = RegularConditionRHS(left, oracleJoin) - | LOOKAHEAD(2) result = OverlapsCondition(left) - | LOOKAHEAD(3) result=InExpression(left) - | LOOKAHEAD(3) result=ExcludesExpression(left) - | LOOKAHEAD(3) result=IncludesExpression(left) - | LOOKAHEAD(2) result=Between(left) - | LOOKAHEAD(2) result = MemberOfExpression(left) - | LOOKAHEAD(3) result=IsNullExpression(left) - | LOOKAHEAD(3) result=IsBooleanExpression(left) - | LOOKAHEAD(3) result=IsJsonExpression(left) - | LOOKAHEAD(3) result=IsUnknownExpression(left) - | LOOKAHEAD(2) result=LikeExpression(left) - | LOOKAHEAD(3) result=IsDistinctExpression(left) - | result=SimilarToExpression(left) - ) - ] - ) + expression=Expression() + ) { arguments.add(expression); } + "," expression=XmlAttributes() { arguments.add(expression); } + ( "," expression=Expression() { arguments.add(expression); } )* { - if (oraclePrior == EqualsTo.ORACLE_PRIOR_START - && result instanceof SupportsOldOracleJoinSyntax) { - ((SupportsOldOracleJoinSyntax) result).setOraclePriorPosition(oraclePrior); - } - while (!exclamationMarks.isEmpty()) { - result = new NotExpression(result, exclamationMarks.pollFirst()); - } - return result; + requireSyntax(getToken(1).kind == CLOSING_BRACKET, + "XMLELEMENT takes its name, XMLATTRIBUTES and content values only"); + return linkElements(arguments); } } -Expression RegularConditionRHS(Expression leftExpression, int oracleJoinRight) #RegularCondition: +Function XmlAttributes() #Function: { - Expression result = null; - Expression rightExpression; - int oracleJoin = EqualsTo.NO_ORACLE_JOIN; - int oraclePrior = EqualsTo.NO_ORACLE_PRIOR; - Token token; + Function function = new Function(); + ExpressionList arguments; + Token name; } { - // Only consume (+) here if it wasn't already consumed by Condition - [ LOOKAHEAD("(" "+" ")") "(" "+" ")" { oracleJoin = EqualsTo.ORACLE_JOIN_RIGHT; } ] - - ( - LOOKAHEAD(2) - ">" { result = new GreaterThan(); } - | "<" { result = new MinorThan(); } - | "=" { result = new EqualsTo(); } - | token= { result = new GreaterThanEquals(token.image); } - | token= { result = new MinorThanEquals(token.image); } - | token= { result = new NotEqualsTo(token.image); } - | token= { result = new NotEqualsTo(token.image); } - | token= { result = new NotEqualsTo(token.image); } - | "*=" { result = new TSQLLeftJoin(); } - | "=*" { result = new TSQLRightJoin(); } - | token= { result = new DoubleAnd(); } - | token= { result = new Contains(); } - | token= { result = new ContainedBy(); } - | "@@" { result = new Matches(); } - | "~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASESENSITIVE); } - | "~*" { result = new RegExpMatchOperator(RegExpMatchOperatorType.MATCH_CASEINSENSITIVE); } - | "!~" { result = new RegExpMatchOperator(RegExpMatchOperatorType.NOT_MATCH_CASESENSITIVE); } - | "!~*" { result = new RegExpMatchOperator(RegExpMatchOperatorType.NOT_MATCH_CASEINSENSITIVE); } - | "@>" { result = new JsonOperator("@>"); } - | "<@" { result = new JsonOperator("<@"); } - | "?" { result = new JsonOperator("?"); } - | "?|" { result = new JsonOperator("?|"); } - | "?&" { result = new JsonOperator("?&"); } - | { result = new JsonOperator("||"); } - | "-" { result = new JsonOperator("-"); } - | "-#" { result = new JsonOperator("-#"); } - | "<->" { result = new GeometryDistance("<->"); } - | "<#>" { result = new GeometryDistance("<#>"); } - | { result = new CosineSimilarity(); } - ) - - ( LOOKAHEAD(2) rightExpression=ComparisonItem() { oraclePrior = EqualsTo.ORACLE_PRIOR_END; } - | rightExpression=ComparisonItem() ) - - [ LOOKAHEAD(2) "(" "+" ")" { oracleJoin = EqualsTo.ORACLE_JOIN_LEFT; } ] - + name= "(" arguments=XmlForestArguments() ")" { - BinaryExpression regCond = (BinaryExpression) result; - regCond.setLeftExpression(leftExpression); - regCond.setRightExpression(rightExpression); - - if (oracleJoin > 0) - ((SupportsOldOracleJoinSyntax) result).setOldOracleJoinSyntax(oracleJoin); - - if (oraclePrior != EqualsTo.NO_ORACLE_PRIOR) - ((SupportsOldOracleJoinSyntax) result).setOraclePriorPosition(oraclePrior); - } - - { - linkAST(result, jjtThis, leftExpression); - return result; + function.setName(name.image); + function.setParameters(arguments); + linkAST(function, jjtThis); + return function; } } -Expression OverlapsCondition(Expression leftExpression): +Expression XmlForestArgument(): { - ExpressionList right; + Expression expression; + String name; + Token first = getToken(1); } { - - right = ParenthesedExpressionList() - { - ExpressionList left; - if (leftExpression instanceof ExpressionList) { - left = (ExpressionList) leftExpression; - } else { - left = new ExpressionList(leftExpression); - } - return new OverlapsCondition(left, right); - } + expression=Expression() + [ name=RelObjectName() { + first = firstToken(expression, first); + expression = linked(new AliasedExpression(expression, new Alias(name, true)), first); + } ] + { return expression; } } -Expression SQLCondition(): -{ - Expression result; - Expression left; +XMLSerializeExpr XMLSerializeExpr(): { + XMLSerializeExpr result = new XMLSerializeExpr(); + Expression expression; + List orderByElements = null; + ColDataType dataType; + Token token; } { + "(" ( - result=ExistsExpression() - | left = SimpleExpression() { result = left; } + LOOKAHEAD({ isKeywordAhead("CONTENT") || isKeywordAhead("DOCUMENT") }) + token= + { result.setSerializationMode(XMLSerializeExpr.SerializationMode.valueOf(token.image.toUpperCase(Locale.ROOT))); } + expression=Expression() { result.setExpression(expression); } + [ dataType=ColDataType() { result.setDataType(dataType); } ] + [ token= { result.setEncoding(stringValue(token)); } ] + [ token= { result.setVersion(stringValue(token)); } ] [ - LOOKAHEAD(2) ( - LOOKAHEAD(2, ) result=OverlapsCondition(left) - | - LOOKAHEAD(3, {!interrupted}) result=InExpression(left) - | - LOOKAHEAD(3) result=ExcludesExpression(left) - | - LOOKAHEAD(3) result=IncludesExpression(left) - | - LOOKAHEAD(2) result=Between(left) - | - result = MemberOfExpression(left) - | - LOOKAHEAD(3) result=IsNullExpression(left) - | - LOOKAHEAD(3) result=IsBooleanExpression(left) - | - LOOKAHEAD(3) result=IsJsonExpression(left) - | LOOKAHEAD(3) result=IsUnknownExpression(left) - | - LOOKAHEAD(2) result=LikeExpression(left) - | - LOOKAHEAD(3) result=IsDistinctExpression(left) - | - result=SimilarToExpression(left) - ) + LOOKAHEAD(2) token= { + requireDdlSyntax("INDENT".equalsIgnoreCase(token.image), "Expected INDENT after NO"); + result.setIndent(false); + } + | + LOOKAHEAD({ isKeywordAhead("INDENT") }) token= { result.setIndent(true); } + [ "=" token= { result.setIndentSize(new LongValue(token.image)); } ] ] + [ + { result.setShowDefaults(true); } + | + LOOKAHEAD({ isKeywordAhead("HIDE") }) token= + { result.setShowDefaults(false); } + ] + | + + "(" + "(" expression=SimpleExpression() ")" + [ orderByElements=OrderByElements() ] + ")" + dataType=ColDataType() { + result.setExpression(expression); + result.setOrderByElements(orderByElements); + result.setDataType(dataType); + } ) + ")" { return result; } } -Expression InExpression(Expression leftExpression) #InExpression : + +JsonTableFunction.JsonTablePassingClause JsonTablePassingClause() : { + Expression valueExpression; + String parameterName; + Token first = getToken(1); +} { - Token token; - int oldOracleJoin = 0; - boolean usingNot = false; - boolean usingGlobal = false; - Expression rightExpression; + valueExpression = Expression() + + parameterName = RelObjectName() + { + return linked(new JsonTableFunction.JsonTablePassingClause(valueExpression, parameterName), first); + } +} + +/** Compatibility entry point; both column response clauses use the same behaviors. */ +JsonFunction.JsonOnResponseBehavior JsonTableOnEmptyBehavior() : { + JsonFunction.JsonOnResponseBehavior behavior; } { - [ "(" "+" ")" { oldOracleJoin=EqualsTo.ORACLE_JOIN_RIGHT; } ] + behavior = JsonTableOnResponseBehavior() + { return behavior; } +} - [ { usingGlobal=true; } ] - [ { usingNot=true; } ] - +JsonFunction.JsonOnResponseBehavior JsonTableOnResponseBehavior() : { + JsonFunction.JsonOnResponseBehavior behavior; + Expression expression; +} +{ ( - LOOKAHEAD(2) token= { rightExpression = new StringValue(token.image); } - | - LOOKAHEAD({ isNestedSetOperationAhead() }) rightExpression = ParenthesedSelect() + expression = Expression() + { + behavior = new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.DEFAULT, expression); + } | - rightExpression = PrimaryExpression() + behavior = JsonQueryOnResponseBehavior() ) - { - InExpression inExpression = new InExpression(leftExpression, rightExpression) - .withOldOracleJoinSyntax(oldOracleJoin) - .withNot(usingNot) - .setGlobal(usingGlobal); - linkAST(inExpression, jjtThis, leftExpression); - return inExpression; - } + { return behavior; } } -Expression IncludesExpression(Expression leftExpression) #IncludesExpression : -{ +JsonTableFunction.JsonTableWrapperClause JsonTableWrapperClause(boolean beforePathExpr) : { + JsonTableFunction.JsonTableWrapperClause wrapperClause = + new JsonTableFunction.JsonTableWrapperClause(beforePathExpr); Token token; - Expression rightExpression; + Token first = getToken(1); } { - (rightExpression = ParenthesedExpressionList()) + ( + { + wrapperClause.setWrapperType(JsonFunction.JsonWrapperType.WITHOUT); + } + | + { + wrapperClause.setWrapperType(JsonFunction.JsonWrapperType.WITH); + } + [ + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && (getToken(1).image.equalsIgnoreCase("CONDITIONAL") + || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL")) + }) + token = + { + if (token.image.equalsIgnoreCase("CONDITIONAL")) { + wrapperClause.setWrapperMode(JsonFunction.JsonWrapperMode.CONDITIONAL); + } else { + wrapperClause.setWrapperMode(JsonFunction.JsonWrapperMode.UNCONDITIONAL); + } + } + ] + ) + [ { wrapperClause.setArray(true); } ] + JsonKeyword("WRAPPER") { - IncludesExpression includesExpression = new IncludesExpression(leftExpression, rightExpression); - - linkAST(includesExpression, jjtThis, leftExpression); - return includesExpression; + return linked(wrapperClause, first); } } -Expression ExcludesExpression(Expression leftExpression) #ExcludesExpression : -{ - Token token; - Expression rightExpression; +JsonTableFunction.JsonTableQuotesClause JsonTableQuotesClause() : { + JsonTableFunction.JsonTableQuotesClause quotesClause = + new JsonTableFunction.JsonTableQuotesClause(); + Token first = getToken(1); } { - (rightExpression = ParenthesedExpressionList()) + ( + { quotesClause.setQuotesType(JsonFunction.JsonQuotesType.KEEP); } + | + JsonKeyword("OMIT") { quotesClause.setQuotesType(JsonFunction.JsonQuotesType.OMIT); } + ) + JsonKeyword("QUOTES") + [ + JsonKeyword("SCALAR") { quotesClause.setOnScalarString(true); } + ] { - ExcludesExpression excludesExpression = new ExcludesExpression(leftExpression, rightExpression); - - linkAST(excludesExpression, jjtThis, leftExpression); - return excludesExpression; + return linked(quotesClause, first); } } -Expression Between(Expression leftExpression) : -{ - Between result = new Between(); - Expression betweenExpressionStart = null; - Expression betweenExpressionEnd = null; +JsonTableFunction.JsonTableColumnDefinition JsonTableColumnDefinition() : { + JsonTableFunction.JsonTableColumnDefinition columnDefinition = null; + JsonTableFunction.JsonTableNestedColumnDefinition nestedColumnDefinition; + JsonTableFunction.JsonTableValueColumnDefinition valueColumnDefinition; + String columnName; + ColDataType dataType; + Expression expression; + String pathName = null; + JsonTableFunction.JsonTableColumnsClause columnsClause; + JsonFunction.JsonOnResponseBehavior behavior; + JsonTableFunction.JsonTableWrapperClause wrapperClause; + JsonTableFunction.JsonTableQuotesClause quotesClause; + String encoding; + String collation; + Token collationLiteral; + Token first = getToken(1); } { - [ { result.setNot(true); }] - - [ - LOOKAHEAD(2) ( - { result.setUsingSymmetric(true); } - | - { result.setUsingAsymmetric(true); } - ) - ] + ( + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("NESTED") }) + JsonKeyword("NESTED") + { nestedColumnDefinition = new JsonTableFunction.JsonTableNestedColumnDefinition(); } + [ LOOKAHEAD(2) { nestedColumnDefinition.setPathKeyword(true); } ] + expression = Expression() { nestedColumnDefinition.setPathExpression(expression); } + [ pathName = RelObjectName() { nestedColumnDefinition.setPathName(pathName); } ] + columnsClause = JsonTableColumnsClause() { + nestedColumnDefinition.setColumnsClause(columnsClause); + columnDefinition = nestedColumnDefinition; + } + | + columnName = RelObjectName() { + valueColumnDefinition = new JsonTableFunction.JsonTableValueColumnDefinition(); + valueColumnDefinition.setColumnName(columnName); + columnDefinition = valueColumnDefinition; + } ( - LOOKAHEAD({ isParenthesedSelectAhead() }) betweenExpressionStart = ParenthesedSelect() + { valueColumnDefinition.setForOrdinality(true); } | - betweenExpressionStart = SimpleExpression() [ - LOOKAHEAD({ isComparisonOperatorAhead() }) - betweenExpressionStart = RegularConditionRHS(betweenExpressionStart, EqualsTo.NO_ORACLE_JOIN) + // Very ugly: ColDataType can consume an IDENTIFIER, which is fine, but we don't want it to + // consume an ALLOW or DISALLOW because that's a keyword for Oracle in this place. + // So we make a LOOKAHEAD on ColDataType, BUT we exclude the two cases for the IDENTIFIER + + /* + [ ColDataType ] + [ FORMAT JSON ] + [ (ALLOW | DISALLOW) SCALARS ] + */ + + LOOKAHEAD( + ColDataType(), + { getToken(1).kind != K_PATH + && !(getToken(1).kind == S_IDENTIFIER && ( + getToken(1).image.equalsIgnoreCase("ALLOW") + || getToken(1).image.equalsIgnoreCase("DISALLOW"))) } ) + dataType = ColDataType() { valueColumnDefinition.setDataType(dataType); } + [ LOOKAHEAD({ Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_COLLATE }) + + ( collation = RelObjectName() + | collationLiteral = { collation = collationLiteral.image; } ) + { valueColumnDefinition.setCollation(collation); } + ] ] [ - LOOKAHEAD("(" "+" ")") - "(" "+" ")" - { - if (betweenExpressionStart instanceof Column) { - ((Column) betweenExpressionStart).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); - } - } + { valueColumnDefinition.setFormatJson(true); } + [ encoding = JsonEncoding() { valueColumnDefinition.setEncoding(encoding); } ] ] - ) - - - ( - LOOKAHEAD({ isParenthesedSelectAhead() }) betweenExpressionEnd = ParenthesedSelect() - | - betweenExpressionEnd = SimpleExpression() [ - LOOKAHEAD({ isComparisonOperatorAhead() }) - betweenExpressionEnd = RegularConditionRHS(betweenExpressionEnd, EqualsTo.NO_ORACLE_JOIN) + ( + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("ALLOW") }) + JsonKeyword("ALLOW") { valueColumnDefinition.setScalarsType(JsonFunction.ScalarsType.ALLOW); } + | + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("DISALLOW") }) + JsonKeyword("DISALLOW") { valueColumnDefinition.setScalarsType(JsonFunction.ScalarsType.DISALLOW); } + ) + JsonKeyword("SCALARS") ] + [ { valueColumnDefinition.setExistsKeyword(true); } ] + // In Oracle, the wrapper clause comes before the PATH expression + [ LOOKAHEAD(2) wrapperClause = JsonTableWrapperClause(true) { valueColumnDefinition.setWrapperClause(wrapperClause); } ] + [ expression = Expression() { valueColumnDefinition.setPathExpression(expression); } ] + // In Truno the wrapper clause comes after the PATH expression + [ wrapperClause = JsonTableWrapperClause(false) { valueColumnDefinition.setWrapperClause(wrapperClause); } ] [ - LOOKAHEAD("(" "+" ")") - "(" "+" ")" + LOOKAHEAD({ + getToken(1).kind == K_KEEP + || (getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("OMIT")) + }) + quotesClause = JsonTableQuotesClause() { valueColumnDefinition.setQuotesClause(quotesClause); } + ] + [ + LOOKAHEAD( JsonTableOnResponseBehavior() ) + behavior = JsonTableOnResponseBehavior() + + { valueColumnDefinition.setOnEmptyBehavior(behavior); } + ] + [ + LOOKAHEAD( JsonTableOnResponseBehavior() ) + behavior = JsonTableOnResponseBehavior() + + { valueColumnDefinition.setOnErrorBehavior(behavior); } + ] + [ + LOOKAHEAD( JsonTableOnResponseBehavior() ) + behavior = JsonTableOnResponseBehavior() + { - if (betweenExpressionEnd instanceof Column) { - ((Column) betweenExpressionEnd).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); - } + valueColumnDefinition.setOnEmptyBehavior(behavior); + valueColumnDefinition.setOnEmptyAfterOnError(true); } ] ) + ) + { + return linked(columnDefinition, first); + } +} + +JsonTableFunction.JsonTableColumnsClause JsonTableColumnsClause() : { + JsonTableFunction.JsonTableColumnsClause columnsClause = + new JsonTableFunction.JsonTableColumnsClause(); + JsonTableFunction.JsonTableColumnDefinition columnDefinition; + Token first = getToken(1); +} +{ + "(" + [ + columnDefinition = JsonTableColumnDefinition() { + columnsClause.addColumnDefinition(columnDefinition); + } + ( + "," + columnDefinition = JsonTableColumnDefinition() { + columnsClause.addColumnDefinition(columnDefinition); + } + )* + ] + ")" + { + return linked(columnsClause, first); + } +} +JsonTableFunction.JsonTablePlanTerm JsonTablePlanTerm() : { + JsonTableFunction.JsonTablePlanTerm term = null; + String value; + Expression expression; + JsonTableFunction.JsonTablePlanExpression nestedPlanExpression; + Token first = getToken(1); +} +{ + ( + LOOKAHEAD(2) + "(" nestedPlanExpression = JsonTablePlanExpression() ")" { + term = new JsonTableFunction.JsonTablePlanTerm(); + term.setNestedPlanExpression(nestedPlanExpression); + } + | + LOOKAHEAD(2) + value = RelObjectName() { + term = new JsonTableFunction.JsonTablePlanTerm(); + term.setName(value); + } + | + expression = Expression() { + term = new JsonTableFunction.JsonTablePlanTerm(); + term.setExpression(expression); + } + ) { - result.setLeftExpression(leftExpression); - result.setBetweenExpressionStart(betweenExpressionStart); - result.setBetweenExpressionEnd(betweenExpressionEnd); - return result; + return linked(term, first); } } -Expression LikeExpression(Expression leftExpression) #LikeExpression: -{ - LikeExpression result = new LikeExpression(); - Expression rightExpression = null; - Expression escape; - Token token; +JsonTableFunction.JsonTablePlanExpression JsonTablePlanExpression() : { + JsonTableFunction.JsonTablePlanExpression planExpression = + new JsonTableFunction.JsonTablePlanExpression(); + JsonTableFunction.JsonTablePlanTerm term; + Token operator = null; + Token first = getToken(1); } { - [ { result.setNot(true); } ] + term = JsonTablePlanTerm() { planExpression.addTerm(term); } ( - token = - | token = - | token = - | token = - | token = - | token = - | token = - | token = - | token = - | token = - | token = - | token = - ) { result.setLikeKeyWord( LikeExpression.KeyWord.from(token.image)); } - [ LOOKAHEAD(2) {result.setUseBinary(true); } ] - rightExpression=SimpleExpression() - [ - LOOKAHEAD("(" "+" ")") - "(" "+" ")" - { - if (rightExpression instanceof Column) { - ((Column) rightExpression).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); - } - } - ] - [ LOOKAHEAD(2) ( - LOOKAHEAD(2) token = { result.setEscape( new StringValue( token.image ) ); } + operator = { + planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.COMMA); + } | - escape=Expression() { result.setEscape(escape); } + operator = { + planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.INNER); + } + | + operator = { + planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.OUTER); + } + | + operator = { + planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.CROSS); + } + | + operator = { + planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.UNION); + } ) - ] + term = JsonTablePlanTerm() { planExpression.addTerm(term); } + )* { - result.setLeftExpression(leftExpression); - result.setRightExpression(rightExpression); - linkAST(result, jjtThis, leftExpression); - return result; + return linked(planExpression, first); } } -Expression SimilarToExpression(Expression leftExpression) #SimilarToExpression: -{ - SimilarToExpression result = new SimilarToExpression(); - Expression rightExpression = null; +JsonTableFunction.JsonTablePlanClause JsonTablePlanClause() : { + JsonTableFunction.JsonTablePlanClause planClause = + new JsonTableFunction.JsonTablePlanClause(); + JsonTableFunction.JsonTablePlanExpression planExpression; + Token first = getToken(1); } { - [ { result.setNot(true); } ] - - rightExpression=SimpleExpression() - [ - LOOKAHEAD("(" "+" ")") - "(" "+" ")" - { - if (rightExpression instanceof Column) { - ((Column) rightExpression).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); - } - } - ] - [ LOOKAHEAD(2) token= { result.setEscape((new StringValue(token.image)).getValue()); }] + + [ { planClause.setDefaultPlan(true); } ] + "(" planExpression = JsonTablePlanExpression() ")" { planClause.setPlanExpression(planExpression); } { - result.setLeftExpression(leftExpression); - result.setRightExpression(rightExpression); - linkAST(result, jjtThis, leftExpression); - return result; + return linked(planClause, first); } } -Expression IsDistinctExpression(Expression leftExpression) #IsDistinctExpression: -{ - IsDistinctExpression result = new IsDistinctExpression(); - Expression rightExpression = null; +JsonTableFunction.JsonTableOnErrorClause JsonTableOnErrorClause(boolean beforeColumns) : { + JsonTableFunction.JsonTableOnErrorClause onErrorClause = + new JsonTableFunction.JsonTableOnErrorClause(beforeColumns); + Token token; + Token first = getToken(1); } { - [ { result.setNot(true); } ] - rightExpression=SimpleExpression() + ( + { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.ERROR); } + | + { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.EMPTY); } + | + { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.TRUE); } + | + { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.FALSE); } + | + { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.NULL); } + ) + { - result.setLeftExpression(leftExpression); - result.setRightExpression(rightExpression); - linkAST(result, jjtThis, leftExpression); - return result; + return linked(onErrorClause, first); } } -Expression IsNullExpression(Expression leftExpression): -{ - IsNullExpression result = new IsNullExpression(); +JsonTableFunction.JsonTableOnEmptyClause JsonTableOnEmptyClause() : { + JsonTableFunction.JsonTableOnEmptyClause onEmptyClause = + new JsonTableFunction.JsonTableOnEmptyClause(); + Token token; + Token first = getToken(1); } { ( - [ { result.setNot(true); } ] { result.setUseIsNull(true); } - | { result.setUseIsNull(true); result.setUseNotNull(true); } - | [ { result.setNot(true); } ] + { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.ERROR); } + | + { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.EMPTY); } + | + { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.TRUE); } + | + { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.FALSE); } + | + { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.NULL); } ) + { - result.setLeftExpression(leftExpression); - return result; + return linked(onEmptyClause, first); } } -Expression IsBooleanExpression(Expression leftExpression): -{ - IsBooleanExpression result = new IsBooleanExpression(); +JsonTableFunction.JsonTableParsingTypeClause JsonTableParsingTypeClause() : { + JsonTableFunction.JsonTableParsingTypeClause parsingType = new JsonTableFunction.JsonTableParsingTypeClause(); + Token first = getToken(1); } { - ( - [ { result.setNot(true); } ] ( { result.setIsTrue(true); } | { result.setIsTrue(false); }) - ) - + + + ( + { parsingType.setType(JsonTableFunction.JsonTableParsingType.STRICT); } + | + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("LAX") }) + JsonKeyword("LAX") { parsingType.setType(JsonTableFunction.JsonTableParsingType.LAX); } + ) + { - result.setLeftExpression(leftExpression); - return result; + return linked(parsingType, first); } } -Expression IsJsonExpression(Expression leftExpression): -{ - IsJsonExpression result = new IsJsonExpression(); - Token type; +JsonTableFunction JsonTableBody() : { + JsonTableFunction function = new JsonTableFunction(); + Expression jsonInput; + Expression jsonPath; + JsonTableFunction.JsonTablePassingClause passingClause; + String pathName = null; + JsonTableFunction.JsonTableColumnsClause columnsClause; + JsonTableFunction.JsonTablePlanClause planClause = null; + JsonTableFunction.JsonTableOnErrorClause onErrorClause = null; + JsonTableFunction.JsonTableParsingTypeClause parsingTypeClause = null; + JsonTableFunction.JsonTableOnEmptyClause onEmptyClause = null; } { - [ { result.setNot(true); } ] - [ LOOKAHEAD({ isKeywordAhead("VALUE") || isKeywordAhead("SCALAR") - || isKeywordAhead("ARRAY") || isKeywordAhead("OBJECT") }) - ( type= | type= | type= | type= ) - { result.setType(IsJsonExpression.Type.valueOf(type.image.toUpperCase(Locale.ROOT))); } ] - [ LOOKAHEAD(2) ( { result.setUniqueKeys(IsJsonExpression.UniqueKeys.WITH); } - | { result.setUniqueKeys(IsJsonExpression.UniqueKeys.WITHOUT); } ) - { result.setUseKeysKeyword(false); } - [ LOOKAHEAD() { result.setUseKeysKeyword(true); } ] ] - { result.setLeftExpression(leftExpression); return result; } + "(" + jsonInput = Expression() { + function.setJsonInputExpression(jsonInput); + } + [ { function.setFormatJson(true); } ] + [ + "," + jsonPath = Expression() { + function.setJsonPathExpression(jsonPath); + function.setParameters(linkElements(new ExpressionList(jsonInput, jsonPath))); + } + [ pathName = RelObjectName() { function.setPathName(pathName); } ] + ] + [ + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) + JsonKeyword("PASSING") + passingClause = JsonTablePassingClause() { function.addPassingClause(passingClause); } + ( + "," + passingClause = JsonTablePassingClause() { function.addPassingClause(passingClause); } + )* + ] + [ LOOKAHEAD(3) onErrorClause = JsonTableOnErrorClause(true) { function.setOnErrorClause(onErrorClause); } ] + [ parsingTypeClause = JsonTableParsingTypeClause() { function.setParsingTypeClause(parsingTypeClause); } ] + [ onEmptyClause = JsonTableOnEmptyClause() { function.setOnEmptyClause(onEmptyClause); } ] + columnsClause = JsonTableColumnsClause() { function.setColumnsClause(columnsClause); } + [ planClause = JsonTablePlanClause() { function.setPlanClause(planClause); } ] + [ onErrorClause = JsonTableOnErrorClause(false) { function.setOnErrorClause(onErrorClause); } ] + ")" + { + return function; + } } -Expression IsUnknownExpression(Expression leftExpression): -{ - IsUnknownExpression result = new IsUnknownExpression(); +XmlTableFunction.XmlTablePassingClause XmlTablePassingClause() : { + XmlTableFunction.XmlTablePassingClause passingClause = new XmlTableFunction.XmlTablePassingClause(); + Expression valueExpression; + String name = null; + Token first = getToken(1); } { - ( - [ { result.setNot(true); } ] - ) - + valueExpression = Expression() { passingClause.setValueExpression(valueExpression); } + [ name = RelObjectName() { passingClause.setName(name); } ] { - result.setLeftExpression(leftExpression); - return result; + return linked(passingClause, first); } } -Expression ExistsExpression(): -{ - ExistsExpression result = new ExistsExpression(); - Expression rightExpression = null; +XmlTableFunction.XmlTableColumnDefinition XmlTableColumnDefinition() : { + XmlTableFunction.XmlTableColumnDefinition columnDefinition = new XmlTableFunction.XmlTableColumnDefinition(); + String columnName; + ColDataType dataType; + Expression expression; + Token first = getToken(1); } { - rightExpression=SimpleExpression() + columnName = RelObjectName() { columnDefinition.setColumnName(columnName); } + ( + { columnDefinition.setForOrdinality(true); } + | + dataType = ColDataType() { columnDefinition.setDataType(dataType); } + [ expression = Expression() { columnDefinition.setPathExpression(expression); } ] + [ expression = Expression() { columnDefinition.setDefaultExpression(expression); } ] + ) { - result.setRightExpression(rightExpression); - return result; + return linked(columnDefinition, first); } } -Expression MemberOfExpression(Expression leftExpression): -{ - MemberOfExpression result; - Expression rightExpression = null; +XmlTableFunction XmlTableBody() : { + XmlTableFunction function = new XmlTableFunction(); + Expression rowPath; + XmlTableFunction.XmlTablePassingClause passingClause; + XmlTableFunction.XmlTableColumnDefinition columnDefinition; } { - rightExpression=Expression() + "(" + rowPath = Expression() { function.setRowPathExpression(rowPath); } + [ + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) + + passingClause = XmlTablePassingClause() { function.addPassingClause(passingClause); } + ( + "," + passingClause = XmlTablePassingClause() { function.addPassingClause(passingClause); } + )* + ] + [ + + columnDefinition = XmlTableColumnDefinition() { function.addColumnDefinition(columnDefinition); } + ( + "," + columnDefinition = XmlTableColumnDefinition() { function.addColumnDefinition(columnDefinition); } + )* + ] + ")" { - return new MemberOfExpression(leftExpression, rightExpression ); + return function; } } -ExpressionList ExpressionList() #ExpressionList: +TableFunction TableFunction(): { - ExpressionList expressionList; + Token prefix = null; + Function function = null; + ParenthesedExpressionList rowsFromFunctions = null; + Token withClause = null; + Token keyword; } { + [ prefix = ] ( - LOOKAHEAD(3, { !interrupted }) expressionList = ComplexExpressionList() - | - LOOKAHEAD(3) expressionList = SimpleExpressionList() + LOOKAHEAD(3) rowsFromFunctions = RowsFromFunctionList() | - LOOKAHEAD(3) expressionList = ParenthesedExpressionList() + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("JSON_TABLE") + }) + JsonKeyword("JSON_TABLE") { keyword = getToken(0); } + function = JsonTableBody() { linkAST(function, keyword); } | - // Fallback, see isUnparenthesizedSelectAhead(): the three probes above are - // syntactic and cannot see through the Pratt operator loop, which lives in a - // Java action. They all fail on a bracketed operand of a larger expression, - // e.g. "( 1 + a ) / ( 1 + b )" or "( 1 + a )" - the third token is an operator - // where the probe expects "," or ")". Such input is still a valid expression - // list, so parse it as one instead of raising a ParseException. - LOOKAHEAD({ !interrupted }) expressionList = ComplexExpressionList() + LOOKAHEAD({ + getToken(1).kind == S_IDENTIFIER + && getToken(1).image.equalsIgnoreCase("XMLTABLE") + }) + keyword= + function = XmlTableBody() { linkAST(function, keyword); } | - expressionList = SimpleExpressionList() + function=Function() ) + [ LOOKAHEAD(2) ( withClause = | withClause = ) ] { - // Avoid redundant ExpressionLists containing only one ParenthesedExpressionList - // return the Parenthesed Sub ExpressionList instead - // Same for ParenthesedExpressionList containing only 1 ExpressionList - - if ( expressionList.size() == 1 && expressionList.get(0) instanceof ExpressionList ) { - ExpressionList subList = (ExpressionList) expressionList.get(0); - if (expressionList instanceof ParenthesedExpressionList) { - if (subList instanceof ParenthesedExpressionList) { - return expressionList; - } else { - return new ParenthesedExpressionList(subList); - } - } else { - if (subList instanceof ParenthesedExpressionList) { - return new ParenthesedExpressionList(subList); - } else { - return subList; - } - } + if (rowsFromFunctions != null) { + return prefix != null + ? withClause != null + ? new TableFunction(prefix.image, rowsFromFunctions, withClause.image) + : new TableFunction(prefix.image, rowsFromFunctions) + : withClause != null + ? new TableFunction(rowsFromFunctions, withClause.image) + : new TableFunction(rowsFromFunctions); } - return expressionList; + + return prefix != null + ? withClause != null + ? new TableFunction(prefix.image, function, withClause.image) + : new TableFunction(prefix.image, function) + : withClause != null + ? new TableFunction(function, withClause.image) + : new TableFunction(function); } } -ParenthesedExpressionList ParenthesedExpressionList(): +ParenthesedExpressionList RowsFromFunctionList(): { - ExpressionList expressions=new ExpressionList(); + ParenthesedExpressionList functions = new ParenthesedExpressionList(); + Function function; + Token first = getToken(1); } { "(" - ( - LOOKAHEAD({ !interrupted }) expressions = ComplexExpressionList() - | - expressions = SimpleExpressionList() - )? + function = RowsFromFunction() { functions.add(function); } + ( + "," + function = RowsFromFunction() { functions.add(function); } + )* ")" { - return new ParenthesedExpressionList(expressions); + linkAST(functions, first); + return functions; } } -ExpressionList SimpleExpressionList(): +/** A function and its optional PostgreSQL record column definition list. */ +Function RowsFromFunction(): { - ExpressionList columns; - ExpressionList expressions = new ExpressionList(); - Expression expr; + Function function; + List columns = new ArrayList(); + ColumnDefinition column; } { - expr=SimpleExpression() { expressions.add(expr); } - ( - LOOKAHEAD(2, {!interrupted} ) "," - ( - LOOKAHEAD( RelObjectName() "->", { !isJsonArrowDialect() } ) expr=LambdaExpression() - | - expr=SimpleExpression() - ) - { - expressions.add(expr); - } - )* - { - return expressions; - } + function=Function() + [ "(" + column=RowsFromColumnDefinition() { columns.add(column); } + ( "," column=RowsFromColumnDefinition() { columns.add(column); } )* + ")" { function.setResultColumnDefinitions(columns); } + ] + { return function; } } - -ExpressionList ColumnList(): +ColumnDefinition RowsFromColumnDefinition(): { - ExpressionList expressions = new ExpressionList(); - Column expr; + String name; + String collation; + String part; + ColDataType type; + ColumnDefinition column; } { - expr=Column() { expressions.add(expr); } - ( LOOKAHEAD(2) "," expr=Column() { expressions.add(expr); } )* - { - return expressions; - } + name=RelObjectName() type=ColDataType() + { column = new ColumnDefinition(name, type); } + [ collation=RelObjectName() + ( "." part=RelObjectName() { collation += "." + part; } )* + { column.addColumnOptions(ColumnOption.collate(collation)); } + ] + { return column; } } -ParenthesedExpressionList ParenthesedColumnList(): -{ - ExpressionList expressions; +List ColumnNamesWithParamsList() : { + List colNames = new ArrayList(); + String columnName; + List parameter = null; } { - "(" expressions = ColumnList() ")" + "(" + columnName=RelObjectName() + + { parameter = null; } + [ parameter = CreateParameter() ] { - return new ParenthesedExpressionList(expressions); + colNames.add(new KeyElement(columnName,parameter)); } + + ( + "," + columnName=RelObjectName() + + { parameter = null; } + [ parameter = CreateParameter() ] + { + colNames.add(new KeyElement(columnName,parameter)); + } + )* + + ")" + + { return colNames; } } -ExpressionList ComplexExpressionList(): -{ - ExpressionList columns; - ExpressionList expressions = new ExpressionList(); - Expression expr; +KeyElement IndexColumnWithParams(): { + String columnName = null; + List columnParams = new ArrayList(); + List parameter = null; + Expression expression = null; + String collation = null; + String operatorClass = null; + List operatorClassParameters = null; + Token sortOrder = null; + Token nullOrdering = null; + KeyElement column = null; + boolean postgres = Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)); + boolean expressionParenthesized = true; } { ( - LOOKAHEAD(2) expr=OracleNamedFunctionParameter() + 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; } | - LOOKAHEAD(2) expr=PostgresNamedFunctionParameter() + columnName=RelObjectName() | - expr=Expression() + "(" expression=Expression() ")" ) + // MySQL prefix lengths precede all PostgreSQL key attributes. + [ LOOKAHEAD("(", { !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) parameter=CreateParameter() { columnParams.addAll(parameter); } ] + [ LOOKAHEAD(2) collation=IndexKeyAttributeName() + { if (!postgres) { columnParams.add("COLLATE"); columnParams.add(collation); } } ] + [ LOOKAHEAD(2, IndexKeyAttributeName(), { + getToken(1).kind == S_IDENTIFIER || getToken(1).kind == S_QUOTED_IDENTIFIER + || (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind != K_ASC && getToken(1).kind != K_DESC + && getToken(1).kind != K_NULLS && getToken(1).kind != K_COLLATE + && getToken(1).kind != K_WITH && getToken(1).kind != K_WITHOUT) }) + operatorClass=IndexKeyAttributeName() + [ LOOKAHEAD(2) operatorClassParameters=PostgreSqlOptions(false) ] + { + if (!postgres) { + columnParams.add(operatorClass); + if (operatorClassParameters != null) { + columnParams.add(PlainSelect.getStringList( + operatorClassParameters, true, true)); + } + } + } + ] + [ LOOKAHEAD(2) (sortOrder= | sortOrder=) + { if (!postgres) { columnParams.add(sortOrder.image); } } ] + [ LOOKAHEAD(2) (nullOrdering= | nullOrdering=) + { if (!postgres) { columnParams.add("NULLS"); columnParams.add(nullOrdering.image); } } ] + ( LOOKAHEAD(2, { !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && getToken(1).kind != K_WITH && getToken(1).kind != K_WITHOUT }) parameter=CreateParameter() { columnParams.addAll(parameter); } )* { - expressions.add(expr); - } - - ( - LOOKAHEAD(2, {!interrupted}) "," - ( - LOOKAHEAD(2) expr=OracleNamedFunctionParameter() - | - LOOKAHEAD(2) expr=PostgresNamedFunctionParameter() - | - LOOKAHEAD( RelObjectName() "->", { !isJsonArrowDialect() } ) expr=LambdaExpression() - | - expr=Expression() - ) { expressions.add(expr); } - )* - - { - return expressions; + column = expression != null + ? new KeyElement(expression, + columnParams.isEmpty() ? null : columnParams) + : new KeyElement(columnName, + columnParams.isEmpty() ? null : columnParams); + column.setCollation(collation); + column.setExpressionParenthesized(expressionParenthesized); + if (operatorClass != null) { + column.setOperatorClass(operatorClass); + column.setOperatorClassParameters(operatorClassParameters); + } + if (sortOrder != null) { + column.setSortOrder(KeyElement.SortOrder.valueOf( + sortOrder.image.toUpperCase(Locale.ROOT))); + } + if (nullOrdering != null) { + column.setNullOrdering(KeyElement.NullOrdering.valueOf( + nullOrdering.image.toUpperCase(Locale.ROOT))); + } + return column; } } -// @Todo: Refactor this with proper SQL:2016 functions according to https://manticore-projects.com/SQL2016Parser/syntax.html#character-value-function -// substring(expr1 from expr2) -// substring(expr1 from expr2 for expr3) -// trim(expr1 from expr2) <-- Superceded by TrimFunction() below -// position(expr1 in expr2) -// overlay(expr1 placing expr2 from expr3) -// overlay(expr1 placing expr2 from expr3 for expr4) -// expr1 has already been consumed -NamedExpressionList NamedExpressionListExprFirst(): +/** Keeps qualified PostgreSQL collation and operator-class names out of expression parsing. */ +String IndexKeyAttributeName(): { - NamedExpressionList retval = new NamedExpressionList(); - List expressions = new ArrayList(); - List names = new ArrayList(); - Expression expr1 = null; - Expression expr2 = null; - Expression expr3 = null; - Expression expr4 = null; - Token tk2 = null; - Token tk3 = null; - Token tk4 = null; + String name; + String part; } { - expr1=SimpleExpression() - (tk2=|tk2=|tk2=) - { - names.add(""); - expressions.add(expr1); - names.add(tk2.image); - } - ( - expr2=SimpleExpression() { expressions.add(expr2);} - ( - (tk3=|tk3=) - expr3=SimpleExpression() {names.add(tk3.image); expressions.add(expr3);} - ( - (tk4=) - expr4=SimpleExpression() {names.add(tk4.image); expressions.add(expr4);} - )? - )? - ) + name=RelObjectName() + ( LOOKAHEAD(".", { Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + "." part=RelObjectNameExt() { name += "." + part; } + )* + { return name; } +} +IndexOption PostgreSqlIndexOption(boolean allowBare): +{ + String name = null; + Expression value = null; + boolean useEquals = false; +} +{ + name=PostgreSqlStorageParameterName() + [ [ "=" { useEquals = true; } ] value=Expression() ] { - retval.setNames(names); - retval.setExpressions(expressions); - return retval; + requireDdlSyntax(allowBare || value != null, + "Operator-class parameters require a value"); + requireDdlSyntax(value == null || useEquals + || !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)), + "PostgreSQL parameter values require an equals sign"); + return new IndexOption(name, value, useEquals); } } -Expression ComparisonItem() : +/** Storage parameters can have namespaces, such as toast.autovacuum_enabled. */ +String PostgreSqlStorageParameterName(): +{ String name; String part; } { - Expression retval = null; + name=RelObjectName() + ( LOOKAHEAD(1, ".") "." part=RelObjectNameExt() { name += "." + part; } )* + { return name; } } -{ - ( - LOOKAHEAD(6, { getToken(1).kind == K_ANY || getToken(1).kind == K_SOME || getToken(1).kind == K_ALL }) retval=AnyComparisonExpression() - | - LOOKAHEAD({ getToken(1).kind == K_ROW }) retval=RowConstructor() - | - retval=SimpleExpression() - ) - { - return retval; - } -} +/** Storage parameters allow a bare name; operator-class parameters require a value. */ +List PostgreSqlIndexOptions(): +{ List options; } +{ options=PostgreSqlOptions(true) { return options; } } -Expression AnyComparisonExpression() : +List PostgreSqlOptions(boolean allowBare): { - AnyType anyType; - Select select; + List options = new ArrayList(); + IndexOption option = null; } { - ( - { anyType = AnyType.ANY; } - | - { anyType = AnyType.SOME; } - | - { anyType = AnyType.ALL; } - ) - select = ParenthesedSelect() - { - return new AnyComparisonExpression(anyType, select); - } + "(" option=PostgreSqlIndexOption(allowBare) { options.add(option); } + ( "," option=PostgreSqlIndexOption(allowBare) { options.add(option); } )* ")" + { return options; } } -Expression SimpleExpression(): -{ - Expression retval = null; - UserVariable user = null; - Token operation = null; +List IndexColumnsWithParamsList(): +{ List columns; } +{ columns=IndexKeyColumns(false) { return columns; } } + +List IndexKeyColumns(boolean temporal) : { + List colNames = new ArrayList(); + KeyElement column = null; } { - [ LOOKAHEAD( 5, { getToken(1).kind == S_AT_IDENTIFIER } ) user = UserVariable() ( operation = "=" | operation = ":=" ) ] - retval=PrimaryExpression() - // PostgreSQL path operators bind below arithmetic and above comparisons. - { retval = prattArithRest(retval, 4); } + "(" + column=IndexColumnWithParams() { - if (user != null) { - VariableAssignment assignment = new VariableAssignment(); - assignment.setVariable(user); - assignment.setOperation(operation.image); - assignment.setExpression(retval); - return assignment; - } else - return retval; + colNames.add(column); } + + ( + "," + column=IndexColumnWithParams() + { + colNames.add(column); + } + )* + + [ { + requireDdlSyntax(temporal, "WITHOUT OVERLAPS requires a PRIMARY KEY or UNIQUE constraint"); + column.setWithoutOverlaps(true); + } ] + ")" + + { return colNames; } } -StringValue CharacterSetIntroducedString(): -{ - Token introducer; - Token literal; +Index Index(): { + ObjectNames name; } { - introducer= literal= - { - return new StringValue(literal.image).withPrefix(introducer.image); - } + name= RelObjectNames() { return new Index().withName(name.getNames()).withType(""); } } -/** Multiplicative/bitwise-shift — higher precedence */ -Expression MulChain(): +/** Parses dialect-specific index modifiers while retaining the legacy single type token. */ +Index CreateIndexModifiers(CreateIndex statement): { - Expression retval; - Expression right; + Index index = new Index(); + Token token; + List parameter; + IndexOptions.Clustering clustering; } { - retval=PrimaryExpression() ( - LOOKAHEAD(2) - ( - "*" right=PrimaryExpression() {{ Multiplication r = new Multiplication(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=PrimaryExpression() {{ Division r = new Division(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - "%" right=PrimaryExpression() {{ Modulo r = new Modulo(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=PrimaryExpression() {{ net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=PrimaryExpression() {{ IntegerDivision r = new IntegerDivision(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - ) - )* - { return retval; } + LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_UNIQUE || isKeywordAhead("CLUSTERED") + || isKeywordAhead("NONCLUSTERED")) }) + [ token= { index.setType(token.image); } ] + clustering=SqlServerIndexClustering() { index.setClustering(clustering); } + | + LOOKAHEAD({ Dialect.SPANNER.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_UNIQUE || isKeywordAhead("NULL_FILTERED")) }) + [ token= { index.setType(token.image); } ] + [ LOOKAHEAD({ isKeywordAhead("NULL_FILTERED") }) token= + { statement.setNullFiltered(true); } ] + | + [ parameter=CreateParameter() { index.setType(parameter.get(0)); } ] + ) + { return index; } } -/** Additive/concat/bitwise — lower precedence */ -Expression AddChain(): +CreateIndex CreateIndex(): { - Expression retval; - Expression right; + CreateIndex createIndex = new CreateIndex(); + Table table = null; + List colNames; + List includeColumns; + Boolean nullsDistinct = null; + List storageParameters = null; + String tableSpace = null; + Expression where = null; + String indexType; + Index index; + ObjectNames name; } { - retval=MulChain() - ( - LOOKAHEAD(2) - ( - "+" right=MulChain() {{ Addition r = new Addition(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - "-" right=MulChain() {{ Subtraction r = new Subtraction(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=MulChain() {{ Concat r = new Concat(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - LOOKAHEAD(2) right=MulChain() {{ Concat r = new Concat(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=MulChain() {{ BitwiseOr r = new BitwiseOr(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - "&" right=MulChain() {{ BitwiseAnd r = new BitwiseAnd(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=MulChain() {{ BitwiseLeftShift r = new BitwiseLeftShift(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - | - right=MulChain() {{ BitwiseRightShift r = new BitwiseRightShift(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }} - ) - )* - { return retval; } -} + index=CreateIndexModifiers(createIndex) -Expression ArrayExpression(Expression obj): { - Expression expr; - Expression idxExpr = null; - Expression startExpr = null; - Expression stopExpr = null; -} { - "[" - [LOOKAHEAD(3) idxExpr = ArrayIndexExpression()] - [ - (":" { startExpr=idxExpr; idxExpr=null; }) - [stopExpr = SimpleExpression()] - ] - "]" - { expr = new ArrayExpression(obj, idxExpr, startExpr, stopExpr); } + + [ LOOKAHEAD({ getToken(1).kind == K_CONCURRENTLY }) + { createIndex.setConcurrently(true); } ] + [ LOOKAHEAD(2) { createIndex.setUsingIfNotExists(true);} ] + [ LOOKAHEAD({ getToken(1).kind != K_ON && getToken(1).kind != K_USING }) + name=RelObjectNames() { index.setName(name.getNames()); } ] ( - LOOKAHEAD(2) "[" - [LOOKAHEAD(3) idxExpr = ArrayIndexExpression()] - [ - (":" { startExpr=idxExpr; idxExpr=null; }) - [stopExpr = SimpleExpression()] + LOOKAHEAD(3)( + [ LOOKAHEAD(2) { createIndex.setOnly(true); } ] table=Table() + [ indexType=UsingIndexType() { index.setUsing(indexType); } ] + ) + | + ( + [ indexType=UsingIndexType() { + index.setUsing(indexType); + createIndex.setIndexTypeBeforeOn(true); + } ] - "]" - { expr = new ArrayExpression(expr, idxExpr, startExpr, stopExpr); } - )* - { return expr; } + [ LOOKAHEAD(2) { createIndex.setOnly(true); } ] table=Table() + ) + ) + colNames = IndexColumnsWithParamsList() + [ includeColumns=ColumnsNamesList() + { createIndex.setIncludeColumns(includeColumns); } + ] + [ LOOKAHEAD(3) [ { nullsDistinct = false; } ] + { + if (nullsDistinct == null) { + nullsDistinct = true; + } + createIndex.setNullsDistinct(nullsDistinct); + } + ] + [ LOOKAHEAD(2) storageParameters=PostgreSqlIndexOptions() + { createIndex.setStorageParameters(storageParameters); } ] + [ LOOKAHEAD(2) tableSpace=RelObjectName() + { createIndex.setTableSpace(tableSpace); } ] + [ LOOKAHEAD(2) where=Expression() { createIndex.setWhere(where); } ] + ( LOOKAHEAD(2, { getToken(1).kind != K_LOCK || getToken(2).kind != K_TABLE }) + CreateIndexTailOption(createIndex, index) )* + { + index.setColumns(colNames); + createIndex.setIndex(index); + createIndex.setTable(table); + return createIndex; + } } /** - * Array subscript index. BigQuery addresses array elements positionally with - * OFFSET(n), ORDINAL(n), SAFE_OFFSET(n) and SAFE_ORDINAL(n). Only OFFSET needs - * an explicit rule here, the others are plain identifiers and parse as functions. + * Index options shared with table key definitions are kept on the index, ALGORITHM and LOCK on + * the statement. Other trailing tokens remain opaque index options. */ -Expression ArrayIndexExpression() : +void CreateIndexTailOption(CreateIndex statement, Index index): { - Token token; - Expression expr; + AlgorithmOrLockOption algorithmOrLock; + IndexSpecOption option; + List parameter; } { ( - LOOKAHEAD(2) token = "(" expr = SimpleExpression() ")" - { - return new Function() - .withName(token.image) - .withParameters(new ExpressionList(expr)); - } + LOOKAHEAD({ getToken(1).kind == K_ALGORITHM || getToken(1).kind == K_LOCK }) + algorithmOrLock=IndexAlgorithmOrLockOption() + { statement.addAlgorithmOrLockOptions(algorithmOrLock); } | - expr = SimpleExpression() { return expr; } + LOOKAHEAD(IndexSpecOption(), { !(getToken(1).kind == K_USING && getToken(2).kind == K_INDEX) }) + option=IndexSpecOption() { index.getIndexOptions().addSpecOptions(option); } + | + parameter=CreateParameter() + { index.getIndexOptions().addSpecOptions(IndexSpecOption.raw(parameter)); } ) } -Expression NavigationStep(Expression base): +// CREATE INDEX and DROP INDEX share MySQL's algorithm_option / lock_option syntax. +AlgorithmOrLockOption IndexAlgorithmOrLockOption(): { - Expression step = null; - String nm = null; - Function method; + AlgorithmOrLockOption.Kind kind; + boolean useEquals = false; + Token value; } { + ( { kind = AlgorithmOrLockOption.Kind.ALGORITHM; } + | { kind = AlgorithmOrLockOption.Kind.LOCK; } ) + [ "=" { useEquals = true; } ] + // COPY is one of MySQL's ALGORITHM values and also starts the COPY statement + ( value= | value= | value= | value= + | value= ) + { return new AlgorithmOrLockOption(kind, value.image, useEquals); } +} + +List ColumnDefinitionParameter(): { + Token tk = null; + List parameter = new ArrayList(); +} { ( - "." + parameter=CreateParameter() + | ( - LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) && isFunctionAhead() }) - method=Function() { step = new MethodCallExpression(base, method); } - | - nm=RelObjectNameExt() { step = new RowGetExpression(base, nm); } + tk= + | tk= + | tk= + | tk= + | tk= ) - | - step = ArrayExpression(base) + { parameter.add(tk.image); } ) - { return step; } + { return parameter; } } -StringValue CharacterLiteral(): -{ - Token literal; - StringValue value; -} -{ - literal= { value = new StringValue(literal.image); } - ( LOOKAHEAD({ isAdjacentStringConcat() }) - literal= - { value.setValue(value.getValue() + new StringValue(literal.image).getValue()); } - )* - { return value; } +ColumnDefinition ColumnDefinition(): { + ColumnDefinition coldef; + String columnName; + ColDataType colDataType; + List columnOptions = new ArrayList(); + ColumnOption option; +} { + columnName=RelObjectName() + colDataType=ColDataType() + ( LOOKAHEAD(2) option=ColumnDefinitionOption() { + columnOptions.add(option); + } )* + { + coldef = new ColumnDefinition(); + coldef.setColumnName(columnName); + coldef.setColDataType(colDataType); + if (!columnOptions.isEmpty()) + coldef.setColumnOptions(columnOptions); + return coldef; + } } -Expression PrimaryExpression() #PrimaryExpression: -{ - Expression retval = null; - Expression nxt = null; - Expression expression = null; - CastExpression castExpr = null; - TimezoneExpression timezoneExpr = null; - Expression timezoneRightExpr = null; - Token token = null; - Token sign = null; - ColDataType type = null; - boolean not = false; - boolean exclamationMarkNot = false; - boolean dateExpressionAllowed = true; - ExpressionList list; - - final List> jsonIdents = new ArrayList>(); -} -{ - [ { not=true; } | "!" { not=true; exclamationMarkNot=true; } ] - [sign="+" | sign="-" | sign="~"] +ColumnOption ColumnDefinitionOption(): { + Token tk; + List foreignOptions; + List parameter; + ForeignKeyReference reference; + ColumnOption option; + IdentityDefinition identity; + NamedConstraint constraint; + String constraintName = null; + Expression defaultExpression; + GeneratedColumnDefinition generated; + ObjectNames collationNames; + String collation; + String compression; + Token engineAttribute; + boolean useEquals = false; +} { ( - { retval = new NullValue(); } - - | LOOKAHEAD({!interrupted && isCaseExpressionAhead()}) retval=CaseWhenExpression() - - | LOOKAHEAD(2, {!interrupted}) retval=CharacterPrimary() - - | LOOKAHEAD({ !interrupted && getToken(1).kind == DATA_TYPE - && "MAP".equalsIgnoreCase(getToken(1).image) - && getToken(2).kind == OPENING_CURLY_BRACKET }) retval=MapExpression() - - | LOOKAHEAD({!interrupted && isImplicitCastAhead()}) retval=ImplicitCast() - - | retval = JdbcParameter() - - | LOOKAHEAD(2) retval =JdbcNamedParameter() - - | LOOKAHEAD(3) retval=UserVariable() - - | LOOKAHEAD(2, {!interrupted}) retval=NumericBind() - - | LOOKAHEAD(4 , {!interrupted}) retval=ExtractExpression() - - | retval=XMLSerializeExpr() - - | LOOKAHEAD(3, { !interrupted}) retval = JsonFunction() - - | LOOKAHEAD(3, { !interrupted}) retval = JsonAggregateFunction() - - | LOOKAHEAD(3, { !interrupted}) retval = FullTextSearch() - - | LOOKAHEAD(2, {!interrupted}) retval= CastExpression() - - | LOOKAHEAD({ !interrupted && (isKeywordAhead("RUNNING") || getToken(1).kind == K_FINAL) - && getToken(3).kind == OPENING_BRACKET }) retval=RowPatternFunction() - - | LOOKAHEAD({ !interrupted && isFunctionAhead() }) - retval = Function() [ LOOKAHEAD(2) retval = AnalyticExpression( (Function) retval ) ] - - | LOOKAHEAD(2) retval = DateUnitExpression() - - | LOOKAHEAD(2, {!interrupted}) retval = IntervalExpression() { dateExpressionAllowed = false; } - - | token= { retval = new DoubleValue(token.image); } - - | token= { retval = new LongValue(token.image); } - - | token= { retval = new HexValue(token.image); } - - | LOOKAHEAD(3) retval=AllColumns(true) - - | LOOKAHEAD({ !interrupted && isAllTableColumnsAhead() }) - retval=AllTableColumns(true) - - // See issue #2207 - // there is a huge! performance deterioration from this production - //| LOOKAHEAD(FunctionAllColumns()) retval=FunctionAllColumns() - - // support timestamp expressions - | LOOKAHEAD(2, {!interrupted}) (token= | token=) { retval = new TimeKeyExpression(token.image); } - - | LOOKAHEAD(2, {!interrupted}) retval=DateTimeLiteralExpression() - - | LOOKAHEAD(3 , {!interrupted}) retval=StructType() - - | LOOKAHEAD(3, {!interrupted}) [ "<" type=ColDataType() ">" ] retval=ArrayConstructor(true) { if (type!=null) ((ArrayConstructor) retval).setDataType(type); } - - | LOOKAHEAD(1, {!interrupted}) retval=ArrayConstructor(false) - - | LOOKAHEAD(2, {!interrupted}) retval = NextValExpression() - - | retval=ConnectByRootOperator() - - | retval=ConnectByPriorOperator() - - | LOOKAHEAD(2, { !interrupted && getToken(1).kind == K_KEY && getToken(2).kind != OPENING_BRACKET }) retval=KeyExpression() - - | LOOKAHEAD(2, {!interrupted}) { retval = new AllValue(); } - - | LOOKAHEAD({ !interrupted && isCharacterSetIntroducedStringAhead() }) - retval=CharacterSetIntroducedString() - - | LOOKAHEAD(2, {!interrupted}) retval=Column() - [ - LOOKAHEAD( "(" "+" ")" ("," | ")") ) - "(" "+" ")" { ((Column) retval).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT); } - ] - - | LOOKAHEAD(2, {!interrupted}) (token= | token=) { retval = new BooleanValue(token.image); } - - | retval=CharacterLiteral() { linkAST(retval,jjtThis); } - - | "{d" token= "}" { retval = new DateValue(token.image); } - - | "{t" token= "}" { retval = new TimeValue(token.image); } - - | "{ts" token= "}" { retval = new TimestampValue(token.image); } + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && isKeywordAhead("OPTIONS") }) + foreignOptions=ForeignDataOptions(false) { option = ColumnOption.foreignOptions(foreignOptions); } + | + LOOKAHEAD({ isKeywordAhead("GENERATED") + && (getToken(4).kind == K_IDENTITY || getToken(5).kind == K_IDENTITY) }) + identity=IdentityDefinition() { option = ColumnOption.identity(identity); } + | + LOOKAHEAD({ (isKeywordAhead("GENERATED") && getToken(2).kind == K_ALWAYS + && getToken(3).kind == K_AS && "(".equals(getToken(4).image)) + || (getToken(1).kind == K_AS && "(".equals(getToken(2).image)) }) + generated=GeneratedColumnDefinition() { option = ColumnOption.generated(generated); } + | + LOOKAHEAD([ RelObjectName() ] , + { Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_CONSTRAINT || getToken(3).kind == K_NO) }) + constraint=PostgreSqlColumnNotNullConstraint() { option = ColumnOption.constraint(constraint); } + | + LOOKAHEAD( ) { option = ColumnOption.nullability(false); } + | + LOOKAHEAD(1, ) { option = ColumnOption.nullability(true); } + | + LOOKAHEAD(1, ) { option = ColumnOption.visibility(true); } + | + LOOKAHEAD(1, ) { option = ColumnOption.visibility(false); } + | + LOOKAHEAD(1, ) { option = ColumnOption.autoIncrement(); } + | + LOOKAHEAD(1, ) ( tk= | tk= | tk= ) + { option = ColumnOption.storage(accessEnum(ColumnOption.Storage.class, tk.image)); } + | + LOOKAHEAD({ isKeywordAhead("COMPRESSION") }) ContextualKeyword("COMPRESSION") compression=RelObjectName() + { option = ColumnOption.compression(compression); } + | + // MySQL column attributes. Other values keep the raw fallback, e.g. Percona's COMPRESSED. + LOOKAHEAD({ isKeywordAhead("COLUMN_FORMAT") && (getToken(2).kind == K_DEFAULT + || "FIXED".equalsIgnoreCase(getToken(2).image) + || "DYNAMIC".equalsIgnoreCase(getToken(2).image)) }) + ContextualKeyword("COLUMN_FORMAT") ( tk= | tk= ) + { option = ColumnOption.columnFormat(accessEnum(ColumnOption.ColumnFormat.class, tk.image)); } + | + LOOKAHEAD({ isKeywordAhead("SRID") && getToken(2).kind == S_LONG }) + ContextualKeyword("SRID") tk= { option = ColumnOption.srid(Long.parseLong(tk.image)); } + | + LOOKAHEAD({ isMySqlEngineAttributeAhead() && (getToken(2).kind == S_CHAR_LITERAL + || "=".equals(getToken(2).image) && getToken(3).kind == S_CHAR_LITERAL) }) + engineAttribute= [ "=" { useEquals = true; } ] tk= + { + option = "ENGINE_ATTRIBUTE".equalsIgnoreCase(engineAttribute.image) + ? ColumnOption.engineAttribute(stringValue(tk)) + : ColumnOption.secondaryEngineAttribute(stringValue(tk)); + option.setUseEquals(useEquals); + } + | + LOOKAHEAD(1, ) + ( tk= { collation = tk.image; } + | collationNames=RelObjectNames() { collation = String.join(".", collationNames.getNames()); } ) + { option = ColumnOption.collate(collation); } + | + LOOKAHEAD(1, ) tk= + { option = ColumnOption.comment(stringValue(tk)); } + | + LOOKAHEAD( ) defaultExpression=Expression() + { option = ColumnOption.onUpdate(defaultExpression); } + | + // Keep SQL Server's inline FOREIGN KEY prefix together so its KEY is not a primary key. + LOOKAHEAD( ) { option = ColumnOption.raw("FOREIGN", "KEY"); } + | + LOOKAHEAD([ RelObjectName() ] ( | | )) + constraint=ColumnKeyConstraint() { option = ColumnOption.constraint(constraint); } + | + LOOKAHEAD([ RelObjectName() ] ) + [ constraintName=RelObjectName() ] + constraint=CheckConstraintSpec(constraintName) + { option = ColumnOption.constraint(constraint); } + | + LOOKAHEAD({ isKeywordAhead("SERIAL") + && getToken(2).kind == K_DEFAULT && getToken(3).kind == K_VALUE }) + tk= + { option = ColumnOption.serialDefaultValue(); } + | + LOOKAHEAD([ RelObjectName() ] ) + [ constraintName=RelObjectName() ] + reference=ForeignKeyReferenceSpec(true) + { reference.setConstraintName(constraintName); option = ColumnOption.reference(reference); } + | + LOOKAHEAD( ) + { option = ColumnOption.raw("DROP", "DEFAULT"); } + | + LOOKAHEAD( ) + { option = ColumnOption.raw("DEFAULT", "ON", "NULL"); } + | + LOOKAHEAD(1, ) { option = ColumnOption.raw("DEFAULT"); } + // Db2 permits an omitted default value. Keep these implicit defaults raw. + [ LOOKAHEAD(2, { !(getToken(1).kind == K_NOT && getToken(2).kind == K_NULL) }) + defaultExpression=ColumnDefaultValue() { option = ColumnOption.defaultValue(defaultExpression); } ] + | + parameter=ColumnDefinitionParameter() + { option = ColumnOption.raw(parameter); } + ) + { return option; } +} - | LOOKAHEAD({ getAsBoolean(Feature.allowUnparenthesizedSubSelects) && !interrupted - && (getToken(1).kind == K_SELECT || getToken(1).kind == K_WITH || getToken(1).kind == K_VALUES - || (getToken(1).kind == OPENING_BRACKET && (getToken(2).kind == K_SELECT || getToken(2).kind == K_WITH || getToken(2).kind == K_VALUES))) }) retval=Select() +/** + * An explicit column DEFAULT value. MySQL's DEFAULT literal and PostgreSQL's DEFAULT b_expr exclude + * COLLATE, so the value ends before a COLLATE at its top level, which is the column's own + * attribute. A COLLATE inside parentheses, function arguments or CASE stays in the expression. + */ +Expression ColumnDefaultValue(): +{ + Expression expression; +} +{ + { columnDefaultStarts.push(getToken(1)); } + try { + expression=Expression() + } finally { + columnDefaultStarts.pop(); + } + { return expression; } +} - | LOOKAHEAD({ !getAsBoolean(Feature.allowUnparenthesizedSubSelects) && !interrupted && isParenthesedSelectAhead() }) retval=ParenthesedSelect() +GeneratedColumnDefinition GeneratedColumnDefinition(): +{ + Expression expression; + boolean generatedAlways = false; + GeneratedColumnDefinition.Storage storage = null; + GeneratedColumnDefinition result; +} +{ + [ LOOKAHEAD({ isKeywordAhead("GENERATED") }) ContextualKeyword("GENERATED") + { generatedAlways = true; } ] + expression=ColumnGenerationExpression() + [ LOOKAHEAD({ getToken(1).kind == K_STORED || isKeywordAhead("VIRTUAL") }) + ( { storage = GeneratedColumnDefinition.Storage.STORED; } + | ContextualKeyword("VIRTUAL") { storage = GeneratedColumnDefinition.Storage.VIRTUAL; } ) ] + { + result = new GeneratedColumnDefinition(expression); + result.setGeneratedAlways(generatedAlways); + result.setStorage(storage); + return result; + } +} - | LOOKAHEAD({ !interrupted && isNestedSetOperationAhead() }) retval=ParenthesedSelect() +/** Shared expression body for generated declarations and ALTER SET EXPRESSION. */ +Expression ColumnGenerationExpression(): +{ Expression expression; } +{ + "(" expression=Expression() ")" + { return expression; } +} +/** + * Keeps a column key's name and attributes on the same node in CREATE and ALTER, including MySQL's + * UNIQUE KEY and KEY (PRIMARY KEY) spellings. + */ +KeyConstraint ColumnKeyConstraint(): +{ + KeyConstraint constraint = new KeyConstraint(); + String name; + Boolean nullsDistinct = null; +} +{ + [ name=RelObjectName() { constraint.setName(name); } ] + ( + { constraint.setType("PRIMARY KEY"); } + | + // MySQL accepts KEY as a column-level synonym for PRIMARY KEY; keep its spelling. + { constraint.setType("KEY"); constraint.setKind(ConstraintKind.PRIMARY_KEY); } | + { constraint.setType("UNIQUE"); } + [ LOOKAHEAD(1) { constraint.setType("UNIQUE KEY"); } ] + [ [ { nullsDistinct = false; } ] { + constraint.setNullsDistinct(nullsDistinct == null ? true : nullsDistinct); + } ] + ) + PostgreSqlIndexStorageOptions(constraint) + PostgreSqlConstraintAttributes(constraint) + { + requireDdlSyntax(constraint.getConstraintAttributes() == null + || !constraint.getConstraintAttributes().isNotValid(), + "NOT VALID requires a table constraint"); + return constraint; + } +} + +IdentityDefinition IdentityDefinition(): +{ + Token token; + IdentityDefinition.GenerationMode mode; + IdentityDefinition identity; + List parameters = new ArrayList(); + Sequence.Parameter parameter; + Sequence sequenceName; + boolean hasPersistence = false; +} +{ + token= { + requireDdlSyntax("GENERATED".equalsIgnoreCase(token.image), "Expected GENERATED"); + } + ( { mode = IdentityDefinition.GenerationMode.ALWAYS; } + | { mode = IdentityDefinition.GenerationMode.BY_DEFAULT; } ) + { identity = new IdentityDefinition(mode); } + [ LOOKAHEAD(1) "(" ( - list=ParenthesedExpressionList() - // Mutli-Variable Lambda Expression, e. g. - // SELECT map_filter(my_column, (k,v) -> v.my_inner_column = 'some_value') - // First-arg form (issue #2195): array_map((x,y,z) -> x + y, ...) ( - LOOKAHEAD(2, { !isJsonArrowDialect() }) "->" - retval = Expression() - { - retval = LambdaExpression.from(list, retval); - } + LOOKAHEAD( ) + sequenceName=Sequence() + { parameter = new Sequence.Parameter(Sequence.ParameterType.SEQUENCE_NAME) + .withSequenceName(sequenceName); } | - { - if (list.size() == 1) { - retval = new ParenthesedExpressionList( (Expression) list.getExpressions().get(0)); - } else { - retval = list; - } + 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); } + )+ + ")" { + identity.setParameters(parameters); + } ] + { return identity; } +} - // PostgreSQL composite row expansion: (function()).* - // Re-enables FunctionAllColumns, which was disabled in #2207 due to the - // performance toll of a speculative syntactic lookahead. A bounded - // semantic follower check instead reads the already-parsed retval and - // peeks the next two tokens, avoiding any speculative production. - [ LOOKAHEAD( { isFunctionAllColumnsAhead(retval) } ) - "." "*" - { retval = new FunctionAllColumns(unwrapParenthesedFunction(retval)); } ] - - // Share field and method navigation with the other primary expressions. - ( LOOKAHEAD(".") nxt=NavigationStep(retval) { retval = nxt; } )* - ) +StringValue MySqlAccountNamePart(): +{ + Token token = null; + String name = null; + StringValue value = null; +} +{ + ( + token= { value = stringValue(token); } + | + name=RelObjectName() + { + // a double-quoted or backquoted part keeps its quote character separately from its + // value, like a string literal; new StringValue(name) would drop the double quotes + value = name.length() > 1 && (name.charAt(0) == '"' || name.charAt(0) == '`') + && name.charAt(name.length() - 1) == name.charAt(0) + ? new StringValue().withValue(name.substring(1, name.length() - 1)) + .setQuoteStr(name.substring(0, 1)) + : new StringValue().withValue(name).setQuoteStr(""); + linkToLastToken(value); + } ) + { return value; } +} - [ - LOOKAHEAD(2) (token= | token= | token=) { retval = new CollateExpression(retval, token.image); } - ] - - [ - LOOKAHEAD(2, { dateExpressionAllowed } ) retval = IntervalExpressionWithoutInterval(retval) - ] +/** + * A MySQL account name, user[@host], shared by CREATE USER, DEFINER and the account statements. + * Each part is unquoted or quoted with ', " or `. The lexer reads an unquoted user@host, and the + * user@ in front of a quoted host, as one identifier, and @host after a quoted user as one + * at-identifier, so those spellings are split here. + */ +UserAccount MySqlAccountName(): +{ + UserAccount account = new UserAccount(); + StringValue part; + Token token; + int at; +} +{ + ( + // user@ followed by a quoted host + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.indexOf('@') > 0 + && getToken(1).image.indexOf('@') == getToken(1).image.length() - 1 }) + token= + { account.setUser(new StringValue().withValue(token.image.substring(0, token.image.length() - 1)) + .setQuoteStr("")); } + part=MySqlAccountNamePart() { account.setHost(part); } + | + // unquoted user@host + LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.indexOf('@') > 0 + && getToken(1).image.indexOf('@') == getToken(1).image.lastIndexOf('@') }) + token= + { + at = token.image.indexOf('@'); + account.setUser(new StringValue().withValue(token.image.substring(0, at)).setQuoteStr("")); + account.setHost(new StringValue().withValue(token.image.substring(at + 1)).setQuoteStr("")); + } + | + part=MySqlAccountNamePart() { account.setUser(part); } + [ + // CURRENT_USER() names the current user like CURRENT_USER; a quoted part has quotes in its image + LOOKAHEAD({ "CURRENT_USER".equalsIgnoreCase(getToken(0).image) + && "(".equals(getToken(1).image) && ")".equals(getToken(2).image) }) + "(" ")" { account.setCurrentUserParentheses(true); } + | + part=MySqlAccountNamePart() { account.setHost(part); } + | + // a quoted user followed by an unquoted @host + LOOKAHEAD({ getToken(1).kind == S_AT_IDENTIFIER && !getToken(1).image.startsWith("@@") }) + token= + { account.setHost(new StringValue().withValue(token.image.substring(1)).setQuoteStr("")); } + ] + ) + { return account; } +} - [ LOOKAHEAD(2) retval = ArrayExpression(retval) ] +List MySqlAccountNameList(): +{ + List accounts = new ArrayList(); + UserAccount account; +} +{ + account=MySqlAccountName() { accounts.add(account); } + ( "," account=MySqlAccountName() { accounts.add(account); } )* + { return accounts; } +} - // navigation chains, e.g. Redshift SUPER col[0].field[1].sub: field accesses - // and subscripts may alternate freely after the primary expression +/** + * Roles of SET ROLE, SET DEFAULT ROLE, ALTER USER ... DEFAULT ROLE and GRANT ... AS user WITH ROLE. + * Only SET ROLE and WITH ROLE (setRole) accept DEFAULT and ALL EXCEPT. + */ +RoleSelection MySqlRoleSelection(boolean setRole): +{ + RoleSelection selection; + List roles; +} +{ ( - LOOKAHEAD(2) nxt = NavigationStep(retval) { retval = nxt; } - )* + LOOKAHEAD({ getToken(1).kind == K_DEFAULT }) + { selection = new RoleSelection(RoleSelection.Kind.DEFAULT); } + | + LOOKAHEAD({ getToken(1).kind == K_NONE }) + { selection = new RoleSelection(RoleSelection.Kind.NONE); } + | + LOOKAHEAD({ getToken(1).kind == K_ALL }) + { selection = new RoleSelection(RoleSelection.Kind.ALL); } + [ + LOOKAHEAD({ getToken(1).kind == K_EXCEPT }) roles=MySqlAccountNameList() + { selection.setKind(RoleSelection.Kind.ALL_EXCEPT); selection.setRoles(requireRoleNames(roles)); } + ] + | + roles=MySqlAccountNameList() + { selection = new RoleSelection(RoleSelection.Kind.ROLES).withRoles(requireRoleNames(roles)); } + ) + { + requireAccessSyntax(setRole || selection.getKind() != RoleSelection.Kind.DEFAULT + && selection.getKind() != RoleSelection.Kind.ALL_EXCEPT, + "DEFAULT and ALL EXCEPT require SET ROLE"); + return selection; + } +} - ( LOOKAHEAD(2) "::" type=ColDataType() { - castExpr = new CastExpression(); - castExpr.setUseCastKeyword(false); - castExpr.setLeftExpression(retval); - castExpr.setColDataType(type); - retval=castExpr; +/** + * IDENTIFIED BY or IDENTIFIED WITH. The plugin may be quoted like an account name part, and the + * hash after AS may be a hexadecimal literal, as SHOW CREATE USER prints both. + */ +UserAuthentication MySqlUserAuthentication(): +{ + UserAuthentication authentication = new UserAuthentication(); + StringValue plugin = null; + Token credential = null; +} +{ + + ( + + ( + credential= { + authentication.setMode(UserAuthentication.Mode.BY_PASSWORD); + authentication.setCredential(stringValue(credential)); + } + | + { + authentication.setMode(UserAuthentication.Mode.BY_RANDOM_PASSWORD); + } + ) + | + plugin=MySqlAccountNamePart() { + authentication.setMode(UserAuthentication.Mode.WITH_PLUGIN); + authentication.setPluginName(plugin); } - )* - - // Check for JSON operands - [ - LOOKAHEAD(2, { !isPostgreSqlJsonAccess(getToken(1)) - && ((ternaryThenBranchDepth == 0 && mapKeyDepth == 0) - || !":".equals(getToken(1).image)) }) ( - LOOKAHEAD(2) ( - token="->" - | - token=":" - | - token="->>" - | - token="#>" + [ + + ( + credential= { + authentication.setMode(UserAuthentication.Mode.WITH_PLUGIN_BY_PASSWORD); + authentication.setCredential(stringValue(credential)); + } | - token="#>>" + { + authentication.setMode( + UserAuthentication.Mode.WITH_PLUGIN_BY_RANDOM_PASSWORD); + } ) - + | + { authentication.setMode(UserAuthentication.Mode.WITH_PLUGIN_AS_STRING); } ( - LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted }) expression=Expression() + credential= { authentication.setCredential(stringValue(credential)); } | - expression=SimpleExpression() + credential= + { authentication.setCredentialValue(new HexValue(credential.image)); } ) - { - jsonIdents.add(new AbstractMap.SimpleEntry(expression, token.image )); - } - )+ - retval = JsonExpression(retval, jsonIdents) - ] - - ( LOOKAHEAD(2) timezoneRightExpr=PrimaryExpression() { - if (timezoneExpr == null) - timezoneExpr = new TimezoneExpression(); - - timezoneExpr.addTimezoneExpression(timezoneRightExpr); - } - )* + ] + ) + { return authentication; } +} - { - if (timezoneExpr != null && !timezoneExpr.getTimezoneExpressions().isEmpty()) { - timezoneExpr.setLeftExpression(retval); - retval=timezoneExpr; - } - if (sign != null) { - retval = new SignedExpression(sign.image.charAt(0), retval); - } - if (not) { - retval = new NotExpression(retval, exclamationMarkNot); +/** + * A CREATE USER account: the first factor, which a plugin without credentials may follow with + * INITIAL AUTHENTICATION, and up to two further factors, each written AND IDENTIFIED ...; the + * server grammar also accepts the further factors without a first one. + */ +UserAccount MySqlUserAccount(): +{ + UserAccount account; + UserAuthentication authentication = null; + UserAuthentication initial = null; +} +{ + account=MySqlAccountName() + [ + authentication=MySqlUserAuthentication() { account.setAuthentication(authentication); } + [ + LOOKAHEAD({ isKeywordAhead("INITIAL") }) + ContextualKeyword("INITIAL") ContextualKeyword("AUTHENTICATION") + initial=MySqlUserAuthentication() + { + requireAccessSyntax(authentication.getMode() == UserAuthentication.Mode.WITH_PLUGIN, + "INITIAL AUTHENTICATION requires IDENTIFIED WITH plugin"); + requireAccessSyntax(initial.getMode() == UserAuthentication.Mode.BY_PASSWORD + || initial.getMode() == UserAuthentication.Mode.BY_RANDOM_PASSWORD + || initial.getMode() == UserAuthentication.Mode.WITH_PLUGIN_AS_STRING, + "INITIAL AUTHENTICATION accepts IDENTIFIED BY or IDENTIFIED WITH plugin AS"); + authentication.setInitialAuthentication(initial); + } + ] + ] + ( + authentication=MySqlUserAuthentication() + { + requireAccessSyntax(initial == null, + "INITIAL AUTHENTICATION cannot be combined with further factors"); + requireAccessSyntax(account.getAdditionalAuthentications().size() < 2, + "An account has at most three authentication factors"); + account.addAdditionalAuthentications(authentication); } - linkAST(retval, jjtThis); - return retval; - } + )* + { return account; } } -/* https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/img_text/hierarchical_query_clause.html - - { CONNECT BY [ NOCYCLE ] condition [ START WITH condition ] - | START WITH condition CONNECT BY [ NOCYCLE ] condition - } - */ - -ConnectByRootOperator ConnectByRootOperator() #ConnectByRootOperator: { - Expression expression; +/** The factor of a multi-factor authentication clause: 2 FACTOR or 3 FACTOR. */ +int MySqlAuthenticationFactor(): +{ + Token number; } { - expression = Expression() - { - return new ConnectByRootOperator(expression); - } + number= ContextualKeyword("FACTOR") + { return factorNumber(number); } } -ConnectByPriorOperator ConnectByPriorOperator() #ConnectByPriorOperator: { - Expression expression; +/** ALTER USER: ADD factor IDENTIFIED ..., MODIFY factor IDENTIFIED ... or DROP factor. */ +UserFactorOperation MySqlFactorChange(): +{ + UserFactorOperation.Operation operation; + int factor; + UserAuthentication authentication = null; } { - expression = Expression() + ( + { operation = UserFactorOperation.Operation.ADD; } + | + { operation = UserFactorOperation.Operation.MODIFY; } + | + { operation = UserFactorOperation.Operation.DROP; } + ) + factor=MySqlAuthenticationFactor() + [ authentication=MySqlUserAuthentication() ] { - return new ConnectByPriorOperator(expression); + requireAccessSyntax(operation.hasAuthentication() == (authentication != null), + "ADD and MODIFY of a factor require IDENTIFIED, DROP does not accept it"); + return new UserFactorOperation(operation, factor).withAuthentication(authentication); } } -KeyExpression KeyExpression() #KeyExpression: { - Expression expression; +/** + * ALTER USER registration of a passwordless device: factor INITIATE REGISTRATION, factor FINISH + * REGISTRATION SET CHALLENGE_RESPONSE AS 'response', or factor UNREGISTER. + */ +UserFactorOperation MySqlFactorRegistration(): +{ + UserFactorOperation operation = new UserFactorOperation(); + int factor; + Token response; } { - expression = Expression() - { - return new KeyExpression(expression); - } + factor=MySqlAuthenticationFactor() { operation.setFactor(factor); } + ( + LOOKAHEAD({ isKeywordAhead("INITIATE") }) + ContextualKeyword("INITIATE") ContextualKeyword("REGISTRATION") + { operation.setOperation(UserFactorOperation.Operation.INITIATE_REGISTRATION); } + | + LOOKAHEAD({ isKeywordAhead("FINISH") }) + ContextualKeyword("FINISH") ContextualKeyword("REGISTRATION") + ContextualKeyword("CHALLENGE_RESPONSE") + { operation.setOperation(UserFactorOperation.Operation.FINISH_REGISTRATION); } + ( + response= { operation.setChallengeResponse(stringValue(response)); } + | + response= { operation.setChallengeResponse(new HexValue(response.image)); } + ) + | + ContextualKeyword("UNREGISTER") + { operation.setOperation(UserFactorOperation.Operation.UNREGISTER); } + ) + { return operation; } } - -NextValExpression NextValExpression() : { - ObjectNames data = null; - Token token; +CreateUser CreateUser(): +{ + CreateUser createUser = new CreateUser(); + UserAccount account = null; } { - token= data = RelObjectNames() - { - return new NextValExpression(data.getNames(), token.image); - } + + [ LOOKAHEAD(3) { createUser.setIfNotExists(true); } ] + account=MySqlUserAccount() { createUser.addAccounts(account); } + ( "," account=MySqlUserAccount() { createUser.addAccounts(account); } )* + MySqlUserOptions(createUser.getOptions(), true) + { return createUser; } } -JdbcNamedParameter JdbcNamedParameter() : { - JdbcNamedParameter parameter = new JdbcNamedParameter(); - String name; - String namePart; +/** + * MySQL account options shared by CREATE USER and ALTER USER, in the fixed clause order. Only + * CREATE USER lists DEFAULT ROLE here; ALTER USER uses its own single-account form. + */ +void MySqlUserOptions(UserOptions options, boolean create): +{ + RoleSelection roles; + TlsOption tls; + ResourceLimit limit; + PasswordLockOption option; + Token value; } { - (":" | "&" { parameter.setParameterCharacter("&"); } ) - name=IdentifierChain() - { - parameter.setName(name); - return parameter; - } + [ + LOOKAHEAD({ getToken(1).kind == K_DEFAULT && "ROLE".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("ROLE") roles=MySqlRoleSelection(false) + { + requireAccessSyntax(create, + "ALTER USER accepts DEFAULT ROLE only for a single account"); + requireAccessSyntax(roles.getKind() == RoleSelection.Kind.ROLES, + "CREATE USER DEFAULT ROLE requires role names"); + options.setDefaultRoles(roles); + } + ] + [ + LOOKAHEAD({ isKeywordAhead("REQUIRE") }) ContextualKeyword("REQUIRE") + ( + LOOKAHEAD({ getToken(1).kind == K_NONE }) + { options.addTlsOptions(new TlsOption(TlsOption.Kind.NONE)); } + | + tls=MySqlTlsOption() + { + requireAccessSyntax(!tls.isAndKeyword(), "REQUIRE cannot start with AND"); + options.addTlsOptions(tls); + } + ( + LOOKAHEAD({ isMySqlTlsOptionAhead() }) + tls=MySqlTlsOption() { options.addTlsOptions(tls); } + )* + ) + ] + [ + LOOKAHEAD({ getToken(1).kind == K_WITH && isMySqlResourceLimitAhead(2) }) + ( + LOOKAHEAD({ isMySqlResourceLimitAhead(1) }) + limit=MySqlResourceLimit() { options.addResourceLimits(limit); } + )+ + ] + ( + LOOKAHEAD({ isMySqlPasswordLockOptionAhead(1) }) + option=MySqlPasswordLockOption() { options.addPasswordLockOptions(option); } + )* + [ + LOOKAHEAD({ getToken(1).kind == K_COMMENT && getToken(2).kind == S_CHAR_LITERAL }) + value= { options.setComment(stringValue(value)); } + | + LOOKAHEAD({ isKeywordAhead("ATTRIBUTE") && getToken(2).kind == S_CHAR_LITERAL }) + ContextualKeyword("ATTRIBUTE") value= + { options.setAttribute(stringValue(value)); } + ] } -OracleNamedFunctionParameter OracleNamedFunctionParameter() : { - Token token = null; - String name = null; - Expression expression; +/** One REQUIRE option, preceded by the optional AND that separates the options. */ +TlsOption MySqlTlsOption(): +{ + TlsOption option = new TlsOption(); + Token word; + Token value; } { - ( name=RelObjectNameExt() | token= ) - - expression=Expression() + [ { option.setAndKeyword(true); } ] + word= { option.setKind(accessEnum(TlsOption.Kind.class, word.image)); } + [ + LOOKAHEAD({ getToken(1).kind == S_CHAR_LITERAL }) + value= { option.setValue(stringValue(value)); } + ] { - return new OracleNamedFunctionParameter(name != null ? name : token.image, expression); + requireAccessSyntax(option.getKind().hasValue() == (option.getValue() != null), + "Invalid REQUIRE option " + word.image); + return option; } } -PostgresNamedFunctionParameter PostgresNamedFunctionParameter() : { - Token token = null; - String name = null; - Expression expression; +ResourceLimit MySqlResourceLimit(): +{ + Token word; + Token value; } { - ( name=RelObjectNameExt() | token= ) - - expression=Expression() + word= value= { - return new PostgresNamedFunctionParameter(name != null ? name : token.image, expression); + return new ResourceLimit(accessEnum(ResourceLimit.Kind.class, word.image), + Long.parseLong(value.image)); } } -UserVariable UserVariable() : { - Token tk; - String varName; +PasswordLockOption MySqlPasswordLockOption(): +{ + PasswordLockOption option = null; + Token value; } { - tk = varName=IdentifierChain2(tk.image) - { - return new UserVariable(varName); - } + ( + LOOKAHEAD({ isKeywordAhead("ACCOUNT") }) ContextualKeyword("ACCOUNT") + ( + { option = new PasswordLockOption(PasswordLockOption.Kind.ACCOUNT_LOCK); } + | + + { option = new PasswordLockOption(PasswordLockOption.Kind.ACCOUNT_UNLOCK); } + ) + | + LOOKAHEAD({ isKeywordAhead("FAILED_LOGIN_ATTEMPTS") }) + ContextualKeyword("FAILED_LOGIN_ATTEMPTS") value= + { + option = new PasswordLockOption(PasswordLockOption.Kind.FAILED_LOGIN_ATTEMPTS) + .withValue(Long.valueOf(value.image)); + } + | + LOOKAHEAD({ isKeywordAhead("PASSWORD_LOCK_TIME") }) ContextualKeyword("PASSWORD_LOCK_TIME") + { option = new PasswordLockOption(PasswordLockOption.Kind.PASSWORD_LOCK_TIME); } + ( + value= { option.setValue(Long.valueOf(value.image)); } + | + { option.setSetting(PasswordLockOption.Setting.UNBOUNDED); } + ) + | + + ( + LOOKAHEAD({ isKeywordAhead("EXPIRE") }) ContextualKeyword("EXPIRE") + { option = new PasswordLockOption(PasswordLockOption.Kind.PASSWORD_EXPIRE); } + [ + { option.setSetting(PasswordLockOption.Setting.DEFAULT); } + | + { option.setSetting(PasswordLockOption.Setting.NEVER); } + | + value= MySqlDayUnit() + { option.setValue(Long.valueOf(value.image)); } + ] + | + + { option = new PasswordLockOption(PasswordLockOption.Kind.PASSWORD_HISTORY); } + ( + { option.setSetting(PasswordLockOption.Setting.DEFAULT); } + | + value= { option.setValue(Long.valueOf(value.image)); } + ) + | + LOOKAHEAD({ isKeywordAhead("REUSE") }) ContextualKeyword("REUSE") + { option = new PasswordLockOption(PasswordLockOption.Kind.PASSWORD_REUSE_INTERVAL); } + ( + { option.setSetting(PasswordLockOption.Setting.DEFAULT); } + | + value= MySqlDayUnit() { option.setValue(Long.valueOf(value.image)); } + ) + | + ContextualKeyword("REQUIRE") + { option = new PasswordLockOption(PasswordLockOption.Kind.PASSWORD_REQUIRE_CURRENT); } + [ + { option.setSetting(PasswordLockOption.Setting.DEFAULT); } + | + LOOKAHEAD({ isKeywordAhead("OPTIONAL") }) ContextualKeyword("OPTIONAL") + { option.setSetting(PasswordLockOption.Setting.OPTIONAL); } + ] + ) + ) + { return option; } } -NumericBind NumericBind() : { - NumericBind var = new NumericBind(); - Token token; -} +void MySqlDayUnit(): +{ Token unit; } { - ":" token= - { - var.setBindId(Integer.valueOf(token.image)); - return var; - } + unit= + { requireAccessSyntax("DAY".equalsIgnoreCase(unit.image), "Expected DAY"); } } -DateTimeLiteralExpression DateTimeLiteralExpression() : { - DateTimeLiteralExpression expr = new DateTimeLiteralExpression(); - Token t; +/** + * ALTER USER authentication: an IDENTIFIED clause, whose password assignment may add REPLACE and + * RETAIN CURRENT PASSWORD, or DISCARD OLD PASSWORD. + */ +UserAuthentication MySqlAlterUserAuthentication(): +{ + UserAuthentication authentication; + Token value; } { - t= - { - expr.setType(DateTimeLiteralExpression.DateTime.from(t.image)); - } - - ( t= | t= ) - { - expr.setValue(t.image); - return expr; - } + ( + authentication=MySqlUserAuthentication() + [ + LOOKAHEAD({ getToken(1).kind == K_REPLACE && getToken(2).kind == S_CHAR_LITERAL }) + value= + { authentication.setCurrentCredential(stringValue(value)); } + ] + [ + LOOKAHEAD({ isKeywordAhead("RETAIN") }) ContextualKeyword("RETAIN") + { authentication.setRetainCurrentPassword(true); } + ] + { + requireAccessSyntax(authentication.getMode().isPasswordAssignment() + || authentication.getCurrentCredential() == null + && !authentication.isRetainCurrentPassword(), + "REPLACE and RETAIN CURRENT PASSWORD require a password assignment"); + } + | + ContextualKeyword("OLD") + { + authentication = new UserAuthentication() + .withMode(UserAuthentication.Mode.DISCARD_OLD_PASSWORD); + } + ) + { return authentication; } } -DateUnitExpression DateUnitExpression() : { - Token t; +/** + * An ALTER USER account with an authentication change, or with one or two factor changes of the + * same kind: ADD ... [ADD ...], MODIFY ... [MODIFY ...] or DROP ... [DROP ...]. + */ +UserAccount MySqlAlterUserAccount(): +{ + UserAccount account; + UserAuthentication authentication; + UserFactorOperation change; + UserFactorOperation second; } { - t= { return new DateUnitExpression( t.image ); } + account=MySqlAccountName() + [ + LOOKAHEAD({ getToken(1).kind == K_IDENTIFIED || getToken(1).kind == K_DISCARD }) + authentication=MySqlAlterUserAuthentication() { account.setAuthentication(authentication); } + | + LOOKAHEAD({ isMySqlFactorChangeAhead() }) + change=MySqlFactorChange() { account.addFactorOperations(change); } + [ + LOOKAHEAD({ isMySqlFactorChangeAhead() }) + second=MySqlFactorChange() + { + requireAccessSyntax(second.getOperation() == change.getOperation(), + "Factor changes of one account repeat the same operation"); + account.addFactorOperations(second); + } + ] + ] + { return account; } } -RangeExpression RangeExpression(Expression startExpression): +/** + * MySQL ALTER USER: accounts with authentication or factor changes and the options shared with + * CREATE USER, USER() with a password change, one account with DEFAULT ROLE, or one account or + * USER() with a registration step of multi-factor authentication. + */ +AlterUser AlterUser(): { - Expression endExpression; + AlterUser alterUser = new AlterUser(); + UserAccount account; + UserAuthentication authentication; + UserFactorOperation registration; + RoleSelection roles; } { - ":" endExpression = Expression() - { - return new RangeExpression(startExpression, endExpression); - } + + [ LOOKAHEAD(2) { alterUser.setIfExists(true); } ] + ( + LOOKAHEAD({ getToken(1).kind == K_USER && "(".equals(getToken(2).image) }) + "(" ")" + ( + LOOKAHEAD({ isMySqlFactorAhead(1) }) + registration=MySqlFactorRegistration() + { + alterUser.withUserFunction(null); + alterUser.getAccounts().get(0).addFactorOperations(registration); + } + | + authentication=MySqlAlterUserAuthentication() + { + requireAccessSyntax(authentication.getMode() == UserAuthentication.Mode.BY_PASSWORD + || authentication.getMode() == UserAuthentication.Mode.BY_RANDOM_PASSWORD + || authentication.getMode() == UserAuthentication.Mode.DISCARD_OLD_PASSWORD, + "USER() accepts IDENTIFIED BY or DISCARD OLD PASSWORD"); + alterUser.withUserFunction(authentication); + } + ) + | + account=MySqlAlterUserAccount() { alterUser.addAccounts(account); } + ( + LOOKAHEAD({ isMySqlFactorAhead(1) }) + registration=MySqlFactorRegistration() + { + requireAccessSyntax(account.getAuthentication() == null + && account.getFactorOperations().isEmpty(), + "A registration step cannot follow an authentication change"); + account.addFactorOperations(registration); + } + | + LOOKAHEAD({ getToken(1).kind == K_DEFAULT && "ROLE".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("ROLE") roles=MySqlRoleSelection(false) + { + requireAccessSyntax(account.getAuthentication() == null + && account.getFactorOperations().isEmpty(), + "DEFAULT ROLE cannot follow an authentication change"); + alterUser.getOptions().setDefaultRoles(roles); + } + | + ( "," account=MySqlAlterUserAccount() { alterUser.addAccounts(account); } )* + MySqlUserOptions(alterUser.getOptions(), false) + ) + ) + { return alterUser; } } - -ArrayConstructor ArrayConstructor(boolean arrayKeyword) : { - ExpressionList expList = new ExpressionList(); - Expression exp; -} { - "[" - [ - exp=ArrayElement() { expList.add(exp); } - ( "," exp=ArrayElement() { expList.add(exp); } )* - ] - "]" - { return new ArrayConstructor(expList, arrayKeyword); } + +/** MySQL CREATE ROLE [IF NOT EXISTS] role [, role] ... with account-style role names. */ +CreateRole MySqlCreateRole(): +{ + CreateRole role = new CreateRole(); + List roles; +} +{ + ContextualKeyword("ROLE") + [ LOOKAHEAD(3) { role.setIfNotExists(true); } ] + roles=MySqlAccountNameList() { role.setRoles(requireRoleNames(roles)); } + { return role; } } -Expression ArrayElement(): +RenameUser RenameUser(): { - Expression expression; + RenameUser renameUser = new RenameUser(); + UserAccount from; + UserAccount to; } { - expression=Expression() [ expression=RangeExpression(expression) ] - { return expression; } + + from=MySqlAccountName() to=MySqlAccountName() { renameUser.addRename(from, to); } + ( + "," from=MySqlAccountName() to=MySqlAccountName() + { renameUser.addRename(from, to); } + )* + { return renameUser; } } -MapExpression MapExpression() #MapExpression: +SetRoleStatement SetRoleStatement(): +{ RoleSelection roles; } { - MapExpression mapExpression = new MapExpression(); - Expression key; - Expression value; + ContextualKeyword("ROLE") roles=MySqlRoleSelection(true) + { return new SetRoleStatement(roles); } } + +/** MySQL SET DEFAULT ROLE ... TO accounts, or MariaDB's form with an optional FOR account. */ +SetDefaultRoleStatement SetDefaultRoleStatement(): { - + SetDefaultRoleStatement statement = new SetDefaultRoleStatement(); + RoleSelection roles; + List accounts; +} +{ + ContextualKeyword("ROLE") roles=MySqlRoleSelection(false) + { statement.setRoles(roles); } [ - key = MapKeyExpression() value = Expression() - { mapExpression.addEntry(key, value); } - ( - "," key = MapKeyExpression() value = Expression() - { mapExpression.addEntry(key, value); } - )* + ( | { statement.setForKeyword(true); } ) + // MySQL reads these accounts as a role list + accounts=MySqlAccountNameList() { statement.setAccounts(requireRoleNames(accounts)); } ] - - { - linkAST(mapExpression, jjtThis); - return mapExpression; - } + { return statement; } } -Expression MapKeyExpression(): +SetPasswordStatement SetPasswordStatement(): { - Expression key; + SetPasswordStatement statement = new SetPasswordStatement(); + UserAccount account; + Expression password; + Token value; } { - try { - { mapKeyDepth++; } - key = Expression() - } finally { - mapKeyDepth--; - } - { return key; } + + [ account=MySqlAccountName() { statement.setAccount(account); } ] + ( + "=" password=Expression() { statement.setPassword(password); } + | + { statement.setRandom(true); } + ) + [ + LOOKAHEAD({ getToken(1).kind == K_REPLACE && getToken(2).kind == S_CHAR_LITERAL }) + value= { statement.setCurrentCredential(stringValue(value)); } + ] + [ + LOOKAHEAD({ isKeywordAhead("RETAIN") }) ContextualKeyword("RETAIN") + { statement.setRetainCurrentPassword(true); } + ] + { return statement; } } -List> StructParameters(): +EventSchedule MySqlEventSchedule(): { - String parameterName = ""; - ColDataType parameterType = null; - AbstractMap.SimpleEntry parameter = null; - List> parameters = new ArrayList>(); + EventSchedule schedule = new EventSchedule(); + Expression expression = null; + Token unitToken = null; + String unit = null; } { - [ LOOKAHEAD(2) parameterName = RelObjectName() ] - parameterType = ColDataType() - { - parameters.add( new AbstractMap.SimpleEntry(parameterName, parameterType) ); - } - + ( - "," { parameterName=""; } - - [ LOOKAHEAD(2) parameterName = RelObjectName() ] - parameterType = ColDataType() - { - parameters.add( new AbstractMap.SimpleEntry(parameterName, parameterType) ); + expression=Expression() { + schedule.setType(EventSchedule.Type.AT); + schedule.setExecuteAt(expression); } - )* - - { - return parameters; - } + | + expression=MySqlEventIntervalValue() { + schedule.setType(EventSchedule.Type.EVERY); + schedule.setInterval(expression); + } + ( LOOKAHEAD({ getToken(1).kind == K_DATE_LITERAL }) + unitToken= { schedule.setIntervalUnit(unitToken.image); } + | unit=RelObjectName() { schedule.setIntervalUnit(unit); } ) + [ expression=Expression() { schedule.setStarts(expression); } ] + [ expression=Expression() { schedule.setEnds(expression); } ] + ) + { return schedule; } } -StructType StructType() #StruckType: +Expression MySqlEventIntervalValue(): { - StructType.Dialect dialect = StructType.Dialect.BIG_QUERY; - Token tk1; - String keyword = ""; - List> parameters = null; - List> arguments = null; - String id = null; + Token value = null; Expression expression = null; - StructType type; } { ( - LOOKAHEAD(4) ( - tk1= { keyword = tk1.image; } - "<" parameters = StructParameters() ">" - "(" arguments = SelectItemsList() ")" - ) + value= { expression = new LongValue(value.image); } | - ( - tk1= { keyword = tk1.image; } - "(" arguments = SelectItemsList() ")" - ) + value= { expression = new DoubleValue(value.image); } | - ( - { arguments= new ArrayList>(); dialect = StructType.Dialect.DUCKDB;} - ( id = RelObjectNameExt() | tk1= { id = tk1.image; } ) - expression = Expression() { arguments.add( new SelectItem( expression, id) ); } - - ( - "," - ( id = RelObjectNameExt() | tk1= { id = tk1.image; } ) - expression = Expression() { arguments.add( new SelectItem( expression, id) ); } - )* - - - ( - LOOKAHEAD(2) "::" "(" parameters = StructParameters() ")" - )* - ) + value= { expression = stringValue(value); } ) - { - type = new StructType(dialect, keyword, parameters, arguments); - linkAST(type,jjtThis); - return type; - } + { return expression; } } -JsonExpression JsonExpression(Expression expr, List> idents) : { - JsonExpression result = new JsonExpression(expr, idents); - Expression expression; - Token token=null; - ColDataType type = null; - CastExpression castExpr = null; +Boolean MySqlEventCompletion(): +{ + boolean preserve = true; } { + [ { preserve = false; } ] + LOOKAHEAD({ "PRESERVE".equalsIgnoreCase(getToken(1).image) }) + + { return preserve; } +} - // chaining JSON Expressions, e.g. - // '{"obj":{"field": "value"}}'::JSON -> 'obj'::TEXT ->> 'field'::TEXT +EventStatus MySqlEventStatus(): +{ + EventStatus status = null; +} +{ ( - LOOKAHEAD(2, {!interrupted} ) ( - LOOKAHEAD(2) ( - "::" type=ColDataType() - { - castExpr = new CastExpression(); - castExpr.setUseCastKeyword(false); - castExpr.setLeftExpression(result); - castExpr.setColDataType(type); - expr=castExpr; - } - ) - )+ - { - result = new JsonExpression(expr); - } - - ( - LOOKAHEAD(2, { !isPostgreSqlJsonAccess(getToken(1)) - && ((ternaryThenBranchDepth == 0 && mapKeyDepth == 0) - || !":".equals(getToken(1).image)) }) ( - token="->" - | - token=":" - | - token="->>" - | - token="#>" - | - token="#>>" - ) - - ( - LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) expression=Expression() - | - expression=SimpleExpression() - ) - { - result.addIdent( expression, token.image ); - } - )* - )* - - { - result.setExpression(expr); - return result; - } + { status = EventStatus.ENABLE; } + | + { status = EventStatus.DISABLE; } + [ LOOKAHEAD({ getToken(1).kind == K_ON && (getToken(2).kind == K_SLAVE + || "REPLICA".equalsIgnoreCase(getToken(2).image)) }) + ( + { status = EventStatus.DISABLE_ON_SLAVE; } + | + ContextualKeyword("REPLICA") { status = EventStatus.DISABLE_ON_REPLICA; } + ) ] + ) + { return status; } } -JsonKeyValuePair JsonKeyValuePair(boolean isFirstEntry) : { - Token keyToken; - - boolean usingKeyKeyword = false; - boolean usingFormatJason = false; - String encoding = null; - boolean isWildcard = false; +CreateEvent CreateEvent(): +{ + CreateEvent createEvent = new CreateEvent(); + Table event = null; + EventSchedule schedule = null; + Boolean preserve = null; + EventStatus status = null; + Token comment = null; + Statement body = null; + MySqlDefiner definer = null; +} +{ + [ LOOKAHEAD({ isKeywordAhead("DEFINER") }) + definer=MySqlRoutineDefiner() { createEvent.setDefiner(definer); } ] + + [ LOOKAHEAD(3) { createEvent.setIfNotExists(true); } ] + event=Table() { createEvent.setEvent(event); } + schedule=MySqlEventSchedule() { createEvent.setSchedule(schedule); } + [ LOOKAHEAD(2) preserve=MySqlEventCompletion() { + createEvent.setOnCompletionPreserve(preserve); + } ] + [ LOOKAHEAD({ getToken(1).kind == K_ENABLE || getToken(1).kind == K_DISABLE }) + status=MySqlEventStatus() { createEvent.setStatus(status); } ] + [ LOOKAHEAD({ getToken(1).kind == K_COMMENT }) comment= { + createEvent.setComment(stringValue(comment)); + } ] + body=MySqlTriggerBody() { createEvent.setBody(body); } + { return createEvent; } +} - Object key = null; - Expression expression = null; - JsonFunctionExpression functionExpression; +AlterEvent AlterEvent(): +{ + AlterEvent alterEvent = new AlterEvent(); + Table event = null; + Table renameTo = null; + EventSchedule schedule = null; + Boolean preserve = null; + EventStatus status = null; + Token comment = null; + Statement body = null; + MySqlDefiner definer = null; +} +{ + [ LOOKAHEAD({ isKeywordAhead("DEFINER") }) + definer=MySqlRoutineDefiner() { alterEvent.setDefiner(definer); } ] + event=Table() { alterEvent.setEvent(event); } + [ LOOKAHEAD({ getToken(1).kind == K_ON && getToken(2).kind == K_SCHEDULE }) + schedule=MySqlEventSchedule() { alterEvent.setSchedule(schedule); } ] + [ LOOKAHEAD({ getToken(1).kind == K_ON && getToken(2).kind == K_COMPLETION }) + preserve=MySqlEventCompletion() { alterEvent.setOnCompletionPreserve(preserve); } ] + [ LOOKAHEAD({ getToken(1).kind == K_RENAME }) + renameTo=Table() { alterEvent.setRenameTo(renameTo); } ] + [ LOOKAHEAD({ getToken(1).kind == K_ENABLE || getToken(1).kind == K_DISABLE }) + status=MySqlEventStatus() { alterEvent.setStatus(status); } ] + [ LOOKAHEAD({ getToken(1).kind == K_COMMENT }) comment= { + alterEvent.setComment(stringValue(comment)); + } ] + [ LOOKAHEAD({ getToken(1).kind == K_DO }) + body=MySqlTriggerBody() { alterEvent.setBody(body); } ] + { return alterEvent; } +} - JsonKeyValuePairSeparator kvSeparator = JsonKeyValuePairSeparator.NOT_USED; +/** Account spelling is shared, including CURRENT_USER and CURRENT_USER(). */ +void MySqlDefiner(MySqlDefiner definer): +{ + UserAccount account; + String name; } { + ContextualKeyword("DEFINER") "=" ( - // lookahead because key is a valid column name - LOOKAHEAD(2) ( - { usingKeyKeyword = true; } - ( - keyToken = { key = keyToken.image; } | - key = Column() - ) - ) - | - LOOKAHEAD(16) key = AllTableColumns(false) { isWildcard = true; } - | - LOOKAHEAD(2) key = AllColumns(false) { isWildcard = true; } - | - LOOKAHEAD(2) key = Column() - | - LOOKAHEAD({getAsBoolean(Feature.allowExpressionAsJsonObjectKey)}) key = Expression() + LOOKAHEAD({ isKeywordAhead("CURRENT_USER") }) name=RelObjectName() + { definer.setUser(linkToLastToken(new StringValue(name).setQuoteStr(""))); } + [ "(" ")" { definer.setCurrentUserParentheses(true); } ] | - keyToken = { key = keyToken.image; } + account=MySqlAccountName() { definer.setUser(account.getUser()); definer.setHost(account.getHost()); } ) - - // Optional Separator + Value - Is not allowed with * or t1.* - [ LOOKAHEAD(1, { !isWildcard } ) - ( - { kvSeparator = JsonKeyValuePairSeparator.VALUE; } - | - { kvSeparator = JsonKeyValuePairSeparator.COLON; } - | - LOOKAHEAD({getAsBoolean(Feature.allowCommaAsKeyValueSeparator)}) { kvSeparator = JsonKeyValuePairSeparator.COMMA; } - ) - expression = Expression() - ] - - // Optional: FORMAT JSON [ ENCODING ... ] - Is not allowed with * or t1.* - [ - LOOKAHEAD(1, { !isWildcard } ) { usingFormatJason = true; } - [ encoding = JsonEncoding() ] - ] - { - final JsonKeyValuePair keyValuePair = new JsonKeyValuePair( key, expression, usingKeyKeyword, kvSeparator ); - keyValuePair.setUsingFormatJson( usingFormatJason ); - keyValuePair.setEncoding(encoding); - return keyValuePair; - } } -JsonFunction JsonObjectBody() : { - JsonFunction result = new JsonFunction(JsonFunctionType.OBJECT); +TriggerDefiner MySqlTriggerDefiner(): +{ TriggerDefiner definer = new TriggerDefiner(); } +{ MySqlDefiner(definer) { return definer; } } - JsonKeyValuePair keyValuePair; - ColDataType dataType; - String encoding; +MySqlDefiner MySqlRoutineDefiner(): +{ MySqlDefiner definer = new MySqlDefiner(); } +{ MySqlDefiner(definer) { return definer; } } + +/** MySQL fixes the prefix order: ALGORITHM, DEFINER, SQL SECURITY. */ +MySqlViewOptions MySqlViewPrefix(): +{ + MySqlViewOptions options = new MySqlViewOptions(); + MySqlDefiner definer; + Token token; + boolean present = false; } { - ( "(" - ( - // First Element - LOOKAHEAD(2) keyValuePair = JsonKeyValuePair(true) { result.add(keyValuePair);} - - // Next Elements - ( - keyValuePair = JsonKeyValuePair(false) { result.add(keyValuePair); } - )* - )? - [ - ( { result.setOnNullType( JsonAggregateOnNullType.NULL ); } ) - | - ( { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } ) - ] - [ { result.setStrict(true); } ] - [ - ( { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); } ) - | - ( { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); } ) - ] - [ - dataType = ColDataType() { result.setReturningType(dataType); } - [ - { result.setReturningFormatJson(true); } - [ encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ] - ] - ] - ")" ) - { - return result; - } + [ "=" ( token= | token= ) { + requireDdlSyntax("MERGE".equalsIgnoreCase(token.image) || "TEMPTABLE".equalsIgnoreCase(token.image) + || "UNDEFINED".equalsIgnoreCase(token.image), "Expected MERGE, TEMPTABLE, or UNDEFINED"); + options.setAlgorithm(MySqlViewOptions.Algorithm.valueOf(token.image.toUpperCase(Locale.ROOT))); + present = true; + } ] + [ LOOKAHEAD({ isKeywordAhead("DEFINER") }) { definer = new MySqlDefiner(); } + MySqlDefiner(definer) { options.setDefiner(definer); present = true; } ] + [ LOOKAHEAD({ isKeywordAhead("SQL") }) ContextualKeyword("SQL") token= { + requireDdlSyntax("DEFINER".equalsIgnoreCase(token.image) || "INVOKER".equalsIgnoreCase(token.image), + "Expected DEFINER or INVOKER"); + options.setSecurity(MySqlViewOptions.Security.valueOf(token.image.toUpperCase(Locale.ROOT))); + present = true; + } ] + { return present ? options : null; } } -JsonFunction JsonArrayBody() : { - JsonFunction result = new JsonFunction(JsonFunctionType.ARRAY); - - Expression expression = null; - JsonFunctionExpression functionExpression; - ColDataType dataType; - String encoding; +CreateTrigger.Timing MySqlTriggerTiming(): +{ + CreateTrigger.Timing timing = null; } { - ( "(" - ( - LOOKAHEAD(2) ( - { result.setOnNullType( JsonAggregateOnNullType.NULL ); } - ) - | - expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); } - - [ - LOOKAHEAD(2) { functionExpression.setUsingFormatJson( true ); } - [ LOOKAHEAD(2) encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ] - ] - ( - "," - expression=Expression() { functionExpression = new JsonFunctionExpression( expression ); result.add( functionExpression ); } - [ - LOOKAHEAD(2) { functionExpression.setUsingFormatJson( true ); } - [ LOOKAHEAD(2) encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ] - ] - )* - )* + ( + { timing = CreateTrigger.Timing.BEFORE; } + | + LOOKAHEAD({ "AFTER".equalsIgnoreCase(getToken(1).image) }) + { timing = CreateTrigger.Timing.AFTER; } + ) + { return timing; } +} - [ - { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } - ] - [ - dataType = ColDataType() { result.setReturningType(dataType); } - [ - { result.setReturningFormatJson(true); } - [ encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ] - ] - ] - ")" ) - { - return result; +CreateTrigger.Order MySqlTriggerOrder(): +{ + CreateTrigger.Order order = null; + Token token = null; +} +{ + LOOKAHEAD({ "FOLLOWS".equalsIgnoreCase(getToken(1).image) + || "PRECEDES".equalsIgnoreCase(getToken(1).image) }) + token= { + order = "FOLLOWS".equalsIgnoreCase(token.image) + ? CreateTrigger.Order.FOLLOWS : CreateTrigger.Order.PRECEDES; } + { return order; } } -void JsonKeyword(String expectedKeyword) : { - Token token; +/** + * MySQL trigger or event statement. BEGIN ... END with SQL statements only remains a Block. Other + * compound statements, such as those with IF or DECLARE, keep their tokens like routine bodies and + * use the same boundary tracking. The semicolon after END is left to separate statements. + */ +Statement MySqlTriggerBody(): +{ + Statement body; + List tokens; + Token first = getToken(1); } { - token = - { - if (!token.image.equalsIgnoreCase(expectedKeyword)) { - throw new ParseException( - "Expected keyword " + expectedKeyword + " but found " + token.image); + ( + LOOKAHEAD({ isStatementBlockAhead() }) body=BeginEndBlock() + | + LOOKAHEAD({ isMySqlCompoundStatementAhead() }) tokens=captureCompoundStatement() + { body = linked(new UnsupportedStatement(tokens), first); } + | + body=SingleStatement() + ) + { return body; } +} + +/** + * Captures a compound statement through its END and optional end label. Qualified names are + * joined, and a semicolon or label colon is attached to the preceding token. + */ +JAVACODE +List captureCompoundStatement() { + List tokens = new LinkedList(); + RoutineBodyBoundary boundary = RoutineBodyBoundary.forCompoundStatement(); + boolean afterDot = false; + Token tok; + while (true) { + tok = getToken(1); + if (boundary.endsAt(tok)) { + break; + } + int last = tokens.size() - 1; + if (last >= 0 && (afterDot || ".".equals(tok.image) || ":".equals(tok.image) + || tok.kind == ST_SEMICOLON)) { + tokens.set(last, tokens.get(last) + tok.image); + } else { + tokens.add(tok.image); } + afterDot = ".".equals(tok.image); + boundary.accept(tok, getToken(2)); + getNextToken(); } + return tokens; } -String JsonEncoding() : { - Token token; +CreateTrigger CreateTrigger(boolean orReplace): +{ + CreateTrigger createTrigger = new CreateTrigger(); + TriggerDefiner definer = null; + Table trigger = null; + CreateTrigger.Timing timing = null; + Token event = null; + Table table = null; + CreateTrigger.Order order = null; + Table otherTrigger = null; + Statement body = null; } { - token = + [ LOOKAHEAD({ "DEFINER".equalsIgnoreCase(getToken(1).image) }) + definer=MySqlTriggerDefiner() { createTrigger.setDefiner(definer); } ] + + [ LOOKAHEAD(2) { createTrigger.setIfNotExists(true); } ] { - if (token.image.equalsIgnoreCase("UTF8")) { - return "UTF8"; - } else if (token.image.equalsIgnoreCase("UTF16")) { - return "UTF16"; - } else if (token.image.equalsIgnoreCase("UTF32")) { - return "UTF32"; - } - throw new ParseException( - "Expected ENCODING value UTF8, UTF16 or UTF32 but found " + token.image); + requireDdlSyntax(!orReplace || !createTrigger.isIfNotExists(), + "OR REPLACE and IF NOT EXISTS cannot be combined"); + createTrigger.setOrReplace(orReplace); } + trigger=Table() { createTrigger.setTrigger(trigger); } + timing=MySqlTriggerTiming() { createTrigger.setTiming(timing); } + ( event= { createTrigger.setEvent(CreateTrigger.Event.INSERT); } + | event= { createTrigger.setEvent(CreateTrigger.Event.UPDATE); } + | event= { createTrigger.setEvent(CreateTrigger.Event.DELETE); } ) + table=Table() { createTrigger.setTable(table); } + + LOOKAHEAD({ "EACH".equalsIgnoreCase(getToken(1).image) }) + [ order=MySqlTriggerOrder() otherTrigger=Table() { + createTrigger.setOrder(order); + createTrigger.setOtherTrigger(otherTrigger); + } ] + body=MySqlTriggerBody() { createTrigger.setBody(body); } + { return createTrigger; } } -JsonFunctionExpression JsonValueOrQueryInputExpression() : { - Expression expression; - JsonFunctionExpression functionExpression; - String encoding; +CreateSchema CreateSchema(): +{ + Token tk = null; + Statement element = null; + CreateSchema schema = new CreateSchema(); + List schemaPath = null; + DatabaseOption databaseOption = null; } { - expression = Expression() { functionExpression = new JsonFunctionExpression(expression); } - [ - { functionExpression.setUsingFormatJson(true); } - [ encoding = JsonEncoding() { functionExpression.setEncoding(encoding); } ] + + [ LOOKAHEAD(2) { schema.setIfNotExists(true); } ] + [ LOOKAHEAD(1) + ( tk= | tk=) { schema.setSchemaName(tk.image); } + + ( + "." { schema.setCatalogName(tk.image); } + ( tk= | tk=) { schema.setSchemaName(tk.image); } + )? + ] + + ( + LOOKAHEAD({ isMySqlDatabaseOptionAhead() }) + databaseOption=MySqlDatabaseOption() { schema.addDatabaseOptions(databaseOption); } + )* + + [ + (tk= | tk=) { schema.setAuthorization(tk.image); } ] + + [schemaPath=PathSpecification() { schema.setSchemaPath(schemaPath); }] + + // Elements keep their names as written; unqualified names refer to the new schema. + ( + LOOKAHEAD({ getToken(1).kind == K_CREATE || getToken(1).kind == K_GRANT }) + element=SchemaElement() { schema.addStatement(element); } + )* { - return functionExpression; + requireDdlSyntax(!schema.hasIfNotExists() || schema.getStatements().isEmpty(), + "CREATE SCHEMA IF NOT EXISTS cannot include schema elements"); + return schema; } } -JsonFunction.JsonOnResponseBehavior JsonValueOnResponseBehavior() : { - JsonFunction.JsonOnResponseBehavior behavior; - Expression expression; +/** + * A statement nested in CREATE SCHEMA. Only the object kinds that PostgreSQL accepts as schema + * elements are allowed: tables, views, indexes, sequences, triggers and GRANT. + */ +Statement SchemaElement(): +{ + Statement element; + Token first = getToken(1); } { - ( - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.ERROR); - } - | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.NULL); - } - | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.EMPTY); - } - | - expression = Expression() - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.DEFAULT, expression); - } - ) - { - return behavior; + { schemaElementDepth++; } + try { + ( + element=Create() + { + requireDdlSyntax(element instanceof CreateTable || element instanceof CreateIndex + || element instanceof CreateSequence || element instanceof CreateTrigger + || element instanceof CreateView && !((CreateView) element).isMaterialized(), + "A schema element must be CREATE TABLE, VIEW, INDEX, SEQUENCE, TRIGGER or GRANT"); + } + | + element=Grant() + ) + } finally { + schemaElementDepth--; } + { linkStatement(element, first); return element; } } -JsonFunction.JsonOnResponseBehavior JsonQueryOnResponseBehavior() : { - JsonFunction.JsonOnResponseBehavior behavior = null; - Token token; +DatabaseOption MySqlDatabaseOption(): +{ + boolean useDefault = false; + boolean useEquals = false; + DatabaseOption.Kind kind = DatabaseOption.Kind.OTHER; + String name = null; + String value = null; + Token valueToken = null; } { + [ { useDefault = true; } ] ( - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.ERROR); + { + kind = DatabaseOption.Kind.CHARACTER_SET; + name = "CHARACTER SET"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.NULL); + { + kind = DatabaseOption.Kind.CHARACTER_SET; + name = "CHAR SET"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.TRUE); + LOOKAHEAD({ isKeywordAhead("CHARSET") }) ContextualKeyword("CHARSET") { + kind = DatabaseOption.Kind.CHARACTER_SET; + name = "CHARSET"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.FALSE); + { + kind = DatabaseOption.Kind.COLLATE; + name = "COLLATE"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.EMPTY); + { + kind = DatabaseOption.Kind.ENCRYPTION; + name = "ENCRYPTION"; } - [ - ( - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.EMPTY_ARRAY); - } - | - JsonKeyword("OBJECT") - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.EMPTY_OBJECT); - } - ) - ] ) - { - return behavior; - } + [ "=" { useEquals = true; } ] + ( value=RelObjectName() | valueToken= { value = valueToken.image; } ) + { return new DatabaseOption(kind, name, value, useDefault, useEquals); } } -JsonFunction.JsonOnResponseBehavior JsonExistsOnResponseBehavior() : { - JsonFunction.JsonOnResponseBehavior behavior = null; +/** PostgreSQL option of CREATE DATABASE; ALTER DATABASE accepts the same option list. */ +DatabaseOption PostgreSqlDatabaseOption(): +{ + Token token; + DatabaseOption.Kind kind; + String name; + String value; + boolean useEquals = false; } { ( - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.TRUE); - } + LOOKAHEAD({ isKeywordAhead("CONNECTION") }) ContextualKeyword("CONNECTION") + { kind = DatabaseOption.Kind.CONNECTION_LIMIT; name = "CONNECTION LIMIT"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.FALSE); - } + { kind = DatabaseOption.Kind.ENCODING; name = "ENCODING"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.UNKNOWN); - } + { kind = DatabaseOption.Kind.TABLESPACE; name = "TABLESPACE"; } | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.ERROR); + LOOKAHEAD({ isPostgreSqlDatabaseOptionAhead(1) }) token= { + name = token.image.toUpperCase(Locale.ROOT); + kind = DatabaseOption.Kind.valueOf(name); } ) - { - return behavior; - } -} - -JsonFunction JsonExistsBody() : { - JsonFunction result = new JsonFunction(JsonFunctionType.EXISTS); - JsonFunctionExpression inputExpression; - Expression expression; - JsonFunction.JsonOnResponseBehavior behavior; -} -{ - "(" - inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); } - "," - expression = Expression() { result.setJsonPathExpression(expression); } - - [ - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) - JsonKeyword("PASSING") - expression = Expression() { result.addPassingExpression(expression); } - ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )* - ] - - [ - LOOKAHEAD( JsonExistsOnResponseBehavior() ) - behavior = JsonExistsOnResponseBehavior() - - { result.setOnErrorBehavior(behavior); } - ] - ")" - { - return result; - } + [ "=" { useEquals = true; } ] + value=PostgreSqlDatabaseOptionValue() + { return new DatabaseOption(kind, name, value, false, useEquals); } } -JsonFunction JsonValueBody() : { - JsonFunction result = new JsonFunction(JsonFunctionType.VALUE); - JsonFunctionExpression inputExpression; - Expression expression; - ColDataType dataType; - JsonFunction.JsonOnResponseBehavior behavior; -} +/** A name, string, signed number, boolean or DEFAULT, as written. */ +String PostgreSqlDatabaseOptionValue(): { - "(" - inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); } - "," - expression = Expression() { result.setJsonPathExpression(expression); } - - [ - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) - JsonKeyword("PASSING") - expression = Expression() { result.addPassingExpression(expression); } - ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )* - ] - - [ dataType = ColDataType() { result.setReturningType(dataType); } ] - - [ - LOOKAHEAD( JsonValueOnResponseBehavior() ) - behavior = JsonValueOnResponseBehavior() - - { result.setOnEmptyBehavior(behavior); } - ] - - [ - LOOKAHEAD( JsonValueOnResponseBehavior() ) - behavior = JsonValueOnResponseBehavior() - - { result.setOnErrorBehavior(behavior); } - ] - ")" - { - return result; - } -} - -JsonFunction JsonQueryBody() : { - JsonFunction result = new JsonFunction(JsonFunctionType.QUERY); - JsonFunctionExpression inputExpression; - Expression expression; - ColDataType dataType; - JsonFunction.JsonOnResponseBehavior behavior; Token token; - String encoding; - ColDataType additionalReturningType; - boolean additionalReturningFormatJson; - String additionalReturningEncoding; - JsonFunction.JsonWrapperType additionalWrapperType; - JsonFunction.JsonWrapperMode additionalWrapperMode; - boolean additionalWrapperArray; - JsonFunction.JsonQuotesType additionalQuotesType; - boolean additionalQuotesOnScalarString; - JsonFunction.JsonOnResponseBehavior additionalOnEmptyBehavior; - JsonFunction.JsonOnResponseBehavior additionalOnErrorBehavior; - StringBuilder additionalBuilder; - boolean hasPassingClause = false; + String value; + String sign = ""; } { - "(" - inputExpression = JsonValueOrQueryInputExpression() { result.setInputExpression(inputExpression); } - "," - expression = Expression() { result.setJsonPathExpression(expression); } - - [ - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) - JsonKeyword("PASSING") { hasPassingClause = true; } - expression = Expression() { result.addPassingExpression(expression); } - ( LOOKAHEAD(2) "," expression = Expression() { result.addPassingExpression(expression); } )* - ] - - [ - dataType = ColDataType() { result.setReturningType(dataType); } - [ - { result.setReturningFormatJson(true); } - [ encoding = JsonEncoding() { result.setReturningEncoding(encoding); } ] - ] - ] + ( + LOOKAHEAD(1) token= { value = token.image; } + | + LOOKAHEAD(1) token= { value = token.image; } + | + ( token= | token= | token= ) { value = token.image; } + | + [ "+" { sign = "+"; } | "-" { sign = "-"; } ] + ( token= | token= ) { value = sign + token.image; } + | + value=RelObjectName() + ) + { return value; } +} - [ +/** + * MySQL ALTER DATABASE/SCHEMA options and the PostgreSQL ALTER DATABASE forms. Options reuse the + * CREATE DATABASE productions; READ ONLY is specific to MySQL's ALTER. Only MySQL options may + * follow an omitted name. + */ +AlterDatabase AlterDatabase(): +{ + AlterDatabase result = new AlterDatabase(); + String name; + DatabaseOption option; + ConfigurationParameterChange change; +} +{ + ( + { result.setUseSchemaKeyword(true); } ( - { result.setWrapperType(JsonFunction.JsonWrapperType.WITHOUT); } - [ { result.setWrapperArray(true); } ] - JsonKeyword("WRAPPER") + LOOKAHEAD({ isAlterDatabaseNameOmitted() }) MySqlAlterDatabaseOptions(result) | - { result.setWrapperType(JsonFunction.JsonWrapperType.WITH); } - [ - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && (getToken(1).image.equalsIgnoreCase("CONDITIONAL") - || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL")) - }) - token = - { - if (token.image.equalsIgnoreCase("CONDITIONAL")) { - result.setWrapperMode(JsonFunction.JsonWrapperMode.CONDITIONAL); - } else { - result.setWrapperMode(JsonFunction.JsonWrapperMode.UNCONDITIONAL); - } - } - ] - [ { result.setWrapperArray(true); } ] - JsonKeyword("WRAPPER") + name=RelObjectName() { result.setDatabaseName(name); } MySqlAlterDatabaseOptions(result) ) - ] - - [ - LOOKAHEAD({ - getToken(1).kind == K_KEEP - || (getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("OMIT")) - }) + | + ( - { result.setQuotesType(JsonFunction.JsonQuotesType.KEEP); } + LOOKAHEAD({ isAlterDatabaseNameOmitted() }) MySqlAlterDatabaseOptions(result) | - JsonKeyword("OMIT") { result.setQuotesType(JsonFunction.JsonQuotesType.OMIT); } - ) - JsonKeyword("QUOTES") - [ - JsonKeyword("SCALAR") - { result.setQuotesOnScalarString(true); } - ] - ] - - [ - LOOKAHEAD( JsonQueryOnResponseBehavior() ) - behavior = JsonQueryOnResponseBehavior() - - { result.setOnEmptyBehavior(behavior); } - ] - - [ - LOOKAHEAD( JsonQueryOnResponseBehavior() ) - behavior = JsonQueryOnResponseBehavior() - - { result.setOnErrorBehavior(behavior); } - ] - - ( - LOOKAHEAD(2, { !hasPassingClause }) - "," - { - additionalReturningType = null; - additionalReturningFormatJson = false; - additionalReturningEncoding = null; - additionalWrapperType = null; - additionalWrapperMode = null; - additionalWrapperArray = false; - additionalQuotesType = null; - additionalQuotesOnScalarString = false; - additionalOnEmptyBehavior = null; - additionalOnErrorBehavior = null; - } - expression = Expression() - [ - additionalReturningType = ColDataType() - [ - { additionalReturningFormatJson = true; } - [ additionalReturningEncoding = JsonEncoding() ] - ] - ] - [ + name=RelObjectName() { result.setDatabaseName(name); } ( - - { additionalWrapperType = JsonFunction.JsonWrapperType.WITHOUT; } - [ { additionalWrapperArray = true; } ] - JsonKeyword("WRAPPER") + name=RelObjectName() + { result.setAction(AlterDatabase.Action.RENAME); result.setNewName(name); } | - - { additionalWrapperType = JsonFunction.JsonWrapperType.WITH; } - [ - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && (getToken(1).image.equalsIgnoreCase("CONDITIONAL") - || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL")) - }) - token = - { - if (token.image.equalsIgnoreCase("CONDITIONAL")) { - additionalWrapperMode = JsonFunction.JsonWrapperMode.CONDITIONAL; - } else { - additionalWrapperMode = JsonFunction.JsonWrapperMode.UNCONDITIONAL; - } - } - ] - [ { additionalWrapperArray = true; } ] - JsonKeyword("WRAPPER") - ) - ] - [ - LOOKAHEAD({ - getToken(1).kind == K_KEEP - || (getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("OMIT")) - }) - ( - { additionalQuotesType = JsonFunction.JsonQuotesType.KEEP; } + LOOKAHEAD({ isKeywordAhead("OWNER") && getToken(2).kind == K_TO }) + ContextualKeyword("OWNER") name=RelObjectName() + { result.setAction(AlterDatabase.Action.OWNER); result.setOwner(name); } | - JsonKeyword("OMIT") { additionalQuotesType = JsonFunction.JsonQuotesType.OMIT; } + LOOKAHEAD({ getToken(1).kind == K_SET && getToken(2).kind == K_TABLESPACE + && getToken(3).kind != K_TO && getToken(3).kind != K_FROM && !"=".equals(getToken(3).image) }) + name=RelObjectName() + { result.setAction(AlterDatabase.Action.SET_TABLESPACE); result.setTablespace(name); } + | + ContextualKeyword("COLLATION") + { result.setAction(AlterDatabase.Action.REFRESH_COLLATION_VERSION); } + | + change=ConfigurationParameterChange() + { result.setAction(AlterDatabase.Action.CONFIGURATION_PARAMETER); result.setParameterChange(change); } + | + [ { result.setUseWith(true); } ] + ( + ( + LOOKAHEAD({ isPostgreSqlDatabaseOptionAhead(1) }) option=PostgreSqlDatabaseOption() + | + option=MySqlAlterDatabaseOption() + ) { result.getOptions().add(option); } + )+ ) - JsonKeyword("QUOTES") - [ - JsonKeyword("SCALAR") { additionalQuotesOnScalarString = true; } - ] - ] - [ - LOOKAHEAD( JsonQueryOnResponseBehavior() ) - additionalOnEmptyBehavior = JsonQueryOnResponseBehavior() - - ] - [ - LOOKAHEAD( JsonQueryOnResponseBehavior() ) - additionalOnErrorBehavior = JsonQueryOnResponseBehavior() - - ] - { - additionalBuilder = new StringBuilder(); - additionalBuilder.append(expression); - if (additionalReturningType != null) { - additionalBuilder.append(" RETURNING ").append(additionalReturningType); - if (additionalReturningFormatJson) { - additionalBuilder.append(" FORMAT JSON"); - if (additionalReturningEncoding != null) { - additionalBuilder.append(" ENCODING ").append(additionalReturningEncoding); - } - } - } - if (additionalWrapperType != null) { - additionalBuilder.append(" ").append(additionalWrapperType); - if (additionalWrapperMode != null) { - additionalBuilder.append(" ").append(additionalWrapperMode); - } - if (additionalWrapperArray) { - additionalBuilder.append(" ARRAY"); - } - additionalBuilder.append(" WRAPPER"); - } - if (additionalQuotesType != null) { - additionalBuilder.append(" ").append(additionalQuotesType).append(" QUOTES"); - if (additionalQuotesOnScalarString) { - additionalBuilder.append(" ON SCALAR STRING"); - } - } - if (additionalOnEmptyBehavior != null) { - additionalBuilder.append(" ").append(additionalOnEmptyBehavior).append(" ON EMPTY"); - } - if (additionalOnErrorBehavior != null) { - additionalBuilder.append(" ").append(additionalOnErrorBehavior).append(" ON ERROR"); - } - result.addAdditionalQueryPathArgument(additionalBuilder.toString()); + ) + ) + { return result; } +} + +void MySqlAlterDatabaseOptions(AlterDatabase result): +{ DatabaseOption option; } +{ + ( option=MySqlAlterDatabaseOption() { result.getOptions().add(option); } )+ +} + +/** MySQL ALTER DATABASE option: a CREATE DATABASE option or READ ONLY. */ +DatabaseOption MySqlAlterDatabaseOption(): +{ + DatabaseOption option; + Token value; + boolean equals = false; +} +{ + ( + LOOKAHEAD({ isMySqlDatabaseOptionAhead() }) option=MySqlDatabaseOption() + | + + [ "=" { equals = true; } ] + ( value= | value= ) { + requireDdlSyntax(value.kind == K_DEFAULT || "0".equals(value.image) || "1".equals(value.image), + "READ ONLY requires DEFAULT, 0, or 1"); + option = new DatabaseOption(DatabaseOption.Kind.READ_ONLY, "READ ONLY", value.image, false, equals); } - )* - ")" + ) + { return option; } +} + +List PathSpecification(): +{ + Token tk; + List pathList = new ArrayList(); +} +{ + (tk=|tk=) { pathList.add(tk.image); } + ("," (tk=|tk=) { pathList.add(tk.image); })* { - return result; + return pathList; } } -JsonFunction JsonFunction() : { - JsonFunction result; +/** Typed MySQL and PostgreSQL options; other option text is kept as one raw option. */ +CreateDatabase CreateDatabase(): +{ + CreateDatabase createDatabase = new CreateDatabase(); + String databaseName = null; + List databaseOptions = null; + DatabaseOption databaseOption = null; } { + + [ LOOKAHEAD(2) { createDatabase.setIfNotExists(true); } ] + databaseName = RelObjectName() { createDatabase.setDatabaseName(databaseName); } + [ LOOKAHEAD({ getToken(1).kind == K_WITH && isPostgreSqlDatabaseOptionAhead(2) }) + { createDatabase.setUseWith(true); } ] ( - ( result = JsonObjectBody() ) - | - ( result = JsonArrayBody() ) - | - ( - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("JSON_VALUE") - }) - JsonKeyword("JSON_VALUE") - result = JsonValueBody() - ) - | - ( - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("JSON_QUERY") - }) - JsonKeyword("JSON_QUERY") - result = JsonQueryBody() - ) - | - ( - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("JSON_EXISTS") - }) - JsonKeyword("JSON_EXISTS") - result = JsonExistsBody() - ) - ) + LOOKAHEAD({ isMySqlDatabaseOptionAhead() || isPostgreSqlDatabaseOptionAhead(1) }) + ( + LOOKAHEAD({ isMySqlDatabaseOptionAhead() }) databaseOption=MySqlDatabaseOption() + | + databaseOption=PostgreSqlDatabaseOption() + ) { createDatabase.addOptions(databaseOption); } + )* + [ databaseOptions = captureRest() { + if (!databaseOptions.isEmpty()) { + createDatabase.addOptions(DatabaseOption.raw(databaseOptions)); + } + } ] { - return result; + return createDatabase; } } -JsonAggregateFunction JsonAggregateFunction() : { - JsonAggregateFunction result = new JsonAggregateFunction(); +/** Shares optional SQL Server constraint modifiers across CREATE and ALTER. */ +IndexOptions.Clustering SqlServerIndexClustering(): +{ Token token; - Object key; - Expression expression; - List expressionOrderByList = null; + IndexOptions.Clustering clustering = null; +} +{ + [ LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && (isKeywordAhead("CLUSTERED") || isKeywordAhead("NONCLUSTERED")) }) + token= { + clustering = IndexOptions.Clustering.valueOf(token.image.toUpperCase(Locale.ROOT)); + } + ] + { return clustering; } +} - Expression filter; - ExpressionList expressionList = null; - List olist = null; - WindowElement windowElement = null; - boolean partitionByBrackets = false; +/** Parses PRIMARY, UNIQUE, plain, FULLTEXT, and SPATIAL indexes for CREATE and ALTER. */ +TableElement TableIndexSpec(boolean createContext): +{ + Token typeToken = null; + Token keywordToken = null; + String indexName = null; + String using = null; + List columns; + List indexOptions = new ArrayList(); + TableElement index; + Boolean nullsDistinct = null; + IndexOptions.Clustering clustering = null; } { ( - ( - ( - "(" { result.setType( JsonFunctionType.OBJECT ); } + typeToken= keywordToken= + clustering=SqlServerIndexClustering() + [ LOOKAHEAD({ clustering == null && getToken(1).kind != OPENING_BRACKET + && getToken(1).kind != K_USING }) indexName=RelObjectName() ] + // MySQL's index_type may also precede the key list: PRIMARY KEY USING BTREE (id) + [ LOOKAHEAD({ getToken(1).kind == K_USING && getToken(2).kind != K_INDEX + && getToken(2).kind != K_COLUMNS }) using=UsingIndexType() ] + columns=IndexKeyColumns(true) + TableIndexOptions(createContext, indexOptions) + { + index = new KeyConstraint() + .withIndexName(indexName) + .withType(typeToken.image + " " + keywordToken.image) + .withUsing(using).withColumns(columns) + .withSpecOptions(indexOptions); + } + | + typeToken= + [ LOOKAHEAD(2) [ { nullsDistinct = false; } ] { + if (nullsDistinct == null) { nullsDistinct = true; } + } ] + [ LOOKAHEAD(2) (keywordToken= | keywordToken=) ] + clustering=SqlServerIndexClustering() + [ LOOKAHEAD({ clustering == null && getToken(1).kind != OPENING_BRACKET + && getToken(1).kind != K_USING }) indexName=RelObjectName() ] + [ using=UsingIndexType() ] + columns=IndexKeyColumns(true) + TableIndexOptions(createContext, indexOptions) + { + // PostgreSQL and MySQL ALTER preserve named constraints separately from index names. + if (createContext || Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + || Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) { + index = new KeyConstraint() + .withIndexName(indexName) + .withType(typeToken.image + + (keywordToken != null ? " " + keywordToken.image : "")) + .withUsing(using).withColumns(columns).withSpecOptions(indexOptions); + } else { + index = new KeyConstraint().withType(typeToken.image) + .withIndexKeyword(keywordToken != null ? keywordToken.image : null) + .withIndexName(indexName).withUsing(using).withColumns(columns) + .withSpecOptions(indexOptions); + } + } + | + typeToken= + [ LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET + && getToken(1).kind != K_USING }) indexName=RelObjectName() ] + [ using=UsingIndexType() ] + columns=IndexColumnsWithParamsList() + TableIndexOptions(createContext, indexOptions) + { + index = new Index().withType(createContext ? typeToken.image : null) + .withIndexKeyword(typeToken.image).withKind(Index.Kind.INDEX) + .withName(indexName).withUsing(using).withColumns(columns) + .withSpecOptions(indexOptions); + } + | + typeToken= + [ LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET + && getToken(1).kind != K_USING }) indexName=RelObjectName() ] + [ using=UsingIndexType() ] + columns=IndexColumnsWithParamsList() + TableIndexOptions(createContext, indexOptions) + { + index = new Index().withType(createContext ? typeToken.image : null) + .withIndexKeyword(typeToken.image).withKind(Index.Kind.INDEX) + .withName(indexName).withUsing(using).withColumns(columns) + .withSpecOptions(indexOptions); + } + | + (typeToken= | typeToken=) + [ LOOKAHEAD(2) (keywordToken= | keywordToken=) ] + [ LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET }) indexName=RelObjectName() ] + columns=IndexColumnsWithParamsList() + TableIndexOptions(createContext, indexOptions) + { + index = new Index().withType(typeToken.image + + (createContext && keywordToken != null + ? " " + keywordToken.image : "")) + .withIndexKeyword(!createContext && keywordToken != null + ? keywordToken.image : null) + .withName(indexName).withColumns(columns).withSpecOptions(indexOptions); + } + ) + { ((IndexOptionSource) index).setNullsDistinct(nullsDistinct); + ((IndexOptionSource) index).setClustering(clustering); } + PostgreSqlConstraintOptions((IndexOptionSource) index) + { return index; } +} + +/** + * Index options after the key list, shared by CREATE TABLE and ALTER TABLE key definitions. + * CREATE TABLE also retains other accepted tokens as opaque options. + */ +void TableIndexOptions(boolean createContext, List options): +{ + IndexSpecOption option; + List parameter; +} +{ + ( + LOOKAHEAD({ createContext }) + ( LOOKAHEAD(2, { !(getToken(1).kind == K_WITH && getToken(2).kind == OPENING_BRACKET) + && !(getToken(1).kind == K_USING && getToken(2).kind == K_INDEX) + && getToken(1).kind != K_DEFERRABLE && !isKeywordAhead("INITIALLY") + && !(getToken(1).kind == K_NOT && (getToken(2).kind == K_DEFERRABLE + || "VALID".equalsIgnoreCase(getToken(2).image))) }) ( - LOOKAHEAD(2) ( - "KEY" { result.setUsingKeyKeyword( true ); } - ( - ( token = | token = | token = | token = | token = ) - { - key = token.image; - } - | - key = Column() - ) - ) - | - ( token = | token = | token = | token = | token = ) - { - key = token.image; - } + LOOKAHEAD(IndexSpecOption()) option=IndexSpecOption() { options.add(option); } | - key = Column() + parameter=CreateParameter() { options.add(IndexSpecOption.raw(parameter)); } ) - { - result.setKey( key ); - } - - ( ":" | "," { result.setType( JsonFunctionType.MYSQL_OBJECT ); } | "VALUE" {result.setUsingValueKeyword( true ); } ) - expression = Expression() { result.setValue( expression ); } - - [ { result.setUsingFormatJson( true ); } ] + )* + | + LOOKAHEAD({ !createContext }) + ( + LOOKAHEAD(IndexSpecOption(), { !(getToken(1).kind == K_USING && getToken(2).kind == K_INDEX) }) + option=IndexSpecOption() { options.add(option); } + )* + ) +} - [ - LOOKAHEAD(2) ( - { result.setOnNullType( JsonAggregateOnNullType.NULL ); } - ) - | - ( - { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } - ) - ] +void PostgreSqlConstraintOptions(IndexOptionSource index): +{ + List columns; +} +{ + [ columns=ColumnsNamesList() { index.setIncludeColumns(columns); } ] + PostgreSqlIndexStorageOptions(index) +} - [ - ( - { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITH ); } - ) - | - ( - { result.setUniqueKeysType( JsonAggregateUniqueKeysType.WITHOUT ); } - ) - ] - ")" - ) - | - ( - - "(" { result.setType( JsonFunctionType.ARRAY ); } - expression=Expression() { result.setExpression( expression ); } - [ { result.setUsingFormatJson( true ); } ] - [ expressionOrderByList = OrderByElements() { result.setExpressionOrderByElements( expressionOrderByList ); } ] +/** Column keys share storage/tablespace options, but do not allow INCLUDE. */ +void PostgreSqlIndexStorageOptions(IndexOptionSource index): +{ + List parameters; + String tableSpace; +} +{ + [ LOOKAHEAD(2) parameters=PostgreSqlIndexOptions() { index.setStorageParameters(parameters); } ] + [ LOOKAHEAD(3) tableSpace=RelObjectName() { + index.setTableSpace(tableSpace); + } ] +} - [ - LOOKAHEAD(2) ( - { result.setOnNullType( JsonAggregateOnNullType.NULL ); } - ) - | - ( - { result.setOnNullType( JsonAggregateOnNullType.ABSENT ); } - ) - ] +void PostgreSqlConstraintAttributes(TableElement element): +{ + NamedConstraint constraint = element instanceof NamedConstraint ? (NamedConstraint) element : null; + ConstraintAttributes attributes; +} +{ + attributes=PostgreSqlConstraintAttributeList(constraint == null ? null : constraint.getConstraintAttributes()) + ( LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_NO && "INHERIT".equalsIgnoreCase(getToken(2).image) }) + TypeDdlKeyword("INHERIT") { + requireDdlSyntax(constraint instanceof CheckConstraint && !((CheckConstraint) constraint).isNoInherit(), + "NO INHERIT requires a CHECK constraint and cannot be repeated"); + ((CheckConstraint) constraint).setNoInherit(true); + } + attributes=PostgreSqlConstraintAttributeList(attributes) + )* + { + requireDdlSyntax(attributes == null || attributes.getEnforced() == null + || constraint instanceof CheckConstraint || constraint instanceof ForeignKeyConstraint, + "ENFORCED is supported only for CHECK and foreign key constraints"); + if (constraint != null) { + constraint.setConstraintAttributes(attributes); + } else if (attributes != null) { + // Retain permissive legacy index syntax without treating indexes as constraints. + StringBuilder suffix = new StringBuilder(); + attributes.appendTo(suffix); + ((Index) element).getTailParameters().add(suffix.toString().trim()); + } + } +} - ")" - ) - ) +/** Shared attribute parsing for table constraints and column REFERENCES clauses. */ +ConstraintAttributes PostgreSqlConstraintAttributeList(ConstraintAttributes attributes): +{ + boolean present = attributes != null; + boolean negative; + Boolean enforced; + Token token; +} +{ + { if (attributes == null) { attributes = new ConstraintAttributes(); } } + ( LOOKAHEAD({ isPostgreSqlConstraintAttributeAhead() }) ( + LOOKAHEAD(2) { negative = false; } + [ { negative = true; } ] { + requireDdlSyntax(attributes.getDeferrable() == null, "Duplicate DEFERRABLE clause"); + attributes.setDeferrable(!negative); present = true; + } + | + LOOKAHEAD({ isKeywordAhead("INITIALLY") }) token= { + requireDdlSyntax(attributes.getInitially() == null, "Duplicate INITIALLY clause"); + requireDdlSyntax("IMMEDIATE".equalsIgnoreCase(token.image) || "DEFERRED".equalsIgnoreCase(token.image), + "Expected IMMEDIATE or DEFERRED"); + attributes.setInitially(ConstraintAttributes.Initially.valueOf(token.image.toUpperCase(Locale.ROOT))); + present = true; + } + | + LOOKAHEAD(2) enforced=ConstraintEnforcement() { + requireDdlSyntax(attributes.getEnforced() == null, "Duplicate ENFORCED clause"); + attributes.setEnforced(enforced); present = true; + } + | + LOOKAHEAD({ getToken(1).kind == K_NOT && "VALID".equalsIgnoreCase(getToken(2).image) }) + { + requireDdlSyntax(!attributes.isNotValid(), "Duplicate NOT VALID clause"); + attributes.setNotValid(true); present = true; + } + ) )* + { return present ? attributes : null; } +} - // -- Filter - [ LOOKAHEAD(2) "(" { result.setAnalyticType(AnalyticType.FILTER_ONLY); } filter = Expression() { result.setFilterExpression( filter ); } ")" ] +Boolean ConstraintEnforcement(): +{ boolean enforced = true; } +{ + [ { enforced = false; } ] + { return enforced; } +} - // -- OVER - [ LOOKAHEAD(2) - {result.setAnalyticType(AnalyticType.OVER);} - "(" - [ - (LOOKAHEAD(3) expressionList=ComplexExpressionList() - | "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" ) - ] - [olist=OrderByElements() ] - [windowElement = WindowElement() ] - { - result.setPartitionExpressionList(expressionList, partitionByBrackets); - result.setOrderByElements(olist); - result.setWindowElement(windowElement); - } - ")" - ] - ) +/** + * Parses a single table-level constraint inside {@code CREATE TABLE (...)}. Index forms delegate + * to {@link #TableIndexSpec(boolean)} so CREATE and ALTER expose the same structured AST. + */ +TableElement CreateTableConstraint(): +{ TableElement index; } +{ index=TableConstraint(true) { return index; } } - { - return result; - } +/** 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; } } -IntervalExpression IntervalExpression() : { - IntervalExpression interval = new IntervalExpression(); - Token token = null; - Expression expr = null; - boolean signed = false; - IntervalQualifier qualifier = null; +/** Shared table-constraint body; index option boundaries depend on CREATE versus ALTER. */ +TableElement TableConstraint(boolean createContext): +{ + String constraintName = null; + TableElement index = null; + NamedConstraint namedConstraint; + ForeignKeyConstraint fkIndex = null; + CheckConstraint checkConstraint = null; } { - - ( - - LOOKAHEAD(3) ( - [ "-" {signed=true;}] - (token= | token=) - ) - | - LOOKAHEAD(2) token= + LOOKAHEAD({ isTableIndexAhead() }) index=TableIndexSpec(createContext) | - expr = Expression() - ) - { - if (expr != null) { - if (signed) expr = new SignedExpression('-', expr); - interval.setExpression(expr); - } else { - interval.setParameter((signed?"-":"") + token.image); - } - } - [ - // The entry decision for this optional block has to be stated explicitly: - // also starts whatever follows IntervalExpression() at its call sites (an alias, for - // instance), so one token of lookahead cannot decide whether to enter. - LOOKAHEAD({ getToken(1).kind == K_DATE_LITERAL || getToken(1).kind == S_IDENTIFIER }) + + [ LOOKAHEAD({ !isTableIndexAhead() && getToken(1).kind != K_FOREIGN + && getToken(1).kind != K_CHECK && getToken(1).kind != K_EXCLUDE + && !(getToken(1).kind == K_NOT && getToken(2).kind == K_NULL) }) constraintName=RelObjectName() ] ( - // Standard qualifier (field [TO field] [(precision)]) such as DAY or DAY TO SECOND. - LOOKAHEAD({ getToken(1).kind == K_DATE_LITERAL }) qualifier = IntervalQualifier() { interval.setIntervalQualifier(qualifier); } + LOOKAHEAD({ isTableIndexAhead() }) index=TableIndexSpec(createContext) { + if (index instanceof NamedConstraint) { + ((NamedConstraint) index).setUseConstraintKeyword(true); + ((NamedConstraint) index).setName(constraintName); + } + } | - // Non-standard single identifier field (e.g. MySQL `INTERVAL 1 foo`), kept for - // backwards compatibility. - token = { interval.setIntervalType(token.image); } + fkIndex=ForeignKeySpec(constraintName) { + fkIndex.setUseConstraintKeyword(true); + index = fkIndex; + } + | + checkConstraint=CheckConstraintSpec(constraintName) { + checkConstraint.setUseConstraintKeyword(true); + index = checkConstraint; + } + | + LOOKAHEAD({ isExcludeConstraintAhead() }) + namedConstraint=PostgreSqlExcludeConstraint() { namedConstraint.setName(constraintName); index = namedConstraint; } + | + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_NOT }) + namedConstraint=PostgreSqlNotNullConstraint() { namedConstraint.setName(constraintName); index = namedConstraint; } ) - ] - { - return interval; - } + | + fkIndex=ForeignKeySpec(null) { index = fkIndex; } + | + checkConstraint=CheckConstraintSpec(null) { index = checkConstraint; } + | + LOOKAHEAD({ isExcludeConstraintAhead() }) index=PostgreSqlExcludeConstraint() + | + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_NOT }) + index=PostgreSqlNotNullConstraint() + ) + PostgreSqlConstraintAttributes(index) + { return index; } } -IntervalExpression IntervalExpressionWithoutInterval(Expression expr) : { - IntervalExpression interval; - IntervalQualifier qualifier = null; - boolean signed = false; -} +/** PostgreSQL 18 adds a table-level NOT NULL with a named target column. */ +NotNullConstraint PostgreSqlNotNullConstraint(): +{ NotNullConstraint constraint = new NotNullConstraint(); String name; boolean noInherit; } { - { - interval = new IntervalExpression(false); - interval.setExpression(expr); - } - qualifier = IntervalQualifier() - { - interval.setIntervalQualifier(qualifier); - return interval; - } + name=RelObjectName() { constraint.setColumn(linkToLastToken(createColumn(name))); } + noInherit=PostgreSqlNoInheritClause() { constraint.setNoInherit(noInherit); } + { return constraint; } } -/** - * Parses an SQL interval qualifier, e.g. {@code DAY}, {@code DAY TO SECOND}, - * {@code DAY(9) TO SECOND} or {@code SECOND(2, 4)}, as defined by the SQL standard. - * Shared by {@link IntervalExpression} (DML interval literals) and by {@code ColDataType} - * (DDL {@code INTERVAL} column / cast target types). - */ -IntervalQualifier IntervalQualifier() : { - Token field = null; - Token toField = null; - Token leadingPrecision = null; - Token fractionalPrecision = null; - Token trailingFractionalPrecision = null; +NotNullConstraint PostgreSqlColumnNotNullConstraint(): +{ String name = null; boolean noInherit; } +{ + [ name=RelObjectName() ] + noInherit=PostgreSqlNoInheritClause() + { return new NotNullConstraint().withColumnConstraint(true).withName(name).withNoInherit(noInherit); } } + +boolean PostgreSqlNoInheritClause(): +{ boolean noInherit = false; } { - field = - [ - LOOKAHEAD(2) "(" leadingPrecision = - [ "," fractionalPrecision = ] - ")" - ] - [ - LOOKAHEAD(2) toField = - [ LOOKAHEAD(2) "(" trailingFractionalPrecision = ")" ] - ] - { - // SECOND(2, 4) TO SECOND(3) specifies fractional seconds precision for both the leading - // and the trailing field. Reject such contradictory input instead of silently dropping one - // of the values. The rejection is placed last so the production does not complete normally - // and JavaCC does not append an unreachable "missing return" guard. - if (fractionalPrecision == null || trailingFractionalPrecision == null) { - return new IntervalQualifier( - field != null ? field.image : null, - leadingPrecision != null ? Integer.valueOf(leadingPrecision.image) : null, - toField != null ? toField.image : null, - trailingFractionalPrecision != null - ? Integer.valueOf(trailingFractionalPrecision.image) - : (fractionalPrecision != null - ? Integer.valueOf(fractionalPrecision.image) : null)); - } - throw new ParseException( - "Invalid interval qualifier: fractional seconds precision is specified for both" - + " the leading field and the trailing field"); - } + [ LOOKAHEAD({ getToken(1).kind == K_NO && "INHERIT".equalsIgnoreCase(getToken(2).image) }) + TypeDdlKeyword("INHERIT") { noInherit = true; } ] + { return noInherit; } } -KeepExpression KeepExpression() : { - KeepExpression keep = new KeepExpression(); - Token token; - List list; +ExcludeConstraint PostgreSqlExcludeConstraint(): +{ + ExcludeConstraint constraint = new ExcludeConstraint(); + String using; + List columns = new ArrayList(); + KeyElement column; + Expression predicate; } { - "(" token = ( { keep.setFirst(true); } | { keep.setFirst(false); }) - list = OrderByElements() ")" - + + [ LOOKAHEAD(2) using=RelObjectName() { constraint.setUsing(using); } ] + [ LOOKAHEAD(2) "(" column=PostgreSqlExcludeElement() { columns.add(column); } + ( "," column=PostgreSqlExcludeElement() { columns.add(column); } )* ")" + { constraint.setColumns(columns); } ] + PostgreSqlConstraintOptions(constraint) + [ "(" predicate=Expression() ")" { constraint.setExpression(predicate); } ] { - keep.setName(token.image); - keep.setOrderByElements(list); - return keep; + requireDdlSyntax(constraint.getColumns() != null || constraint.getExpression() != null, + "Expected exclusion elements or predicate"); + return constraint; } } - -void windowFun(AnalyticExpression retval):{ - ExpressionList expressionList = null; - boolean partitionByBrackets = false; - String windowName = null; - WindowDefinition winDef; -} { +KeyElement PostgreSqlExcludeElement(): +{ + KeyElement column; + Token operator; + ExclusionOperator reference; +} +{ + column=IndexColumnWithParams() ( - {retval.setType(AnalyticType.OVER);} + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && isKeywordAhead("OPERATOR") }) + TypeDdlKeyword("OPERATOR") "(" reference=PostgreSqlOperatorReference() ")" { + reference.setUseOperatorKeyword(true); + column.setExclusionOperatorReference(reference); + } | - {retval.setType(AnalyticType.WITHIN_GROUP);} + ( operator="=" | operator= | operator= | operator="<" | operator=">" + | operator= | operator= | operator="&&" | operator="@>" | operator="<@" ) + { column.setExclusionOperator(operator.image); } ) + { return column; } +} - ( - windowName = RelObjectName() { retval.setWindowName(windowName); } - | - winDef = windowDefinition() { retval.setWindowDefinition(winDef); } - [ - LOOKAHEAD(2) "(" - [ - (LOOKAHEAD(3) expressionList=ComplexExpressionList() - | "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" ) - ] - ")" { winDef.setPartitionExpressionList(expressionList, partitionByBrackets); retval.setType(AnalyticType.WITHIN_GROUP_OVER); } - ] - ) +CreateTable CreateTable(boolean isUsingOrReplace): +{ + CreateTable createTable = new CreateTable(); + Token ofFirst; + Token executeFirst; + Table table = null; + List tableElements = new ArrayList(); + TableElement element; + List typedTableOptions = new ArrayList(); + List createOptions = new ArrayList(); + Token tk = null; + List parameter = new ArrayList(); + TableOption tableOption = null; + SpannerInterleaveIn interleaveIn = null; + Select select = null; + Execute execute; + int optionCount; + Table likeTable = null; + RowMovement rowMovement = null; + String tableColumn = null; + List columns = new ArrayList(); + TablePartitioning partitioning = null; + Table partitionOfTable = null; + PartitionBound partitionBound = null; + ColDataType ofType = null; + Table parent; + List
parents = new ArrayList
(); + ObjectNames typeName; + boolean withData; + boolean foreign = false; + ForeignTableOptions foreignOptions; } +{ + { createTable.setOrReplace(isUsingOrReplace);} + [ { createTable.setUnlogged(true); } ] -WindowDefinition windowDefinition() : { - ExpressionList expressionList = null; - List olist = null; - WindowElement windowElement = null; - boolean partitionByBrackets = false; - WindowDefinition winDef = new WindowDefinition(); -} { - "(" - [ - (LOOKAHEAD(3) expressionList=ComplexExpressionList() - | "(" {partitionByBrackets = true;} expressionList=ComplexExpressionList() ")" ) + // table options, not required but 1 or none + [ ( tk= | tk= ) { createOptions.add(tk.image);} ] + + (parameter = CreateParameter() { createOptions.addAll(parameter); })* + + { for (String opt : createOptions) { if ("FOREIGN".equalsIgnoreCase(opt)) { foreign = true; } } } + + [ LOOKAHEAD(2) { createTable.setIfNotExists(true); }] + table=Table() + [ + // BigQuery: CREATE [SNAPSHOT] TABLE target CLONE source [FOR SYSTEM_TIME AS OF ...] + LOOKAHEAD(2) likeTable=Table() + [ LOOKAHEAD(2) tableColumn=TimeTravelAfterAlias() { likeTable.setTimeTravel(tableColumn); } ] + { createTable.setCloneTable(likeTable); likeTable = null; } ] - [olist=OrderByElements() ] - [windowElement = WindowElement() ] + [ { ofFirst = getToken(1); } typeName=RelObjectNames() { + ofType = new ColDataType(); + ofType.setDataType(typeName.getNames()); + linkAST(ofType, ofFirst); + createTable.setOfType(ofType); + } ] + [ LOOKAHEAD(2) partitionOfTable=Table() + { createTable.setPartitionOf(partitionOfTable); } ] + [ LOOKAHEAD(2) ( + LOOKAHEAD("(" ")") "(" ")" { createTable.setTableElements(tableElements); } + | + LOOKAHEAD("(" RelObjectName() ("," RelObjectName())* ")") ( + "(" tableColumn=RelObjectName() { columns.add(tableColumn); } ("," tableColumn=RelObjectName() { columns.add(tableColumn); } )* ")" + ) + | + ( + "(" element=CreateTableElement(ofType != null || partitionOfTable != null) { tableElements.add(element); } + ( LOOKAHEAD(2) "," element=CreateTableElement(ofType != null || partitionOfTable != null) + { tableElements.add(element); } + )* + [ LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_COMMA && getToken(2).kind == CLOSING_BRACKET }) "," ] + + ")" + ) + ) + ] + [ LOOKAHEAD({ isKeywordAhead("INHERITS") }) ContextualKeyword("INHERITS") + "(" parent=Table() { parents.add(parent); } + ( "," parent=Table() { parents.add(parent); } )* ")" + { createTable.setInherits(parents); } ] + [ LOOKAHEAD({ partitionOfTable != null }) + partitionBound=PostgreSqlPartitionBound() + { createTable.setPartitionBound(partitionBound); } ] + [ LOOKAHEAD({ isKeywordAhead("SERVER") }) foreignOptions=ForeignTableOptions() + { requireDdlSyntax(foreign, "SERVER requires CREATE FOREIGN TABLE"); + typedTableOptions.add(TableOption.foreignServer(foreignOptions)); } ] + CreateTableOptions(typedTableOptions) + [ LOOKAHEAD( ) partitioning=CreateTablePartitioning() + { createTable.setPartitioning(partitioning); } ] + { optionCount = typedTableOptions.size(); } + CreateTableOptions(typedTableOptions) + { createTable.setTableOptionsAfterPartition(typedTableOptions.size() > optionCount); } + + // see https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_7002.htm#i2126725 + // table properties , all these are optional + [ rowMovement = RowMovement() { createTable.setRowMovement(rowMovement); }] + [ LOOKAHEAD(2) + { createTable.setUseAsKeyword(false); } + [ ( tk= | tk= ) + { createTable.setDuplicateHandling(CreateTable.DuplicateHandling.valueOf( + tk.image.toUpperCase(Locale.ROOT))); } ] + [ { createTable.setUseAsKeyword(true); } ] + ( + LOOKAHEAD(1, ) { executeFirst = getToken(1); } execute=Execute() { + linkStatement(execute, executeFirst); + requireDdlSyntax(createTable.isUseAsKeyword() && createTable.getDuplicateHandling() == null, + "CREATE TABLE EXECUTE requires AS and cannot use duplicate handling"); + createTable.setExecute(execute); + } + | + select=Select() + { createTable.setSelect(select, false); } + ) + [ LOOKAHEAD(2) withData=DataPopulation() + { createTable.setWithData(withData); } ] + ] + [ + ( LOOKAHEAD("(" Table() ")") "(" likeTable=Table() { createTable.setLikeTable(likeTable, true); } ")" + | likeTable=Table() { createTable.setLikeTable(likeTable, false); } ) + ] + [ interleaveIn = SpannerInterleaveIn( ) { createTable.setSpannerInterleaveIn(interleaveIn); } ] { - winDef.setPartitionExpressionList(expressionList, partitionByBrackets); - winDef.setOrderByElements(olist); - winDef.setWindowElement(windowElement); + createTable.setTable(table); + if (tableElements.size() > 0) + createTable.setTableElements(tableElements); + if (createOptions.size() > 0) + createTable.setCreateOptionsStrings(createOptions); + if (typedTableOptions.size() > 0) + createTable.setTableOptions(typedTableOptions); + if (!columns.isEmpty()) { + if (ofType != null || partitionOfTable != null) { + for (String name : columns) { + tableElements.add(new ColumnDefinition().withColumnName(name)); + } + createTable.setTableElements(tableElements); + } else { + createTable.setColumns(columns); + } + } + requireDdlSyntax(!foreign + || createTable.getForeignTableOptions() != null, "CREATE FOREIGN TABLE requires SERVER"); + return createTable; } - ")" - { return winDef; } } -AnalyticExpression AnalyticExpression(Function function) : +ForeignTableOptions ForeignTableOptions(): { - AnalyticExpression retval = new AnalyticExpression(function); - Expression filter = null; + ForeignTableOptions result = new ForeignTableOptions(); + String name; + List options; } { - ( - ( - filter=AggregateFilter() { retval.setType(AnalyticType.FILTER_ONLY); } - [ LOOKAHEAD(2) windowFun(retval) ] - { - if (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - && (retval.getType() == AnalyticType.WITHIN_GROUP - || retval.getType() == AnalyticType.WITHIN_GROUP_OVER)) { - throw new ParseException("FILTER must follow WITHIN GROUP"); - } - } - ) - | windowFun(retval) - [ LOOKAHEAD({ retval.getType() == AnalyticType.WITHIN_GROUP - && getToken(1).kind == K_FILTER }) filter=AggregateFilter() ] - ) + ContextualKeyword("SERVER") name=RelObjectName() { result.setServer(name); } + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ForeignDataOptions(false) { result.setOptions(options); } ] + { return result; } +} + +List ForeignDataOptions(boolean alter): +{ List options; } +{ + options=ForeignDataOptionList(alter) { - retval.setFilterExpression(filter); - if (true) { return retval; } + for (ForeignDataOption item : options) { + requireDdlSyntax(item.getValueExpression() == null || item.getValue() != null, + "Option values are string constants"); + } + return options; } } -/** Shared FILTER predicate for ordinary, window, and ordered-set aggregates. */ -Expression AggregateFilter(): -{ Expression filter; } +/** OPTIONS of CREATE SERVER and ALTER SERVER, where MySQL also takes a number, as in PORT 3306. */ +List ServerOptions(boolean alter): +{ List options; } { - "(" filter=Expression() ")" - { return filter; } + options=ForeignDataOptionList(alter) { requireServerOptions(options); return options; } } -WindowElement WindowElement(): +List ForeignDataOptionList(boolean alter): { - WindowElement windowElement = new WindowElement(); - WindowRange range = new WindowRange(); - WindowOffset offset = null; - WindowElement.Exclusion exclusion = null; + List options = new ArrayList(); + ForeignDataOption option; } { - ( { windowElement.setType(WindowElement.Type.ROWS); } - | { windowElement.setType(WindowElement.Type.RANGE); } - | { windowElement.setType(WindowElement.Type.GROUPS); }) - ( ( - { windowElement.setRange(range); } - offset = WindowOffset() { range.setStart(offset); } - offset = WindowOffset() { range.setEnd(offset); } - ) - | - offset = WindowOffset() { windowElement.setOffset(offset); } - ) - [ exclusion = FrameExclusion() { windowElement.setExclusion(exclusion); } ] - + ContextualKeyword("OPTIONS") "(" option=ForeignDataOption() { options.add(option); } + ( "," option=ForeignDataOption() { options.add(option); } )* ")" { - return windowElement; + for (ForeignDataOption item : options) { + requireDdlSyntax(alter || item.getAction() == null, "CREATE options do not allow ADD, SET or DROP"); + } + return options; } } -WindowElement.Exclusion FrameExclusion(): +ForeignDataOption ForeignDataOption(): { - WindowElement.Exclusion exclusion = null; + ForeignDataOption.Action action = null; + String name; + Token value; + Expression number; + ForeignDataOption option; } { - ( - - { exclusion = WindowElement.Exclusion.CURRENT_ROW; } - | - - { exclusion = WindowElement.Exclusion.GROUP; } - | - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("TIES") - }) - - { exclusion = WindowElement.Exclusion.TIES; } + LOOKAHEAD(1, ) name=RelObjectName() + { option = new ForeignDataOption(name, null); option.setAction(ForeignDataOption.Action.DROP); } | - - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("OTHERS") - }) - - { exclusion = WindowElement.Exclusion.NO_OTHERS; } + [ LOOKAHEAD(1) ( { action = ForeignDataOption.Action.ADD; } + | { action = ForeignDataOption.Action.SET; } ) ] + name=RelObjectName() + ( value= { option = new ForeignDataOption(name, stringValue(value)); } + | number=ServerOptionNumber() { option = new ForeignDataOption(name, null).withValueExpression(number); } ) + { option.setAction(action); } ) - { return exclusion; } + { return option; } } -WindowOffset WindowOffset(): +/** MySQL's ulong_num, the value of the PORT server option; only ServerOptions() keeps it. */ +Expression ServerOptionNumber(): +{ Token token; Expression number; } { - WindowOffset offset = new WindowOffset(); - Expression expr = null; + ( token= { number = new LongValue(token.image); } + | token= { number = new DoubleValue(token.image); } + | token= { number = new HexValue(token.image); } ) + { linkAST(number, token, token); return number; } } + +TableElement CreateTableElement(boolean typed): +{ TableElement element; } { ( - ( - ( { offset.setType(WindowOffset.Type.PRECEDING); } | - { offset.setType(WindowOffset.Type.FOLLOWING); } ) - ) - | - LOOKAHEAD(2) ( { offset.setType(WindowOffset.Type.CURRENT); } ) - | - ( expr = SimpleExpression() { - offset.setType(WindowOffset.Type.EXPR); - offset.setExpression(expr); - } - ( { offset.setType(WindowOffset.Type.PRECEDING); } | { offset.setType(WindowOffset.Type.FOLLOWING); } ) - ) - ) - - { - return offset; - } + LOOKAHEAD(1, ) element=LikeClause() + | LOOKAHEAD(3) element=CreateTableConstraint() + | element=CreateTableColumnDefinition(typed) + ) + { return element; } } -ExtractExpression ExtractExpression() : +ColumnDefinition CreateTableColumnDefinition(boolean typed): { - ExtractExpression retval = new ExtractExpression(); - String fieldName = null; - Token token = null; - Expression expr = null; + ColumnDefinition column = null; + String name; + List options = new ArrayList(); + ColumnOption option; + Token token; } { - - "(" - ( fieldName=RelObjectName() { retval.setName(fieldName); } | token= { retval.setName(token.image); } ) - - expr=SimpleExpression() { retval.setExpression(expr); } - ")" - { - return retval; - } + { if (!typed) { return ColumnDefinition(); } } + name=RelObjectName() + { column = new ColumnDefinition().withColumnName(name); } + [ LOOKAHEAD(2) token= { + if (!"OPTIONS".equalsIgnoreCase(token.image)) { + throw new ParseException("Expected OPTIONS after WITH"); + } + column.setWithOptions(true); + } ] + ( LOOKAHEAD(2) option=ColumnDefinitionOption() { options.add(option); } )* + { column.setColumnOptions(options); } + { if (true) { return column; } } } -CastExpression ImplicitCast() #ImplicitCast: +/** Reads complete options and keeps commas separate from legacy raw token groups. */ +void CreateTableOptions(List options): +{ TableOption option; } { - ColDataType colDataType; - Token tk1; - Token tk2; + [ LOOKAHEAD(2, { !isCreateTableQueryPrefix() + && !(getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY) }) + option=CreateTableOption() { options.add(option); } + ( LOOKAHEAD(2, { !isCreateTableQueryPrefix() + && !(getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY) + && !(getToken(1).kind == K_COMMA + && "INTERLEAVE".equalsIgnoreCase(getToken(2).image)) }) + [ "," ] option=CreateTableOption() { options.add(option); } + )* + ] +} - int precision = -1; - int scale = -1; +TableOption CreateTableOption(): +{ TableOption option; List tokens; List storageParameters; String name; } +{ + ( + LOOKAHEAD( "(") storageParameters=PostgreSqlIndexOptions() { + option = new TableOption(); option.setStorageParameters(storageParameters); + } + | + LOOKAHEAD({ getToken(1).kind == K_WITHOUT && "ROWID".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("ROWID") { + option = new TableOption(TableOption.Kind.WITHOUT_ROWID, "WITHOUT ROWID", null, false); + } + | + LOOKAHEAD( ) ContextualKeyword("OIDS") { + option = new TableOption(TableOption.Kind.WITHOUT_OIDS, "WITHOUT OIDS", null, false); + } + | + { option = new TableOption(TableOption.Kind.STRICT, "STRICT", null, false); } + | + LOOKAHEAD( ) option=OnCommitTableOption() + | + // USING INDEX TABLESPACE stays a raw parameter + LOOKAHEAD(2, { getToken(2).kind != K_INDEX }) name=RelObjectName() + { option = TableOption.accessMethod(name); } + | + LOOKAHEAD({ isMySqlTableOptionAhead() }) option=MySqlTableOption() + | + // Snowflake: COPY is reserved because it starts the COPY statement + LOOKAHEAD({ getToken(1).kind == K_COPY && "GRANTS".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("GRANTS") { option = TableOption.raw("COPY", "GRANTS"); } + | tokens=CreateParameter() { option = TableOption.raw(tokens); } ) + { return option; } } + +/** Temporary table ON COMMIT action, including Oracle's private temporary table forms. */ +TableOption OnCommitTableOption(): +{ TableOption.OnCommitAction action; } { - colDataType = DataType() + ( - tk2 = + { action = TableOption.OnCommitAction.DELETE_ROWS; } | - tk2 = + { action = TableOption.OnCommitAction.DROP; } + [ LOOKAHEAD({ isKeywordAhead("DEFINITION") }) ContextualKeyword("DEFINITION") + { action = TableOption.OnCommitAction.DROP_DEFINITION; } ] | - tk2 = + LOOKAHEAD({ isKeywordAhead("PRESERVE") }) ContextualKeyword("PRESERVE") + ( + { action = TableOption.OnCommitAction.PRESERVE_ROWS; } + | + ContextualKeyword("DEFINITION") { action = TableOption.OnCommitAction.PRESERVE_DEFINITION; } + ) ) - { - CastExpression castExpression = new CastExpression(colDataType, tk2.image); - return castExpression; - } + { return TableOption.onCommit(action); } } -CastExpression CastExpression(): -{ - Token keyword; - CastExpression retval; - ColumnDefinition columnDefinition; - ColDataType type; - Expression expression = null; - boolean useCastKeyword; - Token formatCharLiteral; -} -{ +TableOption MySqlTableOption(): { + Token tk; + Token tk2 = null; + String value = null; + List
unionTables = null; + Table unionTable; + boolean useEquals = false; + String name = ""; + TableOption.Kind kind = null; + TableOption option; + ColumnOption.Storage storage = null; + StringValue comment = null; +} { ( - keyword= + tk= { name = tk.image; kind = TableOption.Kind.UNION; + unionTables = new ArrayList
(); } + [ "=" { useEquals = true; } ] + "(" [ unionTable=Table() { unionTables.add(unionTable); } + ( "," unionTable=Table() { unionTables.add(unionTable); } )* ] ")" | - keyword= + LOOKAHEAD({ isMySqlStatisticsOptionAhead() }) tk= { + name = tk.image; + kind = TableOption.Kind.valueOf(name.toUpperCase(Locale.ROOT)); + } + [ "=" { useEquals = true; } ] + ( tk= | tk= ) { value = tk.image; + requireDdlSyntax(kind == TableOption.Kind.STATS_SAMPLE_PAGES + || "DEFAULT".equalsIgnoreCase(value) || "0".equals(value) || "1".equals(value), + "Expected DEFAULT, 0, or 1 for " + name); + } | - keyword= + LOOKAHEAD({ isKeywordAhead("ROW_FORMAT") }) ContextualKeyword("ROW_FORMAT") + { name = "ROW_FORMAT"; kind = TableOption.Kind.ROW_FORMAT; } + [ "=" { useEquals = true; } ] value=RelObjectName() { + requireDdlSyntax(Arrays.asList("DEFAULT", "DYNAMIC", "FIXED", "COMPRESSED", "REDUNDANT", "COMPACT") + .contains(value.toUpperCase(Locale.ROOT)), "Invalid MySQL ROW_FORMAT"); + } | - keyword= - ) - { - retval = new CastExpression(keyword.image); - } - "(" - expression=SimpleExpression() - { retval.setUseCastKeyword(true); } - ( - LOOKAHEAD(2) ( - - "(" - columnDefinition=ColumnDefinition() { retval.addColumnDefinition(columnDefinition); } - ( "," columnDefinition=ColumnDefinition() { retval.addColumnDefinition(columnDefinition); } )* - ")" + LOOKAHEAD({ isMySqlScalarTableOptionAhead() }) option=MySqlScalarTableOption() + { return option; } + | + { name = "TABLESPACE"; kind = TableOption.Kind.TABLESPACE; } + [ "=" { useEquals = true; } ] value=RelObjectName() + [ LOOKAHEAD(2) tk= { + requireDdlSyntax("DISK".equalsIgnoreCase(tk.image) || "MEMORY".equalsIgnoreCase(tk.image), + "Expected DISK or MEMORY after STORAGE"); + storage = ColumnOption.Storage.valueOf(tk.image.toUpperCase(Locale.ROOT)); + } ] + | + tk= { + name = tk.image; + kind = TableOption.Kind.ENGINE; + } + [ "=" { useEquals = true; } ] + value=MySqlTableOptionValue() + | + [ tk= { name = tk.image + " "; } ] + ( + tk= tk2= { + name += tk.image + " " + tk2.image; + } + | + tk= tk2= { + name += tk.image + " " + tk2.image; + } + | + tk= { name += tk.image; } + | + tk= { + name += tk.image; + kind = TableOption.Kind.COLLATE; + } ) + { if (kind == null) { kind = TableOption.Kind.CHARACTER_SET; } } + [ "=" { useEquals = true; } ] + value=MySqlTableOptionValue() | + tk= { + name = tk.image; + kind = TableOption.Kind.COMMENT; + } + [ "=" { useEquals = true; } ] + // A string literal keeps its escaping; other values remain plain text ( - type=ColDataType() { retval.setColDataType(type); } - // MySQL casts to an array of the given type when a multi-valued index key part is - // defined, e.g. CAST(data->'$.zips' AS UNSIGNED ARRAY). ARRAY reads as a further - // word of the type, the way INT UNSIGNED already does. - [ { type.setDataType(type.getDataType() + " ARRAY"); } ] + LOOKAHEAD({ getToken(1).kind == S_CHAR_LITERAL }) tk= + { comment = stringValue(tk); } + | value=MySqlTableOptionValue() ) ) - - // BigQuery FORMAT clause - // https://cloud.google.com/bigquery/docs/reference/standard-sql/conversion_functions#cast_as_date - [ formatCharLiteral= { retval.setFormat(formatCharLiteral.image); } ] - - ")" - { - retval.setLeftExpression(expression); - return retval; + option = new TableOption(kind, name, value, useEquals); + if (comment != null) { option.setComment(comment); } + if (unionTables != null) { option.setUnionTables(unionTables); } + option.setTablespaceStorage(storage); + return option; } } -Expression CaseWhenExpression() #CaseWhenExpression: +/** Shared CREATE/ALTER table options with option-specific value syntax. */ +TableOption MySqlScalarTableOption(): { - CaseExpression caseExp = new CaseExpression(); - Expression switchExp = null; - WhenClause clause; - List whenClauses = new ArrayList(); - Expression elseExp = null; + Token token; + String name; + String value; + TableOption.Kind kind; + boolean useEquals = false; + TableOption additional; } { - { caseCounter++; } - [ LOOKAHEAD(2) switchExp=Expression() ] - ( clause=WhenThenSearchCondition() { whenClauses.add(clause); } )+ - [ - + ( + LOOKAHEAD({ isMySqlNumericTableOptionAhead() }) + ( token= | token= | token= | token= ) { + name = token.image.toUpperCase(Locale.ROOT); kind = TableOption.Kind.valueOf(name); + } + [ "=" { useEquals = true; } ] token= { value = token.image; } + | + LOOKAHEAD({ isMySqlAdditionalTableOptionAhead() }) additional=MySqlAdditionalTableOption() + { name = additional.getName(); kind = additional.getKind(); + value = additional.getValue(); useEquals = additional.isUseEquals(); } + | + { name = "AUTO_INCREMENT"; kind = TableOption.Kind.AUTO_INCREMENT; } + [ "=" { useEquals = true; } ] token= { value = token.image; } + | ( - LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) elseExp=Expression() - | elseExp=SimpleExpression() + { name = "ENCRYPTION"; kind = TableOption.Kind.ENCRYPTION; } + | { name = "PASSWORD"; kind = TableOption.Kind.PASSWORD; } + | { name = "DATA DIRECTORY"; kind = TableOption.Kind.DATA_DIRECTORY; } + | { name = "INDEX DIRECTORY"; kind = TableOption.Kind.INDEX_DIRECTORY; } + | LOOKAHEAD({ isMySqlEngineAttributeAhead() }) token= { + name = token.image.toUpperCase(Locale.ROOT); + kind = TableOption.Kind.valueOf(name); + } ) - ] - { caseCounter--; } - { - caseExp.setSwitchExpression(switchExp); - caseExp.setWhenClauses(whenClauses); - caseExp.setElseExpression(elseExp); - return caseExp; - } + [ "=" { useEquals = true; } ] token= { value = token.image; } + ) + { return new TableOption(kind, name, value, useEquals); } } -WhenClause WhenThenSearchCondition(): +TableOption MySqlAdditionalTableOption(): { - WhenClause whenThen = new WhenClause(); - Expression whenExp; - Expression thenExp; + Token token; + String name; + String value; + boolean useEquals = false; } { - whenExp=Expression() - ( - LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) thenExp=Expression() + LOOKAHEAD({ isKeywordAhead("SECONDARY_ENGINE") }) + token= { name = token.image.toUpperCase(Locale.ROOT); } + [ "=" { useEquals = true; } ] + ( token= { value = token.image; } | token= { value = token.image; } | value=RelObjectName() ) | - thenExp=SimpleExpression() + LOOKAHEAD({ isKeywordAhead("INSERT_METHOD") }) + token= { name = token.image.toUpperCase(Locale.ROOT); } + [ "=" { useEquals = true; } ] + ( token= | token= | token= ) { value = token.image; } + | + LOOKAHEAD({ isKeywordAhead("PACK_KEYS") }) + token= { name = token.image.toUpperCase(Locale.ROOT); } + [ "=" { useEquals = true; } ] + ( token= | token= ) { + value = token.image; + if (token.kind == S_LONG && !"0".equals(value) && !"1".equals(value)) { + throw new ParseException("PACK_KEYS requires 0, 1 or DEFAULT"); + } + } + | + LOOKAHEAD({ isKeywordAhead("AUTOEXTEND_SIZE") }) + token= { name = token.image.toUpperCase(Locale.ROOT); } + [ "=" { useEquals = true; } ] + value=MySqlSizeNumber() + | + LOOKAHEAD({ isKeywordAhead("CHECKSUM") || isKeywordAhead("DELAY_KEY_WRITE") }) + ( token= | token= ) { name = token.image.toUpperCase(Locale.ROOT); } + [ "=" { useEquals = true; } ] + token= { value = token.image; } + | + token= { name = token.image.toUpperCase(Locale.ROOT); } + [ "=" { useEquals = true; } ] + token= { value = token.image; } ) - { - whenThen.setWhenExpression(whenExp); - whenThen.setThenExpression(thenExp); - return whenThen; - } + { if (true) { return new TableOption(TableOption.Kind.valueOf(name), name, value, useEquals); } } } -RowConstructor RowConstructor(): { - Token token; - ParenthesedExpressionList expressions; -} { - token= - expressions = ParenthesedExpressionList() +String MySqlSizeNumber(): +{ + Token number; +} +{ + ( number= | number= ) { - return new RowConstructor(token.image, expressions); + requireDdlSyntax(number.kind == S_LONG || number.image.matches("[0-9]+[kKmMgG]"), + "Expected an unsigned size with an optional K, M or G suffix"); + return number.image; } } -/** -TODO: VariableExpression should be a standalone class with more operations available. -*/ -EqualsTo VariableExpression(): { - Expression left; - Expression right; -} { - left = UserVariable() "=" right = SimpleExpression() - { - EqualsTo equals = new EqualsTo(); - equals.setLeftExpression(left); - equals.setRightExpression(right); - return equals; +/** Adapts CREATE's option nodes to the existing ALTER option APIs. */ +AlterExpression AlterSharedTableOption(): +{ + TableOption option; + TableOption collation = null; + AlterExpressionCharset charset; + AlterExpressionTableOption action; +} +{ + option=MySqlTableOption() + [ LOOKAHEAD({ option.getKind() == TableOption.Kind.CHARACTER_SET && getToken(1).kind == K_COLLATE }) + collation=MySqlTableOption() ] + { + if (option.getKind() == TableOption.Kind.CHARACTER_SET || option.getKind() == TableOption.Kind.COLLATE) { + charset = new AlterExpressionCharset(); + boolean useDefault = option.getName().toUpperCase(Locale.ROOT).startsWith("DEFAULT "); + if (option.getKind() == TableOption.Kind.CHARACTER_SET) { + charset.setOperation(AlterOperation.CONVERT); + charset.setConvertType(useDefault ? AlterExpression.ConvertType.DEFAULT_CHARACTER_SET + : AlterExpression.ConvertType.CHARACTER_SET); + charset.setCharacterSet(option.getValue()); + charset.setUseCharsetKeyword(option.getName().toUpperCase(Locale.ROOT).endsWith("CHARSET")); + charset.setHasEqualForCharacterSet(option.isUseEquals()); + if (collation != null) { + charset.setCollation(collation.getValue()); + charset.setHasEqualForCollate(collation.isUseEquals()); + } + } else { + charset.setOperation(AlterOperation.COLLATE); + charset.setCollation(option.getValue()); + charset.setHasEqualForCollate(option.isUseEquals()); + charset.setDefaultCollateSpecified(useDefault); + } + return charset; + } + action = new AlterExpressionTableOption(); + action.setStructuredTableOption(option); + return action; } } -Execute Execute(): { - ObjectNames funcName; - ExpressionList expressionList; - Execute execute = new Execute(); -} +AlterExpressionOrderBy MySqlAlterOrderBy(): +{ AlterExpressionOrderBy action = new AlterExpressionOrderBy(); OrderByElement element; } { - ( { execute.setExecType(Execute.ExecType.EXEC); } - | { execute.setExecType(Execute.ExecType.EXECUTE); } - | { execute.setExecType(Execute.ExecType.CALL); } ) - - // A colon starts a bind argument here; it must not join the procedure name. - funcName=ColumnIdentifier() { execute.setName(funcName.getNames()); } - [ LOOKAHEAD(2) expressionList=ExecuteArguments() { execute.setExprList(expressionList); } ] - { return execute; } + element=MySqlAlterOrderColumn() { action.getOrderByElements().add(element); } + ( LOOKAHEAD(1) "," element=MySqlAlterOrderColumn() { action.getOrderByElements().add(element); } )* + { return action; } } -ExpressionList ExecuteArguments(): { - ExpressionList arguments = new ExpressionList(); - Expression argument; -} +OrderByElement MySqlAlterOrderColumn(): +{ OrderByElement element = new OrderByElement(); String name; Token order; Token first = getToken(1); } { + name=RelObjectName() { element.setExpression(linkToLastToken(createColumn(name))); } + [ LOOKAHEAD(2) ( order= | order= ) { element.setAsc(order.kind == K_ASC); element.setAscDescPresent(true); } ] + { linkAST(element, first); return element; } +} + +String MySqlTableOptionValue(): { + Token token; + String value = null; +} { ( - LOOKAHEAD("(") arguments=ExpressionList() - | - argument=ExecuteArgument() { arguments.add(argument); } - ( "," argument=ExecuteArgument() { arguments.add(argument); } )* + value=RelObjectName() + | token= { value = token.image; } + | token= { value = token.image; } + | token= { value = token.image; } + | token= { value = token.image; } + | token= { value = token.image; } ) - { return arguments; } + { return value; } } -Expression ExecuteArgument(): { - Expression argument; - boolean output = false; +SpannerInterleaveIn SpannerInterleaveIn(): +{ + Table table = null; + SpannerInterleaveIn.OnDelete action = null; } { - argument=Expression() + table = Table() [ - LOOKAHEAD({ isAccessKeywordAhead("OUTPUT") || isAccessKeywordAhead("OUT") }) - ( | AccessKeyword("OUT") ) - { output = true; } + + ( + { action = SpannerInterleaveIn.OnDelete.NO_ACTION; } + | { action = SpannerInterleaveIn.OnDelete.CASCADE; } + ) ] - { return output ? createOutputArgument(argument) : argument; } - + { + return new SpannerInterleaveIn(table, action); + } } -FullTextSearch FullTextSearch() : { - Token searchModifier; - Expression againstValue; - FullTextSearch fs = new FullTextSearch(); - ExpressionList matchedColumns; + +ColDataType DataType(): +{ + ColDataType colDataType = new ColDataType(); + Token prefix = null; + Token tk = null; + Token tk2 = null; + String schema; + String type=""; + List argumentsStringList = new ArrayList(); + List array = new ArrayList(); + List name; + ColDataType arrayType; + Integer zonePrecision = null; + + String precision = null; + Integer scale = null; + String scaleText; + Token first = getToken(1); } { - "(" matchedColumns=ColumnList() ")" - "(" - againstValue=SimpleExpression() { fs.setAgainstValue(againstValue); } - [ + ( + LOOKAHEAD(2) tk= { + type = tk.image; + return linked(ColDataType.fromTypeParameters(type, precision, scale), first); + } + | + LOOKAHEAD(2) tk= ( + ("<" arrayType = ColDataType() ">") { + colDataType.setDataType("ARRAY<" + arrayType.getDataType() + ">"); + } + ) + | ( - searchModifier="IN NATURAL LANGUAGE MODE" - | searchModifier="IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION" - | searchModifier="IN BOOLEAN MODE" - | searchModifier="WITH QUERY EXPANSION" + ( tk= | tk= | tk = | tk = | tk = + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= ) + { + type = tk.image; + // A DT_ZONE image already contains its parameter, e.g. "TIMESTAMP(3) WITH TIME ZONE". + zonePrecision = tk.kind == DT_ZONE ? zonedTypePrecision(tk.image) : null; + } + ( + // Signedness is parsed by ColDataType after optional precision/scale. Do not + // consume CHARACTER when it starts the trailing CHARACTER SET clause. + LOOKAHEAD(2, { getToken(1).kind != K_CHARACTER || getToken(2).kind != K_SET }) + ( tk = + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= ) { type += " " + tk.image; } + )* + [ + LOOKAHEAD(2) "(" ( tk= { precision = tk.image; } | tk= { precision = "MAX"; } + // Oracle's NUMBER(*, s) and NUMBER(*) + | "*" { precision = "*"; requireDdlSyntax("NUMBER".equalsIgnoreCase(type), + "Wildcard precision is only supported for NUMBER"); } ) + [ | ] + [ "," scaleText=SignedIntegerTypeArgument() { scale = Integer.valueOf(scaleText); } ] + ")" + ] + { + colDataType = ColDataType.fromTypeParameters(type, precision, scale); + if (zonePrecision != null) { + colDataType.setPrecision(zonePrecision); + } + } ) - { fs.setSearchModifier(searchModifier.image); } - ] - ")" - { - fs.setMatchColumns(matchedColumns); - return fs; - } -} - -LambdaExpression LambdaExpression() #LambdaExpression: -{ - ExpressionList columns; - String s; - Expression expression; - LambdaExpression lambdaExpression; -} -{ - ( - columns = ParenthesedColumnList() - | - s = RelObjectName() { columns = new ExpressionList(createColumn(s)); } ) - "->" - expression = Expression() { - lambdaExpression = LambdaExpression.from(columns, expression); - linkAST(lambdaExpression,jjtThis); - return lambdaExpression; + return linked(colDataType, first); } } -RowPatternFunction RowPatternFunction() #RowPatternFunction: +/** Shared SQL large-object names; length and array suffixes stay in ColDataType. */ +String LargeObjectTypeName(): { - RowPatternFunction.EvaluationMode mode; - Function function; + Token national = null; + Token type; + Token large; + Token object; } { - ( LOOKAHEAD({ isKeywordAhead("RUNNING") }) ContextualKeyword("RUNNING") - { mode = RowPatternFunction.EvaluationMode.RUNNING; } - | { mode = RowPatternFunction.EvaluationMode.FINAL; } - ) - function=Function() - { - RowPatternFunction result = new RowPatternFunction(mode, function); - linkAST(result, jjtThis); return result; - } + [ LOOKAHEAD(1, ) national= ] + ( type= | type= | type= | type= ) + large= object= + { return (national == null ? "" : national.image + " ") + + type.image + " " + large.image + " " + object.image; } } -Function Function() #Function: +/** Type modifiers accept negative integer constants, but not unary-plus expressions. */ +String SignedIntegerTypeArgument(): { - Function function; + Token sign = null; + Token number; } { - ( - "{" function = InternalFunction(true) "}" - { normalizeOdbcTimestampInterval(function); } - | LOOKAHEAD(3) function = SpecialStringFunctionWithNamedParameters() - | function = InternalFunction(false) - ) - { - linkAST(function,jjtThis); - return function; - } + [ sign="-" ] number= + { return (sign == null ? "" : sign.image) + number.image; } } -Function SpecialStringFunctionWithNamedParameters() : +/** + * The type of MySQL's WEIGHT_STRING(str AS {CHAR | BINARY}(n)): one of the two type names and a + * length, which the server requires and allows nothing else with. It is built like the same type + * in CAST. + */ +ColDataType WeightStringCastType(): { - Token funcName; - NamedExpressionList namedExpressionList = null; - ExpressionList expressionList = null; - List orderByList; + Token type; + Token length; + Token first = getToken(1); } { - funcName = - - "(" - ( - LOOKAHEAD( { isNamedExprListAhead() } ) namedExpressionList = NamedExpressionListExprFirst() - | - expressionList=ExpressionList() - ) - ")" - + ( type= | type= ) "(" length= ")" { - return new Function() - .withName(funcName.image) - .withNamedParameters(namedExpressionList) - .withParameters(expressionList); - } -} - -JAVACODE -List consumeKeywordArguments() { - List args = null; - while (isKeywordArgumentAhead()) { - String name = getNextToken().image; - ExpressionList exprList = SimpleExpressionList(); - if (args == null) { - args = new ArrayList(); - } - Expression value = exprList.size() == 1 - ? (Expression) exprList.get(0) - : exprList; - args.add(new Function.KeywordArgument(name, value)); + return linked(ColDataType.fromTypeParameters(type.image, length.image, null), first); } - return args; } -Function InternalFunction(boolean escaped): +ColDataType ColDataType(): { - Token prefixToken = null; - Function retval = new Function(); - ObjectNames funcName; - ExpressionList expressionList = null; - ExpressionList chainedExpressionList = null; - KeepExpression keep = null; - Expression expr = null; - Expression attributeExpression = null; - Column attributeColumn = null; - Token attributeToken = null; - Limit limit; - List orderByList = null; - List keywordArgs = null; + ColDataType colDataType = new ColDataType(); + Token prefix = null; + Token tk = null; + Token tk2 = null; + String schema; + String type=""; + List argumentsStringList = new ArrayList(); + List array = new ArrayList(); + List name; + ColDataType arrayType; + ColDataType nestedType = null; + String numericArgument = null; + IntervalQualifier intervalQualifier = null; + Integer zonePrecision = null; + + int precision = -1; + int scale = -1; + Token national = null; + Token nationalType = null; + Token varying = null; + ColDataType.TypeModifier typeModifier = null; + XmlTypeModifier xmlTypeModifier = null; + Token first = getToken(1); } { - [ LOOKAHEAD(2) prefixToken = ] - funcName = RelObjectNames() { if (prefixToken!=null) funcName.getNames().add(0, prefixToken.image ); retval.setName(funcName.getNames()); } - - "(" { consumeXmlLeadingKeyword(retval); } - [ - LOOKAHEAD(2) [ - LOOKAHEAD(2) ( - { retval.setDistinct(true); } - | { retval.setAllColumns(true); } - | { retval.setUnique(true); } - ) - ] + ( + LOOKAHEAD({ isLargeObjectTypeAhead() }) type=LargeObjectTypeName() + { colDataType.setDataType(type); } + | + LOOKAHEAD({ isXmlTypeName(getToken(1).image) && "(".equals(getToken(2).image) }) + ( tk= | tk= ) + { colDataType.setDataType(tk.image); } + xmlTypeModifier = XmlTypeModifier() { colDataType.setXmlTypeModifier(xmlTypeModifier); } + | ( - LOOKAHEAD(3) expressionList = FunctionArgumentList(retval) - - | - // The probe above is syntactic and cannot see through the Pratt operator - // loop, so it fails on arguments such as "( 1 + a ) / ( 1 + b )" and used - // to fall through to Select(), reporting "Encountered ... - // was expecting ". Select() is only reachable here for a bare - // sub-select, so decide on that instead. - LOOKAHEAD({ !isUnparenthesizedSelectAhead() }) expressionList = FunctionArgumentList(retval) - - | - LOOKAHEAD({ !getAsBoolean(Feature.allowUnparenthesizedSubSelects) }) expr = Select() { expressionList = new ExpressionList(expr); } + + "(" + type = RelObjectNameExt() + colDataType = ColDataType() { argumentsStringList.add( type + " " + colDataType.toString()); } + ( + "," + type = RelObjectNameExt() + colDataType = ColDataType() { argumentsStringList.add( type + " " + colDataType.toString()); } + )* + ")" { colDataType = new ColDataType("STRUCT"); } ) - ] - - [ - ( - expr = Expression() { retval.setHavingClause( "MIN", expr ); } - | - expr = Expression() { retval.setHavingClause( "MAX", expr ); } + | + LOOKAHEAD({ isKeywordAhead("NATIONAL") }) ( + national= + (nationalType= | nationalType= | nationalType=) + [ LOOKAHEAD({ isKeywordAhead("VARYING") }) varying= ] + { + type = national.image + " " + nationalType.image + + (varying != null ? " " + varying.image : ""); + colDataType.setDataType(type); + colDataType.setNationalCharacterType( + nationalType.image.equalsIgnoreCase("VARCHAR") || varying != null + ? ColDataType.NationalCharacterType.VARCHAR + : ColDataType.NationalCharacterType.CHAR); + } ) - ] + | + LOOKAHEAD(2) ( + colDataType = DataType() + { + if (isMySqlDialect() + && colDataType.getDataType().toUpperCase(Locale.ROOT).startsWith("NCHAR")) { + colDataType.setNationalCharacterType( + colDataType.getDataType().toUpperCase(Locale.ROOT).contains("VARCHAR") + ? ColDataType.NationalCharacterType.VARCHAR + : ColDataType.NationalCharacterType.CHAR); + } else if (isMySqlDialect() && colDataType.getDataType().toUpperCase(Locale.ROOT) + .startsWith("NVARCHAR")) { + colDataType.setNationalCharacterType(ColDataType.NationalCharacterType.VARCHAR); + } + } + ) + | + ( + tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + | tk= + // PostgreSQL's geometric type + | tk= + // Oracle's RAW(n) + | tk= + // Snowflake's semi-structured ARRAY type, e.g. value:path::ARRAY + | tk= + ) + { + schema = tk.image; + // A DT_ZONE image already contains its parameter, e.g. "TIMESTAMP(3) WITH TIME ZONE". + zonePrecision = tk.kind == DT_ZONE ? zonedTypePrecision(tk.image) : null; + } + + // Consume an optional INTERVAL qualifier such as `hour to minute` or + // `day(9) to second`. Only applicable when the matched type is an INTERVAL and + // is immediately followed by a field word, so other types (and the existing + // `interval (2)` precision form handled below) are unaffected. + [ + LOOKAHEAD({ "interval".equalsIgnoreCase(schema) + && getToken(1).kind == K_DATE_LITERAL }) + intervalQualifier = IntervalQualifier() { colDataType.setIntervalQualifier(intervalQualifier); } + ] + [ LOOKAHEAD(2) "." arrayType = ColDataType() { + schema += "." + arrayType.getDataType(); + // Retain the nested type's structured suffixes instead of flattening them into its name. + colDataType = arrayType; + } ] + { colDataType.setDataType(schema); } + ) [ + LOOKAHEAD(2) "(" ( - { retval.setNullHandling(Function.NullHandling.IGNORE_NULLS); } - ) - | - ( - { retval.setNullHandling(Function.NullHandling.RESPECT_NULLS); } - ) - ] + { tk2 = null; numericArgument = null; } + ( + LOOKAHEAD(( | ) "(") nestedType=ColDataType() + | + ( + ( + ( numericArgument=SignedIntegerTypeArgument() | tk= ) [ LOOKAHEAD(2) (tk2= | tk2=) ] + ) + | + tk= + | + tk= + | + // DuckDB parameterises types with other types: MAP(VARCHAR, INTEGER) + tk= + | + tk= + | + tk="*" { requireDdlSyntax("VECTOR".equalsIgnoreCase(colDataType.getDataType()), + "Wildcard type arguments are only supported for VECTOR"); } + ) + ) + { + if (nestedType != null) { + argumentsStringList.add(nestedType.toString()); + nestedType = null; + } else { + argumentsStringList.add((numericArgument != null ? numericArgument : tk.image) + + (tk2 != null ? " " + tk2.image : "")); + } + } - // BigQuery orders aggregate arguments after the null handling: - // ARRAY_AGG(expr [IGNORE NULLS] [ORDER BY key] [LIMIT n]) - [ - LOOKAHEAD(2) orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } + [ "," ] + )* + ")" ] - + ( LOOKAHEAD(1) typeModifier=MySqlTypeModifier() + { colDataType.addTypeModifier(typeModifier); } )* + ( + LOOKAHEAD(1, ) { tk = null; } + [ LOOKAHEAD(2) "[" tk= "]" ] { + array.add(tk == null ? null : Integer.valueOf(tk.image)); + colDataType.setArrayData(array); + colDataType.setUsingArrayKeyword(true); + } + | + [ LOOKAHEAD(2) ( LOOKAHEAD(2) "[" {tk=null;} [ tk= ] + { array.add(tk!=null?Integer.valueOf(tk.image):null); } "]" )+ + { colDataType.setArrayData(array); } ] + ) [ - limit = PlainLimit() { retval.setLimit(limit); } + LOOKAHEAD({ (getToken(1).kind == K_CHARACTER && getToken(2).kind == K_SET) + || isKeywordAhead("CHARSET") }) TypeCharacterSet(colDataType) + | + LOOKAHEAD({ Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + && (isKeywordAhead("ASCII") || isKeywordAhead("UNICODE")) }) + tk= + { colDataType.setCharacterSetSyntax( + ColDataType.CharacterSetSyntax.valueOf(tk.image.toUpperCase(Locale.ROOT))); } ] { - keywordArgs = consumeKeywordArguments(); + requireDdlSyntax(colDataType.getXmlTypeModifier() == null || argumentsStringList.isEmpty(), + "Typed XML cannot have additional type arguments"); + if (argumentsStringList.size() > 0) { + colDataType.setArgumentsStringList(argumentsStringList); + // Integer arguments expose numeric parameters, including negative scales. + if (argumentsStringList.size() == 1 && argumentsStringList.get(0).matches("\\d+")) { + colDataType.setNumericPrecision(new java.math.BigInteger(argumentsStringList.get(0))); + } else if (argumentsStringList.size() == 2 && argumentsStringList.get(0).matches("\\d+") + && argumentsStringList.get(1).matches("-?\\d+")) { + colDataType.setNumericPrecision(new java.math.BigInteger(argumentsStringList.get(0))); + colDataType.setScale(Integer.valueOf(argumentsStringList.get(1))); + } + } + if (zonePrecision != null) { + colDataType.setPrecision(zonePrecision); + } + linkAST(colDataType, first); + return colDataType; } +} - ")" +/** Shared by column definitions, casts and other uses of ColDataType. */ +void TypeCharacterSet(ColDataType type): +{ + Token name; + boolean abbreviated = false; +} +{ + ( + | LOOKAHEAD({ isKeywordAhead("CHARSET") }) { abbreviated = true; } ) + name=CharacterSetName() + { type.setCharacterSet(name.image); type.setUseCharsetKeyword(abbreviated); } +} - [ - LOOKAHEAD(2) "(" chainedExpressionList = ExpressionList() ")" +/** A MySQL character set or collation name: an identifier, BINARY or a quoted name. */ +Token CharacterSetName(): +{ Token name; } +{ + ( name= | name= | name= | name= ) + { return name; } +} + +XmlTypeModifier XmlTypeModifier(): +{ + XmlTypeModifier.Kind kind = null; + List names = new ArrayList(); + String name; + Token token; +} +{ + "(" + [ LOOKAHEAD({ (isKeywordAhead("CONTENT") || isKeywordAhead("DOCUMENT")) + && !".".equals(getToken(2).image) && !")".equals(getToken(2).image) }) + token= { kind = XmlTypeModifier.Kind.valueOf(token.image.toUpperCase(Locale.ROOT)); } ] + name=RelObjectName() { names.add(name); } + [ "." name=RelObjectNameExt() { names.add(name); } ] + ")" + { return new XmlTypeModifier(kind, names); } +} +ColDataType.TypeModifier MySqlTypeModifier(): +{ + ColDataType.TypeModifier modifier; +} +{ + ( + { modifier = ColDataType.TypeModifier.SIGNED; } + | { modifier = ColDataType.TypeModifier.UNSIGNED; } + | { modifier = ColDataType.TypeModifier.ZEROFILL; } + ) + { return modifier; } +} +/** + * Parses MySQL/MariaDB CHECK, CHECKSUM, OPTIMIZE and REPAIR TABLE statements. Options are accepted + * only for the operation that defines them, without reserving the option words. + */ +TableMaintenanceStatement TableMaintenanceStatement(): +{ + TableMaintenanceStatement statement = new TableMaintenanceStatement(); + TableMaintenanceStatement.Operation operation = null; + TableMaintenanceStatement.Option option = null; + TableMaintenanceStatement.Modifier modifier; + Token word = null; + Table table = null; +} +{ + ( + { operation = TableMaintenanceStatement.Operation.CHECK; } + | { operation = TableMaintenanceStatement.Operation.CHECKSUM; } + | { operation = TableMaintenanceStatement.Operation.OPTIMIZE; } + | { operation = TableMaintenanceStatement.Operation.REPAIR; } + ) + { statement.setOperation(operation); } [ - LOOKAHEAD(2) - ( - LOOKAHEAD({ getToken(1).kind == S_DOUBLE - && getToken(1).image.matches("\\.[0-9]+") }) - attributeToken= { - retval.setAttribute(new LongValue(attributeToken.image.substring(1))); - } - | - "." ( - // tricky lookahead since we do need to support the following constructs - // schema.f1().f2() - Function with Function Column - // schema.f1().f2.f3 - Function with Attribute Column - LOOKAHEAD( 6 ) attributeExpression=Function() { retval.setAttribute(attributeExpression); } - | - attributeColumn=Column() { retval.setAttribute(attributeColumn); } - ) - ) + LOOKAHEAD({ operation.allowsModifier() + && (getToken(1).kind == K_NO_WRITE_TO_BINLOG || getToken(1).kind == K_LOCAL) }) + modifier=BinlogModifier() { statement.setModifier(modifier); } ] - - [ LOOKAHEAD(2) ( - ( - - { - retval.setNullHandling(Function.NullHandling.IGNORE_NULLS); - retval.setIgnoreNullsOutside(true); - } - ) - | - ( - - { - retval.setNullHandling(Function.NullHandling.RESPECT_NULLS); - retval.setIgnoreNullsOutside(true); - } - ) + ( | { statement.setTablesKeyword(true); } ) + table=Table() { statement.addTables(table); } + ( "," table=Table() { statement.addTables(table); } )* + ( + LOOKAHEAD({ isTableMaintenanceOptionAhead(operation) }) + ( + ContextualKeyword("UPGRADE") + { option = TableMaintenanceStatement.Option.FOR_UPGRADE; } + | { option = TableMaintenanceStatement.Option.QUICK; } + | { option = TableMaintenanceStatement.Option.EXTENDED; } + | word= { option = TableMaintenanceStatement.Option.fromKeyword(word.image); } ) - ] - - [ LOOKAHEAD(2) keep = KeepExpression() ] - + { statement.addOptions(option); } + )* { - retval.setEscaped(escaped); - retval.setParameters(expressionList); - retval.setChainedParameters(chainedExpressionList); - retval.setName(funcName.getNames()); - retval.setKeep(keep); - retval.setKeywordArguments(keywordArgs); - return retval; + requireDdlSyntax(operation != TableMaintenanceStatement.Operation.CHECKSUM + || statement.getOptions().size() <= 1, "CHECKSUM TABLE takes QUICK or EXTENDED, not both"); + return statement; } } +/** MySQL's opt_no_write_to_binlog: NO_WRITE_TO_BINLOG or its synonym LOCAL. */ +TableMaintenanceStatement.Modifier BinlogModifier(): +{ Token modifier; } +{ + ( modifier= | modifier= ) + { return TableMaintenanceStatement.Modifier.valueOf(modifier.image.toUpperCase(Locale.ROOT)); } +} + /** - * Argument list of a Function, extracted from InternalFunction() so that it can be - * reached from more than one lookahead guard without duplicating the expansion. + * MySQL FLUSH [NO_WRITE_TO_BINLOG | LOCAL] followed by flush options or by + * {TABLE | TABLES} [tbl_name [, tbl_name] ...] [WITH READ LOCK | FOR EXPORT]. + * https://dev.mysql.com/doc/refman/8.4/en/flush.html */ -ExpressionList FunctionArgumentList(Function retval): +FlushStatement FlushStatement(): { - ExpressionList expressionList = null; - List orderByList; - String onOverflowTruncate = null; - Token overflowToken = null; - Token extraKeywordToken; + FlushStatement statement = new FlushStatement(); + TableMaintenanceStatement.Modifier modifier; + FlushOption option; + Table table; } { - { if ("XMLFOREST".equalsIgnoreCase(retval.getName())) { return XmlForestArguments(); } } - [ LOOKAHEAD(2) extraKeywordToken = { retval.setExtraKeyword(extraKeywordToken.image); } ] - expressionList=ExpressionList() - // explicit lookahead: InternalFunction accepts ORDER BY after IGNORE NULLS too - [ LOOKAHEAD(2) orderByList = OrderByElements() { retval.setOrderByElements(orderByList); } ] - - // https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/LISTAGG.html - [ - ( overflowToken= | overflowToken= ) { onOverflowTruncate=overflowToken.image; } + + [ modifier=BinlogModifier() { statement.setModifier(modifier); } ] + ( + ( { statement.setTablesKeyword(false); } | ) [ - overflowToken = { onOverflowTruncate+= " " + overflowToken.image; } - [ ( overflowToken= | overflowToken= ) { onOverflowTruncate+=" " + overflowToken.image + " COUNT"; }] + table=Table() { statement.addTables(table); } + ( "," table=Table() { statement.addTables(table); } )* ] - ] { retval.setOnOverflowTruncate(onOverflowTruncate); } - - { - return expressionList; - } + [ + // WITH without READ LOCK starts the next statement + LOOKAHEAD({ getToken(1).kind == K_WITH && getToken(2).kind == K_READ + || getToken(1).kind == K_FOR }) + ( + + { statement.setTableLock(FlushStatement.TableLock.WITH_READ_LOCK); } + | + { + requireDdlSyntax(!statement.getTables().isEmpty(), "FOR EXPORT requires a table list"); + statement.setTableLock(FlushStatement.TableLock.FOR_EXPORT); + } + ) + ] + | + option=FlushOption() { statement.addOptions(option); } + ( "," option=FlushOption() { statement.addOptions(option); } )* + ) + { return statement; } } -/** XMLFOREST keeps expressions in the ordinary function parameter list. */ -ExpressionList XmlForestArguments(): +/** A flush option of one word, or of a word and LOGS. Only RELAY LOGS names a channel. */ +FlushOption FlushOption(): { - ExpressionList arguments = new ExpressionList(); - Expression expression; + Token first = getToken(1); + Token word; + Token channel; + FlushOption option; } { - expression=XmlForestArgument() { arguments.add(expression); } - ( "," expression=XmlForestArgument() { arguments.add(expression); } )* - { return arguments; } + ( + LOOKAHEAD({ isWordSequenceAhead(2, "LOGS") }) + ( word= | word= | word= | word= ) + ContextualKeyword("LOGS") + { option = new FlushOption(flushOptionKind(word.image + " LOGS")); } + | + word= { option = new FlushOption(flushOptionKind(word.image)); } + ) + [ + ContextualKeyword("CHANNEL") channel= + { + requireDdlSyntax(option.getKind() == FlushOption.Kind.RELAY_LOGS, + "Only RELAY LOGS takes FOR CHANNEL"); + option.setChannel(stringValue(channel)); + } + ] + { linkAST(option, first); return option; } } -Expression XmlForestArgument(): +// https://dev.mysql.com/doc/refman/8.4/en/kill.html +KillStatement KillStatement(): { - Expression expression; - String name; + KillStatement statement = new KillStatement(); + Expression id; } { - expression=Expression() - [ name=RelObjectName() { expression = new AliasedExpression(expression, new Alias(name, true)); } ] - { return expression; } + + [ + LOOKAHEAD({ getToken(1).kind == K_QUERY || isKeywordAhead("CONNECTION") }) + ( + { statement.setKind(KillStatement.Kind.QUERY); } + | + ContextualKeyword("CONNECTION") { statement.setKind(KillStatement.Kind.CONNECTION); } + ) + ] + id=Expression() { statement.setProcesslistId(id); } + { return statement; } } -XMLSerializeExpr XMLSerializeExpr(): { - XMLSerializeExpr result = new XMLSerializeExpr(); - Expression expression; - List orderByElements = null; - ColDataType dataType; - Token token; +/** + * MySQL HANDLER tbl_name OPEN [[AS] alias], HANDLER name READ ... and HANDLER name CLOSE. READ + * and CLOSE take the handler name, which is unqualified. + * https://dev.mysql.com/doc/refman/8.4/en/handler.html + */ +HandlerStatement HandlerStatement(): +{ + HandlerStatement statement = new HandlerStatement(); + Table table; + String name; + boolean useAs = false; } { - "(" + ( - LOOKAHEAD({ isKeywordAhead("CONTENT") || isKeywordAhead("DOCUMENT") }) - token= - { result.setSerializationMode(XMLSerializeExpr.SerializationMode.valueOf(token.image.toUpperCase(Locale.ROOT))); } - expression=Expression() { result.setExpression(expression); } - [ dataType=ColDataType() { result.setDataType(dataType); } ] - [ token= { result.setEncoding(new StringValue(token.image)); } ] - [ token= { result.setVersion(new StringValue(token.image)); } ] - [ - LOOKAHEAD(2) token= { - requireDdlSyntax("INDENT".equalsIgnoreCase(token.image), "Expected INDENT after NO"); - result.setIndent(false); - } - | - LOOKAHEAD({ isKeywordAhead("INDENT") }) token= { result.setIndent(true); } - [ "=" token= { result.setIndentSize(new LongValue(token.image)); } ] - ] + LOOKAHEAD({ getToken(2).kind != K_READ && getToken(2).kind != K_CLOSE }) + table=Table() [ - { result.setShowDefaults(true); } - | - LOOKAHEAD({ isKeywordAhead("HIDE") }) token= - { result.setShowDefaults(false); } + [ { useAs = true; } ] + name=RelObjectName() { table.setAlias(new Alias(name, useAs)); } ] | - - "(" - "(" expression=SimpleExpression() ")" - [ orderByElements=OrderByElements() ] - ")" - dataType=ColDataType() { - result.setExpression(expression); - result.setOrderByElements(orderByElements); - result.setDataType(dataType); - } + name=RelObjectName() { table = linkToLastToken(createTable(Arrays.asList(name))); } + ( + { statement.setAction(HandlerStatement.Action.CLOSE); } + | + { statement.setAction(HandlerStatement.Action.READ); } + HandlerRead(statement) + ) ) - ")" - { return result; } + { statement.setTable(table); return statement; } } - -JsonTableFunction.JsonTablePassingClause JsonTablePassingClause() : { - Expression valueExpression; - String parameterName; +void HandlerRead(HandlerStatement statement): +{ + String index; + ExpressionList values; + Expression expression; + Limit limit; } { - valueExpression = Expression() - - parameterName = RelObjectName() + ( + LOOKAHEAD({ isHandlerIndexAhead() }) + index=RelObjectName() { statement.setIndexName(index); } + ( + HandlerKeyComparison(statement) values=ParenthesedExpressionList() + { + requireDdlSyntax(!values.isEmpty(), "HANDLER READ requires key values"); + statement.setKeyValues(values); + } + | + { statement.setDirection(HandlerStatement.Direction.FIRST); } + | { statement.setDirection(HandlerStatement.Direction.NEXT); } + | ContextualKeyword("PREV") { statement.setDirection(HandlerStatement.Direction.PREV); } + | { statement.setDirection(HandlerStatement.Direction.LAST); } + ) + | + { statement.setDirection(HandlerStatement.Direction.FIRST); } + | + { statement.setDirection(HandlerStatement.Direction.NEXT); } + ) + [ expression=WhereClause() { statement.setWhere(expression); } ] + [ + limit=LimitWithOffset() { statement.setLimit(limit); } + [ + expression=Expression() + { + requireDdlSyntax(limit.getOffset() == null, "LIMIT offset, row_count takes no OFFSET"); + statement.setOffset(new Offset().withOffset(expression)); + } + ] + ] { - return new JsonTableFunction.JsonTablePassingClause(valueExpression, parameterName); + // MySQL parses HANDLER READ with subqueries disallowed, like PURGE + requireDdlSyntax(!containsSubquery(statement.getKeyValues(), statement.getWhere(), + statement.getLimit() == null ? null : statement.getLimit().getOffset(), + statement.getLimit() == null ? null : statement.getLimit().getRowCount(), + statement.getOffset() == null ? null : statement.getOffset().getOffset()), + "HANDLER READ takes no subquery"); } } -JsonFunction.JsonOnResponseBehavior JsonTableOnEmptyBehavior() : { - JsonFunction.JsonOnResponseBehavior behavior = null; - Expression expression; - Token token; -} +void HandlerKeyComparison(HandlerStatement statement): +{ HandlerStatement.KeyComparison comparison; } { ( - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.ERROR); - } - | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.NULL); - } - | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.TRUE); - } - | - - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.FALSE); - } - | - expression = Expression() + "=" { comparison = HandlerStatement.KeyComparison.EQUALS; } + | { comparison = HandlerStatement.KeyComparison.LESS_THAN_OR_EQUALS; } + | { comparison = HandlerStatement.KeyComparison.GREATER_THAN_OR_EQUALS; } + | "<" { comparison = HandlerStatement.KeyComparison.LESS_THAN; } + | ">" { comparison = HandlerStatement.KeyComparison.GREATER_THAN; } + ) + { statement.setKeyComparison(comparison); } +} + +/** + * MySQL ANALYZE [NO_WRITE_TO_BINLOG | LOCAL] TABLE t, ... [histogram] and, with the PostgreSQL + * dialect or without a dialect, PostgreSQL {ANALYZE | ANALYSE} [(options) | VERBOSE] [target, ...]. + * SingleStatement chooses the ANALYSE spelling only by isPostgreSqlMaintenanceAhead(). + */ +Analyze Analyze(): +{ + Analyze analyze = new Analyze(); + List options; + List targets; + Column column = null; + Token token = null; + Token modifier = null; + Token histogramAction = null; + Token bucketCount = null; + Token data; +} +{ + ( | { analyze.setCommand(Analyze.Command.ANALYSE); } ) + [ + LOOKAHEAD(2) + (modifier= | modifier=) + { analyze.setModifier(Analyze.Modifier.valueOf(modifier.image.toUpperCase(Locale.ROOT))); } + ] + [ + LOOKAHEAD({ getToken(1).kind == OPENING_BRACKET && isPostgreSqlMaintenanceDialect() }) + options=UtilityOptionList() { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.DEFAULT, expression); + analyze.setOptions(options); + analyze.setParenthesizedOptions(true); } | - token = + LOOKAHEAD({ isAnalyzeVerboseAhead() }) + token= { analyze.addOptions(linkToLastToken(new UtilityOption(token.image))); } + ] + [ LOOKAHEAD(2) { analyze.setTableKeyword(true); } ] + [ LOOKAHEAD(1) targets=MaintenanceTargetList() { analyze.setTargets(targets); } ] + [ + LOOKAHEAD(2) + (histogramAction= | histogramAction=) { - if (!token.image.equalsIgnoreCase("EMPTY")) { - throw new ParseException( - "Expected EMPTY, ERROR, NULL or DEFAULT but found " + token.image); - } + analyze.setHistogramAction(Analyze.HistogramAction.valueOf( + histogramAction.image.toUpperCase(Locale.ROOT))); } + + column=Column() { analyze.addHistogramColumns(column); } + ( "," column=Column() { analyze.addHistogramColumns(column); } )* ( - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("OBJECT") }) - JsonKeyword("OBJECT") - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.EMPTY_OBJECT); + // MySQL 8.4 sets a histogram from JSON instead of sampling the column + LOOKAHEAD(2) data= { + requireDdlSyntax(histogramAction.kind == K_UPDATE, "USING DATA requires UPDATE HISTOGRAM"); + analyze.setHistogramData(stringValue(data)); } | - [ ] - { - behavior = new JsonFunction.JsonOnResponseBehavior( - JsonFunction.JsonOnResponseBehaviorType.EMPTY_ARRAY); - } + [ + LOOKAHEAD(3) + bucketCount= + { analyze.setHistogramBucketCount(Integer.valueOf(bucketCount.image)); } + ] + [ + LOOKAHEAD({ (getToken(1).kind == K_AUTO || isKeywordAhead("MANUAL")) + && getToken(2).kind == K_UPDATE }) + ( { analyze.setHistogramUpdateMode(Analyze.HistogramUpdateMode.AUTO); } + | ContextualKeyword("MANUAL") { analyze.setHistogramUpdateMode(Analyze.HistogramUpdateMode.MANUAL); } ) + { + requireDdlSyntax(histogramAction.kind == K_UPDATE, "AUTO UPDATE and MANUAL UPDATE require UPDATE HISTOGRAM"); + } + ] ) - ) + ] { - if (behavior != null) { - return behavior; - } + requireAnalyzeForm(analyze); + return analyze; } } -JsonTableFunction.JsonTableWrapperClause JsonTableWrapperClause(boolean beforePathExpr) : { - JsonTableFunction.JsonTableWrapperClause wrapperClause = - new JsonTableFunction.JsonTableWrapperClause(beforePathExpr); +/** + * PostgreSQL VACUUM, CLUSTER and CHECKPOINT, chosen by isPostgreSqlMaintenanceAhead(). The ANALYSE + * spelling, which that check accepts too, is routed to Analyze() before. + */ +Statement PostgreSqlMaintenance(): +{ + Statement statement; +} +{ + ( + LOOKAHEAD({ getToken(1).kind == K_CHECKPOINT }) + { statement = new CheckpointStatement(); } + | + LOOKAHEAD({ getToken(1).kind == K_VACUUM }) statement=Vacuum() + | + statement=Cluster() + ) + { return statement; } +} + +/** + * PostgreSQL VACUUM [(options)] [target, ...] and VACUUM [FULL] [FREEZE] [VERBOSE] [ANALYZE] + * [target, ...]. As in PostgreSQL, the four words are always options here, never table names. + */ +VacuumStatement Vacuum(): +{ + VacuumStatement statement = new VacuumStatement(); + List options; + List targets; Token token; } { + ( - { - wrapperClause.setWrapperType(JsonFunction.JsonWrapperType.WITHOUT); + LOOKAHEAD({ getToken(1).kind == OPENING_BRACKET }) + options=UtilityOptionList() + { + statement.setOptions(options); + statement.setParenthesizedOptions(true); } | - { - wrapperClause.setWrapperType(JsonFunction.JsonWrapperType.WITH); - } [ - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && (getToken(1).image.equalsIgnoreCase("CONDITIONAL") - || getToken(1).image.equalsIgnoreCase("UNCONDITIONAL")) - }) - token = - { - if (token.image.equalsIgnoreCase("CONDITIONAL")) { - wrapperClause.setWrapperMode(JsonFunction.JsonWrapperMode.CONDITIONAL); - } else { - wrapperClause.setWrapperMode(JsonFunction.JsonWrapperMode.UNCONDITIONAL); - } - } + // FULL can name a table elsewhere, but directly after VACUUM it is the option + LOOKAHEAD({ getToken(1).kind == K_FULL }) + token= { statement.addOptions(linkToLastToken(new UtilityOption(token.image))); } + ] + [ + LOOKAHEAD({ isKeywordAhead("FREEZE") }) + token= { statement.addOptions(linkToLastToken(new UtilityOption(token.image))); } + ] + [ + LOOKAHEAD({ getToken(1).kind == K_VERBOSE }) + token= { statement.addOptions(linkToLastToken(new UtilityOption(token.image))); } + ] + [ + LOOKAHEAD({ getToken(1).kind == K_ANALYZE || getToken(1).kind == K_ANALYSE }) + ( token= | token= ) + { statement.addOptions(linkToLastToken(new UtilityOption(token.image))); } ] ) - [ { wrapperClause.setArray(true); } ] - JsonKeyword("WRAPPER") - { - return wrapperClause; - } + [ LOOKAHEAD(1) targets=MaintenanceTargetList() { statement.setTargets(targets); } ] + { return statement; } } -JsonTableFunction.JsonTableQuotesClause JsonTableQuotesClause() : { - JsonTableFunction.JsonTableQuotesClause quotesClause = - new JsonTableFunction.JsonTableQuotesClause(); +/** + * PostgreSQL CLUSTER (options) [table [USING index]], CLUSTER [VERBOSE] [table [USING index]] and + * the pre-8.3 form CLUSTER [VERBOSE] index ON table, which takes no option list. + */ +ClusterStatement Cluster(): +{ + ClusterStatement statement = new ClusterStatement(); + List options; + Table table; + String index; + Token token; } { + ( - { quotesClause.setQuotesType(JsonFunction.JsonQuotesType.KEEP); } + LOOKAHEAD({ getToken(1).kind == OPENING_BRACKET }) + options=UtilityOptionList() + { + statement.setOptions(options); + statement.setParenthesizedOptions(true); + } + [ LOOKAHEAD(1) ClusterTable(statement) ] | - JsonKeyword("OMIT") { quotesClause.setQuotesType(JsonFunction.JsonQuotesType.OMIT); } + [ + LOOKAHEAD({ getToken(1).kind == K_VERBOSE }) + token= { statement.addOptions(linkToLastToken(new UtilityOption(token.image))); } + ] + [ + LOOKAHEAD({ getToken(2).kind == K_ON && isIdentifierishNameToken(getToken(1)) }) + index=RelObjectName() table=Table() + { + statement.setTable(table); + statement.setIndexName(index); + statement.setIndexSyntax(ClusterStatement.IndexSyntax.ON); + } + | + LOOKAHEAD(1) ClusterTable(statement) + ] ) - JsonKeyword("QUOTES") + { return statement; } +} + +/** The table [USING index] of CLUSTER. */ +void ClusterTable(ClusterStatement statement): +{ + Table table; + String index; +} +{ + table=Table() { statement.setTable(table); } + [ index=RelObjectName() { statement.setIndexName(index); } ] +} + +/** The tables of PostgreSQL VACUUM and ANALYZE, separated by commas. */ +List MaintenanceTargetList(): +{ + List targets = new ArrayList(); + MaintenanceTarget target; +} +{ + target=MaintenanceTarget() { targets.add(target); } + ( "," target=MaintenanceTarget() { targets.add(target); } )* + { return targets; } +} + +/** + * [ONLY] table [*] [(column, ...)], reusing the relation target of LOCK and TRUNCATE. Only the + * PostgreSQL dialect and no dialect accept more than a table name. + */ +MaintenanceTarget MaintenanceTarget(): +{ + Token first = getToken(1); + TableReference reference; + MaintenanceTarget target; + String column; +} +{ + reference=RelationTarget() { target = new MaintenanceTarget(reference); } [ - JsonKeyword("SCALAR") { quotesClause.setOnScalarString(true); } + LOOKAHEAD({ getToken(1).kind == OPENING_BRACKET && isPostgreSqlMaintenanceDialect() }) + "(" column=RelObjectName() { target.addColumns(linkToLastToken(new Column(column))); } + ( "," column=RelObjectName() { target.addColumns(linkToLastToken(new Column(column))); } )* + ")" ] { - return quotesClause; + requireDdlSyntax(target.isPlainTable() || isPostgreSqlMaintenanceDialect(), + "ONLY, * and column lists require the PostgreSQL dialect"); + return linked(target, first); } } -JsonTableFunction.JsonTableColumnDefinition JsonTableColumnDefinition() : { - JsonTableFunction.JsonTableColumnDefinition columnDefinition = null; - JsonTableFunction.JsonTableNestedColumnDefinition nestedColumnDefinition; - JsonTableFunction.JsonTableValueColumnDefinition valueColumnDefinition; - String columnName; - ColDataType dataType; - Expression expression; - String pathName = null; - JsonTableFunction.JsonTableColumnsClause columnsClause; - JsonFunction.JsonOnResponseBehavior behavior; - JsonTableFunction.JsonTableWrapperClause wrapperClause; - JsonTableFunction.JsonTableQuotesClause quotesClause; - String encoding; +/** + * PostgreSQL utility_option_list, shared by VACUUM, ANALYZE and CLUSTER: (name [value], ...). + * As in PostgreSQL's grammar any name and value is accepted; the server checks them when it runs + * the statement. EXPLAIN reads its options through UtilityOption() and maps them to its own model. + */ +List UtilityOptionList(): +{ + List options = new ArrayList(); + UtilityOption option; +} +{ + "(" option=UtilityOption() { options.add(option); } + ( "," option=UtilityOption() { options.add(option); } )* + ")" + { return options; } +} + +UtilityOption UtilityOption(): +{ + Token first = getToken(1); + Token token; + String name; + UtilityOption option; +} +{ + ( + LOOKAHEAD({ isDoubleQuotedIdentifierAhead() }) token= { name = token.image; } + | + ( + token= { name = token.image; } + | token= { name = token.image; } + | name=NonReservedWord() + ) + { requireUtilityOptionWord(name, true); } + ) + { option = new UtilityOption(name); } + [ UtilityOptionArgument(option) ] + { return linked(option, first); } +} + +/** + * The value of a utility option, as PostgreSQL's utility_option_arg: a Boolean word, a signed + * number, a string, or another word or double-quoted identifier. Names and words are identifiers + * and JSqlParser's non-reserved words, which PostgreSQL does not reserve. + */ +void UtilityOptionArgument(UtilityOption option): +{ + Token token; + Token sign = null; + String word; } { ( - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("NESTED") }) - JsonKeyword("NESTED") - { nestedColumnDefinition = new JsonTableFunction.JsonTableNestedColumnDefinition(); } - [ LOOKAHEAD(2) { nestedColumnDefinition.setPathKeyword(true); } ] - expression = Expression() { nestedColumnDefinition.setPathExpression(expression); } - [ pathName = RelObjectName() { nestedColumnDefinition.setPathName(pathName); } ] - columnsClause = JsonTableColumnsClause() { - nestedColumnDefinition.setColumnsClause(columnsClause); - columnDefinition = nestedColumnDefinition; + ( token= | token= | token= ) + { option.setValue(UtilityOption.ValueType.BOOLEAN, token.image); } + | + [ sign="+" | sign="-" ] ( token= | token= ) + { + option.setValue(UtilityOption.ValueType.NUMBER, + sign == null ? token.image : sign.image + token.image); } | - columnName = RelObjectName() { - valueColumnDefinition = new JsonTableFunction.JsonTableValueColumnDefinition(); - valueColumnDefinition.setColumnName(columnName); - columnDefinition = valueColumnDefinition; + token= { option.setValue(UtilityOption.ValueType.STRING, token.image); } + | + LOOKAHEAD({ isDoubleQuotedIdentifierAhead() }) + token= { option.setValue(UtilityOption.ValueType.WORD, token.image); } + | + ( token= { word = token.image; } | token= { word = token.image; } + | word=NonReservedWord() ) + { + requireUtilityOptionWord(word, false); + option.setValue(UtilityOption.isBooleanWord(word) ? UtilityOption.ValueType.BOOLEAN + : UtilityOption.ValueType.WORD, word); } - ( - { valueColumnDefinition.setForOrdinality(true); } - | - [ - // Very ugly: ColDataType can consume an IDENTIFIER, which is fine, but we don't want it to - // consume an ALLOW or DISALLOW because that's a keyword for Oracle in this place. - // So we make a LOOKAHEAD on ColDataType, BUT we exclude the two cases for the IDENTIFIER - - /* - [ ColDataType ] - [ FORMAT JSON ] - [ (ALLOW | DISALLOW) SCALARS ] - */ + ) +} - LOOKAHEAD( - ColDataType(), - { !(getToken(1).kind == S_IDENTIFIER && ( - getToken(1).image.equalsIgnoreCase("ALLOW") - || getToken(1).image.equalsIgnoreCase("DISALLOW"))) } ) - dataType = ColDataType() { valueColumnDefinition.setDataType(dataType); } - ] - [ - { valueColumnDefinition.setFormatJson(true); } - [ encoding = JsonEncoding() { valueColumnDefinition.setEncoding(encoding); } ] - ] - [ - ( - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("ALLOW") }) - JsonKeyword("ALLOW") { valueColumnDefinition.setScalarsType(JsonFunction.ScalarsType.ALLOW); } - | - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("DISALLOW") }) - JsonKeyword("DISALLOW") { valueColumnDefinition.setScalarsType(JsonFunction.ScalarsType.DISALLOW); } - ) - JsonKeyword("SCALARS") - ] - [ { valueColumnDefinition.setExistsKeyword(true); } ] - // In Oracle, the wrapper clause comes before the PATH expression - [ LOOKAHEAD(2) wrapperClause = JsonTableWrapperClause(true) { valueColumnDefinition.setWrapperClause(wrapperClause); } ] - [ expression = Expression() { valueColumnDefinition.setPathExpression(expression); } ] - // In Truno the wrapper clause comes after the PATH expression - [ wrapperClause = JsonTableWrapperClause(false) { valueColumnDefinition.setWrapperClause(wrapperClause); } ] - [ - LOOKAHEAD({ - getToken(1).kind == K_KEEP - || (getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("OMIT")) - }) - quotesClause = JsonTableQuotesClause() { valueColumnDefinition.setQuotesClause(quotesClause); } - ] - [ - LOOKAHEAD( JsonTableOnEmptyBehavior() ) - behavior = JsonTableOnEmptyBehavior() - - { valueColumnDefinition.setOnEmptyBehavior(behavior); } - ] - [ - LOOKAHEAD( JsonQueryOnResponseBehavior() ) - behavior = JsonQueryOnResponseBehavior() - - { valueColumnDefinition.setOnErrorBehavior(behavior); } - ] - [ - LOOKAHEAD( JsonTableOnEmptyBehavior() ) - behavior = JsonTableOnEmptyBehavior() - - { - valueColumnDefinition.setOnEmptyBehavior(behavior); - valueColumnDefinition.setOnEmptyAfterOnError(true); - } - ] - ) +/** Parses PostgreSQL REINDEX; only DATABASE and SYSTEM may omit the name. */ +Reindex Reindex(): +{ + Reindex statement = new Reindex(); + Reindex.Option option; + Table table; + String name; +} +{ + + [ "(" option=ReindexOption() { statement.addOptions(option); } + ( "," option=ReindexOption() { statement.addOptions(option); } )* ")" ] + ( + ( { statement.setTarget(Reindex.Target.INDEX); } + | { statement.setTarget(Reindex.Target.TABLE); } ) + ReindexConcurrently(statement) + table=Table() { statement.setName(table); } + | + { statement.setTarget(Reindex.Target.SCHEMA); } + ReindexConcurrently(statement) + name=RelObjectName() { statement.setName(new Table(name, false)); } + | + ( { statement.setTarget(Reindex.Target.DATABASE); } + | { statement.setTarget(Reindex.Target.SYSTEM); } ) + ReindexConcurrently(statement) + [ LOOKAHEAD(1) name=RelObjectName() { statement.setName(new Table(name, false)); } ] ) - { - return columnDefinition; - } + { return statement; } } -JsonTableFunction.JsonTableColumnsClause JsonTableColumnsClause() : { - JsonTableFunction.JsonTableColumnsClause columnsClause = - new JsonTableFunction.JsonTableColumnsClause(); - JsonTableFunction.JsonTableColumnDefinition columnDefinition; +void ReindexConcurrently(Reindex statement): +{} +{ + // CONCURRENTLY is a keyword here, as in CREATE INDEX, never the reindexed object's name + [ LOOKAHEAD({ getToken(1).kind == K_CONCURRENTLY }) { statement.setConcurrently(true); } ] } + +Reindex.Option ReindexOption(): +{ Reindex.Option option = new Reindex.Option(); Token token; String value = null; } { - "(" + ( { option.setName(Reindex.Option.Name.CONCURRENTLY); } + | { option.setName(Reindex.Option.Name.TABLESPACE); } + | { option.setName(Reindex.Option.Name.VERBOSE); } ) [ - columnDefinition = JsonTableColumnDefinition() { - columnsClause.addColumnDefinition(columnDefinition); - } - ( - "," - columnDefinition = JsonTableColumnDefinition() { - columnsClause.addColumnDefinition(columnDefinition); - } - )* + LOOKAHEAD(1) + ( token= | token= | token= | token= | token= ) + { value = token.image; } + | value=RelObjectName() ] - ")" { - return columnsClause; + requireDdlSyntax(option.getName() != Reindex.Option.Name.TABLESPACE || value != null, + "The REINDEX TABLESPACE option requires a tablespace name"); + option.setValue(value); + return option; } } -JsonTableFunction.JsonTablePlanTerm JsonTablePlanTerm() : { - JsonTableFunction.JsonTablePlanTerm term = null; - String value; - Expression expression; - JsonTableFunction.JsonTablePlanExpression nestedPlanExpression; +/** + * Parses PostgreSQL SECURITY LABEL. The object kind selects how the object is addressed: by a + * name, a qualified column, a routine signature or a large object OID. + */ +SecurityLabel SecurityLabel(): +{ + SecurityLabel statement = new SecurityLabel(); + SecurityLabel.ObjectType type; + Token token; + String name; + Table object; + Column column; + RoutineReference routine; + StringValue label; } { + ContextualKeyword("LABEL") + [ ( token= { statement.setProvider(token.image); } + | name=RelObjectName() { statement.setProvider(name); } ) ] + type=SecurityLabelObjectType(statement) ( - LOOKAHEAD(2) - "(" nestedPlanExpression = JsonTablePlanExpression() ")" { - term = new JsonTableFunction.JsonTablePlanTerm(); - term.setNestedPlanExpression(nestedPlanExpression); - } + LOOKAHEAD({ type == SecurityLabel.ObjectType.COLUMN }) + column=Column() { statement.setColumn(column); } | - LOOKAHEAD(2) - value = RelObjectName() { - term = new JsonTableFunction.JsonTablePlanTerm(); - term.setName(value); - } + LOOKAHEAD({ type.isRoutine() }) + routine=RoutineReference(type == SecurityLabel.ObjectType.AGGREGATE) + { statement.setRoutine(type, routine); } | - expression = Expression() { - term = new JsonTableFunction.JsonTablePlanTerm(); - term.setExpression(expression); - } + LOOKAHEAD({ type == SecurityLabel.ObjectType.LARGE_OBJECT }) + token= { statement.setLargeObjectOid(Long.parseLong(token.image)); } + | + LOOKAHEAD({ type.isRelation() || type == SecurityLabel.ObjectType.SEQUENCE + || type == SecurityLabel.ObjectType.TYPE || type == SecurityLabel.ObjectType.DOMAIN }) + object=CommentObjectName() { statement.setObjectName(type, object); } + | + name=RelObjectName() { statement.setObjectName(type, new Table(name, false)); } ) + ( label=CharacterLiteral(true) { statement.setLabel(label); } | ) + { return statement; } +} + +SecurityLabel.ObjectType SecurityLabelObjectType(SecurityLabel statement): +{ SecurityLabel.ObjectType type; } +{ + ( + { type = SecurityLabel.ObjectType.TABLE; } + | { type = SecurityLabel.ObjectType.COLUMN; } + | { type = SecurityLabel.ObjectType.AGGREGATE; } + | { type = SecurityLabel.ObjectType.DATABASE; } + | { type = SecurityLabel.ObjectType.DOMAIN; } + | { type = SecurityLabel.ObjectType.EVENT_TRIGGER; } + | { type = SecurityLabel.ObjectType.FOREIGN_TABLE; } + | { type = SecurityLabel.ObjectType.FUNCTION; } + | { type = SecurityLabel.ObjectType.MATERIALIZED_VIEW; } + | { type = SecurityLabel.ObjectType.PROCEDURE; } + | { type = SecurityLabel.ObjectType.SCHEMA; } + | { type = SecurityLabel.ObjectType.SEQUENCE; } + | { type = SecurityLabel.ObjectType.TABLESPACE; } + | { type = SecurityLabel.ObjectType.TYPE; } + | { type = SecurityLabel.ObjectType.VIEW; } + | LOOKAHEAD({ isKeywordAhead("LARGE") }) ContextualKeyword("LARGE") ContextualKeyword("OBJECT") + { type = SecurityLabel.ObjectType.LARGE_OBJECT; } + | LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL") + ContextualKeyword("LANGUAGE") { type = SecurityLabel.ObjectType.LANGUAGE; statement.setProcedural(true); } + | LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) ContextualKeyword("LANGUAGE") + { type = SecurityLabel.ObjectType.LANGUAGE; } + | LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) ContextualKeyword("PUBLICATION") + { type = SecurityLabel.ObjectType.PUBLICATION; } + | LOOKAHEAD({ isKeywordAhead("ROLE") }) ContextualKeyword("ROLE") + { type = SecurityLabel.ObjectType.ROLE; } + | LOOKAHEAD({ isKeywordAhead("ROUTINE") }) ContextualKeyword("ROUTINE") + { type = SecurityLabel.ObjectType.ROUTINE; } + | LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) ContextualKeyword("SUBSCRIPTION") + { type = SecurityLabel.ObjectType.SUBSCRIPTION; } + ) + { return type; } +} + +ExpressionList ColumnWithCommentList(): +{ + ExpressionList expressions = new ExpressionList(); + Column img = null; +} +{ + "(" + img=Column() { expressions.add(img); } + ( "," img=Column() { expressions.add(img); } )* + ")" { - return term; + return linkElements(expressions); } } -JsonTableFunction.JsonTablePlanExpression JsonTablePlanExpression() : { - JsonTableFunction.JsonTablePlanExpression planExpression = - new JsonTableFunction.JsonTablePlanExpression(); - JsonTableFunction.JsonTablePlanTerm term; - Token operator = null; + +CreateView CreateView(boolean isUsingOrReplace): +{ + CreateView createView = new CreateView(); + Table view = null; + Select select = null; + ExpressionList columnNames = null; + Token tk = null; + List commentTokens = null; + String name = null; + List storageParameters = null; + List viewOptions = new ArrayList(); + ViewOption viewOption = null; + boolean withData; + MySqlViewOptions mySqlOptions; + CreateView.CheckOption checkOption; } { - term = JsonTablePlanTerm() { planExpression.addTerm(term); } - ( + { createView.setOrReplace(isUsingOrReplace);} + mySqlOptions=MySqlViewPrefix() { createView.setMySqlOptions(mySqlOptions); } + [ + { createView.setForce(ForceOption.NO_FORCE); } + | { createView.setForce(ForceOption.FORCE); } + ] + [ { createView.setSecure(true);} ] + [ + { createView.setTemporary(TemporaryOption.TEMP); } + | { createView.setTemporary(TemporaryOption.TEMPORARY); } + | { createView.setTemporary(TemporaryOption.VOLATILE); } + ] + [ { createView.setRecursive(true); } ] + [ { createView.setMaterialized(true);} ] + + [ LOOKAHEAD(3) { createView.setIfNotExists(true); } ] + view=Table() { createView.setView(view); } + [ LOOKAHEAD({ isKeywordAhead("BACKUP") }) tk= + (tk= | tk=) { createView.setBackup(tk.kind == K_YES); } ] + [LOOKAHEAD(3) (tk= | tk=) { createView.setAutoRefresh(AutoRefreshOption.from(tk.image)); } ] + [LOOKAHEAD(3) { + createView.setIfNotExists(true); + createView.setIfNotExistsAfterViewName(true); + }] + [ columnNames=ColumnWithCommentList( ) { createView.setColumnNames(columnNames); } ] + [ commentTokens=CreateViewTailComment( ) { createView.setViewCommentOptions(commentTokens); } ] + [ name=RelObjectName() { createView.setAccessMethod(name); } ] + [ ( - operator = { - planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.COMMA); - } - | - operator = { - planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.INNER); - } + LOOKAHEAD({ createView.isMaterialized() }) + storageParameters=PostgreSqlIndexOptions() { createView.setStorageParameters(storageParameters); } | - operator = { - planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.OUTER); - } + "(" viewOption=PostgreSqlViewOption() { viewOptions.add(viewOption); } + ( "," viewOption=PostgreSqlViewOption() { viewOptions.add(viewOption); } )* ")" + { createView.setOptions(viewOptions); } + ) + ] + [ name=RelObjectName() { createView.setTableSpace(name); } ] + + select=Select( ) { createView.setSelect(select); } + [ LOOKAHEAD(2) + ( + { createView.setWithReadOnly(true); } | - operator = { - planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.CROSS); - } + checkOption=ViewCheckOption() { createView.setCheckOption(checkOption); } | - operator = { - planExpression.addOperator(JsonTableFunction.JsonTablePlanOperator.UNION); - } + withData=DataPopulation() { createView.setWithData(withData); } ) - term = JsonTablePlanTerm() { planExpression.addTerm(term); } - )* - { - return planExpression; - } + ] + { createView.validateOptions(); return createView; } +} + +CreateView.CheckOption ViewCheckOption(): +{ + CreateView.CheckOption option = CreateView.CheckOption.DEFAULT; +} +{ + [ { option = CreateView.CheckOption.LOCAL; } + | ContextualKeyword("CASCADED") { option = CreateView.CheckOption.CASCADED; } ] + + { return option; } } -JsonTableFunction.JsonTablePlanClause JsonTablePlanClause() : { - JsonTableFunction.JsonTablePlanClause planClause = - new JsonTableFunction.JsonTablePlanClause(); - JsonTableFunction.JsonTablePlanExpression planExpression; +ViewOption PostgreSqlViewOption(): +{ + String name; + Expression value = null; + boolean useEquals = false; } { - - [ { planClause.setDefaultPlan(true); } ] - "(" planExpression = JsonTablePlanExpression() ")" { planClause.setPlanExpression(planExpression); } - { - return planClause; - } + name=RelObjectName() + [ "=" { useEquals = true; } value=PrimaryExpression() ] + { return new ViewOption(name, value, useEquals); } } -JsonTableFunction.JsonTableOnErrorClause JsonTableOnErrorClause(boolean beforeColumns) : { - JsonTableFunction.JsonTableOnErrorClause onErrorClause = - new JsonTableFunction.JsonTableOnErrorClause(beforeColumns); - Token token; -} +/** Shared WITH [NO] DATA tail for table and materialized-view query sources. */ +boolean DataPopulation(): +{ boolean withData = true; } { - ( - { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.ERROR); } - | - { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.EMPTY); } - | - { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.TRUE); } - | - { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.FALSE); } - | - { onErrorClause.setType(JsonTableFunction.JsonTableOnErrorType.NULL); } - ) - - { - return onErrorClause; - } + [ { withData = false; } ] + { return withData; } } -JsonTableFunction.JsonTableOnEmptyClause JsonTableOnEmptyClause() : { - JsonTableFunction.JsonTableOnEmptyClause onEmptyClause = - new JsonTableFunction.JsonTableOnEmptyClause(); - Token token; +List CreateViewTailComment(): +{ + Token tk = null; + Token tk2 = null; + String op = null; + List result = new ArrayList(); } { - ( - { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.ERROR); } - | - { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.EMPTY); } - | - { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.TRUE); } - | - { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.FALSE); } - | - { onEmptyClause.setType(JsonTableFunction.JsonTableOnEmptyType.NULL); } - ) - - { - return onEmptyClause; + tk= + [ "=" { op = "="; } ] + tk2 = { + result.add(""); + result.add(tk.image); + if (op != null) { + result.add(op); + } + result.add(tk2.image); } + { return result;} } -JsonTableFunction.JsonTableParsingTypeClause JsonTableParsingTypeClause() : { - JsonTableFunction.JsonTableParsingTypeClause parsingType = new JsonTableFunction.JsonTableParsingTypeClause(); + +ReferentialAction.Action Action(): +{ + ReferentialAction.Action action = null; } { - - - ( - { parsingType.setType(JsonTableFunction.JsonTableParsingType.STRICT); } - | - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("LAX") }) - JsonKeyword("LAX") { parsingType.setType(JsonTableFunction.JsonTableParsingType.LAX); } - ) - - { - return parsingType; - } + ( { action=ReferentialAction.Action.CASCADE;} + | + {action=ReferentialAction.Action.RESTRICT;} + | + {action=ReferentialAction.Action.NO_ACTION;} + | + ( + {action=ReferentialAction.Action.SET_NULL;} + | + {action=ReferentialAction.Action.SET_DEFAULT;} + ) + ) + { return action; } } -JsonTableFunction JsonTableBody() : { - JsonTableFunction function = new JsonTableFunction(); - Expression jsonInput; - Expression jsonPath; - JsonTableFunction.JsonTablePassingClause passingClause; - String pathName = null; - JsonTableFunction.JsonTableColumnsClause columnsClause; - JsonTableFunction.JsonTablePlanClause planClause = null; - JsonTableFunction.JsonTableOnErrorClause onErrorClause = null; - JsonTableFunction.JsonTableParsingTypeClause parsingTypeClause = null; - JsonTableFunction.JsonTableOnEmptyClause onEmptyClause = null; -} +/** + * Parses optional referential actions: [ON DELETE|UPDATE action] [ON DELETE|UPDATE action] + * Shared between CREATE TABLE FK and ALTER TABLE FK definitions. + */ +void ReferentialActions(ForeignKeyReference reference): +{} { - "(" - jsonInput = Expression() { - function.setJsonInputExpression(jsonInput); - } - [ { function.setFormatJson(true); } ] - [ - "," - jsonPath = Expression() { - function.setJsonPathExpression(jsonPath); - function.setParameters(new ExpressionList(jsonInput, jsonPath)); - } - [ pathName = RelObjectName() { function.setPathName(pathName); } ] - ] - [ - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) - JsonKeyword("PASSING") - passingClause = JsonTablePassingClause() { function.addPassingClause(passingClause); } - ( - "," - passingClause = JsonTablePassingClause() { function.addPassingClause(passingClause); } - )* - ] - [ LOOKAHEAD(3) onErrorClause = JsonTableOnErrorClause(true) { function.setOnErrorClause(onErrorClause); } ] - [ parsingTypeClause = JsonTableParsingTypeClause() { function.setParsingTypeClause(parsingTypeClause); } ] - [ onEmptyClause = JsonTableOnEmptyClause() { function.setOnEmptyClause(onEmptyClause); } ] - columnsClause = JsonTableColumnsClause() { function.setColumnsClause(columnsClause); } - [ planClause = JsonTablePlanClause() { function.setPlanClause(planClause); } ] - [ onErrorClause = JsonTableOnErrorClause(false) { function.setOnErrorClause(onErrorClause); } ] - ")" - { - return function; - } + [ LOOKAHEAD(2) ReferentialActionSpec(reference) ] + [ LOOKAHEAD(2) ReferentialActionSpec(reference) ] } -XmlTableFunction.XmlTablePassingClause XmlTablePassingClause() : { - XmlTableFunction.XmlTablePassingClause passingClause = new XmlTableFunction.XmlTablePassingClause(); - Expression valueExpression; - String name = null; +void ReferentialActionSpec(ForeignKeyReference reference): +{ + Token token; + ReferentialAction.Type type; + ReferentialAction.Action action; + List columnNames = null; } { - valueExpression = Expression() { passingClause.setValueExpression(valueExpression); } - [ name = RelObjectName() { passingClause.setName(name); } ] + ( token= | token= ) + { type = ReferentialAction.Type.from(token.image); } + action=Action() + [ LOOKAHEAD({ type == ReferentialAction.Type.DELETE + && (action == ReferentialAction.Action.SET_NULL + || action == ReferentialAction.Action.SET_DEFAULT) + && "(".equals(getToken(1).image) }) + columnNames=ColumnsNamesList() ] { - return passingClause; + reference.setReferentialAction(type, action); + reference.getReferentialAction(type).setColumnNames(columnNames); } } -XmlTableFunction.XmlTableColumnDefinition XmlTableColumnDefinition() : { - XmlTableFunction.XmlTableColumnDefinition columnDefinition = new XmlTableFunction.XmlTableColumnDefinition(); - String columnName; - ColDataType dataType; - Expression expression; +/** Shares column/period boundaries on both sides of a foreign key. */ +List ForeignKeyColumns(boolean allowParameters): +{ + List columns = new ArrayList(); + KeyElement column; } { - columnName = RelObjectName() { columnDefinition.setColumnName(columnName); } - ( - { columnDefinition.setForOrdinality(true); } - | - dataType = ColDataType() { columnDefinition.setDataType(dataType); } - [ expression = Expression() { columnDefinition.setPathExpression(expression); } ] - [ expression = Expression() { columnDefinition.setDefaultExpression(expression); } ] - ) - { - return columnDefinition; - } + "(" column=ForeignKeyColumn(allowParameters) { columns.add(column); } + ( "," { + requireDdlSyntax(!column.isPeriod(), "PERIOD must mark the final foreign key column"); + } column=ForeignKeyColumn(allowParameters) { columns.add(column); } )* ")" + { return columns; } } -XmlTableFunction XmlTableBody() : { - XmlTableFunction function = new XmlTableFunction(); - Expression rowPath; - XmlTableFunction.XmlTablePassingClause passingClause; - XmlTableFunction.XmlTableColumnDefinition columnDefinition; +KeyElement ForeignKeyColumn(boolean allowParameters): +{ + boolean period = false; + String name; + List parameters = null; } { - "(" - rowPath = Expression() { function.setRowPathExpression(rowPath); } - [ - LOOKAHEAD({ getToken(1).kind == S_IDENTIFIER && getToken(1).image.equalsIgnoreCase("PASSING") }) - - passingClause = XmlTablePassingClause() { function.addPassingClause(passingClause); } - ( - "," - passingClause = XmlTablePassingClause() { function.addPassingClause(passingClause); } - )* - ] - [ - - columnDefinition = XmlTableColumnDefinition() { function.addColumnDefinition(columnDefinition); } - ( - "," - columnDefinition = XmlTableColumnDefinition() { function.addColumnDefinition(columnDefinition); } - )* - ] - ")" - { - return function; - } + [ LOOKAHEAD({ isKeywordAhead("PERIOD") && getToken(2).kind != K_COMMA + && getToken(2).kind != CLOSING_BRACKET }) + ContextualKeyword("PERIOD") { period = true; } ] + name=RelObjectName() + [ parameters=CreateParameter() { + requireDdlSyntax(allowParameters && !period, "Expected a foreign key column name"); + } ] + { return new KeyElement(name, parameters).withPeriod(period); } } -TableFunction TableFunction(): +ForeignKeyReference ForeignKeyReferenceSpec(boolean columnContext): { - Token prefix = null; - Function function = null; - ParenthesedExpressionList rowsFromFunctions = null; - Token withClause = null; + ForeignKeyReference reference = new ForeignKeyReference(); + ForeignKeyReference.MatchType matchType; + Token matchToken; + List refColNames = null; + List referencedColumns; + Table fkTable; } { - [ prefix = ] - ( - LOOKAHEAD(3) rowsFromFunctions = RowsFromFunctionList() - | - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("JSON_TABLE") - }) - JsonKeyword("JSON_TABLE") - function = JsonTableBody() - | - LOOKAHEAD({ - getToken(1).kind == S_IDENTIFIER - && getToken(1).image.equalsIgnoreCase("XMLTABLE") - }) - - function = XmlTableBody() - | - function=Function() - ) - [ LOOKAHEAD(2) ( withClause = | withClause = ) ] + fkTable=Table() + [ LOOKAHEAD(2) referencedColumns=ForeignKeyColumns(false) { + refColNames = new ArrayList(); + for (KeyElement column : referencedColumns) { + refColNames.add(column.getColumnName()); + } + reference.setUsingPeriod(referencedColumns.get(referencedColumns.size() - 1).isPeriod()); + } ] { - if (rowsFromFunctions != null) { - return prefix != null - ? withClause != null - ? new TableFunction(prefix.image, rowsFromFunctions, withClause.image) - : new TableFunction(prefix.image, rowsFromFunctions) - : withClause != null - ? new TableFunction(rowsFromFunctions, withClause.image) - : new TableFunction(rowsFromFunctions); + reference.setTable(fkTable); + reference.setReferencedColumnNames(refColNames); + } + [ + + ( + { matchType = ForeignKeyReference.MatchType.FULL; } + | matchToken= { + matchType = ForeignKeyReference.MatchType.valueOf( + matchToken.image.toUpperCase(Locale.ROOT)); + } + ) + { reference.setMatchType(matchType); } + ] + ReferentialActions(reference) + { + if (columnContext) { + ConstraintAttributes attributes = PostgreSqlConstraintAttributeList(null); + requireDdlSyntax(attributes == null || !attributes.isNotValid(), + "NOT VALID requires a table constraint"); + reference.setConstraintAttributes(attributes); } - - return prefix != null - ? withClause != null - ? new TableFunction(prefix.image, function, withClause.image) - : new TableFunction(prefix.image, function) - : withClause != null - ? new TableFunction(function, withClause.image) - : new TableFunction(function); + return reference; } } -ParenthesedExpressionList RowsFromFunctionList(): +/** + * Parses: CHECK ( expression ) + * Returns a CheckConstraint. Shared between CREATE TABLE and ALTER TABLE. + */ +CheckConstraint CheckConstraintSpec(String constraintName): { - ParenthesedExpressionList functions = new ParenthesedExpressionList(); - Function function; + Expression exp = null; + Boolean enforced = null; + boolean noInherit = false; + CheckConstraint checkConstraint; } { - "(" - function = RowsFromFunction() { functions.add(function); } - ( - "," - function = RowsFromFunction() { functions.add(function); } - )* - ")" + "(" exp = Expression() ")" + [ LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_NO && "INHERIT".equalsIgnoreCase(getToken(2).image) }) + TypeDdlKeyword("INHERIT") { noInherit = true; } ] + [ LOOKAHEAD(2) enforced=ConstraintEnforcement() ] { - return functions; + checkConstraint = new CheckConstraint().withName(constraintName).withExpression(exp) + .withEnforced(enforced).withNoInherit(noInherit); + checkConstraint.setKind(ConstraintKind.CHECK); + return checkConstraint; } } -/** A function and its optional PostgreSQL record column definition list. */ -Function RowsFromFunction(): +/** + * Parses: FOREIGN KEY columns REFERENCES table [columns] [referential actions] + * Returns a populated ForeignKeyConstraint. Shared between CREATE TABLE and ALTER TABLE. + */ +ForeignKeyConstraint ForeignKeySpec(String constraintName): { - Function function; - List columns = new ArrayList(); - ColumnDefinition column; + ForeignKeyConstraint fkIndex = new ForeignKeyConstraint(); + String indexName = null; + Token tk; + Token tk2; + List colNames; + ForeignKeyReference reference; } { - function=Function() - [ "(" - column=RowsFromColumnDefinition() { columns.add(column); } - ( "," column=RowsFromColumnDefinition() { columns.add(column); } )* - ")" { function.setResultColumnDefinitions(columns); } - ] - { return function; } + tk= tk2= + [ LOOKAHEAD(2) indexName=RelObjectName() { fkIndex.setIndexName(indexName); } ] + colNames = ForeignKeyColumns(true) + { + if (constraintName != null) { fkIndex.setName(constraintName); } + fkIndex.withType(tk.image + " " + tk2.image).withColumns(colNames); + } + reference=ForeignKeyReferenceSpec(false) { fkIndex.setReference(reference); } + { + return fkIndex; + } } -ColumnDefinition RowsFromColumnDefinition(): +/** + * Parses USING [INDEX] [name] [TABLESPACE name] clause in ALTER TABLE constraint tails. + */ +void AlterExpressionUsingIndex(AlterExpression alterExp): { - String name; - String collation; - String part; - ColDataType type; - ColumnDefinition column; + String sk4; } { - name=RelObjectName() type=ColDataType() - { column = new ColumnDefinition(name, type); } - [ collation=RelObjectName() - ( "." part=RelObjectName() { collation += "." + part; } )* - { column.addColumnOptions(ColumnOption.collate(collation)); } - ] - { return column; } + { alterExp.addParameters("USING"); } + [ LOOKAHEAD(2) { alterExp.addParameters("INDEX"); } ] + ( + LOOKAHEAD(1, ) sk4=RelObjectName() + { alterExp.addParameters("TABLESPACE"); alterExp.addParameters(sk4); } + | + sk4=RelObjectName() { alterExp.addParameters(sk4); } + [ LOOKAHEAD(2) sk4=RelObjectName() + { alterExp.addParameters("TABLESPACE"); alterExp.addParameters(sk4); } ] + ) } -List ColumnNamesWithParamsList() : { - List colNames = new ArrayList(); - String columnName; - List parameter = null; +/** + * Parses the common tail after a named constraint in ALTER TABLE: + * constraint_state [USING [INDEX] name] [COMMENT 'text'] + */ +void AlterExpressionConstraintTail(AlterExpression alterExp, KeyConstraint constraint): +{ + List constraints; } { - "(" - columnName=RelObjectName() + constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } + [ LOOKAHEAD(2) AlterExpressionUsingIndex(alterExp) ] + [ LOOKAHEAD(2) IndexWithComment(constraint) ] +} - { parameter = null; } - [ parameter = CreateParameter() ] +AlterView AlterView(boolean useReplace): +{ + AlterView alterView = new AlterView(); + MySqlViewOptions options; + CreateView.CheckOption checkOption; + Table view = null; + Select select = null; + List columnNames = null; +} +{ + options=MySqlViewPrefix() { alterView.setMySqlOptions(options); } + view=Table() { alterView.setView(view); alterView.setUseReplace(useReplace); } + [ columnNames = ColumnsNamesList() { alterView.setColumnNames(columnNames); } ] + + select=Select() + [ LOOKAHEAD(2) checkOption=ViewCheckOption() { alterView.setCheckOption(checkOption); } ] { - colNames.add(new Index.ColumnParams(columnName,parameter)); + alterView.setSelect(select); + return alterView; } - - ( - "," - columnName=RelObjectName() - - { parameter = null; } - [ parameter = CreateParameter() ] - { - colNames.add(new Index.ColumnParams(columnName,parameter)); - } - )* - - ")" - - { return colNames; } } -Index.ColumnParams IndexColumnWithParams(): { - String columnName = null; - List columnParams = new ArrayList(); - List parameter = null; - Expression expression = null; - String collation = null; - String operatorClass = null; - List operatorClassParameters = null; - Token sortOrder = null; - Token nullOrdering = null; - Index.ColumnParams column = null; - boolean postgres = Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)); - boolean expressionParenthesized = true; +List CreateParameter(): +{ + String retval = ""; + Token tk = null, tk2 = null; + Expression exp = null; + ColDataType colDataType; + List param = new ArrayList(); } { ( - LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && isFunctionAhead() }) expression=Function() - { expressionParenthesized = false; } + // Postgres: nextval('public.actor_actor_id_seq'::regclass) + ( "(" tk= "::" colDataType = ColDataType() ")" ) + { + param.add("NextVal( " + tk.image + "::" + colDataType + ")" ); + } | - columnName=RelObjectName() + ( + //@todo: implement a proper identifier + (tk= | tk= | tk= | tk=) + { retval+=tk.image; } + + [ + "." + //@todo: implement a proper identifier + (tk2= | tk2= | tk=) + { retval+="."+tk2.image; } + ] + { param.add(retval); } + ) | - "(" expression=Expression() ")" - ) - // MySQL prefix lengths precede all PostgreSQL key attributes. - [ LOOKAHEAD("(", { !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) parameter=CreateParameter() { columnParams.addAll(parameter); } ] - [ LOOKAHEAD(2) collation=IndexKeyAttributeName() - { if (!postgres) { columnParams.add("COLLATE"); columnParams.add(collation); } } ] - [ LOOKAHEAD(2, IndexKeyAttributeName(), { - getToken(1).kind == S_IDENTIFIER || getToken(1).kind == S_QUOTED_IDENTIFIER - || (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind != K_ASC && getToken(1).kind != K_DESC - && getToken(1).kind != K_NULLS && getToken(1).kind != K_COLLATE - && getToken(1).kind != K_WITH) }) - operatorClass=IndexKeyAttributeName() - [ LOOKAHEAD(2) operatorClassParameters=PostgreSqlIndexOptions() ] + LOOKAHEAD(3) [ { param.add("USING INDEX"); }] retval=RelObjectName() + { param.add("TABLESPACE " + retval); } + | + ( + tk= | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= | tk= | tk= + | tk= | tk= | tk= | tk= | tk= | tk = | tk = + | tk= | tk= | tk= | tk= | tk= + | tk= | tk= + // BigQuery CLUSTER BY; CLUSTER became a token for the PostgreSQL statement + | tk= + // MySQL index_option / algorithm_option / lock_option keywords, e.g. the trailing + // "KEY_BLOCK_SIZE = 8 ALGORITHM = INPLACE LOCK = NONE" of CREATE INDEX, the + // "WITH PARSER" option, and the FULLTEXT / SPATIAL index types of CREATE INDEX. + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= + | tk= | tk= | tk= | tk= + | tk= | tk= | tk= + | tk= | tk= + | tk="=" + ) + { param.add(tk.image); } + | + ( tk= | tk= | tk= ) [ LOOKAHEAD(2) "(" exp = Expression() ")" ] { - if (!postgres) { - columnParams.add(operatorClass); - if (operatorClassParameters != null) { - columnParams.add(PlainSelect.getStringList( - operatorClassParameters, true, true)); - } + param.add(tk.image); + if (exp!=null) { + param.add("(" + exp + ")"); } } - ] - [ LOOKAHEAD(2) (sortOrder= | sortOrder=) - { if (!postgres) { columnParams.add(sortOrder.image); } } ] - [ LOOKAHEAD(2) (nullOrdering= | nullOrdering=) - { if (!postgres) { columnParams.add("NULLS"); columnParams.add(nullOrdering.image); } } ] - ( LOOKAHEAD(2, { !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && getToken(1).kind != K_WITH }) parameter=CreateParameter() { columnParams.addAll(parameter); } )* - { - column = expression != null - ? new Index.ColumnParams(expression, - columnParams.isEmpty() ? null : columnParams) - : new Index.ColumnParams(columnName, - columnParams.isEmpty() ? null : columnParams); - column.setCollation(collation); - column.setExpressionParenthesized(expressionParenthesized); - if (operatorClass != null) { - column.setOperatorClass(operatorClass); - column.setOperatorClassParameters(operatorClassParameters); - } - if (sortOrder != null) { - column.setSortOrder(Index.ColumnParams.SortOrder.valueOf( - sortOrder.image.toUpperCase(Locale.ROOT))); - } - if (nullOrdering != null) { - column.setNullOrdering(Index.ColumnParams.NullOrdering.valueOf( - nullOrdering.image.toUpperCase(Locale.ROOT))); - } - return column; - } + | + ( + [ ( tk="+" | tk="-" ) { retval = tk.image; } ] + tk= | tk= + ) + { param.add( retval + tk.image ); } + | + retval=AList() { param.add(retval); } + | + (tk= tk2=) { param.add(tk.image); param.add(tk2.image);} + | + ( exp=ArrayConstructor(true)) { param.add(exp.toString()); } + | + tk="::" colDataType = ColDataType() { param.add(tk.image); param.add(colDataType.toString()); } + ) + {return param;} } -/** Keeps qualified PostgreSQL collation and operator-class names out of expression parsing. */ -String IndexKeyAttributeName(): +// row_movement_clause https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_7002.htm#i2204697 +RowMovement RowMovement(): { - String name; - String part; + RowMovement rowMovement = new RowMovement(); } { - name=RelObjectName() - ( LOOKAHEAD(".", { Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) - "." part=RelObjectNameExt() { name += "." + part; } - )* - { return name; } + ( + ( ) { rowMovement.setMode(RowMovementMode.ENABLE); } + | + ( ) { rowMovement.setMode(RowMovementMode.DISABLE); } + ) + { return rowMovement;} } -Index.Option PostgreSqlIndexOption(): +String AList(): { + StringBuilder retval = new StringBuilder("("); + Token tk = null; String name = null; - Expression value = null; - boolean useEquals = false; -} -{ - name=RelObjectName() [ "=" { useEquals = true; } ] value=Expression() - { return new Index.Option(name, value, useEquals); } -} - -List PostgreSqlIndexOptions(): -{ - List options = new ArrayList(); - Index.Option option = null; -} -{ - "(" option=PostgreSqlIndexOption() { options.add(option); } - ( "," option=PostgreSqlIndexOption() { options.add(option); } )* ")" - { return options; } -} - -List IndexColumnsWithParamsList() : { - List colNames = new ArrayList(); - Index.ColumnParams column = null; + boolean needsSeparator = false; } { "(" - column=IndexColumnWithParams() - { - colNames.add(column); - } - ( - "," - column=IndexColumnWithParams() - { - colNames.add(column); - } - )* + ( + ( (tk= | tk= | tk= | tk= | tk=) { name = tk.image; } + | name=RelObjectName() ) + { + if (needsSeparator) { + retval.append(' '); + } + retval.append(name); + needsSeparator = true; + } + [("," { retval.append(','); needsSeparator = false; } + | "=" { retval.append('='); needsSeparator = false; })] )* ")" - - { return colNames; } -} - -Index Index(): { - ObjectNames name; -} -{ - name= RelObjectNames() { return new Index().withName(name.getNames()).withType(""); } + { + retval.append(")"); + return retval.toString(); + } } -/** Parses dialect-specific index modifiers while retaining the legacy single type token. */ -Index CreateIndexModifiers(CreateIndex statement): +String ColumnsNamesListItem(): { - Index index = new Index(); - Token token; - List parameter; - Index.Clustering clustering; + Token tk = null; + Token sortDirection = null; + String item = null; } { - ( - LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && (getToken(1).kind == K_UNIQUE || isKeywordAhead("CLUSTERED") - || isKeywordAhead("NONCLUSTERED")) }) - [ token= { index.setType(token.image); } ] - clustering=SqlServerIndexClustering() { index.setClustering(clustering); } - | - LOOKAHEAD({ Dialect.SPANNER.name().equals(getAsString(Feature.dialect)) - && (getToken(1).kind == K_UNIQUE || isKeywordAhead("NULL_FILTERED")) }) - [ token= { index.setType(token.image); } ] - [ LOOKAHEAD({ isKeywordAhead("NULL_FILTERED") }) token= - { statement.setNullFiltered(true); } ] - | - [ parameter=CreateParameter() { index.setType(parameter.get(0)); } ] - ) - { return index; } + ( item = RelObjectName() ) + [ LOOKAHEAD(2) "(" tk = ")" { item = item + "(" + tk.image + ")"; } ] + [ LOOKAHEAD( ( | ) ( "," | ")" ) ) (sortDirection = | sortDirection = ) { item = item + " " + sortDirection.image; } ] + { + return item; + } } -CreateIndex CreateIndex(): +List ColumnsNamesList(): { - CreateIndex createIndex = new CreateIndex(); - Table table = null; - List colNames; - List includeColumns; - Boolean nullsDistinct = null; - List storageParameters = null; - String tableSpace = null; - Expression where = null; - String indexType; - Index index; - List parameter = new ArrayList(); - List tailParameters = new ArrayList(); - ObjectNames name; + List retval = new ArrayList(); + String img = null; } { - index=CreateIndexModifiers(createIndex) + "(" + img=ColumnsNamesListItem() { retval.add(img); } + ( "," img=ColumnsNamesListItem() { retval.add(img); } )* - - [ LOOKAHEAD({ getToken(1).kind == K_CONCURRENTLY }) - { createIndex.setConcurrently(true); } ] - [ LOOKAHEAD(2) { createIndex.setUsingIfNotExists(true);} ] - [ LOOKAHEAD({ getToken(1).kind != K_ON && getToken(1).kind != K_USING }) - name=RelObjectNames() { index.setName(name.getNames()); } ] - ( - LOOKAHEAD(3)( - [ { createIndex.setOnly(true); } ] table=Table() - [ indexType=UsingIndexType() { index.setUsing(indexType); } ] - ) - | - ( - [ indexType=UsingIndexType() { - index.setUsing(indexType); - createIndex.setIndexTypeBeforeOn(true); - } - ] - [ { createIndex.setOnly(true); } ] table=Table() - ) - ) - colNames = IndexColumnsWithParamsList() - [ includeColumns=ColumnsNamesList() - { createIndex.setIncludeColumns(includeColumns); } - ] - [ LOOKAHEAD(3) [ { nullsDistinct = false; } ] - { - if (nullsDistinct == null) { - nullsDistinct = true; - } - createIndex.setNullsDistinct(nullsDistinct); - } - ] - [ LOOKAHEAD(2) storageParameters=PostgreSqlIndexOptions() - { createIndex.setStorageParameters(storageParameters); } ] - [ LOOKAHEAD(2) tableSpace=RelObjectName() - { createIndex.setTableSpace(tableSpace); } ] - [ LOOKAHEAD(2) where=Expression() { createIndex.setWhere(where); } ] - ( LOOKAHEAD(2, { getToken(1).kind != K_LOCK || getToken(2).kind != K_TABLE }) - parameter=CreateIndexTailOption() { tailParameters.addAll(parameter); } )* + ")" { - index.setColumns(colNames); - createIndex.setIndex(index); - createIndex.setTable(table); - createIndex.setTailParameters(tailParameters); - return createIndex; + return retval; } } -List CreateIndexTailOption(): +/** DROP names are lexer-separated identifiers, not strings to split again on dots. */ +Table DropObjectName() #TableName: { - List option; + ObjectNames names; + Token literal; + Table table; + String timeTravel = null; } { ( - LOOKAHEAD({ getToken(1).kind == K_ALGORITHM || getToken(1).kind == K_LOCK }) - option=IndexAlgorithmOrLockOption() + names=RelObjectNames() [ LOOKAHEAD(2) timeTravel=TimeTravelBeforeAlias() ] + { table = names.getNames().size() == 1 ? new Table(names.getNames().get(0), false) + : new Table(names.getNames()); table.setTimeTravel(timeTravel); } | - option=CreateParameter() + literal= { table = new Table(literal.image, false); } ) - { return option; } + { linkAST(table, jjtThis); return table; } } -// CREATE INDEX and DROP INDEX share MySQL's algorithm_option / lock_option syntax. -// Keep the legacy token list, including optional equals signs and the original order. -List IndexAlgorithmOrLockOption(): +/** The targets of a DROP statement, typed by the object kind that was dropped. */ +void DropTargets(Drop drop): { - List option = new ArrayList(); - Token keyword; - Token value; -} -{ - ( keyword= | keyword= ) { option.add(keyword.image); } - [ "=" { option.add("="); } ] - // COPY is one of MySQL's ALGORITHM values and also starts the COPY statement - ( value= | value= | value= | value= - | value= ) - { option.add(value.image); return option; } -} - -List ColumnDefinitionParameter(): { - Token tk = null; - List parameter = new ArrayList(); -} { - ( - parameter=CreateParameter() - | - ( - tk= - | tk= - | tk= - | tk= - | tk= - ) - { parameter.add(tk.image); } - ) - { return parameter; } -} - -ColumnDefinition ColumnDefinition(): { - ColumnDefinition coldef; - String columnName; - ColDataType colDataType; - List columnSpecs = new ArrayList(); - List columnOptions = new ArrayList(); - ColumnOption option; -} { - columnName=RelObjectName() - colDataType=ColDataType() - ( LOOKAHEAD(2) option=ColumnDefinitionOption() { - columnOptions.add(option); - columnSpecs.addAll(option.getTokens()); - } )* - { - coldef = new ColumnDefinition(); - coldef.setColumnName(columnName); - coldef.setColDataType(colDataType); - if (columnSpecs.size() > 0) - coldef.setColumnSpecs(columnSpecs); - if (hasStructuredColumnOption(columnOptions)) - coldef.setColumnOptions(columnOptions); - return coldef; - } -} - -ColumnOption ColumnDefinitionOption(): { - Token tk; - List parameter; - ForeignKeyReference reference; - ColumnOption option; - IdentityDefinition identity; - NamedConstraint constraint; - Expression defaultExpression; - GeneratedColumnDefinition generated; - ObjectNames collationNames; - String collation; -} { - ( - LOOKAHEAD({ isKeywordAhead("GENERATED") - && (getToken(4).kind == K_IDENTITY || getToken(5).kind == K_IDENTITY) }) - identity=IdentityDefinition() { option = ColumnOption.identity(identity); } - | - LOOKAHEAD({ (isKeywordAhead("GENERATED") && getToken(2).kind == K_ALWAYS - && getToken(3).kind == K_AS && "(".equals(getToken(4).image)) - || (getToken(1).kind == K_AS && "(".equals(getToken(2).image)) }) - generated=GeneratedColumnDefinition() { option = ColumnOption.generated(generated); } - | - LOOKAHEAD( ) { option = ColumnOption.nullability(false); } - | - LOOKAHEAD() { option = ColumnOption.nullability(true); } - | - LOOKAHEAD() { option = ColumnOption.visibility(true); } - | - LOOKAHEAD() { option = ColumnOption.visibility(false); } - | - LOOKAHEAD() { option = ColumnOption.autoIncrement(); } - | - LOOKAHEAD() - ( tk= { collation = tk.image; } - | collationNames=RelObjectNames() { collation = String.join(".", collationNames.getNames()); } ) - { option = ColumnOption.collate(collation); } - | - LOOKAHEAD() tk= - { option = ColumnOption.comment(new StringValue(tk.image)); } - | - LOOKAHEAD( ) defaultExpression=Expression() - { option = ColumnOption.onUpdate(defaultExpression); } - | - LOOKAHEAD( ) - { option = ColumnOption.constraint(new NamedConstraint().withType("PRIMARY KEY")); } - | - LOOKAHEAD() constraint=ColumnUniqueConstraint() - { option = ColumnOption.constraint(constraint); } + boolean aggregate = drop.getObjectType() == Drop.ObjectType.AGGREGATE; + RoutineReference routine; + UserAccount account; + CastSignature cast; + TransformSignature transform; + OperatorSignature operator; + Table name; + Expression srid; +} +{ + ( + LOOKAHEAD({ drop.getObjectType() == Drop.ObjectType.SPATIAL_REFERENCE_SYSTEM }) + srid=SpatialReferenceSystemNumber() + { drop.addNames(linkToLastToken(new Table(srid.toString(), false))); } | - LOOKAHEAD({ isKeywordAhead("SERIAL") - && getToken(2).kind == K_DEFAULT && getToken(3).kind == K_VALUE }) - tk= - { option = ColumnOption.serialDefaultValue(); } + LOOKAHEAD({ drop.getObjectType().hasRoutineTargets() }) + routine=RoutineReference(aggregate) { drop.addRoutines(routine); } + ( "," routine=RoutineReference(aggregate) { drop.addRoutines(routine); } )* | - LOOKAHEAD() reference=ForeignKeyReferenceSpec() - { option = ColumnOption.reference(reference); } + LOOKAHEAD({ drop.getObjectType().hasAccountTargets() }) + account=MySqlAccountName() { drop.addAccounts(account); } + ( "," account=MySqlAccountName() { drop.addAccounts(account); } )* + { + if (drop.getObjectType() == Drop.ObjectType.ROLE) { + requireRoleNames(drop.getAccounts()); + } + } | - LOOKAHEAD( ) - { option = ColumnOption.raw("DROP", "DEFAULT"); } + LOOKAHEAD({ drop.getObjectType() == Drop.ObjectType.CAST }) + cast=CastSignature() { drop.setCast(cast); } | - LOOKAHEAD( ) - { option = ColumnOption.raw("DEFAULT", "ON", "NULL"); } + LOOKAHEAD({ drop.getObjectType() == Drop.ObjectType.TRANSFORM && getToken(1).kind == K_FOR }) + transform=TransformSignature() { drop.setTransform(transform); } | - LOOKAHEAD() { option = ColumnOption.raw("DEFAULT"); } - // Db2 permits an omitted default value. Keep these implicit defaults raw. - [ LOOKAHEAD(2, { !(getToken(1).kind == K_NOT && getToken(2).kind == K_NULL) }) - defaultExpression=Expression() { option = ColumnOption.defaultValue(defaultExpression); } ] + LOOKAHEAD({ drop.getObjectType() == Drop.ObjectType.OPERATOR + && (DropLookahead.isOperatorAhead(getToken(1), getToken(2), getToken(3)) + || isOperatorNameAhead(1)) }) + operator=OperatorSignature() { drop.addOperators(operator); } + ( "," operator=OperatorSignature() { drop.addOperators(operator); } )* | - parameter=ColumnDefinitionParameter() - { option = ColumnOption.raw(parameter); } + name=DropObjectName() { drop.addNames(name); } + ( "," name=DropObjectName() { drop.addNames(name); } )* + { + // PostgreSQL names an operator by its symbol and operand types and a transform by its + // type and language; Oracle's DROP OPERATOR name keeps the name + requireDdlSyntax(!Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + || drop.getObjectType() != Drop.ObjectType.OPERATOR + && drop.getObjectType() != Drop.ObjectType.TRANSFORM, + "DROP " + drop.getType() + " requires a signature in PostgreSQL"); + } ) - { return option; } } -GeneratedColumnDefinition GeneratedColumnDefinition(): +/** PostgreSQL ( source_type AS target_type ), naming a cast. */ +CastSignature CastSignature(): { - Expression expression; - boolean generatedAlways = false; - GeneratedColumnDefinition.Storage storage = null; - GeneratedColumnDefinition result; + Token first = getToken(1); + CastSignature result = new CastSignature(); + ColDataType type; } { - [ LOOKAHEAD({ isKeywordAhead("GENERATED") }) ContextualKeyword("GENERATED") - { generatedAlways = true; } ] - "(" expression=Expression() ")" - [ LOOKAHEAD({ getToken(1).kind == K_STORED || isKeywordAhead("VIRTUAL") }) - ( { storage = GeneratedColumnDefinition.Storage.STORED; } - | ContextualKeyword("VIRTUAL") { storage = GeneratedColumnDefinition.Storage.VIRTUAL; } ) ] - { - result = new GeneratedColumnDefinition(expression); - result.setGeneratedAlways(generatedAlways); - result.setStorage(storage); - return result; - } + "(" type=ColDataType() { result.setSourceType(type); } + type=ColDataType() { result.setTargetType(type); } ")" + { return linked(result, first); } } -NamedConstraint ColumnUniqueConstraint(): +/** PostgreSQL FOR type_name LANGUAGE lang_name, naming a transform. */ +TransformSignature TransformSignature(): { - NamedConstraint constraint = new NamedConstraint().withType("UNIQUE"); - Boolean nullsDistinct = null; + Token first = getToken(1); + TransformSignature result = new TransformSignature(); + ColDataType type; + String language; } { - - [ [ { nullsDistinct = false; } ] { - constraint.setNullsDistinct(nullsDistinct == null ? true : nullsDistinct); - } ] - { return constraint; } + type=ColDataType() { result.setDataType(type); } + ContextualKeyword("LANGUAGE") language=RelObjectName() { result.setLanguage(language); } + { return linked(result, first); } } -IdentityDefinition IdentityDefinition(): +/** + * PostgreSQL [ schema. ] operator ( { left_type | NONE }, { right_type | NONE } ), naming an + * operator. NONE marks a missing operand, but one operand type is required. + */ +OperatorSignature OperatorSignature(): { - Token token; - IdentityDefinition.GenerationMode mode; - IdentityDefinition identity; - List parameters; + Token first = getToken(1); + OperatorSignature result = new OperatorSignature(); + ExclusionOperator operator; + ColDataType type; } { - token= { - requireDdlSyntax("GENERATED".equalsIgnoreCase(token.image), "Expected GENERATED"); + operator=PostgreSqlOperatorReference() { result.setOperator(operator); } + "(" type=ExtensionOperatorType() { result.setLeftType(type); } + "," type=ExtensionOperatorType() { result.setRightType(type); } ")" + { + requireTypeDdlSyntax(result.getLeftType() != null || result.getRightType() != null, + "An operator signature needs an operand type"); + return linked(result, first); } - ( { mode = IdentityDefinition.GenerationMode.ALWAYS; } - | { mode = IdentityDefinition.GenerationMode.BY_DEFAULT; } ) - { identity = new IdentityDefinition(mode); } - [ LOOKAHEAD(2) "(" parameters=SequenceParameters() ")" { - requireDdlSyntax(!parameters.isEmpty(), "Expected an identity sequence parameter"); - identity.setParameters(parameters); - } ] - { return identity; } } -StringValue MySqlAccountNamePart(): +Drop Drop(): { - Token token = null; - String name = null; - StringValue value = null; + Drop drop = new Drop(); + Token tk = null; + Table name; + Table indexTable = null; + int indexTablePosition = 0; + List dropArgs = new ArrayList(); + AlgorithmOrLockOption indexOption; + List indexOptions = new ArrayList(); + int indexOptionPosition = 0; + boolean useTemporary = false; + String multiWordType = null; + boolean eventTrigger = false; + CascadeBehavior behavior = null; + String engine; + String accessMethod; } { + + [ { drop.setMaterialized(true);} ] ( - token= { value = new StringValue(token.image); } + ( + { multiWordType = "FOREIGN TABLE"; } + | + ContextualKeyword("WRAPPER") { multiWordType = "FOREIGN DATA WRAPPER"; } + ) + | + // PostgreSQL object types of several words, written as COMMENT ON names them + LOOKAHEAD({ isKeywordAhead("ACCESS") && "METHOD".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("ACCESS") ContextualKeyword("METHOD") { multiWordType = "ACCESS METHOD"; } + | + LOOKAHEAD({ isKeywordAhead("PROCEDURAL") && "LANGUAGE".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("PROCEDURAL") ContextualKeyword("LANGUAGE") + { drop.setProcedural(true); multiWordType = "LANGUAGE"; } + | + // a schema named CLASS or FAMILY may qualify an operator, as in class.+ + LOOKAHEAD({ isKeywordAhead("OPERATOR") && !".".equals(getToken(3).image) + && ("CLASS".equalsIgnoreCase(getToken(2).image) || "FAMILY".equalsIgnoreCase(getToken(2).image)) }) + ContextualKeyword("OPERATOR") + ( LOOKAHEAD({ isKeywordAhead("CLASS") }) ContextualKeyword("CLASS") { multiWordType = "OPERATOR CLASS"; } + | ContextualKeyword("FAMILY") { multiWordType = "OPERATOR FAMILY"; } ) + | + LOOKAHEAD({ isKeywordAhead("TEXT") && getToken(2).kind == K_SEARCH }) + ( + { multiWordType = "TEXT SEARCH PARSER"; } + | LOOKAHEAD({ isKeywordAhead("CONFIGURATION") }) ContextualKeyword("CONFIGURATION") + { multiWordType = "TEXT SEARCH CONFIGURATION"; } + | LOOKAHEAD({ isKeywordAhead("DICTIONARY") }) ContextualKeyword("DICTIONARY") + { multiWordType = "TEXT SEARCH DICTIONARY"; } + | ContextualKeyword("TEMPLATE") { multiWordType = "TEXT SEARCH TEMPLATE"; } + ) + | + // MySQL DROP SPATIAL REFERENCE SYSTEM [IF EXISTS] srid + LOOKAHEAD({ isSpatialReferenceSystemAhead() }) + ContextualKeyword("REFERENCE") { multiWordType = "SPATIAL REFERENCE SYSTEM"; } + | + // PostgreSQL DROP OWNED BY role [, ...] + LOOKAHEAD({ isKeywordAhead("OWNED") && getToken(2).kind == K_BY }) tk= + | + // MySQL DROP RESOURCE GROUP + LOOKAHEAD({ isDropResourceGroupAhead() }) { multiWordType = "RESOURCE GROUP"; } + | + // MySQL DROP UNDO TABLESPACE + LOOKAHEAD({ isKeywordAhead("UNDO") && getToken(2).kind == K_TABLESPACE }) + tk= { drop.setUndo(true); } + | + tk= + | + ( + [ {useTemporary=true;} ] tk= + ) + | + tk= + | + tk= + | + tk= + | + tk= + | + tk= + | + [ { drop.setPublicSynonym(true); } ] tk= + | + tk= + | + tk= + | + tk= + | + tk= + | + // PostgreSQL DROP CAST ( source_type AS target_type ) + tk= | - name=RelObjectName() { value = new StringValue(name).setQuoteStr(""); } + // PostgreSQL DROP EVENT TRIGGER and MySQL DROP EVENT (TRIGGER cannot name a MySQL event) + tk= [ LOOKAHEAD(1) { eventTrigger = true; } ] + | + tk= + | + tk= + | + tk= + | + tk= + | + tk= ) - { return value; } -} + { drop.setType(multiWordType != null ? multiWordType : eventTrigger ? "EVENT TRIGGER" : tk.image); } + [ LOOKAHEAD({ drop.getObjectType() == Drop.ObjectType.INDEX + && getToken(1).kind == K_CONCURRENTLY }) + { drop.setConcurrently(true); } ] -UserAuthentication MySqlUserAuthentication(): -{ - UserAuthentication authentication = new UserAuthentication(); - String plugin = null; - Token credential = null; -} -{ - + [ LOOKAHEAD(2, { drop.getObjectType() != Drop.ObjectType.OWNED }) + {drop.setIfExists(true);} ] + + DropTargets(drop) + [ + // PostgreSQL DROP OPERATOR CLASS and FAMILY require USING: they name one object of an + // index access method. The semantic lookahead alone selects this clause. + LOOKAHEAD({ drop.getObjectType().hasAccessMethod() }) + accessMethod=RelObjectName() { + requireDdlSyntax(drop.getNames().size() == 1, "DROP " + drop.getType() + " takes one name"); + drop.setAccessMethod(accessMethod); + } + ] + [ + LOOKAHEAD({ DropLookahead.isForceAhead(drop, getToken(1), getToken(2), getToken(3)) }) + ( | [ ] "(" ")" ) { drop.setForce(true); } + ] + [ + // MySQL DROP [UNDO] TABLESPACE name [ ENGINE [=] engine_name ] + LOOKAHEAD({ drop.getObjectType() == Drop.ObjectType.TABLESPACE && getToken(1).kind == K_ENGINE }) + [ "=" { drop.setEngineUseEquals(true); } ] engine=RelObjectName() { drop.setEngine(engine); } + ] ( - - ( - credential= { - authentication.setMode(UserAuthentication.Mode.BY_PASSWORD); - authentication.setCredential(new StringValue(credential.image)); - } - | - { - authentication.setMode(UserAuthentication.Mode.BY_RANDOM_PASSWORD); + // MySQL DROP INDEX accepts a trailing algorithm_option / lock_option, e.g. + // "DROP INDEX i ON t ALGORITHM = INPLACE LOCK = NONE". LOCK also starts a LOCK TABLE + // statement, so it is only taken here when it cannot begin the next statement. + LOOKAHEAD({ getToken(1).kind == K_ALGORITHM + || (getToken(1).kind == K_LOCK && getToken(2).kind != K_TABLE) }) + indexOption=IndexAlgorithmOrLockOption() { + if (indexOptions.isEmpty()) { + indexOptionPosition = dropArgs.size(); } - ) - | - plugin=RelObjectName() { - authentication.setMode(UserAuthentication.Mode.WITH_PLUGIN); - authentication.setPlugin(plugin); + indexOptions.add(indexOption); } - [ - - ( - credential= { - authentication.setMode(UserAuthentication.Mode.WITH_PLUGIN_BY_PASSWORD); - authentication.setCredential(new StringValue(credential.image)); - } - | - { - authentication.setMode( - UserAuthentication.Mode.WITH_PLUGIN_BY_RANDOM_PASSWORD); + | + tk= { dropArgs.add(tk.image); } + | + ( + name = DropObjectName() { + if (DropLookahead.isOwnerTable(drop, name)) { + requireNoDropOwnerTable(indexTable); + indexTable = name; + indexTablePosition = dropArgs.size(); + } else { + dropArgs.add("ON"); dropArgs.add(name.toString()); } - ) - | - credential= { - authentication.setMode(UserAuthentication.Mode.WITH_PLUGIN_AS_STRING); - authentication.setCredential(new StringValue(credential.image)); } - ] - ) - { return authentication; } + ) + )* + [ { behavior = CascadeBehavior.CASCADE; } | { behavior = CascadeBehavior.RESTRICT; } ] + { + // a cast, transform or operator signature is followed by CASCADE or RESTRICT only + requireDdlSyntax(!DropLookahead.hasSignatureTargets(drop) + || dropArgs.isEmpty() && indexTable == null && indexOptions.isEmpty(), + "Unexpected clause after DROP " + drop.getType()); + requireDdlSyntax(drop.getObjectType() != Drop.ObjectType.RESOURCE_GROUP + || DropLookahead.isResourceGroupTarget(drop) && dropArgs.isEmpty() + && indexTable == null && indexOptions.isEmpty() && behavior == null, + "DROP RESOURCE GROUP takes one group name and FORCE"); + // MySQL's DROP SPATIAL REFERENCE SYSTEM ends with the SRID + requireDdlSyntax(drop.getObjectType() != Drop.ObjectType.SPATIAL_REFERENCE_SYSTEM + || dropArgs.isEmpty() && indexTable == null && indexOptions.isEmpty() + && behavior == null && !drop.isMaterialized(), + "Unexpected clause in DROP " + drop.getType()); + if (dropArgs.size() > 0) { + drop.setParameters(dropArgs); + } + if (indexTable != null) { + drop.setTable(indexTable, indexTablePosition); + } + if (!indexOptions.isEmpty()) { + drop.setAlgorithmOrLockOptions(indexOptions, indexOptionPosition); + } + drop.setBehavior(behavior); + + drop.setUsingTemporary(useTemporary); + + return drop; + } } -UserAccount MySqlUserAccount(): +/** PostgreSQL REASSIGN OWNED BY role [, ...] TO role */ +ReassignOwned ReassignOwned(): { - UserAccount account = new UserAccount(); - StringValue user = null; - StringValue host = null; - UserAuthentication authentication = null; + ReassignOwned statement = new ReassignOwned(); + UserAccount role; } { - user=MySqlAccountNamePart() { account.setUser(user); } - [ host=MySqlAccountNamePart() { account.setHost(host); } ] - [ authentication=MySqlUserAuthentication() { account.setAuthentication(authentication); } ] - { return account; } + ContextualKeyword("OWNED") + role=MySqlAccountName() { statement.addRoles(role); } + ( "," role=MySqlAccountName() { statement.addRoles(role); } )* + role=MySqlAccountName() { statement.setNewRole(role); } + { return statement; } } -CreateUser CreateUser(): +Truncate Truncate(): { - CreateUser createUser = new CreateUser(); - UserAccount account = null; + Truncate truncate = new Truncate(); + TableReference target; + String log = null, storage = null, identity = null, behavior = null; } { - - [ LOOKAHEAD(3) { createUser.setIfNotExists(true); } ] - account=MySqlUserAccount() { createUser.addAccounts(account); } - ( "," account=MySqlUserAccount() { createUser.addAccounts(account); } )* - { return createUser; } + + [ LOOKAHEAD(2) { truncate.setTableToken(true); } ] + target=RelationTarget() { truncate.getTargets().add(target); } + ( LOOKAHEAD(2) "," target=RelationTarget() { truncate.getTargets().add(target); } )* + [ + LOOKAHEAD({ isKeywordAhead("PRESERVE") || getToken(1).kind == K_PURGE }) + ( ContextualKeyword("PRESERVE") { log = "PRESERVE"; } + | { log = "PURGE"; } ) + + ] + [ + LOOKAHEAD({ getToken(1).kind == K_DROP || isKeywordAhead("REUSE") }) + ( { storage = "DROP"; } + [ { storage = "DROP_ALL"; } ] + | ContextualKeyword("REUSE") { storage = "REUSE"; } ) + + ] + [ ( { identity = "RESTART"; } + | ContextualKeyword("CONTINUE") { identity = "CONTINUE"; } ) + ] + [ { behavior = "CASCADE"; } + | { behavior = "RESTRICT"; } ] + { + RelationOptions.apply(truncate, log, storage, identity, behavior); + return truncate; + } } -EventSchedule MySqlEventSchedule(): + +/** MySQL ADD (table_element_list), preserving interleaved columns, indexes and constraints. */ +void MySqlAlterAddGroup(AlterExpression alterExp): { - EventSchedule schedule = new EventSchedule(); - Expression expression = null; - Token unitToken = null; - String unit = null; + List elements = new ArrayList(); + TableElement element; + boolean mixed = false; } { - - ( - expression=Expression() { - schedule.setType(EventSchedule.Type.AT); - schedule.setExecuteAt(expression); + [ { alterExp.hasColumn(true); } ] + "(" element=MySqlAlterAddGroupElement() { elements.add(element); } + ( "," element=MySqlAlterAddGroupElement() { elements.add(element); } )* + ")" + { + for (TableElement item : elements) { + if (!(item instanceof AlterExpression.ColumnDataType)) { + mixed = true; + } } - | - expression=MySqlEventIntervalValue() { - schedule.setType(EventSchedule.Type.EVERY); - schedule.setInterval(expression); + 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); + } } - ( LOOKAHEAD({ getToken(1).kind == K_DATE_LITERAL }) - unitToken= { schedule.setIntervalUnit(unitToken.image); } - | unit=RelObjectName() { schedule.setIntervalUnit(unit); } ) - [ expression=Expression() { schedule.setStarts(expression); } ] - [ expression=Expression() { schedule.setEnds(expression); } ] - ) - { return schedule; } + } } -Expression MySqlEventIntervalValue(): +TableElement MySqlAlterAddGroupElement(): { - Token value = null; - Expression expression = null; + 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 + * definitions. + */ +void AlterExpressionColumnChanges(AlterExpression alterExp): +{ + AlterExpression.ColumnDataType alterExpressionColumnDataType = null; + AlterExpression.ColumnDropDefault alterExpressionColumnDropDefault = null; + AlterExpression.ColumnSetDefault alterExpressionColumnSetDefault = null; + AlterExpression.ColumnSetNotNull alterExpressionColumnSetNotNull = null; + AlterExpression.ColumnSetVisibility alterExpressionColumnSetVisibility = null; } { ( - value= { expression = new LongValue(value.image); } + LOOKAHEAD(3) alterExpressionColumnDropDefault = AlterExpressionColumnDropDefault() + { alterExp.addColDropDefault(alterExpressionColumnDropDefault); } | - value= { expression = new DoubleValue(value.image); } + LOOKAHEAD(3) alterExpressionColumnSetDefault = AlterExpressionColumnSetDefault() + { alterExp.addColSetDefault(alterExpressionColumnSetDefault); } + | + LOOKAHEAD(4) alterExpressionColumnSetNotNull = AlterExpressionColumnSetNotNull() + { alterExp.addColSetNotNull(alterExpressionColumnSetNotNull); } + | + LOOKAHEAD(3) alterExpressionColumnSetVisibility = AlterExpressionColumnSetVisibility() + { alterExp.addColSetVisibility(alterExpressionColumnSetVisibility); } | - value= { expression = new StringValue(value.image); } + LOOKAHEAD(4) ( + "(" + { alterExp.useBrackets(true);} + alterExpressionColumnDataType = AlterExpressionColumnDataType() { + alterExp.addColDataType(alterExpressionColumnDataType); + } + ( + "," + alterExpressionColumnDataType = AlterExpressionColumnDataType() { + alterExp.addColDataType(alterExpressionColumnDataType); + } + )* + ")" + ) ) - { return expression; } } -Boolean MySqlEventCompletion(): -{ - boolean preserve = true; -} -{ - [ { preserve = false; } ] - LOOKAHEAD({ "PRESERVE".equalsIgnoreCase(getToken(1).image) }) - - { return preserve; } -} -EventStatus MySqlEventStatus(): +AlterExpression.ColumnDataType AlterExpressionColumnDataType(): { - EventStatus status = null; + String columnName = null; + boolean withType = false; + boolean useSetData = false; + ColDataType dataType = null; + List columnOptions = new ArrayList(); + ColumnOption option = null; + AlterExpression.ColumnDataType result; + Expression usingExpression = null; + List identityAlterations = null; + IdentityAlteration identityAlteration; + ColumnPosition position = null; } { + columnName = RelObjectName() ( - { status = EventStatus.ENABLE; } - | - { status = EventStatus.DISABLE; } - [ LOOKAHEAD(2) { status = EventStatus.DISABLE_ON_SLAVE; } ] + LOOKAHEAD({ isIdentityAlterationAhead() }) + { identityAlterations = new ArrayList(); } + identityAlteration=ColumnIdentityAlteration() { identityAlterations.add(identityAlteration); } + ( LOOKAHEAD({ isIdentityAlterationAhead() }) + identityAlteration=ColumnIdentityAlteration() { identityAlterations.add(identityAlteration); } )* + | + [ LOOKAHEAD({ getToken(1).kind == K_TYPE || getToken(1).kind == K_SET && getToken(2).kind == K_DATA }) + useSetData=TypeChangePrefix() { withType = true; } ] + ( LOOKAHEAD(2) dataType = ColDataType() )? + ( LOOKAHEAD(2, { !(withType && getToken(1).kind == K_USING) + && getToken(1).kind != K_FIRST && !isKeywordAhead("AFTER") + && !isTrailingPartitionOptionAhead() }) + option = ColumnDefinitionOption() { + columnOptions.add(option); + } )* + [ LOOKAHEAD({ withType && getToken(1).kind == K_USING }) usingExpression=Expression() ] + [ LOOKAHEAD({ getToken(1).kind == K_FIRST || isKeywordAhead("AFTER") }) + position = ColumnPosition() ] ) - { return status; } -} - -CreateEvent CreateEvent(): -{ - CreateEvent createEvent = new CreateEvent(); - Table event = null; - EventSchedule schedule = null; - Boolean preserve = null; - EventStatus status = null; - Token comment = null; - Statement body = null; -} -{ - - [ LOOKAHEAD(3) { createEvent.setIfNotExists(true); } ] - event=Table() { createEvent.setEvent(event); } - schedule=MySqlEventSchedule() { createEvent.setSchedule(schedule); } - [ LOOKAHEAD(2) preserve=MySqlEventCompletion() { - createEvent.setOnCompletionPreserve(preserve); - } ] - [ LOOKAHEAD({ getToken(1).kind == K_ENABLE || getToken(1).kind == K_DISABLE }) - status=MySqlEventStatus() { createEvent.setStatus(status); } ] - [ LOOKAHEAD({ getToken(1).kind == K_COMMENT }) comment= { - createEvent.setComment(new StringValue(comment.image)); - } ] - body=SingleStatement() { createEvent.setBody(body); } - { return createEvent; } + { + requireDdlSyntax(!withType || dataType != null, "TYPE requires a data type"); + result = new AlterExpression.ColumnDataType(columnName, withType, dataType, null); + result.setUseSetData(useSetData); + result.setUsingExpression(usingExpression); + result.setIdentityAlterations(identityAlterations); + result.setColumnOptions(columnOptions); + result.setPosition(position); + return result; + } } -AlterEvent AlterEvent(): +/** MySQL places an ADD, CHANGE or MODIFY column definition with a trailing FIRST or AFTER col. */ +ColumnPosition ColumnPosition(): { - AlterEvent alterEvent = new AlterEvent(); - Table event = null; - Table renameTo = null; - EventSchedule schedule = null; - Boolean preserve = null; - EventStatus status = null; - Token comment = null; - Statement body = null; + ColumnPosition position; + String columnName; } { - event=Table() { alterEvent.setEvent(event); } - [ LOOKAHEAD({ getToken(1).kind == K_ON && getToken(2).kind == K_SCHEDULE }) - schedule=MySqlEventSchedule() { alterEvent.setSchedule(schedule); } ] - [ LOOKAHEAD({ getToken(1).kind == K_ON && getToken(2).kind == K_COMPLETION }) - preserve=MySqlEventCompletion() { alterEvent.setOnCompletionPreserve(preserve); } ] - [ LOOKAHEAD({ getToken(1).kind == K_RENAME }) - renameTo=Table() { alterEvent.setRenameTo(renameTo); } ] - [ LOOKAHEAD({ getToken(1).kind == K_ENABLE || getToken(1).kind == K_DISABLE }) - status=MySqlEventStatus() { alterEvent.setStatus(status); } ] - [ LOOKAHEAD({ getToken(1).kind == K_COMMENT }) comment= { - alterEvent.setComment(new StringValue(comment.image)); - } ] - [ LOOKAHEAD({ getToken(1).kind == K_DO }) - body=SingleStatement() { alterEvent.setBody(body); } ] - { return alterEvent; } + ( + { position = ColumnPosition.first(); } + | + ContextualKeyword("AFTER") columnName = RelObjectName() + { position = ColumnPosition.after(columnName); } + ) + { return position; } } -TriggerDefiner MySqlTriggerDefiner(): -{ - TriggerDefiner definer = new TriggerDefiner(); - StringValue user = null; - StringValue host = null; -} +/** Type changes in ALTER TABLE and ALTER TYPE accept the same optional SET DATA prefix. */ +boolean TypeChangePrefix(): +{ boolean useSetData = false; } { - LOOKAHEAD({ "DEFINER".equalsIgnoreCase(getToken(1).image) }) - "=" user=MySqlAccountNamePart() { definer.setUser(user); } - [ LOOKAHEAD({ getToken(1).kind == K_AT_SIGN }) - host=MySqlAccountNamePart() { definer.setHost(host); } ] - { return definer; } + [ { useSetData = true; } ] + { return useSetData; } } -CreateTrigger.Timing MySqlTriggerTiming(): +IdentityAlteration ColumnIdentityAlteration(): { - CreateTrigger.Timing timing = null; + IdentityAlteration alteration; + IdentityDefinition identity; + IdentityDefinition.GenerationMode mode; + Sequence.Parameter parameter; + Long restart = null; + Token token; } { ( - { timing = CreateTrigger.Timing.BEFORE; } + identity=IdentityDefinition() { + alteration = new IdentityAlteration(IdentityAlteration.Kind.ADD); + alteration.setIdentityDefinition(identity); + } | - LOOKAHEAD({ "AFTER".equalsIgnoreCase(getToken(1).image) }) - { timing = CreateTrigger.Timing.AFTER; } + + ( + LOOKAHEAD({ isKeywordAhead("GENERATED") }) token= + ( { mode = IdentityDefinition.GenerationMode.ALWAYS; } + | { mode = IdentityDefinition.GenerationMode.BY_DEFAULT; } ) + { + alteration = new IdentityAlteration(IdentityAlteration.Kind.SET_GENERATED); + alteration.setGenerationMode(mode); + } + | + parameter=SequenceParameter() { + alteration = new IdentityAlteration(IdentityAlteration.Kind.SET_PARAMETER); + alteration.setParameters(Collections.singletonList(parameter)); + } + ) + | + [ LOOKAHEAD(1) [ ] restart=SequenceParameterValue() ] { + alteration = new IdentityAlteration(IdentityAlteration.Kind.RESTART); + alteration.setRestartWith(restart); + } + | + { alteration = new IdentityAlteration(IdentityAlteration.Kind.DROP); } + [ LOOKAHEAD(2) { alteration.setIfExists(true); } ] ) - { return timing; } + { return alteration; } } -CreateTrigger.Order MySqlTriggerOrder(): +AlterExpression.ColumnDropNotNull AlterExpressionColumnDropNotNull(): { - CreateTrigger.Order order = null; - Token token = null; + String columnName = null; + boolean withNot = false; + ColDataType dataType = null; + List columnSpecs = null; + List parameter = null; } { - LOOKAHEAD({ "FOLLOWS".equalsIgnoreCase(getToken(1).image) - || "PRECEDES".equalsIgnoreCase(getToken(1).image) }) - token= { - order = "FOLLOWS".equalsIgnoreCase(token.image) - ? CreateTrigger.Order.FOLLOWS : CreateTrigger.Order.PRECEDES; + columnName = RelObjectName() + + ( { withNot = true; } )? + + { + return new AlterExpression.ColumnDropNotNull(columnName, withNot); } - { return order; } } -CreateTrigger CreateTrigger(): +AlterExpression.ColumnSetNotNull AlterExpressionColumnSetNotNull(): { - CreateTrigger createTrigger = new CreateTrigger(); - TriggerDefiner definer = null; - Table trigger = null; - CreateTrigger.Timing timing = null; - Token event = null; - Table table = null; - CreateTrigger.Order order = null; - Table otherTrigger = null; - Statement body = null; + String columnName = null; } { - [ LOOKAHEAD({ "DEFINER".equalsIgnoreCase(getToken(1).image) }) - definer=MySqlTriggerDefiner() { createTrigger.setDefiner(definer); } ] - trigger=Table() { createTrigger.setTrigger(trigger); } - timing=MySqlTriggerTiming() { createTrigger.setTiming(timing); } - ( event= { createTrigger.setEvent(CreateTrigger.Event.INSERT); } - | event= { createTrigger.setEvent(CreateTrigger.Event.UPDATE); } - | event= { createTrigger.setEvent(CreateTrigger.Event.DELETE); } ) - table=Table() { createTrigger.setTable(table); } - - LOOKAHEAD({ "EACH".equalsIgnoreCase(getToken(1).image) }) - [ order=MySqlTriggerOrder() otherTrigger=Table() { - createTrigger.setOrder(order); - createTrigger.setOtherTrigger(otherTrigger); - } ] - ( body=SingleStatement() | body=Block() ) { createTrigger.setBody(body); } - { return createTrigger; } + columnName = RelObjectName() + + + { + return new AlterExpression.ColumnSetNotNull(columnName); + } } -CreateSchema CreateSchema(): -{ - Token tk = null; - CreateTable table = null; - CreateView view = null; - CreateSchema schema = new CreateSchema(); - List schemaPath = null; - List statements = new ArrayList(); - DatabaseOption databaseOption = null; -} +AlterExpression.ColumnDropDefault AlterExpressionColumnDropDefault(): { - - [ LOOKAHEAD(2) { schema.setIfNotExists(true); } ] - [ - ( tk= | tk=) { schema.setSchemaName(tk.image); } - - ( - "." { schema.setCatalogName(tk.image); } - ( tk= | tk=) { schema.setSchemaName(tk.image); } - )? - ] - - ( - LOOKAHEAD({ isMySqlDatabaseOptionAhead() }) - databaseOption=MySqlDatabaseOption() { schema.addDatabaseOptions(databaseOption); } - )* - - [ - (tk= | tk=) { schema.setAuthorization(tk.image); } - ] - - [schemaPath=PathSpecification() { schema.setSchemaPath(schemaPath); }] - - ( - LOOKAHEAD(2) ( - - - table = CreateTable(false) - { - table.getTable().setSchemaName(schema.getSchemaName()); - schema.addStatement(table); - } - | - view = CreateView(false) - { - view.getView().setSchemaName(schema.getSchemaName()); - schema.addStatement(view); - } - ) - )* + String columnName = null; + boolean withNot = false; + ColDataType dataType = null; + List columnSpecs = null; + List parameter = null; +} +{ + columnName = RelObjectName() { - return schema; + return new AlterExpression.ColumnDropDefault(columnName); } } -DatabaseOption MySqlDatabaseOption(): +AlterExpression.ColumnSetDefault AlterExpressionColumnSetDefault(): { - boolean useDefault = false; - boolean useEquals = false; - DatabaseOption.Kind kind = DatabaseOption.Kind.OTHER; - String name = null; - String value = null; - Token valueToken = null; + String columnName = null; + Expression defaultValue = null; } { - [ { useDefault = true; } ] - ( - { - kind = DatabaseOption.Kind.CHARACTER_SET; - name = "CHARACTER SET"; - } - | - { - kind = DatabaseOption.Kind.COLLATE; - name = "COLLATE"; - } - | - { - kind = DatabaseOption.Kind.ENCRYPTION; - name = "ENCRYPTION"; - } - ) - [ "=" { useEquals = true; } ] - ( value=RelObjectName() | valueToken= { value = valueToken.image; } ) - { return new DatabaseOption(kind, name, value, useDefault, useEquals); } + columnName = RelObjectName() defaultValue = Expression() + { + return AlterExpression.ColumnSetDefault.fromExpression(columnName, defaultValue); + } } -List PathSpecification(): +AlterExpression.ColumnSetVisibility AlterExpressionColumnSetVisibility(): { - Token tk; - List pathList = new ArrayList(); + String columnName = null; + boolean visible = true; } { - (tk=|tk=) { pathList.add(tk.image); } - ("," (tk=|tk=) { pathList.add(tk.image); })* + columnName = RelObjectName() + ( + { visible = true; } | + { visible = false; } + ) { - return pathList; + return new AlterExpression.ColumnSetVisibility(columnName, visible); } } -CreateDatabase CreateDatabase(): +List AlterExpressionConstraintState(): { - CreateDatabase createDatabase = new CreateDatabase(); - String databaseName = null; - List databaseOptions = null; - DatabaseOption databaseOption = null; + List retval = new ArrayList(); } { - - [ LOOKAHEAD(2) { createDatabase.setIfNotExists(true); } ] - databaseName = RelObjectName() { createDatabase.setDatabaseName(databaseName); } ( - LOOKAHEAD({ isMySqlDatabaseOptionAhead() }) - databaseOption=MySqlDatabaseOption() { createDatabase.addOptions(databaseOption); } + ( + {retval.add(new DeferrableConstraint(false));} + ) + | + ( + {retval.add(new DeferrableConstraint(true));} + ) + | + ( + {retval.add(new ValidateConstraint(false));} + ) + | + ( + {retval.add(new ValidateConstraint(true));} + ) + | + ( + {retval.add(new EnableConstraint(false));} + ) + | + ( + {retval.add(new EnableConstraint(true));} + ) )* - [ databaseOptions = captureRest() { - createDatabase.addOptions(DatabaseOption.raw(databaseOptions)); - } ] { - return createDatabase; + return retval; } } -/** Shares optional SQL Server constraint modifiers across CREATE and ALTER. */ -Index.Clustering SqlServerIndexClustering(): +void IndexWithComment(IndexOptionSource index): { - Token token; - Index.Clustering clustering = null; + Token tk = null; } { - [ LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && (isKeywordAhead("CLUSTERED") || isKeywordAhead("NONCLUSTERED")) }) - token= { - clustering = Index.Clustering.valueOf(token.image.toUpperCase(Locale.ROOT)); - } - ] - { return clustering; } + tk= { + index.setCommentText(tk.image); + } } -/** Parses PRIMARY, UNIQUE, plain, FULLTEXT, and SPATIAL indexes for CREATE and ALTER. */ -Index TableIndexSpec(boolean createContext): +String UsingIndexType() : { - Token typeToken = null; - Token keywordToken = null; - String indexName = null; - String using = null; - List columns; - List indexOptions = new ArrayList(); - Index index; - Boolean nullsDistinct = null; - Index.Clustering clustering = null; + String sk = null; +} +{ + ( sk = RelObjectName() ) + { + return sk; + } +} + +/** MySQL's index_option, shared by CREATE INDEX and the key definitions of CREATE/ALTER TABLE. */ +IndexSpecOption IndexSpecOption(): +{ + Token token; + String value; + TableOption scalar; + IndexSpecOption option; } { ( - typeToken= keywordToken= - clustering=SqlServerIndexClustering() - [ LOOKAHEAD({ clustering == null && getToken(1).kind != OPENING_BRACKET }) indexName=RelObjectName() ] - columns=IndexColumnsWithParamsList() - TableIndexOptions(createContext, indexOptions) - { - index = new NamedConstraint() - .withIndexName(indexName) - .withType(typeToken.image + " " + keywordToken.image) - .withColumns(columns) - .withIndexSpec(indexOptions); + // KEY_BLOCK_SIZE and the engine attributes share the scalar syntax of table options. + LOOKAHEAD({ getToken(1).kind == K_KEY_BLOCK_SIZE || isMySqlEngineAttributeAhead() }) + scalar=MySqlScalarTableOption() { + option = IndexSpecOption.of(IndexSpecOption.Kind.valueOf(scalar.getKind().name()), + scalar.getValue(), scalar.isUseEquals()); } | - typeToken= - [ LOOKAHEAD(2) [ { nullsDistinct = false; } ] { - if (nullsDistinct == null) { nullsDistinct = true; } - } ] - [ LOOKAHEAD(2) (keywordToken= | keywordToken=) ] - clustering=SqlServerIndexClustering() - [ LOOKAHEAD({ clustering == null && getToken(1).kind != OPENING_BRACKET - && getToken(1).kind != K_USING }) indexName=RelObjectName() ] - [ using=UsingIndexType() ] - columns=IndexColumnsWithParamsList() - TableIndexOptions(createContext, indexOptions) - { - // MySQL ALTER preserves both the constraint symbol and the index name. - if (createContext || Dialect.MYSQL.name().equals(getAsString(Feature.dialect))) { - index = new NamedConstraint() - .withIndexName(indexName) - .withType(typeToken.image - + (keywordToken != null ? " " + keywordToken.image : "")) - .withUsing(using).withColumns(columns).withIndexSpec(indexOptions); - } else { - index = new Index().withType(typeToken.image) - .withIndexKeyword(keywordToken != null ? keywordToken.image : null) - .withName(indexName).withUsing(using).withColumns(columns) - .withIndexSpec(indexOptions); - } - } + value=UsingIndexType() { option = IndexSpecOption.of(IndexSpecOption.Kind.INDEX_TYPE, value); } | - typeToken= - [ LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET - && getToken(1).kind != K_USING }) indexName=RelObjectName() ] - [ using=UsingIndexType() ] - columns=IndexColumnsWithParamsList() - TableIndexOptions(createContext, indexOptions) - { - index = new Index().withType(createContext ? typeToken.image : null) - .withIndexKeyword(typeToken.image).withKind(Index.Kind.INDEX) - .withName(indexName).withUsing(using).withColumns(columns) - .withIndexSpec(indexOptions); - } + value=RelObjectName() + { option = IndexSpecOption.of(IndexSpecOption.Kind.PARSER, value); } | - typeToken= - [ LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET - && getToken(1).kind != K_USING }) indexName=RelObjectName() ] - [ using=UsingIndexType() ] - columns=IndexColumnsWithParamsList() - TableIndexOptions(createContext, indexOptions) - { - index = new Index().withType(createContext ? typeToken.image : null) - .withIndexKeyword(typeToken.image).withKind(Index.Kind.INDEX) - .withName(indexName).withUsing(using).withColumns(columns) - .withIndexSpec(indexOptions); - } + token= { option = IndexSpecOption.comment(stringValue(token)); } | - (typeToken= | typeToken=) - [ LOOKAHEAD(2) (keywordToken= | keywordToken=) ] - [ LOOKAHEAD({ getToken(1).kind != OPENING_BRACKET }) indexName=RelObjectName() ] - columns=IndexColumnsWithParamsList() - TableIndexOptions(createContext, indexOptions) - { - index = new Index().withType(typeToken.image - + (createContext && keywordToken != null - ? " " + keywordToken.image : "")) - .withIndexKeyword(!createContext && keywordToken != null - ? keywordToken.image : null) - .withName(indexName).withColumns(columns).withIndexSpec(indexOptions); - } + { option = IndexSpecOption.visibility(true); } + | + { option = IndexSpecOption.visibility(false); } ) - { index.setNullsDistinct(nullsDistinct); index.setClustering(clustering); } - PostgreSqlConstraintOptions(index) - { return index; } + { return option; } } -void TableIndexOptions(boolean createContext, List options): +TablePartitioning CreateTablePartitioning(): { - List parameter; + TablePartitioning partitioning = null; + TablePartitioning subPartitioning = null; + Expression expression = null; + ExpressionList expressionList = null; + ExpressionList columns = null; + List partitionDefinitions = null; + List parameter = null; + List partitionOptions = new ArrayList(); + Token tk = null; } { + ( - LOOKAHEAD({ createContext }) - ( LOOKAHEAD(2, { !(getToken(1).kind == K_WITH && getToken(2).kind == OPENING_BRACKET) - && !(getToken(1).kind == K_USING && getToken(2).kind == K_INDEX) - && getToken(1).kind != K_DEFERRABLE && !isKeywordAhead("INITIALLY") - && !(getToken(1).kind == K_NOT && (getToken(2).kind == K_DEFERRABLE - || "VALID".equalsIgnoreCase(getToken(2).image))) }) - parameter=CreateParameter() { options.addAll(parameter); } )* + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + partitioning=PostgreSqlPartitionKey() + | + // explicit lookaheads: the method keywords win over the BigQuery + // bare-expression alternative below, which they share a prefix with + LOOKAHEAD(2) partitioning=HashOrKeyPartitioning() + | + LOOKAHEAD(2) { partitioning = new TablePartitioning(TablePartitioning.Type.RANGE); } + ( + "(" expressionList=SimpleExpressionList() ")" { + if (expressionList.size() == 1) { + partitioning.setExpression(expressionList.get(0)); + } else { + partitioning.setExpressionList(expressionList); + } + } + | + "(" columns=ColumnList() ")" + { + partitioning.setColumnsSyntax(true); + partitioning.setColumns(columns); + } + ) + | + LOOKAHEAD(2) { partitioning = new TablePartitioning(TablePartitioning.Type.LIST); } + ( + "(" expressionList=SimpleExpressionList() ")" { + if (expressionList.size() == 1) { + partitioning.setExpression(expressionList.get(0)); + } else { + partitioning.setExpressionList(expressionList); + } + } + | + "(" columns=ColumnList() ")" + { + partitioning.setColumnsSyntax(true); + partitioning.setColumns(columns); + } + ) | - LOOKAHEAD({ !createContext }) IndexOptionList(options) + // BigQuery partitions by a bare expression: PARTITION BY d, PARTITION BY DATE(ts), + // PARTITION BY RANGE_BUCKET(id, GENERATE_ARRAY(0, 100, 10)) + LOOKAHEAD({ getToken(1).kind != K_HASH && getToken(1).kind != K_KEY + && getToken(1).kind != K_LINEAR && getToken(1).kind != K_RANGE + && getToken(1).kind != K_LIST }) + expression=SimpleExpression() + { + partitioning = new TablePartitioning(TablePartitioning.Type.EXPRESSION); + partitioning.setExpression(expression); + } ) + [ LOOKAHEAD({ getToken(1).kind == K_PARTITIONS }) + tk= { partitioning.setPartitions(Long.valueOf(tk.image)); } ] + [ + LOOKAHEAD({ getToken(1).kind == K_SUBPARTITION }) + subPartitioning=HashOrKeyPartitioning() + [ LOOKAHEAD({ getToken(1).kind == K_SUBPARTITIONS }) + tk= + { subPartitioning.setPartitions(Long.valueOf(tk.image)); } ] + { partitioning.setSubPartitioning(subPartitioning); } + ] + [ LOOKAHEAD(2) partitionDefinitions=PartitionDefinitions() + { partitioning.setPartitionDefinitions(partitionDefinitions); } ] + ( LOOKAHEAD(2, { !isCreateTableQueryPrefix() + && !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + parameter=CreateParameter() { partitionOptions.addAll(parameter); } )* + { + if (!partitionOptions.isEmpty()) { + partitioning.setPartitionOptions(partitionOptions); + } + return partitioning; + } } -void PostgreSqlConstraintOptions(Index index): -{ - List columns; - List parameters; - String tableSpace; -} -{ - [ columns=ColumnsNamesList() { index.setIncludeColumns(columns); } ] - [ LOOKAHEAD(2) parameters=PostgreSqlIndexOptions() { index.setStorageParameters(parameters); } ] - [ LOOKAHEAD(3) tableSpace=RelObjectName() { - index.setTableSpace(tableSpace); - } ] -} - -void PostgreSqlConstraintAttributes(Index index): +/** Shares collation/opclass nodes with index keys, excluding index-only ordering. */ +TablePartitioning PostgreSqlPartitionKey(): { - ConstraintAttributes attributes = new ConstraintAttributes(); - boolean present = false; - boolean deferrable = true; - Token token; + TablePartitioning result; + Token method; + List keys; + ExpressionList expressions = new ExpressionList(); + boolean attributes = false; } { - [ LOOKAHEAD(2) [ { deferrable = false; } ] { - attributes.setDeferrable(deferrable); present = true; - } ] - [ LOOKAHEAD({ isKeywordAhead("INITIALLY") }) token= token= { - requireDdlSyntax("IMMEDIATE".equalsIgnoreCase(token.image) || "DEFERRED".equalsIgnoreCase(token.image), - "Expected IMMEDIATE or DEFERRED"); - attributes.setInitially(ConstraintAttributes.Initially.valueOf(token.image.toUpperCase(Locale.ROOT))); - present = true; - } ] - [ LOOKAHEAD({ getToken(1).kind == K_NOT && "VALID".equalsIgnoreCase(getToken(2).image) }) - token= { attributes.setNotValid(true); present = true; } ] - { if (present) { index.setConstraintAttributes(attributes); } } + ( method= | method= | method= ) + keys=IndexKeyColumns(false) + { + result = new TablePartitioning(TablePartitioning.Type.valueOf(method.image.toUpperCase(Locale.ROOT))); + for (KeyElement key : keys) { + requireDdlSyntax(key.getSortOrder() == null && key.getNullOrdering() == null + && key.getOperatorClassParameters() == null, + "Partition keys do not accept index ordering or operator-class parameters"); + attributes |= key.getCollation() != null || key.getOperatorClass() != null; + Expression expression = key.getExpression(); + if (expression == null) { expression = createColumn(key.getColumnName()); } + else if (key.isExpressionParenthesized()) { + expression = new ParenthesedExpressionList(expression); + } + expressions.add(expression); + } + if (attributes) { result.setKeyColumns(keys); } + else if (expressions.size() == 1) { result.setExpression(expressions.get(0)); } + else { result.setExpressionList(expressions); } + return result; + } } -/** - * Parses a single table-level constraint inside {@code CREATE TABLE (...)}. Index forms delegate - * to {@link #TableIndexSpec(boolean)} so CREATE and ALTER expose the same structured AST. - */ -Index CreateTableConstraint(): -{ Index index; } -{ index=TableConstraint(true) { return index; } } - -/** Shared table-constraint body; index option boundaries depend on CREATE versus ALTER. */ -Index TableConstraint(boolean createContext): +PartitionBound PostgreSqlPartitionBound(): { - String constraintName = null; - Index index = null; - ForeignKeyIndex fkIndex = null; - CheckConstraint checkConstraint = null; + PartitionBound bound = null; + ExpressionList expressions = null; + Expression modulus = null; + Expression remainder = null; } { ( - LOOKAHEAD({ isTableIndexAhead() }) index=TableIndexSpec(createContext) + { bound = new PartitionBound(PartitionBound.Type.DEFAULT); } | - - [ LOOKAHEAD({ !isTableIndexAhead() && getToken(1).kind != K_FOREIGN - && getToken(1).kind != K_CHECK && getToken(1).kind != K_EXCLUDE }) constraintName=RelObjectName() ] + ( - LOOKAHEAD({ isTableIndexAhead() }) index=TableIndexSpec(createContext) { - if (index instanceof NamedConstraint) { - ((NamedConstraint) index).setUseConstraintKeyword(true); - index.setName(constraintName); - } + "(" expressions=SimpleExpressionList() ")" + { + bound = new PartitionBound(PartitionBound.Type.RANGE); + bound.setFromExpressions(expressions); } + "(" expressions=SimpleExpressionList() ")" + { bound.setToExpressions(expressions); } | - fkIndex=ForeignKeySpec(constraintName) { - fkIndex.setUseConstraintKeyword(true); - index = fkIndex; + "(" expressions=SimpleExpressionList() ")" + { + bound = new PartitionBound(PartitionBound.Type.LIST); + bound.setInExpressions(expressions); } | - checkConstraint=CheckConstraintSpec(constraintName) { - checkConstraint.setUseConstraintKeyword(true); - index = checkConstraint; + "(" + ( + modulus=Expression() "," remainder=Expression() + | + remainder=Expression() "," modulus=Expression() + ) + ")" + { + bound = new PartitionBound(PartitionBound.Type.HASH); + bound.setModulus(modulus); + bound.setRemainder(remainder); } - | - index=PostgreSqlExcludeConstraint() { index.setName(constraintName); } ) - | - fkIndex=ForeignKeySpec(null) { index = fkIndex; } - | - checkConstraint=CheckConstraintSpec(null) { index = checkConstraint; } - | - index=PostgreSqlExcludeConstraint() ) - PostgreSqlConstraintAttributes(index) - { return index; } + { return bound; } } -ExcludeConstraint PostgreSqlExcludeConstraint(): +TablePartitioning HashOrKeyPartitioning(): { - ExcludeConstraint constraint = new ExcludeConstraint(); - String using; - List columns = new ArrayList(); - Index.ColumnParams column; - Expression predicate; + TablePartitioning partitioning = new TablePartitioning(); + ExpressionList expressionList = null; + ExpressionList columns = null; + Token tk = null; + boolean useEquals = false; } { - - [ LOOKAHEAD(2) using=RelObjectName() { constraint.setUsing(using); } ] - [ LOOKAHEAD(2) "(" column=PostgreSqlExcludeElement() { columns.add(column); } - ( "," column=PostgreSqlExcludeElement() { columns.add(column); } )* ")" - { constraint.setColumns(columns); } ] - PostgreSqlConstraintOptions(constraint) - [ "(" predicate=Expression() ")" { constraint.setExpression(predicate); } ] + [ { partitioning.setLinear(true); } ] + ( + "(" expressionList=SimpleExpressionList() ")" + { + partitioning.setType(TablePartitioning.Type.HASH); + if (expressionList.size() == 1) { + partitioning.setExpression(expressionList.get(0)); + } else { + partitioning.setExpressionList(expressionList); + } + } + | + + [ [ "=" { useEquals = true; } ] tk= + { + partitioning.setAlgorithm(Integer.valueOf(tk.image)); + partitioning.setAlgorithmUseEquals(useEquals); + } + ] + "(" [ columns=ColumnList() ] ")" + { + partitioning.setType(TablePartitioning.Type.KEY); + if (columns == null) { + columns = new ExpressionList(); + } + partitioning.setColumns(columns); + } + ) { - requireDdlSyntax(constraint.getColumns() != null || constraint.getExpression() != null, - "Expected exclusion elements or predicate"); - return constraint; + return partitioning; } } -Index.ColumnParams PostgreSqlExcludeElement(): +List PartitionValues(): { - Index.ColumnParams column; - Token operator; + List values = new ArrayList(); + Expression expression = null; } { - column=IndexColumnWithParams() - ( operator="=" | operator= | operator= | operator="<" | operator=">" - | operator= | operator= | operator="&&" | operator="@>" | operator="<@" ) - { column.setExclusionOperator(operator.image); return column; } + ( + LOOKAHEAD({ getToken(1).kind == K_MAXVALUE }) + { values.add("MAXVALUE"); } + | expression=Expression() { values.add(expression.toString()); } + ) + ( + "," + ( + LOOKAHEAD({ getToken(1).kind == K_MAXVALUE }) + { values.add("MAXVALUE"); } + | expression=Expression() { values.add(expression.toString()); } + ) + )* + { + return values; + } } - -CreateTable CreateTable(boolean isUsingOrReplace): +PartitionDefinition PartitionDefinition(): { - CreateTable createTable = new CreateTable(); - Table table = null; - List tableElements = new ArrayList(); - TableElement element; - List typedTableOptions = new ArrayList(); - List createOptions = new ArrayList(); - Token tk = null; - List parameter = new ArrayList(); - TableOption tableOption = null; - SpannerInterleaveIn interleaveIn = null; - Select select = null; - Table likeTable = null; - RowMovement rowMovement = null; - String tableColumn = null; - List columns = new ArrayList(); - TablePartitioning partitioning = null; - Table partitionOfTable = null; - PartitionBound partitionBound = null; - ColDataType ofType = null; + PartitionDefinition partitionDefinition = new PartitionDefinition(); + List values = null; + List subPartitionDefinitions = null; + String partitionName = null; } { - { createTable.setOrReplace(isUsingOrReplace);} - [ { createTable.setUnlogged(true); } ] - - // table options, not required but 1 or none - [ tk= { createOptions.add(tk.image);} ] - - (parameter = CreateParameter() { createOptions.addAll(parameter); })* - - - [ LOOKAHEAD(2) { createTable.setIfNotExists(true); }] - table=Table() + partitionName=RelObjectName() + { partitionDefinition.setPartitionName(partitionName); } [ - // BigQuery: CREATE [SNAPSHOT] TABLE target CLONE source [FOR SYSTEM_TIME AS OF ...] - LOOKAHEAD(2) likeTable=Table() - [ LOOKAHEAD(2) tableColumn=TimeTravelAfterAlias() { likeTable.setTimeTravel(tableColumn); } ] - { createTable.setCloneTable(likeTable); likeTable = null; } - ] - [ ofType=ColDataType() { createTable.setOfType(ofType); } ] - [ LOOKAHEAD(2) partitionOfTable=Table() - { createTable.setPartitionOf(partitionOfTable); } ] - [ LOOKAHEAD(2) ( - LOOKAHEAD(3) ( - "(" tableColumn=RelObjectName() { columns.add(tableColumn); } ("," tableColumn=RelObjectName() { columns.add(tableColumn); } )* ")" - ) - | + + ( + + { + partitionDefinition.setValueOperator( + PartitionDefinition.ValueOperator.LESS_THAN); + } ( - "(" element=CreateTableElement(ofType != null) { tableElements.add(element); } - ( LOOKAHEAD(2) "," element=CreateTableElement(ofType != null) - { tableElements.add(element); } - )* - [ LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind == K_COMMA && getToken(2).kind == CLOSING_BRACKET }) "," ] - - ")" - ) - ) - ] - [ LOOKAHEAD({ partitionOfTable != null }) - partitionBound=PostgreSqlPartitionBound() - { createTable.setPartitionBound(partitionBound); } ] - CreateTableOptions(typedTableOptions) - [ partitioning=CreateTablePartitioning() { createTable.setPartitioning(partitioning); } ] - - // see https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_7002.htm#i2126725 - // table properties , all these are optional - [ rowMovement = RowMovement() { createTable.setRowMovement(rowMovement); }] - [ LOOKAHEAD(2) - { createTable.setUseAsKeyword(false); } - [ { createTable.setUseAsKeyword(true); } ] - ( LOOKAHEAD() select=TableStatement() | select=Select() ) - { createTable.setSelect(select, false); } - ] - [ - ( LOOKAHEAD("(" Table() ")") "(" likeTable=Table() { createTable.setLikeTable(likeTable, true); } ")" - | likeTable=Table() { createTable.setLikeTable(likeTable, false); } ) + + { + partitionDefinition.setMaxValue(true); + partitionDefinition.setValues(Collections.singletonList("MAXVALUE")); + } + | + "(" values=PartitionValues() ")" { partitionDefinition.setValues(values); } + ) + | + + { + partitionDefinition.setValueOperator(PartitionDefinition.ValueOperator.IN); + } + "(" values=PartitionValues() ")" { partitionDefinition.setValues(values); } + ) ] - [ interleaveIn = SpannerInterleaveIn( ) { createTable.setSpannerInterleaveIn(interleaveIn); } ] + ( PartitionDefinitionOption(partitionDefinition) )* + [ subPartitionDefinitions=SubpartitionDefinitions() + { partitionDefinition.setSubPartitionDefinitions(subPartitionDefinitions); } ] { - createTable.setTable(table); - if (tableElements.size() > 0) - createTable.setTableElements(tableElements); - if (createOptions.size() > 0) - createTable.setCreateOptionsStrings(createOptions); - if (typedTableOptions.size() > 0) - createTable.setTableOptions(typedTableOptions); - if (columns.size() > 0) - createTable.setColumns(columns); - return createTable; + return partitionDefinition; } } -TableElement CreateTableElement(boolean typed): -{ TableElement element; } +List PartitionDefinitions(): { - ( - LOOKAHEAD() element=LikeClause() - | LOOKAHEAD(3) element=CreateTableConstraint() - | element=CreateTableColumnDefinition(typed) - ) - { return element; } + List partitionDefinitions = new ArrayList(); + PartitionDefinition partitionDefinition = null; +} +{ + "(" partitionDefinition=PartitionDefinition() + { partitionDefinitions.add(partitionDefinition); } + ( "," partitionDefinition=PartitionDefinition() + { partitionDefinitions.add(partitionDefinition); } )* + ")" + { + return partitionDefinitions; + } } -ColumnDefinition CreateTableColumnDefinition(boolean typed): +PartitionDefinition SubpartitionDefinition(): { - ColumnDefinition column = null; - String name; - List options = new ArrayList(); - ColumnOption option; - Token token; + PartitionDefinition partitionDefinition = new PartitionDefinition(); + String partitionName = null; } { - { if (!typed) { return ColumnDefinition(); } } - name=RelObjectName() - { column = new ColumnDefinition().withColumnName(name); } - [ LOOKAHEAD(2) token= { - if (!"OPTIONS".equalsIgnoreCase(token.image)) { - throw new ParseException("Expected OPTIONS after WITH"); - } - column.setWithOptions(true); - } ] - ( LOOKAHEAD(2) option=ColumnDefinitionOption() { options.add(option); } )* - { column.setColumnOptions(options); } - { if (true) { return column; } } + partitionName=RelObjectName() + { + partitionDefinition.setPartitionName(partitionName); + partitionDefinition.setSubPartition(true); + } + ( PartitionDefinitionOption(partitionDefinition) )* + { + return partitionDefinition; + } } -/** Reads complete options and keeps commas separate from legacy raw token groups. */ -void CreateTableOptions(List options): -{ TableOption option; } +List SubpartitionDefinitions(): { - [ LOOKAHEAD(2, { getToken(1).kind != K_AS && getToken(1).kind != K_TABLE - && !(getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY) }) - option=CreateTableOption() { options.add(option); } - ( LOOKAHEAD(2, { getToken(1).kind != K_AS && getToken(1).kind != K_TABLE - && !(getToken(1).kind == K_PARTITION && getToken(2).kind == K_BY) - && !(getToken(1).kind == K_COMMA - && "INTERLEAVE".equalsIgnoreCase(getToken(2).image)) }) - [ "," ] option=CreateTableOption() { options.add(option); } - )* - ] + List partitionDefinitions = new ArrayList(); + PartitionDefinition partitionDefinition = null; } - -TableOption CreateTableOption(): -{ TableOption option; List tokens; } { - ( LOOKAHEAD({ isMySqlTableOptionAhead() }) option=MySqlTableOption() - | tokens=CreateParameter() { option = TableOption.raw(tokens); } ) - { return option; } + "(" partitionDefinition=SubpartitionDefinition() + { partitionDefinitions.add(partitionDefinition); } + ( "," partitionDefinition=SubpartitionDefinition() + { partitionDefinitions.add(partitionDefinition); } )* + ")" + { + return partitionDefinitions; + } } -TableOption MySqlTableOption(): { - Token tk; - Token tk2 = null; +void PartitionDefinitionOption(PartitionDefinition partitionDefinition): +{ + Token tk = null; String value = null; - List
unionTables = null; - Table unionTable; boolean useEquals = false; - String name = ""; - TableOption.Kind kind = null; - TableOption option; -} { +} +{ ( - tk= { name = tk.image; kind = TableOption.Kind.UNION; - unionTables = new ArrayList
(); } - [ "=" { useEquals = true; } ] - "(" [ unionTable=Table() { unionTables.add(unionTable); } - ( "," unionTable=Table() { unionTables.add(unionTable); } )* ] ")" + [ { partitionDefinition.setStorageKeyword(true); } ] + [ "=" { useEquals = true; } ] value=RelObjectName() + { + partitionDefinition.setStorageEngine(value); + partitionDefinition.setStorageEngineUseEquals(useEquals); + } | - LOOKAHEAD({ isMySqlStatisticsOptionAhead() }) tk= { - name = tk.image; - kind = TableOption.Kind.valueOf(name.toUpperCase(Locale.ROOT)); + [ "=" { useEquals = true; } ] tk= + { + partitionDefinition.setCommentValue(stringValue(tk)); + partitionDefinition.setCommentUseEquals(useEquals); } - [ "=" { useEquals = true; } ] - ( tk= | tk= ) { value = tk.image; - requireDdlSyntax(kind == TableOption.Kind.STATS_SAMPLE_PAGES - || "DEFAULT".equalsIgnoreCase(value) || "0".equals(value) || "1".equals(value), - "Expected DEFAULT, 0, or 1 for " + name); + | + [ "=" { useEquals = true; } ] tk= + { + partitionDefinition.setDataDirectory(tk.image); + partitionDefinition.setDataDirectoryUseEquals(useEquals); } | - tk= { - name = tk.image; - kind = TableOption.Kind.ENGINE; + [ "=" { useEquals = true; } ] tk= + { + partitionDefinition.setIndexDirectory(tk.image); + partitionDefinition.setIndexDirectoryUseEquals(useEquals); } - [ "=" { useEquals = true; } ] - value=MySqlTableOptionValue() | - [ tk= { name = tk.image + " "; } ] - ( - tk= tk2= { - name += tk.image + " " + tk2.image; - } - | - tk= tk2= { - name += tk.image + " " + tk2.image; - } - | - tk= { name += tk.image; } - | - tk= { - name += tk.image; - kind = TableOption.Kind.COLLATE; - } - ) - { if (kind == null) { kind = TableOption.Kind.CHARACTER_SET; } } - [ "=" { useEquals = true; } ] - value=MySqlTableOptionValue() + [ "=" { useEquals = true; } ] tk= + { + partitionDefinition.setMaxRows(tk.image); + partitionDefinition.setMaxRowsUseEquals(useEquals); + } | - tk= { - name = tk.image; - kind = TableOption.Kind.COMMENT; + [ "=" { useEquals = true; } ] tk= + { + partitionDefinition.setMinRows(tk.image); + partitionDefinition.setMinRowsUseEquals(useEquals); + } + | + [ "=" { useEquals = true; } ] value=RelObjectName() + { + partitionDefinition.setTablespace(value); + partitionDefinition.setTablespaceUseEquals(useEquals); + } + ) +} + +List PartitionNamesList() : +{ + String partitionName = null; + List partitionNames = new ArrayList(); +} +{ + partitionName = RelObjectName() { + partitionNames.add(partitionName); + } + ( + LOOKAHEAD(2) "," partitionName = RelObjectName() { + partitionNames.add(partitionName); + } + )* + { + return partitionNames; + } +} + +/** + * Parses DISCARD/IMPORT (PARTITION names TABLESPACE | TABLESPACE). + * Both keywords share the same structure, differing only in operation enum. + */ +AlterExpression AlterExpressionDiscardOrImport(): +{ + AlterExpression alterExp; + List partitions = null; + AlterOperation partOp; + AlterOperation tableOp; +} +{ + ( + { partOp = AlterOperation.DISCARD_PARTITION; tableOp = AlterOperation.DISCARD_TABLESPACE; } + | + { partOp = AlterOperation.IMPORT_PARTITION; tableOp = AlterOperation.IMPORT_TABLESPACE; } + ) + ( + + { alterExp = new AlterExpressionPartition(); alterExp.setOperation(partOp); } + partitions = PartitionNamesList() + { alterExp.setPartitions(partitions); } + + { alterExp.setTableOption("TABLESPACE"); } + | + + { alterExp = new AlterExpressionTableOption(); alterExp.setOperation(tableOp); } + ) + { return alterExp; } +} + + +/** + * Parses SQL Server's [CONSTRAINT name] DEFAULT expression FOR column [WITH VALUES]. + */ +DefaultConstraint DefaultConstraintSpec(): +{ + DefaultConstraint constraint = new DefaultConstraint(); + String name; + Expression expression; +} +{ + [ name=RelObjectName() { constraint.setName(name); } ] + expression=Expression() { constraint.setExpression(expression); } + name=RelObjectName() { constraint.setColumn(linkToLastToken(createColumn(name))); } + // See InsertBulk(): is in the FOLLOW set of every statement tail. WITH VALUES wins + // over a hypothetical CTE named VALUES, which is the useful reading here. + [ LOOKAHEAD(2) { constraint.setWithValues(true); } ] + { return constraint; } +} + +/** Parses Informix's ADD CONSTRAINT definition [CONSTRAINT name]. */ +NamedConstraint InformixConstraint(): +{ + NamedConstraint constraint; + Token type; + List columns; + String name; +} +{ + + ( + ( type= | type= ) + columns=ColumnsNamesList() { + constraint = new KeyConstraint() + .withType(type.kind == K_PRIMARY ? "PRIMARY KEY" : type.image) + .withColumnsNames(columns); } - [ "=" { useEquals = true; } ] - value=MySqlTableOptionValue() | - tk= { - name = tk.image; - kind = TableOption.Kind.AUTO_INCREMENT; - } - [ "=" { useEquals = true; } ] - value=MySqlTableOptionValue() + constraint=ForeignKeySpec(null) + | + constraint=CheckConstraintSpec(null) ) + [ name=RelObjectName() { constraint.setName(name); } ] { - option = new TableOption(kind, name, value, useEquals); - if (unionTables != null) { option.setUnionTables(unionTables); } - return option; + constraint.setUseConstraintKeyword(true); + constraint.setConstraintNamePosition(NamedConstraint.ConstraintNamePosition.AFTER); + return constraint; } } -String MySqlTableOptionValue(): { - Token token; - String value = null; -} { - ( - value=RelObjectName() - | token= { value = token.image; } - | token= { value = token.image; } - | token= { value = token.image; } - | token= { value = token.image; } - | token= { value = token.image; } - ) - { return value; } -} - -SpannerInterleaveIn SpannerInterleaveIn(): +/** + * Parses ADD/ALTER CONSTRAINT clause within AlterExpression. + * Handles: CONSTRAINT [UNIQUE [KEY|INDEX]] name columns + * CONSTRAINT name (FOREIGN KEY|PRIMARY KEY|UNIQUE|KEY|CHECK|[NOT] ENFORCED) + */ +void AlterExpressionAddConstraint(AlterExpression alterExp): { - Table table = null; - SpannerInterleaveIn.OnDelete action = null; + Token tk; + Token tk2 = null; + String sk3 = null; + List columnNames = null; + ForeignKeyConstraint fkIndex = null; + KeyConstraint index = null; + Table fkTable; + List constraints = null; + CheckConstraint checkCs = null; + IndexOptions.Clustering clustering = null; + String using = null; } { - table = Table() - [ - + + ( + LOOKAHEAD(2) + ( + ( { alterExp.setConstraintType("UNIQUE KEY"); } + | { alterExp.setConstraintType("UNIQUE INDEX"); } + | { alterExp.setConstraintType("UNIQUE"); } ) + sk3=RelObjectName() { + alterExp.setConstraintSymbol(sk3); + index = new KeyConstraint().withType(alterExp.getConstraintType()) + .withIndexName(sk3).withUseConstraintKeyword(true); + } + columnNames=ColumnsNamesList() { + index.setColumnsNames(columnNames); + alterExp.setConstraint(index); + } + ) + | + sk3=RelObjectName() + ( + ( fkIndex=ForeignKeySpec(sk3) + { alterExp.setConstraint(fkIndex); } + constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } + ) + | + ( tk= tk2= + clustering=SqlServerIndexClustering() + [ LOOKAHEAD({ getToken(1).kind == K_USING && getToken(2).kind != K_INDEX }) + using=UsingIndexType() ] + columnNames=ColumnsNamesList() + { + index = new KeyConstraint() + .withName(sk3) + .withType(tk.image + " " + tk2.image) + .withClustering(clustering).withUsing(using) + .withColumnsNames(columnNames); + alterExp.setConstraint(index); + } + AlterExpressionConstraintTail(alterExp, index) + ) + | + LOOKAHEAD(2) ( + { boolean enforced = true; } + [ tk = { enforced = false; } ] + { + alterExp.setEnforced(enforced); + alterExp.setConstraintType("CONSTRAINT"); + alterExp.setConstraintSymbol(sk3); + } + ) + | ( - { action = SpannerInterleaveIn.OnDelete.NO_ACTION; } - | { action = SpannerInterleaveIn.OnDelete.CASCADE; } + checkCs = CheckConstraintSpec(sk3) + { alterExp.setConstraint(checkCs); } ) - ] - { - return new SpannerInterleaveIn(table, action); - } + | + ( + tk= (tk2= | tk2=)? + clustering=SqlServerIndexClustering() + [ LOOKAHEAD({ getToken(1).kind == K_USING && getToken(2).kind != K_INDEX }) + using=UsingIndexType() ] + columnNames=ColumnsNamesList() + { + index = new KeyConstraint() + .withName(sk3) + .withType(tk.image + (tk2!=null?" " + tk2.image:"")) + .withClustering(clustering).withUsing(using) + .withColumnsNames(columnNames); + alterExp.setConstraint(index); + } + AlterExpressionConstraintTail(alterExp, index) + ) + | + ( + tk= + columnNames=ColumnsNamesList() + { + index = new KeyConstraint() + .withName(sk3) + .withType(tk.image) + .withColumnsNames(columnNames); + alterExp.setConstraint(index); + } + constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } + ) + ) + ) } - -ColDataType DataType(): +/** + * Parses the DROP operations within AlterExpression. + * Handles: DROP (PARTITION|columns|COLUMN|INDEX|KEY|UNIQUE|PRIMARY KEY|FOREIGN KEY|CONSTRAINT) + */ +AlterExpression AlterExpressionDrop(): { - ColDataType colDataType = new ColDataType(); - Token prefix = null; - Token tk = null; - Token tk2 = null; - String schema; - String type=""; - List argumentsStringList = new ArrayList(); - List array = new ArrayList(); - List name; - ColDataType arrayType; - Integer zonePrecision = null; - - String precision = null; - Integer scale = null; - String scaleText; + AlterExpressionDrop drop = new AlterExpressionDrop(); + AlterExpression alterExp = drop; + CascadeBehavior behavior; + Token tk; + Token tk2; + List columnNames = null; + List partitions = null; + Index index = null; } { + { alterExp.setOperation(AlterOperation.DROP); } ( - LOOKAHEAD(2) tk= { - type = tk.image; - return ColDataType.fromTypeParameters(type, precision, scale); - } + LOOKAHEAD({ isNamedConstraintDropAhead() }) + MySqlDropNamedConstraint(alterExp) | - LOOKAHEAD(2) tk= ( - ("<" arrayType = ColDataType() ">") { - colDataType.setDataType("ARRAY<" + arrayType.getDataType() + ">"); + ( + { + alterExp = new AlterExpressionPartition(); + alterExp.setOperation(AlterOperation.DROP_PARTITION); + } + partitions=PartitionNamesList() { + alterExp.setPartitions(partitions); } ) | ( - ( tk= | tk= | tk = | tk = | tk = - | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= ) - { - type = tk.image; - // A DT_ZONE image already contains its parameter, e.g. "TIMESTAMP(3) WITH TIME ZONE". - zonePrecision = tk.kind == DT_ZONE ? zonedTypePrecision(tk.image) : null; - } - ( - // Signedness is parsed by ColDataType after optional precision/scale. Do not - // consume CHARACTER when it starts the trailing CHARACTER SET clause. - LOOKAHEAD(2, { getToken(1).kind != K_CHARACTER || getToken(2).kind != K_SET }) - ( tk = - | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= ) { type += " " + tk.image; } - )* + // Oracle Multi Column Drop + columnNames=ColumnsNamesList() { alterExp.setDropColumns(columnNames); columnNames = null; } + [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ] [ - LOOKAHEAD(2) "(" ( tk= { precision = tk.image; } | tk= { precision = "MAX"; } ) - [ | ] - [ "," scaleText=SignedIntegerTypeArgument() { scale = Integer.valueOf(scaleText); } ] - ")" + "CASCADE" { alterExp.addParameters("CASCADE"); } + [ "CONSTRAINTS" { alterExp.addParameters("CONSTRAINTS"); } ] ] - { - colDataType = ColDataType.fromTypeParameters(type, precision, scale); - if (zonePrecision != null) { - colDataType.setPrecision(zonePrecision); - } - } ) + | + ( + ( LOOKAHEAD(2) { alterExp.hasColumn(true); } )? + [ { alterExp.setUsingIfExists(true); } ] + (tk=KeywordOrIdentifier() ) { alterExp.setColumnName(tk.image); } + [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ] + [ + // Oracle CASCADE CONSTRAINTS remains a raw parameter + LOOKAHEAD(2) "CASCADE" "CONSTRAINTS" { alterExp.addParameters("CASCADE", "CONSTRAINTS"); } + | behavior=TypeAlterBehavior() { drop.setBehavior(behavior); } + ] + ) + | + ( + ( tk= | tk= ) + ( tk2= | tk2= ) { + index = new Index().withType(tk.image).withName(tk2.image); + alterExp.setIndex(index); + } + ) + | + ( + tk= { alterExp.setOperation(AlterOperation.DROP_UNIQUE); } + columnNames=ColumnsNamesList() { alterExp.setDropColumns(columnNames); columnNames = null; } + [ behavior=TypeAlterBehavior() { drop.setBehavior(behavior); } ] + ) + | + ( + tk= tk2= { alterExp.setOperation(AlterOperation.DROP_PRIMARY_KEY); } + [ behavior=TypeAlterBehavior() { drop.setBehavior(behavior); } ] + ) + | + ( + tk= tk2= { alterExp.setOperation(AlterOperation.DROP_FOREIGN_KEY); } + columnNames=ColumnsNamesList() { alterExp.setDropColumns(columnNames); columnNames = null; } + [ behavior=TypeAlterBehavior() { drop.setBehavior(behavior); } ] + ) + | + ( + [ { alterExp.setUsingIfExists(true); } ] + ( tk= | tk=) { alterExp.setConstraintName(tk.image); } + [ behavior=TypeAlterBehavior() { drop.setBehavior(behavior); } ] + ) + ) + { 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, + * COALESCE/REORGANIZE/EXCHANGE/PARTITION BY, REMOVE PARTITIONING + */ +AlterExpression AlterExpressionPartitionOp(): +{ + AlterExpressionPartition alterExp = new AlterExpressionPartition(); + AlterOperation operation; + Token tk; + List partitions = null; + List partitionDefinition = null; + Table exchangeTable = null; + TablePartitioning partitioning = null; + AlterExpressionPartition.ExchangeValidationMode validationMode; +} +{ + ( + LOOKAHEAD(2) ( + { operation = AlterOperation.TRUNCATE_PARTITION; } + | { operation = AlterOperation.ANALYZE_PARTITION; } + | { operation = AlterOperation.CHECK_PARTITION; } + | { operation = AlterOperation.OPTIMIZE_PARTITION; } + | { operation = AlterOperation.REBUILD_PARTITION; } + | { operation = AlterOperation.REPAIR_PARTITION; } + ) + { alterExp.setOperation(operation); } + [ + LOOKAHEAD({ operation != AlterOperation.TRUNCATE_PARTITION + && operation != AlterOperation.CHECK_PARTITION + && isPartitionBinlogModifierAhead() }) + PartitionBinlogModifier(alterExp) + ] + partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } + | + LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.COALESCE_PARTITION); } + [ PartitionBinlogModifier(alterExp) ] + tk= { alterExp.setPartitionCount(Integer.valueOf(tk.image)); } + | + LOOKAHEAD(2) + [ LOOKAHEAD({ isPartitionBinlogModifierAhead() }) PartitionBinlogModifier(alterExp) ] + partitions=PartitionNamesList() partitionDefinition=PartitionDefinitions() { + alterExp.setOperation(AlterOperation.REORGANIZE_PARTITION); + alterExp.setPartitions(partitions); + alterExp.setPartitionDefinitions(partitionDefinition); + } + | + LOOKAHEAD(2) partitions=PartitionNamesList() + exchangeTable=Table() + [ LOOKAHEAD(2) validationMode=AlterValidationMode() { alterExp.setExchangeValidationMode(validationMode); } ] + { + alterExp.setOperation(AlterOperation.EXCHANGE_PARTITION); + alterExp.setPartitions(partitions); + alterExp.setExchangeTable(exchangeTable); + } + | + LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.REMOVE_PARTITIONING); } + | + LOOKAHEAD(2) partitioning=CreateTablePartitioning() { + alterExp.setOperation(AlterOperation.PARTITION_BY); + alterExp.setPartitioning(partitioning); + } ) - - { - return colDataType; - } + { return alterExp; } } -/** Shared SQL large-object names; length and array suffixes stay in ColDataType. */ -String LargeObjectTypeName(): +/** + * Parses MySQL ADD PARTITION [NO_WRITE_TO_BINLOG | LOCAL] {(definitions) | PARTITIONS n} + * after ADD. + */ +AlterExpressionPartition AddPartition(): { - Token national = null; - Token type; - Token large; - Token object; + AlterExpressionPartition alterExp = new AlterExpressionPartition(); + List partitionDefinitions; + Token tk; } { - [ LOOKAHEAD() national= ] - ( type= | type= | type= | type= ) - large= object= - { return (national == null ? "" : national.image + " ") - + type.image + " " + large.image + " " + object.image; } + { alterExp.setOperation(AlterOperation.ADD_PARTITION); } + [ PartitionBinlogModifier(alterExp) ] + ( + partitionDefinitions=PartitionDefinitions() { + alterExp.setPartitionDefinitions(partitionDefinitions); + } + | + tk= { alterExp.setPartitionCount(Integer.valueOf(tk.image)); } + ) + { return alterExp; } } -/** Type modifiers accept negative integer constants, but not unary-plus expressions. */ -String SignedIntegerTypeArgument(): +/** Parses MySQL's opt_no_write_to_binlog of a partition operation. */ +void PartitionBinlogModifier(AlterExpressionPartition alterExp): { - Token sign = null; - Token number; + TableMaintenanceStatement.Modifier modifier; } { - [ sign="-" ] number= - { return (sign == null ? "" : sign.image) + number.image; } + modifier=BinlogModifier() { alterExp.setModifier(modifier); } } -ColDataType ColDataType(): +/** + * Parses ADD/ALTER/MODIFY operations within ALTER TABLE. + * Handles: PRIMARY KEY, INDEX/KEY, SPATIAL/FULLTEXT, column COMMENT, + * ADD PARTITION, column definitions, UNIQUE, FOREIGN KEY, CHECK ENFORCED, CONSTRAINT. + */ +AlterExpression AlterExpressionAddAlterModify(): { - ColDataType colDataType = new ColDataType(); - Token prefix = null; - Token tk = null; + AlterExpression alterExp = new AlterExpression(); + Token tk; Token tk2 = null; - String schema; - String type=""; - List argumentsStringList = new ArrayList(); - List array = new ArrayList(); - List name; - ColDataType arrayType; - ColDataType nestedType = null; - String numericArgument = null; - IntervalQualifier intervalQualifier = null; - Integer zonePrecision = null; - - int precision = -1; - int scale = -1; - Token national = null; - Token nationalType = null; - Token varying = null; - ColDataType.TypeModifier typeModifier = null; - XmlTypeModifier xmlTypeModifier = null; + String sk3 = null; + String sk4 = null; + List columnNames = null; + List indexColumnNames = null; + List constraints = null; + Index index = null; + NamedConstraint constraint; + TableElement element; + AlterExpression.ColumnDataType alterExpressionColumnDataType = null; + AlterExpression.ColumnDropNotNull alterExpressionColumnDropNotNull = null; + List indexSpec = new ArrayList(); } { ( - LOOKAHEAD({ isLargeObjectTypeAhead() }) type=LargeObjectTypeName() - { colDataType.setDataType(type); } + { alterExp.setOperation(AlterOperation.ADD); } | - LOOKAHEAD({ isXmlTypeName(getToken(1).image) && "(".equals(getToken(2).image) }) - ( tk= | tk= ) - { colDataType.setDataType(tk.image); } - xmlTypeModifier = XmlTypeModifier() { colDataType.setXmlTypeModifier(xmlTypeModifier); } + { alterExp.setOperation(AlterOperation.ALTER); } | - ( - - "(" - type = RelObjectNameExt() - colDataType = ColDataType() { argumentsStringList.add( type + " " + colDataType.toString()); } - ( - "," - type = RelObjectNameExt() - colDataType = ColDataType() { argumentsStringList.add( type + " " + colDataType.toString()); } - )* - ")" { colDataType = new ColDataType("STRUCT"); } - ) - | - LOOKAHEAD({ isKeywordAhead("NATIONAL") }) ( - national= - (nationalType= | nationalType= | nationalType=) - [ LOOKAHEAD({ isKeywordAhead("VARYING") }) varying= ] - { - type = national.image + " " + nationalType.image - + (varying != null ? " " + varying.image : ""); - colDataType.setDataType(type); - colDataType.setNationalCharacterType( - nationalType.image.equalsIgnoreCase("VARCHAR") || varying != null - ? ColDataType.NationalCharacterType.VARCHAR - : ColDataType.NationalCharacterType.CHAR); - } - ) + { alterExp.setOperation(AlterOperation.MODIFY); } + ) + + ( + LOOKAHEAD({ getToken(1).kind == K_DEFAULT || getToken(1).kind == K_CONSTRAINT + && getToken(3).kind == K_DEFAULT }) constraint=DefaultConstraintSpec() { + requireDdlSyntax(alterExp.getOperation() == AlterOperation.ADD, + "Table-level DEFAULT constraints require ADD"); + alterExp.setConstraint(constraint); + } | - LOOKAHEAD(2) ( - colDataType = DataType() - { - if (isMySqlDialect() - && colDataType.getDataType().toUpperCase(Locale.ROOT).startsWith("NCHAR")) { - colDataType.setNationalCharacterType( - colDataType.getDataType().toUpperCase(Locale.ROOT).contains("VARCHAR") - ? ColDataType.NationalCharacterType.VARCHAR - : ColDataType.NationalCharacterType.CHAR); - } else if (isMySqlDialect() && colDataType.getDataType().toUpperCase(Locale.ROOT) - .startsWith("NVARCHAR")) { - colDataType.setNationalCharacterType(ColDataType.NationalCharacterType.VARCHAR); - } - } - ) + LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ALTER + && getToken(1).kind == K_INDEX }) + tk= sk3=RelObjectName() TableIndexOptions(false, indexSpec) { + index = new Index().withIndexKeyword(tk.image).withName(sk3) + .withKind(Index.Kind.INDEX).withSpecOptions(indexSpec); + alterExp.setIndex(index); + } | - ( - tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - | tk= - ) - { - schema = tk.image; - // A DT_ZONE image already contains its parameter, e.g. "TIMESTAMP(3) WITH TIME ZONE". - zonePrecision = tk.kind == DT_ZONE ? zonedTypePrecision(tk.image) : null; + LOOKAHEAD( ( | + | | ) "(", + { Dialect.INFORMIX.name().equals(getAsString(Feature.dialect)) }) + constraint=InformixConstraint() { + requireDdlSyntax(alterExp.getOperation() == AlterOperation.ADD, + "Informix constraint definitions require ADD"); + alterExp.setConstraint(constraint); } - - // Consume an optional INTERVAL qualifier such as `hour to minute` or - // `day(9) to second`. Only applicable when the matched type is an INTERVAL and - // is immediately followed by a field word, so other types (and the existing - // `interval (2)` precision form handled below) are unaffected. - [ - LOOKAHEAD({ "interval".equalsIgnoreCase(schema) - && getToken(1).kind == K_DATE_LITERAL }) - intervalQualifier = IntervalQualifier() { colDataType.setIntervalQualifier(intervalQualifier); } - ] - [ LOOKAHEAD(2) "." arrayType = ColDataType() { - schema += "." + arrayType.toString(); - colDataType.setPrecision(arrayType.getPrecision()); - colDataType.setScale(arrayType.getScale()); - } ] - { colDataType.setDataType(schema); } - ) - - [ - LOOKAHEAD(2) "(" - ( - { tk2 = null; numericArgument = null; } - ( - LOOKAHEAD(( | ) "(") nestedType=ColDataType() - | - ( + | + LOOKAHEAD([ RelObjectName() ] + ( | ) , + { alterExp.getOperation() == AlterOperation.ADD + && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + constraint=PostgreSqlConstraintUsingIndex() { alterExp.setConstraint(constraint); } + | + LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ADD + && ((Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + || Dialect.MYSQL.name().equals(getAsString(Feature.dialect))) + && (getToken(1).kind == K_CONSTRAINT || getToken(1).kind == K_PRIMARY + || getToken(1).kind == K_UNIQUE || getToken(1).kind == K_FOREIGN + || 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)) }) + element=TableConstraint(false) { setAlterTableElement(alterExp, element); } + | + LOOKAHEAD({ isTableIndexAhead() }) element=TableIndexSpec(false) { + setAlterTableElement(alterExp, element); + } + constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } + [ AlterExpressionUsingIndex(alterExp) ] + | + // Include the literal: COLUMN comment is a column definition, not a COMMENT clause. + LOOKAHEAD(RelObjectName() ) ( + sk3=RelObjectName() tk= { alterExp.withColumnName(sk3).withCommentText(tk.image); } + ) + | + LOOKAHEAD( [ | ] + ( "(" | ), + { 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) ( - ( numericArgument=SignedIntegerTypeArgument() | tk= ) [ LOOKAHEAD(2) (tk2= | tk2=) ] + { alterExp.hasColumn(true); } + | + { alterExp.hasColumns(true); } ) + )? + [ + LOOKAHEAD(2) + ( + { alterExp.setUseIfNotExists(true); } + | + { alterExp.setUsingIfExists(true); } + ) + ] + ( + LOOKAHEAD(3) AlterExpressionColumnChanges(alterExp) | - tk= - | - tk= - | - // DuckDB parameterises types with other types: MAP(VARCHAR, INTEGER) - tk= + LOOKAHEAD(3) alterExpressionColumnDropNotNull = AlterExpressionColumnDropNotNull() + { alterExp.addColDropNotNull( alterExpressionColumnDropNotNull);} | - tk= - ) + LOOKAHEAD(2) alterExpressionColumnDataType = AlterExpressionColumnDataType() + { alterExp.addColDataType(alterExpressionColumnDataType); } + // T-SQL and Snowflake let one ADD list several columns and table + // constraints without repeating ADD. + ( + LOOKAHEAD(",", { alterExp.getOperation() == AlterOperation.ADD + && (Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect)) + || Dialect.SNOWFLAKE.name().equals(getAsString(Feature.dialect))) + && isAlterAddListItemAhead() }) + "," { alterExp.setBareAddList(true); } + ( + LOOKAHEAD({ getToken(1).kind == K_CONSTRAINT || getToken(1).kind == K_CHECK + || getToken(1).kind == K_PRIMARY || getToken(1).kind == K_UNIQUE + || getToken(1).kind == K_FOREIGN }) + element=TableConstraint(false) { setAlterTableElement(alterExp, element); } + | + alterExpressionColumnDataType = AlterExpressionColumnDataType() + { alterExp.addColDataType(alterExpressionColumnDataType); } + ) + )* ) - { - if (nestedType != null) { - argumentsStringList.add(nestedType.toString()); - nestedType = null; - } else { - argumentsStringList.add((numericArgument != null ? numericArgument : tk.image) - + (tk2 != null ? " " + tk2.image : "")); - } + ) + | + LOOKAHEAD(3) AlterExpressionColumnChanges(alterExp) + | + // Standalone FK now uses ForeignKeyConstraint, same as CONSTRAINT FK + ( + { ForeignKeyConstraint fkIndex; } + fkIndex = ForeignKeySpec(null) + { + setAlterTableElement(alterExp, fkIndex); } - - [ "," ] - )* - ")" - ] - ( LOOKAHEAD(1) typeModifier=MySqlTypeModifier() - { colDataType.addTypeModifier(typeModifier); } )* - [ LOOKAHEAD(2) ( LOOKAHEAD(2) "[" {tk=null;} [ tk= ] { array.add(tk!=null?Integer.valueOf(tk.image):null); } "]" )+ { colDataType.setArrayData(array); } ] - [ LOOKAHEAD({ (getToken(1).kind == K_CHARACTER && getToken(2).kind == K_SET) - || isKeywordAhead("CHARSET") }) TypeCharacterSet(colDataType) ] - - { - requireDdlSyntax(colDataType.getXmlTypeModifier() == null || argumentsStringList.isEmpty(), - "Typed XML cannot have additional type arguments"); - if (argumentsStringList.size() > 0) { - colDataType.setArgumentsStringList(argumentsStringList); - // Integer arguments expose numeric parameters, including negative scales. - if (argumentsStringList.size() == 1 && argumentsStringList.get(0).matches("\\d+")) { - colDataType.setNumericPrecision(new java.math.BigInteger(argumentsStringList.get(0))); - } else if (argumentsStringList.size() == 2 && argumentsStringList.get(0).matches("\\d+") - && argumentsStringList.get(1).matches("-?\\d+")) { - colDataType.setNumericPrecision(new java.math.BigInteger(argumentsStringList.get(0))); - colDataType.setScale(Integer.valueOf(argumentsStringList.get(1))); + ) + | + LOOKAHEAD(3) ( + sk3=RelObjectName() + { boolean enforced = true; } + [ tk = { enforced = false; } ] + { + alterExp.setEnforced(enforced); + alterExp.setConstraintType("CHECK"); + alterExp.setConstraintSymbol(sk3); } - } - if (zonePrecision != null) { - colDataType.setPrecision(zonePrecision); - } - return colDataType; - } -} - -/** Shared by column definitions, casts and other uses of ColDataType. */ -void TypeCharacterSet(ColDataType type): -{ - Token name; - boolean abbreviated = false; -} -{ - ( - | LOOKAHEAD({ isKeywordAhead("CHARSET") }) { abbreviated = true; } ) - ( name= | name= | name= | name= ) - { type.setCharacterSet(name.image); type.setUseCharsetKeyword(abbreviated); } + ) + | + ( + AlterExpressionAddConstraint(alterExp) + ) + ) + { return alterExp; } } -XmlTypeModifier XmlTypeModifier(): +/** Parses CockroachDB primary-key elements without legacy raw index parameters. */ +KeyElement CockroachPrimaryKeyColumn(): { - XmlTypeModifier.Kind kind = null; - List names = new ArrayList(); + KeyElement column; String name; + Expression expression; Token token; } -{ - "(" - [ LOOKAHEAD({ (isKeywordAhead("CONTENT") || isKeywordAhead("DOCUMENT")) - && !".".equals(getToken(2).image) && !")".equals(getToken(2).image) }) - token= { kind = XmlTypeModifier.Kind.valueOf(token.image.toUpperCase(Locale.ROOT)); } - ] - name=RelObjectName() { names.add(name); } - [ "." name=RelObjectNameExt() { names.add(name); } ] - ")" - { return new XmlTypeModifier(kind, names); } -} - -ColDataType.TypeModifier MySqlTypeModifier(): -{ - ColDataType.TypeModifier modifier; -} { ( - { modifier = ColDataType.TypeModifier.SIGNED; } - | { modifier = ColDataType.TypeModifier.UNSIGNED; } - | { modifier = ColDataType.TypeModifier.ZEROFILL; } + LOOKAHEAD({ isFunctionAhead() }) expression=Function() + { column = new KeyElement(expression).withExpressionParenthesized(false); } + | + name=RelObjectName() { column = new KeyElement(name); } + | + "(" expression=Expression() ")" { column = new KeyElement(expression); } ) - { return modifier; } + [ (token= | token=) { column.setOperatorClass(token.image); } ] + [ (token= | token=) { + column.setSortOrder(KeyElement.SortOrder.valueOf(token.image.toUpperCase(Locale.ROOT))); + } ] + [ (token= | token=) { + column.setNullOrdering(KeyElement.NullOrdering.valueOf(token.image.toUpperCase(Locale.ROOT))); + } ] + { return column; } } -Analyze Analyze(): +AlterExpressionPrimaryKey CockroachAlterPrimaryKey(): { - Analyze analyze = new Analyze(); - Table table = null; - Column column = null; - Token modifier = null; - Token histogramAction = null; - Token bucketCount = null; + AlterExpressionPrimaryKey action = new AlterExpressionPrimaryKey(); + List columns = new ArrayList(); + KeyElement column; + List options; + Expression bucketCount; + Token token; } { - - [ - LOOKAHEAD(2) - (modifier= | modifier=) - { analyze.setModifier(Analyze.Modifier.valueOf(modifier.image.toUpperCase(Locale.ROOT))); } - ] - [ LOOKAHEAD(2) { analyze.setTableKeyword(true); } ] - table=Table() { analyze.addTables(table); } - ( "," table=Table() { analyze.addTables(table); } )* - [ - LOOKAHEAD(2) - (histogramAction= | histogramAction=) - { - analyze.setHistogramAction(Analyze.HistogramAction.valueOf( - histogramAction.image.toUpperCase(Locale.ROOT))); + + "(" column=CockroachPrimaryKeyColumn() { columns.add(column); } + ( "," column=CockroachPrimaryKeyColumn() { columns.add(column); } )* ")" + { action.getConstraint().setColumns(columns); } + [ { action.setUsingHash(true); } + [ LOOKAHEAD( ) token= { + requireDdlSyntax("BUCKET_COUNT".equalsIgnoreCase(token.image), "Expected BUCKET_COUNT"); } - - column=Column() { analyze.addHistogramColumns(column); } - ( "," column=Column() { analyze.addHistogramColumns(column); } )* - [ - LOOKAHEAD(3) - bucketCount= - { analyze.setHistogramBucketCount(Integer.valueOf(bucketCount.image)); } - ] + "=" bucketCount=Expression() { action.setBucketCount(bucketCount); } ] ] - - { - return analyze; - } -} - -ExpressionList ColumnWithCommentList(): -{ - ExpressionList expressions = new ExpressionList(); - Column img = null; -} -{ - "(" - img=Column() { expressions.add(img); } - ( "," img=Column() { expressions.add(img); } )* - ")" - { - return expressions; - } + // LOOKAHEAD(2) as in the identical constructs at CreateIndex() and AlterExpression(). + [ LOOKAHEAD(2) options=PostgreSqlIndexOptions() { action.getConstraint().setStorageParameters(options); } ] + { return action; } } - -CreateView CreateView(boolean isUsingOrReplace): +/** + * Parses all RENAME variants within ALTER TABLE. + * Handles: RENAME [COLUMN] old TO new, RENAME [TO|AS] tablename, RENAME tablename, + * RENAME INDEX/KEY/CONSTRAINT old TO new. + */ +AlterExpression AlterExpressionRenameOp(): { - CreateView createView = new CreateView(); - Table view = null; - Select select = null; - ExpressionList columnNames = null; - Token tk = null; - List commentTokens = null; - String name = null; - List storageParameters = null; - List viewOptions = new ArrayList(); - ViewOption viewOption = null; - boolean withData = true; + AlterExpression alterExp = new AlterExpressionRename(); + Token tk; + Token tk2; + Index index; + Table newTable; } { - { createView.setOrReplace(isUsingOrReplace);} - [ - { createView.setForce(ForceOption.NO_FORCE); } - | { createView.setForce(ForceOption.FORCE); } - ] - [ { createView.setSecure(true);} ] - [ - { createView.setTemporary(TemporaryOption.TEMP); } - | { createView.setTemporary(TemporaryOption.TEMPORARY); } - | { createView.setTemporary(TemporaryOption.VOLATILE); } - ] - [ { createView.setRecursive(true); } ] - [ { createView.setMaterialized(true);} ] - - [ LOOKAHEAD(3) { createView.setIfNotExists(true); } ] - view=Table() { createView.setView(view); } - [ LOOKAHEAD({ isKeywordAhead("BACKUP") }) tk= - (tk= | tk=) { createView.setBackup(tk.kind == K_YES); } ] - [LOOKAHEAD(3) (tk= | tk=) { createView.setAutoRefresh(AutoRefreshOption.from(tk.image)); } ] - [LOOKAHEAD(3) { - createView.setIfNotExists(true); - createView.setIfNotExistsAfterViewName(true); - }] - [ columnNames=ColumnWithCommentList( ) { createView.setColumnNames(columnNames); } ] - [ commentTokens=CreateViewTailComment( ) { createView.setViewCommentOptions(commentTokens); } ] - [ name=RelObjectName() { createView.setAccessMethod(name); } ] - [ + + ( + LOOKAHEAD(2) ( + ( + { alterExp.setOperation(AlterOperation.RENAME_INDEX); } + | { alterExp.setOperation(AlterOperation.RENAME_KEY); } + ) + | + { alterExp.setOperation(AlterOperation.RENAME_CONSTRAINT); } + ) + (tk= | tk=) { + if (alterExp.getOperation() == AlterOperation.RENAME_CONSTRAINT) { + alterExp.setConstraintName(tk.image); + } else { + alterExp.setOldIndex(new Index().withName(tk.image)); + } + } + + (tk2= | tk2=) { + if (alterExp.getOperation() == AlterOperation.RENAME_CONSTRAINT) { + alterExp.setNewConstraintName(tk2.image); + } else { + index = new Index().withName(tk2.image); + alterExp.setIndex(index); + } + } + | + LOOKAHEAD({ getToken(1).kind == K_TO || getToken(1).kind == K_AS }) ( + (tk= | tk=) { + alterExp.setOperation(AlterOperation.RENAME_TABLE); + alterExp.setTableRenameKeyword(AlterExpression.TableRenameKeyword.valueOf( + tk.image.toUpperCase(Locale.ROOT))); + } + newTable=Table() { alterExp.setNewTable(newTable); } + ) + | + LOOKAHEAD(3) ( - LOOKAHEAD({ createView.isMaterialized() }) - storageParameters=PostgreSqlIndexOptions() { createView.setStorageParameters(storageParameters); } - | - "(" viewOption=PostgreSqlViewOption() { viewOptions.add(viewOption); } - ( "," viewOption=PostgreSqlViewOption() { viewOptions.add(viewOption); } )* ")" - { createView.setOptions(viewOptions); } + { alterExp.setOperation(AlterOperation.RENAME); } + [ { alterExp.hasColumn(true); } ] + (tk=KeywordOrIdentifier()) { alterExp.setColOldName(tk.image); } + + (tk2=KeywordOrIdentifier()) { alterExp.setColumnName(tk2.image); } ) - ] - [ name=RelObjectName() { createView.setTableSpace(name); } ] - - select=Select( ) { createView.setSelect(select); } - [ LOOKAHEAD(2) + | ( - { createView.setWithReadOnly(true); } - | - [ { createView.setCheckOption(CreateView.CheckOption.LOCAL); } - | LOOKAHEAD({ isKeywordAhead("CASCADED") }) tk= - { createView.setCheckOption(CreateView.CheckOption.CASCADED); } ] - { - if (createView.getCheckOption() == null) { - createView.setCheckOption(CreateView.CheckOption.DEFAULT); - } + { + alterExp.setOperation(AlterOperation.RENAME_TABLE); + alterExp.setTableRenameKeyword(AlterExpression.TableRenameKeyword.NONE); } - | - [ { withData = false; } ] { createView.setWithData(withData); } + newTable=Table() { alterExp.setNewTable(newTable); } ) - ] - { createView.validateOptions(); return createView; } + ) + { return alterExp; } } -ViewOption PostgreSqlViewOption(): +AlterExpressionPartition AlterExpressionPostgreSqlPartitionOp(): { - String name; - Expression value = null; - boolean useEquals = false; + AlterExpressionPartition alterExp = new AlterExpressionPartition(); + Table partitionTable = null; + PartitionBound partitionBound = null; } { - name=RelObjectName() - [ "=" { useEquals = true; } value=PrimaryExpression() ] - { return new ViewOption(name, value, useEquals); } + ( + partitionTable=Table() + partitionBound=PostgreSqlPartitionBound() + { + alterExp.setOperation(AlterOperation.ATTACH_PARTITION); + alterExp.setPartitionTable(partitionTable); + alterExp.setPartitionBound(partitionBound); + } + | + partitionTable=Table() + { + alterExp.setOperation(AlterOperation.DETACH_PARTITION); + alterExp.setPartitionTable(partitionTable); + } + [ + { + alterExp.setDetachMode(AlterExpressionPartition.DetachMode.CONCURRENTLY); + } + | + { + alterExp.setDetachMode(AlterExpressionPartition.DetachMode.FINALIZE); + } + ] + ) + { return alterExp; } } -List CreateViewTailComment(): +/** +* Dispatcher production for all ALTER TABLE expression types. +* Delegates to focused sub-productions for each operation category. +*/ +AlterConstraintAttributes AlterConstraintAttributes(): { - Token tk = null; - Token tk2 = null; - String op = null; - List result = new ArrayList(); + AlterConstraintAttributes action = new AlterConstraintAttributes(); + String name; + ConstraintAttributes attributes; } { - tk= - [ "=" { op = "="; } ] - tk2 = { - result.add(""); - result.add(tk.image); - if (op != null) { - result.add(op); - } - result.add(tk2.image); + name=RelObjectName() + attributes=PostgreSqlConstraintAttributeList(null) + { + requireDdlSyntax(attributes != null && !attributes.isNotValid(), + "ALTER CONSTRAINT requires attributes and does not accept NOT VALID"); + action.setConstraintSymbol(name); + action.setAttributes(attributes); + return action; } - { return result;} } - -ReferentialAction.Action Action(): -{ - ReferentialAction.Action action = null; -} +/** WITH VALIDATION or WITHOUT VALIDATION: after EXCHANGE PARTITION, or MySQL's ALTER TABLE modifier. */ +AlterExpressionPartition.ExchangeValidationMode AlterValidationMode(): +{ AlterExpressionPartition.ExchangeValidationMode mode; } { - ( { action=ReferentialAction.Action.CASCADE;} - | - {action=ReferentialAction.Action.RESTRICT;} - | - {action=ReferentialAction.Action.NO_ACTION;} - | - ( - {action=ReferentialAction.Action.SET_NULL;} - | - {action=ReferentialAction.Action.SET_DEFAULT;} - ) - ) - { return action; } + ( { mode = AlterExpressionPartition.ExchangeValidationMode.WITH; } + | { mode = AlterExpressionPartition.ExchangeValidationMode.WITHOUT; } ) + + { return mode; } } -/** - * Parses optional referential actions: [ON DELETE|UPDATE action] [ON DELETE|UPDATE action] - * Shared between CREATE TABLE FK and ALTER TABLE FK definitions. - */ -void ReferentialActions(ForeignKeyReference reference): +AlterExpression AlterExpression(): { + AlterExpression alterExp = null; Token tk; - ReferentialAction.Action action = null; -} -{ - [ LOOKAHEAD(2) ( - - ( tk= | tk= ) action = Action() - { reference.setReferentialAction(ReferentialAction.Type.from(tk.image), action); } - )] - [ LOOKAHEAD(2) ( - - ( tk= | tk= ) action = Action() - { reference.setReferentialAction(ReferentialAction.Type.from(tk.image), action); } - )] -} + Token tk2 = null; + String sk3 = null; + AlterExpressionPartition.ExchangeValidationMode validationMode; -ForeignKeyReference ForeignKeyReferenceSpec(): -{ - ForeignKeyReference reference = new ForeignKeyReference(); - ForeignKeyReference.MatchType matchType; - Token matchToken; - List refColNames = null; - Table fkTable; + // for captureRest() + List tokens = new LinkedList(); } { - fkTable=Table() [ LOOKAHEAD(2) refColNames=ColumnsNamesList() ] - { - reference.setTable(fkTable); - reference.setReferencedColumnNames(refColNames); - } - [ - + + ( + LOOKAHEAD({ isKeywordAhead("OPTIONS") || getToken(1).kind == K_ALTER + && "OPTIONS".equalsIgnoreCase(getToken(getToken(2).kind == K_COLUMN ? 4 : 3).image) }) + alterExp=AlterForeignDataOptions() + | + LOOKAHEAD({ isAlterValidationModifierAhead() }) validationMode=AlterValidationMode() + { alterExp = new AlterExpressionTableOption().withValidationMode(validationMode); } + | + LOOKAHEAD( ) alterExp=MySqlAlterOrderBy() + | + LOOKAHEAD({ isMySqlTableOptionAhead() }) + alterExp=AlterSharedTableOption() + | + LOOKAHEAD({ getToken(1).kind == K_ALTER && getToken(2).kind == K_CONSTRAINT + && isPostgreSqlConstraintAttributeAhead(4) }) alterExp=AlterConstraintAttributes() + | + LOOKAHEAD({ isPostgreSqlRelationActionAhead() }) alterExp=PostgreSqlRelationAction() { + requireDdlSyntax(((RelationAlterAction) alterExp).getColumnNumber() == null, + "ALTER TABLE expects a column name, not an ordinal"); + } + | + LOOKAHEAD( , + { Dialect.COCKROACHDB.name().equals(getAsString(Feature.dialect)) }) + alterExp = CockroachAlterPrimaryKey() + | + alterExp = AlterExpressionAddAlterModify() + | + ( + { alterExp = new AlterExpression(); } + { alterExp.setOperation(AlterOperation.CHANGE); } + [ { alterExp.hasColumn(true); alterExp.setOptionalSpecifier("COLUMN"); } ] ( - { matchType = ForeignKeyReference.MatchType.FULL; } - | matchToken= { - matchType = ForeignKeyReference.MatchType.valueOf( - matchToken.image.toUpperCase(Locale.ROOT)); + { AlterExpression.ColumnDataType alterExpressionColumnDataType; } + (tk=KeywordOrIdentifier()) + alterExpressionColumnDataType = AlterExpressionColumnDataType() { alterExp.withColumnOldName(tk.image).addColDataType(alterExpressionColumnDataType); } + ) + ) + | + alterExp = AlterExpressionDrop() + | + LOOKAHEAD(5) ( + { alterExp = new AlterExpression(); } + { + alterExp.setOperation(AlterOperation.FORCE_ROW_LEVEL_SECURITY); } ) - { reference.setMatchType(matchType); } - ] - ReferentialActions(reference) - { - return reference; - } -} - -/** - * Parses: CHECK ( expression ) - * Returns a CheckConstraint. Shared between CREATE TABLE and ALTER TABLE. - */ -CheckConstraint CheckConstraintSpec(String constraintName): -{ - Expression exp = null; - Boolean enforced = null; - CheckConstraint checkConstraint; -} -{ - "(" exp = Expression() ")" - [ LOOKAHEAD(2) - [ { enforced = false; } ] - { if (enforced == null) { enforced = true; } } - ] - { - checkConstraint = new CheckConstraint().withName(constraintName).withExpression(exp) - .withEnforced(enforced); - checkConstraint.setKind(Index.Kind.CHECK); - return checkConstraint; - } -} + | + LOOKAHEAD(5) ( + { alterExp = new AlterExpression(); } + { + alterExp.setOperation(AlterOperation.NO_FORCE_ROW_LEVEL_SECURITY); + } + ) + | + LOOKAHEAD(1) ( + { alterExp = new AlterExpression(); } + { alterExp.setOperation(AlterOperation.FORCE); } + ) + | + ( + { alterExp = new AlterExpressionTableOption(); } + { alterExp.setOperation(AlterOperation.ALGORITHM); } + ["=" { alterExp.setUseEqual(true);} ] + sk3 = RelObjectName() { alterExp.setAlgorithmOption(sk3); } + ) + | + ( + { alterExp = new AlterExpressionTableOption(); } + { alterExp.setOperation(AlterOperation.LOCK); } + ["=" { alterExp.setUseEqual(true);} ] + sk3 = RelObjectName() { alterExp.setLockOption(sk3); } + ) + | + LOOKAHEAD(2) alterExp = AlterExpressionRenameOp() + | + ({ alterExp = new AlterExpressionCharset(); } + { + alterExp.setOperation(AlterOperation.CONVERT); + alterExp.setConvertType(AlterExpression.ConvertType.CONVERT_TO); + } + + ( + | LOOKAHEAD({ isKeywordAhead("CHARSET") }) { alterExp.setUseCharsetKeyword(true); } ) + ( tk= | tk=CharacterSetName() ) { alterExp.setCharacterSet(tk.image); } + [ LOOKAHEAD(2) tk2=CharacterSetName() { alterExp.setCollation(tk2.image); }] + ) + | + alterExp = AlterExpressionDiscardOrImport() + | + alterExp = AlterExpressionPostgreSqlPartitionOp() + | + LOOKAHEAD(4) ( + { alterExp = new AlterExpression(); } + { + alterExp.setOperation(AlterOperation.DISABLE_ROW_LEVEL_SECURITY); + } + ) + | + LOOKAHEAD(2) ( + { alterExp = new AlterExpressionTableOption(); } + { + alterExp.setOperation(AlterOperation.DISABLE_KEYS); + } + ) + | + LOOKAHEAD(4) ( + { alterExp = new AlterExpression(); } + { + alterExp.setOperation(AlterOperation.ENABLE_ROW_LEVEL_SECURITY); + } + ) + | + LOOKAHEAD(2) ( + { alterExp = new AlterExpressionTableOption(); } + { + alterExp.setOperation(AlterOperation.ENABLE_KEYS); + } + ) + | + alterExp = AlterExpressionPartitionOp() + | + { alterExp = new AlterExpression(); } + tokens = captureRest() { + alterExp.setOperation(AlterOperation.UNSPECIFIC); + StringBuilder optionalSpecifier = new StringBuilder(); + int i=0; -/** - * Parses: FOREIGN KEY columns REFERENCES table [columns] [referential actions] - * Returns a populated ForeignKeyIndex. Shared between CREATE TABLE and ALTER TABLE. - */ -ForeignKeyIndex ForeignKeySpec(String constraintName): -{ - ForeignKeyIndex fkIndex = new ForeignKeyIndex(); - String indexName = null; - Token tk; - Token tk2; - List colNames; - ForeignKeyReference reference; -} -{ - tk= tk2= - [ LOOKAHEAD(2) indexName=RelObjectName() { fkIndex.setIndexName(indexName); } ] - colNames = ColumnNamesWithParamsList() - { - if (constraintName != null) { fkIndex.setName(constraintName); } - fkIndex.withType(tk.image + " " + tk2.image).withColumns(colNames); - } - reference=ForeignKeyReferenceSpec() { fkIndex.setReference(reference); } - { - return fkIndex; - } -} + for (String s: tokens) + if (! (s.equals(";") || s.equals("\n\n\n")) ) { + if (i>0) + optionalSpecifier.append( " " ); + optionalSpecifier.append( s ); + i++; + } -/** - * Parses USING [INDEX] [name] [TABLESPACE name] clause in ALTER TABLE constraint tails. - */ -void AlterExpressionUsingIndex(AlterExpression alterExp): -{ - String sk4; -} -{ - { alterExp.addParameters("USING"); } - [ LOOKAHEAD(2) { alterExp.addParameters("INDEX"); } ] - ( - LOOKAHEAD(2, ) sk4=RelObjectName() - { alterExp.addParameters("TABLESPACE"); alterExp.addParameters(sk4); } - | - sk4=RelObjectName() { alterExp.addParameters(sk4); } - [ LOOKAHEAD(2) sk4=RelObjectName() - { alterExp.addParameters("TABLESPACE"); alterExp.addParameters(sk4); } ] + requireDdlSyntax(i > 0, "Expected an ALTER TABLE action"); + alterExp.setOptionalSpecifier( optionalSpecifier.toString() ); + } ) -} - -/** - * Parses the common tail after a named constraint in ALTER TABLE: - * constraint_state [USING [INDEX] name] [COMMENT 'text'] - */ -void AlterExpressionConstraintTail(AlterExpression alterExp, Index index): -{ - List constraints; -} -{ - constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } - [ LOOKAHEAD(2) AlterExpressionUsingIndex(alterExp) ] - [ LOOKAHEAD(2) index = IndexWithComment(index) { alterExp.setIndex(index); } ] -} -AlterView AlterView(boolean useReplace): -{ - AlterView alterView = new AlterView(); - Table view = null; - Select select = null; - List columnNames = null; -} -{ - view=Table() { alterView.setView(view); alterView.setUseReplace(useReplace); } - [ columnNames = ColumnsNamesList() { alterView.setColumnNames(columnNames); } ] - - select=Select() { - alterView.setSelect(select); - return alterView; + return alterExp; } } - -List CreateParameter(): +Statement Alter(): { - String retval = ""; - Token tk = null, tk2 = null; - Expression exp = null; - ColDataType colDataType; - List param = new ArrayList(); + Statement statement; + List captureRest; } { ( - // Postgres: nextval('public.actor_actor_id_seq'::regclass) - ( "(" tk= "::" colDataType = ColDataType() ")" ) - { - param.add("NextVal( " + tk.image + "::" + colDataType + ")" ); - } - | - ( - //@todo: implement a proper identifier - (tk= | tk= | tk= | tk=) - { retval+=tk.image; } - - [ - "." - //@todo: implement a proper identifier - (tk2= | tk2= | tk=) - { retval+="."+tk2.image; } - ] - { param.add(retval); } - ) - | - LOOKAHEAD(3) [ { param.add("USING INDEX"); }] retval=RelObjectName() - { param.add("TABLESPACE " + retval); } - | ( - tk= | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= | tk= | tk= | tk= - | tk= | tk= | tk= | tk= | tk= | tk = | tk = - | tk= | tk= | tk= | tk= | tk= - | tk= | tk= - // MySQL index_option / algorithm_option / lock_option keywords, e.g. the trailing - // "KEY_BLOCK_SIZE = 8 ALGORITHM = INPLACE LOCK = NONE" of CREATE INDEX, the - // "WITH PARSER" option, and the FULLTEXT / SPATIAL index types of CREATE INDEX. - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= - | tk= | tk= | tk= | tk= - | tk= | tk= | tk= - | tk= | tk= - | tk="=" + + ( + LOOKAHEAD({ isAlterInstanceAhead() }) statement = AlterInstance() + | + LOOKAHEAD( ) statement = AlterForeignDataWrapper() + | + LOOKAHEAD({ isKeywordAhead("SERVER") }) statement = AlterServer() + | + LOOKAHEAD({ getToken(1).kind == K_USER && "MAPPING".equalsIgnoreCase(getToken(2).image) }) statement = AlterUserMapping() + | + LOOKAHEAD({ isAlterLanguageAhead() }) statement = AlterLanguage() + | + LOOKAHEAD({ isWordSequenceAhead(1, "LARGE", "OBJECT") }) statement = AlterLargeObject() + | + LOOKAHEAD({ isTextSearchMetadataAhead() }) statement = AlterTextSearchMetadata() + | + LOOKAHEAD({ getToken(1).kind == K_TEXT_LITERAL && getToken(2).kind == K_SEARCH + && "CONFIGURATION".equalsIgnoreCase(getToken(3).image) }) + statement = AlterTextSearchConfiguration() + | + LOOKAHEAD({ isKeywordAhead("COLLATION") }) statement = AlterCollation() + | + LOOKAHEAD({ isKeywordAhead("RULE") }) statement = AlterRule() + | + LOOKAHEAD({ isPostgreSqlOperatorDdlAhead() }) statement = PostgreSqlAlterOperator() + | + LOOKAHEAD(1, ) statement = AlterAggregate() + | + LOOKAHEAD({ isKeywordAhead("STATISTICS") }) statement = AlterStatistics() + | + LOOKAHEAD({ isAlterConversionAhead() }) statement = AlterConversion() + | + // Other routine forms, such as SQL Server definitions, remain unsupported. + LOOKAHEAD({ isAlterRoutineAhead() }) statement = AlterRoutine() + | + LOOKAHEAD(AlterTrigger() ( | )) statement = AlterTrigger() + | + LOOKAHEAD(1, ) statement = AlterPolicy() + | + LOOKAHEAD({ isMySqlAlterUserAhead() }) statement = AlterUser() + | + LOOKAHEAD({ isKeywordAhead("ROLE") || isKeywordAhead("USER") || isKeywordAhead("GROUP") }) + statement = AlterRole() + | + statement = AlterDefaultPrivileges() + | + LOOKAHEAD({ (getToken(1).kind == K_DATABASE || getToken(1).kind == K_SCHEMA) + && Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) }) + statement = AlterDatabase() + | + // Other dialects keep unmodelled ALTER DATABASE forms as unsupported statements. + LOOKAHEAD(AlterDatabase()) statement = AlterDatabase() + | + LOOKAHEAD(1, ) statement = AlterSchema() + | + LOOKAHEAD(1, ) statement = AlterType() + | + LOOKAHEAD(1, ) statement = AlterDomain() + | + LOOKAHEAD({ isKeywordAhead("EXTENSION") }) statement = AlterExtension() + | + LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) statement = AlterPublication() + | + LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) statement = AlterSubscription() + | + LOOKAHEAD({ isPostgreSqlEventTriggerAhead(true) }) statement = AlterEventTrigger() + | + LOOKAHEAD([ MySqlRoutineDefiner() ] , + { getToken(1).kind == K_EVENT || isKeywordAhead("DEFINER") }) + statement = AlterEvent() + | + LOOKAHEAD(( | | ) ) + statement = PostgreSqlTablespaceMove() + | + // other ALTER TABLESPACE forms, such as Oracle data file clauses, remain unsupported + LOOKAHEAD(AlterTablespace() ( | )) + statement = AlterTablespace() + | + statement = AlterForeignTable() + | + statement = AlterTable(false) + | + statement = AlterSession() + | + LOOKAHEAD(MySqlViewPrefix() Table() [ ColumnsNamesList() ] ) statement = AlterView(false) + | + LOOKAHEAD({ getToken(1).kind == K_INDEX || getToken(1).kind == K_MATERIALIZED + || getToken(1).kind == K_VIEW }) statement=PostgreSqlAlterRelation() + | + statement = AlterSystemStatement() + | + statement = AlterSequence() + | + captureRest = captureRest() + { + statement = new UnsupportedStatement("ALTER", captureRest); + } + ) ) - { param.add(tk.image); } - | - ( tk= | tk= | tk= ) [ LOOKAHEAD(2) "(" exp = Expression() ")" ] - { - param.add(tk.image); - if (exp!=null) { - param.add("(" + exp + ")"); - } - } | ( - [ ( tk="+" | tk="-" ) { retval = tk.image; } ] - tk= | tk= - ) - { param.add( retval + tk.image ); } - | - retval=AList() { param.add(retval); } - | - (tk= tk2=) { param.add(tk.image); param.add(tk2.image);} - | - ( exp=ArrayConstructor(true)) { param.add(exp.toString()); } - | - tk="::" colDataType = ColDataType() { param.add(tk.image); param.add(colDataType.toString()); } - ) - {return param;} -} - -// row_movement_clause https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_7002.htm#i2204697 -RowMovement RowMovement(): -{ - RowMovement rowMovement = new RowMovement(); -} -{ - ( - ( ) { rowMovement.setMode(RowMovementMode.ENABLE); } - | - ( ) { rowMovement.setMode(RowMovementMode.DISABLE); } - ) - { return rowMovement;} -} - -String AList(): -{ - StringBuilder retval = new StringBuilder("("); - Token tk = null; - String name = null; -} -{ - "(" - - ( - ( (tk= | tk= | tk= | tk= | tk=) { retval.append(tk.image); } - | (name=RelObjectName()) { retval.append(name); }) - [("," {retval.append(",");} | "=" {retval.append("=");})] )* - - ")" + + ( + statement = AlterView(true) + | + captureRest = captureRest() + { + statement = new UnsupportedStatement("REPLACE", captureRest); + } + ) + ) + ) { - retval.append(")"); - return retval.toString(); + return statement; } } -String ColumnsNamesListItem(): +AlterTablespaceMove PostgreSqlTablespaceMove(): { - Token tk = null; - Token sortDirection = null; - String item = null; + AlterTablespaceMove result = new AlterTablespaceMove(); + String name; } { - ( item = RelObjectName() ) - [ LOOKAHEAD(2) "(" tk = ")" { item = item + "(" + tk.image + ")"; } ] - [ LOOKAHEAD( ( | ) ( "," | ")" ) ) (sortDirection = | sortDirection = ) { item = item + " " + sortDirection.image; } ] - { - return item; - } + ( { result.setObjectType(AlterTablespaceMove.ObjectType.TABLE); } + | { result.setObjectType(AlterTablespaceMove.ObjectType.INDEX); } + | { result.setObjectType(AlterTablespaceMove.ObjectType.MATERIALIZED_VIEW); } ) + name=RelObjectName() { result.setSourceTablespace(name); } + [ ContextualKeyword("OWNED") name=RelObjectName() { result.getOwners().add(name); } + ( "," name=RelObjectName() { result.getOwners().add(name); } )* ] + name=RelObjectName() { result.setTargetTablespace(name); } + [ { result.setNoWait(true); } ] + { return result; } } -List ColumnsNamesList(): +/** + * MySQL CREATE [UNDO] TABLESPACE with InnoDB options, or PostgreSQL CREATE TABLESPACE with an + * owner, a location and tablespace parameters. + */ +CreateTablespace CreateTablespace(): { - List retval = new ArrayList(); - String img = null; + CreateTablespace statement = new CreateTablespace(); + String name; + Token token; + StringValue dataFile; + List parameters; + List options; } { - "(" - img=ColumnsNamesListItem() { retval.add(img); } - ( "," img=ColumnsNamesListItem() { retval.add(img); } )* + ( + LOOKAHEAD({ isKeywordAhead("UNDO") }) ContextualKeyword("UNDO") + name=RelObjectName() { statement.setUndo(true); statement.setName(name); } + dataFile=MySqlTablespaceDataFile() { statement.setDataFile(dataFile); } + [ LOOKAHEAD({ isMySqlTablespaceOptionAhead(1) }) options=MySqlTablespaceOptions(true, true) + { statement.setOptions(options); } ] + | + name=RelObjectName() { statement.setName(name); } + ( + LOOKAHEAD({ isKeywordAhead("OWNER") || isKeywordAhead("LOCATION") }) + [ LOOKAHEAD({ isKeywordAhead("OWNER") }) ContextualKeyword("OWNER") + name=RelObjectName() { statement.setOwner(name); } ] + ContextualKeyword("LOCATION") token= + { statement.setLocation(stringValue(token)); } + [ LOOKAHEAD( "(") parameters=PostgreSqlIndexOptions() + { statement.setParameters(parameters); } ] + | + [ dataFile=MySqlTablespaceDataFile() { statement.setDataFile(dataFile); } ] + [ LOOKAHEAD({ isMySqlTablespaceOptionAhead(1) }) options=MySqlTablespaceOptions(true, false) + { statement.setOptions(options); } ] + ) + ) + { return statement; } +} - ")" - { - return retval; - } +StringValue MySqlTablespaceDataFile(): +{ Token token; } +{ + ContextualKeyword("DATAFILE") token= { return stringValue(token); } } -String FuncArgsListItem(): +/** + * MySQL ALTER [UNDO] TABLESPACE and PostgreSQL ALTER TABLESPACE. Alter() selects this production + * only when it matches the whole statement. + */ +AlterTablespace AlterTablespace(): { - Token tk = null; - String argName = null; - String argType = null; + AlterTablespace statement = new AlterTablespace(); + String name; + List parameters; + List names = new ArrayList(); + List options; } { ( - LOOKAHEAD(2) ( - argName = RelObjectName() - argType = RelObjectName() - [ "(" tk = ")" { argType = argType + "(" + tk.image + ")"; } ] + LOOKAHEAD({ isKeywordAhead("UNDO") }) ContextualKeyword("UNDO") + name=RelObjectName() { statement.setUndo(true); statement.setName(name); } + + ( + { statement.setState(AlterTablespace.State.ACTIVE); } + | LOOKAHEAD({ isKeywordAhead("INACTIVE") }) ContextualKeyword("INACTIVE") + { statement.setState(AlterTablespace.State.INACTIVE); } ) + { statement.setAction(AlterTablespace.Action.SET_STATE); } + [ LOOKAHEAD({ isMySqlTablespaceOptionAhead(1) }) options=MySqlTablespaceOptions(false, true) + { statement.setOptions(options); } ] | + name=RelObjectName() { statement.setName(name); } ( - argType = RelObjectName() - [ "(" tk = ")" { argType = argType + "(" + tk.image + ")"; } ] + name=RelObjectName() + { statement.setAction(AlterTablespace.Action.RENAME); statement.setNewName(name); } + | + LOOKAHEAD({ isKeywordAhead("OWNER") }) ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(AlterTablespace.Action.OWNER); statement.setOwner(name); } + | + parameters=PostgreSqlIndexOptions() + { statement.setAction(AlterTablespace.Action.SET_PARAMETERS); statement.setParameters(parameters); } + | + "(" name=PostgreSqlStorageParameterName() { names.add(name); } + ( "," name=PostgreSqlStorageParameterName() { names.add(name); } )* ")" + { statement.setAction(AlterTablespace.Action.RESET_PARAMETERS); statement.setResetParameters(names); } + | + LOOKAHEAD({ isMySqlTablespaceOptionAhead(1) }) options=MySqlTablespaceOptions(false, false) + { statement.setAction(AlterTablespace.Action.OPTIONS); statement.setOptions(options); } ) ) - { - return argName != null ? String.format("%s %s", argName, argType) : argType; - } + { return statement; } } -List FuncArgsList(): +/** + * MySQL tablespace options in source order, optionally separated by commas. Each clause accepts + * only the options that it defines. + */ +List MySqlTablespaceOptions(boolean create, boolean undo): { - List retval = null; - String img = null; + List options = new ArrayList(); + TableOption option; } { - "(" - { retval = new ArrayList(); } - [ - img=FuncArgsListItem() { retval.add(img); } - ( "," img=FuncArgsListItem() { retval.add(img); } )* - ] - ")" - { - return retval; - } + option=MySqlTablespaceOption() { options.add(validateTablespaceOption(option, create, undo)); } + ( + LOOKAHEAD({ isMySqlTablespaceOptionAhead(1) + || getToken(1).kind == K_COMMA && isMySqlTablespaceOptionAhead(2) }) + [ "," ] option=MySqlTablespaceOption() + { options.add(validateTablespaceOption(option, create, undo)); } + )* + { return options; } } -/** DROP names are lexer-separated identifiers, not strings to split again on dots. */ -Table DropObjectName() #TableName: +/** Reuses the table option models for ENGINE, ENCRYPTION, AUTOEXTEND_SIZE and ENGINE_ATTRIBUTE. */ +TableOption MySqlTablespaceOption(): { - ObjectNames names; - Token literal; - Table table; - String timeTravel = null; + TableOption option; + String value; + boolean useEquals = false; } { ( - names=RelObjectNames() [ LOOKAHEAD(2) timeTravel=TimeTravelBeforeAlias() ] - { table = names.getNames().size() == 1 ? new Table(names.getNames().get(0), false) - : new Table(names.getNames()); table.setTimeTravel(timeTravel); } + LOOKAHEAD({ isKeywordAhead("FILE_BLOCK_SIZE") }) ContextualKeyword("FILE_BLOCK_SIZE") + [ "=" { useEquals = true; } ] value=MySqlSizeNumber() + { option = new TableOption(TableOption.Kind.FILE_BLOCK_SIZE, "FILE_BLOCK_SIZE", value, useEquals); } | - literal= { table = new Table(literal.image, false); } + LOOKAHEAD({ getToken(1).kind == K_ENGINE }) option=MySqlTableOption() + | + option=MySqlScalarTableOption() ) - { linkAST(table, jjtThis); return table; } + { return option; } } -Drop Drop(): +/** The new relation statements reuse the same actions as structured ALTER TABLE properties. */ +AlterRelation PostgreSqlAlterRelation(): { - Drop drop = new Drop(); - Token tk = null; - Table name; - Table indexTable = null; - int indexTablePosition = 0; - List dropArgs = new ArrayList(); - List funcArgs = null; - List indexOption; - boolean useTemporary = false; + AlterRelation result = new AlterRelation(); + Table relation; + RelationAlterAction action; +} +{ + ( { result.setObjectType(AlterRelation.ObjectType.INDEX); } + | { result.setObjectType(AlterRelation.ObjectType.VIEW); } + | { result.setObjectType(AlterRelation.ObjectType.MATERIALIZED_VIEW); } ) + [ LOOKAHEAD(2) { result.setIfExists(true); } ] + relation=Table() { result.setRelation(relation); } + action=PostgreSqlRelationAction() { + validateRelationAction(result.getObjectType(), action); result.getActions().add(action); + } + ( "," action=PostgreSqlRelationAction() { + validateRelationAction(result.getObjectType(), action); result.getActions().add(action); + } )* + { + if (result.getActions().size() > 1) { + for (RelationAlterAction item : result.getActions()) { + requireDdlSyntax(!EnumSet.of(RelationAlterAction.Kind.RENAME, + RelationAlterAction.Kind.RENAME_COLUMN, RelationAlterAction.Kind.SET_SCHEMA, + RelationAlterAction.Kind.ATTACH_PARTITION, RelationAlterAction.Kind.DEPENDS_ON_EXTENSION) + .contains(item.getKind()), "This relation action must be a separate statement"); + } + } + return result; + } +} + +/** Shared state syntax; each caller applies its own target restrictions. */ +RelationAlterAction.EnableState PostgreSqlEnableState(): +{ RelationAlterAction.EnableState state; } +{ + ( { state = RelationAlterAction.EnableState.DISABLE; } + | { state = RelationAlterAction.EnableState.ENABLE; } + [ { state = RelationAlterAction.EnableState.ENABLE_ALWAYS; } + | LOOKAHEAD({ isKeywordAhead("REPLICA") }) ContextualKeyword("REPLICA") + { state = RelationAlterAction.EnableState.ENABLE_REPLICA; } ] ) + { return state; } +} + +RelationAlterAction PostgreSqlRelationAction(): +{ + RelationAlterAction action = new RelationAlterAction(); + String name; + Token token; + Table relation; + Expression expression; + Long statistics; + RelationAlterAction.EnableState enableState; + List options; + List names = new ArrayList(); } { - - [ { drop.setMaterialized(true);} ] ( - tk= + LOOKAHEAD({ isKeywordAhead("CLUSTER") }) name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.CLUSTER_ON); action.setValue(name); } + | + name=AccessQualifiedName() + { action.setKind(RelationAlterAction.Kind.OF); action.setValue(name); } | + { action.setKind(RelationAlterAction.Kind.NOT_OF); } + | + enableState=PostgreSqlEnableState() { action.setEnableState(enableState); } ( - [ {useTemporary=true;} ] tk= + + ( LOOKAHEAD(1) { action.setTriggerTarget(RelationAlterAction.TriggerTarget.ALL); } + | LOOKAHEAD(1) { action.setTriggerTarget(RelationAlterAction.TriggerTarget.USER); } + | name=RelObjectName() { action.setTriggerTarget(RelationAlterAction.TriggerTarget.NAME); action.setValue(name); } ) + { + action.setKind(RelationAlterAction.Kind.TRIGGER_STATE); + requireDdlSyntax(action.getTriggerTarget() == RelationAlterAction.TriggerTarget.NAME + || enableState == RelationAlterAction.EnableState.ENABLE + || enableState == RelationAlterAction.EnableState.DISABLE, + "ENABLE ALWAYS/REPLICA requires a trigger name"); + } + | ContextualKeyword("RULE") name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.RULE_STATE); action.setValue(name); } ) | - tk= + + ( + LOOKAHEAD(1) name=RelObjectName() { + action.setKind(RelationAlterAction.Kind.RENAME); action.setNewName(name); + } + | + [ LOOKAHEAD(1) { action.hasColumn(true); } ] + name=RelObjectName() { action.setColumnName(name); } + name=RelObjectName() { + action.setKind(RelationAlterAction.Kind.RENAME_COLUMN); action.setNewName(name); + } + ) | - tk= + LOOKAHEAD({ isKeywordAhead("OWNER") }) ContextualKeyword("OWNER") name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.OWNER); action.setValue(name); } | - tk= + + ( + + ( LOOKAHEAD({ isKeywordAhead("CLUSTER") }) + { action.setKind(RelationAlterAction.Kind.SET_WITHOUT_CLUSTER); } + | ContextualKeyword("OIDS") { action.setKind(RelationAlterAction.Kind.SET_WITHOUT_OIDS); } ) + | { action.setKind(RelationAlterAction.Kind.SET_UNLOGGED); } + | LOOKAHEAD({ isKeywordAhead("LOGGED") }) ContextualKeyword("LOGGED") + { action.setKind(RelationAlterAction.Kind.SET_LOGGED); } + | name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.SET_SCHEMA); action.setValue(name); } + | name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.SET_TABLESPACE); action.setValue(name); } + | LOOKAHEAD({ isKeywordAhead("ACCESS") }) ContextualKeyword("ACCESS") ContextualKeyword("METHOD") name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.SET_ACCESS_METHOD); action.setValue(name); } + | options=PostgreSqlIndexOptions() + { action.setKind(RelationAlterAction.Kind.SET_OPTIONS); action.setOptions(options); } + ) | - tk= + "(" name=IndexKeyAttributeName() { names.add(name); } + ( "," name=IndexKeyAttributeName() { names.add(name); } )* ")" + { action.setKind(RelationAlterAction.Kind.RESET_OPTIONS); action.setResetOptions(names); } | - tk= + LOOKAHEAD( ) name=RelObjectName() + [ { action.setNoInherit(true); } ] ContextualKeyword("INHERIT") + { action.setKind(RelationAlterAction.Kind.ALTER_CONSTRAINT_INHERIT); action.setConstraintName(name); } | - tk= + [ LOOKAHEAD(1) { action.hasColumn(true); } ] + ( token= { action.setColumnNumber(Integer.valueOf(token.image)); } + | name=RelObjectName() { action.setColumnName(name); } ) + { action.setKind(RelationAlterAction.Kind.ALTER_COLUMN); } + ( + + ( + expression=Expression() { + action.setColumnAction(RelationAlterAction.ColumnAction.SET_DEFAULT); + action.setDefaultExpression(expression); + } + | + LOOKAHEAD({ isKeywordAhead("EXPRESSION") }) ContextualKeyword("EXPRESSION") + expression=ColumnGenerationExpression() { + action.setColumnAction(RelationAlterAction.ColumnAction.SET_EXPRESSION); + action.setGenerationExpression(expression); + } + | + LOOKAHEAD({ isKeywordAhead("STATISTICS") }) ContextualKeyword("STATISTICS") + { action.setColumnAction(RelationAlterAction.ColumnAction.SET_STATISTICS); } + ( { action.setStatisticsDefault(true); } + | statistics=SequenceParameterValue() { + requireDdlSyntax(statistics >= -1 && statistics <= 10000, "Statistics target must be between -1 and 10000"); + action.setStatistics(statistics); + } ) + | + LOOKAHEAD(1, "(") options=PostgreSqlIndexOptions() { + for (IndexOption option : options) { + requireDdlSyntax(option.getValue() != null && option.isUseEquals(), + "Column attributes require a value and an equals sign"); + } + action.setColumnAction(RelationAlterAction.ColumnAction.SET_OPTIONS); action.setOptions(options); + } + | + ( token= | token= | token= ) { + requireDdlSyntax(Arrays.asList("PLAIN", "EXTERNAL", "EXTENDED", "MAIN", "DEFAULT") + .contains(token.image.toUpperCase(Locale.ROOT)), "Invalid column storage strategy"); + action.setColumnAction(RelationAlterAction.ColumnAction.SET_STORAGE); action.setValue(token.image); + } + | + ContextualKeyword("COMPRESSION") name=RelObjectName() + { action.setColumnAction(RelationAlterAction.ColumnAction.SET_COMPRESSION); action.setValue(name); } + ) + | + "(" name=RelObjectName() { names.add(name); } + ( "," name=RelObjectName() { names.add(name); } )* ")" + { action.setColumnAction(RelationAlterAction.ColumnAction.RESET_OPTIONS); action.setResetOptions(names); } + | + + ( + { action.setColumnAction(RelationAlterAction.ColumnAction.DROP_DEFAULT); } + | + ContextualKeyword("EXPRESSION") { action.setColumnAction(RelationAlterAction.ColumnAction.DROP_EXPRESSION); } + [ LOOKAHEAD(2) { action.setUsingIfExists(true); } ] + ) + ) | - tk= + relation=Table() + { action.setKind(RelationAlterAction.Kind.ATTACH_PARTITION); action.setRelation(relation); } | - tk= - ) - { drop.setType(tk.image); } - - [ LOOKAHEAD(2) {drop.setIfExists(true);} ] - - name = DropObjectName() { drop.setName(name); } - ( "," name = DropObjectName() { drop.addNames(name); } )* - [ LOOKAHEAD(2) funcArgs = FuncArgsList() ] - ( - LOOKAHEAD({ getToken(1).kind == K_ALGORITHM - || (getToken(1).kind == K_LOCK && getToken(2).kind != K_TABLE) }) - indexOption=IndexAlgorithmOrLockOption() { dropArgs.addAll(indexOption); } + LOOKAHEAD({ isKeywordAhead("DEPENDS") || getToken(1).kind == K_NO && "DEPENDS".equalsIgnoreCase(getToken(2).image) }) + [ { action.setNoDependency(true); } ] ContextualKeyword("DEPENDS") ContextualKeyword("EXTENSION") name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.DEPENDS_ON_EXTENSION); action.setValue(name); } | - ( - tk= | tk= | tk= - // MySQL DROP INDEX accepts a trailing algorithm_option / lock_option, - // e.g. "DROP INDEX i ON t ALGORITHM = INPLACE LOCK = NONE". - | tk= | tk= | tk="=" - ) { dropArgs.add(tk.image); } + name=RelObjectName() + { action.setKind(RelationAlterAction.Kind.VALIDATE_CONSTRAINT); action.setConstraintName(name); } | + LOOKAHEAD({ isKeywordAhead("REPLICA") }) ContextualKeyword("REPLICA") + { action.setKind(RelationAlterAction.Kind.REPLICA_IDENTITY); } ( - name = DropObjectName() { - if (drop.getObjectType() == Drop.ObjectType.INDEX) { - requireNoDropIndexOwner(indexTable); - indexTable = name; - indexTablePosition = dropArgs.size(); - } else { - dropArgs.add("ON"); dropArgs.add(name.toString()); - } - } + name=RelObjectName() + { action.setReplicaIdentity(RelationAlterAction.ReplicaIdentity.USING_INDEX); action.setValue(name); } + | ( token= | token= | token= | token= ) + { action.setReplicaIdentity(accessEnum(RelationAlterAction.ReplicaIdentity.class, token.image)); } ) | - // The lock_option of DROP INDEX. LOCK also starts a LOCK TABLE statement, so it is only - // taken as a DROP argument when it cannot be the beginning of the next statement. - LOOKAHEAD({ getToken(1).kind == K_LOCK && getToken(2).kind != K_TABLE }) - tk= { dropArgs.add(tk.image); } - )* - { - if (dropArgs.size() > 0) { - drop.setParameters(dropArgs); - } - if (indexTable != null) { - drop.setTable(indexTable, indexTablePosition); - } - if (drop.getType().equals("FUNCTION")) { - drop.getTypeToParameters().put("FUNCTION", funcArgs); - } - - drop.setUsingTemporary(useTemporary); - - return drop; - } + [ { action.setNoInherit(true); } ] ContextualKeyword("INHERIT") relation=Table() + { action.setKind(RelationAlterAction.Kind.INHERIT); action.setRelation(relation); } + ) + { return action; } } -Truncate Truncate(): +AlterForeignDataOptions AlterForeignDataOptions(): { - Truncate truncate = new Truncate(); - Table table; - List
tables = new ArrayList
(); - boolean only = false; - boolean cascade = false; + AlterForeignDataOptions action = new AlterForeignDataOptions(); + String name; + List options; } { -/** -* TRUNCATE can be followed directly by the table name in Postgresql -* See: https://www.postgresql.org/docs/current/sql-truncate.html -* -* TRUNCATE [ TABLE ] [ ONLY ] name [ * ] [, ... ] -* [ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ] -* -*/ - - [LOOKAHEAD(2) {truncate.setTableToken(true);}] - [ { only = true; }] - table=Table() { tables.add(table); } (LOOKAHEAD(2) "," table=Table() { tables.add(table); } )* - [ { cascade = true; }] - { - if (only && tables.size() > 1 ) { - throw new ParseException("Cannot TRUNCATE ONLY with multiple tables"); - } else { - return truncate - .withTables(tables) - .withTable(table) - .withOnly(only) - .withCascade(cascade); - } - } + [ [ LOOKAHEAD(1) { action.hasColumn(true); } ] + name=RelObjectName() { action.setColumnName(name); } ] + options=ForeignDataOptions(true) { action.setOptions(options); } + { return action; } } -/** - * 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 - * definitions. - */ -void AlterExpressionColumnChanges(AlterExpression alterExp): +Alter AlterForeignTable(): +{ Alter alter; } { - AlterExpression.ColumnDataType alterExpressionColumnDataType = null; - AlterExpression.ColumnDropDefault alterExpressionColumnDropDefault = null; - AlterExpression.ColumnSetDefault alterExpressionColumnSetDefault = null; - AlterExpression.ColumnSetNotNull alterExpressionColumnSetNotNull = null; - AlterExpression.ColumnSetVisibility alterExpressionColumnSetVisibility = null; -} -{ - ( - LOOKAHEAD(3) alterExpressionColumnDropDefault = AlterExpressionColumnDropDefault() - { alterExp.addColDropDefault(alterExpressionColumnDropDefault); } - | - LOOKAHEAD(3) alterExpressionColumnSetDefault = AlterExpressionColumnSetDefault() - { alterExp.addColSetDefault(alterExpressionColumnSetDefault); } - | - LOOKAHEAD(4) alterExpressionColumnSetNotNull = AlterExpressionColumnSetNotNull() - { alterExp.addColSetNotNull(alterExpressionColumnSetNotNull); } - | - LOOKAHEAD(3) alterExpressionColumnSetVisibility = AlterExpressionColumnSetVisibility() - { alterExp.addColSetVisibility(alterExpressionColumnSetVisibility); } - | - LOOKAHEAD(4) ( - "(" - { alterExp.useBrackets(true);} - alterExpressionColumnDataType = AlterExpressionColumnDataType() { - alterExp.addColDataType(alterExpressionColumnDataType); - } - ( - "," - alterExpressionColumnDataType = AlterExpressionColumnDataType() { - alterExp.addColDataType(alterExpressionColumnDataType); - } - )* - ")" - ) - ) + alter=AlterTable(true) { alter.setForeignTable(true); return alter; } } - - -AlterExpression.ColumnDataType AlterExpressionColumnDataType(): -{ - String columnName = null; - boolean withType = false; - ColDataType dataType = null; - List columnSpecs = new ArrayList(); - List columnOptions = new ArrayList(); - ColumnOption option = null; - AlterExpression.ColumnDataType result; - Expression usingExpression = null; - List identityAlterations = null; - IdentityAlteration identityAlteration; + +Alter AlterTable(boolean foreign): +{ + Alter alter = new Alter(); + Table table; + AlterExpression alterExp; + AlterExpression previous; + boolean usingIfExists = false; } { - columnName = RelObjectName() + { alter.setForeignTable(foreign); } + [ LOOKAHEAD(2) { alter.setUseTableIfExists(true); } ] + [ LOOKAHEAD(2) { alter.setUseOnly(true); } ] + [ LOOKAHEAD(2) { + requireDdlSyntax(!alter.isUseTableIfExists(), "Duplicate IF EXISTS"); + alter.setUseTableIfExists(true); + } ] + table=Table() { alter.setTable(table); } + [ "*" { + requireDdlSyntax(!alter.isUseOnly(), "ONLY cannot be combined with descendant marker"); + alter.setUseDescendants(true); + } ] + + alterExp=AlterExpression() { alter.addAlterExpression(alterExp); } + ( - LOOKAHEAD({ isIdentityAlterationAhead() }) - { identityAlterations = new ArrayList(); } - identityAlteration=ColumnIdentityAlteration() { identityAlterations.add(identityAlteration); } - ( LOOKAHEAD({ isIdentityAlterationAhead() }) - identityAlteration=ColumnIdentityAlteration() { identityAlterations.add(identityAlteration); } )* - | - ( LOOKAHEAD(2) { withType = true; } )? - ( LOOKAHEAD(2) dataType = ColDataType() )? - ( LOOKAHEAD(2, { !(withType && getToken(1).kind == K_USING) }) option = ColumnDefinitionOption() { - columnOptions.add(option); - columnSpecs.addAll(option.getTokens()); - } )* - [ LOOKAHEAD({ withType && getToken(1).kind == K_USING }) usingExpression=Expression() ] - ) + "," { previous = alterExp; } alterExp=AlterExpression() + { + requireDdlSyntax(!isMisplacedAlterValidationModifier(previous, alterExp), + "WITH or WITHOUT VALIDATION cannot follow a command that ends the action list"); + alter.addAlterExpression(alterExp); + } + | LOOKAHEAD({ isMySqlTableOptionAhead() }) + { requireDdlSyntax(isMySqlTableOptionAction(alterExp), "Expected a comma before table options"); } + alterExp=AlterSharedTableOption() { alter.addAlterExpression(alterExp); } + )* + + // MySQL partition_options end the action list without a comma + [ + LOOKAHEAD({ isTrailingPartitionOptionAhead() }) + { + requireDdlSyntax(!Alter.isTrailingPartitionOption(alterExp), + "PARTITION BY and REMOVE PARTITIONING cannot follow each other"); + } + alterExp=AlterExpressionPartitionOp() { alter.addAlterExpression(alterExp); } + ] + { - result = new AlterExpression.ColumnDataType(columnName, withType, dataType, columnSpecs); - result.setUsingExpression(usingExpression); - result.setIdentityAlterations(identityAlterations); - if (hasStructuredColumnOption(columnOptions)) { - result.setColumnOptions(columnOptions); + for (AlterExpression action : alter.getAlterExpressions()) { + requireDdlSyntax(foreign || !(action instanceof AlterForeignDataOptions), "OPTIONS requires ALTER FOREIGN TABLE"); } - return result; + return alter; } } -IdentityAlteration ColumnIdentityAlteration(): +AlterSession AlterSession(): { - IdentityAlteration alteration; - IdentityDefinition identity; - IdentityDefinition.GenerationMode mode; - Sequence.Parameter parameter; - Long restart = null; + AlterSessionOperation operation = null; + List parameters = new ArrayList(); Token token; } { - ( - identity=IdentityDefinition() { - alteration = new IdentityAlteration(IdentityAlteration.Kind.ADD); - alteration.setIdentityDefinition(identity); - } + ( + ( + ( { operation = AlterSessionOperation.ADVISE_COMMIT; } + | { operation = AlterSessionOperation.ADVISE_ROLLBACK; } + | { operation = AlterSessionOperation.ADVISE_NOTHING; } + ) + ) | - ( - LOOKAHEAD({ isKeywordAhead("GENERATED") }) token= - ( { mode = IdentityDefinition.GenerationMode.ALWAYS; } - | { mode = IdentityDefinition.GenerationMode.BY_DEFAULT; } ) - { - alteration = new IdentityAlteration(IdentityAlteration.Kind.SET_GENERATED); - alteration.setGenerationMode(mode); - } - | - parameter=SequenceParameter() { - alteration = new IdentityAlteration(IdentityAlteration.Kind.SET_PARAMETER); - alteration.setParameters(Collections.singletonList(parameter)); - } + { operation = AlterSessionOperation.CLOSE_DATABASE_LINK; } ) | - [ LOOKAHEAD(2) restart=SequenceParameterValue() ] { - alteration = new IdentityAlteration(IdentityAlteration.Kind.RESTART); - alteration.setRestartWith(restart); - } + ( + ( { operation = AlterSessionOperation.ENABLE_COMMIT_IN_PROCEDURE; } + | { operation = AlterSessionOperation.ENABLE_GUARD; } + | ( { operation = AlterSessionOperation.ENABLE_PARALLEL_DML; } + | { operation = AlterSessionOperation.ENABLE_PARALLEL_DDL; } + | { operation = AlterSessionOperation.ENABLE_PARALLEL_QUERY; } + ) + | { operation = AlterSessionOperation.ENABLE_RESUMABLE; } + ) + ) | - { alteration = new IdentityAlteration(IdentityAlteration.Kind.DROP); } - [ LOOKAHEAD(2) { alteration.setIfExists(true); } ] + ( + ( { operation = AlterSessionOperation.DISABLE_COMMIT_IN_PROCEDURE; } + | { operation = AlterSessionOperation.DISABLE_GUARD; } + | ( { operation = AlterSessionOperation.DISABLE_PARALLEL_DML; } + | { operation = AlterSessionOperation.DISABLE_PARALLEL_DDL; } + | { operation = AlterSessionOperation.DISABLE_PARALLEL_QUERY; } + ) + | { operation = AlterSessionOperation.DISABLE_RESUMABLE; } + ) + ) + | + ( + ( { operation = AlterSessionOperation.FORCE_PARALLEL_DML; } + | { operation = AlterSessionOperation.FORCE_PARALLEL_DDL; } + | { operation = AlterSessionOperation.FORCE_PARALLEL_QUERY; } + ) + ) + | + ( + { operation = AlterSessionOperation.SET; } + ) ) - { return alteration; } -} -AlterExpression.ColumnDropNotNull AlterExpressionColumnDropNotNull(): -{ - String columnName = null; - boolean withNot = false; - ColDataType dataType = null; - List columnSpecs = null; - List parameter = null; -} -{ - columnName = RelObjectName() - - ( { withNot = true; } )? - + ( ( token = + | token = + | token = "=" + | token = + | token = + ) { parameters.add( token.image ); } + )* + + { - return new AlterExpression.ColumnDropNotNull(columnName, withNot); + return new AlterSession(operation, parameters); } } -AlterExpression.ColumnSetNotNull AlterExpressionColumnSetNotNull(): +AlterSystemStatement AlterSystemStatement(): { - String columnName = null; + AlterSystemOperation operation = null; + List parameters = new LinkedList(); } { - columnName = RelObjectName() - - + ( + ( + { operation = AlterSystemOperation.ARCHIVE_LOG; } + ) + | + ( + { operation = AlterSystemOperation.CHECKPOINT; } + ) + | + ( + { operation = AlterSystemOperation.DUMP_ACTIVE_SESSION_HISTORY; } + ) + | + ( + ( + ContextualKeyword("DISTRIBUTED") ContextualKeyword("RECOVERY") { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; } + | { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; } + ) + ) + | + ( + ( + ContextualKeyword("DISTRIBUTED") ContextualKeyword("RECOVERY") { operation = AlterSystemOperation.DISABLE_DISTRIBUTED_RECOVERY; } + | { operation = AlterSystemOperation.DISABLE_RESTRICTED_SESSION; } + ) + ) + | + ( + { operation = AlterSystemOperation.FLUSH; } + ) + | + ( + { operation = AlterSystemOperation.DISCONNECT_SESSION; } + ) + | + ( + { operation = AlterSystemOperation.KILL_SESSION; } + ) + | + ( + { operation = AlterSystemOperation.SWITCH; } + ) + | + ( + { operation = AlterSystemOperation.SUSPEND; } + ) + | + ( + { operation = AlterSystemOperation.RESUME; } + ) + | + ( + { operation = AlterSystemOperation.QUIESCE; } + ) + | + ( + { operation = AlterSystemOperation.UNQUIESCE; } + ) + | + ( + { operation = AlterSystemOperation.SHUTDOWN; } + ) + | + ( + { operation = AlterSystemOperation.REGISTER; } + ) + | + ( + { operation = AlterSystemOperation.SET; } + ) + | + ( + { operation = AlterSystemOperation.RESET; } + ) + ) + parameters = captureRest() + { - return new AlterExpression.ColumnSetNotNull(columnName); + return new AlterSystemStatement(operation, parameters); } } -AlterExpression.ColumnDropDefault AlterExpressionColumnDropDefault(): +Wait Wait(): { - String columnName = null; - boolean withNot = false; - ColDataType dataType = null; - List columnSpecs = null; - List parameter = null; + Wait wait = new Wait(); + Token token = null; } { - columnName = RelObjectName() + // sqlserver-oracle-> WAIT (TIMEOUT) + // https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_10002.htm#i2126016 + token= { - return new AlterExpression.ColumnDropDefault(columnName); + wait.setTimeout(Long.parseLong(token.image)); + return wait; } } -AlterExpression.ColumnSetDefault AlterExpressionColumnSetDefault(): +StartTransaction StartTransaction(): { - String columnName = null; - Expression defaultValue = null; + StartTransaction statement = new StartTransaction(); + TransactionKeyword keyword; } { - columnName = RelObjectName() defaultValue = Expression() - { - return AlterExpression.ColumnSetDefault.fromExpression(columnName, defaultValue); - } + ( + ContextualKeyword("TRANSACTION") + | + { statement.setCommand(StartTransaction.Command.BEGIN); } + [ LOOKAHEAD({ getToken(1).kind == K_WORK || isKeywordAhead("TRANSACTION") }) + keyword=TransactionKeyword() { statement.setKeyword(keyword); } ] + ) + [ LOOKAHEAD({ isTransactionModeAhead() }) + TransactionModeList(statement.getModes(), statement.getModeContext()) ] + { return statement; } } -AlterExpression.ColumnSetVisibility AlterExpressionColumnSetVisibility(): +TransactionKeyword TransactionKeyword(): +{ TransactionKeyword keyword; } { - String columnName = null; - boolean visible = true; + ( { keyword = TransactionKeyword.WORK; } + | ContextualKeyword("TRANSACTION") { keyword = TransactionKeyword.TRANSACTION; + requireDdlSyntax(!isMySqlDialect(), "MySQL does not accept the TRANSACTION keyword here"); } ) + { return keyword; } } + +TransactionChain TransactionChain(): +{ boolean negative = false; } +{ + [ { negative = true; } ] ContextualKeyword("CHAIN") + { return negative ? TransactionChain.NO_CHAIN : TransactionChain.CHAIN; } +} + +TransactionRelease TransactionRelease(): +{ boolean negative = false; } { - columnName = RelObjectName() - ( - { visible = true; } | - { visible = false; } - ) - { - return new AlterExpression.ColumnSetVisibility(columnName, visible); - } + [ { negative = true; } ] + { return negative ? TransactionRelease.NO_RELEASE : TransactionRelease.RELEASE; } } -List AlterExpressionConstraintState(): +/** + * Transaction characteristics of BEGIN, START TRANSACTION and SET TRANSACTION. PostgreSQL + * separates them with commas or spaces, MySQL with commas; requireTransactionModes() applies the + * dialect rules of the context. + */ +void TransactionModeList(List modes, TransactionMode.Context context): +{ TransactionMode mode; boolean comma; } { - List retval = new ArrayList(); + mode=TransactionMode() { modes.add(mode); } + ( + LOOKAHEAD({ ",".equals(getToken(1).image) || isTransactionModeAhead() }) + { comma = false; } + [ "," { comma = true; } ] + mode=TransactionMode() + { requireDdlSyntax(!isMySqlDialect() || comma, "MySQL transaction characteristics require commas"); + modes.add(mode); } + )* + { requireTransactionModes(modes, context); } } + +TransactionMode TransactionMode(): +{ TransactionMode mode; } { ( + LOOKAHEAD({ isKeywordAhead("ISOLATION") }) + ContextualKeyword("ISOLATION") ( - {retval.add(new DeferrableConstraint(false));} - ) - | - ( - {retval.add(new DeferrableConstraint(true));} + LOOKAHEAD({ isKeywordAhead("SERIALIZABLE") }) ContextualKeyword("SERIALIZABLE") + { mode = TransactionMode.ISOLATION_LEVEL_SERIALIZABLE; } + | { mode = TransactionMode.ISOLATION_LEVEL_REPEATABLE_READ; } + | + ( LOOKAHEAD({ isKeywordAhead("COMMITTED") }) ContextualKeyword("COMMITTED") + { mode = TransactionMode.ISOLATION_LEVEL_READ_COMMITTED; } + | ContextualKeyword("UNCOMMITTED") { mode = TransactionMode.ISOLATION_LEVEL_READ_UNCOMMITTED; } ) ) | - ( - {retval.add(new ValidateConstraint(false));} - ) + + ( { mode = TransactionMode.READ_ONLY; } + | ContextualKeyword("WRITE") { mode = TransactionMode.READ_WRITE; } ) | - ( - {retval.add(new ValidateConstraint(true));} - ) + { mode = TransactionMode.DEFERRABLE; } | - ( - {retval.add(new EnableConstraint(false));} - ) + { mode = TransactionMode.NOT_DEFERRABLE; } | - ( - {retval.add(new EnableConstraint(true));} - ) - )* - { - return retval; - } + ContextualKeyword("CONSISTENT") ContextualKeyword("SNAPSHOT") + { mode = TransactionMode.WITH_CONSISTENT_SNAPSHOT; } + ) + { return mode; } } -Index IndexWithComment(Index index): -{ - Token tk = null; -} +ReleaseSavepointStatement ReleaseSavepointStatement(): +{ String name; boolean usingSavepointKeyword = false; } { - tk= { - index.setCommentText(tk.image); - } - { - return index; - } + + [ LOOKAHEAD({ getToken(1).kind == K_SAVEPOINT }) { usingSavepointKeyword = true; } ] + name=RelObjectName() + { requireDdlSyntax(!isMySqlDialect() || usingSavepointKeyword, "MySQL RELEASE requires SAVEPOINT"); + return new ReleaseSavepointStatement(name).withUsingSavepointKeyword(usingSavepointKeyword); } } -void IndexOptionList(List list) : -{} +SavepointStatement SavepointStatement(): +{ String name; } { - ( - LOOKAHEAD(2) IndexOption(list) - )* + name=RelObjectName() + { return new SavepointStatement(name); } } -String UsingIndexType() : +RollbackStatement RollbackStatement(): { - String sk = null; + RollbackStatement statement = new RollbackStatement(); + TransactionKeyword keyword; + TransactionChain chain; + TransactionRelease release; + String name; + TransactionId id; } { - ( sk = RelObjectName() ) + ( + + | + // The action keeps the JAVACODE call from being the lookahead's first unit. + LOOKAHEAD({ isWordAt(1, "ABORT") }) { statement.setCommand(RollbackStatement.Command.ABORT); } + consumeTransactionWord() + ) + ( + // PostgreSQL ROLLBACK PREPARED 'id' takes no other clause. + LOOKAHEAD({ isPreparedTransactionAhead() }) ContextualKeyword("PREPARED") id=StringTransactionId(true) + { statement.setPreparedTransaction(TransactionCompletionStatement.PreparedTransactionKeyword.PREPARED, id); } + | + [ LOOKAHEAD({ getToken(1).kind == K_WORK || isKeywordAhead("TRANSACTION") }) + keyword=TransactionKeyword() { statement.setKeyword(keyword); } ] + // FORCE INSTALL starts a new statement, whereas FORCE 'id' belongs here. + [ + LOOKAHEAD(2) + ( + [ LOOKAHEAD({ getToken(1).kind == K_SAVEPOINT }) { statement.setUsingSavepointKeyword(true); } ] + name=RelObjectName() { statement.setSavepointName(name); } + | + id=StringTransactionId(false) + { statement.setPreparedTransaction(TransactionCompletionStatement.PreparedTransactionKeyword.FORCE, id); } + | + chain=TransactionChain() { statement.setChain(chain); } + ) + ] + [ LOOKAHEAD({ statement.getSavepointName() == null + && statement.getPreparedTransactionId() == null && isTransactionReleaseAhead() }) + release=TransactionRelease() { statement.setRelease(release); } ] + ) { - return sk; + requireDdlSyntax(statement.getCommand() != RollbackStatement.Command.ABORT + || statement.getSavepointName() == null && statement.getPreparedTransactionId() == null, + "ABORT does not accept TO SAVEPOINT, FORCE or PREPARED"); + requireTransactionCompletionSyntax(statement); + return statement; } } -void IndexOption(List list) : +Commit Commit(): { - Token tk1 = null; - Token tk2 = null; - String sk1 = null; - boolean useEqual = false; + Commit commit = new Commit(); + TransactionKeyword keyword; + TransactionChain chain; + TransactionRelease release; + TransactionId id; } { + ( | { commit.setCommand(Commit.Command.END); } ) ( - tk1= ["=" { useEqual = true; } ] tk2= - { - list.add("KEY_BLOCK_SIZE" + (useEqual ? " = " : "") + tk2.image); - } - | - tk1= tk2= - { - list.add("WITH PARSER " + tk2.image); - } - | - tk1= tk2= - { - list.add("COMMENT " + tk2.image); - } - | - tk1= - { - list.add("VISIBLE"); - } - | - tk1= - { - list.add("INVISIBLE"); - } - | - sk1 = UsingIndexType(){ - list.add("USING " + sk1); - } + // PostgreSQL COMMIT PREPARED 'id' takes no other clause. + LOOKAHEAD({ isPreparedTransactionAhead() }) ContextualKeyword("PREPARED") id=StringTransactionId(true) + { commit.setPreparedTransaction(TransactionCompletionStatement.PreparedTransactionKeyword.PREPARED, id); } + | + [ LOOKAHEAD({ getToken(1).kind == K_WORK || isKeywordAhead("TRANSACTION") }) + keyword=TransactionKeyword() { commit.setKeyword(keyword); } ] + [ chain=TransactionChain() { commit.setChain(chain); } ] + [ LOOKAHEAD({ isTransactionReleaseAhead() }) release=TransactionRelease() { commit.setRelease(release); } ] ) + { + requireTransactionCompletionSyntax(commit); + return commit; + } } -TablePartitioning CreateTablePartitioning(): +/** + * Consumes a statement word that is not a token, such as ABORT. As a JAVACODE production it does + * not add identifiers to the tokens that can start or follow a statement. + */ +JAVACODE +void consumeTransactionWord() { + getNextToken(); +} + +/** + * A transaction identifier written as one string literal: the identifier of PostgreSQL's PREPARE + * TRANSACTION, COMMIT PREPARED and ROLLBACK PREPARED, which must be a PostgreSQL string constant, + * or of Oracle's ROLLBACK FORCE. + */ +TransactionId StringTransactionId(boolean postgreSql): +{ Token token; StringValue value; } { - TablePartitioning partitioning = null; - TablePartitioning subPartitioning = null; - Expression expression = null; - ExpressionList expressionList = null; - ExpressionList columns = null; - List partitionDefinitions = null; - List parameter = null; - List partitionOptions = new ArrayList(); - Token tk = null; + token= + { + value = stringValue(token); + requireDdlSyntax(!postgreSql || isPostgreSqlStringConstant(value), + "PostgreSQL expects a string constant: " + token.image); + return linkToLastToken(new TransactionId(value)); + } +} + +/** + * PostgreSQL PREPARE TRANSACTION 'id'. isPrepareTransactionAhead() tells it from + * PREPARE name AS statement. + */ +PrepareTransactionStatement PrepareTransactionStatement(): +{ TransactionId id; } +{ + ContextualKeyword("TRANSACTION") id=StringTransactionId(true) + { return new PrepareTransactionStatement(id); } } + +/** + * MySQL XA {START | BEGIN} xid [JOIN | RESUME], XA END xid [SUSPEND [FOR MIGRATE]], + * XA PREPARE xid, XA COMMIT xid [ONE PHASE], XA ROLLBACK xid and XA RECOVER [CONVERT XID]. + * XA is not a token; isXaStatementAhead() routes here. MariaDB has no CONVERT XID. + */ +XaStatement XaStatement(): +{ XaStatement.Action action; TransactionId xid = null; XaStatement.Option option = null; } { - + // The action keeps the JAVACODE call from being the production's first unit. + { } consumeTransactionWord() ( - // explicit lookaheads: the method keywords win over the BigQuery - // bare-expression alternative below, which they share a prefix with - LOOKAHEAD(2) partitioning=HashOrKeyPartitioning() + ( { action = XaStatement.Action.START; } | { action = XaStatement.Action.BEGIN; } ) + xid=XaTransactionId() + [ { option = XaStatement.Option.JOIN; } | { option = XaStatement.Option.RESUME; } ] | - LOOKAHEAD(2) { partitioning = new TablePartitioning(TablePartitioning.Type.RANGE); } - ( - "(" expressionList=SimpleExpressionList() ")" { - if (expressionList.size() == 1) { - partitioning.setExpression(expressionList.get(0)); - } else { - partitioning.setExpressionList(expressionList); - } - } - | - "(" columns=ColumnList() ")" - { - partitioning.setColumnsSyntax(true); - partitioning.setColumns(columns); - } - ) + { action = XaStatement.Action.END; } xid=XaTransactionId() + [ { option = XaStatement.Option.SUSPEND; } + [ ContextualKeyword("MIGRATE") { option = XaStatement.Option.SUSPEND_FOR_MIGRATE; } ] ] | - LOOKAHEAD(2) { partitioning = new TablePartitioning(TablePartitioning.Type.LIST); } - ( - "(" expressionList=SimpleExpressionList() ")" { - if (expressionList.size() == 1) { - partitioning.setExpression(expressionList.get(0)); - } else { - partitioning.setExpressionList(expressionList); - } - } - | - "(" columns=ColumnList() ")" - { - partitioning.setColumnsSyntax(true); - partitioning.setColumns(columns); - } - ) + { action = XaStatement.Action.PREPARE; } xid=XaTransactionId() | - // BigQuery partitions by a bare expression: PARTITION BY d, PARTITION BY DATE(ts), - // PARTITION BY RANGE_BUCKET(id, GENERATE_ARRAY(0, 100, 10)) - LOOKAHEAD({ getToken(1).kind != K_HASH && getToken(1).kind != K_KEY - && getToken(1).kind != K_LINEAR && getToken(1).kind != K_RANGE - && getToken(1).kind != K_LIST }) - expression=SimpleExpression() - { - partitioning = new TablePartitioning(TablePartitioning.Type.EXPRESSION); - partitioning.setExpression(expression); - } + { action = XaStatement.Action.COMMIT; } xid=XaTransactionId() + [ LOOKAHEAD({ isKeywordAhead("ONE") }) ContextualKeyword("ONE") ContextualKeyword("PHASE") + { option = XaStatement.Option.ONE_PHASE; } ] + | + { action = XaStatement.Action.ROLLBACK; } xid=XaTransactionId() + | + ContextualKeyword("RECOVER") { action = XaStatement.Action.RECOVER; } + [ ContextualKeyword("XID") { option = XaStatement.Option.CONVERT_XID; + requireDdlSyntax(!Dialect.MARIADB.name().equals(getAsString(Feature.dialect)), + "MariaDB does not accept XA RECOVER CONVERT XID"); } ] ) - [ LOOKAHEAD({ getToken(1).kind == K_PARTITIONS }) - tk= { partitioning.setPartitions(Long.valueOf(tk.image)); } ] - [ - LOOKAHEAD({ getToken(1).kind == K_SUBPARTITION }) - subPartitioning=HashOrKeyPartitioning() - [ LOOKAHEAD({ getToken(1).kind == K_SUBPARTITIONS }) - tk= - { subPartitioning.setPartitions(Long.valueOf(tk.image)); } ] - { partitioning.setSubPartitioning(subPartitioning); } - ] - [ LOOKAHEAD(2) partitionDefinitions=PartitionDefinitions() - { partitioning.setPartitionDefinitions(partitionDefinitions); } ] - ( LOOKAHEAD(2, { getToken(1).kind != K_AS }) - parameter=CreateParameter() { partitionOptions.addAll(parameter); } )* - { - if (!partitionOptions.isEmpty()) { - partitioning.setPartitionOptions(partitionOptions); - } - return partitioning; - } + { return new XaStatement(action, xid).withOption(option); } } -PartitionBound PostgreSqlPartitionBound(): +/** The xid of the MySQL XA statements: gtrid [, bqual [, formatID]]. */ +TransactionId XaTransactionId(): +{ Token first = getToken(1); TransactionId xid; Expression part; Token formatId; } { - PartitionBound bound = null; - ExpressionList expressions = null; - Expression modulus = null; - Expression remainder = null; + part=XaTransactionIdPart() { xid = new TransactionId(part); } + [ "," part=XaTransactionIdPart() { xid.setBranchQualifier(part); } + [ "," formatId= { xid.setFormatId(xaFormatId(formatId)); } ] ] + { return linked(xid, first); } } + +/** A gtrid or bqual: a string, hexadecimal or bit-value literal. */ +Expression XaTransactionIdPart(): +{ Token token; Expression part; } { ( - { bound = new PartitionBound(PartitionBound.Type.DEFAULT); } + token= + { part = stringValue(token); + requireDdlSyntax(isXaStringPart((StringValue) part), "XA expects a string, hexadecimal or bit-value literal: " + token.image); } | - - ( - "(" expressions=SimpleExpressionList() ")" - { - bound = new PartitionBound(PartitionBound.Type.RANGE); - bound.setFromExpressions(expressions); - } - "(" expressions=SimpleExpressionList() ")" - { bound.setToExpressions(expressions); } - | - "(" expressions=SimpleExpressionList() ")" - { - bound = new PartitionBound(PartitionBound.Type.LIST); - bound.setInExpressions(expressions); - } - | - "(" modulus=Expression() "," - remainder=Expression() ")" - { - bound = new PartitionBound(PartitionBound.Type.HASH); - bound.setModulus(modulus); - bound.setRemainder(remainder); - } - ) + token= + { requireDdlSyntax(isXaHexPart(token.image), "Invalid hexadecimal literal: " + token.image); + part = linkToLastToken(new HexValue(token.image)); } ) - { return bound; } + { return part; } } -TablePartitioning HashOrKeyPartitioning(): -{ - TablePartitioning partitioning = new TablePartitioning(); - ExpressionList expressionList = null; - ExpressionList columns = null; - Token tk = null; - boolean useEquals = false; -} +/** + * MySQL CREATE, ALTER and SET RESOURCE GROUP. RESOURCE, VCPU and THREAD_PRIORITY are not tokens; + * isResourceGroupStatementAhead() routes here. DROP RESOURCE GROUP is read by Drop(). + */ +Statement ResourceGroupStatement(): +{ Statement statement; } { - [ { partitioning.setLinear(true); } ] ( - "(" expressionList=SimpleExpressionList() ")" - { - partitioning.setType(TablePartitioning.Type.HASH); - if (expressionList.size() == 1) { - partitioning.setExpression(expressionList.get(0)); - } else { - partitioning.setExpressionList(expressionList); - } - } + ContextualKeyword("RESOURCE") statement=CreateResourceGroup() | - - [ [ "=" { useEquals = true; } ] tk= - { - partitioning.setAlgorithm(Integer.valueOf(tk.image)); - partitioning.setAlgorithmUseEquals(useEquals); - } - ] - "(" [ columns=ColumnList() ] ")" - { - partitioning.setType(TablePartitioning.Type.KEY); - if (columns == null) { - columns = new ExpressionList(); - } - partitioning.setColumns(columns); - } + ContextualKeyword("RESOURCE") statement=AlterResourceGroup() + | + ContextualKeyword("RESOURCE") statement=SetResourceGroup() ) - { - return partitioning; - } + { return statement; } } -List PartitionValues(): +CreateResourceGroup CreateResourceGroup(): +{ CreateResourceGroup group = new CreateResourceGroup(); String name; OptionAssignment assignment; } { - List values = new ArrayList(); - Expression expression = null; + name=RelObjectName() { group.setName(resourceGroupName(name)); } + assignment=ResourceGroupOptionAssignment() { group.setTypeAssignment(assignment); } + ( { group.setType(CreateResourceGroup.Type.USER); } + | { group.setType(CreateResourceGroup.Type.SYSTEM); } ) + ResourceGroupOptions(group) + { return group; } } + +AlterResourceGroup AlterResourceGroup(): +{ AlterResourceGroup group = new AlterResourceGroup(); String name; } { - ( - LOOKAHEAD({ getToken(1).kind == K_MAXVALUE }) - { values.add("MAXVALUE"); } - | expression=Expression() { values.add(expression.toString()); } - ) - ( - "," - ( - LOOKAHEAD({ getToken(1).kind == K_MAXVALUE }) - { values.add("MAXVALUE"); } - | expression=Expression() { values.add(expression.toString()); } - ) - )* - { - return values; - } + name=RelObjectName() { group.setName(resourceGroupName(name)); } + ResourceGroupOptions(group) + // FORCE INSTALL starts the next statement + [ LOOKAHEAD({ getToken(1).kind == K_FORCE && getToken(2).kind != K_INSTALL }) + { group.setForce(true); } ] + { return group; } } -PartitionDefinition PartitionDefinition(): +/** The optional = or := between a resource group option and its value. */ +OptionAssignment ResourceGroupOptionAssignment(): +{ OptionAssignment assignment = OptionAssignment.NONE; } { - PartitionDefinition partitionDefinition = new PartitionDefinition(); - List values = null; - List subPartitionDefinitions = null; - String partitionName = null; + [ "=" { assignment = OptionAssignment.EQUALS; } | ":=" { assignment = OptionAssignment.COLON_EQUALS; } ] + { return assignment; } } + +/** + * [VCPU [=] vcpu_spec [[,] vcpu_spec] ...] [THREAD_PRIORITY [=] [-] N] [ENABLE | DISABLE], in the + * order of MySQL's grammar. + */ +void ResourceGroupOptions(ResourceGroupDefinition group): +{ OptionAssignment assignment; VcpuRange range; Token number; boolean negative = false; } { - partitionName=RelObjectName() - { partitionDefinition.setPartitionName(partitionName); } + [ LOOKAHEAD({ isKeywordAhead("VCPU") }) ContextualKeyword("VCPU") + assignment=ResourceGroupOptionAssignment() { group.setVcpuAssignment(assignment); } + range=ResourceGroupVcpuRange() { group.addVcpus(range); } + ( [ "," ] range=ResourceGroupVcpuRange() { group.addVcpus(range); } )* ] + [ LOOKAHEAD({ isKeywordAhead("THREAD_PRIORITY") }) ContextualKeyword("THREAD_PRIORITY") + assignment=ResourceGroupOptionAssignment() { group.setThreadPriorityAssignment(assignment); } + [ "-" { negative = true; } ] number= + { group.setThreadPriority(negative ? -resourceGroupNumber(number) : resourceGroupNumber(number)); } ] + [ { group.setState(ResourceGroupDefinition.State.ENABLE); } + | { group.setState(ResourceGroupDefinition.State.DISABLE); } ] +} + +/** A CPU number, or two of them around a minus sign. */ +VcpuRange ResourceGroupVcpuRange(): +{ Token start; Token end = null; } +{ + start= [ "-" end= ] + { return new VcpuRange(resourceGroupNumber(start), end == null ? null : Integer.valueOf(resourceGroupNumber(end))); } +} + +SetResourceGroup SetResourceGroup(): +{ SetResourceGroup statement = new SetResourceGroup(); String name; Expression threadId; } +{ + name=RelObjectName() { statement.setName(resourceGroupName(name)); } + [ threadId=ResourceGroupThreadId() { statement.addThreadIds(threadId); } + ( [ "," ] threadId=ResourceGroupThreadId() { statement.addThreadIds(threadId); } )* ] + { linkElements(statement.getThreadIds()); return statement; } +} + +/** A thread ID: a decimal or hexadecimal number. */ +Expression ResourceGroupThreadId(): +{ Token token; Expression threadId; } +{ + ( + token= { threadId = resourceGroupThreadId(token); } + | + token= + { requireDdlSyntax(isXaHexPart(token.image), "Invalid hexadecimal literal: " + token.image); + threadId = linkToLastToken(new HexValue(token.image)); } + ) + { return threadId; } +} + +/** + * SET [scope] TRANSACTION modes, SET [scope] SESSION CHARACTERISTICS AS TRANSACTION modes and + * SET [scope] TRANSACTION SNAPSHOT 'id'. The modes are those of BEGIN and START TRANSACTION, and + * requireSetTransactionSyntax() checks which scope each dialect accepts. + */ +SetTransactionStatement SetTransactionStatement(): +{ SetTransactionStatement statement = new SetTransactionStatement(); Token snapshot; } +{ + [ - + // SESSION CHARACTERISTICS is a form of its own; SET SESSION SESSION CHARACTERISTICS has both + LOOKAHEAD({ isSetTransactionScopeAt(1) && !isSessionCharacteristicsAt(1) }) ( - - { - partitionDefinition.setValueOperator( - PartitionDefinition.ValueOperator.LESS_THAN); - } - ( - - { - partitionDefinition.setMaxValue(true); - partitionDefinition.setValues(Collections.singletonList("MAXVALUE")); - } - | - "(" values=PartitionValues() ")" { partitionDefinition.setValues(values); } - ) + { statement.setScope(SetScope.GLOBAL); } | - - { - partitionDefinition.setValueOperator(PartitionDefinition.ValueOperator.IN); - } - "(" values=PartitionValues() ")" { partitionDefinition.setValues(values); } + { statement.setScope(SetScope.SESSION); } + | + { statement.setScope(SetScope.LOCAL); } + | + LOOKAHEAD({ isKeywordAhead("PERSIST") }) ContextualKeyword("PERSIST") + { statement.setScope(SetScope.PERSIST); } + | + ContextualKeyword("PERSIST_ONLY") { statement.setScope(SetScope.PERSIST_ONLY); } ) ] - ( PartitionDefinitionOption(partitionDefinition) )* - [ subPartitionDefinitions=SubpartitionDefinitions() - { partitionDefinition.setSubPartitionDefinitions(subPartitionDefinitions); } ] + [ LOOKAHEAD({ isSessionCharacteristicsAt(1) }) ContextualKeyword("CHARACTERISTICS") + { statement.setSessionCharacteristics(true); } ] + ContextualKeyword("TRANSACTION") + ( + LOOKAHEAD({ isKeywordAhead("SNAPSHOT") }) ContextualKeyword("SNAPSHOT") snapshot= + { statement.setSnapshotId(stringValue(snapshot)); } + | + TransactionModeList(statement.getModes(), TransactionMode.Context.SET_TRANSACTION) + ) + { requireSetTransactionSyntax(statement); return statement; } +} + +/** SET CONSTRAINTS {ALL | name [, ...]} {DEFERRED | IMMEDIATE}. */ +SetConstraintsStatement SetConstraintsStatement(): +{ SetConstraintsStatement statement = new SetConstraintsStatement(); String name; Token timing; } +{ + + ( + // ALL is reserved, so a constraint of that name is quoted + LOOKAHEAD({ getToken(1).kind == K_ALL }) + | + name=AccessQualifiedName() { statement.addConstraintName(name); } + ( "," name=AccessQualifiedName() { statement.addConstraintName(name); } )* + ) + timing= { - return partitionDefinition; + requireDdlSyntax("DEFERRED".equalsIgnoreCase(timing.image) || "IMMEDIATE".equalsIgnoreCase(timing.image), + "Expected DEFERRED or IMMEDIATE"); + requireDdlSyntax(!isMySqlDialect(), "MySQL does not accept SET CONSTRAINTS"); + statement.setTiming(ConstraintAttributes.Initially.valueOf(timing.image.toUpperCase(Locale.ROOT))); + return statement; } } -List PartitionDefinitions(): +Comment Comment(): { - List partitionDefinitions = new ArrayList(); - PartitionDefinition partitionDefinition = null; + CommentTarget target; + Comment result = new Comment(); + Table table; + Table view; + Column column; + StringValue comment; } { - "(" partitionDefinition=PartitionDefinition() - { partitionDefinitions.add(partitionDefinition); } - ( "," partitionDefinition=PartitionDefinition() - { partitionDefinitions.add(partitionDefinition); } )* - ")" + + ( + ( + table = Table() { result.setTable(table); } + ) + | + ( + column = Column() { result.setColumn(column); } + ) + | + ( + view = Table() { result.setView(view); } + ) + | + target=CommentTarget() { result.setTarget(target); } + ) + + ( + comment=CharacterLiteral(true) { result.setComment(comment); } + | + ) { - return partitionDefinitions; + return result; } } -PartitionDefinition SubpartitionDefinition(): +/** Catalog names are already tokenized into parts; quoted dots are part of one identifier. */ +Table CommentObjectName(): +{ ObjectNames names; } { - PartitionDefinition partitionDefinition = new PartitionDefinition(); - String partitionName = null; + names=RelObjectNames() + { return names.getNames().size() == 1 ? new Table(names.getNames().get(0), false) + : new Table(names.getNames()); } } + +/** The object kind decides the shape of the reference that follows it. */ +CommentTarget CommentTarget(): { - partitionName=RelObjectName() - { - partitionDefinition.setPartitionName(partitionName); - partitionDefinition.setSubPartition(true); - } - ( PartitionDefinitionOption(partitionDefinition) )* - { - return partitionDefinition; - } + CommentTarget result = new CommentTarget(); + CommentTarget.Kind kind; + Table name; + String objectName; + RoutineReference routine; + ColDataType type; + ExclusionOperator operator; + Long oid; } - -List SubpartitionDefinitions(): { - List partitionDefinitions = new ArrayList(); - PartitionDefinition partitionDefinition = null; + kind=CommentTargetKind(result) { result.setKind(kind); } + ( + LOOKAHEAD({ kind.isRoutine() }) + routine=RoutineReference(kind == CommentTarget.Kind.AGGREGATE) { result.setRoutine(routine); } + | + LOOKAHEAD({ kind.isOwnedByRelation() }) + objectName=RelObjectName() { result.setName(new Table(objectName, false)); } + + [ LOOKAHEAD({ kind == CommentTarget.Kind.CONSTRAINT && getToken(1).kind == K_DOMAIN + && !".".equals(getToken(2).image) && getToken(2).kind != K_IS }) + { result.setOnDomain(true); } ] + name=CommentObjectName() { result.setRelation(name); } + | + LOOKAHEAD({ kind == CommentTarget.Kind.CAST }) + "(" type=ColDataType() { result.setSourceType(type); } + type=ColDataType() { result.setTargetType(type); } ")" + | + LOOKAHEAD({ kind == CommentTarget.Kind.OPERATOR }) + operator=PostgreSqlOperatorReference() { result.setOperator(operator); } + "(" type=ExtensionOperatorType() { result.setLeftOperandType(type); } + "," type=ExtensionOperatorType() { result.setRightOperandType(type); } ")" + { requireTypeDdlSyntax(result.getLeftOperandType() != null || result.getRightOperandType() != null, + "An operator signature needs an operand type"); } + | + LOOKAHEAD({ kind.isOwnedByAccessMethod() }) + name=CommentObjectName() { result.setName(name); } + objectName=RelObjectName() { result.setAccessMethod(objectName); } + | + LOOKAHEAD({ kind == CommentTarget.Kind.LARGE_OBJECT }) + oid=ObjectIdentifier() { result.setLargeObjectOid(oid); } + | + LOOKAHEAD({ kind == CommentTarget.Kind.TRANSFORM }) + type=ColDataType() { result.setTransformType(type); } + ContextualKeyword("LANGUAGE") objectName=RelObjectName() { result.setLanguage(objectName); } + | + name=CommentObjectName() { result.setName(name); } + ) + { return result; } +} + +/** Kind words without a token are matched contextually and remain ordinary identifiers. */ +CommentTarget.Kind CommentTargetKind(CommentTarget target): +{ CommentTarget.Kind kind; } +{ + ( + { kind = CommentTarget.Kind.INDEX; } + | { kind = CommentTarget.Kind.SCHEMA; } + | { kind = CommentTarget.Kind.SEQUENCE; } + | { kind = CommentTarget.Kind.MATERIALIZED_VIEW; } + | { kind = CommentTarget.Kind.DOMAIN; } + | { kind = CommentTarget.Kind.TYPE; } + | { kind = CommentTarget.Kind.FUNCTION; } + | { kind = CommentTarget.Kind.CONSTRAINT; } + | { kind = CommentTarget.Kind.TRIGGER; } + | { kind = CommentTarget.Kind.POLICY; } + | LOOKAHEAD({ isKeywordAhead("RULE") }) ContextualKeyword("RULE") { kind = CommentTarget.Kind.RULE; } + | { kind = CommentTarget.Kind.PROCEDURE; } + | LOOKAHEAD({ isKeywordAhead("ROUTINE") }) ContextualKeyword("ROUTINE") { kind = CommentTarget.Kind.ROUTINE; } + | { kind = CommentTarget.Kind.AGGREGATE; } + | { kind = CommentTarget.Kind.CAST; } + | LOOKAHEAD({ isKeywordAhead("ACCESS") }) ContextualKeyword("ACCESS") ContextualKeyword("METHOD") + { kind = CommentTarget.Kind.ACCESS_METHOD; } + | LOOKAHEAD({ isKeywordAhead("COLLATION") }) ContextualKeyword("COLLATION") { kind = CommentTarget.Kind.COLLATION; } + | { kind = CommentTarget.Kind.DATABASE; } + | { kind = CommentTarget.Kind.EVENT_TRIGGER; } + | LOOKAHEAD({ isKeywordAhead("EXTENSION") }) ContextualKeyword("EXTENSION") { kind = CommentTarget.Kind.EXTENSION; } + | + ( + ContextualKeyword("WRAPPER") { kind = CommentTarget.Kind.FOREIGN_DATA_WRAPPER; } + | { kind = CommentTarget.Kind.FOREIGN_TABLE; } + ) + | LOOKAHEAD({ isKeywordAhead("PROCEDURAL") || isKeywordAhead("LANGUAGE") }) + [ LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL") { target.setProcedural(true); } ] + ContextualKeyword("LANGUAGE") { kind = CommentTarget.Kind.LANGUAGE; } + | LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) ContextualKeyword("PUBLICATION") { kind = CommentTarget.Kind.PUBLICATION; } + | LOOKAHEAD({ isKeywordAhead("ROLE") }) ContextualKeyword("ROLE") { kind = CommentTarget.Kind.ROLE; } + | LOOKAHEAD({ isKeywordAhead("SERVER") }) ContextualKeyword("SERVER") { kind = CommentTarget.Kind.SERVER; } + | LOOKAHEAD({ isKeywordAhead("STATISTICS") }) ContextualKeyword("STATISTICS") { kind = CommentTarget.Kind.STATISTICS; } + | LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) ContextualKeyword("SUBSCRIPTION") { kind = CommentTarget.Kind.SUBSCRIPTION; } + | { kind = CommentTarget.Kind.TABLESPACE; } + | LOOKAHEAD({ isKeywordAhead("OPERATOR") }) ContextualKeyword("OPERATOR") { kind = CommentTarget.Kind.OPERATOR; } + // a schema named CLASS or FAMILY may qualify an operator, as in class.+ + [ LOOKAHEAD({ (isKeywordAhead("CLASS") || isKeywordAhead("FAMILY")) && !".".equals(getToken(2).image) }) + ( LOOKAHEAD({ isKeywordAhead("CLASS") }) ContextualKeyword("CLASS") { kind = CommentTarget.Kind.OPERATOR_CLASS; } + | ContextualKeyword("FAMILY") { kind = CommentTarget.Kind.OPERATOR_FAMILY; } ) ] + | LOOKAHEAD({ isKeywordAhead("LARGE") }) ContextualKeyword("LARGE") ContextualKeyword("OBJECT") + { kind = CommentTarget.Kind.LARGE_OBJECT; } + | LOOKAHEAD({ isKeywordAhead("CONVERSION") }) ContextualKeyword("CONVERSION") { kind = CommentTarget.Kind.CONVERSION; } + | LOOKAHEAD({ isKeywordAhead("TRANSFORM") }) ContextualKeyword("TRANSFORM") { kind = CommentTarget.Kind.TRANSFORM; } + | LOOKAHEAD({ isKeywordAhead("TEXT") }) + ( + { kind = CommentTarget.Kind.TEXT_SEARCH_PARSER; } + | LOOKAHEAD({ isKeywordAhead("CONFIGURATION") }) ContextualKeyword("CONFIGURATION") + { kind = CommentTarget.Kind.TEXT_SEARCH_CONFIGURATION; } + | LOOKAHEAD({ isKeywordAhead("DICTIONARY") }) ContextualKeyword("DICTIONARY") + { kind = CommentTarget.Kind.TEXT_SEARCH_DICTIONARY; } + | ContextualKeyword("TEMPLATE") { kind = CommentTarget.Kind.TEXT_SEARCH_TEMPLATE; } + ) + ) + { return kind; } } + +/** An unsigned 32-bit PostgreSQL object identifier, such as the OID of a large object. */ +Long ObjectIdentifier(): +{ Token token; long value; } { - "(" partitionDefinition=SubpartitionDefinition() - { partitionDefinitions.add(partitionDefinition); } - ( "," partitionDefinition=SubpartitionDefinition() - { partitionDefinitions.add(partitionDefinition); } )* - ")" + token= { - return partitionDefinitions; + try { + value = Long.parseLong(token.image); + } catch (NumberFormatException exception) { + value = -1; + } + requireTypeDdlSyntax(value >= 0 && value <= 0xFFFFFFFFL, "OID out of range: " + token.image); + return value; } } -void PartitionDefinitionOption(PartitionDefinition partitionDefinition): +/** Consumes a keyword that remains an ordinary identifier outside this grammar context. */ +void ContextualKeyword(String expected): +{ Token keyword; } { - Token tk = null; - String value = null; - boolean useEquals = false; + keyword= { + if (!expected.equalsIgnoreCase(keyword.image)) { + throw new ParseException("Expected " + expected + " but found " + keyword.image); + } + } } + +void AccessKeyword(String expected): +{ Token token; } +{ (token= | token=) { requireAccessSyntax(expected.equalsIgnoreCase(token.image), "Expected " + expected); } } + +String AccessQualifiedName(): +{ String name; String part; } +{ name=RelObjectName() ( "." part=RelObjectNameExt() { name += "." + part; } )* { return name; } } + +List AccessNames(): +{ List names = new ArrayList(); String name; } +{ name=RelObjectName() { names.add(name); } ( "," name=RelObjectName() { names.add(name); } )* { return names; } } + +RoleOption RoleOption(boolean create): +{ RoleOption option = null; Token token; Token value; String sign = ""; Expression expression; List names; boolean encrypted = false; } { ( - [ { partitionDefinition.setStorageKeyword(true); } ] - [ "=" { useEquals = true; } ] value=RelObjectName() - { - partitionDefinition.setStorageEngine(value); - partitionDefinition.setStorageEngineUseEquals(useEquals); - } + LOOKAHEAD({ isAccessKeywordAhead("CONNECTION") }) + AccessKeyword("CONNECTION") [ ( "+" | "-" { sign = "-"; } ) ] value= + { option = new RoleOption(RoleOption.Kind.CONNECTION_LIMIT); option.setValue(new LongValue(sign + value.image)); } | - [ "=" { useEquals = true; } ] tk= - { - partitionDefinition.setComment(tk.image); - partitionDefinition.setCommentUseEquals(useEquals); - } + LOOKAHEAD({ isAccessKeywordAhead("PASSWORD") || isAccessKeywordAhead("ENCRYPTED") }) + [ AccessKeyword("ENCRYPTED") { encrypted = true; } ] + ( value= { expression = stringValue(value); } | { expression = new NullValue(); } ) + { option = new RoleOption(RoleOption.Kind.PASSWORD); option.setEncrypted(encrypted); option.setValue(expression); } | - [ "=" { useEquals = true; } ] tk= - { - partitionDefinition.setDataDirectory(tk.image); - partitionDefinition.setDataDirectoryUseEquals(useEquals); - } + LOOKAHEAD({ isAccessKeywordAhead("VALID") }) + AccessKeyword("VALID") AccessKeyword("UNTIL") value= + { option = new RoleOption(RoleOption.Kind.VALID_UNTIL); option.setValue(stringValue(value)); } | - [ "=" { useEquals = true; } ] tk= - { - partitionDefinition.setIndexDirectory(tk.image); - partitionDefinition.setIndexDirectoryUseEquals(useEquals); - } + + ( AccessKeyword("ROLE") { option = new RoleOption(RoleOption.Kind.IN_ROLE); } + | { option = new RoleOption(RoleOption.Kind.IN_GROUP); } ) + names=AccessNames() + { requireAccessSyntax(create, "Membership attributes require CREATE ROLE"); option.setRoles(names); } | - [ "=" { useEquals = true; } ] tk= - { - partitionDefinition.setMaxRows(tk.image); - partitionDefinition.setMaxRowsUseEquals(useEquals); - } + LOOKAHEAD({ isAccessKeywordAhead("ROLE") || isAccessKeywordAhead("USER") || isAccessKeywordAhead("ADMIN") }) + ( token= | token= ) + names=AccessNames() + { requireAccessSyntax(create, "Membership attributes require CREATE ROLE"); option = new RoleOption(accessEnum(RoleOption.Kind.class, token.image)); option.setRoles(names); } | - [ "=" { useEquals = true; } ] tk= - { - partitionDefinition.setMinRows(tk.image); - partitionDefinition.setMinRowsUseEquals(useEquals); - } + LOOKAHEAD({ isAccessKeywordAhead("SYSID") }) + AccessKeyword("SYSID") value= + { requireAccessSyntax(create, "SYSID requires CREATE ROLE"); option = new RoleOption(RoleOption.Kind.SYSID); option.setValue(new LongValue(value.image)); } | - [ "=" { useEquals = true; } ] value=RelObjectName() - { - partitionDefinition.setTablespace(value); - partitionDefinition.setTablespaceUseEquals(useEquals); - } + token= { option = new RoleOption(accessEnum(RoleOption.Kind.class, token.image)); } ) + { return option; } } -List PartitionNamesList() : +CreateRole CreateRole(): +{ CreateRole role = new CreateRole(); String name; RoleOption option; Token token; } { - String partitionName = null; - List partitionNames = new ArrayList(); + ( token= | token= | token= ) { role.setCommand(accessEnum(CreateRole.Command.class, token.image)); } + name=RelObjectName() { role.setName(name); } + [ LOOKAHEAD(1) { role.setUseWith(true); } ] + ( LOOKAHEAD({ isRoleOptionAhead(1) }) option=RoleOption(true) { role.getOptions().add(option); } )* + { requireAccessSyntax(!role.isUseWith() || !role.getOptions().isEmpty(), "WITH requires role attributes"); return role; } } + +AlterSchema AlterSchema(): { - partitionName = RelObjectName() { - partitionNames.add(partitionName); - } + AlterSchema statement = new AlterSchema(); + String name; +} +{ + name=RelObjectName() { statement.setSchemaName(name); } ( - LOOKAHEAD(2) "," partitionName = RelObjectName() { - partitionNames.add(partitionName); - } - )* - { - return partitionNames; - } + name=RelObjectName() + { statement.setAction(AlterSchema.Action.RENAME); statement.setNewName(name); } + | + ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(AlterSchema.Action.OWNER); statement.setOwner(name); } + ) + { return statement; } } -/** - * Parses DISCARD/IMPORT (PARTITION names TABLESPACE | TABLESPACE). - * Both keywords share the same structure, differing only in operation enum. - */ -AlterExpression AlterExpressionDiscardOrImport(): +AlterRole AlterRole(): { - AlterExpression alterExp; - List partitions = null; - AlterOperation partOp; - AlterOperation tableOp; + AlterRole role = new AlterRole(); String name; RoleOption option; Token token; + ConfigurationParameterChange change; List names; } { + ( token= | token= | token= ) { role.setCommand(accessEnum(CreateRole.Command.class, token.image)); } + ( LOOKAHEAD(1) { role.setName("ALL"); } | name=RelObjectName() { role.setName(name); } ) + [ LOOKAHEAD(2) name=RelObjectName() { role.setDatabase(name); } ] ( - { partOp = AlterOperation.DISCARD_PARTITION; tableOp = AlterOperation.DISCARD_TABLESPACE; } + name=RelObjectName() { role.setAction(AlterRole.Action.RENAME); role.setNewName(name); } | - { partOp = AlterOperation.IMPORT_PARTITION; tableOp = AlterOperation.IMPORT_TABLESPACE; } - ) - ( - - { alterExp = new AlterExpressionPartition(); alterExp.setOperation(partOp); } - partitions = PartitionNamesList() - { alterExp.setPartitions(partitions); } - - { alterExp.setTableOption("TABLESPACE"); } + ( { role.setAction(AlterRole.Action.ADD_USER); } | { role.setAction(AlterRole.Action.DROP_USER); } ) + names=AccessNames() { requireAccessSyntax(role.getCommand() == CreateRole.Command.GROUP, "ADD/DROP USER requires ALTER GROUP"); role.setUsers(names); } | - - { alterExp = new AlterExpressionTableOption(); alterExp.setOperation(tableOp); } + change=ConfigurationParameterChange() { role.setParameterChange(change); } + | + [ { role.setUseWith(true); } ] + option=RoleOption(false) { role.getOptions().add(option); role.setAction(AlterRole.Action.OPTIONS); } + ( LOOKAHEAD({ isRoleOptionAhead(1) }) option=RoleOption(false) { role.getOptions().add(option); } )* ) - { return alterExp; } + { + requireAccessSyntax(role.getDatabase() == null && !"ALL".equals(role.getName()) + || role.getAction() == AlterRole.Action.SET || role.getAction() == AlterRole.Action.RESET, + "ALL and IN DATABASE require SET or RESET"); + requireAccessSyntax(role.getCommand() != CreateRole.Command.GROUP || role.getAction() == AlterRole.Action.RENAME + || role.getAction() == AlterRole.Action.ADD_USER || role.getAction() == AlterRole.Action.DROP_USER, "Invalid ALTER GROUP action"); + return role; + } } - /** - * Parses SQL Server's [CONSTRAINT name] DEFAULT expression FOR column [WITH VALUES]. + * PostgreSQL SET/RESET of a configuration parameter, shared by ALTER ROLE, ALTER DATABASE and + * ALTER FUNCTION/PROCEDURE/ROUTINE. */ -DefaultConstraint DefaultConstraintSpec(): +ConfigurationParameterChange ConfigurationParameterChange(): { - DefaultConstraint constraint = new DefaultConstraint(); + ConfigurationParameterChange change = new ConfigurationParameterChange(); String name; - Expression expression; + Expression value; + ExpressionList values = new ExpressionList(); } { - [ name=RelObjectName() { constraint.setName(name); } ] - expression=Expression() { constraint.setExpression(expression); } - name=RelObjectName() { constraint.setColumn(createColumn(name)); } - // See InsertBulk(): is in the FOLLOW set of every statement tail. WITH VALUES wins - // over a hypothetical CTE named VALUES, which is the useful reading here. - [ LOOKAHEAD(2) { constraint.setWithValues(true); } ] - { return constraint; } + ( + name=AccessQualifiedName() { change.setParameter(name); } + ( + { change.setValueKind(ConfigurationParameterChange.ValueKind.FROM_CURRENT); } + | + ( | "=" { change.setUseEquals(true); } ) + ( + LOOKAHEAD(1) { change.setValueKind(ConfigurationParameterChange.ValueKind.DEFAULT); } + | + value=AccessSettingValue() { values.add(value); } + ( "," value=AccessSettingValue() { values.add(value); } )* + { change.setValues(values); } + ) + ) + | + { change.setAction(ConfigurationParameterChange.Action.RESET); } + ( LOOKAHEAD(1) { change.setParameter("ALL"); } | name=AccessQualifiedName() { change.setParameter(name); } ) + ) + { return change; } } -/** Parses Informix's ADD CONSTRAINT definition [CONSTRAINT name]. */ -NamedConstraint InformixConstraint(): +Expression AccessSettingValue(): +{ Expression value; Token token; } +{ ( LOOKAHEAD(1) token= { value = linkToLastToken(new Column(token.image)); } | value=PrimaryExpression() ) { return value; } } + +/** PostgreSQL and MySQL static privileges; another identifier is a MySQL dynamic privilege. */ +Privilege AccessPrivilege(): +{ Privilege result; Privilege.Kind kind = null; Token token = null; String column; ExpressionList columns = null; } { - NamedConstraint constraint; - Token type; - List columns; - String name; + ( + { kind = Privilege.Kind.ALTER; } + [ { kind = Privilege.Kind.ALTER_SYSTEM; } + | LOOKAHEAD({ isAccessKeywordAhead("ROUTINE") }) AccessKeyword("ROUTINE") { kind = Privilege.Kind.ALTER_ROUTINE; } ] + | + { kind = Privilege.Kind.CREATE; } + [ { kind = Privilege.Kind.CREATE_VIEW; } + | { kind = Privilege.Kind.CREATE_USER; } + | { kind = Privilege.Kind.CREATE_TABLESPACE; } + | { kind = Privilege.Kind.CREATE_TEMPORARY_TABLES; } + | LOOKAHEAD({ isAccessKeywordAhead("ROLE") }) AccessKeyword("ROLE") { kind = Privilege.Kind.CREATE_ROLE; } + | LOOKAHEAD({ isAccessKeywordAhead("ROUTINE") }) AccessKeyword("ROUTINE") { kind = Privilege.Kind.CREATE_ROUTINE; } ] + | + { kind = Privilege.Kind.DROP; } + [ LOOKAHEAD({ isAccessKeywordAhead("ROLE") }) AccessKeyword("ROLE") { kind = Privilege.Kind.DROP_ROLE; } ] + | + { kind = Privilege.Kind.GRANT_OPTION; } + | + { kind = Privilege.Kind.LOCK_TABLES; } + | + ( { kind = Privilege.Kind.SHOW_VIEW; } | AccessKeyword("DATABASES") { kind = Privilege.Kind.SHOW_DATABASES; } ) + | + LOOKAHEAD({ isAccessKeywordAhead("REPLICATION") && (getToken(2).kind == K_SLAVE || "CLIENT".equalsIgnoreCase(getToken(2).image)) }) + AccessKeyword("REPLICATION") + ( { kind = Privilege.Kind.REPLICATION_SLAVE; } | AccessKeyword("CLIENT") { kind = Privilege.Kind.REPLICATION_CLIENT; } ) + | + ( token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= ) + { kind = accessEnum(Privilege.Kind.class, token.image); } + | + token= + { if (Arrays.asList("MAINTAIN", "USAGE", "PROCESS", "PROXY", "RELOAD", "SUPER").contains(token.image.toUpperCase(Locale.ROOT))) { + kind = accessEnum(Privilege.Kind.class, token.image); + requireAccessSyntax(kind != Privilege.Kind.PROXY, "PROXY requires an account target"); + } } + ) + { result = kind == null ? Privilege.dynamic(token.image) : new Privilege(kind); } + [ LOOKAHEAD({ isAccessKeywordAhead("PRIVILEGES") }) + AccessKeyword("PRIVILEGES") { requireAccessSyntax(result.getKind() == Privilege.Kind.ALL, "PRIVILEGES requires ALL"); result.setUsePrivileges(true); } ] + [ "(" { columns = new ExpressionList(); } + column=RelObjectName() { columns.add(linkToLastToken(new Column(column))); } + ( "," column=RelObjectName() { columns.add(linkToLastToken(new Column(column))); } )* + ")" { result.setColumns(linkElements(columns)); } ] + { return result; } } + +PrivilegeTarget.Kind AccessObjectKind(boolean plural): +{ Token token; String name; } { - ( - ( type= | type= ) - columns=ColumnsNamesList() { - constraint = new NamedConstraint() - .withType(type.kind == K_PRIMARY ? "PRIMARY KEY" : type.image) - .withColumnsNames(columns); - } + + ( AccessKeyword("WRAPPER") { name = "FOREIGN_DATA_WRAPPER"; } + | AccessKeyword("SERVER") { name = "FOREIGN_SERVER"; } ) | - constraint=ForeignKeySpec(null) + LOOKAHEAD({ isAccessKeywordAhead("LARGE") }) + AccessKeyword("LARGE") ( token= ) { name = "LARGE_" + token.image.toUpperCase(Locale.ROOT); } | - constraint=CheckConstraintSpec(null) + ( token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= ) + { name = token.image.toUpperCase(Locale.ROOT); } ) - [ name=RelObjectName() { constraint.setName(name); } ] { - constraint.setUseConstraintKeyword(true); - constraint.setConstraintNamePosition(NamedConstraint.ConstraintNamePosition.AFTER); - return constraint; + if (plural) { + requireAccessSyntax(name.endsWith("S"), "Expected plural privilege target"); + name = name.substring(0, name.length() - 1); + } + return accessEnum(PrivilegeTarget.Kind.class, name); } } -/** - * Parses ADD/ALTER CONSTRAINT clause within AlterExpression. - * Handles: CONSTRAINT [UNIQUE [KEY|INDEX]] name columns - * CONSTRAINT name (FOREIGN KEY|PRIMARY KEY|UNIQUE|KEY|CHECK|[NOT] ENFORCED) - */ -void AlterExpressionAddConstraint(AlterExpression alterExp): +RoutineReference.Argument AccessRoutineArgument(): +{ RoutineReference.Argument argument; } +{ argument=RoutineArgument(false) { return argument; } } + +RoutineReference AccessRoutine(): +{ RoutineReference result = new RoutineReference(); String name; RoutineReference.Argument argument; List arguments; } { - Token tk; - Token tk2 = null; - String sk3 = null; - List columnNames = null; - ForeignKeyIndex fkIndex = null; - Index index = null; - Table fkTable; - List constraints = null; - CheckConstraint checkCs = null; - Index.Clustering clustering = null; + name=AccessQualifiedName() { result.setName(name); } + [ LOOKAHEAD(1) "(" { arguments = new ArrayList(); result.setArguments(arguments); } + [ argument=AccessRoutineArgument() { arguments.add(argument); } + ( "," argument=AccessRoutineArgument() { arguments.add(argument); } )* ] ")" ] + { return result; } } + +PrivilegeTarget AccessTarget(boolean defaults): +{ PrivilegeTarget target = new PrivilegeTarget(); PrivilegeTarget.Kind kind; ObjectNames name; RoutineReference routine; Token number; } { - ( - LOOKAHEAD(2) - ( - ( { alterExp.setConstraintType("UNIQUE KEY"); } - | { alterExp.setConstraintType("UNIQUE INDEX"); } - | { alterExp.setConstraintType("UNIQUE"); } ) - sk3=RelObjectName() { - alterExp.setConstraintSymbol(sk3); - index = new Index(); - } - columnNames=ColumnsNamesList() { - index.setColumnsNames(columnNames); - alterExp.setIndex(index); - } - ) + LOOKAHEAD({ defaults }) + kind=AccessObjectKind(true) + { requireAccessSyntax(defaults && EnumSet.of(PrivilegeTarget.Kind.TABLE, PrivilegeTarget.Kind.SEQUENCE, PrivilegeTarget.Kind.FUNCTION, + PrivilegeTarget.Kind.ROUTINE, PrivilegeTarget.Kind.TYPE, PrivilegeTarget.Kind.SCHEMA, PrivilegeTarget.Kind.LARGE_OBJECT).contains(kind), + "Invalid default-privilege target"); + target.setKind(kind); target.setDefaultPrivileges(true); } | - sk3=RelObjectName() - ( - ( fkIndex=ForeignKeySpec(sk3) - { alterExp.setIndex(fkIndex); } - constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } - ) - | - ( tk= tk2= - clustering=SqlServerIndexClustering() - columnNames=ColumnsNamesList() - { - index = new NamedConstraint() - .withName(sk3) - .withType(tk.image + " " + tk2.image) - .withClustering(clustering) - .withColumnsNames(columnNames); - alterExp.setIndex(index); - } - AlterExpressionConstraintTail(alterExp, index) - ) - | - LOOKAHEAD(2) ( - { boolean enforced = true; } - [ tk = { enforced = false; } ] - { - alterExp.setEnforced(enforced); - alterExp.setConstraintType("CONSTRAINT"); - alterExp.setConstraintSymbol(sk3); - } - ) - | - ( - checkCs = CheckConstraintSpec(sk3) - { alterExp.setIndex(checkCs); } - ) - | - ( - tk= (tk2= { alterExp.setUk(true); } | tk2=)? - clustering=SqlServerIndexClustering() - columnNames=ColumnsNamesList() - { - index = new NamedConstraint() - .withName(sk3) - .withType(tk.image + (tk2!=null?" " + tk2.image:"")) - .withClustering(clustering) - .withColumnsNames(columnNames); - alterExp.setIndex(index); - } - AlterExpressionConstraintTail(alterExp, index) - ) + LOOKAHEAD(1) kind=AccessObjectKind(true) + { requireAccessSyntax(!defaults && EnumSet.of(PrivilegeTarget.Kind.TABLE, PrivilegeTarget.Kind.SEQUENCE, + PrivilegeTarget.Kind.FUNCTION, PrivilegeTarget.Kind.PROCEDURE, PrivilegeTarget.Kind.ROUTINE).contains(kind), + "Invalid ALL IN SCHEMA target"); target.setKind(kind); target.setAllInSchema(true); } + name=RelObjectNames() { target.getNames().add(name.getNames()); } + ( "," name=RelObjectNames() { target.getNames().add(name.getNames()); } )* + | + LOOKAHEAD({ isAccessTargetKindAhead() && (isAccessKeywordAhead("FUNCTION") || isAccessKeywordAhead("PROCEDURE") || isAccessKeywordAhead("ROUTINE")) }) + kind=AccessObjectKind(false) { target.setKind(kind); target.setExplicitKind(true); } + routine=AccessRoutine() { target.getRoutines().add(routine); } + ( "," routine=AccessRoutine() { target.getRoutines().add(routine); } )* + | + LOOKAHEAD({ isAccessTargetKindAhead() && isAccessKeywordAhead("LARGE") }) + kind=AccessObjectKind(false) { target.setKind(kind); target.setExplicitKind(true); } + number= { target.getNames().add(Collections.singletonList(number.image)); } + ( "," number= { target.getNames().add(Collections.singletonList(number.image)); } )* + | + [ LOOKAHEAD({ isAccessTargetKindAhead() }) kind=AccessObjectKind(false) { target.setKind(kind); target.setExplicitKind(true); } ] + ( + // MySQL privilege levels *, *.* and db.* + "*" { target.setWildcard(PrivilegeTarget.Wildcard.DEFAULT_DATABASE); } + [ "." "*" { target.setWildcard(PrivilegeTarget.Wildcard.GLOBAL); } ] | + name=RelObjectNames() { target.getNames().add(name.getNames()); } ( - tk= - columnNames=ColumnsNamesList() - { - index = new NamedConstraint() - .withName(sk3) - .withType(tk.image) - .withColumnsNames(columnNames); - alterExp.setIndex(index); - } - constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } + "." "*" + { requireAccessSyntax(name.getNames().size() == 1, "Expected database.*"); target.setWildcard(PrivilegeTarget.Wildcard.DATABASE); } + | + ( "," name=RelObjectNames() { target.getNames().add(name.getNames()); } )* ) ) + { requireAccessSyntax(target.getWildcard() == null || target.getKind() == PrivilegeTarget.Kind.TABLE, "Wildcards require a table target"); } ) + { requireAccessSyntax(target.isDefaultPrivileges() == defaults, "Invalid default-privilege target"); return target; } } -/** - * Parses the DROP operations within AlterExpression. - * Handles: DROP (PARTITION|columns|COLUMN|INDEX|KEY|UNIQUE|PRIMARY KEY|FOREIGN KEY|CONSTRAINT) - */ -AlterExpression AlterExpressionDrop(): -{ - AlterExpression alterExp = new AlterExpressionDrop(); - Token tk; - Token tk2; - List columnNames = null; - List partitions = null; - Index index = null; -} +/** A role specification shared by MySQL and PostgreSQL grantees, grantors and accounts. */ +Grantee AccessGrantee(): +{ Grantee grantee; StringValue name; UserAccount account; Token token; } { - { alterExp.setOperation(AlterOperation.DROP); } ( - ( - { - alterExp = new AlterExpressionPartition(); - alterExp.setOperation(AlterOperation.DROP_PARTITION); - } - partitions=PartitionNamesList() { - alterExp.setPartitions(partitions); - } - ) - | - ( - // Oracle Multi Column Drop - columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); columnNames = null; } - [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ] - [ - "CASCADE" { alterExp.addParameters("CASCADE"); } - [ "CONSTRAINTS" { alterExp.addParameters("CONSTRAINTS"); } ] - ] - ) - | - ( - ( LOOKAHEAD(2) { alterExp.hasColumn(true); } )? - [ { alterExp.setUsingIfExists(true); } ] - (tk=KeywordOrIdentifier() ) { alterExp.setColumnName(tk.image); } - [ "INVALIDATE" { alterExp.addParameters("INVALIDATE"); } ] - [ - "CASCADE" { alterExp.addParameters("CASCADE"); } - [ "CONSTRAINTS" { alterExp.addParameters("CONSTRAINTS"); } ] - ] - ) - | - ( - ( tk= | tk= ) - ( tk2= | tk2= ) { - index = new Index().withType(tk.image).withName(tk2.image); - alterExp.setIndex(index); - } - ) + LOOKAHEAD({ getToken(1).kind == K_GROUP }) name=MySqlAccountNamePart() + { grantee = new Grantee(Grantee.Kind.GROUP).withAccount(new UserAccount().withUser(name)); } | - ( - tk= { alterExp.setOperation(AlterOperation.DROP_UNIQUE); } - columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); columnNames = null; } - [ ( tk= | tk= ) { alterExp.addParameters(tk.image); } ] - ) + LOOKAHEAD({ isAccessSpecialGranteeAhead() }) ( token= | token= ) + { grantee = new Grantee(accessEnum(Grantee.Kind.class, token.image)); } + [ LOOKAHEAD(2) "(" ")" { requireAccessSyntax(grantee.getKind() == Grantee.Kind.CURRENT_USER, "Only CURRENT_USER takes parentheses"); + grantee.setCurrentUserParentheses(true); } ] | - ( - tk= tk2= { alterExp.setOperation(AlterOperation.DROP_PRIMARY_KEY); } - [ ( tk= | tk= ) { alterExp.addParameters(tk.image); } ] - ) + account=MySqlAccountName() { grantee = new Grantee(account); } + ) + { return grantee; } +} + +List AccessGrantees(): +{ List grantees = new ArrayList(); Grantee grantee; } +{ grantee=AccessGrantee() { grantees.add(grantee); } ( "," grantee=AccessGrantee() { grantees.add(grantee); } )* { return grantees; } } + +PrivilegeClause AccessClause(boolean revoke, boolean defaults): +{ PrivilegeClause clause = new PrivilegeClause(); Privilege privilege; PrivilegeTarget target; List roles; List grantees; Grantee account; } +{ + ( + LOOKAHEAD({ isAccessKeywordAhead("PROXY") && getToken(2).kind == K_ON }) + AccessKeyword("PROXY") account=AccessGrantee() + { + requireAccessSyntax(!defaults, "PROXY is not part of default privileges"); + requireAccessSyntax(account.getKind() == Grantee.Kind.ACCOUNT || account.getKind() == Grantee.Kind.CURRENT_USER, "PROXY requires an account"); + clause.setPrivileges(new ArrayList()); + clause.getPrivileges().add(new Privilege(Privilege.Kind.PROXY)); + target = new PrivilegeTarget(); target.setKind(PrivilegeTarget.Kind.ACCOUNT); target.setAccount(account); + clause.setTarget(target); + } + | + LOOKAHEAD({ isAccessAllGrantOptionAhead() }) + { privilege = new Privilege(Privilege.Kind.ALL); } + [ AccessKeyword("PRIVILEGES") { privilege.setUsePrivileges(true); } ] + "," + { + requireAccessSyntax(!defaults, "ALL, GRANT OPTION is not part of default privileges"); + clause.setPrivileges(new ArrayList()); + clause.getPrivileges().add(privilege); + clause.getPrivileges().add(new Privilege(Privilege.Kind.GRANT_OPTION)); + clause.setTarget(null); + } | - ( - tk= tk2= { alterExp.setOperation(AlterOperation.DROP_FOREIGN_KEY); } - columnNames=ColumnsNamesList() { alterExp.setPkColumns(columnNames); columnNames = null; } - [ ( tk= | tk= ) { alterExp.addParameters(tk.image); } ] - ) + LOOKAHEAD({ isObjectPrivilegeAhead() }) + { clause.setPrivileges(new ArrayList()); } + privilege=AccessPrivilege() { clause.getPrivileges().add(privilege); } + ( "," privilege=AccessPrivilege() { clause.getPrivileges().add(privilege); } )* + target=AccessTarget(defaults) { clause.setTarget(target); } | - ( - [ { alterExp.setUsingIfExists(true); } ] - ( tk= | tk=) { alterExp.setConstraintName(tk.image); } - [ ( tk= | tk= ) { alterExp.addParameters(tk.image); } ] - ) + roles=MySqlAccountNameList() { clause.setRoleItems(requireRoleNames(roles)); clause.setTarget(null); } ) - { return alterExp; } + ( { requireAccessSyntax(!revoke, "REVOKE requires FROM"); } | { requireAccessSyntax(revoke, "GRANT requires TO"); } ) + grantees=AccessGrantees() { clause.setGranteeItems(grantees); return clause; } } -/** - * Parses partition maintenance operations within AlterExpression. - * Handles: TRUNCATE/ANALYZE/CHECK/OPTIMIZE/REBUILD/REPAIR PARTITION, - * COALESCE/REORGANIZE/EXCHANGE/PARTITION BY, REMOVE PARTITIONING - */ -AlterExpression AlterExpressionPartitionOp(): +GrantOption AccessGrantOption(): +{ GrantOption option; Token token; } { - AlterExpressionPartition alterExp = new AlterExpressionPartition(); - Token tk; - List partitions = null; - List partitionDefinition = null; - Table exchangeTable = null; - TablePartitioning partitioning = null; + ( token= | token= | token= ) { option = new GrantOption(accessEnum(GrantOption.Kind.class, token.image)); } + ( token= | token= | token= ) { option.setValue(accessEnum(GrantOption.Value.class, token.image)); return option; } } + +Grantee AccessGrantor(boolean defaults): +{ Grantee grantor; } { - ( - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.TRUNCATE_PARTITION); } - partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } - | - LOOKAHEAD(2) tk= { - alterExp.setOperation(AlterOperation.COALESCE_PARTITION); - alterExp.setCoalescePartitionCount(Integer.valueOf(tk.image)); - } - | - LOOKAHEAD(2) - partitions=PartitionNamesList() partitionDefinition=PartitionDefinitions() { - alterExp.setOperation(AlterOperation.REORGANIZE_PARTITION); - alterExp.setPartitions(partitions); - alterExp.setPartitionDefinitions(partitionDefinition); - } - | - LOOKAHEAD(2) partitions=PartitionNamesList() - exchangeTable=Table() - [ - LOOKAHEAD(2) ( - { - alterExp.setExchangeValidationMode(AlterExpressionPartition.ExchangeValidationMode.WITH); - } - | - { - alterExp.setExchangeValidationMode(AlterExpressionPartition.ExchangeValidationMode.WITHOUT); - } - ) - ] + AccessKeyword("GRANTED") grantor=AccessGrantee() + { + requireAccessSyntax(!defaults, "GRANTED BY is not part of default privileges"); + requireAccessSyntax(grantor.getKind() != Grantee.Kind.PUBLIC && grantor.getKind() != Grantee.Kind.GROUP, "Invalid grantor"); + return grantor; + } +} + +Grant Grant(): +{ Grant grant; } +{ grant=AccessGrant(false) { return grant; } } + +Grant AccessGrant(boolean defaults): +{ Grant grant = new Grant(); PrivilegeClause clause; GrantOption option; Grantee grantee; RoleSelection roles; } +{ + clause=AccessClause(false, defaults) { grant.setClause(clause); } + [ LOOKAHEAD(1) + option=AccessGrantOption() { grant.getOptions().add(option); } + ( "," option=AccessGrantOption() { grant.getOptions().add(option); } )* + { requireAccessSyntax(isValidAccessGrantOptions(clause, grant.getOptions()), "Invalid GRANT option"); } + ] + [ grantee=AccessGrantee() { - alterExp.setOperation(AlterOperation.EXCHANGE_PARTITION); - alterExp.setPartitions(partitions); - alterExp.setExchangeTable(exchangeTable); - } - | - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.ANALYZE_PARTITION); } - partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } - | - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.CHECK_PARTITION); } - partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } - | - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.OPTIMIZE_PARTITION); } - partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } - | - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.REBUILD_PARTITION); } - partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } - | - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.REPAIR_PARTITION); } - partitions=PartitionNamesList() { alterExp.setPartitions(partitions); } - | - LOOKAHEAD(2) { alterExp.setOperation(AlterOperation.REMOVE_PARTITIONING); } - | - LOOKAHEAD(2) partitioning=CreateTablePartitioning() { - alterExp.setOperation(AlterOperation.PARTITION_BY); - alterExp.setPartitioning(partitioning); + requireAccessSyntax(!defaults && clause.getPrivileges() != null && clause.getTarget() != null + && clause.getTarget().getKind() != PrivilegeTarget.Kind.ACCOUNT, "AS requires object privileges"); + requireAccessSyntax(grantee.getKind() == Grantee.Kind.ACCOUNT || grantee.getKind() == Grantee.Kind.CURRENT_USER, "AS requires an account"); + grant.setAsUser(grantee); } + [ LOOKAHEAD({ getToken(1).kind == K_WITH && "ROLE".equalsIgnoreCase(getToken(2).image) }) + AccessKeyword("ROLE") roles=MySqlRoleSelection(true) { grant.setWithRole(roles); } ] + ] + [ LOOKAHEAD({ isAccessKeywordAhead("GRANTED") }) grantee=AccessGrantor(defaults) { clause.setGrantor(grantee); } ] + { return grant; } +} + +Revoke Revoke(boolean defaults): +{ Revoke revoke = new Revoke(); PrivilegeClause clause; Token token; Grantee grantor; } +{ + + [ LOOKAHEAD(2) + { requireAccessSyntax(!defaults, "IF EXISTS is not part of default privileges"); revoke.setIfExists(true); } ] + [ LOOKAHEAD(3) ( token= | token= | token= ) + { revoke.setOptionFor(accessEnum(GrantOption.Kind.class, token.image)); } ] + clause=AccessClause(true, defaults) { revoke.setClause(clause); } + [ LOOKAHEAD({ isAccessKeywordAhead("GRANTED") }) grantor=AccessGrantor(defaults) { clause.setGrantor(grantor); } ] + [ ( { revoke.setBehavior(CascadeBehavior.CASCADE); } | { revoke.setBehavior(CascadeBehavior.RESTRICT); } ) ] + [ + { requireAccessSyntax(!defaults, "IGNORE UNKNOWN USER is not part of default privileges"); revoke.setIgnoreUnknownUser(true); } ] + { requireAccessSyntax(revoke.getOptionFor() == null || (clause.getPrivileges() == null + ? revoke.getOptionFor() != GrantOption.Kind.GRANT : revoke.getOptionFor() == GrantOption.Kind.GRANT), "Invalid REVOKE option"); + return revoke; } +} + +AlterDefaultPrivileges AlterDefaultPrivileges(): +{ AlterDefaultPrivileges result = new AlterDefaultPrivileges(); Token token; List names; Grant grant; Revoke revoke; Token statementFirst; } +{ + AccessKeyword("PRIVILEGES") + [ ( token= | token= ) { result.setRoleKeyword(accessEnum(AlterDefaultPrivileges.RoleKeyword.class, token.image)); } + names=AccessNames() { result.setRoles(names); } ] + [ names=AccessNames() { result.setSchemas(names); } ] + { statementFirst = getToken(1); } + ( grant=AccessGrant(true) { linkStatement(grant, statementFirst); result.setGrant(grant); } + | revoke=Revoke(true) { linkStatement(revoke, statementFirst); result.setRevoke(revoke); } ) + { return result; } +} + +TriggerEvent PostgreSqlTriggerEvent(): +{ TriggerEvent result = null; String name; ExpressionList columns; } +{ + ( + { result = new TriggerEvent(CreateTrigger.Event.INSERT); } + | { result = new TriggerEvent(CreateTrigger.Event.DELETE); } + | { result = new TriggerEvent(CreateTrigger.Event.TRUNCATE); } + | { result = new TriggerEvent(CreateTrigger.Event.UPDATE); } + [ { columns = new ExpressionList(); } + name=RelObjectName() { columns.add(linkToLastToken(createColumn(name))); } + ( "," name=RelObjectName() { columns.add(linkToLastToken(createColumn(name))); } )* + { result.setColumns(linkElements(columns)); } ] + ) + { return result; } +} + +TransitionRelation PostgreSqlTransitionRelation(): +{ TransitionRelation result = new TransitionRelation(); Token token; String name; } +{ + ( token= ) { result.setImage(accessEnum(TransitionRelation.Image.class, token.image)); } + [ { result.setUseAs(true); } ] name=RelObjectName() { result.setName(name); return result; } +} + +/** PostgreSQL ALTER TRIGGER name ON table RENAME TO or [NO] DEPENDS ON EXTENSION. */ +AlterTrigger AlterTrigger(): +{ + AlterTrigger result = new AlterTrigger(); + String name; + Table table; +} +{ + name=RelObjectName() { result.setName(name); } + table=Table() { result.setTable(table); } + ( + name=RelObjectName() { result.setNewName(name); } + | + LOOKAHEAD({ isExtensionDependencyAhead(1) }) + [ { result.setNoDependency(true); } ] + ContextualKeyword("DEPENDS") ContextualKeyword("EXTENSION") name=RelObjectName() + { result.setAction(AlterTrigger.Action.DEPENDS_ON_EXTENSION); result.setExtensionName(name); } + ) + { return result; } +} + +CreateTrigger PostgreSqlTrigger(boolean replace): +{ + CreateTrigger result = new CreateTrigger(); String name; Table table; CreateTrigger.Timing timing; + TriggerEvent event; TransitionRelation transition; Expression expression; Token token; boolean negative = false; + Statement body = null; + Function routine = new Function(); ExpressionList arguments = new ExpressionList(); +} +{ + [ { result.setConstraint(true); } ] + name=RelObjectName() { result.setTrigger(createTable(Collections.singletonList(name))); result.setOrReplace(replace); } + ( + LOOKAHEAD({ isAccessKeywordAhead("INSTEAD") }) AccessKeyword("INSTEAD") { result.setTiming(CreateTrigger.Timing.INSTEAD_OF); } + | timing=MySqlTriggerTiming() { result.setTiming(timing); } + ) + event=PostgreSqlTriggerEvent() { result.getEvents().add(event); } + ( event=PostgreSqlTriggerEvent() { result.getEvents().add(event); } )* + table=Table() { result.setTable(table); } + // greedy: FROM here names the referenced table, it never starts the trigger body + [ LOOKAHEAD(2) table=Table() { result.setReferencedTable(table); } ] + [ [ { negative = true; } ] { result.getConstraintAttributes().setDeferrable(!negative); } ] + [ LOOKAHEAD({ isAccessKeywordAhead("INITIALLY") }) + AccessKeyword("INITIALLY") ( token= ) + { result.getConstraintAttributes().setInitially(accessEnum(ConstraintAttributes.Initially.class, token.image)); } ] + [ LOOKAHEAD({ isAccessKeywordAhead("REFERENCING") }) AccessKeyword("REFERENCING") + transition=PostgreSqlTransitionRelation() { result.getTransitionRelations().add(transition); } + ( LOOKAHEAD({ isAccessKeywordAhead("OLD") || isAccessKeywordAhead("NEW") }) + transition=PostgreSqlTransitionRelation() { result.getTransitionRelations().add(transition); } )* ] + [ [ LOOKAHEAD({ isAccessKeywordAhead("EACH") }) AccessKeyword("EACH") { result.setUseEach(true); } ] + ( { result.setOrientation(CreateTrigger.Orientation.ROW); } + | { result.setOrientation(CreateTrigger.Orientation.STATEMENT); } ) ] + [ "(" expression=Expression() ")" { result.setWhenExpression(expression); } ] + ( + LOOKAHEAD(2) + ( | { result.setExecuteKeyword(CreateTrigger.ExecuteKeyword.PROCEDURE); } ) + name=AccessQualifiedName() { routine.setName(name); } + "(" [ expression=PostgreSqlTriggerArgument() { arguments.add(expression); } + ( "," expression=PostgreSqlTriggerArgument() { arguments.add(expression); } )* ] ")" + { routine.setParameters(arguments); result.setRoutine(routine); } + | + // DuckDB 2.0 runs a statement rather than a function + body=SingleStatement() { result.setBody(body); } ) - { return alterExp; } + { + requireAccessSyntax(!result.isConstraint() || !replace && result.getTiming() == CreateTrigger.Timing.AFTER + && result.getOrientation() == CreateTrigger.Orientation.ROW, "A constraint trigger requires AFTER FOR EACH ROW without OR REPLACE"); + requireAccessSyntax(result.isConstraint() || result.getReferencedTable() == null + && result.getConstraintAttributes().getDeferrable() == null && result.getConstraintAttributes().getInitially() == null, + "FROM and deferrability require a constraint trigger"); + return result; + } +} + +Expression PostgreSqlTriggerArgument(): +{ Expression result; Token token; String name; } +{ + ( + token= { result = stringValue(token); } + | token= { result = new LongValue(token.image); } + | token= { result = new DoubleValue(token.image); } + | name=RelObjectName() { result = linkToLastToken(createColumn(name)); } + ) + { return result; } } /** - * Parses ADD/ALTER/MODIFY operations within ALTER TABLE. - * Handles: PRIMARY KEY, INDEX/KEY, SPATIAL/FULLTEXT, column COMMENT, - * ADD PARTITION, column definitions, UNIQUE, FOREIGN KEY, CHECK ENFORCED, CONSTRAINT. + * Parses PostgreSQL CREATE EVENT TRIGGER. The routine invocation matches CREATE TRIGGER but takes + * no arguments; the event and filter names stay ordinary identifiers. */ -AlterExpression AlterExpressionAddAlterModify(): +CreateEventTrigger CreateEventTrigger(): { - AlterExpression alterExp = new AlterExpression(); - Token tk; - Token tk2 = null; - String sk3 = null; - String sk4 = null; - List columnNames = null; - List indexColumnNames = null; - List constraints = null; - Index index = null; - AlterExpression.ColumnDataType alterExpressionColumnDataType = null; - AlterExpression.ColumnDropNotNull alterExpressionColumnDropNotNull = null; - List indexSpec = new ArrayList(); - List partitionDefinition = null; + CreateEventTrigger statement = new CreateEventTrigger(); + CreateEventTrigger.Filter filter; + Function function = new Function(); + String name; } { - ( - { alterExp.setOperation(AlterOperation.ADD); } - | - { alterExp.setOperation(AlterOperation.ALTER); } - | - { alterExp.setOperation(AlterOperation.MODIFY); } - ) + name=RelObjectName() { statement.setName(name); } + name=RelObjectName() { statement.setEvent(name); } + [ filter=EventTriggerFilter() { statement.addFilters(filter); } + ( filter=EventTriggerFilter() { statement.addFilters(filter); } )* ] + ( | { statement.setExecuteKeyword(CreateTrigger.ExecuteKeyword.PROCEDURE); } ) + name=AccessQualifiedName() "(" ")" + { + function.setName(name); + function.setParameters(new ExpressionList()); + statement.setFunction(function); + return statement; + } +} + +CreateEventTrigger.Filter EventTriggerFilter(): +{ CreateEventTrigger.Filter filter = new CreateEventTrigger.Filter(); String name; Token value; } +{ + name=RelObjectName() { filter.setVariable(name); } + "(" value= { filter.addValues(stringValue(value)); } + ( "," value= { filter.addValues(stringValue(value)); } )* ")" + { return filter; } +} +/** Event trigger states reuse the enable states of table trigger and rule actions. */ +AlterEventTrigger AlterEventTrigger(): +{ AlterEventTrigger statement = new AlterEventTrigger(); RelationAlterAction.EnableState state; String name; } +{ + name=RelObjectName() { statement.setName(name); } ( - LOOKAHEAD({ getToken(1).kind == K_DEFAULT || getToken(1).kind == K_CONSTRAINT - && getToken(3).kind == K_DEFAULT }) index=DefaultConstraintSpec() { - requireDdlSyntax(alterExp.getOperation() == AlterOperation.ADD, - "Table-level DEFAULT constraints require ADD"); - alterExp.setIndex(index); - } - | - LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ALTER - && getToken(1).kind == K_INDEX }) - tk= sk3=RelObjectName() IndexOptionList(indexSpec) { - index = new Index().withIndexKeyword(tk.image).withName(sk3) - .withKind(Index.Kind.INDEX).withIndexSpec(indexSpec); - alterExp.setIndex(index); - } - | - LOOKAHEAD( ( | - | | ) "(", - { Dialect.INFORMIX.name().equals(getAsString(Feature.dialect)) }) - index=InformixConstraint() { - requireDdlSyntax(alterExp.getOperation() == AlterOperation.ADD, - "Informix constraint definitions require ADD"); - alterExp.setIndex(index); - } - | - LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ADD - && (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - || Dialect.MYSQL.name().equals(getAsString(Feature.dialect))) - && (getToken(1).kind == K_CONSTRAINT || getToken(1).kind == K_PRIMARY - || getToken(1).kind == K_UNIQUE || getToken(1).kind == K_FOREIGN - || getToken(1).kind == K_CHECK || getToken(1).kind == K_EXCLUDE) }) - index=TableConstraint(false) { setAlterTableIndex(alterExp, index); } - | - LOOKAHEAD({ isTableIndexAhead() }) index=TableIndexSpec(false) { - setAlterTableIndex(alterExp, index); - } - constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } - [ AlterExpressionUsingIndex(alterExp) ] - | - LOOKAHEAD(2) ( - sk3=RelObjectName() tk= { alterExp.withColumnName(sk3).withCommentText(tk.image); } - ) - | - LOOKAHEAD(3) ( - { - alterExp = new AlterExpressionPartition(); - alterExp.setOperation(AlterOperation.ADD_PARTITION); - } - partitionDefinition=PartitionDefinitions() { - alterExp.setPartitionDefinitions(partitionDefinition); - } - ) - | - LOOKAHEAD(3) ( - ( LOOKAHEAD(2) - ( - { alterExp.hasColumn(true); } - | - { alterExp.hasColumns(true); } - ) - )? - [ - LOOKAHEAD(2) - ( - { alterExp.setUseIfNotExists(true); } - | - { alterExp.setUsingIfExists(true); } - ) - ] - ( - LOOKAHEAD(3) AlterExpressionColumnChanges(alterExp) - | - LOOKAHEAD(3) alterExpressionColumnDropNotNull = AlterExpressionColumnDropNotNull() - { alterExp.addColDropNotNull( alterExpressionColumnDropNotNull);} - | - LOOKAHEAD(2) alterExpressionColumnDataType = AlterExpressionColumnDataType() - { alterExp.addColDataType(alterExpressionColumnDataType); } - ) - ) - | - LOOKAHEAD(3) AlterExpressionColumnChanges(alterExp) - | - // Standalone FK now uses ForeignKeyIndex, same as CONSTRAINT FK - ( - { ForeignKeyIndex fkIndex; } - fkIndex = ForeignKeySpec(null) - { - setAlterTableIndex(alterExp, fkIndex); - } - ) - | - LOOKAHEAD(3) ( - sk3=RelObjectName() - { boolean enforced = true; } - [ tk = { enforced = false; } ] - { - alterExp.setEnforced(enforced); - alterExp.setConstraintType("CHECK"); - alterExp.setConstraintSymbol(sk3); - } - ) - | - ( - AlterExpressionAddConstraint(alterExp) - ) + state=PostgreSqlEnableState() { statement.setEnableState(state); } + | ContextualKeyword("OWNER") name=RelObjectName() { statement.setOwner(name); } + | name=RelObjectName() { statement.setNewName(name); } ) - { return alterExp; } + { return statement; } } -/** Parses CockroachDB primary-key elements without legacy raw index parameters. */ -Index.ColumnParams CockroachPrimaryKeyColumn(): +List UsersList(): { - Index.ColumnParams column; - String name; - Expression expression; - Token token; + List users = new ArrayList(); + String user = null; } { - ( - LOOKAHEAD({ isFunctionAhead() }) expression=Function() - { column = new Index.ColumnParams(expression).withExpressionParenthesized(false); } - | - name=RelObjectName() { column = new Index.ColumnParams(name); } - | - "(" expression=Expression() ")" { column = new Index.ColumnParams(expression); } - ) - [ (token= | token=) { column.setOperatorClass(token.image); } ] - [ (token= | token=) { - column.setSortOrder(Index.ColumnParams.SortOrder.valueOf(token.image.toUpperCase(Locale.ROOT))); - } ] - [ (token= | token=) { - column.setNullOrdering(Index.ColumnParams.NullOrdering.valueOf(token.image.toUpperCase(Locale.ROOT))); - } ] - { return column; } + user=RelObjectName() { users.add(user); } + ( "," user=ColumnsNamesListItem() { users.add(user); } )* + { + return users; + } } -AlterExpressionPrimaryKey CockroachAlterPrimaryKey(): +void readGrantTypes(ArrayList privileges): { - AlterExpressionPrimaryKey action = new AlterExpressionPrimaryKey(); - List columns = new ArrayList(); - Index.ColumnParams column; - List options; - Expression bucketCount; - Token token; } { - - "(" column=CockroachPrimaryKeyColumn() { columns.add(column); } - ( "," column=CockroachPrimaryKeyColumn() { columns.add(column); } )* ")" - { action.getIndex().setColumns(columns); } - [ { action.setUsingHash(true); } - [ LOOKAHEAD( ) token= { - requireDdlSyntax("BUCKET_COUNT".equalsIgnoreCase(token.image), "Expected BUCKET_COUNT"); - } - "=" bucketCount=Expression() { action.setBucketCount(bucketCount); } ] - ] - // LOOKAHEAD(2) as in the identical constructs at CreateIndex() and AlterExpression(). - [ LOOKAHEAD(2) options=PostgreSqlIndexOptions() { action.getIndex().setStorageParameters(options); } ] - { return action; } + {privileges.add("SELECT");} | + {privileges.add("INSERT");} | + {privileges.add("UPDATE");} | + {privileges.add("DELETE");} | + {privileges.add("EXECUTE");} | + {privileges.add("ALTER");} | + {privileges.add("DROP");} } -/** - * Parses all RENAME variants within ALTER TABLE. - * Handles: RENAME [COLUMN] old TO new, RENAME [TO|AS] tablename, RENAME tablename, - * RENAME INDEX/KEY/CONSTRAINT old TO new. - */ -AlterExpression AlterExpressionRenameOp(): +Sequence Sequence() #Sequence : { - AlterExpression alterExp = new AlterExpressionRename(); - Token tk; - Token tk2; - Index index; - Table newTable; + ObjectNames data = null; + String serverName = null, databaseName = null, schemaName = null, sequenceName = null; } { - - ( - LOOKAHEAD(2) ( - ( - { alterExp.setOperation(AlterOperation.RENAME_INDEX); } - | { alterExp.setOperation(AlterOperation.RENAME_KEY); } - ) - | - { alterExp.setOperation(AlterOperation.RENAME_CONSTRAINT); } - ) - (tk= | tk=) { - alterExp.setOldIndex(new Index().withName(tk.image)); - } - - (tk2= | tk2=) { - index = new Index().withName(tk2.image); - alterExp.setIndex(index); - } - | - LOOKAHEAD({ getToken(1).kind == K_TO || getToken(1).kind == K_AS }) ( - (tk= | tk=) { - alterExp.setOperation(AlterOperation.RENAME_TABLE); - alterExp.setTableRenameKeyword(AlterExpression.TableRenameKeyword.valueOf( - tk.image.toUpperCase(Locale.ROOT))); - } - newTable=Table() { alterExp.setNewTable(newTable); } - ) - | - LOOKAHEAD(3) - ( - { alterExp.setOperation(AlterOperation.RENAME); } - [ { alterExp.hasColumn(true); } ] - (tk=KeywordOrIdentifier()) { alterExp.setColOldName(tk.image); } - - (tk2=KeywordOrIdentifier()) { alterExp.setColumnName(tk2.image); } - ) - | - ( - { - alterExp.setOperation(AlterOperation.RENAME_TABLE); - alterExp.setTableRenameKeyword(AlterExpression.TableRenameKeyword.NONE); - } - newTable=Table() { alterExp.setNewTable(newTable); } - ) - ) - { return alterExp; } + data = RelObjectNames() + { + Sequence sequence = new Sequence(data.getNames()); + linkAST(sequence,jjtThis); + return sequence; + } } -AlterExpressionPartition AlterExpressionPostgreSqlPartitionOp(): +List SequenceParameters(): { - AlterExpressionPartition alterExp = new AlterExpressionPartition(); - Table partitionTable = null; - PartitionBound partitionBound = null; + List parameters = new ArrayList(); + Sequence.Parameter parameter; +} +{ + ( LOOKAHEAD(2) parameter=SequenceParameter() { parameters.add(parameter); } )* + { return parameters; } +} + +Sequence.Parameter SequenceParameter(): +{ + Sequence.ParameterType type; + Long value = null; + Token token; + boolean withKeyword = false; } { ( - partitionTable=Table() - partitionBound=PostgreSqlPartitionBound() - { - alterExp.setOperation(AlterOperation.ATTACH_PARTITION); - alterExp.setPartitionTable(partitionTable); - alterExp.setPartitionBound(partitionBound); - } + [ { withKeyword = true; } ] value=SequenceParameterValue() + { type = withKeyword ? Sequence.ParameterType.INCREMENT_BY : Sequence.ParameterType.INCREMENT; } | - partitionTable=Table() - { - alterExp.setOperation(AlterOperation.DETACH_PARTITION); - alterExp.setPartitionTable(partitionTable); - } - [ - { - alterExp.setDetachMode(AlterExpressionPartition.DetachMode.CONCURRENTLY); - } - | - { - alterExp.setDetachMode(AlterExpressionPartition.DetachMode.FINALIZE); - } - ] + [ { withKeyword = true; } ] value=SequenceParameterValue() + { type = withKeyword ? Sequence.ParameterType.START_WITH : Sequence.ParameterType.START; } + | + [ LOOKAHEAD(2) value=SequenceParameterValue() ] + { type = Sequence.ParameterType.RESTART_WITH; } + | + ( token= | token= | token= ) value=SequenceParameterValue() + { type = Sequence.ParameterType.valueOf(token.image.toUpperCase(Locale.ROOT)); } + | + ( token= | token= | token= ) + { type = Sequence.ParameterType.valueOf("NO_" + token.image.toUpperCase(Locale.ROOT)); } + | + ( token= | token= | token= | token= + | token= | token= | token= | token= + | token= | token= | token= ) + { type = Sequence.ParameterType.valueOf(token.image.toUpperCase(Locale.ROOT)); } ) - { return alterExp; } + { return new Sequence.Parameter(type).withValue(value); } } -/** -* Dispatcher production for all ALTER TABLE expression types. -* Delegates to focused sub-productions for each operation category. -*/ -AlterExpression AlterExpression(): +Long SequenceParameterValue(): { - AlterExpression alterExp = null; - Token tk; - Token tk2 = null; - String sk3 = null; + Token sign = null; + Token value; +} +{ + [ sign="-" | sign="+" ] value= + { return Long.valueOf((sign == null ? "" : sign.image) + value.image); } +} - // for captureRest() - List tokens = new LinkedList(); +SequenceOwnership SequenceOwnership(): +{ + Token token; + Column column; + SequenceOwnership ownership; } { + token= { + requireDdlSyntax("OWNED".equalsIgnoreCase(token.image), "Expected OWNED"); + } + + ( LOOKAHEAD(1) { ownership = SequenceOwnership.none(); } + | column=Column() { ownership = SequenceOwnership.ownedBy(column); } ) + { return ownership; } +} +/** AS, ownership and numeric parameters share the same sequence-option boundary. */ +void SequenceDefinitionOptions(Sequence sequence): +{ + List parameters = new ArrayList(); + Sequence.Parameter parameter; + SequenceOwnership ownership; + Token dataType; +} +{ ( - LOOKAHEAD( , - { Dialect.COCKROACHDB.name().equals(getAsString(Feature.dialect)) }) - alterExp = CockroachAlterPrimaryKey() - | - alterExp = AlterExpressionAddAlterModify() - | - ( - { alterExp = new AlterExpression(); } - { alterExp.setOperation(AlterOperation.CHANGE); } - [ { alterExp.hasColumn(true); alterExp.setOptionalSpecifier("COLUMN"); } ] + LOOKAHEAD(2) ( - { AlterExpression.ColumnDataType alterExpressionColumnDataType; } - (tk=KeywordOrIdentifier()) - alterExpressionColumnDataType = AlterExpressionColumnDataType() { alterExp.withColumnOldName(tk.image).addColDataType(alterExpressionColumnDataType); } - ) - ) - | - alterExp = AlterExpressionDrop() - | - LOOKAHEAD(5) ( - { alterExp = new AlterExpression(); } - { - alterExp.setOperation(AlterOperation.FORCE_ROW_LEVEL_SECURITY); + ( dataType= | dataType= ) { + requireDdlSyntax(sequence.getDataType() == null, "Duplicate sequence AS clause"); + sequence.setDataType(dataType.image); } - ) - | - LOOKAHEAD(5) ( - { alterExp = new AlterExpression(); } - { - alterExp.setOperation(AlterOperation.NO_FORCE_ROW_LEVEL_SECURITY); + | + LOOKAHEAD({ isKeywordAhead("OWNED") }) ownership=SequenceOwnership() { + requireDdlSyntax(sequence.getOwnership() == null, "Duplicate sequence OWNED BY clause"); + sequence.setOwnership(ownership); } + | + parameter=SequenceParameter() { parameters.add(parameter); } ) - | - LOOKAHEAD(1) ( - { alterExp = new AlterExpression(); } - { alterExp.setOperation(AlterOperation.FORCE); } - ) - | - ( - { alterExp = new AlterExpressionTableOption(); } - { alterExp.setOperation(AlterOperation.ALGORITHM); } - ["=" { alterExp.setUseEqual(true);} ] - sk3 = RelObjectName() { alterExp.setAlgorithmOption(sk3); } - ) - | - ( - { alterExp = new AlterExpressionTableOption(); } - { alterExp.setOperation(AlterOperation.KEY_BLOCK_SIZE); } - ["=" { alterExp.setUseEqual(true);} ] - tk= { alterExp.setKeyBlockSize(Integer.parseInt(tk.image)); } - ) - | - ( - { alterExp = new AlterExpressionTableOption(); } - { alterExp.setOperation(AlterOperation.LOCK); } - ["=" { alterExp.setUseEqual(true);} ] - sk3 = RelObjectName() { alterExp.setLockOption(sk3); } - ) - | - ( - { alterExp = new AlterExpressionTableOption(); } - { alterExp.setOperation(AlterOperation.ENGINE); } - ["=" { alterExp.setUseEqual(true);} ] - sk3 = RelObjectName() { alterExp.setEngineOption(sk3); } - ) - | - LOOKAHEAD(2) alterExp = AlterExpressionRenameOp() - | - ({ alterExp = new AlterExpressionCharset(); } - { - alterExp.setOperation(AlterOperation.CONVERT); - alterExp.setConvertType(AlterExpression.ConvertType.CONVERT_TO); - } - tk= { alterExp.setCharacterSet(tk.image); } - [ tk2= { alterExp.setCollation(tk2.image); }] - ) - | - LOOKAHEAD(3) - ( - { alterExp = new AlterExpressionCharset(); } - - ( - [ "=" { alterExp.setHasEqualForCharacterSet(true); } ] - tk= { - alterExp.setOperation(AlterOperation.CONVERT); - alterExp.setConvertType(AlterExpression.ConvertType.DEFAULT_CHARACTER_SET); - alterExp.setCharacterSet(tk.image); - } - [ [ "=" { alterExp.setHasEqualForCollate(true); } ] - tk2= { alterExp.setCollation(tk2.image); }] - | - - [ "=" { alterExp.setHasEqualForCollate(true); } ] - tk= { - alterExp.setOperation(AlterOperation.COLLATE); - alterExp.setCollation(tk.image); - alterExp.setDefaultCollateSpecified(true); - } - ) - ) - | - ({ alterExp = new AlterExpressionCharset(); } - [ "=" { alterExp.setHasEqualForCharacterSet(true); } ] - tk= { - alterExp.setOperation(AlterOperation.CONVERT); - alterExp.setConvertType(AlterExpression.ConvertType.CHARACTER_SET); - alterExp.setCharacterSet(tk.image); + )* + { + sequence.setParameters(parameters); + if (!parameters.isEmpty() || sequence.getOwnership() != null) { + widen(sequence, null, getToken(0)); } - [ [ "=" { alterExp.setHasEqualForCollate(true); } ] - tk2= { alterExp.setCollation(tk2.image); }] - ) - | - ({ alterExp = new AlterExpressionCharset(); } - { alterExp.setOperation(AlterOperation.COLLATE); } - [ "=" { alterExp.setHasEqualForCollate(true); } ] - tk= { alterExp.setCollation(tk.image); } - ) - | - ({ alterExp = new AlterExpressionTableOption(); } - {alterExp.setOperation(AlterOperation.COMMENT);} - ["=" {alterExp.setOperation(AlterOperation.COMMENT_WITH_EQUAL_SIGN);} ] - tk= { alterExp.setCommentText(tk.image); } - ) - | - ({ alterExp = new AlterExpressionTableOption(); } - {alterExp.setOperation(AlterOperation.SET_TABLE_OPTION);} - ["=" { alterExp.setUseEqual(true);} ] - tk= { - if (alterExp.getUseEqual()) { - alterExp.setTableOption("ENCRYPTION = " + tk.image); - } else { - alterExp.setTableOption("ENCRYPTION " + tk.image); - } - } - ) - | - alterExp = AlterExpressionDiscardOrImport() - | - alterExp = AlterExpressionPostgreSqlPartitionOp() - | - LOOKAHEAD(4) ( - { alterExp = new AlterExpression(); } - { - alterExp.setOperation(AlterOperation.DISABLE_ROW_LEVEL_SECURITY); - } - ) - | - LOOKAHEAD(2) ( - { alterExp = new AlterExpressionTableOption(); } - { - alterExp.setOperation(AlterOperation.DISABLE_KEYS); - } - ) - | - LOOKAHEAD(4) ( - { alterExp = new AlterExpression(); } - { - alterExp.setOperation(AlterOperation.ENABLE_ROW_LEVEL_SECURITY); - } - ) - | - LOOKAHEAD(2) ( - { alterExp = new AlterExpressionTableOption(); } - { - alterExp.setOperation(AlterOperation.ENABLE_KEYS); - } - ) - | - ({ alterExp = new AlterExpressionTableOption(); } - {alterExp.setOperation(AlterOperation.SET_TABLE_OPTION);} - ["=" { alterExp.setUseEqual(true);} ] - tk= { - if (alterExp.getUseEqual()) { - alterExp.setTableOption("AUTO_INCREMENT = " + tk.image); - } else { - alterExp.setTableOption("AUTO_INCREMENT " + tk.image); - } - } - ) - | - alterExp = AlterExpressionPartitionOp() - | - { alterExp = new AlterExpression(); } - tokens = captureRest() { - alterExp.setOperation(AlterOperation.UNSPECIFIC); - StringBuilder optionalSpecifier = new StringBuilder(); - int i=0; + } +} - for (String s: tokens) - if (! (s.equals(";") || s.equals("\n\n\n")) ) { - if (i>0) - optionalSpecifier.append( " " ); - optionalSpecifier.append( s ); - i++; - } +CreateSequence CreateSequence(): +{ + CreateSequence result = new CreateSequence(); + Sequence sequence; + Token persistence; + Token scope = null; +} +{ + [ + ( { result.setPersistence(CreateSequence.Persistence.UNLOGGED); } + | + [ ( scope= | scope= ) ] + ( persistence= | persistence= ) { + result.setPersistence(CreateSequence.Persistence.valueOf( + (scope == null ? "" : scope.image.toUpperCase(Locale.ROOT) + "_") + + persistence.image.toUpperCase(Locale.ROOT))); + } ) + ] + + [ LOOKAHEAD(3) { result.setIfNotExists(true); } ] + sequence=Sequence() { result.setSequence(sequence); } + SequenceDefinitionOptions(sequence) + { return result; } +} - alterExp.setOptionalSpecifier( optionalSpecifier.toString() ); - } +AlterSequence AlterSequence(): +{ + AlterSequence result = new AlterSequence(); + Sequence sequence; + String name; +} +{ + [ LOOKAHEAD(2) { result.setIfExists(true); } ] + sequence=Sequence() { result.setSequence(sequence); } + ( + name=RelObjectName() + { result.setAction(AlterSequence.Action.RENAME); result.setNewName(name); } + | + LOOKAHEAD({ isKeywordAhead("OWNER") }) ContextualKeyword("OWNER") name=RelObjectName() + { result.setAction(AlterSequence.Action.OWNER); result.setOwner(name); } + | + + ( + name=RelObjectName() + { result.setAction(AlterSequence.Action.SET_SCHEMA); result.setSchemaName(name); } + | { result.setAction(AlterSequence.Action.SET_UNLOGGED); } + | ContextualKeyword("LOGGED") { result.setAction(AlterSequence.Action.SET_LOGGED); } + ) + | + SequenceDefinitionOptions(sequence) ) - - { - return alterExp; - } + { return result; } } -Statement Alter(): + +Statement Create(): { + boolean isUsingOrReplace=false; + Token tk; Statement statement; List captureRest; } { + [ { isUsingOrReplace = true; } ] ( - ( - - ( - LOOKAHEAD({ isKeywordAhead("ROLE") || isKeywordAhead("USER") || isKeywordAhead("GROUP") }) - statement = AlterRole() - | - statement = AlterDefaultPrivileges() - | - LOOKAHEAD() statement = AlterSchema() - | - LOOKAHEAD() statement = AlterType() - | - LOOKAHEAD() statement = AlterDomain() - | - LOOKAHEAD({ isKeywordAhead("EXTENSION") }) statement = AlterExtension() - | - LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) statement = AlterPublication() - | - LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) statement = AlterSubscription() - | - statement = AlterEvent() - | - statement = AlterTable() - | - statement = AlterSession() - | - statement = AlterView(false) - | - statement = AlterSystemStatement() - | - statement = AlterSequence() - | - captureRest = captureRest() - { - statement = new UnsupportedStatement("ALTER", captureRest); - } - ) - ) + LOOKAHEAD({ isKeywordAhead("ACCESS") && "METHOD".equalsIgnoreCase(getToken(2).image) }) + { requireDdlSyntax(!isUsingOrReplace, "CREATE ACCESS METHOD does not support OR REPLACE"); } + statement = CreateAccessMethod() | - ( - - ( - statement = AlterView(true) - | - captureRest = captureRest() - { - statement = new UnsupportedStatement("REPLACE", captureRest); - } - ) - ) + LOOKAHEAD( ) { requireDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for foreign-data objects"); } statement = CreateForeignDataWrapper() + | + LOOKAHEAD({ isKeywordAhead("SERVER") }) { requireDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for foreign-data objects"); } statement = CreateServer() + | + LOOKAHEAD({ getToken(1).kind == K_USER && "MAPPING".equalsIgnoreCase(getToken(2).image) }) { requireDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for foreign-data objects"); } statement = CreateUserMapping() + | + LOOKAHEAD({ isCreateLanguageAhead() }) statement = CreateLanguage(isUsingOrReplace) + | + LOOKAHEAD({ isTextSearchMetadataAhead() }) + { requireDdlSyntax(!isUsingOrReplace, "Text-search objects do not support OR REPLACE"); } + statement = CreateTextSearchMetadata() + | + LOOKAHEAD({ getToken(1).kind == K_TEXT_LITERAL && getToken(2).kind == K_SEARCH + && "CONFIGURATION".equalsIgnoreCase(getToken(3).image) }) + { requireDdlSyntax(!isUsingOrReplace, "CREATE TEXT SEARCH CONFIGURATION does not support OR REPLACE"); } statement = CreateTextSearchConfiguration() + | + LOOKAHEAD({ isKeywordAhead("RULE") }) statement = CreateRule(isUsingOrReplace) + | + LOOKAHEAD({ isKeywordAhead("COLLATION") }) { requireDdlSyntax(!isUsingOrReplace, "CREATE COLLATION does not support OR REPLACE"); } statement = CreateCollation() + | + LOOKAHEAD({ isPostgreSqlOperatorDdlAhead() }) + { requireDdlSyntax(!isUsingOrReplace, "CREATE OPERATOR does not support OR REPLACE"); } + statement = PostgreSqlCreateOperator() + | + LOOKAHEAD({ isPostgreSqlCreateAggregateAhead() }) statement = CreateAggregate(isUsingOrReplace) + | + LOOKAHEAD({ getToken(1).kind == K_TABLESPACE + || isKeywordAhead("UNDO") && getToken(2).kind == K_TABLESPACE }) + { requireDdlSyntax(!isUsingOrReplace, "CREATE TABLESPACE does not support OR REPLACE"); } + statement = CreateTablespace() + | + LOOKAHEAD({ isKeywordAhead("STATISTICS") }) statement = CreateStatistics() + | + // a statement of another product that starts with the same words stays unsupported + LOOKAHEAD({ isCastDdlAhead() }) statement = CastDdl(isUsingOrReplace) + | + LOOKAHEAD({ isSpatialReferenceSystemAhead() }) + statement = CreateSpatialReferenceSystem(isUsingOrReplace) + | + LOOKAHEAD({ isMySqlCreateRoleAhead() }) statement = MySqlCreateRole() + { requireAccessSyntax(!isUsingOrReplace, "CREATE ROLE does not accept OR REPLACE"); } + | + LOOKAHEAD({ isPostgreSqlRoleAhead() }) statement = CreateRole() + { requireAccessSyntax(!isUsingOrReplace, "CREATE ROLE does not accept OR REPLACE"); } + | + LOOKAHEAD({ isPostgreSqlTriggerAhead() }) statement = PostgreSqlTrigger(isUsingOrReplace) + | + LOOKAHEAD(1, ) { requireTypeDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE TYPE"); } statement = CreateType() + | + LOOKAHEAD(1, ) { requireTypeDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE DOMAIN"); } statement = CreateDomain() + | + LOOKAHEAD({ isKeywordAhead("EXTENSION") + && "REPOSITORY".equalsIgnoreCase(getToken(2).image) }) + { requireTypeDdlSyntax(!isUsingOrReplace, + "OR REPLACE is not supported for CREATE EXTENSION REPOSITORY"); } + statement = CreateExtensionRepository() + | + LOOKAHEAD({ isKeywordAhead("EXTENSION") }) { requireTypeDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE EXTENSION"); } statement = CreateExtension() + | + LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) + { requireReplicationSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE PUBLICATION"); } + statement = CreatePublication() + | + LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) + { requireReplicationSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE SUBSCRIPTION"); } + statement = CreateSubscription() + | + statement = CreateUser() + | + LOOKAHEAD({ isPostgreSqlEventTriggerAhead(false) }) + { requireDdlSyntax(!isUsingOrReplace, "CREATE EVENT TRIGGER does not support OR REPLACE"); } + statement = CreateEventTrigger() + | + LOOKAHEAD([ MySqlRoutineDefiner() ] , + { getToken(1).kind == K_EVENT || isKeywordAhead("DEFINER") }) + statement = CreateEvent() + | + LOOKAHEAD(MySqlViewPrefix() ) statement = CreateView(isUsingOrReplace) + | + LOOKAHEAD([ MySqlTriggerDefiner() ] , + { getToken(1).kind == K_TRIGGER || isKeywordAhead("DEFINER") }) + statement = CreateTrigger(isUsingOrReplace) + | + LOOKAHEAD({ isCreateMacroAhead() }) statement = CreateMacro(isUsingOrReplace) + | + LOOKAHEAD({ isCreateFunctionMacroAhead() }) statement = CreateMacro(isUsingOrReplace) + | + LOOKAHEAD({ isLoadableFunctionAhead() }) statement = CreateLoadableFunction(isUsingOrReplace) + | + LOOKAHEAD([ MySqlRoutineDefiner() ] ( | )) + statement = CreateFunctionStatement(isUsingOrReplace) + | + statement = CreateSchema() + | + statement = CreateDatabase() + | + LOOKAHEAD([ | [ | ] ( | ) ] ) + statement = CreateSequence() + | + statement = CreateSynonym(isUsingOrReplace) + | + LOOKAHEAD({ isUnknownCreateAhead() }) captureRest = captureRest() + { statement = unsupportedCreate(isUsingOrReplace, captureRest); } + | + LOOKAHEAD(3) statement = CreateTable(isUsingOrReplace) + | + LOOKAHEAD(2) statement = CreateView(isUsingOrReplace) + | + statement = CreatePolicy() + | + /* @fixme + * Create Index uses CreateParameter() which allows all kind of tokens + * it can conflict with other statements and must be at the end right now + */ + statement = CreateIndex() + | + captureRest = captureRest() + { statement = unsupportedCreate(isUsingOrReplace, captureRest); } ) { return statement; } } -Alter AlterTable(): +/** + * MySQL CREATE [AGGREGATE] FUNCTION [IF NOT EXISTS] name RETURNS type SONAME 'library', selected by + * isLoadableFunctionAhead(). SONAME is not a token. MySQL has no OR REPLACE; MariaDB has. + */ +CreateFunction CreateLoadableFunction(boolean isUsingOrReplace): { - Alter alter = new Alter(); - Table table; - AlterExpression alterExp; - boolean usingIfExists = false; + CreateFunction function = new CreateFunction(); + LoadableFunction definition = new LoadableFunction(); + String name; + Token token; } { - - [ { alter.setUseOnly(true); } ] - [ LOOKAHEAD(2) { alter.setUseTableIfExists(true); } ] - table=Table() { alter.setTable(table); } - - alterExp=AlterExpression() { alter.addAlterExpression(alterExp); } - - ("," alterExp=AlterExpression() { alter.addAlterExpression(alterExp); } )* - { - return alter; + requireDdlSyntax(!isUsingOrReplace || !Dialect.MYSQL.name().equals(getAsString(Feature.dialect)), + "A MySQL loadable function does not support OR REPLACE"); + function.setOrReplace(isUsingOrReplace); + } + [ { function.setAggregate(true); } ] + + [ LOOKAHEAD(2) { definition.setIfNotExists(true); } ] + name=RelObjectName() { definition.setName(name); } + + ( token= | token= | token= ) + { + requireDdlSyntax(LoadableFunction.ReturnType.from(token.image) != null, + "A loadable function returns STRING, INTEGER, REAL or DECIMAL"); + definition.setReturnTypeKeyword(token.image); + } + ContextualKeyword("SONAME") + ( token= | token= ) + { + // a quoted text without prefix; double quotes are an identifier token in some configurations + requireDdlSyntax(token.image.startsWith("'") || token.image.startsWith("\""), + "SONAME expects a string literal"); + definition.setLibrary(token.kind == S_CHAR_LITERAL ? stringValue(token) + : linkToLastToken(new StringValue(token.image))); + } + { + function.setLoadableFunction(definition); + return function; } } -AlterSession AlterSession(): +/** With a MySQL dialect, the characteristics are also parsed; the tokens still render the statement. */ +CreateFunctionalStatement CreateFunctionStatement(boolean isUsingOrReplace): { - AlterSessionOperation operation = null; - List parameters = new ArrayList(); - Token token; + CreateFunctionalStatement type = null; + List tokens = new LinkedList(); + String statementType = null; + MySqlDefiner definer = null; + List characteristics = new ArrayList(); } { - ( - ( - ( { operation = AlterSessionOperation.ADVISE_COMMIT; } - | { operation = AlterSessionOperation.ADVISE_ROLLBACK; } - | { operation = AlterSessionOperation.ADVISE_NOTHING; } - ) - ) - | - ( - { operation = AlterSessionOperation.CLOSE_DATABASE_LINK; } - ) - | - ( - ( { operation = AlterSessionOperation.ENABLE_COMMIT_IN_PROCEDURE; } - | { operation = AlterSessionOperation.ENABLE_GUARD; } - | ( { operation = AlterSessionOperation.ENABLE_PARALLEL_DML; } - | { operation = AlterSessionOperation.ENABLE_PARALLEL_DDL; } - | { operation = AlterSessionOperation.ENABLE_PARALLEL_QUERY; } - ) - | { operation = AlterSessionOperation.ENABLE_RESUMABLE; } - ) - ) - | - ( - ( { operation = AlterSessionOperation.DISABLE_COMMIT_IN_PROCEDURE; } - | { operation = AlterSessionOperation.DISABLE_GUARD; } - | ( { operation = AlterSessionOperation.DISABLE_PARALLEL_DML; } - | { operation = AlterSessionOperation.DISABLE_PARALLEL_DDL; } - | { operation = AlterSessionOperation.DISABLE_PARALLEL_QUERY; } - ) - | { operation = AlterSessionOperation.DISABLE_RESUMABLE; } - ) - ) - | - ( - ( { operation = AlterSessionOperation.FORCE_PARALLEL_DML; } - | { operation = AlterSessionOperation.FORCE_PARALLEL_DDL; } - | { operation = AlterSessionOperation.FORCE_PARALLEL_QUERY; } - ) - ) - | - ( - { operation = AlterSessionOperation.SET; } - ) - ) - - ( ( token = - | token = - | token = "=" - | token = - | token = - ) { parameters.add( token.image ); } - )* - - - { - return new AlterSession(operation, parameters); + [ definer=MySqlRoutineDefiner() ] + ( + { statementType = "FUNCTION"; } + | + { statementType = "PROCEDURE"; } + ) + tokens=captureFunctionBody(isMySqlDialect() ? characteristics : null) + { + if(statementType.equals("FUNCTION")) { + type = new CreateFunction(isUsingOrReplace, tokens); + } + if(statementType.equals("PROCEDURE")) { + type = new CreateProcedure(isUsingOrReplace, tokens); } + type.setFunctionDeclarationParts(tokens, characteristics); + type.setDefiner(definer); + return type; + } } -AlterSystemStatement AlterSystemStatement(): +/** + * PostgreSQL ALTER FUNCTION, PROCEDURE or ROUTINE, or MySQL ALTER FUNCTION or PROCEDURE. One + * statement's characteristics belong to one dialect; MySQL's take no argument list. + */ +AlterRoutine AlterRoutine(): { - AlterSystemOperation operation = null; - List parameters = new LinkedList(); + AlterRoutine result = new AlterRoutine(); + RoutineReference routine; + RoutineCharacteristic characteristic; + String name; } { - ( - ( - { operation = AlterSystemOperation.ARCHIVE_LOG; } - ) + ( + { result.setRoutineType(AlterRoutine.RoutineType.FUNCTION); } | - ( - { operation = AlterSystemOperation.CHECKPOINT; } - ) + { result.setRoutineType(AlterRoutine.RoutineType.PROCEDURE); } | - ( - { operation = AlterSystemOperation.DUMP_ACTIVE_SESSION_HISTORY; } - ) + ContextualKeyword("ROUTINE") { result.setRoutineType(AlterRoutine.RoutineType.ROUTINE); } + ) + routine=RoutineReference(false) { result.setRoutine(routine); } + ( + name=RelObjectName() + { result.setAction(AlterRoutine.Action.RENAME); result.setNewName(name); } | - ( - ( - ContextualKeyword("DISTRIBUTED") ContextualKeyword("RECOVERY") { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; } - | { operation = AlterSystemOperation.ENABLE_DISTRIBUTED_RECOVERY; } - ) - ) + LOOKAHEAD({ isWordSequenceAhead(1, "OWNER", "TO") }) ContextualKeyword("OWNER") name=RelObjectName() + { result.setAction(AlterRoutine.Action.OWNER); result.setOwner(name); } | - ( - ( - ContextualKeyword("DISTRIBUTED") ContextualKeyword("RECOVERY") { operation = AlterSystemOperation.DISABLE_DISTRIBUTED_RECOVERY; } - | { operation = AlterSystemOperation.DISABLE_RESTRICTED_SESSION; } - ) - ) + LOOKAHEAD({ getToken(1).kind == K_SET && getToken(2).kind == K_SCHEMA + && !isPostgreSqlRoutineCharacteristicAhead(1) }) + name=RelObjectName() + { result.setAction(AlterRoutine.Action.SET_SCHEMA); result.setSchemaName(name); } | - ( - { operation = AlterSystemOperation.FLUSH; } - ) + LOOKAHEAD({ isExtensionDependencyAhead(1) }) + [ { result.setNoDependency(true); } ] + ContextualKeyword("DEPENDS") ContextualKeyword("EXTENSION") name=RelObjectName() + { result.setAction(AlterRoutine.Action.DEPENDS_ON_EXTENSION); result.setExtensionName(name); } | + LOOKAHEAD({ isMySqlRoutineCharacteristicAhead(1) }) ( - { operation = AlterSystemOperation.DISCONNECT_SESSION; } - ) + LOOKAHEAD({ isMySqlRoutineCharacteristicAhead(1) }) + characteristic=MySqlRoutineCharacteristic(false) { result.getCharacteristics().add(characteristic); } + )+ + { + requireDdlSyntax(result.getRoutineType() != AlterRoutine.RoutineType.ROUTINE + && routine.getArguments() == null, + "MySQL characteristics require ALTER FUNCTION or PROCEDURE without arguments"); + } | ( - { operation = AlterSystemOperation.KILL_SESSION; } - ) + LOOKAHEAD({ isPostgreSqlRoutineCharacteristicAhead(1) }) + characteristic=PostgreSqlRoutineCharacteristic() { result.getCharacteristics().add(characteristic); } + )+ + [ { result.setRestrict(true); } ] + ) + { return result; } +} + +RoutineCharacteristic PostgreSqlRoutineCharacteristic(): +{ + RoutineCharacteristic.Kind kind = RoutineCharacteristic.Kind.CONFIGURATION_PARAMETER; + RoutineCharacteristic.SecurityClause clause = null; + ConfigurationParameterChange change = null; + String value = null; +} +{ + ( + change=ConfigurationParameterChange() | - ( - { operation = AlterSystemOperation.SWITCH; } - ) + LOOKAHEAD({ isKeywordAhead("IMMUTABLE") }) ContextualKeyword("IMMUTABLE") + { kind = RoutineCharacteristic.Kind.IMMUTABLE; } | - ( - { operation = AlterSystemOperation.SUSPEND; } - ) + LOOKAHEAD({ isKeywordAhead("STABLE") }) ContextualKeyword("STABLE") + { kind = RoutineCharacteristic.Kind.STABLE; } | - ( - { operation = AlterSystemOperation.RESUME; } - ) + { kind = RoutineCharacteristic.Kind.VOLATILE; } | - ( - { operation = AlterSystemOperation.QUIESCE; } - ) + LOOKAHEAD({ isKeywordAhead("CALLED") }) ContextualKeyword("CALLED") ContextualKeyword("INPUT") + { kind = RoutineCharacteristic.Kind.CALLED_ON_NULL_INPUT; } | - ( - { operation = AlterSystemOperation.UNQUIESCE; } - ) + ContextualKeyword("INPUT") + { kind = RoutineCharacteristic.Kind.RETURNS_NULL_ON_NULL_INPUT; } | - ( - { operation = AlterSystemOperation.SHUTDOWN; } - ) + { kind = RoutineCharacteristic.Kind.STRICT; } | - ( - { operation = AlterSystemOperation.REGISTER; } - ) + LOOKAHEAD({ isKeywordAhead("LEAKPROOF") }) ContextualKeyword("LEAKPROOF") + { kind = RoutineCharacteristic.Kind.LEAKPROOF; } | - ( - { operation = AlterSystemOperation.SET; } - ) + ContextualKeyword("LEAKPROOF") { kind = RoutineCharacteristic.Kind.NOT_LEAKPROOF; } + | + LOOKAHEAD({ isKeywordAhead("EXTERNAL") }) ContextualKeyword("EXTERNAL") + kind=RoutineSecurity() { clause = RoutineCharacteristic.SecurityClause.EXTERNAL_SECURITY; } | + kind=RoutineSecurity() { clause = RoutineCharacteristic.SecurityClause.SECURITY; } + | + ( - { operation = AlterSystemOperation.RESET; } + LOOKAHEAD({ isKeywordAhead("UNSAFE") }) ContextualKeyword("UNSAFE") + { kind = RoutineCharacteristic.Kind.PARALLEL_UNSAFE; } + | + { kind = RoutineCharacteristic.Kind.PARALLEL_RESTRICTED; } + | + ContextualKeyword("SAFE") { kind = RoutineCharacteristic.Kind.PARALLEL_SAFE; } ) + | + LOOKAHEAD({ isKeywordAhead("COST") }) ContextualKeyword("COST") value=PostgreSqlNumericValue() + { kind = RoutineCharacteristic.Kind.COST; } + | + value=PostgreSqlNumericValue() { kind = RoutineCharacteristic.Kind.ROWS; } + | + LOOKAHEAD({ isKeywordAhead("SUPPORT") }) ContextualKeyword("SUPPORT") value=AccessQualifiedName() + { kind = RoutineCharacteristic.Kind.SUPPORT; } ) - parameters = captureRest() - { - return new AlterSystemStatement(operation, parameters); + return change != null ? new RoutineCharacteristic(change) + : new RoutineCharacteristic(kind, value).withSecurityClause(clause); } } -Wait Wait(): +/** MySQL routine characteristic; only CREATE accepts [NOT] DETERMINISTIC. */ +RoutineCharacteristic MySqlRoutineCharacteristic(boolean create): { - Wait wait = new Wait(); - Token token = null; + RoutineCharacteristic.Kind kind; + RoutineCharacteristic.SecurityClause clause = null; + Token token; + StringValue comment = null; } { - // sqlserver-oracle-> WAIT (TIMEOUT) - // https://docs.oracle.com/cd/B19306_01/server.102/b14200/statements_10002.htm#i2126016 - token= + ( + token= + { kind = RoutineCharacteristic.Kind.COMMENT; comment = stringValue(token); } + | + LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) ContextualKeyword("LANGUAGE") ContextualKeyword("SQL") + { kind = RoutineCharacteristic.Kind.LANGUAGE_SQL; } + | + LOOKAHEAD({ isKeywordAhead("CONTAINS") }) ContextualKeyword("CONTAINS") ContextualKeyword("SQL") + { kind = RoutineCharacteristic.Kind.CONTAINS_SQL; } + | + ContextualKeyword("SQL") { kind = RoutineCharacteristic.Kind.NO_SQL; } + | + LOOKAHEAD({ create && isWordSequenceAhead(1, "DETERMINISTIC") }) ContextualKeyword("DETERMINISTIC") + { kind = RoutineCharacteristic.Kind.DETERMINISTIC; } + | + LOOKAHEAD({ create && isWordSequenceAhead(1, "NOT", "DETERMINISTIC") }) + ContextualKeyword("DETERMINISTIC") { kind = RoutineCharacteristic.Kind.NOT_DETERMINISTIC; } + | + LOOKAHEAD({ isKeywordAhead("READS") }) ContextualKeyword("READS") ContextualKeyword("SQL") + { kind = RoutineCharacteristic.Kind.READS_SQL_DATA; } + | + LOOKAHEAD({ isKeywordAhead("MODIFIES") }) ContextualKeyword("MODIFIES") ContextualKeyword("SQL") + { kind = RoutineCharacteristic.Kind.MODIFIES_SQL_DATA; } + | + ContextualKeyword("SQL") kind=RoutineSecurity() + { clause = RoutineCharacteristic.SecurityClause.SQL_SECURITY; } + ) { - wait.setTimeout(Long.parseLong(token.image)); - return wait; + return new RoutineCharacteristic(kind).withComment(comment).withSecurityClause(clause); } } -SavepointStatement SavepointStatement(): +RoutineCharacteristic.Kind RoutineSecurity(): +{ RoutineCharacteristic.Kind kind; } +{ + ( + LOOKAHEAD({ isKeywordAhead("DEFINER") }) ContextualKeyword("DEFINER") + { kind = RoutineCharacteristic.Kind.SECURITY_DEFINER; } + | + ContextualKeyword("INVOKER") { kind = RoutineCharacteristic.Kind.SECURITY_INVOKER; } + ) + { return kind; } +} + +/** PostgreSQL NumericOnly: an optionally signed integer or decimal, as written. */ +String PostgreSqlNumericValue(): { - SavepointStatement savepointStatement; + Token sign = null; + Token number; } { - token= - { - savepointStatement = new SavepointStatement(token.image); - return savepointStatement; - } + [ sign="+" | sign="-" ] ( number= | number= ) + { return (sign == null ? "" : sign.image) + number.image; } } -RollbackStatement RollbackStatement(): +CreateFunctionalStatement SqlServerRoutine(): { - RollbackStatement rollbackStatement; - boolean usingWorkKeyword=false; - boolean usingSavepointKeyword=false; - String savepointName=null; - String forceDistributedTransactionIdentifier=null; + CreateFunctionalStatement result; + CreateFunctionalStatement.Operation operation = CreateFunctionalStatement.Operation.CREATE; + List parts; + FunctionReturnType returnType; } { - { rollbackStatement = new RollbackStatement(); } - [ { rollbackStatement.setUsingWorkKeyword(true); } ] - // explicit lookahead: FORCE INSTALL starts a new statement, FORCE 'id' belongs here - [ - LOOKAHEAD(2) - ( - ( - [ { rollbackStatement.setUsingSavepointKeyword(true); }] - token= { rollbackStatement.setSavepointName(token.image); } - ) - | - ( - token= { rollbackStatement.setForceDistributedTransactionIdentifier(token.image); } - ) - ) - ] + ( [ { operation = CreateFunctionalStatement.Operation.CREATE_OR_ALTER; } ] + | { operation = CreateFunctionalStatement.Operation.ALTER; } ) + ( + parts=captureSqlServerFunctionHeader() + returnType=SqlServerFunctionReturnType() + { result = new CreateFunction(parts); result.setReturnType(returnType); } + parts=captureSqlServerRoutineBody(false) { result.setRoutineBodyParts(parts); } + | parts=captureSqlServerRoutineBody(true) { result = new CreateProcedure(parts); } + ) + { result.setOperation(operation); return result; } +} - { - return rollbackStatement; +FunctionReturnType SqlServerFunctionReturnType(): +{ + FunctionReturnType result = new FunctionReturnType(); + UserVariable variable; ColDataType dataType; + TableElement element; List elements = new ArrayList(); +} +{ + + ( + LOOKAHEAD({ getToken(1).kind == K_TABLE || getToken(1).kind == S_AT_IDENTIFIER }) + [ variable=UserVariable() { result.setTableVariable(variable.toString()); } ] + { result.setTable(true); } + [ "(" element=SqlServerReturnTableElement() { elements.add(element); } + ( "," element=SqlServerReturnTableElement() { elements.add(element); } )* ")" + { result.setTableElements(elements); } ] + { requireDdlSyntax(result.getTableVariable() == null || result.getTableElements() != null, + "A return table variable requires column definitions"); } + | dataType=ColDataType() { result.setDataType(dataType); } + ) + { return result; } +} + +TableElement SqlServerReturnTableElement(): +{ TableElement element; } +{ + ( LOOKAHEAD(3) element=CreateTableConstraint() | element=ColumnDefinition() ) + { return element; } +} + +JAVACODE +List captureSqlServerFunctionHeader() { + List parts = new ArrayList(); + int depth = 0; + while (true) { + Token next = getToken(1); + if (next.kind == K_RETURNS && depth == 0) break; + if (next.kind == EOF || next.kind == ST_SEMICOLON) { + throw new ParseException("A SQL Server function requires RETURNS"); + } + if ("(".equals(next.image)) depth++; + if (")".equals(next.image)) depth--; + if (depth < 0) throw new ParseException("Unbalanced function parameters"); + parts.add(getNextToken().image); } + if (parts.size() < 3 || "(".equals(parts.get(0)) || !")".equals(parts.get(parts.size() - 1))) { + throw new ParseException("A SQL Server function requires a name and parameter parentheses"); + } + return parts; } -Commit Commit(): +JAVACODE +List captureSqlServerRoutineBody(boolean procedure) { + List parts = new ArrayList(); + int depth = 0; + while (true) { + Token next = getToken(1); + // Procedure definitions occupy the rest of their batch, including statements + // after an END. Their opaque bodies may contain BEGIN TRANSACTION and TRY/CATCH. + if (next.kind == EOF || (!procedure && next.kind == ST_SEMICOLON && depth == 0)) break; + if (!procedure) { + if (next.kind == K_BEGIN || next.kind == K_CASE) { + depth++; + } else if (next.kind == K_END) { + if (--depth < 0) throw new ParseException("Unmatched END in routine"); + } + } + parts.add(getNextToken().image); + } + if (depth != 0) throw new ParseException("Unterminated SQL Server routine block"); + if (parts.isEmpty()) throw new ParseException("A routine body is required"); + return parts; +} + +CreateSynonym CreateSynonym(boolean isUsingOrReplace): { - Commit commit=new Commit(); + CreateSynonym createSynonym = new CreateSynonym(); + Synonym synonym; + boolean publicSynonym = false; + ObjectNames data = null; } { - + [ { publicSynonym = true; } ] + synonym=Synonym() { createSynonym.setSynonym(synonym); } + data = RelObjectNames() { - return commit; + createSynonym.setOrReplace(isUsingOrReplace); + createSynonym.setPublicSynonym(publicSynonym); + createSynonym.setForList(data.getNames()); + return createSynonym; } } -Comment Comment(): +Synonym Synonym() #Synonym : { - CommentTarget target; - Comment result = new Comment(); - Table table; - Table view; - Column column; - StringValue comment; + ObjectNames data = null; + String serverName = null, databaseName = null, schemaName = null, sequenceName = null; } { - - ( - ( - table = Table() { result.setTable(table); } - ) - | - ( - column = Column() { result.setColumn(column); } - ) - | - ( - view = Table() { result.setView(view); } - ) - | - target=CommentTarget() { result.setTarget(target); } - ) - - ( - comment=CharacterLiteral() { result.setComment(comment); } - | - ) + data = RelObjectNames() { - return result; + Synonym synonym = new Synonym(data.getNames()); + linkAST(synonym,jjtThis); + return synonym; } } -/** Catalog names are already tokenized into parts; quoted dots are part of one identifier. */ -Table CommentObjectName(): -{ ObjectNames names; } + +String TypeDdlName(): +{ String name; String part; } { - names=RelObjectNames() - { return names.getNames().size() == 1 ? new Table(names.getNames().get(0), false) - : new Table(names.getNames()); } + name=RelObjectName() + ( LOOKAHEAD(2) "." part=RelObjectNameExt() { name += "." + part; } )* + { return name; } } -CommentTarget CommentTarget(): +void TypeDdlKeyword(String expected): +{ Token keyword; } +{ ( keyword= | keyword= ) { requireTypeDdlSyntax(expected.equalsIgnoreCase(keyword.image), "Expected " + expected); } } + +Expression ExtensionVersion(): +{ Token token; String name; Expression result; } { - CommentTarget result = new CommentTarget(); - Table name; - String constraintName; - RoutineReference routine; + ( token= { result = stringValue(token); } + | name=RelObjectName() { result = linkToLastToken(createColumn(name)); } ) + { return result; } } + +TypeAttribute TypeAttribute(): +{ TypeAttribute attribute = new TypeAttribute(); String name; ColDataType type; } { - ( - routine=RoutineReference(false) - { result.setKind(CommentTarget.Kind.FUNCTION); result.setRoutine(routine); } - | - constraintName=RelObjectName() - { result.setKind(CommentTarget.Kind.CONSTRAINT); result.setName(new Table(constraintName, false)); } - - [ LOOKAHEAD({ getToken(1).kind == K_DOMAIN && !".".equals(getToken(2).image) - && getToken(2).kind != K_IS }) { result.setOnDomain(true); } ] - name=CommentObjectName() { result.setRelation(name); } + name=RelObjectName() { attribute.setName(name); } + type=ColDataType() { attribute.setDataType(type); } + [ name=TypeDdlName() { attribute.setCollation(name); } ] + { return attribute; } +} + +CreateType CreateType(): +{ + CreateType result = new CreateType(); + String name; Token label; TypeAttribute attribute; + EnumTypeDefinition enumeration = new EnumTypeDefinition(); + CompositeTypeDefinition composite = new CompositeTypeDefinition(); + RangeTypeDefinition range = new RangeTypeDefinition(); + RangeTypeDefinition.Option option; + List elements; +} +{ + name=TypeDdlName() { result.setName(name); } + [ + // A base type. A parenthesis can also start the statement after a shell type. + LOOKAHEAD({ isDefinitionAhead() }) + elements=PostgreSqlDefinition() { result.setDefinition(new BaseTypeDefinition(elements)); } | + ( - { result.setKind(CommentTarget.Kind.INDEX); } - | { result.setKind(CommentTarget.Kind.SCHEMA); } - | { result.setKind(CommentTarget.Kind.SEQUENCE); } - | { result.setKind(CommentTarget.Kind.MATERIALIZED_VIEW); } - | { result.setKind(CommentTarget.Kind.DOMAIN); } - | { result.setKind(CommentTarget.Kind.TYPE); } + LOOKAHEAD({ isKeywordAhead("ENUM") }) TypeDdlKeyword("ENUM") "(" + [ label= { enumeration.getLabels().add(stringValue(label)); } + ( "," label= { enumeration.getLabels().add(stringValue(label)); } )* ] + ")" { result.setDefinition(enumeration); } + | "(" option=RangeTypeOption() { range.getOptions().add(option); } + ( "," option=RangeTypeOption() { range.getOptions().add(option); } )* ")" + { + requireTypeDdlSyntax(range.getSubtype() != null, "A range definition requires SUBTYPE"); + result.setDefinition(range); + } + | "(" [ attribute=TypeAttribute() { composite.getAttributes().add(attribute); } + ( "," attribute=TypeAttribute() { composite.getAttributes().add(attribute); } )* ] + ")" { result.setDefinition(composite); } ) - name=CommentObjectName() { result.setName(name); } - ) + ] { return result; } } -/** Consumes a keyword that remains an ordinary identifier outside this grammar context. */ -void ContextualKeyword(String expected): -{ Token keyword; } +/** + * PostgreSQL's definition, "(" def_elem [, ...] ")": the property list of a base type in CREATE + * TYPE name (...) and of ALTER TYPE name SET (...). + */ +List PostgreSqlDefinition(): +{ List elements = new ArrayList(); DefinitionElement element; } { - keyword= { - if (!expected.equalsIgnoreCase(keyword.image)) { - throw new ParseException("Expected " + expected + " but found " + keyword.image); - } - } + "(" element=PostgreSqlDefinitionElement() { elements.add(element); } + ( "," element=PostgreSqlDefinitionElement() { elements.add(element); } )* ")" + { return elements; } } -void AccessKeyword(String expected): -{ Token token; } -{ (token= | token=) { requireAccessSyntax(expected.equalsIgnoreCase(token.image), "Expected " + expected); } } - -String AccessQualifiedName(): -{ String name; String part; } -{ name=RelObjectName() ( "." part=RelObjectNameExt() { name += "." + part; } )* { return name; } } +/** PostgreSQL's def_elem, label [ = def_arg ]. Any identifier or keyword is a label. */ +DefinitionElement PostgreSqlDefinitionElement(): +{ Token name; DefinitionArgument argument = null; } +{ + // The action keeps the JAVACODE call from being the production's first unit. + { } name=PostgreSqlWord() + [ "=" argument=PostgreSqlDefinitionArgument() ] + { return new DefinitionElement(name.image, argument); } +} -List AccessNames(): -{ List names = new ArrayList(); String name; } -{ name=RelObjectName() { names.add(name); } ( "," name=RelObjectName() { names.add(name); } )* { return names; } } +/** Consumes an identifier or any keyword. As a JAVACODE production it adds no choice conflicts. */ +JAVACODE +Token PostgreSqlWord() { + Token token = getToken(1); + if (!isPostgreSqlWord(token)) { + throw new ParseException("Encountered unexpected token: \"" + token.image + "\" at line " + + token.beginLine + ", column " + token.beginColumn + ". Expected a name."); + } + return getNextToken(); +} -RoleOption RoleOption(boolean create): -{ RoleOption option = null; Token token; Token value; String sign = ""; Expression expression; List names; boolean encrypted = false; } +/** + * PostgreSQL's def_arg: a type (which is also how a function or any other name is read), a + * reserved keyword, an operator, a number, a string constant or NONE. + */ +DefinitionArgument PostgreSqlDefinitionArgument(): +{ + Token token; Token first = getToken(1); Token sign = null; + String name; String operator; StringBuilder schema = new StringBuilder(); + ColDataType type; StringValue string; Expression number; + boolean setOf = false; boolean typeReference = false; + DefinitionArgument result; +} { ( - LOOKAHEAD({ isAccessKeywordAhead("CONNECTION") }) - AccessKeyword("CONNECTION") [ ( "+" | "-" { sign = "-"; } ) ] value= - { option = new RoleOption(RoleOption.Kind.CONNECTION_LIMIT); option.setValue(new LongValue(sign + value.image)); } - | - LOOKAHEAD({ isAccessKeywordAhead("PASSWORD") || isAccessKeywordAhead("ENCRYPTED") }) - [ AccessKeyword("ENCRYPTED") { encrypted = true; } ] - ( value= { expression = new StringValue(value.image); } | { expression = new NullValue(); } ) - { option = new RoleOption(RoleOption.Kind.PASSWORD); option.setEncrypted(encrypted); option.setValue(expression); } + LOOKAHEAD({ isDefinitionWordValueAhead() }) { } token=PostgreSqlWord() + { result = definitionWordValue(token); } | - LOOKAHEAD({ isAccessKeywordAhead("VALID") }) - AccessKeyword("VALID") AccessKeyword("UNTIL") value= - { option = new RoleOption(RoleOption.Kind.VALID_UNTIL); option.setValue(new StringValue(value.image)); } + token= + { + string = stringValue(token); + requireDdlSyntax(isPostgreSqlStringConstant(string), + "PostgreSQL expects a string constant: " + token.image); + result = DefinitionArgument.string(string); + } | - - ( AccessKeyword("ROLE") { option = new RoleOption(RoleOption.Kind.IN_ROLE); } - | { option = new RoleOption(RoleOption.Kind.IN_GROUP); } ) - names=AccessNames() - { requireAccessSyntax(create, "Membership attributes require CREATE ROLE"); option.setRoles(names); } + LOOKAHEAD(2) [ sign="+" | sign="-" ] + ( token= { number = linkToLastToken(new LongValue(token.image)); } + | token= { number = linkToLastToken(new DoubleValue(token.image)); } ) + { + if (sign != null) { + number = linked(new SignedExpression(sign.image.charAt(0), number), first); + } + result = DefinitionArgument.number(number); + } | - LOOKAHEAD({ isAccessKeywordAhead("ROLE") || isAccessKeywordAhead("USER") || isAccessKeywordAhead("ADMIN") }) - ( token= | token= ) - names=AccessNames() - { requireAccessSyntax(create, "Membership attributes require CREATE ROLE"); option = new RoleOption(accessEnum(RoleOption.Kind.class, token.image)); option.setRoles(names); } + LOOKAHEAD({ isKeywordAhead("OPERATOR") && getToken(2).kind == OPENING_BRACKET }) + ContextualKeyword("OPERATOR") "(" + ( LOOKAHEAD(2) name=RelObjectName() "." { schema.append(name).append('.'); } )* + operator=PostgreSqlOperatorName() ")" + { result = DefinitionArgument.operator(schema + operator, true); } | - LOOKAHEAD({ isAccessKeywordAhead("SYSID") }) - AccessKeyword("SYSID") value= - { requireAccessSyntax(create, "SYSID requires CREATE ROLE"); option = new RoleOption(RoleOption.Kind.SYSID); option.setValue(new LongValue(value.image)); } + operator=PostgreSqlOperatorName() { result = DefinitionArgument.operator(operator, false); } | - token= { option = new RoleOption(accessEnum(RoleOption.Kind.class, token.image)); } + [ LOOKAHEAD({ isKeywordAhead("SETOF") }) ContextualKeyword("SETOF") { setOf = true; } ] + type=ColDataType() + { requireDdlSyntax(!hasEmptyParentheses(first, getToken(0)), "Type modifiers must not be empty"); } + [ "%" { + requireDdlSyntax(type.toString().indexOf('.') > 0, "%TYPE follows the name of a column"); + typeReference = true; + } ] + { result = DefinitionArgument.type(type, setOf, typeReference); } ) - { return option; } -} - -CreateRole CreateRole(): -{ CreateRole role = new CreateRole(); String name; RoleOption option; Token token; } -{ - ( token= | token= | token= ) { role.setCommand(accessEnum(CreateRole.Command.class, token.image)); } - name=RelObjectName() { role.setName(name); } - [ LOOKAHEAD(1) { role.setUseWith(true); } ] - ( LOOKAHEAD({ isRoleOptionAhead(1) }) option=RoleOption(true) { role.getOptions().add(option); } )* - { requireAccessSyntax(!role.isUseWith() || !role.getOptions().isEmpty(), "WITH requires role attributes"); return role; } + { return result; } } -AlterSchema AlterSchema(): -{ - AlterSchema statement = new AlterSchema(); - String name; -} +/** PostgreSQL CREATE OPERATOR, CREATE OPERATOR CLASS or CREATE OPERATOR FAMILY. */ +Statement PostgreSqlCreateOperator(): +{ Statement statement; } { - name=RelObjectName() { statement.setSchemaName(name); } ( - name=RelObjectName() - { statement.setAction(AlterSchema.Action.RENAME); statement.setNewName(name); } + LOOKAHEAD({ isOperatorClassOrFamilyAhead() && "CLASS".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("OPERATOR") statement=CreateOperatorClass() | - ContextualKeyword("OWNER") name=RelObjectName() - { statement.setAction(AlterSchema.Action.OWNER); statement.setOwner(name); } + LOOKAHEAD({ isOperatorClassOrFamilyAhead() }) + ContextualKeyword("OPERATOR") statement=CreateOperatorFamily() + | + ContextualKeyword("OPERATOR") statement=CreateOperator() ) { return statement; } } -AlterRole AlterRole(): +/** PostgreSQL's CREATE OPERATOR any_operator definition. */ +CreateOperator CreateOperator(): +{ CreateOperator statement = new CreateOperator(); ExclusionOperator operator; List definition; } { - AlterRole role = new AlterRole(); String name; RoleOption option; Token token; Expression value; - ExpressionList values = new ExpressionList(); List names; + operator=PostgreSqlOperatorReference() { statement.setOperator(operator); } + definition=PostgreSqlDefinition() { statement.setDefinition(definition); } + { return statement; } } + +/** + * PostgreSQL's CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE type USING index_method + * [ FAMILY family ] AS opclass_item_list. + */ +CreateOperatorClass CreateOperatorClass(): { - ( token= | token= | token= ) { role.setCommand(accessEnum(CreateRole.Command.class, token.image)); } - ( LOOKAHEAD(1) { role.setName("ALL"); } | name=RelObjectName() { role.setName(name); } ) - [ LOOKAHEAD(2) name=RelObjectName() { role.setDatabase(name); } ] - ( - name=RelObjectName() { role.setAction(AlterRole.Action.RENAME); role.setNewName(name); } - | - ( { role.setAction(AlterRole.Action.ADD_USER); } | { role.setAction(AlterRole.Action.DROP_USER); } ) - names=AccessNames() { requireAccessSyntax(role.getCommand() == CreateRole.Command.GROUP, "ADD/DROP USER requires ALTER GROUP"); role.setUsers(names); } - | - name=AccessQualifiedName() { role.setAction(AlterRole.Action.SET); role.setParameter(name); } - ( - { role.setFromCurrent(true); } - | - ( | "=" { role.setUseEquals(true); } ) - ( - LOOKAHEAD(1) { role.setUseDefault(true); } - | - value=AccessSettingValue() { values.add(value); } - ( "," value=AccessSettingValue() { values.add(value); } )* - { role.setValues(values); } - ) - ) - | - ( LOOKAHEAD(1) { role.setParameter("ALL"); } | name=AccessQualifiedName() { role.setParameter(name); } ) - { role.setAction(AlterRole.Action.RESET); } - | - [ { role.setUseWith(true); } ] - option=RoleOption(false) { role.getOptions().add(option); role.setAction(AlterRole.Action.OPTIONS); } - ( LOOKAHEAD({ isRoleOptionAhead(1) }) option=RoleOption(false) { role.getOptions().add(option); } )* - ) - { - requireAccessSyntax(role.getDatabase() == null && !"ALL".equals(role.getName()) - || role.getAction() == AlterRole.Action.SET || role.getAction() == AlterRole.Action.RESET, - "ALL and IN DATABASE require SET or RESET"); - requireAccessSyntax(role.getCommand() != CreateRole.Command.GROUP || role.getAction() == AlterRole.Action.RENAME - || role.getAction() == AlterRole.Action.ADD_USER || role.getAction() == AlterRole.Action.DROP_USER, "Invalid ALTER GROUP action"); - return role; - } + CreateOperatorClass statement = new CreateOperatorClass(); String name; ColDataType type; + OperatorClassItem item; } - -Expression AccessSettingValue(): -{ Expression value; Token token; } -{ ( LOOKAHEAD(1) token= { value = new Column(token.image); } | value=PrimaryExpression() ) { return value; } } - -Privilege AccessPrivilege(): -{ Privilege result; Token token; boolean all = false; String column; ExpressionList columns = null; } { - ( token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= ) - { result = new Privilege(accessEnum(Privilege.Kind.class, token.image)); } - [ { requireAccessSyntax(result.getKind() == Privilege.Kind.ALTER, "SYSTEM requires ALTER"); result.setKind(Privilege.Kind.ALTER_SYSTEM); } ] - [ LOOKAHEAD({ isAccessKeywordAhead("PRIVILEGES") }) - AccessKeyword("PRIVILEGES") { requireAccessSyntax(result.getKind() == Privilege.Kind.ALL, "PRIVILEGES requires ALL"); result.setUsePrivileges(true); } ] - [ "(" { columns = new ExpressionList(); } - column=RelObjectName() { columns.add(new Column(column)); } - ( "," column=RelObjectName() { columns.add(new Column(column)); } )* - ")" { result.setColumns(columns); } ] - { return result; } + ContextualKeyword("CLASS") name=TypeDdlName() { statement.setName(name); } + [ { statement.setDefaultClass(true); } ] + type=ColDataType() { statement.setDataType(type); } + name=RelObjectName() { statement.setAccessMethod(name); } + [ LOOKAHEAD({ isKeywordAhead("FAMILY") }) ContextualKeyword("FAMILY") + name=TypeDdlName() { statement.setFamily(name); } ] + item=OperatorClassItem() { statement.getItems().add(item); } + ( "," item=OperatorClassItem() { statement.getItems().add(item); } )* + { return statement; } } -PrivilegeTarget.Kind AccessObjectKind(boolean plural): -{ Token token; String name; } +/** PostgreSQL's CREATE OPERATOR FAMILY name USING index_method. */ +CreateOperatorFamily CreateOperatorFamily(): +{ CreateOperatorFamily statement = new CreateOperatorFamily(); String name; } { - ( - - ( AccessKeyword("WRAPPER") { name = "FOREIGN_DATA_WRAPPER"; } - | AccessKeyword("SERVER") { name = "FOREIGN_SERVER"; } ) - | - LOOKAHEAD({ isAccessKeywordAhead("LARGE") }) - AccessKeyword("LARGE") ( token= ) { name = "LARGE_" + token.image.toUpperCase(Locale.ROOT); } - | - ( token= | token= | token= | token= | token= | token= | token= | token= | token= | token= | token= ) - { name = token.image.toUpperCase(Locale.ROOT); } - ) - { - if (plural) { - requireAccessSyntax(name.endsWith("S"), "Expected plural privilege target"); - name = name.substring(0, name.length() - 1); - } - return accessEnum(PrivilegeTarget.Kind.class, name); - } + ContextualKeyword("FAMILY") name=TypeDdlName() { statement.setName(name); } + name=RelObjectName() { statement.setAccessMethod(name); } + { return statement; } } -RoutineReference.Argument AccessRoutineArgument(): -{ RoutineReference.Argument argument; } -{ argument=RoutineArgument(false) { return argument; } } - -RoutineReference AccessRoutine(): -{ RoutineReference result = new RoutineReference(); String name; RoutineReference.Argument argument; List arguments; } +/** + * PostgreSQL's opclass_item: OPERATOR n operator [ (left, right) ] [ FOR SEARCH | FOR ORDER BY + * family ], FUNCTION n [ (type [, ...]) ] function [ (arguments) ], or STORAGE type. + */ +OperatorClassItem OperatorClassItem(): { - name=AccessQualifiedName() { result.setName(name); } - [ LOOKAHEAD(1) "(" { arguments = new ArrayList(); result.setArguments(arguments); } - [ argument=AccessRoutineArgument() { arguments.add(argument); } - ( "," argument=AccessRoutineArgument() { arguments.add(argument); } )* ] ")" ] - { return result; } + OperatorClassItem item = new OperatorClassItem(); Token number; String name; + ExclusionOperator operator; OperatorSignature signature; RoutineReference function; + List types; ColDataType type; } - -PrivilegeTarget AccessTarget(boolean defaults): -{ PrivilegeTarget target = new PrivilegeTarget(); PrivilegeTarget.Kind kind; ObjectNames name; RoutineReference routine; Token number; } { ( - LOOKAHEAD({ defaults }) - kind=AccessObjectKind(true) - { requireAccessSyntax(defaults && EnumSet.of(PrivilegeTarget.Kind.TABLE, PrivilegeTarget.Kind.SEQUENCE, PrivilegeTarget.Kind.FUNCTION, - PrivilegeTarget.Kind.ROUTINE, PrivilegeTarget.Kind.TYPE, PrivilegeTarget.Kind.SCHEMA, PrivilegeTarget.Kind.LARGE_OBJECT).contains(kind), - "Invalid default-privilege target"); - target.setKind(kind); target.setDefaultPrivileges(true); } - | - LOOKAHEAD(1) kind=AccessObjectKind(true) - { requireAccessSyntax(!defaults && EnumSet.of(PrivilegeTarget.Kind.TABLE, PrivilegeTarget.Kind.SEQUENCE, - PrivilegeTarget.Kind.FUNCTION, PrivilegeTarget.Kind.PROCEDURE, PrivilegeTarget.Kind.ROUTINE).contains(kind), - "Invalid ALL IN SCHEMA target"); target.setKind(kind); target.setAllInSchema(true); } - name=RelObjectNames() { target.getNames().add(name.getNames()); } - ( "," name=RelObjectNames() { target.getNames().add(name.getNames()); } )* - | - LOOKAHEAD({ isAccessTargetKindAhead() && (isAccessKeywordAhead("FUNCTION") || isAccessKeywordAhead("PROCEDURE") || isAccessKeywordAhead("ROUTINE")) }) - kind=AccessObjectKind(false) { target.setKind(kind); target.setExplicitKind(true); } - routine=AccessRoutine() { target.getRoutines().add(routine); } - ( "," routine=AccessRoutine() { target.getRoutines().add(routine); } )* + LOOKAHEAD({ isKeywordAhead("OPERATOR") }) ContextualKeyword("OPERATOR") + number= { item.setKind(OperatorClassItem.Kind.OPERATOR); item.setNumber(operatorClassNumber(number)); } + ( + LOOKAHEAD(PostgreSqlOperatorReference() "(") signature=OperatorSignature() + { + item.setOperator(signature.getOperator()); + item.setOperandTypes(new ArrayList( + Arrays.asList(signature.getLeftType(), signature.getRightType()))); + } + | + operator=PostgreSqlOperatorReference() { item.setOperator(operator); } + ) + [ + + ( { item.setPurpose(OperatorClassItem.Purpose.SEARCH); } + | name=TypeDdlName() + { item.setPurpose(OperatorClassItem.Purpose.ORDER_BY); item.setSortFamily(name); } ) + ] | - LOOKAHEAD({ isAccessTargetKindAhead() && isAccessKeywordAhead("LARGE") }) - kind=AccessObjectKind(false) { target.setKind(kind); target.setExplicitKind(true); } - number= { target.getNames().add(Collections.singletonList(number.image)); } - ( "," number= { target.getNames().add(Collections.singletonList(number.image)); } )* + + number= { item.setKind(OperatorClassItem.Kind.FUNCTION); item.setNumber(operatorClassNumber(number)); } + [ LOOKAHEAD(1) types=OperatorClassTypes() { item.setOperandTypes(types); } ] + function=RoutineReference(false) { item.setFunction(function); } | - [ LOOKAHEAD({ isAccessTargetKindAhead() }) kind=AccessObjectKind(false) { target.setKind(kind); target.setExplicitKind(true); } ] - name=RelObjectNames() { target.getNames().add(name.getNames()); } - ( "," name=RelObjectNames() { target.getNames().add(name.getNames()); } )* + type=ColDataType() { item.setKind(OperatorClassItem.Kind.STORAGE); item.setStorageType(type); } ) - { requireAccessSyntax(target.isDefaultPrivileges() == defaults, "Invalid default-privilege target"); return target; } + { return item; } } -String AccessGrantee(): -{ String name; boolean group = false; } -{ [ LOOKAHEAD(1) { group = true; } ] name=RelObjectName() { return (group ? "GROUP " : "") + name; } } - -List AccessGrantees(): -{ List names = new ArrayList(); String name; } -{ name=AccessGrantee() { names.add(name); } ( "," name=AccessGrantee() { names.add(name); } )* { return names; } } - -PrivilegeClause AccessClause(boolean revoke, boolean defaults): -{ PrivilegeClause clause = new PrivilegeClause(); Privilege privilege; PrivilegeTarget target; List names; } +/** PostgreSQL's opclass_drop: OPERATOR n (type [, ...]) or FUNCTION n (type [, ...]). */ +OperatorClassItem OperatorClassDropItem(): +{ OperatorClassItem item = new OperatorClassItem(); Token number; List types; } { ( - LOOKAHEAD({ isObjectPrivilegeAhead() }) - { clause.setPrivileges(new ArrayList()); } - privilege=AccessPrivilege() { clause.getPrivileges().add(privilege); } - ( "," privilege=AccessPrivilege() { clause.getPrivileges().add(privilege); } )* - target=AccessTarget(defaults) { clause.setTarget(target); } + LOOKAHEAD({ isKeywordAhead("OPERATOR") }) ContextualKeyword("OPERATOR") + { item.setKind(OperatorClassItem.Kind.OPERATOR); } | - names=AccessNames() { clause.setRoles(names); } + { item.setKind(OperatorClassItem.Kind.FUNCTION); } ) - ( { requireAccessSyntax(!revoke, "REVOKE requires FROM"); } | { requireAccessSyntax(revoke, "GRANT requires TO"); } ) - names=AccessGrantees() { clause.setGrantees(names); return clause; } + number= { item.setNumber(operatorClassNumber(number)); } + types=OperatorClassTypes() { item.setOperandTypes(types); } + { return item; } } -Grant Grant(): -{ Grant grant; } -{ grant=AccessGrant(false) { return grant; } } - -Grant AccessGrant(boolean defaults): -{ Grant grant = new Grant(); PrivilegeClause clause; Token token; GrantOption option; String name; } +/** PostgreSQL's type_list in parentheses. */ +List OperatorClassTypes(): +{ List types = new ArrayList(); ColDataType type; } { - clause=AccessClause(false, defaults) { grant.setClause(clause); } - [ LOOKAHEAD(1) - ( token= | token= | token= ) { option = new GrantOption(accessEnum(GrantOption.Kind.class, token.image)); } - ( token= | token= | token= ) - { option.setValue(accessEnum(GrantOption.Value.class, token.image)); grant.setOption(option); - requireAccessSyntax(clause.getPrivileges() == null ? option.getKind() != GrantOption.Kind.GRANT - : option.getKind() == GrantOption.Kind.GRANT && option.getValue() == GrantOption.Value.OPTION, "Invalid GRANT option"); } - ] - [ LOOKAHEAD({ isAccessKeywordAhead("GRANTED") }) AccessKeyword("GRANTED") name=RelObjectName() - { requireAccessSyntax(!defaults, "GRANTED BY is not part of default privileges"); clause.setGrantedBy(name); } ] - { return grant; } + "(" type=ColDataType() { types.add(type); } + ( "," type=ColDataType() { types.add(type); } )* ")" + { return types; } } -Revoke Revoke(boolean defaults): -{ Revoke revoke = new Revoke(); PrivilegeClause clause; Token token; String name; } +/** PostgreSQL ALTER OPERATOR, ALTER OPERATOR CLASS or ALTER OPERATOR FAMILY. */ +Statement PostgreSqlAlterOperator(): +{ Statement statement; } { - - [ LOOKAHEAD(3) ( token= | token= | token= ) - { revoke.setOptionFor(accessEnum(GrantOption.Kind.class, token.image)); } ] - clause=AccessClause(true, defaults) { revoke.setClause(clause); } - [ LOOKAHEAD({ isAccessKeywordAhead("GRANTED") }) AccessKeyword("GRANTED") name=RelObjectName() - { requireAccessSyntax(!defaults, "GRANTED BY is not part of default privileges"); clause.setGrantedBy(name); } ] - [ ( { revoke.setBehavior(Revoke.Behavior.CASCADE); } | { revoke.setBehavior(Revoke.Behavior.RESTRICT); } ) ] - { requireAccessSyntax(revoke.getOptionFor() == null || (clause.getPrivileges() == null - ? revoke.getOptionFor() != GrantOption.Kind.GRANT : revoke.getOptionFor() == GrantOption.Kind.GRANT), "Invalid REVOKE option"); - return revoke; } + ( + LOOKAHEAD({ isOperatorClassOrFamilyAhead() && "CLASS".equalsIgnoreCase(getToken(2).image) }) + ContextualKeyword("OPERATOR") statement=AlterOperatorClass() + | + LOOKAHEAD({ isOperatorClassOrFamilyAhead() }) + ContextualKeyword("OPERATOR") statement=AlterOperatorFamily() + | + ContextualKeyword("OPERATOR") statement=AlterOperator() + ) + { return statement; } } -AlterDefaultPrivileges AlterDefaultPrivileges(): -{ AlterDefaultPrivileges result = new AlterDefaultPrivileges(); Token token; List names; Grant grant; Revoke revoke; } +/** + * PostgreSQL's ALTER OPERATOR operator_with_argtypes { OWNER TO role | SET SCHEMA schema | + * SET ( operator_def_list ) }. + */ +AlterOperator AlterOperator(): { - AccessKeyword("PRIVILEGES") - [ ( token= | token= ) { result.setRoleKeyword(accessEnum(AlterDefaultPrivileges.RoleKeyword.class, token.image)); } - names=AccessNames() { result.setRoles(names); } ] - [ names=AccessNames() { result.setSchemas(names); } ] - ( grant=AccessGrant(true) { result.setGrant(grant); } - | revoke=Revoke(true) { result.setRevoke(revoke); } ) - { return result; } + AlterOperator statement = new AlterOperator(); OperatorSignature operator; String name; + List properties; } - -TriggerEvent PostgreSqlTriggerEvent(): -{ TriggerEvent result = null; String name; ExpressionList columns; } { + operator=OperatorSignature() { statement.setOperator(operator); } ( - { result = new TriggerEvent(CreateTrigger.Event.INSERT); } - | { result = new TriggerEvent(CreateTrigger.Event.DELETE); } - | { result = new TriggerEvent(CreateTrigger.Event.TRUNCATE); } - | { result = new TriggerEvent(CreateTrigger.Event.UPDATE); } - [ { columns = new ExpressionList(); } - name=RelObjectName() { columns.add(createColumn(name)); } - ( "," name=RelObjectName() { columns.add(createColumn(name)); } )* - { result.setColumns(columns); } ] + ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(AlterOperator.Action.OWNER); statement.setNewName(name); } + | + + ( + name=RelObjectName() + { statement.setAction(AlterOperator.Action.SET_SCHEMA); statement.setNewName(name); } + | + properties=PostgreSqlDefinition() + { statement.setAction(AlterOperator.Action.SET_PROPERTIES); statement.setProperties(properties); } + ) ) - { return result; } + { return statement; } } -TransitionRelation PostgreSqlTransitionRelation(): -{ TransitionRelation result = new TransitionRelation(); Token token; String name; } +/** + * PostgreSQL's ALTER OPERATOR CLASS name USING index_method { RENAME TO name | OWNER TO role | + * SET SCHEMA schema }. + */ +AlterOperatorClass AlterOperatorClass(): +{ AlterOperatorClass statement = new AlterOperatorClass(); String name; } { - ( token= ) { result.setImage(accessEnum(TransitionRelation.Image.class, token.image)); } - [ { result.setUseAs(true); } ] name=RelObjectName() { result.setName(name); return result; } + ContextualKeyword("CLASS") name=TypeDdlName() { statement.setName(name); } + name=RelObjectName() { statement.setAccessMethod(name); } + ( + name=RelObjectName() { statement.setAction(AlterOperatorClass.Action.RENAME); } + | ContextualKeyword("OWNER") name=RelObjectName() { statement.setAction(AlterOperatorClass.Action.OWNER); } + | name=RelObjectName() { statement.setAction(AlterOperatorClass.Action.SET_SCHEMA); } + ) + { statement.setNewName(name); return statement; } } -CreateTrigger PostgreSqlTrigger(boolean replace): +/** + * PostgreSQL's ALTER OPERATOR FAMILY name USING index_method { ADD opclass_item_list | + * DROP opclass_drop_list | RENAME TO name | OWNER TO role | SET SCHEMA schema }. + */ +AlterOperatorFamily AlterOperatorFamily(): +{ AlterOperatorFamily statement = new AlterOperatorFamily(); String name = null; OperatorClassItem item; } +{ + ContextualKeyword("FAMILY") name=TypeDdlName() { statement.setName(name); } + name=RelObjectName() { statement.setAccessMethod(name); name = null; } + ( + { statement.setAction(AlterOperatorFamily.Action.ADD); } + item=OperatorClassItem() { statement.getItems().add(item); } + ( "," item=OperatorClassItem() { statement.getItems().add(item); } )* + | + { statement.setAction(AlterOperatorFamily.Action.DROP); } + item=OperatorClassDropItem() { statement.getItems().add(item); } + ( "," item=OperatorClassDropItem() { statement.getItems().add(item); } )* + | name=RelObjectName() { statement.setAction(AlterOperatorFamily.Action.RENAME); } + | ContextualKeyword("OWNER") name=RelObjectName() { statement.setAction(AlterOperatorFamily.Action.OWNER); } + | name=RelObjectName() { statement.setAction(AlterOperatorFamily.Action.SET_SCHEMA); } + ) + { statement.setNewName(name); return statement; } +} + +/** + * PostgreSQL's CREATE [ OR REPLACE ] AGGREGATE name aggr_args definition, and the old form + * CREATE AGGREGATE name old_aggr_definition, whose definition names the input type. + */ +CreateAggregate CreateAggregate(boolean orReplace): { - CreateTrigger result = new CreateTrigger(); String name; Table table; CreateTrigger.Timing timing; - TriggerEvent event; TransitionRelation transition; Expression expression; Token token; boolean negative = false; - Statement body = null; - Function routine = new Function(); ExpressionList arguments = new ExpressionList(); + CreateAggregate statement = new CreateAggregate(); String name; + RoutineReference aggregate; List definition; } { - [ { result.setConstraint(true); } ] - name=RelObjectName() { result.setTrigger(createTable(Collections.singletonList(name))); result.setOrReplace(replace); } + { statement.setOrReplace(orReplace); } ( - LOOKAHEAD({ isAccessKeywordAhead("INSTEAD") }) AccessKeyword("INSTEAD") { result.setTiming(CreateTrigger.Timing.INSTEAD_OF); } - | timing=MySqlTriggerTiming() { result.setTiming(timing); } + LOOKAHEAD({ isOldAggregateDefinitionAhead() }) + name=TypeDdlName() { aggregate = new RoutineReference(); aggregate.setName(name); } + definition=PostgreSqlDefinition() { requireOldAggregateDefinition(definition); } + | + aggregate=RoutineReference(true) definition=PostgreSqlDefinition() ) - event=PostgreSqlTriggerEvent() { result.getEvents().add(event); } - ( event=PostgreSqlTriggerEvent() { result.getEvents().add(event); } )* - table=Table() { result.setTable(table); } - // greedy: FROM here names the referenced table, it never starts the trigger body - [ LOOKAHEAD(2) table=Table() { result.setReferencedTable(table); } ] - [ [ { negative = true; } ] { result.getConstraintAttributes().setDeferrable(!negative); } ] - [ LOOKAHEAD({ isAccessKeywordAhead("INITIALLY") }) - AccessKeyword("INITIALLY") ( token= ) - { result.getConstraintAttributes().setInitially(accessEnum(ConstraintAttributes.Initially.class, token.image)); } ] - [ LOOKAHEAD({ isAccessKeywordAhead("REFERENCING") }) AccessKeyword("REFERENCING") - transition=PostgreSqlTransitionRelation() { result.getTransitionRelations().add(transition); } - ( LOOKAHEAD({ isAccessKeywordAhead("OLD") || isAccessKeywordAhead("NEW") }) - transition=PostgreSqlTransitionRelation() { result.getTransitionRelations().add(transition); } )* ] - [ [ LOOKAHEAD({ isAccessKeywordAhead("EACH") }) AccessKeyword("EACH") { result.setUseEach(true); } ] - ( { result.setOrientation(CreateTrigger.Orientation.ROW); } - | { result.setOrientation(CreateTrigger.Orientation.STATEMENT); } ) ] - [ "(" expression=Expression() ")" { result.setWhenExpression(expression); } ] + { statement.setAggregate(aggregate); statement.setDefinition(definition); return statement; } +} + +/** + * PostgreSQL's ALTER AGGREGATE name aggr_args { RENAME TO name | OWNER TO role | + * SET SCHEMA schema }. + */ +AlterAggregate AlterAggregate(): +{ AlterAggregate statement = new AlterAggregate(); RoutineReference aggregate; String name; } +{ + aggregate=RoutineReference(true) { statement.setAggregate(aggregate); } ( - LOOKAHEAD(2) - ( | { result.setExecuteKeyword(CreateTrigger.ExecuteKeyword.PROCEDURE); } ) - name=AccessQualifiedName() { routine.setName(name); } - "(" [ expression=PostgreSqlTriggerArgument() { arguments.add(expression); } - ( "," expression=PostgreSqlTriggerArgument() { arguments.add(expression); } )* ] ")" - { routine.setParameters(arguments); result.setRoutine(routine); } - | - // DuckDB 2.0 runs a statement rather than a function - body=SingleStatement() { result.setBody(body); } + name=RelObjectName() { statement.setAction(AlterAggregate.Action.RENAME); } + | ContextualKeyword("OWNER") name=RelObjectName() { statement.setAction(AlterAggregate.Action.OWNER); } + | name=RelObjectName() { statement.setAction(AlterAggregate.Action.SET_SCHEMA); } ) - { - requireAccessSyntax(!result.isConstraint() || !replace && result.getTiming() == CreateTrigger.Timing.AFTER - && result.getOrientation() == CreateTrigger.Orientation.ROW, "A constraint trigger requires AFTER FOR EACH ROW without OR REPLACE"); - requireAccessSyntax(result.isConstraint() || result.getReferencedTable() == null - && result.getConstraintAttributes().getDeferrable() == null && result.getConstraintAttributes().getInitially() == null, - "FROM and deferrability require a constraint trigger"); - return result; - } + { statement.setNewName(name); return statement; } } -Expression PostgreSqlTriggerArgument(): -{ Expression result; Token token; String name; } +RangeTypeDefinition.Option RangeTypeOption(): +{ String name; RangeTypeDefinition.OptionKind kind; ColDataType type; } { + name=RelObjectName() "=" { kind = typeDdlEnum(RangeTypeDefinition.OptionKind.class, name); } ( - token= { result = new StringValue(token.image); } - | token= { result = new LongValue(token.image); } - | token= { result = new DoubleValue(token.image); } - | name=RelObjectName() { result = createColumn(name); } + LOOKAHEAD({ kind == RangeTypeDefinition.OptionKind.SUBTYPE }) + type=ColDataType() { return new RangeTypeDefinition.Option(type); } + | name=TypeDdlName() { return new RangeTypeDefinition.Option(kind, name); } ) +} + +CascadeBehavior TypeAlterBehavior(): +{ CascadeBehavior result; } +{ + ( { result = CascadeBehavior.CASCADE; } + | { result = CascadeBehavior.RESTRICT; } ) { return result; } } -List UsersList(): +AlterType.AttributeChange TypeAttributeChange(): { - List users = new ArrayList(); - String user = null; + AlterType.AttributeChange result = new AlterType.AttributeChange(); + TypeAttribute attribute = new TypeAttribute(); + String name; ColDataType type; CascadeBehavior behavior; + boolean useSetData; } { - user=RelObjectName() { users.add(user); } - ( "," user=ColumnsNamesListItem() { users.add(user); } )* - { - return users; - } + ( + TypeDdlKeyword("ATTRIBUTE") attribute=TypeAttribute() + { result.setKind(AlterType.AttributeChange.Kind.ADD); } + | TypeDdlKeyword("ATTRIBUTE") [ LOOKAHEAD(2) { result.setIfExists(true); } ] + name=RelObjectName() { attribute.setName(name); result.setKind(AlterType.AttributeChange.Kind.DROP); } + | TypeDdlKeyword("ATTRIBUTE") name=RelObjectName() { attribute.setName(name); } + useSetData=TypeChangePrefix() { result.setUseSetData(useSetData); } + type=ColDataType() { attribute.setDataType(type); result.setKind(AlterType.AttributeChange.Kind.ALTER); } + [ name=TypeDdlName() { attribute.setCollation(name); } ] + ) + [ behavior=TypeAlterBehavior() { result.setBehavior(behavior); } ] + { result.setAttribute(attribute); return result; } } -void readGrantTypes(ArrayList privileges): +AlterType AlterType(): { + AlterType result = new AlterType(); String name; Token label; + AlterType.AttributeChange change; CascadeBehavior behavior; List properties; } { - {privileges.add("SELECT");} | - {privileges.add("INSERT");} | - {privileges.add("UPDATE");} | - {privileges.add("DELETE");} | - {privileges.add("EXECUTE");} | - {privileges.add("ALTER");} | - {privileges.add("DROP");} + name=TypeDdlName() { result.setName(name); } + ( + LOOKAHEAD( ) + { result.setAction(AlterType.Action.ADD_VALUE); } + [ { result.setIfNotExists(true); } ] + label= { result.setValue(stringValue(label)); } + [ ( { result.setPosition(AlterType.Position.BEFORE); } + | TypeDdlKeyword("AFTER") { result.setPosition(AlterType.Position.AFTER); } ) + label= { result.setNeighborValue(stringValue(label)); } ] + | + ( + label= { result.setValue(stringValue(label)); } + label= { result.setNewValue(stringValue(label)); result.setAction(AlterType.Action.RENAME_VALUE); } + | LOOKAHEAD({ isKeywordAhead("ATTRIBUTE") }) TypeDdlKeyword("ATTRIBUTE") + name=RelObjectName() { result.setAttributeName(name); } + name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.RENAME_ATTRIBUTE); } + [ behavior=TypeAlterBehavior() { result.setBehavior(behavior); } ] + | name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.RENAME); } + ) + | + ( + name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.SET_SCHEMA); } + | properties=PostgreSqlDefinition() + { result.setProperties(properties); result.setAction(AlterType.Action.SET_PROPERTIES); } + ) + | LOOKAHEAD({ isKeywordAhead("OWNER") }) TypeDdlKeyword("OWNER") + name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.OWNER); } + | change=TypeAttributeChange() { result.setAction(AlterType.Action.ATTRIBUTES); result.getAttributeChanges().add(change); } + ( "," change=TypeAttributeChange() { result.getAttributeChanges().add(change); } )* + ) + { return result; } } -Sequence Sequence() #Sequence : +DomainConstraint DomainConstraint(boolean allowNull): +{ DomainConstraint result = new DomainConstraint(); String name; Expression expression; } { - ObjectNames data = null; - String serverName = null, databaseName = null, schemaName = null, sequenceName = null; + [ name=RelObjectName() { result.setName(name); } ] + ( + { result.setKind(DomainConstraint.Kind.NOT_NULL); } + | { requireTypeDdlSyntax(allowNull, "ALTER DOMAIN ADD does not accept NULL"); result.setKind(DomainConstraint.Kind.NULL); } + | "(" expression=Expression() ")" + { result.setKind(DomainConstraint.Kind.CHECK); result.setExpression(expression); } + ) + { return result; } } + +CreateDomain CreateDomain(): +{ CreateDomain result = new CreateDomain(); String name; ColDataType type; Expression expression; DomainConstraint constraint; } { - data = RelObjectNames() - { - Sequence sequence = new Sequence(data.getNames()); - linkAST(sequence,jjtThis); - return sequence; - } + name=TypeDdlName() { result.setName(name); } + [ { result.setUseAs(true); } ] type=ColDataType() { result.setDataType(type); } + [ name=TypeDdlName() { result.setCollation(name); } ] + [ expression=Expression() { result.setDefaultExpression(expression); } ] + // A following CHECK TABLE statement is not a domain CHECK constraint. + ( LOOKAHEAD(1, { !isTableMaintenanceAhead() }) + constraint=DomainConstraint(true) { result.getConstraints().add(constraint); } )* + { return result; } +} + +AlterDomain AlterDomain(): +{ AlterDomain result = new AlterDomain(); String name; Expression expression; DomainConstraint constraint; } +{ + name=TypeDdlName() { result.setName(name); } + ( + + ( + expression=Expression() { result.setAction(AlterDomain.Action.SET_DEFAULT); result.setDefaultExpression(expression); } + | { result.setAction(AlterDomain.Action.SET_NOT_NULL); } + | name=RelObjectName() { result.setAction(AlterDomain.Action.SET_SCHEMA); result.setNewName(name); } + ) + | + ( + { result.setAction(AlterDomain.Action.DROP_DEFAULT); } + | { result.setAction(AlterDomain.Action.DROP_NOT_NULL); } + | [ LOOKAHEAD(2) { result.setIfExists(true); } ] + name=RelObjectName() { result.setAction(AlterDomain.Action.DROP_CONSTRAINT); result.setConstraintName(name); } + [ { result.setBehavior(CascadeBehavior.CASCADE); } + | { result.setBehavior(CascadeBehavior.RESTRICT); } ] + ) + | constraint=DomainConstraint(false) { result.setAction(AlterDomain.Action.ADD_CONSTRAINT); result.setConstraint(constraint); } + [ TypeDdlKeyword("VALID") { + requireTypeDdlSyntax(constraint.getKind() == DomainConstraint.Kind.CHECK, "NOT VALID requires a CHECK constraint"); + result.setNotValid(true); + } ] + | + ( + name=RelObjectName() { result.setConstraintName(name); } + name=RelObjectName() { result.setNewName(name); result.setAction(AlterDomain.Action.RENAME_CONSTRAINT); } + | name=RelObjectName() { result.setNewName(name); result.setAction(AlterDomain.Action.RENAME); } + ) + | + name=RelObjectName() { result.setConstraintName(name); result.setAction(AlterDomain.Action.VALIDATE_CONSTRAINT); } + | LOOKAHEAD({ isKeywordAhead("OWNER") }) TypeDdlKeyword("OWNER") + name=RelObjectName() { result.setNewName(name); result.setAction(AlterDomain.Action.OWNER); } + ) + { return result; } } -List SequenceParameters(): +/** + * DuckDB 2.0's CREATE EXTENSION REPOSITORY [IF NOT EXISTS] name [WITH PREFIX prefix]. + */ +CreateExtensionRepository CreateExtensionRepository() #CreateExtensionRepository: { - List parameters = new ArrayList(); - Sequence.Parameter parameter; + CreateExtensionRepository createExtensionRepository = new CreateExtensionRepository(); + Expression prefix; + String name; } { - ( LOOKAHEAD(2) parameter=SequenceParameter() { parameters.add(parameter); } )* - { return parameters; } + TypeDdlKeyword("EXTENSION") TypeDdlKeyword("REPOSITORY") + [ LOOKAHEAD(3) + { createExtensionRepository.setIfNotExists(true); } ] + name=RelObjectName() { createExtensionRepository.setName(name); } + // greedy: WITH PREFIX belongs to the repository definition + [ + LOOKAHEAD(2) TypeDdlKeyword("PREFIX") prefix=SimpleExpression() + { createExtensionRepository.setPrefix(prefix); } + ] + { return createExtensionRepository; } } -Sequence.Parameter SequenceParameter(): +CreateExtension CreateExtension(): +{ CreateExtension result = new CreateExtension(); String name; Expression version; } { - Sequence.ParameterType type; - Long value = null; - Token token; - boolean withKeyword = false; + TypeDdlKeyword("EXTENSION") + [ LOOKAHEAD(3) { result.setIfNotExists(true); } ] + name=RelObjectName() { result.setName(name); } + [ LOOKAHEAD(1) { result.setUseWith(true); } ] + ( + name=RelObjectName() { result.getOptions().add(new CreateExtension.Option(CreateExtension.OptionKind.SCHEMA, name, null)); } + | version=ExtensionVersion() { result.getOptions().add(new CreateExtension.Option(CreateExtension.OptionKind.VERSION, null, version)); } + | { result.getOptions().add(new CreateExtension.Option(CreateExtension.OptionKind.CASCADE, null, null)); } + )* + { return result; } } + +RoutineReference.Argument RoutineSignatureArgument(): +{ RoutineReference.Argument argument; } +{ argument=RoutineArgument(true) { return argument; } } + +/** Common argument AST; only extension aggregate signatures may end a type at ORDER BY. */ +RoutineReference.Argument RoutineArgument(boolean allowOrderBy): +{ RoutineReference.Argument result = new RoutineReference.Argument(); String name; Token mode; ColDataType type; } { + [ + LOOKAHEAD({ isKeywordAhead("IN") || isKeywordAhead("OUT") || isKeywordAhead("INOUT") || isKeywordAhead("VARIADIC") }) + ( { result.setMode(RoutineReference.Argument.Mode.IN); } + | mode= { result.setMode(allowOrderBy + ? typeDdlEnum(RoutineReference.Argument.Mode.class, mode.image) + : accessEnum(RoutineReference.Argument.Mode.class, mode.image)); } ) + ] ( - [ { withKeyword = true; } ] value=SequenceParameterValue() - { type = withKeyword ? Sequence.ParameterType.INCREMENT_BY : Sequence.ParameterType.INCREMENT; } - | - [ { withKeyword = true; } ] value=SequenceParameterValue() - { type = withKeyword ? Sequence.ParameterType.START_WITH : Sequence.ParameterType.START; } - | - [ LOOKAHEAD(2) value=SequenceParameterValue() ] - { type = Sequence.ParameterType.RESTART_WITH; } - | - ( token= | token= | token= ) value=SequenceParameterValue() - { type = Sequence.ParameterType.valueOf(token.image.toUpperCase(Locale.ROOT)); } - | - ( token= | token= | token= ) - { type = Sequence.ParameterType.valueOf("NO_" + token.image.toUpperCase(Locale.ROOT)); } - | - ( token= | token= | token= | token= - | token= | token= | token= | token= - | token= | token= | token= ) - { type = Sequence.ParameterType.valueOf(token.image.toUpperCase(Locale.ROOT)); } + LOOKAHEAD(ColDataType() ("," | ")" | )) type=ColDataType() + | name=RelObjectName() { result.setName(name); } type=ColDataType() ) - { return new Sequence.Parameter(type).withValue(value); } + { + requireAccessSyntax(allowOrderBy || getToken(1).kind != K_ORDER, + "ORDER BY requires an aggregate signature"); + result.setDataType(type); + return result; + } } -Long SequenceParameterValue(): +RoutineReference RoutineReference(boolean aggregate): { - Token sign = null; - Token value; + RoutineReference result = new RoutineReference(); String name; RoutineReference.Argument argument; + List arguments; List orderBy; } { - [ sign="-" | sign="+" ] value= - { return Long.valueOf((sign == null ? "" : sign.image) + value.image); } + name=TypeDdlName() { result.setName(name); } + [ + LOOKAHEAD(1) + "(" { arguments = new ArrayList(); result.setArguments(arguments); } + ( + "*" { requireTypeDdlSyntax(aggregate, "Only aggregate signatures accept *"); result.setAllArguments(true); } + | + // ORDER is non-reserved, so ORDER BY without direct arguments is not an argument name + [ LOOKAHEAD(1, { getToken(1).kind != K_ORDER || getToken(2).kind != K_BY }) + argument=RoutineSignatureArgument() { arguments.add(argument); } + ( "," argument=RoutineSignatureArgument() { arguments.add(argument); } )* ] + [ { requireTypeDdlSyntax(aggregate, "ORDER BY requires an aggregate signature"); orderBy = new ArrayList(); } + argument=RoutineSignatureArgument() { orderBy.add(argument); } + ( "," argument=RoutineSignatureArgument() { orderBy.add(argument); } )* + { result.setOrderByArguments(orderBy); } ] + ) + ")" + ] + { requireTypeDdlSyntax(!aggregate || isAggregateSignature(result), "An aggregate signature is required"); return result; } } -SequenceOwnership SequenceOwnership(): -{ - Token token; - Column column; - SequenceOwnership ownership; -} +String ExtensionOperatorName(): +{ ExclusionOperator operator; } +{ operator=PostgreSqlOperatorReference() { return operator.getQualifiedName(); } } + +/** + * Shared schema-qualified operator spelling used in DDL references. A database may precede the + * schema, as in db.schema.+, and is then a part of the schema name. + */ +ExclusionOperator PostgreSqlOperatorReference(): +{ String schema = null; String name; } { - token= { - requireDdlSyntax("OWNED".equalsIgnoreCase(token.image), "Expected OWNED"); - } - - ( LOOKAHEAD(1) { ownership = SequenceOwnership.none(); } - | column=Column() { ownership = SequenceOwnership.ownedBy(column); } ) - { return ownership; } + ( LOOKAHEAD(RelObjectName() ".") name=RelObjectName() "." + { schema = schema == null ? name : schema + "." + name; } )* + name=PostgreSqlOperatorName() + { return new ExclusionOperator().withSchemaName(schema).withName(name); } } -CreateSequence CreateSequence(): +/** + * The lexer splits some PostgreSQL operators, such as <<= or -|-, into several tokens. Parts that + * touch each other are joined, because PostgreSQL reads them as one operator. + */ +String PostgreSqlOperatorName(): +{ StringBuilder name = new StringBuilder(); Token token; } { - CreateSequence createSequence = new CreateSequence(); - Sequence sequence; - List sequenceParameters; - Token dataType = null; - SequenceOwnership ownership; + token=PostgreSqlOperatorPart() { name.append(token.image); } + ( + LOOKAHEAD(1, { getToken(1).specialToken == null && getToken(1).beginLine == getToken(0).endLine + && getToken(1).beginColumn == getToken(0).endColumn + 1 }) + token=PostgreSqlOperatorPart() { name.append(token.image); } + )* + { requirePostgreSqlOperatorName(name.toString()); return name.toString(); } } + +Token PostgreSqlOperatorPart(): +{ Token token; } { - sequence=Sequence() { createSequence.setSequence(sequence); } - [ ( dataType= | dataType= ) { sequence.setDataType(dataType.image); } ] - sequenceParameters = SequenceParameters() - [ LOOKAHEAD({ isKeywordAhead("OWNED") }) ownership=SequenceOwnership() { sequence.setOwnership(ownership); } ] + ( + token="+" | token="-" | token="*" | token="/" | token="%" | token= | token= + | token="<" | token=">" | token="=" | token="==" | token= | token= + | token= | token= | token= | token="*=" | token="=*" + | token= | token= | token= | token="|>" | token="&" | token= + | token= | token= | token= | token= + | token="~" | token="~*" | token="!~" | token="!~*" | token="~~" | token="~~*" | token="!~~" | token="!~~*" + | token="~~~" | token="!" | token= | token="@>" | token="<@" | token="@@" | token= + | token="?" | token="?|" | token="?&" | token="->" | token="->>" | token= | token="#>" + | token="#>>" | token= | token="-#" | token="<->" | token="<#>" + // "=>" is no operator by itself, but it is a part of one such as <==> + | token= + // the lexer reads @ before # as the start of a variable name, as in @#@ + | token= + ) { - sequence.setParameters(sequenceParameters); - return createSequence; + requireTypeDdlSyntax(token.kind != S_AT_IDENTIFIER || token.image.matches("[@#]+"), + "Expected an operator but found " + token.image); + // PostgreSQL reads "< =" as two operators, while the lexer tolerates whitespace inside it + requireTypeDdlSyntax(!token.image.matches("(?s).*\\s.*"), + "Unexpected whitespace in operator " + token.image); + return token; } } -AlterSequence AlterSequence(): +ColDataType ExtensionOperatorType(): +{ ColDataType type = null; } +{ ( | type=ColDataType() ) { return type; } } + +ExtensionObject ExtensionObject(): { - AlterSequence alterSequence = new AlterSequence(); - Sequence sequence; - List sequenceParameters; - SequenceOwnership ownership; + ExtensionObject result = new ExtensionObject(); String name; String kind; + RoutineReference routine; ColDataType type; } { - sequence=Sequence() { alterSequence.setSequence(sequence); } - sequenceParameters = SequenceParameters() - [ LOOKAHEAD({ isKeywordAhead("OWNED") }) ownership=SequenceOwnership() { sequence.setOwnership(ownership); } ] + ( + LOOKAHEAD({ isKeywordAhead("FUNCTION") || isKeywordAhead("PROCEDURE") || isKeywordAhead("ROUTINE") || isKeywordAhead("AGGREGATE") }) + ( LOOKAHEAD(1) { kind = "PROCEDURE"; } | kind=RelObjectName() ) + routine=RoutineReference("AGGREGATE".equalsIgnoreCase(kind)) + { result.setKind(typeDdlEnum(ExtensionObject.Kind.class, kind)); result.setRoutine(routine); } + | LOOKAHEAD({ isKeywordAhead("CAST") }) "(" + type=ColDataType() { result.setSourceType(type); } + type=ColDataType() { result.setTargetType(type); } ")" { result.setKind(ExtensionObject.Kind.CAST); } + | LOOKAHEAD({ isKeywordAhead("OPERATOR") && !"CLASS".equalsIgnoreCase(getToken(2).image) && !"FAMILY".equalsIgnoreCase(getToken(2).image) }) + TypeDdlKeyword("OPERATOR") name=ExtensionOperatorName() "(" + type=ExtensionOperatorType() { result.setSourceType(type); } "," + type=ExtensionOperatorType() { result.setTargetType(type); } ")" + { result.setKind(ExtensionObject.Kind.OPERATOR); result.setName(name); } + | LOOKAHEAD({ isKeywordAhead("TRANSFORM") }) TypeDdlKeyword("TRANSFORM") + type=ColDataType() { result.setSourceType(type); } TypeDdlKeyword("LANGUAGE") + name=RelObjectName() { result.setLanguage(name); result.setKind(ExtensionObject.Kind.TRANSFORM); } + | + ( + + ( { kind = "FOREIGN_TABLE"; } + | TypeDdlKeyword("WRAPPER") { kind = "FOREIGN_DATA_WRAPPER"; } ) + | LOOKAHEAD(2) { kind = "MATERIALIZED_VIEW"; } + | LOOKAHEAD({ isKeywordAhead("TEXT") }) + name=RelObjectName() { kind = "TEXT_SEARCH_" + name; } + | LOOKAHEAD({ isKeywordAhead("EVENT") }) { kind = "EVENT_TRIGGER"; } + | LOOKAHEAD({ isKeywordAhead("ACCESS") }) TypeDdlKeyword("ACCESS") TypeDdlKeyword("METHOD") { kind = "ACCESS_METHOD"; } + | LOOKAHEAD({ isKeywordAhead("OPERATOR") }) TypeDdlKeyword("OPERATOR") + name=RelObjectName() { kind = "OPERATOR_" + name; } + | LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) TypeDdlKeyword("PROCEDURAL") TypeDdlKeyword("LANGUAGE") + { result.setProcedural(true); kind = "LANGUAGE"; } + | kind=RelObjectName() + ) + { result.setKind(typeDdlEnum(ExtensionObject.Kind.class, kind)); } + name=TypeDdlName() { result.setName(name); } + [ name=RelObjectName() { result.setAccessMethod(name); } ] + ) { - sequence.setParameters(sequenceParameters); - return alterSequence; + requireTypeDdlSyntax((result.getKind() == ExtensionObject.Kind.OPERATOR_CLASS || result.getKind() == ExtensionObject.Kind.OPERATOR_FAMILY) + == (result.getAccessMethod() != null), "USING is required only for operator classes and families"); + return result; } } -Statement Create(): -{ - boolean isUsingOrReplace=false; - Token tk; - Statement statement; - List captureRest; -} +AlterExtension AlterExtension(): +{ AlterExtension result = new AlterExtension(); String name; Expression version; ExtensionObject member; } { - [ { isUsingOrReplace = true; } ] + TypeDdlKeyword("EXTENSION") name=RelObjectName() { result.setName(name); } ( - LOOKAHEAD({ isPostgreSqlRoleAhead() }) statement = CreateRole() - { requireAccessSyntax(!isUsingOrReplace, "CREATE ROLE does not accept OR REPLACE"); } - | - LOOKAHEAD({ isPostgreSqlTriggerAhead() }) statement = PostgreSqlTrigger(isUsingOrReplace) - | - LOOKAHEAD() { requireTypeDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE TYPE"); } statement = CreateType() - | - LOOKAHEAD() { requireTypeDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE DOMAIN"); } statement = CreateDomain() - | - LOOKAHEAD({ isKeywordAhead("EXTENSION") - && "REPOSITORY".equalsIgnoreCase(getToken(2).image) }) - { requireTypeDdlSyntax(!isUsingOrReplace, - "OR REPLACE is not supported for CREATE EXTENSION REPOSITORY"); } - statement = CreateExtensionRepository() - | - LOOKAHEAD({ isKeywordAhead("EXTENSION") }) { requireTypeDdlSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE EXTENSION"); } statement = CreateExtension() - | - LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) - { requireReplicationSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE PUBLICATION"); } - statement = CreatePublication() - | - LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) - { requireReplicationSyntax(!isUsingOrReplace, "OR REPLACE is not supported for CREATE SUBSCRIPTION"); } - statement = CreateSubscription() - | - statement = CreateUser() - | - statement = CreateEvent() - | - LOOKAHEAD({ getToken(1).kind == K_TRIGGER - || "DEFINER".equalsIgnoreCase(getToken(1).image) }) - statement = CreateTrigger() - | - statement = CreateFunctionStatement(isUsingOrReplace) - | - statement = CreateSchema() - | - statement = CreateDatabase() - | - statement = CreateSequence() - | - statement = CreateSynonym(isUsingOrReplace) - | - LOOKAHEAD({ isCreateMacroAhead() }) statement = CreateMacro(isUsingOrReplace) - | - LOOKAHEAD(3) statement = CreateTable(isUsingOrReplace) - | - LOOKAHEAD(2) statement = CreateView(isUsingOrReplace) - | - statement = CreatePolicy() - | - /* @fixme - * Create Index uses CreateParameter() which allows all kind of tokens - * it can conflict with other statements and must be at the end right now - */ - statement = CreateIndex() - | - captureRest = captureRest() - { - statement = new UnsupportedStatement("CREATE", captureRest); - } + { result.setAction(AlterExtension.Action.UPDATE); } + [ version=ExtensionVersion() { result.setVersion(version); } ] + | name=RelObjectName() { result.setAction(AlterExtension.Action.SET_SCHEMA); result.setSchema(name); } + | ( { result.setAction(AlterExtension.Action.ADD); } | { result.setAction(AlterExtension.Action.DROP); } ) + member=ExtensionObject() { result.setMember(member); } ) - { - return statement; - } + { return result; } } -CreateFunctionalStatement CreateFunctionStatement(boolean isUsingOrReplace): +void ReplicationKeyword(String expected): +{ Token token; } +{ token= { requireReplicationSyntax(expected.equalsIgnoreCase(token.image), "Expected " + expected); } } + +Expression ReplicationOptionValue(): +{ Token token; Expression result; } { - CreateFunctionalStatement type = null; - List tokens = new LinkedList(); - String statementType = null; + ( LOOKAHEAD(1) token= { result = linkToLastToken(new Column(token.image)); } | result=PrimaryExpression() ) + { return result; } } + +PublicationOption PublicationOption(): +{ String name; Expression value = null; } { - ( - { statementType = "FUNCTION"; } - | - { statementType = "PROCEDURE"; } - ) - tokens=captureFunctionBody() - { - if(statementType.equals("FUNCTION")) { - type = new CreateFunction(isUsingOrReplace, tokens); - } - if(statementType.equals("PROCEDURE")) { - type = new CreateProcedure(isUsingOrReplace, tokens); - } + name=RelObjectName() [ "=" value=ReplicationOptionValue() ] + { return new PublicationOption(name, replicationEnum(PublicationOption.Kind.class, name), value); } +} - return type; - } +List PublicationOptions(): +{ List options = new ArrayList(); PublicationOption option; } +{ + "(" option=PublicationOption() { options.add(option); } + ( "," option=PublicationOption() { options.add(option); } )* ")" + { return options; } } -CreateFunctionalStatement SqlServerRoutine(): +SubscriptionOption SubscriptionOption(): +{ String name; Expression value = null; } { - CreateFunctionalStatement result; - CreateFunctionalStatement.Operation operation = CreateFunctionalStatement.Operation.CREATE; - List parts; - FunctionReturnType returnType; + name=RelObjectName() [ "=" value=ReplicationOptionValue() ] + { return new SubscriptionOption(name, replicationEnum(SubscriptionOption.Kind.class, name), value); } } + +List SubscriptionOptions(): +{ List options = new ArrayList(); SubscriptionOption option; } { - ( [ { operation = CreateFunctionalStatement.Operation.CREATE_OR_ALTER; } ] - | { operation = CreateFunctionalStatement.Operation.ALTER; } ) - ( - parts=captureSqlServerFunctionHeader() - returnType=SqlServerFunctionReturnType() - { result = new CreateFunction(parts); result.setReturnType(returnType); } - parts=captureSqlServerRoutineBody(false) { result.setRoutineBodyParts(parts); } - | parts=captureSqlServerRoutineBody(true) { result = new CreateProcedure(parts); } - ) - { result.setOperation(operation); return result; } + "(" option=SubscriptionOption() { options.add(option); } + ( "," option=SubscriptionOption() { options.add(option); } )* ")" + { return options; } } -FunctionReturnType SqlServerFunctionReturnType(): +PublicationTable PublicationTable(boolean drop): +{ PublicationTable result = new PublicationTable(); Table table; String name; Expression expression; ExpressionList columns; } { - FunctionReturnType result = new FunctionReturnType(); - UserVariable variable; ColDataType dataType; - TableElement element; List elements = new ArrayList(); + [ LOOKAHEAD(2) { result.setOnly(true); } ] + table=Table() { result.setTable(table); } + [ "*" { result.setIncludeDescendants(true); } ] + [ LOOKAHEAD(1) "(" { columns = new ExpressionList(); } + name=RelObjectName() { columns.add(linkToLastToken(createColumn(name))); } + ( "," name=RelObjectName() { columns.add(linkToLastToken(createColumn(name))); } )* ")" + { result.setColumns(linkElements(columns)); } ] + [ "(" expression=Expression() ")" { result.setWhere(expression); } ] + { + requireReplicationSyntax(!(result.isOnly() && result.isIncludeDescendants()), "ONLY and * cannot be combined"); + requireReplicationSyntax(!drop || (result.getColumns() == null && result.getWhere() == null), "DROP publication tables cannot have column lists or filters"); + return result; + } } + +PublicationTarget PublicationTarget(boolean drop): +{ PublicationTarget result = new PublicationTarget(); PublicationTable table; String schema; } { - ( - LOOKAHEAD({ getToken(1).kind == K_TABLE || getToken(1).kind == S_AT_IDENTIFIER }) - [ variable=UserVariable() { result.setTableVariable(variable.toString()); } ] - { result.setTable(true); } - [ "(" element=SqlServerReturnTableElement() { elements.add(element); } - ( "," element=SqlServerReturnTableElement() { elements.add(element); } )* ")" - { result.setTableElements(elements); } ] - { requireDdlSyntax(result.getTableVariable() == null || result.getTableElements() != null, - "A return table variable requires column definitions"); } - | dataType=ColDataType() { result.setDataType(dataType); } + { result.setKind(PublicationTarget.Kind.TABLE); } + table=PublicationTable(drop) { result.getTables().add(table); } + ( LOOKAHEAD({ getToken(1).image.equals(",") && getToken(2).kind != K_TABLE && getToken(2).kind != K_TABLES }) + "," table=PublicationTable(drop) { result.getTables().add(table); } )* + | + { result.setKind(PublicationTarget.Kind.TABLES_IN_SCHEMA); } + schema=RelObjectName() { result.getSchemas().add(schema); } + ( LOOKAHEAD({ getToken(1).image.equals(",") && getToken(2).kind != K_TABLE && getToken(2).kind != K_TABLES }) + "," schema=RelObjectName() { result.getSchemas().add(schema); } )* ) { return result; } } -TableElement SqlServerReturnTableElement(): -{ TableElement element; } +List PublicationTargets(boolean drop): +{ List targets = new ArrayList(); PublicationTarget target; } { - ( LOOKAHEAD(3) element=CreateTableConstraint() | element=ColumnDefinition() ) - { return element; } + target=PublicationTarget(drop) { targets.add(target); } + ( "," target=PublicationTarget(drop) { targets.add(target); } )* + { return targets; } } -JAVACODE -List captureSqlServerFunctionHeader() { - List parts = new ArrayList(); - int depth = 0; - while (true) { - Token next = getToken(1); - if (next.kind == K_RETURNS && depth == 0) break; - if (next.kind == EOF || next.kind == ST_SEMICOLON) { - throw new ParseException("A SQL Server function requires RETURNS"); - } - if ("(".equals(next.image)) depth++; - if (")".equals(next.image)) depth--; - if (depth < 0) throw new ParseException("Unbalanced function parameters"); - parts.add(getNextToken().image); - } - if (parts.size() < 3 || "(".equals(parts.get(0)) || !")".equals(parts.get(parts.size() - 1))) { - throw new ParseException("A SQL Server function requires a name and parameter parentheses"); - } - return parts; +CreatePublication CreatePublication(): +{ CreatePublication result = new CreatePublication(); String name; List targets; List options; } +{ + ReplicationKeyword("PUBLICATION") name=RelObjectName() { result.setName(name); } + [ + + ( { result.setAllTables(true); } + | targets=PublicationTargets(false) { result.setTargets(targets); } ) + ] + [ LOOKAHEAD(2) options=PublicationOptions() { result.setOptions(options); } ] + { return result; } } -JAVACODE -List captureSqlServerRoutineBody(boolean procedure) { - List parts = new ArrayList(); - int depth = 0; - while (true) { - Token next = getToken(1); - // Procedure definitions occupy the rest of their batch, including statements - // after an END. Their opaque bodies may contain BEGIN TRANSACTION and TRY/CATCH. - if (next.kind == EOF || (!procedure && next.kind == ST_SEMICOLON && depth == 0)) break; - if (!procedure) { - if (next.kind == K_BEGIN || next.kind == K_CASE) { - depth++; - } else if (next.kind == K_END) { - if (--depth < 0) throw new ParseException("Unmatched END in routine"); - } - } - parts.add(getNextToken().image); - } - if (depth != 0) throw new ParseException("Unterminated SQL Server routine block"); - if (parts.isEmpty()) throw new ParseException("A routine body is required"); - return parts; +AlterPublication AlterPublication(): +{ AlterPublication result = new AlterPublication(); String name; List targets; List options; boolean drop = false; } +{ + ReplicationKeyword("PUBLICATION") name=RelObjectName() { result.setName(name); } + ( + LOOKAHEAD({ isKeywordAhead("OWNER") }) ReplicationKeyword("OWNER") + name=RelObjectName() { result.setNewName(name); result.setAction(AlterPublication.Action.OWNER); } + | name=RelObjectName() { result.setNewName(name); result.setAction(AlterPublication.Action.RENAME); } + | LOOKAHEAD( "(") options=PublicationOptions() { result.setOptions(options); result.setAction(AlterPublication.Action.SET_OPTIONS); } + | ( { result.setAction(AlterPublication.Action.ADD); } + | { result.setAction(AlterPublication.Action.SET); } + | { result.setAction(AlterPublication.Action.DROP); drop = true; } ) + targets=PublicationTargets(drop) { result.setTargets(targets); } + ) + { return result; } } -CreateSynonym CreateSynonym(boolean isUsingOrReplace): +List SubscriptionPublications(): +{ List names = new ArrayList(); String name; } { - CreateSynonym createSynonym = new CreateSynonym(); - Synonym synonym; - boolean publicSynonym = false; - ObjectNames data = null; + name=RelObjectName() { names.add(name); } + ( "," name=RelObjectName() { names.add(name); } )* + { return names; } } + +CreateSubscription CreateSubscription(): +{ CreateSubscription result = new CreateSubscription(); String name; Token connection; List publications; List options; } { - [ { publicSynonym = true; } ] - synonym=Synonym() { createSynonym.setSynonym(synonym); } - data = RelObjectNames() - { - createSynonym.setOrReplace(isUsingOrReplace); - createSynonym.setPublicSynonym(publicSynonym); - createSynonym.setForList(data.getNames()); - return createSynonym; - } + ReplicationKeyword("SUBSCRIPTION") name=RelObjectName() { result.setName(name); } + ReplicationKeyword("CONNECTION") connection= { result.setConnection(stringValue(connection)); } + ReplicationKeyword("PUBLICATION") publications=SubscriptionPublications() { result.setPublications(publications); } + [ LOOKAHEAD(2) options=SubscriptionOptions() { result.setOptions(options); } ] + { return result; } } -Synonym Synonym() #Synonym : +AlterSubscription AlterSubscription(): +{ AlterSubscription result = new AlterSubscription(); String name; Token connection; List publications; List options; } { - ObjectNames data = null; - String serverName = null, databaseName = null, schemaName = null, sequenceName = null; + ReplicationKeyword("SUBSCRIPTION") name=RelObjectName() { result.setName(name); } + ( + LOOKAHEAD({ isKeywordAhead("CONNECTION") }) ReplicationKeyword("CONNECTION") + connection= { result.setConnection(stringValue(connection)); result.setAction(AlterSubscription.Action.CONNECTION); } + | LOOKAHEAD({ isKeywordAhead("OWNER") }) ReplicationKeyword("OWNER") + name=RelObjectName() { result.setNewName(name); result.setAction(AlterSubscription.Action.OWNER); } + | name=RelObjectName() { result.setNewName(name); result.setAction(AlterSubscription.Action.RENAME); } + | { result.setAction(AlterSubscription.Action.ENABLE); } + | { result.setAction(AlterSubscription.Action.DISABLE); } + | options=SubscriptionOptions() { + requireReplicationSyntax(options.size() == 1 && options.get(0).getKind() == SubscriptionOption.Kind.LSN + && options.get(0).getValue() != null, "SKIP requires one lsn = value option"); + result.setOptions(options); result.setAction(AlterSubscription.Action.SKIP); + } + | LOOKAHEAD( "(") options=SubscriptionOptions() { result.setOptions(options); result.setAction(AlterSubscription.Action.SET_OPTIONS); } + | ReplicationKeyword("PUBLICATION") { result.setAction(AlterSubscription.Action.REFRESH_PUBLICATION); } + [ LOOKAHEAD(2) options=SubscriptionOptions() { result.setOptions(options); } ] + | ( { result.setAction(AlterSubscription.Action.SET_PUBLICATION); } + | { result.setAction(AlterSubscription.Action.ADD_PUBLICATION); } + | { result.setAction(AlterSubscription.Action.DROP_PUBLICATION); } ) + ReplicationKeyword("PUBLICATION") publications=SubscriptionPublications() { result.setPublications(publications); } + [ LOOKAHEAD(2) options=SubscriptionOptions() { result.setOptions(options); } ] + ) + { return result; } } + +CreatePolicy CreatePolicy() #CreatePolicy: { - data = RelObjectNames() + CreatePolicy createPolicy = new CreatePolicy(); + String policyName; + Table table; + String policyMode = null; + Token commandToken = null; + PolicyOptions options; +} +{ + policyName=RelObjectName() { createPolicy.setPolicyName(policyName); } + table=Table() { createPolicy.setTable(table); } + + [ + LOOKAHEAD({ isKeywordAhead("PERMISSIVE") || isKeywordAhead("RESTRICTIVE") }) + policyMode=RelObjectName() + { createPolicy.setPolicyMode(PolicyMode.from(policyMode)); } + ] + + [ + ( commandToken= + | commandToken= + | commandToken= + | commandToken= + | commandToken= + ) + { createPolicy.setPolicyCommand(PolicyCommand.from(commandToken.image)); } + ] + + options=PolicyOptions() { createPolicy.setOptions(options); } + { - Synonym synonym = new Synonym(data.getNames()); - linkAST(synonym,jjtThis); - return synonym; + + return createPolicy; } } -String TypeDdlName(): -{ String name; String part; Token keyword; } +PolicyOptions PolicyOptions(): +{ PolicyOptions options = new PolicyOptions(); String role; Expression expression; } { - ( name=RelObjectName() | keyword= { name = keyword.image; } ) - ( LOOKAHEAD(2) "." ( part=RelObjectNameExt() | keyword= { part = keyword.image; } ) - { name += "." + part; } )* - { return name; } + [ role=RelObjectName() { options.getRoles().add(role); } + ( "," role=RelObjectName() { options.getRoles().add(role); } )* ] + [ "(" expression=Expression() ")" { options.setUsingExpression(expression); } ] + [ LOOKAHEAD(2) "(" expression=Expression() ")" { options.setWithCheckExpression(expression); } ] + { return options; } } - -void TypeDdlKeyword(String expected): -{ Token keyword; } -{ ( keyword= | keyword= ) { requireTypeDdlSyntax(expected.equalsIgnoreCase(keyword.image), "Expected " + expected); } } - -Expression ExtensionVersion(): -{ Token token; String name; Expression result; } +AlterPolicy AlterPolicy(): +{ AlterPolicy statement = new AlterPolicy(); String name; Table table; PolicyOptions options; } { - ( token= { result = new StringValue(token.image); } - | name=RelObjectName() { result = createColumn(name); } ) - { return result; } + name=RelObjectName() { statement.setPolicyName(name); } + table=Table() { statement.setTable(table); } + ( name=RelObjectName() { statement.setNewName(name); } + | options=PolicyOptions() { statement.setOptions(options); } ) + { return statement; } } - -TypeAttribute TypeAttribute(): -{ TypeAttribute attribute = new TypeAttribute(); String name; ColDataType type; } +DropPolicy DropPolicy(): +{ DropPolicy statement = new DropPolicy(); String name; Table table; Token behavior; } { - name=RelObjectName() { attribute.setName(name); } - type=ColDataType() { attribute.setDataType(type); } - [ name=TypeDdlName() { attribute.setCollation(name); } ] - { return attribute; } + [ LOOKAHEAD(2) { statement.setIfExists(true); } ] + name=RelObjectName() { statement.setPolicyName(name); } + table=Table() { statement.setTable(table); } + [ (behavior= | behavior=) { statement.setBehavior(CascadeBehavior.valueOf(behavior.image.toUpperCase(Locale.ROOT))); } ] + { return statement; } } -CreateType CreateType(): +UnsupportedStatement UnsupportedStatement(): { - CreateType result = new CreateType(); - String name; Token label; TypeAttribute attribute; - EnumTypeDefinition enumeration = new EnumTypeDefinition(); - CompositeTypeDefinition composite = new CompositeTypeDefinition(); - RangeTypeDefinition range = new RangeTypeDefinition(); - RangeTypeDefinition.Option option; + List tokens = new LinkedList(); + Token first = getToken(1); } { - name=TypeDdlName() { result.setName(name); } - [ - - ( - LOOKAHEAD({ isKeywordAhead("ENUM") }) TypeDdlKeyword("ENUM") "(" - [ label= { enumeration.getLabels().add(new StringValue(label.image)); } - ( "," label= { enumeration.getLabels().add(new StringValue(label.image)); } )* ] - ")" { result.setDefinition(enumeration); } - | "(" option=RangeTypeOption() { range.getOptions().add(option); } - ( "," option=RangeTypeOption() { range.getOptions().add(option); } )* ")" - { - requireTypeDdlSyntax(range.getSubtype() != null, "A range definition requires SUBTYPE"); - result.setDefinition(range); - } - | "(" [ attribute=TypeAttribute() { composite.getAttributes().add(attribute); } - ( "," attribute=TypeAttribute() { composite.getAttributes().add(attribute); } )* ] - ")" { result.setDefinition(composite); } - ) - ] - { return result; } + tokens=captureUnsupportedStatementDeclaration() + { + return linked(new UnsupportedStatement(tokens), first); + } } -RangeTypeDefinition.Option RangeTypeOption(): -{ String name; RangeTypeDefinition.OptionKind kind; ColDataType type; } -{ - name=RelObjectName() "=" { kind = typeDdlEnum(RangeTypeDefinition.OptionKind.class, name); } - ( - LOOKAHEAD({ kind == RangeTypeDefinition.OptionKind.SUBTYPE }) - type=ColDataType() { return new RangeTypeDefinition.Option(type); } - | name=TypeDdlName() { return new RangeTypeDefinition.Option(kind, name); } - ) +JAVACODE +List captureRest() { + List tokens = new LinkedList(); + Token tok; + while(true) { + tok = getToken(1); + int l = tokens.size(); + if( tok.kind == EOF || tok.kind == ST_SEMICOLON ) { + break; + } else if ( l>0 && ( tok.image.equals(".") || tokens.get(l-1).endsWith(".")) ) { + tokens.set(l-1, tokens.get(l-1) + tok.image); + } else { + tokens.add(tok.image); + } + tok = getNextToken(); + } + return tokens; } -AlterType.Behavior TypeAlterBehavior(): -{ AlterType.Behavior result; } -{ - ( { result = AlterType.Behavior.CASCADE; } - | { result = AlterType.Behavior.RESTRICT; } ) - { return result; } -} +/** + * Captures opaque routine declarations through their terminating semicolon. + * PostgreSQL AS string bodies can use ordinary, escape or dollar quotes. + * The boundary tracker distinguishes simple statements, declaration sections, + * compound bodies, and expression CASE from procedural END qualifiers. + * With a list, MySQL characteristics between the header and the body are also + * parsed into it; their tokens are captured as well. + */ -AlterType.AttributeChange TypeAttributeChange(): -{ - AlterType.AttributeChange result = new AlterType.AttributeChange(); - TypeAttribute attribute = new TypeAttribute(); - String name; ColDataType type; AlterType.Behavior behavior; -} -{ - ( - TypeDdlKeyword("ATTRIBUTE") attribute=TypeAttribute() - { result.setKind(AlterType.AttributeChange.Kind.ADD); } - | TypeDdlKeyword("ATTRIBUTE") [ LOOKAHEAD(2) { result.setIfExists(true); } ] - name=RelObjectName() { attribute.setName(name); result.setKind(AlterType.AttributeChange.Kind.DROP); } - | TypeDdlKeyword("ATTRIBUTE") name=RelObjectName() { attribute.setName(name); } - [ { result.setUseSetData(true); } ] - type=ColDataType() { attribute.setDataType(type); result.setKind(AlterType.AttributeChange.Kind.ALTER); } - [ name=TypeDdlName() { attribute.setCollation(name); } ] - ) - [ behavior=TypeAlterBehavior() { result.setBehavior(behavior); } ] - { result.setAttribute(attribute); return result; } +JAVACODE +List captureFunctionBody(List characteristics) { + List tokens = new LinkedList(); + Token tok; + RoutineBodyBoundary boundary = new RoutineBodyBoundary(); + while(true) { + tok = getToken(1); + int l = tokens.size(); + if (characteristics != null && boundary.isBeforeBody() && isMySqlCreateRoutineCharacteristicAhead()) { + characteristics.add(MySqlRoutineCharacteristic(true)); + for (Token consumed = tok; ; consumed = consumed.next) { + tokens.add(consumed.image); + boundary.accept(consumed, consumed == token ? getToken(1) : consumed.next); + if (consumed == token) { + break; + } + } + continue; + } + if (boundary.endsAt(tok)) { + if (tok.kind == ST_SEMICOLON) { + tokens.add(tok.image); + } + break; + } else if (boundary.startsQuotedBody(tok, getToken(2))) { + tokens.add(getNextToken().image); + tokens.add(captureRoutineBodyLiteral()); + boundary.quotedBody(); + continue; + } else if ( l>0 && ( tok.image.equals(".") || tokens.get(l-1).endsWith(".")) ) { + tokens.set(l-1, tokens.get(l-1) + tok.image); + } else { + tokens.add(tok.image); + } + boundary.accept(tok, getToken(2)); + tok = getNextToken(); + } + return tokens; } -AlterType AlterType(): -{ - AlterType result = new AlterType(); String name; Token label; - AlterType.AttributeChange change; AlterType.Behavior behavior; -} -{ - name=TypeDdlName() { result.setName(name); } - ( - LOOKAHEAD( ) - { result.setAction(AlterType.Action.ADD_VALUE); } - [ { result.setIfNotExists(true); } ] - label= { result.setValue(new StringValue(label.image)); } - [ ( { result.setPosition(AlterType.Position.BEFORE); } - | TypeDdlKeyword("AFTER") { result.setPosition(AlterType.Position.AFTER); } ) - label= { result.setNeighborValue(new StringValue(label.image)); } ] - | - ( - label= { result.setValue(new StringValue(label.image)); } - label= { result.setNewValue(new StringValue(label.image)); result.setAction(AlterType.Action.RENAME_VALUE); } - | LOOKAHEAD({ isKeywordAhead("ATTRIBUTE") }) TypeDdlKeyword("ATTRIBUTE") - name=RelObjectName() { result.setAttributeName(name); } - name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.RENAME_ATTRIBUTE); } - [ behavior=TypeAlterBehavior() { result.setBehavior(behavior); } ] - | name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.RENAME); } - ) - | name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.SET_SCHEMA); } - | LOOKAHEAD({ isKeywordAhead("OWNER") }) TypeDdlKeyword("OWNER") - name=RelObjectName() { result.setNewName(name); result.setAction(AlterType.Action.OWNER); } - | change=TypeAttributeChange() { result.setAction(AlterType.Action.ATTRIBUTES); result.getAttributeChanges().add(change); } - ( "," change=TypeAttributeChange() { result.getAttributeChanges().add(change); } )* - ) - { return result; } +/** + * Keeps the separator required by PostgreSQL's continued string literals. + * The routine's legacy token list otherwise renders every gap as one space. + */ +JAVACODE +String captureRoutineBodyLiteral() { + String literal = getNextToken().image; + if (literal.startsWith("$") || !isAdjacentStringConcat()) { + return literal; + } + StringBuilder body = new StringBuilder(literal); + while (isAdjacentStringConcat() && getToken(1).image.startsWith("'")) { + body.append('\n').append(getNextToken().image); + } + return body.toString(); } -DomainConstraint DomainConstraint(boolean allowNull): -{ DomainConstraint result = new DomainConstraint(); String name; Expression expression; } -{ - [ name=RelObjectName() { result.setName(name); } ] - ( - { result.setKind(DomainConstraint.Kind.NOT_NULL); } - | { requireTypeDdlSyntax(allowNull, "ALTER DOMAIN ADD does not accept NULL"); result.setKind(DomainConstraint.Kind.NULL); } - | "(" expression=Expression() ")" - { result.setKind(DomainConstraint.Kind.CHECK); result.setExpression(expression); } - ) - { return result; } -} +/** +* Reads the tokens of a Postgres dollar quoted string, + rebuilding the white space of the text based on each token's position and length + 1) $$...$$ + 2) $tag$...$tag$ +*/ -CreateDomain CreateDomain(): -{ CreateDomain result = new CreateDomain(); String name; ColDataType type; Expression expression; DomainConstraint constraint; } -{ - name=TypeDdlName() { result.setName(name); } - [ { result.setUseAs(true); } ] type=ColDataType() { result.setDataType(type); } - [ name=TypeDdlName() { result.setCollation(name); } ] - [ expression=Expression() { result.setDefaultExpression(expression); } ] - ( constraint=DomainConstraint(true) { result.getConstraints().add(constraint); } )* - { return result; } -} +JAVACODE +String getQuotedString(String closingQuote, String escapeChar) { + StringBuilder buffer = new StringBuilder(); + Deque windowQueue = new ArrayDeque(); + int delimiterLength = closingQuote.length(); -AlterDomain AlterDomain(): -{ AlterDomain result = new AlterDomain(); String name; Expression expression; DomainConstraint constraint; } -{ - name=TypeDdlName() { result.setName(name); } - ( - - ( - expression=Expression() { result.setAction(AlterDomain.Action.SET_DEFAULT); result.setDefaultExpression(expression); } - | { result.setAction(AlterDomain.Action.SET_NOT_NULL); } - | name=RelObjectName() { result.setAction(AlterDomain.Action.SET_SCHEMA); result.setNewName(name); } - ) - | - ( - { result.setAction(AlterDomain.Action.DROP_DEFAULT); } - | { result.setAction(AlterDomain.Action.DROP_NOT_NULL); } - | [ LOOKAHEAD(2) { result.setIfExists(true); } ] - name=RelObjectName() { result.setAction(AlterDomain.Action.DROP_CONSTRAINT); result.setConstraintName(name); } - [ { result.setBehavior(AlterDomain.Behavior.CASCADE); } - | { result.setBehavior(AlterDomain.Behavior.RESTRICT); } ] - ) - | constraint=DomainConstraint(false) { result.setAction(AlterDomain.Action.ADD_CONSTRAINT); result.setConstraint(constraint); } - [ TypeDdlKeyword("VALID") { - requireTypeDdlSyntax(constraint.getKind() == DomainConstraint.Kind.CHECK, "NOT VALID requires a CHECK constraint"); - result.setNotValid(true); - } ] - | - ( - name=RelObjectName() { result.setConstraintName(name); } - name=RelObjectName() { result.setNewName(name); result.setAction(AlterDomain.Action.RENAME_CONSTRAINT); } - | name=RelObjectName() { result.setNewName(name); result.setAction(AlterDomain.Action.RENAME); } - ) - | - name=RelObjectName() { result.setConstraintName(name); result.setAction(AlterDomain.Action.VALIDATE_CONSTRAINT); } - | LOOKAHEAD({ isKeywordAhead("OWNER") }) TypeDdlKeyword("OWNER") - name=RelObjectName() { result.setNewName(name); result.setAction(AlterDomain.Action.OWNER); } - ) - { return result; } + Token prevToken = null; + Token token; + + while (true) { + token = getNextToken(); + if (token.kind == 0) { + throw new ParseException("Unterminated quoted string"); + } + appendWhitespaceFromTokenGap(buffer, prevToken, token); + appendTokenImageAndTrackDelimiter(buffer, windowQueue, delimiterLength, token.image, closingQuote); + if (endsWithDelimiter(windowQueue, closingQuote)) { + buffer.setLength(buffer.length() - delimiterLength); + return buffer.toString(); + } + prevToken = token; + } } -/** - * DuckDB 2.0's CREATE EXTENSION REPOSITORY [IF NOT EXISTS] name [WITH PREFIX prefix]. - */ -CreateExtensionRepository CreateExtensionRepository() #CreateExtensionRepository: +JAVACODE +String getQuotedIdentifier(String openingQuote, String closingQuote, String escapeChar) { + return openingQuote + getQuotedString(closingQuote, escapeChar) + closingQuote; +} + + +JAVACODE +List captureUnsupportedStatementDeclaration() { + List tokens = new LinkedList(); + Token tok; + + while(true) { + tok = getToken(1); + if( tok.kind == EOF || tok.kind== ST_SEMICOLON || tok.kind== K_END ) { + break; + } + tokens.add(tok.image); + tok = getNextToken(); + } + return tokens; +} + +String IdentifierChain(): { - CreateExtensionRepository createExtensionRepository = new CreateExtensionRepository(); - Expression prefix; - String name; + String identifierChain; + String part; } { - TypeDdlKeyword("EXTENSION") TypeDdlKeyword("REPOSITORY") - [ LOOKAHEAD(3) - { createExtensionRepository.setIfNotExists(true); } ] - name=RelObjectName() { createExtensionRepository.setName(name); } - // greedy: WITH PREFIX belongs to the repository definition - [ - LOOKAHEAD(2) TypeDdlKeyword("PREFIX") prefix=SimpleExpression() - { createExtensionRepository.setPrefix(prefix); } - ] - { return createExtensionRepository; } + identifierChain=RelObjectNameExt() + ( LOOKAHEAD(2) "." part=RelObjectNameExt() { identifierChain += "." + part; } )* + + { + return identifierChain; + } } -CreateExtension CreateExtension(): -{ CreateExtension result = new CreateExtension(); String name; Expression version; } +String IdentifierChain2(String identifierChain): { - TypeDdlKeyword("EXTENSION") - [ LOOKAHEAD(3) { result.setIfNotExists(true); } ] - name=RelObjectName() { result.setName(name); } - [ LOOKAHEAD(1) { result.setUseWith(true); } ] - ( - name=RelObjectName() { result.getOptions().add(new CreateExtension.Option(CreateExtension.OptionKind.SCHEMA, name, null)); } - | version=ExtensionVersion() { result.getOptions().add(new CreateExtension.Option(CreateExtension.OptionKind.VERSION, null, version)); } - | { result.getOptions().add(new CreateExtension.Option(CreateExtension.OptionKind.CASCADE, null, null)); } - )* - { return result; } + String part; +} +{ + ( LOOKAHEAD(2) "." part=RelObjectNameExt() { identifierChain += "." + part; } )* + { + return identifierChain; + } } -RoutineReference.Argument RoutineSignatureArgument(): -{ RoutineReference.Argument argument; } -{ argument=RoutineArgument(true) { return argument; } } - -/** Common argument AST; only extension aggregate signatures may end a type at ORDER BY. */ -RoutineReference.Argument RoutineArgument(boolean allowOrderBy): -{ RoutineReference.Argument result = new RoutineReference.Argument(); String name; Token mode; ColDataType type; } +Expression CharacterPrimary(): +{ + Expression expression; +} { - [ - LOOKAHEAD({ isKeywordAhead("IN") || isKeywordAhead("OUT") || isKeywordAhead("INOUT") || isKeywordAhead("VARIADIC") }) - ( { result.setMode(RoutineReference.Argument.Mode.IN); } - | mode= { result.setMode(allowOrderBy - ? typeDdlEnum(RoutineReference.Argument.Mode.class, mode.image) - : accessEnum(RoutineReference.Argument.Mode.class, mode.image)); } ) - ] ( - LOOKAHEAD(ColDataType() ("," | ")" | )) type=ColDataType() - | name=RelObjectName() { result.setName(name); } type=ColDataType() + expression = TranscodingFunction() + | + expression = TrimFunction() ) + // @todo + // @see https://manticore-projects.com/SQL2016Parser/syntax.html#character-value-function + // | character_substring_function + // | regular_expression_substring_function + // | regex_substring_function + // | fold + // | character_transliteration + // | regex_transliteration + // | character_overlay_function + // | normalize_function + // | specific_type_method + { - requireAccessSyntax(allowOrderBy || getToken(1).kind != K_ORDER, - "ORDER BY requires an aggregate signature"); - result.setDataType(type); - return result; + return expression; } } -RoutineReference RoutineReference(boolean aggregate): +TranscodingFunction TranscodingFunction() #TranscodingFunction : { - RoutineReference result = new RoutineReference(); String name; RoutineReference.Argument argument; - List arguments; List orderBy; + Token keywordToken; + TranscodingFunction transcodingFunction; + ColDataType colDataType; + Expression expression; + String transcodingName=null; + Token style; } { - name=TypeDdlName() { result.setName(name); } - [ - LOOKAHEAD(1) - "(" { arguments = new ArrayList(); result.setArguments(arguments); } + ( keywordToken= | keywordToken= | keywordToken= ) + "(" + ( + LOOKAHEAD(4, { !Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) }) + colDataType = ColDataType() + "," expression = Expression() + [ "," style = { transcodingName = style.image; } ] + + { + transcodingFunction = new TranscodingFunction(keywordToken.image, colDataType, expression, transcodingName); + } + | ( - "*" { requireTypeDdlSyntax(aggregate, "Only aggregate signatures accept *"); result.setAllArguments(true); } - | - [ argument=RoutineSignatureArgument() { arguments.add(argument); } - ( "," argument=RoutineSignatureArgument() { arguments.add(argument); } )* ] - [ { requireTypeDdlSyntax(aggregate, "ORDER BY requires an aggregate signature"); orderBy = new ArrayList(); } - argument=RoutineSignatureArgument() { orderBy.add(argument); } - ( "," argument=RoutineSignatureArgument() { orderBy.add(argument); } )* - { result.setOrderByArguments(orderBy); } ] + expression = Expression() + ( + transcodingName=IdentifierChain() + { transcodingFunction = new TranscodingFunction(keywordToken.image, expression, transcodingName); } + | + "," colDataType=ColDataType() + { transcodingFunction = new TranscodingFunction(keywordToken.image, colDataType, expression, null) + .setSyntax(TranscodingFunction.Syntax.TYPE_LAST); } + ) ) - ")" - ] - { requireTypeDdlSyntax(!aggregate || result.getArguments() != null, "An aggregate signature is required"); return result; } + ) + ")" + { + return transcodingFunction; + } } -String ExtensionOperatorName(): -{ String schema = null; String operator = ""; Token token; } +TrimFunction TrimFunction(): { - [ LOOKAHEAD(RelObjectName() ".") schema=RelObjectName() "." ] - ( token="+" | token="-" | token="*" | token="/" | token="%" | token="=" - | token= | token= | token="<" | token=">" - | token= | token= | token="&&" | token="@>" | token="<@" | token="~" - | token="~*" | token="!~" | token="!~*" | token="?" | token="?|" | token="?&" - | token= ) - { operator = token.image; return (schema == null ? "" : schema + ".") + operator; } + TrimFunction.TrimSpecification trimSpecification=null; + Expression expression = null; + boolean usesFrom = false; + Expression fromExpression = null; } +{ + "(" + [ + LOOKAHEAD(2) ( + { trimSpecification = TrimFunction.TrimSpecification.LEADING; } + | + { trimSpecification = TrimFunction.TrimSpecification.TRAILING; } + | + { trimSpecification = TrimFunction.TrimSpecification.BOTH; } + ) + ] -ColDataType ExtensionOperatorType(): -{ ColDataType type = null; } -{ ( | type=ColDataType() ) { return type; } } + // This is not SQL:2016 compliant, but Postgres supports it + [ expression = Expression() ] -ExtensionObject ExtensionObject(): -{ - ExtensionObject result = new ExtensionObject(); String name; String kind; - RoutineReference routine; ColDataType type; -} -{ - ( - LOOKAHEAD({ isKeywordAhead("FUNCTION") || isKeywordAhead("PROCEDURE") || isKeywordAhead("ROUTINE") || isKeywordAhead("AGGREGATE") }) - ( LOOKAHEAD(1) { kind = "PROCEDURE"; } | kind=RelObjectName() ) - routine=RoutineReference("AGGREGATE".equalsIgnoreCase(kind)) - { result.setKind(typeDdlEnum(ExtensionObject.Kind.class, kind)); result.setRoutine(routine); } - | LOOKAHEAD({ isKeywordAhead("CAST") }) "(" - type=ColDataType() { result.setSourceType(type); } - type=ColDataType() { result.setTargetType(type); } ")" { result.setKind(ExtensionObject.Kind.CAST); } - | LOOKAHEAD({ isKeywordAhead("OPERATOR") && !"CLASS".equalsIgnoreCase(getToken(2).image) && !"FAMILY".equalsIgnoreCase(getToken(2).image) }) - TypeDdlKeyword("OPERATOR") name=ExtensionOperatorName() "(" - type=ExtensionOperatorType() { result.setSourceType(type); } "," - type=ExtensionOperatorType() { result.setTargetType(type); } ")" - { result.setKind(ExtensionObject.Kind.OPERATOR); result.setName(name); } - | LOOKAHEAD({ isKeywordAhead("TRANSFORM") }) TypeDdlKeyword("TRANSFORM") - type=ColDataType() { result.setSourceType(type); } TypeDdlKeyword("LANGUAGE") - name=RelObjectName() { result.setLanguage(name); result.setKind(ExtensionObject.Kind.TRANSFORM); } - | + [ ( - - ( { kind = "FOREIGN_TABLE"; } - | TypeDdlKeyword("WRAPPER") { kind = "FOREIGN_DATA_WRAPPER"; } ) - | LOOKAHEAD(2) { kind = "MATERIALIZED_VIEW"; } - | LOOKAHEAD({ isKeywordAhead("TEXT") }) - name=RelObjectName() { kind = "TEXT_SEARCH_" + name; } - | LOOKAHEAD({ isKeywordAhead("EVENT") }) { kind = "EVENT_TRIGGER"; } - | LOOKAHEAD({ isKeywordAhead("ACCESS") }) TypeDdlKeyword("ACCESS") TypeDdlKeyword("METHOD") { kind = "ACCESS_METHOD"; } - | LOOKAHEAD({ isKeywordAhead("OPERATOR") }) TypeDdlKeyword("OPERATOR") - name=RelObjectName() { kind = "OPERATOR_" + name; } - | LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) TypeDdlKeyword("PROCEDURAL") TypeDdlKeyword("LANGUAGE") - { result.setProcedural(true); kind = "LANGUAGE"; } - | kind=RelObjectName() + "," + | + { usesFrom = true; } ) - { result.setKind(typeDdlEnum(ExtensionObject.Kind.class, kind)); } - name=TypeDdlName() { result.setName(name); } - [ name=RelObjectName() { result.setAccessMethod(name); } ] - ) + fromExpression = Expression() + ] + ")" + { - requireTypeDdlSyntax((result.getKind() == ExtensionObject.Kind.OPERATOR_CLASS || result.getKind() == ExtensionObject.Kind.OPERATOR_FAMILY) - == (result.getAccessMethod() != null), "USING is required only for operator classes and families"); - return result; + return new TrimFunction(trimSpecification, expression, fromExpression, usesFrom); } } -AlterExtension AlterExtension(): -{ AlterExtension result = new AlterExtension(); String name; Expression version; ExtensionObject member; } +void SnowflakeTimeTravelAt(StringBuilder builder): { - TypeDdlKeyword("EXTENSION") name=RelObjectName() { result.setName(name); } + Expression expression; + Token tk; +} +{ + // AT( { TIMESTAMP => | OFFSET => | STATEMENT => | STREAM => '' } ) + + { builder.append("AT ("); } ( - { result.setAction(AlterExtension.Action.UPDATE); } - [ version=ExtensionVersion() { result.setVersion(version); } ] - | name=RelObjectName() { result.setAction(AlterExtension.Action.SET_SCHEMA); result.setSchema(name); } - | ( { result.setAction(AlterExtension.Action.ADD); } | { result.setAction(AlterExtension.Action.DROP); } ) - member=ExtensionObject() { result.setMember(member); } + //@fixme: this should be TIMESTAMP only but JavaCC-8 has issues with compound tokens! + "=>" expression = Expression() + { builder.append( "TIMESTAMP => ").append(expression.toString()); } + | + "=>" expression = Expression() + { builder.append( "OFFSET => ").append(expression.toString()); } + | + "=>" ( tk=| tk= | tk= ) + { builder.append( "STATEMENT => ").append(tk.image); } + | + "=>" tk= + { builder.append( "STREAM => ").append(tk.image); } ) - { return result; } + { builder.append(")"); } } -void ReplicationKeyword(String expected): -{ Token token; } -{ token= { requireReplicationSyntax(expected.equalsIgnoreCase(token.image), "Expected " + expected); } } -Expression ReplicationOptionValue(): -{ Token token; Expression result; } +void SnowflakeTimeTravelBefore(StringBuilder builder): { - ( LOOKAHEAD(1) token= { result = new Column(token.image); } | result=PrimaryExpression() ) - { return result; } + Expression expression; + Token tk; } - -PublicationOption PublicationOption(): -{ String name; Expression value = null; } { - name=RelObjectName() [ "=" value=ReplicationOptionValue() ] - { return new PublicationOption(name, replicationEnum(PublicationOption.Kind.class, name), value); } + // BEFORE( STATEMENT => ) + + { builder.append("BEFORE ("); } + "=>" ( tk=| tk= | tk= ) + { builder.append( "STATEMENT => ").append(tk.image); } + { builder.append(")"); } } -List PublicationOptions(): -{ List options = new ArrayList(); PublicationOption option; } +void SnowflakeTimeTravelChange(StringBuilder builder): { - "(" option=PublicationOption() { options.add(option); } - ( "," option=PublicationOption() { options.add(option); } )* ")" - { return options; } + Expression expression; + Token tk; } - -SubscriptionOption SubscriptionOption(): -{ String name; Expression value = null; } { - name=RelObjectName() [ "=" value=ReplicationOptionValue() ] - { return new SubscriptionOption(name, replicationEnum(SubscriptionOption.Kind.class, name), value); } + /* + CHANGES ( INFORMATION => { DEFAULT | APPEND_ONLY } ) + AT ( { TIMESTAMP => | OFFSET => | STATEMENT => | STREAM => '' } ) + | + BEFORE ( STATEMENT => ) + [ END( { TIMESTAMP => | OFFSET => | STATEMENT => } ) ] + */ + + "=>" + { builder.append("CHANGES (INFORMATION => ");} + + ( tk = | tk=) + { builder.append(tk.image); } + + { builder.append(") "); } + + ( + SnowflakeTimeTravelAt(builder) + | + SnowflakeTimeTravelBefore(builder) + ) + + [ + LOOKAHEAD(2) + { builder.append(" END ("); } + + ( + //@fixme: this should be TIMESTAMP only but JavaCC-8 has issues with compound tokens! + "=>" expression = Expression() + { builder.append( "TIMESTAMP => ").append(expression.toString()); } + | + "=>" expression = Expression() + { builder.append( "OFFSET => ").append(expression.toString()); } + | + "=>" ( tk=| tk= | tk= ) + { builder.append( "STATEMENT => ").append(tk.image); } + ) + + { builder.append(")"); } + ] } -List SubscriptionOptions(): -{ List options = new ArrayList(); SubscriptionOption option; } +void DataBricksTemporalSpec(StringBuilder builder): { - "(" option=SubscriptionOption() { options.add(option); } - ( "," option=SubscriptionOption() { options.add(option); } )* ")" - { return options; } + Token tk; + Expression expression; } - -PublicationTable PublicationTable(boolean drop): -{ PublicationTable result = new PublicationTable(); Table table; String name; Expression expression; ExpressionList columns; } { - [ { result.setOnly(true); } ] - table=Table() { result.setTable(table); } - [ "*" { result.setIncludeDescendants(true); } ] - [ LOOKAHEAD(1) "(" { columns = new ExpressionList(); } - name=RelObjectName() { columns.add(createColumn(name)); } - ( "," name=RelObjectName() { columns.add(createColumn(name)); } )* ")" - { result.setColumns(columns); } ] - [ "(" expression=Expression() ")" { result.setWhere(expression); } ] + /* + temporal_spec https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-names#syntax-3 { - requireReplicationSyntax(!(result.isOnly() && result.isIncludeDescendants()), "ONLY and * cannot be combined"); - requireReplicationSyntax(!drop || (result.getColumns() == null && result.getWhere() == null), "DROP publication tables cannot have column lists or filters"); - return result; + @ timestamp_encoding | + @V version | + [ FOR ] { SYSTEM_TIMESTAMP | TIMESTAMP } AS OF timestamp_expression | + [ FOR ] { SYSTEM_VERSION | VERSION } AS OF version } -} + */ + (tk= | tk=) { builder.append(tk.image).append(" "); } + (tk= | tk=) { builder.append(tk.image); } + | + [ { builder.append(" FOR"); } ] -PublicationTarget PublicationTarget(boolean drop): -{ PublicationTarget result = new PublicationTarget(); PublicationTable table; String schema; } -{ + ( tk= | tk= ) + expression=Expression() + { builder.append(" ").append(tk.image).append(" AS OF ").append(expression.toString()); } + | ( - { result.setKind(PublicationTarget.Kind.TABLE); } - table=PublicationTable(drop) { result.getTables().add(table); } - ( LOOKAHEAD({ getToken(1).image.equals(",") && getToken(2).kind != K_TABLE && getToken(2).kind != K_TABLES }) - "," table=PublicationTable(drop) { result.getTables().add(table); } )* - | - { result.setKind(PublicationTarget.Kind.TABLES_IN_SCHEMA); } - schema=RelObjectName() { result.getSchemas().add(schema); } - ( LOOKAHEAD({ getToken(1).image.equals(",") && getToken(2).kind != K_TABLE && getToken(2).kind != K_TABLES }) - "," schema=RelObjectName() { result.getSchemas().add(schema); } )* + ( tk= | tk= ) { builder.append(" ").append(tk.image); } + (tk= | tk= ) { builder.append(" AS OF ").append(tk.image); } ) - { return result; } } -List PublicationTargets(boolean drop): -{ List targets = new ArrayList(); PublicationTarget target; } +void BigQueryHistoricalVersion(StringBuilder builder): { - target=PublicationTarget(drop) { targets.add(target); } - ( "," target=PublicationTarget(drop) { targets.add(target); } )* - { return targets; } + Token tk; + Expression expression; } - -CreatePublication CreatePublication(): -{ CreatePublication result = new CreatePublication(); String name; List targets; List options; } { - ReplicationKeyword("PUBLICATION") name=RelObjectName() { result.setName(name); } - [ - - ( { result.setAllTables(true); } - | targets=PublicationTargets(false) { result.setTargets(targets); } ) - ] - [ LOOKAHEAD(2) options=PublicationOptions() { result.setOptions(options); } ] - { return result; } + /* + FOR SYSTEM_TIME AS OF timestamp_expression + */ + expression=Expression() + { builder.append(" FOR SYSTEM_TIME AS OF ").append(expression.toString()); } } -AlterPublication AlterPublication(): -{ AlterPublication result = new AlterPublication(); String name; List targets; List options; boolean drop = false; } +String TimeTravelBeforeAlias(): +{ + StringBuilder builder = new StringBuilder(); +} { - ReplicationKeyword("PUBLICATION") name=RelObjectName() { result.setName(name); } ( - LOOKAHEAD({ isKeywordAhead("OWNER") }) ReplicationKeyword("OWNER") - name=RelObjectName() { result.setNewName(name); result.setAction(AlterPublication.Action.OWNER); } - | name=RelObjectName() { result.setNewName(name); result.setAction(AlterPublication.Action.RENAME); } - | LOOKAHEAD( "(") options=PublicationOptions() { result.setOptions(options); result.setAction(AlterPublication.Action.SET_OPTIONS); } - | ( { result.setAction(AlterPublication.Action.ADD); } - | { result.setAction(AlterPublication.Action.SET); } - | { result.setAction(AlterPublication.Action.DROP); drop = true; } ) - targets=PublicationTargets(drop) { result.setTargets(targets); } + SnowflakeTimeTravelAt(builder) + | + SnowflakeTimeTravelBefore(builder) + | + SnowflakeTimeTravelChange(builder) + | + DataBricksTemporalSpec(builder) ) - { return result; } -} -List SubscriptionPublications(): -{ List names = new ArrayList(); String name; } -{ - name=RelObjectName() { names.add(name); } - ( "," name=RelObjectName() { names.add(name); } )* - { return names; } + { + return builder.toString(); + } } -CreateSubscription CreateSubscription(): -{ CreateSubscription result = new CreateSubscription(); String name; Token connection; List publications; List options; } +String TimeTravelAfterAlias(): { - ReplicationKeyword("SUBSCRIPTION") name=RelObjectName() { result.setName(name); } - ReplicationKeyword("CONNECTION") connection= { result.setConnection(new StringValue(connection.image)); } - ReplicationKeyword("PUBLICATION") publications=SubscriptionPublications() { result.setPublications(publications); } - [ LOOKAHEAD(2) options=SubscriptionOptions() { result.setOptions(options); } ] - { return result; } + StringBuilder builder = new StringBuilder(); } - -AlterSubscription AlterSubscription(): -{ AlterSubscription result = new AlterSubscription(); String name; Token connection; List publications; List options; } { - ReplicationKeyword("SUBSCRIPTION") name=RelObjectName() { result.setName(name); } - ( - LOOKAHEAD({ isKeywordAhead("CONNECTION") }) ReplicationKeyword("CONNECTION") - connection= { result.setConnection(new StringValue(connection.image)); result.setAction(AlterSubscription.Action.CONNECTION); } - | LOOKAHEAD({ isKeywordAhead("OWNER") }) ReplicationKeyword("OWNER") - name=RelObjectName() { result.setNewName(name); result.setAction(AlterSubscription.Action.OWNER); } - | name=RelObjectName() { result.setNewName(name); result.setAction(AlterSubscription.Action.RENAME); } - | { result.setAction(AlterSubscription.Action.ENABLE); } - | { result.setAction(AlterSubscription.Action.DISABLE); } - | options=SubscriptionOptions() { - requireReplicationSyntax(options.size() == 1 && options.get(0).getKind() == SubscriptionOption.Kind.LSN - && options.get(0).getValue() != null, "SKIP requires one lsn = value option"); - result.setOptions(options); result.setAction(AlterSubscription.Action.SKIP); - } - | LOOKAHEAD( "(") options=SubscriptionOptions() { result.setOptions(options); result.setAction(AlterSubscription.Action.SET_OPTIONS); } - | ReplicationKeyword("PUBLICATION") { result.setAction(AlterSubscription.Action.REFRESH_PUBLICATION); } - [ LOOKAHEAD(2) options=SubscriptionOptions() { result.setOptions(options); } ] - | ( { result.setAction(AlterSubscription.Action.SET_PUBLICATION); } - | { result.setAction(AlterSubscription.Action.ADD_PUBLICATION); } - | { result.setAction(AlterSubscription.Action.DROP_PUBLICATION); } ) - ReplicationKeyword("PUBLICATION") publications=SubscriptionPublications() { result.setPublications(publications); } - [ LOOKAHEAD(2) options=SubscriptionOptions() { result.setOptions(options); } ] - ) - { return result; } + BigQueryHistoricalVersion(builder) + { + return builder.toString(); + } } -CreatePolicy CreatePolicy() #CreatePolicy: +CreateStatistics CreateStatistics(): { - CreatePolicy createPolicy = new CreatePolicy(); - String policyName; - Table table; - String policyMode = null; - Token commandToken = null; - String roleName; - Expression usingExpr = null; - Expression checkExpr = null; + CreateStatistics statement = new CreateStatistics(); + String name; CreateStatistics.Kind kind; Expression expression; Table table; } { - policyName=RelObjectName() { createPolicy.setPolicyName(policyName); } - table=Table() { createPolicy.setTable(table); } - - [ - LOOKAHEAD({ isKeywordAhead("PERMISSIVE") || isKeywordAhead("RESTRICTIVE") }) - policyMode=RelObjectName() - { createPolicy.setPolicyMode(PolicyMode.from(policyMode)); } - ] - - [ - ( commandToken= - | commandToken= - | commandToken= - | commandToken= - | commandToken= - ) - { createPolicy.setPolicyCommand(PolicyCommand.from(commandToken.image)); } - ] - - [ - roleName=RelObjectName() { createPolicy.addRole(roleName); } - ( "," roleName=RelObjectName() { createPolicy.addRole(roleName); } )* - ] - - [ "(" usingExpr=Expression() ")" { createPolicy.setUsingExpression(usingExpr); } ] - - [ LOOKAHEAD(2) "(" checkExpr=Expression() ")" { createPolicy.setWithCheckExpression(checkExpr); } ] - + ContextualKeyword("STATISTICS") + [ LOOKAHEAD(2) { statement.setIfNotExists(true); } ] + [ LOOKAHEAD({ getToken(1).kind != K_ON && getToken(1).kind != OPENING_BRACKET }) + name=TypeDdlName() { statement.setName(name); } ] + [ "(" name=RelObjectName() { kind=accessEnum(CreateStatistics.Kind.class,name); statement.getKinds().add(kind); } + ( "," name=RelObjectName() { kind=accessEnum(CreateStatistics.Kind.class,name); + requireDdlSyntax(!statement.getKinds().contains(kind),"Duplicate statistics kind"); statement.getKinds().add(kind); } )* ")" ] + expression=PostgreSqlStatisticsExpression() { statement.getExpressions().add(expression); } + ( "," expression=PostgreSqlStatisticsExpression() { statement.getExpressions().add(expression); } )* + table=Table() { statement.setTable(table); } { - - return createPolicy; + requireDdlSyntax(!statement.isIfNotExists() || statement.getName()!=null,"IF NOT EXISTS requires a statistics name"); + requireDdlSyntax(statement.getExpressions().size()>1 || statement.getKinds().isEmpty() + && statement.getExpressions().get(0) instanceof ParenthesedExpressionList, + "Single-expression statistics require a parenthesized expression and no explicit kinds"); + return statement; } } +Expression PostgreSqlStatisticsExpression(): +{ Expression expression; String name; Token open; } +{ + ( open="(" expression=Expression() ")" { expression = new ParenthesedExpressionList(expression); linkAST((ASTNodeAccess) expression, open); } + | name=RelObjectName() { expression = linkToLastToken(createColumn(name)); } ) + { return expression; } +} +AlterStatistics AlterStatistics(): +{ AlterStatistics statement = new AlterStatistics(); String name; Long target; } +{ + ContextualKeyword("STATISTICS") name=TypeDdlName() { statement.setName(name); } + ( name=RelObjectName() { statement.setAction(AlterStatistics.Action.RENAME); statement.setNewName(name); } + | ContextualKeyword("OWNER") name=RelObjectName() { statement.setAction(AlterStatistics.Action.OWNER); statement.setOwner(name); } + | ( name=RelObjectName() { statement.setAction(AlterStatistics.Action.SET_SCHEMA); statement.setSchemaName(name); } + | ContextualKeyword("STATISTICS") { statement.setAction(AlterStatistics.Action.SET_STATISTICS); } + ( | target=SequenceParameterValue() { + requireDdlSyntax(target>=-1 && target<=10000,"Statistics target must be DEFAULT or between -1 and 10000"); + statement.setStatistics(target.intValue()); } ) ) ) + { return statement; } +} -UnsupportedStatement UnsupportedStatement(): +CreateForeignDataWrapper CreateForeignDataWrapper(): { - List tokens = new LinkedList(); + CreateForeignDataWrapper statement = new CreateForeignDataWrapper(); + String name; ForeignDataWrapperFunctions functions; List options; } { - tokens=captureUnsupportedStatementDeclaration() - { - return new UnsupportedStatement(tokens); - } + ContextualKeyword("WRAPPER") name=RelObjectName() + functions=ForeignDataWrapperFunctions() + { statement.setName(name); statement.setFunctions(functions); } + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ForeignDataOptions(false) { statement.setOptions(options); } ] + { return statement; } } -JAVACODE -List captureRest() { - List tokens = new LinkedList(); - Token tok; - while(true) { - tok = getToken(1); - int l = tokens.size(); - if( tok.kind == EOF || tok.kind == ST_SEMICOLON ) { - break; - } else if ( l>0 && ( tok.image.equals(".") || tokens.get(l-1).endsWith(".")) ) { - tokens.set(l-1, tokens.get(l-1) + tok.image); - } else { - tokens.add(tok.image); - } - tok = getNextToken(); - } - return tokens; +AlterForeignDataWrapper AlterForeignDataWrapper(): +{ + AlterForeignDataWrapper statement = new AlterForeignDataWrapper(); + String name; ForeignDataWrapperFunctions functions; List options; +} +{ + ContextualKeyword("WRAPPER") name=RelObjectName() { statement.setName(name); } + ( + name=RelObjectName() + { statement.setAction(ForeignObjectAlterAction.RENAME); statement.setNewName(name); } + | LOOKAHEAD({ isKeywordAhead("OWNER") }) ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(ForeignObjectAlterAction.OWNER); statement.setOwner(name); } + | functions=ForeignDataWrapperFunctions() { statement.setFunctions(functions); } + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ForeignDataOptions(true) { statement.setOptions(options); } ] + { requireDdlSyntax(functions.isHandlerSpecified() || functions.isValidatorSpecified() + || statement.getOptions() != null, "ALTER FOREIGN DATA WRAPPER requires an action"); } + ) + { return statement; } } -/** - * Captures opaque routine declarations through their terminating semicolon. - * PostgreSQL AS string bodies can use ordinary, escape or dollar quotes. - * Strings and END tokens in parenthesized arguments are not body boundaries. - */ - -JAVACODE -List captureFunctionBody() { - List tokens = new LinkedList(); - Token tok; - boolean foundEnd = false; - boolean bodyStarted = false; - int parentheses = 0; - while(true) { - tok = getToken(1); - int l = tokens.size(); - if( tok.kind == EOF || ( foundEnd && tok.kind == ST_SEMICOLON) ) { - if (tok.kind == ST_SEMICOLON) { - tokens.add(tok.image); - } - break; - } else if (parentheses == 0 && !bodyStarted && tok.kind == K_AS - && getToken(2).kind == S_CHAR_LITERAL) { - tokens.add(getNextToken().image); - tokens.add(captureRoutineBodyLiteral()); - foundEnd = true; - bodyStarted = true; - continue; - } else if ( l>0 && ( tok.image.equals(".") || tokens.get(l-1).endsWith(".")) ) { - tokens.set(l-1, tokens.get(l-1) + tok.image); - } else { - tokens.add(tok.image); - } - foundEnd |= parentheses == 0 && tok.kind == K_END; - if (parentheses == 0 && (tok.kind == K_AS || tok.kind == K_BEGIN)) bodyStarted = true; - if (tok.kind == OPENING_BRACKET) parentheses++; - if (tok.kind == CLOSING_BRACKET) parentheses--; - - tok = getNextToken(); - } - return tokens; +ForeignDataWrapperFunctions ForeignDataWrapperFunctions(): +{ + ForeignDataWrapperFunctions functions = new ForeignDataWrapperFunctions(); + String name; boolean handler; +} +{ + ( LOOKAHEAD({ isKeywordAhead("HANDLER") || isKeywordAhead("VALIDATOR") || getToken(1).kind == K_NO }) + { name = null; } + ( + + ( { handler = true; } + | ContextualKeyword("VALIDATOR") { handler = false; } ) + | + ( { handler = true; } + | ContextualKeyword("VALIDATOR") { handler = false; } ) + name=AccessQualifiedName() + ) + { + if (handler) { + requireDdlSyntax(!functions.isHandlerSpecified(), "Duplicate HANDLER clause"); functions.setHandler(name); + } else { + requireDdlSyntax(!functions.isValidatorSpecified(), "Duplicate VALIDATOR clause"); functions.setValidator(name); + } + } + )* + { return functions; } } -/** - * Keeps the separator required by PostgreSQL's continued string literals. - * The routine's legacy token list otherwise renders every gap as one space. - */ -JAVACODE -String captureRoutineBodyLiteral() { - String literal = getNextToken().image; - if (literal.startsWith("$") || !isAdjacentStringConcat()) { - return literal; - } - StringBuilder body = new StringBuilder(literal); - while (isAdjacentStringConcat() && getToken(1).image.startsWith("'")) { - body.append('\n').append(getNextToken().image); +CreateServer CreateServer(): +{ + CreateServer statement = new CreateServer(); String name; Token type; + Expression version; List options; +} +{ + ContextualKeyword("SERVER") + [ LOOKAHEAD(2) { statement.setIfNotExists(true); } ] + name=ServerObjectName() { statement.setName(name); } + [ type= { statement.setType(stringValue(type)); } ] + [ version=ForeignServerVersion() { statement.setVersion(version); } ] + ContextualKeyword("WRAPPER") name=ServerObjectName() { statement.setForeignDataWrapper(name); } + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ServerOptions(false) { statement.setOptions(options); } ] + { + // MySQL: CREATE SERVER name FOREIGN DATA WRAPPER wrapper OPTIONS (option[, ...]) + requireDdlSyntax(!Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + || !statement.isIfNotExists() && statement.getType() == null && statement.getVersion() == null + && statement.getOptions() != null, + "MySQL CREATE SERVER takes a name, FOREIGN DATA WRAPPER and OPTIONS"); + return statement; } - return body.toString(); } -/** -* Reads the tokens of a Postgres dollar quoted string, - rebuilding the white space of the text based on each token's position and length - 1) $$...$$ - 2) $tag$...$tag$ -*/ - -JAVACODE -String getQuotedString(String closingQuote, String escapeChar) { - StringBuilder buffer = new StringBuilder(); - Deque windowQueue = new ArrayDeque(); - int delimiterLength = closingQuote.length(); +/** A server or wrapper name; MySQL's ident_or_text also takes a string literal, kept as written. */ +String ServerObjectName(): +{ String name; Token token; } +{ + ( name=RelObjectName() + | token= { + requireDdlSyntax(isMySqlServerSyntaxAllowed() && isMySqlTextString(new StringValue(token.image)), + "Expected a name but found " + token.image); + name = token.image; + } ) + { return name; } +} - Token prevToken = null; - Token token; +Expression ForeignServerVersion(): +{ Token value; Expression version; } +{ + ( value= { version = stringValue(value); } + | { version = new NullValue(); } ) + { return version; } +} - while (true) { - token = getNextToken(); - if (token.kind == 0) { - throw new ParseException("Unterminated quoted string"); - } - appendWhitespaceFromTokenGap(buffer, prevToken, token); - appendTokenImageAndTrackDelimiter(buffer, windowQueue, delimiterLength, token.image, closingQuote); - if (endsWithDelimiter(windowQueue, closingQuote)) { - buffer.setLength(buffer.length() - delimiterLength); - return buffer.toString(); - } - prevToken = token; +AlterServer AlterServer(): +{ + AlterServer statement = new AlterServer(); String name; + Expression version; List options; +} +{ + ContextualKeyword("SERVER") name=ServerObjectName() { statement.setName(name); } + ( + name=RelObjectName() + { statement.setAction(ForeignObjectAlterAction.RENAME); statement.setNewName(name); } + | LOOKAHEAD({ isKeywordAhead("OWNER") }) ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(ForeignObjectAlterAction.OWNER); statement.setOwner(name); } + | [ version=ForeignServerVersion() { statement.setVersion(version); } ] + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ServerOptions(true) { statement.setOptions(options); } ] + { requireDdlSyntax(statement.getVersion() != null || statement.getOptions() != null, + "ALTER SERVER requires VERSION or OPTIONS"); } + ) + { + // MySQL: ALTER SERVER name OPTIONS (option[, ...]) + requireDdlSyntax(!Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + || statement.getAction() == ForeignObjectAlterAction.OPTIONS && statement.getVersion() == null, + "MySQL ALTER SERVER takes OPTIONS"); + return statement; } } -JAVACODE -String getQuotedIdentifier(String openingQuote, String closingQuote, String escapeChar) { - return openingQuote + getQuotedString(closingQuote, escapeChar) + closingQuote; +CreateUserMapping CreateUserMapping(): +{ + CreateUserMapping statement = new CreateUserMapping(); String name; List options; } - - -JAVACODE -List captureUnsupportedStatementDeclaration() { - List tokens = new LinkedList(); - Token tok; - - while(true) { - tok = getToken(1); - if( tok.kind == EOF || tok.kind== ST_SEMICOLON || tok.kind== K_END ) { - break; - } - tokens.add(tok.image); - tok = getNextToken(); - } - return tokens; +{ + ContextualKeyword("MAPPING") + [ LOOKAHEAD(2) { statement.setIfNotExists(true); } ] + name=RelObjectName() { statement.setUser(name); } + ContextualKeyword("SERVER") name=RelObjectName() { statement.setServer(name); } + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ForeignDataOptions(false) { statement.setOptions(options); } ] + { return statement; } } -String IdentifierChain(): +DropUserMapping DropUserMapping(): { - String identifierChain; - String part; + DropUserMapping statement = new DropUserMapping(); String name; } { - identifierChain=RelObjectNameExt() - ( LOOKAHEAD(2) "." part=RelObjectNameExt() { identifierChain += "." + part; } )* + ContextualKeyword("MAPPING") + [ LOOKAHEAD(2) { statement.setIfExists(true); } ] + name=RelObjectName() { statement.setUser(name); } + ContextualKeyword("SERVER") name=RelObjectName() { statement.setServer(name); } + { return statement; } +} - { - return identifierChain; - } +AlterUserMapping AlterUserMapping(): +{ + AlterUserMapping statement = new AlterUserMapping(); String name; List options; +} +{ + ContextualKeyword("MAPPING") name=RelObjectName() { statement.setUser(name); } + ContextualKeyword("SERVER") name=RelObjectName() { statement.setServer(name); } + options=ForeignDataOptions(true) { statement.setOptions(options); return statement; } } -String IdentifierChain2(String identifierChain): +CreateAccessMethod CreateAccessMethod(): { - String part; + CreateAccessMethod statement = new CreateAccessMethod(); + String name; } { - ( LOOKAHEAD(2) "." part=RelObjectNameExt() { identifierChain += "." + part; } )* - { - return identifierChain; - } + ContextualKeyword("ACCESS") ContextualKeyword("METHOD") name=RelObjectName() + { statement.setName(name); } + ( { statement.setType(CreateAccessMethod.Type.TABLE); } + | { statement.setType(CreateAccessMethod.Type.INDEX); } ) + name=AccessQualifiedName() + { statement.setHandler(name); return statement; } } -Expression CharacterPrimary(): +/** PostgreSQL CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE name [HANDLER ...]. */ +CreateLanguage CreateLanguage(boolean orReplace): { - Expression expression; + CreateLanguage statement = new CreateLanguage(); String name; +} +{ + { statement.setOrReplace(orReplace); } + [ LOOKAHEAD({ isKeywordAhead("TRUSTED") }) ContextualKeyword("TRUSTED") { statement.setTrusted(true); } ] + [ LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL") { statement.setProcedural(true); } ] + ContextualKeyword("LANGUAGE") name=RelObjectName() + { requireConversionName(name, false); statement.setName(name); } + [ LOOKAHEAD({ getToken(1).kind == K_HANDLER }) name=TypeDdlName() + { requireConversionName(name, false); statement.setHandler(name); } + [ LOOKAHEAD({ isKeywordAhead("INLINE") }) ContextualKeyword("INLINE") name=TypeDdlName() + { requireConversionName(name, false); statement.setInlineHandler(name); } ] + [ + LOOKAHEAD({ isKeywordAhead("VALIDATOR") }) ContextualKeyword("VALIDATOR") name=TypeDdlName() + { requireConversionName(name, false); statement.setValidator(name); } + | + ContextualKeyword("VALIDATOR") { statement.setNoValidator(true); } + ] + ] + { return statement; } } + +AlterLanguage AlterLanguage(): +{ AlterLanguage statement = new AlterLanguage(); String name; } { + [ LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL") { statement.setProcedural(true); } ] + ContextualKeyword("LANGUAGE") name=RelObjectName() + { requireConversionName(name, false); statement.setName(name); } ( - expression = TranscodingFunction() + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterLanguage.Action.RENAME); statement.setNewName(name); } | - expression = TrimFunction() + ContextualKeyword("OWNER") name=RelObjectName() + { requireConversionName(name, true); statement.setAction(AlterLanguage.Action.OWNER); statement.setOwner(name); } ) - // @todo - // @see https://manticore-projects.com/SQL2016Parser/syntax.html#character-value-function - // | character_substring_function - // | regular_expression_substring_function - // | regex_substring_function - // | fold - // | character_transliteration - // | regex_transliteration - // | character_overlay_function - // | normalize_function - // | specific_type_method - - { - return expression; - } + { return statement; } } -TranscodingFunction TranscodingFunction() #TranscodingFunction : +AlterLargeObject AlterLargeObject(): { - Token keywordToken; - TranscodingFunction transcodingFunction; - ColDataType colDataType; - Expression expression; - String transcodingName=null; - Token style; + AlterLargeObject statement = new AlterLargeObject(); String owner; + Token first; Token sign = null; Token number; Expression objectId; } { - ( keywordToken= | keywordToken= | keywordToken= ) - "(" + ContextualKeyword("LARGE") ContextualKeyword("OBJECT") { first = getToken(1); } + [ sign="+" | sign="-" ] ( - LOOKAHEAD(4, { !Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) }) - colDataType = ColDataType() - "," expression = Expression() - [ "," style = { transcodingName = style.image; } ] - - { - transcodingFunction = new TranscodingFunction(keywordToken.image, colDataType, expression, transcodingName); - } + number= { objectId = linkToLastToken(new LongValue(number.image)); } | - ( - expression = Expression() - ( - transcodingName=IdentifierChain() - { transcodingFunction = new TranscodingFunction(keywordToken.image, expression, transcodingName); } - | - "," colDataType=ColDataType() - { transcodingFunction = new TranscodingFunction(keywordToken.image, colDataType, expression, null) - .setSyntax(TranscodingFunction.Syntax.TYPE_LAST); } - ) - ) + number= { objectId = linkToLastToken(new DoubleValue(number.image)); } + | + number= { + requireDdlSyntax(number.image.regionMatches(true, 0, "0x", 0, 2), + "A large-object OID must be numeric, not a bit string"); + objectId = linkToLastToken(new HexValue(number.image)); + } ) - ")" { - return transcodingFunction; + if (sign != null) { + objectId = linked(new SignedExpression(sign.image.charAt(0), objectId), first); + } + statement.setLargeObjectId(objectId); } + ContextualKeyword("OWNER") owner=RelObjectName() + { requireConversionName(owner, true); statement.setOwner(owner); return statement; } } -TrimFunction TrimFunction(): -{ - TrimFunction.TrimSpecification trimSpecification=null; - Expression expression = null; - boolean usesFrom = false; - Expression fromExpression = null; -} -{ - "(" - [ - LOOKAHEAD(2) ( - { trimSpecification = TrimFunction.TrimSpecification.LEADING; } - | - { trimSpecification = TrimFunction.TrimSpecification.TRAILING; } - | - { trimSpecification = TrimFunction.TrimSpecification.BOTH; } - ) - ] - - // This is not SQL:2016 compliant, but Postgres supports it - [ expression = Expression() ] +Statement CreateTextSearchMetadata(): +{ Statement statement; } +{ + + ( + LOOKAHEAD({ isKeywordAhead("DICTIONARY") }) statement=CreateTextSearchDictionary() + | + LOOKAHEAD({ isKeywordAhead("PARSER") }) statement=CreateTextSearchParser() + | + statement=CreateTextSearchTemplate() + ) + { return statement; } +} - [ - ( - "," - | - { usesFrom = true; } - ) - fromExpression = Expression() - ] - ")" +CreateTextSearchDictionary CreateTextSearchDictionary(): +{ CreateTextSearchDictionary statement = new CreateTextSearchDictionary(); String name; List options; } +{ + ContextualKeyword("DICTIONARY") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + options=PostgreSqlDefinition() + { requireTextSearchDictionary(options); statement.setOptions(options); return statement; } +} - { - return new TrimFunction(trimSpecification, expression, fromExpression, usesFrom); - } +CreateTextSearchParser CreateTextSearchParser(): +{ CreateTextSearchParser statement = new CreateTextSearchParser(); String name; List functions; } +{ + name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + functions=PostgreSqlDefinition() + { requireTextSearchFunctions(functions, true); statement.setFunctions(functions); return statement; } } -void SnowflakeTimeTravelAt(StringBuilder builder): +CreateTextSearchTemplate CreateTextSearchTemplate(): +{ CreateTextSearchTemplate statement = new CreateTextSearchTemplate(); String name; List functions; } { - Expression expression; - Token tk; + ContextualKeyword("TEMPLATE") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + functions=PostgreSqlDefinition() + { requireTextSearchFunctions(functions, false); statement.setFunctions(functions); return statement; } } + +Statement AlterTextSearchMetadata(): +{ Statement statement; } { - // AT( { TIMESTAMP => | OFFSET => | STATEMENT => | STREAM => '' } ) + + ( + LOOKAHEAD({ isKeywordAhead("DICTIONARY") }) statement=AlterTextSearchDictionary() + | + LOOKAHEAD({ isKeywordAhead("PARSER") }) statement=AlterTextSearchParser() + | + statement=AlterTextSearchTemplate() + ) + { return statement; } +} - { builder.append("AT ("); } +AlterTextSearchDictionary AlterTextSearchDictionary(): +{ AlterTextSearchDictionary statement = new AlterTextSearchDictionary(); String name; List options; } +{ + ContextualKeyword("DICTIONARY") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } ( - //@fixme: this should be TIMESTAMP only but JavaCC-8 has issues with compound tokens! - "=>" expression = Expression() - { builder.append( "TIMESTAMP => ").append(expression.toString()); } + options=PostgreSqlDefinition() { statement.setAction(AlterTextSearchDictionary.Action.OPTIONS); statement.setOptions(options); } | - "=>" expression = Expression() - { builder.append( "OFFSET => ").append(expression.toString()); } + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchDictionary.Action.RENAME); statement.setNewName(name); } | - "=>" ( tk=| tk= | tk= ) - { builder.append( "STATEMENT => ").append(tk.image); } + ContextualKeyword("OWNER") name=RelObjectName() + { requireConversionName(name, true); statement.setAction(AlterTextSearchDictionary.Action.OWNER); statement.setOwner(name); } | - "=>" tk= - { builder.append( "STREAM => ").append(tk.image); } + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchDictionary.Action.SET_SCHEMA); statement.setSchemaName(name); } ) - { builder.append(")"); } + { return statement; } } - -void SnowflakeTimeTravelBefore(StringBuilder builder): +AlterTextSearchParser AlterTextSearchParser(): +{ AlterTextSearchParser statement = new AlterTextSearchParser(); String name; } { - Expression expression; - Token tk; + name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + ( + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchParser.Action.RENAME); statement.setNewName(name); } + | + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchParser.Action.SET_SCHEMA); statement.setSchemaName(name); } + ) + { return statement; } } + +AlterTextSearchTemplate AlterTextSearchTemplate(): +{ AlterTextSearchTemplate statement = new AlterTextSearchTemplate(); String name; } { - // BEFORE( STATEMENT => ) + ContextualKeyword("TEMPLATE") name=TypeDdlName() + { requireConversionName(name, false); statement.setName(name); } + ( + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchTemplate.Action.RENAME); statement.setNewName(name); } + | + name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterTextSearchTemplate.Action.SET_SCHEMA); statement.setSchemaName(name); } + ) + { return statement; } +} - { builder.append("BEFORE ("); } - "=>" ( tk=| tk= | tk= ) - { builder.append( "STATEMENT => ").append(tk.image); } - { builder.append(")"); } +CreateTextSearchConfiguration CreateTextSearchConfiguration(): +{ CreateTextSearchConfiguration statement = new CreateTextSearchConfiguration(); String name; } +{ + ContextualKeyword("CONFIGURATION") + name=AccessQualifiedName() { statement.setName(name); } + "(" ( { statement.setSourceKind(CreateTextSearchConfiguration.SourceKind.PARSER); } + | { statement.setSourceKind(CreateTextSearchConfiguration.SourceKind.COPY); } ) + "=" name=TextSearchConfigurationSource() ")" { statement.setSourceName(name); return statement; } } -void SnowflakeTimeTravelChange(StringBuilder builder): +AlterTextSearchConfiguration AlterTextSearchConfiguration(): { - Expression expression; - Token tk; + AlterTextSearchConfiguration statement = new AlterTextSearchConfiguration(); + String name; List names; } { - /* - CHANGES ( INFORMATION => { DEFAULT | APPEND_ONLY } ) - AT ( { TIMESTAMP => | OFFSET => | STATEMENT => | STREAM => '' } ) - | - BEFORE ( STATEMENT => ) - [ END( { TIMESTAMP => | OFFSET => | STATEMENT => } ) ] - */ + ContextualKeyword("CONFIGURATION") + name=AccessQualifiedName() { statement.setName(name); } + ( + ContextualKeyword("MAPPING") names=AccessNames() { statement.setTokenTypes(names); } + names=TextSearchDictionaryNames() + { statement.setAction(AlterTextSearchConfiguration.Action.ADD_MAPPING); statement.setDictionaries(names); } + | + ContextualKeyword("MAPPING") + [ names=AccessNames() { statement.setTokenTypes(names); } ] + ( name=AccessQualifiedName() { statement.setOldDictionary(name); } + name=AccessQualifiedName() + { statement.setAction(AlterTextSearchConfiguration.Action.REPLACE_MAPPING); statement.setNewDictionary(name); } + | names=TextSearchDictionaryNames() { + requireDdlSyntax(!statement.getTokenTypes().isEmpty(), "ALTER MAPPING WITH requires token types"); + statement.setAction(AlterTextSearchConfiguration.Action.ALTER_MAPPING); statement.setDictionaries(names); + } ) + | + ContextualKeyword("MAPPING") + [ LOOKAHEAD(2) { statement.setIfExists(true); } ] + names=AccessNames() + { statement.setAction(AlterTextSearchConfiguration.Action.DROP_MAPPING); statement.setTokenTypes(names); } + | + name=RelObjectName() + { statement.setAction(AlterTextSearchConfiguration.Action.RENAME); statement.setNewName(name); } + | + name=RelObjectName() + { statement.setAction(AlterTextSearchConfiguration.Action.SET_SCHEMA); statement.setSchemaName(name); } + | + ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(AlterTextSearchConfiguration.Action.OWNER); statement.setOwner(name); } + ) + { return statement; } +} - "=>" - { builder.append("CHANGES (INFORMATION => ");} +List TextSearchDictionaryNames(): +{ List names = new ArrayList(); String name; } +{ + name=AccessQualifiedName() { names.add(name); } + ( "," name=AccessQualifiedName() { names.add(name); } )* + { return names; } +} - ( tk = | tk=) - { builder.append(tk.image); } +String TextSearchConfigurationSource(): +{ String name; Token value; } +{ + ( value= { name = value.image; } | name=AccessQualifiedName() ) + { return name; } +} - { builder.append(") "); } +CreateRule CreateRule(boolean orReplace): +{ + CreateRule statement = new CreateRule(); String name; Table table; + Token event; Expression condition; Statement action; +} +{ + ContextualKeyword("RULE") name=RelObjectName() + { statement.setName(name); statement.setOrReplace(orReplace); } + ( event= | event= | event= | event= ) + { statement.setEvent(CreateRule.Event.valueOf(event.image.toUpperCase(java.util.Locale.ROOT))); } + table=Table() { statement.setTable(table); } + [ condition=Expression() { statement.setWhereExpression(condition); } ] + + [ LOOKAHEAD({ isKeywordAhead("ALSO") || isKeywordAhead("INSTEAD") }) + ( LOOKAHEAD({ isKeywordAhead("ALSO") }) ContextualKeyword("ALSO") { statement.setBehavior(CreateRule.Behavior.ALSO); } + | AccessKeyword("INSTEAD") { statement.setBehavior(CreateRule.Behavior.INSTEAD); } ) ] + ( + { statement.setNothing(true); } + | LOOKAHEAD(Select()) action=Select() { statement.getActions().add(action); } + | LOOKAHEAD(1, "(") "(" { statement.setUseParentheses(true); } + [ LOOKAHEAD({ getToken(1).kind != ST_SEMICOLON && !")".equals(getToken(1).image) }) + action=PostgreSqlRuleAction() { statement.getActions().add(action); } ] + ( + [ LOOKAHEAD({ getToken(1).kind != ST_SEMICOLON && !")".equals(getToken(1).image) }) + action=PostgreSqlRuleAction() { statement.getActions().add(action); } ] )* + ")" + | action=PostgreSqlRuleAction() { statement.getActions().add(action); } + ) + { return statement; } +} - ( - SnowflakeTimeTravelAt(builder) - | - SnowflakeTimeTravelBefore(builder) - ) +/** PostgreSQL's ALTER RULE name ON table RENAME TO new_name, its only ALTER RULE form. */ +AlterRule AlterRule(): +{ AlterRule statement = new AlterRule(); Token name; Table table; } +{ + ContextualKeyword("RULE") name=PostgreSqlWord() { requirePostgreSqlColId(name.image); statement.setName(name.image); } + table=Table() + { + requireDdlSyntax(table.getNameParts().size() <= 3, "A table name has at most three parts"); + statement.setTable(table); + } + name=PostgreSqlWord() { requirePostgreSqlColId(name.image); statement.setNewName(name.image); } + { return statement; } +} - [ - LOOKAHEAD(2) - { builder.append(" END ("); } +Statement PostgreSqlRuleAction(): +{ Statement statement; } +{ + statement=SingleStatement() + { + requireDdlSyntax(statement instanceof Select || statement instanceof TableStatement || statement instanceof Insert + || statement instanceof Update || statement instanceof Delete + || statement instanceof NotifyStatement, + "A rule action must be SELECT, INSERT, UPDATE, DELETE or NOTIFY"); + return statement; + } +} + +NotifyStatement NotifyStatement(): +{ NotifyStatement statement = new NotifyStatement(); String channel; Token payload; } +{ + channel=RelObjectName() { statement.setChannel(channel); } + [ "," payload= { statement.setPayload(stringValue(payload)); } ] + { return statement; } +} +/** + * PostgreSQL's IMPORT FOREIGN SCHEMA remote_schema [{LIMIT TO | EXCEPT} (relation_expr [, ...])] + * FROM SERVER server INTO local_schema [OPTIONS (option 'value' [, ...])]. + */ +ImportForeignSchema ImportForeignSchema(): +{ + ImportForeignSchema statement = new ImportForeignSchema(); + ImportForeignSchema.Qualification qualification = null; + List tables = new ArrayList(); + TableReference table; + String name; + List options; +} +{ + name=RelObjectName() { statement.setRemoteSchema(name); } + [ ( - //@fixme: this should be TIMESTAMP only but JavaCC-8 has issues with compound tokens! - "=>" expression = Expression() - { builder.append( "TIMESTAMP => ").append(expression.toString()); } - | - "=>" expression = Expression() - { builder.append( "OFFSET => ").append(expression.toString()); } + { qualification = ImportForeignSchema.Qualification.LIMIT_TO; } | - "=>" ( tk=| tk= | tk= ) - { builder.append( "STATEMENT => ").append(tk.image); } + { qualification = ImportForeignSchema.Qualification.EXCEPT; } ) - - { builder.append(")"); } - ] + "(" table=RelationTarget() { tables.add(table); } + ( "," table=RelationTarget() { tables.add(table); } )* ")" + { statement.setTables(qualification, tables); } + ] + ContextualKeyword("SERVER") name=RelObjectName() { statement.setServer(name); } + name=RelObjectName() { statement.setLocalSchema(name); } + [ LOOKAHEAD({ isKeywordAhead("OPTIONS") }) options=ForeignDataOptions(false) { statement.setOptions(options); } ] + { return statement; } } -void DataBricksTemporalSpec(StringBuilder builder): +/** + * PostgreSQL's DISCARD {ALL | PLANS | SEQUENCES | TEMP | TEMPORARY}. + */ +DiscardStatement DiscardStatement(): +{ DiscardStatement statement = new DiscardStatement(); } { - Token tk; - Expression expression; + + ( + { statement.setTarget(DiscardStatement.Target.ALL); } + | + { statement.setTarget(DiscardStatement.Target.TEMP); } + | + { statement.setTarget(DiscardStatement.Target.TEMPORARY); } + | + LOOKAHEAD({ isKeywordAhead("PLANS") }) ContextualKeyword("PLANS") + { statement.setTarget(DiscardStatement.Target.PLANS); } + | + ContextualKeyword("SEQUENCES") { statement.setTarget(DiscardStatement.Target.SEQUENCES); } + ) + { return statement; } } + +/** + * PostgreSQL's LISTEN channel and UNLISTEN {channel | *}. + */ +ListenStatement ListenStatement(): +{ ListenStatement statement = new ListenStatement(); String channel; } { - /* - temporal_spec https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-names#syntax-3 + ( + channel=RelObjectName() { statement.setChannel(channel); } + | + { statement.setAction(ListenStatement.Action.UNLISTEN); } + ( "*" | channel=RelObjectName() { statement.setChannel(channel); } ) + ) { - @ timestamp_encoding | - @V version | - [ FOR ] { SYSTEM_TIMESTAMP | TIMESTAMP } AS OF timestamp_expression | - [ FOR ] { SYSTEM_VERSION | VERSION } AS OF version + if (statement.getChannel() != null) { + requirePostgreSqlColId(statement.getChannel()); + } + return statement; } - */ - (tk= | tk=) { builder.append(tk.image).append(" "); } - (tk= | tk=) { builder.append(tk.image); } - | - [ { builder.append(" FOR"); } ] +} - ( tk= | tk= ) - expression=Expression() - { builder.append(" ").append(tk.image).append(" AS OF ").append(expression.toString()); } - | +/** + * PostgreSQL's CREATE CAST, CREATE [OR REPLACE] TRANSFORM and CREATE [DEFAULT] CONVERSION, after + * CREATE [OR REPLACE]. Only a transform takes OR REPLACE. + */ +Statement CastDdl(boolean orReplace): +{ Statement statement; } +{ ( - ( tk= | tk= ) { builder.append(" ").append(tk.image); } - (tk= | tk= ) { builder.append(" AS OF ").append(tk.image); } + { requireDdlSyntax(!orReplace, "CREATE CAST does not support OR REPLACE"); } + statement=CreateCast() + | + LOOKAHEAD({ isKeywordAhead("TRANSFORM") }) statement=CreateTransform(orReplace) + | + { requireDdlSyntax(!orReplace, "CREATE CONVERSION does not support OR REPLACE"); } + statement=CreateConversion() ) + { return statement; } } -void BigQueryHistoricalVersion(StringBuilder builder): +/** + * PostgreSQL's CreateCastStmt: CAST (source AS target) with WITH FUNCTION function, WITHOUT + * FUNCTION or WITH INOUT, and an optional AS ASSIGNMENT or AS IMPLICIT. + */ +CreateCast CreateCast(): +{ CreateCast statement = new CreateCast(); CastSignature cast; RoutineReference function; Token context; } { - Token tk; - Expression expression; + cast=CastSignature() { statement.setCast(cast); } + ( + + ( function=RoutineReference(false) { statement.setFunction(function); } + | ContextualKeyword("INOUT") { statement.setMethod(CreateCast.Method.WITH_INOUT); } ) + | + { statement.setMethod(CreateCast.Method.WITHOUT_FUNCTION); } + ) + [ context= { statement.setContext(typeDdlEnum(CreateCast.Context.class, context.image)); } ] + { return statement; } } + +/** + * PostgreSQL's CreateTransformStmt: TRANSFORM FOR type LANGUAGE lang with a FROM SQL item, a TO + * SQL item, or both in either order. + */ +CreateTransform CreateTransform(boolean orReplace): +{ CreateTransform statement = new CreateTransform(); TransformSignature transform; RoutineReference function; } { - /* - FOR SYSTEM_TIME AS OF timestamp_expression - */ - expression=Expression() - { builder.append(" FOR SYSTEM_TIME AS OF ").append(expression.toString()); } + ContextualKeyword("TRANSFORM") transform=TransformSignature() + { statement.setOrReplace(orReplace); statement.setTransform(transform); } + "(" + ( + function=TransformFunction() { statement.setFromSqlFunction(function); } + [ "," function=TransformFunction() { statement.setToSqlFunction(function); } ] + | + function=TransformFunction() { statement.setToSqlFunction(function); } + [ "," function=TransformFunction() + { statement.setFromSqlFunction(function); statement.setToSqlFirst(true); } ] + ) + ")" + { return statement; } } -String TimeTravelBeforeAlias(): +/** SQL WITH FUNCTION function, after FROM or TO in a transform item. */ +RoutineReference TransformFunction(): +{ RoutineReference function; } { - StringBuilder builder = new StringBuilder(); + ContextualKeyword("SQL") function=RoutineReference(false) + { return function; } } + +/** PostgreSQL's CreateConversionStmt: [DEFAULT] CONVERSION name FOR 'source' TO 'dest' FROM function. */ +CreateConversion CreateConversion(): +{ CreateConversion statement = new CreateConversion(); String name; StringValue encoding; } { - ( - SnowflakeTimeTravelAt(builder) - | - SnowflakeTimeTravelBefore(builder) - | - SnowflakeTimeTravelChange(builder) - | - DataBricksTemporalSpec(builder) - ) + [ { statement.setDefaultConversion(true); } ] + ContextualKeyword("CONVERSION") name=TypeDdlName() { requireConversionName(name, false); statement.setName(name); } + encoding=ConversionEncoding() { statement.setSourceEncoding(encoding); } + encoding=ConversionEncoding() { statement.setDestinationEncoding(encoding); } + name=TypeDdlName() { requireConversionName(name, false); statement.setFunction(name); } + { return statement; } +} +/** An encoding name, which PostgreSQL's grammar reads as a string constant. */ +StringValue ConversionEncoding(): +{ Token token; StringValue value; } +{ + token= { - return builder.toString(); + value = stringValue(token); + requireDdlSyntax(!isPostgreSqlDialect() || isPostgreSqlStringConstant(value), + "PostgreSQL expects a string constant: " + token.image); + return value; } } -String TimeTravelAfterAlias(): +/** PostgreSQL's ALTER CONVERSION name with RENAME TO, OWNER TO or SET SCHEMA. */ +AlterConversion AlterConversion(): +{ AlterConversion statement = new AlterConversion(); String name; } { - StringBuilder builder = new StringBuilder(); + ContextualKeyword("CONVERSION") name=TypeDdlName() { requireConversionName(name, false); statement.setName(name); } + ( name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterConversion.Action.RENAME); statement.setNewName(name); } + | ContextualKeyword("OWNER") name=RelObjectName() + { requireConversionName(name, true); statement.setAction(AlterConversion.Action.OWNER); statement.setOwner(name); } + | name=RelObjectName() + { requireConversionName(name, false); statement.setAction(AlterConversion.Action.SET_SCHEMA); statement.setSchemaName(name); } ) + { return statement; } } + +CreateCollation CreateCollation(): { - BigQueryHistoricalVersion(builder) - { - return builder.toString(); - } + CreateCollation statement = new CreateCollation(); String name; List options; +} +{ + ContextualKeyword("COLLATION") + [ LOOKAHEAD(2) { statement.setIfNotExists(true); } ] + name=AccessQualifiedName() { statement.setName(name); } + ( name=AccessQualifiedName() { statement.setSourceCollation(name); } + | options=PostgreSqlOptions(true) { + for (IndexOption option : options) { + requireDdlSyntax(option.getValue() == null || option.isUseEquals(), + "Collation parameter values require an equals sign"); + } + statement.setOptions(options); + } ) + { return statement; } +} + +AlterCollation AlterCollation(): +{ AlterCollation statement = new AlterCollation(); String name; } +{ + ContextualKeyword("COLLATION") name=AccessQualifiedName() { statement.setName(name); } + ( { statement.setAction(AlterCollation.Action.REFRESH_VERSION); } + | name=RelObjectName() + { statement.setAction(AlterCollation.Action.RENAME); statement.setNewName(name); } + | name=RelObjectName() + { statement.setAction(AlterCollation.Action.SET_SCHEMA); statement.setSchemaName(name); } + | ContextualKeyword("OWNER") name=RelObjectName() + { statement.setAction(AlterCollation.Action.OWNER); statement.setOwner(name); } ) + { return statement; } } diff --git a/src/site/sphinx/contribution.rst b/src/site/sphinx/contribution.rst index 41c327fbb4..8510822e06 100644 --- a/src/site/sphinx/contribution.rst +++ b/src/site/sphinx/contribution.rst @@ -88,7 +88,8 @@ The JSQLParser is generated by ``JavaCC`` based on the provided Grammar. The Gra :caption: JMH performance results Benchmark (version) Mode Cnt Score Error Units - JSQLParserBenchmark.parseSQLStatements latest avgt 15 32.525 ± 0.413 ms/op + JSQLParserBenchmark.parseSQLStatements latest avgt 15 21.138 ± 0.557 ms/op + JSQLParserBenchmark.parseSQLStatements 5.4 avgt 15 32.528 ± 0.666 ms/op JSQLParserBenchmark.parseSQLStatements 5.3 avgt 15 983.459 ± 8.197 ms/op JSQLParserBenchmark.parseSQLStatements 5.1 avgt 15 319.601 ± 4.081 ms/op diff --git a/src/site/sphinx/index.rst b/src/site/sphinx/index.rst index 283bc5c4d7..8419d30126 100644 --- a/src/site/sphinx/index.rst +++ b/src/site/sphinx/index.rst @@ -156,8 +156,56 @@ One grammar covers the SQL standard plus all major RDBMS. Missing syntax gets ad - ``INSERT`` · ``UPDATE`` · ``UPSERT`` · ``MERGE`` · ``DELETE`` · ``TRUNCATE TABLE`` * - **DDL** - ``CREATE …`` · ``ALTER …`` · ``DROP …`` + * - **PostgreSQL ownership** + - ``DROP OWNED`` · ``REASSIGN OWNED`` + * - **Two-phase commit** + - PostgreSQL ``PREPARE TRANSACTION`` · ``COMMIT PREPARED`` · ``ROLLBACK PREPARED`` · MySQL ``XA START``/``END``/``PREPARE``/``COMMIT``/``ROLLBACK``/``RECOVER`` + * - **MySQL table maintenance** + - ``ANALYZE`` · ``CHECK`` · ``CHECKSUM`` · ``OPTIMIZE`` · ``REPAIR TABLE`` + * - **PostgreSQL maintenance** + - ``VACUUM`` · ``ANALYZE`` · ``CLUSTER`` · ``CHECKPOINT`` + * - **MySQL locks** + - ``LOCK TABLES`` · ``UNLOCK TABLES`` · ``LOCK INSTANCE FOR BACKUP`` · ``UNLOCK INSTANCE`` + * - **MySQL resource groups** + - ``CREATE``/``ALTER``/``DROP RESOURCE GROUP`` · ``SET RESOURCE GROUP`` + * - **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`` + * - **PostgreSQL session statements** + - ``DISCARD`` · ``LISTEN`` · ``UNLISTEN`` · ``SHOW``/``RESET TIME ZONE``/``TRANSACTION ISOLATION LEVEL``/``SESSION AUTHORIZATION`` · ``COPY`` options from before 9.0 + * - **MySQL server administration** + - ``FLUSH`` · ``KILL`` · ``RESET PERSIST`` · ``HANDLER … OPEN``/``READ``/``CLOSE`` + * - **PostgreSQL foreign schema import** + - ``IMPORT FOREIGN SCHEMA … [LIMIT TO | EXCEPT (…)] FROM SERVER … INTO … [OPTIONS (…)]`` + * - **MySQL replication** + - ``CHANGE REPLICATION SOURCE TO`` · ``CHANGE REPLICATION FILTER`` · ``START``/``STOP REPLICA`` · ``RESET REPLICA`` · ``RESET BINARY LOGS AND GTIDS`` · ``PURGE BINARY LOGS`` + * - **MySQL data loading** + - ``LOAD DATA`` · ``LOAD XML`` · ``SELECT … INTO OUTFILE`` with the same ``FIELDS`` and ``LINES`` clauses + * - **PostgreSQL cursors** + - ``DECLARE … CURSOR`` · ``FETCH`` · ``MOVE`` · ``CLOSE`` + * - **MySQL account management** + - ``CREATE``/``ALTER``/``RENAME USER`` · ``CREATE ROLE`` · ``SET ROLE`` · ``SET DEFAULT ROLE`` · ``SET PASSWORD`` + * - **Tablespaces** + - MySQL and PostgreSQL ``CREATE TABLESPACE`` · ``ALTER TABLESPACE`` + * - **MySQL spatial reference systems and instance** + - ``CREATE``/``DROP SPATIAL REFERENCE SYSTEM`` · ``ALTER INSTANCE`` * - **PostgreSQL RLS** - ``CREATE POLICY`` · ``ALTER TABLE … ENABLE``/``DISABLE``/``FORCE``/``NO FORCE ROW LEVEL SECURITY`` + * - **Routine changes** + - ``ALTER FUNCTION`` · ``ALTER PROCEDURE`` · ``ALTER ROUTINE`` · PostgreSQL ``ALTER TRIGGER`` + * - **MySQL metadata statements** + - ``SHOW [FULL] COLUMNS``/``FIELDS`` · ``SHOW INDEX``/``INDEXES``/``KEYS`` · ``SHOW TABLE STATUS`` · ``SHOW CREATE TABLE``/``VIEW``/``PROCEDURE``/``FUNCTION``/``TRIGGER``/``EVENT``/``DATABASE``/``USER`` · ``SHOW [GLOBAL | SESSION] VARIABLES``/``STATUS`` · ``SHOW [FULL] PROCESSLIST`` · ``SHOW GRANTS [FOR …]`` · ``SHOW WARNINGS``/``ERRORS`` · ``SHOW BINARY LOGS``/``BINLOG EVENTS``/``RELAYLOG EVENTS`` · ``SHOW ENGINE …`` · ``SHOW PROFILE`` · ``SHOW DATABASES``/``TRIGGERS``/``EVENTS``/``OPEN TABLES``/``CHARACTER SET``/``COLLATION`` · ``SHOW PROCEDURE``/``FUNCTION STATUS``/``CODE`` · ``SHOW REPLICA STATUS``/``REPLICAS`` + * - **MySQL utility statements** + - ``EXPLAIN``/``DESCRIBE [ANALYZE] FORMAT = …`` · ``EXPLAIN FOR CONNECTION`` · ``DESCRIBE t col`` · ``PREPARE … FROM`` · ``EXECUTE … USING`` · ``DROP PREPARE`` · ``DO`` + * - **PostgreSQL administration** + - ``CREATE``/``ALTER EVENT TRIGGER`` · ``REINDEX`` · ``SECURITY LABEL`` + * - **PostgreSQL types and rules** + - ``CREATE TYPE`` (shell, composite, enum, range and base types) · ``ALTER TYPE`` · ``CREATE RULE`` · ``ALTER RULE`` + * - **PostgreSQL casts, transforms and conversions** + - ``CREATE CAST`` · ``DROP CAST`` · ``CREATE [OR REPLACE] TRANSFORM`` · ``DROP TRANSFORM`` · ``CREATE [DEFAULT] CONVERSION`` · ``ALTER CONVERSION`` + * - **PostgreSQL operators and aggregates** + - ``CREATE``/``ALTER OPERATOR`` · ``CREATE``/``ALTER OPERATOR CLASS`` · ``CREATE``/``ALTER OPERATOR FAMILY`` · ``CREATE``/``ALTER AGGREGATE`` * - **Salesforce SOQL** - ``INCLUDES`` · ``EXCLUDES`` diff --git a/src/site/sphinx/keywords.rst b/src/site/sphinx/keywords.rst index a9058fbaad..4fb9318da6 100644 --- a/src/site/sphinx/keywords.rst +++ b/src/site/sphinx/keywords.rst @@ -7,8 +7,6 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | **Keyword** | +---------------------------+ -| ABSENT | -+---------------------------+ | ALL | +---------------------------+ | AND | @@ -37,34 +35,20 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | CROSS | +---------------------------+ -| CSV | -+---------------------------+ -| CURRENT | -+---------------------------+ | DISTINCT | +---------------------------+ | DISTINCTROW | +---------------------------+ | ELSE | +---------------------------+ -| ERRORS | -+---------------------------+ | EXCEPT | +---------------------------+ | EXCLUDES | +---------------------------+ -| EXISTS | -+---------------------------+ -| EXTEND | -+---------------------------+ | FALSE | +---------------------------+ -| FBV | -+---------------------------+ | FETCH | +---------------------------+ -| FILE | -+---------------------------+ | FINAL | +---------------------------+ | FOR | @@ -89,8 +73,6 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | ILIKE | +---------------------------+ -| IMPORT | -+---------------------------+ | IN | +---------------------------+ | INCLUDES | @@ -145,10 +127,6 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | PREFERRING | +---------------------------+ -| PREWHERE | -+---------------------------+ -| PRIOR | -+---------------------------+ | PROCEDURE | +---------------------------+ | PUBLIC | @@ -157,30 +135,18 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | RETURNING | +---------------------------+ -| RETURNS | -+---------------------------+ | RIGHT | +---------------------------+ -| SAMPLE | -+---------------------------+ -| SCRIPT | -+---------------------------+ | SET | +---------------------------+ -| SETTINGS | -+---------------------------+ | SOME | +---------------------------+ | SQL_CACHE | +---------------------------+ | SQL_CALC_FOUND_ROWS | +---------------------------+ -| SQL_NO_CACHE | -+---------------------------+ | START | +---------------------------+ -| STATEMENT | -+---------------------------+ | STRAIGHT_JOIN | +---------------------------+ | TABLES | @@ -193,14 +159,10 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | TRUE | +---------------------------+ -| UNBOUNDED | -+---------------------------+ | UNION | +---------------------------+ | UNIQUE | +---------------------------+ -| UNKNOWN | -+---------------------------+ | UNPIVOT | +---------------------------+ | USE | @@ -211,8 +173,6 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | VALUES | +---------------------------+ -| VERIFY | -+---------------------------+ | WHEN | +---------------------------+ | WHERE | @@ -221,7 +181,5 @@ The following Keywords are **reserved** in JSQLParser-|JSQLPARSER_VERSION| and m +---------------------------+ | WITH | +---------------------------+ -| XMLSERIALIZE | -+---------------------------+ | XOR | +---------------------------+ diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst index 6e4c96feb2..bbf0f1f907 100644 --- a/src/site/sphinx/usage.rst +++ b/src/site/sphinx/usage.rst @@ -204,6 +204,7 @@ For several statements at once, use ``CCJSqlParserUtil.parseStatements()``, whic .. note:: Supported statement separators are semicolon ``;``, ``GO``, slash ``/`` and two empty lines ``\n\n\n``. + Use ``withBlankLinesAsSeparator(false)`` to treat empty lines as plain whitespace instead. If parsing fails on syntax JSQLParser does not know, see :ref:`Handle Parse Errors` — and please `open an issue `_, missing syntax gets added on demand. @@ -231,6 +232,128 @@ The fastest way to learn the object model is to look at it. Paste your SQL into Read that as a map: each line is a getter away. ``select.getSelectItems()``, ``select.getFromItem()``, ``select.getWhere()``. Once the tree gets deeper than a couple of levels, stop casting by hand and use :ref:`Use the Visitor Patterns`. +MySQL index hints, insert sources and DELETE ... USING +------------------------------------------------------ + +A table reference keeps every MySQL index hint in ``Table.getIndexHints()``, in +source order, for example ``t USE INDEX (i1) IGNORE INDEX FOR ORDER BY (i2)``. +``MySQLIndexHint.getScope()`` returns ``JOIN``, ``ORDER_BY`` or ``GROUP_BY`` for a +``FOR`` clause and ``null`` without one. ``USE INDEX ()`` has an empty index list; +``IGNORE`` and ``FORCE`` require at least one index. ``getIndexHint()`` still returns +the first hint, and ``setHint()`` replaces all hints with one. + +``WEIGHT_STRING(str AS CHAR(n))`` and ``WEIGHT_STRING(str AS BINARY(n))`` keep the cast +in ``Function.getCastType()``, a ``ColDataType`` as in ``CAST``. + +``INSERT INTO t VALUES ROW(1, 2), ROW(3, 4)`` and ``INSERT INTO t TABLE s`` use the same +``Values`` and ``TableStatement`` models as the queries ``VALUES ROW(...)`` and +``TABLE s``. ``INSERT INTO t () VALUES ()`` has an empty, non-null +``getColumns()``; REPLACE accepts the same forms. ``toString()`` and +``InsertDeParser`` both render through ``Insert.appendTo``, which writes ``PARTITION`` +before the column list. + +``DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id`` keeps the joins of the USING +clause in ``Delete.getUsingJoins()``, after ``getUsingFromItemList()``. PostgreSQL's +``DELETE FROM t USING s JOIN u ON ...`` uses the same properties. ``getJoins()`` +holds the joins of the target, as in ``DELETE FROM t1, t2 USING ...``, and is +rendered before USING. + +PostgreSQL CHECK inheritance +---------------------------- + +With ``Dialect.POSTGRESQL``, CREATE and ALTER CHECK constraints support +``NO INHERIT``. ``CheckConstraint.isNoInherit()`` reports this flag; use +``setNoInherit`` or ``withNoInherit`` to change it. The check expression remains +an editable ``Expression`` visited by the existing table traversal and deparsers. + +For ``ALTER TABLE t ADD CHECK (id > 0) NO INHERIT NOT VALID``, the two options +are independent: ``isNoInherit()`` is true and +``getConstraintAttributes().isNotValid()`` is true. Clearing one flag preserves +the other when the statement is rendered. + +DROP targets +------------ + +``Drop`` keeps the parts of a DROP statement that are not plain object names in +typed properties: + +* FUNCTION, PROCEDURE, ROUTINE and AGGREGATE targets are ``RoutineReference`` + items in ``getRoutines()``, the model that GRANT and COMMENT use. Every target + keeps its own signature, so ``DROP PROCEDURE p(int)`` and + ``DROP FUNCTION f(int), g(text)`` render as written. Null arguments mean an + omitted signature; an empty list is an explicit ``()``. +* USER, ROLE and GROUP targets and the roles of PostgreSQL ``DROP OWNED BY`` are + ``UserAccount`` items in ``getAccounts()``, read with the MySQL account-name rule + that CREATE USER uses. MySQL accounts keep their host, as in ``'app'@'%'``, + and a quoted PostgreSQL role name such as ``"Admin"`` keeps ``"`` in + ``getQuoteStr()``. +* ``DROP TRIGGER t ON tbl`` and ``DROP RULE r ON tbl`` expose ``tbl`` through + ``getTable()``, like ``DROP INDEX i ON tbl``, and table discovery reports it. + SQL Server's ``ON DATABASE`` and ``ON ALL SERVER`` trigger scopes stay + parameters. +* ``getBehavior()`` holds an explicit CASCADE or RESTRICT as a + ``CascadeBehavior``. It is rendered last. +* ``isUndo()``, ``getEngine()`` and ``isEngineUseEquals()`` cover MySQL + ``DROP [UNDO] TABLESPACE name [ENGINE [=] engine]``. ``isForce()`` covers + PostgreSQL ``DROP DATABASE name [WITH] (FORCE)``; the optional WITH is + always rendered. +* ``getAccessMethod()`` holds the index access method of PostgreSQL + ``DROP OPERATOR CLASS|FAMILY name USING method``, which takes one name. + ``isProcedural()`` records the ``PROCEDURAL LANGUAGE`` spelling. +* PostgreSQL names casts, operators and transforms by types. ``getCast()`` is the + ``CastSignature`` of ``DROP CAST (source_type AS target_type)``. + ``getOperators()`` holds an ``OperatorSignature`` per target of + ``DROP OPERATOR [schema.]op ({left_type | NONE}, {right_type | NONE}) [, ...]``; + its operator is the ``ExclusionOperator`` reference that COMMENT ON OPERATOR + uses, and a null operand type stands for NONE. ``getTransform()`` is the + ``TransformSignature`` of ``DROP TRANSFORM FOR type_name LANGUAGE lang_name``. + Oracle's ``DROP OPERATOR name`` keeps a plain name, which the PostgreSQL + dialect rejects. + +TYPE, DOMAIN, EVENT, EVENT TRIGGER, TABLESPACE, USER and GROUP are recognized +object types, and so are PostgreSQL's ACCESS METHOD, CAST, LANGUAGE, OPERATOR, +OPERATOR CLASS, OPERATOR FAMILY, TRANSFORM and TEXT SEARCH CONFIGURATION, +DICTIONARY, PARSER and TEMPLATE. +``getType()`` returns their words separated by spaces, as in ``ACCESS METHOD``. MySQL's +``DROP SPATIAL REFERENCE SYSTEM [IF EXISTS] srid`` has the object type +``SPATIAL_REFERENCE_SYSTEM`` and its name is the SRID as written. PostgreSQL ``REASSIGN OWNED BY old_role [, ...] TO new_role`` is +parsed into ``ReassignOwned``, whose roles use the same ``UserAccount`` model. + +.. code-block:: java + + Drop drop = (Drop) CCJSqlParserUtil.parse("DROP FUNCTION f(int), g(text) CASCADE", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + RoutineReference g = drop.getRoutines().get(1); + g.getArguments().get(0).setDataType(new ColDataType("varchar")); + // DROP FUNCTION f(int), g(varchar) CASCADE + String sql = drop.toString(); + +The legacy accessors remain and are derived from these properties: + +* ``getName()`` and ``getNames()`` return read-only snapshots of routine, + account and operator names. Edit ``getRoutines()``, ``getAccounts()`` or + ``getOperators()`` to change them. A cast or transform has no name. +* ``getTypeToParameters()`` and ``getParamsByType()`` return a read-only map with + the argument declarations of the last routine, where the legacy + single-signature form kept them. The map now also covers PROCEDURE, ROUTINE + and AGGREGATE. +* ``getParameters()`` is a snapshot that includes ON with the owner table, the + MySQL ALGORITHM and LOCK clauses and the CASCADE or RESTRICT keyword, in + source order. ``setParameters()`` replaces the clause with raw tokens and + clears all three; ``addParameters()`` keeps them. Raw tokens are not parsed: + ``addParameters("CASCADE")`` leaves ``getBehavior()`` null. +* ``setName()``, ``setNames()``, ``addNames()`` and ``setTypeToParameters()`` + first convert routine and account targets to the legacy names and single + signature, so ``setName()`` on ``DROP FUNCTION f(int)`` still renders + ``DROP FUNCTION g(int)``. Use ``getRoutines()`` to keep several signatures. + +Migration: mutating the map returned by ``getTypeToParameters()`` for a parsed +routine now throws ``UnsupportedOperationException``; edit its +``RoutineReference`` instead. ``getObjectType()`` reports the new ``AGGREGATE``, +``DOMAIN``, ``EVENT_TRIGGER``, ``GROUP``, ``OWNED``, ``ROLE``, ``ROUTINE``, +``RULE``, ``TYPE`` and ``USER`` kinds where it reported ``OTHER``. +``DROP OWNED BY r`` no longer returns the name ``BY``. + DROP INDEX owners ----------------- @@ -250,7 +373,254 @@ setters do not parse SQL or infer a table. Table discovery and statement visitors traverse DROP TABLE/VIEW targets and 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 ALGORITHM and LOCK clauses retain their order and optional equals signs as +typed nodes; see :ref:`Share MySQL index options`. + +MySQL named constraint drops +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Without a dialect and with ``Dialect.MYSQL``, ``DROP FOREIGN KEY name`` and +``DROP CHECK name`` expose the target through ``AlterExpression.getConstraintName()``. +``Dialect.MARIADB`` accepts the named FOREIGN KEY form; MariaDB has no ``DROP CHECK``. +Other dialects drop constraints with ``DROP CONSTRAINT``. A parenthesized +``DROP FOREIGN KEY (...)`` keeps the legacy column-list form. 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"); + +Edit table and view column renames +---------------------------------- + +``AlterExpression.getColumnRename()`` exposes a ``ColumnRenameAction`` with +``getSourceName()`` and ``getTargetName()``. Their setters update the existing +AST directly, preserving the optional ``COLUMN`` keyword. Names include their +written identifier quotes; include quotes in replacement names when needed. + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE accounts RENAME COLUMN old_id TO new_id", + parser -> parser.withDialect(Dialect.MYSQL)); + ColumnRenameAction rename = alter.getAlterExpressions().get(0).getColumnRename(); + rename.getSourceName(); // old_id + rename.setTargetName("customer_id"); + // ALTER TABLE accounts RENAME COLUMN old_id TO customer_id + String sql = alter.toString(); + +Import ``ColumnRenameAction`` from ``net.sf.jsqlparser.statement.alter``. +PostgreSQL table renames of columns use the same API. With ``Dialect.POSTGRESQL``, +column renames on views and materialized views expose it through the entries in +``AlterRelation.getActions()``. The lookup returns ``null`` for other operations, +including renaming the table, view, index or constraint itself. Existing +action-specific getters and setters remain available and see the same changes. + +Shared CASCADE and RESTRICT behavior +------------------------------------ + +``AlterDomain``, ``AlterType`` (including ``AttributeChange``), ``DropPolicy``, +``Truncate`` and ``Revoke`` use ``net.sf.jsqlparser.statement.CascadeBehavior`` +for their explicit ``CASCADE`` and ``RESTRICT`` clauses. A null value preserves +an omitted clause; it does not insert an explicit ``RESTRICT``. + +.. code-block:: java + + import net.sf.jsqlparser.statement.CascadeBehavior; + + truncate.setDropBehavior(CascadeBehavior.RESTRICT); + revoke.setBehavior(truncate.getDropBehavior()); + revoke.setBehavior(null); // Omit the clause and leave the server default unchanged. + +Migration: the nested enums ``AlterDomain.Behavior``, ``AlterType.Behavior``, +``DropPolicy.Behavior``, ``Truncate.DropBehavior`` and ``Revoke.Behavior`` have +been removed. Replace their imports and enum references with ``CascadeBehavior``. +The existing getter and setter names remain, but their return and parameter types +have changed, so clients must recompile. ``Truncate.setCascade(false)`` still +clears the clause. Foreign-key referential actions retain their separate enum. + +``ALTER TABLE`` drop actions expose the same enum through +``AlterExpressionDrop.getBehavior()``, for example in +``ALTER TABLE t DROP COLUMN IF EXISTS c RESTRICT`` and +``ALTER TABLE t DROP CONSTRAINT c CASCADE``. Oracle's ``CASCADE CONSTRAINTS`` and +``INVALIDATE`` remain raw parameters. ``getParameters()`` still ends with the +behavior keyword; when a behavior is set, it returns a read-only snapshot, so use +``setBehavior`` to change the clause. + +Edit shared table options +------------------------- + +``CreateTable.getTableOptions()`` and +``AlterExpressionTableOption.getStructuredTableOption()`` use the same mutable +``TableOption`` model. Structured values and opaque tokens are alternative +representations. ``setTokens(nonNullList)`` discards the previous kind, name, +value and child nodes: the option becomes ``Kind.OTHER`` without parsing the +tokens. Raw token lists remain mutable; ``getTokens()`` on a structured option +returns an unmodifiable snapshot. + +.. code-block:: java + + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT) ENGINE=InnoDB"); + TableOption option = table.getTableOption(TableOption.Kind.ENGINE).orElseThrow(); + option.setTokens(List.of("ROW_FORMAT", "=", "DYNAMIC")); + table.getTableOption(TableOption.Kind.ENGINE).isEmpty(); // true + + // Supply structured properties explicitly; the old tokens are discarded. + option.withKind(TableOption.Kind.COMMENT).withName("COMMENT") + .withValue("'new'").withUseEquals(true); + // CREATE TABLE t (id INT) COMMENT = 'new' + +Any structured setter leaves the opaque representation; it never recovers +previous values from those tokens. ``setTokens(null)`` clears opaque tokens +without restoring discarded properties, and leaves structured options alone. +``setUnionTables``, ``setStorageParameters``, ``setForeignTableOptions`` and +``setOnCommitAction`` replace the current contents with their respective +structured payloads. Their lists and child nodes remain editable. An empty +UNION list means ``UNION ()``; +a null payload omits its value. A non-null ``setTablespaceStorage`` also selects +TABLESPACE; supply its tablespace name with ``setValue``. Choose the new kind and spelling explicitly +when using the scalar setters. These methods edit the AST rather than checking +database-specific DDL validity. + +A temporary table's ``ON COMMIT`` clause and a table access method are single +options. ``Kind.ON_COMMIT`` exposes ``getOnCommitAction()``: ``PRESERVE_ROWS``, +``DELETE_ROWS`` or ``DROP``, plus ``PRESERVE_DEFINITION`` and ``DROP_DEFINITION`` +for Oracle private temporary tables. ``Kind.ACCESS_METHOD`` stores the method of +``USING method`` as its value, including ``CREATE TABLE … USING method AS query``. +Use ``TableOption.onCommit`` and ``TableOption.accessMethod`` to build them. +``getTableOptionsStrings()`` keeps the legacy word tokens, such as ``ON``, +``COMMIT``, ``DELETE`` and ``ROWS``. + +.. code-block:: java + + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TEMP TABLE t (id INT) USING heap ON COMMIT DROP", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + table.getTableOption(TableOption.Kind.ACCESS_METHOD).orElseThrow().getValue(); // heap + table.getTableOption(TableOption.Kind.ON_COMMIT).orElseThrow() + .setOnCommitAction(TableOption.OnCommitAction.PRESERVE_ROWS); + // CREATE TEMP TABLE t (id INT) USING heap ON COMMIT PRESERVE ROWS + +Share MySQL index options +------------------------- + +CREATE INDEX, the index and key definitions of CREATE TABLE, and ALTER TABLE +``ADD`` or ``ALTER INDEX`` parse MySQL index options with one grammar rule into +one model. ``IndexOptions.getSpecOptions()``, also available on ``Index`` and +``KeyConstraint``, returns the options written after the key list as mutable, +ordered ``IndexSpecOption`` nodes. ``getKind()`` selects the payload: + +* ``KEY_BLOCK_SIZE``, ``ENGINE_ATTRIBUTE`` and ``SECONDARY_ENGINE_ATTRIBUTE``: + ``getValue()`` and the optional ``=`` reported by ``isUseEquals()`` +* ``INDEX_TYPE`` (``USING BTREE``) and ``PARSER`` (``WITH PARSER ngram``): + ``getValue()`` +* ``COMMENT``: ``getComment()`` returns the literal as a ``StringValue`` that + records how the dialect escapes it, so ``getNotExcapedValue()`` returns the + stored text, for example ``it's`` for ``'it''s'`` or, with MySQL backslash + escapes, ``'it\'s'``. ``getValue()`` remains the literal's SQL text. +* ``VISIBILITY``: ``getVisible()`` for VISIBLE or INVISIBLE +* ``OTHER``: opaque tokens that CREATE TABLE and CREATE INDEX accept for other + dialects + +Values keep their SQL spelling, including the quotes of string literals. An +index type written before the key list, as in ``KEY k USING BTREE (a)``, +``PRIMARY KEY USING BTREE (id)`` or ``CREATE INDEX k USING HASH ON t (a)``, +remains ``getUsing()``; ``CreateIndex.isIndexTypeBeforeOn()`` still distinguishes +the two CREATE INDEX positions. After the key list it is an ``INDEX_TYPE`` option +at its source position. PostgreSQL's INCLUDE, NULLS DISTINCT, storage parameters +and tablespace keep their dedicated properties. + +CREATE INDEX keeps these options on ``getIndex()``. Its ALGORITHM and LOCK +clauses are ``AlgorithmOrLockOption`` nodes in +``CreateIndex.getAlgorithmOrLockOptions()``; DROP INDEX exposes the same type +through ``Drop.getAlgorithmOrLockOptions()``. CREATE INDEX renders them after the +index options, as MySQL requires. + +.. code-block:: java + + CreateIndex create = (CreateIndex) CCJSqlParserUtil.parse( + "CREATE UNIQUE INDEX uk ON t (a) USING BTREE COMMENT 'x' ALGORITHM = INPLACE", + parser -> parser.withDialect(Dialect.MYSQL)); + List options = create.getIndex().getSpecOptions(); + options.get(0).setValue("HASH"); // INDEX_TYPE + options.add(IndexSpecOption.visibility(false)); + create.getAlgorithmOrLockOptions().get(0).setValue("COPY"); + // CREATE UNIQUE INDEX uk ON t (a) USING HASH COMMENT 'x' INVISIBLE ALGORITHM = COPY + +The kind of an option is fixed. Setters for a payload that the kind does not have, +and ``setTokens`` on a typed option, throw ``IllegalStateException``; replace the +node to change its kind. ``IndexSpecOption.raw`` copies its tokens and never +parses them. + +The legacy accessors are derived from these nodes. ``getIndexSpec()`` returns an +unmodifiable token snapshot of ``getSpecOptions()``, or null when the options are +unset. ``CreateIndex.getTailParameters()`` returns the tokens of the index options +followed by ALGORITHM and LOCK, and ``Drop.getParameters()`` includes ALGORITHM +and LOCK at their source position. ``setIndexSpec`` and +``CreateIndex.setTailParameters`` replace these clauses with one opaque option; +``Drop.setParameters`` also clears ALGORITHM and LOCK. + +Migration: edits of the ``getIndexSpec()`` and ``getTailParameters()`` snapshots +now throw ``UnsupportedOperationException``; edit the nodes or call the setters. +ALTER TABLE key definitions report the same tokens as CREATE TABLE, for example +``KEY_BLOCK_SIZE``, ``=`` and ``8`` instead of the single entry +``KEY_BLOCK_SIZE = 8``. For a constructed statement without trailing clauses, +``getTailParameters()`` returns an empty list instead of null. Typed option +keywords are rendered in upper case. + +MySQL table and partition comments +---------------------------------- + +A table ``COMMENT`` in CREATE TABLE, CREATE TABLE … AS SELECT and ALTER TABLE is a +``StringValue`` in ``TableOption.getComment()``. Partition and subpartition comments, +including those of ALTER TABLE ADD and REORGANIZE PARTITION, are in +``PartitionDefinition.getCommentValue()``. The literal records the escaping of the +parser configuration, so ``getNotExcapedValue()`` returns the text MySQL stores. + +.. code-block:: java + + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT) COMMENT = 'it\\'s' " + + "PARTITION BY HASH (id) (PARTITION p0 COMMENT 'a\\\\b')", + parser -> parser.withDialect(Dialect.MYSQL)); + TableOption option = table.getTableOption(TableOption.Kind.COMMENT).orElseThrow(); + option.getComment().getNotExcapedValue(); // it's + option.getValue(); // 'it\'s' + table.getPartitioning().getPartitionDefinitions().get(0) + .getCommentValue().getNotExcapedValue(); // a\b + +``getValue()``, ``getTokens()``, ``CreateTable.getTableOptionsStrings()``, +``AlterExpressionTableOption.getCommentText()`` and ``PartitionDefinition.getComment()`` +still return the literal as written, and the SQL output is unchanged except that a +string prefix such as ``n'…'`` is printed in upper case, as in other string literals. +The table comment literal is rendered by the expression deparser and visited like a +column COMMENT literal. + +``setComment``, ``withComment`` and the ``TableOption.comment`` factory replace the +option's contents with the literal and select COMMENT. They keep the equals spelling, +and an existing COMMENT also keeps its name; a null literal omits the value. +``setValue`` stores a plain value and ``setTokens`` opaque tokens. Neither is parsed, +so ``getComment()`` then returns null. Selecting another kind keeps the literal's SQL +text as a plain value. A COMMENT value that is not a string literal also stays a plain +value, for example a double-quoted string parsed without the MySQL dialect, where it +is a quoted identifier. + +``PartitionDefinition.setComment(String)`` reads the SQL text of a literal with +standard escaping; pass a ``StringValue`` with another escaping to +``setCommentValue``. Inspect PostgreSQL schema statements ------------------------------------ @@ -279,7 +649,185 @@ Ordinary views expose ordered ``ViewOption`` values for ``security_barrier``, `` ``getTableElements()`` preserves the order of columns, constraints and ``LIKE`` clauses, including multiple source tables. The three legacy nullable ``LikeClause`` getters report explicit options of that kind; ``isIncluding(OptionKind)`` also resolves ``ALL`` in declaration order. A typed table's ``OF`` type is available through ``CreateTable.getOfType()``. -Table constraints expose ``Index.getNullsDistinct()``, ``getIncludeColumns()``, storage parameters and ``ConstraintAttributes``. ``ExcludeConstraint`` reuses ``Index.ColumnParams`` for its keys; each key exposes its expression and exclusion operator. Column identity clauses are represented by ``ColumnOption.Kind.IDENTITY`` and ``IdentityDefinition``, with a generation mode and ordered ``Sequence.Parameter`` values. These APIs cover the schema clauses described in `CREATE TABLE `_. +Table constraints expose their names and ``ConstraintAttributes`` independently from indexes. ``KeyConstraint`` and ``ExcludeConstraint`` expose ``IndexOptions`` for null treatment, INCLUDE columns, storage parameters and tablespace options. Their ``KeyElement`` nodes expose key expressions, ordering and exclusion operators. Column identity clauses are represented by ``ColumnOption.Kind.IDENTITY`` and ``IdentityDefinition``, with a generation mode and ordered ``Sequence.Parameter`` values. These APIs cover the schema clauses described in `CREATE TABLE `_. + +Inspect indexes and constraints separately +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +``Index`` represents index declarations. Constraints are independent +``NamedConstraint`` nodes: ``KeyConstraint`` for PRIMARY KEY/UNIQUE, +``ForeignKeyConstraint``, ``CheckConstraint``, ``ExcludeConstraint``, +``DefaultConstraint``, ``NotNullConstraint`` and ``ConstraintUsingIndex``. +Constraint nodes do not extend ``Index``. Their ``ConstraintKind`` is separate +from the physical index classification ``Index.Kind``. + +``CreateTable.getIndexes()`` returns only indexes, while +``getTableConstraints()`` returns table-level constraints. Both are mutable +views of ``getTableElements()`` when ordered elements are present; removing a +constraint preserves indexes and their source positions. To inspect column +and table constraints together, use ``getConstraints()``. This returns +``ConstraintDeclaration`` views in declaration order. + +.. code-block:: java + + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT PRIMARY KEY, label TEXT)"); + ConstraintDeclaration primary = table.getConstraints().stream() + .filter(declaration -> declaration.getKind() == ConstraintKind.PRIMARY_KEY) + .findFirst().orElseThrow(); + primary.getColumn().setColumnName("new_id"); + // CREATE TABLE t (new_id INT PRIMARY KEY, label TEXT) + +``getColumn()`` retains the owner of an inline declaration and is null for a +table constraint. ``getColumnOption()`` exposes an inline option; +``getConstraint()`` exposes its original ``NamedConstraint`` when one exists. +Column REFERENCES and nullability options retain their own payloads instead +of manufacturing a table constraint or a key-column list. Edit the original +source nodes to change SQL. Explicit NOT NULL and REFERENCES are classified; +ordinary column DEFAULT values are options, while explicit +``DefaultConstraint`` nodes are classified as DEFAULT. NULL, raw tokens and implied constraints are not +inferred. + +The declaration list is an unmodifiable membership snapshot. Its views read +live source nodes, so type edits change ``getKind()``. Request a new list after +adding, removing or changing column options. Structured constraint nodes +remain included when their kind is OTHER. Without ordered table elements, +manually constructed columns precede table constraints and indexes. + +``ColumnOption.getConstraintKind()`` and +``AlterExpression.getConstraintKind()`` also return ``ConstraintKind``. +``getOperation()`` distinguishes addition from removal. ALTER ADD constraints +use ``getConstraint()``; ADD INDEX uses ``getIndex()``. These getters expose +stored definitions; after changing an action, ``getConstraintKind()`` describes +the active syntax rather than an inactive stored definition. Column actions +retain constraints on their column options. RENAME CONSTRAINT uses +``getConstraintName()`` for the source and ``getNewConstraintName()`` for the +target; it does not manufacture index nodes. A named ``DROP CONSTRAINT pk`` reports +``OTHER`` because SQL alone does not reveal what ``pk`` names. This query does +not validate a definition's completeness or consult the database catalogue. + +MySQL table-level ``UNIQUE``, ``UNIQUE KEY`` and ``UNIQUE INDEX`` declarations +are ``KeyConstraint`` nodes. A standalone ``CREATE UNIQUE INDEX`` remains +``CreateIndex`` with an ``Index`` payload. The parser does not invent backing +index nodes for PRIMARY KEY/UNIQUE constraints. PostgreSQL ``USING INDEX`` +retains the existing index name on ``ConstraintUsingIndex`` rather than +creating key elements or an index definition. + +An ALTER foreign key owns one ``ForeignKeyConstraint`` and its mutable +``ForeignKeyReference``. The legacy ``getFk*``/``setFk*`` accessors and +referential-action helpers delegate to these same nodes, so edits through +either API affect both SQL renderers. + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE child ADD FOREIGN KEY (parent_id) REFERENCES parent (id)"); + AlterExpression action = alter.getAlterExpressions().get(0); + ForeignKeyConstraint foreignKey = (ForeignKeyConstraint) action.getConstraint(); + foreignKey.getReference().getTable().setSchemaName("archive"); + action.setFkSourceTable("parent_history"); + // Both APIs now refer to archive.parent_history. + foreignKey.setReferentialAction(ReferentialAction.Type.DELETE, + ReferentialAction.Action.CASCADE); + +New code should use the structured constraint API. ``getFkColumns()`` returns +a rendered snapshot, like ``getPkColumns()`` and ``getUkColumns()``; use +``setFkColumns()``/``addFkColumns()`` to replace or append names, or edit +``foreignKey.getColumns()`` directly. Referenced-column lists and +referential-action objects are live objects on the shared reference. + +A non-null legacy FK setter creates a foreign-key definition when none is +present. It rejects an existing non-FK constraint or index with +``IllegalStateException`` instead of retaining a second hidden definition; +replace the definition explicitly with ``setConstraint()`` first. Reading, +clearing or removing absent FK properties does not create a definition. +Replacing or clearing ``setConstraint()`` also replaces or clears what the +legacy FK accessors expose. These accessors inspect stored definitions; use +``getOperation()``/``getConstraintKind()`` to identify the active action. + +Migration from the former combined model: + +* Replace table-constraint reads from ``getIndexes()`` with + ``getTableConstraints()`` and ALTER constraint reads from ``getIndex()`` + with ``getConstraint()``. ``ConstraintDeclaration.getIndex()`` is replaced + by ``getConstraint()``. +* Replace ``ForeignKeyIndex`` with ``ForeignKeyConstraint`` and concrete + ``new NamedConstraint()`` construction with the appropriate constraint + class, usually ``KeyConstraint``. ``NamedConstraint`` is now abstract. +* Constraint enum values move from ``Index.Kind`` to ``ConstraintKind``; + ``Index.Kind`` retains only UNIQUE, INDEX, FULLTEXT, SPATIAL and OTHER. +* Shared key and option values are now ``KeyElement`` (formerly + ``Index.ColumnParams``), ``IndexOption`` (formerly ``Index.Option``) and + ``IndexOptions.Clustering`` (formerly ``Index.Clustering``). These are + standalone shared components, not aliases to nested index types. Replace + ``getColumnWithParams()``/``setColumnNamesWithParams()`` with + ``getColumns()``/``setColumns()`` using ``KeyElement`` values. + +``getType()`` preserves the rendered spelling. ``setType()`` refreshes kind +metadata for indexes and key constraints; ``setKind()`` does not rewrite SQL. +Constraints with a fixed renderer, such as CHECK, always report their actual +constraint kind. Replacing an index with a table constraint requires replacing +the AST node; changing an index's type string cannot change its Java type. + +ALTER key definitions use ``getKeyConstraint()`` for typed access to the same +object returned by ``getConstraint()``. PRIMARY KEY and UNIQUE builder setters +also create this canonical definition; they no longer keep separate column, +name or KEY/INDEX state: + +.. code-block:: java + + Alter add = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD UNIQUE KEY uq (id)", + parser -> parser.withDialect(Dialect.MYSQL)); + KeyConstraint key = add.getAlterExpressions().get(0).getKeyConstraint(); + key.setColumns(List.of(new KeyElement("account_id"))); + key.setIndexName("uq_account"); + System.out.println(add); // ALTER TABLE t ADD UNIQUE KEY uq_account (account_id) + +Parenthesized deletion targets have their own ``getDropColumns()`` and +``setDropColumns()`` API. It covers multi-column ``DROP (...)``, ``DROP UNIQUE +(...)`` and the parser's legacy parenthesized ``DROP FOREIGN KEY (...)`` form. +Named constraint drops continue to use ``getConstraintName()``. No key +definition is manufactured for a drop: + +.. code-block:: java + + Alter drop = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t DROP (old_a, old_b)"); + drop.getAlterExpressions().get(0).getDropColumns().set(0, "obsolete_a"); + System.out.println(drop); // ALTER TABLE t DROP (obsolete_a, old_b) + +``setDropColumns`` copies its input; ``getDropColumns`` returns the owned mutable +list. ``withDropColumns`` and ``addDropColumns`` also work before selecting the +operation. Stored drop targets and key definitions remain independent when an +operation changes. + +Migration of older ALTER builders: + +* ``getPkColumns()`` and ``getUkColumns()`` now consistently return snapshots, + including manually built keys. Use their setters/adders or edit + ``getKeyConstraint().getColumns()`` to change SQL. The string setters replace + elements without retaining expression or ordering attributes. +* The legacy PK accessor remains a DROP-target alias when DROP, DROP UNIQUE or + DROP FOREIGN KEY is already selected. Replace builders that set PK columns + before selecting DROP with ``withDropColumns(...)``; changing the operation + does not transfer a key definition into deletion targets. +* ``getUkName`` accesses the UNIQUE definition's index name; the constraint + symbol remains ``getKeyConstraint().getName()``. KEY/INDEX flags read that same + definition. ``setUkTypeSpecified(false)`` removes the spelling; re-enabling it + without a spelling selects INDEX. +* Non-null key setters create a definition only when none exists. They throw + ``IllegalStateException`` for a competing constraint or index; use + ``setConstraint`` for an explicit replacement. Reads and null clears never + create a definition or restore values from a replaced one. + +Exclusion keys expose ``getExclusionOperatorReference()`` for structured access +to an operator's ``schemaName``, ``name`` and ``useOperatorKeyword`` flag. In +``Dialect.POSTGRESQL``, both CREATE and ALTER accept ``WITH OPERATOR(pg_catalog.&&)``. +Editing the reference updates both statement renderers. The existing string +``getExclusionOperator()`` returns its complete SQL spelling; its setter remains +available for replacing opaque operator text. New code can construct a reference +with ``new ExclusionOperator().withSchemaName("pg_catalog").withName("&&") +.withUseOperatorKeyword(true)``. .. code-block:: java @@ -291,8 +839,120 @@ Table constraints expose ``Index.getNullsDistinct()``, ``getIncludeColumns()``, column.setUsingExpression(CCJSqlParserUtil.parseExpression("id * 10")); String updatedSql = alter.toString(); -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 `_. +Identity alterations are directly accessible through ``AlterExpression.getColumnIdentityActions()``; +the existing ``ColumnDataType.getIdentityAlterations()`` API remains available. +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)``. + + +Edit column identity actions +---------------------------- + +``getColumnIdentityActions()`` returns active ``ALTER COLUMN`` identity actions +as ``ColumnIdentityAction`` entries. Each entry exposes the editable column name +and its ordered ``IdentityAlteration`` list, without requiring a data-type cast: + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE accounts ALTER COLUMN id " + + "ADD GENERATED BY DEFAULT AS IDENTITY (CACHE 10)", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + ColumnIdentityAction column = alter.getAlterExpressions().get(0) + .getColumnIdentityActions().get(0); + column.setColumnName("account_id"); + IdentityAlteration identity = column.getIdentityAlterations().get(0); + identity.setGenerationMode(IdentityDefinition.GenerationMode.ALWAYS); + identity.getParameters().get(0).setValue(20L); + System.out.println(alter); + // ALTER TABLE accounts ALTER COLUMN account_id + // ADD GENERATED ALWAYS AS IDENTITY (CACHE 20) + +The outer list has unmodifiable membership; its entries are the original AST +nodes. Request a new list after changing action membership or switching the +outer ALTER operation. The inner alteration list is mutable: replace an entry +to change its kind, or use ``setIdentityAlterations`` to replace the ordered +actions for a column. Unrelated actions and inactive inherited payloads are +excluded. An inline identity declaration in ``ADD COLUMN`` remains a +``ColumnOption`` rather than an identity alteration. + +``getGenerationMode``/``setGenerationMode`` work for both ``ADD`` and +``SET_GENERATED``. ``getParameters``/``setParameters`` work for ``ADD`` and +``SET_PARAMETER``. ADD access delegates to its existing ``IdentityDefinition``; +replacing or clearing that definition immediately changes both views. Parameters +are ordered mutable ``Sequence.Parameter`` values, with null meaning omitted. +RESTART and DROP retain their distinct ``getRestartWith`` and ``isIfExists`` +properties. A sequence such as ``SET CACHE 10 RESTART WITH 20`` remains two +ordered alterations. + +For a newly constructed ADD action without a definition, mode and parameter +getters return null. Non-null setters create the definition; setting parameters +first uses BY DEFAULT. Null setters do not create one. This does not change the +SQL grammar or validate whether a column already has an identity in a database. + + +Column defaults on tables and views +----------------------------------- + +``AlterExpression.getColumnDefaults()`` exposes active ``SET DEFAULT`` actions +through ``ColumnDefaultAction`` for both tables and views. The returned list is +read-only, but its entries are the original mutable AST objects: + +.. code-block:: java + + for (String objectType : List.of("TABLE", "VIEW")) { + Statement statement = CCJSqlParserUtil.parse( + "ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT 1", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + List actions = statement instanceof Alter + ? ((Alter) statement).getAlterExpressions() + : ((AlterRelation) statement).getActions(); + for (AlterExpression action : actions) { + for (ColumnDefaultAction column : action.getColumnDefaults()) { + column.setDefaultExpression(new LongValue(42)); + } + } + System.out.println(statement); // SET DEFAULT 42 for either object type + } + +``getColumnName()`` and ``setColumnName()`` access the affected column. +``getDefaultExpression()`` exposes parsed expressions; ``getDefaultValue()`` +returns their SQL text. Existing ``ColumnSetDefault`` constructors still accept +opaque strings, for which ``getDefaultExpression()`` returns ``null``. +Replacing an expression also replaces any opaque value. Unrelated actions +return an empty list. This lookup follows the action's current rendering path: +changing an operation or retaining unused metadata does not make a fixed-body +action expose ``SET DEFAULT`` entries it will not render. + +``hasActiveColumnDefinitions()`` reports whether the action currently renders +its column definitions through the general ALTER body. ``getColDataTypeList()`` +continues to expose stored metadata even when another body takes precedence. +``AlterDeParser`` uses the active path, so expression visitors rewrite the +selected default or column expressions without rendering inactive metadata. +``TableDefinitionTraversal`` and the table-name finder visit the expressions +and tables belonging to the selected body. The metadata validator uses that +same selection. For example, adding a column definition to an action that still +stores an earlier foreign key renders the column and does not require the +inactive foreign table or its columns to exist. ``getConstraint()`` and +``getIndex()`` still expose the stored objects for direct inspection. + +``getActiveTableDefinition()`` returns the original definition contributing to +the current body, or ``null`` when another payload takes precedence. A legacy +``ADD CONSTRAINT`` header contributes only its keys; its unused storage options +are not traversed. Column options likewise visit only the payload selected by +their ``Kind``, including after changing an option to ``FOREIGN_OPTIONS``. + +Custom ``AlterExpression`` subclasses overriding ``appendBody`` should also +reflect their dispatch in ``usesColumnActionBody()``, ``usesGeneralBody()`` and +``hasActiveConstraintHeader()``. Subclasses rendering a separate definition can +override ``getActiveTableDefinition()``. The general-body hook also determines +``hasActiveColumnDefinitions()``. Structured column attributes ============================ @@ -319,11 +979,131 @@ Charset remains in ``ColDataType.getCharacterSet()``; column collation is in its COLLATE option. Consumers can map both directly without reconstructing tokens. StringValue comment bodies retain their SQL escape representation. -The legacy ``getColumnSpecs()`` returns a token snapshot when options are -structured; expression fragments may occupy one token and structured keywords -use canonical capitalization. Mutate the option objects to change the AST. -``addColumnSpecs`` preserves existing options; ``setColumnSpecs`` explicitly -replaces them with raw specifications. +A column DEFAULT value ends before a COLLATE at its top level, which becomes the +column's COLLATE option: MySQL's DEFAULT literal and PostgreSQL's DEFAULT ``b_expr`` +do not include COLLATE. A COLLATE inside parentheses, function arguments or a CASE +expression stays in the default expression. ``SET DEFAULT`` actions and CREATE +DOMAIN keep an expression COLLATE. + +Migration: ``DEFAULT 'N' COLLATE utf8mb4_bin`` in a column definition previously +produced one DEFAULT option holding a ``CollateExpression``. It now produces a +DEFAULT option with ``'N'`` and a COLLATE option with ``getCollation()``; +``getColumnSpecs()`` returns ``[DEFAULT, 'N', COLLATE, utf8mb4_bin]``. SQL output +is unchanged. + +MySQL column attributes have their own kinds: ``SRID`` (``getSrid()``), +``COLUMN_FORMAT`` (``getColumnFormat()``: FIXED, DYNAMIC or DEFAULT), and +``ENGINE_ATTRIBUTE``/``SECONDARY_ENGINE_ATTRIBUTE`` (``getEngineAttribute()`` +and ``isUseEquals()`` for the optional equals sign). Engine attribute literals +are visited and rendered like comment literals. Inline ``UNIQUE KEY`` is one +``KeyConstraint`` of type ``UNIQUE KEY``. A bare inline ``KEY``, MySQL's column +synonym for PRIMARY KEY, keeps its ``KEY`` spelling and reports +``ConstraintKind.PRIMARY_KEY``. Other values, such as Percona Server's +``COLUMN_FORMAT COMPRESSED``, remain opaque options. + +.. code-block:: java + + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT KEY, g POINT SRID 4326 COLUMN_FORMAT FIXED)"); + List columns = table.getColumnDefinitions(); + columns.get(0).getColumnOptions().get(0).getConstraintKind(); // PRIMARY_KEY + ColumnOption srid = columns.get(1).getColumnOptions().get(0); + srid.getSrid(); // 4326 + srid.setSrid(0); + columns.get(1).addColumnOptions( + ColumnOption.engineAttribute(new StringValue("{}"))); + // CREATE TABLE t (id INT KEY, g POINT SRID 0 COLUMN_FORMAT FIXED ENGINE_ATTRIBUTE '{}') + +Migration: these attributes were previously one opaque option per token, and +``UNIQUE KEY`` was a UNIQUE constraint followed by an opaque ``KEY``. Inspect the +kinds instead of the opaque nodes. ``getColumnSpecs()`` and ``getTokens()`` keep +the previous token split, for example ``[SRID, 4326]`` and ``[UNIQUE, KEY]``. +When constructing the KEY spelling, set the kind after the type: +``new KeyConstraint().withType("KEY").withKind(ConstraintKind.PRIMARY_KEY)``. +``CHAR(n) BINARY`` remains an opaque option: MySQL treats ``BINARY`` as part of +the data type's character set clause, not as a column attribute. + +``ColumnDefinition`` stores all options in one ordered list, including opaque +``ColumnOption.Kind.OTHER`` nodes. ``getColumnOptions()`` returns that mutable +list. ``getColumnSpecs()`` returns an **unmodifiable snapshot** for both raw and +structured options; expression fragments may occupy one token and structured +keywords use canonical capitalization. Unset options return null; an explicitly +empty list returns an empty snapshot. + +.. code-block:: java + + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT DEFAULT 1)"); + ColumnDefinition column = table.getColumnDefinitions().get(0); + column.getColumnOptions().get(0).setDefaultExpression(new LongValue(2)); + column.addColumnSpecs("NOT", "NULL"); // keeps the structured DEFAULT node + // CREATE TABLE t (id INT DEFAULT 2 NOT NULL) + +Migration: calls such as ``getColumnSpecs().add(...)`` or ``.set(...)`` now throw +``UnsupportedOperationException`` instead of sometimes changing the AST and +sometimes editing a discarded copy. Use ``addColumnSpecs`` to append raw tokens, +edit the option nodes directly, or pass a modified token-list copy to +``setColumnSpecs`` to replace every option with opaque text. Raw tokens are never +automatically parsed. Consequently ``getColumnOptions()`` is also non-null for +raw specifications; inspect ``Kind`` to distinguish them. + +The constructor and ``setColumnSpecs`` copy supplied tokens. ``setColumnOptions`` +copies list membership but retains the mutable child nodes; later changes to the +caller's list do not change the column. Both getters return null after either +setter receives null. Appending preserves the current nodes and accepts an +immutable input list. An empty append preserves existing options and creates an +empty option list when none was set. + +``ColumnOption.getTokens()`` and ``GeneratedColumnDefinition.getTokens()`` also +return unmodifiable, detached snapshots. Reading tokens does not detach the +underlying expressions or other child nodes: their setters and direct edits +remain visible in SQL output, visitors and newly requested snapshots. + +For opaque ``Kind.OTHER`` options, copy the tokens, edit the copy, then call +``setTokens``. The setter and both ``ColumnOption.raw`` factories copy their +inputs; subsequent changes to the supplied list or array do not edit the AST. +Null raw tokens remain unset and return null; an empty list returns an empty +snapshot. Raw tokens are never parsed or classified. + +.. code-block:: java + + ColumnOption raw = ColumnOption.raw("SELECTIVITY", "10"); + List tokens = new ArrayList<>(raw.getTokens()); + tokens.set(1, "20"); + raw.setTokens(tokens); // SELECTIVITY 20 + +Migration: raw token getter edits now throw ``UnsupportedOperationException``, +as do edits to structured token snapshots that previously changed a discarded +copy. ``setTokens`` only accepts opaque options; it throws +``IllegalStateException`` for structured options, including SERIAL DEFAULT +VALUE. Use typed setters for structured edits. To explicitly replace a +structured option with raw text, replace its node in the column's option list: + +.. code-block:: java + + column.getColumnOptions().set(0, ColumnOption.raw("DEFAULT", "8")); + +MySQL column positions +~~~~~~~~~~~~~~~~~~~~~~ + +The trailing ``FIRST`` or ``AFTER column`` of an ALTER TABLE ADD, CHANGE or +MODIFY column definition is a ``ColumnPosition`` on the +``AlterExpression.ColumnDataType``, not a column option. ``getColumnSpecs()`` +still ends with its tokens, and ``setColumnSpecs`` replaces the options and the +position. Migration: ``getColumnOptions()`` no longer contains the two opaque +``AFTER`` and column-name nodes. As in MySQL, the position must follow the +column attributes; a position followed by further attributes is now rejected. + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD COLUMN c INT NOT NULL AFTER id"); + AlterExpression.ColumnDataType column = + alter.getAlterExpressions().get(0).getColDataTypeList().get(0); + column.getPosition().getColumnName(); // id + column.getColumnSpecs(); // [NOT, NULL, AFTER, id] + column.setPosition(ColumnPosition.first()); + // ALTER TABLE t ADD COLUMN c INT NOT NULL FIRST Inspect logical replication statements ====================================== @@ -361,7 +1141,7 @@ See `CREATE PUBLICATION `_ and `ALTER TYPE `_. ``CreateDomain`` stores a ``ColDataType``, default expression and ordered ``DomainConstraint`` nodes. Each constraint distinguishes nullability from a check expression and preserves its optional name. ``AlterDomain`` models default/nullability changes, constraint actions, ownership, renaming and schema moves. Its ``isNotValid()`` flag describes the newly added check constraint. Domain expressions participate in statement visitors, expression deparsers and validation. @@ -385,6 +1183,94 @@ Type names, domain names and routine signatures are not reported as tables by `` See PostgreSQL's documentation for `CREATE TYPE `_, `ALTER TYPE `_, `CREATE DOMAIN `_ and `ALTER EXTENSION `_. +Inspect operator and aggregate definitions +========================================== + +PostgreSQL's operator and aggregate DDL parses to typed statements that reuse the models of +``DROP OPERATOR``, ``DROP AGGREGATE`` and ``CREATE TYPE``: an operator is an ``ExclusionOperator`` +(schema and symbol) or an ``OperatorSignature`` (with its operand types, ``null`` for ``NONE``), an +aggregate is a ``RoutineReference``, and a definition list holds ``DefinitionElement`` items with a +``DefinitionArgument``. PostgreSQL checks the names and values of a definition when it runs the +statement, so they are not restricted. + +.. list-table:: + :header-rows: 1 + :widths: 45 55 + + * - Statement + - Model + * - ``CREATE OPERATOR [schema.]op (definition)`` + - ``CreateOperator``: ``getOperator()``, ``getDefinition()``, ``getDefinitionElement(name)`` + * - ``ALTER OPERATOR op (left, right) {OWNER TO | SET SCHEMA | SET (...)}`` + - ``AlterOperator``: ``getOperator()``, ``getAction()``, ``getNewName()``, ``getProperties()`` + * - ``CREATE OPERATOR CLASS name [DEFAULT] FOR TYPE type USING method [FAMILY family] AS ...`` + - ``CreateOperatorClass``: ``getName()``, ``isDefaultClass()``, ``getDataType()``, + ``getAccessMethod()``, ``getFamily()``, ``getItems()`` + * - ``ALTER OPERATOR CLASS name USING method {RENAME TO | OWNER TO | SET SCHEMA}`` + - ``AlterOperatorClass``: ``getName()``, ``getAccessMethod()``, ``getAction()``, + ``getNewName()`` + * - ``CREATE OPERATOR FAMILY name USING method`` + - ``CreateOperatorFamily``: ``getName()``, ``getAccessMethod()`` + * - ``ALTER OPERATOR FAMILY name USING method {ADD ... | DROP ... | RENAME TO | OWNER TO | SET SCHEMA}`` + - ``AlterOperatorFamily``: ``getName()``, ``getAccessMethod()``, ``getAction()``, + ``getItems()``, ``getNewName()`` + * - ``CREATE [OR REPLACE] AGGREGATE name (arguments) (definition)`` and the old + ``CREATE AGGREGATE name (BASETYPE = type, ...)`` + - ``CreateAggregate``: ``isOrReplace()``, ``getAggregate()``, ``isOldStyle()``, + ``getDefinition()``, ``getDefinitionElement(name)`` + * - ``ALTER AGGREGATE name (arguments) {RENAME TO | OWNER TO | SET SCHEMA}`` + - ``AlterAggregate``: ``getAggregate()``, ``getAction()``, ``getNewName()`` + +``getNewName()`` is the new name, the role or the schema of the action. An ``OperatorClassItem`` +is one member of an operator class or family: its ``Kind`` is ``OPERATOR``, ``FUNCTION`` or +``STORAGE``, with the strategy or support number, the operator and its optional operand types, the +``Purpose`` (``FOR SEARCH`` or ``FOR ORDER BY`` with ``getSortFamily()``), the function as a +``RoutineReference``, or the storage type. A member that ``ALTER OPERATOR FAMILY ... DROP`` removes +has a kind, a number and operand types only. + +.. code-block:: java + + CreateOperator operator = (CreateOperator) CCJSqlParserUtil.parse( + "CREATE OPERATOR app.=== (FUNCTION = app.eq, LEFTARG = int, RIGHTARG = int, " + + "NEGATOR = OPERATOR(app.!==), HASHES)"); + operator.getOperator().getSchemaName(); // app + operator.getOperator().getName(); // === + operator.getDefinitionElement("NEGATOR").getArgument().getOperator(); // app.!== + operator.getDefinitionElement("HASHES").getArgument(); // null + + CreateOperatorClass operatorClass = (CreateOperatorClass) CCJSqlParserUtil.parse( + "CREATE OPERATOR CLASS oc DEFAULT FOR TYPE int4 USING btree AS " + + "OPERATOR 1 < (int4, int4), FUNCTION 1 btint4cmp(int4, int4)"); + OperatorClassItem item = operatorClass.getItems().get(0); + item.getNumber(); // 1 + item.getOperator().getName(); // < + item.getOperandTypes(); // [int4, int4] + + CreateAggregate aggregate = (CreateAggregate) CCJSqlParserUtil.parse( + "CREATE AGGREGATE app.total (numeric ORDER BY int) (SFUNC = app.add, STYPE = numeric)"); + aggregate.getAggregate().getName(); // app.total + aggregate.getAggregate().getOrderByArguments(); // [int] + aggregate.getDefinitionElement("STYPE").getArgument().getDataType(); // numeric + +An operator name is one name with its exact text, such as ``===``, ``<==>`` or ``@#@``, wherever +PostgreSQL DDL names an operator. It follows the rules of PostgreSQL's lexer: the parts must touch +each other, a name of several characters ends in ``+`` or ``-`` only if it contains one of +``~ ! @ # % ^ & | ?``, ``=>`` alone is not an operator, and a name has at most 63 characters. A +database may precede the schema (``db.schema.+``); ``getSchemaName()`` then returns both. An +operator that contains a backtick is not supported, and without ``Dialect.POSTGRESQL`` the lexer +reads ``#`` before ``#``, ``@`` or a letter as the start of a name. An aggregate signature is +``*`` or has at least one argument, so ``agg()`` is rejected wherever an aggregate is named. + +Without a dialect, ``CREATE OPERATOR`` and ``ALTER OPERATOR`` are read this way when an operator +symbol follows, so Oracle's ``CREATE OPERATOR name BINDING ...`` stays an +``UnsupportedStatement``, and so do MySQL's ``CREATE AGGREGATE FUNCTION`` and SQL Server's +``CREATE AGGREGATE name (@parameter type) ...``. With ``Dialect.POSTGRESQL`` they are parse +errors. Validators report ``createOperator``, ``alterOperator``, ``createOperatorClass``, +``alterOperatorClass``, ``createOperatorFamily``, ``alterOperatorFamily``, ``createAggregate`` +and ``alterAggregate``, which PostgreSQL enables. + +See `CREATE OPERATOR `_, `ALTER OPERATOR `_, `CREATE OPERATOR CLASS `_, `ALTER OPERATOR CLASS `_, `CREATE OPERATOR FAMILY `_, `ALTER OPERATOR FAMILY `_, `CREATE AGGREGATE `_ and `ALTER AGGREGATE `_. + Classify a Statement ============================== @@ -468,7 +1354,7 @@ The features - ``SELECT``, ``DELETE .. RETURNING``, ``SHOW``, ``DESCRIBE``, ``EXPLAIN`` * - ``MODIFIES_DATA`` - rows are written or destroyed - - ``INSERT``, ``UPDATE``, ``DELETE``, ``MERGE``, ``UPSERT``, ``TRUNCATE``, ``DROP`` + - ``INSERT``, ``UPDATE``, ``DELETE``, ``MERGE``, ``UPSERT``, ``TRUNCATE``, ``DROP``, ``ALTER TABLE .. TRUNCATE PARTITION`` * - ``MODIFIES_SCHEMA`` - the catalogue changes - ``CREATE``, ``ALTER``, ``DROP``, ``TRUNCATE``, ``GRANT``, ``COMMENT`` @@ -522,7 +1408,7 @@ Convenience methods wrap the common combinations: features.modifiesSchema(); // is(MODIFIES_SCHEMA) features.isOpaque(); // CALL, EXECUTE, dynamic SQL -When something is merely *possible*, the analysis tells you **why**, so you can resolve it against your own catalogue or allow-list rather than guessing: +When the analysis identifies an unresolved function, procedure or dynamic SQL marker, it records the reference so you can consult your own catalogue or allow-list: .. code-block:: java :caption: Safeguarding a read-only connection @@ -535,6 +1421,10 @@ When something is merely *possible*, the analysis tells you **why**, so you can // e.g. [nextval] } +The generic fallback for an unclassified statement preserves ``OPAQUE`` and the possible effects ``READS_DATA``, ``RETURNS_RESULT_SET``, ``MODIFIES_DATA`` and ``MODIFIES_SCHEMA``, but does not add a Java statement or container class name to ``getUnresolvedReferences()``. The reference set can therefore be empty while the effects remain unknown. Check ``isOpaque()`` and ``may(..)``; an empty reference set alone does not establish safety. + +Existing explicit references and markers remain, including procedure and function names, ``do``, ``unsupported`` and ``explain``. Stored routine declarations also retain their existing statement-type markers, such as ``createfunction``; these are independent of the generic fallback. + If you can prove some functions side-effect free, hand in a predicate and the uncertainty collapses: .. code-block:: java @@ -595,6 +1485,8 @@ Find Table Names tableNames = TablesNamesFinder.findTablesInExpression(exprStr); assertThat( tableNames ).containsExactlyInAnyOrder("A", "B", "C"); +A name is left out only where it resolves to a ``WITH`` item in scope. An alias hides no table, and without ``RECURSIVE`` a ``WITH`` item does not see itself or the items after it. The target of a DML statement is always reported. So the result may hold names that are no tables on some databases, such as a ``WITH`` item that recurses without ``RECURSIVE``: check it against the metadata of the database if that matters. + Use the Visitor Patterns ============================== @@ -704,6 +1596,49 @@ Statement lists and nested blocks share the separator policy used by semicolon settings. Custom deparsers receive each child statement and the ``IF/ELSE`` condition through the visitor API, with the supplied context. +Customize JSON expression output +-------------------------------- + +``ExpressionDeParser`` visits structured children of ``JsonFunction`` and +``JsonTableFunction`` while rendering them. A custom expression printer can +rewrite inputs, paths, PASSING values and DEFAULT expressions, including nested +JSON_TABLE columns, without changing the AST. JSON object keys and values are +visited when they are ``Expression`` objects; opaque objects and additional +query-path strings retain their existing rendering. + +.. code-block:: java + + Statement statement = CCJSqlParserUtil.parse( + "SELECT JSON_VALUE((SELECT doc FROM source_table), '$.a')"); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(Column column, S context) { + return getBuilder().append("payload"); + } + }; + statement.accept(new StatementDeParser(expressions, new SelectDeParser(), + expressions.getBuilder()), null); + // SELECT JSON_VALUE((SELECT payload FROM source_table), '$.a') + +``StatementDeParser`` connects the select and expression printers, so subqueries +inside JSON expressions use the same printer. For expression-only use with +subqueries, connect an appropriate ``SelectDeParser`` explicitly. + +JSON nodes also expose ``appendTo(StringBuilder, Consumer)`` for +direct rendering. The consumer prints each child into the same builder; +``ExpressionDeParser`` forwards the visitor context through that callback. +``JsonFunction`` additionally has consumer overloads of ``appendObject``, +``appendArray``, ``appendValue``, ``appendQuery`` and ``appendExists``. + +Subclass migration: override these consumer overloads or ``appendTo`` to +customize both default and visitor output. The deparser enters through ``appendTo``; +overriding only a legacy single-argument ``append*`` or ``toString()`` method does +not customize that path. ``JsonFunction`` also uses the consumer overloads for +type-specific default rendering. Subclasses of concrete JSON_TABLE column +definitions should move ``toString()`` customization +to ``appendTo``. Direct subclasses of the abstract ``JsonTableColumnDefinition`` +retain their opaque ``toString()`` fallback until they override ``appendTo``. + ODBC timestamp intervals ============================== @@ -730,7 +1665,12 @@ open. These empty-input results replace the previous null returns of these metho By default a syntax error aborts the whole parse. Two features let a script survive one bad statement: - ``parser.withErrorRecovery(true)`` skips to the next statement separator and returns an empty statement. -- ``parser.withUnsupportedStatements(true)`` returns an ``UnsupportedStatement`` holding the raw text instead — though the **first** statement must be a regular one. +- ``parser.withUnsupportedStatements(true)`` captures an unrecognised statement root as + ``UnsupportedStatement``; it may be the first statement. Failures in recognised statement + grammar still throw, or use ``withErrorRecovery(true)`` and record the error. Thus + ``SELECT * FROM``, ``INSERT INTO t (a`` and ``UPDATE t SET`` do not become opaque statements. + The two options serve different purposes; enabling unsupported capture does not suppress + recognised syntax errors. .. code-block:: java :caption: Error Recovery @@ -750,19 +1690,27 @@ By default a syntax error aborts the whole parse. Two features let a script surv :caption: Unsupported Statement Statements statements = CCJSqlParserUtil.parseStatements( - "select * from mytable; select from; select * from mytable2; select 4;" + "select * from mytable; shutdown defrag; select * from mytable2; select 4;" , parser -> parser.withUnsupportedStatements() ); // 4 statements with one Unsupported Statement holding the content assertEquals(4, statements.size()); assertInstanceOf(UnsupportedStatement.class, statements.get(1)); - assertEquals("select from", statements.get(1).toString()); + assertEquals("shutdown defrag", statements.get(1).toString()); // no errors records, because a statement has been returned assertEquals(0, parser.getParseErrors().size()); .. note:: + Opaque capture is not SQL validation. An unrecognised root or an existing opaque + grammar branch cannot establish validity in an unknown dialect. Callers that need + validity must validate against that dialect. Recognised syntax failures formerly + captured by the generic fallback now throw or produce an error-recovery placeholder; + partial IF results and typed prefixes with invalid trailing clauses are not published + as successful statements. ``SingleStatement()`` remains an incremental entry point; + use ``Statement()`` or ``Statements()`` to check complete statement boundaries. + An ``UnsupportedStatement`` is reported as ``OPAQUE`` by :ref:`Classify a Statement` — nothing about its effects is knowable. @@ -808,9 +1756,61 @@ One grammar covers every supported RDBMS, but a few pieces of syntax mean differ - ``ALTER TABLE ... ALTER PRIMARY KEY USING COLUMNS (...)`` with optional hash sharding and storage parameters * - ``TERADATA`` - ``UPDATE target FROM sources SET ...`` with the FROM clause before SET + * - ``SQLITE`` + - ``INSERT OR ABORT``, ``INSERT OR FAIL``, ``INSERT OR IGNORE`` and ``INSERT OR ROLLBACK`` conflict clauses; + ``UPDATE OR`` with any of ``ABORT``, ``FAIL``, ``IGNORE``, ``REPLACE`` and ``ROLLBACK`` Features set explicitly *after* the preset win over it. +MySQL comments +~~~~~~~~~~~~~~ + +With ``Dialect.MYSQL``, ``--`` starts a line comment only when followed by +whitespace or a control character. Thus ``SELECT 1--2`` contains subtraction +and a negative operand. SQL inside an unversioned executable comment is parsed +normally: ``SELECT 1 /*! + 2 */`` becomes ``SELECT 1 + 2``. Optimizer hints +(``/*+ ... */``) remain separate from executable comments. + +Conditional executable comments require an explicit target server version: + +.. code-block:: java + + Statement stmt = CCJSqlParserUtil.parse( + "SELECT 1 /*!90702 + 2 */", + parser -> parser.withDialect(Dialect.MYSQL).withMySqlServerVersion(90702)); + +The value is ``major * 10000 + minor * 100 + patch``; for example, ``90702`` +means 9.7.2 and ``260700`` means 26.7.0. Five-digit and six-digit comment version +prefixes follow MySQL's whitespace rules. SQL for a newer server is ignored; +SQL for the configured version or an older one participates in the AST. +Both SQL renderers produce the resolved SQL for that target, without the +conditional wrappers. Without a target, a conditional executable comment +raises an error instead of silently discarding its SQL. This replaces the +previous treatment of all executable comments as ordinary discarded comments. +The same configuration applies to parsers constructed with a ``StreamProvider`` +or ``FeatureConfiguration``. Other dialects retain their comment behavior. +Nested executable comments are rejected; nested-comment acceptance in other +dialects is not a guarantee that the same SQL is valid on MySQL. + +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 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -837,6 +1837,61 @@ responsibility. When constructing a ``ColDataType`` directly, use ``null`` for omitted parameters. The legacy ``int`` constructor continues to treat negative arguments as omitted parameters. +String literal values +~~~~~~~~~~~~~~~~~~~~~ + +``StringValue.getValue()`` returns the literal body as written, and ``toString()`` +renders it unchanged. ``getNotExcapedValue()`` returns the characters it denotes. +A doubled quote of the literal's own quote character is resolved, so +``"it""s"`` yields ``it"s``. ``getEscaping()`` records how the parser read +backslashes: + +* ``MYSQL_BACKSLASH`` without a dialect or with ``Dialect.MYSQL``/``MARIADB`` when + backslash escapes are enabled: ``'it\'s'`` yields ``it's``, ``\n``, ``\t``, + ``\0`` and ``\Z`` become their characters, and ``\%`` and ``\_`` keep their backslash. +* ``POSTGRESQL_ESCAPE_STRING`` for ``E'...'`` with ``Dialect.POSTGRESQL``, including + ``\x``, octal and ``\u`` escapes; octal and hexadecimal escapes are UTF-8 bytes. +* ``POSTGRESQL_UNICODE_ESCAPE`` for ``U&'...'``, see + `PostgreSQL Unicode escape strings`_. +* ``STANDARD`` otherwise, including dollar-quoted strings and constructed values; + backslashes stay literal. Other dialects with backslash escapes keep this reading. + +``setEscaping()`` selects the reading for a constructed value. Escaping is not +part of ``equals()``, like the quote character. + +PostgreSQL Unicode escape strings +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +With ``Dialect.POSTGRESQL``, ``U&'...'`` and an optional ``UESCAPE 'c'`` clause form one +``StringValue``. Its prefix is ``U&``, ``getValue()`` returns the body as written, and +``toString()`` renders the literal with its clause. ``getUnicodeEscapeCharacter()`` returns +the ``UESCAPE`` character, or ``null`` without the clause, when the escape character is a +backslash. ``getNotExcapedValue()`` resolves the escapes as PostgreSQL does: + +* the escape character followed by four hexadecimal digits, or by ``+`` and six, is that + code point. A character above U+FFFF can also be written as a UTF-16 surrogate pair of + two escapes; +* a doubled escape character and a doubled quote stand for themselves. + +.. code-block:: java + + Comment comment = (Comment) CCJSqlParserUtil.parse( + "COMMENT ON TABLE t IS U&'d!0061t!+000061' UESCAPE '!'", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + comment.getComment().getNotExcapedValue(); // "data" + comment.toString(); // COMMENT ON TABLE t IS U&'d!0061t!+000061' UESCAPE '!' + +* The parser rejects what PostgreSQL rejects: + an escape without its digits, code point 0 or one above U+10FFFF, an unpaired surrogate, + and an escape character that is a hexadecimal digit, ``+``, a quote, whitespace or not ASCII. + ``getNotExcapedValue()`` throws ``IllegalArgumentException`` for such a constructed value. +* Without ``Dialect.POSTGRESQL``, ``U&'x'`` keeps its previous reading: the column ``U``, + the ``&`` operator and the string ``'x'``. +* ``UESCAPE`` may follow the literal after spaces, tabs or newlines, but not after a comment + or a continuation line. +* ``U&"..."`` quoted identifiers are not supported. +* The ``UESCAPE`` character is not part of ``equals()``, like the escaping. + Other dialect-specific syntax ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -853,7 +1908,7 @@ both the position and the brackets around a Doris hint. CockroachDB primary-key changes require ``parser.withDialect(Dialect.COCKROACHDB)``. Their action is an ``AlterExpressionPrimaryKey`` with key elements and storage -parameters in ``getIndex()``. ``isUsingHash()`` preserves ``USING HASH``, while +parameters in ``getConstraint()``. ``isUsingHash()`` preserves ``USING HASH``, while ``getBucketCount()`` holds the legacy ``WITH BUCKET_COUNT = expression`` value. The newer ``WITH (bucket_count = expression)`` form uses the index storage parameters. @@ -943,7 +1998,7 @@ operator-class names, for example ``name COLLATE pg_catalog."C" pg_catalog.text_ops ASC NULLS LAST``. Function keys such as ``lower(name)`` are stored as expressions. Key attributes are available through ``getCollation()``, ``getOperatorClass()``, ``getOperatorClassParameters()``, ``getSortOrder()`` and -``getNullOrdering()`` on ``Index.ColumnParams``. Under this dialect these +``getNullOrdering()`` on ``KeyElement``. Under this dialect these attributes are not duplicated in the legacy ``getParams()`` list, so changing or removing them is reflected when rendering SQL. Other dialects retain the legacy parameter representation, including MySQL prefix lengths. @@ -1039,9 +2094,11 @@ The individual features * - ``withBackslashEscapeCharacter`` - ``\\..`` escaping inside string literals, in addition to the standard ``'..`` doubling * - ``withDoubleQuotedStrings`` - - ``".."`` reads as a string literal instead of a quoted identifier (BigQuery, Spark/Databricks, MySQL default ``sql_mode``) + - ``".."`` reads as a string literal instead of a quoted identifier (BigQuery, Spark/Databricks, MySQL default ``sql_mode``); combined with ``withBackslashEscapeCharacter``, ``\\"`` does not end the literal, as in MySQL ``"it\\"s"`` * - ``withHashLineComments`` - ``#`` starts a line comment + * - ``withBlankLinesAsSeparator`` + - ``false`` stops two empty lines (``\n\n\n``) ending a statement, so they read as plain whitespace * - ``withAdjacentStringLiterals`` - adjacent string literals concatenate: ``NEWLINE`` (SQL standard, PostgreSQL) or ``WHITESPACE`` (GoogleSQL, Spark/Databricks); ``true`` selects ``NEWLINE``, ``false`` switches it off * - ``withAllowComplexParsing`` @@ -1134,12 +2191,26 @@ the PostgreSQL ``CreateRole`` AST for this ambiguous form:: "CREATE USER app", parser -> parser.withDialect(AbstractJSqlParser.Dialect.POSTGRESQL)); +MySQL account names (``user[@host]``) of ``CREATE USER`` and of view, trigger and +routine ``DEFINER`` clauses share one grammar rule and are read into separate user +and host ``StringValue`` parts (``UserAccount`` and ``MySqlDefiner``). Every MySQL +spelling is accepted, including ``app@localhost``, ``app@'%'`` and +``'app'@localhost``. A part quoted with ``'``, ``"`` or a backquote keeps its quote +character in ``getQuoteStr()`` and its text in ``getValue()``:: + + CreateUser createUser = (CreateUser) CCJSqlParserUtil.parse( + "CREATE USER `app`@'%' IDENTIFIED BY 'secret'"); + UserAccount account = createUser.getAccounts().get(0); + account.getUser().getValue(); // app + account.getUser().getQuoteStr(); // ` + account.getHost().getValue(); // % + ``Grant`` retains its string-based getters, setters and fluent methods. Its ``PrivilegeClause`` exposes typed ``Privilege`` items, column lists, ``PrivilegeTarget`` kinds, multiple role memberships and grantor information. ``getPrivileges()`` is a mutable string view of the typed privilege list. ``getRole()`` and ``getObjectName()`` expose the first role or named target for -legacy callers; use ``getRoles()`` and ``getTarget()`` for the complete lists. +legacy callers; use ``getRoleItems()`` and ``getTarget()`` for the complete lists. Names in ``PrivilegeTarget`` are multipart identifiers, not SQL clause text. Routine targets use ``RoutineReference`` data-type signatures, with null arguments for an omitted signature and an empty list for explicit ``()``. @@ -1158,7 +2229,7 @@ role values, trigger conditions and invocation arguments. Declaring a trigger is classified as a schema change, not execution of its body. Capability validation covers these statement families, not every server-version -or catalog-dependent restriction. EVENT TRIGGER is outside this support. +or catalog-dependent restriction. Event triggers use separate statements, described below. Serialized role SQL can contain passwords; avoid logging real credentials. References: `CREATE ROLE `_, @@ -1168,6 +2239,158 @@ References: `CREATE ROLE `_, `CREATE TRIGGER `_. +MySQL privileges and accounts in GRANT and REVOKE +------------------------------------------------- + +``Grant`` and ``Revoke`` also parse the MySQL forms, in every dialect: + +- **Privilege levels**: ``PrivilegeTarget.getWildcard()`` is ``DEFAULT_DATABASE`` for ``*``, + ``GLOBAL`` for ``*.*`` and ``DATABASE`` for ``db.*``, whose database is the single entry + of ``getNames()``. Named levels such as ``db.tbl`` keep a null wildcard. Only named + table targets are reported by table-name discovery. +- **Privileges**: MySQL static privileges are ``Privilege.Kind`` constants, for example + ``CREATE_TEMPORARY_TABLES`` or ``REPLICATION_SLAVE``; ``getName()`` returns the SQL + spelling. Another identifier, such as ``BACKUP_ADMIN``, is a dynamic privilege of kind + ``DYNAMIC`` with ``getDynamicName()``. +- **Grantees**: ``PrivilegeClause.getGranteeItems()`` returns ``Grantee`` values, which + MySQL and PostgreSQL share. ``ACCOUNT`` holds a ``UserAccount``: a MySQL ``user[@host]``, + read like the ``CREATE USER`` account names above, or a PostgreSQL role name without + host. The other kinds are + PostgreSQL ``GROUP name``, ``PUBLIC``, ``CURRENT_USER`` (MySQL also ``CURRENT_USER()``), + ``CURRENT_ROLE`` and ``SESSION_USER``. ``getGrantor()`` types ``GRANTED BY`` the same way. +- **Role memberships**: ``getRoleItems()`` holds the granted roles as ``UserAccount`` + values, so ``'reader'`` and ``'writer'@'%'`` keep their quoting and host. A membership + has no privileges and no target. +- **MySQL clauses**: ``PROXY ON user`` is a ``PROXY`` privilege on an ``ACCOUNT`` target + (``PrivilegeTarget.getAccount()``). ``REVOKE ALL [PRIVILEGES], GRANT OPTION FROM ...`` + has the privileges ``ALL`` and ``GRANT_OPTION`` and no target. ``Revoke`` records + ``IF EXISTS`` and ``IGNORE UNKNOWN USER``; ``Grant.getAsUser()`` and ``getWithRole()`` + hold ``AS user [WITH ROLE ...]``; the role selection is a ``RoleSelection`` from + ``net.sf.jsqlparser.statement.create.user``. + +.. code-block:: java + + Grant grant = (Grant) CCJSqlParserUtil.parse( + "GRANT SELECT, BACKUP_ADMIN ON db1.* TO 'app'@'%', CURRENT_USER"); + grant.getTarget().getWildcard(); // DATABASE + grant.getPrivilegeItems().get(1).getDynamicName(); // BACKUP_ADMIN + UserAccount app = grant.getClause().getGranteeItems().get(0).getAccount(); + app.getHost().getValue(); // % + +``Grant.getOptions()`` lists every ``WITH`` option, including PostgreSQL membership +options such as ``WITH INHERIT TRUE, SET FALSE``. Privileges take only ``GRANT OPTION``; +memberships take distinct ``ADMIN``, ``INHERIT`` and ``SET`` options. + +The string accessors are kept and derived from the typed state: ``getUsers()``, +``getGrantees()`` and ``getRoles()`` are mutable string views that write through, +``getOption()`` is the first option and ``getGrantedBy()`` renders the grantor. +``getObjectName()`` returns a wildcard level as written, for example ``db1.*``, and +``setObjectName()`` replaces it with a named target. Assigned text is converted with +``Grantee.valueOf()``: special role names are recognized and other text is kept as the +account name. Parsed memberships have no target; ``new Grant()`` still starts with an +empty table target, and ``setRole()`` clears it. + +The MySQL and MariaDB validation capabilities now include ``revoke``. + +References: `GRANT `_, +`REVOKE `_, +`Specifying Account Names `_. + +PostgreSQL event triggers, REINDEX, SECURITY LABEL and schema elements +---------------------------------------------------------------------- + +``CREATE EVENT TRIGGER`` parses to ``CreateEventTrigger``. ``getEvent()`` keeps the event +name as written and ``getFilters()`` the ``WHEN … IN (…)`` conditions in source order. The +invoked function reuses ``CreateTrigger.ExecuteKeyword`` and a ``Function`` without +arguments. ``ALTER EVENT TRIGGER`` parses to ``AlterEventTrigger``; its states reuse +``RelationAlterAction.EnableState``, and each non-null setter selects the ``STATE``, +``OWNER`` or ``RENAME`` action. A MySQL event named ``trigger`` still parses to +``CreateEvent`` or ``AlterEvent``. + +.. code-block:: java + + CreateEventTrigger trigger = (CreateEventTrigger) CCJSqlParserUtil.parse( + "CREATE EVENT TRIGGER etg ON ddl_command_start " + + "WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION abort_any_command()"); + trigger.getEvent(); // ddl_command_start + trigger.getFilters().get(0).getVariable(); // TAG + trigger.getFunction().getName(); // abort_any_command + +``REINDEX`` parses to ``Reindex``: a ``Target`` (INDEX, TABLE, SCHEMA, DATABASE or SYSTEM), +the ``CONCURRENTLY`` keyword, the parenthesized ``CONCURRENTLY``, ``TABLESPACE`` and +``VERBOSE`` options with their values as written, and the object name. Only DATABASE and +SYSTEM may omit the name. ``getTable()`` returns the name only for ``REINDEX TABLE``, which +table visitors report. ``REINDEX`` is a non-reserved keyword. + +``SECURITY LABEL`` parses to ``SecurityLabel`` with the provider as written and one target, +told apart by ``getObjectType()``: a named object (``getObjectName()``), a qualified column +(``getColumn()``), a FUNCTION, PROCEDURE, ROUTINE or AGGREGATE signature (``getRoutine()``) +or a large object OID. A null label stands for ``IS NULL``. Table visitors report tables, +views, materialized views, foreign tables and a column's table. + +``CREATE SCHEMA`` keeps its schema elements in ``getStatements()`` and renders them after the +``AUTHORIZATION`` and ``PATH`` clauses. The element kinds are PostgreSQL's: ``CREATE TABLE``, +``CREATE VIEW``, ``CREATE INDEX``, ``CREATE SEQUENCE``, ``CREATE TRIGGER`` and ``GRANT``; +``CREATE SCHEMA IF NOT EXISTS`` cannot include them. Elements keep their names as written, +and unqualified names refer to the new schema. The parser no longer copies the schema name +into ``CREATE TABLE`` elements. Table visitors, validation and ``StatementDeParser`` traverse +the elements. + +Validators report ``createEventTrigger``, ``alterEventTrigger``, ``reindex``, +``reindexConcurrently`` (PostgreSQL 12) and ``securityLabel``. Feature analysis classifies +these statements as schema changes; ``REINDEX`` also reads data. + +References: `CREATE EVENT TRIGGER `_, +`ALTER EVENT TRIGGER `_, +`REINDEX `_, +`SECURITY LABEL `_, +`CREATE SCHEMA `_. + +Migrating shared ALTER enums +---------------------------- + +``AlterServer.Action`` and ``AlterForeignDataWrapper.Action`` have been replaced +by ``ForeignObjectAlterAction`` in ``net.sf.jsqlparser.statement.alter``. Both +statements' ``getAction()`` and ``setAction()`` now use this enum, with the same +``OPTIONS``, ``OWNER`` and ``RENAME`` constants. Update imports and recompile code +using these APIs; the removed nested enums are not compatibility aliases. + +.. code-block:: java + + AlterServer server = (AlterServer) CCJSqlParserUtil.parse( + "ALTER SERVER s VERSION NULL"); + server.setAction(ForeignObjectAlterAction.OWNER); + server.setOwner("CURRENT_USER"); + // ALTER SERVER s OWNER TO CURRENT_USER + + AlterForeignDataWrapper wrapper = (AlterForeignDataWrapper) CCJSqlParserUtil.parse( + "ALTER FOREIGN DATA WRAPPER w NO HANDLER"); + wrapper.setAction(ForeignObjectAlterAction.OWNER); + wrapper.setOwner("CURRENT_USER"); + // ALTER FOREIGN DATA WRAPPER w OWNER TO CURRENT_USER + +``OPTIONS`` remains the initial action. It includes server ``VERSION`` changes +and wrapper handler/validator changes as well as foreign-data options. These +payloads remain on their respective statement classes. Switching to ``OWNER`` or +``RENAME`` leaves the inactive payload available for switching back to ``OPTIONS``. + +``RelationAlterAction.TriggerState``, ``getTriggerState()`` and +``setTriggerState()`` have been removed. Use the existing +``RelationAlterAction.EnableState``, ``getEnableState()`` and ``setEnableState()`` +for both trigger and rewrite-rule actions: + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ENABLE REPLICA TRIGGER trg", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + RelationAlterAction trigger = (RelationAlterAction) alter.getAlterExpressions().get(0); + trigger.setEnableState(RelationAlterAction.EnableState.DISABLE); + // ALTER TABLE t DISABLE TRIGGER trg + +The action's ``Kind`` still distinguishes ``TRIGGER_STATE`` from ``RULE_STATE``. +Trigger targets also retain their ``NAME``, ``ALL`` and ``USER`` distinctions. + Oracle anonymous blocks ----------------------- @@ -1204,6 +2427,110 @@ Parse procedure definitions one SQL Server batch at a time: a procedure consumes remaining batch, including SQL after an ``END``. Client-side ``GO`` batch splitting is not performed by this routine declaration parser. +PostgreSQL table-level NOT NULL constraints +------------------------------------------ + +``Dialect.POSTGRESQL`` supports PostgreSQL 18's table-level +``CONSTRAINT nn NOT NULL id``, in both CREATE TABLE and ALTER TABLE ADD. +``NotNullConstraint`` exposes the constraint name, target ``Column`` and +``noInherit`` flag; ``getConstraintAttributes().isNotValid()`` represents an +ALTER ``NOT VALID`` clause when present. + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD CONSTRAINT nn NOT NULL id NOT VALID", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + NotNullConstraint constraint = (NotNullConstraint) + alter.getAlterExpressions().get(0).getConstraint(); + constraint.getColumn().setColumnName("other_id"); + constraint.setName("other_nn"); + +The target column participates in expression visitors and deparsers. New nodes +can be built with ``new NotNullConstraint().withName("nn") +.withColumn(new Column("id"))``. This is distinct from column definitions and +``ALTER COLUMN ... SET NOT NULL``; those retain their existing APIs. + +MySQL and PostgreSQL tablespaces +-------------------------------- + +``CREATE TABLESPACE`` parses to ``CreateTablespace`` and ``ALTER TABLESPACE`` to +``AlterTablespace`` in every dialect; ``isUndo()`` records the MySQL ``UNDO`` keyword. +A PostgreSQL definition exposes ``getOwner()``, ``getLocation()`` and the ``WITH`` +parameters as ``IndexOption`` values in ``getParameters()``. A MySQL definition exposes +``getDataFile()`` and keeps its options in source order in ``getOptions()``. They reuse the +``TableOption`` kinds ``ENGINE``, ``ENCRYPTION``, ``AUTOEXTEND_SIZE`` and +``ENGINE_ATTRIBUTE``; CREATE also accepts ``FILE_BLOCK_SIZE``. + +.. code-block:: java + + CreateTablespace create = (CreateTablespace) CCJSqlParserUtil.parse( + "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' FILE_BLOCK_SIZE = 8192 ENGINE = InnoDB"); + create.getDataFile().getValue(); // ts1.ibd + create.getOption(TableOption.Kind.ENGINE).get().getValue(); // InnoDB + + AlterTablespace alter = (AlterTablespace) CCJSqlParserUtil.parse( + "ALTER TABLESPACE fast SET (random_page_cost = 1.1)"); + alter.getAction(); // SET_PARAMETERS + alter.getParameters(); // [random_page_cost = 1.1] + +``getAction()`` is ``RENAME``, ``OWNER``, ``SET_PARAMETERS`` or ``RESET_PARAMETERS``, +``SET_STATE`` for ``ALTER UNDO TABLESPACE … SET ACTIVE|INACTIVE``, or ``OPTIONS`` for MySQL +options. Undo tablespaces accept only ``ENGINE``, ``CREATE UNDO TABLESPACE`` requires +``ADD DATAFILE``, and ALTER rejects ``FILE_BLOCK_SIZE``. Other ``ALTER TABLESPACE`` forms, +such as Oracle and NDB data file clauses, still parse as ``UnsupportedStatement``, and +``ALTER TABLE ALL IN TABLESPACE`` remains ``AlterTablespaceMove``. Validators report the +``createTablespace`` and ``alterTablespace`` features, which the MySQL and PostgreSQL +capabilities enable; feature analysis reports ``MODIFIES_SCHEMA``. + +MySQL spatial reference systems and ALTER INSTANCE +-------------------------------------------------- + +MySQL `CREATE SPATIAL REFERENCE SYSTEM +`_ parses to +``CreateSpatialReferenceSystem``. ``isOrReplace()`` and ``isIfNotExists()`` exclude each +other, ``getSrid()`` is the number as written (a ``LongValue``, or a ``HexValue`` for +``0x...`` and ``X'...'``), and ``getAttributes()`` keeps the ``NAME``, ``DEFINITION``, +``ORGANIZATION … IDENTIFIED BY`` and ``DESCRIPTION`` attributes in source order as +``SpatialReferenceSystemAttribute`` values. ``getName()``, ``getDefinition()``, +``getOrganization()``, ``getOrganizationId()`` and ``getDescription()`` return the first +attribute of their kind. The parser follows MySQL's grammar, which takes the attributes in +any order and any number: the server reports a repeated attribute, a missing ``NAME`` or +``DEFINITION`` and an SRID above 4294967295 when it runs the statement, not as syntax +errors. `DROP SPATIAL REFERENCE SYSTEM +`_ parses to +``Drop`` with the object type ``SPATIAL_REFERENCE_SYSTEM``. + +.. code-block:: java + + CreateSpatialReferenceSystem srs = (CreateSpatialReferenceSystem) CCJSqlParserUtil.parse( + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'Greek' ORGANIZATION 'EPSG' " + + "IDENTIFIED BY 4120 DEFINITION 'GEOGCS[\"Greek\"]'"); + srs.getSrid(); // 4120 + srs.getName().getValue(); // Greek + srs.getOrganizationId(); // 4120 + +MySQL `ALTER INSTANCE `_ parses +to ``AlterInstance``. ``getAction()`` is ``ENABLE_INNODB_REDO_LOG``, +``DISABLE_INNODB_REDO_LOG``, ``ROTATE_INNODB_MASTER_KEY``, ``ROTATE_BINLOG_MASTER_KEY``, +``RELOAD_TLS`` or ``RELOAD_KEYRING``. For ``RELOAD TLS``, ``getChannel()`` is the identifier +after ``FOR CHANNEL`` as written, or null, and ``isNoRollbackOnError()`` records +``NO ROLLBACK ON ERROR``. MySQL reads ``INNODB``, ``BINLOG`` and ``REDO_LOG`` as +identifiers, so they may be written in backticks, and the engine of ``ROTATE`` also as a +string; the statement prints them as plain words. The grammar takes any identifier as the +channel; the server accepts ``mysql_main`` and ``mysql_admin``. + +These statements are read with ``Dialect.MYSQL`` and without a dialect. With +``Dialect.MYSQL``, a ``CREATE SPATIAL`` statement that is neither this one nor +``CREATE SPATIAL INDEX``, and an ``ALTER INSTANCE`` with another action, are errors; +without a dialect they stay ``UnsupportedStatement``, as in the other dialects, where +``DROP SPATIAL REFERENCE SYSTEM`` is still rejected. ``REFERENCE``, ``INSTANCE``, +``ROTATE``, ``RELOAD`` and the other words remain ordinary identifiers. Validators report +the ``createSpatialReferenceSystem`` and ``alterInstance`` features, which the MySQL +capabilities enable, and ``drop``. Feature analysis reports ``MODIFIES_SCHEMA`` for +``CREATE SPATIAL REFERENCE SYSTEM`` and ``MODIFIES_SESSION`` for ``ALTER INSTANCE``, a +server operation like ``ALTER SYSTEM``. + SQL Server identity inserts --------------------------- @@ -1215,6 +2542,750 @@ visitors, both SQL renderers and metadata validation use this structured target. Feature analysis reports ``MODIFIES_SESSION``; the directive itself inserts no rows. The dedicated validation capability is ``setIdentityInsert``. +Database options and configuration parameters +--------------------------------------------- + +``CreateDatabase``, MySQL's ``CREATE SCHEMA`` and ``AlterDatabase`` share the +``DatabaseOption`` model. MySQL options are ``CHARACTER_SET`` (``getName()`` keeps +the ``CHARACTER SET``, ``CHAR SET`` or ``CHARSET`` spelling), ``COLLATE``, +``ENCRYPTION`` and, for ALTER only, ``READ_ONLY``. PostgreSQL options have one kind +each, from ``OWNER`` and ``TEMPLATE`` to ``CONNECTION_LIMIT``, ``IS_TEMPLATE`` and +``OID``; ``isUseWith()`` records the optional ``WITH``. Values keep their SQL text, +such as ``'UTF8'`` or ``-1``. Other option text remains one raw ``OTHER`` option. + +``AlterDatabase.getAction()`` selects what is rendered: ``OPTIONS`` (the default), +``RENAME``, ``OWNER``, ``SET_TABLESPACE``, ``REFRESH_COLLATION_VERSION`` or +``CONFIGURATION_PARAMETER``. Payloads of the other actions are kept. ``SET`` and +``RESET`` of a configuration parameter use ``ConfigurationParameterChange``, which +``AlterRole`` shares: + +.. code-block:: java + + AlterDatabase alter = (AlterDatabase) CCJSqlParserUtil.parse( + "ALTER DATABASE app SET search_path TO app, public", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + ConfigurationParameterChange change = alter.getParameterChange(); + change.getParameter(); // search_path + change.getValues(); // [app, public], a mutable ExpressionList + change.setValueKind(ConfigurationParameterChange.ValueKind.DEFAULT); + // ALTER DATABASE app SET search_path TO DEFAULT + +``getValueKind()`` is ``VALUES``, ``DEFAULT`` or ``FROM_CURRENT``; ``RESET ALL`` uses +the parameter name ``ALL``. ``AlterRole`` keeps ``getParameter()``, ``isUseEquals()``, +``isFromCurrent()``, ``isUseDefault()``, ``getValues()`` and their setters; they read +and edit ``getParameterChange()``. ``FROM CURRENT`` and ``DEFAULT`` are now mutually +exclusive: ``setFromCurrent(false)`` and ``setUseDefault(false)`` return to the values. + +Without the MySQL dialect, ``ALTER DATABASE`` forms that are neither MySQL nor +PostgreSQL syntax, such as ``ALTER DATABASE d SET RECOVERY SIMPLE``, remain an +``UnsupportedStatement``; ``Dialect.MYSQL`` reports them as errors. ``ALTER SCHEMA`` +followed by MySQL options is an ``AlterDatabase`` in every dialect, while PostgreSQL's +``ALTER SCHEMA ... RENAME TO/OWNER TO`` remains an ``AlterSchema``. Validation +reports the ``createDatabase`` and ``alterDatabase`` features, which the MySQL, +MariaDB and PostgreSQL capabilities enable. + +``CreateDatabase.getOptions()`` is now a live list that is never null, and +``setOptions`` copies its argument. ``getDatabaseOptions()`` is an unmodifiable +token snapshot derived from the options, including ``WITH``, and is null without +options. ``setDatabaseOptions`` replaces all options with one raw option, and +``addDatabaseOptions`` appends one while keeping the typed options. Parsed +statements no longer end with an empty raw option. + +References: MySQL `CREATE DATABASE `_, +`ALTER DATABASE `_; +PostgreSQL `CREATE DATABASE `_, +`ALTER DATABASE `_. + +Routine and trigger alterations +------------------------------- + +PostgreSQL ``ALTER FUNCTION``, ``ALTER PROCEDURE`` and ``ALTER ROUTINE`` and MySQL +``ALTER FUNCTION`` and ``ALTER PROCEDURE`` parse to ``AlterRoutine``. ``getRoutineType()`` +names the keyword and ``getRoutine()`` is a ``RoutineReference`` with the optional +PostgreSQL argument types. ``getAction()`` is ``CHARACTERISTICS``, ``RENAME``, ``OWNER``, +``SET_SCHEMA`` or ``DEPENDS_ON_EXTENSION`` (``isNoDependency()`` for ``NO DEPENDS``); +payloads of the other actions are kept. ``getCharacteristics()`` is a mutable list of +``RoutineCharacteristic`` in source order, shared by both dialects. Each ``Kind`` renders +its own keywords, such as ``IMMUTABLE``, ``CALLED_ON_NULL_INPUT``, ``PARALLEL_SAFE``, +``COST`` or MySQL's ``READS_SQL_DATA``. ``SECURITY_DEFINER`` and ``SECURITY_INVOKER`` keep +the ``[EXTERNAL] SECURITY`` or ``SQL SECURITY`` spelling in ``getSecurityClause()``. +``COST``, ``ROWS``, ``SUPPORT`` and ``COMMENT`` keep their value as SQL text in ``getValue()``. +``getComment()`` returns the ``COMMENT`` literal as a ``StringValue`` read with the dialect's +escaping, so ``getNotExcapedValue()`` is the text MySQL stores. ``SET`` and ``RESET`` reuse +``ConfigurationParameterChange``: + +.. code-block:: java + + AlterRoutine alter = (AlterRoutine) CCJSqlParserUtil.parse( + "ALTER FUNCTION f(int) IMMUTABLE SET search_path = public", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + alter.getRoutine().getArguments(); // [int] + alter.getCharacteristics().get(0).getKind(); // IMMUTABLE + alter.getCharacteristics().get(1).getParameterChange().getParameter(); // search_path + +The characteristics of one statement belong to one dialect, and MySQL's take no argument +list. Other forms after ``ALTER FUNCTION`` or ``ALTER PROCEDURE``, such as Oracle's +``COMPILE`` or SQL Server routine definitions without the SQL Server dialect, remain an +``UnsupportedStatement``. PostgreSQL's ``ALTER TRIGGER name ON table RENAME TO`` and +``[NO] DEPENDS ON EXTENSION`` parse to ``AlterTrigger``; table visitors report its table. +Validators report ``alterFunction``, ``alterProcedure``, ``alterRoutine`` and +``alterTrigger``; PostgreSQL enables all of them, MySQL and MariaDB the first two. + +PostgreSQL's ``ALTER RULE name ON table RENAME TO new_name`` +(`ALTER RULE `_) parses to +``AlterRule`` with ``getName()``, ``getTable()`` and ``getNewName()``; table visitors report +its table and validators report ``alterRule``, which PostgreSQL enables. It is the only +``ALTER RULE`` form, so any other text after ``ALTER RULE`` is a parse error. + +PostgreSQL's cast, transform and conversion definitions are typed statements: + +* ``CREATE CAST (source_type AS target_type) {WITH FUNCTION function [(argument_type [, ...])] | WITHOUT FUNCTION | WITH INOUT} [AS ASSIGNMENT | AS IMPLICIT]`` + (`CREATE CAST `_) parses to + ``CreateCast``. ``getCast()`` is the ``CastSignature`` that ``DROP CAST`` uses, + ``getMethod()`` is ``WITH_FUNCTION``, ``WITHOUT_FUNCTION`` or ``WITH_INOUT``, + ``getFunction()`` is the ``RoutineReference`` of ``WITH FUNCTION``, and ``getContext()`` + is ``ASSIGNMENT``, ``IMPLICIT`` or ``null`` for a cast that applies only when written. +* ``CREATE [OR REPLACE] TRANSFORM FOR type_name LANGUAGE lang_name (FROM SQL WITH FUNCTION function, TO SQL WITH FUNCTION function)`` + (`CREATE TRANSFORM `_) parses + to ``CreateTransform``. ``getTransform()`` is the ``TransformSignature`` that + ``DROP TRANSFORM`` uses. ``getFromSqlFunction()`` and ``getToSqlFunction()`` are + ``RoutineReference`` objects, one of them ``null`` when the statement has only the other + item, and ``isToSqlFirst()`` keeps the order of the two items. +* ``CREATE [DEFAULT] CONVERSION name FOR 'source_encoding' TO 'dest_encoding' FROM function_name`` + (`CREATE CONVERSION `_) parses + to ``CreateConversion`` with ``isDefaultConversion()``, ``getName()``, + ``getSourceEncoding()`` and ``getDestinationEncoding()`` as ``StringValue`` and + ``getFunction()``. +* ``ALTER CONVERSION name {RENAME TO new_name | OWNER TO role | SET SCHEMA schema}`` + (`ALTER CONVERSION `_) parses + to ``AlterConversion`` with ``getAction()`` and ``getNewName()``, ``getOwner()`` or + ``getSchemaName()``. + +.. code-block:: java + + CreateCast cast = (CreateCast) CCJSqlParserUtil.parse( + "CREATE CAST (bigint AS int4) WITH FUNCTION int4(bigint) AS ASSIGNMENT"); + cast.getCast().getSourceType(); // ColDataType bigint + cast.getMethod(); // CreateCast.Method.WITH_FUNCTION + cast.getFunction().getName(); // int4 + cast.getContext(); // CreateCast.Context.ASSIGNMENT + + CreateTransform transform = (CreateTransform) CCJSqlParserUtil.parse( + "CREATE TRANSFORM FOR hstore LANGUAGE plpython3u (" + + "FROM SQL WITH FUNCTION hstore_to_plpython(internal), " + + "TO SQL WITH FUNCTION plpython_to_hstore(internal))"); + transform.getTransform().getLanguage(); // plpython3u + transform.getToSqlFunction().getName(); // plpython_to_hstore + +Validators report ``createCast``, ``createTransform``, ``createConversion`` and +``alterConversion``, which PostgreSQL enables. With ``Dialect.POSTGRESQL`` these are the only +statements that ``CREATE CAST``, ``CREATE TRANSFORM``, ``CREATE [DEFAULT] CONVERSION`` and +``ALTER CONVERSION`` start, so any other text after them is a parse error. In another dialect +and without one, a statement is read this way when it has PostgreSQL's form +(``CAST (...) WITH FUNCTION``, ``WITH INOUT`` or ``WITHOUT FUNCTION``, +``TRANSFORM FOR type LANGUAGE``, ``CONVERSION name FOR``, and ``ALTER CONVERSION name`` +followed by ``RENAME``, ``OWNER`` or ``SET``); a statement of another product that starts with +the same words, such as ``CREATE CAST (a AS b) WITH SPECIFIC FUNCTION f``, remains an +``UnsupportedStatement``. + +``CreateFunctionalStatement.getDefiner()`` returns the MySQL ``DEFINER`` of +``CREATE DEFINER = ... FUNCTION|PROCEDURE`` as the ``MySqlDefiner`` that views and +triggers use. With ``Dialect.MYSQL`` or ``Dialect.MARIADB``, +``CreateFunctionalStatement.getCharacteristics()`` lists the characteristics between the +routine header and its body, such as ``COMMENT``, ``DETERMINISTIC``, ``READS SQL DATA`` or +``SQL SECURITY INVOKER``, with the same ``RoutineCharacteristic`` kinds; ``DETERMINISTIC`` +and ``NOT_DETERMINISTIC`` occur only here. ``getFunctionDeclarationParts()`` still holds +every token and renders the statement unchanged, so the list is read-only. Replacing the +tokens with ``setFunctionDeclarationParts(parts)`` clears it, while +``setFunctionDeclarationParts(parts, characteristics)`` sets both, and appending tokens +keeps it. Without a MySQL dialect the list stays empty. MySQL ``CREATE TRIGGER`` accepts ``IF NOT EXISTS`` (``isIfNotExists()``) +and keeps MariaDB's ``OR REPLACE``. A ``BEGIN ... END`` trigger body with only SQL +statements remains a ``Block``; a compound body with procedural statements such as +``IF``, ``DECLARE`` or loops is an ``UnsupportedStatement`` with its tokens, captured with +the boundary of routine bodies. In both cases the semicolon after ``END`` separates the +next statement. + +References: PostgreSQL `ALTER FUNCTION `_, +`ALTER PROCEDURE `_, +`ALTER ROUTINE `_, +`ALTER TRIGGER `_; +MySQL `ALTER FUNCTION `_, +`ALTER PROCEDURE `_, +`CREATE TRIGGER `_. + +MySQL table maintenance statements +---------------------------------- + +``CHECK TABLE``, ``CHECKSUM TABLE``, ``OPTIMIZE TABLE`` and ``REPAIR TABLE`` parse to +``TableMaintenanceStatement`` in every dialect; ``ANALYZE TABLE`` remains ``Analyze``. +``getOperation()`` identifies the statement, ``getModifier()`` returns +``NO_WRITE_TO_BINLOG`` or ``LOCAL`` for OPTIMIZE and REPAIR, and ``isTablesKeyword()`` +records the ``TABLES`` spelling. ``getOptions()`` keeps the trailing options in source +order. CHECK accepts ``FOR UPGRADE``, ``QUICK``, ``FAST``, ``MEDIUM``, ``EXTENDED`` and +``CHANGED``; CHECKSUM accepts one of ``QUICK`` and ``EXTENDED``; REPAIR accepts ``QUICK``, +``EXTENDED`` and ``USE_FRM``. Other combinations are rejected, and the option words and +``CHECKSUM`` remain ordinary identifiers elsewhere. With unsupported statements enabled, these +statements are parsed rather than captured as unsupported statements. + +.. code-block:: java + + TableMaintenanceStatement repair = (TableMaintenanceStatement) CCJSqlParserUtil.parse( + "REPAIR NO_WRITE_TO_BINLOG TABLE t1, t2 QUICK"); + repair.getTables(); // [t1, t2] + repair.getOptions(); // [QUICK] + +Table visitors and metadata validation use the table list. Validators report the +``tableMaintenance`` feature, which the MySQL and MariaDB capabilities enable. Feature +analysis reports ``READS_DATA`` and ``RETURNS_RESULT_SET``; OPTIMIZE and REPAIR also +report ``MODIFIES_SCHEMA``, and REPAIR may report ``MODIFIES_DATA``. + +``ANALYZE TABLE ... UPDATE HISTOGRAM ON`` keeps ``WITH n BUCKETS`` +(``getHistogramBucketCount()``), MySQL 8.4's ``AUTO UPDATE`` or ``MANUAL UPDATE`` +(``getHistogramUpdateMode()``) and ``USING DATA 'json'`` (``getHistogramData()``, a +``StringValue``). ``USING DATA`` excludes the other two options, and ``DROP HISTOGRAM`` +takes none of them. + +PostgreSQL maintenance statements +--------------------------------- + +With ``Dialect.POSTGRESQL`` and without a dialect, PostgreSQL's maintenance statements parse +to typed statements: + +* ``VACUUM [(option [value], ...)] [target, ...]`` and + ``VACUUM [FULL] [FREEZE] [VERBOSE] [ANALYZE] [target, ...]`` parse to ``VacuumStatement``. +* ``ANALYZE [(option [value], ...)] [target, ...]`` and ``ANALYZE [VERBOSE] [target, ...]`` + extend ``Analyze``, which keeps the MySQL ``ANALYZE TABLE`` form and its histogram clause. A + statement takes one form: options, or targets with ``ONLY``, ``*`` or columns, cannot be + combined with ``NO_WRITE_TO_BINLOG``, ``LOCAL``, ``TABLE`` or ``UPDATE``/``DROP HISTOGRAM``. + The PostgreSQL form can be spelled ``ANALYSE``, which ``getCommand()`` keeps. +* ``CLUSTER [(option [value], ...)] [table [USING index]]``, + ``CLUSTER [VERBOSE] [table [USING index]]`` and the pre-8.3 ``CLUSTER [VERBOSE] index ON table`` + parse to ``ClusterStatement``; ``getIndexSyntax()`` tells ``USING`` and ``ON`` apart. +* ``CHECKPOINT`` parses to ``CheckpointStatement``. + +The three option lists share ``UtilityOption``: ``getName()`` keeps the name as written, and +``getValueType()`` tells whether the value is a Boolean word, a number, a string or another word. +``getBooleanValue()``, ``getLongValue()``, ``getStringValue()`` and ``getEnumValue(Class)`` read +it, and ``getKind(Class)`` maps the name to ``VacuumStatement.OptionKind``, +``Analyze.OptionKind`` or ``ClusterStatement.OptionKind``. The unparenthesized keywords are +options too: ``VACUUM FULL t`` holds the option ``FULL`` like ``VACUUM (FULL) t``, and +``isParenthesizedOptions()`` tells the forms apart. As in PostgreSQL's grammar, an option list +takes any name and any Boolean word, number, string or word as its value, as long as an unquoted +name or word is not one that PostgreSQL reserves (``ANALYZE`` and ``ANALYSE`` are names); +PostgreSQL checks the names and values when it runs the statement. ``getKind(Class)`` is null for a name the statement does not know, +such as ``VACUUM (FOO) t``, and the typed readers are null for a value of another type, such as +``PARALLEL 1.5``. A double-quoted name keeps its case, as in PostgreSQL: ``"verbose"`` is +``VERBOSE``, and ``"VERBOSE"`` is an unknown option. ``EXPLAIN (...)`` reads its options +through the same production but keeps ``ExplainStatement.Option``, and accepts only the names +and values it accepted before. + +A ``MaintenanceTarget`` of VACUUM and ANALYZE is ``[ONLY] table [*] [(column, ...)]``: its +``getReference()`` is the ``TableReference`` of ``LOCK`` and ``TRUNCATE``, and +``getColumns()`` lists the columns. ``Analyze.getTargets()`` holds the tables of both forms; +``getTable()`` and ``getTables()`` are derived from it, and ``getTables()`` now returns a +read-only snapshot. + +.. code-block:: java + + VacuumStatement vacuum = (VacuumStatement) CCJSqlParserUtil.parse( + "VACUUM (PARALLEL 2, INDEX_CLEANUP OFF) t (a)", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + vacuum.getOptions().get(0).getLongValue(); // 2 + vacuum.getOptions().get(1).getBooleanValue(); // false + vacuum.getTargets().get(0).getColumns(); // [a] + +``VACUUM``, ``CLUSTER``, ``FREEZE``, ``CHECKPOINT`` and ``ANALYSE`` remain identifiers elsewhere. As in +PostgreSQL, ``FULL``, ``FREEZE``, ``VERBOSE`` and ``ANALYZE`` directly after ``VACUUM`` are +options, never table names. With ``Dialect.POSTGRESQL``, ``ANALYZE verbose`` now means the +``VERBOSE`` option; without a dialect it is still a table named ``verbose`` unless a table +name follows, and other dialects keep that reading. Without a dialect, a statement starting +with one of these words is a PostgreSQL statement only when its next tokens take the +PostgreSQL form, so other products' variants such as ``VACUUM INTO 'file'`` remain +unsupported statements. Other dialects do not parse these statements, nor ``ANALYSE``. + +Table visitors report the tables of the targets and the CLUSTER table, but not the column +lists or the index. Validators report the ``analyze``, ``vacuum``, ``cluster`` and +``checkpoint`` features, which the PostgreSQL capabilities enable; the MySQL and MariaDB +capabilities now enable ``analyze`` as well. Feature analysis reports ``MODIFIES_SCHEMA`` and +``READS_DATA`` for VACUUM and CLUSTER, as for ANALYZE, and ``MODIFIES_SESSION`` for +CHECKPOINT, a server operation like ``ALTER SYSTEM CHECKPOINT``. +MySQL table and backup locks +---------------------------- + +MySQL and MariaDB `LOCK TABLES `_ +parses to the ``LockStatement`` of PostgreSQL and Oracle ``LOCK TABLE``. Each entry of +``getTargets()`` keeps its table, the alias as ``getTable().getAlias()``, and +``getLockType()``: ``READ``, ``READ_LOCAL``, ``WRITE``, ``LOW_PRIORITY_WRITE`` or MariaDB's +``WRITE_CONCURRENT``. MySQL 8.4 has only ``READ [LOCAL]`` and ``WRITE``; +``LOW_PRIORITY WRITE`` is accepted because `MySQL 8.0 +`_ (deprecated, without effect) +and MariaDB accept it. The lock type is null for a PostgreSQL or Oracle target, and +``isTablesKeyword()`` records the ``TABLES`` spelling. MariaDB's trailing ``WAIT n`` and +``NOWAIT`` use ``getWaitSeconds()`` and ``isNoWait()``, like PostgreSQL and Oracle. +``UNLOCK TABLE`` and ``UNLOCK TABLES`` parse to ``UnlockStatement``, and +`LOCK INSTANCE FOR BACKUP and UNLOCK INSTANCE +`_ to +``BackupLockStatement``, whose ``getAction()`` is ``LOCK`` or ``UNLOCK``. + +.. code-block:: java + + LockStatement lock = (LockStatement) CCJSqlParserUtil.parse( + "LOCK TABLES t AS a READ LOCAL, u WRITE"); + lock.getTargets().get(0).getTable().getAlias().getName(); // a + lock.getTargets().get(0).getLockType(); // READ_LOCAL + +The MySQL and MariaDB dialects read these forms, and so does the parser without a dialect: +an alias or a lock type after the first table name tells MySQL's form from PostgreSQL's +``LOCK [TABLE] name``, so ``LOCK tables NOWAIT`` still locks a table named ``tables``. +``WRITE CONCURRENT``, ``WAIT`` and ``NOWAIT`` after a MySQL target list require +``Dialect.MARIADB``, and ``Dialect.MARIADB`` rejects the backup lock statements, which +MariaDB does not have. PostgreSQL and the other dialects keep rejecting the MySQL forms. +``UNLOCK``, ``INSTANCE`` and ``BACKUP`` remain ordinary identifiers. + +Table visitors report the locked tables but not their aliases. Validators report the +``lock``, ``unlockTables`` and ``backupLock`` features; the MySQL capabilities enable all +three, MariaDB the first two, and PostgreSQL and Oracle ``lock``. Feature analysis reports +``MODIFIES_TRANSACTION``. + +MySQL servers, plugins and components +------------------------------------- + +MySQL `CREATE SERVER `_ and +`ALTER SERVER `_ parse to the +``CreateServer`` and ``AlterServer`` of the PostgreSQL statements. A ``ForeignDataOption`` +keeps its value in ``getValueExpression()``: a ``StringValue``, or for MySQL's ``PORT`` the +number as written (``LongValue``, ``DoubleValue`` or ``HexValue``). ``getValue()`` still +returns the string value and is null for a number. A server or wrapper name written as a +string literal, as in ``FOREIGN DATA WRAPPER 'mysql'``, is kept with its quotes. + +.. code-block:: java + + CreateServer server = (CreateServer) CCJSqlParserUtil.parse( + "CREATE SERVER s FOREIGN DATA WRAPPER mysql OPTIONS (HOST 'h', PORT 3306)"); + ForeignDataOption port = server.getOptions().get(1); + port.getValueExpression(); // LongValue 3306 + port.getValue(); // null + +Numeric values and quoted names are read with the MySQL and MariaDB dialects and without a +dialect, and only in these two statements; PostgreSQL and the other option lists keep +requiring string constants. ``Dialect.MYSQL`` follows the server grammar: the options are +``USER``, ``HOST``, ``DATABASE``, ``OWNER``, ``PASSWORD`` and ``SOCKET`` with a string and +``PORT`` with a number, ``OPTIONS`` is required, and the PostgreSQL clauses (``IF NOT +EXISTS``, ``TYPE``, ``VERSION``, ``ADD``/``SET``/``DROP`` options, ``RENAME TO``, +``OWNER TO``) are rejected. ``DROP SERVER`` stays a ``Drop``. + +`INSTALL PLUGIN `_, +`UNINSTALL PLUGIN `_, +`INSTALL COMPONENT `_ and +`UNINSTALL COMPONENT `_ +parse to one ``PluginStatement`` with an ``Action`` (``INSTALL``, ``UNINSTALL``) and an +``ObjectType`` (``PLUGIN``, ``COMPONENT``). A plugin statement has ``getPluginName()`` and, +for ``INSTALL``, the ``getLibrary()`` after ``SONAME``. A component statement lists its URNs +in ``getComponents()``, and ``INSTALL COMPONENT ... SET`` its assignments in +``getVariables()``: each ``ComponentVariable`` has a ``SetScope`` (``NONE``, ``GLOBAL`` or +``PERSIST``), the name as written, the operator (``=`` or ``:=``) and the value expression; +the word ``ON`` is read as a column. As in MySQL, a value is not ``DEFAULT`` or a subquery. + +.. code-block:: java + + PluginStatement install = (PluginStatement) CCJSqlParserUtil.parse( + "INSTALL COMPONENT 'file://component1' SET GLOBAL component1.var1 = 12 + 3", + parser -> parser.withDialect(Dialect.MYSQL)); + ComponentVariable variable = install.getVariables().get(0); + // GLOBAL, component1.var1, 12 + 3 + String parts = variable.getScope() + ", " + variable.getName() + ", " + variable.getValue(); + +The statements are read with the MySQL and MariaDB dialects and without a dialect; MariaDB +has no components. With the MySQL and MariaDB dialects every ``INSTALL`` is this statement. +Without a dialect DuckDB's ``INSTALL extension`` keeps producing an ``ExtensionStatement``, +also for extensions named ``plugin`` or ``component``: ``SONAME`` after the plugin name or a +component URN selects the MySQL statement. ``UNINSTALL``, ``PLUGIN``, ``COMPONENT`` and +``SONAME`` remain ordinary identifiers. The validator checks ``installPlugin`` (MySQL and +MariaDB) and ``installComponent`` (MySQL), and ``createServer`` and ``alterServer`` are now +part of the MySQL and MariaDB capabilities. Feature analysis reports ``MODIFIES_SESSION``. + +PostgreSQL session statements and COPY options +---------------------------------------------- + +With ``Dialect.POSTGRESQL`` and without a dialect, PostgreSQL's session statements parse to +typed statements: + +* `DISCARD `_ + ``{ALL | PLANS | SEQUENCES | TEMP | TEMPORARY}`` parses to ``DiscardStatement``. ``getTarget()`` + keeps the target as written; ``TEMP`` and ``TEMPORARY`` name the same state. +* `LISTEN `_ ``channel`` and + `UNLISTEN `_ ``{channel | *}`` parse to + ``ListenStatement``, next to ``NotifyStatement``. ``getAction()`` is ``LISTEN`` or + ``UNLISTEN``, and ``getChannel()`` is null for ``UNLISTEN *`` (``isAllChannels()``). +* `SHOW `_ ``TIME ZONE``, + ``SHOW TRANSACTION ISOLATION LEVEL`` and ``SHOW SESSION AUTHORIZATION`` parse to the + ``ShowStatement`` of other ``SHOW name`` statements instead of ``UnsupportedStatement``, and + `RESET `_ takes the same names. ``SET``, + ``RESET`` and ``SHOW`` read them through one rule: ``getName()`` is ``Time Zone``, as before + for ``SET`` and ``RESET``, ``TRANSACTION ISOLATION LEVEL`` or ``SESSION AUTHORIZATION``. + +`COPY `_ also accepts the option syntax that +PostgreSQL used before 9.0 and still accepts: keywords without parentheses or commas after the file +name and the optional ``WITH``, in any order (``BINARY``, ``FREEZE``, ``DELIMITER [AS] 'x'``, +``NULL [AS] 'x'``, ``CSV``, ``HEADER``, ``QUOTE [AS] 'x'``, ``ESCAPE [AS] 'x'``, +``FORCE QUOTE {column, ... | *}``, ``FORCE NOT NULL {column, ... | *}``, +``FORCE NULL {column, ... | *}`` and ``ENCODING 'x'``), and ``COPY BINARY table``. +``CopyStatement.getLegacyOptions()`` holds a ``CopyLegacyOption`` per option, in source order, +with its ``Kind``, its string (``getValue()``) and whether ``AS`` preceded it, or the columns of a +``FORCE`` option (``isAllColumns()`` for ``*``). ``isBinary()`` records ``COPY BINARY``. The +options in parentheses keep their reading through ``getOptions()``; a statement takes one of +the two forms. + +.. code-block:: java + + CopyStatement copy = (CopyStatement) CCJSqlParserUtil.parse( + "COPY t TO STDOUT WITH CSV HEADER FORCE QUOTE a, b"); + copy.getLegacyOptions().get(0).getKind(); // CSV + copy.getLegacyOptions().get(2).getColumns(); // [a, b] + +Other dialects keep rejecting these forms, and ``SHOW TIME ZONE`` remains an +``UnsupportedStatement`` there. ``LISTEN`` and ``UNLISTEN`` become non-reserved keywords and, +like ``DISCARD``, remain usable as names. As in PostgreSQL's grammar, a channel or a ``FORCE`` +column cannot be an unquoted word that PostgreSQL reserves, such as ``ALL``. + +Table visitors report the copied table and no table for the session statements. Validators +report the ``discard`` and ``listen`` features, which the PostgreSQL capabilities enable +together with ``show``. Feature analysis reports ``MODIFIES_SESSION`` for ``DISCARD``, +``LISTEN`` and ``UNLISTEN``, and a possible ``MODIFIES_SCHEMA`` for ``DISCARD ALL``, ``TEMP`` +and ``TEMPORARY``, which drop the temporary tables of the session. + +MySQL server administration statements +-------------------------------------- + +With ``Dialect.MYSQL`` and without a dialect, these MySQL 8.4 statements parse to typed +statements: + +* `FLUSH `_ parses to + ``FlushStatement``. ``getModifier()`` returns ``NO_WRITE_TO_BINLOG`` or ``LOCAL``, the + ``TableMaintenanceStatement.Modifier`` of OPTIMIZE, REPAIR and the partition operations. + ``getOptions()`` keeps the flush options in source order. Each is a ``FlushOption`` whose + ``getKind()`` is one of MySQL 8.4's options, from ``BINARY_LOGS`` to ``USER_RESOURCES``, + and whose ``getChannel()`` holds the string literal of ``RELAY LOGS FOR CHANNEL 'name'``. + Without options the statement is + ``FLUSH {TABLE | TABLES} [tbl_name, ...] [WITH READ LOCK | FOR EXPORT]`` + (``isFlushTables()``), with ``getTables()``, ``isTablesKeyword()`` and ``getTableLock()``. + As in MySQL, that form takes no flush option, ``FOR EXPORT`` requires a table list, only + ``RELAY LOGS`` names a channel, and ``FLUSH HOSTS``, which MySQL 8.4 removed, is rejected; + with unsupported statements enabled it remains an ``UnsupportedStatement``. +* `KILL [CONNECTION | QUERY] processlist_id + `_ parses to ``KillStatement``. + ``getKind()`` is ``CONNECTION``, ``QUERY`` or null when neither is given, and + ``getProcesslistId()`` is an expression, since MySQL accepts ``@id`` or ``1 + 2`` there. +* `RESET PERSIST [[IF EXISTS] system_var_name] + `_ extends ``ResetStatement`` + with ``isPersist()`` and ``isIfExists()``; ``getName()`` is the variable as written, with + a component or ``DEFAULT`` prefix such as ``validate_password.length``, or null when the + statement names none. Without a dialect only a variable name or ``IF EXISTS`` after + ``PERSIST`` selects this form, so a bare ``RESET PERSIST`` still resets a parameter named + ``persist``, as it does in the other dialects. +* `HANDLER `_ parses to + ``HandlerStatement``, whose ``getAction()`` is ``OPEN``, ``READ`` or ``CLOSE``. + ``getTable()`` is the table that OPEN opens, with the handler name as its alias, or the + unqualified handler name that READ and CLOSE take; ``getHandlerName()`` returns the name in + both cases. A READ has ``getIndexName()`` and either ``getKeyComparison()`` (``=``, + ``<=``, ``>=``, ``<`` or ``>``) with ``getKeyValues()``, or ``getDirection()`` + (``FIRST``, ``NEXT``, ``PREV`` or ``LAST``, and only ``FIRST`` or ``NEXT`` without an + index), followed by ``getWhere()``, ``getLimit()`` and ``getOffset()``. As in MySQL, a + READ takes no subquery. + +.. code-block:: java + + FlushStatement flush = (FlushStatement) CCJSqlParserUtil.parse( + "FLUSH LOCAL TABLES t1, t2 WITH READ LOCK"); + flush.getTables(); // [t1, t2] + flush.getTableLock(); // WITH_READ_LOCK + + HandlerStatement read = (HandlerStatement) CCJSqlParserUtil.parse( + "HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3"); + read.getKeyComparison(); // GREATER_THAN_OR_EQUALS + read.getKeyValues(); // (1, 2) + +Other dialects keep rejecting these statements. ``HANDLER`` becomes a non-reserved keyword +and remains usable as a name, like ``FLUSH``, ``KILL`` and the option words. + +Table visitors report the tables of ``FLUSH TABLES`` and the table that ``HANDLER ... OPEN`` +opens, but not the handler name of READ and CLOSE, which may be an alias. They find the +tables of subqueries in the KILL expression, and they now return no table for every +``RESET`` statement instead of throwing. Validators report the +``flush``, ``kill``, ``handler`` and ``resetPersist`` features, which the MySQL capabilities +enable; PostgreSQL's ``RESET`` keeps ``reset``. Feature analysis reports +``MODIFIES_SESSION`` for FLUSH, KILL and HANDLER OPEN and CLOSE, adds +``MODIFIES_TRANSACTION`` for the table locks of FLUSH TABLES, and reports ``READS_DATA`` and +``RETURNS_RESULT_SET`` for HANDLER READ. + +PostgreSQL IMPORT FOREIGN SCHEMA +-------------------------------- + +With ``Dialect.POSTGRESQL`` and without a dialect, +`IMPORT FOREIGN SCHEMA `_ +``remote_schema [{LIMIT TO | EXCEPT} (table [, ...])] FROM SERVER server INTO local_schema +[OPTIONS (option 'value' [, ...])]`` parses to ``ImportForeignSchema``, a +``ForeignDataStatement`` like ``CreateServer`` and ``CreateUserMapping``. ``getRemoteSchema()``, +``getServer()`` and ``getLocalSchema()`` hold the names. ``getQualification()`` is ``LIMIT_TO``, +``EXCEPT`` or null when the whole schema is imported, and ``getTables()`` lists the tables as +``TableReference`` values, the relation targets of ``LOCK`` and ``TRUNCATE``, because +PostgreSQL's grammar reads the same relation syntax there. ``setTables(qualification, tables)`` +changes both together. ``getOptions()`` holds the ``ForeignDataOption`` values that the other +foreign-data statements use; ``ADD``, ``SET`` and ``DROP`` are rejected as in their ``CREATE`` +forms. + +.. code-block:: java + + ImportForeignSchema imported = (ImportForeignSchema) CCJSqlParserUtil.parse( + "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1, t2) FROM SERVER srv INTO local " + + "OPTIONS (import_default 'true')"); + imported.getQualification(); // LIMIT_TO + imported.getTables(); // [t1, t2] + imported.getOptions().get(0).getName(); // import_default + +Other dialects keep rejecting the statement, and the EXASOL dialect keeps ``IMPORT`` for its +own statement. Table visitors report no table: the listed names belong to the remote schema. +Validators report the ``importForeignSchema`` feature, which the PostgreSQL capabilities and +``FeaturesAllowed.DDL`` enable. Feature analysis reports ``MODIFIES_SCHEMA``. +MySQL replication statements +---------------------------- + +The MySQL 8.4 replication statements parse with ``Dialect.MYSQL`` and without a dialect, into +the classes of ``net.sf.jsqlparser.statement.replication``: + +- `CHANGE REPLICATION SOURCE TO + `_ is a + ``ChangeReplicationSourceStatement``. Each ``ReplicationSourceOption`` keeps its spelling and + ``getKind()``, and ``Kind.getValueType()`` says what the option takes: a string, a number, + ``NULL``, ``0`` or ``1``, a keyword such as ``OFF`` (held as a ``Column``, like ``ON`` in + PostgreSQL publication options), or the ``ParenthesedExpressionList`` of + ``IGNORE_SERVER_IDS``. A value of another type is a parse error, as in MySQL. + ``PRIVILEGE_CHECKS_USER`` keeps its account in ``getAccount()``, and + ``getPrimaryKeyCheck()`` and ``getGtidAssignment()`` read the keyword options. +- `CHANGE REPLICATION FILTER + `_ is a + ``ChangeReplicationFilterStatement`` of ``ReplicationFilter`` rules. A rule's list, which may + be empty, holds database names, ``db.table`` names, quoted patterns or ``(from, to)`` pairs, + as ``getDatabases()``, ``getTables()``, ``getPatterns()`` and ``getRewrites()``. +- `START REPLICA `_ and + `STOP REPLICA `_ are + ``StartReplicaStatement`` and ``StopReplicaStatement``, with ``getThreads()`` + (``IO_THREAD``, ``SQL_THREAD``). START keeps its ``UNTIL`` conditions as + ``ReplicaUntilOption`` and the ``USER``, ``PASSWORD``, ``DEFAULT_AUTH`` and ``PLUGIN_DIR`` + strings. +- `RESET BINARY LOGS AND GTIDS [TO n] + `_ and + `RESET REPLICA [ALL] `_, also as + the comma list of the `RESET `_ statement, + are a ``ResetReplicationStatement`` of ``ResetReplicationStatement.Option`` entries. +- `PURGE BINARY LOGS `_ + extends Oracle's ``PurgeStatement``: ``getPurgeObjectType()`` is ``BINARY_LOGS``, + ``getLogBound()`` is ``TO`` or ``BEFORE``, and ``getLogExpression()`` is the log name literal + or the point in time. As in MySQL, the ``BEFORE`` expression takes no subquery at any depth. + ``Dialect.MARIADB`` reads it as well, and MariaDB's ``PURGE MASTER LOGS`` as + ``MASTER_LOGS``. + +``FOR CHANNEL 'name'`` takes a string, which ``getChannel()`` returns as a ``StringValue``. + +.. code-block:: java + + ChangeReplicationSourceStatement change = (ChangeReplicationSourceStatement) + CCJSqlParserUtil.parse("CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h', " + + "IGNORE_SERVER_IDS = (1, 2) FOR CHANNEL 'c1'"); + change.getOptions().get(0).getKind(); // SOURCE_HOST + change.getChannel().getValue(); // c1 + +MySQL 8.4 removed ``CHANGE MASTER TO``, ``START SLAVE``, ``RESET MASTER`` and the ``MASTER_`` +options, so they stay unsupported. Without a dialect a bare ``RESET REPLICA`` remains the +PostgreSQL ``ResetStatement`` of a parameter named ``replica``; ``Dialect.MYSQL``, or ``ALL``, +``FOR CHANNEL`` or a further option after it, makes it MySQL's. PostgreSQL, Oracle and MariaDB +keep their readings of ``RESET``, ``PURGE`` and ``START``. ``STOP`` becomes a non-reserved +keyword and remains usable as a name. + +Table visitors report the tables of ``REPLICATE_DO_TABLE`` and ``REPLICATE_IGNORE_TABLE``. +Validators report the ``changeReplicationSource``, ``changeReplicationFilter``, +``startReplica``, ``stopReplica``, ``resetReplication`` and ``purgeBinaryLogs`` features; the +MySQL capabilities enable all of them and MariaDB ``purgeBinaryLogs``. Feature analysis reports +``MODIFIES_SESSION``, as for ``ALTER SYSTEM``. + +MySQL LOAD DATA and LOAD XML +---------------------------- + +MySQL and MariaDB `LOAD DATA `_ and +`LOAD XML `_ parse to +``MySqlLoadDataStatement``; BigQuery's ``LOAD DATA {INTO | OVERWRITE}`` remains +``LoadDataStatement``. ``getFormat()`` is ``DATA`` or ``XML``. As in the server's grammar, +both forms take every clause: ``getLockOption()`` (``LOW_PRIORITY`` or ``CONCURRENT``), +``isLocal()``, ``getFileName()``, ``getDuplicateHandling()`` (``REPLACE`` or ``IGNORE``, the +enum of ``CREATE TABLE … SELECT``), ``getTable()``, ``getPartitions()``, +``getCharacterSet()`` with ``isUseCharsetKeyword()`` for the ``CHARSET`` spelling, +``getRowsIdentifiedBy()``, ``getFileFormat()``, ``getIgnoreCount()`` with ``getIgnoreUnit()`` +(``LINES`` or ``ROWS``), ``getColumns()`` (columns and ``UserVariable`` targets, empty for +``()``) and ``getUpdateSets()`` for the ``SET`` clause. + +.. code-block:: java + + MySqlLoadDataStatement load = (MySqlLoadDataStatement) CCJSqlParserUtil.parse( + "LOAD DATA LOCAL INFILE 'a.csv' INTO TABLE t FIELDS TERMINATED BY ',' " + + "IGNORE 1 LINES (a, @b) SET c = @b + 1"); + load.getFileFormat().getFieldsTerminatedBy().getValue(); // , + load.getUpdateSets().get(0).getValue(0); // @b + 1 + +``MySqlFileFormat`` holds the ``{FIELDS | COLUMNS}`` and ``LINES`` clauses, which +``SELECT … INTO OUTFILE`` shares: ``MySqlSelectIntoClause.getFileFormat()`` returns it, and the +clause's earlier getters and setters, such as ``getFieldsTerminatedBy()``, read and write it. +Each clause needs at least one subclause, so a bare ``FIELDS`` or ``LINES``, which MySQL +rejects, is now a parse error. The subclauses may come in any order and repeat, as MySQL +allows; like the server, the format keeps the last value of each and prints them in the +documented order. ``INTO OUTFILE`` also takes ``CHARSET`` and a quoted character set name. + +The MySQL and MariaDB dialects read these forms, and so does the parser without a dialect: +``INFILE`` after ``LOAD DATA`` or ``LOAD XML`` and the optional ``LOW_PRIORITY``, +``CONCURRENT`` and ``LOCAL`` tells them from BigQuery's ``LOAD DATA INTO`` and from DuckDB's +and PostgreSQL's ``LOAD name``, so ``LOAD xml`` still loads an extension named ``xml``. The +other dialects keep rejecting the MySQL forms. ``INFILE`` and ``CONCURRENT`` remain ordinary +identifiers. + +Table visitors report the target table and the tables of subqueries in the ``SET`` clause. +Validators report the ``loadData`` feature, which the MySQL and MariaDB capabilities now +enable. Feature analysis reports ``MODIFIES_DATA``. + +PostgreSQL cursors +------------------ + +PostgreSQL's cursor statements parse to the ``net.sf.jsqlparser.statement.cursor`` package: + +* `DECLARE name [BINARY] [ASENSITIVE | INSENSITIVE] [[NO] SCROLL] CURSOR [{WITH | WITHOUT} HOLD] + FOR query `_ parses to + ``DeclareCursorStatement``. ``getOptions()`` lists the ``CursorOption`` values in their + order; as in PostgreSQL's grammar they may come in any order and repeat, and PostgreSQL + rejects contradicting ones such as ``SCROLL NO SCROLL`` when it runs the statement. + ``getHoldability()`` is ``WITH_HOLD``, ``WITHOUT_HOLD`` or null, and ``getQuery()`` is the + ``Select``: a SELECT, ``VALUES``, ``TABLE t`` or a query with ``WITH``. +* `FETCH `_ and + `MOVE `_ + ``[direction] [FROM | IN] cursor`` parse to ``FetchCursorStatement``, whose ``getKind()`` + is ``FETCH`` or ``MOVE``. The direction is an optional ``FetchDirection`` keyword + (``NEXT``, ``PRIOR``, ``FIRST``, ``LAST``, ``ABSOLUTE``, ``RELATIVE``, ``FORWARD``, + ``BACKWARD``) with ``getCount()`` or ``isAll()``: ``ABSOLUTE`` and ``RELATIVE`` take a + count, ``FORWARD`` and ``BACKWARD`` an optional count or ``ALL``, and a count or ``ALL`` + can stand alone. A count is a signed 32-bit integer, as in PostgreSQL. ``getFromKeyword()`` + is ``FROM``, ``IN`` or null. +* `CLOSE {name | ALL} `_ parses to + ``CloseCursorStatement``; ``isAll()`` is true when it has no cursor name. + +.. code-block:: java + + FetchCursorStatement fetch = (FetchCursorStatement) CCJSqlParserUtil.parse( + "FETCH ABSOLUTE -1 FROM c", parser -> parser.withDialect(Dialect.POSTGRESQL)); + fetch.getDirection(); // ABSOLUTE + fetch.getCount(); // -1 + fetch.getCursorName(); // c + +A cursor name is any name PostgreSQL takes as a column identifier, so its reserved words and +type or function name keywords such as ``table`` or ``binary`` are rejected. As in PostgreSQL, +a direction word that ends the statement names the cursor: ``FETCH next`` fetches from a +cursor named ``next``. + +``Dialect.POSTGRESQL`` reads ``FETCH``, ``MOVE``, ``CLOSE`` and ``DECLARE`` followed by a +name as cursor statements. Without a dialect they parse when they take the PostgreSQL form: +``DECLARE`` needs a name, the cursor options and ``CURSOR``, and ``FETCH``, ``MOVE`` and +``CLOSE`` must end at a semicolon or the end of the input, so other products' variants such +as ``FETCH NEXT FROM c INTO @x`` or ``CLOSE GLOBAL c`` remain unsupported statements. Other +dialects keep their readings, and ``DECLARE @variable`` still parses to the SQL Server +``DeclareStatement`` in every dialect that read it before. ``MOVE`` becomes a non-reserved +keyword; it remains usable as a name, as do ``CLOSE``, ``CURSOR`` and the option and +direction words. ``SELECT ... FETCH FIRST`` is unchanged. + +Table visitors report the tables of the query of ``DECLARE`` and none for the other +statements, whose cursor name is not a table. Validators report the ``declareCursor``, +``fetchCursor`` (``FETCH`` and ``MOVE``) and ``closeCursor`` features, which the PostgreSQL +capabilities enable, and validate the query of ``DECLARE`` like a SELECT. Feature analysis +reports ``MODIFIES_SESSION`` for all of them, ``READS_DATA`` for a ``DECLARE`` whose query +reads a table, ``RETURNS_RESULT_SET`` for ``FETCH``, and a possible ``READS_DATA`` for +``FETCH`` and ``MOVE``, which run the query of the cursor. + +MySQL account management statements +----------------------------------- + +``CREATE USER`` and ``ALTER USER`` share ``UserOptions`` (``getOptions()``) in MySQL's +clause order: the ``DEFAULT ROLE`` roles, the ``REQUIRE`` options (``TlsOption``), the +``WITH`` resource limits (``ResourceLimit``), the password and locking options +(``PasswordLockOption``) in source order, and ``COMMENT`` or ``ATTRIBUTE``. Omitted +clauses stay omitted. ``UserAuthentication`` adds ``ALTER USER``'s ``REPLACE 'current'`` +(``getCurrentCredential()``), ``RETAIN CURRENT PASSWORD`` and the +``DISCARD_OLD_PASSWORD`` mode. + +.. code-block:: java + + AlterUser alter = (AlterUser) CCJSqlParserUtil.parse( + "ALTER USER 'app'@'%' IDENTIFIED BY 'new' RETAIN CURRENT PASSWORD " + + "PASSWORD EXPIRE INTERVAL 90 DAY ACCOUNT LOCK"); + alter.getAccounts().get(0).getAuthentication().isRetainCurrentPassword(); // true + alter.getOptions().getPasswordLockOptions(); // [PASSWORD EXPIRE INTERVAL 90 DAY, ACCOUNT LOCK] + +MySQL multi-factor authentication is part of the same model. ``CREATE USER`` keeps the +second and third factor of ``IDENTIFIED ... AND IDENTIFIED ... [AND IDENTIFIED ...]`` in +``UserAccount.getAdditionalAuthentications()``, and the temporary first factor of a +passwordless plugin, ``IDENTIFIED WITH plugin INITIAL AUTHENTICATION IDENTIFIED ...``, in +``UserAuthentication.getInitialAuthentication()``. ``ALTER USER`` keeps +``{ADD | MODIFY} n FACTOR IDENTIFIED ...``, ``DROP n FACTOR`` and the registration steps +``n FACTOR INITIATE REGISTRATION``, ``n FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE AS +'...'`` and ``n FACTOR UNREGISTER`` as ``UserFactorOperation`` objects (operation, factor +number, authentication or challenge response) in ``UserAccount.getFactorOperations()``. As +on the server, an account takes one or two changes of the same kind, and the factor number +is checked only when the statement runs. + +.. code-block:: java + + AlterUser factors = (AlterUser) CCJSqlParserUtil.parse( + "ALTER USER app ADD 2 FACTOR IDENTIFIED WITH authentication_ldap_sasl AS 'uid=app' " + + "ADD 3 FACTOR IDENTIFIED WITH authentication_webauthn"); + UserFactorOperation second = factors.getAccounts().get(0).getFactorOperations().get(0); + second.getOperation(); // ADD + second.getFactor(); // 2 + second.getAuthentication().getPlugin(); // authentication_ldap_sasl + +``ALTER USER USER() ...`` keeps ``USER()`` as the unquoted account name, as +``DEFINER = CURRENT_USER`` does; ``isUserFunction()`` identifies it. +``ALTER USER acct DEFAULT ROLE {NONE | ALL | role, ...}`` stores a ``RoleSelection`` in +``getOptions().getDefaultRoles()``. PostgreSQL's ``ALTER USER``, an alias of ``ALTER ROLE`` +(``WITH LOGIN``, ``PASSWORD 'x'``, ``SET``, ``RENAME TO`` ...), still parses to +``AlterRole``. MySQL syntax is recognized by ``IF EXISTS``, ``USER()``, quoted names, +hosts, account lists, a missing action or a MySQL account clause. + +``RENAME USER`` parses to ``RenameUser`` with ordered ``from``/``to`` pairs. MySQL +``CREATE ROLE [IF NOT EXISTS] role, ...`` with quoted names, hosts or several roles keeps +them in ``CreateRole.getRoles()``, and ``getName()`` is null. A single unquoted name, which +both databases accept, keeps the PostgreSQL ``getName()``; so does an unquoted ``r@h``, which +the lexer reads as one identifier, unless the MySQL or MariaDB dialect is selected. Role names +use the shared account spelling and are ``UserAccount`` values without authentication. + +``SET DEFAULT ROLE`` (MySQL's ``TO``, MariaDB's ``FOR``) and ``SET PASSWORD FOR`` parse to +``SetDefaultRoleStatement`` and ``SetPasswordStatement`` in every dialect. ``SET ROLE`` and +``SET PASSWORD`` without ``FOR`` share the variable assignment shape that PostgreSQL uses +for ``SET ROLE name`` and ``SET ROLE NONE``, so they remain a ``SetStatement`` unless +``Dialect.MYSQL`` or ``Dialect.MARIADB`` is selected. With these dialects every form parses +to ``SetRoleStatement`` (``DEFAULT``, ``NONE``, ``ALL [EXCEPT ...]`` or a role list) or +``SetPasswordStatement`` (``= password`` or ``TO RANDOM``, then ``REPLACE`` and +``RETAIN CURRENT PASSWORD``). The MySQL-only ``SET ROLE ALL EXCEPT ...`` and role names +with a quoted user or host, such as ``'r'@'%'``, parse to ``SetRoleStatement`` in every +dialect. + +.. code-block:: java + + SetRoleStatement setRole = (SetRoleStatement) CCJSqlParserUtil.parse( + "SET ROLE ALL EXCEPT 'admin'@'%'", + parser -> parser.withDialect(Dialect.MYSQL)); + setRole.getRoles().getKind(); // ALL_EXCEPT + setRole.getRoles().getRoles(); // ['admin'@'%'] + +Validators report ``alterUser``, ``renameUser``, ``setRole``, ``setDefaultRole`` and +``setPassword``; the MySQL and MariaDB capabilities enable them and ``createRole``. +Feature analysis reports ``MODIFIES_SCHEMA``, or ``MODIFIES_SESSION`` for ``SET ROLE``. +Multi-factor authentication clauses are not modeled. Serialized account SQL can contain +passwords; avoid logging real credentials. + Legacy MySQL GROUP BY ordering ============================== @@ -1236,36 +3307,78 @@ replacing the expression list clears them. Validators report the separate PostgreSQL COMMENT targets ========================= -``COMMENT ON`` supports ``INDEX``, ``SCHEMA``, ``SEQUENCE``, ``DOMAIN``, ``TYPE``, -``MATERIALIZED VIEW``, ``FUNCTION`` and ``CONSTRAINT`` in addition to the existing -``TABLE``, ``COLUMN`` and ``VIEW`` forms. These unambiguous target forms also parse -without a dialect preset. Tagged dollar strings still require -``Dialect.POSTGRESQL`` or ``withDollarQuotedStringTags(true)``. +``COMMENT ON`` supports these PostgreSQL object kinds in addition to the existing +``TABLE``, ``COLUMN`` and ``VIEW`` forms: + +- ``INDEX``, ``SCHEMA``, ``SEQUENCE``, ``DOMAIN``, ``TYPE``, ``MATERIALIZED VIEW``, + ``FOREIGN TABLE``, ``COLLATION``, ``STATISTICS``, ``CONVERSION`` and + ``TEXT SEARCH {CONFIGURATION | DICTIONARY | PARSER | TEMPLATE}`` +- ``ACCESS METHOD``, ``DATABASE``, ``EVENT TRIGGER``, ``EXTENSION``, + ``FOREIGN DATA WRAPPER``, ``[PROCEDURAL] LANGUAGE``, ``PUBLICATION``, ``ROLE``, + ``SERVER``, ``SUBSCRIPTION`` and ``TABLESPACE`` +- ``FUNCTION``, ``PROCEDURE``, ``ROUTINE`` and ``AGGREGATE`` signatures +- ``CONSTRAINT``, ``TRIGGER``, ``POLICY`` and ``RULE`` with their owning table +- ``CAST (source_type AS target_type)`` +- ``OPERATOR [schema.]op (left_type, right_type)``, where ``NONE`` marks the missing + operand of a unary operator +- ``OPERATOR CLASS`` and ``OPERATOR FAMILY`` with ``USING access_method`` +- ``LARGE OBJECT oid`` and ``TRANSFORM FOR type_name LANGUAGE lang_name`` + +These unambiguous target forms also parse without a dialect preset. Kind words such as +``ROLE``, ``SERVER``, ``RULE``, ``OPERATOR`` or ``CONVERSION`` are not reserved and +remain ordinary identifiers. +Tagged dollar strings still require ``Dialect.POSTGRESQL`` or +``withDollarQuotedStringTags(true)``. The additional targets are exposed through ``Comment.getTarget()`` as a ``CommentTarget``. Its ``Kind`` identifies the object, and ``getName()`` preserves the individual identifier components. ``Table`` is used as the name container; an index or type name does not thereby represent a table dependency. +``isProcedural()`` records ``PROCEDURAL LANGUAGE``. The original ``Comment.getTable()``, ``getColumn()`` and ``getView()`` accessors continue to describe their respective existing forms. ``COMMENT ON FUNCTION app.f(IN value integer) IS 'description'`` uses the shared -``RoutineReference`` in ``getTarget().getRoutine()``. Argument mode, optional name +``RoutineReference`` in ``getTarget().getRoutine()``; ``Kind.isRoutine()`` identifies +these kinds and ``getName()`` is null. Argument mode, optional name and ``ColDataType`` are preserved. An omitted signature has null arguments; -``f()`` has an empty argument list. The signature identifies a function and is not -a function call. +``f()`` has an empty argument list. The signature identifies a routine and is not +a function call. An ``AGGREGATE`` requires a signature and also accepts ``(*)`` and +ordered-set signatures such as ``(float8 ORDER BY integer)`` or ``(ORDER BY integer)``. For ``COMMENT ON CONSTRAINT ck ON app.t IS NULL``, ``getName()`` is the constraint -name and ``getRelation()`` is its owning table. ``ON DOMAIN app.d`` sets -``isOnDomain()`` and stores the domain as the owner instead. ``NULL`` removes the -comment and remains represented by a null ``Comment.getComment()``. - -Table discovery visits tables, column owners, views, materialized views and -table-owned constraints. It does not infer an index's table or treat domains, -sequences, types or functions as tables. Statement visitors visit comment -literals, and custom SQL deparsers can replace the explicit relation or literal. -Feature analysis reports a schema modification. Validation exposes a separate -``commentOn...`` capability for each additional target kind. +name and ``getRelation()`` is its owning table. ``TRIGGER``, ``POLICY`` and ``RULE`` +targets use the same fields; ``Kind.isOwnedByRelation()`` identifies these kinds. +Only a constraint accepts ``ON DOMAIN app.d``, which sets ``isOnDomain()`` and stores +the domain as the owner instead. A ``CAST`` target exposes ``getSourceType()`` and +``getTargetType()``. ``NULL`` removes the comment and remains represented by a null +``Comment.getComment()``. + +``COMMENT ON OPERATOR app.-> (jsonb, NONE)`` reads the operator with the reference +shared by exclusion constraints and ``ALTER EXTENSION``: ``getOperator()`` returns an +``ExclusionOperator`` with ``getSchemaName()`` and the operator symbol in ``getName()``. +``getLeftOperandType()`` and ``getRightOperandType()`` hold the operand types, and null +stands for ``NONE``; at least one operand type is required. The lexer reads some +PostgreSQL operators, such as ``<<=`` or ``-|-``, as several tokens. Parts that touch +each other are joined into one operator, while whitespace or a comment separates two +operators as in PostgreSQL. Exclusion constraints and ``ALTER EXTENSION`` accept the same +operators. Operators that the lexer reads as part of an identifier, such as ``##`` +without ``Dialect.POSTGRESQL``, are not supported. + +``OPERATOR CLASS`` and ``OPERATOR FAMILY`` targets keep their name in ``getName()`` +and the index access method in ``getAccessMethod()``; ``Kind.isOwnedByAccessMethod()`` +identifies these kinds. ``LARGE OBJECT`` exposes ``getLargeObjectOid()``, which +accepts an unsigned 32-bit integer. ``TRANSFORM`` exposes ``getTransformType()`` and +``getLanguage()``. Each ``TEXT SEARCH`` object type has its own ``Kind``, for example +``TEXT_SEARCH_DICTIONARY``. + +Table discovery visits tables, column owners, views, materialized views, foreign +tables and the tables owning constraints, triggers, policies and rules. It does not +infer an index's table or treat domains, sequences, types, routines or other catalog +objects as tables. Statement visitors visit comment literals, and custom SQL deparsers +can replace the explicit relation or literal. Feature analysis reports a schema +modification. Validation exposes a separate ``commentOn...`` capability for each +additional target kind. Current date/time expression metadata ===================================== @@ -1300,3 +3413,411 @@ 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.getConstraint()``. 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).getConstraint(); + 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. + +Transaction statements +====================== + +``START TRANSACTION`` produces a ``StartTransaction`` with an ordered list of typed +``TransactionMode`` values. PostgreSQL isolation levels, ``READ ONLY`` / ``READ WRITE``, and +``[NOT] DEFERRABLE`` are supported, as is MySQL ``WITH CONSISTENT SNAPSHOT``. +PostgreSQL accepts mode lists with or without commas; output uses commas. +The explicit MySQL dialect rejects a transaction containing both ``READ ONLY`` and +``READ WRITE``, while retaining repeated occurrences of the same mode. + +Choose the dialect explicitly to parse ``BEGIN`` as a transaction command: + +.. code-block:: java + + StartTransaction transaction = (StartTransaction) CCJSqlParserUtil.parse( + "BEGIN ISOLATION LEVEL SERIALIZABLE READ ONLY", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + transaction.getModes().set(1, TransactionMode.READ_WRITE); + // BEGIN ISOLATION LEVEL SERIALIZABLE, READ WRITE + String sql = transaction.toString(); + +Without a dialect, ``BEGIN`` retains the existing procedural block interpretation. +MySQL and PostgreSQL dialects distinguish ``BEGIN`` transactions from +``BEGIN SELECT ...; END`` blocks by the following tokens. Oracle blocks and opaque +routine bodies retain their existing handling. + +``Commit`` and ``RollbackStatement`` share ``TransactionCompletionStatement``, which +exposes the optional ``TransactionKeyword`` (``WORK`` or PostgreSQL ``TRANSACTION``), +``TransactionChain`` (``CHAIN`` or ``NO_CHAIN``) and MySQL ``TransactionRelease`` +(``RELEASE`` or ``NO_RELEASE``). Null fields preserve the server's default behavior; +``AND CHAIN`` cannot be combined with ``RELEASE``. The PostgreSQL spellings ``END`` and +``ABORT`` produce a ``Commit`` and a ``RollbackStatement`` whose ``getCommand()`` is +``END`` or ``ABORT``, so consumers handle one model per completion: + +.. code-block:: java + + Commit end = (Commit) CCJSqlParserUtil.parse("END WORK AND CHAIN", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + // END, WORK, CHAIN + String sql = end.getCommand() + ", " + end.getKeyword() + ", " + end.getChain(); + +``END`` is a statement only with the PostgreSQL dialect, at the start of a statement and +outside ``BEGIN ... END`` blocks; ``ABORT`` is also read without a dialect. The existing +rollback work/savepoint/force accessors remain available. ``RELEASE [SAVEPOINT]`` +produces ``ReleaseSavepointStatement``; the MySQL dialect requires ``SAVEPOINT``. +Savepoint names retain identifier quoting. + +``SET [scope] TRANSACTION``, PostgreSQL ``SET [scope] SESSION CHARACTERISTICS AS +TRANSACTION`` and ``SET [scope] TRANSACTION SNAPSHOT 'id'`` produce a +``SetTransactionStatement``. It reuses ``TransactionMode`` for the characteristics and +the ``SetScope`` of ``SetStatement`` for the scope keyword written after ``SET``; +``isSessionCharacteristics()`` marks the PostgreSQL form and ``getSnapshotId()`` returns +the snapshot as a ``StringValue``. Each dialect accepts the scopes of its server: MySQL +``GLOBAL``, ``SESSION``, ``LOCAL``, ``PERSIST`` and ``PERSIST_ONLY``, MariaDB ``GLOBAL``, +``SESSION`` and ``LOCAL``, and PostgreSQL ``SESSION`` and ``LOCAL``, also before +``SESSION CHARACTERISTICS`` and ``SNAPSHOT``. The MySQL dialect requires commas and +accepts one isolation level and one access mode. Variable assignments such as +``SET transaction_isolation = 'READ-COMMITTED'`` remain ``SetStatement``, whose +``getScope()`` now types the ``getEffectParameter()`` keyword. + +``SET CONSTRAINTS {ALL | name [, ...]} {DEFERRED | IMMEDIATE}`` produces a +``SetConstraintsStatement``. An empty ``getConstraintNames()`` list means ``ALL``, and +``getTiming()`` reuses ``ConstraintAttributes.Initially``. The MySQL dialect rejects it. + +.. code-block:: java + + SetTransactionStatement set = (SetTransactionStatement) CCJSqlParserUtil.parse( + "SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY", + parser -> parser.withDialect(Dialect.MYSQL)); + set.setScope(SetScope.GLOBAL); + // SET GLOBAL TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY + String sql = set.toString(); + +These statements are traversed by statement visitors, deparsers and transaction +feature analysis. The validator checks ``rollback``, ``savepoint``, ``setTransaction``, +``setConstraints`` and the clause features (``transactionChain``, +``transactionRelease``, ``transactionEndAbort``, ``setTransactionGlobal``, +``setTransactionPersist``, ``setTransactionSessionCharacteristics``, +``setTransactionSnapshot``) against the MySQL and PostgreSQL capability sets. +PostgreSQL ``AND [NO] CHAIN`` is enabled beginning with its version 12 capability set. + +Two-phase commit +---------------- + +The two-phase commit statements share one ``TransactionId``: a global transaction +identifier, and for MySQL's xid an optional branch qualifier and format ID +(``gtrid [, bqual [, formatID]]``). The identifier parts are the literals as written, a +``StringValue`` or a ``HexValue``. + +PostgreSQL ``PREPARE TRANSACTION 'id'`` produces a ``PrepareTransactionStatement``; it is +read before ``PREPARE name AS statement``, which keeps producing ``PrepareStatement``. +``COMMIT PREPARED 'id'`` and ``ROLLBACK PREPARED 'id'`` produce a ``Commit`` and a +``RollbackStatement`` whose ``getPreparedTransactionKeyword()`` is ``PREPARED`` and whose +``getPreparedTransactionId()`` names the transaction. Oracle's ``ROLLBACK FORCE 'id'`` +uses the same pair with the keyword ``FORCE``; ``getForceDistributedTransactionIdentifier()`` +still returns the identifier as written. The PostgreSQL forms are read with the PostgreSQL +dialect or without one, and take a PostgreSQL string constant. + +MySQL ``XA {START | BEGIN} xid [JOIN | RESUME]``, ``XA END xid [SUSPEND [FOR MIGRATE]]``, +``XA PREPARE xid``, ``XA COMMIT xid [ONE PHASE]``, ``XA ROLLBACK xid`` and +``XA RECOVER [CONVERT XID]`` produce an ``XaStatement`` with an ``Action`` and an +optional ``Option``. They are read with the MySQL and MariaDB dialects or without one; +MariaDB does not accept ``CONVERT XID``. The gtrid and bqual are string, hexadecimal or +bit-value literals, and the formatID is an unsigned integer. + +.. code-block:: java + + XaStatement xa = (XaStatement) CCJSqlParserUtil.parse("XA START X'0a', 'b', 1 JOIN", + parser -> parser.withDialect(Dialect.MYSQL)); + TransactionId xid = xa.getTransactionId(); + // START, X'0a', 'b', 1, JOIN + String parts = xa.getAction() + ", " + xid.getGlobalTransactionId() + ", " + + xid.getBranchQualifier() + ", " + xid.getFormatId() + ", " + xa.getOption(); + +The validator checks ``twoPhaseCommit`` (PostgreSQL) and ``xa`` (MySQL and MariaDB). +Feature analysis reports ``XA RECOVER`` as returning a result set and the other +statements as transaction control. + +MySQL resource groups +===================== + +MySQL ``CREATE RESOURCE GROUP name TYPE [=] {SYSTEM | USER} [VCPU [=] vcpu_spec [, ...]] +[THREAD_PRIORITY [=] N] [ENABLE | DISABLE]`` produces a ``CreateResourceGroup`` and +``ALTER RESOURCE GROUP name [VCPU ...] [THREAD_PRIORITY ...] [ENABLE | DISABLE] [FORCE]`` +an ``AlterResourceGroup``. Both extend ``ResourceGroupDefinition``, which holds the name, +the VCPU list as ``VcpuRange`` elements (a single CPU or ``start-end``), the thread +priority and the ``State``. Each option remembers whether it was written with ``=``, ``:=`` +or nothing (``OptionAssignment``); the optional commas of the VCPU list are always printed. +``SET RESOURCE GROUP name [FOR thread_id [, ...]]`` produces a ``SetResourceGroup`` whose +thread IDs are the numbers as written (``LongValue`` or ``HexValue``); +``getThreadIds()`` is null without ``FOR``. +``DROP RESOURCE GROUP name [FORCE]`` is a ``Drop`` with the object type ``RESOURCE_GROUP`` +and ``isForce()``. + +.. code-block:: java + + CreateResourceGroup group = (CreateResourceGroup) CCJSqlParserUtil.parse( + "CREATE RESOURCE GROUP rg1 TYPE = USER VCPU = 0-3, 5 THREAD_PRIORITY = 10 ENABLE", + parser -> parser.withDialect(Dialect.MYSQL)); + // USER, [0-3, 5], 10, ENABLE + String parts = group.getType() + ", " + group.getVcpus() + ", " + + group.getThreadPriority() + ", " + group.getState(); + +The statements are read with the MySQL dialect or without one and follow MySQL's grammar: +the options come in the order above, and CPU numbers and the priority are plain integers. +What MySQL checks when it runs the statement, such as the CPU numbers of the machine or the +priority range of the group type, is not checked. In other dialects ``CREATE`` and ``ALTER +RESOURCE GROUP`` stay an ``UnsupportedStatement`` and ``DROP RESOURCE GROUP rg`` keeps the +generic ``Drop`` reading. The validator checks ``createResourceGroup``, +``alterResourceGroup`` and ``setResourceGroup`` (MySQL); feature analysis reports +``SET RESOURCE GROUP`` as a session change and the others as schema changes. + +MySQL loadable functions +======================== + +MySQL ``CREATE [AGGREGATE] FUNCTION [IF NOT EXISTS] name RETURNS {STRING | INTEGER | REAL | +DECIMAL} SONAME 'library'`` produces a ``CreateFunction`` whose ``getLoadableFunction()`` +holds the name, the ``ReturnType``, the library as a ``StringValue`` and ``isIfNotExists()``; +``isAggregate()`` tells the two forms apart. The synonyms ``INT``, ``INT4`` and ``DEC`` keep +their spelling in ``getReturnTypeKeyword()``. ``getFunctionDeclarationParts()`` is derived from +the definition, and setting declaration parts removes it. + +.. code-block:: java + + CreateFunction function = (CreateFunction) CCJSqlParserUtil.parse( + "CREATE AGGREGATE FUNCTION IF NOT EXISTS f RETURNS REAL SONAME 'udf.so'", + parser -> parser.withDialect(Dialect.MYSQL)); + LoadableFunction definition = function.getLoadableFunction(); + // true, f, REAL, udf.so + String parts = function.isAggregate() + ", " + definition.getName() + ", " + + definition.getReturnType() + ", " + definition.getLibrary().getValue(); + +With the MySQL dialect the statement follows MySQL's grammar: ``AGGREGATE``, or a function name +directly followed by ``RETURNS``, must continue as a loadable function, without ``OR REPLACE``. +With the MariaDB dialect or without one, a statement of exactly this shape gets the definition +(``OR REPLACE`` included) and anything else keeps its previous reading. Other dialects are +unchanged: ``CREATE AGGREGATE FUNCTION`` stays an ``UnsupportedStatement`` there. +``TablesNamesFinder`` finds no tables in a loadable function. + +MySQL ALTER TABLE validation modifier +===================================== + +MySQL ``ALTER TABLE ... {WITH | WITHOUT} VALIDATION`` is an ``AlterExpressionTableOption`` +with the operation ``VALIDATION`` and ``getValidationMode()``, like the ``ALGORITHM`` and +``LOCK`` modifiers it may be mixed with in the action list. The mode written directly after +``EXCHANGE PARTITION ... WITH TABLE t`` still belongs to that action +(``AlterExpressionPartition.getExchangeValidationMode()``). + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t1 WITHOUT VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2", + parser -> parser.withDialect(Dialect.MYSQL)); + AlterExpressionTableOption modifier = + (AlterExpressionTableOption) alter.getAlterExpressions().get(0); + // VALIDATION, WITHOUT, EXCHANGE_PARTITION + String parts = modifier.getOperation() + ", " + modifier.getValidationMode() + ", " + + alter.getAlterExpressions().get(1).getOperation(); + +With the MySQL dialect, ``WITH`` or ``WITHOUT`` at the start of an action must be this +modifier, and it is rejected after a comma that follows a command MySQL accepts only at the +end of the list (a partition management command, ``DISCARD`` or ``IMPORT TABLESPACE``, +``PARTITION BY``, ``REMOVE PARTITIONING``). With the MariaDB dialect or without one, the +modifier is read where it is a whole item of the list; other dialects keep the raw-text action. + +MySQL SHOW statements +===================== + +The MySQL statements that read table, column and object definitions parse to typed +statements in every dialect: + +* ``SHOW [EXTENDED] [FULL] TABLES [{FROM | IN} db] [LIKE 'p' | WHERE expr]`` parses to + ``ShowTablesStatement``, as before. +* ``SHOW [EXTENDED] [FULL] {COLUMNS | FIELDS} {FROM | IN} t [{FROM | IN} db] + [LIKE 'p' | WHERE expr]`` extends ``ShowColumnsStatement``. ``getTable()`` returns the + ``Table``; ``getTableName()`` and ``setTableName(String)`` remain and are derived from it. + ``isExtended()``, ``isFull()`` and ``isFieldsKeyword()`` record the modifiers and the + ``FIELDS`` spelling, and ``getTableSelectionMode()`` the ``FROM``/``IN`` spelling before + the table. +* ``SHOW [EXTENDED] {INDEX | INDEXES | KEYS} {FROM | IN} t [{FROM | IN} db] [WHERE expr]`` + extends ``ShowIndexStatement`` in the same way: ``getTable()``, ``isExtended()``, + ``getKeyword()`` (``INDEX``, ``INDEXES`` or ``KEYS``), ``getTableSelectionMode()``, + ``getDbSelection()`` and ``getWhereCondition()``. The ``String`` constructor, + ``getTableName()`` and ``setTableName(String)`` remain. ``SHOW INDEX FROM t FROM db`` + used to fail. +* ``SHOW TABLE STATUS [{FROM | IN} db] [LIKE 'p' | WHERE expr]`` parses to + ``ShowTableStatusStatement``. +* ``SHOW CREATE`` parses to ``ShowCreateStatement``. ``getObjectType()`` is ``TABLE``, + ``VIEW``, ``PROCEDURE``, ``FUNCTION``, ``TRIGGER``, ``EVENT``, ``DATABASE`` or ``USER``. + The first six name the object with ``getName()``, a ``Table``. ``DATABASE`` uses + ``getDatabaseName()``, ``isSchemaKeyword()`` and ``isIfNotExists()``. ``USER`` uses + ``getAccount()``, a ``UserAccount`` without authentication; ``isCurrentUser()`` and + ``isCurrentUserParentheses()`` describe ``CURRENT_USER`` and ``CURRENT_USER()``. + +The ``{FROM | IN} db`` clause is a ``ShowDbSelection`` (``getSelectionMode()`` and +``getName()``) and the ``LIKE 'p' | WHERE expr`` filter a ``ShowFilter`` (``getKind()`` and +``getExpression()``). ``ShowTablesStatement``, ``ShowColumnsStatement``, +``ShowTableStatusStatement`` and ``MySqlShowStatement`` return them from +``getDbSelection()`` and ``getFilter()``; ``ShowIndexStatement`` has the database clause +only. The separate accessors remain and read and write these values: +``getSelectionMode()``/``getDbSelectionMode()``, ``getDbName()``, ``getLikeExpression()`` +and ``getWhereCondition()``. A selection mode set before the database name is kept for it. +A statement holds one filter, so ``setWhereCondition`` replaces a ``LIKE`` filter and +``setLikeExpression`` a ``WHERE`` filter; ``ShowTablesStatement`` used to keep and render +both. ``ShowTablesStatement.toString()`` no longer fails without modifiers or without a +selection mode. + +The other `MySQL 8.4 SHOW statements `_ +parse to ``MySqlShowStatement``. ``getKind()`` tells which one it is and ``getKeyword()`` +how its keywords were spelled: + +* ``VARIABLES`` and ``STATUS`` take a scope and a filter; +* ``PROCESSLIST`` takes ``FULL``; +* ``DATABASES`` (also ``SCHEMAS``), ``PROCEDURE_STATUS``, ``FUNCTION_STATUS``, + ``CHARACTER_SET`` (also ``CHARSET`` and ``CHAR SET``) and ``COLLATION`` take a filter; +* ``TRIGGERS`` (with ``FULL``), ``EVENTS`` and ``OPEN_TABLES`` take a database and a filter; +* ``PROCEDURE_CODE`` and ``FUNCTION_CODE`` take the routine name, and ``ENGINE`` the engine + name and ``STATUS``, ``MUTEX`` or ``LOGS``; +* ``GRANTS`` takes ``FOR account [USING role, ...]``; +* ``WARNINGS`` and ``ERRORS`` take ``COUNT(*)`` or a limit; +* ``BINLOG_EVENTS`` takes ``IN 'log'``, ``FROM pos`` and a limit, and ``RELAYLOG_EVENTS`` + also ``FOR CHANNEL 'c'``; +* ``REPLICA_STATUS`` takes ``FOR CHANNEL 'c'``; +* ``PROFILE`` takes types such as ``CPU`` or ``BLOCK IO``, ``FOR QUERY n`` and a limit; +* ``ENGINES`` (also ``STORAGE ENGINES``), ``PLUGINS``, ``PRIVILEGES``, ``PROFILES``, + ``BINARY_LOGS``, ``BINARY_LOG_STATUS`` and ``REPLICAS`` take nothing. + +The parts have typed accessors: ``getScope()`` (``GLOBAL``, ``SESSION`` or ``LOCAL``), +``isFull()``, ``isCount()``, ``getRoutineName()`` (a ``Table``), ``getEngineName()`` and +``getEngineInfo()``, ``getDbSelection()``, ``getFilter()``, ``getAccount()`` and +``getUsingRoles()`` (``UserAccount`` values, read like the accounts of ``CREATE USER``), +``getLogName()``, ``getPosition()``, ``getLimit()`` (``LIMIT [offset,] n``) with +``getOffset()`` (``LIMIT n OFFSET offset``), ``getChannel()``, ``getProfileTypes()`` and +``getProfileQuery()``. ``Kind.allows(Part)`` tells which parts a kind takes; setting +another part throws ``IllegalArgumentException``, and ``setKind`` drops the parts the new +kind does not take. ``setKeyword("SCHEMAS")`` selects the kind together with its spelling. + +.. code-block:: java + + ShowColumnsStatement columns = (ShowColumnsStatement) CCJSqlParserUtil.parse( + "SHOW FULL COLUMNS FROM orders FROM shop LIKE 'c%'"); + columns.getTableName(); // orders + columns.getDbName(); // shop + + ShowCreateStatement create = (ShowCreateStatement) CCJSqlParserUtil.parse( + "SHOW CREATE USER 'app'@'%'"); + create.getAccount().getHost().getNotExcapedValue(); // % + + MySqlShowStatement grants = (MySqlShowStatement) CCJSqlParserUtil.parse( + "SHOW GRANTS FOR 'app'@'%' USING 'reader'"); + grants.getKind(); // GRANTS + grants.getUsingRoles().size(); // 1 + + MySqlShowStatement events = (MySqlShowStatement) CCJSqlParserUtil.parse( + "SHOW BINLOG EVENTS IN 'binlog.000001' FROM 4 LIMIT 10", + parser -> parser.withDialect(Dialect.MYSQL)); + events.getLogName().getValue(); // binlog.000001 + events.getLimit().getRowCount(); // 10 + +``MySqlShowStatement`` is read with ``Dialect.MYSQL`` and ``Dialect.MARIADB`` and without +a dialect; other dialects keep ``UnsupportedStatement``. Without a dialect, a single word +such as ``SHOW VARIABLES`` or ``SHOW GRANTS`` remains a ``ShowStatement``, as in every +dialect but MySQL and MariaDB. The spellings MySQL 8.4 removed, ``SHOW MASTER STATUS``, +``SHOW MASTER LOGS``, ``SHOW SLAVE STATUS`` and ``SHOW SLAVE HOSTS``, are read with +``Dialect.MARIADB`` and without a dialect. + +With ``Dialect.MYSQL`` or ``Dialect.MARIADB`` the ``LIKE`` pattern of every ``SHOW`` +statement is a string literal, as in the server, and parses to a ``StringValue``; +without a dialect it is any simple expression, as before. Limit values are unsigned +integers, names or ``?`` parameters, log names and channels are strings, and a log +position is an unsigned number. + +A typed statement is used only when it covers the whole statement. Other forms, such as +Snowflake's ``SHOW COLUMNS IN SCHEMA s``, ClickHouse's ``SHOW CREATE TABLE t FORMAT f`` or +``SHOW WARNINGS LIKE 'a'``, remain ``UnsupportedStatement``; ``SHOW INDEX`` forms with +such trailing clauses used to fail. A ``WHERE`` filter is read to its end, so +``SHOW COLUMNS FROM t WHERE a = 1 AND b = 2`` no longer becomes an +``UnsupportedStatement``, and text the expression does not take is a parse error. + +``StatementDeParser`` prints the expressions of the filters, limits and log positions with +its ``ExpressionDeParser``. Table visitors report the table of ``SHOW COLUMNS`` and +``SHOW INDEX`` (qualified by the ``FROM db`` clause) and the table or view of +``SHOW CREATE TABLE`` and ``SHOW CREATE VIEW``; until now ``SHOW INDEX`` raised +``UnsupportedOperationException``, as ``SHOW TABLES`` still does. ``SHOW TABLE STATUS`` +and ``MySqlShowStatement`` name no table. Validators report the ``showColumns``, +``showIndex``, ``showTableStatus``, ``showCreate`` and ``mySqlShow`` features, which the +MySQL and MariaDB capabilities enable, and look up the database of ``MySqlShowStatement`` +and the procedure of ``SHOW PROCEDURE CODE``. Feature analysis +reports ``RETURNS_RESULT_SET``. + +MySQL EXPLAIN, prepared statements and DO +========================================= + +The MySQL forms of these utility statements extend the existing models. They are read with +``Dialect.MYSQL`` and ``Dialect.MARIADB`` and, unless noted, without a dialect; other dialects +are unchanged. + +* `EXPLAIN `_, + ``DESCRIBE`` and ``DESC`` take ``ANALYZE [FORMAT = name]`` or + ``[FORMAT = name] [INTO @variable]``, then ``FOR CONNECTION id`` or + ``[FOR {SCHEMA | DATABASE} name]`` and a ``SELECT``, ``TABLE``, ``VALUES``, ``INSERT``, + ``REPLACE``, ``UPDATE`` or ``DELETE`` statement. They parse to ``ExplainStatement``, whose + ``getKeyword()`` keeps the spelling. ``ANALYZE`` and ``FORMAT`` are ``Option`` values like + PostgreSQL's options; ``Option.isUseEqual()`` marks MySQL's ``FORMAT = name``, and + ``getFormat()`` reads the format as ``ExplainStatement.Format``. A format other than + ``TRADITIONAL``, ``JSON`` or ``TREE`` is rejected, as MySQL rejects it while it parses. + ``getIntoVariable()``, ``getConnectionId()``, ``getSchemaName()`` and ``isSchemaKeyword()`` + hold the other clauses, and ``getTargetKind()`` tells a statement, a table and a connection + apart. ``EXPLAIN SELECT``, ``EXPLAIN ANALYZE SELECT`` and ``DESCRIBE SELECT`` keep their + readings, and ``DESCRIBE TABLE t`` needs the MySQL dialect. +* ``{DESCRIBE | DESC | EXPLAIN} table {column | 'pattern'}`` keeps ``DescribeStatement`` and + ``ExplainStatement``; ``getColumnPattern()`` is the ``Column`` or the ``StringValue``. It + needs the MySQL dialect, since ``DESCRIBE x y`` names an object kind in Snowflake. +* `PREPARE name FROM {'text' | @variable} `_ + extends ``PrepareStatement``: ``getSource()`` is the ``StringValue`` or ``UserVariable`` and + ``getStatement()`` is null. The statement text is not parsed. +* `EXECUTE name USING @a, @b `_ fills + ``Execute.getUsingVariables()``. +* `DROP PREPARE name `_ parses + to ``DeallocateStatement`` with ``getKeyword()`` ``DROP``. +* `DO expr [, expr] ... `_ extends + ``DoStatement``: ``getSelectItems()`` holds the expressions, which MySQL reads as a select list, + and ``getCode()`` is null. Without a dialect, ``DO`` before a string or ``LANGUAGE`` remains + PostgreSQL's code block, which needs ``Dialect.POSTGRESQL``. + +.. code-block:: java + + ExplainStatement explain = (ExplainStatement) CCJSqlParserUtil.parse( + "EXPLAIN ANALYZE FORMAT = TREE SELECT * FROM t", + parser -> parser.withDialect(Dialect.MYSQL)); + explain.getFormat(); // TREE + explain.getOption(ExplainStatement.OptionType.ANALYZE); // present + + Execute execute = (Execute) CCJSqlParserUtil.parse("EXECUTE s USING @a, @b"); + execute.getUsingVariables().size(); // 2 + +Table visitors report the tables of the explained statement, of ``EXPLAIN table`` (until now +none) and of subqueries in MySQL's ``DO``. ``PREPARE ... FROM`` raises +``UnsupportedOperationException``, like ``EXECUTE`` and PostgreSQL's ``DO``, because the tables +of the statement text are unknown. Validators report ``explain``, ``prepare``, +``executeUsing``, ``deallocate`` and ``doStatement``; the MySQL and MariaDB capabilities now +include ``prepare``, ``executeExecute``, ``executeUsing`` and ``doStatement``. Feature analysis +reports ``MODIFIES_SESSION`` instead of ``RETURNS_RESULT_SET`` for ``EXPLAIN ... INTO``, and reads +the expressions of MySQL's ``DO`` instead of reporting ``OPAQUE``. diff --git a/src/test/java/net/sf/jsqlparser/expression/AnalyticExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/AnalyticExpressionTest.java index df4ef1eba5..b1a7b059f9 100644 --- a/src/test/java/net/sf/jsqlparser/expression/AnalyticExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/AnalyticExpressionTest.java @@ -43,4 +43,23 @@ void testDatabricks() throws JSQLParserException { TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + + @Test + void testPartitionByBracketedOperand() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT SUM(x) OVER (PARTITION BY (1 + a) / 2 ORDER BY b) FROM t", true); + + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT SUM(x) OVER w FROM t WINDOW w AS (PARTITION BY (1 + a) / 2)", true); + + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT LISTAGG(x, ',') WITHIN GROUP (ORDER BY y) OVER (PARTITION BY (1 + a) / 2) FROM t", + true); + + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t PREFERRING HIGH x PARTITION BY (1 + a) / 2", true); + + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT SUM(x) OVER (PARTITION BY (a, b), c) FROM t", true); + } } diff --git a/src/test/java/net/sf/jsqlparser/expression/ArrayExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/ArrayExpressionTest.java index 4e114c90f0..90ad192fca 100644 --- a/src/test/java/net/sf/jsqlparser/expression/ArrayExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/ArrayExpressionTest.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.expression; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.SelectItem; @@ -142,4 +143,61 @@ void testMalformedNavigationRejected() { () -> TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a[0].* FROM t", true)); } + @Test + void testColumnSlices() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT l[2:3] FROM t", "SELECT l[:2] FROM t", + "SELECT l[2:] FROM t", "SELECT l[:] FROM t", "SELECT l[-5:] FROM t", + "SELECT l[1:-1:2] FROM t", "SELECT l[1:-:2] FROM t", "SELECT l[:-:-1] FROM t", + "SELECT l[x:y] FROM t", "SELECT s[2:] > 'a' FROM t"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + + PlainSelect select = (PlainSelect) TestUtils + .assertSqlCanBeParsedAndDeparsed("SELECT l[1:-:2] FROM t", true); + RangeExpression slice = (RangeExpression) select.getSelectItem(0) + .getExpression(Column.class).getArrayConstructor().getExpressions().get(0); + assertEquals("1", slice.getStartExpression().toString()); + assertNull(slice.getEndExpression()); + assertEquals("2", slice.getStepExpression().toString()); + } + + @Test + void testExpressionSlices() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT f()[2:] FROM t", "SELECT (l)[:2] FROM t", + "SELECT ([1, 2, 3])[1:-:-1]", "SELECT l[1][2:3] FROM t", + "SELECT l[:2][1] FROM t"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + + ArrayExpression slice = (ArrayExpression) CCJSqlParserUtil.parseExpression("f()[x:y:2]"); + assertNull(slice.getIndexExpression()); + assertEquals("x", slice.getStartIndexExpression().toString()); + assertEquals("y", slice.getStopIndexExpression().toString()); + assertEquals("2", slice.getStepExpression().toString()); + } + + @Test + void testEmptyStepIsDropped() throws JSQLParserException { + assertEquals("l[1:2]", CCJSqlParserUtil.parseExpression("l[1:2:]").toString()); + } + + @Test + void testJsonPathOutsideSubscripts() throws JSQLParserException { + assertInstanceOf(JsonExpression.class, CCJSqlParserUtil.parseExpression("c:a[1]")); + } + + @Test + void testJsonPathNestedInSubscript() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT l[(SELECT c : a FROM t2)] FROM t", + "SELECT l[f(x, c : a)] FROM t", "SELECT l[CASE WHEN c : a = 1 THEN 1 END] FROM t", + "SELECT f()[(SELECT c : a FROM t)]"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + + PlainSelect select = (PlainSelect) TestUtils + .assertSqlCanBeParsedAndDeparsed("SELECT l[ARRAY[c : a]] FROM t", true); + ArrayConstructor array = (ArrayConstructor) select.getSelectItem(0) + .getExpression(Column.class).getArrayConstructor().getExpressions().get(0); + assertInstanceOf(JsonExpression.class, array.getExpressions().get(0)); + } } diff --git a/src/test/java/net/sf/jsqlparser/expression/CastExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/CastExpressionTest.java index 6e0ff80a96..afb6778ade 100644 --- a/src/test/java/net/sf/jsqlparser/expression/CastExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/CastExpressionTest.java @@ -16,6 +16,7 @@ import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.deparser.StatementDeParser; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; @@ -25,6 +26,27 @@ */ public class CastExpressionTest { + @Test + void testCastToSingleFieldRow() throws JSQLParserException { + String sql = "SELECT CAST(ROW(1) AS ROW(x BIGINT))"; + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql); + CastExpression cast = Assertions.assertInstanceOf(CastExpression.class, + select.getSelectItem(0).getExpression()); + Assertions.assertEquals(1, cast.getColumnDefinitions().size()); + Assertions.assertEquals("x", cast.getColumnDefinitions().get(0).getColumnName()); + Assertions.assertEquals("BIGINT", + cast.getColumnDefinitions().get(0).getColDataType().getDataType()); + + Assertions.assertAll( + () -> assertSqlCanBeParsedAndDeparsed(sql), + () -> { + StringBuilder builder = new StringBuilder(); + select.accept(new StatementDeParser(builder)); + Assertions.assertEquals(sql, builder.toString()); + }); + assertSqlCanBeParsedAndDeparsed("SELECT TRY_CAST(ROW(1) AS ROW(x BIGINT))"); + } + @Test public void testCastToRowConstructorIssue1267() throws JSQLParserException { TestUtils.assertExpressionCanBeParsedAndDeparsed( diff --git a/src/test/java/net/sf/jsqlparser/expression/ColumnsTransformerTest.java b/src/test/java/net/sf/jsqlparser/expression/ColumnsTransformerTest.java new file mode 100644 index 0000000000..44efd7e81d --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/ColumnsTransformerTest.java @@ -0,0 +1,112 @@ +/*- + * #%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.expression; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.select.AllColumns; +import net.sf.jsqlparser.statement.select.PlainSelect; +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 ColumnsTransformerTest { + + @ParameterizedTest + @ValueSource(strings = {"*", "t.*", "COLUMNS('m')"}) + void testExceptColumnsReplacePattern(String matcher) throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT " + matcher + " EXCEPT STRICT '^tmp_' FROM t"); + Expression expression = select.getSelectItem(0).getExpression(); + ColumnsTransformer transformer = getTransformer(expression); + transformer.setExceptColumns(new ParenthesedExpressionList<>(new Column("keep"))); + + assertOutput("SELECT " + matcher + " EXCEPT STRICT (keep) FROM t", select); + assertNull(transformer.getExceptPattern()); + if (expression instanceof ColumnsExpression) { + assertVisitedValues(List.of("m", "keep"), expression); + } + } + + @ParameterizedTest + @ValueSource(strings = {"*", "t.*", "COLUMNS('m')"}) + void testExceptPatternReplacesColumns(String matcher) throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT " + matcher + " EXCEPT STRICT (keep) FROM t"); + Expression expression = select.getSelectItem(0).getExpression(); + ColumnsTransformer transformer = getTransformer(expression); + transformer.setExceptPattern(new StringValue("'^tmp_'")); + + assertOutput("SELECT " + matcher + " EXCEPT STRICT '^tmp_' FROM t", select); + if (expression instanceof ColumnsExpression) { + assertVisitedValues(List.of("m", "^tmp_"), expression); + } + assertNull(transformer.getExceptColumns()); + } + + @Test + void testClearingPatternPreservesColumns() { + ColumnsTransformer transformer = + new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.EXCEPT) + .setExceptColumns(new ParenthesedExpressionList<>(new Column("keep"))) + .setExceptPattern(null); + assertEquals("EXCEPT (keep)", transformer.toString()); + } + + @Test + void testClearingColumnsPreservesPattern() { + ColumnsTransformer transformer = + new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.EXCEPT) + .setExceptPattern(new StringValue("'^tmp_'")) + .setExceptColumns(null); + assertEquals("EXCEPT '^tmp_'", transformer.toString()); + } + + private static ColumnsTransformer getTransformer(Expression expression) { + return expression instanceof AllColumns + ? ((AllColumns) expression).getTransformers().get(0) + : ((ColumnsExpression) expression).getTransformers().get(0); + } + + private static void assertOutput(String expected, PlainSelect select) + throws JSQLParserException { + assertEquals(expected, select.toString()); + StatementDeParser deparser = new StatementDeParser(new StringBuilder()); + select.accept(deparser, null); + assertEquals(expected, deparser.getBuilder().toString()); + assertEquals(expected, CCJSqlParserUtil.parse(expected).toString()); + } + + private static void assertVisitedValues(List expected, Expression expression) { + List visited = new ArrayList<>(); + expression.accept(new ExpressionVisitorAdapter() { + @Override + public Void visit(StringValue value, S context) { + visited.add(value.getValue()); + return null; + } + + @Override + public Void visit(Column column, S context) { + visited.add(column.getColumnName()); + return null; + } + }, null); + assertEquals(expected, visited); + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/DateUnitExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/DateUnitExpressionTest.java index 164c9e112a..920070b8f1 100644 --- a/src/test/java/net/sf/jsqlparser/expression/DateUnitExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/DateUnitExpressionTest.java @@ -10,7 +10,10 @@ package net.sf.jsqlparser.expression; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.update.Update; import net.sf.jsqlparser.test.TestUtils; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -27,4 +30,67 @@ void testParsing() throws JSQLParserException { Function f = select.getSelectItem(0).getExpression(Function.class); Assertions.assertThat(f.getParameters().get(1)).isInstanceOf(DateUnitExpression.class); } + + @Test + void testUnitArgumentKeepsItsSpelling() throws JSQLParserException { + String sqlStr = "SELECT DATEADD(day, 1, d) FROM t"; + + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr); + + Function f = select.getSelectItem(0).getExpression(Function.class); + DateUnitExpression unit = (DateUnitExpression) f.getParameters().get(0); + Assertions.assertThat(unit.getType()).isEqualTo(DateUnitExpression.DateUnit.DAY); + Assertions.assertThat(unit).hasToString("day"); + } + + @Test + void testUnitWordOutsideFunctionArgumentsIsColumn() throws JSQLParserException { + String sqlStr = "SELECT year FROM t"; + + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr); + + Column column = select.getSelectItem(0).getExpression(Column.class); + Assertions.assertThat(column.getColumnName()).isEqualTo("year"); + } + + @Test + void testUnitWordAsQualifierIsColumn() throws JSQLParserException { + String sqlStr = "SELECT month.amount FROM sales month"; + + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr); + + Column column = select.getSelectItem(0).getExpression(Column.class); + Assertions.assertThat(column.getFullyQualifiedName()).isEqualTo("month.amount"); + } + + @Test + void testUnitWordWithinArgumentExpressionIsColumn() throws JSQLParserException { + String sqlStr = "SELECT COALESCE(year + 1, 0) FROM t"; + + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr); + + Function f = select.getSelectItem(0).getExpression(Function.class); + Addition addition = (Addition) f.getParameters().get(0); + Assertions.assertThat(addition.getLeftExpression()).isInstanceOf(Column.class); + } + + @Test + void testQuotedUnitWordArgumentIsColumn() throws JSQLParserException { + String sqlStr = "SELECT DATEADD(\"day\", 1, d) FROM t"; + + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr); + + Function f = select.getSelectItem(0).getExpression(Function.class); + Assertions.assertThat(f.getParameters().get(0)).isInstanceOf(Column.class); + } + + @Test + void testUnitWordInUpdateSetTupleIsColumn() throws JSQLParserException { + String sqlStr = "UPDATE t SET (a, year) = (1, 2)"; + + Update update = (Update) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr); + + Assertions.assertThat(update.getUpdateSets().get(0).getColumn(1).getColumnName()) + .isEqualTo("year"); + } } diff --git a/src/test/java/net/sf/jsqlparser/expression/DigitSeparatorsTest.java b/src/test/java/net/sf/jsqlparser/expression/DigitSeparatorsTest.java new file mode 100644 index 0000000000..c9b46ac602 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/DigitSeparatorsTest.java @@ -0,0 +1,64 @@ +/*- + * #%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.expression; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.select.PlainSelect; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; + +class DigitSeparatorsTest { + + private static Expression firstItem(String sql, boolean digitSeparators) + throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql, + parser -> parser.withDigitSeparators(digitSeparators)); + return select.getSelectItem(0).getExpression(); + } + + @ParameterizedTest + @CsvSource({"1_000, 1000", "1_000_000, 1000000", "92_000.0, 92000.0", "1_000.5_5, 1000.55", + ".5_5, .55", "1e1_0, 1e10", "1_0e10, 10e10", "1.5e+1_0, 1.5e+10"}) + void testSeparatorsAreDropped(String literal, String expected) throws JSQLParserException { + assertEquals(expected, firstItem("SELECT " + literal, true).toString()); + } + + @Test + void testSeparatedNumbersAreNumbers() throws JSQLParserException { + assertEquals(1000L, ((LongValue) firstItem("SELECT 1_000", true)).getValue()); + assertEquals(92000.0, ((DoubleValue) firstItem("SELECT 92_000.0", true)).getValue()); + assertEquals("SELECT * FROM t LIMIT 1000", CCJSqlParserUtil + .parse("SELECT * FROM t LIMIT 1_000", parser -> parser.withDigitSeparators()) + .toString()); + } + + @Test + void testPostgreSqlAllowsSeparators() throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT 1_000", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertInstanceOf(LongValue.class, select.getSelectItem(0).getExpression()); + } + + // MySQL identifiers may start with digits + @Test + void testWithoutSeparatorsDigitLedNamesStayIdentifiers() throws JSQLParserException { + assertInstanceOf(Column.class, firstItem("SELECT 1_000", false)); + assertInstanceOf(Column.class, firstItem("SELECT 2024_01.c FROM 2024_01", false)); + assertEquals("SELECT .5 _5", CCJSqlParserUtil.parse("SELECT .5_5").toString()); + assertEquals("SELECT 1.5e+1 _0", CCJSqlParserUtil.parse("SELECT 1.5e+1_0").toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/ExpressionPrecedenceTest.java b/src/test/java/net/sf/jsqlparser/expression/ExpressionPrecedenceTest.java index a0a4973718..040607ddde 100644 --- a/src/test/java/net/sf/jsqlparser/expression/ExpressionPrecedenceTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/ExpressionPrecedenceTest.java @@ -12,15 +12,27 @@ import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.operators.arithmetic.Addition; import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd; +import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseLeftShift; +import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseOr; +import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseRightShift; +import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor; import net.sf.jsqlparser.expression.operators.arithmetic.Concat; +import net.sf.jsqlparser.expression.operators.arithmetic.Division; +import net.sf.jsqlparser.expression.operators.arithmetic.Modulo; +import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; +import net.sf.jsqlparser.expression.operators.arithmetic.Subtraction; import net.sf.jsqlparser.expression.operators.conditional.AndExpression; +import net.sf.jsqlparser.expression.operators.conditional.OrExpression; +import net.sf.jsqlparser.expression.operators.conditional.XorExpression; import net.sf.jsqlparser.expression.operators.relational.Between; import net.sf.jsqlparser.expression.operators.relational.EqualsTo; import net.sf.jsqlparser.expression.operators.relational.ExistsExpression; import net.sf.jsqlparser.expression.operators.relational.InExpression; +import net.sf.jsqlparser.expression.operators.relational.Intersects; import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; import net.sf.jsqlparser.expression.operators.relational.LikeExpression; import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.test.TestUtils; @@ -36,7 +48,15 @@ public class ExpressionPrecedenceTest { @Test public void testGetSign() throws JSQLParserException { + // || binds like +, so tighter than & Expression expr = CCJSqlParserUtil.parseExpression("1&2||3"); + Assertions.assertInstanceOf(BitwiseAnd.class, expr); + Assertions.assertInstanceOf(LongValue.class, ((BitwiseAnd) expr).getLeftExpression()); + Assertions.assertInstanceOf(Concat.class, ((BitwiseAnd) expr).getRightExpression()); + + // PostgreSQL puts || and & on one level + expr = CCJSqlParserUtil.parseExpression("1&2||3", false, + parser -> parser.withDialect(Dialect.POSTGRESQL)); Assertions.assertInstanceOf(Concat.class, expr); Assertions.assertInstanceOf(BitwiseAnd.class, ((Concat) expr).getLeftExpression()); Assertions.assertInstanceOf(LongValue.class, ((Concat) expr).getRightExpression()); @@ -217,4 +237,112 @@ public void testValuePositionNotStaysOnOperand() throws JSQLParserException { Addition add = Assertions.assertInstanceOf(Addition.class, addition); Assertions.assertInstanceOf(NotExpression.class, add.getRightExpression()); } + + @Test + public void testCaretBindsTighterThanMultiplication() throws JSQLParserException { + // PostgreSQL's power and MySQL's XOR both evaluate 2 * 3 ^ 2 as 2 * (3 ^ 2) + Multiplication multiplication = Assertions.assertInstanceOf(Multiplication.class, + CCJSqlParserUtil.parseExpression("2 * 3 ^ 2")); + Assertions.assertInstanceOf(LongValue.class, multiplication.getLeftExpression()); + Assertions.assertInstanceOf(BitwiseXor.class, multiplication.getRightExpression()); + + Division division = Assertions.assertInstanceOf(Division.class, + CCJSqlParserUtil.parseExpression("10 / 2 ^ 2")); + Assertions.assertInstanceOf(BitwiseXor.class, division.getRightExpression()); + + Modulo modulo = Assertions.assertInstanceOf(Modulo.class, + CCJSqlParserUtil.parseExpression("18 % 4 ^ 2")); + Assertions.assertInstanceOf(BitwiseXor.class, modulo.getRightExpression()); + + multiplication = Assertions.assertInstanceOf(Multiplication.class, + CCJSqlParserUtil.parseExpression("2 ^ 3 * 2")); + Assertions.assertInstanceOf(BitwiseXor.class, multiplication.getLeftExpression()); + + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT pi() * r ^ 2 FROM circles"); + } + + @Test + public void testCaretIsLeftAssociative() throws JSQLParserException { + BitwiseXor outer = Assertions.assertInstanceOf(BitwiseXor.class, + CCJSqlParserUtil.parseExpression("2 ^ 3 ^ 2")); + Assertions.assertInstanceOf(BitwiseXor.class, outer.getLeftExpression()); + Assertions.assertInstanceOf(LongValue.class, outer.getRightExpression()); + } + + @Test + public void testBitwiseOperatorsBindLooserThanAddition() throws JSQLParserException { + // PostgreSQL, MySQL and SQLite all evaluate 1 & 7 - 2 as 1 & (7 - 2) + BitwiseAnd and = Assertions.assertInstanceOf(BitwiseAnd.class, + CCJSqlParserUtil.parseExpression("1 & 7 - 2")); + Assertions.assertInstanceOf(LongValue.class, and.getLeftExpression()); + Assertions.assertInstanceOf(Subtraction.class, and.getRightExpression()); + + BitwiseOr or = Assertions.assertInstanceOf(BitwiseOr.class, + CCJSqlParserUtil.parseExpression("a | b + c")); + Assertions.assertInstanceOf(Addition.class, or.getRightExpression()); + + BitwiseLeftShift leftShift = Assertions.assertInstanceOf(BitwiseLeftShift.class, + CCJSqlParserUtil.parseExpression("1 << n - 1")); + Assertions.assertInstanceOf(Subtraction.class, leftShift.getRightExpression()); + + BitwiseRightShift rightShift = Assertions.assertInstanceOf(BitwiseRightShift.class, + CCJSqlParserUtil.parseExpression("a + b >> 2")); + Assertions.assertInstanceOf(Addition.class, rightShift.getLeftExpression()); + + Intersects xor = Assertions.assertInstanceOf(Intersects.class, + CCJSqlParserUtil.parseExpression("a # b + c", false, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + Assertions.assertInstanceOf(Addition.class, xor.getRightExpression()); + + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT flags & 1 << bit - 1 FROM t"); + } + + @Test + public void testBitwiseOperatorsShareOneLeftAssociativeLevel() throws JSQLParserException { + // as in PostgreSQL and SQLite: 4 | 1 & 0 is (4 | 1) & 0 + BitwiseAnd and = Assertions.assertInstanceOf(BitwiseAnd.class, + CCJSqlParserUtil.parseExpression("4 | 1 & 0")); + Assertions.assertInstanceOf(BitwiseOr.class, and.getLeftExpression()); + } + + @Test + public void testSpaceSeparatedConcatStillBindsLikeAddition() throws JSQLParserException { + BitwiseAnd and = Assertions.assertInstanceOf(BitwiseAnd.class, + CCJSqlParserUtil.parseExpression("a & b | | c")); + Assertions.assertInstanceOf(Concat.class, and.getRightExpression()); + } + + @Test + public void testMySqlBitwiseOperatorsAreTiered() throws JSQLParserException { + // MySQL tiers the bitwise operators: << and >> above &, & above | + BitwiseOr or = Assertions.assertInstanceOf(BitwiseOr.class, + CCJSqlParserUtil.parseExpression("1 | 2 & 4", false, + parser -> parser.withDialect(Dialect.MYSQL))); + Assertions.assertInstanceOf(BitwiseAnd.class, or.getRightExpression()); + + BitwiseAnd and = Assertions.assertInstanceOf(BitwiseAnd.class, + CCJSqlParserUtil.parseExpression("3 & 1 << 2", false, + parser -> parser.withDialect(Dialect.MYSQL))); + Assertions.assertInstanceOf(BitwiseLeftShift.class, and.getRightExpression()); + + // the whole chain still sits below + and -, as in the default dialect + BitwiseAnd shifted = Assertions.assertInstanceOf(BitwiseAnd.class, + CCJSqlParserUtil.parseExpression("1 & 7 - 2", false, + parser -> parser.withDialect(Dialect.MYSQL))); + Assertions.assertInstanceOf(Subtraction.class, shifted.getRightExpression()); + } + + @Test + public void testXorBindsBetweenAndAndOr() throws JSQLParserException { + // MySQL: XOR sits between AND and OR + OrExpression or = Assertions.assertInstanceOf(OrExpression.class, + CCJSqlParserUtil.parseExpression("1 OR 1 XOR 1", false, + parser -> parser.withDialect(Dialect.MYSQL))); + Assertions.assertInstanceOf(XorExpression.class, or.getRightExpression()); + + XorExpression xor = Assertions.assertInstanceOf(XorExpression.class, + CCJSqlParserUtil.parseExpression("1 XOR 1 AND 1", false, + parser -> parser.withDialect(Dialect.MYSQL))); + Assertions.assertInstanceOf(AndExpression.class, xor.getRightExpression()); + } } diff --git a/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java b/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java index deb508c199..6456918b15 100644 --- a/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/FunctionTest.java @@ -157,4 +157,14 @@ void testAesDecryptWithKeyExpressionInSelect() throws JSQLParserException { TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + + @Test + void testBracketedOperandAndEmptyListArguments() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT f((1 + a) / (1 + b), (c + d) * 2) FROM t", true); + + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT f(()) FROM t", true); + + TestUtils.assertSqlCanBeParsedAndDeparsed("INSERT INTO t VALUES ()", true); + } } diff --git a/src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java index b31efae37c..ad2a8eb5c8 100644 --- a/src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java @@ -10,6 +10,7 @@ package net.sf.jsqlparser.expression; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.select.PlainSelect; import org.junit.jupiter.api.Assertions; @@ -55,6 +56,99 @@ void testHashArrowOperatorsRoundTrip() throws JSQLParserException { } } + @ParameterizedTest + @ValueSource(strings = {"select", "from", "where", "join", "union", "and", "or", "not", "case", + "when", "else", "as", "is", "like", "having", "distinct", "inner", "into", "with", + "outer", "cross", "using", "output", "null", "order", "group"}) + void testSnowflakeKeywordAsPathName(String keyword) throws JSQLParserException { + String sqlStr = "SELECT v:" + keyword + "::INT, v:" + keyword + ".x[0] FROM vartab"; + PlainSelect st = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sqlStr, true); + Assertions.assertInstanceOf(JsonExpression.class, st.getSelectItem(0).getExpression()); + Assertions.assertInstanceOf(JsonExpression.class, st.getSelectItem(1).getExpression()); + } + + @Test + void testSnowflakeKeywordPathNameBeforeClause() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed( + "SELECT v:from FROM t WHERE v:where::INT = 1 ORDER BY v:order", + true); + } + + @Test + void testSnowflakeKeywordPathNameInInsertSelect() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("INSERT INTO \"MY_DB\".\"MY_SCHEMA\".\"T\" (\"c\")\n" + + "SELECT \"F\".\"DATA_VALUE\":window::VARCHAR FROM \"MY_DB\".\"MY_SCHEMA\".\"RAW_TRACES\" AS \"F\"", + true); + } + + @Test + void testSnowflakeKeywordPathNameOnLateralFlatten() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("INSERT INTO \"MY_DB\".\"MY_SCHEMA\".\"OBS\" (\"o\")\n" + + "SELECT \"obs\".VALUE:output::VARIANT\n" + + "FROM \"MY_DB\".\"MY_SCHEMA\".\"RAW_TRACES\" AS \"F\",\n" + + " lateral flatten(input=>\"F\".\"DATA_VALUE\":observations, outer => true, mode => 'ARRAY') AS \"obs\"", + true); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT v:from::INT, v:output.x[0] FROM t", + "SELECT v:select + 1, v:where * 2 - v:from FROM t", + "SELECT v:window::INT + 1 FROM t WHERE v:order::INT > 2"}) + void testKeywordPathNameDatabricksAndMysqlArithmetic(String sql) throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(Dialect.DATABRICKS)); + assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SNOWFLAKE)); + assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.MYSQL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT coalesce(v:from, v:select::INT) FROM t", + "SELECT CASE WHEN v:when::INT = 1 THEN v:else ELSE v:end END FROM t", + "SELECT * FROM (SELECT v:from AS a FROM t) x WHERE x.a IN (SELECT v:where FROM u)", + "SELECT * FROM t WHERE EXISTS (SELECT 1 FROM u WHERE u.v:order::INT = t.id)", + "SELECT f(v:window, (SELECT w:output FROM u)) FROM t"}) + void testKeywordPathNameInsideNestedConstructs(String sql) throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SNOWFLAKE)); + } + + @ParameterizedTest + @ValueSource(strings = {"select", "from", "where", "join", "union", "and", "or", "not", "case", + "when", "else", "as", "is", "like", "having", "distinct", "inner", "into", "with", + "outer", "cross", "using", "output", "null", "true", "false", "order", "group"}) + void testSnowflakeKeywordAfterDotInPath(String keyword) throws JSQLParserException { + String sqlStr = "SELECT v:a." + keyword + ", v:a.b." + keyword + "::INT, v:a[0]." + keyword + + ".x[1] FROM vartab"; + PlainSelect st = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sqlStr, true); + for (int i = 0; i < 3; i++) { + Assertions.assertInstanceOf(JsonExpression.class, st.getSelectItem(i).getExpression()); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT v:a.output + 1, \"F\".\"X\":\"a\".from::VARIANT AS y FROM t F", + "SELECT * FROM t WHERE v:payload.output::INT = 1 ORDER BY v:payload.from", + "SELECT v:a.output FROM t, lateral flatten(input => t.v:a.input.where) f"}) + void testKeywordAfterDotInPathInContext(String sql) throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SNOWFLAKE)); + } + + @Test + void testKeywordAfterDotOutsideJsonPathIsStillRejected() { + // a reserved word is not a part of a qualified name, only of a JSON path + Assertions.assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT t.output FROM t", + parser -> parser.withDialect(Dialect.SNOWFLAKE))); + } + + @Test + void testKeywordFollowedByParenthesisStaysFunction() throws JSQLParserException { + // only parsing is asserted: a function behind ":" deparses with "." + Assertions.assertNotNull(CCJSqlParserUtil.parse("SELECT v:left(x) FROM t", + parser -> parser.withDialect(Dialect.SNOWFLAKE))); + } + @Test void testSnowflakeGetOperator() throws JSQLParserException { // https://docs.snowflake.com/en/user-guide/querying-semistructured diff --git a/src/test/java/net/sf/jsqlparser/expression/JsonTableCollationTest.java b/src/test/java/net/sf/jsqlparser/expression/JsonTableCollationTest.java new file mode 100644 index 0000000000..84eac19a7e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/JsonTableCollationTest.java @@ -0,0 +1,86 @@ +/*- + * #%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.expression; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.JsonTableFunction.JsonTableValueColumnDefinition; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.TableFunction; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class JsonTableCollationTest { + @ParameterizedTest + @ValueSource(strings = { + "n VARCHAR(10) COLLATE utf8mb4_bin PATH '$.n'", + "n VARCHAR(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin PATH '$.n'", + "n VARCHAR(10) COLLATE `utf8mb4_bin` PATH '$.n'", + "n VARCHAR(10) COLLATE 'utf8mb4_bin' PATH '$.n'", + "n VARCHAR(10) COLLATE \"utf8mb4_bin\" PATH '$.n'", + "NESTED PATH '$.items[*]' COLUMNS (n VARCHAR(10) COLLATE utf8mb4_bin PATH '$.n')" + }) + void collatedColumnsRoundTrip(String column) throws JSQLParserException { + PlainSelect select = parse(sql(column)); + parse(select.toString()); + } + + @Test + void collationCanBeInspectedEditedRemovedAndConstructed() throws JSQLParserException { + PlainSelect select = parse(sql("n VARCHAR(10) COLLATE utf8mb4_bin PATH '$.n'")); + JsonTableFunction table = + (JsonTableFunction) ((TableFunction) select.getFromItem()).getFunction(); + JsonTableValueColumnDefinition column = + (JsonTableValueColumnDefinition) table.getColumnsClause().getColumnDefinitions() + .get(0); + assertEquals("utf8mb4_bin", column.getCollation()); + assertEquals("VARCHAR", column.getDataType().getBaseTypeName()); + column.setCollation("utf8mb4_general_ci"); + TestUtils.assertStatementCanBeDeparsedAs(select, + sql("n VARCHAR(10) COLLATE utf8mb4_general_ci PATH '$.n'"), true); + parse(select.toString()); + column.setCollation(null); + TestUtils.assertStatementCanBeDeparsedAs(select, sql("n VARCHAR(10) PATH '$.n'"), true); + parse(select.toString()); + JsonTableValueColumnDefinition constructed = new JsonTableValueColumnDefinition() + .setColumnName("v") + .setDataType(new ColDataType("VARCHAR").addArgumentsStringList("10")) + .setCollation("utf8mb4_bin").setPathExpression(new StringValue("$.v")); + table.getColumnsClause().getColumnDefinitions().set(0, constructed); + TestUtils.assertStatementCanBeDeparsedAs(select, + sql("v VARCHAR(10) COLLATE utf8mb4_bin PATH '$.v'"), true); + parse(select.toString()); + } + + @Test + void columnCollationRequiresMySqlDialect() { + String sql = sql("n VARCHAR(10) COLLATE utf8mb4_bin PATH '$.n'"); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + } + + private static PlainSelect parse(String sql) throws JSQLParserException { + return (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(Dialect.MYSQL)); + } + + private static String sql(String column) { + return "SELECT * FROM JSON_TABLE('[{\"n\":\"ab\"}]', '$[*]' COLUMNS (" + column + + ")) AS jt"; + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/JsonTableExistsTest.java b/src/test/java/net/sf/jsqlparser/expression/JsonTableExistsTest.java new file mode 100644 index 0000000000..6f7a4a38a6 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/JsonTableExistsTest.java @@ -0,0 +1,85 @@ +/*- + * #%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.expression; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.JsonTableFunction.JsonTableValueColumnDefinition; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.TableFunction; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class JsonTableExistsTest { + @ParameterizedTest + @ValueSource(strings = { + "n INT EXISTS PATH '$.n'", + "n VARCHAR(10) EXISTS PATH '$.n'", + "NESTED PATH '$.items[*]' COLUMNS (n INT EXISTS PATH '$.n')" + }) + void typedExistsRoundTrips(String column) throws JSQLParserException { + String sql = sql(column); + for (Dialect dialect : new Dialect[] {null, Dialect.MYSQL, Dialect.ORACLE}) { + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sql, + true, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString(), false, + parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + } + + @Test + void typedExistsCanBeInspectedAndEdited() throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql("n INT EXISTS PATH '$.n'")); + JsonTableFunction table = + (JsonTableFunction) ((TableFunction) select.getFromItem()).getFunction(); + JsonTableValueColumnDefinition column = + (JsonTableValueColumnDefinition) table.getColumnsClause().getColumnDefinitions() + .get(0); + assertTrue(column.isExists()); + assertEquals("INT", column.getDataType().getBaseTypeName()); + column.setColumnName("present").setDataType(new ColDataType("BIGINT")) + .setPathExpression(new StringValue("$.other")); + TestUtils.assertStatementCanBeDeparsedAs(select, + sql("present BIGINT EXISTS PATH '$.other'"), true); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString()); + column.setExistsKeyword(false); + TestUtils.assertStatementCanBeDeparsedAs(select, sql("present BIGINT PATH '$.other'"), + true); + } + + @Test + void constructedAndUntypedExistsColumnsRetainOrder() throws JSQLParserException { + JsonTableValueColumnDefinition column = new JsonTableValueColumnDefinition() + .setColumnName("n").setExistsKeyword(true).setDataType(new ColDataType("INT")) + .setPathExpression(new StringValue("$.n")); + assertEquals("n INT EXISTS PATH '$.n'", column.toString()); + column.setDataType(null); + assertEquals("n EXISTS PATH '$.n'", column.toString()); + TestUtils.assertSqlCanBeParsedAndDeparsed(sql(column.toString())); + } + + private static String sql(String column) { + return "SELECT * FROM JSON_TABLE('[{\"n\":1},{}]', '$[*]' COLUMNS (" + column + ")) AS jt"; + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/JsonTableResponseTest.java b/src/test/java/net/sf/jsqlparser/expression/JsonTableResponseTest.java new file mode 100644 index 0000000000..a63d5aa808 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/JsonTableResponseTest.java @@ -0,0 +1,106 @@ +/*- + * #%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.expression; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.JsonTableFunction.JsonTableValueColumnDefinition; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.TableFunction; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class JsonTableResponseTest { + @ParameterizedTest + @ValueSource(strings = { + "DEFAULT '9' ON ERROR", + "DEFAULT '0' ON EMPTY DEFAULT '9' ON ERROR", + "DEFAULT '9' ON ERROR DEFAULT '0' ON EMPTY", + "NULL ON EMPTY DEFAULT '9' ON ERROR", + "ERROR ON EMPTY DEFAULT '9' ON ERROR" + }) + void defaultsRoundTripInEitherOrder(String response) throws JSQLParserException { + String sql = sql("n INT PATH '$.n' " + response); + for (Dialect dialect : new Dialect[] {null, Dialect.MYSQL, Dialect.ORACLE}) { + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sql, + true, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString(), false, + parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + } + + @Test + void defaultExpressionsAreVisitedAndEditable() throws JSQLParserException { + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + sql("n INT PATH '$.n' DEFAULT '0' ON EMPTY DEFAULT '9' ON ERROR")); + JsonTableFunction table = + (JsonTableFunction) ((TableFunction) select.getFromItem()).getFunction(); + JsonTableValueColumnDefinition column = + (JsonTableValueColumnDefinition) table.getColumnsClause().getColumnDefinitions() + .get(0); + assertEquals(JsonFunction.JsonOnResponseBehaviorType.DEFAULT, + column.getOnErrorBehavior().getType()); + assertEquals("9", ((StringValue) column.getOnErrorBehavior().getExpression()).getValue()); + List visited = new ArrayList<>(); + table.accept(new ExpressionVisitorAdapter() { + @Override + public Void visit(StringValue value, S context) { + visited.add(value.getValue()); + if ("9".equals(value.getValue())) { + value.setValue("7"); + } + return null; + } + }, null); + assertTrue(visited.containsAll(List.of("$.n", "0", "9"))); + TestUtils.assertStatementCanBeDeparsedAs(select, + sql("n INT PATH '$.n' DEFAULT '0' ON EMPTY DEFAULT '7' ON ERROR"), true); + column.setOnErrorBehavior(new JsonFunction.JsonOnResponseBehavior( + JsonFunction.JsonOnResponseBehaviorType.DEFAULT, new StringValue("8"))); + column.setOnEmptyAfterOnError(true); + TestUtils.assertStatementCanBeDeparsedAs(select, + sql("n INT PATH '$.n' DEFAULT '8' ON ERROR DEFAULT '0' ON EMPTY"), true); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString()); + } + + @Test + void nestedDefaultsRoundTrip() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sql( + "NESTED PATH '$.items[*]' COLUMNS (n INT PATH '$.n' DEFAULT '9' ON ERROR)")); + } + + @ParameterizedTest + @ValueSource( + strings = {"NULL", "ERROR", "TRUE", "FALSE", "EMPTY", "EMPTY ARRAY", "EMPTY OBJECT"}) + void sharedNonDefaultResponsesRoundTrip(String behavior) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sql("n PATH '$.n' " + behavior + " ON ERROR")); + TestUtils.assertSqlCanBeParsedAndDeparsed(sql("n PATH '$.n' " + behavior + " ON EMPTY")); + } + + private static String sql(String column) { + return "SELECT * FROM JSON_TABLE('[{\"n\":1},{},{\"n\":\"bad\"}]', '$[*]' COLUMNS (" + + column + ")) AS jt"; + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/QuotedHexValueTest.java b/src/test/java/net/sf/jsqlparser/expression/QuotedHexValueTest.java new file mode 100644 index 0000000000..2902220374 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/QuotedHexValueTest.java @@ -0,0 +1,81 @@ +/*- + * #%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.expression; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class QuotedHexValueTest { + @ParameterizedTest + @ValueSource(strings = { + "SELECT X'6162' AS v", + "SELECT X'6162' AS v", + "SELECT X'6162' FROM t", + "SELECT X'6162' ", + "SELECT X'6162'\tAS v", + "SELECT X'6162'\nAS v" + }) + void whitespaceIsNotPartOfHexLiteral(String sql) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.MYSQL, Dialect.POSTGRESQL}) { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql, + parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + HexValue hex = (HexValue) select.getSelectItem(0).getExpression(); + assertEquals("X'6162'", hex.getValue()); + assertEquals("6162", hex.getDigits()); + assertEquals(24930L, hex.getLong()); + assertEquals("ab", hex.getStringValue().getValue()); + assertEquals("\\x61\\x62", hex.getBlob().getValue()); + String canonical = select.toString(); + for (int i = 0; i < 3; i++) { + select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(canonical, + false, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + assertEquals(canonical, select.toString()); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"X'61 62'", "X'61' '62'", "X'61''62'", "X''", "x'6162'", "0x6162"}) + void existingHexTokenFormsArePreserved(String literal) throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT " + literal + " AS v"); + assertEquals(literal, ((HexValue) select.getSelectItem(0).getExpression()).getValue()); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString(), false); + } + + @Test + void jsonDefaultHexIsAccessibleAndEditable() throws JSQLParserException { + String sql = "SELECT JSON_VALUE('{}', '$.v' DEFAULT X'6162' ON EMPTY)"; + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false); + JsonFunction function = (JsonFunction) select.getSelectItem(0).getExpression(); + HexValue hex = (HexValue) function.getOnEmptyBehavior().getExpression(); + assertEquals("6162", hex.getDigits()); + assertEquals("ab", hex.getStringValue().getValue()); + hex.setValue("X'6364'"); + TestUtils.assertStatementCanBeDeparsedAs(select, sql.replace("6162", "6364")); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString(), false); + assertEquals("cd", hex.getStringValue().getValue()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/StringValueTest.java b/src/test/java/net/sf/jsqlparser/expression/StringValueTest.java index 3dcb03a3dd..63fe8b5626 100644 --- a/src/test/java/net/sf/jsqlparser/expression/StringValueTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/StringValueTest.java @@ -10,12 +10,30 @@ package net.sf.jsqlparser.expression; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; +import java.time.Duration; +import java.util.Arrays; +import java.util.HashSet; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.operators.arithmetic.Concat; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.comment.Comment; +import net.sf.jsqlparser.statement.create.table.ColumnOption; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; /** * @@ -50,6 +68,307 @@ public void testGetNotExcapedValue() { assertEquals(expResult, result); } + @Test + public void testGetNotExcapedValueLargeInputIsLinear() { + // a string literal made of many escaped single quotes used to be unescaped with a + // deleteCharAt() per pair, which is quadratic and lets a modest literal burn CPU + int pairs = 1_000_000; + StringBuilder sb = new StringBuilder(2 * pairs + 2); + sb.append('\''); + for (int i = 0; i < pairs; i++) { + sb.append("''"); + } + sb.append('\''); + StringValue instance = new StringValue(sb.toString()); + + String result = assertTimeoutPreemptively(Duration.ofSeconds(2), + instance::getNotExcapedValue); + + assertEquals(pairs, result.length()); + for (int i = 0; i < result.length(); i++) { + assertEquals('\'', result.charAt(i)); + } + } + + private static StringValue literal(String sql, Dialect dialect) throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT " + sql, + parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + return (StringValue) select.getSelectItem(0).getExpression(); + } + + @Test + void testMySqlBackslashEscapes() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB}) { + StringValue value = literal("'it\\'s a\\\\b'", dialect); + assertEquals(StringValue.Escaping.MYSQL_BACKSLASH, value.getEscaping()); + assertEquals("it\\'s a\\\\b", value.getValue()); + assertEquals("it's a\\b", value.getNotExcapedValue()); + assertEquals("it's", literal("'it''s'", dialect).getNotExcapedValue()); + } + assertEquals("x\ny\tz\0\u001A\b\r", + literal("'x\\ny\\tz\\0\\Z\\b\\r'", Dialect.MYSQL).getNotExcapedValue()); + // \% and \_ keep their backslash; other escaped characters stand for themselves + assertEquals("a\\%b\\_cq\"", literal("'a\\%b\\_c\\q\\\"'", Dialect.MYSQL) + .getNotExcapedValue()); + assertEquals("it's", literal("N'it\\'s'", Dialect.MYSQL).getNotExcapedValue()); + } + + @Test + void testDoubledQuoteFollowsTheQuoteCharacter() throws JSQLParserException { + assertEquals("it\"s", literal("\"it\"\"s\"", Dialect.MYSQL).getNotExcapedValue()); + assertEquals("it''s", literal("\"it''s\"", Dialect.MYSQL).getNotExcapedValue()); + } + + @Test + void testBackslashEscapesWithoutDialect() throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT 'it\\'s'", + parser -> parser.withBackslashEscapeCharacter(true)); + StringValue value = (StringValue) select.getSelectItem(0).getExpression(); + assertEquals(StringValue.Escaping.MYSQL_BACKSLASH, value.getEscaping()); + assertEquals("it's", value.getNotExcapedValue()); + + StringValue standard = literal("'a\\nb'", null); + assertEquals(StringValue.Escaping.STANDARD, standard.getEscaping()); + assertEquals("a\\nb", standard.getNotExcapedValue()); + } + + @Test + void testPostgresEscapeStrings() throws JSQLParserException { + StringValue standard = literal("'a\\nb'", Dialect.POSTGRESQL); + assertEquals(StringValue.Escaping.STANDARD, standard.getEscaping()); + assertEquals("a\\nb", standard.getNotExcapedValue()); + + StringValue escape = literal("E'it\\'s\\tx\\\\'", Dialect.POSTGRESQL); + assertEquals(StringValue.Escaping.POSTGRESQL_ESCAPE_STRING, escape.getEscaping()); + assertEquals("it's\tx\\", escape.getNotExcapedValue()); + assertEquals("it's", literal("E'it''s'", Dialect.POSTGRESQL).getNotExcapedValue()); + // octal and hexadecimal escapes are bytes of the UTF-8 encoding + assertEquals("AAéé café 😀 q", literal( + "E'\\x41\\101\\303\\251\\xC3\\xA9 caf\\u00e9 \\U0001F600 \\q'", + Dialect.POSTGRESQL).getNotExcapedValue()); + assertEquals("it''s\\n", literal("$$it''s\\n$$", Dialect.POSTGRESQL) + .getNotExcapedValue()); + } + + @Test + void testPostgresEscapeStringUnicodeEscapes() throws JSQLParserException { + String[][] cases = { + {"E'\\U0010FFFF'", new String(Character.toChars(0x10FFFF))}, + // a surrogate pair as two escapes, in either form + {"E'\\uD83D\\uDE00'", "\uD83D\uDE00"}, + {"E'\\ud83d\\U0000de00'", "\uD83D\uDE00"}, + {"E'\\x41\\uD83D\\uDE00\\101'", "A\uD83D\uDE00A"}}; + for (String[] c : cases) { + assertEquals(c[1], literal(c[0], Dialect.POSTGRESQL).getNotExcapedValue(), c[0]); + } + + // the escapes PostgreSQL rejects: too few digits, invalid code points and a surrogate + // not written as a pair + for (String sql : new String[] {"E'\\u00e'", "E'\\U0001F60'", "E'\\u0000'", + "E'\\U00000000'", "E'\\U00110000'", "E'\\U7FFFFFFF'", "E'\\UFFFFFFFF'", + "E'\\uD800'", "E'\\uD800x'", "E'\\uD800\\u0041'", "E'\\uD800\\x41'", + "E'\\uD800'''", "E'\\uDE00'", "E'\\uD800\\uD800\\uDE00'"}) { + assertThrows(IllegalArgumentException.class, () -> new StringValue(sql) + .withEscaping(StringValue.Escaping.POSTGRESQL_ESCAPE_STRING) + .getNotExcapedValue(), sql); + assertThrows(JSQLParserException.class, () -> literal(sql, Dialect.POSTGRESQL), sql); + } + // only the escapes of PostgreSQL strings are checked + assertEquals("\\uD800", literal("'\\uD800'", Dialect.POSTGRESQL).getNotExcapedValue()); + assertEquals("\\uD800", literal("E'\\uD800'", null).getNotExcapedValue()); + } + + @Test + void testPostgresUnicodeEscapeStrings() throws JSQLParserException { + StringValue value = literal("U&'\\0041BC \\00e9'", Dialect.POSTGRESQL); + assertEquals(StringValue.Escaping.POSTGRESQL_UNICODE_ESCAPE, value.getEscaping()); + assertEquals("U&", value.getPrefix()); + assertEquals("\\0041BC \\00e9", value.getValue()); + assertNull(value.getUnicodeEscapeCharacter()); + assertEquals("ABC \u00e9", value.getNotExcapedValue()); + + StringValue custom = literal("U&'d!0061t!+000061' UESCAPE '!'", Dialect.POSTGRESQL); + assertEquals("d!0061t!+000061", custom.getValue()); + assertEquals(Character.valueOf('!'), custom.getUnicodeEscapeCharacter()); + assertEquals("data", custom.getNotExcapedValue()); + assertEquals("U&'d!0061t!+000061' UESCAPE '!'", custom.toString()); + + String[][] cases = { + {"U&'\\+01F600'", "\uD83D\uDE00"}, + {"U&'a\\\\b'", "a\\b"}, + {"U&'it''s'", "it's"}, + // a surrogate pair as two escapes, in either form + {"u&'\\D83D\\DE00'", "\uD83D\uDE00"}, + {"U&'\\d83d\\+00de00'", "\uD83D\uDE00"}, + {"U&'caf\\00E9 \\+00AC00 \uD55C\uAE00'", "caf\u00e9 \uAC00 \uD55C\uAE00"}, + // a doubled escape character stands for itself; other backslashes stay + {"U&'a!!b\\n!0021' UESCAPE '!'", "a!b\\n!"}, + {"U&'\\' UESCAPE '!'", "\\"}, + {"U&'#0041' uescape '#'", "A"}, + {"U&'x' UESCAPE '\\'", "x"}, + {"U&''", ""}}; + for (String[] c : cases) { + assertEquals(c[1], literal(c[0], Dialect.POSTGRESQL).getNotExcapedValue(), c[0]); + } + } + + @Test + void testPostgresUnicodeEscapeStringsRoundTrip() throws JSQLParserException { + for (String sql : new String[] { + "COMMENT ON TABLE t IS U&'\\0041BC \\00e9'", + "COMMENT ON TABLE t IS U&'d!0061t!+000061' UESCAPE '!'", + "CREATE TABLE t (a text DEFAULT U&'\\+01F600', b text DEFAULT U&'it''s')", + "ALTER TABLE t ALTER COLUMN a SET DEFAULT U&'a\\\\b'", + "INSERT INTO t VALUES (U&'#0041' UESCAPE '#', U&'x')", + "SELECT * FROM t WHERE a = U&'\\00e9' AND b LIKE U&'%!0041' UESCAPE '!'"}) { + Statement statement = TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + Statement reparsed = CCJSqlParserUtil.parse(statement.toString(), + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(sql, reparsed.toString()); + } + Comment comment = (Comment) CCJSqlParserUtil.parse( + "COMMENT ON TABLE t IS U&'d!0061t!+000061' UESCAPE '!'", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals("data", comment.getComment().getNotExcapedValue()); + // a continuation line belongs to the same Unicode escape string, as on the server + StringValue continued = literal("U&'\\0041'\n'\\0042'", Dialect.POSTGRESQL); + assertEquals("AB", continued.getNotExcapedValue()); + assertEquals("U&'\\0041\\0042'", continued.toString()); + } + + @Test + void testConstructedUnicodeEscapeStrings() { + StringValue value = new StringValue("U&'!0041' UESCAPE '!'"); + assertEquals("U&", value.getPrefix()); + assertEquals("!0041", value.getValue()); + assertEquals(StringValue.Escaping.POSTGRESQL_UNICODE_ESCAPE, value.getEscaping()); + assertEquals("A", value.getNotExcapedValue()); + assertEquals("U&'!0041' UESCAPE '!'", value.toString()); + assertEquals("U&'!0041'", value.withUnicodeEscapeCharacter(null).toString()); + assertEquals("!0041", value.getNotExcapedValue()); + + StringValue built = new StringValue("'#00e9'").withPrefix("U&") + .withEscaping(StringValue.Escaping.POSTGRESQL_UNICODE_ESCAPE) + .withUnicodeEscapeCharacter('#'); + assertEquals("U&'#00e9' UESCAPE '#'", built.toString()); + assertEquals("\u00e9", built.getNotExcapedValue()); + ExpressionDeParser deParser = new ExpressionDeParser(); + built.accept(deParser, null); + assertEquals("U&'#00e9' UESCAPE '#'", deParser.getBuilder().toString()); + + assertThrows(IllegalArgumentException.class, + () -> new StringValue("U&'\\00'").getNotExcapedValue()); + assertThrows(IllegalArgumentException.class, + () -> new StringValue("U&'x' UESCAPE '+'").getNotExcapedValue()); + // without the escaping a U& prefix only renders + assertEquals("\\0041", new StringValue("'\\0041'").withPrefix("U&").getNotExcapedValue()); + } + + @Test + void testUnicodeUnescapingIsLinear() { + int escapes = 500_000; + StringBuilder sb = new StringBuilder(13 * escapes + 4).append("U&'"); + for (int i = 0; i < escapes; i++) { + sb.append("\\0041\\+01F600"); + } + StringValue instance = new StringValue(sb.append('\'').toString()); + + String result = assertTimeoutPreemptively(Duration.ofSeconds(2), + instance::getNotExcapedValue); + + assertEquals(3 * escapes, result.length()); + } + + @Test + void testOtherBackslashDialectsKeepTheirSource() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.BIGQUERY, Dialect.DATABRICKS, + Dialect.SNOWFLAKE}) { + StringValue value = literal("'it\\'s'", dialect); + assertEquals(StringValue.Escaping.STANDARD, value.getEscaping()); + assertEquals("it\\'s", value.getNotExcapedValue()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"r'a\\'", "R'a\\'", "r\"a\\\"", "R\"a\\\""}) + void testDatabricksRawLiteralEndsAtFirstQuote(String literal) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse( + "SELECT " + literal + " UNION SELECT pw FROM secrets -- " + literal.charAt(1), + parser -> parser.withDialect(Dialect.DATABRICKS)); + + assertEquals(new HashSet<>(Arrays.asList("secrets")), + new TablesNamesFinder().getTables(statement)); + } + + @Test + void testDatabricksRawLiteralBody() throws JSQLParserException { + StringValue single = literal("r'C:\\dir\\'", Dialect.DATABRICKS); + assertEquals("R", single.getPrefix()); + assertEquals("C:\\dir\\", single.getValue()); + + StringValue dbl = literal("r\"C:\\dir\\\"", Dialect.DATABRICKS); + assertEquals("R", dbl.getPrefix()); + assertEquals("\"", dbl.getQuoteStr()); + assertEquals("C:\\dir\\", dbl.getValue()); + assertEquals("R\"C:\\dir\\\"", dbl.toString()); + } + + @Test + void testRawLiteralPrefixElsewhereIsUnchanged() throws JSQLParserException { + assertEquals("a\\' x", literal("r'a\\' x'", Dialect.BIGQUERY).getValue()); + assertEquals("a\\' x", literal("r'a\\' x'", Dialect.MYSQL).getValue()); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT r \"x\" FROM t", true); + assertEquals("SELECT r \"x\" FROM t", + CCJSqlParserUtil.parse("SELECT r\"x\" FROM t").toString()); + } + + @Test + void testConstructedValuesDefaultToStandardEscaping() { + StringValue value = new StringValue("'a\\n''b'"); + assertEquals(StringValue.Escaping.STANDARD, value.getEscaping()); + assertEquals("a\\n'b", value.getNotExcapedValue()); + assertEquals("a\n'b", + value.withEscaping(StringValue.Escaping.MYSQL_BACKSLASH).getNotExcapedValue()); + value.setEscaping(null); + assertEquals(StringValue.Escaping.STANDARD, value.getEscaping()); + } + + @Test + void testColumnDefaultValueIsUnescaped() throws JSQLParserException { + for (String literal : new String[] {"'it''s'", "'it\\'s'"}) { + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD COLUMN s VARCHAR(10) DEFAULT " + literal, + parser -> parser.withDialect(Dialect.MYSQL)); + ColumnOption option = alter.getAlterExpressions().get(0).getColDataTypeList().get(0) + .getColumnOptions().get(0); + assertEquals("it's", + ((StringValue) option.getDefaultExpression()).getNotExcapedValue()); + assertEquals("ALTER TABLE t ADD COLUMN s VARCHAR (10) DEFAULT " + literal, + alter.toString()); + } + } + + @Test + void testBackslashUnescapingIsLinear() { + int pairs = 1_000_000; + StringBuilder sb = new StringBuilder(2 * pairs + 2).append('\''); + for (int i = 0; i < pairs; i++) { + sb.append("\\'"); + } + StringValue instance = new StringValue(sb.append('\'').toString()) + .withEscaping(StringValue.Escaping.MYSQL_BACKSLASH); + + String result = assertTimeoutPreemptively(Duration.ofSeconds(2), + instance::getNotExcapedValue); + + assertEquals(pairs, result.length()); + } + @Test public void testPrefixes() { checkStringValue("E'test'", "test", "E"); @@ -90,6 +409,51 @@ public void testOracleAlternativeQuoting() throws JSQLParserException { TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + @ParameterizedTest + @ValueSource(strings = {"q'{a}'", "q'(a)'", "q'[a]'", "q''a''", "Q'[a]'"}) + void testOracleAlternativeQuotingEndsAtFirstDelimiter(String literal) + throws JSQLParserException { + String sqlStr = + "SELECT " + literal + " FROM t WHERE id IN (SELECT id FROM secrets) AND x = " + + literal; + + Statement statement = TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + + assertEquals(new HashSet<>(Arrays.asList("t", "secrets")), + new TablesNamesFinder().getTables(statement)); + assertEquals(3, CCJSqlParserUtil.parseStatements( + "SELECT " + literal + " FROM t; DELETE FROM u; SELECT " + literal + " FROM t") + .size()); + } + + @Test + void testOracleAlternativeQuotingKeepsOneLiteralPerQuote() throws JSQLParserException { + PlainSelect select = (PlainSelect) TestUtils + .assertSqlCanBeParsedAndDeparsed("SELECT q'[a]' || q'[b]' FROM dual", true); + + Concat concat = (Concat) select.getSelectItem(0).getExpression(); + assertEquals("[a]", ((StringValue) concat.getLeftExpression()).getValue()); + assertEquals("[b]", ((StringValue) concat.getRightExpression()).getValue()); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', quoteCharacter = '"', value = { + "q'[a]b]'|[a]b]", + "q'[a]]'|[a]]", + "q'[]'|[]", + "q'[]]'|[]]", + "q'[it's]'|[it's]", + "q'(a)b)'|(a)b)", + "q'{a}}'|{a}}", + "q''a'b''|'a'b'"}) + void testOracleAlternativeQuotingBody(String literal, String value) + throws JSQLParserException { + PlainSelect select = (PlainSelect) TestUtils + .assertSqlCanBeParsedAndDeparsed("SELECT " + literal + " FROM dual", true); + + assertEquals(value, ((StringValue) select.getSelectItem(0).getExpression()).getValue()); + } + @Test public void testParseInput_BYTEA() throws Exception { String sqlStr = "VALUES (X'', X'01FF', X'01 bc 2a', X'01' '02')"; diff --git a/src/test/java/net/sf/jsqlparser/expression/WeightStringFunctionTest.java b/src/test/java/net/sf/jsqlparser/expression/WeightStringFunctionTest.java new file mode 100644 index 0000000000..1c72fbbeb9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/expression/WeightStringFunctionTest.java @@ -0,0 +1,141 @@ +/*- + * #%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.expression; + +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 static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Collections; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class WeightStringFunctionTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + + private static Function selectFunction(String sql, int index, + Consumer consumer) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sql, true, consumer); + return (Function) select.getSelectItem(index).getExpression(); + } + + @Test + void castToCharWithMySqlDialect() throws JSQLParserException { + String sql = "SELECT CHAR(77 USING utf8mb4), WEIGHT_STRING('x' AS CHAR(3))"; + Function function = selectFunction(sql, 1, MYSQL); + + assertEquals("WEIGHT_STRING", function.getName()); + assertEquals("'x'", function.getParameters().get(0).toString()); + // the same ColDataType as in CAST('x' AS CHAR(3)) + assertEquals("CHAR (3)", function.getCastType().getDataType()); + CastExpression cast = + (CastExpression) CCJSqlParserUtil.parseExpression("CAST('x' AS CHAR(3))"); + assertEquals(cast.getColDataType().toString(), function.getCastType().toString()); + assertEquals("WEIGHT_STRING('x' AS CHAR (3))", function.toString()); + assertEquals(3, function.getCastType().getNumericPrecision().intValue()); + + // the type spans its own text, inside the call + Node node = function.getCastType().getASTNode(); + assertEquals("CHAR(3)", sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + @Test + void castToBinaryWithoutDialect() throws JSQLParserException { + Function function = selectFunction("SELECT weight_string(c AS BINARY(4)) FROM t", 0, null); + + assertEquals("BINARY (4)", function.getCastType().getDataType()); + assertInstanceOf(Column.class, function.getParameters().get(0)); + } + + @Test + void plainCallHasNoCastType() throws JSQLParserException { + Function function = selectFunction("SELECT WEIGHT_STRING('x')", 0, MYSQL); + + assertNull(function.getCastType()); + assertEquals("WEIGHT_STRING('x')", function.toString()); + } + + @Test + void charUsingKeepsItsKeywordArgument() throws JSQLParserException { + Function function = selectFunction("SELECT CHAR(77 USING utf8mb4)", 0, MYSQL); + + assertNull(function.getCastType()); + assertEquals("USING", function.getKeywordArguments().get(0).getKeyword()); + } + + @Test + void nestedInExpressionsAndSubqueries() throws JSQLParserException { + String sql = "SELECT HEX(WEIGHT_STRING(a AS CHAR(2))) FROM t" + + " WHERE WEIGHT_STRING(b AS BINARY(8)) = (SELECT WEIGHT_STRING(c) FROM s)"; + assertSqlCanBeParsedAndDeparsed(sql, true, MYSQL); + + assertEquals(2, TablesNamesFinder.findTables(sql).size()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT WEIGHT_STRING('x' AS CHAR)", + "SELECT WEIGHT_STRING('x' AS VARCHAR(3))", + "SELECT WEIGHT_STRING('x' AS CHAR(3)", + "SELECT LOWER('x' AS CHAR(3))", + "SELECT WEIGHT_STRING('x' AS CHAR(3) AS BINARY(3))", + "SELECT WEIGHT_STRING('x' AS CHAR(3) CHARACTER SET utf8mb4)", + "SELECT WEIGHT_STRING('x' AS CHAR(n))", + "SELECT WEIGHT_STRING('x' AS BINARY(3, 2))", + "SELECT WEIGHT_STRING('x' AS CHAR(3) ARRAY)", + "SELECT WEIGHT_STRING('x', 'y' AS CHAR(3))", + "SELECT WEIGHT_STRING(DISTINCT 'x' AS CHAR(3))", + "SELECT WEIGHT_STRING(AS CHAR(3))", + "SELECT db.WEIGHT_STRING('x' AS CHAR(3))" + }) + void rejectsOtherCastForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @Test + void statementBoundary() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT WEIGHT_STRING('x' AS CHAR(3)); SELECT 1", MYSQL); + + assertEquals(2, statements.size()); + } + + @Test + void buildCastTypeOnTheModel() throws JSQLParserException { + ColDataType binary = new ColDataType("BINARY"); + binary.setArgumentsStringList(Collections.singletonList("4")); + Function function = new Function().withName("WEIGHT_STRING") + .withParameters(new StringValue("x")).withCastType(binary); + + assertEquals("WEIGHT_STRING('x' AS BINARY (4))", function.toString()); + assertDeparse(new PlainSelect().addSelectItem(function), + "SELECT WEIGHT_STRING('x' AS BINARY (4))"); + + function.setCastType(null); + assertEquals("WEIGHT_STRING('x')", function.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/expression/operators/relational/ComparisonOperatorTest.java b/src/test/java/net/sf/jsqlparser/expression/operators/relational/ComparisonOperatorTest.java index 7be79658ab..4530364195 100644 --- a/src/test/java/net/sf/jsqlparser/expression/operators/relational/ComparisonOperatorTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/operators/relational/ComparisonOperatorTest.java @@ -10,10 +10,15 @@ package net.sf.jsqlparser.expression.operators.relational; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.BinaryExpression; +import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; class ComparisonOperatorTest { @@ -43,4 +48,95 @@ void testCosineSimilarity() throws JSQLParserException { Assertions.assertInstanceOf(CosineSimilarity.class, CCJSqlParserUtil.parseExpression("embedding <=> '[3,1,2]'")); } + + @Test + void testVectorDistanceOperatorsInProjection() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a <-> b FROM t"); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a <#> b FROM t"); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a <=> b FROM t"); + Assertions.assertInstanceOf(GeometryDistance.class, + CCJSqlParserUtil.parseExpression("a <-> b")); + Assertions.assertInstanceOf(GeometryDistance.class, + CCJSqlParserUtil.parseExpression("a <#> b")); + Assertions.assertInstanceOf(CosineSimilarity.class, + CCJSqlParserUtil.parseExpression("a <=> b")); + } + + @ParameterizedTest + @ValueSource(strings = {"<->", "<#>", "<=>"}) + void testVectorDistanceOperatorsFollowedByComparison(String distance) + throws JSQLParserException { + String[] comparators = {"<", ">", "="}; + for (String comparator : comparators) { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t WHERE a " + distance + " b " + comparator + " c"); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t WHERE (a " + distance + " b) " + comparator + " c"); + } + Assertions.assertInstanceOf(MinorThan.class, + CCJSqlParserUtil.parseExpression("a " + distance + " b < c")); + } + + @ParameterizedTest + @ValueSource(strings = {"<->", "<#>", "<=>"}) + void testVectorDistanceOperatorsInProjectionFollowedByComparison(String distance) + throws JSQLParserException { + String[] comparators = {"<", ">", "="}; + for (String comparator : comparators) { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a " + distance + " b " + comparator + " c FROM t"); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT (a " + distance + " b) " + comparator + " c FROM t"); + } + } + + @ParameterizedTest + @ValueSource(strings = {"<->", "<#>", "<=>"}) + void testVectorDistanceOperatorsShareBitwisePrecedence(String distance) + throws JSQLParserException { + Class distanceType = + "<=>".equals(distance) ? CosineSimilarity.class : GeometryDistance.class; + + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a " + distance + " b & c FROM t"); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a & b " + distance + " c FROM t"); + + BinaryExpression bitwiseRoot = + (BinaryExpression) CCJSqlParserUtil.parseExpression("a " + distance + " b & c"); + Assertions.assertInstanceOf(BitwiseAnd.class, bitwiseRoot); + Assertions.assertInstanceOf(distanceType, bitwiseRoot.getLeftExpression()); + + BinaryExpression distanceRoot = + (BinaryExpression) CCJSqlParserUtil.parseExpression("a & b " + distance + " c"); + Assertions.assertInstanceOf(distanceType, distanceRoot); + Assertions.assertInstanceOf(BitwiseAnd.class, distanceRoot.getLeftExpression()); + } + + @Test + void testGeometryDistanceOrderByControl() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT * FROM t ORDER BY a <-> b"); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT * FROM t ORDER BY a <#> b"); + } + + @Test + void testVectorDistancePrecedenceAboveComparisonBelowArithmetic() throws JSQLParserException { + BinaryExpression geometryComparison = Assertions.assertInstanceOf(MinorThan.class, + CCJSqlParserUtil.parseExpression("a <-> b + c < 5")); + GeometryDistance geometryDistance = Assertions.assertInstanceOf(GeometryDistance.class, + geometryComparison.getLeftExpression()); + Assertions.assertInstanceOf(Addition.class, geometryDistance.getRightExpression()); + + BinaryExpression cosineComparison = Assertions.assertInstanceOf(MinorThan.class, + CCJSqlParserUtil.parseExpression("a <=> b + c < 5")); + CosineSimilarity cosineSimilarity = Assertions.assertInstanceOf(CosineSimilarity.class, + cosineComparison.getLeftExpression()); + Assertions.assertInstanceOf(Addition.class, cosineSimilarity.getRightExpression()); + } + + @Test + void testComparisonChainsRemainInvalid() { + Assertions.assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT * FROM t WHERE a < b < c")); + Assertions.assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT * FROM t WHERE a <-> b < c < d")); + } } diff --git a/src/test/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearchExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearchExpressionTest.java index 8a1c61714c..ee39216196 100644 --- a/src/test/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearchExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/expression/operators/relational/FullTextSearchExpressionTest.java @@ -9,7 +9,15 @@ */ package net.sf.jsqlparser.expression.operators.relational; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; + +import java.time.Duration; +import java.util.ArrayList; +import java.util.List; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; @@ -35,4 +43,18 @@ public void testIssue1223() throws JSQLParserException { + "full_text desc", true); } + + @Test + public void testToStringIsLinearInMatchColumns() { + List columns = new ArrayList<>(); + for (int i = 0; i < 200_000; i++) { + columns.add(new Column("c" + i)); + } + FullTextSearch fullTextSearch = new FullTextSearch() + .withMatchColumns(new ExpressionList<>(columns)) + .withAgainstValue(new StringValue("x")); + + String sql = assertTimeoutPreemptively(Duration.ofSeconds(2), fullTextSearch::toString); + assertThat(sql).startsWith("MATCH (c0,c1,").endsWith(",c199999) AGAINST ('x')"); + } } diff --git a/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java b/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java new file mode 100644 index 0000000000..84ea4711fa --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java @@ -0,0 +1,499 @@ +/*- + * #%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.parser; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.io.IOException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.Deque; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.TreeMap; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.AnalyticExpression; +import net.sf.jsqlparser.expression.CaseExpression; +import net.sf.jsqlparser.expression.CastExpression; +import net.sf.jsqlparser.expression.ConnectByPriorOperator; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.operators.relational.EqualsTo; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.create.sequence.CreateSequence; +import net.sf.jsqlparser.statement.select.PlainSelect; +import org.junit.jupiter.api.Test; + +/** + * Every object a parse returns that implements {@link ASTNodeAccess} maps back to its source text. + * Its node spans at least one character, inside the range of the object that holds it. No two + * ranges in a statement partly overlap, and the text of an expression's range parses to that + * expression again. The model is walked through its getters, over the SQL files of the test + * resources. + */ +public class ASTNodeCoverageTest { + private static final Path CORPUS = Paths.get("src/test/resources"); + + @Test + public void testEveryParsedNodeMapsBackToItsSource() throws IOException { + Map problems = new TreeMap<>(); + for (Path file : sqlFiles()) { + String sql = Files.readString(file); + Object statements; + try { + // a statement the parser rejects leaves the rest of its file to check, and the + // Oracle tests parse in the dialect they are written in + boolean oracle = file.toString().contains("oracle-tests"); + statements = CCJSqlParserUtil.parseStatements(sql, parser -> { + parser.withErrorRecovery(); + if (oracle) { + parser.withDialect(AbstractJSqlParser.Dialect.ORACLE); + } + }); + } catch (JSQLParserException e) { + // the corpus also holds SQL the parser rejects + continue; + } + new Walk(file.toString(), sql, problems).check(statements); + } + assertThat(problems).isEmpty(); + } + + @Test + public void testRangesOfStatementsClausesAndTypes() throws JSQLParserException { + String sql = "WITH t AS (SELECT 1) SELECT * FROM t;"; + assertSpans("WITH t AS (SELECT 1) SELECT * FROM t", sql, (ASTNodeAccess) statement(sql)); + + sql = "UPDATE t SET a = 1 WHERE b = 2"; + assertSpans(sql, sql, (ASTNodeAccess) statement(sql)); + + sql = "SELECT /*+ INDEX(t i) */ a FROM t"; + assertSpans("/*+ INDEX(t i) */", sql, ((PlainSelect) statement(sql)).getOracleHint()); + + sql = "SELECT CASE WHEN a = 1 THEN 'x' END, CAST(a AS DECIMAL(10, 2)), s.t.c," + + " ROW_NUMBER() OVER (PARTITION BY a ORDER BY b), SUBSTRING(a FROM 2 FOR 3)" + + " FROM t ORDER BY a DESC NULLS LAST"; + PlainSelect select = (PlainSelect) statement(sql); + assertSpans("WHEN a = 1 THEN 'x'", sql, + ((CaseExpression) item(select, 0)).getWhenClauses().get(0)); + assertSpans("DECIMAL(10, 2)", sql, ((CastExpression) item(select, 1)).getColDataType()); + assertSpans("s.t", sql, ((Column) item(select, 2)).getTable()); + assertSpans("PARTITION BY a", sql, + (ASTNodeAccess) ((AnalyticExpression) item(select, 3)) + .getPartitionExpressionList()); + // the list prints the parentheses of its function + assertSpans("(a FROM 2 FOR 3)", sql, ((Function) item(select, 4)).getNamedParameters()); + assertSpans("a DESC NULLS LAST", sql, select.getOrderByElements().get(0)); + + sql = "SELECT * FROM a, b WHERE a.id(+) = b.id"; + assertSpans("a.id(+)", sql, + ((EqualsTo) ((PlainSelect) statement(sql)).getWhere()).getLeftExpression()); + + sql = "SELECT id FROM t LIMIT 5 BY id"; + assertSpans("LIMIT 5 BY id", sql, ((PlainSelect) statement(sql)).getLimitBy()); + + sql = "CREATE SEQUENCE s INCREMENT BY 1 OWNED BY t.c"; + assertSpans("s INCREMENT BY 1 OWNED BY t.c", sql, + ((CreateSequence) statement(sql)).getSequence()); + + sql = "SELECT 'a'\n'b'"; + Statement merged = CCJSqlParserUtil.parse(sql, parser -> parser.withAdjacentStringLiterals( + AbstractJSqlParser.AdjacentStringLiterals.NEWLINE)); + assertSpans("'a'\n'b'", sql, item((PlainSelect) merged, 0)); + } + + @Test + public void testStatementsTheCorpusLacks() throws JSQLParserException { + Map problems = new TreeMap<>(); + for (String sql : new String[] { + "WITH x AS (INSERT INTO t VALUES (1) RETURNING *) SELECT * FROM x", + "WITH x AS (UPDATE t SET a = 1 RETURNING *) SELECT * FROM x", + "WITH x AS (DELETE FROM t RETURNING *) SELECT * FROM x", + "PREPARE TRANSACTION 'x'", "COMMIT PREPARED 'x'", "ROLLBACK PREPARED 'x'", + "ROLLBACK WORK FORCE '1.2.3'", "XA START X'0a', B'01', 1 JOIN", + "XA END 'x' SUSPEND FOR MIGRATE", "XA RECOVER CONVERT XID", + "CREATE RESOURCE GROUP rg TYPE = USER VCPU = 0-3, 5 THREAD_PRIORITY = 10 ENABLE", + "ALTER RESOURCE GROUP rg VCPU = 0 DISABLE FORCE", + "SET RESOURCE GROUP rg FOR 14, 0x1F", "DROP RESOURCE GROUP rg FORCE", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'Greek' ORGANIZATION 'EPSG' IDENTIFIED BY 0x1018 DEFINITION 'x' DESCRIPTION 'd'", + "DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_admin NO ROLLBACK ON ERROR", + "INSTALL PLUGIN p SONAME 'p.so'", "UNINSTALL PLUGIN p", + "INSTALL COMPONENT 'file://c', 'file://d' SET GLOBAL c.v = 1 + 2, w = ON", + "UNINSTALL COMPONENT 'file://c'", + "CREATE SERVER 's' FOREIGN DATA WRAPPER mysql OPTIONS (HOST 'h', PORT 3306)", + "ALTER SERVER s OPTIONS (PORT 0x10, SOCKET '/tmp/x')", + "CREATE SCHEMA s CREATE TABLE t (a INT) CREATE VIEW v AS SELECT 1", + "CREATE TABLE t AS EXECUTE p", + "ALTER DEFAULT PRIVILEGES GRANT SELECT ON TABLES TO r", + "IF a = 1 SELECT 1;", + "BEGIN SELECT 1; END;", + "DISCARD TEMPORARY", "LISTEN \"Ch 1\"", "UNLISTEN *", + "ALTER RULE \"Rule 1\" ON s.t RENAME TO r2", + "CREATE TYPE s.box3 (INPUT = s.box3_in, PASSEDBYVALUE, INTERNALLENGTH = - 1, " + + "ELEMENT = setof float8[], LIKE = t.a%TYPE, DEFAULT = E'x', x = extended)", + "ALTER TYPE box3 SET (SEND = NONE, STORAGE = plain, x = +1.5, y = varchar(3))", + "IMPORT FOREIGN SCHEMA r LIMIT TO (ONLY t1, s.t2 *) FROM SERVER s INTO l OPTIONS (a 'b')", + "SHOW TRANSACTION ISOLATION LEVEL", "RESET SESSION AUTHORIZATION", + "SHOW GLOBAL VARIABLES LIKE 'a%'", + "SHOW STATUS WHERE Variable_name LIKE 'a%' AND Value > 0", + "SHOW BINLOG EVENTS IN 'f' FROM 4 LIMIT 2, 3", + "SHOW RELAYLOG EVENTS FROM 1.5 LIMIT 5 OFFSET a FOR CHANNEL 'c'", + "SHOW GRANTS FOR 'u'@'h' USING r1, `r2`@`h`", + "SHOW PROCEDURE CODE d.p", "SHOW PROFILE CPU, BLOCK IO FOR QUERY 2 LIMIT ?", + "SHOW EXTENDED INDEXES IN t IN d WHERE Key_name = 'x'", + "SHOW ENGINE 'innodb' STATUS", "SHOW TRIGGERS FROM d LIKE 't%'", + "COPY s.t (a) TO STDOUT WITH NULL AS 'x' CSV FORCE QUOTE a, \"B\"", + "COPY BINARY t FROM STDIN FREEZE ENCODING 'UTF8'", + "COPY t FROM STDIN DELIMITER AS ';' CSV FORCE NOT NULL *", + "VACUUM (VERBOSE, PARALLEL 2) ONLY s.t (a, b), u *", + "VACUUM FULL FREEZE VERBOSE ANALYZE t", + "ANALYZE VERBOSE t (a)", + "ANALYZE (SKIP_LOCKED false)", + "ANALYZE TABLE t UPDATE HISTOGRAM ON c WITH 8 BUCKETS AUTO UPDATE", + "CLUSTER (VERBOSE) t USING i", + "CLUSTER VERBOSE i ON t", + "ANALYSE (\"verbose\", PARALLEL -1) t", + "CHECKPOINT", + "FLUSH LOCAL TABLES db1.t, s WITH READ LOCK", + "FLUSH ERROR LOGS, RELAY LOGS FOR CHANNEL 'c1', STATUS", + "KILL QUERY 1 + 2", + "HANDLER db1.t OPEN AS h", + "HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3 OFFSET 1", + "HANDLER h CLOSE", + "RESET PERSIST IF EXISTS max_connections", + "DROP CAST IF EXISTS (int[] AS public.t) CASCADE", + "DROP OPERATOR public.=== (integer, integer), ~ (NONE, bigint)", + "DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u", + "CREATE CAST (int[] AS public.t) WITH FUNCTION s.f(IN a int[], text) AS ASSIGNMENT", + "CREATE OR REPLACE TRANSFORM FOR public.hstore LANGUAGE plpython3u " + + "(TO SQL WITH FUNCTION g(internal), FROM SQL WITH FUNCTION s.f(internal))", + "CREATE DEFAULT CONVERSION s.c FOR 'UTF8' TO E'LATIN1' FROM s.f", + "ALTER CONVERSION s.c OWNER TO CURRENT_USER", + "CREATE OPERATOR public.=== (FUNCTION = s.f, LEFTARG = int[], COMMUTATOR = <==>, " + + "NEGATOR = OPERATOR(s.!==), HASHES)", + "ALTER OPERATOR s.@#@ (NONE, varchar(3)) SET (RESTRICT = NONE, JOIN = s.f, x = 1)", + "ALTER OPERATOR + (int, int) OWNER TO u", + "CREATE OPERATOR CLASS s.oc DEFAULT FOR TYPE varchar(3) USING gist FAMILY s.fam AS " + + "OPERATOR 1 s.< (int, int[]) FOR ORDER BY s.float_ops, OPERATOR 2 <=, " + + "FUNCTION 1 (int, text) s.f(IN a int, text), STORAGE double precision", + "ALTER OPERATOR CLASS s.oc USING btree SET SCHEMA t", + "CREATE OPERATOR FAMILY s.fam USING btree", + "ALTER OPERATOR FAMILY s.fam USING btree ADD OPERATOR 1 < (int4, int2) FOR SEARCH, " + + "FUNCTION 1 (int4) cmp(int4, int2)", + "ALTER OPERATOR FAMILY s.fam USING btree DROP OPERATOR 1 (int4, int2), " + + "FUNCTION 1 (varchar(3))", + "CREATE OR REPLACE AGGREGATE s.agg (a int, VARIADIC b text[] ORDER BY c numeric(3, 1)) " + + "(SFUNC = s.f, STYPE = int[], SORTOP = <, INITCOND = '0', MSSPACE = 8)", + "CREATE AGGREGATE agg (BASETYPE = varchar(3), SFUNC = f, STYPE = int)", + "ALTER AGGREGATE s.agg (int, varchar(3)) RENAME TO agg2", + "SELECT a FROM t AS x USE KEY (i1) FORCE INDEX FOR JOIN (i2, i3) WHERE a = 1", + "SELECT a FROM t USE INDEX () JOIN s IGNORE INDEX FOR ORDER BY (i1) ON t.a = s.a", + "UPDATE t USE INDEX (i1) IGNORE INDEX FOR ORDER BY (i2) SET a = 1", + "SELECT WEIGHT_STRING('x' AS CHAR(3)), WEIGHT_STRING(a AS BINARY(4))", + "INSERT INTO t (a, b) VALUES ROW(1, 2), ROW(3, 4)", + "INSERT INTO t PARTITION (p0) (a) TABLE s", + "INSERT INTO t () VALUES ()", + "REPLACE INTO t () VALUES ()", + "REPLACE INTO t (a, b) VALUES ROW(1, 2)", + "DELETE FROM t1, t2 USING t1 INNER JOIN t2 INNER JOIN t3 WHERE t1.id = t2.id", + "DELETE FROM t USING s JOIN u ON s.id = u.id, v WHERE t.id = s.id", + "EXPLAIN ANALYZE FORMAT = TREE FOR SCHEMA s SELECT a FROM t", + "EXPLAIN FORMAT = JSON INTO @'p' REPLACE INTO t VALUES (1)", + "DESC FOR CONNECTION 0x1F", + "PREPARE s FROM @'q'", "PREPARE s FROM 'SELECT ?'", "EXECUTE s USING @a, @'b'", + "DROP PREPARE s", "DO 1 AS a, (SELECT 1)", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h', SOURCE_HEARTBEAT_PERIOD = 2.5," + + " IGNORE_SERVER_IDS = (1, 2), PRIVILEGE_CHECKS_USER = 'u'@'%'," + + " SOURCE_TLS_CIPHERSUITES = NULL, GTID_ONLY = 1," + + " REQUIRE_TABLE_PRIMARY_KEY_CHECK = OFF FOR CHANNEL 'c'", + "CHANGE REPLICATION SOURCE TO IGNORE_SERVER_IDS = ()", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d), REPLICATE_DO_TABLE = (d.t)," + + " REPLICATE_WILD_DO_TABLE = ('d.%'), REPLICATE_REWRITE_DB = ((a, b))", + "START REPLICA SQL_THREAD UNTIL SOURCE_LOG_FILE = 'b', SOURCE_LOG_POS = 4" + + " USER = 'u' PASSWORD = 'p' FOR CHANNEL 'c'", + "STOP REPLICA IO_THREAD, SQL_THREAD FOR CHANNEL 'c'", + "RESET REPLICA ALL FOR CHANNEL 'c', BINARY LOGS AND GTIDS TO 5", + "PURGE BINARY LOGS BEFORE NOW() - INTERVAL 3 DAY", + "LOAD DATA LOCAL INFILE 'a' REPLACE INTO TABLE db1.t PARTITION (p0) CHARSET latin1" + + " FIELDS TERMINATED BY ',' LINES TERMINATED BY ';' IGNORE 1 LINES" + + " (a, @b) SET c = @b + 1, d = DEFAULT", + "LOAD XML INFILE 'a' INTO TABLE t ROWS IDENTIFIED BY '' LINES STARTING BY 'x' ()", + "SELECT a INTO OUTFILE '/tmp/o' COLUMNS ESCAPED BY '^' FROM t", + "SELECT a FROM t INTO OUTFILE '/tmp/o' CHARACTER SET 'utf8mb4'" + + " LINES TERMINATED BY ';'", + "DECLARE c BINARY NO SCROLL CURSOR WITH HOLD FOR WITH x AS (SELECT a FROM t) " + + "SELECT a FROM x", + "FETCH FORWARD -2 FROM c", + "MOVE ALL IN c", + "CLOSE ALL"}) { + new Walk(sql, sql, problems).check(CCJSqlParserUtil.parseStatements(sql)); + } + for (String sql : new String[] {"SELECT v:select FROM t", "SELECT v:select::INT FROM t", + "SELECT v:select.x[0], v:from::INT + 1 FROM t", + "SELECT v:a.output, v:a.b.from::INT, v:a[0].from.x[1] + 1 FROM t"}) { + new Walk(sql, sql, problems).check(CCJSqlParserUtil.parseStatements(sql, + parser -> parser.withDialect(AbstractJSqlParser.Dialect.SNOWFLAKE))); + } + String describe = "DESC TABLE t; DO 'x'; DESCRIBE t 'a%'; EXPLAIN t a; DESC t 0x61"; + new Walk(describe, describe, problems).check(CCJSqlParserUtil.parseStatements(describe, + parser -> parser.withDialect(AbstractJSqlParser.Dialect.MYSQL))); + String block = "BEGIN x := 1; NULL; foo(1); END;"; + new Walk(block, block, problems).check(CCJSqlParserUtil.parseStatements(block, + parser -> parser.withDialect(AbstractJSqlParser.Dialect.ORACLE))); + String opaque = "FOO BAR BAZ"; + new Walk(opaque, opaque, problems).check(CCJSqlParserUtil.parseStatements(opaque, + parser -> parser.withUnsupportedStatements(true))); + assertThat(problems).isEmpty(); + } + + @Test + public void testCommentBeforeEndOfInputHasPosition() throws ParseException { + String sql = "SELECT a FROM t -- trailing"; + Statements statements = CCJSqlParserUtil.newParser(sql).Statements(); + Token endOfInput = ((ASTNodeAccess) statements.get(0)).getASTNode().jjtGetLastToken().next; + Token comment = endOfInput.specialToken; + assertEquals("-- trailing", + sql.substring(comment.absoluteBegin - 1, comment.absoluteEnd - 1)); + } + + private static Statement statement(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql); + } + + private static Expression item(PlainSelect select, int index) { + return select.getSelectItem(index).getExpression(); + } + + private static void assertSpans(String expected, String sql, ASTNodeAccess part) { + Node node = part.getASTNode(); + assertEquals(expected, sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1), part.getClass().getSimpleName()); + } + + private static List sqlFiles() throws IOException { + try (Stream files = Files.walk(CORPUS)) { + return files.filter(file -> file.toString().endsWith(".sql")).sorted() + .collect(Collectors.toList()); + } + } + + private static final class Walk { + private final String source; + private final String sql; + private final Map problems; + private final Set visited = Collections.newSetFromMap(new IdentityHashMap<>()); + private final List ranges = new ArrayList<>(); + + Walk(String source, String sql, Map problems) { + this.source = source; + this.sql = sql; + this.problems = problems; + } + + void check(Object statements) { + visit(statements, null); + checkNoPartialOverlap(); + } + + private void visit(Object value, int[] enclosing) { + if (value == null || !visited.add(value)) { + return; + } + int[] range = range(value); + if (range != null) { + checkRange(value, range, enclosing); + } + int[] inner = range != null ? range : enclosing; + visitElements(value, inner); + if (isModel(value)) { + for (Method getter : value.getClass().getMethods()) { + if (isChildGetter(getter)) { + visitChild(value, getter, inner); + } + } + } + } + + private void visitElements(Object value, int[] enclosing) { + if (value instanceof Collection) { + for (Object element : (Collection) value) { + visit(element, enclosing); + } + } else if (value instanceof Map) { + for (Map.Entry entry : ((Map) value).entrySet()) { + visit(entry.getKey(), enclosing); + visit(entry.getValue(), enclosing); + } + } else if (value instanceof Map.Entry) { + visit(((Map.Entry) value).getKey(), enclosing); + visit(((Map.Entry) value).getValue(), enclosing); + } else if (value instanceof Optional) { + ((Optional) value).ifPresent(present -> visit(present, enclosing)); + } + } + + private void visitChild(Object value, Method getter, int[] enclosing) { + try { + Object child = getter.invoke(value); + if (isHeld(child, getter.invoke(value))) { + visit(child, enclosing); + } + } catch (ReflectiveOperationException | RuntimeException e) { + // a getter that cannot answer for this object has no child to walk + } + } + + /** + * The object's range, or null when it has none, reporting an object that should have one. + */ + private int[] range(Object value) { + // an object that prints as nothing, such as a clause left at its default, has no text + if (!(value instanceof ASTNodeAccess) || value.toString().isBlank()) { + return null; + } + Node node = ((ASTNodeAccess) value).getASTNode(); + if (node == null) { + report("has no node", value); + return null; + } + if (node.parser != null) { + report("keeps its parser alive", value); + } + int begin = node.jjtGetFirstToken().absoluteBegin - 1; + int end = node.jjtGetLastToken().absoluteEnd - 1; + if (begin < 0 || end <= begin || end > sql.length()) { + report("spans no text", value); + return null; + } + return new int[] {begin, end}; + } + + private void checkRange(Object value, int[] range, int[] enclosing) { + if (enclosing != null && (range[0] < enclosing[0] || range[1] > enclosing[1])) { + report("lies outside the object that holds it", value); + } + checkInsideParent(value, range); + ranges.add(new Object[] {range, value}); + String text = sql.substring(range[0], range[1]); + // PRIOR is an operator only inside CONNECT BY + if (value instanceof Expression && !(value instanceof ConnectByPriorOperator)) { + checkReparses(value, text, + expression -> CCJSqlParserUtil.parseExpression(expression, false)); + } else if (value instanceof Statement) { + checkReparses(value, text, CCJSqlParserUtil::parse); + } + } + + private void checkInsideParent(Object value, int[] range) { + ASTNodeAccess parent = value instanceof ASTNodeAccessImpl + ? ((ASTNodeAccessImpl) value).getParent() + : null; + Node parentNode = parent == null ? null : parent.getASTNode(); + if (parentNode != null && (parentNode.jjtGetFirstToken().absoluteBegin - 1 > range[0] + || parentNode.jjtGetLastToken().absoluteEnd - 1 < range[1])) { + report("lies outside its parent " + parent.getClass().getSimpleName(), value); + } + } + + private void checkReparses(Object value, String text, Parse parse) { + Object again; + try { + again = parse.apply(text); + } catch (JSQLParserException e) { + // text that needs its surroundings to parse proves nothing + return; + } + if (again != null + && !normalized(again.toString()).equals(normalized(value.toString()))) { + report("reparses to something else", value, value + " reparses to " + again); + } + } + + // sorted by start, the longer first, ranges nest when each ends inside the one still open + private void checkNoPartialOverlap() { + ranges.sort(Comparator.comparingInt(entry -> ((int[]) entry[0])[0]) + .thenComparingInt(entry -> -((int[]) entry[0])[1])); + Deque open = new ArrayDeque<>(); + for (Object[] entry : ranges) { + int[] range = (int[]) entry[0]; + while (!open.isEmpty() && ((int[]) open.peek()[0])[1] <= range[0]) { + open.pop(); + } + if (!open.isEmpty() && ((int[]) open.peek()[0])[1] < range[1]) { + report("partly overlaps " + open.peek()[1].getClass().getSimpleName(), + entry[1], entry[1]); + } + open.push(entry); + } + } + + private void report(String problem, Object value) { + report(problem, value, value); + } + + private void report(String problem, Object value, Object detail) { + problems.putIfAbsent(value.getClass().getSimpleName() + " " + problem, + source + ": " + detail); + } + } + + private interface Parse { + Object apply(String text) throws JSQLParserException; + } + + private static String normalized(String text) { + return text.replaceAll("\\s+", "").toUpperCase(Locale.ROOT); + } + + // a getter that builds new objects on each call computes them rather than holding them + @SuppressWarnings("PMD.CompareObjectsWithEquals") + private static boolean isHeld(Object child, Object again) { + if (child instanceof ASTNodeAccess) { + return child == again; + } + if (child instanceof Collection && !((Collection) child).isEmpty()) { + return again instanceof Collection && !((Collection) again).isEmpty() + && ((Collection) child).iterator().next() == ((Collection) again) + .iterator().next(); + } + return true; + } + + private static boolean isModel(Object value) { + String name = value.getClass().getName(); + return name.startsWith("net.sf.jsqlparser.") + && !name.startsWith("net.sf.jsqlparser.parser.") + && !(value instanceof Enum); + } + + private static boolean isChildGetter(Method method) { + return method.getParameterCount() == 0 && method.getName().startsWith("get") + && !Modifier.isStatic(method.getModifiers()) + && !method.getName().equals("getParent") && !method.getName().equals("getASTNode"); + } +} diff --git a/src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java b/src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java index 6de42eb6a6..bf74eb6a3c 100644 --- a/src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java +++ b/src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java @@ -14,6 +14,7 @@ import net.sf.jsqlparser.expression.LongValue; import net.sf.jsqlparser.expression.StringValue; import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd; import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication; import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; import net.sf.jsqlparser.schema.Column; @@ -41,6 +42,7 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -525,6 +527,36 @@ void testParseEmpty() { assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse((String) null)); } + @Test + void testParseRejectsUnconsumedInput() throws Exception { + // "\n\n\n" separates statements exactly like ";" does, so both inputs below hold + // two statements; a single statement parse must not silently return the first only + String newlineSeparated = "SELECT a FROM dual WHERE x = ?\n\n\n AND y = ?"; + String semicolonSeparated = "SELECT a FROM dual; SELECT b FROM dual"; + + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(newlineSeparated)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(semicolonSeparated)); + assertThrows(ParseException.class, + () -> CCJSqlParserUtil.newParser(newlineSeparated).Statement()); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse(new ByteArrayInputStream( + newlineSeparated.getBytes(StandardCharsets.UTF_8)))); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parseAST(newlineSeparated)); + + // trailing separators and comments do not make a statement incomplete + assertEquals("SELECT a FROM dual", + CCJSqlParserUtil.parse("SELECT a FROM dual;").toString()); + assertEquals("SELECT a FROM dual", + CCJSqlParserUtil.parse("SELECT a FROM dual\n\n\n").toString()); + assertEquals("SELECT a FROM dual", + CCJSqlParserUtil.parse("SELECT a FROM dual -- done").toString()); + + // the multi statement API keeps working + assertEquals(2, CCJSqlParserUtil.parseStatements(semicolonSeparated).size()); + assertEquals(3, CCJSqlParserUtil.parseStatements( + "SELECT * FROM DUAL\n\n\nSELECT * FROM DUAL\n\n\n\nSELECT * FROM dual").size()); + } + @Test void testSingleStatementWithEmptyLines() throws JSQLParserException { String sqlStr = "update shop_info set title=?,\n" @@ -548,6 +580,44 @@ void testSingleStatementWithEmptyLines() throws JSQLParserException { + "where id=?", true); } + @Test + void testBlankLinesAsSeparatorDisabled() throws JSQLParserException { + Consumer blankLinesAsWhitespace = p -> p.withBlankLinesAsSeparator(false); + + assertEquals("SELECT a FROM dual WHERE x = ? AND y = ?", + CCJSqlParserUtil.parse("SELECT a FROM dual WHERE x = ?\n\n\n AND y = ?", + blankLinesAsWhitespace).toString()); + assertEquals("SELECT a, b FROM t", + CCJSqlParserUtil.parse("SELECT a,\n\n\n\nb FROM t", blankLinesAsWhitespace) + .toString()); + assertEquals("SELECT a FROM t WHERE a > 1", + CCJSqlParserUtil.parse("SELECT a FROM t\n\n\nWHERE a > 1", blankLinesAsWhitespace) + .toString()); + assertEquals("SELECT a FROM t UNION SELECT a FROM u", + CCJSqlParserUtil.parse("SELECT a FROM t\n\n\n\n\nUNION\n\n\nSELECT a FROM u", + blankLinesAsWhitespace).toString()); + assertEquals("SELECT a FROM t JOIN u ON t.id = u.id", + CCJSqlParserUtil.parse("SELECT a FROM t\n\n\nJOIN u ON t.id = u.id", + blankLinesAsWhitespace).toString()); + assertEquals("SELECT a FROM dual", + CCJSqlParserUtil.parse("SELECT a FROM dual\n\n\n", blankLinesAsWhitespace) + .toString()); + assertEquals("SELECT 'a\n\n\nb' FROM dual", + CCJSqlParserUtil.parse("SELECT 'a\n\n\nb' FROM dual", blankLinesAsWhitespace) + .toString()); + + assertEquals(1, CCJSqlParserUtil.parseStatements( + "SELECT a FROM t\n\n\nWHERE a > 1", blankLinesAsWhitespace).size()); + assertEquals(3, CCJSqlParserUtil.parseStatements( + "SELECT 1 FROM dual;\n\n\nSELECT 2 FROM dual\ngo\nSELECT 3 FROM dual\n/\n", + blankLinesAsWhitespace).size()); + + JSQLParserException exception = assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT a\n\n\n\nFROM", blankLinesAsWhitespace)); + assertTrue(exception.getCause().getMessage().contains("at line 5, column 1"), + exception.getCause().getMessage()); + } + @Test public void testHashLineCommentsFeature() throws Exception { // with the flag: MySQL line comments, `#` to end of line, @@ -718,6 +788,152 @@ public void testDoubleQuotedStringsPreset() throws Exception { } } + @Test + public void testDoubleQuotedStringsWithBackslashEscapes() throws Exception { + // MySQL reads "it\"s" as it"s; the escaped quote must not end the literal + for (AbstractJSqlParser.Dialect dialect : new AbstractJSqlParser.Dialect[] { + AbstractJSqlParser.Dialect.MYSQL, AbstractJSqlParser.Dialect.MARIADB, + AbstractJSqlParser.Dialect.BIGQUERY, AbstractJSqlParser.Dialect.DATABRICKS}) { + PlainSelect select = (PlainSelect) ((Select) CCJSqlParserUtil.parse( + "SELECT \"it\\\"s\", \"a\\\\\"", p -> p.withDialect(dialect))) + .getSelectBody(); + assertEquals("it\\\"s", + ((StringValue) select.getSelectItems().get(0).getExpression()).getValue()); + assertEquals("a\\\\", + ((StringValue) select.getSelectItems().get(1).getExpression()).getValue()); + assertEquals("SELECT \"it\\\"s\", \"a\\\\\"", select.toString()); + } + // a doubled quote still continues a MySQL literal + assertEquals("SELECT \"b\"\"c\\\"d\"", CCJSqlParserUtil.parse("SELECT \"b\"\"c\\\"d\"", + p -> p.withDialect(AbstractJSqlParser.Dialect.MYSQL)).toString()); + String alter = "ALTER TABLE t ADD COLUMN s VARCHAR (10) DEFAULT \"it\\\"s\""; + assertEquals(alter, CCJSqlParserUtil + .parse(alter, p -> p.withDialect(AbstractJSqlParser.Dialect.MYSQL)).toString()); + // the same escape needs both features + assertEquals("SELECT \"it\\\"s\"", CCJSqlParserUtil.parse("SELECT \"it\\\"s\"", + p -> p.withDoubleQuotedStrings(true).withBackslashEscapeCharacter(true)) + .toString()); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("SELECT \"it\\\"s\"", p -> p.withDoubleQuotedStrings(true))); + // MySQL closes "a\"" before b, so the rest is unterminated as on the server + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "SELECT \"a\\\"\"b\"", p -> p.withDialect(AbstractJSqlParser.Dialect.MYSQL))); + // quoted identifiers keep a trailing backslash + for (AbstractJSqlParser.Dialect dialect : new AbstractJSqlParser.Dialect[] {null, + AbstractJSqlParser.Dialect.POSTGRESQL, AbstractJSqlParser.Dialect.SNOWFLAKE}) { + PlainSelect select = (PlainSelect) ((Select) CCJSqlParserUtil.parse( + "SELECT \"col\\\" FROM \"t\"", p -> { + if (dialect != null) { + p.withDialect(dialect); + } + })).getSelectBody(); + assertEquals("\"col\\\"", + ((Column) select.getSelectItems().get(0).getExpression()).getColumnName()); + assertEquals("SELECT \"col\\\" FROM \"t\"", select.toString()); + } + } + + @Test + public void testSingleQuotedStringsMixBackslashEscapesAndDoubledQuotes() throws Exception { + // each is one MySQL string; the first used to split into a string and an alias + for (String literal : new String[] {"'it\\'s ''x'''", "'a\\0b\\'c'", "'\\Z\\''", + "'a''b\\'c'", "'x\\%\\'y'", "N'it\\'s'"}) { + PlainSelect select = (PlainSelect) ((Select) CCJSqlParserUtil.parse( + "SELECT " + literal + " FROM t", + p -> p.withDialect(AbstractJSqlParser.Dialect.MYSQL))).getSelectBody(); + assertEquals(1, select.getSelectItems().size(), literal); + assertNull(select.getSelectItems().get(0).getAlias(), literal); + assertInstanceOf(StringValue.class, select.getSelectItems().get(0).getExpression()); + assertEquals("SELECT " + literal + " FROM t", select.toString()); + } + // PostgreSQL E'' strings escape quotes; standard strings keep a literal backslash + assertEquals("SELECT E'it\\'s ''x'''", CCJSqlParserUtil.parse("SELECT E'it\\'s ''x'''", + p -> p.withDialect(AbstractJSqlParser.Dialect.POSTGRESQL)).toString()); + assertEquals("SELECT 'a\\', 'b'", CCJSqlParserUtil.parse("SELECT 'a\\', 'b'", + p -> p.withDialect(AbstractJSqlParser.Dialect.POSTGRESQL)).toString()); + // without backslash escapes the literal still ends at the escaped-looking quote + assertEquals("SELECT 'a\\' AS x", CCJSqlParserUtil.parse("SELECT 'a\\' AS x").toString()); + assertEquals("SELECT * FROM t WHERE a LIKE 'x\\_%' ESCAPE '\\'", CCJSqlParserUtil + .parse("SELECT * FROM t WHERE a LIKE 'x\\_%' ESCAPE '\\'").toString()); + } + + @Test + public void testPostgresUnicodeEscapeStringsAreOneLiteral() throws Exception { + Consumer postgres = + p -> p.withDialect(AbstractJSqlParser.Dialect.POSTGRESQL); + for (String literal : new String[] {"U&'\\0041BC \\00e9'", + "U&'d!0061t!+000061' UESCAPE '!'", "U&'it''s'", "U&'a\\\\b'", + "U&'\\' UESCAPE '!'", "U&'x' UESCAPE '\\'"}) { + PlainSelect select = (PlainSelect) ((Select) CCJSqlParserUtil.parse( + "SELECT " + literal + " FROM t", postgres)).getSelectBody(); + assertEquals(1, select.getSelectItems().size(), literal); + assertNull(select.getSelectItems().get(0).getAlias(), literal); + assertInstanceOf(StringValue.class, select.getSelectItems().get(0).getExpression()); + assertEquals("SELECT " + literal + " FROM t", select.toString()); + } + // the prefix is case-insensitive; UESCAPE may follow without or after any whitespace + assertEquals("SELECT U&'#0041' UESCAPE '#', U&'x' FROM t", CCJSqlParserUtil.parse( + "SELECT u&'#0041'\n\tuescape\n'#', U&'x'FROM t", postgres).toString()); + // spaces inside U&' make it an expression + assertInstanceOf(BitwiseAnd.class, ((PlainSelect) CCJSqlParserUtil + .parse("SELECT U & 'x' FROM t", postgres)).getSelectItem(0).getExpression()); + assertInstanceOf(BitwiseAnd.class, ((PlainSelect) CCJSqlParserUtil + .parse("SELECT U &'x' FROM t", postgres)).getSelectItem(0).getExpression()); + } + + @Test + public void testUnicodeEscapeStringsNeedThePostgresDialect() throws Exception { + for (AbstractJSqlParser.Dialect dialect : new AbstractJSqlParser.Dialect[] {null, + AbstractJSqlParser.Dialect.MYSQL, AbstractJSqlParser.Dialect.ORACLE, + AbstractJSqlParser.Dialect.SQLSERVER, AbstractJSqlParser.Dialect.ANSI_SQL}) { + Consumer consumer = p -> { + if (dialect != null) { + p.withDialect(dialect); + } + }; + for (String sql : new String[] {"SELECT U&'x' FROM t", + "SELECT u&'\\0041' FROM t"}) { + BitwiseAnd and = assertInstanceOf(BitwiseAnd.class, ((PlainSelect) CCJSqlParserUtil + .parse(sql, consumer)).getSelectItem(0).getExpression(), sql); + assertInstanceOf(Column.class, and.getLeftExpression(), sql); + assertNull(assertInstanceOf(StringValue.class, and.getRightExpression(), sql) + .getPrefix(), sql); + } + for (String sql : new String[] {"SELECT a & b FROM t", "SELECT U & 1 FROM t", + "SELECT U&1 FROM t", "SELECT U & 'x' FROM t"}) { + assertInstanceOf(BitwiseAnd.class, ((PlainSelect) CCJSqlParserUtil.parse(sql, + consumer)).getSelectItem(0).getExpression(), sql); + } + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("SELECT U&'d!0061' UESCAPE '!' FROM t", consumer)); + // literals that merely start with & are unaffected + assertEquals("SELECT '&', '&x', N'&', 'a' & 'b' FROM t", CCJSqlParserUtil + .parse("SELECT '&', '&x', N'&', 'a' & 'b' FROM t", consumer).toString()); + } + // the bitwise reading also stays for PostgreSQL's U & 1 and a & b + for (String sql : new String[] {"SELECT a & b FROM t", "SELECT U & 1 FROM t", + "SELECT U&1 FROM t", "SELECT '&' & 'b' FROM t"}) { + assertInstanceOf(BitwiseAnd.class, ((PlainSelect) CCJSqlParserUtil.parse(sql, + p -> p.withDialect(AbstractJSqlParser.Dialect.POSTGRESQL))) + .getSelectItem(0).getExpression(), sql); + } + } + + @Test + public void testInvalidUnicodeEscapeStringsAreRejected() { + for (String literal : new String[] {"U&'\\00'", "U&'\\0000'", "U&'\\+110000'", + "U&'\\+12'", "U&'\\D800'", "U&'\\DC00'", "U&'\\D800x'", + "U&'\\D800\\0041'", "U&'\\D800\\\\'", "U&'x\\'", "U&'\\g000'", + "U&'x' UESCAPE '+'", "U&'x' UESCAPE 'a'", "U&'x' UESCAPE 'F'", + "U&'x' UESCAPE ' '", "U&'x' UESCAPE '\"'", "U&'x' UESCAPE '\u00e9'"}) { + for (String sql : new String[] {"SELECT " + literal, "SELECT f(" + literal + ")", + "COMMENT ON TABLE t IS " + literal}) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + p -> p.withDialect(AbstractJSqlParser.Dialect.POSTGRESQL)), sql); + } + } + } + @Test public void testAdjacentStringLiteralsNewline() throws Exception { // default (off): the MySQL / SQL Server alias reading, unchanged diff --git a/src/test/java/net/sf/jsqlparser/parser/ExpressionParsingFallbackTest.java b/src/test/java/net/sf/jsqlparser/parser/ExpressionParsingFallbackTest.java new file mode 100644 index 0000000000..924e8ef85a --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/ExpressionParsingFallbackTest.java @@ -0,0 +1,129 @@ +/*- + * #%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.parser; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotSame; +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 java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.feature.Feature; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; + +class ExpressionParsingFallbackTest { + private static final String PARTIAL_EXPRESSION = "[customer].[id] = 1 trailing tokens"; + + @ParameterizedTest + @EnumSource(ParserApi.class) + void configuresCompleteExpressionsOnce(ParserApi api) throws JSQLParserException { + List attempts = new ArrayList<>(); + Expression result = api.parse("[customer].[id] = 1", false, parser -> { + attempts.add(parser); + parser.withSquareBracketQuotation(true); + }); + + assertEquals("[customer].[id] = 1", result.toString()); + assertEquals(1, attempts.size()); + } + + @ParameterizedTest + @EnumSource(ParserApi.class) + void reappliesConfigurationToAFreshParserForPartialInput(ParserApi api) + throws JSQLParserException { + List attempts = new ArrayList<>(); + List modes = new ArrayList<>(); + Expression result = api.parse(PARTIAL_EXPRESSION, true, parser -> { + attempts.add(parser); + modes.add(parser.getAsBoolean(Feature.allowComplexParsing)); + parser.withSquareBracketQuotation(true); + }); + + assertEquals("[customer].[id] = 1", result.toString()); + assertEquals(List.of(false, true), modes); + assertNotSame(attempts.get(0), attempts.get(1)); + } + + @ParameterizedTest + @EnumSource(ParserApi.class) + void rejectsTrailingTokensWhenPartialParsingIsDisabled(ParserApi api) { + JSQLParserException exception = assertThrows(JSQLParserException.class, + () -> api.parse(PARTIAL_EXPRESSION, false, + parser -> parser.withSquareBracketQuotation(true))); + + assertEquals("could only parse partial expression [customer].[id] = 1", + exception.getMessage()); + assertNull(exception.getCause()); + } + + @ParameterizedTest + @EnumSource(ParserApi.class) + void preservesSyntaxFailureCauses(ParserApi api) { + for (boolean partial : new boolean[] {false, true}) { + JSQLParserException exception = assertThrows(JSQLParserException.class, + () -> api.parse(";", partial, null)); + + ParseException cause = assertInstanceOf(ParseException.class, exception.getCause()); + assertEquals(cause.getMessage(), exception.getMessage()); + } + } + + @ParameterizedTest + @EnumSource(ParserApi.class) + void leavesNullAndEmptyInputUnconfigured(ParserApi api) throws JSQLParserException { + Consumer unexpectedConfiguration = parser -> { + throw new AssertionError("Empty input must not configure a parser"); + }; + for (boolean partial : new boolean[] {false, true}) { + assertNull(api.parse(null, partial, unexpectedConfiguration)); + assertNull(api.parse("", partial, unexpectedConfiguration)); + } + } + + @ParameterizedTest + @EnumSource(ParserApi.class) + void acceptsNullConfiguration(ParserApi api) throws JSQLParserException { + assertEquals("x = 92", api.parse("x=92", false, null).toString()); + assertEquals("x = 92", api.parse("x=92 trailing tokens", true, null).toString()); + } + + @ParameterizedTest + @EnumSource(ParserApi.class) + void propagatesConfigurationFailuresWithoutRetrying(ParserApi api) { + IllegalStateException failure = new IllegalStateException("Configuration failed"); + List attempts = new ArrayList<>(); + IllegalStateException exception = assertThrows(IllegalStateException.class, + () -> api.parse("x=92", false, parser -> { + attempts.add(parser); + throw failure; + })); + + assertSame(failure, exception); + assertEquals(1, attempts.size()); + } + + private enum ParserApi { + EXPRESSION, CONDITION; + + Expression parse(String text, boolean allowPartialParse, Consumer consumer) + throws JSQLParserException { + return this == EXPRESSION + ? CCJSqlParserUtil.parseExpression(text, allowPartialParse, consumer) + : CCJSqlParserUtil.parseCondExpression(text, allowPartialParse, consumer); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/parser/LeadingCommentsTest.java b/src/test/java/net/sf/jsqlparser/parser/LeadingCommentsTest.java new file mode 100644 index 0000000000..6b83c46cb5 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/LeadingCommentsTest.java @@ -0,0 +1,80 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.parser; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.Select; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +public class LeadingCommentsTest { + + @Test + public void blockCommentsBeforeStatementInSourceOrder() throws JSQLParserException { + Select select = (Select) CCJSqlParserUtil + .parse("/* keep orderby */ /*+ FULL(t) */ SELECT * FROM mytable"); + assertEquals(List.of("/* keep orderby */", "/*+ FULL(t) */"), select.getLeadingComments()); + } + + @ParameterizedTest + @ValueSource(strings = {"\n", "\r\n", "\r"}) + public void lineCommentsExcludeLineTerminators(String lineTerminator) + throws JSQLParserException { + Select select = + (Select) CCJSqlParserUtil.parse("-- paging hint" + lineTerminator + "SELECT 1"); + assertEquals(List.of("-- paging hint"), select.getLeadingComments()); + } + + @Test + public void mixedCommentsRetainExactImagesAndSourceOrder() throws JSQLParserException { + Select select = (Select) CCJSqlParserUtil + .parse("/* a */ -- b\r\n// c\r/* d */ SELECT 1"); + assertEquals(List.of("/* a */", "-- b", "// c", "/* d */"), select.getLeadingComments()); + } + + @Test + public void commentInsideStatementIsNotLeading() throws JSQLParserException { + Select select = (Select) CCJSqlParserUtil.parse("SELECT /* mid comment */ 1"); + assertEquals(List.of(), select.getLeadingComments()); + } + + @Test + public void statementWithoutComments() throws JSQLParserException { + Select select = (Select) CCJSqlParserUtil.parse("SELECT * FROM mytable"); + assertEquals(List.of(), select.getLeadingComments()); + } + + @Test + public void programmaticStatementHasNoLeadingComments() { + assertEquals(List.of(), new PlainSelect().getLeadingComments()); + } + + @Test + public void toStringDropsLeadingCommentsAsBefore() throws JSQLParserException { + Select select = (Select) CCJSqlParserUtil + .parse("/* keep orderby */ SELECT * FROM mytable"); + assertFalse(select.toString().contains("/*")); + } + + @Test + public void commentsSplitPerStatement() throws JSQLParserException { + Statements statements = CCJSqlParserUtil + .parseStatements("/* first */ SELECT 1; /* second */ SELECT 2"); + assertEquals(List.of("/* first */"), ((Select) statements.get(0)).getLeadingComments()); + assertEquals(List.of("/* second */"), ((Select) statements.get(1)).getLeadingComments()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/parser/LongChainPredicateTest.java b/src/test/java/net/sf/jsqlparser/parser/LongChainPredicateTest.java index 7c92090a8b..9eeceec8d9 100644 --- a/src/test/java/net/sf/jsqlparser/parser/LongChainPredicateTest.java +++ b/src/test/java/net/sf/jsqlparser/parser/LongChainPredicateTest.java @@ -11,8 +11,11 @@ import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.time.Duration; + import net.sf.jsqlparser.expression.Function; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.statement.select.AllTableColumns; @@ -100,4 +103,18 @@ void oracleOuterJoinColumnPlusOnMemoPath() throws Exception { assertSqlCanBeParsedAndDeparsed( "SELECT * FROM a, b WHERE " + chain(8, "x(+)") + " = b.x"); } + + @Test + void veryLongChainsParseInLinearTime() { + // the memoizing walk used to fetch each part with getToken(i), which rescans the + // token list from the start, so one walk over a 10000-part chain took many seconds + assertTimeoutPreemptively(Duration.ofSeconds(5), () -> { + assertTrue( + firstExpression("SELECT " + chain(10000, "col") + " FROM t") instanceof Column); + assertTrue(firstExpression( + "SELECT " + chain(10000, "*") + " FROM t") instanceof AllTableColumns); + assertTrue(firstExpression( + "SELECT " + chain(10000, "f(1)") + " FROM t") instanceof Function); + }); + } } diff --git a/src/test/java/net/sf/jsqlparser/parser/LookaheadCleanupTest.java b/src/test/java/net/sf/jsqlparser/parser/LookaheadCleanupTest.java new file mode 100644 index 0000000000..079c8c1f74 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/LookaheadCleanupTest.java @@ -0,0 +1,163 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.parser; + +import static org.junit.jupiter.api.Assertions.*; +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.ConnectionDefinition; +import net.sf.jsqlparser.statement.CloudConnectionDefinition; +import net.sf.jsqlparser.statement.export.DBMSDestination; +import org.junit.jupiter.api.Test; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.statement.select.MySqlSelectIntoClause; +import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.lock.LockStatement; +import net.sf.jsqlparser.statement.create.rule.CreateRule; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.notify.NotifyStatement; +import net.sf.jsqlparser.expression.LongValue; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class LookaheadCleanupTest { + @ParameterizedTest + @ValueSource(strings = {"EXA AT conn TABLE t", "ORA AT conn TABLE schemaName.tableName", + "JDBC DRIVER = 'driverName' AT conn TABLE \"t\"", + "EXA AT conn TABLE t (c1, c2) REPLACE TRUNCATE"}) + void dispatchesTableDestinationsWithCompleteConsumption(String sql) throws Exception { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + DBMSDestination destination = parser.DBMSDestination(); + assertNotNull(destination.getTable()); + assertNull(destination.getStatement()); + assertNotNull(destination.getConnectionDefinition()); + assertEquals(CCJSqlParserConstants.EOF, parser.getToken(1).kind); + assertSqlCanBeParsedAndDeparsed("EXPORT sourceTable INTO " + sql, true, + p -> p.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = {"EXA AT conn STATEMENT 'insert into t values (?)'", + "ORA AT conn STATEMENT 'insert into t values (?)'"}) + void preservesStatementDestinations(String sql) throws Exception { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + DBMSDestination destination = parser.DBMSDestination(); + assertNull(destination.getTable()); + assertEquals("insert into t values (?)", destination.getStatement().getValue()); + assertEquals(CCJSqlParserConstants.EOF, parser.getToken(1).kind); + assertSqlCanBeParsedAndDeparsed("EXPORT sourceTable INTO " + sql, true, + p -> p.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = {"EXA AT conn TABLE", "ORA AT conn STATEMENT", "EXA AT conn SELECT t"}) + void rejectsIncompleteAndWrongDestinationPrefixes(String sql) { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + assertThrows(ParseException.class, parser::DBMSDestination); + if (sql.endsWith("TABLE")) { + assertEquals(CCJSqlParserConstants.K_TABLE, parser.getToken(0).kind); + assertEquals(CCJSqlParserConstants.EOF, parser.getToken(1).kind); + } + } + + @ParameterizedTest + @ValueSource(strings = {"AT conn", "AT '127.0.0.1'", "AT CLOUD NONE conn", + "AT CLOUD AZURE BLOBSTORAGE conn"}) + void preservesCloudAndOrdinaryConnections(String sql) throws Exception { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + ConnectionDefinition connection = parser.ConnectionOrCloudConnectionDefinition(); + if (sql.startsWith("AT CLOUD")) { + assertInstanceOf(CloudConnectionDefinition.class, connection); + } else { + assertEquals(ConnectionDefinition.class, connection.getClass()); + } + assertEquals(CCJSqlParserConstants.EOF, parser.getToken(1).kind); + assertSqlCanBeParsedAndDeparsed("EXPORT sourceTable INTO CSV " + sql + " FILE 'file.csv'", + true, p -> p.withDialect(Dialect.EXASOL)); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT id FROM t LIMIT 7 OFFSET 2", + "SELECT id FROM t UNION ALL SELECT id FROM u LIMIT 7 OFFSET 2"}) + void boundedSelectTailsKeepTheirAstAndFollowingStatement(String sql) throws Exception { + Select select = (Select) complete(sql); + assertEquals(7, ((LongValue) select.getLimit().getRowCount()).getValue()); + assertEquals(2, ((LongValue) select.getOffset().getOffset()).getValue()); + assertEquals("SELECT 42", CCJSqlParserUtil.parseStatements(sql + "; SELECT 42").get(1) + .toString()); + } + + @Test + void boundedFetchKeepsItsCount() throws Exception { + Select select = (Select) complete("SELECT id FROM t OFFSET 2 ROWS FETCH NEXT 7 ROWS ONLY"); + assertEquals(2, ((LongValue) select.getOffset().getOffset()).getValue()); + assertEquals(7, ((LongValue) select.getFetch().getExpression()).getValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT a INTO OUTFILE '/tmp/result.txt' FIELDS TERMINATED BY ',' " + + "OPTIONALLY ENCLOSED BY '\"' LINES TERMINATED BY 'end' FROM t", + "SELECT a FROM t INTO OUTFILE '/tmp/result.txt' COLUMNS TERMINATED BY ',' " + + "OPTIONALLY ENCLOSED BY '\"' LINES TERMINATED BY 'end'"}) + void boundedOutfileOptionsKeepTheirOrderingAndValues(String sql) throws Exception { + MySqlSelectIntoClause into = ((Select) complete(sql)).getPlainSelect() + .getMySqlSelectIntoClause(); + assertEquals(MySqlSelectIntoClause.Type.OUTFILE, into.getType()); + assertEquals("/tmp/result.txt", into.getFileName().getValue()); + assertEquals(",", into.getFieldsTerminatedBy().getValue()); + assertTrue(into.isFieldsOptionallyEnclosed()); + assertEquals("end", into.getLinesTerminatedBy().getValue()); + } + + @Test + void boundedParenthesesKeepExecutionArgumentsAndRuleActions() throws Exception { + Execute execute = (Execute) complete("CALL p (:a, :b)"); + assertEquals("p", execute.getName()); + assertEquals(2, execute.getExprList().size()); + assertEquals(":a", execute.getExprList().get(0).toString()); + assertEquals(":b", execute.getExprList().get(1).toString()); + CreateRule rule = (CreateRule) complete("CREATE RULE r AS ON INSERT TO t DO " + + "(INSERT INTO log VALUES (9); NOTIFY ch, 'changed')"); + assertEquals(2, rule.getActions().size()); + assertEquals("log", ((Insert) rule.getActions().get(0)).getTable().getName()); + assertEquals("changed", + ((NotifyStatement) rule.getActions().get(1)).getPayload().getValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"LOCK TABLE a IN SHARE MODE WAIT 5", "LOCK a IN SHARE MODE WAIT 5"}) + void boundedTableKeywordKeepsLockTargetAndWait(String sql) throws Exception { + LockStatement lock = (LockStatement) complete(sql); + assertEquals(sql.startsWith("LOCK TABLE"), lock.isUseTableKeyword()); + assertEquals("a", lock.getTable().getName()); + assertEquals("SHARE", lock.getLockMode().getValue()); + assertEquals(5L, lock.getWaitSeconds()); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT id FROM t LIMIT", "SELECT id FROM t OFFSET", + "SELECT id FROM t FETCH NEXT", "CALL p (", "CALL p (:a,)", "LOCK TABLE", + "CREATE RULE r AS ON INSERT TO t DO (NOTIFY ch", "SELECT a FROM t INTO OUTFILE 'x' " + + "LINES TERMINATED BY 'end' FIELDS TERMINATED BY ','"}) + void boundedGuardsRejectIncompleteAndReorderedNeighbors(String sql) { + assertThrows(net.sf.jsqlparser.JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql)); + } + + private static Statement complete(String sql) throws Exception { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + Statement statement = parser.Statement(); + assertEquals(CCJSqlParserConstants.EOF, parser.getToken(1).kind); + assertEquals(statement.toString(), CCJSqlParserUtil.parse(statement.toString()).toString()); + return statement; + } + +} diff --git a/src/test/java/net/sf/jsqlparser/parser/LookaheadDispatchTest.java b/src/test/java/net/sf/jsqlparser/parser/LookaheadDispatchTest.java new file mode 100644 index 0000000000..0aa5ee61d0 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/LookaheadDispatchTest.java @@ -0,0 +1,223 @@ +/*- + * #%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.parser; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.AllValue; +import net.sf.jsqlparser.expression.BooleanValue; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.OracleNamedFunctionParameter; +import net.sf.jsqlparser.expression.OverlapsCondition; +import net.sf.jsqlparser.expression.PostgresNamedFunctionParameter; +import net.sf.jsqlparser.expression.TimeKeyExpression; +import net.sf.jsqlparser.expression.operators.relational.Between; +import net.sf.jsqlparser.expression.operators.relational.EqualsTo; +import net.sf.jsqlparser.expression.operators.relational.ExistsExpression; +import net.sf.jsqlparser.expression.operators.relational.InExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; +import net.sf.jsqlparser.expression.operators.relational.SupportsOldOracleJoinSyntax; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.select.PlainSelect; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class LookaheadDispatchTest { + @ParameterizedTest + @MethodSource("singleTokenExpressions") + void preservesSingleTokenExpressionKinds(String sql, Class type, + String deparsed) throws Exception { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + Expression expression = parser.PrimaryExpression(); + assertInstanceOf(type, expression); + assertEquals(deparsed, expression.toString()); + assertEquals(CCJSqlParserConstants.EOF, parser.getNextToken().kind); + Expression parsed = CCJSqlParserUtil.parseExpression(sql, false); + assertInstanceOf(type, parsed); + assertEquals(deparsed, parsed.toString()); + } + + static Stream singleTokenExpressions() { + return Stream.of( + Arguments.of("TRUE", BooleanValue.class, "true"), + Arguments.of("FALSE", BooleanValue.class, "false"), + Arguments.of("ALL", AllValue.class, "ALL"), + Arguments.of("CURRENT", TimeKeyExpression.class, "CURRENT"), + Arguments.of("CURRENT_DATE", TimeKeyExpression.class, "CURRENT_DATE"), + Arguments.of("CURRENT_TIME", TimeKeyExpression.class, "CURRENT_TIME"), + Arguments.of("CURRENT_TIMESTAMP", TimeKeyExpression.class, "CURRENT_TIMESTAMP"), + Arguments.of("CURRENT_TIMEZONE", TimeKeyExpression.class, "CURRENT_TIMEZONE"), + Arguments.of("CURRENT_DATE()", TimeKeyExpression.class, "CURRENT_DATE()")); + } + + @ParameterizedTest + @ValueSource(strings = {"\"TRUE\"", "\"CURRENT_DATE\"", "\"ALL\""}) + void preservesQuotedNames(String name) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed("SELECT " + name); + assertEquals(name, assertInstanceOf(Column.class, select.getSelectItem(0).getExpression()) + .getColumnName()); + } + + @ParameterizedTest + @ValueSource(strings = {"TRUE", "ALL", "CURRENT_DATE"}) + void honorsInterruptionBeforeSingleTokenExpressions(String sql) { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + parser.interrupted = true; + assertThrows(ParseException.class, parser::PrimaryExpression); + assertEquals(sql, parser.getNextToken().image); + } + + @ParameterizedTest + @MethodSource("conditions") + void preservesConditionAlternatives(String sql, Class type) + throws Exception { + CCJSqlParser conditionParser = CCJSqlParserUtil.newParser(sql); + Expression condition = conditionParser.Condition(); + assertInstanceOf(type, condition); + assertEquals(sql, condition.toString()); + assertEquals(CCJSqlParserConstants.EOF, conditionParser.getNextToken().kind); + + CCJSqlParser sqlConditionParser = CCJSqlParserUtil.newParser(sql); + Expression sqlCondition = sqlConditionParser.SQLCondition(); + assertInstanceOf(type, sqlCondition); + assertEquals(sql, sqlCondition.toString()); + assertEquals(CCJSqlParserConstants.EOF, sqlConditionParser.getNextToken().kind); + + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t WHERE " + sql); + assertInstanceOf(type, select.getWhere()); + } + + static Stream conditions() { + return Stream.of( + Arguments.of("a", Column.class), + Arguments.of("exists", Column.class), + Arguments.of("exists.col", Column.class), + Arguments.of("EXISTS (SELECT 1)", ExistsExpression.class), + Arguments.of("EXISTS (1)", ExistsExpression.class), + Arguments.of("a IN (1, 2)", InExpression.class), + Arguments.of("a BETWEEN 1 AND 2", Between.class), + Arguments.of("a IS NULL", IsNullExpression.class), + Arguments.of("(a, b) OVERLAPS (c, d)", OverlapsCondition.class)); + } + + @ParameterizedTest + @ValueSource(strings = {"a", "exists", "exists.col"}) + void preservesComparisons(String column) throws Exception { + String sql = column + " = 1"; + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql); + EqualsTo condition = assertInstanceOf(EqualsTo.class, parser.Condition()); + assertEquals(column, assertInstanceOf(Column.class, condition.getLeftExpression()) + .getFullyQualifiedName()); + assertEquals(sql, condition.toString()); + assertEquals(CCJSqlParserConstants.EOF, parser.getNextToken().kind); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t WHERE " + sql); + } + + @Test + void preservesOraclePriorPosition() throws Exception { + CCJSqlParser parser = CCJSqlParserUtil.newParser("PRIOR a = b"); + EqualsTo condition = assertInstanceOf(EqualsTo.class, parser.Condition()); + assertEquals(SupportsOldOracleJoinSyntax.ORACLE_PRIOR_START, + condition.getOraclePriorPosition()); + assertEquals("a", assertInstanceOf(Column.class, condition.getLeftExpression()) + .getColumnName()); + assertEquals("b", assertInstanceOf(Column.class, condition.getRightExpression()) + .getColumnName()); + assertEquals(CCJSqlParserConstants.EOF, parser.getNextToken().kind); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t CONNECT BY PRIOR a = b"); + } + + @ParameterizedTest + @ValueSource(strings = {"a IN (", "a BETWEEN 1 AND", "EXISTS (SELECT", + "(a, b) OVERLAPS ("}) + void rejectsMalformedConditions(String sql) { + assertThrows(ParseException.class, () -> CCJSqlParserUtil.newParser(sql).Condition()); + assertThrows(ParseException.class, () -> CCJSqlParserUtil.newParser(sql).SQLCondition()); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT * FROM t WHERE " + sql)); + } + + @ParameterizedTest + @ValueSource(strings = {"a =", "exists ="}) + void rejectsMalformedComparisons(String sql) { + assertThrows(ParseException.class, () -> CCJSqlParserUtil.newParser(sql).Condition()); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT * FROM t WHERE " + sql)); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void honorsInterruptionBeforeConditionDispatch(boolean sqlCondition) { + CCJSqlParser parser = CCJSqlParserUtil.newParser("1"); + parser.interrupted = true; + assertThrows(ParseException.class, () -> { + if (sqlCondition) { + parser.SQLCondition(); + } else { + parser.Condition(); + } + }); + assertEquals("1", parser.getNextToken().image); + } + + @ParameterizedTest + @CsvSource(value = {"arg|=>", "arg|:=", "OUTER|=>", "OUTER|:=", "\"arg\"|=>", + "\"arg\"|:=", "overlaps|=>", "overlaps|:="}, delimiter = '|') + void preservesNamedParameterKindsInEveryArgumentPosition(String name, String assignment) + throws JSQLParserException { + for (String prefix : new String[] {"", "a.b, "}) { + String sql = "SELECT f(" + prefix + name + " " + assignment + " value_col)"; + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sql); + Function function = assertInstanceOf(Function.class, + select.getSelectItem(0).getExpression()); + int index = prefix.isEmpty() ? 0 : 1; + assertEquals(index + 1, function.getParameters().size()); + if (index == 1) { + assertEquals("a.b", assertInstanceOf(Column.class, + function.getParameters().get(0)).getFullyQualifiedName()); + } + Expression argument = function.getParameters().get(index); + Expression value; + if ("=>".equals(assignment)) { + OracleNamedFunctionParameter parameter = + assertInstanceOf(OracleNamedFunctionParameter.class, argument); + assertEquals(name, parameter.getName()); + value = parameter.getExpression(); + } else { + PostgresNamedFunctionParameter parameter = + assertInstanceOf(PostgresNamedFunctionParameter.class, argument); + assertEquals(name, parameter.getName()); + value = parameter.getExpression(); + } + assertEquals("value_col", assertInstanceOf(Column.class, value).getColumnName()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"a.b => 1", "a.b := 1", "1 => 1", "1 := 1", "'a' => 1", + "'a' := 1", "arg =>", "arg :="}) + void rejectsInvalidNamedParametersInEveryArgumentPosition(String argument) { + for (String prefix : new String[] {"", "a.b, "}) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT f(" + prefix + argument + ")")); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/parser/MySqlCommentTest.java b/src/test/java/net/sf/jsqlparser/parser/MySqlCommentTest.java new file mode 100644 index 0000000000..e1fa6d5f93 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/MySqlCommentTest.java @@ -0,0 +1,257 @@ +/*- + * #%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.parser; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.ByteArrayInputStream; +import java.io.StringReader; +import java.nio.charset.StandardCharsets; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.SignedExpression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.expression.operators.arithmetic.Subtraction; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.select.PlainSelect; +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 MySqlCommentTest { + private static PlainSelect parse(String sql) throws JSQLParserException { + return (PlainSelect) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + } + + private static PlainSelect parse(String sql, int version) throws JSQLParserException { + return (PlainSelect) CCJSqlParserUtil.parse(sql, + p -> p.withDialect(Dialect.MYSQL).withMySqlServerVersion(version)); + } + + private static void assertOutput(String expected, Statement statement) throws Exception { + assertEquals(expected, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(expected, output.toString()); + assertEquals(expected, parse(output.toString()).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT 1--2", "SELECT 1 --2", "SELECT 1- -2", + "SELECT 1--/*! 2 */"}) + void preservesMinusAndNegativeOperand(String sql) throws Exception { + PlainSelect select = parse(sql); + Subtraction subtraction = + assertInstanceOf(Subtraction.class, select.getSelectItem(0).getExpression()); + assertEquals(1, ((LongValue) subtraction.getLeftExpression()).getValue()); + SignedExpression negative = + assertInstanceOf(SignedExpression.class, subtraction.getRightExpression()); + assertEquals('-', negative.getSign()); + assertEquals(2, ((LongValue) negative.getExpression()).getValue()); + assertOutput("SELECT 1 - -2", select); + } + + @ParameterizedTest + @ValueSource(strings = {" ", "\t", "\r", "\n", "\f", "\u0007", "\u007f"}) + void acceptsWhitespaceOrControlAfterDoubleDash(String separator) throws Exception { + String sql = "SELECT 1--" + separator; + if (!separator.equals("\r") && !separator.equals("\n")) { + sql += "discarded /*! +99 */"; + } + assertOutput("SELECT 1", parse(sql)); + } + + @Test + void keepsLineAndBlockCommentsSeparateFromExecutableSql() throws Exception { + assertOutput("SELECT 1", parse("SELECT 1--")); + assertOutput("SELECT 1 + 2", parse("SELECT 1 -- ignored\n + 2")); + assertOutput("SELECT 1", parse("SELECT 1 /* +99 */")); + assertOutput("SELECT 1", parse("SELECT 1 # /*! +99 */")); + assertOutput("SELECT 1 + 2", parse("SELECT /*! 1 /* inner */ + 2 */")); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT 1 /*! +2 */", "SELECT 1/*!+2*/", + "/*!SELECT 1 + 2*/", "SELECT /*!1*/ /*!+*/ /*!2*/", + "SELECT 1 /*! +\n2 */"}) + void parsesUnversionedCommentContentsAsExpressions(String sql) throws Exception { + PlainSelect select = parse(sql); + Addition addition = + assertInstanceOf(Addition.class, select.getSelectItem(0).getExpression()); + assertEquals(1, ((LongValue) addition.getLeftExpression()).getValue()); + assertEquals(2, ((LongValue) addition.getRightExpression()).getValue()); + assertOutput("SELECT 1 + 2", select); + addition.setRightExpression(new LongValue(3)); + assertOutput("SELECT 1 + 3", select); + } + + @Test + void parsesExecutableSelectModifier() throws Exception { + PlainSelect select = parse("SELECT /*! STRAIGHT_JOIN */ a FROM t"); + assertTrue(select.getMySqlHintStraightJoin()); + assertEquals("a", select.getSelectItem(0).getExpression().toString()); + assertNull(select.getSelectItem(0).getAlias()); + assertOutput("SELECT STRAIGHT_JOIN a FROM t", select); + } + + @Test + void leavesQuotedContentsAndOptimizerHintsIntact() throws Exception { + PlainSelect quoted = parse("SELECT '/*! +2 */ --x', `a--b`, \"/*! +3 */\""); + assertEquals("/*! +2 */ --x", + ((StringValue) quoted.getSelectItem(0).getExpression()).getValue()); + assertEquals("`a--b`", quoted.getSelectItem(1).getExpression().toString()); + assertEquals("/*! +3 */", + ((StringValue) quoted.getSelectItem(2).getExpression()).getValue()); + assertOutput("SELECT '*/', 2", parse("SELECT /*! '*/' */, 2")); + PlainSelect hint = parse("SELECT /*+ BKA(t) */ a FROM t"); + assertNotNull(hint.getOracleHint()); + assertOutput(hint.toString(), hint); + } + + @Test + void respectsExplicitQuoteAndEscapeOverrides() throws Exception { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT /*! \"--x\" */, '/*! text */'", + p -> p.withDialect(Dialect.MYSQL).withDoubleQuotedStrings(false) + .withBackslashEscapeCharacter(false)); + assertInstanceOf(net.sf.jsqlparser.schema.Column.class, + select.getSelectItem(0).getExpression()); + assertEquals("/*! text */", + ((StringValue) select.getSelectItem(1).getExpression()).getValue()); + assertOutput("SELECT 'x\\\'/*! text */'", parse("SELECT /*! 'x\\\'/*! text */' */")); + } + + @Test + void resolvesConditionalCommentsForAnExplicitTarget() throws Exception { + String sql = "SELECT 1 /*!90702 +2 */"; + assertOutput("SELECT 1", parse(sql, 90701)); + assertOutput("SELECT 1 + 2", parse(sql, 90702)); + assertOutput("SELECT 1 + 2", parse(sql, 260700)); + assertOutput("SELECT 1", parse("SELECT 1 /*!260700 +2 */", 90702)); + assertOutput("SELECT 1 + 2", parse("SELECT 1 /*!260700 +2 */", 260700)); + assertOutput("SELECT 1 + 2", parse("SELECT 1 /*!090702\t+2 */", 90702)); + assertOutput("SELECT 1 + 2", parse("SELECT 1 /*!90702+2 */", 90702)); + assertOutput("SELECT 1", parse("SELECT 1 /*!99999 not valid SQL */", 90702)); + } + + @Test + void followsFiveDigitFallbackWhenSixthDigitHasNoFollowingWhitespace() throws Exception { + assertOutput("SELECT 0 + 2", parse("SELECT /*!100000+2*/", 10000)); + assertOutput("SELECT 1234 + 2", parse("SELECT /*!1234+2*/")); + } + + @Test + void requiresVersionWithoutSilentlyFallingBackOrDroppingSql() { + String sql = "SELECT 1 /*!90702 +2 */"; + JSQLParserException exception = assertThrows(JSQLParserException.class, () -> parse(sql)); + assertTrue(exception.getCause().getMessage().contains("withMySqlServerVersion")); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + p -> p.withDialect(Dialect.MYSQL).withUnsupportedStatements())); + assertThrows(TokenMgrException.class, () -> new CCJSqlParser(new StreamProvider( + new StringReader(sql))).withDialect(Dialect.MYSQL).Statement()); + assertThrows(IllegalArgumentException.class, + () -> CCJSqlParserUtil.newParser(sql).withMySqlServerVersion(-1)); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT 1 /*! +2", "SELECT 1 /*!", "SELECT /*! 1", + "SELECT /*! 1 -- closing marker hidden */"}) + void rejectsUnterminatedExecutableComments(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + @Test + void rejectsNestedExecutableComments() { + assertThrows(JSQLParserException.class, + () -> parse("SELECT /*! 1 /*! +99 */ + 2 */")); + } + + @Test + void sharesLexingAcrossStringReaderInputStreamAndFeatureConfiguration() throws Exception { + String sql = "SELECT 1--2 /*!90702 +3 */"; + String expected = "SELECT 1 - -2 + 3"; + assertOutput(expected, parse(sql, 90702)); + assertOutput(expected, new CCJSqlParser(new StringProvider(sql)).withDialect(Dialect.MYSQL) + .withMySqlServerVersion(90702).Statement()); + assertOutput(expected, new CCJSqlParser(new StreamProvider(new StringReader(sql))) + .withDialect(Dialect.MYSQL).withMySqlServerVersion(90702).Statement()); + assertOutput(expected, CCJSqlParserUtil.newParser(new ByteArrayInputStream( + sql.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8.name()) + .withDialect(Dialect.MYSQL).withMySqlServerVersion(90702).Statement()); + FeatureConfiguration configuration = new FeatureConfiguration() + .setValue(Feature.dialect, Dialect.MYSQL.name()) + .setValue(Feature.mySqlServerVersion, 90702); + assertOutput(expected, + CCJSqlParserUtil.newParser(sql).withConfiguration(configuration).Statement()); + assertEquals("1 - -2 + 3", CCJSqlParserUtil.parseExpression("1--2 /*! +3 */", false, + p -> p.withDialect(Dialect.MYSQL)).toString()); + } + + @Test + void preservesStatementBoundariesAndOriginalTokenPositions() throws Exception { + assertEquals(2, CCJSqlParserUtil.parseStatements("/*! SELECT 1 */; SELECT 2;", + p -> p.withDialect(Dialect.MYSQL)).size()); + assertEquals(2, CCJSqlParserUtil.parseStatements("SELECT 1/*!+2*/; SELECT 3--4;", + p -> p.withDialect(Dialect.MYSQL)).size()); + CCJSqlParser parser = CCJSqlParserUtil.newParser("/*!1*/--2").withDialect(Dialect.MYSQL); + Token one = parser.getNextToken(); + assertEquals("1", one.image); + assertEquals(4, one.beginColumn); + assertEquals(4, one.absoluteBegin); + Token minus = parser.getNextToken(); + assertEquals("-", minus.image); + assertEquals(7, minus.beginColumn); + assertEquals(7, minus.absoluteBegin); + assertEquals("-", parser.getNextToken().image); + assertEquals("2", parser.getNextToken().image); + } + + @Test + void handlesBufferExpansionAndStreamReinitialization() throws Exception { + String sql = "SELECT " + " ".repeat(4090) + "1--2/*!+3*/"; + assertOutput("SELECT 1 - -2 + 3", parse(sql)); + assertOutput("SELECT '" + "x".repeat(9000) + "'", + parse("SELECT /*! '" + "x".repeat(9000) + "' */")); + CCJSqlParser parser = CCJSqlParserUtil.newParser("SELECT /*!1*/") + .withDialect(Dialect.MYSQL); + assertEquals("SELECT 1", parser.Statement().toString()); + parser.ReInit(new StringProvider("SELECT 2--3")); + assertEquals("SELECT 2 - -3", parser.Statement().toString()); + } + + @Test + void rejectsLiteralInternalMinusMarkerInEveryDialect() { + String sql = "SELECT 1 " + (char) 2 + " 2"; + for (Dialect dialect : Dialect.values()) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + p -> p.withDialect(dialect)), dialect.name()); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + p -> p.withDialect(dialect).withUnsupportedStatements()), dialect.name()); + } + } + + @Test + void preservesOtherDialectCommentsAndQuotedBodies() throws Exception { + assertEquals("SELECT 1", CCJSqlParserUtil.parse("SELECT 1--2").toString()); + for (Dialect dialect : Dialect.values()) { + if (dialect != Dialect.MYSQL) { + assertEquals("SELECT 1", CCJSqlParserUtil.parse("SELECT 1 /*!90702 +2 */ --3", + p -> p.withDialect(dialect)).toString(), dialect.name()); + } + } + assertEquals("SELECT $x$/*! --2 */$x$", CCJSqlParserUtil.parse( + "SELECT $x$/*! --2 */$x$", p -> p.withDialect(Dialect.POSTGRESQL)).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/parser/OracleVectorTypeTest.java b/src/test/java/net/sf/jsqlparser/parser/OracleVectorTypeTest.java new file mode 100644 index 0000000000..27333e842a --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/parser/OracleVectorTypeTest.java @@ -0,0 +1,75 @@ +/*- + * #%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.parser; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import java.util.Arrays; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class OracleVectorTypeTest { + @ParameterizedTest + @ValueSource(strings = {"*, *", "*, FLOAT32", "3, *", "*, *, DENSE", "*, *, SPARSE", + "*, FLOAT32, SPARSE", "3, *, SPARSE", "3, FLOAT32, *", "*, *, *", "3, FLOAT32", + "3", "1024, FLOAT32, SPARSE"}) + void preservesVectorArguments(String arguments) throws JSQLParserException { + List expected = Arrays.asList(arguments.split(", ")); + for (String name : List.of("VECTOR", "vector")) { + String typeSql = name + "(" + arguments + ")"; + for (ColDataType type : List.of(CCJSqlParserUtil.parseColDataType(typeSql), + CCJSqlParserUtil.parseColDataType(typeSql, + p -> p.withDialect(Dialect.ORACLE)))) { + assertEquals(name, type.getDataType()); + assertEquals(expected, type.getArgumentsStringList()); + assertEquals(name + " (" + arguments + ")", type.toString()); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"VECTOR(*, *)", "VECTOR(*, FLOAT32)", "VECTOR(3, *)", + "VECTOR(*, *, SPARSE)", "VECTOR(3, FLOAT32, *)"}) + void roundTripsVectorColumnsBeforeOtherColumns(String typeSql) throws JSQLParserException { + String sql = "CREATE TABLE items (embedding " + typeSql + ", label VARCHAR2(20))"; + for (Statement statement : List.of(TestUtils.assertSqlCanBeParsedAndDeparsed(sql), + CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.ORACLE)))) { + CreateTable table = (CreateTable) statement; + assertEquals(2, table.getColumnDefinitions().size()); + assertEquals("label", table.getColumnDefinitions().get(1).getColumnName()); + StringBuilder buffer = new StringBuilder(); + statement.accept(new StatementDeParser(buffer), null); + assertEquals(statement.toString(), buffer.toString()); + CreateTable reparsed = (CreateTable) CCJSqlParserUtil.parse(buffer.toString()); + assertEquals( + table.getColumnDefinitions().get(0).getColDataType().getArgumentsStringList(), + reparsed.getColumnDefinitions().get(0).getColDataType() + .getArgumentsStringList()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"VARCHAR(*)", "NUMERIC(3, *)", "custom_type(*)", + "\"VECTOR\"(*, *)", "VECTOR(*,", "VECTOR(, *)", "VECTOR(*, *) NOT NULL"}) + void rejectsWildcardsOutsideVectorAndIncompleteTypes(String typeSql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parseColDataType(typeSql)); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parseColDataType(typeSql, + p -> p.withDialect(Dialect.ORACLE))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/schema/ColumnTest.java b/src/test/java/net/sf/jsqlparser/schema/ColumnTest.java index 4c8469429e..c5db20f74c 100644 --- a/src/test/java/net/sf/jsqlparser/schema/ColumnTest.java +++ b/src/test/java/net/sf/jsqlparser/schema/ColumnTest.java @@ -9,17 +9,34 @@ */ package net.sf.jsqlparser.schema; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.select.PlainSelect; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.ResourceLock; +import org.junit.jupiter.api.parallel.Resources; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.ArrayList; +import java.util.Collections; import java.util.List; +import java.util.stream.Stream; +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static net.sf.jsqlparser.test.TestUtils.assertStatementCanBeDeparsedAs; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; /** * * @author tw */ +@ResourceLock(Resources.SYSTEM_PROPERTIES) public class ColumnTest { @Test @@ -54,4 +71,202 @@ public void testConstructorNamePartsAndDelimiters() { assertThat(table.getNamePartDelimiters()).containsExactly(".", ":"); } + @ParameterizedTest + @MethodSource("qualifiedQuotedNames") + void testQualifiedQuotedNames(String name, List tableParts, String columnName) { + assertColumn(new Column(name), name, tableParts, columnName); + Column column = new Column(); + column.setName(name, true); + assertColumn(column, name, tableParts, columnName); + assertColumn(new Column().withColumnName(name), name, tableParts, columnName); + } + + @ParameterizedTest + @MethodSource("separatedQuotedNames") + void testQuotedNameParts(String name, List tableParts, String columnName) { + List nameParts = new ArrayList<>(tableParts); + Collections.reverse(nameParts); + nameParts.add(columnName); + assertColumn(new Column(nameParts), name, tableParts, columnName); + assertColumn(new Column(nameParts, Collections.nCopies(nameParts.size() - 1, ".")), + name, tableParts, columnName); + } + + @ParameterizedTest + @MethodSource("parsedQualifiedQuotedNames") + void testParsedQualifiedQuotedNames(String name, List tableParts, String columnName) + throws JSQLParserException { + String sql = "SELECT " + name + " FROM t1"; + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withSquareBracketQuotation(true)); + assertColumn(select.getSelectItem(0).getExpression(Column.class), name, tableParts, + columnName); + PlainSelect reparsed = (PlainSelect) CCJSqlParserUtil.parse(select.toString(), + parser -> parser.withSquareBracketQuotation(true)); + assertColumn(reparsed.getSelectItem(0).getExpression(Column.class), name, tableParts, + columnName); + } + + @ParameterizedTest + @MethodSource("wholeQuotedNames") + void testWholeQuotedDottedNames(String name, String expected, List tableParts, + String columnName) throws JSQLParserException { + assertColumn(new Column(name), expected, tableParts, columnName); + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT " + name + " FROM t1", + parser -> parser.withSquareBracketQuotation(true)); + assertColumn(select.getSelectItem(0).getExpression(Column.class), expected, tableParts, + columnName); + assertStatementCanBeDeparsedAs(select, "SELECT " + expected + " FROM t1"); + } + + @ParameterizedTest + @ValueSource(strings = {"id", "`id`", "\"id\"", "[id]"}) + void testUnqualifiedNames(String name) { + Column column = new Column(name); + assertEquals(name, column.getColumnName()); + assertEquals(name, column.toString()); + assertEquals("id", column.getUnquotedColumnName()); + assertNull(column.getTable()); + } + + @ParameterizedTest + @MethodSource("legacyQualifiedTableNames") + void testLegacyQualifiedTableNames(String tableName, String expected, + List tableParts) { + assertColumn(new Column(List.of(tableName, "id")), expected, tableParts, "id"); + assertColumn(new Column(List.of(tableName, "id"), List.of(".")), expected, + tableParts, "id"); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void testBigQueryQualifiedTableColumn(boolean explicitDialect) throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT `project.dataset.table`.id FROM `project.dataset.table`", parser -> { + if (explicitDialect) { + parser.withDialect(Dialect.BIGQUERY); + } + }); + Column column = select.getSelectItem(0).getExpression(Column.class); + assertColumn(column, "\"project\".\"dataset\".\"table\".id", + List.of("\"table\"", "\"dataset\"", "\"project\""), "id"); + assertEquals("project", column.getUnquotedCatalogName()); + assertEquals("dataset", column.getUnquotedSchemaName()); + assertEquals("table", column.getUnquotedTableName()); + assertEquals(select.getFromItem(Table.class).getNameParts(), + column.getTable().getNameParts()); + assertStatementCanBeDeparsedAs(select, + "SELECT \"project\".\"dataset\".\"table\".id FROM \"project\".\"dataset\".\"table\""); + } + + @ParameterizedTest + @ValueSource(strings = {"t1.`id`", "`t1.id`", "\"t1.id\"", "[t1.id]", "s.t1.id"}) + void testExplicitlyDisabledSplitting(String name) { + Column column = new Column(); + column.setName(name, false); + assertEquals(name, column.getColumnName()); + assertEquals(name, column.toString()); + assertNull(column.getTable()); + } + + @ParameterizedTest + @ValueSource(strings = {"false", "OFF", "0"}) + void testSystemPropertyDisablesSplitting(String value) { + String previous = System.getProperty("SPLIT_NAMES_ON_DELIMITER"); + try { + System.setProperty("SPLIT_NAMES_ON_DELIMITER", value); + for (String name : List.of("t1.`id`", "`t1.id`", "\"t1.id\"", "[t1.id]", "s.t1.id")) { + Column column = new Column(name); + assertEquals(name, column.getColumnName()); + assertEquals(name, column.toString()); + assertNull(column.getTable()); + } + } finally { + if (previous == null) { + System.clearProperty("SPLIT_NAMES_ON_DELIMITER"); + } else { + System.setProperty("SPLIT_NAMES_ON_DELIMITER", previous); + } + } + } + + private static void assertColumn(Column column, String name, List tableParts, + String columnName) { + assertEquals(name, column.toString()); + assertEquals(name, column.getFullyQualifiedName()); + assertEquals(columnName, column.getColumnName()); + assertThat(column.getTable().getNameParts()).containsExactlyElementsOf(tableParts); + assertEquals(tableParts.get(0), column.getTableName()); + assertEquals(tableParts.size() > 1 ? tableParts.get(1) : null, column.getSchemaName()); + assertEquals(tableParts.size() > 2 ? tableParts.get(2) : null, column.getCatalogName()); + } + + static Stream qualifiedQuotedNames() { + return Stream.of( + Arguments.of("t1.`id`", List.of("t1"), "`id`"), + Arguments.of("t1.\"id\"", List.of("t1"), "\"id\""), + Arguments.of("t1.[id]", List.of("t1"), "[id]"), + Arguments.of("`t1`.id", List.of("`t1`"), "id"), + Arguments.of("\"t1\".id", List.of("\"t1\""), "id"), + Arguments.of("[t1].id", List.of("[t1]"), "id"), + Arguments.of("`t1`.`id`", List.of("`t1`"), "`id`"), + Arguments.of("\"t1\".\"id\"", List.of("\"t1\""), "\"id\""), + Arguments.of("[t1].[id]", List.of("[t1]"), "[id]"), + Arguments.of("s.t1.`id`", List.of("t1", "s"), "`id`"), + Arguments.of("`s`.`t1`.`id`", List.of("`t1`", "`s`"), "`id`"), + Arguments.of("\"s\".\"t1\".\"id\"", List.of("\"t1\"", "\"s\""), "\"id\""), + Arguments.of("[s].[t1].[id]", List.of("[t1]", "[s]"), "[id]"), + Arguments.of("[s].`t1`.\"id\"", List.of("`t1`", "[s]"), "\"id\""), + Arguments.of("t1.`i.d`", List.of("t1"), "`i.d`"), + Arguments.of("t1.`i``.d`", List.of("t1"), "`i``.d`"), + Arguments.of("t1.\"i\"\".d\"", List.of("t1"), "\"i\"\".d\""), + Arguments.of("t1.[i]].d]", List.of("t1"), "[i]].d]"), + Arguments.of("`t.1`.id", List.of("`t.1`"), "id"), + Arguments.of("`s.1`.`t.1`.`i.d`", List.of("`t.1`", "`s.1`"), "`i.d`"), + Arguments.of("\"s.1\".\"t.1\".\"i.d\"", List.of("\"t.1\"", "\"s.1\""), "\"i.d\""), + Arguments.of("[s.1].[t.1].[i.d]", List.of("[t.1]", "[s.1]"), "[i.d]"), + Arguments.of("`t``.1`.`i``.d`", List.of("`t``.1`"), "`i``.d`"), + Arguments.of("\"t\"\".1\".\"i\"\".d\"", List.of("\"t\"\".1\""), "\"i\"\".d\""), + Arguments.of("[t]].1].[i]].d]", List.of("[t]].1]"), "[i]].d]"), + Arguments.of("`t\".1`.\"i`.d\"", List.of("`t\".1`"), "\"i`.d\""), + Arguments.of("t1.id", List.of("t1"), "id"), + Arguments.of("s.t1.id", List.of("t1", "s"), "id")); + } + + static Stream separatedQuotedNames() { + // A single table token containing dots keeps the legacy BigQuery interpretation. + return qualifiedQuotedNames() + .filter(arguments -> { + List tableParts = (List) arguments.get()[1]; + return tableParts.size() > 1 || !((String) tableParts.get(0)).contains("."); + }); + } + + static Stream parsedQualifiedQuotedNames() { + return separatedQuotedNames() + .filter(arguments -> !((String) arguments.get()[0]).contains("]]")); + } + + static Stream legacyQualifiedTableNames() { + return Stream.of( + Arguments.of("schema.table", "schema.table.id", List.of("table", "schema")), + Arguments.of("`schema.table`", "\"schema\".\"table\".id", + List.of("\"table\"", "\"schema\"")), + Arguments.of("`project.dataset.table`", "\"project\".\"dataset\".\"table\".id", + List.of("\"table\"", "\"dataset\"", "\"project\""))); + } + + static Stream wholeQuotedNames() { + return Stream.of( + Arguments.of("`t1.id`", "\"t1\".\"id\"", List.of("\"t1\""), "\"id\""), + Arguments.of("\"t1.id\"", "\"t1\".\"id\"", List.of("\"t1\""), "\"id\""), + Arguments.of("[t1.id]", "\"t1\".\"id\"", List.of("\"t1\""), "\"id\""), + Arguments.of("`s.t1.id`", "\"s\".\"t1\".\"id\"", List.of("\"t1\"", "\"s\""), + "\"id\""), + Arguments.of("\"s.t1.id\"", "\"s\".\"t1\".\"id\"", List.of("\"t1\"", "\"s\""), + "\"id\""), + Arguments.of("[s.t1.id]", "\"s\".\"t1\".\"id\"", List.of("\"t1\"", "\"s\""), + "\"id\"")); + } + } diff --git a/src/test/java/net/sf/jsqlparser/schema/MultiPartNameTest.java b/src/test/java/net/sf/jsqlparser/schema/MultiPartNameTest.java index dfb5034f61..113b019ac5 100644 --- a/src/test/java/net/sf/jsqlparser/schema/MultiPartNameTest.java +++ b/src/test/java/net/sf/jsqlparser/schema/MultiPartNameTest.java @@ -9,6 +9,9 @@ */ package net.sf.jsqlparser.schema; +import java.time.Duration; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.select.PlainSelect; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -21,4 +24,31 @@ void replaceBackticksWithDoubleQuotes() { Assertions.assertThat("\"starbake\".\"customers\"").isEqualToIgnoringCase( MultiPartName.replaceBackticksWithDoubleQuotes("`starbake`.`customers`")); } + + @Test + void unquoteMatchesQuotePattern() { + String[] names = {"", "a", "\"a\"", "[a]", "`a`", "\"a\".\"b\"", "\"\"\"\"", "\"]", + "[\"a\"]", "a\"", "\"a", "]a[", "``a``", "\"a\"\"b\"", "[[a]]"}; + for (String name : names) { + assertEquals(MultiPartName.LEADING_TRAILING_QUOTES_PATTERN.matcher(name).replaceAll(""), + MultiPartName.unquote(name), name); + assertEquals(MultiPartName.LEADING_TRAILING_QUOTES_PATTERN.matcher(name).find(), + MultiPartName.isQuoted(name), name); + } + assertNull(MultiPartName.unquote(null)); + assertFalse(MultiPartName.isQuoted(null)); + } + + @Test + void unquoteIsLinearOnRunsOfEscapedQuotes() { + // a quoted identifier with a dot and many doubled quotes used to backtrack quadratically + String quotes = "\"\"".repeat(40000); + String sql = "SELECT * FROM \"a" + quotes + ".b\""; + PlainSelect select = (PlainSelect) assertTimeoutPreemptively(Duration.ofSeconds(2), + () -> CCJSqlParserUtil.parse(sql)); + assertNotNull(select.getFromItem()); + assertEquals("a" + quotes + ".b", + assertTimeoutPreemptively(Duration.ofSeconds(2), + () -> MultiPartName.unquote("\"a" + quotes + ".b\""))); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/CascadeBehaviorTest.java b/src/test/java/net/sf/jsqlparser/statement/CascadeBehaviorTest.java new file mode 100644 index 0000000000..1f41e0d492 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/CascadeBehaviorTest.java @@ -0,0 +1,143 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.alter.AlterDomain; +import net.sf.jsqlparser.statement.alter.AlterType; +import net.sf.jsqlparser.statement.drop.DropPolicy; +import net.sf.jsqlparser.statement.grant.Revoke; +import net.sf.jsqlparser.statement.truncate.Truncate; +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.MethodSource; + +class CascadeBehaviorTest { + static Stream statements() { + return Stream.of( + "ALTER DOMAIN amount DROP CONSTRAINT positive", + "ALTER TYPE item RENAME ATTRIBUTE old_name TO new_name", + "ALTER TYPE item ADD ATTRIBUTE code text", + "ALTER TYPE item DROP ATTRIBUTE price", + "ALTER TYPE item ALTER ATTRIBUTE price SET DATA TYPE bigint", + "DROP POLICY visible ON items", + "TRUNCATE TABLE items", + "REVOKE SELECT ON items FROM reader"); + } + + @ParameterizedTest + @MethodSource("statements") + void parsesSharedEnumAndPreservesOmittedClauses(String sql) throws JSQLParserException { + for (boolean postgres : new boolean[] {false, true}) { + for (CascadeBehavior behavior : new CascadeBehavior[] { + null, CascadeBehavior.CASCADE, CascadeBehavior.RESTRICT}) { + String expectedSql = sql + (behavior == null ? "" : " " + behavior); + Statement statement = parse(expectedSql, postgres); + assertSame(behavior, getBehavior(statement)); + assertRoundTrip(statement, expectedSql, behavior, postgres); + } + } + } + + @ParameterizedTest + @MethodSource("statements") + void sharedEnumSettersChangeAndRemoveClauses(String sql) throws JSQLParserException { + for (boolean postgres : new boolean[] {false, true}) { + Statement statement = parse(sql + " CASCADE", postgres); + for (CascadeBehavior behavior : new CascadeBehavior[] { + CascadeBehavior.RESTRICT, null, CascadeBehavior.CASCADE}) { + setBehavior(statement, behavior); + assertSame(behavior, getBehavior(statement)); + assertRoundTrip(statement, sql + (behavior == null ? "" : " " + behavior), + behavior, postgres); + } + } + } + + @Test + void truncateBooleanSetterStillClearsRatherThanSelectsRestrict() throws JSQLParserException { + Truncate statement = (Truncate) parse("TRUNCATE TABLE items RESTRICT", true); + assertFalse(statement.getCascade()); + statement.setCascade(true); + assertTrue(statement.getCascade()); + assertSame(CascadeBehavior.CASCADE, statement.getDropBehavior()); + assertRoundTrip(statement, "TRUNCATE TABLE items CASCADE", CascadeBehavior.CASCADE, true); + + statement.setCascade(false); + assertFalse(statement.getCascade()); + assertNull(statement.getDropBehavior()); + assertRoundTrip(statement, "TRUNCATE TABLE items", null, true); + } + + private static Statement parse(String sql, boolean postgres) throws JSQLParserException { + return postgres + ? CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.POSTGRESQL)) + : CCJSqlParserUtil.parse(sql); + } + + private static void assertRoundTrip(Statement statement, String expectedSql, + CascadeBehavior behavior, boolean postgres) throws JSQLParserException { + assertEquals(expectedSql, statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(expectedSql, deparsed.toString()); + Statement reparsed = parse(deparsed.toString(), postgres); + assertSame(behavior, getBehavior(reparsed)); + assertEquals(expectedSql, reparsed.toString()); + } + + private static CascadeBehavior getBehavior(Statement statement) { + if (statement instanceof AlterDomain) { + return ((AlterDomain) statement).getBehavior(); + } else if (statement instanceof AlterType) { + AlterType type = (AlterType) statement; + return type.getAttributeChanges().isEmpty() ? type.getBehavior() + : type.getAttributeChanges().get(0).getBehavior(); + } else if (statement instanceof DropPolicy) { + return ((DropPolicy) statement).getBehavior(); + } else if (statement instanceof Truncate) { + return ((Truncate) statement).getDropBehavior(); + } else if (statement instanceof Revoke) { + return ((Revoke) statement).getBehavior(); + } + throw new IllegalArgumentException("Unsupported statement: " + statement); + } + + private static void setBehavior(Statement statement, CascadeBehavior behavior) { + if (statement instanceof AlterDomain) { + ((AlterDomain) statement).setBehavior(behavior); + } else if (statement instanceof AlterType) { + AlterType type = (AlterType) statement; + if (type.getAttributeChanges().isEmpty()) { + type.setBehavior(behavior); + } else { + type.getAttributeChanges().get(0).setBehavior(behavior); + } + } else if (statement instanceof DropPolicy) { + ((DropPolicy) statement).setBehavior(behavior); + } else if (statement instanceof Truncate) { + ((Truncate) statement).setDropBehavior(behavior); + } else if (statement instanceof Revoke) { + ((Revoke) statement).setBehavior(behavior); + } else { + throw new IllegalArgumentException("Unsupported statement: " + statement); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/ConfigurationParameterChangeTest.java b/src/test/java/net/sf/jsqlparser/statement/ConfigurationParameterChangeTest.java new file mode 100644 index 0000000000..4f70e77464 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/ConfigurationParameterChangeTest.java @@ -0,0 +1,166 @@ +/*- + * #%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; + +import static org.assertj.core.api.Assertions.assertThat; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.ConfigurationParameterChange.Action; +import net.sf.jsqlparser.statement.ConfigurationParameterChange.ValueKind; +import net.sf.jsqlparser.statement.alter.database.AlterDatabase; +import net.sf.jsqlparser.statement.role.AlterRole; +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 ConfigurationParameterChangeTest { + + @ParameterizedTest + @ValueSource(strings = {"SET search_path TO app, public", "SET work_mem = '64MB'", + "SET work_mem TO DEFAULT", "SET work_mem = DEFAULT", "SET work_mem FROM CURRENT", + "SET myext.setting = 1", "RESET work_mem", "RESET ALL"}) + void testAlterRoleAndDatabaseShareTheClause(String clause) throws JSQLParserException { + AlterRole role = (AlterRole) CCJSqlParserUtil.parse("ALTER ROLE app " + clause); + AlterDatabase database = + (AlterDatabase) CCJSqlParserUtil.parse("ALTER DATABASE app " + clause); + + assertThat(role.getParameterChange().toString()).isEqualTo(clause); + assertThat(database.getParameterChange().toString()).isEqualTo(clause); + assertThat(database.getAction()) + .isEqualTo(AlterDatabase.Action.CONFIGURATION_PARAMETER); + assertThat(role.getAction().name()) + .isEqualTo(role.getParameterChange().getAction().name()); + assertThat(deparse(role)).isEqualTo("ALTER ROLE app " + clause); + assertThat(deparse(database)).isEqualTo("ALTER DATABASE app " + clause); + } + + @Test + void testParsedState() throws JSQLParserException { + ConfigurationParameterChange set = parseChange("SET search_path TO app, public"); + assertThat(set.getAction()).isEqualTo(Action.SET); + assertThat(set.getParameter()).isEqualTo("search_path"); + assertThat(set.getValueKind()).isEqualTo(ValueKind.VALUES); + assertThat(set.isUseEquals()).isFalse(); + assertThat(set.getValues()).extracting(Object::toString).containsExactly("app", "public"); + + ConfigurationParameterChange setDefault = parseChange("SET work_mem = DEFAULT"); + assertThat(setDefault.getValueKind()).isEqualTo(ValueKind.DEFAULT); + assertThat(setDefault.isUseEquals()).isTrue(); + assertThat(setDefault.getValues()).isNull(); + + assertThat(parseChange("SET work_mem FROM CURRENT").getValueKind()) + .isEqualTo(ValueKind.FROM_CURRENT); + + ConfigurationParameterChange resetAll = parseChange("RESET ALL"); + assertThat(resetAll.getAction()).isEqualTo(Action.RESET); + assertThat(resetAll.getParameter()).isEqualTo("ALL"); + } + + @Test + void testBuildAndEdit() { + ConfigurationParameterChange change = + new ConfigurationParameterChange(Action.SET, "statement_timeout") + .withUseEquals(true) + .withValues(new ExpressionList(new StringValue("5s"))); + assertThat(change.toString()).isEqualTo("SET statement_timeout = '5s'"); + + change.setValueKind(ValueKind.DEFAULT); + assertThat(change.toString()).isEqualTo("SET statement_timeout = DEFAULT"); + change.setValueKind(ValueKind.VALUES); + assertThat(change.toString()).isEqualTo("SET statement_timeout = '5s'"); + change.setValueKind(ValueKind.FROM_CURRENT); + assertThat(change.toString()).isEqualTo("SET statement_timeout FROM CURRENT"); + + change.setAction(Action.RESET); + assertThat(change.toString()).isEqualTo("RESET statement_timeout"); + + AlterDatabase database = new AlterDatabase(); + database.setDatabaseName("app"); + database.setAction(AlterDatabase.Action.CONFIGURATION_PARAMETER); + database.setParameterChange(change); + assertThat(database.toString()).isEqualTo("ALTER DATABASE app RESET statement_timeout"); + } + + @Test + void testAlterRoleLegacyAccessorsReadTheChange() throws JSQLParserException { + AlterRole role = (AlterRole) CCJSqlParserUtil + .parse("ALTER ROLE ALL IN DATABASE appdb SET search_path = app, public"); + assertThat(role.getAction()).isEqualTo(AlterRole.Action.SET); + assertThat(role.getParameter()).isEqualTo("search_path"); + assertThat(role.isUseEquals()).isTrue(); + assertThat(role.isUseDefault()).isFalse(); + assertThat(role.isFromCurrent()).isFalse(); + assertThat(role.getValues()).isSameAs(role.getParameterChange().getValues()); + + role.getValues().set(0, new Column("new_schema")); + role.setUseEquals(false); + assertThat(role.toString()) + .isEqualTo( + "ALTER ROLE ALL IN DATABASE appdb SET search_path TO new_schema, public"); + + role.setUseDefault(true); + assertThat(role.getParameterChange().getValueKind()).isEqualTo(ValueKind.DEFAULT); + assertThat(role.toString()).endsWith("SET search_path TO DEFAULT"); + role.setFromCurrent(true); + assertThat(role.isUseDefault()).isFalse(); + assertThat(role.toString()).endsWith("SET search_path FROM CURRENT"); + role.setFromCurrent(false); + assertThat(role.toString()).endsWith("SET search_path TO new_schema, public"); + + role.setAction(AlterRole.Action.RESET); + assertThat(role.getParameterChange().getAction()).isEqualTo(Action.RESET); + assertThat(role.toString()).isEqualTo("ALTER ROLE ALL IN DATABASE appdb RESET search_path"); + + role.getParameterChange().setAction(Action.SET); + assertThat(role.getAction()).isEqualTo(AlterRole.Action.SET); + } + + @Test + void testAlterRoleLegacySetters() { + AlterRole role = new AlterRole(); + role.setName("app"); + assertThat(role.getParameterChange()).isNull(); + assertThat(role.getParameter()).isNull(); + assertThat(role.getValues()).isNull(); + assertThat(role.isUseEquals()).isFalse(); + + role.setParameter("work_mem"); + role.setAction(AlterRole.Action.SET); + role.setValues(new ExpressionList(new StringValue("64MB"))); + assertThat(role.toString()).isEqualTo("ALTER ROLE app SET work_mem TO '64MB'"); + + role.setAction(AlterRole.Action.RENAME); + role.setNewName("app2"); + assertThat(role.toString()).isEqualTo("ALTER ROLE app RENAME TO app2"); + assertThat(role.getParameter()).isEqualTo("work_mem"); + + role.setParameterChange(new ConfigurationParameterChange(Action.RESET, "ALL")); + assertThat(role.getAction()).isEqualTo(AlterRole.Action.RESET); + assertThat(role.toString()).isEqualTo("ALTER ROLE app RESET ALL"); + } + + private static ConfigurationParameterChange parseChange(String clause) + throws JSQLParserException { + return ((AlterDatabase) CCJSqlParserUtil.parse("ALTER DATABASE d " + clause)) + .getParameterChange(); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder)); + return builder.toString(); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/DdlVisitorTraversalTest.java b/src/test/java/net/sf/jsqlparser/statement/DdlVisitorTraversalTest.java new file mode 100644 index 0000000000..0efd5168b1 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/DdlVisitorTraversalTest.java @@ -0,0 +1,156 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.select.FromItemVisitorAdapter; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +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.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class DdlVisitorTraversalTest { + static Stream definitions() { + return Stream.of( + Arguments.of("ALTER VIEW v ALTER COLUMN id SET DEFAULT 7", List.of("7"), + List.of("v")), + Arguments.of("ALTER INDEX ix SET (fillfactor = 70)", List.of("70"), List.of()), + Arguments.of("ALTER POLICY p ON t USING (id > 7) WITH CHECK (id < 9)", + List.of("7", "9"), List.of("t")), + Arguments.of("DROP POLICY p ON t", List.of(), List.of("t")), + Arguments.of("CREATE STATISTICS s ON (id + 7), label FROM t", List.of("7"), + List.of("t")), + Arguments.of("CREATE FOREIGN DATA WRAPPER w OPTIONS (host 'before')", + List.of("before"), List.of()), + Arguments.of("ALTER FOREIGN DATA WRAPPER w OPTIONS (SET host 'before')", + List.of("before"), List.of()), + Arguments.of( + "CREATE SERVER s TYPE 'pg' VERSION '18' FOREIGN DATA WRAPPER w OPTIONS (host 'before')", + List.of("before", "pg", "18"), List.of()), + Arguments.of("ALTER SERVER s VERSION '18' OPTIONS (SET host 'before')", + List.of("before", "18"), List.of()), + Arguments.of( + "CREATE USER MAPPING FOR CURRENT_USER SERVER s OPTIONS (user 'before')", + List.of("before"), List.of()), + Arguments.of( + "ALTER USER MAPPING FOR CURRENT_USER SERVER s OPTIONS (SET user 'before')", + List.of("before"), List.of()), + Arguments.of("CREATE COLLATION c (locale = 'C')", List.of("C"), List.of()), + Arguments.of( + "CREATE RULE r AS ON INSERT TO t WHERE NEW.id > 7 DO (INSERT INTO log VALUES (9); NOTIFY ch, 'before')", + List.of("7", "9", "before"), List.of("t", "log"))); + } + + @Test + void valuesChildrenIncludingWithAndTailKeepTheVisitorContext() throws Exception { + Object context = new Object(); + List values = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S actualContext) { + assertSame(context, actualContext); + values.add(value.getValue()); + return null; + } + }; + Statement statement = CCJSqlParserUtil.parse( + "WITH c AS (SELECT 11) VALUES (22) ORDER BY (33 + 0) LIMIT 44 OFFSET 55"); + statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + context); + assertEquals(List.of(11L, 22L, 33L, 0L, 44L, 55L), values); + } + + @ParameterizedTest + @MethodSource("definitions") + void visitsAndMutatesChildrenWithContext(String sql, List expectedValues, + List expectedTables) throws Exception { + Statement statement = CCJSqlParserUtil.parse(sql); + List values = new ArrayList<>(); + List tables = new ArrayList<>(); + Object context = new Object(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S actualContext) { + assertSame(context, actualContext); + values.add(value.getStringValue()); + value.setValue(value.getValue() + 1); + return null; + } + + @Override + public Void visit(StringValue value, S actualContext) { + assertSame(context, actualContext); + values.add(value.getValue()); + value.setValue("changed"); + return null; + } + }; + FromItemVisitorAdapter fromItems = new FromItemVisitorAdapter() { + @Override + public Void visit(Table table, S actualContext) { + assertSame(context, actualContext); + tables.add(table.getName()); + table.setName("changed_" + table.getName()); + return null; + } + }; + SelectVisitorAdapter selects = + new SelectVisitorAdapter<>(expressions, fromItems); + statement.accept(new StatementVisitorAdapter<>(selects), context); + assertEquals(expectedValues, values); + assertEquals(expectedTables, tables); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER VIEW v ALTER COLUMN id SET DEFAULT abs(7)", + "ALTER POLICY p ON t USING (abs(id) > 7)", + "CREATE STATISTICS s ON (abs(id)) FROM t"}) + void validatesNestedExpressions(String sql) { + FeaturesAllowed withoutFunctions = new FeaturesAllowed().add(FeaturesAllowed.DDL); + assertFalse(new Validation(List.of(withoutFunctions), sql).validate().isEmpty()); + FeaturesAllowed withFunctions = + new FeaturesAllowed().add(FeaturesAllowed.DDL).add(Feature.function); + assertTrue(new Validation(List.of(withFunctions), sql).validate().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE RULE r AS ON INSERT TO t DO INSERT INTO log VALUES (7)", + "CREATE RULE r AS ON SELECT TO v DO INSTEAD SELECT * FROM t", + "ALTER POLICY p ON t USING (id > 7)", + "CREATE STATISTICS s ON (id + 7), label FROM t"}) + void storedDefinitionsAreSchemaChangesRatherThanExecutedBodies(String sql) throws Exception { + StatementFeatures features = CCJSqlParserUtil.parse(sql).getFeatures(); + assertTrue(features.is(StmtFeature.MODIFIES_SCHEMA)); + assertFalse(features.is(StmtFeature.MODIFIES_DATA)); + assertFalse(features.is(StmtFeature.RETURNS_RESULT_SET)); + assertFalse(features.is(StmtFeature.READS_DATA)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/DiscardStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/DiscardStatementTest.java new file mode 100644 index 0000000000..126f28722d --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/DiscardStatementTest.java @@ -0,0 +1,145 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.DiscardStatement.Target; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +class DiscardStatementTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + private static final List> POSTGRESQL_AND_NO_DIALECT = + Arrays.asList(POSTGRESQL, parser -> { + }); + + @ParameterizedTest + @EnumSource(Target.class) + void parsesEveryTargetWithPostgreSqlAndWithoutDialect(Target target) + throws JSQLParserException { + String sql = "DISCARD " + target.name(); + for (Consumer mode : POSTGRESQL_AND_NO_DIALECT) { + DiscardStatement discard = assertInstanceOf(DiscardStatement.class, + assertSqlCanBeParsedAndDeparsed(sql, false, mode)); + assertEquals(target, discard.getTarget()); + } + } + + @Test + void keepsTheSpellingOfTheTarget() throws JSQLParserException { + assertEquals("DISCARD TEMP", CCJSqlParserUtil.parse("discard temp", POSTGRESQL).toString()); + assertEquals("DISCARD TEMPORARY", + CCJSqlParserUtil.parse("Discard Temporary", POSTGRESQL).toString()); + assertEquals("DISCARD SEQUENCES", + CCJSqlParserUtil.parse("discard sequences", POSTGRESQL).toString()); + } + + @Test + void buildsAndDeparses() { + assertDeparse(new DiscardStatement(), "DISCARD ALL"); + DiscardStatement discard = new DiscardStatement(Target.PLANS); + assertDeparse(discard, "DISCARD PLANS"); + assertDeparse(discard.withTarget(Target.TEMPORARY), "DISCARD TEMPORARY"); + assertThrows(NullPointerException.class, () -> discard.setTarget(null)); + } + + @ParameterizedTest + @ValueSource(strings = {"DISCARD", "DISCARD TABLES", "DISCARD ALL PLANS", "DISCARD PLAN", + "DISCARD SEQUENCE", "DISCARD TEMPORARY TABLES", "DISCARD 'ALL'", "DISCARD (ALL)"}) + void rejectsOtherTargets(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void otherDialectsAndOtherUsesKeepTheirReading() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER}) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("DISCARD ALL", + parser -> parser.withDialect(dialect)), dialect.name()); + } + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse("DISCARD ALL", + parser -> parser.withDialect(Dialect.MYSQL).withUnsupportedStatements(true))); + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse("DISCARD foo", + parser -> parser.withUnsupportedStatements(true))); + assertInstanceOf(Alter.class, assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t DISCARD TABLESPACE", true, + parser -> parser.withDialect(Dialect.MYSQL))); + assertSqlCanBeParsedAndDeparsed("SELECT discard FROM discard AS discard", true, + POSTGRESQL); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "DISCARD ALL; DISCARD PLANS\nSELECT 1;\nDISCARD PLANS\nDISCARD TEMP;DISCARD SEQUENCES", + POSTGRESQL); + assertEquals(6, statements.size()); + assertEquals("DISCARD PLANS", statements.get(1).toString()); + assertEquals("DISCARD PLANS", statements.get(3).toString()); + assertEquals("DISCARD TEMP", statements.get(4).toString()); + assertEquals("DISCARD SEQUENCES", statements.get(5).toString()); + + Statements unsupported = CCJSqlParserUtil.parseStatements( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'; DISCARD ALL", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(2, unsupported.size()); + assertInstanceOf(DiscardStatement.class, unsupported.get(1)); + } + + @Test + void reachesStatementVisitors() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("DISCARD SEQUENCES", POSTGRESQL); + String visited = statement.accept(new StatementVisitorAdapter() { + @Override + public String visit(DiscardStatement discard, S context) { + return discard.getTarget().name(); + } + }, null); + assertEquals("SEQUENCES", visited); + assertThat(new TablesNamesFinder<>().getTables(statement)).isEmpty(); + } + + @Test + void modifiesTheSessionAndMayDropTemporaryTables() throws JSQLParserException { + StatementFeatures plans = CCJSqlParserUtil.parse("DISCARD PLANS").getFeatures(); + assertThat(plans.getCertain()).containsExactly(StmtFeature.MODIFIES_SESSION); + assertThat(plans.getUncertain()).isEmpty(); + + for (String sql : new String[] {"DISCARD ALL", "DISCARD TEMP", "DISCARD TEMPORARY"}) { + StatementFeatures features = CCJSqlParserUtil.parse(sql).getFeatures(); + assertThat(features.getCertain()).containsExactly(StmtFeature.MODIFIES_SESSION); + assertThat(features.getUncertain()).containsExactly(StmtFeature.MODIFIES_SCHEMA); + } + assertTrue(new DiscardStatement(Target.ALL).isDroppingTemporaryTables()); + assertFalse(new DiscardStatement(Target.SEQUENCES).isDroppingTemporaryTables()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/DoStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/DoStatementTest.java index 6c5b495ec4..666e5ebefe 100644 --- a/src/test/java/net/sf/jsqlparser/statement/DoStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/DoStatementTest.java @@ -10,19 +10,24 @@ package net.sf.jsqlparser.statement; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.*; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.List; +import java.util.stream.Collectors; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.Function; import net.sf.jsqlparser.expression.StringValue; 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.statement.select.ParenthesedSelect; +import net.sf.jsqlparser.statement.select.SelectItem; import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; import net.sf.jsqlparser.util.TablesNamesFinder; import net.sf.jsqlparser.util.deparser.ExpressionDeParser; @@ -30,6 +35,7 @@ import net.sf.jsqlparser.util.deparser.StatementDeParser; import net.sf.jsqlparser.util.validation.Validation; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -124,7 +130,13 @@ void gatesDialectAndRejectsMalformedWrappers() throws Exception { String sql = "DO $$BEGIN NULL; END$$"; assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); for (Dialect dialect : Dialect.values()) { - if (dialect != Dialect.POSTGRESQL) { + if (dialect == Dialect.MYSQL || dialect == Dialect.MARIADB) { + // MySQL's DO evaluates the literal as an expression instead + DoStatement expressions = (DoStatement) CCJSqlParserUtil.parse(sql, + p -> p.withDialect(dialect)); + assertNull(expressions.getCode()); + assertEquals(1, expressions.getSelectItems().size()); + } else if (dialect != Dialect.POSTGRESQL) { assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect))); } @@ -147,4 +159,117 @@ void validatesWrapperCapabilityWithoutClaimingBodyValidation() { assertFalse(new Validation(config, List.of(new FeaturesAllowed(Feature.select)), "DO $$arbitrary language body$$").validate().isEmpty()); } + + @ParameterizedTest + @ValueSource(strings = {"DO SLEEP(0)", "DO 1, @a := 2", "DO (SELECT 1)", + "DO GET_LOCK('l', 10), RELEASE_LOCK('l')", "DO 1 AS a", "DO 1 a", "DO *", + "DO (SELECT COUNT(*) FROM t)"}) + void mySqlExpressions(String sql) throws Exception { + DoStatement statement = (DoStatement) assertSqlCanBeParsedAndDeparsed(sql, true, + p -> p.withDialect(Dialect.MYSQL)); + assertNull(statement.getCode()); + assertNull(statement.getLanguage()); + assertFalse(statement.getSelectItems().isEmpty()); + // without a dialect DO followed by an expression other than a string is MySQL's + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, true).toString()); + assertEquals(sql, CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MARIADB)) + .toString()); + } + + @Test + void mySqlExpressionModel() throws Exception { + DoStatement statement = (DoStatement) CCJSqlParserUtil + .parse("DO SLEEP(1), (SELECT a FROM t) AS x", p -> p.withDialect(Dialect.MYSQL)); + List> items = statement.getSelectItems(); + assertEquals(2, items.size()); + assertEquals("SLEEP", assertInstanceOf(Function.class, items.get(0).getExpression()) + .getName()); + assertInstanceOf(ParenthesedSelect.class, items.get(1).getExpression()); + assertEquals("x", items.get(1).getAlias().getName()); + + statement.withSelectItems(List.of(new SelectItem<>(new StringValue("v")))); + assertEquals("DO 'v'", statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals("DO 'v'", output.toString()); + } + + @Test + void mySqlStringNeedsTheDialect() throws Exception { + // a string after DO could also be PostgreSQL's code block + String block = "DO 'BEGIN NULL; END'"; + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(block)); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("DO LANGUAGE plpgsql 'BEGIN NULL; END'")); + DoStatement statement = (DoStatement) assertSqlCanBeParsedAndDeparsed("DO 'x', 'y'", + true, p -> p.withDialect(Dialect.MYSQL)); + assertNull(statement.getCode()); + assertEquals(2, statement.getSelectItems().size()); + assertNotNull(((DoStatement) CCJSqlParserUtil.parse(block, + p -> p.withDialect(Dialect.POSTGRESQL))).getCode()); + } + + @ParameterizedTest + @ValueSource(strings = {"DO", "DO 1,", "DO 1 INTO @a", "DO 1 FROM t", "DO 1 WHERE 1 = 1", + "DO , 1"}) + void rejectsMalformedMySqlExpressions(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL))); + } + + @Test + void otherDialectsDoNotReadMySqlExpressions() { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER, + Dialect.H2)) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("DO SLEEP(0)", p -> p.withDialect(dialect))); + } + } + + @Test + void mySqlStatementBoundaries() throws Exception { + Statements statements = CCJSqlParserUtil.parseStatements( + "DO GET_LOCK('l', 10); SELECT 1; DO RELEASE_LOCK('l')\nSELECT 2", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals(List.of("DO GET_LOCK('l', 10)", "SELECT 1", "DO RELEASE_LOCK('l')", + "SELECT 2"), + statements.stream().map(Object::toString).collect(Collectors.toList())); + } + + @Test + void mySqlTablesFeaturesAndVisitors() throws Exception { + assertThat(TablesNamesFinder.findTables("DO (SELECT COUNT(*) FROM t), SLEEP(0)")) + .containsExactly("t"); + + StatementFeatures reads = CCJSqlParserUtil.parse("DO (SELECT a FROM t)").getFeatures(); + assertTrue(reads.is(StmtFeature.READS_DATA)); + assertFalse(reads.returnsResultSet()); + assertFalse(reads.isOpaque()); + StatementFeatures sleep = CCJSqlParserUtil.parse("DO SLEEP(1)").getFeatures(); + assertTrue(sleep.getUnresolvedReferences().contains("sleep")); + assertTrue(sleep.mayModifyData()); + + List functions = new ArrayList<>(); + CCJSqlParserUtil.parse("DO SLEEP(1), RELEASE_LOCK('l')").accept( + new StatementVisitorAdapter<>(new SelectVisitorAdapter<>( + new ExpressionVisitorAdapter() { + @Override + public Void visit(Function function, S context) { + functions.add(function.getName()); + return null; + } + })), + null); + assertEquals(List.of("SLEEP", "RELEASE_LOCK"), functions); + } + + @Test + void validatesMySqlExpressions() { + FeatureConfiguration config = + new FeatureConfiguration().setValue(Feature.dialect, Dialect.MYSQL.name()); + assertTrue(new Validation(config, List.of(MySqlVersion.V8_0), "DO SLEEP(1), 2") + .validate().isEmpty()); + assertFalse(new Validation(config, List.of(new FeaturesAllowed(Feature.select)), + "DO SLEEP(1)").validate().isEmpty()); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/KeywordsTest.java b/src/test/java/net/sf/jsqlparser/statement/KeywordsTest.java index 9e2c14ce7e..d07d818aab 100644 --- a/src/test/java/net/sf/jsqlparser/statement/KeywordsTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/KeywordsTest.java @@ -9,15 +9,54 @@ */ package net.sf.jsqlparser.statement; +import java.util.function.Consumer; +import java.util.stream.Stream; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.AnalyticExpression; +import net.sf.jsqlparser.expression.ConnectByPriorOperator; +import net.sf.jsqlparser.expression.JsonAggregateOnNullType; +import net.sf.jsqlparser.expression.JsonFunction; +import net.sf.jsqlparser.expression.TernaryExpression; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.WindowElement; +import net.sf.jsqlparser.expression.WindowOffset; +import net.sf.jsqlparser.expression.XMLSerializeExpr; +import net.sf.jsqlparser.statement.piped.FromQuery; +import net.sf.jsqlparser.statement.piped.SelectPipeOperator; +import net.sf.jsqlparser.expression.NotExpression; +import net.sf.jsqlparser.expression.MapExpression; +import net.sf.jsqlparser.expression.JdbcNamedParameter; +import net.sf.jsqlparser.expression.operators.relational.EqualsTo; +import net.sf.jsqlparser.expression.operators.relational.InExpression; +import net.sf.jsqlparser.expression.operators.relational.ExistsExpression; +import net.sf.jsqlparser.expression.operators.relational.IsUnknownExpression; +import net.sf.jsqlparser.expression.operators.relational.SupportsOldOracleJoinSyntax; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.parser.ParserKeywordsUtils; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; +import net.sf.jsqlparser.statement.delete.Delete; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.select.Join; +import net.sf.jsqlparser.statement.select.MySqlSelectModifier; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.SampleClause; +import net.sf.jsqlparser.statement.select.WithItem; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; - -import java.util.stream.Stream; +import org.junit.jupiter.params.provider.ValueSource; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.*; /** * Verifies that all non-reserved keywords can be used as unquoted identifiers (schema, table, @@ -62,4 +101,457 @@ public void testGroupsAsIdentifier() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed("SELECT a groups FROM mytable", true); assertSqlCanBeParsedAndDeparsed("CREATE TABLE mytable (groups INT)", true); } + + // sample and extend are non-reserved in the common dialects and reach the + // parser as ordinary table and column names in downstream rewriting tools. + @Test + public void testSampleExtendAsIdentifier() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT sample, extend FROM mytable", true); + assertSqlCanBeParsedAndDeparsed("SELECT mytable.extend FROM mytable", true); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM mytable WHERE extend = 'x'", true); + assertSqlCanBeParsedAndDeparsed("UPDATE mytable SET sample = 1, extend = 'x' WHERE id = 1", + true); + assertSqlCanBeParsedAndDeparsed("INSERT INTO mytable (sample, extend) VALUES (1, 'x')", + true); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM sample", true); + assertSqlCanBeParsedAndDeparsed("DELETE FROM sample WHERE extend = 'x'", true); + assertSqlCanBeParsedAndDeparsed("INSERT INTO sample (extend) VALUES ('x')", true); + assertSqlCanBeParsedAndDeparsed("SELECT a AS sample, b AS extend FROM mytable", true); + } + + @ParameterizedTest + @ValueSource(strings = {"exists", "sample", "extend", "SaMpLe", "ExTeNd"}) + void testSampleExtendImplicitAliases(String keyword) throws JSQLParserException { + // keyword is a non-reserved keyword in the common dialects and reaches the + // parser as an ordinary column name in downstream rewriting tools. + assertSqlCanBeParsedAndDeparsed("SELECT " + keyword + " FROM mytable", true); + assertSqlCanBeParsedAndDeparsed("SELECT mytable.\" + keyword + \" FROM mytable", true); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM mytable WHERE \" + keyword + \" = 1", true); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM mytable ORDER BY \" + keyword + \"", true); + assertSqlCanBeParsedAndDeparsed("UPDATE mytable SET \" + keyword + \" = 1 WHERE id = 1", + true); + assertSqlCanBeParsedAndDeparsed("INSERT INTO mytable (\" + keyword + \") VALUES (1)", true); + assertSqlCanBeParsedAndDeparsed("SELECT a AS \" + keyword + \" FROM mytable", true); + } + + // the guarded keyword form keeps its operator meaning + @Test + public void testExistsPredicateStaysPredicate() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT EXISTS (SELECT 1 FROM x) FROM mytable", true); + assertInstanceOf(ExistsExpression.class, select.getSelectItem(0).getExpression()); + PlainSelect negated = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM mytable WHERE NOT EXISTS (SELECT 1 FROM x)", true); + assertInstanceOf(ExistsExpression.class, + assertInstanceOf(NotExpression.class, negated.getWhere()).getExpression()); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM mytable WHERE EXISTS (SELECT 1 FROM x)", + true); + } + + @ParameterizedTest + @ValueSource(strings = {"exists", "ExIsTs"}) + void testExistsImplicitAliases(String keyword) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT a " + keyword + " FROM mytable " + keyword, true); + assertEquals(keyword, select.getSelectItem(0).getAlias().getName()); + assertEquals(keyword, select.getFromItem().getAlias().getName()); + assertEquals("a", assertInstanceOf(Column.class, + select.getSelectItem(0).getExpression()).getColumnName()); + } + + @ParameterizedTest + @ValueSource(strings = {"exists", "ExIsTs", "sample", "extend", "SaMpLe", "ExTeNd"}) + void testExistsCte(String keyword) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "WITH " + keyword + "(x) AS (SELECT 1) SELECT x FROM " + keyword, true); + WithItem withItem = select.getWithItemsList().get(0); + assertEquals(keyword, withItem.getAliasName()); + assertNotNull(withItem.getParenthesedStatement()); + assertNull(withItem.getExpression()); + assertEquals(keyword, assertInstanceOf(Table.class, select.getFromItem()).getName()); + assertSqlCanBeParsedAndDeparsed( + "WITH RECURSIVE " + keyword + "(x) AS (SELECT 1) SELECT * FROM " + keyword, true); + } + + @ParameterizedTest + @ValueSource(strings = {"exists", "ExIsTs", "sample", "extend", "SaMpLe", "ExTeNd"}) + void testExistsExpressionContexts(String keyword) throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT ALL " + keyword + " FROM mytable"); + assertEquals(keyword, assertInstanceOf(Column.class, + select.getSelectItem(0).getExpression()).getColumnName()); + assertSqlCanBeParsedAndDeparsed("SELECT CASE " + keyword + + " WHEN 1 THEN " + keyword + " ELSE 0 END FROM mytable", true); + assertSqlCanBeParsedAndDeparsed("UPDATE " + keyword + " SET a = 1", true); + } + + @ParameterizedTest + @ValueSource(strings = {"exists", "ExIsTs", "sample", "extend", "SaMpLe", "ExTeNd"}) + void testExistsTernaryOperand(String keyword) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT flag ? " + keyword + " : 0 FROM mytable", true); + TernaryExpression ternary = assertInstanceOf(TernaryExpression.class, + select.getSelectItem(0).getExpression()); + assertEquals(keyword, assertInstanceOf(Column.class, ternary.getThenExpression()) + .getColumnName()); + } + + @ParameterizedTest + @ValueSource(strings = {"SAMPLE (10)", "SAMPLE BLOCK (10) SEED (1)", + "SAMPLE 0.1 OFFSET 1000", "USING SAMPLE 10 PERCENT (BERNOULLI)", + "TABLESAMPLE SYSTEM (10)"}) + void testSampleClauseStaysClause(String clause) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM mytable " + clause, true); + Table table = assertInstanceOf(Table.class, select.getFromItem()); + assertNull(table.getAlias()); + SampleClause sample = table.getSampleClause(); + assertNotNull(sample); + assertEquals(" " + clause, sample.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"sample", "extend", "SaMpLe", "ExTeNd"}) + void testSampleExtendPipeExpression(String keyword) throws JSQLParserException { + FromQuery query = (FromQuery) assertSqlCanBeParsedAndDeparsed( + "FROM " + keyword + " |> EXTEND " + keyword + " AS x", true); + SelectPipeOperator operator = assertInstanceOf(SelectPipeOperator.class, + query.getPipeOperators().get(0)); + assertEquals("EXTEND", operator.getOperatorName()); + assertEquals(keyword, assertInstanceOf(Column.class, + operator.getSelectItems().get(0).getExpression()).getColumnName()); + assertSqlCanBeParsedAndDeparsed( + "FROM mytable |> EXTEND " + keyword + "(x) AS x", true); + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT ALL " + keyword + "(x) FROM mytable"); + assertEquals(keyword, assertInstanceOf(Function.class, + select.getSelectItem(0).getExpression()).getName()); + } + + @Test + void testExistsColumnWithOracleJoin() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM mytable WHERE exists(+) = 1", true); + EqualsTo equals = assertInstanceOf(EqualsTo.class, select.getWhere()); + assertEquals("exists", assertInstanceOf(Column.class, equals.getLeftExpression()) + .getColumnName()); + assertEquals(SupportsOldOracleJoinSyntax.ORACLE_JOIN_RIGHT, + ((Column) equals.getLeftExpression()).getOldOracleJoinSyntax()); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT 1", "VALUES (1)"}) + void testExistsUnparenthesizedSubSelect(String query) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT EXISTS " + query, true, p -> p.withUnparenthesizedSubSelects(true)); + assertInstanceOf(ExistsExpression.class, select.getSelectItem(0).getExpression()); + PlainSelect where = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM mytable WHERE EXISTS " + query, true, + p -> p.withUnparenthesizedSubSelects(true)); + assertInstanceOf(ExistsExpression.class, where.getWhere()); + } + + @ParameterizedTest + @ValueSource(strings = {"a", "t.a", "[1]", "+1", "(1)", "(+1)", ":arr", "limit", "offset"}) + void testExistsBareOperandStaysPredicate(String operand) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT EXISTS " + operand + " FROM t", true); + ExistsExpression exists = assertInstanceOf(ExistsExpression.class, + select.getSelectItem(0).getExpression()); + assertEquals(operand, exists.getRightExpression().toString()); + PlainSelect where = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t WHERE EXISTS " + operand, true); + assertInstanceOf(ExistsExpression.class, where.getWhere()); + } + + @Test + void testExistsNamedParameterInTernary() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT flag ? EXISTS :arr : 0 FROM t", true); + TernaryExpression ternary = assertInstanceOf(TernaryExpression.class, + select.getSelectItem(0).getExpression()); + ExistsExpression exists = assertInstanceOf(ExistsExpression.class, + ternary.getThenExpression()); + assertEquals("arr", assertInstanceOf(JdbcNamedParameter.class, + exists.getRightExpression()).getName()); + } + + @Test + void testExistsMapKey() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT MAP {exists: 1}", true); + MapExpression map = assertInstanceOf(MapExpression.class, + select.getSelectItem(0).getExpression()); + assertEquals("exists", assertInstanceOf(Column.class, map.getEntries().get(0).getKey()) + .getColumnName()); + } + + @ParameterizedTest + @ValueSource(strings = {"IN (1, 2)", "NOT IN (1, 2)"}) + void testExistsColumnInCondition(String suffix) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t WHERE exists " + suffix, true); + InExpression in = assertInstanceOf(InExpression.class, select.getWhere()); + assertEquals("exists", assertInstanceOf(Column.class, in.getLeftExpression()) + .getColumnName()); + } + + @ParameterizedTest + @ValueSource(strings = {"ORDER BY id", "ORDER SIBLINGS BY id", "GROUP BY id", "LIMIT 1", + "LIMIT 1.0", "LIMIT ALL", "LIMIT NULL", "LIMIT ?", "LIMIT $1", "LIMIT :n", "LIMIT &n", + "OFFSET 1", "OFFSET 1.0", "OFFSET ?", "OFFSET $1", "OFFSET :n", "OFFSET &n"}) + void testExistsColumnBeforeClause(String suffix) throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM t WHERE exists " + suffix, true); + assertEquals("exists", assertInstanceOf(Column.class, select.getWhere()).getColumnName()); + if (suffix.startsWith("LIMIT")) { + assertNotNull(select.getLimit()); + assertEquals(suffix, select.getLimit().toString().trim()); + } else if (suffix.startsWith("OFFSET")) { + assertNotNull(select.getOffset()); + assertEquals(suffix, select.getOffset().toString().trim()); + } + } + + @Test + void testExistsBeforeNestedTernary() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT flag ? exists : b ? c : d FROM t", true); + TernaryExpression ternary = assertInstanceOf(TernaryExpression.class, + select.getSelectItem(0).getExpression()); + assertEquals("exists", assertInstanceOf(Column.class, ternary.getThenExpression()) + .getColumnName()); + assertInstanceOf(TernaryExpression.class, ternary.getElseExpression()); + PlainSelect mapSelect = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT MAP {exists: b ? c : d}", true); + MapExpression map = assertInstanceOf(MapExpression.class, + mapSelect.getSelectItem(0).getExpression()); + assertEquals("exists", assertInstanceOf(Column.class, map.getEntries().get(0).getKey()) + .getColumnName()); + assertInstanceOf(TernaryExpression.class, map.getEntries().get(0).getValue()); + } + + // ERRORS introduces Exasol's IMPORT/EXPORT error clauses but is an ordinary name elsewhere, + // e.g. a DuckDB column holding the errors of an upstream step. + @Test + public void testErrorsAsIdentifier() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT errors FROM mytable", true); + assertSqlCanBeParsedAndDeparsed("SELECT t.errors AS errors FROM mytable t", true); + assertSqlCanBeParsedAndDeparsed("WITH errors AS (SELECT 1) SELECT * FROM errors", true); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE mytable (errors VARCHAR)", true); + } + + // Dialect-specific clause words (Exasol IMPORT/EXPORT, ClickHouse PREWHERE/SETTINGS, CREATE + // FUNCTION ... RETURNS) are ordinary names in other dialects, e.g. PostgreSQL or DuckDB. + @Test + public void testDialectClauseWordsAsIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed( + "SELECT csv, fbv, file, prewhere, returns, script, settings, verify FROM mytable", + true); + assertSqlCanBeParsedAndDeparsed("SELECT t.file, t.settings FROM mytable t", true); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM settings", true); + assertSqlCanBeParsedAndDeparsed("WITH file AS (SELECT 1) SELECT * FROM file", true); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE mytable (csv VARCHAR, settings JSON)", true); + } + + @Test + public void testClickHouseClausesAfterTable() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT a FROM mytable PREWHERE b = 1 WHERE c = 2", true); + assertSqlCanBeParsedAndDeparsed("SELECT a FROM mytable SETTINGS max_threads = 8", true); + } + + // MySQL 8.4 and PostgreSQL 18 accept these keywords as unquoted column and table names. + public static Stream serverKeywordNames() { + return Stream.of("absent", "any", "between", "current", "exclude", "force", "full", + "grouping", "if", "import", "offset", "only", "prior", "returning", "set", "some", + "sql_no_cache", "unbounded", "unknown", "value", "values", "xmlserialize") + .flatMap(keyword -> Stream.of(Arguments.of(keyword, null), + Arguments.of(keyword, Dialect.MYSQL), + Arguments.of(keyword, Dialect.POSTGRESQL))); + } + + private static Statement assertRoundTrip(String sql, Dialect dialect) + throws JSQLParserException { + Consumer consumer = parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }; + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, consumer); + assertEquals(statement.toString(), + CCJSqlParserUtil.parse(statement.toString(), consumer).toString()); + return statement; + } + + @ParameterizedTest(name = "{0} ({1})") + @MethodSource("serverKeywordNames") + void testServerKeywordAsColumnAndTableName(String keyword, Dialect dialect) + throws JSQLParserException { + CreateTable createTable = (CreateTable) assertRoundTrip( + "CREATE TABLE mytable (id INT, " + keyword + " INT)", dialect); + assertEquals(keyword, createTable.getColumnDefinitions().get(1).getColumnName()); + + Alter alter = (Alter) assertRoundTrip( + "ALTER TABLE mytable ADD COLUMN " + keyword + " INT", dialect); + assertEquals(keyword, + alter.getAlterExpressions().get(0).getColDataTypeList().get(0).getColumnName()); + + // A keyword table name made CREATE TABLE fall back to an UnsupportedStatement + CreateTable namedTable = (CreateTable) assertRoundTrip( + "CREATE TABLE " + keyword + " (a INT)", dialect); + assertEquals(keyword, namedTable.getTable().getName()); + + assertRoundTrip("SELECT " + keyword + ", t." + keyword + " AS " + keyword + + " FROM mytable t WHERE " + keyword + " = 1 ORDER BY " + keyword, dialect); + assertRoundTrip("SELECT a FROM " + keyword + " WHERE a = 1", dialect); + assertRoundTrip("UPDATE mytable SET " + keyword + " = 1", dialect); + assertRoundTrip("INSERT INTO mytable (" + keyword + ") VALUES (1)", dialect); + } + + @Test + void testTableAndColumnKeepTheirOptionalClauses() throws JSQLParserException { + CreateTable createTable = (CreateTable) assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE IF NOT EXISTS if (a INT)", true); + assertTrue(createTable.isIfNotExists()); + assertEquals("if", createTable.getTable().getName()); + + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE IF EXISTS value ADD COLUMN IF NOT EXISTS set INT", true); + assertTrue(alter.isUseTableIfExists()); + assertEquals("value", alter.getTable().getName()); + assertEquals("set", + alter.getAlterExpressions().get(0).getColDataTypeList().get(0).getColumnName()); + } + + @Test + void testJoinAndIndexHintKeywordsStayClauses() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM a FULL JOIN b ON a.id = b.id", true); + assertNull(((Table) select.getFromItem()).getAlias()); + assertTrue(select.getJoins().get(0).isFull()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM a full FULL OUTER JOIN b ON full.id = b.id", true); + assertEquals("full", select.getFromItem().getAlias().getName()); + Join join = select.getJoins().get(0); + assertTrue(join.isFull() && join.isOuter()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM mytable FORCE INDEX (idx) WHERE a = 1", true, + parser -> parser.withDialect(Dialect.MYSQL)); + Table table = (Table) select.getFromItem(); + assertNull(table.getAlias()); + assertNotNull(table.getIndexHint()); + } + + @Test + void testReturningAndAbsentStayClauses() throws JSQLParserException { + Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed( + "DELETE FROM mytable RETURNING id", true); + assertNull(delete.getTable().getAlias()); + assertNotNull(delete.getReturningClause()); + + Insert insert = (Insert) assertSqlCanBeParsedAndDeparsed( + "INSERT INTO mytable SELECT a FROM other RETURNING id", true); + assertNull(((PlainSelect) insert.getSelect()).getFromItem().getAlias()); + assertNotNull(insert.getReturningClause()); + + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT JSON_ARRAY(a ABSENT ON NULL RETURNING JSON) FROM mytable", true); + JsonFunction function = (JsonFunction) select.getSelectItem(0).getExpression(); + assertEquals(1, function.getExpressions().size()); + assertEquals(JsonAggregateOnNullType.ABSENT, function.getOnNullType()); + assertEquals("JSON", function.getReturningType().getDataType()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed("SELECT JSON_ARRAY(RETURNING JSON)", + true); + function = (JsonFunction) select.getSelectItem(0).getExpression(); + assertTrue(function.getExpressions().isEmpty()); + assertEquals("JSON", function.getReturningType().getDataType()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed("SELECT JSON_OBJECT(ABSENT ON NULL)", + true); + function = (JsonFunction) select.getSelectItem(0).getExpression(); + assertTrue(function.getKeyValuePairs().isEmpty()); + assertEquals(JsonAggregateOnNullType.ABSENT, function.getOnNullType()); + } + + @Test + void testModifierAndOperatorKeywordsStayKeywords() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT SQL_NO_CACHE a FROM mytable", true); + assertTrue(select.getMySqlSelectModifiers().contains(MySqlSelectModifier.SQL_NO_CACHE)); + assertEquals("a", ((Column) select.getSelectItem(0).getExpression()).getColumnName()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT PRIOR ename FROM emp CONNECT BY PRIOR empno = mgr", true); + assertInstanceOf(ConnectByPriorOperator.class, select.getSelectItem(0).getExpression()); + EqualsTo connect = (EqualsTo) select.getOracleHierarchical().getConnectExpression(); + assertEquals(SupportsOldOracleJoinSyntax.ORACLE_PRIOR_START, + connect.getOraclePriorPosition()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT SUM(a) OVER (ORDER BY b ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)" + + " FROM mytable", + true); + WindowElement frame = + ((AnalyticExpression) select.getSelectItem(0).getExpression()).getWindowElement(); + assertEquals(WindowOffset.Type.PRECEDING, frame.getRange().getStart().getType()); + assertNull(frame.getRange().getStart().getExpression()); + assertEquals(WindowOffset.Type.CURRENT, frame.getRange().getEnd().getType()); + + select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT XMLSERIALIZE(CONTENT x AS VARCHAR(100)) FROM mytable WHERE a IS NOT UNKNOWN", + true); + assertInstanceOf(XMLSerializeExpr.class, select.getSelectItem(0).getExpression()); + assertInstanceOf(IsUnknownExpression.class, select.getWhere()); + } + + @Test + void testPostgreSqlOnlyStaysKeyword() throws JSQLParserException { + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE ONLY public.mytable ADD COLUMN a INT", true); + assertTrue(alter.isUseOnly()); + assertEquals("public.mytable", alter.getTable().getFullyQualifiedName()); + + PlainSelect select = + (PlainSelect) assertSqlCanBeParsedAndDeparsed("SELECT * FROM ONLY mytable", true); + assertTrue(select.isUsingOnly()); + + CreateIndex createIndex = (CreateIndex) assertSqlCanBeParsedAndDeparsed( + "CREATE INDEX idx ON ONLY mytable (a)", true); + assertTrue(createIndex.isOnly()); + + // Still unsupported forms must not be read as a table named only + for (String sql : new String[] {"DELETE FROM ONLY mytable", + "SELECT * FROM a JOIN ONLY b ON a.id = b.id", "SELECT * FROM a, ONLY b", + "UPDATE a SET x = 1 FROM ONLY b"}) { + assertFalse(readsTableNamedOnly(sql), sql); + } + } + + private static boolean readsTableNamedOnly(String sql) { + try { + return new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse(sql)).stream() + .anyMatch("only"::equalsIgnoreCase); + } catch (JSQLParserException exception) { + return false; + } + } + + @Test + void testExcludeColumnAndPathType() throws JSQLParserException { + CreateTable createTable = (CreateTable) assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE mytable (exclude INT, p path, EXCLUDE USING gist (p WITH &&))", true, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals("exclude", createTable.getColumnDefinitions().get(0).getColumnName()); + assertEquals("path", + createTable.getColumnDefinitions().get(1).getColDataType().getDataType()); + assertEquals(1, createTable.getTableElements(ExcludeConstraint.class).size()); + + // PATH still introduces the path of a JSON_TABLE column without a type + assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM JSON_TABLE(doc, '$' COLUMNS (a PATH '$.a', b INT PATH '$.b')) jt", + true); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/MySqlExplainTest.java b/src/test/java/net/sf/jsqlparser/statement/MySqlExplainTest.java new file mode 100644 index 0000000000..b11c8ca4ee --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/MySqlExplainTest.java @@ -0,0 +1,346 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.UserVariable; +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.Table; +import net.sf.jsqlparser.statement.ExplainStatement.Format; +import net.sf.jsqlparser.statement.ExplainStatement.Option; +import net.sf.jsqlparser.statement.ExplainStatement.OptionType; +import net.sf.jsqlparser.statement.ExplainStatement.TargetKind; +import net.sf.jsqlparser.statement.delete.Delete; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.statement.update.Update; +import net.sf.jsqlparser.statement.upsert.Upsert; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL's EXPLAIN, DESCRIBE and DESC forms. */ +class MySqlExplainTest { + + private static Statement mysql(String sql) throws JSQLParserException { + return assertSqlCanBeParsedAndDeparsed(sql, true, p -> p.withDialect(Dialect.MYSQL)); + } + + private static ExplainStatement explain(String sql) throws JSQLParserException { + return assertInstanceOf(ExplainStatement.class, mysql(sql)); + } + + private static void assertRejected(String sql, Dialect dialect) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)), sql); + } + + @ParameterizedTest + @ValueSource(strings = {"EXPLAIN FORMAT = JSON SELECT * FROM t", + "EXPLAIN FORMAT = TREE UPDATE t SET a = 1", + "EXPLAIN FORMAT = TRADITIONAL DELETE FROM t WHERE a = 1", + "EXPLAIN FORMAT = JSON INSERT INTO t VALUES (1)", + "EXPLAIN FORMAT = JSON REPLACE INTO t VALUES (1)", "EXPLAIN REPLACE INTO t VALUES (1)", + "EXPLAIN FORMAT = TREE TABLE t", "EXPLAIN FORMAT = TREE (SELECT a FROM t)", + "EXPLAIN FORMAT = JSON WITH x AS (SELECT a FROM t) SELECT * FROM x", + "EXPLAIN ANALYZE FORMAT = TREE SELECT * FROM t", + "EXPLAIN ANALYZE FORMAT = JSON SELECT * FROM t", + "EXPLAIN FORMAT = JSON INTO @plan SELECT * FROM t", + "EXPLAIN INTO @plan SELECT * FROM t", "EXPLAIN FOR CONNECTION 1", + "EXPLAIN FORMAT = JSON FOR CONNECTION 7", "EXPLAIN ANALYZE FOR CONNECTION 1", + "EXPLAIN FOR SCHEMA s SELECT * FROM t", + "EXPLAIN FORMAT = TREE FOR DATABASE s UPDATE t SET a = 1", + "EXPLAIN ANALYZE FOR DATABASE s SELECT * FROM t", + "DESC FORMAT = JSON SELECT * FROM t", "DESCRIBE ANALYZE SELECT * FROM t", + "DESC ANALYZE FORMAT = TREE SELECT * FROM t", "DESCRIBE FOR CONNECTION 1", + "DESCRIBE UPDATE t SET a = 1", "DESC INSERT INTO t VALUES (1)", + "DESC DELETE FROM t", "DESCRIBE REPLACE INTO t VALUES (1)", + "DESC VALUES ROW(1)", "DESC FORMAT = JSON INTO @plan SELECT * FROM t"}) + void explainForms(String sql) throws JSQLParserException { + ExplainStatement explain = explain(sql); + assertEquals(sql.substring(0, sql.indexOf(' ')), explain.getKeyword()); + // the forms MySQL alone has are read without a dialect too + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, true).toString()); + } + + @Test + void describeTableStatementNeedsTheMySqlDialect() throws JSQLParserException { + ExplainStatement explain = explain("DESC TABLE t"); + assertEquals("TABLE t", explain.getStatement().toString()); + assertEquals("DESCRIBE TABLE t", explain("DESCRIBE TABLE t").toString()); + assertEquals("DESC TABLE t", + CCJSqlParserUtil.parse("DESC TABLE t", p -> p.withDialect(Dialect.MARIADB)) + .toString()); + // Snowflake's DESCRIBE TABLE t describes a table, so a bare parser takes neither reading + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("DESC TABLE t")); + assertEquals("DESC ANALYZE TABLE t", + CCJSqlParserUtil.parse("DESC ANALYZE TABLE t").toString()); + } + + @Test + void formatOption() throws JSQLParserException { + ExplainStatement explain = explain("EXPLAIN ANALYZE FORMAT = TREE SELECT * FROM t"); + assertEquals(List.of(OptionType.ANALYZE, OptionType.FORMAT), + explain.getOptionList().stream().map(Option::getType) + .collect(java.util.stream.Collectors.toList())); + Option format = explain.getOption(OptionType.FORMAT); + assertEquals("TREE", format.getValue()); + assertTrue(format.isUseEqual()); + assertFalse(explain.getOption(OptionType.ANALYZE).isUseEqual()); + assertEquals(Format.TREE, explain.getFormat()); + assertEquals(TargetKind.STATEMENT, explain.getTargetKind()); + assertInstanceOf(Select.class, explain.getStatement()); + assertNull(explain.getIntoVariable()); + assertNull(explain.getConnectionId()); + + assertNull(explain("EXPLAIN SELECT * FROM t").getFormat()); + assertEquals(Format.JSON, + ((ExplainStatement) CCJSqlParserUtil.parse("EXPLAIN FORMAT JSON SELECT 1")) + .getFormat()); + } + + @ParameterizedTest + @ValueSource(strings = {"EXPLAIN FORMAT=json SELECT 1", "EXPLAIN format = 'JSON' SELECT 1", + "EXPLAIN FORMAT = \"Json\" SELECT 1", "EXPLAIN FORMAT = `json` SELECT 1"}) + void formatNamesAreCaseInsensitiveAndMayBeQuoted(String sql) throws JSQLParserException { + ExplainStatement explain = + (ExplainStatement) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + assertEquals(Format.JSON, explain.getFormat()); + assertEquals("EXPLAIN FORMAT = JSON SELECT 1", explain.toString()); + assertDeparse(explain, "EXPLAIN FORMAT = JSON SELECT 1"); + } + + @Test + void intoVariable() throws JSQLParserException { + ExplainStatement explain = explain("EXPLAIN FORMAT = JSON INTO @plan SELECT * FROM t"); + assertEquals("plan", explain.getIntoVariable().getName()); + assertEquals(Format.JSON, explain.getFormat()); + + explain = (ExplainStatement) CCJSqlParserUtil.parse( + "EXPLAIN FORMAT = JSON INTO @'my plan' SELECT 1", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals("EXPLAIN FORMAT = JSON INTO @'my plan' SELECT 1", explain.toString()); + } + + @Test + void forConnection() throws JSQLParserException { + ExplainStatement explain = explain("EXPLAIN FORMAT = JSON FOR CONNECTION 7"); + assertEquals(TargetKind.CONNECTION, explain.getTargetKind()); + assertEquals(7L, assertInstanceOf(LongValue.class, explain.getConnectionId()).getValue()); + assertNull(explain.getStatement()); + assertNull(explain.getTable()); + + explain = explain("EXPLAIN FOR CONNECTION 0x1F"); + assertInstanceOf(HexValue.class, explain.getConnectionId()); + assertEquals("EXPLAIN FOR CONNECTION 0x1F", explain.toString()); + } + + @Test + void forSchema() throws JSQLParserException { + ExplainStatement explain = explain("EXPLAIN FOR SCHEMA s SELECT * FROM t"); + assertEquals("s", explain.getSchemaName()); + assertTrue(explain.isSchemaKeyword()); + + explain = explain("EXPLAIN FOR DATABASE 'my db' SELECT * FROM t"); + assertEquals("'my db'", explain.getSchemaName()); + assertFalse(explain.isSchemaKeyword()); + } + + @Test + void explainedStatements() throws JSQLParserException { + assertInstanceOf(Update.class, explain("DESCRIBE UPDATE t SET a = 1").getStatement()); + assertInstanceOf(Delete.class, explain("DESC DELETE FROM t").getStatement()); + assertInstanceOf(Upsert.class, + explain("EXPLAIN REPLACE INTO t VALUES (1)").getStatement()); + assertEquals("DESC", explain("DESC ANALYZE SELECT * FROM t").getKeyword()); + } + + @ParameterizedTest + @ValueSource(strings = {"DESCRIBE t a", "DESC t a", "EXPLAIN t a", "DESCRIBE t 'a%'", + "EXPLAIN db.t 'a_'", "DESC t `a b`", "DESCRIBE t 0x61", "DESCRIBE t comment"}) + void tableColumnPattern(String sql) throws JSQLParserException { + Statement statement = mysql(sql); + // DESCRIBE x y could also be Snowflake's DESCRIBE of an object kind + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + assertEquals(sql, CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MARIADB)) + .toString()); + Object pattern = statement instanceof ExplainStatement + ? ((ExplainStatement) statement).getColumnPattern() + : ((DescribeStatement) statement).getColumnPattern(); + String text = sql.split(" ", 3)[2]; + assertEquals(text, pattern.toString()); + Class type = text.startsWith("'") ? StringValue.class + : text.startsWith("0x") ? HexValue.class : Column.class; + assertTrue(type.isInstance(pattern), text); + assertThat(new TablesNamesFinder<>().getTables(statement)).hasSize(1); + } + + @Test + void columnPatternModel() throws JSQLParserException { + DescribeStatement describe = (DescribeStatement) mysql("DESCRIBE t 'a%'"); + assertEquals("t", describe.getTable().getFullyQualifiedName()); + assertEquals("a%", ((StringValue) describe.getColumnPattern()).getValue()); + + ExplainStatement explain = explain("EXPLAIN t a"); + assertEquals(TargetKind.TABLE, explain.getTargetKind()); + assertEquals("a", ((Column) explain.getColumnPattern()).getColumnName()); + assertTrue(explain.getOptionList().isEmpty()); + + assertEquals("DESC t", new DescribeStatement(new Table("t")).setDescribeType("DESC") + .toString()); + assertEquals("DESC t c", new DescribeStatement(new Table("t")).setDescribeType("DESC") + .withColumnPattern(new Column("c")).toString()); + } + + @Test + void existingReadingsAreKept() throws JSQLParserException { + // DESCRIBE of a query and of a table stays DescribeStatement + assertInstanceOf(DescribeStatement.class, mysql("DESC SELECT * FROM t")); + assertInstanceOf(DescribeStatement.class, mysql("DESCRIBE (SELECT a FROM t)")); + for (String table : List.of("DESC analyze", "DESC replace", "DESC format", "DESC t")) { + DescribeStatement describe = (DescribeStatement) mysql(table); + assertNull(describe.getColumnPattern()); + } + // EXPLAIN ANALYZE SELECT keeps its option model, EXPLAIN table its table + ExplainStatement explain = explain("EXPLAIN ANALYZE SELECT * FROM t"); + assertNull(explain.getOption(OptionType.ANALYZE).getValue()); + assertEquals("replace", explain("EXPLAIN replace").getTable().getName()); + // the generic options without an equals sign remain where they were read + assertSqlCanBeParsedAndDeparsed("EXPLAIN FORMAT JSON SELECT * FROM t", true, + p -> p.withDialect(Dialect.MYSQL)); + assertSqlCanBeParsedAndDeparsed("EXPLAIN PLAN FOR SELECT 1", true, + p -> p.withDialect(Dialect.ORACLE)); + assertSqlCanBeParsedAndDeparsed("EXPLAIN (FORMAT JSON) SELECT 1", true, + p -> p.withDialect(Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"EXPLAIN FORMAT = XML SELECT 1", "EXPLAIN FORMAT = TEXT SELECT 1", + "EXPLAIN FORMAT = 'LONG' SELECT 1", "EXPLAIN FORMAT = SELECT 1", + "EXPLAIN FORMAT = JSON ANALYZE SELECT 1", + "EXPLAIN ANALYZE FORMAT = JSON INTO @v SELECT 1", + "EXPLAIN INTO @v FORMAT = JSON SELECT 1", "EXPLAIN FORMAT = JSON INTO @@v SELECT 1", + "EXPLAIN FORMAT = JSON INTO v SELECT 1", "EXPLAIN FOR CONNECTION", + "EXPLAIN FOR CONNECTION -1", "EXPLAIN FOR CONNECTION 1.5", + "EXPLAIN FOR CONNECTION @c", "EXPLAIN FOR SCHEMA s FOR CONNECTION 1", + "EXPLAIN FOR SCHEMA s", "EXPLAIN FORMAT = JSON t", "EXPLAIN FORMAT = JSON", + "DESCRIBE t a b", "DESCRIBE t a.b", "EXPLAIN t a, b", "DESC FOR CONNECTION 1 a"}) + void rejectedForms(String sql) { + assertRejected(sql, Dialect.MYSQL); + } + + @ParameterizedTest + @ValueSource(strings = {"EXPLAIN FORMAT = JSON SELECT 1", "EXPLAIN FOR CONNECTION 1", + "DESCRIBE t a", "EXPLAIN t 'a%'", "DESC FORMAT = JSON SELECT 1", + "DESC UPDATE t SET a = 1", "EXPLAIN REPLACE INTO t VALUES (1)"}) + void otherDialectsAreUnchanged(String sql) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER, + Dialect.H2)) { + assertRejected(sql, dialect); + } + } + + @Test + void summarizeTakesNoColumn() { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("SUMMARIZE t a")); + } + + @Test + void statementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "EXPLAIN FORMAT = JSON SELECT 1; DESCRIBE t a; EXPLAIN FOR CONNECTION 3;\n" + + "DESC t\nCOMMIT;\nDESC t 'a%'; EXPLAIN t", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals(List.of("EXPLAIN FORMAT = JSON SELECT 1", "DESCRIBE t a", + "EXPLAIN FOR CONNECTION 3", "DESC t", "COMMIT", "DESC t 'a%'", "EXPLAIN t"), + statements.stream().map(Object::toString) + .collect(java.util.stream.Collectors.toList())); + assertEquals("DESCRIBE t COMMIT", CCJSqlParserUtil + .parse("DESCRIBE t COMMIT", p -> p.withDialect(Dialect.MYSQL)).toString()); + } + + @Test + void tablesAndFeatures() throws JSQLParserException { + assertThat(TablesNamesFinder.findTables("EXPLAIN FORMAT = JSON SELECT * FROM t")) + .containsExactly("t"); + assertThat(TablesNamesFinder.findTables("EXPLAIN FOR CONNECTION 3")).isEmpty(); + // EXPLAIN table describes the table, as DESCRIBE table does + assertThat(TablesNamesFinder.findTables("EXPLAIN db.t")).containsExactly("db.t"); + + StatementFeatures into = CCJSqlParserUtil + .parse("EXPLAIN FORMAT = JSON INTO @plan SELECT * FROM t").getFeatures(); + assertTrue(into.is(StmtFeature.MODIFIES_SESSION)); + assertFalse(into.returnsResultSet()); + assertTrue(CCJSqlParserUtil.parse("EXPLAIN FOR CONNECTION 3").getFeatures() + .returnsResultSet()); + } + + @Test + void validation() { + FeatureConfiguration config = + new FeatureConfiguration().setValue(Feature.dialect, Dialect.MYSQL.name()); + for (String sql : List.of("EXPLAIN FORMAT = JSON SELECT * FROM t", "DESCRIBE t a", + "EXPLAIN FOR CONNECTION 3", "DESC FORMAT = TREE UPDATE t SET a = 1")) { + assertTrue(new Validation(config, List.of(MySqlVersion.V8_0), sql).validate() + .isEmpty(), sql); + } + assertThat(new Validation(List.of(FeaturesAllowed.SELECT), + "EXPLAIN FORMAT = JSON SELECT * FROM t").validate().get(0).getErrors()) + .anyMatch(error -> error.getMessage().contains(Feature.explain.name())); + } + + @Test + void buildsMySqlForms() throws JSQLParserException { + ExplainStatement explain = new ExplainStatement("EXPLAIN") + .setConnectionId(new LongValue(3)); + explain.addOption(new Option(OptionType.FORMAT).withValue("TREE").withUseEqual(true)); + assertEquals("EXPLAIN FORMAT = TREE FOR CONNECTION 3", explain.toString()); + assertDeparse(explain, "EXPLAIN FORMAT = TREE FOR CONNECTION 3"); + + Statement select = CCJSqlParserUtil.parse("SELECT 1"); + explain.setStatement(select); + assertNull(explain.getConnectionId()); + assertEquals(TargetKind.STATEMENT, explain.getTargetKind()); + explain.setTable(new Table("t")); + assertNull(explain.getStatement()); + assertEquals(TargetKind.TABLE, explain.getTargetKind()); + + ExplainStatement into = new ExplainStatement("DESC") + .withIntoVariable(new UserVariable("plan")).withSchemaName("s") + .withSchemaKeyword(true); + into.setStatement(select); + assertEquals("DESC INTO @plan FOR SCHEMA s SELECT 1", into.toString()); + assertDeparse(into, "DESC INTO @plan FOR SCHEMA s SELECT 1"); + + assertEquals(Format.TREE, Format.from("tree")); + assertNull(Format.find("LONG")); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/MySqlFileFormatTest.java b/src/test/java/net/sf/jsqlparser/statement/MySqlFileFormatTest.java new file mode 100644 index 0000000000..68e8fad265 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/MySqlFileFormatTest.java @@ -0,0 +1,207 @@ +/*- + * #%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; + +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.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.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.statement.load.MySqlLoadDataStatement; +import net.sf.jsqlparser.statement.select.MySqlSelectIntoClause; +import net.sf.jsqlparser.statement.select.Select; +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 MySqlFileFormatTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer NO_DIALECT = parser -> { + }; + + @ParameterizedTest + @ValueSource(strings = { + "SELECT a FROM t INTO OUTFILE '/tmp/o' CHARSET utf8mb4 FIELDS TERMINATED BY ','", + "SELECT a FROM t INTO OUTFILE '/tmp/o' CHARACTER SET 'utf8mb4' " + + "LINES TERMINATED BY '\\n'", + "SELECT a FROM t INTO OUTFILE '/tmp/o' CHARACTER SET binary", + "SELECT a FROM t INTO OUTFILE '/tmp/o' COLUMNS ENCLOSED BY '\"' LINES STARTING BY 'x'", + "SELECT a INTO OUTFILE '/tmp/o' FIELDS ESCAPED BY '^' LINES STARTING BY '>' " + + "TERMINATED BY ';' FROM t"}) + void parsesIntoOutfileClauses(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(MYSQL, NO_DIALECT)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertEquals(sql, deparse(statement)); + } + } + + @Test + void intoOutfileAcceptsSubclausesInAnyOrder() throws JSQLParserException { + String sql = "SELECT a INTO OUTFILE '/tmp/o' FIELDS ESCAPED BY '^' TERMINATED BY ',' " + + "TERMINATED BY ';' LINES TERMINATED BY '\\n' STARTING BY 'x' FROM t"; + String expected = "SELECT a INTO OUTFILE '/tmp/o' FIELDS TERMINATED BY ';' ESCAPED BY '^' " + + "LINES STARTING BY 'x' TERMINATED BY '\\n' FROM t"; + for (Consumer dialect : List.of(MYSQL, NO_DIALECT)) { + Statement statement = CCJSqlParserUtil.parse(sql, dialect); + assertEquals(expected, statement.toString()); + assertEquals(expected, deparse(statement)); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT a INTO OUTFILE '/tmp/o' FIELDS FROM t", + "SELECT a INTO OUTFILE '/tmp/o' LINES FROM t", + "SELECT a INTO OUTFILE '/tmp/o' COLUMNS LINES TERMINATED BY 'x' FROM t", + "SELECT a FROM t INTO OUTFILE '/tmp/o' FIELDS", + "SELECT a FROM t INTO OUTFILE '/tmp/o' LINES", + "SELECT a FROM t INTO OUTFILE '/tmp/o' FIELDS TERMINATED BY ',' CHARSET latin1", + "SELECT a FROM t INTO OUTFILE '/tmp/o' LINES TERMINATED BY 'x' FIELDS ESCAPED BY '^'"}) + void rejectsBareOrMisplacedClauses(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void outfileGettersReadTheSharedFormat() throws JSQLParserException { + MySqlSelectIntoClause into = into("SELECT a FROM t INTO OUTFILE '/tmp/o' CHARSET latin1 " + + "COLUMNS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '^' " + + "LINES STARTING BY 'x' TERMINATED BY ';'"); + MySqlFileFormat format = into.getFileFormat(); + + assertEquals("latin1", into.getCharacterSet()); + assertTrue(into.isUseCharsetKeyword()); + assertEquals(MySqlSelectIntoClause.FieldsKeyword.COLUMNS, into.getFieldsKeyword()); + assertEquals(MySqlFileFormat.FieldsKeyword.COLUMNS, format.getFieldsKeyword()); + assertSame(format.getFieldsTerminatedBy(), into.getFieldsTerminatedBy()); + assertTrue(into.isFieldsOptionallyEnclosed()); + assertSame(format.getFieldsEnclosedBy(), into.getFieldsEnclosedBy()); + assertSame(format.getFieldsEscapedBy(), into.getFieldsEscapedBy()); + assertSame(format.getLinesStartingBy(), into.getLinesStartingBy()); + assertSame(format.getLinesTerminatedBy(), into.getLinesTerminatedBy()); + assertTrue(into.hasFieldsClause()); + assertTrue(into.hasLinesClause()); + + MySqlSelectIntoClause plain = into("SELECT a FROM t INTO OUTFILE '/tmp/o'"); + assertNull(plain.getFileFormat()); + assertNull(plain.getFieldsKeyword()); + assertNull(plain.getFieldsTerminatedBy()); + assertFalse(plain.isFieldsOptionallyEnclosed()); + assertNull(plain.getLinesTerminatedBy()); + assertFalse(plain.hasFieldsClause()); + assertFalse(plain.hasLinesClause()); + } + + @Test + void loadDataAndIntoOutfileShareTheFormat() throws JSQLParserException { + String clauses = "FIELDS TERMINATED BY ',' LINES TERMINATED BY '\\n'"; + MySqlFileFormat outfile = + into("SELECT a FROM t INTO OUTFILE '/tmp/o' " + clauses).getFileFormat(); + MySqlFileFormat load = ((MySqlLoadDataStatement) CCJSqlParserUtil + .parse("LOAD DATA INFILE '/tmp/o' INTO TABLE t " + clauses)).getFileFormat(); + assertEquals(clauses, outfile.toString()); + assertEquals(clauses, load.toString()); + } + + @Test + void legacySettersWriteTheSharedFormat() { + MySqlSelectIntoClause into = new MySqlSelectIntoClause(); + into.setType(MySqlSelectIntoClause.Type.OUTFILE); + into.setFileName(new StringValue("/tmp/o")); + assertNull(into.getFileFormat()); + assertEquals("INTO OUTFILE '/tmp/o'", into.toString()); + + // OPTIONALLY set before the character it applies to still renders + into.setFieldsOptionallyEnclosed(true); + into.setFieldsEnclosedBy(new StringValue("\"")); + into.setFieldsKeyword(MySqlSelectIntoClause.FieldsKeyword.COLUMNS); + into.setLinesTerminatedBy(new StringValue(";")); + into.setCharacterSet("utf8mb4"); + assertEquals(MySqlFileFormat.FieldsKeyword.COLUMNS, + into.getFileFormat().getFieldsKeyword()); + assertEquals("INTO OUTFILE '/tmp/o' CHARACTER SET utf8mb4 COLUMNS OPTIONALLY ENCLOSED BY " + + "'\"' LINES TERMINATED BY ';'", into.toString()); + + into.setFieldsKeyword(null); + into.setUseCharsetKeyword(true); + assertNull(into.getFieldsKeyword()); + assertEquals("INTO OUTFILE '/tmp/o' CHARSET utf8mb4 FIELDS OPTIONALLY ENCLOSED BY '\"' " + + "LINES TERMINATED BY ';'", into.toString()); + + into.withFileFormat(new MySqlFileFormat().withFieldsEscapedBy(new StringValue("^"))); + assertEquals("^", into.getFieldsEscapedBy().getValue()); + assertNull(into.getFieldsEnclosedBy()); + assertEquals("INTO OUTFILE '/tmp/o' CHARSET utf8mb4 FIELDS ESCAPED BY '^'", + into.toString()); + } + + @Test + void rendersEachClauseOnlyWhenSet() { + MySqlFileFormat format = new MySqlFileFormat(); + assertTrue(format.isEmpty()); + assertEquals("", format.toString()); + + format.setLinesStartingBy(new StringValue("x")); + assertFalse(format.hasFieldsClause()); + assertEquals("LINES STARTING BY 'x'", format.toString()); + + format.withFieldsEnclosedBy(new StringValue("\"")).withFieldsOptionallyEnclosed(false) + .withLinesStartingBy(null).withLinesTerminatedBy(new StringValue(";")); + assertEquals("FIELDS ENCLOSED BY '\"' LINES TERMINATED BY ';'", format.toString()); + + // a spelling without a subclause renders as before, though MySQL rejects it + MySqlFileFormat keywordOnly = + new MySqlFileFormat().withFieldsKeyword(MySqlFileFormat.FieldsKeyword.FIELDS); + assertTrue(keywordOnly.hasFieldsClause()); + assertEquals("FIELDS", keywordOnly.toString()); + } + + @Test + void nodesSpanTheIntoClauseAndItsFormat() throws JSQLParserException { + String sql = "SELECT a INTO OUTFILE '/tmp/o' CHARSET latin1 FIELDS TERMINATED BY ',' " + + "LINES TERMINATED BY ';' FROM t"; + MySqlSelectIntoClause into = into(sql); + assertEquals("INTO OUTFILE '/tmp/o' CHARSET latin1 FIELDS TERMINATED BY ',' " + + "LINES TERMINATED BY ';'", text(sql, into)); + assertEquals("FIELDS TERMINATED BY ',' LINES TERMINATED BY ';'", + text(sql, into.getFileFormat())); + assertEquals("';'", text(sql, into.getLinesTerminatedBy())); + } + + private static MySqlSelectIntoClause into(String sql) throws JSQLParserException { + Select select = (Select) assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + return select.getPlainSelect().getMySqlSelectIntoClause(); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + private static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/MySqlPreparedStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/MySqlPreparedStatementTest.java new file mode 100644 index 0000000000..c37fcae318 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/MySqlPreparedStatementTest.java @@ -0,0 +1,220 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.UserVariable; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.execute.Execute; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationError; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL's PREPARE ... FROM, EXECUTE ... USING and DROP PREPARE. */ +class MySqlPreparedStatementTest { + + private static Statement mysql(String sql) throws JSQLParserException { + Statement statement = + assertSqlCanBeParsedAndDeparsed(sql, true, p -> p.withDialect(Dialect.MYSQL)); + // these forms are read without a dialect too + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, true).toString()); + return statement; + } + + private static void assertRejected(String sql, Dialect dialect) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)), sql); + } + + @Test + void prepareFromString() throws JSQLParserException { + PrepareStatement prepare = (PrepareStatement) mysql("PREPARE s FROM 'SELECT ?'"); + assertEquals("s", prepare.getName()); + assertEquals("SELECT ?", + assertInstanceOf(StringValue.class, prepare.getSource()).getValue()); + assertNull(prepare.getStatement()); + assertNull(prepare.getParameterTypes()); + + prepare = (PrepareStatement) CCJSqlParserUtil.parse("PREPARE s FROM \"SELECT 1\"", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals("SELECT 1", ((StringValue) prepare.getSource()).getValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"PREPARE s FROM @sql", "PREPARE s FROM @'the sql'", + "PREPARE `my stmt` FROM @sql"}) + void prepareFromVariable(String sql) throws JSQLParserException { + PrepareStatement prepare = (PrepareStatement) mysql(sql); + assertInstanceOf(UserVariable.class, prepare.getSource()); + assertNull(prepare.getStatement()); + } + + @Test + void prepareSourceAndStatementExcludeEachOther() throws JSQLParserException { + PrepareStatement prepare = (PrepareStatement) mysql("PREPARE s FROM @sql"); + prepare.setStatement(CCJSqlParserUtil.parse("SELECT 1")); + assertNull(prepare.getSource()); + assertEquals("PREPARE s AS SELECT 1", prepare.toString()); + prepare.withSource(new UserVariable("q")); + assertNull(prepare.getStatement()); + assertEquals("PREPARE s FROM @q", prepare.toString()); + assertDeparse(prepare, "PREPARE s FROM @q"); + } + + @Test + void executeUsing() throws JSQLParserException { + Execute execute = (Execute) mysql("EXECUTE s USING @a, @b"); + assertEquals(Execute.ExecType.EXECUTE, execute.getExecType()); + assertEquals("s", execute.getName()); + assertNull(execute.getExprList()); + assertEquals(List.of("a", "b"), execute.getUsingVariables().stream() + .map(UserVariable::getName).collect(Collectors.toList())); + + execute = (Execute) mysql("EXECUTE s USING @'first value'"); + assertEquals(1, execute.getUsingVariables().size()); + assertNull(((Execute) mysql("EXECUTE s")).getUsingVariables()); + + Execute built = new Execute().withName("s").withUsingVariables( + new ExpressionList<>(new UserVariable("x"), new UserVariable("y"))); + assertEquals("EXECUTE s USING @x, @y", built.toString()); + assertDeparse(built, "EXECUTE s USING @x, @y"); + } + + @Test + void dropPrepare() throws JSQLParserException { + DeallocateStatement drop = (DeallocateStatement) mysql("DROP PREPARE s"); + assertEquals(DeallocateStatement.Keyword.DROP, drop.getKeyword()); + assertTrue(drop.isUsingPrepareKeyword()); + assertEquals("s", drop.getName()); + + DeallocateStatement deallocate = (DeallocateStatement) mysql("DEALLOCATE PREPARE s"); + assertEquals(DeallocateStatement.Keyword.DEALLOCATE, deallocate.getKeyword()); + assertTrue(deallocate.isUsingPrepareKeyword()); + + deallocate.withKeyword(DeallocateStatement.Keyword.DROP).setUsingPrepareKeyword(false); + assertEquals("DROP PREPARE s", deallocate.toString()); + deallocate.setKeyword(null); + assertEquals("DEALLOCATE s", deallocate.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"PREPARE s FROM SELECT 1", "PREPARE s FROM 'a' 'b'", + "PREPARE s FROM @@sql", "PREPARE s FROM sql", "PREPARE s (INT) FROM 'SELECT ?'", + "PREPARE s FROM", "EXECUTE s USING 1", "EXECUTE s USING @a,", "EXECUTE s USING", + "EXECUTE s USING @@a", "EXECUTE s USING a", "CALL p USING @a", + "EXECUTE s (1) USING @a", "DROP PREPARE", "DROP PREPARE s t"}) + void rejectedForms(String sql) { + assertRejected(sql, Dialect.MYSQL); + } + + @Test + void otherDialectsAreUnchanged() throws JSQLParserException { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER)) { + assertRejected("PREPARE s FROM 'SELECT 1'", dialect); + assertRejected("EXECUTE s USING @a", dialect); + assertRejected("DROP PREPARE s", dialect); + } + assertSqlCanBeParsedAndDeparsed("PREPARE p(bigint) AS SELECT $1", true, + p -> p.withDialect(Dialect.POSTGRESQL)); + // forms the MySQL dialect read before keep their reading + for (String sql : List.of("DEALLOCATE s", "EXECUTE s (1, 2)", "PREPARE p AS SELECT 1")) { + assertSqlCanBeParsedAndDeparsed(sql, true, p -> p.withDialect(Dialect.MYSQL)); + } + } + + @Test + void statementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "PREPARE s FROM 'SELECT ? + ?'; SET @a = 1; EXECUTE s USING @a, @a;\n" + + "DROP PREPARE s; DEALLOCATE PREPARE s", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals(List.of("PREPARE s FROM 'SELECT ? + ?'", "SET @a = 1", + "EXECUTE s USING @a, @a", "DROP PREPARE s", "DEALLOCATE PREPARE s"), + statements.stream().map(Object::toString).collect(Collectors.toList())); + } + + @Test + void tablesAndFeatures() throws JSQLParserException { + // the tables of a statement held in a string or a variable are unknown + Statement prepare = CCJSqlParserUtil.parse("PREPARE s FROM 'SELECT * FROM t'"); + assertThrows(UnsupportedOperationException.class, + () -> new TablesNamesFinder<>().getTables(prepare)); + Statement execute = CCJSqlParserUtil.parse("EXECUTE s USING @a"); + assertThrows(UnsupportedOperationException.class, + () -> new TablesNamesFinder<>().getTables(execute)); + assertThat(TablesNamesFinder.findTables("DROP PREPARE s")).isEmpty(); + assertThat(TablesNamesFinder.findTables("PREPARE p AS SELECT * FROM t")) + .containsExactly("t"); + + assertTrue(prepare.getFeatures().is(StmtFeature.MODIFIES_SESSION)); + assertFalse(prepare.getFeatures().isOpaque()); + assertTrue(CCJSqlParserUtil.parse("DROP PREPARE s").getFeatures() + .is(StmtFeature.MODIFIES_SESSION)); + assertTrue(execute.getFeatures().isOpaque()); + } + + @Test + void visitorsReachVariables() throws JSQLParserException { + List names = new ArrayList<>(); + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>( + new SelectVisitorAdapter<>(new ExpressionVisitorAdapter() { + @Override + public Void visit(UserVariable variable, S context) { + names.add(variable.getName()); + return null; + } + })); + CCJSqlParserUtil.parse("EXECUTE s USING @a, @b").accept(visitor, null); + CCJSqlParserUtil.parse("PREPARE s FROM @c").accept(visitor, null); + assertEquals(List.of("a", "b", "c"), names); + } + + @Test + void validation() { + for (String sql : List.of("PREPARE s FROM 'SELECT ?'", "PREPARE s FROM @sql", + "EXECUTE s USING @a, @b", "EXECUTE s", "DROP PREPARE s")) { + assertTrue(new Validation(List.of(MySqlVersion.V8_0), sql).validate().isEmpty(), sql); + assertTrue(new Validation(List.of(MariaDbVersion.V10_5_4), sql).validate().isEmpty(), + sql); + } + List errors = new Validation(List.of(FeaturesAllowed.SELECT), + "EXECUTE s USING @a").validate(); + assertThat(errors.get(0).getErrors()).anyMatch( + error -> error.getMessage().contains(Feature.executeUsing.name())); + errors = new Validation(List.of(FeaturesAllowed.SELECT), "PREPARE s FROM @sql").validate(); + assertThat(errors.get(0).getErrors()) + .anyMatch(error -> error.getMessage().contains(Feature.prepare.name())); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/OracleReturningIntoTest.java b/src/test/java/net/sf/jsqlparser/statement/OracleReturningIntoTest.java new file mode 100644 index 0000000000..d6abe7ab12 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/OracleReturningIntoTest.java @@ -0,0 +1,199 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.JdbcNamedParameter; +import net.sf.jsqlparser.expression.JdbcParameter; +import net.sf.jsqlparser.expression.UserVariable; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.delete.Delete; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.merge.Merge; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.update.Update; +import net.sf.jsqlparser.test.TestUtils; +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.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class OracleReturningIntoTest { + static Stream dmlStatements() { + return Stream.of("INSERT INTO employees (id, salary) VALUES (1, 100)", + "UPDATE employees SET salary = salary + 100 WHERE id = 1", + "DELETE FROM employees WHERE id = 1", + "MERGE INTO employees e USING changes c ON (e.id = c.id) " + + "WHEN MATCHED THEN UPDATE SET e.salary = c.salary"); + } + + @ParameterizedTest + @MethodSource("dmlStatements") + void preservesNamedOutputBinds(String dml) throws JSQLParserException { + String sql = dml + " RETURNING id, salary INTO :out_id, :out_salary"; + for (Statement statement : parseBoth(sql)) { + ReturningClause clause = returningClause(statement); + assertFalse(clause.isBulkCollect()); + assertEquals(2, clause.getDataItems().size()); + assertEquals("out_id", + assertInstanceOf(JdbcNamedParameter.class, clause.getDataItems().get(0)) + .getName()); + assertEquals("out_salary", + assertInstanceOf(JdbcNamedParameter.class, clause.getDataItems().get(1)) + .getName()); + roundTrip(statement); + } + } + + @ParameterizedTest + @MethodSource("dmlStatements") + void preservesBulkCollectionAndTargets(String dml) throws JSQLParserException { + for (String targets : List.of("ids, salaries", ":ids, :salaries")) { + String sql = dml + " RETURNING id, salary BULK COLLECT INTO " + targets; + for (Statement statement : parseBoth(sql)) { + ReturningClause clause = returningClause(statement); + assertTrue(clause.isBulkCollect()); + assertEquals(2, clause.getDataItems().size()); + assertEquals(targets.startsWith(":"), + clause.getDataItems().get(0) instanceof JdbcNamedParameter); + assertTrue(statement.toString().contains(" BULK COLLECT INTO ")); + roundTrip(statement); + } + } + } + + @Test + void countsJdbcOutputParametersAfterInputParameters() throws JSQLParserException { + for (Statement statement : parseBoth("UPDATE employees SET salary = ? WHERE id = ? " + + "RETURNING id, salary INTO ?, ?")) { + ReturningClause clause = returningClause(statement); + assertFalse(clause.isBulkCollect()); + assertEquals(3, + assertInstanceOf(JdbcParameter.class, clause.getDataItems().get(0)).getIndex()); + assertEquals(4, + assertInstanceOf(JdbcParameter.class, clause.getDataItems().get(1)).getIndex()); + roundTrip(statement); + } + } + + @ParameterizedTest + @ValueSource(strings = {"out_id", "record.out_id", "@out_id"}) + void preservesExistingOutputTargets(String target) throws JSQLParserException { + Statement statement = CCJSqlParserUtil + .parse("INSERT INTO employees (id) VALUES (1) RETURNING id INTO " + target); + Object actual = returningClause(statement).getDataItems().get(0); + Class expectedType = target.startsWith("@") ? UserVariable.class : Table.class; + assertInstanceOf(expectedType, actual); + assertEquals(target, actual.toString()); + roundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = {"bulk", "AS bulk", "\"bulk\"", "AS collect"}) + void keepsAliasesBeforeBulkCollect(String alias) throws JSQLParserException { + for (Statement statement : parseBoth("UPDATE employees SET salary = 100 " + + "RETURNING salary " + alias + " BULK COLLECT INTO salaries")) { + ReturningClause clause = returningClause(statement); + assertTrue(clause.isBulkCollect()); + assertEquals(alias.replace("AS ", ""), clause.get(0).getAlias().getName()); + roundTrip(statement); + } + } + + @Test + void keepsBulkAndCollectAsOrdinaryIdentifiersAndAliases() throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil + .parse("SELECT bulk, collect, salary bulk, salary collect FROM employees"); + assertEquals("bulk", select.getSelectItem(0).getExpression().toString()); + assertEquals("collect", select.getSelectItem(1).getExpression().toString()); + assertEquals("bulk", select.getSelectItem(2).getAlias().getName()); + assertEquals("collect", select.getSelectItem(3).getAlias().getName()); + roundTrip(select); + } + + @ParameterizedTest + @ValueSource(strings = {"bulk", "collect"}) + void keepsAliasesBeforeOrdinaryInto(String alias) throws JSQLParserException { + for (Statement statement : parseBoth("DELETE FROM employees RETURNING id " + alias + + " INTO out_id")) { + ReturningClause clause = returningClause(statement); + assertFalse(clause.isBulkCollect()); + assertEquals(alias, clause.get(0).getAlias().getName()); + roundTrip(statement); + } + } + + @Test + void allowsChangingCollectionModeThroughTheAst() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse( + "DELETE FROM employees RETURNING id BULK COLLECT INTO ids"); + ReturningClause clause = returningClause(statement); + clause.setBulkCollect(false); + assertFalse(statement.toString().contains("BULK COLLECT")); + roundTrip(statement); + clause.setBulkCollect(true); + assertTrue(statement.toString().contains("BULK COLLECT")); + roundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = {"INTO", "INTO :", "INTO :out_id,", "BULK COLLECT INTO", + "BULK COLLECT INTO ids,", "BULK COLLECT", "INTO :out_id + 1"}) + void rejectsIncompleteClauses(String clause) { + String sql = "DELETE FROM employees RETURNING id " + clause; + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.ORACLE))); + } + + private static List parseBoth(String sql) throws JSQLParserException { + return List.of(TestUtils.assertSqlCanBeParsedAndDeparsed(sql), + CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.ORACLE))); + } + + private static ReturningClause returningClause(Statement statement) { + if (statement instanceof Insert) { + return ((Insert) statement).getReturningClause(); + } + if (statement instanceof Update) { + return ((Update) statement).getReturningClause(); + } + if (statement instanceof Delete) { + return ((Delete) statement).getReturningClause(); + } + return ((Merge) statement).getReturningClause(); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder buffer = new StringBuilder(); + statement.accept(new StatementDeParser(buffer), null); + assertEquals(statement.toString(), buffer.toString()); + Statement reparsed = CCJSqlParserUtil.parse(buffer.toString()); + assertEquals(buffer.toString(), reparsed.toString()); + if (!(statement instanceof PlainSelect)) { + ReturningClause before = returningClause(statement); + ReturningClause after = returningClause(reparsed); + assertEquals(before.isBulkCollect(), after.isBulkCollect()); + assertEquals(before.getDataItems().size(), after.getDataItems().size()); + for (int i = 0; i < before.getDataItems().size(); i++) { + assertEquals(before.getDataItems().get(i).getClass(), + after.getDataItems().get(i).getClass()); + assertEquals(before.getDataItems().get(i).toString(), + after.getDataItems().get(i).toString()); + } + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/PluginStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/PluginStatementTest.java new file mode 100644 index 0000000000..ab00776d4f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/PluginStatementTest.java @@ -0,0 +1,472 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.statement.TransactionStatementTest.assertSpans; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.Arrays; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.parser.ASTNodeAccess; +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.statement.select.PlainSelect; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL INSTALL and UNINSTALL PLUGIN and COMPONENT. */ +class PluginStatementTest { + private static final Dialect[] MYSQL_FAMILY = {Dialect.MYSQL, Dialect.MARIADB, null}; + private static final Dialect[] MYSQL_OR_NONE = {Dialect.MYSQL, null}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + /** + * Parses {@code sql}, which must print as written, and checks the statement span, the deparser, + * the reparse, the feature analysis and the table finder. + */ + private static PluginStatement roundTrip(String sql, Dialect dialect) throws Exception { + PluginStatement statement = assertInstanceOf(PluginStatement.class, parse(sql, dialect)); + assertEquals(sql, statement.toString()); + assertSpans(sql, sql, statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + assertEquals(sql, parse(output.toString(), dialect).toString()); + assertEquals(Set.of(StmtFeature.MODIFIES_SESSION), statement.getFeatures().getCertain()); + assertTrue(statement.getFeatures().getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder<>().getTables((Statement) statement).isEmpty()); + return statement; + } + + // ---- plugins ------------------------------------------------------------------------------- + + @Test + void installPluginNamesThePluginAndItsLibrary() throws Exception { + String sql = "INSTALL PLUGIN myplugin SONAME 'somelib.so'"; + for (Dialect dialect : MYSQL_FAMILY) { + PluginStatement statement = roundTrip(sql, dialect); + assertEquals(PluginStatement.Action.INSTALL, statement.getAction()); + assertEquals(PluginStatement.ObjectType.PLUGIN, statement.getObjectType()); + assertEquals("myplugin", statement.getPluginName()); + assertEquals("somelib.so", statement.getLibrary().getValue()); + assertSpans("'somelib.so'", sql, statement.getLibrary()); + assertTrue(statement.getComponents().isEmpty()); + assertTrue(statement.getVariables().isEmpty()); + } + } + + @Test + void uninstallPluginNamesThePlugin() throws Exception { + for (Dialect dialect : MYSQL_FAMILY) { + PluginStatement statement = roundTrip("UNINSTALL PLUGIN myplugin", dialect); + assertEquals(PluginStatement.Action.UNINSTALL, statement.getAction()); + assertEquals(PluginStatement.ObjectType.PLUGIN, statement.getObjectType()); + assertEquals("myplugin", statement.getPluginName()); + assertNull(statement.getLibrary()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"INSTALL PLUGIN `my plugin` SONAME 'somelib.so'", + "INSTALL PLUGIN rpl_semi_sync_source SONAME \"nosuch_semisync_source.so\"", + "INSTALL PLUGIN plugin SONAME ''", "INSTALL PLUGIN soname SONAME 'x'", + "UNINSTALL PLUGIN `my plugin`", "UNINSTALL PLUGIN plugin", + "UNINSTALL PLUGIN component"}) + void pluginNamesAndLibrariesAreKeptAsWritten(String sql) throws Exception { + roundTrip(sql, Dialect.MYSQL); + PluginStatement lower = + (PluginStatement) parse(sql.toLowerCase(java.util.Locale.ROOT), Dialect.MYSQL); + assertEquals(sql.toLowerCase(java.util.Locale.ROOT), + lower.toString().toLowerCase(java.util.Locale.ROOT)); + } + + // ---- components ---------------------------------------------------------------------------- + + @Test + void installComponentListsUrnsAndVariables() throws Exception { + String sql = "INSTALL COMPONENT 'file://component1', 'file://component2'" + + " SET GLOBAL component1.var1 = 12 + 3, PERSIST component1.var3 = 'x'"; + for (Dialect dialect : MYSQL_OR_NONE) { + PluginStatement statement = roundTrip(sql, dialect); + assertEquals(PluginStatement.Action.INSTALL, statement.getAction()); + assertEquals(PluginStatement.ObjectType.COMPONENT, statement.getObjectType()); + assertNull(statement.getPluginName()); + assertNull(statement.getLibrary()); + assertEquals(Arrays.asList("file://component1", "file://component2"), + statement.getComponents().stream().map(StringValue::getValue) + .collect(Collectors.toList())); + assertSpans("'file://component2'", sql, statement.getComponents().get(1)); + assertEquals(2, statement.getVariables().size()); + ComponentVariable first = statement.getVariables().get(0); + assertEquals(SetScope.GLOBAL, first.getScope()); + assertEquals("component1.var1", first.getName()); + assertEquals(SetStatement.AssignmentOperator.EQUALS, first.getOperator()); + assertSpans("12 + 3", sql, assertInstanceOf(Addition.class, first.getValue())); + ComponentVariable second = statement.getVariables().get(1); + assertEquals(SetScope.PERSIST, second.getScope()); + assertEquals("component1.var3", second.getName()); + assertEquals("x", assertInstanceOf(StringValue.class, second.getValue()).getValue()); + assertEquals("PERSIST component1.var3 = 'x'", second.toString()); + } + } + + @Test + void uninstallComponentListsUrns() throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + PluginStatement statement = + roundTrip("UNINSTALL COMPONENT 'file://component1'", dialect); + assertEquals(PluginStatement.Action.UNINSTALL, statement.getAction()); + assertEquals(PluginStatement.ObjectType.COMPONENT, statement.getObjectType()); + assertEquals(1, statement.getComponents().size()); + assertTrue(statement.getVariables().isEmpty()); + } + assertEquals(2, roundTrip("UNINSTALL COMPONENT 'file://c', 'file://d'", Dialect.MYSQL) + .getComponents().size()); + } + + @ParameterizedTest + @ValueSource(strings = {"INSTALL COMPONENT 'file://component_validate_password'", + "INSTALL COMPONENT 'file://c' SET v = 1", "INSTALL COMPONENT 'file://c' SET c.v := 1", + "INSTALL COMPONENT 'file://c' SET GLOBAL c.v = ON", + "INSTALL COMPONENT 'file://c' SET PERSIST v = OFF, w = 1", + "INSTALL COMPONENT 'file://c' SET DEFAULT.v = 1", + "INSTALL COMPONENT 'file://c' SET GLOBAL DEFAULT.v = 1", + "INSTALL COMPONENT 'file://c' SET persist.v = 1, PERSIST persist.w = 2, persist_only.x = 3", + "INSTALL COMPONENT 'file://c' SET `global` = 1, c.global = 2, c.`default` = 3", + "INSTALL COMPONENT 'file://c' SET v = (1 + 2) * 3, w = CONCAT('a', 'b'), x = NOW(), y = @a + 1, z = @@global.max_connections", + "INSTALL COMPONENT 'file://c' SET v = other, w = a.b, x = NULL, y = true, z = -1.5e3", + "INSTALL COMPONENT 'file://c' SET v = a AND b OR NOT c, w = CASE WHEN 1 THEN 2 ELSE 3 END, x = VALUES(a), y = DEFAULT(a)", + "INSTALL COMPONENT 'file://c', 'file://d' SET GLOBAL v = 1, GLOBAL w = 2, x = 3", + "INSTALL COMPONENT \"file://c\"", "INSTALL COMPONENT ''"}) + void componentFormsOfTheServerGrammarRoundTrip(String sql) throws Exception { + roundTrip(sql, Dialect.MYSQL); + } + + @Test + void variablesKeepScopeNameOperatorAndValue() throws Exception { + String sql = "INSTALL COMPONENT 'file://c' SET c.v := 1, DEFAULT.w = ON, persist.x = 2," + + " PERSIST y = OFF"; + List variables = roundTrip(sql, Dialect.MYSQL).getVariables(); + assertEquals(SetScope.NONE, variables.get(0).getScope()); + assertEquals("c.v", variables.get(0).getName()); + assertEquals(SetStatement.AssignmentOperator.COLON_EQUALS, variables.get(0).getOperator()); + assertEquals(1L, assertInstanceOf(LongValue.class, variables.get(0).getValue()).getValue()); + assertEquals("DEFAULT.w", variables.get(1).getName()); + Column on = assertInstanceOf(Column.class, variables.get(1).getValue()); + assertEquals("ON", on.getColumnName()); + assertSpans("ON", sql, on); + assertEquals(SetScope.NONE, variables.get(2).getScope()); + assertEquals("persist.x", variables.get(2).getName()); + assertEquals(SetScope.PERSIST, variables.get(3).getScope()); + assertEquals("y", variables.get(3).getName()); + } + + // ---- rejected ------------------------------------------------------------------------------ + + @ParameterizedTest + @ValueSource(strings = {"INSTALL PLUGIN myplugin", "INSTALL PLUGIN SONAME 'somelib.so'", + "INSTALL PLUGIN myplugin SONAME somelib", + "INSTALL PLUGIN myplugin SONAME N'somelib.so'", + "INSTALL PLUGIN 'myplugin' SONAME 'somelib.so'", + "INSTALL PLUGIN a.b SONAME 'somelib.so'", + "INSTALL PLUGIN IF NOT EXISTS myplugin SONAME 'somelib.so'", + "INSTALL PLUGIN select SONAME 'x'", "INSTALL SONAME 'somelib.so'", "INSTALL myplugin", + "INSTALL myplugin FROM community", "FORCE INSTALL myplugin", "INSTALL", "UNINSTALL", + "UNINSTALL PLUGIN", "UNINSTALL PLUGIN 'myplugin'", + "UNINSTALL PLUGIN myplugin SONAME 'somelib.so'", "UNINSTALL PLUGIN IF EXISTS myplugin", + "UNINSTALL PLUGIN a, b", "UNINSTALL SONAME 'somelib.so'", "UNINSTALL myplugin", + "INSTALL COMPONENT", "INSTALL COMPONENT component1", "INSTALL COMPONENT 'file://c',", + "INSTALL COMPONENT N'file://c'", "INSTALL COMPONENT X'41'", + "INSTALL COMPONENT 'file://c' 'file://d'", "INSTALL COMPONENT 'file://c' SET", + "INSTALL COMPONENT 'file://c' SET @@GLOBAL.validate_password.length = 12", + "INSTALL COMPONENT 'file://c' SET @v = 1", + "INSTALL COMPONENT 'file://c' SET SESSION v = 1", + "INSTALL COMPONENT 'file://c' SET LOCAL v = 1", + "INSTALL COMPONENT 'file://c' SET PERSIST_ONLY v = 1", + "INSTALL COMPONENT 'file://c' SET global.v = 1", + "INSTALL COMPONENT 'file://c' SET session.v = 1", + "INSTALL COMPONENT 'file://c' SET local.v = 1", + "INSTALL COMPONENT 'file://c' SET `session`.v = 1", + "INSTALL COMPONENT 'file://c' SET GLOBAL global.v = 1", + "INSTALL COMPONENT 'file://c' SET GLOBAL = 1", + "INSTALL COMPONENT 'file://c' SET persist = 1", + "INSTALL COMPONENT 'file://c' SET persist_only = 1", + "INSTALL COMPONENT 'file://c' SET v", + "INSTALL COMPONENT 'file://c' SET v =", "INSTALL COMPONENT 'file://c' SET a.b.c = 1", + "INSTALL COMPONENT 'file://c' SET DEFAULT = 1", + "INSTALL COMPONENT 'file://c' SET v TO 1", + "INSTALL COMPONENT 'file://c' SET GLOBAL PERSIST v = 1", + "INSTALL COMPONENT 'file://c' SET v = DEFAULT", + "INSTALL COMPONENT 'file://c' SET v = ALL", + "INSTALL COMPONENT 'file://c' SET v = ON + 1", + "INSTALL COMPONENT 'file://c' SET v = (SELECT 1)", + "INSTALL COMPONENT 'file://c' SET v = 1 + (SELECT 1)", + "INSTALL COMPONENT 'file://c' SET v = EXISTS (SELECT 1)", + "INSTALL COMPONENT 'file://c' SET v = 1 IN (SELECT 1)", + "INSTALL COMPONENT 'file://c' SET v = (TABLE t)", + "INSTALL COMPONENT 'file://c' SET v = (VALUES ROW(1))", + "INSTALL COMPONENT 'file://c' SET v = 1,", + "INSTALL COMPONENT 'file://c' SET v = 1 w = 2", + "UNINSTALL COMPONENT", "UNINSTALL COMPONENT c", + "UNINSTALL COMPONENT 'file://c' SET v = 1"}) + void mySqlRejectsWhatTheServerRejects(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + } + + @ParameterizedTest + @ValueSource(strings = {"INSTALL COMPONENT 'file://c'", "UNINSTALL COMPONENT 'file://c'", + "INSTALL COMPONENT 'file://c' SET v = 1"}) + void mariaDbHasNoComponents(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MARIADB), sql); + } + + @ParameterizedTest + @ValueSource(strings = {"INSTALL PLUGIN myplugin SONAME 'somelib.so'", + "UNINSTALL PLUGIN myplugin", "INSTALL COMPONENT 'file://c'", + "UNINSTALL COMPONENT 'file://c'"}) + void otherDialectsKeepRejectingTheStatements(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.ORACLE, + Dialect.SQLSERVER}) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"UNINSTALL myplugin", "INSTALL PLUGIN myplugin SONAME", + "INSTALL PLUGIN myplugin SONAME x", "INSTALL COMPONENT 'file://c' SET v = (SELECT 1)", + "UNINSTALL PLUGIN myplugin SONAME 'x'", "UNINSTALL COMPONENT c"}) + void noDialectRejectsMalformedStatements(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, null), sql); + } + + // ---- other readings ------------------------------------------------------------------------ + + @ParameterizedTest + @ValueSource(strings = {"INSTALL plugin", "INSTALL plugin FROM community", "INSTALL component", + "INSTALL component FROM 'http://example.org'", "FORCE INSTALL plugin", + "INSTALL spatial"}) + void duckDbExtensionsKeepTheirReading(String sql) throws Exception { + for (Dialect dialect : new Dialect[] {null, Dialect.ORACLE, Dialect.POSTGRESQL}) { + ExtensionStatement statement = + assertInstanceOf(ExtensionStatement.class, parse(sql, dialect)); + assertEquals(ExtensionStatement.Operation.INSTALL, statement.getOperation()); + assertEquals(sql, statement.toString()); + } + } + + @Test + void statementWordsRemainIdentifiers() throws Exception { + String sql = "SELECT uninstall, plugin, component, soname FROM install"; + for (Dialect dialect : MYSQL_FAMILY) { + PlainSelect select = assertInstanceOf(PlainSelect.class, parse(sql, dialect)); + assertEquals(sql, select.toString()); + assertEquals(Set.of("install"), + new TablesNamesFinder<>().getTables((Statement) select)); + } + assertEquals("CREATE TABLE uninstall (plugin INT, component INT)", + parse("CREATE TABLE uninstall (plugin INT, component INT)", Dialect.MYSQL) + .toString()); + } + + // ---- statement boundaries ------------------------------------------------------------------ + + private static Stream newStatementStarts() { + return Stream.of( + Arguments.of(Dialect.MYSQL, "INSTALL PLUGIN myplugin SONAME 'somelib.so'"), + Arguments.of(Dialect.MARIADB, "UNINSTALL PLUGIN myplugin"), + Arguments.of(null, "UNINSTALL PLUGIN myplugin"), + Arguments.of(Dialect.MYSQL, "INSTALL COMPONENT 'file://c' SET GLOBAL c.v = 1"), + Arguments.of(Dialect.MYSQL, "UNINSTALL COMPONENT 'file://c', 'file://d'"), + Arguments.of(null, "UNINSTALL COMPONENT 'file://c'")); + } + + @ParameterizedTest + @MethodSource("newStatementStarts") + void newStatementStartsEndThePreviousStatement(Dialect dialect, String sql) throws Exception { + // COMMIT on its own line is closed by the next statement start rather than a semicolon + String script = "SELECT 1;\nCOMMIT\n" + sql + "\n;SAVEPOINT sp"; + for (boolean opaque : new boolean[] {false, true}) { + Statements statements = CCJSqlParserUtil.parseStatements(script, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + p.withUnsupportedStatements(opaque); + }); + assertEquals(4, statements.size(), script); + assertEquals("COMMIT", statements.get(1).toString()); + assertInstanceOf(PluginStatement.class, statements.get(2)); + assertEquals(sql, statements.get(2).toString()); + assertSpans(sql, script, (ASTNodeAccess) statements.get(2)); + assertInstanceOf(SavepointStatement.class, statements.get(3)); + } + } + + @Test + void scriptsKeepEachStatement() throws Exception { + String script = "INSTALL COMPONENT 'file://c' SET c.v = 1; SET GLOBAL x = 2;" + + " INSTALL PLUGIN p SONAME 'p.so'; SELECT * FROM t; UNINSTALL PLUGIN p;" + + " UNINSTALL COMPONENT 'file://c'"; + Statements statements = + CCJSqlParserUtil.parseStatements(script, p -> p.withDialect(Dialect.MYSQL)); + assertEquals(6, statements.size()); + assertEquals(1, ((PluginStatement) statements.get(0)).getVariables().size()); + assertInstanceOf(SetStatement.class, statements.get(1)); + assertEquals(Set.of("t"), new TablesNamesFinder<>().getTables(statements.get(3))); + assertEquals(PluginStatement.Action.UNINSTALL, + ((PluginStatement) statements.get(5)).getAction()); + assertEquals(statements.toString(), CCJSqlParserUtil + .parseStatements(statements.toString(), p -> p.withDialect(Dialect.MYSQL)) + .toString()); + } + + // ---- visitors and validation --------------------------------------------------------------- + + @Test + void visitorDispatchPassesContextAndResult() throws Exception { + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(PluginStatement statement, S context) { + return context + ":" + statement.getAction() + " " + statement.getObjectType(); + } + }; + Statement statement = parse("UNINSTALL PLUGIN p", null); + assertEquals("ctx:UNINSTALL PLUGIN", statement.accept(visitor, "ctx")); + assertNull(statement.accept(new StatementVisitorAdapter<>(), null)); + StringBuilder seen = new StringBuilder(); + new StatementVisitorAdapter() { + @Override + public Void visit(PluginStatement plugin, S context) { + seen.append(plugin.getPluginName()); + return null; + } + }.visit((PluginStatement) statement); + assertEquals("p", seen.toString()); + } + + @Test + void expressionsReachTheVisitors() throws Exception { + PluginStatement statement = (PluginStatement) parse( + "INSTALL COMPONENT 'file://c', 'file://d' SET v = a + 1, w = 'x'", Dialect.MYSQL); + StringBuilder seen = new StringBuilder(); + statement.visitExpressions(expression -> seen.append(expression).append('|')); + assertEquals("'file://c'|'file://d'|a + 1|'x'|", seen.toString()); + seen.setLength(0); + ((PluginStatement) parse("INSTALL PLUGIN p SONAME 'p.so'", null)) + .visitExpressions(expression -> seen.append(expression)); + assertEquals("'p.so'", seen.toString()); + ((PluginStatement) parse("UNINSTALL PLUGIN p", null)) + .visitExpressions(expression -> fail("no expression")); + } + + private static boolean isValid(Dialect dialect, String sql, + ValidationCapability... capabilities) { + FeatureConfiguration configuration = new FeatureConfiguration(); + if (dialect != null) { + configuration.setValue(Feature.dialect, dialect.name()); + } + return new Validation(configuration, Arrays.asList(capabilities), sql).validate() + .isEmpty(); + } + + @Test + void validationKnowsWhichServersTakeWhichForm() { + String plugin = "INSTALL PLUGIN p SONAME 'p.so'; UNINSTALL PLUGIN p"; + String component = "INSTALL COMPONENT 'file://c' SET v = 1; UNINSTALL COMPONENT 'file://c'"; + assertTrue(isValid(Dialect.MYSQL, plugin, MySqlVersion.V8_0)); + assertTrue(isValid(Dialect.MYSQL, component, MySqlVersion.V8_0)); + assertTrue(isValid(Dialect.MARIADB, plugin, MariaDbVersion.V10_5_4)); + assertFalse(isValid(null, "UNINSTALL COMPONENT 'file://c'", MariaDbVersion.V10_5_4)); + assertFalse(isValid(null, "UNINSTALL PLUGIN p", PostgresqlVersion.V14)); + assertTrue(isValid(null, plugin, new FeaturesAllowed(Feature.installPlugin))); + assertFalse(isValid(null, component, new FeaturesAllowed(Feature.installPlugin))); + assertTrue(isValid(null, component, new FeaturesAllowed(Feature.installComponent))); + assertFalse(isValid(null, "INSTALL PLUGIN p SONAME 'p.so'", + new FeaturesAllowed(Feature.installExtension))); + } + + // ---- the model ----------------------------------------------------------------------------- + + @Test + void statementsCanBeBuilt() { + PluginStatement install = new PluginStatement(PluginStatement.Action.INSTALL, + PluginStatement.ObjectType.PLUGIN).withPluginName("p") + .withLibrary(new StringValue("'p.so'")); + assertEquals("INSTALL PLUGIN p SONAME 'p.so'", install.toString()); + install.setAction(PluginStatement.Action.UNINSTALL); + install.setLibrary(null); + assertEquals("UNINSTALL PLUGIN p", install.toString()); + + PluginStatement component = new PluginStatement(PluginStatement.Action.INSTALL, + PluginStatement.ObjectType.PLUGIN); + component.setObjectType(PluginStatement.ObjectType.COMPONENT); + component.addComponents(new StringValue("'file://c'"), new StringValue("'file://d'")) + .addVariables( + new ComponentVariable("c.v", new LongValue(1)).withScope(SetScope.PERSIST), + new ComponentVariable("w", new Column("ON")) + .withOperator(SetStatement.AssignmentOperator.COLON_EQUALS)); + assertEquals("INSTALL COMPONENT 'file://c', 'file://d' SET PERSIST c.v = 1, w := ON", + component.toString()); + component.setComponents(new java.util.ArrayList<>(component.getComponents().subList(0, 1))); + component.setVariables(new java.util.ArrayList<>()); + assertEquals("INSTALL COMPONENT 'file://c'", component.toString()); + assertThrows(NullPointerException.class, () -> component.setAction(null)); + assertThrows(NullPointerException.class, () -> component.setObjectType(null)); + assertThrows(NullPointerException.class, () -> component.setComponents(null)); + assertThrows(NullPointerException.class, () -> component.setVariables(null)); + } + + @Test + void componentVariableKeepsItsContract() { + ComponentVariable variable = new ComponentVariable("v", new LongValue(1)); + assertEquals(SetScope.NONE, variable.getScope()); + assertEquals("v = 1", variable.toString()); + variable.setScope(null); + assertEquals(SetScope.NONE, variable.getScope()); + variable.setScope(SetScope.GLOBAL); + variable.setName("c.v"); + variable.setValue(new StringValue("'x'")); + variable.setOperator(SetStatement.AssignmentOperator.COLON_EQUALS); + assertEquals("GLOBAL c.v := 'x'", variable.toString()); + assertThrows(IllegalArgumentException.class, () -> variable.setScope(SetScope.SESSION)); + assertThrows(IllegalArgumentException.class, + () -> variable.setScope(SetScope.PERSIST_ONLY)); + assertThrows(IllegalArgumentException.class, + () -> variable.setOperator(SetStatement.AssignmentOperator.TO)); + assertThrows(IllegalArgumentException.class, () -> variable.setOperator(null)); + assertThrows(NullPointerException.class, () -> variable.setName(null)); + assertThrows(NullPointerException.class, () -> variable.setValue(null)); + assertThrows(NullPointerException.class, () -> new ComponentVariable(null, null)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/PostgreSQLModifyFormsTest.java b/src/test/java/net/sf/jsqlparser/statement/PostgreSQLModifyFormsTest.java new file mode 100644 index 0000000000..70bd156a93 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/PostgreSQLModifyFormsTest.java @@ -0,0 +1,672 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2024 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement; + +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.assertNotNull; +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.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.schema.TableReference; +import net.sf.jsqlparser.statement.delete.Delete; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.merge.Merge; +import net.sf.jsqlparser.statement.merge.MergeDelete; +import net.sf.jsqlparser.statement.merge.MergeDoNothing; +import net.sf.jsqlparser.statement.merge.MergeInsert; +import net.sf.jsqlparser.statement.merge.MergeOperation; +import net.sf.jsqlparser.statement.merge.MergeOperationVisitor; +import net.sf.jsqlparser.statement.merge.MergeOperationVisitorAdapter; +import net.sf.jsqlparser.statement.merge.MergeSide; +import net.sf.jsqlparser.statement.merge.MergeUpdate; +import net.sf.jsqlparser.statement.merge.MergeWhen; +import net.sf.jsqlparser.statement.select.ParenthesedSelect; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.statement.update.Update; +import net.sf.jsqlparser.statement.update.UpdateSet; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL's relation_expr_opt_alias targets, WHERE CURRENT OF, set_clause sources and + * merge_when_clause actions of UPDATE, DELETE and MERGE. + */ +class PostgreSQLModifyFormsTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer MARIADB = + parser -> parser.withDialect(Dialect.MARIADB); + private static final Consumer ORACLE = + parser -> parser.withDialect(Dialect.ORACLE); + + private static final String MERGE = "MERGE INTO t USING s ON t.id = s.id "; + + /** Parses exactly with PostgreSQL and without a dialect; both render the statement again. */ + private static Statement parse(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertEquals(sql, statement.toString()); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), POSTGRESQL).toString()); + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, false).toString()); + return statement; + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder)); + return builder.toString(); + } + + private static void assertRejected(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL), sql); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql), sql); + } + + private static void assertTarget(TableReference target, String name, boolean only, + boolean descendants, boolean parenthesized, String alias) { + assertEquals(name, target.getTable().getFullyQualifiedName()); + assertEquals(only, target.isOnly()); + assertEquals(descendants, target.isIncludeDescendants()); + assertEquals(parenthesized, target.isParenthesized()); + assertEquals(only || descendants, target.hasInheritanceScope()); + Alias tableAlias = target.getTable().getAlias(); + assertEquals(alias, tableAlias == null ? null : tableAlias.getName()); + assertNotNull(target.getTable().getASTNode()); + } + + @ParameterizedTest + @ValueSource(strings = { + "UPDATE ONLY t SET a = 1", + "UPDATE ONLY t AS x SET a = 1", + "UPDATE ONLY t x SET a = 1", + "UPDATE t * SET a = 1", + "UPDATE t * AS x SET a = 1", + "UPDATE t * x SET a = 1", + "UPDATE ONLY (t) SET a = 1", + "UPDATE ONLY (t) AS x SET a = 1", + "UPDATE ONLY (sc.t) x SET a = 1", + "UPDATE ONLY sc.t AS x SET a = 1 FROM u WHERE x.a = u.a RETURNING *", + "UPDATE sc.t * AS x SET a = 1 FROM u WHERE x.a = u.a RETURNING x.a", + "WITH w AS (SELECT 1 AS a) UPDATE ONLY t AS x SET a = w.a FROM w", + "DELETE FROM ONLY t", + "DELETE FROM ONLY t AS x WHERE x.a = 1", + "DELETE FROM ONLY t x WHERE x.a = 1", + "DELETE FROM t * WHERE a = 1", + "DELETE FROM t * AS x WHERE x.a = 1", + "DELETE FROM t * x WHERE x.a = 1", + "DELETE FROM t *", + "DELETE FROM ONLY (t)", + "DELETE FROM ONLY (t) AS x WHERE x.a = 1", + "DELETE FROM ONLY t USING u WHERE t.a = u.a", + "DELETE FROM ONLY t AS x USING u WHERE x.a = u.a RETURNING x.a", + "DELETE FROM sc.t * AS x USING u, s WHERE x.a = u.a RETURNING *", + "WITH w AS (SELECT 1 AS a) DELETE FROM ONLY t AS x USING w WHERE x.a = w.a", + "MERGE INTO ONLY t USING s ON t.id = s.id WHEN MATCHED THEN DELETE", + "MERGE INTO ONLY t AS x USING s ON x.id = s.id WHEN MATCHED THEN DELETE", + "MERGE INTO ONLY (t) x USING s ON x.id = s.id WHEN MATCHED THEN DELETE", + "MERGE INTO t * USING s ON t.id = s.id WHEN MATCHED THEN DELETE", + "MERGE INTO t * x USING s ON x.id = s.id WHEN MATCHED THEN UPDATE SET (a, b) = ROW(1, 2)", + "MERGE INTO t * AS x USING s ON x.id = s.id WHEN MATCHED THEN DO NOTHING" + }) + void inheritanceScopeOfTheTarget(String sql) throws JSQLParserException { + parse(sql); + } + + @Test + void updateTargetModel() throws JSQLParserException { + Update update = (Update) parse("UPDATE ONLY t AS x SET a = 1"); + assertTarget(update.getTableReference(), "t", true, false, false, "x"); + assertTrue(update.getTable().getAlias().isUseAs()); + assertEquals(update.getTableReference().getTable(), update.getTable()); + + update = (Update) parse("UPDATE ONLY (sc.t) x SET a = 1"); + assertTarget(update.getTableReference(), "sc.t", true, false, true, "x"); + assertFalse(update.getTable().getAlias().isUseAs()); + + update = (Update) parse("UPDATE t * SET a = 1"); + assertTarget(update.getTableReference(), "t", false, true, false, null); + + update = (Update) parse("UPDATE t AS x SET a = 1"); + assertTarget(update.getTableReference(), "t", false, false, false, "x"); + + // the star needs no space + update = (Update) CCJSqlParserUtil.parse("UPDATE t* SET a = 1", POSTGRESQL); + assertEquals("UPDATE t * SET a = 1", update.toString()); + } + + @Test + void deleteAndMergeTargetModel() throws JSQLParserException { + Delete delete = (Delete) parse("DELETE FROM ONLY t AS x WHERE x.a = 1"); + assertTarget(delete.getTableReference(), "t", true, false, false, "x"); + assertTrue(delete.isHasFrom()); + assertEquals("x.a = 1", delete.getWhere().toString()); + + delete = (Delete) parse("DELETE FROM sc.t * x USING u WHERE x.a = u.a"); + assertTarget(delete.getTableReference(), "sc.t", false, true, false, "x"); + assertEquals(1, delete.getUsingFromItemList().size()); + + delete = (Delete) parse("DELETE FROM t WHERE a = 1"); + assertTarget(delete.getTableReference(), "t", false, false, false, null); + + Merge merge = (Merge) parse( + "MERGE INTO ONLY (t) x USING s ON x.id = s.id WHEN MATCHED THEN DELETE"); + assertTarget(merge.getTableReference(), "t", true, false, true, "x"); + assertEquals("s", merge.getFromItem().toString()); + + merge = (Merge) parse("MERGE INTO t * USING s ON t.id = s.id WHEN MATCHED THEN DELETE"); + assertTarget(merge.getTableReference(), "t", false, true, false, null); + } + + @Test + void targetsAreBuiltThroughTheModel() { + Update update = new Update().withTable(new Table("t")) + .addUpdateSet(new Column("a"), new LongValue(1)); + assertEquals("UPDATE t SET a = 1", update.toString()); + update.getTableReference().setOnly(true); + assertEquals("UPDATE ONLY t SET a = 1", update.toString()); + assertEquals(update.toString(), deparse(update)); + + // replacing the table keeps the scope + update.setTable(new Table("u").withAlias(new Alias("x", true))); + assertEquals("UPDATE ONLY u AS x SET a = 1", update.toString()); + TableReference descendants = new TableReference(new Table("t")); + descendants.setIncludeDescendants(true); + assertEquals("UPDATE t * SET a = 1", update.withTableReference(descendants).toString()); + assertThrows(NullPointerException.class, () -> update.setTableReference(null)); + + Delete delete = new Delete().withTable(new Table("t")).withHasFrom(true); + assertEquals("DELETE FROM t", delete.toString()); + delete.getTableReference().setParenthesized(true); + assertEquals("DELETE FROM ONLY (t)", delete.toString()); + assertEquals(delete.toString(), deparse(delete)); + assertEquals("DELETE FROM t *", delete.withTableReference(descendants).toString()); + assertThrows(NullPointerException.class, () -> delete.setTableReference(null)); + + Merge merge = new Merge().withTableReference(descendants); + assertEquals("t", merge.getTable().getName()); + assertThrows(NullPointerException.class, () -> merge.setTableReference(null)); + } + + @ParameterizedTest + @ValueSource(strings = { + "UPDATE ONLY t * SET a = 1", + "UPDATE (t) SET a = 1", + "UPDATE ONLY (t *) SET a = 1", + "UPDATE ONLY (t AS x) SET a = 1", + "UPDATE ONLY ONLY t SET a = 1", + "UPDATE ONLY SET a = 1", + "UPDATE t * * SET a = 1", + "UPDATE t AS x * SET a = 1", + "DELETE FROM ONLY t * WHERE a = 1", + "DELETE FROM (t) WHERE a = 1", + "DELETE FROM ONLY (t AS x)", + "DELETE ONLY t", + "DELETE FROM t AS x *", + "MERGE INTO ONLY t * USING s ON t.id = s.id WHEN MATCHED THEN DELETE", + "MERGE ONLY t USING s ON t.id = s.id WHEN MATCHED THEN DELETE" + }) + void rejectedTargets(String sql) { + assertRejected(sql); + } + + @Test + void mySqlHasNoOnlyTargets() throws JSQLParserException { + // MySQL's ONLY is no keyword of UPDATE or DELETE; the forms stay as they were + for (Consumer dialect : Arrays.asList(MYSQL, MARIADB)) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("UPDATE ONLY t SET a = 1", dialect)); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("DELETE FROM ONLY t WHERE a = 1", dialect)); + Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed("DELETE FROM only WHERE a = 1", + false, dialect); + assertEquals("only", delete.getTable().getName()); + assertFalse(delete.getTableReference().isOnly()); + } + Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed("DELETE FROM only", false); + assertEquals("only", delete.getTable().getName()); + + // index hints and multi-table forms keep their readings + Update update = (Update) assertSqlCanBeParsedAndDeparsed( + "UPDATE t AS x USE INDEX (i) SET a = 1", false, MYSQL); + assertEquals(1, update.getTable().getIndexHints().size()); + assertFalse(update.getTableReference().hasInheritanceScope()); + assertSqlCanBeParsedAndDeparsed("UPDATE LOW_PRIORITY IGNORE t, u SET t.a = u.a", false, + MYSQL); + assertSqlCanBeParsedAndDeparsed("DELETE t, u FROM t JOIN u ON t.id = u.id", false, MYSQL); + assertSqlCanBeParsedAndDeparsed("UPDATE OR REPLACE t SET a = 1", false, + parser -> parser.withDialect(Dialect.SQLITE)); + } + + @ParameterizedTest + @ValueSource(strings = { + "UPDATE t SET a = 1 WHERE CURRENT OF c", + "UPDATE t SET a = 1 WHERE CURRENT OF c RETURNING a", + "UPDATE ONLY t AS x SET a = 1 WHERE CURRENT OF c", + "UPDATE t SET a = 1 FROM u WHERE CURRENT OF c", + "UPDATE t SET a = 1 WHERE CURRENT OF \"My Cursor\"", + "UPDATE t SET a = 1 WHERE CURRENT OF current", + "UPDATE t SET (a, b) = (1, 2) WHERE CURRENT OF c", + "DELETE FROM t WHERE CURRENT OF c", + "DELETE FROM t WHERE CURRENT OF c RETURNING *", + "DELETE FROM ONLY t x WHERE CURRENT OF c", + "DELETE FROM t USING u WHERE CURRENT OF c" + }) + void whereCurrentOf(String sql) throws JSQLParserException { + parse(sql); + // the positioned forms are standard SQL + assertSqlCanBeParsedAndDeparsed(sql, false, ORACLE); + } + + @Test + void whereCurrentOfModel() throws JSQLParserException { + Update update = (Update) parse("UPDATE t SET a = 1 WHERE CURRENT OF c RETURNING a"); + assertEquals("c", update.getCursorName()); + assertNull(update.getWhere()); + assertNotNull(update.getReturningClause()); + + Delete delete = (Delete) parse("DELETE FROM t WHERE CURRENT OF \"My Cursor\""); + assertEquals("\"My Cursor\"", delete.getCursorName()); + assertNull(delete.getWhere()); + + // a column named current is still a condition + update = (Update) parse("UPDATE t SET a = 1 WHERE current = 1"); + assertNull(update.getCursorName()); + assertEquals("current = 1", update.getWhere().toString()); + delete = (Delete) parse("DELETE FROM t WHERE current"); + assertNull(delete.getCursorName()); + + update = new Update().withTable(new Table("t")) + .addUpdateSet(new Column("a"), new LongValue(1)).withCursorName("c"); + assertEquals("UPDATE t SET a = 1 WHERE CURRENT OF c", update.toString()); + assertEquals(update.toString(), deparse(update)); + delete = new Delete().withTable(new Table("t")).withHasFrom(true).withCursorName("c"); + assertEquals("DELETE FROM t WHERE CURRENT OF c", delete.toString()); + assertEquals(delete.toString(), deparse(delete)); + delete.setCursorName(null); + assertEquals("DELETE FROM t", delete.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "UPDATE t SET a = 1 WHERE CURRENT OF c AND a = 1", + "UPDATE t SET a = 1 WHERE CURRENT OF sc.c", + "UPDATE t SET a = 1 WHERE CURRENT OF", + "UPDATE t SET a = 1 WHERE CURRENT c", + "UPDATE t SET a = 1 WHERE CURRENT OF 'c'", + "UPDATE t SET a = 1 WHERE a = 1 AND CURRENT OF c", + "UPDATE t SET a = 1 WHERE CURRENT OF c WHERE a = 1", + "DELETE FROM t WHERE CURRENT OF c OR a = 1", + "DELETE FROM t WHERE CURRENT OF sc.c", + "DELETE FROM t WHERE CURRENT OF", + "SELECT * FROM t WHERE CURRENT OF c", + "MERGE INTO t USING s ON t.id = s.id WHEN MATCHED THEN DELETE WHERE CURRENT OF c" + }) + void rejectedCursorForms(String sql) { + assertRejected(sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "UPDATE t SET a = DEFAULT", + "UPDATE t SET (a, b) = (1, 2)", + "UPDATE t SET (a, b) = ROW(1, 2)", + "UPDATE t SET (a, b) = ROW(1, DEFAULT)", + "UPDATE t SET (a, b) = (DEFAULT, DEFAULT)", + "UPDATE t SET (a, b) = (SELECT 1, 2)", + "UPDATE t SET (a, b) = (SELECT s.a, s.b FROM s WHERE s.id = t.id)", + "UPDATE t SET (a) = (1)", + "UPDATE t SET (a) = ROW(1)", + "UPDATE t SET (a) = 1", + "UPDATE t SET (a) = (SELECT 1)", + "UPDATE t SET (a) = DEFAULT", + "UPDATE t SET a = 1, (b, c) = ROW(2, 3), d = DEFAULT", + "UPDATE t SET (a, b) = ROW(1, 2), (c, d) = (3, 4)", + "UPDATE t SET (a, b) = (SELECT 1, 2), c = 3", + "UPDATE t SET (arr[1], a) = ROW(1, 2)", + "UPDATE t SET (arr[1][2], arr[1:2]) = ROW(1, 2)", + "UPDATE t SET (a, b) = ((SELECT 1, 2))", + "UPDATE t SET (a, b) = 1", + "UPDATE t SET (a, b) = f(1)", + "UPDATE t SET (a, b) = DEFAULT", + "UPDATE t SET (a, b) = ROW(1, 2) || ROW(3, 4)", + "UPDATE t SET a = ROW(1, 2)", + "MERGE INTO t USING s ON t.id = s.id WHEN MATCHED THEN UPDATE SET (a, b) = ROW(s.a, DEFAULT), c = DEFAULT", + "MERGE INTO t USING s ON t.id = s.id WHEN MATCHED THEN UPDATE SET (a, b) = (SELECT 1, 2)", + "INSERT INTO t VALUES (1, 2) ON CONFLICT (id) DO UPDATE SET (a, b) = ROW(1, 2)" + }) + void setClauseSources(String sql) throws JSQLParserException { + parse(sql); + } + + @Test + void setClauseModel() throws JSQLParserException { + Update update = (Update) parse("UPDATE t SET a = 1, (b, c) = ROW(2, DEFAULT), d = DEFAULT"); + List sets = update.getUpdateSets(); + assertEquals(3, sets.size()); + assertEquals("a", sets.get(0).getColumn(0).getColumnName()); + + // ROW(...) is one source for the column list, the function it is in other expressions + UpdateSet row = sets.get(1); + assertInstanceOf(ParenthesedExpressionList.class, row.getColumns()); + assertEquals(2, row.getColumns().size()); + assertEquals(1, row.getValues().size()); + assertFalse(row.getValues() instanceof ParenthesedExpressionList); + Function constructor = assertInstanceOf(Function.class, row.getValue(0)); + assertEquals("ROW", constructor.getName()); + assertEquals(2, constructor.getParameters().size()); + assertNotNull(row.getColumn(0).getASTNode()); + assertEquals("d = DEFAULT", sets.get(2).toString()); + + // a parenthesized list keeps one value per column, a sub-select is one value + update = (Update) parse("UPDATE t SET (a, b) = (1, 2), (c, d) = (SELECT 3, 4)"); + assertInstanceOf(ParenthesedExpressionList.class, + update.getUpdateSets().get(0).getValues()); + assertEquals(2, update.getUpdateSets().get(0).getValues().size()); + assertInstanceOf(ParenthesedSelect.class, update.getUpdateSets().get(1).getValue(0)); + + // other dialects read ROW(...) as well + assertSqlCanBeParsedAndDeparsed("UPDATE t SET (a, b) = ROW(1, 2)", false, ORACLE); + assertSqlCanBeParsedAndDeparsed("UPDATE t SET (a, b) = ROW(1, 2)", false, MYSQL); + } + + @ParameterizedTest + @ValueSource(strings = { + "UPDATE t SET (a, b) = ROW 1, 2", + "UPDATE t SET () = ROW(1, 2)", + "UPDATE t SET (a, b) ROW(1, 2)", + "UPDATE t SET (a, b) = ROW(1, 2),", + "UPDATE t SET (a, b) = ", + "UPDATE t SET ROW(a, b) = ROW(1, 2)", + "UPDATE t SET (a, (b)) = ROW(1, 2)", + "UPDATE t SET (a + 1) = ROW(1)", + "UPDATE t SET (a, 1) = DEFAULT" + }) + void rejectedSetClauses(String sql) { + assertRejected(sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "WHEN MATCHED THEN DO NOTHING", + "WHEN MATCHED AND t.a > 1 THEN DO NOTHING", + "WHEN NOT MATCHED THEN DO NOTHING", + "WHEN NOT MATCHED AND s.a > 1 THEN DO NOTHING", + "WHEN NOT MATCHED BY SOURCE THEN DO NOTHING", + "WHEN NOT MATCHED BY SOURCE AND t.a > 1 THEN DO NOTHING", + "WHEN NOT MATCHED BY TARGET THEN DO NOTHING", + "WHEN NOT MATCHED BY SOURCE THEN DELETE", + "WHEN NOT MATCHED BY SOURCE THEN UPDATE SET a = 1", + "WHEN NOT MATCHED BY TARGET THEN INSERT (id) VALUES (s.id)", + "WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN INSERT DEFAULT VALUES" + + " WHEN NOT MATCHED BY SOURCE THEN DELETE", + "WHEN NOT MATCHED THEN INSERT DEFAULT VALUES", + "WHEN NOT MATCHED BY TARGET AND s.a > 1 THEN INSERT DEFAULT VALUES", + "WHEN NOT MATCHED THEN INSERT OVERRIDING SYSTEM VALUE VALUES (1, 2)", + "WHEN NOT MATCHED THEN INSERT OVERRIDING USER VALUE VALUES (1, 2)", + "WHEN NOT MATCHED THEN INSERT (id, a) OVERRIDING SYSTEM VALUE VALUES (1, 2)", + "WHEN NOT MATCHED THEN INSERT (id, a) OVERRIDING USER VALUE VALUES (1, 2)", + "WHEN MATCHED THEN DO NOTHING RETURNING merge_action()" + }) + void mergeWhenClauses(String clauses) throws JSQLParserException { + parse(MERGE + clauses); + } + + @Test + void mergeDoNothingModel() throws JSQLParserException { + Merge merge = (Merge) parse(MERGE + "WHEN MATCHED AND t.a > 1 THEN DO NOTHING" + + " WHEN NOT MATCHED AND s.a > 2 THEN DO NOTHING" + + " WHEN NOT MATCHED BY SOURCE AND t.a > 3 THEN DO NOTHING" + + " WHEN NOT MATCHED BY TARGET AND s.a > 1 THEN DO NOTHING" + + " WHEN NOT MATCHED BY SOURCE AND t.a > 4 THEN DELETE" + + " WHEN NOT MATCHED BY SOURCE THEN UPDATE SET a = 1" + + " WHEN MATCHED THEN DELETE" + + " WHEN NOT MATCHED BY TARGET AND s.a > 5 THEN INSERT (id) VALUES (s.id)" + + " WHEN NOT MATCHED THEN INSERT (id) VALUES (s.id)"); + List operations = merge.getOperations(); + assertEquals(9, operations.size()); + + MergeDoNothing matched = assertInstanceOf(MergeDoNothing.class, operations.get(0)); + assertEquals(MergeWhen.MATCHED, matched.getWhen()); + assertEquals("t.a > 1", matched.getAndPredicate().toString()); + assertEquals(" WHEN MATCHED AND t.a > 1 THEN DO NOTHING", matched.toString()); + assertEquals(MergeWhen.NOT_MATCHED, ((MergeDoNothing) operations.get(1)).getWhen()); + assertEquals("s.a > 2", ((MergeDoNothing) operations.get(1)).getAndPredicate().toString()); + assertEquals(MergeWhen.NOT_MATCHED_BY_SOURCE, + ((MergeDoNothing) operations.get(2)).getWhen()); + assertEquals(MergeWhen.NOT_MATCHED_BY_TARGET, + ((MergeDoNothing) operations.get(3)).getWhen()); + + // the other actions derive the condition from their side + assertEquals(MergeWhen.NOT_MATCHED_BY_SOURCE, ((MergeDelete) operations.get(4)).getWhen()); + assertEquals(MergeWhen.NOT_MATCHED_BY_SOURCE, ((MergeUpdate) operations.get(5)).getWhen()); + assertEquals(MergeWhen.MATCHED, ((MergeDelete) operations.get(6)).getWhen()); + assertEquals(MergeWhen.NOT_MATCHED_BY_TARGET, ((MergeInsert) operations.get(7)).getWhen()); + assertEquals(MergeWhen.NOT_MATCHED, ((MergeInsert) operations.get(8)).getWhen()); + assertEquals(MergeWhen.MATCHED, new MergeUpdate().getWhen()); + + assertEquals(MergeSide.SOURCE, MergeWhen.NOT_MATCHED_BY_SOURCE.getSide()); + assertEquals(MergeSide.TARGET, MergeWhen.NOT_MATCHED_BY_TARGET.getSide()); + assertNull(MergeWhen.MATCHED.getSide()); + assertNull(MergeWhen.NOT_MATCHED.getSide()); + assertEquals("WHEN NOT MATCHED BY SOURCE", MergeWhen.NOT_MATCHED_BY_SOURCE.toString()); + + MergeDoNothing built = new MergeDoNothing().withWhen(MergeWhen.NOT_MATCHED) + .withAndPredicate(new Column("a")); + assertEquals(" WHEN NOT MATCHED AND a THEN DO NOTHING", built.toString()); + assertEquals(MergeWhen.MATCHED, new MergeDoNothing().getWhen()); + assertThrows(NullPointerException.class, () -> built.setWhen(null)); + + // DO NOTHING is neither the standard update nor the insert clause + merge = (Merge) parse(MERGE + "WHEN MATCHED THEN DO NOTHING"); + assertNull(merge.getMergeUpdate()); + assertNull(merge.getMergeInsert()); + } + + @Test + void mergeInsertModel() throws JSQLParserException { + Merge merge = (Merge) parse(MERGE + + "WHEN NOT MATCHED AND s.a > 1 THEN INSERT DEFAULT VALUES" + + " WHEN NOT MATCHED AND s.a > 2 THEN INSERT (id, a) OVERRIDING USER VALUE VALUES (1, 2)" + + " WHEN NOT MATCHED THEN INSERT OVERRIDING SYSTEM VALUE VALUES (1, 2)"); + MergeInsert defaults = (MergeInsert) merge.getOperations().get(0); + assertTrue(defaults.isDefaultValues()); + assertNull(defaults.getValues()); + assertNull(defaults.getColumns()); + assertEquals(Insert.OverridingMode.NONE, defaults.getOverridingMode()); + + MergeInsert user = (MergeInsert) merge.getOperations().get(1); + assertFalse(user.isDefaultValues()); + assertEquals(Insert.OverridingMode.USER, user.getOverridingMode()); + assertEquals(2, user.getColumns().size()); + assertEquals(2, user.getValues().size()); + + MergeInsert system = (MergeInsert) merge.getOperations().get(2); + assertEquals(Insert.OverridingMode.SYSTEM, system.getOverridingMode()); + assertNull(system.getColumns()); + + MergeInsert built = new MergeInsert(); + assertEquals(" WHEN NOT MATCHED THEN INSERT DEFAULT VALUES", built.toString()); + built.withOverridingMode(Insert.OverridingMode.SYSTEM).addColumns(new Column("id")) + .withValues(new ParenthesedExpressionList(new LongValue(1))); + assertThrows(NullPointerException.class, () -> built.setOverridingMode(null)); + } + + @ParameterizedTest + @ValueSource(strings = { + "WHEN MATCHED THEN DO", + "WHEN MATCHED THEN NOTHING", + "WHEN MATCHED THEN DO NOTHING WHERE t.a = 1", + "WHEN MATCHED THEN DO UPDATE SET a = 1", + "WHEN MATCHED THEN INSERT DEFAULT VALUES", + "WHEN MATCHED THEN INSERT VALUES (1)", + "WHEN NOT MATCHED THEN UPDATE SET a = 1", + "WHEN NOT MATCHED THEN DELETE", + "WHEN NOT MATCHED BY TARGET THEN DELETE", + "WHEN NOT MATCHED BY SOURCE THEN INSERT VALUES (1)", + "WHEN NOT MATCHED BY SOURCE THEN INSERT DEFAULT VALUES", + "WHEN MATCHED BY SOURCE THEN DELETE", + "WHEN NOT MATCHED BY foo THEN DO NOTHING", + "WHEN NOT MATCHED THEN INSERT (id) DEFAULT VALUES", + "WHEN NOT MATCHED THEN INSERT OVERRIDING SYSTEM VALUE DEFAULT VALUES", + "WHEN NOT MATCHED THEN INSERT OVERRIDING VALUE VALUES (1)", + "WHEN NOT MATCHED THEN INSERT OVERRIDING SYSTEM VALUES (1)", + "WHEN NOT MATCHED THEN INSERT OVERRIDING SYSTEM VALUE (id) VALUES (1)", + "WHEN NOT MATCHED THEN INSERT DEFAULT VALUES (1)", + "WHEN NOT MATCHED THEN INSERT DEFAULT VALUES WHERE s.a = 1", + "WHEN NOT MATCHED THEN INSERT VALUES (1), (2)", + "WHEN NOT MATCHED THEN INSERT (id) SELECT 1" + }) + void rejectedMergeClauses(String clauses) { + assertThrows(Exception.class, () -> CCJSqlParserUtil.parse(MERGE + clauses, POSTGRESQL), + clauses); + assertThrows(Exception.class, () -> CCJSqlParserUtil.parse(MERGE + clauses), clauses); + } + + @Test + void otherMergeDialectsKeepTheirClauses() throws JSQLParserException { + Merge merge = (Merge) assertSqlCanBeParsedAndDeparsed( + "MERGE INTO t USING s ON (t.id = s.id) WHEN MATCHED THEN UPDATE SET a = 1" + + " WHERE t.a = 2 DELETE WHERE t.a = 3" + + " WHEN NOT MATCHED THEN INSERT (id) VALUES (s.id) WHERE s.a = 2", + true, ORACLE); + assertNotNull(merge.getMergeUpdate().getDeleteWhereCondition()); + assertNotNull(merge.getMergeInsert().getWhereCondition()); + assertFalse(merge.getMergeInsert().isDefaultValues()); + assertFalse(merge.getTableReference().hasInheritanceScope()); + + assertSqlCanBeParsedAndDeparsed( + "MERGE INTO t AS x WITH (HOLDLOCK) USING s ON x.id = s.id" + + " WHEN NOT MATCHED BY TARGET THEN INSERT (id) VALUES (s.id)" + + " WHEN NOT MATCHED BY SOURCE THEN DELETE OUTPUT deleted.id", + true, parser -> parser.withDialect(Dialect.SQLSERVER)); + } + + @Test + void visitorsReachTheDoNothingPredicate() throws JSQLParserException { + Merge merge = (Merge) CCJSqlParserUtil.parse(MERGE + + "WHEN MATCHED AND t.a IN (SELECT a FROM u) THEN DO NOTHING" + + " WHEN NOT MATCHED THEN INSERT DEFAULT VALUES", POSTGRESQL); + + List columns = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(Column column, S context) { + columns.add(column.getFullyQualifiedName()); + return super.visit(column, context); + } + }; + merge.getOperations().get(0).accept(new MergeOperationVisitorAdapter<>(expressions), null); + assertEquals(Arrays.asList("t.a"), columns); + merge.getOperations().get(1).accept(new MergeOperationVisitorAdapter<>(expressions), null); + merge.accept(new StatementVisitorAdapter(new SelectVisitorAdapter<>(expressions)), + null); + + // a visitor written before DO NOTHING existed skips the action + MergeOperationVisitor legacy = new MergeOperationVisitor() { + @Override + public String visit(MergeDelete mergeDelete, S context) { + return "delete"; + } + + @Override + public String visit(MergeUpdate mergeUpdate, S context) { + return "update"; + } + + @Override + public String visit(MergeInsert mergeInsert, S context) { + return "insert"; + } + }; + assertNull(merge.getOperations().get(0).accept(legacy, null)); + assertEquals("insert", merge.getOperations().get(1).accept(legacy, null)); + + assertEquals(Arrays.asList("s", "t", "u"), + sorted(new TablesNamesFinder().getTables((Statement) merge))); + } + + private static List sorted(Collection names) { + List list = new ArrayList<>(names); + Collections.sort(list); + return list; + } + + @Test + void tablesNamesFinder() throws JSQLParserException { + assertEquals(Arrays.asList("sc.t", "u"), sorted(TablesNamesFinder.findTables( + "UPDATE ONLY sc.t AS x SET (a, b) = ROW(1, (SELECT max(a) FROM u))" + + " WHERE CURRENT OF c"))); + assertEquals(Arrays.asList("t", "u"), sorted(TablesNamesFinder.findTables( + "DELETE FROM t * AS x USING u WHERE CURRENT OF c"))); + assertEquals(Arrays.asList("s", "t"), sorted(TablesNamesFinder.findTables( + "MERGE INTO ONLY (t) x USING s ON x.id = s.id WHEN NOT MATCHED THEN DO NOTHING"))); + } + + @Test + void statementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + MERGE + "WHEN MATCHED THEN DO NOTHING; " + + "UPDATE t SET (a, b) = ROW(1, 2) WHERE CURRENT OF c; " + + "DELETE FROM ONLY t x WHERE CURRENT OF c; " + + MERGE + "WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; " + + "DO $$ BEGIN NULL; END $$; " + + "UPDATE t * SET a = DEFAULT", + POSTGRESQL); + assertEquals(6, statements.size()); + assertInstanceOf(Merge.class, statements.get(0)); + assertEquals("c", ((Update) statements.get(1)).getCursorName()); + assertEquals("c", ((Delete) statements.get(2)).getCursorName()); + assertTrue(((MergeInsert) ((Merge) statements.get(3)).getOperations().get(0)) + .isDefaultValues()); + assertTrue(((Update) statements.get(5)).getTableReference().isIncludeDescendants()); + } + + @Test + void validation() { + ValidationTestAsserts.validateNoErrors("UPDATE ONLY t AS x SET (a, b) = ROW(1, 2)", 1, + PostgresqlVersion.V14); + ValidationTestAsserts.validateNoErrors("DELETE FROM ONLY t x WHERE CURRENT OF c", 1, + PostgresqlVersion.V14); + ValidationTestAsserts.validateNoErrors( + MERGE + "WHEN MATCHED AND t.a > 1 THEN DO NOTHING" + + " WHEN NOT MATCHED THEN INSERT DEFAULT VALUES", + 1, FeaturesAllowed.DML); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/PostgreSqlCopyTest.java b/src/test/java/net/sf/jsqlparser/statement/PostgreSqlCopyTest.java index 451e4a6906..a2cfbba0f3 100644 --- a/src/test/java/net/sf/jsqlparser/statement/PostgreSqlCopyTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/PostgreSqlCopyTest.java @@ -9,15 +9,26 @@ */ package net.sf.jsqlparser.statement; +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.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CopyLegacyOption.Kind; +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; @@ -87,6 +98,192 @@ void rejectsMalformedWithOptions(String options) { assertThrows(JSQLParserException.class, () -> parse("COPY users TO STDOUT " + options)); } + @ParameterizedTest + @ValueSource(strings = { + "COPY t TO STDOUT CSV HEADER", + "COPY t FROM STDIN WITH CSV HEADER DELIMITER ';' NULL ''", + "COPY t (a, b) TO '/tmp/x.csv' WITH DELIMITER AS ',' CSV QUOTE AS '\"' ESCAPE AS '\\' " + + "FORCE QUOTE a, b", + "COPY t FROM STDIN CSV FORCE NOT NULL a", + "COPY t FROM STDIN CSV FORCE NOT NULL *", + "COPY t FROM STDIN CSV FORCE NULL a, b", + "COPY t FROM STDIN CSV FORCE NULL *", + "COPY t TO STDOUT BINARY", + "COPY t TO STDOUT CSV FORCE QUOTE *", + "COPY t TO STDOUT CSV FORCE QUOTE \"A b\", c", + "COPY t TO STDOUT CSV FORCE QUOTE \"all\", header, quote", + "COPY t FROM STDIN WITH BINARY", + "COPY t FROM STDIN FREEZE CSV", + "COPY t FROM STDIN ENCODING 'UTF8'", + "COPY t FROM STDIN NULL AS 'x' DELIMITER AS '|'", + "COPY t TO STDOUT HEADER CSV", + "COPY t TO STDOUT DELIMITER '|' CSV", + "COPY t TO STDOUT QUOTE '\"' ESCAPE E'\\\\'", + "COPY (SELECT a FROM t) TO STDOUT WITH CSV HEADER", + "COPY BINARY t TO STDOUT", + "COPY BINARY t (a, b) FROM '/tmp/x'", + "COPY BINARY s.t TO STDOUT WITH ENCODING 'UTF8'", + "COPY BINARY t FROM STDIN FREEZE"}) + void parsesTheOptionSyntaxFromBefore90(String sql) throws JSQLParserException { + for (CopyStatement copy : new CopyStatement[] {parse(sql), + (CopyStatement) CCJSqlParserUtil.parse(sql)}) { + assertEquals(sql, copy.toString()); + assertNull(copy.getOptions()); + assertRoundTrip(copy); + } + } + + @Test + void keepsEachLegacyOptionTyped() throws JSQLParserException { + CopyStatement copy = parse("COPY t (a, b) TO '/tmp/x.csv' WITH DELIMITER AS ',' CSV " + + "QUOTE AS '\"' ESCAPE '\\' FORCE QUOTE a, \"B\" ENCODING 'UTF8'"); + assertTrue(copy.isWithKeyword()); + assertFalse(copy.isBinary()); + assertEquals("'/tmp/x.csv'", copy.getPath()); + List options = copy.getLegacyOptions(); + assertEquals(Arrays.asList(Kind.DELIMITER, Kind.CSV, Kind.QUOTE, Kind.ESCAPE, + Kind.FORCE_QUOTE, Kind.ENCODING), + options.stream().map(CopyLegacyOption::getKind).collect(Collectors.toList())); + + CopyLegacyOption delimiter = options.get(0); + assertTrue(delimiter.isAsKeyword()); + assertEquals(",", delimiter.getValue().getValue()); + assertNull(options.get(1).getValue()); + assertFalse(options.get(3).isAsKeyword()); + assertEquals("\\", options.get(3).getValue().getValue()); + + CopyLegacyOption forceQuote = options.get(4); + assertFalse(forceQuote.isAllColumns()); + assertEquals(Arrays.asList("a", "\"B\""), forceQuote.getColumns().stream() + .map(Column::getColumnName).collect(Collectors.toList())); + assertEquals("FORCE QUOTE a, \"B\"", forceQuote.toString()); + assertEquals("UTF8", options.get(5).getValue().getValue()); + + CopyLegacyOption all = parse("COPY t FROM STDIN CSV FORCE NOT NULL *").getLegacyOptions() + .get(1); + assertEquals(Kind.FORCE_NOT_NULL, all.getKind()); + assertTrue(all.isAllColumns()); + assertTrue(all.getColumns().isEmpty()); + + CopyStatement binary = parse("COPY BINARY s.t (a) FROM STDIN"); + assertTrue(binary.isBinary()); + assertEquals("s.t", binary.getTable().getFullyQualifiedName()); + assertTrue(binary.getLegacyOptions().isEmpty()); + } + + @Test + void describesWhatEachKindTakes() { + assertFalse(Kind.CSV.takesString()); + assertTrue(Kind.NULL.takesString()); + assertTrue(Kind.NULL.allowsAsKeyword()); + assertTrue(Kind.ENCODING.takesString()); + assertFalse(Kind.ENCODING.allowsAsKeyword()); + assertTrue(Kind.FORCE_NULL.takesColumns()); + assertFalse(Kind.HEADER.takesColumns()); + assertEquals("FORCE NOT NULL", Kind.FORCE_NOT_NULL.getKeyword()); + } + + @Test + void buildsAndDeparsesLegacyOptions() throws JSQLParserException { + CopyStatement copy = new CopyStatement().withTable(new Table("t")).withFrom(true) + .withPath("STDIN").withWithKeyword(true) + .addLegacyOptions(new CopyLegacyOption(Kind.CSV), + new CopyLegacyOption(Kind.NULL).withAsKeyword(true) + .withValue(new StringValue("x")), + new CopyLegacyOption(Kind.FORCE_NULL).addColumns(new Column("a"), + new Column("b")), + new CopyLegacyOption(Kind.FORCE_NOT_NULL).withAllColumns(true)); + assertEquals("COPY t FROM STDIN WITH CSV NULL AS 'x' FORCE NULL a, b FORCE NOT NULL *", + copy.toString()); + assertRoundTrip(copy); + + copy.setLegacyOptions(null); + assertEquals("COPY t FROM STDIN WITH", copy.toString()); + copy.withBinary(true).withLegacyOptions( + Arrays.asList(new CopyLegacyOption(Kind.FREEZE))); + assertEquals("COPY BINARY t FROM STDIN WITH FREEZE", copy.toString()); + assertRoundTrip(copy); + copy.setBinary(false); + copy.withLegacyOptions(Arrays.asList(new CopyLegacyOption(Kind.CSV), + new CopyLegacyOption(Kind.HEADER))); + assertEquals("COPY t FROM STDIN WITH CSV HEADER", copy.toString()); + assertRoundTrip(copy); + } + + @ParameterizedTest + @ValueSource(strings = { + "COPY t TO STDOUT CSV (FORMAT csv)", + "COPY t TO STDOUT (FORMAT csv) CSV", + "COPY t TO STDOUT ENCODING AS 'UTF8'", + "COPY t TO STDOUT ENCODING UTF8", + "COPY t TO STDOUT DELIMITER", + "COPY t TO STDOUT DELIMITER ,", + "COPY t TO STDOUT DELIMITER AS AS ','", + "COPY t TO STDOUT NULL 1", + "COPY t TO STDOUT CSV QUOTE", + "COPY t TO STDOUT HEADER true", + "COPY t TO STDOUT CSV, HEADER", + "COPY t TO STDOUT CSV HEADER WITH", + "COPY t TO STDOUT WITH WITH CSV", + "COPY t TO STDOUT FORCE QUOTE", + "COPY t TO STDOUT FORCE QUOTE a,", + "COPY t TO STDOUT FORCE QUOTE (a)", + "COPY t TO STDOUT FORCE QUOTE t.a", + "COPY t TO STDOUT FORCE QUOTE a, *", + "COPY t TO STDOUT FORCE QUOTE all", + "COPY t TO STDOUT FORCE NOT NULL a, freeze", + "COPY t TO STDOUT FORCE NOT a", + "COPY t TO STDOUT FORCE", + "COPY BINARY (SELECT 1) TO STDOUT", + "COPY BINARY t", + "COPY BINARY BINARY t TO STDOUT"}) + void rejectsWhatPostgreSqlRejects(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + @Test + void otherDialectsKeepRejectingTheLegacyForms() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.ORACLE, Dialect.SQLSERVER}) { + for (String sql : new String[] {"COPY t TO STDOUT CSV HEADER", + "COPY t FROM STDIN NULL ''", "COPY BINARY t TO STDOUT"}) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(dialect)), dialect + " " + sql); + } + } + // without a word after it, BINARY still names DuckDB's table + CopyStatement duckDb = + (CopyStatement) CCJSqlParserUtil.parse("COPY binary TO 'out.csv' (FORMAT CSV)"); + assertFalse(duckDb.isBinary()); + assertEquals("binary", duckDb.getTable().getName()); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "COPY t FROM STDIN CSV HEADER; COPY t TO STDOUT BINARY\nSELECT 1;" + + "COPY BINARY t TO STDOUT WITH;COPY t TO STDOUT FORCE QUOTE a, b", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(5, statements.size()); + assertEquals("COPY t TO STDOUT BINARY", statements.get(1).toString()); + assertEquals("COPY BINARY t TO STDOUT WITH", statements.get(3).toString()); + + // DuckDB's FORCE INSTALL starts the next statement, FORCE QUOTE continues the options + Statements duckDb = CCJSqlParserUtil.parseStatements( + "SELECT 1; COPY t TO 'x.csv' CSV\nFORCE INSTALL httpfs"); + assertEquals(3, duckDb.size()); + assertEquals("COPY t TO 'x.csv' CSV", duckDb.get(1).toString()); + assertInstanceOf(ExtensionStatement.class, duckDb.get(2)); + } + + @Test + void findsTheTableBehindTheLegacyOptions() throws JSQLParserException { + assertThat(new TablesNamesFinder<>().getTables( + parse("COPY BINARY s.t TO STDOUT CSV FORCE QUOTE a"))) + .containsExactly("s.t"); + assertThat(parse("COPY t FROM STDIN CSV").getFeatures().getCertain()) + .containsExactlyInAnyOrder(StmtFeature.READS_DATA, StmtFeature.MODIFIES_DATA); + } + private static CopyStatement parse(String sql) throws JSQLParserException { return (CopyStatement) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); } diff --git a/src/test/java/net/sf/jsqlparser/statement/PostgreSqlSetToTest.java b/src/test/java/net/sf/jsqlparser/statement/PostgreSqlSetToTest.java new file mode 100644 index 0000000000..f031781a38 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/PostgreSqlSetToTest.java @@ -0,0 +1,165 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +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.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.SetStatement.AssignmentOperator; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +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 PostgreSqlSetToTest { + private static SetStatement parse(String sql) throws JSQLParserException { + return (SetStatement) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"SET search_path TO my_schema, public", + "SET LOCAL statement_timeout TO 5000", "SET SESSION application_name TO 'worker'", + "SET datestyle TO postgres, dmy", "SET client_encoding TO DEFAULT", + "SET app.user_name TO 'reader'", "SET \"TimeZone\" TO 'UTC'", + "SET standard_conforming_strings TO on", "SET enable_seqscan TO off", + "SET enable_hashjoin TO true", "SET enable_mergejoin TO false", + "SET search_path TO off, on"}) + void parsesScopeNamesAndValueLists(String sql) throws Exception { + SetStatement set = parse(sql); + assertEquals(1, set.getCount()); + assertEquals(AssignmentOperator.TO, set.getAssignmentOperator()); + assertFalse(set.isUseEqual()); + assertRoundTrip(set, sql); + SetStatement generic = (SetStatement) CCJSqlParserUtil.parse(sql); + assertEquals(AssignmentOperator.TO, generic.getAssignmentOperator()); + } + + @Test + void distinguishesOneValueListFromSeveralAssignments() throws Exception { + SetStatement set = parse("SET LOCAL search_path TO my_schema, public, '$user'"); + assertEquals("LOCAL", set.getEffectParameter()); + assertEquals("search_path", set.getName()); + assertEquals(1, set.getCount()); + assertEquals(3, set.getExpressions().size()); + assertEquals("my_schema", set.getExpressions().get(0).toString()); + assertEquals("public", set.getExpressions().get(1).toString()); + assertEquals("$user", ((StringValue) set.getExpressions().get(2)).getValue()); + } + + @Test + void keepsLegacyAssignmentApiAndSeparators() throws Exception { + SetStatement constructed = new SetStatement("x", new ExpressionList<>(new LongValue(1))); + assertTrue(constructed.isUseEqual()); + constructed.setAssignmentOperator(AssignmentOperator.TO); + assertRoundTrip(constructed, "SET x TO 1"); + assertFalse(constructed.isUseEqual()); + constructed.setUseEqual(true); + assertEquals("SET x = 1", constructed.toString()); + constructed.setUseEqual(false); + assertEquals("SET x 1", constructed.toString()); + SetStatement assignments = (SetStatement) CCJSqlParserUtil.parse("SET @a=1, @b:=2, @c=3", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals(3, assignments.getCount()); + assertEquals(AssignmentOperator.EQUALS, assignments.getAssignmentOperator(0)); + assertEquals(AssignmentOperator.COLON_EQUALS, assignments.getAssignmentOperator(1)); + assertEquals("SET @a = 1, @b := 2, @c = 3", assignments.toString()); + assertRoundTrip(parse("SET TIME ZONE 'UTC'"), "SET Time Zone 'UTC'"); + } + + @Test + void keepsExistingOnExpressionsOutsideToAssignments() throws Exception { + for (String sql : List.of("SET v = on + 1", "SET v = 1, on")) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.MYSQL, Dialect.SQLSERVER)) { + SetStatement set = (SetStatement) CCJSqlParserUtil.parse(sql, + p -> p.withDialect(dialect)); + assertEquals(AssignmentOperator.EQUALS, set.getAssignmentOperator()); + assertRoundTrip(set, sql); + } + } + } + + @Test + void visitsValuesInToEqualsAndSpaceForms() throws Exception { + List values = new ArrayList<>(); + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>( + new SelectVisitorAdapter<>(new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S context) { + values.add(value.getValue()); + return null; + } + })); + parse("SET x TO 1, 2").accept(visitor, null); + CCJSqlParserUtil.parse("SET x = 3, y 4").accept(visitor, null); + assertEquals(List.of(1L, 2L, 3L, 4L), values); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(value.getValue() + 10); + } + }; + parse("SET x TO 1, 2").accept( + new StatementDeParser(expressions, new SelectDeParser(), output), null); + assertEquals("SET x TO 11, 12", output.toString()); + } + + @Test + void retainsFollowingStatements() throws Exception { + Statements statements = CCJSqlParserUtil.parseStatements( + "SET LOCAL search_path TO my_schema, public; SELECT 1; SET x = 3;", + p -> p.withDialect(Dialect.POSTGRESQL)); + assertEquals(3, statements.size()); + assertEquals(AssignmentOperator.TO, + ((SetStatement) statements.get(0)).getAssignmentOperator()); + assertEquals(AssignmentOperator.EQUALS, + ((SetStatement) statements.get(2)).getAssignmentOperator()); + } + + @ParameterizedTest + @ValueSource(strings = {"SET search_path TO", "SET search_path TO public,", + "SET x TO = 1", "SET x TO 1, y TO 2", "SET x = 1, y TO 2", + "SET @x TO 1", "SET TIME ZONE TO 'UTC'"}) + void rejectsMalformedOrMultipleParameterToAssignments(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + @Test + void doesNotEnableToForExplicitMySqlDialect() { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("SET x TO 1", + p -> p.withDialect(Dialect.MYSQL))); + } + + private static void assertRoundTrip(SetStatement set, String expected) throws Exception { + assertEquals(expected, set.toString()); + StringBuilder output = new StringBuilder(); + set.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + SetStatement reparsed = parse(output.toString()); + assertEquals(set.getAssignmentOperator(), reparsed.getAssignmentOperator()); + assertEquals(set.getEffectParameter(), reparsed.getEffectParameter()); + assertEquals(set.getName(), reparsed.getName()); + assertEquals(set.getExpressions().toString(), reparsed.getExpressions().toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/RefreshMaterializedViewStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/RefreshMaterializedViewStatementTest.java index 4ebba56c7f..ad0561352b 100644 --- a/src/test/java/net/sf/jsqlparser/statement/RefreshMaterializedViewStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/RefreshMaterializedViewStatementTest.java @@ -10,9 +10,21 @@ package net.sf.jsqlparser.statement; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement; +import net.sf.jsqlparser.statement.refresh.RefreshMode; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.RefreshMaterializedViewStatementDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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; /** * @@ -21,8 +33,83 @@ public class RefreshMaterializedViewStatementTest { + @ParameterizedTest + @ValueSource(strings = {"REFRESH MATERIALIZED VIEW my_view", + "REFRESH MATERIALIZED VIEW my_view WITH DATA", + "REFRESH MATERIALIZED VIEW my_view WITH NO DATA", + "REFRESH MATERIALIZED VIEW CONCURRENTLY my_view", + "REFRESH MATERIALIZED VIEW CONCURRENTLY my_view WITH DATA"}) + public void testRefreshModes(String sql) throws JSQLParserException { + RefreshMaterializedViewStatement statement = + (RefreshMaterializedViewStatement) assertSqlCanBeParsedAndDeparsed(sql); + StringBuilder output = new StringBuilder(); + new RefreshMaterializedViewStatementDeParser(output).deParse(statement); + assertEquals(sql, output.toString()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + + @Test + void preservesModeWhenVisitingViewName() throws JSQLParserException { + RefreshMaterializedViewStatement statement = + (RefreshMaterializedViewStatement) CCJSqlParserUtil + .parse("REFRESH MATERIALIZED VIEW old_schema.mv WITH NO DATA"); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser(); + SelectDeParser selects = new SelectDeParser(expressions, output) { + @Override + public StringBuilder visit(Table table, S context) { + assertEquals("context", context); + getBuilder().append("new_schema.\"renamed view\""); + return getBuilder(); + } + }; + StringBuilder original = new StringBuilder(); + StatementDeParser deparser = new StatementDeParser(expressions, selects, original); + deparser.setBuilder(output); + assertSame(output, statement.accept(deparser, "context")); + assertEquals("", original.toString()); + assertEquals("REFRESH MATERIALIZED VIEW new_schema.\"renamed view\" WITH NO DATA", + output.toString()); + RefreshMaterializedViewStatement reparsed = + (RefreshMaterializedViewStatement) CCJSqlParserUtil.parse(output.toString()); + assertEquals(RefreshMode.WITH_NO_DATA, reparsed.getRefreshMode()); + assertEquals("new_schema", reparsed.getView().getSchemaName()); + } + + @Test + void statementDeparserUsesReplacementOutputBuffer() throws JSQLParserException { + StringBuilder original = new StringBuilder("old output"); + StringBuilder replacement = new StringBuilder(); + StatementDeParser deparser = new StatementDeParser(original); + deparser.setBuilder(replacement); + RefreshMaterializedViewStatement statement = + (RefreshMaterializedViewStatement) CCJSqlParserUtil + .parse("REFRESH MATERIALIZED VIEW schema_name.mv WITH NO DATA"); + assertSame(replacement, statement.accept(deparser, null)); + assertEquals("old output", original.toString()); + assertEquals(statement.toString(), replacement.toString()); + } + + @Test + void respectsReplacementOutputBuffer() throws JSQLParserException { + StringBuilder original = new StringBuilder(); + StringBuilder replacement = new StringBuilder(); + RefreshMaterializedViewStatementDeParser deparser = + new RefreshMaterializedViewStatementDeParser(original); + deparser.setBuilder(replacement); + deparser.deParse((RefreshMaterializedViewStatement) CCJSqlParserUtil + .parse("REFRESH MATERIALIZED VIEW mv WITH NO DATA")); + assertEquals("", original.toString()); + assertEquals("REFRESH MATERIALIZED VIEW mv WITH NO DATA", replacement.toString()); + } + @Test - public void testSimpleUse() throws JSQLParserException { - assertSqlCanBeParsedAndDeparsed("REFRESH MATERIALIZED VIEW my_view"); + void rendersDefaultModeLikeOmittedMode() { + RefreshMaterializedViewStatement statement = new RefreshMaterializedViewStatement( + new Table("mv"), true, RefreshMode.DEFAULT); + StringBuilder output = new StringBuilder(); + new RefreshMaterializedViewStatementDeParser(output).deParse(statement); + assertEquals("REFRESH MATERIALIZED VIEW CONCURRENTLY mv", output.toString()); + assertEquals(statement.toString(), output.toString()); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/ResetStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/ResetStatementTest.java index b3372ff736..2d6268069e 100644 --- a/src/test/java/net/sf/jsqlparser/statement/ResetStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/ResetStatementTest.java @@ -10,12 +10,34 @@ package net.sf.jsqlparser.statement; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; 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.assertNotNull; +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.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; public class ResetStatementTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer NO_DIALECT = parser -> { + }; @Test public void tesResetTZ() throws JSQLParserException { @@ -27,6 +49,58 @@ public void tesResetAll() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed("RESET ALL"); } + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "RESET TIME ZONE | Time Zone", + "RESET TRANSACTION ISOLATION LEVEL | TRANSACTION ISOLATION LEVEL", + "RESET SESSION AUTHORIZATION | SESSION AUTHORIZATION", + "RESET transaction | transaction", + "RESET session | session", + "RESET time | time"}) + void readsTheParameterNamesOfShow(String sql, String name) throws JSQLParserException { + for (ResetStatement reset : new ResetStatement[] { + (ResetStatement) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)), + (ResetStatement) CCJSqlParserUtil.parse(sql)}) { + assertEquals(name, reset.getName()); + assertEquals("RESET " + name, reset.toString()); + assertSqlCanBeParsedAndDeparsed(reset.toString()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"RESET TRANSACTION ISOLATION", "RESET TRANSACTION LEVEL", + "RESET SESSION AUTHORIZATION x", "RESET DATE ZONE", "RESET TIME ZONE x"}) + void rejectsIncompletePhrases(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + } + + @Test + void timeZoneNeedsTheWordTime() throws JSQLParserException { + // other date/time keywords before ZONE were read as TIME ZONE + for (String sql : new String[] {"RESET DATE ZONE", "RESET TIMESTAMP ZONE", + "SET DATE ZONE 'UTC'"}) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql), sql); + } + assertEquals("SET Time Zone 'UTC'", + CCJSqlParserUtil.parse("SET time zone 'UTC'").toString()); + assertEquals("SET LOCAL Time Zone LOCAL", + CCJSqlParserUtil.parse("SET LOCAL TIME ZONE LOCAL").toString()); + } + + @Test + void otherDialectsKeepRejectingThePostgreSqlPhrases() { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.ORACLE}) { + for (String sql : new String[] {"RESET TRANSACTION ISOLATION LEVEL", + "RESET SESSION AUTHORIZATION"}) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + dialect + " " + sql); + } + } + } + @Test public void testObject() { ResetStatement resetStatement = new ResetStatement(); @@ -37,4 +111,129 @@ public void testObject() { assertEquals("somethingElse", resetStatement.getName()); } + @ParameterizedTest + @ValueSource(strings = {"RESET PERSIST", "RESET PERSIST max_connections", + "RESET PERSIST IF EXISTS max_connections", "RESET PERSIST `max_connections`", + "RESET PERSIST a.b", "RESET PERSIST `a`.`b`", "RESET PERSIST DEFAULT.x", + "RESET PERSIST IF EXISTS validate_password.length", + "RESET PERSIST IF EXISTS DEFAULT.x"}) + public void testResetPersistInMySql(String sql) throws JSQLParserException { + ResetStatement reset = (ResetStatement) assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + assertTrue(reset.isPersist()); + assertEquals(sql, deparse(reset)); + } + + @Test + public void testResetPersistState() throws JSQLParserException { + ResetStatement all = (ResetStatement) CCJSqlParserUtil.parse("reset persist", MYSQL); + assertTrue(all.isPersist()); + assertFalse(all.isIfExists()); + assertNull(all.getName()); + assertEquals("RESET PERSIST", all.toString()); + + ResetStatement one = (ResetStatement) CCJSqlParserUtil + .parse("RESET PERSIST IF EXISTS max_connections", MYSQL); + assertTrue(one.isPersist()); + assertTrue(one.isIfExists()); + assertEquals("max_connections", one.getName()); + + // a component variable keeps its prefix in the name + ResetStatement component = (ResetStatement) CCJSqlParserUtil + .parse("RESET PERSIST IF EXISTS `validate_password`.length", MYSQL); + assertEquals("`validate_password`.length", component.getName()); + assertEquals("DEFAULT.x", + ((ResetStatement) CCJSqlParserUtil.parse("RESET PERSIST DEFAULT.x", MYSQL)) + .getName()); + } + + @ParameterizedTest + @ValueSource(strings = {"RESET PERSIST max_connections", + "RESET PERSIST IF EXISTS max_connections", "RESET PERSIST validate_password.length", + "RESET PERSIST DEFAULT.x"}) + public void testResetPersistWithANameWithoutDialect(String sql) throws JSQLParserException { + ResetStatement reset = + (ResetStatement) assertSqlCanBeParsedAndDeparsed(sql, false, NO_DIALECT); + assertTrue(reset.isPersist()); + assertEquals(sql.substring(sql.lastIndexOf(' ') + 1), reset.getName()); + } + + @Test + public void testBareResetPersistKeepsItsReadingOutsideMySql() throws JSQLParserException { + // PostgreSQL resets a parameter named persist; only MySQL reads the PERSIST keyword alone + for (Consumer dialect : List.of(NO_DIALECT, + (Consumer) parser -> parser.withDialect(Dialect.POSTGRESQL), + (Consumer) parser -> parser.withDialect(Dialect.MARIADB))) { + ResetStatement reset = + (ResetStatement) assertSqlCanBeParsedAndDeparsed("RESET persist", false, + dialect); + assertFalse(reset.isPersist()); + assertEquals("persist", reset.getName()); + } + ResetStatement script = (ResetStatement) CCJSqlParserUtil + .parseStatements("RESET persist; SELECT 1", NO_DIALECT).get(0); + assertFalse(script.isPersist()); + } + + @ParameterizedTest + @ValueSource(strings = {"RESET PERSIST max_connections", + "RESET PERSIST IF EXISTS max_connections", "RESET PERSIST a.b"}) + public void testOtherDialectsKeepRejectingResetPersistOfAName(String sql) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.MARIADB, Dialect.ORACLE)) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect))); + } + } + + @ParameterizedTest + @ValueSource(strings = {"RESET PERSIST IF EXISTS", "RESET PERSIST IF max_connections", + "RESET PERSIST a.b.c", "RESET PERSIST a.", "RESET PERSIST DEFAULT", + "RESET PERSIST a b", "RESET PERSIST 'max_connections'", + "RESET PERSIST max_connections, wait_timeout"}) + public void testRejectsResetPersistFormsMySqlRejects(String sql) { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @Test + public void testResetPersistEndsTheStatement() throws JSQLParserException { + List statements = CCJSqlParserUtil + .parseStatements("RESET PERSIST; RESET PERSIST IF EXISTS x; SELECT 1", MYSQL) + .stream().map(Object::toString).collect(Collectors.toList()); + assertEquals(List.of("RESET PERSIST", "RESET PERSIST IF EXISTS x", "SELECT 1"), + statements); + } + + @Test + public void testFindsNoTables() throws JSQLParserException { + for (String sql : new String[] {"RESET ALL", "RESET work_mem", "RESET PERSIST x"}) { + assertThat(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse(sql))) + .isEmpty(); + } + } + + @Test + public void testNodeSpansTheStatement() throws JSQLParserException { + String sql = "RESET PERSIST IF EXISTS max_connections"; + Node node = ((ASTNodeAccess) CCJSqlParserUtil.parse(sql, MYSQL)).getASTNode(); + assertEquals(sql, sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + @Test + public void testBuildsResetPersistInCode() { + ResetStatement reset = new ResetStatement().withPersist(true); + assertEquals("RESET PERSIST", reset.toString()); + reset.withIfExists(true).setName("x"); + assertEquals("RESET PERSIST IF EXISTS x", deparse(reset)); + reset.setPersist(false); + assertEquals("RESET x", reset.toString()); + } + + private static String deparse(ResetStatement reset) { + StringBuilder builder = new StringBuilder(); + reset.accept(new StatementDeParser(builder), null); + return builder.toString(); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/SerializationTest.java b/src/test/java/net/sf/jsqlparser/statement/SerializationTest.java index f5cfad0f6d..8b23ebdc21 100644 --- a/src/test/java/net/sf/jsqlparser/statement/SerializationTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/SerializationTest.java @@ -9,19 +9,43 @@ */ package net.sf.jsqlparser.statement; -import net.sf.jsqlparser.JSQLParserException; -import net.sf.jsqlparser.parser.CCJSqlParserUtil; -import net.sf.jsqlparser.statement.select.PlainSelect; -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; - import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; +import java.math.BigDecimal; +import java.util.List; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.SpannerInterleaveIn; +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.CreateTable; +import net.sf.jsqlparser.statement.select.JoinHint; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.SampleClause; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; public class SerializationTest { + @Test + void serializeSelectWithLeadingComments() throws Exception { + PlainSelect original = (PlainSelect) CCJSqlParserUtil + .parse("/* keep orderby */ SELECT id FROM mytable"); + Assertions.assertEquals(List.of("/* keep orderby */"), original.getLeadingComments()); + PlainSelect copy = roundTrip(original); + Assertions.assertEquals("SELECT id FROM mytable", copy.toString()); + Assertions.assertNull(copy.getASTNode()); + Assertions.assertEquals(List.of(), copy.getLeadingComments()); + } + @Test void serializeWithItem() throws JSQLParserException, IOException, ClassNotFoundException { String sqlStr = @@ -49,4 +73,182 @@ void serializeWithItem() throws JSQLParserException, IOException, ClassNotFoundE "The deserialized object should be equal to the original"); } + @ParameterizedTest + @ValueSource(strings = {"LOOP", "HASH", "MERGE", "REMOTE"}) + void serializeSqlServerJoinHint(String keyword) throws Exception { + PlainSelect original = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a.id FROM a INNER " + keyword + " JOIN b ON a.id = b.id"); + PlainSelect copy = roundTrip(original); + JoinHint hint = copy.getJoins().get(0).getJoinHint(); + Assertions.assertEquals(keyword, hint.getKeyword()); + Assertions.assertEquals(JoinHint.Position.BEFORE_JOIN, hint.getPosition()); + Assertions.assertEquals("b", ((Table) copy.getJoins().get(0).getFromItem()).getName()); + Assertions.assertEquals("a.id = b.id", + copy.getJoins().get(0).getOnExpressions().iterator().next().toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"shuffle", "BROADCAST"}) + void serializeDorisJoinHint(String keyword) throws Exception { + PlainSelect original = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a.id FROM a LEFT JOIN [" + keyword + "] b USING (id)", false, + parser -> parser.withDialect(Dialect.DORIS)); + PlainSelect copy = roundTrip(original); + JoinHint hint = copy.getJoins().get(0).getJoinHint(); + Assertions.assertEquals(keyword, hint.getKeyword()); + Assertions.assertEquals(JoinHint.Position.AFTER_JOIN, hint.getPosition()); + Assertions.assertEquals("id", + copy.getJoins().get(0).getUsingColumns().get(0).getColumnName()); + Assertions.assertTrue(copy.getJoins().get(0).isLeft()); + } + + static Stream samplingClauses() { + return Stream.of( + Arguments.of("TABLESAMPLE BERNOULLI (10)", + new SampleClause("TABLESAMPLE", "BERNOULLI", 10L, null, null, null)), + Arguments.of("TABLESAMPLE SYSTEM (10.5 PERCENT) REPEATABLE (7)", + new SampleClause("TABLESAMPLE", "SYSTEM", 10.5, "PERCENT", 7L, null)), + Arguments.of("SAMPLE (99)", + new SampleClause("SAMPLE", null, 99L, null, null, null)), + Arguments.of("SAMPLE BLOCK (99.1) SEED (10.1)", + new SampleClause("SAMPLE", "BLOCK", 99.1, null, null, 10.1)), + Arguments.of("SAMPLE 0.1 OFFSET 1000", + new SampleClause("SAMPLE", null, 0.1, null, null, null, false, 1000L)), + Arguments.of("USING SAMPLE 10%", + new SampleClause("USING SAMPLE", null, 10L, "%", null, null, false, null)), + Arguments.of("USING SAMPLE 10 ROWS (system, 377)", + new SampleClause("USING SAMPLE", "SYSTEM", 10L, "ROWS", null, 377L, + false, null).setMethodInBrackets(true)), + Arguments.of("USING SAMPLE RESERVOIR (50 ROWS)", + new SampleClause("USING SAMPLE", "RESERVOIR", 50L, "ROWS", null, null))); + } + + @ParameterizedTest + @MethodSource("samplingClauses") + void serializeTableSampleClause(String clause, SampleClause expected) throws Exception { + PlainSelect original = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT id FROM events " + clause + " WHERE id > 0"); + assertSampleClause(expected, ((Table) original.getFromItem()).getSampleClause()); + PlainSelect copy = roundTrip(original); + assertSampleClause(expected, ((Table) copy.getFromItem()).getSampleClause()); + Assertions.assertEquals("events", ((Table) copy.getFromItem()).getName()); + Assertions.assertEquals("id > 0", copy.getWhere().toString()); + Assertions.assertEquals("id", copy.getSelectItem(0).toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT * FROM (SELECT id FROM events) TABLESAMPLE SYSTEM (10 PERCENT)", + "SELECT * FROM (events) TABLESAMPLE SYSTEM (10 PERCENT)", + "SELECT * FROM events MATCH_RECOGNIZE (PATTERN (A) DEFINE A AS id > 0) " + + "TABLESAMPLE SYSTEM (10 PERCENT)" + }) + void serializeOtherSampleClauseOwners(String sql) throws Exception { + PlainSelect original = (PlainSelect) CCJSqlParserUtil.parse(sql); + PlainSelect copy = roundTrip(original); + assertSampleClause(new SampleClause("TABLESAMPLE", "SYSTEM", 10L, "PERCENT", null, null), + copy.getFromItem().getSampleClause()); + } + + @Test + void serializeSampleClauseAfterMutation() throws Exception { + PlainSelect original = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM events SAMPLE BLOCK (10) SEED (7)"); + SampleClause sample = original.getFromItem().getSampleClause(); + sample.setPercentageArgument(new BigDecimal("12.5")); + sample.setSeedArgument(new BigDecimal("7.5")); + PlainSelect copy = roundTrip(original); + SampleClause copiedSample = copy.getFromItem().getSampleClause(); + assertSampleClause(new SampleClause("SAMPLE", "BLOCK", new BigDecimal("12.5"), null, + null, new BigDecimal("7.5")), copiedSample); + Assertions.assertNotSame(sample, copiedSample); + sample.setSeedArgument(99L); + Assertions.assertEquals(new BigDecimal("7.5"), copiedSample.getSeedArgument()); + } + + @ParameterizedTest + @ValueSource(strings = {"", " ON DELETE CASCADE", " ON DELETE NO ACTION"}) + void serializeSpannerInterleaveIn(String action) throws Exception { + CreateTable original = (CreateTable) TestUtils.assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE child (id INT) PRIMARY KEY (id), INTERLEAVE IN PARENT parent" + + action); + CreateTable copy = roundTrip(original); + SpannerInterleaveIn interleave = copy.getSpannerInterleaveIn(); + Assertions.assertEquals("parent", interleave.getTable().getName()); + SpannerInterleaveIn.OnDelete expected = action.isEmpty() ? null + : action.endsWith("CASCADE") ? SpannerInterleaveIn.OnDelete.CASCADE + : SpannerInterleaveIn.OnDelete.NO_ACTION; + Assertions.assertEquals(expected, interleave.getOnDelete()); + Assertions.assertEquals("child", copy.getTable().getName()); + Assertions.assertEquals("id", copy.getColumnDefinitions().get(0).getColumnName()); + Assertions.assertEquals("INT", + copy.getColumnDefinitions().get(0).getColDataType().getDataType()); + original.getSpannerInterleaveIn().getTable().setName("changed"); + Assertions.assertEquals("parent", interleave.getTable().getName()); + } + + @Test + void serializeCombinedHelpers() throws Exception { + PlainSelect original = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a.id FROM a TABLESAMPLE SYSTEM (10) INNER LOOP JOIN b " + + "ON a.id = b.id JOIN c ON b.id = c.id"); + PlainSelect copy = roundTrip(original); + Assertions.assertEquals("LOOP", copy.getJoins().get(0).getJoinHint().getKeyword()); + assertSampleClause(new SampleClause("TABLESAMPLE", "SYSTEM", 10L, null, null, null), + ((Table) copy.getFromItem()).getSampleClause()); + Assertions.assertNull(((Table) copy.getJoins().get(0).getFromItem()).getSampleClause()); + Assertions.assertNull(copy.getJoins().get(1).getJoinHint()); + Assertions.assertNull(((Table) copy.getJoins().get(1).getFromItem()).getSampleClause()); + } + + @Test + void serializeSelectWithoutHelpers() throws Exception { + PlainSelect original = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a.id FROM a INNER JOIN b ON a.id = b.id WHERE b.id > 0"); + PlainSelect copy = roundTrip(original); + Assertions.assertNull(copy.getJoins().get(0).getJoinHint()); + Assertions.assertNull(((Table) copy.getFromItem()).getSampleClause()); + Assertions.assertEquals("b.id > 0", copy.getWhere().toString()); + } + + @Test + void serializeCreateTableWithoutInterleave() throws Exception { + CreateTable original = (CreateTable) TestUtils.assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE ordinary (id INT)"); + CreateTable copy = roundTrip(original); + Assertions.assertNull(copy.getSpannerInterleaveIn()); + Assertions.assertEquals("ordinary", copy.getTable().getName()); + Assertions.assertEquals("id", copy.getColumnDefinitions().get(0).getColumnName()); + } + + private static void assertSampleClause(SampleClause expected, SampleClause actual) { + Assertions.assertNotNull(actual); + Assertions.assertEquals(expected.getKeyword(), actual.getKeyword()); + Assertions.assertEquals(expected.getMethod(), actual.getMethod()); + Assertions.assertEquals(expected.getPercentageArgument(), actual.getPercentageArgument()); + Assertions.assertEquals(expected.getPercentageUnit(), actual.getPercentageUnit()); + Assertions.assertEquals(expected.isArgumentInBrackets(), actual.isArgumentInBrackets()); + Assertions.assertEquals(expected.isMethodInBrackets(), actual.isMethodInBrackets()); + Assertions.assertEquals(expected.getOffsetArgument(), actual.getOffsetArgument()); + Assertions.assertEquals(expected.getRepeatArgument(), actual.getRepeatArgument()); + Assertions.assertEquals(expected.getSeedArgument(), actual.getSeedArgument()); + } + + @SuppressWarnings("unchecked") + private static T roundTrip(T original) + throws IOException, ClassNotFoundException { + ByteArrayOutputStream bytes = new ByteArrayOutputStream(); + try (ObjectOutputStream out = new ObjectOutputStream(bytes)) { + out.writeObject(original); + } + T copy; + try (ObjectInputStream in = + new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()))) { + copy = (T) in.readObject(); + } + Assertions.assertNotSame(original, copy); + Assertions.assertEquals(original.toString(), copy.toString()); + return copy; + } + } diff --git a/src/test/java/net/sf/jsqlparser/statement/SetConstraintsStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/SetConstraintsStatementTest.java new file mode 100644 index 0000000000..d673e544c9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/SetConstraintsStatementTest.java @@ -0,0 +1,137 @@ +/*- + * #%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; + +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.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.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class SetConstraintsStatementTest { + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static SetConstraintsStatement roundTrip(String sql, Dialect dialect) + throws Exception { + SetConstraintsStatement statement = + assertInstanceOf(SetConstraintsStatement.class, parse(sql, dialect)); + TransactionStatementTest.assertSpans(sql, sql, statement); + assertEquals(sql, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + assertEquals(sql, parse(sql, dialect).toString()); + assertEquals(Set.of(StmtFeature.MODIFIES_TRANSACTION), + statement.getFeatures().getCertain()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + return statement; + } + + @Test + void allConstraints() throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.ORACLE, null}) { + SetConstraintsStatement statement = roundTrip("SET CONSTRAINTS ALL DEFERRED", dialect); + assertTrue(statement.isAll()); + assertTrue(statement.getConstraintNames().isEmpty()); + assertEquals(ConstraintAttributes.Initially.DEFERRED, statement.getTiming()); + } + } + + @Test + void namedConstraintsKeepQualifiersAndQuotes() throws Exception { + SetConstraintsStatement statement = roundTrip( + "SET CONSTRAINTS c1, app.c2, \"Mixed Case\" IMMEDIATE", Dialect.POSTGRESQL); + assertFalse(statement.isAll()); + assertEquals(List.of("c1", "app.c2", "\"Mixed Case\""), statement.getConstraintNames()); + assertEquals(ConstraintAttributes.Initially.IMMEDIATE, statement.getTiming()); + } + + @Test + void namedConstraintsAreNoLongerReadAsAssignments() throws Exception { + // master read this as the assignments CONSTRAINTS = c1 and c2 = IMMEDIATE + String sql = "SET CONSTRAINTS c1, c2 IMMEDIATE"; + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + assertEquals(List.of("c1", "c2"), roundTrip(sql, dialect).getConstraintNames()); + } + assertInstanceOf(SetStatement.class, parse("SET constraints = 1", Dialect.POSTGRESQL)); + assertInstanceOf(SetStatement.class, parse("SET constraints TO 1", null)); + } + + @ParameterizedTest + @ValueSource(strings = {"SET CONSTRAINTS ALL LATER", "SET CONSTRAINTS ALL", + "SET CONSTRAINTS c1,", "SET CONSTRAINTS c1, IMMEDIATE", + "SET CONSTRAINTS ALL, c1 DEFERRED", "SET CONSTRAINTS ALL DEFERRED garbage"}) + void malformedFormsAreRejected(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL), sql); + } + + @ParameterizedTest + @ValueSource(strings = {"SET CONSTRAINTS ALL DEFERRED", "SET CONSTRAINTS c1, c2 IMMEDIATE"}) + void mysqlRejectsSetConstraints(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL)); + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MARIADB)); + } + + @Test + void modelCanBeBuiltAndChanged() { + SetConstraintsStatement statement = new SetConstraintsStatement(); + assertEquals("SET CONSTRAINTS ALL IMMEDIATE", statement.toString()); + statement.addConstraintName("c1").addConstraintName("s.c2") + .withTiming(ConstraintAttributes.Initially.DEFERRED); + assertEquals("SET CONSTRAINTS c1, s.c2 DEFERRED", statement.toString()); + statement.getConstraintNames().clear(); + assertEquals("SET CONSTRAINTS ALL DEFERRED", statement.toString()); + assertThrows(NullPointerException.class, () -> statement.setTiming(null)); + assertThrows(NullPointerException.class, () -> statement.addConstraintName(null)); + } + + @Test + void visitorsBoundariesAndValidation() throws Exception { + Statement statement = parse("SET CONSTRAINTS ALL DEFERRED", Dialect.POSTGRESQL); + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(SetConstraintsStatement set, S context) { + return context + ":" + set.getTiming(); + } + }; + assertEquals("ctx:DEFERRED", statement.accept(visitor, "ctx")); + assertNull(statement.accept(new StatementVisitorAdapter<>(), null)); + Statements script = CCJSqlParserUtil.parseStatements( + "BEGIN; SET CONSTRAINTS ALL DEFERRED; INSERT INTO t VALUES (1); COMMIT", + p -> p.withDialect(Dialect.POSTGRESQL)); + assertEquals(4, script.size()); + assertInstanceOf(SetConstraintsStatement.class, script.get(1)); + FeatureConfiguration none = new FeatureConfiguration(); + assertTrue(new Validation(none, List.of(PostgresqlVersion.V10), + "SET CONSTRAINTS c1 IMMEDIATE").validate().isEmpty()); + assertFalse(new Validation(none, List.of(MySqlVersion.V8_0), + "SET CONSTRAINTS ALL DEFERRED").validate().isEmpty()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/SetPasswordStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/SetPasswordStatementTest.java new file mode 100644 index 0000000000..6b19e84b83 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/SetPasswordStatementTest.java @@ -0,0 +1,126 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +class SetPasswordStatementTest { + + private static SetPasswordStatement parse(String sql, Dialect dialect) + throws JSQLParserException { + SetPasswordStatement statement = assertInstanceOf(SetPasswordStatement.class, TestUtils + .assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(dialect))); + assertEquals(sql, assertInstanceOf(SetPasswordStatement.class, CCJSqlParserUtil + .parse(statement.toString(), parser -> parser.withDialect(dialect))).toString()); + return statement; + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "MARIADB"}) + void setsPasswordForAccount(Dialect dialect) throws JSQLParserException { + SetPasswordStatement statement = parse("SET PASSWORD FOR 'app'@'%' = 'x'", dialect); + + assertEquals("app", statement.getAccount().getUser().getValue()); + assertEquals("%", statement.getAccount().getHost().getValue()); + assertEquals("x", ((StringValue) statement.getPassword()).getValue()); + assertFalse(statement.isRandom()); + + SetPasswordStatement current = parse("SET PASSWORD = 'x'", dialect); + assertNull(current.getAccount()); + } + + @Test + void generatesRandomPasswordAndRetainsCurrent() throws JSQLParserException { + SetPasswordStatement statement = parse( + "SET PASSWORD FOR app TO RANDOM REPLACE 'old' RETAIN CURRENT PASSWORD", + Dialect.MYSQL); + + assertTrue(statement.isRandom()); + assertNull(statement.getPassword()); + assertEquals("old", statement.getCurrentCredential().getValue()); + assertTrue(statement.isRetainCurrentPassword()); + + assertTrue(parse("SET PASSWORD TO RANDOM", Dialect.MYSQL).isRandom()); + assertTrue(parse("SET PASSWORD = 'new' REPLACE 'old'", Dialect.MYSQL) + .getCurrentCredential() != null); + } + + @Test + void keepsMariaDbPasswordFunction() throws JSQLParserException { + SetPasswordStatement statement = + parse("SET PASSWORD FOR 'app'@'%' = PASSWORD('x')", Dialect.MARIADB); + + assertEquals("PASSWORD", ((Function) statement.getPassword()).getName()); + } + + @Test + void keepsGenericAssignmentWithoutMySqlDialect() throws JSQLParserException { + for (String sql : List.of("SET PASSWORD = 'x'", "SET PASSWORD TO RANDOM")) { + assertInstanceOf(SetStatement.class, CCJSqlParserUtil.parse(sql), sql); + assertInstanceOf(SetStatement.class, + CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.POSTGRESQL)), + sql); + } + // FOR names an account and is typed in every configuration + assertInstanceOf(SetPasswordStatement.class, TestUtils + .assertSqlCanBeParsedAndDeparsed("SET PASSWORD FOR 'app'@'%' = 'x'", false)); + } + + @Test + void buildsAndDeparses() { + SetPasswordStatement statement = new SetPasswordStatement() + .withAccount(new UserAccount().withUser(new StringValue("app"))) + .withPassword(new StringValue("new")).withRetainCurrentPassword(true); + + assertDeparse(statement, "SET PASSWORD FOR 'app' = 'new' RETAIN CURRENT PASSWORD"); + assertDeparse(statement.withRandom(true).withPassword(null), + "SET PASSWORD FOR 'app' TO RANDOM RETAIN CURRENT PASSWORD"); + } + + @Test + void reportsSchemaChangeWithoutTables() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("SET PASSWORD FOR app = 'x'"); + + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(TablesNamesFinder.findTables(statement.toString())).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = {"SET PASSWORD FOR app", "SET PASSWORD = 'x' REPLACE", + "SET PASSWORD TO 'x'", "SET PASSWORD FOR app TO RANDOM RETAIN PASSWORD", + "SET PASSWORD FOR app IDENTIFIED BY 'x' = 'y'"}) + void rejectsSyntaxOutsideTheStatementDefinition(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/SetRoleStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/SetRoleStatementTest.java new file mode 100644 index 0000000000..8b24d9bd16 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/SetRoleStatementTest.java @@ -0,0 +1,175 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.user.RoleSelection; +import net.sf.jsqlparser.statement.create.user.RoleSelection.Kind; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL SET ROLE and SET DEFAULT ROLE; PostgreSQL SET ROLE stays a {@link SetStatement}. */ +class SetRoleStatementTest { + + private static T parse(Class type, String sql, Dialect dialect) + throws JSQLParserException { + T statement = assertInstanceOf(type, TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(dialect))); + assertEquals(sql, assertInstanceOf(type, + CCJSqlParserUtil.parse(statement.toString(), parser -> parser.withDialect(dialect))) + .toString()); + return statement; + } + + private static List names(RoleSelection roles) { + return roles.getRoles().stream().map(UserAccount::toString).collect(Collectors.toList()); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "MARIADB"}) + void typesEverySetRoleFormInMySqlDialects(Dialect dialect) throws JSQLParserException { + assertEquals(Kind.DEFAULT, + parse(SetRoleStatement.class, "SET ROLE DEFAULT", dialect).getRoles().getKind()); + assertEquals(Kind.NONE, + parse(SetRoleStatement.class, "SET ROLE NONE", dialect).getRoles().getKind()); + assertEquals(Kind.ALL, + parse(SetRoleStatement.class, "SET ROLE ALL", dialect).getRoles().getKind()); + + RoleSelection except = + parse(SetRoleStatement.class, "SET ROLE ALL EXCEPT 'writer', 'admin'@'%'", dialect) + .getRoles(); + assertEquals(Kind.ALL_EXCEPT, except.getKind()); + assertEquals(List.of("'writer'", "'admin'@'%'"), names(except)); + + RoleSelection roles = + parse(SetRoleStatement.class, "SET ROLE 'reader', app_role", dialect).getRoles(); + assertEquals(Kind.ROLES, roles.getKind()); + assertEquals(List.of("'reader'", "app_role"), names(roles)); + } + + @Test + void keepsPostgreSqlSetRole() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.POSTGRESQL}) { + for (String sql : List.of("SET ROLE app_admin", "SET ROLE 'reader'", "SET ROLE NONE", + "SET ROLE DEFAULT", "SET ROLE ALL", "SET LOCAL ROLE 'app'", + "SET SESSION ROLE app")) { + assertInstanceOf(SetStatement.class, CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }), sql); + } + } + // variable assignments and scoped forms are not MySQL SET ROLE + for (String sql : List.of("SET role = 'x'", "SET LOCAL ROLE 'app'")) { + assertInstanceOf(SetStatement.class, + CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)), sql); + } + } + + @Test + void typesMySqlOnlyFormsWithoutDialect() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.ANSI_SQL, Dialect.POSTGRESQL}) { + assertEquals(Kind.ALL_EXCEPT, + parse(SetRoleStatement.class, "SET ROLE ALL EXCEPT 'writer'", dialect) + .getRoles().getKind()); + } + for (String sql : List.of("SET ROLE r1, 'r2'@'%'", "SET ROLE 'r'@localhost", + "SET ROLE r@'%'", "SET ROLE `r`@`%`")) { + assertInstanceOf(SetRoleStatement.class, + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false), sql); + } + // an unquoted r@h is one identifier, as before + assertInstanceOf(SetStatement.class, CCJSqlParserUtil.parse("SET ROLE r@h")); + } + + @Test + void setsDefaultRoles() throws JSQLParserException { + SetDefaultRoleStatement single = parse(SetDefaultRoleStatement.class, + "SET DEFAULT ROLE 'reader' TO 'app'@'%'", Dialect.MYSQL); + assertEquals(List.of("'reader'"), names(single.getRoles())); + assertEquals("app", single.getAccounts().get(0).getUser().getValue()); + assertFalse(single.isForKeyword()); + + SetDefaultRoleStatement all = parse(SetDefaultRoleStatement.class, + "SET DEFAULT ROLE ALL TO 'app'@'%', 'u2'@'%'", Dialect.MYSQL); + assertEquals(Kind.ALL, all.getRoles().getKind()); + assertEquals(2, all.getAccounts().size()); + + assertEquals(Kind.NONE, parse(SetDefaultRoleStatement.class, + "SET DEFAULT ROLE NONE TO app", Dialect.MYSQL).getRoles().getKind()); + // available without a dialect, as no generic SET form starts with SET DEFAULT ROLE + assertInstanceOf(SetDefaultRoleStatement.class, TestUtils + .assertSqlCanBeParsedAndDeparsed("SET DEFAULT ROLE r1, r2 TO app", false)); + } + + @Test + void setsMariaDbDefaultRole() throws JSQLParserException { + SetDefaultRoleStatement forUser = parse(SetDefaultRoleStatement.class, + "SET DEFAULT ROLE reader FOR 'app'@'localhost'", Dialect.MARIADB); + assertTrue(forUser.isForKeyword()); + assertEquals(1, forUser.getAccounts().size()); + + SetDefaultRoleStatement current = + parse(SetDefaultRoleStatement.class, "SET DEFAULT ROLE NONE", Dialect.MARIADB); + assertTrue(current.getAccounts().isEmpty()); + } + + @Test + void buildsAndDeparses() { + UserAccount reader = new UserAccount().withUser(new StringValue("reader")); + assertDeparse(new SetRoleStatement(new RoleSelection(Kind.ALL_EXCEPT).addRoles(reader)), + "SET ROLE ALL EXCEPT 'reader'"); + assertDeparse(new SetDefaultRoleStatement().withRoles(new RoleSelection(Kind.ROLES) + .addRoles(reader)).addAccounts(new UserAccount().withUser(new StringValue("app")) + .withHost(new StringValue("%"))), + "SET DEFAULT ROLE 'reader' TO 'app'@'%'"); + } + + @Test + void reportsStatementFeatures() throws JSQLParserException { + Statement setRole = + CCJSqlParserUtil.parse("SET ROLE ALL", parser -> parser.withDialect(Dialect.MYSQL)); + assertThat(setRole.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + + Statement setDefaultRole = CCJSqlParserUtil.parse("SET DEFAULT ROLE ALL TO app"); + assertThat(setDefaultRole.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(TablesNamesFinder.findTables(setDefaultRole.toString())).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = {"SET ROLE ALL EXCEPT", "SET ROLE 'r' IDENTIFIED BY 'x'", + "SET DEFAULT ROLE DEFAULT TO app", "SET DEFAULT ROLE ALL EXCEPT r TO app", + "SET DEFAULT ROLE TO app", "SET DEFAULT ROLE ALL TO"}) + void rejectsSyntaxOutsideTheStatementDefinition(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/SetStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/SetStatementTest.java index d2619c50aa..38168d0455 100644 --- a/src/test/java/net/sf/jsqlparser/statement/SetStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/SetStatementTest.java @@ -12,10 +12,14 @@ import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.StringValue; import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import java.lang.reflect.Modifier; import org.junit.jupiter.api.Test; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; /** @@ -74,7 +78,8 @@ public void testObject() { assertEquals(0, setStatement.getCount()); setStatement.addKeyValuePairs( - new SetStatement.NameExpr("test", new ExpressionList<>(new StringValue("1")), false)); + new SetStatement.NameExpr("test", new ExpressionList<>(new StringValue("1")), + false)); setStatement.getKeyValuePairs().get(0).setUseEqual(true); assertEquals("test", setStatement.getKeyValuePairs().get(0).getName()); @@ -99,4 +104,36 @@ public void testMultiPartVariables() throws JSQLParserException { String sqlStr = "set a.b.c=false"; assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + + @Test + public void testTypedScopeKeepsTheEffectParameterAccessors() throws JSQLParserException { + SetStatement set = (SetStatement) CCJSqlParserUtil.parse("set local statement_timeout = 0"); + assertEquals(SetScope.LOCAL, set.getScope()); + assertEquals("LOCAL", set.getEffectParameter()); + // the scope keyword is rendered in upper case + assertEquals("SET LOCAL statement_timeout = 0", set.toString()); + set.setEffectParameter("persist_only"); + assertEquals(SetScope.PERSIST_ONLY, set.getScope()); + assertEquals("SET PERSIST_ONLY statement_timeout = 0", set.toString()); + set.withScope(null); + assertEquals(SetScope.NONE, set.getScope()); + assertNull(set.getEffectParameter()); + assertEquals("SET statement_timeout = 0", set.toString()); + assertThrows(IllegalArgumentException.class, () -> set.setEffectParameter("forever")); + set.withEffectParameter("Session").clear(); + assertEquals(SetScope.NONE, set.getScope()); + assertEquals(SetScope.SESSION, + ((SetStatement) CCJSqlParserUtil.parse("SET SESSION x = 1")).getScope()); + } + + @Test + public void testNameExprIsPublic() throws JSQLParserException { + assertTrue(Modifier.isPublic(SetStatement.NameExpr.class.getModifiers())); + SetStatement set = (SetStatement) CCJSqlParserUtil.parse("SET a = 1, b := 2"); + SetStatement.NameExpr second = set.getKeyValuePairs().get(1); + assertEquals(SetStatement.AssignmentOperator.COLON_EQUALS, second.getAssignmentOperator()); + second.setAssignmentOperator(SetStatement.AssignmentOperator.EQUALS); + assertEquals("SET a = 1, b = 2", set.toString()); + assertThrows(NullPointerException.class, () -> second.setAssignmentOperator(null)); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/SetTransactionStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/SetTransactionStatementTest.java new file mode 100644 index 0000000000..2efbabe889 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/SetTransactionStatementTest.java @@ -0,0 +1,347 @@ +/*- + * #%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; + +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.List; +import java.util.Locale; +import java.util.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +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.util.TablesNamesFinder; +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.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class SetTransactionStatementTest { + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + /** Parses, renders through toString and the deparser, reparses and checks the analysis. */ + private static SetTransactionStatement roundTrip(String sql, Dialect dialect, String expected) + throws Exception { + SetTransactionStatement statement = + assertInstanceOf(SetTransactionStatement.class, parse(sql, dialect)); + TransactionStatementTest.assertSpans(sql, sql, statement); + assertEquals(expected, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + assertEquals(expected, parse(expected, dialect).toString()); + assertEquals(Set.of(StmtFeature.MODIFIES_TRANSACTION), + statement.getFeatures().getCertain()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + return statement; + } + + static Stream mysqlForms() { + return Stream.of( + Arguments.of("SET TRANSACTION ISOLATION LEVEL READ COMMITTED", SetScope.NONE, + List.of(TransactionMode.ISOLATION_LEVEL_READ_COMMITTED)), + Arguments.of("SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ ONLY", + SetScope.SESSION, + List.of(TransactionMode.ISOLATION_LEVEL_REPEATABLE_READ, + TransactionMode.READ_ONLY)), + Arguments.of("SET GLOBAL TRANSACTION READ WRITE", SetScope.GLOBAL, + List.of(TransactionMode.READ_WRITE)), + Arguments.of("SET GLOBAL TRANSACTION READ ONLY, ISOLATION LEVEL SERIALIZABLE", + SetScope.GLOBAL, + List.of(TransactionMode.READ_ONLY, + TransactionMode.ISOLATION_LEVEL_SERIALIZABLE)), + Arguments.of("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED", SetScope.NONE, + List.of(TransactionMode.ISOLATION_LEVEL_READ_UNCOMMITTED))); + } + + @ParameterizedTest + @MethodSource("mysqlForms") + void mysqlScopesAndCharacteristics(String sql, SetScope scope, List modes) + throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, null}) { + SetTransactionStatement statement = roundTrip(sql, dialect, sql); + assertEquals(scope, statement.getScope()); + assertEquals(modes, statement.getModes()); + assertFalse(statement.isSessionCharacteristics()); + assertNull(statement.getSnapshotId()); + } + } + + static Stream scopedForms() { + List all = List.of(Dialect.MYSQL, Dialect.MARIADB, Dialect.POSTGRESQL); + List mysqlOnly = List.of(Dialect.MYSQL); + List mysqlAndMariaDb = List.of(Dialect.MYSQL, Dialect.MARIADB); + return Stream.of( + Arguments.of("SET LOCAL TRANSACTION READ ONLY", SetScope.LOCAL, all), + Arguments.of("SET LOCAL TRANSACTION ISOLATION LEVEL SERIALIZABLE", SetScope.LOCAL, + all), + Arguments.of("SET LOCAL TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY", + SetScope.LOCAL, all), + Arguments.of("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED", + SetScope.SESSION, all), + Arguments.of("SET GLOBAL TRANSACTION READ ONLY", SetScope.GLOBAL, mysqlAndMariaDb), + Arguments.of("SET PERSIST TRANSACTION READ ONLY", SetScope.PERSIST, mysqlOnly), + Arguments.of("SET PERSIST_ONLY TRANSACTION ISOLATION LEVEL READ COMMITTED", + SetScope.PERSIST_ONLY, mysqlOnly), + Arguments.of("set persist_only transaction read write", SetScope.PERSIST_ONLY, + mysqlOnly)); + } + + @ParameterizedTest + @MethodSource("scopedForms") + void scopesFollowEachServerGrammar(String sql, SetScope scope, List accepting) + throws Exception { + String expected = sql.toUpperCase(Locale.ROOT); + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, Dialect.POSTGRESQL, + null}) { + if (dialect == null || accepting.contains(dialect)) { + SetTransactionStatement statement = roundTrip(sql, dialect, expected); + assertEquals(scope, statement.getScope()); + assertFalse(statement.isSessionCharacteristics()); + } else { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), + sql + " with " + dialect); + } + } + } + + @Test + void postgresTransactionCharacteristicsAcceptSpacesAndCommas() throws Exception { + SetTransactionStatement statement = + roundTrip("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY DEFERRABLE", + Dialect.POSTGRESQL, + "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE"); + assertEquals(SetScope.NONE, statement.getScope()); + assertEquals( + List.of(TransactionMode.ISOLATION_LEVEL_SERIALIZABLE, TransactionMode.READ_ONLY, + TransactionMode.DEFERRABLE), + statement.getModes()); + roundTrip("SET TRANSACTION ISOLATION LEVEL READ COMMITTED", Dialect.POSTGRESQL, + "SET TRANSACTION ISOLATION LEVEL READ COMMITTED"); + roundTrip("SET TRANSACTION READ WRITE, NOT DEFERRABLE", Dialect.POSTGRESQL, + "SET TRANSACTION READ WRITE, NOT DEFERRABLE"); + assertEquals(SetScope.SESSION, + roundTrip("SET SESSION TRANSACTION READ ONLY", Dialect.POSTGRESQL, + "SET SESSION TRANSACTION READ ONLY").getScope()); + } + + @ParameterizedTest + @ValueSource(strings = {"SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE", + "set session characteristics as transaction read only"}) + void postgresSessionCharacteristics(String sql) throws Exception { + String expected = sql.toUpperCase(Locale.ROOT); + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + SetTransactionStatement statement = roundTrip(sql, dialect, expected); + assertEquals(SetScope.NONE, statement.getScope()); + assertTrue(statement.isSessionCharacteristics()); + assertFalse(statement.getModes().isEmpty()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET LOCAL SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET SESSION SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE"}) + void postgresScopeBeforeSessionCharacteristicsIsKept(String sql) throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + SetTransactionStatement statement = roundTrip(sql, dialect, sql); + assertEquals(sql.startsWith("SET LOCAL") ? SetScope.LOCAL : SetScope.SESSION, + statement.getScope()); + assertTrue(statement.isSessionCharacteristics()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET TRANSACTION SNAPSHOT '00000003-0000001B-1'", + "SET SESSION TRANSACTION SNAPSHOT '00000003-0000001B-1'", + "SET LOCAL TRANSACTION SNAPSHOT '00000003-0000001B-1'"}) + void postgresSnapshotKeepsTheStringLiteral(String sql) throws Exception { + SetScope scope = sql.startsWith("SET SESSION") ? SetScope.SESSION + : sql.startsWith("SET LOCAL") ? SetScope.LOCAL : SetScope.NONE; + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + SetTransactionStatement statement = roundTrip(sql, dialect, sql); + StringValue snapshot = statement.getSnapshotId(); + assertEquals("00000003-0000001B-1", snapshot.getValue()); + TransactionStatementTest.assertSpans("'00000003-0000001B-1'", sql, snapshot); + assertTrue(statement.getModes().isEmpty()); + assertEquals(scope, statement.getScope()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET TRANSACTION ISOLATION LEVEL READ COMMITTED READ ONLY", + "SET TRANSACTION READ ONLY, READ WRITE", + "SET TRANSACTION ISOLATION LEVEL READ COMMITTED, ISOLATION LEVEL SERIALIZABLE", + "SET TRANSACTION DEFERRABLE", "SET SESSION TRANSACTION NOT DEFERRABLE", + "SET TRANSACTION WITH CONSISTENT SNAPSHOT", + "SET TRANSACTION SNAPSHOT '00000003-0000001B-1'", + "SET SESSION TRANSACTION SNAPSHOT '1'", "SET LOCAL TRANSACTION SNAPSHOT '1'", + "SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET LOCAL SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET SESSION SESSION CHARACTERISTICS AS TRANSACTION READ ONLY"}) + void mysqlRejectsPostgresOnlyAndRepeatedCharacteristics(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL)); + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MARIADB)); + } + + @ParameterizedTest + @ValueSource(strings = {"SET GLOBAL TRANSACTION READ ONLY", + "SET PERSIST TRANSACTION READ ONLY", + "SET PERSIST_ONLY TRANSACTION ISOLATION LEVEL READ COMMITTED", + "SET TRANSACTION WITH CONSISTENT SNAPSHOT"}) + void postgresRejectsMysqlOnlyForms(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"SET GLOBAL TRANSACTION SNAPSHOT 'x'", + "SET PERSIST TRANSACTION SNAPSHOT 'x'", + "SET PERSIST SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET GLOBAL SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET PERSIST_ONLY SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + "SET SESSION CHARACTERISTICS AS TRANSACTION SNAPSHOT '1'", + "SET LOCAL SESSION CHARACTERISTICS AS TRANSACTION SNAPSHOT '1'"}) + void scopesThatNoServerAcceptsAreRejected(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.MYSQL, Dialect.MARIADB, + null}) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET TRANSACTION ISOLATION LEVEL", "SET TRANSACTION READ", + "SET TRANSACTION READ ONLY,", "SET TRANSACTION , READ ONLY", + "SET SESSION CHARACTERISTICS AS TRANSACTION", + "SET SESSION CHARACTERISTICS TRANSACTION READ ONLY", + "SET TRANSACTION ISOLATION LEVEL READ COMMITTED garbage"}) + void malformedFormsAreRejected(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.MYSQL, null}) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET SESSION work_mem TO DEFAULT", "SET LOCAL statement_timeout = '5s'", + "SET @@SESSION.sql_mode = 'STRICT_TRANS_TABLES'", + "SET transaction_isolation = 'READ-COMMITTED'", + "SET SESSION transaction_isolation = 'READ-COMMITTED'", "SET transaction = 1", + "SET LOCAL transaction = 1", + "SET LOCAL transaction_isolation = 'READ-COMMITTED'", + "SET GLOBAL transaction_isolation = 'READ-COMMITTED'", + "SET PERSIST transaction_isolation = 'READ-COMMITTED'", + "SET PERSIST_ONLY transaction_isolation = 'READ-COMMITTED'", + "SET SESSION AUTHORIZATION DEFAULT"}) + void variableAssignmentsRemainSetStatements(String sql) throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.MYSQL, null}) { + if (sql.contains(" TO ") && dialect == Dialect.MYSQL + || sql.contains("AUTHORIZATION") && dialect == Dialect.MYSQL) { + continue; + } + Statement statement = parse(sql, dialect); + assertInstanceOf(SetStatement.class, statement, sql); + assertEquals(sql, statement.toString()); + } + } + + @Test + void modelCanBeBuiltAndChanged() throws Exception { + SetTransactionStatement statement = new SetTransactionStatement() + .withScope(SetScope.GLOBAL).addMode(TransactionMode.READ_ONLY); + assertEquals("SET GLOBAL TRANSACTION READ ONLY", statement.toString()); + statement.setScope(SetScope.PERSIST_ONLY); + assertEquals("SET PERSIST_ONLY TRANSACTION READ ONLY", statement.toString()); + statement.withScope(null).withSessionCharacteristics(true).getModes().set(0, + TransactionMode.READ_WRITE); + assertEquals(SetScope.NONE, statement.getScope()); + assertEquals("SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE", statement.toString()); + statement.setScope(SetScope.LOCAL); + assertTrue(statement.isSessionCharacteristics()); + assertEquals("SET LOCAL SESSION CHARACTERISTICS AS TRANSACTION READ WRITE", + statement.toString()); + statement.withSessionCharacteristics(false).setScope(null); + assertEquals(SetScope.NONE, statement.getScope()); + assertFalse(statement.isSessionCharacteristics()); + statement.getModes().clear(); + statement.withSnapshotId(new StringValue("snap")); + assertEquals("SET TRANSACTION SNAPSHOT 'snap'", statement.toString()); + assertEquals(statement.toString(), + parse(statement.toString(), Dialect.POSTGRESQL).toString()); + assertThrows(NullPointerException.class, () -> statement.addMode(null)); + } + + @Test + void visitorsAndStatementBoundaries() throws Exception { + Statement statement = parse("SET TRANSACTION READ ONLY", Dialect.POSTGRESQL); + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(SetTransactionStatement set, S context) { + return context + ":" + set.getModes(); + } + }; + assertEquals("ctx:[READ ONLY]", statement.accept(visitor, "ctx")); + assertNull(statement.accept(new StatementVisitorAdapter<>(), null)); + Statements script = CCJSqlParserUtil.parseStatements( + "SET TRANSACTION READ ONLY; SELECT 1; SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE", + p -> p.withDialect(Dialect.POSTGRESQL)); + assertEquals(3, script.size()); + assertInstanceOf(SetTransactionStatement.class, script.get(0)); + assertInstanceOf(SetTransactionStatement.class, script.get(2)); + } + + @Test + void validationSeparatesMysqlAndPostgresForms() { + FeatureConfiguration none = new FeatureConfiguration(); + assertTrue(new Validation(none, List.of(MySqlVersion.V8_0), + "SET GLOBAL TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY; " + + "SET SESSION TRANSACTION READ WRITE") + .validate().isEmpty()); + assertFalse(new Validation(none, List.of(MySqlVersion.V8_0), + "SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY").validate().isEmpty()); + assertFalse(new Validation(none, List.of(MySqlVersion.V8_0), + "SET TRANSACTION SNAPSHOT 'x'").validate().isEmpty()); + assertTrue(new Validation(none, List.of(PostgresqlVersion.V10), + "SET TRANSACTION ISOLATION LEVEL READ COMMITTED DEFERRABLE; " + + "SET TRANSACTION SNAPSHOT 'x'; " + + "SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY") + .validate().isEmpty()); + assertFalse(new Validation(none, List.of(PostgresqlVersion.V10), + "SET GLOBAL TRANSACTION READ ONLY").validate().isEmpty()); + assertFalse(new Validation(new FeatureConfiguration().setValue(Feature.dialect, + Dialect.MYSQL.name()), List.of(MySqlVersion.V8_0), + "SET TRANSACTION READ ONLY, READ WRITE").validate().isEmpty()); + assertTrue(new Validation(none, List.of(MySqlVersion.V8_0), + "SET PERSIST TRANSACTION READ ONLY; SET PERSIST_ONLY TRANSACTION READ WRITE; " + + "SET LOCAL TRANSACTION ISOLATION LEVEL SERIALIZABLE") + .validate().isEmpty()); + assertTrue(new Validation(none, List.of(PostgresqlVersion.V10), + "SET LOCAL TRANSACTION READ ONLY; SET SESSION TRANSACTION SNAPSHOT 'x'; " + + "SET LOCAL SESSION CHARACTERISTICS AS TRANSACTION READ ONLY") + .validate().isEmpty()); + assertFalse(new Validation(none, List.of(PostgresqlVersion.V10), + "SET PERSIST TRANSACTION READ ONLY").validate().isEmpty()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/ShowColumnsStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/ShowColumnsStatementTest.java index 825a18def0..71c3b81f4c 100644 --- a/src/test/java/net/sf/jsqlparser/statement/ShowColumnsStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/ShowColumnsStatementTest.java @@ -9,9 +9,28 @@ */ package net.sf.jsqlparser.statement; -import net.sf.jsqlparser.JSQLParserException; +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; 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.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; /** * @@ -19,8 +38,154 @@ */ public class ShowColumnsStatementTest { + private static final List> DIALECTS = List.of(parser -> { + }, parser -> parser.withDialect(Dialect.MYSQL), + parser -> parser.withDialect(Dialect.MARIADB)); + + /** Parses without a dialect and with MySQL and MariaDB, then deparses and reparses. */ + private static ShowColumnsStatement roundTrip(String sql) throws JSQLParserException { + ShowColumnsStatement result = null; + for (Consumer dialect : DIALECTS) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(ShowColumnsStatement.class, statement); + assertDeparse(statement, sql); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + result = (ShowColumnsStatement) statement; + } + return result; + } + @Test public void testSimpleUse() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed("SHOW COLUMNS FROM mydatabase"); } + + @Test + void plainFormKeepsTheTableNameApi() throws JSQLParserException { + ShowColumnsStatement show = roundTrip("SHOW COLUMNS FROM mytable"); + + assertEquals("mytable", show.getTableName()); + assertEquals("mytable", show.getTable().getName()); + assertFalse(show.isExtended()); + assertFalse(show.isFull()); + assertFalse(show.isFieldsKeyword()); + assertEquals(SelectionMode.FROM, show.getTableSelectionMode()); + assertNull(show.getDbName()); + assertNull(show.getLikeExpression()); + assertNull(show.getWhereCondition()); + } + + @Test + void fullColumnsWithDatabaseAndLike() throws JSQLParserException { + ShowColumnsStatement show = roundTrip("SHOW FULL COLUMNS FROM gc20 FROM v LIKE 'n%'"); + + assertTrue(show.isFull()); + assertEquals("gc20", show.getTableName()); + assertEquals(SelectionMode.FROM, show.getDbSelectionMode()); + assertEquals("v", show.getDbName()); + assertEquals("n%", ((StringValue) show.getLikeExpression()).getValue()); + } + + @Test + void extendedFullFieldsInWithWhere() throws JSQLParserException { + ShowColumnsStatement show = + roundTrip("SHOW EXTENDED FULL FIELDS IN db.t IN `other` WHERE `Key` = 'PRI'"); + + assertTrue(show.isExtended()); + assertTrue(show.isFull()); + assertTrue(show.isFieldsKeyword()); + assertEquals(SelectionMode.IN, show.getTableSelectionMode()); + assertEquals("db", show.getTable().getSchemaName()); + assertEquals("db.t", show.getTableName()); + assertEquals(SelectionMode.IN, show.getDbSelectionMode()); + assertEquals("`other`", show.getDbName()); + assertEquals("`Key` = 'PRI'", show.getWhereCondition().toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SHOW FIELDS FROM t", + "SHOW FULL FIELDS FROM gc20", + "SHOW COLUMNS IN t", + "SHOW COLUMNS FROM `db`.`t`", + "SHOW COLUMNS FROM t IN db", + "SHOW EXTENDED COLUMNS FROM t", + "SHOW COLUMNS FROM t LIKE 'a%'", + "SHOW FULL COLUMNS FROM t WHERE Comment <> ''" + }) + void parsesEveryMySqlForm(String sql) throws JSQLParserException { + roundTrip(sql); + } + + @Test + void keywordsAreCaseInsensitive() throws JSQLParserException { + assertEquals("SHOW FULL FIELDS IN t FROM db", + CCJSqlParserUtil.parse("show full fields in t from db").toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SHOW COLUMNS IN SCHEMA s", + "SHOW COLUMNS IN TABLE t", + "SHOW COLUMNS LIKE 'x' IN TABLE t", + "SHOW COLUMNS FROM t NOT LIKE 'x'", + "SHOW COLUMNS FROM t FROM db LIMIT 3", + "SHOW FULL FUNCTIONS" + }) + void otherDialectFormsRemainUnsupported(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true); + assertInstanceOf(UnsupportedStatement.class, statement); + } + + @Test + void endsAtTheStatementBoundary() throws JSQLParserException { + Statements statements = + CCJSqlParserUtil.parseStatements("SHOW FULL COLUMNS FROM t;\nSELECT 1"); + + assertEquals(2, statements.size()); + assertInstanceOf(ShowColumnsStatement.class, statements.get(0)); + + IfElseStatement ifElse = (IfElseStatement) CCJSqlParserUtil + .parse("IF a = 1 SHOW COLUMNS FROM t ELSE SHOW TABLE STATUS"); + assertInstanceOf(ShowColumnsStatement.class, ifElse.getIfStatement()); + assertEquals("SHOW TABLE STATUS", ifElse.getElseStatement().toString()); + } + + @Test + void findsTheTable() throws JSQLParserException { + assertThat(TablesNamesFinder.findTables("SHOW FULL COLUMNS FROM s.t")) + .containsExactly("s.t"); + // the trailing FROM db names the database of the table + assertThat(TablesNamesFinder.findTables("SHOW COLUMNS FROM t FROM db")) + .containsExactly("db.t"); + } + + @Test + void legacyTableNameAccessors() { + ShowColumnsStatement show = new ShowColumnsStatement("db.t"); + + assertEquals("db", show.getTable().getSchemaName()); + assertEquals("db.t", show.getTableName()); + assertEquals("SHOW COLUMNS FROM db.t", show.toString()); + assertEquals("SHOW COLUMNS FROM t2", show.withTableName("t2").toString()); + show.setTableName(null); + assertNull(show.getTable()); + } + + @Test + void buildsAndDeparses() { + ShowColumnsStatement show = new ShowColumnsStatement(new Table("t")).withFull(true) + .withFieldsKeyword(true).withTableSelectionMode(SelectionMode.IN) + .withDbName("db").withLikeExpression(new StringValue("a%")); + + assertDeparse(show, "SHOW FULL FIELDS IN t FROM db LIKE 'a%'"); + } + + @Test + void reportsMetadataFeatures() throws JSQLParserException { + StatementFeatures features = + CCJSqlParserUtil.parse("SHOW FULL COLUMNS FROM t").getFeatures(); + + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/ShowIndexStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/ShowIndexStatementTest.java index 0350fd585d..0d432d9081 100644 --- a/src/test/java/net/sf/jsqlparser/statement/ShowIndexStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/ShowIndexStatementTest.java @@ -9,9 +9,31 @@ */ package net.sf.jsqlparser.statement; -import net.sf.jsqlparser.JSQLParserException; +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; 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.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.show.ShowDbSelection; +import net.sf.jsqlparser.statement.show.ShowIndexStatement; +import net.sf.jsqlparser.statement.show.ShowIndexStatement.Keyword; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; /** * @@ -20,8 +42,137 @@ public class ShowIndexStatementTest { + private static final List> DIALECTS = List.of(parser -> { + }, parser -> parser.withDialect(Dialect.MYSQL), + parser -> parser.withDialect(Dialect.MARIADB)); + + /** Parses without a dialect and with MySQL and MariaDB, then deparses and reparses. */ + private static ShowIndexStatement roundTrip(String sql) throws JSQLParserException { + ShowIndexStatement result = null; + for (Consumer dialect : DIALECTS) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(ShowIndexStatement.class, statement); + assertDeparse(statement, sql); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + result = (ShowIndexStatement) statement; + } + return result; + } + @Test public void testSimpleUse() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed("SHOW INDEX FROM mydatabase"); } + + @Test + void legacyForm() throws JSQLParserException { + ShowIndexStatement show = roundTrip("SHOW INDEX FROM mytable"); + + assertEquals("mytable", show.getTableName()); + assertEquals(Keyword.INDEX, show.getKeyword()); + assertEquals(SelectionMode.FROM, show.getTableSelectionMode()); + assertFalse(show.isExtended()); + assertNull(show.getDbSelection()); + assertNull(show.getWhereCondition()); + } + + @Test + void trailingDatabase() throws JSQLParserException { + ShowIndexStatement show = roundTrip("SHOW INDEX FROM t FROM v"); + + assertEquals("t", show.getTableName()); + assertEquals("v", show.getDbName()); + assertEquals(SelectionMode.FROM, show.getDbSelection().getSelectionMode()); + assertEquals("v.t", show.getQualifiedTable().getFullyQualifiedName()); + } + + @Test + void extendedIndexesInTable() throws JSQLParserException { + ShowIndexStatement show = roundTrip("SHOW EXTENDED INDEXES IN t"); + + assertTrue(show.isExtended()); + assertEquals(Keyword.INDEXES, show.getKeyword()); + assertEquals(SelectionMode.IN, show.getTableSelectionMode()); + } + + @Test + void keysOfQualifiedTableWithWhere() throws JSQLParserException { + ShowIndexStatement show = + roundTrip("SHOW KEYS FROM db.t IN `other` WHERE Key_name = 'PRIMARY'"); + + assertEquals(Keyword.KEYS, show.getKeyword()); + assertEquals("db", show.getTable().getSchemaName()); + assertEquals(SelectionMode.IN, show.getDbSelection().getSelectionMode()); + assertEquals("`other`.t", show.getQualifiedTable().getFullyQualifiedName()); + assertEquals("Key_name = 'PRIMARY'", show.getWhereCondition().toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW INDEXES FROM t", "SHOW KEYS IN t", "SHOW EXTENDED INDEX FROM t", + "SHOW INDEX IN t IN db", + "SHOW EXTENDED KEYS FROM `t` FROM `db` WHERE Seq_in_index > 1"}) + void variants(String sql) throws JSQLParserException { + roundTrip(sql); + } + + @Test + void keywordsAreCaseInsensitive() throws JSQLParserException { + assertEquals("SHOW INDEXES FROM my_table", + CCJSqlParserUtil.parse("show indexes from my_table").toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW INDEXES IN TABLE t", "SHOW INDEX FROM t LIKE 'x'", + "SHOW FULL INDEX FROM t"}) + void otherFormsRemainUnsupported(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true); + assertInstanceOf(UnsupportedStatement.class, statement); + assertInstanceOf(ShowStatement.class, CCJSqlParserUtil.parse("SHOW INDEXES")); + } + + @Test + void endsAtTheStatementBoundary() throws JSQLParserException { + Statements statements = + CCJSqlParserUtil.parseStatements("SHOW INDEX FROM t FROM db;\nSELECT 1"); + + assertEquals(2, statements.size()); + assertInstanceOf(ShowIndexStatement.class, statements.get(0)); + } + + @Test + void findsTheTable() throws JSQLParserException { + // used to throw UnsupportedOperationException + assertThat(TablesNamesFinder.findTables("SHOW INDEX FROM s.t")).containsExactly("s.t"); + assertThat(TablesNamesFinder.findTables("SHOW KEYS FROM t IN db")).containsExactly("db.t"); + } + + @Test + void legacyAccessorsAndBuilders() { + ShowIndexStatement show = new ShowIndexStatement("db.t"); + + assertEquals("db", show.getTable().getSchemaName()); + assertEquals("SHOW INDEX FROM db.t", show.toString()); + assertEquals("SHOW INDEX FROM t2", show.withTableName("t2").toString()); + + show = new ShowIndexStatement(new Table("t")).withExtended(true) + .withKeyword(Keyword.KEYS).withTableSelectionMode(SelectionMode.IN) + .withDbSelection(new ShowDbSelection("db")) + .withWhereCondition(new Column("Non_unique")); + assertDeparse(show, "SHOW EXTENDED KEYS IN t FROM db WHERE Non_unique"); + + show.setKeyword(null); + show.setTableSelectionMode(null); + assertEquals("SHOW EXTENDED INDEX FROM t FROM db WHERE Non_unique", show.toString()); + show.setTableName(null); + assertNull(show.getTable()); + assertNull(show.getQualifiedTable()); + } + + @Test + void reportsMetadataFeatures() throws JSQLParserException { + StatementFeatures features = + CCJSqlParserUtil.parse("SHOW INDEX FROM t FROM db").getFeatures(); + + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/ShowStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/ShowStatementTest.java index 7f10338964..698c1f9811 100644 --- a/src/test/java/net/sf/jsqlparser/statement/ShowStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/ShowStatementTest.java @@ -10,10 +10,21 @@ package net.sf.jsqlparser.statement; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.show.ShowCreateStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.function.Consumer; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.assertj.core.api.Assertions.assertThat; /** * @@ -21,6 +32,9 @@ */ public class ShowStatementTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + @Test public void testSimpleUse() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed("SHOW mydatabase"); @@ -38,11 +52,64 @@ void testShowIndexesFromTable() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "SHOW TIME ZONE | Time Zone", + "SHOW TRANSACTION ISOLATION LEVEL | TRANSACTION ISOLATION LEVEL", + "SHOW SESSION AUTHORIZATION | SESSION AUTHORIZATION", + "show time zone | Time Zone", + "show transaction isolation level | TRANSACTION ISOLATION LEVEL"}) + void readsPostgreSqlParameterPhrasesWithPostgreSqlAndWithoutDialect(String sql, String name) + throws JSQLParserException { + for (Statement statement : new Statement[] {CCJSqlParserUtil.parse(sql, POSTGRESQL), + CCJSqlParserUtil.parse(sql)}) { + ShowStatement show = Assertions.assertInstanceOf(ShowStatement.class, statement); + Assertions.assertEquals(name, show.getName()); + Assertions.assertEquals("SHOW " + name, show.toString()); + assertSqlCanBeParsedAndDeparsed(show.toString(), false, POSTGRESQL); + assertThat(new TablesNamesFinder<>().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.RETURNS_RESULT_SET); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW TIME ZONE x", "SHOW TRANSACTION ISOLATION", + "SHOW TRANSACTION ISOLATION LEVEL x", "SHOW DATE ZONE", + "SHOW SESSION AUTHORIZATION ALL"}) + void otherWordsStayUnsupported(String sql) throws JSQLParserException { + Assertions.assertInstanceOf(UnsupportedStatement.class, + CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @Test + void otherDialectsKeepTheGenericReading() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.ORACLE, Dialect.SNOWFLAKE}) { + for (String sql : new String[] {"SHOW TIME ZONE", "SHOW TRANSACTION ISOLATION LEVEL", + "SHOW SESSION AUTHORIZATION"}) { + Assertions.assertInstanceOf(UnsupportedStatement.class, + CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), sql); + } + } + } + + @Test + void parameterPhrasesEndAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SHOW TIME ZONE; SHOW SESSION AUTHORIZATION\nSELECT 1;" + + "SHOW TRANSACTION ISOLATION LEVEL\nDISCARD ALL", + POSTGRESQL); + Assertions.assertEquals(5, statements.size()); + Assertions.assertEquals("SHOW SESSION AUTHORIZATION", statements.get(1).toString()); + Assertions.assertEquals("SHOW TRANSACTION ISOLATION LEVEL", statements.get(3).toString()); + Assertions.assertInstanceOf(DiscardStatement.class, statements.get(4)); + } + @Test void testShowCreateTable() throws JSQLParserException { String sqlStr = "show create table my_table"; Statement statement = assertSqlCanBeParsedAndDeparsed(sqlStr, true); - Assertions.assertTrue(statement instanceof UnsupportedStatement); + Assertions.assertTrue(statement instanceof ShowCreateStatement); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/SqlServerRoutineTest.java b/src/test/java/net/sf/jsqlparser/statement/SqlServerRoutineTest.java index f1644d0e3a..c579a10124 100644 --- a/src/test/java/net/sf/jsqlparser/statement/SqlServerRoutineTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/SqlServerRoutineTest.java @@ -21,7 +21,7 @@ import net.sf.jsqlparser.statement.create.function.CreateFunction; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.CheckConstraint; -import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; import net.sf.jsqlparser.util.TablesNamesFinder; import net.sf.jsqlparser.util.deparser.ExpressionDeParser; @@ -74,7 +74,7 @@ void exposesIssue715ReturnTableAndConstraintExpressions() throws Exception { List columns = statement.getReturnType().getTableElements(ColumnDefinition.class); assertEquals(2, columns.size()); - assertEquals(2, statement.getReturnType().getTableElements(Index.class).size()); + assertEquals(2, statement.getReturnType().getTableElements(NamedConstraint.class).size()); assertEquals("id", columns.get(0).getColumnName()); List visited = new ArrayList<>(); ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { diff --git a/src/test/java/net/sf/jsqlparser/statement/StatementFeatureFallbackTest.java b/src/test/java/net/sf/jsqlparser/statement/StatementFeatureFallbackTest.java new file mode 100644 index 0000000000..7826cddd85 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/StatementFeatureFallbackTest.java @@ -0,0 +1,162 @@ +/*- + * #%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; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.List; +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.schema.Column; +import net.sf.jsqlparser.statement.create.function.CreateFunction; +import net.sf.jsqlparser.statement.oracle.OracleAssignment; +import net.sf.jsqlparser.statement.oracle.OracleNullStatement; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class StatementFeatureFallbackTest { + private static final class UnclassifiedStatement implements Statement { + @Override + public T accept(StatementVisitor visitor, S context) { + return null; + } + } + + private static void assertOpaque(StatementFeatures features, String... references) { + assertThat(features.getCertain()).containsExactly(StmtFeature.OPAQUE); + assertThat(features.getUncertain()).containsExactlyInAnyOrder(StmtFeature.READS_DATA, + StmtFeature.RETURNS_RESULT_SET, StmtFeature.MODIFIES_DATA, + StmtFeature.MODIFIES_SCHEMA); + assertThat(features.getUnresolvedReferences()).containsExactlyInAnyOrder(references); + } + + @Test + void unclassifiedStatementHasNoCatalogueReference() { + Statement statement = new UnclassifiedStatement(); + assertOpaque(statement.getFeatures()); + assertOpaque(statement.getFeatures(name -> true)); + assertOpaque(StatementFeatureVisitor.analyse(statement)); + } + + @Test + void anonymousStatementHasNoEmptyReference() { + Statement statement = new Statement() { + @Override + public T accept(StatementVisitor visitor, S context) { + return null; + } + }; + assertOpaque(statement.getFeatures()); + } + + @Test + void inertOracleStatementRetainsConservativeFallback() { + assertOpaque(new OracleNullStatement().getFeatures()); + assertOpaque(new OracleAssignment(new Column("x"), new LongValue(1)).getFeatures()); + } + + @Test + void fallbackPreservesFunctionReferenceFoundBeforeClassification() { + Function function = new Function(); + function.setName("Unproven_Function"); + Statement assignment = new OracleAssignment(new Column("x"), function); + assertOpaque(assignment.getFeatures(), "unproven_function"); + assertOpaque(assignment.getFeatures(name -> name.equals("unproven_function"))); + } + + @ParameterizedTest + @ValueSource(ints = {0, 1, 2}) + void aggregateFallbackHasNoContainerReference(int count) { + Statements script = new Statements(); + for (int i = 0; i < count; i++) { + script.add(new UnclassifiedStatement()); + } + assertOpaque(StatementFeatureVisitor.analyse(script)); + assertOpaque(StatementFeatureVisitor.analyse(script, name -> true)); + List each = StatementFeatureVisitor.analyseEach(script); + assertThat(each).hasSize(count); + each.forEach(StatementFeatureFallbackTest::assertOpaque); + } + + @Test + void perStatementAnalysisDoesNotLeakReferencesOrResultPositions() throws Exception { + Statements script = new Statements(); + script.add(CCJSqlParserUtil.parse("CALL Do_Something(1)")); + script.add(new UnclassifiedStatement()); + script.add(CCJSqlParserUtil.parse("SELECT 1")); + List each = StatementFeatureVisitor.analyseEach(script); + assertOpaque(each.get(0), "do_something"); + assertOpaque(each.get(1)); + assertThat(each.get(2).getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + assertThat(each.get(2).getUncertain()).isEmpty(); + assertThat(each.get(2).getUnresolvedReferences()).isEmpty(); + StatementFeatures union = StatementFeatureVisitor.analyse(script); + assertThat(union.getCertain()).containsExactlyInAnyOrder(StmtFeature.OPAQUE, + StmtFeature.RETURNS_RESULT_SET); + assertThat(union.getUncertain()).containsExactlyInAnyOrder(StmtFeature.READS_DATA, + StmtFeature.MODIFIES_DATA, StmtFeature.MODIFIES_SCHEMA); + assertThat(union.getUnresolvedReferences()).containsExactly("do_something"); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT 1", "CREATE TABLE t (id INTEGER)"}) + void classifiedStatementsDoNotFallBack(String sql) throws Exception { + StatementFeatures features = CCJSqlParserUtil.parse(sql).getFeatures(); + assertThat(features.getCertain()).containsExactly(sql.startsWith("SELECT") + ? StmtFeature.RETURNS_RESULT_SET + : StmtFeature.MODIFIES_SCHEMA); + assertThat(features.getUncertain()).isEmpty(); + assertThat(features.getUnresolvedReferences()).isEmpty(); + } + + @Test + void procedureAndDynamicSqlMarkersRemainResolvable() throws Exception { + assertOpaque(CCJSqlParserUtil.parse("CALL Do_Something(1)").getFeatures(), "do_something"); + assertOpaque(CCJSqlParserUtil.parse("DO 'BEGIN NULL; END'", + parser -> parser.withDialect(Dialect.POSTGRESQL)).getFeatures(), "do"); + assertOpaque(CCJSqlParserUtil.parse("some unsupported sql", + parser -> parser.withUnsupportedStatements(true)).getFeatures(), "unsupported"); + } + + @Test + void explainMarkerRemainsExplicit() throws Exception { + StatementFeatures features = CCJSqlParserUtil.parse("EXPLAIN SELECT 1").getFeatures(); + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + assertThat(features.getUncertain()).containsExactlyInAnyOrder(StmtFeature.MODIFIES_DATA, + StmtFeature.READS_DATA); + assertThat(features.getUnresolvedReferences()).containsExactly("explain"); + } + + @Test + void selectFunctionReferenceAndAllowListRemainEffective() throws Exception { + Statement statement = CCJSqlParserUtil.parse("SELECT Unproven_Function(1)"); + StatementFeatures features = statement.getFeatures(); + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + assertThat(features.getUncertain()).containsExactlyInAnyOrder(StmtFeature.MODIFIES_DATA, + StmtFeature.MODIFIES_SCHEMA); + assertThat(features.getUnresolvedReferences()).containsExactly("unproven_function"); + StatementFeatures pure = statement.getFeatures(name -> name.equals("unproven_function")); + assertThat(pure.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + assertThat(pure.getUncertain()).isEmpty(); + assertThat(pure.getUnresolvedReferences()).isEmpty(); + } + + @Test + void storedRoutineExplicitMarkerIsOutsideGenericFallback() { + StatementFeatures features = new CreateFunction().getFeatures(); + assertThat(features.getCertain()).containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(features.getUncertain()).containsExactlyInAnyOrder(StmtFeature.MODIFIES_DATA, + StmtFeature.READS_DATA); + assertThat(features.getUnresolvedReferences()).containsExactly("createfunction"); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorMetadataDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorMetadataDdlTest.java new file mode 100644 index 0000000000..26de5fae98 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorMetadataDdlTest.java @@ -0,0 +1,177 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.EnumSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.alter.AlterAggregate; +import net.sf.jsqlparser.statement.alter.AlterCollation; +import net.sf.jsqlparser.statement.alter.AlterConversion; +import net.sf.jsqlparser.statement.alter.AlterOperator; +import net.sf.jsqlparser.statement.alter.AlterOperatorClass; +import net.sf.jsqlparser.statement.alter.AlterOperatorFamily; +import net.sf.jsqlparser.statement.alter.AlterRule; +import net.sf.jsqlparser.statement.alter.AlterRoutine; +import net.sf.jsqlparser.statement.alter.AlterStatistics; +import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; +import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration; +import net.sf.jsqlparser.statement.alter.AlterTrigger; +import net.sf.jsqlparser.statement.alter.database.AlterDatabase; +import net.sf.jsqlparser.statement.alter.schema.AlterSchema; +import net.sf.jsqlparser.statement.create.aggregate.CreateAggregate; +import net.sf.jsqlparser.statement.create.cast.CreateCast; +import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.operator.CreateOperator; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorClass; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorFamily; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.transform.CreateTransform; +import net.sf.jsqlparser.statement.create.user.CreateUser; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class StatementFeatureVisitorMetadataDdlTest { + static Stream definitions() { + return Stream.of( + Arguments.of("ALTER COLLATION c REFRESH VERSION", AlterCollation.class), + Arguments.of("ALTER COLLATION c RENAME TO c2", AlterCollation.class), + Arguments.of("ALTER DATABASE d READ ONLY = 0", AlterDatabase.class), + Arguments.of("ALTER DATABASE d CHARACTER SET utf8mb4 COLLATE utf8mb4_bin", + AlterDatabase.class), + Arguments.of("ALTER DATABASE d SET work_mem = '64MB'", AlterDatabase.class), + Arguments.of("ALTER DATABASE d OWNER TO CURRENT_USER", AlterDatabase.class), + Arguments.of("ALTER FUNCTION f(int) OWNER TO u1", AlterRoutine.class), + Arguments.of("ALTER PROCEDURE p SET search_path = public", AlterRoutine.class), + Arguments.of("ALTER FUNCTION f READS SQL DATA", AlterRoutine.class), + Arguments.of("ALTER TRIGGER t ON tbl RENAME TO t2", AlterTrigger.class), + Arguments.of("ALTER RULE r ON tbl RENAME TO r2", AlterRule.class), + Arguments.of("ALTER CONVERSION c RENAME TO c2", AlterConversion.class), + Arguments.of("CREATE CAST (int AS text) WITH INOUT", CreateCast.class), + Arguments.of("CREATE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION f)", + CreateTransform.class), + Arguments.of("CREATE DEFAULT CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f", + CreateConversion.class), + Arguments.of("CREATE OPERATOR === (FUNCTION = f, LEFTARG = int)", + CreateOperator.class), + Arguments.of("ALTER OPERATOR === (int, int) SET (RESTRICT = NONE)", + AlterOperator.class), + Arguments.of("CREATE OPERATOR CLASS oc FOR TYPE int USING btree AS OPERATOR 1 <", + CreateOperatorClass.class), + Arguments.of("ALTER OPERATOR CLASS oc USING btree RENAME TO oc2", + AlterOperatorClass.class), + Arguments.of("CREATE OPERATOR FAMILY f USING btree", CreateOperatorFamily.class), + Arguments.of("ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 (int, int)", + AlterOperatorFamily.class), + Arguments.of("CREATE AGGREGATE agg(int) (SFUNC = f, STYPE = int)", + CreateAggregate.class), + Arguments.of("ALTER AGGREGATE agg(*) OWNER TO u", AlterAggregate.class), + Arguments.of("ALTER SCHEMA s RENAME TO s2", AlterSchema.class), + Arguments.of("ALTER SCHEMA s OWNER TO CURRENT_USER", AlterSchema.class), + Arguments.of("ALTER STATISTICS s RENAME TO s2", AlterStatistics.class), + Arguments.of("ALTER STATISTICS s SET STATISTICS 500", AlterStatistics.class), + Arguments.of("ALTER TABLE ALL IN TABLESPACE old_space SET TABLESPACE new_space", + AlterTablespaceMove.class), + Arguments.of( + "ALTER INDEX ALL IN TABLESPACE old_space SET TABLESPACE new_space NOWAIT", + AlterTablespaceMove.class), + Arguments.of("CREATE TEXT SEARCH CONFIGURATION c (COPY = pg_catalog.simple)", + CreateTextSearchConfiguration.class), + Arguments.of("CREATE TEXT SEARCH CONFIGURATION c (PARSER = p)", + CreateTextSearchConfiguration.class), + Arguments.of("ALTER TEXT SEARCH CONFIGURATION c ADD MAPPING FOR word WITH simple", + AlterTextSearchConfiguration.class), + Arguments.of("ALTER TEXT SEARCH CONFIGURATION c DROP MAPPING FOR word", + AlterTextSearchConfiguration.class), + Arguments.of("CREATE USER u", CreateUser.class), + Arguments.of("CREATE USER u IDENTIFIED BY 'password'", CreateUser.class)); + } + + @ParameterizedTest + @MethodSource("definitions") + void metadataDefinitionsHaveOnlySchemaEffectsAcrossEntryPoints(String sql, Class type) + throws Exception { + Statement statement = TestUtils.assertSqlCanBeParsedAndDeparsed(sql); + assertInstanceOf(type, statement); + assertSchemaOnly(statement.getFeatures()); + assertSchemaOnly(StatementFeatureVisitor.analyse(statement)); + assertSchemaOnly(StatementFeatureVisitor.analyse(sql)); + assertSchemaOnly(StatementFeatureVisitor.analyse(statement, name -> true)); + Statements script = CCJSqlParserUtil.parseStatements(sql); + assertSchemaOnly(StatementFeatureVisitor.analyse(script)); + List each = StatementFeatureVisitor.analyseEach(script); + assertEquals(1, each.size()); + assertSchemaOnly(each.get(0)); + } + + @ParameterizedTest + @MethodSource("definitions") + void classificationDoesNotSuppressFollowingExecutedSql(String sql, Class type) + throws Exception { + Statements script = CCJSqlParserUtil.parseStatements(sql + "; SELECT f(id) FROM t"); + assertInstanceOf(type, script.getStatements().get(0)); + List each = StatementFeatureVisitor.analyseEach(script); + assertSchemaOnly(each.get(0)); + assertEquals(Set.of("f"), each.get(1).getUnresolvedReferences()); + assertEquals(EnumSet.of(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET), + each.get(1).getCertain()); + StatementFeatures union = StatementFeatureVisitor.analyse(script); + assertEquals(EnumSet.of(StmtFeature.MODIFIES_SCHEMA, StmtFeature.READS_DATA, + StmtFeature.RETURNS_RESULT_SET), union.getCertain()); + assertEquals(Set.of("f"), union.getUnresolvedReferences()); + assertTrue(union.mayModifyData()); + } + + @ParameterizedTest + @ValueSource( + strings = {"CREATE ROLE r", "CREATE TRIGGER tr AFTER INSERT ON t EXECUTE FUNCTION f()", + "CREATE POLICY p ON t USING (f(id) > 0)"}) + void existingStoredDefinitionsRemainSchemaOnly(String sql) throws Exception { + assertSchemaOnly(TestUtils.assertSqlCanBeParsedAndDeparsed(sql).getFeatures()); + } + + @Test + void unknownAndUnsupportedStatementsRemainConservative() throws Exception { + Statement unknown = new Statement() { + @Override + public T accept(StatementVisitor visitor, S context) { + return null; + } + }; + assertOpaque(unknown.getFeatures()); + assertOpaque(StatementFeatureVisitor.analyse(new Statements())); + StatementFeatures unsupported = CCJSqlParserUtil + .parse("garbage", p -> p.withUnsupportedStatements(true)).getFeatures(); + assertOpaque(unsupported); + assertEquals(Set.of("unsupported"), unsupported.getUnresolvedReferences()); + } + + private static void assertSchemaOnly(StatementFeatures features) { + assertEquals(EnumSet.of(StmtFeature.MODIFIES_SCHEMA), features.getCertain()); + assertTrue(features.getUncertain().isEmpty()); + assertTrue(features.getUnresolvedReferences().isEmpty()); + } + + private static void assertOpaque(StatementFeatures features) { + assertEquals(EnumSet.of(StmtFeature.OPAQUE), features.getCertain()); + assertEquals( + EnumSet.of(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET, + StmtFeature.MODIFIES_DATA, StmtFeature.MODIFIES_SCHEMA), + features.getUncertain()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorTest.java b/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorTest.java index 95490e7532..86b736f5a8 100644 --- a/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/StatementFeatureVisitorTest.java @@ -14,6 +14,7 @@ package net.sf.jsqlparser.statement; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.delete.Delete; import net.sf.jsqlparser.schema.Column; @@ -21,6 +22,8 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import java.util.Collections; import java.util.EnumSet; @@ -253,6 +256,45 @@ void destructiveDdlAlsoModifiesData() throws JSQLParserException { } } + /** + * The ALTER TABLE actions that delete, swap or replace rows are destructive DDL in the same + * sense: {@code TRUNCATE PARTITION ALL} empties a partitioned table just like TRUNCATE. + */ + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t TRUNCATE PARTITION ALL", + "ALTER TABLE t TRUNCATE PARTITION p0", "ALTER TABLE t DROP PARTITION p0, p1", + "ALTER TABLE t ADD COLUMN c INT, DROP PARTITION p0", + "ALTER TABLE t EXCHANGE PARTITION p0 WITH TABLE u", + "ALTER TABLE t DISCARD TABLESPACE", "ALTER TABLE t DISCARD PARTITION p0 TABLESPACE", + "ALTER TABLE t IMPORT TABLESPACE", "ALTER TABLE t IMPORT PARTITION p0 TABLESPACE"}) + void destructiveAlterActionsAlsoModifyData(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.modifiesSchema()).isTrue(); + assertThat(f.modifiesData()).isTrue(); + assertThat(f.returnsResultSet()).isFalse(); + } + + /** + * An ALTER TABLE action the grammar does not model, such as ClickHouse's DELETE and UPDATE + * mutations, is kept as raw text, so a write cannot be excluded. + */ + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t DELETE WHERE id > 0", + "ALTER TABLE t UPDATE c = 1 WHERE id > 0"}) + void unmodelledAlterActionMayModifyData(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.modifiesSchema()).isTrue(); + assertThat(f.mayModifyData()).isTrue(); + assertThat(f.getUnresolvedReferences()).containsExactly("unsupported"); + } + + @Test + void repairPartitionMayModifyDataLikeRepairTable() throws JSQLParserException { + StatementFeatures f = analyse("ALTER TABLE t REPAIR PARTITION p0"); + assertThat(f.modifiesData()).isFalse(); + assertThat(f.mayModifyData()).isTrue(); + } + // ---- the cases a flag union gets wrong -------------------------------------------------- @Test @@ -274,6 +316,17 @@ void dataModifyingCteAtTopLevel() throws JSQLParserException { assertThat(f.modifiesData()).isTrue(); } + @ParameterizedTest(name = "{0}") + @ValueSource(strings = {"WITH c AS (DELETE FROM t RETURNING *) TABLE c", + "WITH c AS (UPDATE t SET a = 1 RETURNING *) TABLE u", + "WITH c AS (INSERT INTO t VALUES (1) RETURNING *) TABLE c ORDER BY a LIMIT 1"}) + @DisplayName("data-modifying CTE in front of TABLE: TABLE returns rows, the CTE still mutates") + void dataModifyingCteBeforeTable(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.returnsResultSet()).isTrue(); + assertThat(f.modifiesData()).isTrue(); + } + @Test @DisplayName("RETURNING inside a nested CTE of an INSERT returns nothing to the client") void nestedReturningIsNotAResultSet() throws JSQLParserException { @@ -327,6 +380,88 @@ void allowListCollapsesTheUncertainty() throws JSQLParserException { } } + /** + * {@code ROWS FROM (..)} keeps its functions in {@code getRowsFromFunctions()} and leaves + * {@code getFunction()} null, so a check against the single function alone lets every one of + * them through as harmless. + */ + @Nested + @DisplayName("table functions in the FROM clause") + class TableFunctions { + + private StatementFeatures analyseNothingPure(String sql) throws JSQLParserException { + Predicate nothingIsPure = name -> false; + return StatementFeatureVisitor.analyse(CCJSqlParserUtil.parse(sql), nothingIsPure); + } + + @Test + void singleTableFunctionIsChecked() throws JSQLParserException { + String sql = "SELECT * FROM pg_ls_dir('.')"; + + StatementFeatures impure = analyseNothingPure(sql); + assertThat(impure.returnsResultSet()).isTrue(); + assertThat(impure.modifiesData()).isFalse(); + assertThat(impure.getUncertain()).contains(StmtFeature.MODIFIES_DATA, + StmtFeature.MODIFIES_SCHEMA); + assertThat(impure.getUnresolvedReferences()).containsExactly("pg_ls_dir"); + + StatementFeatures pure = analyse(sql, "pg_ls_dir"); + assertThat(pure.mayModifyData()).isFalse(); + assertThat(pure.getUnresolvedReferences()).isEmpty(); + } + + @Test + void rowsFromWithOneFunctionIsChecked() throws JSQLParserException { + String sql = "SELECT * FROM ROWS FROM (pg_ls_dir('.'))"; + + StatementFeatures impure = analyseNothingPure(sql); + assertThat(impure.returnsResultSet()).isTrue(); + assertThat(impure.modifiesData()).isFalse(); + assertThat(impure.getUncertain()).contains(StmtFeature.MODIFIES_DATA, + StmtFeature.MODIFIES_SCHEMA); + assertThat(impure.getUnresolvedReferences()).containsExactly("pg_ls_dir"); + + StatementFeatures pure = analyse(sql, "pg_ls_dir"); + assertThat(pure.mayModifyData()).isFalse(); + assertThat(pure.getUnresolvedReferences()).isEmpty(); + } + + @Test + void rowsFromChecksEveryFunction() throws JSQLParserException { + String sql = "SELECT * FROM ROWS FROM (generate_series(1, 2), pg_ls_dir('.'))"; + + StatementFeatures impure = analyseNothingPure(sql); + assertThat(impure.mayModifyData()).isTrue(); + assertThat(impure.getUnresolvedReferences()) + .containsExactlyInAnyOrder("generate_series", "pg_ls_dir"); + + StatementFeatures onlyFirstPure = analyse(sql, "generate_series"); + assertThat(onlyFirstPure.mayModifyData()) + .as("a pure first function must not hide the second") + .isTrue(); + assertThat(onlyFirstPure.getUnresolvedReferences()).containsExactly("pg_ls_dir"); + + StatementFeatures pure = analyse(sql, "generate_series", "pg_ls_dir"); + assertThat(pure.mayModifyData()).isFalse(); + assertThat(pure.getUnresolvedReferences()).isEmpty(); + } + + @Test + void rowsFromWithOrdinalityIsChecked() throws JSQLParserException { + String sql = "SELECT * FROM ROWS FROM (generate_series(1, 2), pg_ls_dir('.')) " + + "WITH ORDINALITY AS r(n, name, ord)"; + + StatementFeatures impure = analyseNothingPure(sql); + assertThat(impure.mayModifyData()).isTrue(); + assertThat(impure.getUnresolvedReferences()) + .containsExactlyInAnyOrder("generate_series", "pg_ls_dir"); + + StatementFeatures pure = analyse(sql, "generate_series", "pg_ls_dir"); + assertThat(pure.mayModifyData()).isFalse(); + assertThat(pure.getUnresolvedReferences()).isEmpty(); + } + } + @Nested @DisplayName("DDL and opaque statements") class PendingStatementOverrides { @@ -399,6 +534,31 @@ void selectIntoIsNotAResultSet() throws JSQLParserException { assertThat(f.modifiesSchema()).isTrue(); } + /** MySQL's INTO OUTFILE and INTO DUMPFILE write the rows to a server file, like COPY .. TO. */ + @ParameterizedTest + @ValueSource(strings = {"SELECT '' INTO DUMPFILE '/var/www/s.php'", + "SELECT a FROM t INTO OUTFILE '/tmp/t.csv'", + "SELECT a INTO OUTFILE '/tmp/t.csv' FIELDS TERMINATED BY ',' FROM t", + "SELECT a FROM t INTO DUMPFILE '/tmp/t.bin'"}) + void selectIntoFileModifiesData(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.modifiesData()).isTrue(); + assertThat(f.returnsResultSet()).isFalse(); + } + + /** Exasol's EXPORT writes to a file or another database, like BigQuery's EXPORT DATA. */ + @ParameterizedTest + @ValueSource(strings = {"EXPORT t INTO LOCAL CSV FILE '/tmp/t.csv'", + "EXPORT (SELECT a FROM t) INTO LOCAL CSV FILE '/tmp/t.csv'"}) + void exportModifiesData(String sql) throws JSQLParserException { + StatementFeatures f = CCJSqlParserUtil + .parse(sql, parser -> parser.withDialect(AbstractJSqlParser.Dialect.EXASOL)) + .getFeatures(); + assertThat(f.modifiesData()).isTrue(); + assertThat(f.is(StmtFeature.READS_DATA)).isTrue(); + assertThat(f.returnsResultSet()).isFalse(); + } + /** *

Why the SQL looks the way it does

* @@ -498,4 +658,135 @@ void explainIsUncertain() throws JSQLParserException { assertThat(f.returnsResultSet()).isTrue(); assertThat(f.mayModifyData()).isTrue(); } + + /** + * Every expression position has to be traversed, otherwise a function call placed there escapes + * the purity check and a subquery placed there escapes the lock and write checks. + */ + @Nested + @DisplayName("every expression position is traversed") + class ExpressionPositions { + + private StatementFeatures analyseAllPureExcept(String sql, String impure) + throws JSQLParserException { + return StatementFeatureVisitor.analyse(CCJSqlParserUtil.parse(sql), + name -> !name.equals(impure)); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "SELECT substring(pg_read_file('x') FROM 2 FOR 3)", + "SELECT trim(LEADING 'x' FROM pg_read_file('x'))", + "SELECT position(pg_read_file('x') IN a) FROM t", + "SELECT overlay(a PLACING pg_read_file('x') FROM 2) FROM t", + "SELECT a FROM t WHERE a = ANY (SELECT pg_read_file('x'))", + "SELECT a FROM t WHERE a > ALL (SELECT pg_read_file('x'))", + "SELECT a FROM t WHERE a = SOME (SELECT pg_read_file('x'))", + "VALUES (pg_read_file('x'))", + "SELECT a FROM t WHERE a IN (VALUES (pg_read_file('x')))", + "SELECT a FROM t LIMIT length(pg_read_file('x'))", + "SELECT a FROM t WHERE a LIKE 'a' ESCAPE pg_read_file('x')", + "SELECT d AT TIME ZONE pg_read_file('x') FROM t", + "SELECT j -> pg_read_file('x') FROM t", + "SELECT json_objectagg(a : pg_read_file('x')) FROM t", + "SELECT a FROM t WHERE pg_read_file('x') MEMBER OF (j)", + "SELECT a FROM t START WITH a = pg_read_file('x') CONNECT BY PRIOR a = b", + "SELECT a FROM t LIMIT 1 BY pg_read_file('x')", + "WITH c AS (SELECT pg_read_file('x')) SELECT a FROM c UNION SELECT b FROM u", + "SELECT a FROM t UNION SELECT b FROM u ORDER BY pg_read_file('x')", + "SELECT a FROM t UNION SELECT b FROM u LIMIT length(pg_read_file('x'))", + "SELECT j ->> pg_read_file('x') FROM t", + "SELECT j #> ARRAY[pg_read_file('x')] FROM t", + "SELECT j #>> ARRAY[pg_read_file('x')] FROM t", + "SELECT a[length(pg_read_file('x'))] FROM t", + "SELECT t.a[length(pg_read_file('x'))] FROM t", + "SELECT a[1:length(pg_read_file('x'))] FROM t", + "SELECT a FROM t WHERE a[length(pg_read_file('x'))] = 1", + "SELECT 1 UNION SELECT 2 LIMIT length(pg_read_file('x'))", + "SELECT 1 UNION SELECT 2 FETCH FIRST length(pg_read_file('x')) ROWS ONLY", + "WITH c AS (SELECT pg_read_file('x')) TABLE c", + "TABLE t ORDER BY pg_read_file('x')", + "TABLE t LIMIT length(pg_read_file('x'))", + "TABLE t OFFSET length(pg_read_file('x'))", + "TABLE t FETCH FIRST length(pg_read_file('x')) ROWS ONLY", + "SET @x = pg_read_file('x')", + "SET @a = 1, @b = pg_read_file('x')", + "SET x = pg_read_file('x')", + "DECLARE @x INT = length(pg_read_file('x'))", + "ASSERT length(pg_read_file('x')) > 0"}) + void functionIsChecked(String sql) throws JSQLParserException { + StatementFeatures impure = analyseAllPureExcept(sql, "pg_read_file"); + assertThat(impure.getUnresolvedReferences()).containsExactly("pg_read_file"); + assertThat(impure.getUncertain()).contains(StmtFeature.MODIFIES_DATA, + StmtFeature.MODIFIES_SCHEMA); + + StatementFeatures pure = analyseAllPureExcept(sql, ""); + assertThat(pure.mayModifyData()).isFalse(); + assertThat(pure.getUnresolvedReferences()).isEmpty(); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "SELECT a FROM t WHERE a = ANY (SELECT b FROM u FOR UPDATE)", + "SELECT a FROM t WHERE a > ALL (SELECT b FROM u FOR UPDATE)", + "VALUES ((SELECT b FROM u FOR UPDATE))", + "SELECT a FROM t WHERE a IN (VALUES ((SELECT b FROM u FOR UPDATE)))", + "SELECT a FROM t LIMIT (SELECT b FROM u FOR UPDATE)"}) + void rowLockIsSeen(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.is(StmtFeature.MODIFIES_TRANSACTION)).isTrue(); + assertThat(f.is(StmtFeature.READS_DATA)).isTrue(); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "SELECT a FROM t WHERE a = ANY (WITH c AS (DELETE FROM u RETURNING b) SELECT b FROM c)", + "VALUES ((WITH c AS (DELETE FROM u RETURNING b) SELECT b FROM c))"}) + void nestedWriteIsSeen(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.modifiesData()).isTrue(); + assertThat(f.returnsResultSet()).isTrue(); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "SELECT NEXT VALUE FOR s", + "SELECT NEXTVAL FOR s", + "SELECT NEXT VALUE FOR dbo.s FROM t", + "SELECT a FROM t WHERE a = NEXT VALUE FOR s", + "SELECT s.NEXTVAL FROM dual", + "SELECT a FROM t WHERE a = (SELECT s.nextval FROM dual)"}) + void sequenceAdvanceIsChecked(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.returnsResultSet()).isTrue(); + assertThat(f.mayModifyData()).isTrue(); + assertThat(f.getUnresolvedReferences()).containsExactly("nextval"); + } + + @Test + void columnOutsideTheSequenceSyntaxIsNotChecked() throws JSQLParserException { + StatementFeatures f = analyse("SELECT nextval, t.currval FROM t"); + assertThat(f.mayModifyData()).isFalse(); + assertThat(f.getUnresolvedReferences()).isEmpty(); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "SET @x = (SELECT a FROM t)", + "DECLARE @x INT = (SELECT a FROM t)"}) + void assignedSubqueryIsRead(String sql) throws JSQLParserException { + StatementFeatures f = analyse(sql); + assertThat(f.is(StmtFeature.MODIFIES_SESSION)).isTrue(); + assertThat(f.is(StmtFeature.READS_DATA)).isTrue(); + assertThat(f.returnsResultSet()).isFalse(); + } + + @Test + void topLevelValuesReturnsRowsWithoutReading() throws JSQLParserException { + StatementFeatures f = analyse("VALUES (1, 2)"); + assertThat(f.returnsResultSet()).isTrue(); + assertThat(f.is(StmtFeature.READS_DATA)).isFalse(); + assertThat(f.mayModifyData()).isFalse(); + } + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/StatementsTest.java b/src/test/java/net/sf/jsqlparser/statement/StatementsTest.java index 835b9ca4f3..5708b83b4d 100644 --- a/src/test/java/net/sf/jsqlparser/statement/StatementsTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/StatementsTest.java @@ -9,16 +9,17 @@ */ package net.sf.jsqlparser.statement; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrowsExactly; + import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.parser.CCJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.parser.ParseException; import net.sf.jsqlparser.parser.StringProvider; import net.sf.jsqlparser.statement.select.Select; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; -import static org.junit.jupiter.api.Assertions.assertNull; - import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; @@ -93,7 +94,7 @@ public void testStatementsErrorRecovery3() throws JSQLParserException, ParseExce @Test public void testStatementsErrorRecovery4() throws JSQLParserException { Statements statements = CCJSqlParserUtil.parseStatements( - "select * from mytable; select from; select * from mytable2; select 4 from dual;", + "select * from mytable; shutdown defrag; select * from mytable2; select 4 from dual;", parser -> parser.withUnsupportedStatements()); assertEquals(4, statements.size()); @@ -103,6 +104,14 @@ public void testStatementsErrorRecovery4() throws JSQLParserException { assertInstanceOf(Select.class, statements.get(2)); assertInstanceOf(Select.class, statements.get(3)); - TestUtils.assertStatementCanBeDeparsedAs(statements.get(1), "select from", true); + TestUtils.assertStatementCanBeDeparsedAs(statements.get(1), "shutdown defrag", true); } + + @Test + void malformedKnownStatementDoesNotUseUnsupportedCapture() { + assertThrowsExactly(JSQLParserException.class, () -> CCJSqlParserUtil.parseStatements( + "select * from mytable; select from; select * from mytable2; select 4 from dual;", + parser -> parser.withUnsupportedStatements())); + } + } diff --git a/src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java new file mode 100644 index 0000000000..77e6084c97 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java @@ -0,0 +1,228 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.stream.Collectors; +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.TableMaintenanceStatement.Modifier; +import net.sf.jsqlparser.statement.TableMaintenanceStatement.Operation; +import net.sf.jsqlparser.statement.TableMaintenanceStatement.Option; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class TableMaintenanceStatementTest { + + private static TableMaintenanceStatement parse(String sql) throws JSQLParserException { + return (TableMaintenanceStatement) assertSqlCanBeParsedAndDeparsed(sql, true); + } + + private static List tableNames(TableMaintenanceStatement statement) { + return statement.getTables().stream().map(Table::getFullyQualifiedName) + .collect(Collectors.toList()); + } + + @Test + void optimizeTable() throws JSQLParserException { + TableMaintenanceStatement statement = parse("OPTIMIZE TABLE t"); + + assertEquals(Operation.OPTIMIZE, statement.getOperation()); + assertNull(statement.getModifier()); + assertFalse(statement.isTablesKeyword()); + assertEquals(List.of("t"), tableNames(statement)); + assertTrue(statement.getOptions().isEmpty()); + } + + @Test + void optimizeModifierAndTableList() throws JSQLParserException { + TableMaintenanceStatement statement = + parse("OPTIMIZE NO_WRITE_TO_BINLOG TABLE db.t1, `t 2`"); + + assertEquals(Modifier.NO_WRITE_TO_BINLOG, statement.getModifier()); + assertEquals(List.of("db.t1", "`t 2`"), tableNames(statement)); + } + + @Test + void localModifierAndTablesKeyword() throws JSQLParserException { + TableMaintenanceStatement statement = parse("OPTIMIZE LOCAL TABLES t1, t2"); + + assertEquals(Modifier.LOCAL, statement.getModifier()); + assertTrue(statement.isTablesKeyword()); + assertEquals("OPTIMIZE LOCAL TABLES t1, t2", statement.toString()); + } + + @Test + void repairOptions() throws JSQLParserException { + TableMaintenanceStatement statement = + parse("REPAIR NO_WRITE_TO_BINLOG TABLE t QUICK EXTENDED USE_FRM"); + + assertEquals(Operation.REPAIR, statement.getOperation()); + assertEquals(List.of(Option.QUICK, Option.EXTENDED, Option.USE_FRM), + statement.getOptions()); + } + + @Test + void checkOptionsKeepSourceOrder() throws JSQLParserException { + TableMaintenanceStatement statement = + parse("CHECK TABLE t1, t2 FOR UPGRADE QUICK FAST MEDIUM EXTENDED CHANGED"); + + assertEquals(Operation.CHECK, statement.getOperation()); + assertEquals(List.of(Option.FOR_UPGRADE, Option.QUICK, Option.FAST, Option.MEDIUM, + Option.EXTENDED, Option.CHANGED), statement.getOptions()); + assertEquals(List.of("t1", "t2"), tableNames(statement)); + } + + @Test + void checksumTableWithOption() throws JSQLParserException { + TableMaintenanceStatement statement = parse("CHECKSUM TABLE t1, db.t2 QUICK"); + + assertEquals(Operation.CHECKSUM, statement.getOperation()); + assertNull(statement.getModifier()); + assertEquals(List.of("t1", "db.t2"), tableNames(statement)); + assertEquals(List.of(Option.QUICK), statement.getOptions()); + } + + @ParameterizedTest + @ValueSource(strings = {"CHECKSUM TABLE t", "CHECKSUM TABLE t EXTENDED", + "CHECKSUM TABLES t1, t2"}) + void checksumTableForms(String sql) throws JSQLParserException { + assertEquals(Operation.CHECKSUM, parse(sql).getOperation()); + for (Dialect dialect : List.of(Dialect.MYSQL, Dialect.MARIADB)) { + assertEquals(sql, CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)) + .toString()); + } + } + + @Test + void keywordsAreCaseInsensitive() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("check tables t medium for upgrade"); + + assertEquals("CHECK TABLES t MEDIUM FOR UPGRADE", statement.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CHECK NO_WRITE_TO_BINLOG TABLE t", + "CHECK LOCAL TABLE t", + "CHECK TABLE t USE_FRM", + "OPTIMIZE TABLE t QUICK", + "REPAIR TABLE t FAST", + "REPAIR TABLE t FOR UPGRADE", + "OPTIMIZE t", + "REPAIR TABLE", + "CHECKSUM NO_WRITE_TO_BINLOG TABLE t", + "CHECKSUM LOCAL TABLE t", + "CHECKSUM TABLE t FAST", + "CHECKSUM TABLE t FOR UPGRADE", + "CHECKSUM TABLE t QUICK EXTENDED", + "CHECKSUM t" + }) + void rejectsSyntaxOutsideTheStatementDefinition(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void parsesInMySqlAndMariaDbDialects() throws JSQLParserException { + for (Dialect dialect : List.of(Dialect.MYSQL, Dialect.MARIADB)) { + Statement statement = CCJSqlParserUtil.parse("OPTIMIZE TABLE t", + parser -> parser.withDialect(dialect)); + assertInstanceOf(TableMaintenanceStatement.class, statement, dialect.name()); + } + } + + @Test + void buildsAndDeparses() { + TableMaintenanceStatement statement = new TableMaintenanceStatement(Operation.REPAIR) + .withModifier(Modifier.LOCAL).addTables(new Table("t1"), new Table("t2")) + .addOptions(Option.QUICK); + + assertDeparse(statement, "REPAIR LOCAL TABLE t1, t2 QUICK"); + } + + @Test + void findsTables() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("CHECK TABLE a, s.b QUICK"); + + assertThat(TablesNamesFinder.findTables(statement.toString())) + .containsExactlyInAnyOrder("a", "s.b"); + } + + @Test + void wordsRemainUsableOutsideTheStatement() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT optimize, repair, quick, fast, medium, changed " + + "FROM maintenance"); + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t OPTIMIZE PARTITION p1"); + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t CHECK PARTITION p1"); + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t REPAIR PARTITION p1"); + assertSqlCanBeParsedAndDeparsed( + "SELECT checksum, CHECKSUM(*), CHECKSUM(a, b) FROM checksum"); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE t (checksum INT) CHECKSUM = 1"); + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t CHECKSUM = 0, ADD COLUMN checksum INT"); + } + + @Test + void domainCheckConstraintIsNotATableCheck() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "CREATE DOMAIN d AS INT CHECK (VALUE > 0);\nCHECK TABLE t;", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + + assertEquals(2, statements.size()); + assertEquals("CREATE DOMAIN d AS INT CHECK (VALUE > 0)", + statements.get(0).toString()); + assertInstanceOf(TableMaintenanceStatement.class, statements.get(1)); + } + + @Test + void reportsStatementFeatures() throws JSQLParserException { + StatementFeatures check = CCJSqlParserUtil.parse("CHECK TABLE t").getFeatures(); + assertThat(check.getCertain()).containsExactlyInAnyOrder(StmtFeature.READS_DATA, + StmtFeature.RETURNS_RESULT_SET); + + StatementFeatures checksum = CCJSqlParserUtil.parse("CHECKSUM TABLE t").getFeatures(); + assertThat(checksum.getCertain()).containsExactlyInAnyOrder(StmtFeature.READS_DATA, + StmtFeature.RETURNS_RESULT_SET); + assertFalse(checksum.may(StmtFeature.MODIFIES_SCHEMA)); + + StatementFeatures optimize = CCJSqlParserUtil.parse("OPTIMIZE TABLE t").getFeatures(); + assertThat(optimize.getCertain()).contains(StmtFeature.MODIFIES_SCHEMA); + assertFalse(optimize.may(StmtFeature.MODIFIES_DATA)); + + StatementFeatures repair = CCJSqlParserUtil.parse("REPAIR TABLE t").getFeatures(); + assertThat(repair.getCertain()).contains(StmtFeature.MODIFIES_SCHEMA); + assertThat(repair.getUncertain()).contains(StmtFeature.MODIFIES_DATA); + } + + @Test + void isAStatementStartForUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "FOO; CHECK TABLE t; OPTIMIZE TABLE t; CHECKSUM TABLE t; REPAIR TABLE t; CHECK x", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(List.of("UnsupportedStatement", "TableMaintenanceStatement", + "TableMaintenanceStatement", "TableMaintenanceStatement", + "TableMaintenanceStatement", "UnsupportedStatement"), + statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList())); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/TransactionStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/TransactionStatementTest.java new file mode 100644 index 0000000000..2ec359b4f7 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/TransactionStatementTest.java @@ -0,0 +1,565 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.StringReader; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.StringProvider; +import net.sf.jsqlparser.parser.StreamProvider; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.statement.create.function.CreateFunction; +import net.sf.jsqlparser.statement.oracle.OracleBlock; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class TransactionStatementTest { + private Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + /** Asserts that the object's node spans {@code expected} within {@code source}. */ + static void assertSpans(String expected, String source, ASTNodeAccess access) { + Node node = access.getASTNode(); + assertNotNull(node, expected); + assertEquals(expected, source.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + private Statement roundTrip(String sql, Dialect dialect) throws Exception { + Statement statement = parse(sql, dialect); + assertSpans(sql, sql, (ASTNodeAccess) statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(statement.toString(), output.toString()); + Statement reparsed = parse(output.toString(), dialect); + assertEquals(statement.getClass(), reparsed.getClass()); + assertEquals(statement.toString(), reparsed.toString()); + assertEquals(Set.of(StmtFeature.MODIFIES_TRANSACTION), + statement.getFeatures().getCertain()); + assertTrue(statement.getFeatures().getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + return statement; + } + + @ParameterizedTest + @ValueSource(strings = {"START TRANSACTION", "BEGIN", "BEGIN WORK", "BEGIN TRANSACTION", + "START TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE", + "BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE NOT DEFERRABLE", + "BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED", + "START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED", + "BEGIN NOT DEFERRABLE, READ ONLY, ISOLATION LEVEL SERIALIZABLE"}) + void postgresStartsAreStructured(String sql) throws Exception { + StartTransaction statement = assertInstanceOf(StartTransaction.class, + roundTrip(sql, Dialect.POSTGRESQL)); + assertEquals(sql.startsWith("BEGIN") ? StartTransaction.Command.BEGIN + : StartTransaction.Command.START_TRANSACTION, statement.getCommand()); + assertEquals(sql.startsWith("BEGIN WORK") ? TransactionKeyword.WORK + : sql.startsWith("BEGIN TRANSACTION") ? TransactionKeyword.TRANSACTION : null, + statement.getKeyword()); + } + + @ParameterizedTest + @ValueSource(strings = {"START TRANSACTION", "BEGIN", "BEGIN WORK", + "START TRANSACTION READ ONLY", "START TRANSACTION READ WRITE", + "START TRANSACTION WITH CONSISTENT SNAPSHOT, READ ONLY", + "START TRANSACTION READ WRITE, WITH CONSISTENT SNAPSHOT"}) + void mysqlStartsAreStructured(String sql) throws Exception { + assertInstanceOf(StartTransaction.class, roundTrip(sql, Dialect.MYSQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"START TRANSACTION READ ONLY, READ WRITE", + "START TRANSACTION READ WRITE, READ ONLY"}) + void contradictoryAccessModesAreRejectedOnlyForMysql(String sql) throws Exception { + JSQLParserException error = assertThrows(JSQLParserException.class, + () -> parse(sql, Dialect.MYSQL)); + assertTrue(error.getCause().getMessage() + .contains("cannot specify both READ ONLY and READ WRITE")); + assertThrows(JSQLParserException.class, + () -> parse(sql.replace(", ", ", WITH CONSISTENT SNAPSHOT, "), Dialect.MYSQL)); + StartTransaction postgres = assertInstanceOf(StartTransaction.class, + roundTrip(sql, Dialect.POSTGRESQL)); + List expected = sql.endsWith("READ WRITE") + ? List.of(TransactionMode.READ_ONLY, TransactionMode.READ_WRITE) + : List.of(TransactionMode.READ_WRITE, TransactionMode.READ_ONLY); + assertEquals(expected, postgres.getModes()); + assertEquals(sql, postgres.toString()); + StartTransaction permissive = assertInstanceOf(StartTransaction.class, + CCJSqlParserUtil.parse(sql)); + assertEquals(expected, permissive.getModes()); + assertEquals(sql, permissive.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"START TRANSACTION READ ONLY, READ ONLY", + "START TRANSACTION READ WRITE, READ WRITE"}) + void mysqlRepeatedAccessModesArePreserved(String sql) throws Exception { + StartTransaction statement = assertInstanceOf(StartTransaction.class, + roundTrip(sql, Dialect.MYSQL)); + TransactionMode mode = sql.endsWith("READ ONLY") + ? TransactionMode.READ_ONLY + : TransactionMode.READ_WRITE; + assertEquals(List.of(mode, mode), statement.getModes()); + assertEquals(sql, statement.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"COMMIT", "COMMIT WORK", "COMMIT TRANSACTION", "COMMIT AND CHAIN", + "COMMIT WORK AND NO CHAIN", "COMMIT TRANSACTION AND CHAIN", "ROLLBACK", + "ROLLBACK WORK", "ROLLBACK TRANSACTION", "ROLLBACK AND CHAIN", + "ROLLBACK WORK AND NO CHAIN", "ROLLBACK TRANSACTION AND CHAIN"}) + void postgresCompletionRetainsKeywordAndChain(String sql) throws Exception { + Statement statement = roundTrip(sql, Dialect.POSTGRESQL); + TransactionChain chain = sql.endsWith("NO CHAIN") ? TransactionChain.NO_CHAIN + : sql.endsWith("CHAIN") ? TransactionChain.CHAIN : null; + TransactionKeyword keyword = sql.contains("WORK") ? TransactionKeyword.WORK + : sql.contains("TRANSACTION") ? TransactionKeyword.TRANSACTION : null; + if (statement instanceof Commit) { + assertEquals(chain, ((Commit) statement).getChain()); + assertEquals(keyword, ((Commit) statement).getKeyword()); + } else { + RollbackStatement rollback = assertInstanceOf(RollbackStatement.class, statement); + assertEquals(chain, rollback.getChain()); + assertEquals(keyword, rollback.getKeyword()); + assertEquals(keyword == TransactionKeyword.WORK, rollback.isUsingWorkKeyword()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"COMMIT WORK AND CHAIN", "COMMIT AND NO CHAIN", + "ROLLBACK WORK AND NO CHAIN", "ROLLBACK AND CHAIN"}) + void mysqlCompletionPreservesChain(String sql) throws Exception { + roundTrip(sql, Dialect.MYSQL); + } + + @ParameterizedTest + @ValueSource(strings = {"SAVEPOINT \"a b\"", "ROLLBACK TO \"a b\"", + "ROLLBACK TRANSACTION TO SAVEPOINT \"a b\"", "RELEASE SAVEPOINT \"a b\"", + "RELEASE \"a b\"", "RELEASE sp"}) + void postgresSavepointNamesAndOptionalKeyword(String sql) throws Exception { + roundTrip(sql, Dialect.POSTGRESQL); + } + + @Test + void mysqlSavepointNamesAreQuotedAndMutable() throws Exception { + roundTrip("SAVEPOINT `a b`", Dialect.MYSQL); + roundTrip("ROLLBACK TO SAVEPOINT `a b`", Dialect.MYSQL); + ReleaseSavepointStatement statement = assertInstanceOf(ReleaseSavepointStatement.class, + roundTrip("RELEASE SAVEPOINT `a b`", Dialect.MYSQL)); + assertEquals("`a b`", statement.getSavepointName()); + assertTrue(statement.isUsingSavepointKeyword()); + statement.withSavepointName("changed").withUsingSavepointKeyword(false); + assertEquals("RELEASE changed", statement.toString()); + assertEquals("RELEASE changed", statement.appendTo(new StringBuilder()).toString()); + } + + @Test + void typedModesCanBeChangedWithoutKeepingAnOpaqueSource() throws Exception { + StartTransaction statement = assertInstanceOf(StartTransaction.class, parse( + "BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY NOT DEFERRABLE", + Dialect.POSTGRESQL)); + assertEquals(List.of(TransactionMode.ISOLATION_LEVEL_REPEATABLE_READ, + TransactionMode.READ_ONLY, TransactionMode.NOT_DEFERRABLE), + statement.getModes()); + statement.withCommand(StartTransaction.Command.START_TRANSACTION).withKeyword(null); + statement.getModes().set(1, TransactionMode.READ_WRITE); + statement.addMode(TransactionMode.DEFERRABLE); + String sql = + "START TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, NOT DEFERRABLE, DEFERRABLE"; + assertEquals(sql, statement.toString()); + assertEquals(sql, roundTrip(sql, Dialect.POSTGRESQL).toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + } + + @Test + void legacyRollbackMutatorsStillControlWorkAndSavepoint() throws Exception { + RollbackStatement rollback = new RollbackStatement().withUsingWorkKeyword(true) + .withUsingSavepointKeyword(true).withSavepointName("sp"); + assertEquals("ROLLBACK WORK TO SAVEPOINT sp", rollback.toString()); + rollback.setUsingWorkKeyword(false); + assertNull(rollback.getKeyword()); + rollback.setKeyword(TransactionKeyword.TRANSACTION); + assertFalse(rollback.isUsingWorkKeyword()); + rollback.setUsingWorkKeyword(true); + assertEquals(TransactionKeyword.WORK, rollback.getKeyword()); + roundTrip("ROLLBACK WORK FORCE '25.32.87'", Dialect.ORACLE); + rollback.withSavepointName(null).withChain(TransactionChain.NO_CHAIN); + assertEquals("ROLLBACK WORK AND NO CHAIN", rollback.toString()); + Commit commit = new Commit().withKeyword(TransactionKeyword.WORK) + .withChain(TransactionChain.CHAIN); + assertEquals("COMMIT WORK AND CHAIN", commit.toString()); + } + + @Test + void statementBoundariesAndProceduralBlocksRemainSeparate() throws Exception { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.MYSQL)) { + Statements script = CCJSqlParserUtil.parseStatements( + "BEGIN; SELECT 1; SAVEPOINT sp; ROLLBACK TO SAVEPOINT sp; RELEASE SAVEPOINT sp; COMMIT AND NO CHAIN; SELECT 2", + p -> p.withDialect(dialect)); + assertEquals(7, script.size()); + assertInstanceOf(StartTransaction.class, script.get(0)); + assertInstanceOf(ReleaseSavepointStatement.class, script.get(4)); + assertInstanceOf(Commit.class, script.get(5)); + assertEquals("SELECT 2", script.get(6).toString()); + assertEquals(7, CCJSqlParserUtil.parseStatements(script.toString(), + p -> p.withDialect(dialect)).size()); + assertInstanceOf(Block.class, parse("BEGIN SELECT 1; END", dialect)); + } + assertInstanceOf(Block.class, CCJSqlParserUtil.parse("BEGIN SELECT 1; END")); + assertInstanceOf(OracleBlock.class, parse("BEGIN NULL; END;", Dialect.ORACLE)); + assertInstanceOf(StartTransaction.class, CCJSqlParserUtil.parse("START TRANSACTION")); + assertInstanceOf(ReleaseSavepointStatement.class, CCJSqlParserUtil.parse("RELEASE sp")); + } + + @Test + void directAndReaderEntryPointsUseTheSameDialectDisambiguation() throws Exception { + assertInstanceOf(StartTransaction.class, new CCJSqlParser(new StringProvider("BEGIN")) + .withDialect(Dialect.POSTGRESQL).Statement()); + assertInstanceOf(StartTransaction.class, + new CCJSqlParser(new StreamProvider(new StringReader("BEGIN"))) + .withDialect(Dialect.MYSQL).Statement()); + assertInstanceOf(StartTransaction.class, CCJSqlParserUtil.newParser("BEGIN") + .withDialect(Dialect.POSTGRESQL).Statement()); + } + + @Test + void releaseRemainsAvailableAsAnIdentifier() throws Exception { + for (String sql : List.of("SELECT release FROM release", "SELECT release(1) AS release", + "CREATE TABLE release (release INT)", "SAVEPOINT release")) { + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + } + } + + @Test + void visitorDispatchPassesContextAndResult() throws Exception { + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(StartTransaction statement, S context) { + return context + ":" + statement.getCommand(); + } + + @Override + public String visit(ReleaseSavepointStatement statement, S context) { + return context + ":" + statement.getSavepointName(); + } + }; + assertEquals("ctx:BEGIN", parse("BEGIN", Dialect.POSTGRESQL).accept(visitor, "ctx")); + assertEquals("ctx:sp", parse("RELEASE sp", Dialect.POSTGRESQL).accept(visitor, "ctx")); + assertNull( + parse("BEGIN", Dialect.POSTGRESQL).accept(new StatementVisitorAdapter<>(), null)); + } + + @ParameterizedTest + @ValueSource(strings = {"START", "START TRANSACTION READ", + "START TRANSACTION ISOLATION LEVEL BAD", + "BEGIN ISOLATION READ COMMITTED", "BEGIN READ ONLY,", "BEGIN , READ ONLY", + "COMMIT AND", "COMMIT AND NO", "COMMIT AND CHAIN AND CHAIN", + "ROLLBACK AND", "ROLLBACK TO SAVEPOINT sp AND CHAIN", "ROLLBACK AND CHAIN TO sp", + "RELEASE", "RELEASE SAVEPOINT", "RELEASE SAVEPOINT sp garbage", + "COMMIT PREPARED", "ROLLBACK PREPARED 'id' AND CHAIN", "XA START 'id'", + "START TRANSACTION WITH CONSISTENT SNAPSHOT"}) + void malformedAndDeferredPostgresSyntaxIsRejected(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"BEGIN TRANSACTION", "BEGIN READ ONLY", "START TRANSACTION DEFERRABLE", + "START TRANSACTION ISOLATION LEVEL READ COMMITTED", "RELEASE sp", + "START TRANSACTION READ ONLY WITH CONSISTENT SNAPSHOT", "COMMIT TRANSACTION", + "ROLLBACK TRANSACTION"}) + void explicitMysqlDialectRejectsPostgresOnlySyntax(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL)); + } + + @Test + void validatesNewCapabilitiesAndPostgresChainVersion() { + FeatureConfiguration pg = new FeatureConfiguration().setValue(Feature.dialect, + Dialect.POSTGRESQL.name()); + assertTrue(new Validation(pg, List.of(PostgresqlVersion.V10), + "BEGIN ISOLATION LEVEL SERIALIZABLE READ ONLY DEFERRABLE; RELEASE sp") + .validate().isEmpty()); + assertFalse(new Validation(pg, List.of(PostgresqlVersion.V11), "COMMIT AND CHAIN") + .validate().isEmpty()); + assertTrue(new Validation(pg, List.of(PostgresqlVersion.V12), + "COMMIT AND CHAIN; ROLLBACK AND NO CHAIN").validate().isEmpty()); + assertFalse(new Validation(pg, List.of(new FeaturesAllowed(Feature.commit)), + "COMMIT AND CHAIN").validate().isEmpty()); + assertFalse(new Validation(pg, List.of(new FeaturesAllowed(Feature.select)), + "BEGIN; RELEASE sp").validate().isEmpty()); + FeatureConfiguration mysql = new FeatureConfiguration().setValue(Feature.dialect, + Dialect.MYSQL.name()); + assertTrue(new Validation(mysql, List.of(MySqlVersion.V8_0), + "START TRANSACTION WITH CONSISTENT SNAPSHOT, READ ONLY; RELEASE SAVEPOINT sp; COMMIT AND CHAIN") + .validate().isEmpty()); + assertFalse(new Validation(pg, List.of(MySqlVersion.V8_0), + "START TRANSACTION ISOLATION LEVEL SERIALIZABLE DEFERRABLE") + .validate().isEmpty()); + } + + static Stream mysqlReleaseForms() { + return Stream.of( + Arguments.of("COMMIT AND NO CHAIN NO RELEASE", false, + null, TransactionChain.NO_CHAIN, TransactionRelease.NO_RELEASE), + Arguments.of("COMMIT RELEASE", false, null, null, TransactionRelease.RELEASE), + Arguments.of("COMMIT WORK NO RELEASE", false, TransactionKeyword.WORK, null, + TransactionRelease.NO_RELEASE), + Arguments.of("COMMIT AND NO CHAIN RELEASE", false, null, + TransactionChain.NO_CHAIN, TransactionRelease.RELEASE), + Arguments.of("ROLLBACK WORK AND CHAIN NO RELEASE", true, TransactionKeyword.WORK, + TransactionChain.CHAIN, TransactionRelease.NO_RELEASE), + Arguments.of("ROLLBACK RELEASE", true, null, null, TransactionRelease.RELEASE), + Arguments.of("ROLLBACK AND NO CHAIN RELEASE", true, null, + TransactionChain.NO_CHAIN, TransactionRelease.RELEASE)); + } + + @ParameterizedTest + @MethodSource("mysqlReleaseForms") + void mysqlCompletionRetainsRelease(String sql, boolean rollback, TransactionKeyword keyword, + TransactionChain chain, TransactionRelease release) throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB}) { + Class type = + rollback ? RollbackStatement.class : Commit.class; + TransactionCompletionStatement statement = + assertInstanceOf(type, roundTrip(sql, dialect)); + assertEquals(sql, statement.toString()); + assertEquals(keyword, statement.getKeyword()); + assertEquals(chain, statement.getChain()); + assertEquals(release, statement.getRelease()); + assertFalse(statement.isPostgresSpelling()); + } + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"COMMIT AND CHAIN RELEASE", "ROLLBACK WORK AND CHAIN RELEASE", + "COMMIT RELEASE RELEASE", "COMMIT NO", "ROLLBACK TO SAVEPOINT sp RELEASE", + "ROLLBACK RELEASE AND CHAIN"}) + void contradictoryOrMisplacedReleaseIsRejected(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, null}) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"COMMIT RELEASE", "COMMIT AND NO CHAIN NO RELEASE", + "ROLLBACK NO RELEASE", "END RELEASE", "ABORT NO RELEASE"}) + void postgresRejectsRelease(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"END", "END WORK", "END TRANSACTION", "END AND CHAIN", + "END WORK AND NO CHAIN", "ABORT", "ABORT WORK", "ABORT TRANSACTION AND CHAIN", + "ABORT AND NO CHAIN"}) + void postgresEndAndAbortAreCommitAndRollback(String sql) throws Exception { + TransactionCompletionStatement statement = + assertInstanceOf(TransactionCompletionStatement.class, + roundTrip(sql, Dialect.POSTGRESQL)); + assertTrue(statement.isPostgresSpelling()); + if (sql.startsWith("END")) { + assertEquals(Commit.Command.END, + assertInstanceOf(Commit.class, statement).getCommand()); + } else { + RollbackStatement rollback = assertInstanceOf(RollbackStatement.class, statement); + assertEquals(RollbackStatement.Command.ABORT, rollback.getCommand()); + assertNull(rollback.getSavepointName()); + } + assertEquals(sql.contains("WORK") ? TransactionKeyword.WORK + : sql.contains("TRANSACTION") ? TransactionKeyword.TRANSACTION : null, + statement.getKeyword()); + assertEquals(sql.endsWith("NO CHAIN") ? TransactionChain.NO_CHAIN + : sql.endsWith("CHAIN") ? TransactionChain.CHAIN : null, statement.getChain()); + } + + @Test + void abortIsUnambiguousWithoutADialectButEndIsNot() throws Exception { + assertInstanceOf(RollbackStatement.class, CCJSqlParserUtil.parse("ABORT WORK")); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("END")); + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER}) { + assertThrows(JSQLParserException.class, () -> parse("ABORT", dialect)); + assertThrows(JSQLParserException.class, () -> parse("END", dialect)); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ABORT TO SAVEPOINT sp", "ABORT TO sp", "ABORT FORCE '1.2.3'", + "END TO SAVEPOINT sp", "END PREPARED 'x'", "END AND", "ABORT AND", + "END garbage", "ABORT garbage"}) + void postgresSpellingsTakeOnlyTheCompletionClauses(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL)); + } + + @Test + void endStillClosesBlocksAndCaseExpressions() throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.MYSQL, null}) { + assertInstanceOf(Block.class, + dialect == null ? CCJSqlParserUtil.parse("BEGIN SELECT 1; SELECT 2; END") + : parse("BEGIN SELECT 1; SELECT 2; END", dialect)); + } + Statements script = CCJSqlParserUtil.parseStatements( + "BEGIN; SELECT CASE WHEN a THEN 1 END AS \"end\" FROM t; END; ABORT", + p -> p.withDialect(Dialect.POSTGRESQL)); + assertEquals(4, script.size()); + assertInstanceOf(StartTransaction.class, script.get(0)); + assertEquals(Commit.Command.END, ((Commit) script.get(2)).getCommand()); + assertEquals(RollbackStatement.Command.ABORT, + ((RollbackStatement) script.get(3)).getCommand()); + assertInstanceOf(IfElseStatement.class, + CCJSqlParserUtil.parse("IF 1 = 1 BEGIN SELECT 1; END ELSE SELECT 2")); + assertInstanceOf(CreateFunction.class, + parse("CREATE FUNCTION f() RETURNS int LANGUAGE sql BEGIN ATOMIC SELECT 1; END", + Dialect.POSTGRESQL)); + for (String sql : List.of("SELECT abort FROM abort", "CREATE TABLE abort (abort INT)", + "SELECT 1 AS \"end\"")) { + assertEquals(sql, parse(sql, Dialect.POSTGRESQL).toString()); + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + } + } + + static Stream newStatementStarts() { + return Stream.of( + Arguments.of(Dialect.POSTGRESQL, "END", Commit.class), + Arguments.of(Dialect.POSTGRESQL, "END WORK AND CHAIN", Commit.class), + Arguments.of(Dialect.POSTGRESQL, "ABORT", RollbackStatement.class), + Arguments.of(null, "ABORT TRANSACTION", RollbackStatement.class), + Arguments.of(Dialect.MYSQL, "COMMIT AND NO CHAIN NO RELEASE", Commit.class), + Arguments.of(Dialect.MYSQL, "ROLLBACK RELEASE", RollbackStatement.class), + Arguments.of(Dialect.MYSQL, "SET GLOBAL TRANSACTION READ WRITE", + SetTransactionStatement.class), + Arguments.of(Dialect.POSTGRESQL, "SET TRANSACTION SNAPSHOT '1'", + SetTransactionStatement.class), + Arguments.of(Dialect.POSTGRESQL, + "SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + SetTransactionStatement.class), + Arguments.of(Dialect.MYSQL, + "SET PERSIST_ONLY TRANSACTION ISOLATION LEVEL READ COMMITTED", + SetTransactionStatement.class), + Arguments.of(Dialect.POSTGRESQL, "SET LOCAL TRANSACTION SNAPSHOT '1'", + SetTransactionStatement.class), + Arguments.of(Dialect.POSTGRESQL, + "SET LOCAL SESSION CHARACTERISTICS AS TRANSACTION READ ONLY", + SetTransactionStatement.class), + Arguments.of(Dialect.POSTGRESQL, "SET CONSTRAINTS ALL DEFERRED", + SetConstraintsStatement.class)); + } + + @ParameterizedTest + @MethodSource("newStatementStarts") + void newStatementStartsEndThePreviousStatement(Dialect dialect, String sql, + Class type) throws Exception { + // COMMIT on its own line is closed by the next statement start rather than a semicolon + String script = "SELECT 1;\nCOMMIT\n" + sql + "\n;SAVEPOINT sp"; + for (boolean opaque : new boolean[] {false, true}) { + Statements statements = CCJSqlParserUtil.parseStatements(script, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + p.withUnsupportedStatements(opaque); + }); + assertEquals(4, statements.size(), script); + assertEquals("COMMIT", statements.get(1).toString()); + assertInstanceOf(type, statements.get(2)); + assertEquals(sql, statements.get(2).toString()); + assertSpans("COMMIT", script, (ASTNodeAccess) statements.get(1)); + assertSpans(sql, script, (ASTNodeAccess) statements.get(2)); + assertInstanceOf(SavepointStatement.class, statements.get(3)); + } + } + + @Test + void completionModelIsSharedAndMutable() { + Commit commit = new Commit().withCommand(Commit.Command.END) + .withKeyword(TransactionKeyword.TRANSACTION).withChain(TransactionChain.CHAIN); + assertEquals("END TRANSACTION AND CHAIN", commit.toString()); + commit.withCommand(Commit.Command.COMMIT).withKeyword(null).withChain(null) + .withRelease(TransactionRelease.RELEASE); + assertEquals("COMMIT RELEASE", commit.toString()); + RollbackStatement rollback = new RollbackStatement() + .withCommand(RollbackStatement.Command.ABORT).withUsingWorkKeyword(true); + assertEquals("ABORT WORK", rollback.toString()); + rollback.withCommand(RollbackStatement.Command.ROLLBACK) + .withChain(TransactionChain.NO_CHAIN).withRelease(TransactionRelease.NO_RELEASE); + assertEquals("ROLLBACK WORK AND NO CHAIN NO RELEASE", rollback.toString()); + StringBuilder output = new StringBuilder("x: "); + rollback.accept(new StatementDeParser(output), null); + assertEquals("x: ROLLBACK WORK AND NO CHAIN NO RELEASE", output.toString()); + assertThrows(NullPointerException.class, () -> commit.setCommand(null)); + assertThrows(NullPointerException.class, () -> rollback.setCommand(null)); + } + + @Test + void validatesRollbackSavepointReleaseAndPostgresSpellings() { + FeatureConfiguration pg = new FeatureConfiguration().setValue(Feature.dialect, + Dialect.POSTGRESQL.name()); + FeatureConfiguration mysql = new FeatureConfiguration().setValue(Feature.dialect, + Dialect.MYSQL.name()); + assertTrue(new Validation(pg, List.of(PostgresqlVersion.V12), + "SAVEPOINT sp; ROLLBACK TO SAVEPOINT sp; ROLLBACK; END AND CHAIN; ABORT") + .validate().isEmpty()); + assertTrue(new Validation(mysql, List.of(MySqlVersion.V8_0), + "SAVEPOINT sp; ROLLBACK TO sp; COMMIT AND NO CHAIN NO RELEASE; ROLLBACK RELEASE") + .validate().isEmpty()); + assertFalse(new Validation(new FeatureConfiguration(), List.of(MySqlVersion.V8_0), + "ABORT").validate().isEmpty()); + assertFalse(new Validation(new FeatureConfiguration(), List.of(PostgresqlVersion.V12), + "COMMIT RELEASE").validate().isEmpty()); + assertFalse(new Validation(pg, List.of(new FeaturesAllowed(Feature.rollback)), + "ROLLBACK TO sp").validate().isEmpty()); + assertTrue(new Validation(pg, + List.of(new FeaturesAllowed(Feature.rollback, Feature.savepoint)), + "SAVEPOINT sp; ROLLBACK TO sp").validate().isEmpty()); + assertFalse(new Validation(pg, List.of(new FeaturesAllowed(Feature.commit)), + "ROLLBACK").validate().isEmpty()); + assertTrue(new Validation(new FeatureConfiguration(), + List.of(net.sf.jsqlparser.util.validation.feature.SqlServerVersion.V2019), + "COMMIT; ROLLBACK").validate().isEmpty()); + } + + @Test + void visitorDispatchCoversCompletionSpellings() throws Exception { + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(Commit commit, S context) { + return context + ":" + commit.getCommand(); + } + + @Override + public String visit(RollbackStatement rollback, S context) { + return context + ":" + rollback.getCommand(); + } + }; + assertEquals("ctx:END", parse("END", Dialect.POSTGRESQL).accept(visitor, "ctx")); + assertEquals("ctx:ABORT", parse("ABORT", Dialect.POSTGRESQL).accept(visitor, "ctx")); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/TwoPhaseTransactionTest.java b/src/test/java/net/sf/jsqlparser/statement/TwoPhaseTransactionTest.java new file mode 100644 index 0000000000..23008330b7 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/TwoPhaseTransactionTest.java @@ -0,0 +1,548 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.statement.TransactionStatementTest.assertSpans; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.Arrays; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +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.statement.TransactionCompletionStatement.PreparedTransactionKeyword; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.OracleVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL PREPARE TRANSACTION, COMMIT PREPARED and ROLLBACK PREPARED, and the MySQL XA + * statements, which share {@link TransactionId}. + */ +class TwoPhaseTransactionTest { + private static final Dialect[] MYSQL_FAMILY = {Dialect.MYSQL, Dialect.MARIADB, null}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + /** + * Parses {@code sql}, which must print as written, and checks the statement span, the deparser, + * the reparse, the feature analysis and the table finder. + */ + private static Statement roundTrip(String sql, Dialect dialect, StmtFeature feature) + throws Exception { + Statement statement = parse(sql, dialect); + assertEquals(sql, statement.toString()); + assertSpans(sql, sql, (ASTNodeAccess) statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + Statement reparsed = parse(sql, dialect); + assertEquals(statement.getClass(), reparsed.getClass()); + assertEquals(sql, reparsed.toString()); + assertEquals(Set.of(feature), statement.getFeatures().getCertain()); + assertTrue(statement.getFeatures().getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder<>().getTables(statement).isEmpty()); + return statement; + } + + private static Statement roundTrip(String sql, Dialect dialect) throws Exception { + return roundTrip(sql, dialect, StmtFeature.MODIFIES_TRANSACTION); + } + + private static StringValue string(Object value) { + return assertInstanceOf(StringValue.class, value); + } + + // ---- PostgreSQL ---------------------------------------------------------------------------- + + @ParameterizedTest + @ValueSource(strings = {"PREPARE TRANSACTION 'foobar'", "COMMIT PREPARED 'foobar'", + "ROLLBACK PREPARED 'foobar'"}) + void postgresTwoPhaseStatementsNameTheTransaction(String sql) throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + Statement statement = roundTrip(sql, dialect); + TransactionId id; + if (statement instanceof PrepareTransactionStatement) { + id = ((PrepareTransactionStatement) statement).getTransactionId(); + } else { + TransactionCompletionStatement completion = + assertInstanceOf(TransactionCompletionStatement.class, statement); + assertEquals(PreparedTransactionKeyword.PREPARED, + completion.getPreparedTransactionKeyword()); + assertNull(completion.getKeyword()); + assertNull(completion.getChain()); + assertNull(completion.getRelease()); + assertFalse(completion.isPostgresSpelling()); + id = completion.getPreparedTransactionId(); + } + assertEquals("foobar", string(id.getGlobalTransactionId()).getValue()); + assertNull(id.getBranchQualifier()); + assertNull(id.getFormatId()); + assertSpans("'foobar'", sql, id); + assertSpans("'foobar'", sql, string(id.getGlobalTransactionId())); + } + assertInstanceOf(Commit.class, parse("COMMIT PREPARED 'foobar'", null)); + assertNull(((RollbackStatement) parse("ROLLBACK PREPARED 'foobar'", null)) + .getForceDistributedTransactionIdentifier()); + } + + @ParameterizedTest + @ValueSource(strings = {"PREPARE TRANSACTION E'a\\'b'", "COMMIT PREPARED U&'\\0041'", + "ROLLBACK PREPARED $$x$$", "COMMIT PREPARED $t$x$t$", "prepare transaction 'x'", + "commit prepared 'x'", "rollback prepared 'x'"}) + void postgresTakesEveryStringConstant(String sql) throws Exception { + Statement statement = parse(sql, Dialect.POSTGRESQL); + assertEquals(sql.toUpperCase(Locale.ROOT).startsWith("PREPARE"), + statement instanceof PrepareTransactionStatement); + assertSpans(sql, sql, (ASTNodeAccess) statement); + assertEquals(statement.toString(), + parse(statement.toString(), Dialect.POSTGRESQL).toString()); + } + + @Test + void escapeStringsKeepTheirValue() throws Exception { + PrepareTransactionStatement statement = assertInstanceOf( + PrepareTransactionStatement.class, + parse("PREPARE TRANSACTION E'a\\'b'", Dialect.POSTGRESQL)); + StringValue value = string(statement.getTransactionId().getGlobalTransactionId()); + assertEquals("E", value.getPrefix()); + assertEquals("a'b", value.getNotExcapedValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"PREPARE TRANSACTION", "PREPARE TRANSACTION N'x'", + "PREPARE TRANSACTION B'01'", "PREPARE TRANSACTION X'0A'", + "PREPARE TRANSACTION 'x' 'y'", "PREPARE TRANSACTION 'x', 'y'", + "COMMIT PREPARED", "COMMIT PREPARED x", "COMMIT PREPARED 1", "COMMIT PREPARED N'x'", + "COMMIT PREPARED B'01'", "COMMIT PREPARED 'x' AND CHAIN", + "COMMIT WORK PREPARED 'x'", "COMMIT TRANSACTION PREPARED 'x'", + "COMMIT PREPARED 'x', 'y'", "COMMIT PREPARED 'x' 'y'", "ROLLBACK PREPARED", + "ROLLBACK PREPARED x", "ROLLBACK PREPARED X'0A'", "ROLLBACK PREPARED 'x' AND NO CHAIN", + "ROLLBACK WORK PREPARED 'x'", "ROLLBACK PREPARED 'x' TO SAVEPOINT sp", + "ROLLBACK PREPARED 'x' FORCE 'y'", "END PREPARED 'x'", "ABORT PREPARED 'x'", + "XA START 'x'", "XA RECOVER"}) + void postgresRejectsMalformedTwoPhaseStatements(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL), sql); + } + + @Test + void doubleQuotedIdentifiersAreNoTransactionIds() { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("COMMIT PREPARED \"x\"", + p -> p.withDialect(Dialect.POSTGRESQL))); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("COMMIT PREPARED \"x\"", p -> p.withDoubleQuotedStrings(true))); + } + + @ParameterizedTest + @ValueSource(strings = {"PREPARE TRANSACTION 'x'", "COMMIT PREPARED 'x'", + "ROLLBACK PREPARED 'x'"}) + void otherDialectsKeepRejectingPostgresTwoPhaseStatements(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER}) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @Test + void preparedStatementsKeepTheirReading() throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + for (String sql : List.of("PREPARE transaction AS SELECT 1", + "PREPARE transaction (int) AS SELECT $1", "PREPARE p AS SELECT 1")) { + PrepareStatement statement = + assertInstanceOf(PrepareStatement.class, parse(sql, dialect)); + assertEquals(sql.substring(8, sql.indexOf(' ', 8)), statement.getName()); + } + } + for (String sql : List.of("SELECT prepared FROM prepared", "CREATE TABLE prepared (a INT)", + "SAVEPOINT prepared", "ROLLBACK TO prepared")) { + assertEquals(sql, parse(sql, Dialect.POSTGRESQL).toString()); + assertEquals(sql, parse(sql, null).toString()); + } + } + + @Test + void oracleForceSharesTheTransactionId() throws Exception { + RollbackStatement rollback = assertInstanceOf(RollbackStatement.class, + roundTrip("ROLLBACK WORK FORCE '25.32.87'", Dialect.ORACLE)); + assertEquals(PreparedTransactionKeyword.FORCE, rollback.getPreparedTransactionKeyword()); + assertEquals("'25.32.87'", rollback.getForceDistributedTransactionIdentifier()); + assertEquals("25.32.87", + string(rollback.getPreparedTransactionId().getGlobalTransactionId()).getValue()); + assertSpans("'25.32.87'", "ROLLBACK WORK FORCE '25.32.87'", + rollback.getPreparedTransactionId()); + assertEquals("ROLLBACK FORCE 'x'", parse("ROLLBACK FORCE 'x'", null).toString()); + assertThrows(JSQLParserException.class, + () -> parse("ROLLBACK FORCE 'x' AND CHAIN", Dialect.ORACLE)); + } + + @Test + void legacyForceAccessorsDeriveFromTheTransactionId() { + RollbackStatement rollback = + new RollbackStatement().withForceDistributedTransactionIdentifier("'1.2.3'"); + assertEquals("ROLLBACK FORCE '1.2.3'", rollback.toString()); + assertEquals(PreparedTransactionKeyword.FORCE, rollback.getPreparedTransactionKeyword()); + assertEquals("'1.2.3'", rollback.getForceDistributedTransactionIdentifier()); + assertEquals("1.2.3", + string(rollback.getPreparedTransactionId().getGlobalTransactionId()).getValue()); + // text that is not a string literal is kept as written, as before + rollback.setForceDistributedTransactionIdentifier("4.5.6"); + assertEquals("ROLLBACK FORCE 4.5.6", rollback.toString()); + assertEquals("4.5.6", rollback.getForceDistributedTransactionIdentifier()); + rollback.setForceDistributedTransactionIdentifier(" "); + assertNull(rollback.getPreparedTransactionId()); + assertNull(rollback.getForceDistributedTransactionIdentifier()); + assertEquals("ROLLBACK", rollback.toString()); + + TransactionId id = new TransactionId(new StringValue("'g'")); + rollback.withPreparedTransaction(PreparedTransactionKeyword.PREPARED, id); + assertNull(rollback.getForceDistributedTransactionIdentifier()); + rollback.setForceDistributedTransactionIdentifier(null); + assertSame(id, rollback.getPreparedTransactionId()); + assertEquals("ROLLBACK PREPARED 'g'", rollback.toString()); + rollback.setPreparedTransaction(null, null); + assertNull(rollback.getPreparedTransactionKeyword()); + assertThrows(NullPointerException.class, () -> rollback.setPreparedTransaction(null, id)); + + Commit commit = new Commit().withPreparedTransaction(id); + assertEquals("COMMIT PREPARED 'g'", commit.toString()); + StringBuilder output = new StringBuilder(); + commit.accept(new StatementDeParser(output), null); + assertEquals("COMMIT PREPARED 'g'", output.toString()); + commit.withPreparedTransaction(null).withChain(TransactionChain.CHAIN); + assertEquals("COMMIT AND CHAIN", commit.toString()); + PrepareTransactionStatement prepare = new PrepareTransactionStatement(id); + assertEquals("PREPARE TRANSACTION 'g'", prepare.toString()); + assertThrows(NullPointerException.class, () -> prepare.setTransactionId(null)); + } + + // ---- MySQL XA ------------------------------------------------------------------------------ + + static Stream xaStatements() { + return Stream.of( + Arguments.of("XA START 'x'", XaStatement.Action.START, null), + Arguments.of("XA BEGIN 'x'", XaStatement.Action.BEGIN, null), + Arguments.of("XA START 'x' JOIN", XaStatement.Action.START, + XaStatement.Option.JOIN), + Arguments.of("XA BEGIN 'x' RESUME", XaStatement.Action.BEGIN, + XaStatement.Option.RESUME), + Arguments.of("XA END 'x'", XaStatement.Action.END, null), + Arguments.of("XA END 'x' SUSPEND", XaStatement.Action.END, + XaStatement.Option.SUSPEND), + Arguments.of("XA END 'x' SUSPEND FOR MIGRATE", XaStatement.Action.END, + XaStatement.Option.SUSPEND_FOR_MIGRATE), + Arguments.of("XA PREPARE 'x'", XaStatement.Action.PREPARE, null), + Arguments.of("XA COMMIT 'x'", XaStatement.Action.COMMIT, null), + Arguments.of("XA COMMIT 'x' ONE PHASE", XaStatement.Action.COMMIT, + XaStatement.Option.ONE_PHASE), + Arguments.of("XA ROLLBACK 'x'", XaStatement.Action.ROLLBACK, null)); + } + + @ParameterizedTest + @MethodSource("xaStatements") + void xaStatementsKeepActionXidAndOption(String sql, XaStatement.Action action, + XaStatement.Option option) throws Exception { + for (Dialect dialect : MYSQL_FAMILY) { + XaStatement statement = + assertInstanceOf(XaStatement.class, roundTrip(sql, dialect)); + assertEquals(action, statement.getAction()); + assertEquals(option, statement.getOption()); + TransactionId xid = statement.getTransactionId(); + assertEquals("x", string(xid.getGlobalTransactionId()).getValue()); + assertNull(xid.getBranchQualifier()); + assertSpans("'x'", sql, xid); + } + } + + @ParameterizedTest + @ValueSource(strings = {"XA RECOVER", "XA RECOVER CONVERT XID"}) + void xaRecoverListsPreparedTransactions(String sql) throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, null}) { + XaStatement statement = assertInstanceOf(XaStatement.class, + roundTrip(sql, dialect, StmtFeature.RETURNS_RESULT_SET)); + assertEquals(XaStatement.Action.RECOVER, statement.getAction()); + assertNull(statement.getTransactionId()); + assertEquals(sql.endsWith("XID") ? XaStatement.Option.CONVERT_XID : null, + statement.getOption()); + } + assertInstanceOf(XaStatement.class, roundTrip("XA RECOVER", Dialect.MARIADB, + StmtFeature.RETURNS_RESULT_SET)); + // MariaDB writes XA RECOVER FORMAT = 'SQL' instead + assertThrows(JSQLParserException.class, + () -> parse("XA RECOVER CONVERT XID", Dialect.MARIADB)); + } + + @Test + void xidTakesBranchQualifierFormatIdAndEveryLiteralForm() throws Exception { + String sql = "XA START X'0a', B'0101', 7 JOIN"; + XaStatement statement = assertInstanceOf(XaStatement.class, roundTrip(sql, Dialect.MYSQL)); + TransactionId xid = statement.getTransactionId(); + assertEquals("X'0a'", assertInstanceOf(HexValue.class, xid.getGlobalTransactionId()) + .getValue()); + StringValue bits = string(xid.getBranchQualifier()); + assertEquals("B", bits.getPrefix()); + assertEquals("0101", bits.getValue()); + assertEquals(7L, xid.getFormatId()); + assertSpans("X'0a', B'0101', 7", sql, xid); + assertSpans("X'0a'", sql, (ASTNodeAccess) xid.getGlobalTransactionId()); + assertSpans("B'0101'", sql, bits); + + for (String form : List.of("XA PREPARE 0x6162, 'b'", "XA COMMIT 'a', '', 0", + "XA ROLLBACK x'', X'00ff'", "XA END 'a', 'b', 9223372036854775807", + "XA START \"a\", \"b\", 1")) { + assertEquals(form, roundTrip(form, Dialect.MYSQL).toString()); + } + assertEquals("XA START 'a', 'b', 2147483647", + roundTrip("XA START 'a', 'b', 2147483647", Dialect.MARIADB).toString()); + assertEquals("XA START B'01'", parse("XA START b'01'", Dialect.MYSQL).toString()); + assertEquals("XA START 'a', 'b', 7", + parse("XA START 'a', 'b', 007", Dialect.MYSQL).toString()); + assertEquals("XA START 'it''s'", roundTrip("XA START 'it''s'", null).toString()); + assertEquals("it's", string(((XaStatement) parse("XA START 'it\\'s'", Dialect.MYSQL)) + .getTransactionId().getGlobalTransactionId()).getNotExcapedValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"XA", "XA START", "XA START x", "XA START 1", "XA START NULL", + "XA START @v", "XA START ?", "XA START N'x'", "XA START _utf8'x'", "XA START E'x'", + "XA START $$x$$", "XA START X'0'", "XA START X'0 a'", "XA START X'0a' '0b'", + "XA START 0X10", "XA START B'012'", "XA START 'a' 'b'", "XA START 'a',", + "XA START 'a', 'b',", "XA START 'a', 'b', 'c'", "XA START 'a', 'b', -1", + "XA START 'a', 'b', x", "XA START 'a', 'b', 1, 2", "XA START 'a', 1", + "XA START 'a', 'b', 9223372036854775808", "XA START 'x' JOIN RESUME", + "XA START 'x' SUSPEND", "XA START 'x' ONE PHASE", "XA BEGIN WORK", + "XA END 'x' FOR MIGRATE", "XA END 'x' SUSPEND FOR", "XA END 'x' JOIN", + "XA END 'x' SUSPEND MIGRATE", "XA PREPARE 'x' ONE PHASE", "XA PREPARE", + "XA COMMIT 'x' ONE", "XA COMMIT 'x' PHASE", "XA COMMIT 'x' SUSPEND", + "XA COMMIT 'x' AND CHAIN", "XA ROLLBACK 'x' JOIN", "XA ROLLBACK 'x' TO sp", + "XA RECOVER 'x'", "XA RECOVER CONVERT", "XA RECOVER XID", "XA RECOVER CONVERT 'x'", + "XA COMMIT", "XA ROLLBACK", "XA END"}) + void xaRejectsMalformedStatements(String sql) { + for (Dialect dialect : MYSQL_FAMILY) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @Test + void mariaDbFormatIdsAreSigned32Bit() { + assertThrows(JSQLParserException.class, + () -> parse("XA START 'a', 'b', 2147483648", Dialect.MARIADB)); + } + + @ParameterizedTest + @ValueSource(strings = {"XA START 'x'", "XA END 'x'", "XA COMMIT 'x' ONE PHASE", + "XA RECOVER"}) + void otherDialectsKeepRejectingXa(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.ORACLE, + Dialect.SQLSERVER, Dialect.H2}) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @Test + void xaRemainsAnIdentifier() throws Exception { + for (Dialect dialect : MYSQL_FAMILY) { + for (String sql : List.of("SELECT xa FROM xa", "CREATE TABLE xa (xa INT)", + "SELECT recover, migrate, phase, xid FROM t", + "ALTER TABLE t ADD COLUMN xa INT", "INSERT INTO xa (xa) VALUES (1)")) { + assertEquals(sql, parse(sql, dialect).toString()); + } + } + } + + // ---- statement boundaries, visitors and validation ----------------------------------------- + + static Stream newStatementStarts() { + return Stream.of( + Arguments.of(Dialect.POSTGRESQL, "PREPARE TRANSACTION 'x'", + PrepareTransactionStatement.class), + Arguments.of(Dialect.POSTGRESQL, "COMMIT PREPARED 'x'", Commit.class), + Arguments.of(null, "ROLLBACK PREPARED 'x'", RollbackStatement.class), + Arguments.of(Dialect.MYSQL, "XA START 'x', 'b', 1 JOIN", XaStatement.class), + Arguments.of(Dialect.MYSQL, "XA END 'x' SUSPEND FOR MIGRATE", XaStatement.class), + Arguments.of(Dialect.MARIADB, "XA COMMIT 'x' ONE PHASE", XaStatement.class), + Arguments.of(null, "XA RECOVER", XaStatement.class), + Arguments.of(Dialect.MYSQL, "XA RECOVER CONVERT XID", XaStatement.class)); + } + + @ParameterizedTest + @MethodSource("newStatementStarts") + void newStatementStartsEndThePreviousStatement(Dialect dialect, String sql, + Class type) throws Exception { + // COMMIT on its own line is closed by the next statement start rather than a semicolon + String script = "SELECT 1;\nCOMMIT\n" + sql + "\n;SAVEPOINT sp"; + for (boolean opaque : new boolean[] {false, true}) { + Statements statements = CCJSqlParserUtil.parseStatements(script, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + p.withUnsupportedStatements(opaque); + }); + assertEquals(4, statements.size(), script); + assertEquals("COMMIT", statements.get(1).toString()); + assertInstanceOf(type, statements.get(2)); + assertEquals(sql, statements.get(2).toString()); + assertSpans(sql, script, (ASTNodeAccess) statements.get(2)); + assertInstanceOf(SavepointStatement.class, statements.get(3)); + } + } + + @Test + void scriptsKeepEachStatement() throws Exception { + String mysql = "XA START 'x'; INSERT INTO t VALUES (1); XA END 'x'; XA PREPARE 'x';" + + " XA RECOVER; XA COMMIT 'x'"; + Statements statements = + CCJSqlParserUtil.parseStatements(mysql, p -> p.withDialect(Dialect.MYSQL)); + assertEquals(6, statements.size()); + assertEquals(Set.of("t"), new TablesNamesFinder<>().getTables(statements.get(1))); + assertEquals(XaStatement.Action.RECOVER, ((XaStatement) statements.get(4)).getAction()); + String postgres = "BEGIN; UPDATE t SET a = 1; PREPARE TRANSACTION 'x'; COMMIT PREPARED 'x';" + + " ROLLBACK PREPARED 'y'; END"; + statements = CCJSqlParserUtil.parseStatements(postgres, + p -> p.withDialect(Dialect.POSTGRESQL)); + assertEquals(6, statements.size()); + assertInstanceOf(PrepareTransactionStatement.class, statements.get(2)); + assertEquals(Commit.Command.END, ((Commit) statements.get(5)).getCommand()); + assertEquals(statements.toString(), CCJSqlParserUtil.parseStatements( + statements.toString(), p -> p.withDialect(Dialect.POSTGRESQL)).toString()); + } + + @Test + void visitorDispatchPassesContextAndResult() throws Exception { + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(PrepareTransactionStatement statement, S context) { + return context + ":" + statement.getTransactionId(); + } + + @Override + public String visit(XaStatement statement, S context) { + return context + ":" + statement.getAction(); + } + }; + assertEquals("ctx:'x'", parse("PREPARE TRANSACTION 'x'", null).accept(visitor, "ctx")); + assertEquals("ctx:END", parse("XA END 'x'", null).accept(visitor, "ctx")); + assertNull(parse("XA END 'x'", null).accept(new StatementVisitorAdapter<>(), null)); + assertNull(parse("PREPARE TRANSACTION 'x'", null) + .accept(new StatementVisitorAdapter<>(), null)); + } + + private static boolean isValid(Dialect dialect, String sql, + ValidationCapability... capabilities) { + FeatureConfiguration configuration = new FeatureConfiguration(); + if (dialect != null) { + configuration.setValue(Feature.dialect, dialect.name()); + } + return new Validation(configuration, Arrays.asList(capabilities), sql).validate() + .isEmpty(); + } + + @Test + void validationKnowsWhichServersTakeWhichForm() { + String postgres = "PREPARE TRANSACTION 'x'; COMMIT PREPARED 'x'; ROLLBACK PREPARED 'x'"; + assertTrue(isValid(Dialect.POSTGRESQL, postgres, PostgresqlVersion.V10)); + assertTrue(isValid(null, postgres, PostgresqlVersion.V14)); + for (String sql : postgres.split("; ")) { + assertFalse(isValid(null, sql, MySqlVersion.V8_0), sql); + assertFalse(isValid(null, sql, OracleVersion.V19C), sql); + } + assertFalse(isValid(Dialect.POSTGRESQL, "COMMIT PREPARED 'x'", + new FeaturesAllowed(Feature.commit))); + assertTrue(isValid(Dialect.POSTGRESQL, "COMMIT PREPARED 'x'", + new FeaturesAllowed(Feature.commit, Feature.twoPhaseCommit))); + assertTrue(isValid(Dialect.POSTGRESQL, "ROLLBACK PREPARED 'x'", + new FeaturesAllowed(Feature.rollback, Feature.twoPhaseCommit))); + assertTrue(isValid(Dialect.ORACLE, "ROLLBACK FORCE 'x'", OracleVersion.V19C)); + + String xa = "XA START 'x'; XA END 'x'; XA PREPARE 'x'; XA COMMIT 'x'; XA RECOVER"; + assertTrue(isValid(Dialect.MYSQL, xa, MySqlVersion.V8_0)); + assertTrue(isValid(Dialect.MARIADB, xa, MariaDbVersion.V10_5_4)); + assertTrue(isValid(null, xa, new FeaturesAllowed(Feature.xa))); + assertFalse(isValid(null, "XA RECOVER", PostgresqlVersion.V14)); + assertFalse(isValid(null, "XA ROLLBACK 'x'", new FeaturesAllowed(Feature.rollback))); + } + + // ---- the shared model ---------------------------------------------------------------------- + + @Test + void transactionIdKeepsTheXidShape() { + TransactionId id = new TransactionId(new StringValue("'g'")); + assertEquals("'g'", id.toString()); + id.withBranchQualifier(new HexValue("X'0a'")).withFormatId(3L); + assertEquals("'g', X'0a', 3", id.toString()); + assertThrows(IllegalStateException.class, () -> id.setBranchQualifier(null)); + assertThrows(IllegalArgumentException.class, () -> id.setFormatId(-1L)); + id.withFormatId(null).withBranchQualifier(null); + assertEquals("'g'", id.toString()); + assertThrows(IllegalStateException.class, () -> id.setFormatId(1L)); + assertThrows(NullPointerException.class, () -> id.setGlobalTransactionId(null)); + assertEquals("'h', 'b', 1", + new TransactionId(new StringValue("'h'"), new StringValue("'b'"), 1L).toString()); + assertThrows(IllegalStateException.class, + () -> new TransactionId(new StringValue("'h'"), null, 1L)); + id.withGlobalTransactionId(new HexValue("0x01")); + assertEquals("0x01", id.appendTo(new StringBuilder()).toString()); + } + + @Test + void xaStatementKeepsOptionsWithTheirAction() { + TransactionId xid = new TransactionId(new StringValue("'x'")); + XaStatement statement = new XaStatement(XaStatement.Action.END, xid) + .withOption(XaStatement.Option.SUSPEND_FOR_MIGRATE); + assertEquals("XA END 'x' SUSPEND FOR MIGRATE", statement.toString()); + assertThrows(IllegalArgumentException.class, + () -> statement.setAction(XaStatement.Action.COMMIT)); + assertThrows(IllegalArgumentException.class, + () -> statement.setOption(XaStatement.Option.ONE_PHASE)); + statement.withOption(null).withAction(XaStatement.Action.COMMIT) + .withOption(XaStatement.Option.ONE_PHASE); + assertEquals("XA COMMIT 'x' ONE PHASE", statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals("XA COMMIT 'x' ONE PHASE", output.toString()); + assertSame(xid, statement.getTransactionId()); + XaStatement recover = new XaStatement(XaStatement.Action.RECOVER, null) + .withOption(XaStatement.Option.CONVERT_XID); + assertEquals("XA RECOVER CONVERT XID", recover.toString()); + recover.withOption(null).withAction(XaStatement.Action.BEGIN).withTransactionId(xid) + .withOption(XaStatement.Option.RESUME); + assertEquals("XA BEGIN 'x' RESUME", recover.toString()); + assertThrows(NullPointerException.class, () -> recover.setAction(null)); + assertThrows(NullPointerException.class, () -> new XaStatement(null, xid)); + for (XaStatement.Option option : XaStatement.Option.values()) { + long actions = Arrays.stream(XaStatement.Action.values()).filter(option::appliesTo) + .count(); + assertEquals(option == XaStatement.Option.JOIN + || option == XaStatement.Option.RESUME ? 2 : 1, actions, option.name()); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/UnsupportedIfBoundaryTest.java b/src/test/java/net/sf/jsqlparser/statement/UnsupportedIfBoundaryTest.java new file mode 100644 index 0000000000..a9952e140e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/UnsupportedIfBoundaryTest.java @@ -0,0 +1,54 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrowsExactly; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.select.Select; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class UnsupportedIfBoundaryTest { + @ParameterizedTest + @ValueSource(strings = {"IF x > 0 SELECT 1 WHERE", "IF x > 0 SELECT * FROM"}) + void malformedIfBodyCannotBecomeAnOpaqueSuffix(String sql) { + for (boolean unsupported : new boolean[] {false, true}) { + for (String prefix : new String[] {"", "SELECT 0;"}) { + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parseStatements(prefix + sql + ";SELECT 2;", + p -> p.withUnsupportedStatements(unsupported))); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"IF x > 0 SELECT 1 WHERE", "IF x > 0 SELECT * FROM"}) + void malformedIfBodyRecordsOneErrorWithoutPublishingPartialIf(String sql) throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + for (String prefix : new String[] {"", "SELECT 0;"}) { + CCJSqlParser parser = CCJSqlParserUtil.newParser(prefix + sql + ";SELECT 2;") + .withUnsupportedStatements(unsupported).withErrorRecovery(true); + Statements statements = parser.Statements(); + int index = prefix.isEmpty() ? 0 : 1; + assertEquals(index + 2, statements.size()); + assertNull(statements.get(index)); + assertEquals("SELECT 2", + assertInstanceOf(Select.class, statements.get(index + 1)).toString()); + assertEquals(1, parser.getParseErrors().size()); + } + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementRecoveryTest.java b/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementRecoveryTest.java new file mode 100644 index 0000000000..d3d5ade826 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementRecoveryTest.java @@ -0,0 +1,296 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrowsExactly; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.ByteArrayInputStream; +import java.io.StringReader; +import java.nio.charset.StandardCharsets; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.ParseException; +import net.sf.jsqlparser.parser.StreamProvider; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class UnsupportedStatementRecoveryTest { + static Stream malformedStatements() { + return Stream.of("SELECT * FROM", "INSERT INTO t (a", "UPDATE t SET", + "SELECT", "INSERT", "UPDATE", "WITH", "SELECT 1 +", + "insert into t values (1,", "select f(1, 2) from t where x =", + "IF x > 0 UPDATE t SET", "IF x > 0 SELECT 1; ELSE UPDATE t SET"); + } + + static Stream opaqueStatements() { + return Stream.of(Arguments.of("shutdown defrag", "shutdown defrag"), + Arguments.of("SET IDENTITY_INSERT tb_inter_d2v_transfer on", + "SET IDENTITY_INSERT tb_inter_d2v_transfer on"), + Arguments.of("set isolation to dirty read", "set isolation to dirty read"), + Arguments.of("set isolation dirty read", "set isolation dirty read"), + Arguments.of("SET ISOLATION TO DIRTY READ WITH WARNING", + "SET ISOLATION TO DIRTY READ WITH WARNING"), + Arguments.of("SET ISOLATION TO COMMITTED READ LAST COMMITTED", + "SET ISOLATION TO COMMITTED READ LAST COMMITTED"), + Arguments.of("SET ISOLATION TO CURSOR STABILITY RETAIN UPDATE LOCKS", + "SET ISOLATION TO CURSOR STABILITY RETAIN UPDATE LOCKS"), + Arguments.of("SET ISOLATION TO REPEATABLE READ", + "SET ISOLATION TO REPEATABLE READ"), + // These are capture controls, not claims of valid dialect syntax. + Arguments.of("mystery 'a;b' /* comment */ payload", "mystery 'a;b' payload"), + Arguments.of("this is an unsupported statement", + "this is an unsupported statement")); + } + + @ParameterizedTest + @MethodSource("malformedStatements") + void malformedSupportedSyntaxIsNotOpaque(String sql) throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + for (boolean complex : new boolean[] {false, true}) { + for (String delimiter : new String[] {"", ";"}) { + String input = sql + delimiter; + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(input, + p -> p.withUnsupportedStatements(unsupported) + .withAllowComplexParsing(complex))); + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parseStatements(input, + p -> p.withUnsupportedStatements(unsupported) + .withAllowComplexParsing(complex))); + CCJSqlParser parser = CCJSqlParserUtil.newParser(input) + .withUnsupportedStatements(unsupported) + .withAllowComplexParsing(complex); + assertThrowsExactly(ParseException.class, parser::Statement); + parser = CCJSqlParserUtil.newParser(input) + .withUnsupportedStatements(unsupported) + .withAllowComplexParsing(complex); + assertThrowsExactly(ParseException.class, parser::Statements); + } + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT * FROM", "INSERT INTO t (a", "UPDATE t SET", + "IF x > 0 SELECT 1; ELSE UPDATE t SET"}) + void syntaxRecoveryRecordsErrorWithoutPublishingPartialAst(String sql) throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + CCJSqlParser parser = CCJSqlParserUtil.newParser(sql) + .withUnsupportedStatements(unsupported).withErrorRecovery(true); + assertNull(parser.Statement()); + assertEquals(1, parser.getParseErrors().size()); + for (String prefix : new String[] {"", "SELECT 0;", ";;SELECT 0;;;"}) { + parser = CCJSqlParserUtil.newParser(prefix + sql + ";;SELECT 2;") + .withUnsupportedStatements(unsupported).withErrorRecovery(true); + Statements statements = parser.Statements(); + int index = prefix.contains("SELECT") ? 1 : 0; + assertEquals(index + 2, statements.size()); + if (index > 0) { + assertEquals("SELECT 0", + assertInstanceOf(Select.class, statements.get(0)).toString()); + } + assertNull(statements.get(index)); + assertEquals("SELECT 2", + assertInstanceOf(Select.class, statements.get(index + 1)).toString()); + assertEquals(1, parser.getParseErrors().size()); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT * FROM", "INSERT INTO t (a", "UPDATE t SET", + "IF x > 0 SELECT 1; ELSE UPDATE t SET", "UPDATE t SET a = 'x;y',"}) + void laterMalformedStatementCannotEscapeAsPrefixAndOpaqueSuffix(String sql) { + for (boolean unsupported : new boolean[] {false, true}) { + for (boolean complex : new boolean[] {false, true}) { + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parseStatements("SELECT 0;" + sql + ";SELECT 2;", + p -> p.withUnsupportedStatements(unsupported) + .withAllowComplexParsing(complex))); + } + } + } + + @ParameterizedTest + @MethodSource("opaqueStatements") + void opaqueStatementTextAndFollowingStatementsSurvive(String sql, String expected) + throws Exception { + for (boolean recovery : new boolean[] {false, true}) { + Statement result = CCJSqlParserUtil.parse("/* before */" + sql + "; -- after\n", + p -> p.withUnsupportedStatements(true).withErrorRecovery(recovery)); + assertEquals(expected, assertInstanceOf(UnsupportedStatement.class, result).toString()); + TestUtils.assertStatementCanBeDeparsedAs(result, expected, true); + for (String prefix : new String[] {"", ";;", "SELECT 0;", "SELECT 0;;;"}) { + CCJSqlParser parser = CCJSqlParserUtil.newParser(prefix + sql + ";;;SELECT 2;") + .withUnsupportedStatements(true).withErrorRecovery(recovery); + Statements statements = parser.Statements(); + int index = prefix.contains("SELECT") ? 1 : 0; + assertEquals(index + 2, statements.size()); + if (index > 0) { + assertEquals("SELECT 0", statements.get(0).toString()); + } + assertEquals(expected, + assertInstanceOf(UnsupportedStatement.class, statements.get(index)) + .toString()); + assertEquals("SELECT 2", + assertInstanceOf(Select.class, statements.get(index + 1)).toString()); + assertTrue(parser.getParseErrors().isEmpty()); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT * FROM", "INSERT INTO t (a", "UPDATE t SET"}) + void readerAndInputStreamUseSameRecoveryPolicy(String sql) throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + for (boolean recovery : new boolean[] {false, true}) { + for (boolean multiple : new boolean[] {false, true}) { + CCJSqlParser reader = + new CCJSqlParser(new StreamProvider(new StringReader(sql))) + .withUnsupportedStatements(unsupported) + .withErrorRecovery(recovery); + CCJSqlParser stream = CCJSqlParserUtil.newParser( + new ByteArrayInputStream(sql.getBytes(StandardCharsets.UTF_8)), "UTF-8") + .withUnsupportedStatements(unsupported).withErrorRecovery(recovery); + for (CCJSqlParser parser : new CCJSqlParser[] {reader, stream}) { + if (recovery) { + assertNull(multiple ? parser.Statements().get(0) : parser.Statement()); + assertEquals(1, parser.getParseErrors().size()); + } else { + assertThrowsExactly(ParseException.class, + () -> { + if (multiple) { + parser.Statements(); + } else { + parser.Statement(); + } + }); + } + } + } + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET IDENTITY_INSERT = 1", "SET IDENTITY_INSERT.foo = 1", + "SET isolation = 1", "SET isolation.foo = 1"}) + void ordinarySetAssignmentsAreNotRerouted(String sql) throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + for (Dialect dialect : new Dialect[] {Dialect.SQLSERVER, Dialect.POSTGRESQL, + Dialect.EXASOL}) { + assertInstanceOf(SetStatement.class, TestUtils.assertSqlCanBeParsedAndDeparsed(sql, + true, + p -> p.withDialect(dialect).withUnsupportedStatements(unsupported))); + } + assertInstanceOf(SetStatement.class, + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, + p -> p.withUnsupportedStatements(unsupported))); + } + } + + @Test + void ordinarySetToValueRemainsTypedInApplicableDialects() throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + assertInstanceOf(SetStatement.class, CCJSqlParserUtil.parse("SET isolation TO 1", + p -> p.withUnsupportedStatements(unsupported))); + assertInstanceOf(SetStatement.class, CCJSqlParserUtil.parse("SET isolation TO 1", + p -> p.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(unsupported))); + } + } + + @Test + void validTypedStatementsAndSeparatorlessAdjacencyRemainSupported() throws Exception { + for (boolean unsupported : new boolean[] {false, true}) { + for (boolean recovery : new boolean[] {false, true}) { + assertInstanceOf(Select.class, TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a FROM t", true, + p -> p.withUnsupportedStatements(unsupported).withErrorRecovery(recovery))); + assertInstanceOf(IfElseStatement.class, TestUtils.assertSqlCanBeParsedAndDeparsed( + "IF x > 0 SELECT 1 ELSE SELECT 2", true, + p -> p.withUnsupportedStatements(unsupported).withErrorRecovery(recovery))); + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT 0; SELECT 1 SELECT 2", + p -> p.withUnsupportedStatements(unsupported).withErrorRecovery(recovery)); + assertEquals(3, statements.size()); + assertEquals("SELECT 2", + assertInstanceOf(Select.class, statements.get(2)).toString()); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"FROM t SELECT a, b", "FROM t |> WHERE a > 1", + "PIVOT sales ON region USING SUM(amount)", "UNPIVOT monthly_sales ON jan, feb", + "DESC table_name", "SUMMARIZE cfe.test", "VALUE (1)", "BRANCH START"}) + void alternateKnownRootsKeepTheirTypedDispatch(String sql) throws Exception { + Statement control = CCJSqlParserUtil.parse(sql); + assertTrue(!(control instanceof UnsupportedStatement)); + Statement actual = CCJSqlParserUtil.parse(sql, p -> p.withUnsupportedStatements(true)); + assertEquals(control.getClass(), actual.getClass()); + assertEquals(control.toString(), actual.toString()); + Statements script = CCJSqlParserUtil.parseStatements("SELECT 0;" + sql + ";SELECT 2;", + p -> p.withUnsupportedStatements(true)); + assertEquals(3, script.size()); + assertEquals(control.getClass(), script.get(1).getClass()); + assertEquals("SELECT 2", script.get(2).toString()); + } + + @Test + void oneStatementEntryDoesNotCaptureMultipleStatementsAsOneOpaqueValue() { + for (String sql : new String[] {"SELECT 1; SELECT 2", "shutdown defrag; SELECT 2"}) { + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withUnsupportedStatements(true))); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET IDENTITY_INSERT t", "SET IDENTITY_INSERT a.b.c.d ON", + "SET ISOLATION TO DIRTY", "SET IDENTITY_INSERT t ON garbage", + "SET ISOLATION TO COMMITTED READ WITH WARNING", + "SET ISOLATION TO REPEATABLE READ RETAIN UPDATE LOCKS"}) + void incompleteOpaqueVendorFormsAreRejected(String sql) { + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withUnsupportedStatements(true))); + assertThrowsExactly(JSQLParserException.class, + () -> CCJSqlParserUtil.parseStatements(sql, + p -> p.withUnsupportedStatements(true))); + } + + @Test + void lexicalErrorsAreNotSwallowed() { + assertThrowsExactly(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "UPDATE t SET a = 'unterminated", p -> p.withUnsupportedStatements(true))); + } + + @Test + void directSingleStatementRemainsIncremental() throws Exception { + CCJSqlParser parser = + CCJSqlParserUtil.newParser("SELECT * FROM").withUnsupportedStatements(true); + assertEquals("SELECT *", + assertInstanceOf(Select.class, parser.SingleStatement()).toString()); + assertEquals("FROM", parser.getToken(1).image); + parser = CCJSqlParserUtil.newParser("UPDATE t SET").withUnsupportedStatements(true) + .withErrorRecovery(true); + assertThrowsExactly(ParseException.class, parser::SingleStatement); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java index a7a7b6d4d0..f86f1bd106 100644 --- a/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/UnsupportedStatementTest.java @@ -15,8 +15,15 @@ import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.Arrays; +import java.util.function.Consumer; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.alter.AlterRelation; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; import net.sf.jsqlparser.statement.select.Select; import net.sf.jsqlparser.test.TestUtils; @@ -24,6 +31,8 @@ import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.function.Executable; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class UnsupportedStatementTest { @Test @@ -118,11 +127,11 @@ public void testCaptureRestIssue1993() throws JSQLParserException { } @Test - void testAlter() throws JSQLParserException { + void testFormerlyUnsupportedAlterIndex() throws JSQLParserException { String sqlStr = "ALTER INDEX idx_t_fa RENAME TO idx_t_fb"; Statement statement = TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); - assertInstanceOf(UnsupportedStatement.class, statement); + assertInstanceOf(AlterRelation.class, statement); } @Test @@ -195,10 +204,38 @@ void testInformixSetStatementIssue1945() throws JSQLParserException { "set isolation to dirty read;", true, parser -> parser.withUnsupportedStatements()); } + @ParameterizedTest + @ValueSource(strings = { + "CREATE SECRET sample (TYPE S3)", + "CREATE OR REPLACE SECRET sample (TYPE S3)"}) + void unknownCreateFallsBackToUnsupportedStatement(String sql) throws JSQLParserException { + for (Consumer dialect : Arrays.>asList(parser -> { + }, parser -> parser.withDialect(Dialect.POSTGRESQL))) { + Statement statement = CCJSqlParserUtil.parse(sql, dialect); + + assertInstanceOf(UnsupportedStatement.class, statement); + // the captured tokens render with single spaces; OR REPLACE is kept + assertEquals(sql.replaceAll("\\s+", ""), statement.toString().replaceAll("\\s+", "")); + } + } + + @Test + void unknownCreateDoesNotStopAScript() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "CREATE TABLE a (x int); CREATE SECRET sample (TYPE S3); CREATE INDEX i ON a (x);", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + + assertEquals(3, statements.size()); + assertInstanceOf(CreateTable.class, statements.get(0)); + assertInstanceOf(UnsupportedStatement.class, statements.get(1)); + assertInstanceOf(CreateIndex.class, statements.get(2)); + } + @Test void testRedshiftSetStatementIssue1708() throws JSQLParserException { Statement st = TestUtils.assertSqlCanBeParsedAndDeparsed( "SET x TO y;", true, parser -> parser.withUnsupportedStatements()); - assertInstanceOf(UnsupportedStatement.class, st); + SetStatement set = assertInstanceOf(SetStatement.class, st); + assertEquals(SetStatement.AssignmentOperator.TO, set.getAssignmentOperator()); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/UtilityOptionTest.java b/src/test/java/net/sf/jsqlparser/statement/UtilityOptionTest.java new file mode 100644 index 0000000000..e6a451fbc5 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/UtilityOptionTest.java @@ -0,0 +1,134 @@ +/*- + * #%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; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +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.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.UtilityOption.ValueType; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement.OptionKind; +import org.junit.jupiter.api.Test; + +class UtilityOptionTest { + + private enum IndexCleanup { + AUTO, ON, OFF + } + + @Test + void factoriesWriteTypedValues() { + assertEquals("VERBOSE", new UtilityOption("VERBOSE").toString()); + assertEquals("SKIP_LOCKED TRUE", UtilityOption.of("SKIP_LOCKED", true).toString()); + assertEquals("PARALLEL 3", UtilityOption.of("PARALLEL", 3).toString()); + assertEquals("BUFFER_USAGE_LIMIT 'it''s'", + UtilityOption.ofString("BUFFER_USAGE_LIMIT", "it's").toString()); + assertEquals(ValueType.WORD, UtilityOption.ofWord("INDEX_CLEANUP", "auto").getValueType()); + assertEquals(ValueType.BOOLEAN, + UtilityOption.ofWord("INDEX_CLEANUP", "off").getValueType()); + } + + @Test + void readsValuesAsPostgreSqlDoes() { + UtilityOption option = new UtilityOption("VERBOSE"); + assertFalse(option.hasValue()); + assertNull(option.getBooleanValue()); + assertNull(option.getStringValue()); + assertNull(option.getEnumValue(IndexCleanup.class)); + + assertEquals(Boolean.TRUE, option.withValue(ValueType.BOOLEAN, "on").getBooleanValue()); + assertEquals(Boolean.FALSE, option.withValue(ValueType.NUMBER, "0").getBooleanValue()); + assertNull(option.withValue(ValueType.NUMBER, "2").getBooleanValue()); + assertEquals(Boolean.TRUE, option.withValue(ValueType.STRING, "'true'").getBooleanValue()); + assertNull(option.withValue(ValueType.WORD, "yes").getBooleanValue()); + assertEquals(-4L, option.withValue(ValueType.NUMBER, "-4").getLongValue()); + assertNull(option.withValue(ValueType.STRING, "'4'").getLongValue()); + assertEquals("a\nb", option.withValue(ValueType.STRING, "E'a\\nb'").getStringValue()); + assertEquals(IndexCleanup.AUTO, + option.withValue(ValueType.WORD, "auto").getEnumValue(IndexCleanup.class)); + + option.removeValue(); + assertFalse(option.hasValue()); + assertThrows(IllegalArgumentException.class, () -> option.setValue(ValueType.WORD, null)); + assertThrows(NullPointerException.class, () -> option.setName(null)); + } + + @Test + void namesAndKinds() { + UtilityOption analyse = new UtilityOption("analyse"); + assertTrue(analyse.isNamed("ANALYZE")); + assertEquals(OptionKind.ANALYZE, analyse.getKind(OptionKind.class)); + assertNull(new UtilityOption("FORMAT").getKind(OptionKind.class)); + assertEquals(VacuumStatement.OptionKind.PARALLEL, + analyse.withName("Parallel").getKind(OptionKind.class)); + + // PostgreSQL keeps the case of a quoted name and compares it with the lower-case name + UtilityOption quoted = new UtilityOption("\"verbose\""); + assertEquals(OptionKind.VERBOSE, quoted.getKind(OptionKind.class)); + assertTrue(quoted.isNamed("VERBOSE")); + assertNull(quoted.withName("\"VERBOSE\"").getKind(OptionKind.class)); + assertNull(quoted.withName("\"analyse\"").getKind(OptionKind.class)); + assertEquals("a\"b", quoted.withValue(ValueType.WORD, "\"a\"\"b\"").getStringValue()); + } + + @Test + void rendersParenthesizedOrKeywordForms() { + String[] keywords = {"FULL", "VERBOSE"}; + StringBuilder builder = new StringBuilder("X"); + UtilityOption.appendOptions(builder, List.of(), false, keywords); + assertEquals("X", builder.toString()); + + builder = new StringBuilder("X"); + UtilityOption.appendOptions(builder, + List.of(new UtilityOption("verbose"), new UtilityOption("full")), false, keywords); + assertEquals("X full verbose", builder.toString()); + + builder = new StringBuilder("X"); + UtilityOption.appendOptions(builder, List.of(UtilityOption.of("FULL", true)), false, + keywords); + assertEquals("X (FULL TRUE)", builder.toString()); + + builder = new StringBuilder("X"); + UtilityOption.appendOptions(builder, List.of(new UtilityOption("SKIP_LOCKED")), false, + keywords); + assertEquals("X (SKIP_LOCKED)", builder.toString()); + + // a quoted name would read as a table name without parentheses + builder = new StringBuilder("X"); + UtilityOption.appendOptions(builder, List.of(new UtilityOption("\"full\"")), false, + keywords); + assertEquals("X (\"full\")", builder.toString()); + assertTrue(UtilityOption.isKeywordForm(List.of(), keywords)); + assertFalse(UtilityOption.isKeywordForm( + List.of(new UtilityOption("FULL"), new UtilityOption("full")), keywords)); + } + + @Test + void explainReadsTheSharedOptionList() throws JSQLParserException { + for (String sql : List.of("EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) SELECT * FROM t", + "EXPLAIN (ANALYZE false, COSTS 0, SERIALIZE TEXT, MEMORY) SELECT 1")) { + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + } + // EXPLAIN keeps its own option names and values, which accept no more than before + for (String sql : List.of("EXPLAIN (FULL) SELECT 1", "EXPLAIN (COSTS 'on') SELECT 1", + "EXPLAIN (FORMAT 'json') SELECT 1", "EXPLAIN (ANALYZE +1) SELECT 1", + "EXPLAIN (FOO) SELECT 1", "EXPLAIN (\"costs\") SELECT 1", + "EXPLAIN (COSTS \"on\") SELECT 1", "EXPLAIN (COSTS 1.0) SELECT 1", + "EXPLAIN (COSTS -1) SELECT 1", "EXPLAIN (ANALYSE) SELECT 1")) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql), sql); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/admin/MySqlFlushStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/admin/MySqlFlushStatementTest.java new file mode 100644 index 0000000000..79566e6dd4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/admin/MySqlFlushStatementTest.java @@ -0,0 +1,300 @@ +/*- + * #%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.admin; + +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.TableMaintenanceStatement.Modifier; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterSystemStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlFlushStatementTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer NO_DIALECT = parser -> { + }; + + @ParameterizedTest + @ValueSource(strings = { + "FLUSH TABLES", + "FLUSH TABLE", + "FLUSH TABLES WITH READ LOCK", + "FLUSH TABLES t, s WITH READ LOCK", + "FLUSH TABLES t FOR EXPORT", + "FLUSH TABLE t", + "FLUSH TABLES db1.t, `u`", + "FLUSH LOCAL TABLES t FOR EXPORT", + "FLUSH NO_WRITE_TO_BINLOG TABLE t WITH READ LOCK", + "FLUSH PRIVILEGES", + "FLUSH LOCAL BINARY LOGS", + "FLUSH NO_WRITE_TO_BINLOG LOGS", + "FLUSH ERROR LOGS, SLOW LOGS, STATUS", + "FLUSH RELAY LOGS", + "FLUSH RELAY LOGS FOR CHANNEL 'c1'", + "FLUSH LOGS, RELAY LOGS FOR CHANNEL 'c1'", + "FLUSH OPTIMIZER_COSTS", + "FLUSH USER_RESOURCES", + "FLUSH ENGINE LOGS, GENERAL LOGS", + "FLUSH BINARY LOGS, ENGINE LOGS, ERROR LOGS, GENERAL LOGS, LOGS, OPTIMIZER_COSTS, " + + "PRIVILEGES, RELAY LOGS, SLOW LOGS, STATUS, USER_RESOURCES"}) + void parsesMySqlFormsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(FlushStatement.class, statement); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void keepsTheOptionsInSourceOrder() throws JSQLParserException { + FlushStatement flush = + parse("flush local binary logs, relay logs for channel 'c1', status"); + assertEquals(Modifier.LOCAL, flush.getModifier()); + assertFalse(flush.isFlushTables()); + assertEquals(List.of(FlushOption.Kind.BINARY_LOGS, FlushOption.Kind.RELAY_LOGS, + FlushOption.Kind.STATUS), + flush.getOptions().stream().map(FlushOption::getKind) + .collect(Collectors.toList())); + assertNull(flush.getOptions().get(0).getChannel()); + assertEquals("c1", flush.getOptions().get(1).getChannel().getValue()); + assertTrue(flush.getTables().isEmpty()); + assertNull(flush.getTableLock()); + assertEquals("FLUSH LOCAL BINARY LOGS, RELAY LOGS FOR CHANNEL 'c1', STATUS", + flush.toString()); + } + + @Test + void keepsTheTablesAndTheirLock() throws JSQLParserException { + FlushStatement flush = parse("FLUSH NO_WRITE_TO_BINLOG TABLES db1.t, s WITH READ LOCK"); + assertTrue(flush.isFlushTables()); + assertTrue(flush.isTablesKeyword()); + assertEquals(Modifier.NO_WRITE_TO_BINLOG, flush.getModifier()); + assertEquals(List.of("db1.t", "s"), flush.getTables().stream() + .map(Table::getFullyQualifiedName).collect(Collectors.toList())); + assertEquals(FlushStatement.TableLock.WITH_READ_LOCK, flush.getTableLock()); + + FlushStatement export = parse("FLUSH TABLE t FOR EXPORT"); + assertFalse(export.isTablesKeyword()); + assertNull(export.getModifier()); + assertEquals(FlushStatement.TableLock.FOR_EXPORT, export.getTableLock()); + + FlushStatement all = parse("FLUSH TABLES"); + assertTrue(all.getTables().isEmpty()); + assertNull(all.getTableLock()); + assertTrue(all.getOptions().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = { + "FLUSH", + "FLUSH LOCAL", + "FLUSH HOSTS", + "FLUSH QUERY CACHE", + "FLUSH DES_KEY_FILE", + "FLUSH LOGS,", + "FLUSH BINARY", + "FLUSH STATUS LOGS", + "FLUSH LOCAL NO_WRITE_TO_BINLOG LOGS", + "FLUSH TABLES FOR EXPORT", + "FLUSH TABLES t WITH READ LOCK, PRIVILEGES", + "FLUSH PRIVILEGES, TABLES", + "FLUSH TABLES t WITH READ", + "FLUSH TABLES t FOR UPDATE", + "FLUSH TABLES t WITH READ LOCK FOR EXPORT", + "FLUSH RELAY LOGS FOR CHANNEL c1", + "FLUSH RELAY LOGS FOR CHANNEL `c1`", + "FLUSH RELAY LOGS FOR CHANNEL", + "FLUSH BINARY LOGS FOR CHANNEL 'c1'", + "FLUSH TABLES t,"}) + void rejectsFormsMySqlRejects(String sql) { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"FLUSH TABLES", "FLUSH PRIVILEGES", "FLUSH LOCAL LOGS"}) + void otherDialectsKeepRejectingFlush(String sql) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER)) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + sql + " " + dialect); + } + } + + @Test + void oracleAlterSystemFlushIsUnchanged() throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed("ALTER SYSTEM FLUSH SHARED_POOL", + true, parser -> parser.withDialect(Dialect.ORACLE)); + assertInstanceOf(AlterSystemStatement.class, statement); + } + + @Test + void wordsRemainUsableAsNames() throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertSqlCanBeParsedAndDeparsed( + "SELECT flush, logs, relay, slow, general, privileges, status, channel FROM flush", + true, dialect); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t AS flush", true, dialect); + } + } + + @Test + void endsTheStatementsAroundIt() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT 1; FLUSH TABLES WITH READ LOCK; FLUSH LOGS; UNLOCK TABLES", MYSQL); + assertEquals(List.of("PlainSelect", "FlushStatement", "FlushStatement", + "UnlockStatement"), names(statements)); + assertEquals("FLUSH TABLES WITH READ LOCK", statements.get(1).toString()); + + // WITH without READ LOCK starts the next statement + Statements next = CCJSqlParserUtil.parseStatements( + "SELECT 1; FLUSH TABLES t\nWITH x AS (SELECT 1) SELECT * FROM x", MYSQL); + assertEquals(List.of("PlainSelect", "FlushStatement", "PlainSelect"), names(next)); + assertEquals("FLUSH TABLES t", next.get(1).toString()); + } + + @Test + void isAStatementStartForUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "FOO BAR; FLUSH TABLES; BAZ; FLUSH HOSTS", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(List.of("UnsupportedStatement", "FlushStatement", "UnsupportedStatement", + "UnsupportedStatement"), names(statements)); + assertEquals("FLUSH HOSTS", statements.get(3).toString()); + + Statements postgres = CCJSqlParserUtil.parseStatements("FLUSH TABLES", + parser -> parser.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, postgres.get(0)); + } + + @Test + void findsTheFlushedTables() throws JSQLParserException { + assertThat(new TablesNamesFinder<>() + .getTables(CCJSqlParserUtil.parse("FLUSH TABLES db1.t, s WITH READ LOCK"))) + .containsExactlyInAnyOrder("db1.t", "s"); + assertThat(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse("FLUSH TABLES"))) + .isEmpty(); + assertThat(new TablesNamesFinder<>() + .getTables(CCJSqlParserUtil.parse("FLUSH PRIVILEGES, LOGS"))).isEmpty(); + } + + @Test + void reportsSessionFeaturesAndTheLock() throws JSQLParserException { + StatementFeatures logs = CCJSqlParserUtil.parse("FLUSH LOGS").getFeatures(); + assertThat(logs.getCertain()).containsExactly(StmtFeature.MODIFIES_SESSION); + + for (String sql : new String[] {"FLUSH TABLES WITH READ LOCK", + "FLUSH TABLE t FOR EXPORT"}) { + assertThat(CCJSqlParserUtil.parse(sql).getFeatures().getCertain()) + .containsExactlyInAnyOrder(StmtFeature.MODIFIES_SESSION, + StmtFeature.MODIFIES_TRANSACTION); + } + } + + @Test + void nodesSpanTheStatementTablesAndOptions() throws JSQLParserException { + String sql = "FLUSH LOCAL TABLES db1.t, s WITH READ LOCK"; + FlushStatement flush = parse(sql); + assertEquals(sql, text(sql, flush)); + assertEquals("db1.t", text(sql, flush.getTables().get(0))); + assertEquals("s", text(sql, flush.getTables().get(1))); + + sql = "FLUSH ERROR LOGS, RELAY LOGS FOR CHANNEL 'c1', STATUS"; + flush = parse(sql); + assertEquals(sql, text(sql, flush)); + assertEquals("ERROR LOGS", text(sql, flush.getOptions().get(0))); + assertEquals("RELAY LOGS FOR CHANNEL 'c1'", text(sql, flush.getOptions().get(1))); + assertEquals("'c1'", text(sql, flush.getOptions().get(1).getChannel())); + assertEquals("STATUS", text(sql, flush.getOptions().get(2))); + } + + @Test + void buildsStatementsInCode() { + FlushStatement flush = new FlushStatement(); + assertTrue(flush.isFlushTables()); + assertEquals("FLUSH TABLES", flush.toString()); + flush.withTablesKeyword(false).addTables(new Table("db", "t")) + .withTableLock(FlushStatement.TableLock.FOR_EXPORT) + .withModifier(Modifier.NO_WRITE_TO_BINLOG); + assertEquals("FLUSH NO_WRITE_TO_BINLOG TABLE db.t FOR EXPORT", flush.toString()); + assertEquals(flush.toString(), deparse(flush)); + + FlushOption relay = new FlushOption(FlushOption.Kind.RELAY_LOGS) + .withChannel(new StringValue("c1")); + FlushStatement options = new FlushStatement() + .withOptions(List.of(new FlushOption(FlushOption.Kind.OPTIMIZER_COSTS))) + .addOptions(relay); + assertFalse(options.isFlushTables()); + assertEquals("FLUSH OPTIMIZER_COSTS, RELAY LOGS FOR CHANNEL 'c1'", options.toString()); + assertEquals(options.toString(), deparse(options)); + options.setOptions(null); + options.setTables(List.of(new Table("t"))); + assertEquals("FLUSH TABLES t", options.toString()); + options.setTables(null); + assertEquals("FLUSH TABLES", options.toString()); + + assertEquals(FlushOption.Kind.SLOW_LOGS, FlushOption.Kind.fromKeyword("slow logs")); + assertNull(FlushOption.Kind.fromKeyword("HOSTS")); + assertNull(FlushOption.Kind.fromKeyword(null)); + assertThrows(NullPointerException.class, () -> relay.setKind(null)); + assertEquals("ENGINE LOGS", new FlushOption(FlushOption.Kind.ENGINE_LOGS).toString()); + } + + private static FlushStatement parse(String sql) throws JSQLParserException { + return (FlushStatement) assertSqlCanBeParsedAndDeparsed(sql, true, MYSQL); + } + + private static List names(Statements statements) { + return statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList()); + } + + static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/admin/MySqlKillStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/admin/MySqlKillStatementTest.java new file mode 100644 index 0000000000..2fe79d9edb --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/admin/MySqlKillStatementTest.java @@ -0,0 +1,182 @@ +/*- + * #%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.admin; + +import static net.sf.jsqlparser.statement.admin.MySqlFlushStatementTest.deparse; +import static net.sf.jsqlparser.statement.admin.MySqlFlushStatementTest.text; +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.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.UserVariable; +import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterSystemStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlKillStatementTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer NO_DIALECT = parser -> { + }; + + @ParameterizedTest + @ValueSource(strings = { + "KILL 123", + "KILL QUERY 123", + "KILL CONNECTION 123", + "KILL CONNECTION 1 + 2", + "KILL @x", + "KILL QUERY @id", + "KILL CONNECTION_ID()", + "KILL ?", + "KILL connection + 1"}) + void parsesMySqlFormsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, dialect); + assertInstanceOf(KillStatement.class, statement); + assertEquals(statement.toString(), deparse(statement)); + assertEquals(statement.toString(), + CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void keepsWhatItEndsAndTheIdentifierExpression() throws JSQLParserException { + KillStatement kill = parse("KILL 123"); + assertNull(kill.getKind()); + assertEquals(123L, ((LongValue) kill.getProcesslistId()).getValue()); + + assertEquals(KillStatement.Kind.QUERY, parse("kill query 123").getKind()); + assertEquals(KillStatement.Kind.CONNECTION, parse("KILL CONNECTION 123").getKind()); + assertInstanceOf(Addition.class, parse("KILL CONNECTION 1 + 2").getProcesslistId()); + assertInstanceOf(UserVariable.class, parse("KILL @x").getProcesslistId()); + + // CONNECTION is the keyword only before the identifier, as in MySQL's grammar + KillStatement function = parse("KILL CONNECTION_ID()"); + assertNull(function.getKind()); + assertInstanceOf(Function.class, function.getProcesslistId()); + KillStatement plus = parse("KILL connection + 1"); + assertEquals(KillStatement.Kind.CONNECTION, plus.getKind()); + assertEquals("KILL CONNECTION +1", plus.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "KILL", + "KILL QUERY", + "KILL CONNECTION", + "KILL QUERY CONNECTION 1", + "KILL 1 2", + "KILL 1, 2", + "KILL USER u"}) + void rejectsFormsMySqlRejects(String sql) { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"KILL 1", "KILL QUERY 1"}) + void otherDialectsKeepRejectingKill(String sql) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER)) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + sql + " " + dialect); + } + } + + @Test + void oracleAlterSystemKillSessionIsUnchanged() throws JSQLParserException { + assertInstanceOf(AlterSystemStatement.class, assertSqlCanBeParsedAndDeparsed( + "ALTER SYSTEM KILL SESSION '13, 8'", true, + parser -> parser.withDialect(Dialect.ORACLE))); + } + + @Test + void wordsRemainUsableAsNames() throws JSQLParserException { + // MySQL 8.4 reserves KILL, but the parser keeps accepting it as a name, as before + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertSqlCanBeParsedAndDeparsed("SELECT kill, query, connection FROM kill", true, + dialect); + } + } + + @Test + void endsTheStatementsAroundIt() throws JSQLParserException { + Statements statements = + CCJSqlParserUtil.parseStatements("SELECT 1; KILL QUERY 5; KILL 6", MYSQL); + assertEquals(List.of("PlainSelect", "KillStatement", "KillStatement"), + statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList())); + + Statements unsupported = CCJSqlParserUtil.parseStatements("FOO; KILL 5", + parser -> parser.withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, unsupported.get(0)); + assertInstanceOf(KillStatement.class, unsupported.get(1)); + } + + @Test + void findsTablesOnlyInASubquery() throws JSQLParserException { + assertThat(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse("KILL 5"))) + .isEmpty(); + assertThat(new TablesNamesFinder<>() + .getTables(CCJSqlParserUtil.parse("KILL (SELECT MAX(id) FROM t)"))) + .containsExactly("t"); + assertThat(new TablesNamesFinder<>().getTables(new KillStatement())).isEmpty(); + } + + @Test + void reportsSessionFeatures() throws JSQLParserException { + assertThat(CCJSqlParserUtil.parse("KILL QUERY 5").getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + } + + @Test + void nodesSpanTheStatementAndTheIdentifier() throws JSQLParserException { + String sql = "KILL CONNECTION 1 + 2"; + KillStatement kill = parse(sql); + assertEquals(sql, text(sql, kill)); + assertEquals("1 + 2", text(sql, kill.getProcesslistId())); + } + + @Test + void buildsStatementsInCode() { + KillStatement kill = new KillStatement().withProcesslistId(new LongValue(5)); + assertEquals("KILL 5", kill.toString()); + kill.withKind(KillStatement.Kind.QUERY); + assertEquals("KILL QUERY 5", deparse(kill)); + assertEquals("KILL CONNECTION @x", new KillStatement(KillStatement.Kind.CONNECTION, + new UserVariable("x")).toString()); + } + + private static KillStatement parse(String sql) throws JSQLParserException { + return (KillStatement) assertSqlCanBeParsedAndDeparsed(sql, true, MYSQL); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterActionRenderingTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterActionRenderingTest.java new file mode 100644 index 0000000000..94815435b3 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterActionRenderingTest.java @@ -0,0 +1,180 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.alter.AlterExpression.TableRenameKeyword; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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.Arguments; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterActionRenderingTest { + + static Stream drops() { + return Stream.of( + drop("DROP old_column", action -> action.setColumnName("old_column")), + drop("DROP COLUMN IF EXISTS old_column CASCADE", action -> { + action.hasColumn(true); + action.setUsingIfExists(true); + action.setColumnName("old_column"); + action.addParameters("CASCADE"); + }), + drop("DROP CONSTRAINT IF EXISTS old_constraint RESTRICT", action -> { + action.setUsingIfExists(true); + action.setConstraintName("old_constraint"); + action.addParameters("RESTRICT"); + }), + drop("DROP INDEX old_index", action -> action.setIndex( + new Index().withType("INDEX").withName("old_index"))), + drop("DROP KEY old_key", action -> action.setIndex( + new Index().withType("KEY").withName("old_key"))), + drop("DROP (a, b) CASCADE CONSTRAINTS", action -> { + action.setPkColumns(List.of("a", "b")); + action.addParameters("CASCADE", "CONSTRAINTS"); + })); + } + + private static Arguments drop(String sql, Consumer configure) { + return Arguments.of(sql, configure); + } + + @ParameterizedTest + @MethodSource("drops") + void legacyAndTypedDropActionsShareRendering(String body, Consumer configure) + throws JSQLParserException { + for (AlterExpression action : List.of(new AlterExpression(), new AlterExpressionDrop())) { + action.setOperation(AlterOperation.DROP); + configure.accept(action); + assertRoundTrip(action, body, AlterExpressionDrop.class); + } + } + + @ParameterizedTest + @EnumSource(TableRenameKeyword.class) + void legacyAndTypedTableRenamesHonorTheSelectedKeyword(TableRenameKeyword keyword) + throws JSQLParserException { + String body = "RENAME" + (keyword == TableRenameKeyword.NONE ? "" : " " + keyword) + + " db2.renamed"; + for (AlterExpression action : List.of(new AlterExpression(), new AlterExpressionRename())) { + action.setOperation(AlterOperation.RENAME_TABLE); + action.setNewTable(new Table("db2", "renamed")); + action.setTableRenameKeyword(keyword); + assertRoundTrip(action, body, AlterExpressionRename.class); + } + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void legacyAndTypedColumnRenamesShareRendering(boolean hasColumn) throws JSQLParserException { + for (AlterExpression action : List.of(new AlterExpression(), new AlterExpressionRename())) { + action.setOperation(AlterOperation.RENAME); + action.hasColumn(hasColumn); + action.setColumnOldName("old_column"); + action.setColumnName("new_column"); + assertRoundTrip(action, "RENAME " + (hasColumn ? "COLUMN " : "") + + "old_column TO new_column", AlterExpressionRename.class); + } + } + + @ParameterizedTest + @EnumSource(value = AlterOperation.class, + names = {"RENAME_INDEX", "RENAME_KEY"}) + void legacyAndTypedIndexRenamesShareRendering(AlterOperation operation) + throws JSQLParserException { + for (AlterExpression action : List.of(new AlterExpression(), new AlterExpressionRename())) { + action.setOperation(operation); + action.setOldIndex(new Index().withName("old_name")); + action.setIndex(new Index().withName("new_name")); + assertRoundTrip(action, operation.toString().replace('_', ' ') + + " old_name TO new_name", AlterExpressionRename.class); + } + } + + @Test + void legacyAndTypedConstraintRenamesShareRendering() throws JSQLParserException { + for (AlterExpression action : List.of(new AlterExpression(), new AlterExpressionRename())) { + action.setOperation(AlterOperation.RENAME_CONSTRAINT); + action.setConstraintName("old_name"); + action.setNewConstraintName("new_name"); + assertRoundTrip(action, "RENAME CONSTRAINT old_name TO new_name", + AlterExpressionRename.class); + } + } + + @Test + void commonTailIsAppendedOnceForTypedAndLegacyActions() { + for (AlterExpression action : List.of(new AlterExpression(), new AlterExpressionDrop())) { + Index index = new Index().withType("INDEX").withName("old_index"); + index.setCommentText("'index comment'"); + action.setOperation(AlterOperation.DROP); + action.setIndex(index); + action.addParameters("CASCADE"); + assertEquals("DROP INDEX old_index CASCADE COMMENT 'index comment'", action.toString()); + StringBuilder output = new StringBuilder(); + statement(action).accept(new StatementDeParser(output), null); + assertEquals("ALTER TABLE t DROP INDEX old_index CASCADE COMMENT 'index comment'", + output.toString()); + } + } + + @Test + void mixedActionsStillUseTheCustomExpressionDeparser() throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t DROP COLUMN obsolete, " + + "RENAME COLUMN old_column TO new_column, ADD COLUMN amount INT DEFAULT (1 + 2)"); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(value.getValue() + 100); + } + }; + alter.accept(new StatementDeParser(expressions, new SelectDeParser(), output), null); + String expected = "ALTER TABLE t DROP COLUMN obsolete, " + + "RENAME COLUMN old_column TO new_column, ADD COLUMN amount INT DEFAULT (101 + 102)"; + assertEquals(expected, output.toString()); + assertEquals(expected, CCJSqlParserUtil.parse(output.toString()).toString()); + } + + private static Alter statement(AlterExpression action) { + Alter alter = new Alter(); + alter.setTable(new Table("t")); + alter.addAlterExpression(action); + return alter; + } + + private static void assertRoundTrip(AlterExpression action, String expectedBody, + Class parsedType) throws JSQLParserException { + String expected = "ALTER TABLE t " + expectedBody; + Alter alter = statement(action); + assertEquals(expected, alter.toString()); + StringBuilder output = new StringBuilder(); + alter.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + Alter reparsed = (Alter) CCJSqlParserUtil.parse(output.toString()); + assertInstanceOf(parsedType, reparsed.getAlterExpressions().get(0)); + assertEquals(expected, reparsed.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java new file mode 100644 index 0000000000..ce41db3d31 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java @@ -0,0 +1,128 @@ +/*- + * #%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.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; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +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.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * ALTER TABLE ADD accepts the table constraint forms of CREATE TABLE in every dialect, not only + * with the MySQL and PostgreSQL dialects. + */ +class AlterAddTableConstraintTest { + private static final List DIALECTS = + Arrays.asList(null, Dialect.ANSI_SQL, Dialect.ORACLE, Dialect.SQLSERVER, Dialect.H2); + + @ParameterizedTest + @ValueSource(strings = { + "CHECK (id > 0)", + "CHECK (id > 0) NOT VALID", + "CONSTRAINT ck CHECK (id > 0) NOT VALID", + "FOREIGN KEY (id) REFERENCES parent (id) DEFERRABLE INITIALLY DEFERRED", + "CONSTRAINT fk FOREIGN KEY (id) REFERENCES parent (id) NOT VALID", + "CONSTRAINT pk PRIMARY KEY (id) DEFERRABLE INITIALLY DEFERRED", + "CONSTRAINT uq UNIQUE (id) DEFERRABLE INITIALLY IMMEDIATE", + "CONSTRAINT ex EXCLUDE USING gist (id WITH =)"}) + void createAndAlterExposeTheSameConstraintInEveryDialect(String definition) + throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + Consumer configuration = parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }; + CreateTable create = (CreateTable) CCJSqlParserUtil + .parse("CREATE TABLE t (id INT, " + definition + ")", configuration); + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t ADD " + definition + ", ADD COLUMN other INT", true, + configuration); + NamedConstraint expected = create.getTableConstraints().get(0); + NamedConstraint actual = alter.getAlterExpressions().get(0).getConstraint(); + assertEquals(expected.getClass(), actual.getClass(), String.valueOf(dialect)); + assertEquals(expected.toString(), actual.toString(), String.valueOf(dialect)); + assertEquals(2, alter.getAlterExpressions().size()); + } + } + + @Test + void attributesAndReferencesAreStructuredWithoutADialect() throws JSQLParserException { + String sql = "ALTER TABLE t ADD CONSTRAINT fk FOREIGN KEY (id) REFERENCES parent (id) " + + "DEFERRABLE INITIALLY DEFERRED"; + Alter alter = (Alter) CCJSqlParserUtil.parse(sql); + ForeignKeyConstraint foreignKey = assertInstanceOf(ForeignKeyConstraint.class, + alter.getAlterExpressions().get(0).getConstraint()); + ConstraintAttributes attributes = foreignKey.getConstraintAttributes(); + assertEquals(Boolean.TRUE, attributes.getDeferrable()); + assertEquals(ConstraintAttributes.Initially.DEFERRED, attributes.getInitially()); + assertThat(TablesNamesFinder.findTables(sql)).containsExactlyInAnyOrder("t", "parent"); + + CheckConstraint check = assertInstanceOf(CheckConstraint.class, + ((Alter) CCJSqlParserUtil.parse("ALTER TABLE t ADD CHECK (id > 0) NOT VALID")) + .getAlterExpressions().get(0).getConstraint()); + assertNull(check.getName()); + assertTrue(check.getConstraintAttributes().isNotValid()); + } + + @Test + void formsThatAlreadyParsedKeepTheGenericRepresentation() throws JSQLParserException { + AlterExpression deferrable = ((Alter) CCJSqlParserUtil + .parse("ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (id) DEFERRABLE")) + .getAlterExpressions().get(0); + assertThat(deferrable.getConstraints()).hasSize(1); + assertInstanceOf(DeferrableConstraint.class, deferrable.getConstraints().get(0)); + + AlterExpression unique = ((Alter) CCJSqlParserUtil + .parse("ALTER TABLE t ADD CONSTRAINT UNIQUE KEY uk (id)")) + .getAlterExpressions().get(0); + assertEquals("UNIQUE KEY", unique.getConstraintType()); + } + + @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))); + } + + @Test + void enforcedPrimaryKeyIsRejected() { + JSQLParserException exception = assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil + .parse("ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (id) ENFORCED")); + assertThat(exception).hasStackTraceContaining( + "ENFORCED is supported only for CHECK and foreign key constraints"); + } +} 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterConstraintSeparationTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterConstraintSeparationTest.java new file mode 100644 index 0000000000..f568b6eba5 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterConstraintSeparationTest.java @@ -0,0 +1,201 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.List; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.CheckConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +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 AlterConstraintSeparationTest { + @Test + void uniqueConstraintAndOrdinaryIndexHaveSeparateEditableDefinitions() throws Exception { + Alter statement = parse("ALTER TABLE t ADD UNIQUE INDEX uq (id), ADD INDEX ix (other)", + Dialect.MYSQL); + AlterExpression uniqueAction = statement.getAlterExpressions().get(0); + KeyConstraint unique = assertInstanceOf(KeyConstraint.class, uniqueAction.getConstraint()); + assertNull(uniqueAction.getIndex()); + assertEquals(ConstraintKind.UNIQUE, uniqueAction.getConstraintKind()); + assertEquals("uq", unique.getIndexName()); + assertNull(unique.getName()); + + AlterExpression indexAction = statement.getAlterExpressions().get(1); + assertNull(indexAction.getConstraint()); + assertEquals(ConstraintKind.OTHER, indexAction.getConstraintKind()); + assertEquals(Index.Kind.INDEX, indexAction.getIndex().getKind()); + unique.setName("unique_symbol"); + unique.setIndexName("new_uq"); + assertEquals("new_uq", uniqueAction.getUkName()); + uniqueAction.setUkName("legacy_uq"); + assertEquals("legacy_uq", unique.getIndexName()); + uniqueAction.setUkColumns(List.of("new_id")); + indexAction.getIndex().setName("new_ix"); + assertRoundTrip(statement, + "ALTER TABLE t ADD CONSTRAINT unique_symbol UNIQUE INDEX legacy_uq (new_id), " + + "ADD INDEX new_ix (other)", + Dialect.MYSQL); + } + + @Test + void genericConstraintKeywordPathExposesACompleteUniqueDefinition() throws Exception { + Alter statement = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD CONSTRAINT UNIQUE KEY uq (id)"); + AlterExpression action = statement.getAlterExpressions().get(0); + KeyConstraint key = assertInstanceOf(KeyConstraint.class, action.getConstraint()); + assertNull(action.getIndex()); + assertEquals(ConstraintKind.UNIQUE, key.getKind()); + assertEquals("UNIQUE KEY", key.getType()); + assertEquals("uq", key.getIndexName()); + assertEquals("CONSTRAINT UNIQUE KEY uq (id)", key.toString()); + action.setUkColumns(List.of("new_id")); + key.setIndexName("renamed_uq"); + key.setType("UNIQUE INDEX"); + assertEquals("renamed_uq", action.getConstraintSymbol()); + assertEquals("UNIQUE INDEX", action.getConstraintType()); + assertEquals("CONSTRAINT UNIQUE INDEX renamed_uq (new_id)", key.toString()); + action.setConstraintSymbol("legacy_uq"); + assertEquals("legacy_uq", key.getIndexName()); + action.setConstraintType("UNIQUE KEY"); + assertEquals("UNIQUE KEY", key.getType()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(statement.toString(), deparsed.toString()); + assertEquals(statement.toString(), CCJSqlParserUtil.parse(deparsed.toString()).toString()); + } + + @Test + void replacingDefinitionChangesTheRenderedActionAndItsClassification() throws Exception { + Alter statement = parse("ALTER TABLE t ADD INDEX ix (id)", Dialect.MYSQL); + AlterExpression action = statement.getAlterExpressions().get(0); + action.setConstraint(new KeyConstraint().withType("PRIMARY KEY") + .withColumnsNames(List.of("id"))); + assertNull(action.getIndex()); + assertEquals(ConstraintKind.PRIMARY_KEY, action.getConstraintKind()); + action.setIndex(null); + assertRoundTrip(statement, "ALTER TABLE t ADD PRIMARY KEY (id)", Dialect.MYSQL); + + action.setIndex( + new Index().withIndexKeyword("INDEX").withKind(Index.Kind.INDEX).withName("ix_new") + .withColumnsNames(List.of("id"))); + assertNull(action.getConstraint()); + action.setConstraint(null); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertRoundTrip(statement, "ALTER TABLE t ADD INDEX ix_new (id)", Dialect.MYSQL); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void replacingLegacyUniqueDefinitionClearsItsOldHeader(boolean replaceWithIndex) + throws Exception { + Alter statement = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD CONSTRAINT UNIQUE KEY uq (id)"); + AlterExpression action = statement.getAlterExpressions().get(0); + String original = statement.toString(); + action.setConstraint(action.getConstraint()); + assertEquals(original, statement.toString()); + if (replaceWithIndex) { + action.setIndex(new Index().withIndexKeyword("INDEX").withKind(Index.Kind.INDEX) + .withName("ix").withColumnsNames(List.of("id"))); + assertNull(action.getConstraint()); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertRoundTrip(statement, "ALTER TABLE t ADD INDEX ix (id)", Dialect.MYSQL); + } else { + action.setConstraint(new CheckConstraint() + .withExpression(CCJSqlParserUtil.parseCondExpression("id > 0"))); + assertNull(action.getIndex()); + assertEquals(ConstraintKind.CHECK, action.getConstraintKind()); + assertRoundTrip(statement, "ALTER TABLE t ADD CHECK (id > 0)", Dialect.MYSQL); + } + assertNull(action.getConstraintType()); + assertNull(action.getConstraintSymbol()); + } + + @Test + void clearingLegacyUniqueDefinitionClearsItsHeaderAliases() throws Exception { + Alter statement = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD CONSTRAINT UNIQUE KEY uq (id)"); + AlterExpression action = statement.getAlterExpressions().get(0); + action.setConstraint(null); + assertNull(action.getConstraint()); + assertNull(action.getConstraintType()); + assertNull(action.getConstraintSymbol()); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + } + + @Test + void namedConstraintDropDoesNotInferDefinitionFromItsNameOrInactiveFields() throws Exception { + Alter statement = parse("ALTER TABLE t DROP CONSTRAINT pk_t", Dialect.POSTGRESQL); + AlterExpression action = statement.getAlterExpressions().get(0); + assertNull(action.getConstraint()); + assertNull(action.getIndex()); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + action.setConstraint(new CheckConstraint()); + action.setConstraintName("new_constraint"); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertRoundTrip(statement, "ALTER TABLE t DROP CONSTRAINT new_constraint", + Dialect.POSTGRESQL); + } + + @Test + void constraintRenameUsesNamesWithoutCreatingIndexDefinitions() throws Exception { + Alter statement = parse("ALTER TABLE t RENAME CONSTRAINT old_name TO new_name", + Dialect.POSTGRESQL); + AlterExpression action = statement.getAlterExpressions().get(0); + assertNull(action.getIndex()); + assertNull(action.getOldIndex()); + assertNull(action.getConstraint()); + assertEquals("old_name", action.getConstraintName()); + assertEquals("new_name", action.getNewConstraintName()); + action.setConstraintName("source_name"); + action.setNewConstraintName("target_name"); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertRoundTrip(statement, "ALTER TABLE t RENAME CONSTRAINT source_name TO target_name", + Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"INDEX", "KEY"}) + void indexRenameRetainsIndexTargetsAndKeyword(String keyword) throws Exception { + Alter statement = parse("ALTER TABLE t RENAME " + keyword + " old_name TO new_name", + Dialect.MYSQL); + AlterExpression action = statement.getAlterExpressions().get(0); + assertNull(action.getConstraint()); + assertNull(action.getConstraintName()); + assertNull(action.getNewConstraintName()); + action.getOldIndex().setName("source_name"); + action.getIndex().setName("target_name"); + assertRoundTrip(statement, + "ALTER TABLE t RENAME " + keyword + " source_name TO target_name", Dialect.MYSQL); + } + + private static Alter parse(String sql, Dialect dialect) throws Exception { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static void assertRoundTrip(Alter statement, String sql, Dialect dialect) + throws Exception { + assertEquals(sql, statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + assertEquals(sql, parse(deparsed.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterDropBehaviorTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterDropBehaviorTest.java new file mode 100644 index 0000000000..3a0263388c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterDropBehaviorTest.java @@ -0,0 +1,143 @@ +/*- + * #%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.statement.CascadeBehavior; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterDropBehaviorTest { + private static final Dialect[] DIALECTS = {Dialect.POSTGRESQL, null}; + + @ParameterizedTest + @CsvSource(value = {"DROP COLUMN b RESTRICT|RESTRICT", "DROP b RESTRICT|RESTRICT", + "DROP COLUMN IF EXISTS b RESTRICT|RESTRICT", "DROP IF EXISTS b CASCADE|CASCADE", + "DROP COLUMN b CASCADE|CASCADE", "DROP COLUMN b|"}, delimiter = '|') + void columnDropsExposeTheirBehavior(String action, CascadeBehavior behavior) + throws JSQLParserException { + String sql = "ALTER TABLE users " + action; + for (Dialect dialect : DIALECTS) { + Alter alter = parse(sql, dialect); + AlterExpressionDrop drop = + assertInstanceOf(AlterExpressionDrop.class, alter.getAlterExpressions().get(0)); + assertEquals("b", drop.getColumnName()); + assertEquals(action.contains("IF EXISTS"), drop.isUsingIfExists()); + assertEquals(behavior, drop.getBehavior()); + assertEquals(behavior == null ? null : List.of(behavior.name()), + drop.getParameters()); + assertRoundTrip(alter, sql, dialect); + } + } + + @Test + void restrictAppliesToItsOwnAction() throws JSQLParserException { + String sql = "ALTER TABLE users DROP a, DROP COLUMN b RESTRICT"; + for (Dialect dialect : DIALECTS) { + Alter alter = parse(sql, dialect); + assertNull(((AlterExpressionDrop) alter.getAlterExpressions().get(0)).getBehavior()); + assertEquals(CascadeBehavior.RESTRICT, + ((AlterExpressionDrop) alter.getAlterExpressions().get(1)).getBehavior()); + assertRoundTrip(alter, sql, dialect); + } + } + + @ParameterizedTest + @CsvSource(value = {"DROP CONSTRAINT IF EXISTS c RESTRICT|RESTRICT", + "DROP CONSTRAINT c CASCADE|CASCADE", "DROP PRIMARY KEY CASCADE|CASCADE", + "DROP UNIQUE (a, b) RESTRICT|RESTRICT", "DROP FOREIGN KEY (a) CASCADE|CASCADE"}, + delimiter = '|') + void constraintDropsShareTheBehavior(String action, CascadeBehavior behavior) + throws JSQLParserException { + String sql = "ALTER TABLE t " + action; + AlterExpressionDrop drop = assertInstanceOf(AlterExpressionDrop.class, + parse(sql, null).getAlterExpressions().get(0)); + assertEquals(behavior, drop.getBehavior()); + assertEquals(List.of(behavior.name()), drop.getParameters()); + assertRoundTrip(parse(sql, null), sql, null); + } + + @ParameterizedTest + @CsvSource(value = {"DROP COLUMN c CASCADE CONSTRAINTS||CASCADE,CONSTRAINTS", + "DROP COLUMN c INVALIDATE CASCADE CONSTRAINTS||INVALIDATE,CASCADE,CONSTRAINTS", + "DROP COLUMN c INVALIDATE CASCADE|CASCADE|INVALIDATE,CASCADE", + "DROP (a, b) CASCADE CONSTRAINTS||CASCADE,CONSTRAINTS"}, delimiter = '|') + void oracleClausesRemainRawParameters(String action, CascadeBehavior behavior, + String parameters) throws JSQLParserException { + String sql = "ALTER TABLE t " + action; + for (Dialect dialect : new Dialect[] {Dialect.ORACLE, null}) { + Alter alter = parse(sql, dialect); + AlterExpressionDrop drop = (AlterExpressionDrop) alter.getAlterExpressions().get(0); + assertEquals(behavior, drop.getBehavior()); + assertEquals(List.of(parameters.split(",")), drop.getParameters()); + assertRoundTrip(alter, sql, dialect); + } + } + + @Test + void editingTheBehaviorUpdatesBothRenderersAndLegacyParameters() + throws JSQLParserException { + Alter alter = parse("ALTER TABLE users DROP COLUMN b RESTRICT", Dialect.POSTGRESQL); + AlterExpressionDrop drop = (AlterExpressionDrop) alter.getAlterExpressions().get(0); + assertThrows(UnsupportedOperationException.class, () -> drop.getParameters().add("X")); + + drop.setBehavior(CascadeBehavior.CASCADE); + assertEquals(List.of("CASCADE"), drop.getParameters()); + assertRoundTrip(alter, "ALTER TABLE users DROP COLUMN b CASCADE", Dialect.POSTGRESQL); + + drop.setBehavior(null); + assertNull(drop.getParameters()); + assertRoundTrip(alter, "ALTER TABLE users DROP COLUMN b", Dialect.POSTGRESQL); + + AlterExpressionDrop built = + new AlterExpressionDrop().withBehavior(CascadeBehavior.RESTRICT); + built.setOperation(AlterOperation.DROP); + built.hasColumn(true); + built.setColumnName("b"); + Alter statement = new Alter(); + statement.setTable(new Table("users")); + statement.addAlterExpression(built); + assertRoundTrip(statement, "ALTER TABLE users DROP COLUMN b RESTRICT", Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP COLUMN b RESTRICT CASCADE", "DROP COLUMN b CASCADE RESTRICT", + "DROP COLUMN b RESTRICT RESTRICT"}) + void rejectsRepeatedBehaviors(String action) { + for (Dialect dialect : DIALECTS) { + assertThrows(JSQLParserException.class, + () -> parse("ALTER TABLE users " + action, dialect)); + } + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) (dialect == null + ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect))); + } + + private static void assertRoundTrip(Alter alter, String expected, Dialect dialect) + throws JSQLParserException { + assertEquals(expected, alter.toString()); + StringBuilder deparsed = new StringBuilder(); + alter.accept(new StatementDeParser(deparsed), null); + assertEquals(expected, deparsed.toString()); + assertEquals(expected, parse(deparsed.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterForeignKeyStateTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterForeignKeyStateTest.java new file mode 100644 index 0000000000..75fe0a0105 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterForeignKeyStateTest.java @@ -0,0 +1,306 @@ +/*- + * #%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.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 java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Database; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.ReferentialAction; +import net.sf.jsqlparser.statement.ReferentialAction.Action; +import net.sf.jsqlparser.statement.ReferentialAction.Type; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.ForeignKeyReference; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; +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.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterForeignKeyStateTest { + private static final String FK_SQL = "ALTER TABLE child ADD CONSTRAINT fk FOREIGN KEY " + + "(parent_id) REFERENCES app.parent(id) ON DELETE CASCADE"; + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "POSTGRESQL"}) + void legacyEditsUpdateParsedForeignKeysAndBothRenderers(Dialect dialect) throws Exception { + Alter statement = parse(FK_SQL, dialect); + AlterExpression action = first(statement); + ForeignKeyConstraint foreignKey = foreignKey(action); + assertEquals(List.of("parent_id"), action.getFkColumns()); + assertEquals("app", action.getFkSourceSchema()); + assertEquals("parent", action.getFkSourceTable()); + assertSame(foreignKey.getReferencedColumnNames(), action.getFkSourceColumns()); + assertSame(foreignKey.getReferentialAction(Type.DELETE), + action.getReferentialAction(Type.DELETE)); + + action.setFkColumns(List.of("owner_id")); + action.setFkSourceSchema("archive"); + action.setFkSourceTable("owners"); + action.setFkSourceColumns(new ArrayList<>(List.of("owner_key"))); + action.setReferentialAction(Type.DELETE, Action.RESTRICT); + + assertSame(foreignKey, action.getConstraint()); + assertEquals("fk", foreignKey.getName()); + assertRoundTrip("ALTER TABLE child ADD CONSTRAINT fk FOREIGN KEY (owner_id) " + + "REFERENCES archive.owners(owner_key) ON DELETE RESTRICT", statement, dialect); + } + + @Test + void actionColumnListsAndAttributesSurviveLegacyAndStructuredMutations() throws Exception { + Alter statement = parse("ALTER TABLE posts ADD CONSTRAINT fk FOREIGN KEY " + + "(tenant_id, author_id) REFERENCES users(tenant_id, id) MATCH SIMPLE " + + "ON DELETE SET NULL (author_id) DEFERRABLE INITIALLY DEFERRED NOT VALID", + Dialect.POSTGRESQL); + AlterExpression action = first(statement); + ForeignKeyConstraint foreignKey = foreignKey(action); + ReferentialAction delete = foreignKey.getReferentialAction(Type.DELETE); + assertSame(delete, action.getReferentialAction(Type.DELETE)); + action.setOnDeleteSetNull(true); + assertSame(delete, action.getReferentialAction(Type.DELETE)); + assertEquals(List.of("author_id"), delete.getColumnNames()); + + action.getReferentialAction(Type.DELETE).setColumnNames(List.of("tenant_id")); + action.setReferentialAction(Type.DELETE, Action.SET_DEFAULT); + assertSame(delete, foreignKey.getReferentialAction(Type.DELETE)); + assertEquals(List.of("tenant_id"), delete.getColumnNames()); + assertRoundTrip("ALTER TABLE posts ADD CONSTRAINT fk FOREIGN KEY " + + "(tenant_id, author_id) REFERENCES users(tenant_id, id) MATCH SIMPLE " + + "ON DELETE SET DEFAULT (tenant_id) DEFERRABLE INITIALLY DEFERRED NOT VALID", + statement, Dialect.POSTGRESQL); + + delete.setAction(Action.CASCADE); + action.removeReferentialAction(Type.DELETE); + assertNull(foreignKey.getReferentialAction(Type.DELETE)); + assertFalse(action.isOnDeleteSetNull()); + assertRoundTrip("ALTER TABLE posts ADD CONSTRAINT fk FOREIGN KEY " + + "(tenant_id, author_id) REFERENCES users(tenant_id, id) MATCH SIMPLE " + + "DEFERRABLE INITIALLY DEFERRED NOT VALID", statement, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void builderSetterOrderAndFluentSchemaPreserveOneReference(boolean schemaFirst) + throws Exception { + AlterExpression action = new AlterExpression(); + action.setReferentialAction(Type.DELETE, Action.CASCADE); + if (schemaFirst) { + action.withFkSourceSchema("archive").withFkSourceTable("parents"); + } else { + action.withFkSourceTable("parents").withFkSourceSchema("archive"); + } + action.withFkColumns(List.of("parent_id")).withFkSourceColumns(List.of("id")); + assertNull(action.getOperation()); + action.setOperation(AlterOperation.ADD); + assertEquals("parents", action.getFkSourceTable()); + assertEquals("archive", action.getFkSourceSchema()); + assertEquals(ConstraintKind.FOREIGN_KEY, action.getConstraintKind()); + assertRoundTrip("ALTER TABLE child ADD FOREIGN KEY (parent_id) " + + "REFERENCES archive.parents(id) ON DELETE CASCADE", statement(action), + Dialect.POSTGRESQL); + } + + @Test + void keySnapshotsAndFluentAdditionsUseTheCurrentStructuredColumns() throws Exception { + Alter statement = parse(FK_SQL, Dialect.POSTGRESQL); + AlterExpression action = first(statement); + ForeignKeyConstraint foreignKey = foreignKey(action); + foreignKey.setColumnsNames(List.of("account_id")); + List snapshot = action.getFkColumns(); + assertEquals(List.of("account_id"), snapshot); + snapshot.set(0, "detached"); + assertEquals(List.of("account_id"), action.getFkColumns()); + action.addFkColumns("tenant_id").addFkColumns(List.of("region_id")); + action.addFkSourceColumns("tenant_id").addFkSourceColumns(List.of("region_id")); + action.getFkSourceColumns().set(0, "account_key"); + assertSame(foreignKey.getReferencedColumnNames(), action.getFkSourceColumns()); + assertEquals(List.of("account_id", "tenant_id", "region_id"), + foreignKey.getColumnsNames()); + assertRoundTrip("ALTER TABLE child ADD CONSTRAINT fk FOREIGN KEY " + + "(account_id, tenant_id, region_id) REFERENCES app.parent" + + "(account_key, tenant_id, region_id) ON DELETE CASCADE", statement, + Dialect.POSTGRESQL); + } + + @Test + void referenceReplacementAndNameEditsPreserveOtherQualifiedNameParts() throws Exception { + AlterExpression action = first(parse(FK_SQL, Dialect.POSTGRESQL)); + Table table = new Table("new_schema", "new_parent"); + table.setDatabase(new Database("catalog")); + ForeignKeyReference replacement = new ForeignKeyReference().withTable(table) + .withReferencedColumnNames(new ArrayList<>(List.of("new_id"))) + .withReferentialAction(Type.UPDATE, Action.NO_ACTION); + foreignKey(action).setReference(replacement); + assertEquals("new_schema", action.getFkSourceSchema()); + assertEquals("new_parent", action.getFkSourceTable()); + assertSame(replacement.getReferencedColumnNames(), action.getFkSourceColumns()); + assertNull(action.getReferentialAction(Type.DELETE)); + assertSame(replacement.getReferentialAction(Type.UPDATE), + action.getReferentialAction(Type.UPDATE)); + + action.setFkSourceSchema("\"changed.schema\""); + action.setFkSourceTable("\"changed.parent\""); + assertSame(table, replacement.getTable()); + assertEquals("catalog", table.getDatabase().getDatabaseName()); + assertEquals("\"changed.schema\"", table.getSchemaName()); + assertEquals("\"changed.parent\"", table.getName()); + } + + @Test + void replacingOrClearingTheConstraintDoesNotRestoreDetachedForeignKeyState() + throws Exception { + AlterExpression action = first(parse(FK_SQL, Dialect.POSTGRESQL)); + ForeignKeyConstraint old = foreignKey(action); + ForeignKeyConstraint replacement = new ForeignKeyConstraint() + .withColumnsNames(List.of("replacement_id")) + .withTable(new Table("replacement_parent")) + .withReferencedColumnNames(List.of("id")); + action.setConstraint(replacement); + assertEquals(List.of("replacement_id"), action.getFkColumns()); + assertEquals("replacement_parent", action.getFkSourceTable()); + assertNull(action.getFkSourceSchema()); + assertNull(action.getReferentialAction(Type.DELETE)); + assertEquals(Action.CASCADE, old.getReferentialAction(Type.DELETE).getAction()); + action.setConstraint(null); + assertNoForeignKeyValues(action); + action.setFkSourceTable("fresh_parent"); + assertNull(action.getFkColumns()); + assertNull(action.getFkSourceColumns()); + assertNull(action.getReferentialAction(Type.DELETE)); + assertEquals("fresh_parent", foreignKey(action).getTable().getName()); + } + + @Test + void absentReadsClearsAndRemovalsDoNotCreateAForeignKey() { + AlterExpression action = new AlterExpression(); + assertNoForeignKeyValues(action); + clearForeignKeyValues(action); + assertNull(action.getConstraint()); + assertNull(action.getIndex()); + assertNull(action.getOperation()); + } + + @Test + void storedForeignKeyDefinitionDoesNotChangeADropTarget() throws Exception { + Alter statement = parse("ALTER TABLE child DROP FOREIGN KEY fk", Dialect.MYSQL); + AlterExpression action = first(statement); + ForeignKeyConstraint stale = new ForeignKeyConstraint().withName("stale") + .withColumnsNames(List.of("unused")) + .withTable(new Table("unused_parent")) + .withReferencedColumnNames(List.of("unused_id")); + action.setConstraint(stale); + assertSame(stale, action.getConstraint()); + assertEquals(ConstraintKind.FOREIGN_KEY, action.getConstraintKind()); + assertRoundTrip("ALTER TABLE child DROP FOREIGN KEY fk", statement, Dialect.MYSQL); + } + + static Stream nonForeignKeyDefinitions() { + return Stream.of( + new AlterExpression().withOperation(AlterOperation.ADD).withIndex( + new Index().withType("INDEX").withName("ix") + .withColumnsNames(List.of("id"))), + new AlterExpression().withOperation(AlterOperation.ADD).withConstraint( + new KeyConstraint().withType("UNIQUE").withColumnsNames(List.of("id"))), + new AlterExpression().withOperation(AlterOperation.ADD) + .withPkColumns(List.of("id")), + new AlterExpression().withOperation(AlterOperation.ADD) + .withUkColumns(List.of("id")), + new AlterExpressionPrimaryKey().withPkColumns(List.of("id"))); + } + + @ParameterizedTest + @MethodSource("nonForeignKeyDefinitions") + void legacyForeignKeySettersDoNotOverwriteOtherDefinitions(AlterExpression action) { + Index originalIndex = action.getIndex(); + NamedConstraint originalConstraint = action.getConstraint(); + List originalPkColumns = action.getPkColumns(); + List originalUkColumns = action.getUkColumns(); + String before = action.toString(); + assertNoForeignKeyValues(action); + clearForeignKeyValues(action); + assertThrows(IllegalStateException.class, () -> action.setFkColumns(List.of("fk"))); + assertThrows(IllegalStateException.class, () -> action.setFkSourceSchema("schema")); + assertThrows(IllegalStateException.class, () -> action.setFkSourceTable("parent")); + assertThrows(IllegalStateException.class, () -> action.setFkSourceColumns(List.of("id"))); + assertThrows(IllegalStateException.class, + () -> action.setReferentialAction(Type.DELETE, Action.CASCADE)); + assertSame(originalIndex, action.getIndex()); + assertSame(originalConstraint, action.getConstraint()); + assertEquals(originalPkColumns, action.getPkColumns()); + assertEquals(originalUkColumns, action.getUkColumns()); + assertEquals(before, action.toString()); + } + + private static void assertNoForeignKeyValues(AlterExpression action) { + assertNull(action.getFkColumns()); + assertNull(action.getFkSourceSchema()); + assertNull(action.getFkSourceTable()); + assertNull(action.getFkSourceColumns()); + assertNull(action.getReferentialAction(Type.DELETE)); + assertFalse(action.isOnDeleteCascade()); + assertFalse(action.isOnDeleteRestrict()); + assertFalse(action.isOnDeleteSetNull()); + } + + private static void clearForeignKeyValues(AlterExpression action) { + action.setFkColumns(null); + action.setFkSourceSchema(null); + action.setFkSourceTable(null); + action.setFkSourceColumns(null); + action.removeReferentialAction(Type.DELETE); + action.setOnDeleteCascade(false); + action.setOnDeleteRestrict(false); + action.setOnDeleteSetNull(false); + } + + private static ForeignKeyConstraint foreignKey(AlterExpression action) { + return assertInstanceOf(ForeignKeyConstraint.class, action.getConstraint()); + } + + private static AlterExpression first(Alter statement) { + return statement.getAlterExpressions().get(0); + } + + private static Alter statement(AlterExpression action) { + Alter statement = new Alter(); + statement.setTable(new Table("child")); + statement.addAlterExpression(action); + return statement; + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static void assertRoundTrip(String expected, Alter statement, Dialect dialect) + throws JSQLParserException { + assertEquals(expected, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(expected, output.toString()); + assertEquals(expected, parse(output.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterInstanceTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterInstanceTest.java new file mode 100644 index 0000000000..7c1337c567 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterInstanceTest.java @@ -0,0 +1,308 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +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.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterInstance.Action; +import net.sf.jsqlparser.statement.lock.BackupLockStatement; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.Arguments; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL ALTER INSTANCE. */ +class AlterInstanceTest { + private static final Dialect[] MYSQL_OR_NONE = {Dialect.MYSQL, null}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertSpans(String expected, String source, ASTNodeAccess access) { + Node node = access.getASTNode(); + assertNotNull(node, expected); + assertEquals(expected, source.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + /** + * Parses {@code sql}, which must print as {@code expected}, and checks the statement span, the + * deparser, the reparse, the feature analysis and the table finder. + */ + private static AlterInstance roundTrip(String sql, String expected, Dialect dialect) + throws Exception { + AlterInstance statement = assertInstanceOf(AlterInstance.class, parse(sql, dialect)); + assertEquals(expected, statement.toString()); + assertSpans(sql, sql, statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + Statement reparsed = parse(output.toString(), dialect); + assertInstanceOf(AlterInstance.class, reparsed); + assertEquals(expected, reparsed.toString()); + assertEquals(Set.of(StmtFeature.MODIFIES_SESSION), statement.getFeatures().getCertain()); + assertTrue(statement.getFeatures().getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder<>().getTables(statement).isEmpty()); + return statement; + } + + static Stream actions() { + return Stream.of( + Arguments.of("ALTER INSTANCE ENABLE INNODB REDO_LOG", + Action.ENABLE_INNODB_REDO_LOG, null, false), + Arguments.of("ALTER INSTANCE DISABLE INNODB REDO_LOG", + Action.DISABLE_INNODB_REDO_LOG, null, false), + Arguments.of("ALTER INSTANCE ROTATE INNODB MASTER KEY", + Action.ROTATE_INNODB_MASTER_KEY, null, false), + Arguments.of("ALTER INSTANCE ROTATE BINLOG MASTER KEY", + Action.ROTATE_BINLOG_MASTER_KEY, null, false), + Arguments.of("ALTER INSTANCE RELOAD TLS", Action.RELOAD_TLS, null, false), + Arguments.of("ALTER INSTANCE RELOAD TLS NO ROLLBACK ON ERROR", Action.RELOAD_TLS, + null, true), + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_main", + Action.RELOAD_TLS, "mysql_main", false), + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_admin", + Action.RELOAD_TLS, "mysql_admin", false), + Arguments.of( + "ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_admin NO ROLLBACK ON ERROR", + Action.RELOAD_TLS, "mysql_admin", true), + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL `mysql_main`", + Action.RELOAD_TLS, "`mysql_main`", false), + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL MYSQL_MAIN", + Action.RELOAD_TLS, "MYSQL_MAIN", false), + // the grammar takes any identifier; the server checks the name when it runs + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL other_channel", + Action.RELOAD_TLS, "other_channel", false), + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL channel", Action.RELOAD_TLS, + "channel", false), + Arguments.of("ALTER INSTANCE RELOAD TLS FOR CHANNEL tls NO ROLLBACK ON ERROR", + Action.RELOAD_TLS, "tls", true), + Arguments.of("ALTER INSTANCE RELOAD KEYRING", Action.RELOAD_KEYRING, null, false)); + } + + @ParameterizedTest + @MethodSource("actions") + void everyActionIsStructured(String sql, Action action, String channel, + boolean noRollbackOnError) throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + AlterInstance statement = roundTrip(sql, sql, dialect); + assertEquals(action, statement.getAction()); + assertEquals(channel, statement.getChannel()); + assertEquals(noRollbackOnError, statement.isNoRollbackOnError()); + assertTrue(sql.startsWith("ALTER INSTANCE " + action.getSql())); + } + } + + static Stream spellings() { + return Stream.of( + Arguments.of("alter instance rotate innodb master key", + "ALTER INSTANCE ROTATE INNODB MASTER KEY"), + Arguments.of("ALTER INSTANCE ROTATE `INNODB` MASTER KEY", + "ALTER INSTANCE ROTATE INNODB MASTER KEY"), + Arguments.of("ALTER INSTANCE ROTATE `binlog` MASTER KEY", + "ALTER INSTANCE ROTATE BINLOG MASTER KEY"), + Arguments.of("ALTER INSTANCE ROTATE 'BINLOG' MASTER KEY", + "ALTER INSTANCE ROTATE BINLOG MASTER KEY"), + Arguments.of("ALTER INSTANCE ROTATE \"binlog\" MASTER KEY", + "ALTER INSTANCE ROTATE BINLOG MASTER KEY"), + Arguments.of("ALTER INSTANCE DISABLE innodb redo_log", + "ALTER INSTANCE DISABLE INNODB REDO_LOG"), + Arguments.of("ALTER INSTANCE DISABLE `INNODB` `REDO_LOG`", + "ALTER INSTANCE DISABLE INNODB REDO_LOG"), + Arguments.of("ALTER INSTANCE ENABLE `innodb` `redo_log`", + "ALTER INSTANCE ENABLE INNODB REDO_LOG"), + Arguments.of("alter instance reload tls for channel mysql_main " + + "no rollback on error", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_main NO ROLLBACK ON ERROR"), + Arguments.of("alter instance reload keyring", "ALTER INSTANCE RELOAD KEYRING")); + } + + @ParameterizedTest + @MethodSource("spellings") + void quotedAndLowerCaseWordsPrintAsPlainKeywords(String sql, String expected) + throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + roundTrip(sql, expected, dialect); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER INSTANCE ROTATE MASTER KEY", + "ALTER INSTANCE ROTATE MYISAM MASTER KEY", + "ALTER INSTANCE ROTATE REDO_LOG MASTER KEY", + "ALTER INSTANCE ROTATE 'x' MASTER KEY", + "ALTER INSTANCE ROTATE N'INNODB' MASTER KEY", + "ALTER INSTANCE ROTATE X'494E4E4F4442' MASTER KEY", + "ALTER INSTANCE ROTATE INNODB MASTER", + "ALTER INSTANCE ROTATE INNODB KEY", + "ALTER INSTANCE ROTATE INNODB MASTER KEYS", + "ALTER INSTANCE ROTATE INNODB MASTER KEY x", + "ALTER INSTANCE ROTATE INNODB, BINLOG MASTER KEY", + "ALTER INSTANCE ROTATE INNODB MASTER KEY, ROTATE BINLOG MASTER KEY", + "ALTER INSTANCE RELOAD", + "ALTER INSTANCE RELOAD SSL", + "ALTER INSTANCE RELOAD TLS ROLLBACK ON ERROR", + "ALTER INSTANCE RELOAD TLS NO ROLLBACK", + "ALTER INSTANCE RELOAD TLS NO ROLLBACK ON ERROR x", + "ALTER INSTANCE RELOAD TLS NO ROLLBACK ON ERROR FOR CHANNEL mysql_main", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL 'mysql_main'", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL \"mysql_main\"", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL 1", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL d.mysql_main", + "ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_main, mysql_admin", + "ALTER INSTANCE RELOAD TLS FOR mysql_main", + "ALTER INSTANCE RELOAD TLS CHANNEL mysql_main", + "ALTER INSTANCE RELOAD TLS, RELOAD KEYRING", + "ALTER INSTANCE RELOAD KEYRING NO ROLLBACK ON ERROR", + "ALTER INSTANCE RELOAD KEYRING x", + "ALTER INSTANCE ENABLE INNODB", + "ALTER INSTANCE ENABLE REDO_LOG", + "ALTER INSTANCE ENABLE INNODB REDO LOG", + "ALTER INSTANCE ENABLE MYISAM REDO_LOG", + "ALTER INSTANCE ENABLE BINLOG REDO_LOG", + "ALTER INSTANCE ENABLE INNODB UNDO_LOG", + "ALTER INSTANCE ENABLE 'INNODB' REDO_LOG", + "ALTER INSTANCE ENABLE \"INNODB\" REDO_LOG", + "ALTER INSTANCE ENABLE INNODB 'REDO_LOG'", + "ALTER INSTANCE ENABLE INNODB REDO_LOG NO ROLLBACK ON ERROR", + "ALTER INSTANCE DISABLE INNODB REDO_LOG x", + "ALTER INSTANCE ENABLE INNODB REDO_LOG, DISABLE INNODB REDO_LOG"}) + void rejectsWhatTheServerGrammarRejects(String sql) { + for (Dialect dialect : MYSQL_OR_NONE) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER INSTANCE", "ALTER INSTANCE FLUSH TLS", + "ALTER INSTANCE mysql ENABLE INNODB REDO_LOG"}) + void mySqlDialectRejectsAnUnknownAction(String sql) throws Exception { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + // without a dialect only a known action selects the statement + assertInstanceOf(UnsupportedStatement.class, parse(sql, null)); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MARIADB", "POSTGRESQL", "ORACLE", "SQLSERVER"}) + void otherDialectsKeepTheirReading(Dialect dialect) throws Exception { + assertInstanceOf(UnsupportedStatement.class, + parse("ALTER INSTANCE ROTATE INNODB MASTER KEY", dialect)); + assertInstanceOf(UnsupportedStatement.class, parse("ALTER INSTANCE RELOAD SSL", dialect)); + } + + @Test + void otherAlterStatementsAndInstanceNamesKeepTheirReading() throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + assertInstanceOf(Alter.class, parse("ALTER TABLE instance ADD COLUMN c INT", dialect)); + assertInstanceOf(Alter.class, + parse("ALTER TABLE t ENABLE KEYS", dialect)); + assertInstanceOf(Select.class, parse("SELECT instance FROM instance", dialect)); + assertInstanceOf(BackupLockStatement.class, + parse("LOCK INSTANCE FOR BACKUP", dialect)); + } + } + + @Test + void statementsEndAtTheBoundary() throws Exception { + String script = "ALTER INSTANCE RELOAD TLS;\n" + + "ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_admin;\n" + + "ALTER INSTANCE DISABLE INNODB REDO_LOG;\n" + + "SELECT 1;\n" + + "ALTER INSTANCE ROTATE BINLOG MASTER KEY"; + for (Dialect dialect : MYSQL_OR_NONE) { + Statements statements = dialect == null ? CCJSqlParserUtil.parseStatements(script) + : CCJSqlParserUtil.parseStatements(script, p -> p.withDialect(dialect)); + assertEquals(5, statements.size()); + assertEquals(Action.RELOAD_TLS, ((AlterInstance) statements.get(0)).getAction()); + assertEquals("mysql_admin", ((AlterInstance) statements.get(1)).getChannel()); + assertEquals(Action.DISABLE_INNODB_REDO_LOG, + ((AlterInstance) statements.get(2)).getAction()); + assertInstanceOf(Select.class, statements.get(3)); + assertEquals(Action.ROTATE_BINLOG_MASTER_KEY, + ((AlterInstance) statements.get(4)).getAction()); + assertSpans("ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_admin", script, + (ASTNodeAccess) statements.get(1)); + } + assertEquals("ALTER INSTANCE RELOAD KEYRING", + parse("ALTER INSTANCE RELOAD KEYRING;", Dialect.MYSQL).toString()); + } + + @Test + void canBeBuiltAndEdited() { + AlterInstance statement = new AlterInstance(Action.RELOAD_TLS).withChannel("mysql_admin") + .withNoRollbackOnError(true); + assertEquals("ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_admin NO ROLLBACK ON ERROR", + statement.toString()); + assertThrows(IllegalArgumentException.class, + () -> statement.setAction(Action.RELOAD_KEYRING)); + statement.setChannel(null); + assertThrows(IllegalArgumentException.class, + () -> statement.setAction(Action.RELOAD_KEYRING)); + statement.setNoRollbackOnError(false); + assertEquals("ALTER INSTANCE RELOAD KEYRING", + statement.withAction(Action.RELOAD_KEYRING).toString()); + assertThrows(IllegalArgumentException.class, () -> statement.setChannel("mysql_main")); + assertThrows(IllegalArgumentException.class, () -> statement.setNoRollbackOnError(true)); + statement.setChannel(null); + statement.setNoRollbackOnError(false); + assertNull(statement.getChannel()); + assertFalse(statement.isNoRollbackOnError()); + assertThrows(NullPointerException.class, () -> statement.setAction(null)); + assertThrows(NullPointerException.class, () -> new AlterInstance(null)); + assertEquals("ALTER INSTANCE ENABLE INNODB REDO_LOG", + new AlterInstance(Action.ENABLE_INNODB_REDO_LOG).toString()); + } + + @Test + void visitorsReachTheStatement() throws Exception { + AlterInstance statement = + (AlterInstance) parse("ALTER INSTANCE RELOAD TLS", Dialect.MYSQL); + assertNull(statement.accept(new StatementVisitorAdapter(), null)); + + StringBuilder seen = new StringBuilder(); + StatementVisitor visitor = new StatementVisitorAdapter() { + @Override + public String visit(AlterInstance visited, S context) { + seen.append(visited.getAction()).append(context); + return "visited"; + } + }; + assertEquals("visited", statement.accept(visitor, "!")); + visitor.visit(statement); + assertEquals("RELOAD_TLS!RELOAD_TLSnull", seen.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyAccessorsTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyAccessorsTest.java index ddda3cc7eb..45cb380a91 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyAccessorsTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyAccessorsTest.java @@ -9,6 +9,8 @@ */ package net.sf.jsqlparser.statement.alter; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.KeyElement; import static org.junit.jupiter.api.Assertions.*; import java.util.ArrayList; import java.util.List; @@ -46,7 +48,7 @@ void readsCurrentIndexAndAppliesSettersAndFluentAdditions(boolean primary) throw String prefix = "ALTER TABLE t ADD " + (primary ? "PRIMARY KEY" : "UNIQUE"); Alter statement = (Alter) CCJSqlParserUtil.parse(prefix + " (a)"); AlterExpression action = statement.getAlterExpressions().get(0); - Index originalIndex = action.getIndex(); + KeyConstraint originalIndex = (KeyConstraint) action.getConstraint(); originalIndex.setColumnsNames(List.of("b")); List snapshot = columns(action, primary); assertEquals(List.of("b"), snapshot); @@ -61,7 +63,7 @@ void readsCurrentIndexAndAppliesSettersAndFluentAdditions(boolean primary) throw action.addUkColumns("d").addUkColumns(List.of("e")); } assertEquals(List.of("c", "d", "e"), columns(action, primary)); - assertSame(originalIndex, action.getIndex()); + assertSame(originalIndex, action.getConstraint()); assertDeparsed(statement, prefix + " (c, d, e)"); setColumns(action, primary, null); assertTrue(columns(action, primary).isEmpty()); @@ -76,15 +78,15 @@ void replacingWithBareNamesDropsElementOptionsButKeepsIndexMetadata(boolean prim + (primary ? "PRIMARY KEY" : "UNIQUE"); Alter statement = (Alter) CCJSqlParserUtil.parse(prefix + " (a DESC, b) DEFERRABLE"); AlterExpression action = statement.getAlterExpressions().get(0); - Index index = action.getIndex(); - Index.ColumnParams first = index.getColumns().get(0); + KeyConstraint index = (KeyConstraint) action.getConstraint(); + KeyElement first = index.getColumns().get(0); assertEquals("a DESC", first.toString()); setColumns(action, primary, List.of("b", "a")); assertEquals(List.of("b", "a"), columns(action, primary)); assertNull(index.getColumns().get(1).getSortOrder()); assertNull(index.getColumns().get(1).getParams()); assertNotSame(first, index.getColumns().get(1)); - assertSame(index, action.getIndex()); + assertSame(index, action.getConstraint()); assertEquals("key_t", index.getName()); assertDeparsed(statement, prefix + " (b, a) DEFERRABLE"); } @@ -96,13 +98,13 @@ void settingAnUnchangedSnapshotPreservesSqlButRebuildsPlainElements(boolean prim String prefix = "ALTER TABLE t ADD " + (primary ? "PRIMARY KEY" : "UNIQUE"); Alter statement = (Alter) CCJSqlParserUtil.parse(prefix + " (a DESC, b)"); AlterExpression action = statement.getAlterExpressions().get(0); - Index index = action.getIndex(); - Index.ColumnParams expression = new Index.ColumnParams(new Column("a")) + KeyConstraint index = (KeyConstraint) action.getConstraint(); + KeyElement expression = new KeyElement(new Column("a")) .withExpressionParenthesized(false) - .withSortOrder(Index.ColumnParams.SortOrder.DESC); + .withSortOrder(KeyElement.SortOrder.DESC); index.getColumns().set(0, expression); setColumns(action, primary, new ArrayList<>(columns(action, primary))); - Index.ColumnParams replacement = index.getColumns().get(0); + KeyElement replacement = index.getColumns().get(0); assertNotSame(expression, replacement); assertEquals("a DESC", replacement.getColumnName()); assertNull(replacement.getExpression()); @@ -116,13 +118,13 @@ void structuredReorderingRetainsElementIdentityAndOptions(boolean primary) throw String prefix = "ALTER TABLE t ADD " + (primary ? "PRIMARY KEY" : "UNIQUE"); Alter statement = (Alter) CCJSqlParserUtil.parse(prefix + " (a DESC, b)"); AlterExpression action = statement.getAlterExpressions().get(0); - Index index = action.getIndex(); - Index.ColumnParams first = index.getColumns().get(0); - Index.ColumnParams second = index.getColumns().get(1); + KeyConstraint index = (KeyConstraint) action.getConstraint(); + KeyElement first = index.getColumns().get(0); + KeyElement second = index.getColumns().get(1); index.setColumns(List.of(second, first)); assertSame(first, index.getColumns().get(1)); assertSame(second, index.getColumns().get(0)); - assertEquals(Index.ColumnParams.SortOrder.DESC, first.getSortOrder()); + assertEquals(KeyElement.SortOrder.DESC, first.getSortOrder()); assertEquals(List.of("b", "a DESC"), columns(action, primary)); assertDeparsed(statement, prefix + " (b, a DESC)"); } @@ -130,9 +132,9 @@ void structuredReorderingRetainsElementIdentityAndOptions(boolean primary) throw @ParameterizedTest @ValueSource(booleans = {false, true}) void supportsAnIndexWithoutColumnsAndFluentPopulation(boolean primary) { - Index index = new Index().withType(primary ? "PRIMARY KEY" : "UNIQUE"); + KeyConstraint index = new KeyConstraint().withType(primary ? "PRIMARY KEY" : "UNIQUE"); AlterExpression action = new AlterExpression().withOperation(AlterOperation.ADD) - .withIndex(index); + .withConstraint(index); assertTrue(index.getColumnsNames().isEmpty()); assertTrue(columns(action, primary).isEmpty()); index.getColumnsNames().add("detached"); @@ -150,17 +152,20 @@ void supportsAnIndexWithoutColumnsAndFluentPopulation(boolean primary) { } @Test - void retainsLegacyOnlyConstructionAndIgnoresUnrelatedIndexes() { + void legacyConstructionUsesASingleDefinitionAndRejectsUnrelatedIndexes() { AlterExpression action = new AlterExpression().withOperation(AlterOperation.ADD) .withPkColumns(new ArrayList<>(List.of("a"))); action.getPkColumns().add("b"); + assertEquals("ADD PRIMARY KEY (a)", action.toString()); + action.addPkColumns("b"); assertEquals("ADD PRIMARY KEY (a, b)", action.toString()); + assertSame(action.getConstraint(), action.getKeyConstraint()); Index unrelated = new Index().withType("INDEX").withColumnsNames(List.of("other")); action.setIndex(unrelated); - action.setPkColumns(List.of("pk")); - action.setUkColumns(List.of("uk")); - assertEquals(List.of("pk"), action.getPkColumns()); - assertEquals(List.of("uk"), action.getUkColumns()); + assertThrows(IllegalStateException.class, () -> action.setPkColumns(List.of("pk"))); + assertThrows(IllegalStateException.class, () -> action.setUkColumns(List.of("uk"))); + assertNull(action.getPkColumns()); + assertNull(action.getUkColumns()); assertEquals(List.of("other"), unrelated.getColumnsNames()); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyStateTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyStateTest.java new file mode 100644 index 0000000000..176a5569a6 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterKeyStateTest.java @@ -0,0 +1,293 @@ +/*- + * #%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 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.CheckConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.ConstraintUsingIndex; +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.KeyElement; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; +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.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterKeyStateTest { + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void legacyBuildersCreateOneKeyAndExposeOnlySnapshots(boolean primary) throws Exception { + AlterExpression action = new AlterExpression(); + assertNull(action.getKeyConstraint()); + assertNull(action.getPkColumns()); + assertNull(action.getUkColumns()); + setColumns(action, primary, null); + action.setUkName(null); + action.setUkTypeSpecified(false); + assertNull(action.getConstraint()); + + List input = new ArrayList<>(List.of("\"key.name\"")); + setColumns(action, primary, input); + input.add("detached"); + KeyConstraint key = action.getKeyConstraint(); + assertSame(key, action.getConstraint()); + assertEquals(primary ? ConstraintKind.PRIMARY_KEY : ConstraintKind.UNIQUE, key.getKind()); + columns(action, primary).add("also_detached"); + assertEquals(List.of("\"key.name\""), key.getColumnsNames()); + assertNull(action.getOperation()); + action.setOperation(AlterOperation.ADD); + roundTrip(statement(action), Dialect.POSTGRESQL); + setColumns(action, primary, List.of("other")); + assertSame(key, action.getKeyConstraint()); + assertEquals(List.of("other"), key.getColumnsNames()); + roundTrip(statement(action), Dialect.POSTGRESQL); + setColumns(action, primary, null); + assertSame(key, action.getKeyConstraint()); + assertTrue(key.getColumns().isEmpty()); + } + + @Test + void parsedPrimaryKeyPreservesAttributesAndUsesTheSameEditableElements() throws Exception { + Alter statement = parse("ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (id) " + + "INCLUDE (payload) DEFERRABLE", Dialect.POSTGRESQL); + AlterExpression action = first(statement); + KeyConstraint key = action.getKeyConstraint(); + assertEquals(Boolean.TRUE, key.getConstraintAttributes().getDeferrable()); + assertEquals(List.of("payload"), key.getIncludeColumns()); + action.setPkColumns(List.of("\"new.id\"")); + assertEquals(List.of("\"new.id\""), key.getColumnsNames()); + KeyElement replacement = new KeyElement("final_id"); + key.setColumns(List.of(replacement)); + assertSame(replacement, action.getKeyConstraint().getColumns().get(0)); + assertEquals(List.of("final_id"), action.getPkColumns()); + assertEquals("ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (final_id) " + + "INCLUDE (payload) DEFERRABLE", statement.toString()); + roundTrip(statement, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"UNIQUE", "UNIQUE KEY", "UNIQUE INDEX"}) + void uniqueNameAndKeywordAliasesFollowTheStructuredDefinition(String type) throws Exception { + Alter statement = parse("ALTER TABLE t ADD " + type + " uq (id)", Dialect.MYSQL); + AlterExpression action = first(statement); + KeyConstraint key = action.getKeyConstraint(); + assertEquals(type.endsWith("KEY"), action.getUk()); + assertEquals(!"UNIQUE".equals(type), action.isUkTypeSpecified()); + key.setIndexName("typed_name"); + assertEquals("typed_name", action.getUkName()); + action.setUkName("legacy_name"); + assertEquals("legacy_name", key.getIndexName()); + action.setUk(true); + assertTrue(action.getUk()); + assertTrue(action.isUkTypeSpecified()); + assertEquals("ALTER TABLE t ADD UNIQUE KEY legacy_name (id)", statement.toString()); + roundTrip(statement, Dialect.MYSQL); + action.setUk(false); + assertFalse(action.getUk()); + assertEquals("ALTER TABLE t ADD UNIQUE INDEX legacy_name (id)", statement.toString()); + roundTrip(statement, Dialect.MYSQL); + action.setUkTypeSpecified(false); + assertFalse(action.isUkTypeSpecified()); + assertEquals("ALTER TABLE t ADD UNIQUE legacy_name (id)", statement.toString()); + roundTrip(statement, Dialect.MYSQL); + action.setUkTypeSpecified(true); + assertFalse(action.getUk()); + assertTrue(action.isUkTypeSpecified()); + roundTrip(statement, Dialect.MYSQL); + } + + @Test + void genericNamedUniqueKeywordEditsKeepTheLegacyHeaderInSync() throws Exception { + Alter statement = parse("ALTER TABLE t ADD CONSTRAINT UNIQUE KEY uq (id)", null); + AlterExpression action = first(statement); + action.setUk(false); + assertEquals("UNIQUE INDEX", action.getConstraintType()); + assertFalse(action.getUk()); + assertTrue(action.isUkTypeSpecified()); + roundTrip(statement, null); + action.setUkTypeSpecified(false); + assertEquals("UNIQUE", action.getConstraintType()); + assertFalse(action.isUkTypeSpecified()); + roundTrip(statement, null); + } + + @Test + void replacementsAndClearsCannotRestoreOldKeyNamesOrKeywords() { + AlterExpression action = new AlterExpression().withUkName("old_name").withUk(true) + .withUkColumns(List.of("old_column")); + KeyConstraint old = action.getKeyConstraint(); + KeyConstraint replacement = new KeyConstraint().withType("UNIQUE") + .withColumnsNames(List.of("new_column")); + action.setConstraint(replacement); + assertNull(action.getUkName()); + assertFalse(action.getUk()); + assertFalse(action.isUkTypeSpecified()); + assertEquals(List.of("new_column"), action.getUkColumns()); + assertEquals("old_name", old.getIndexName()); + action.setConstraint(null); + assertNull(action.getKeyConstraint()); + assertNull(action.getUkColumns()); + assertNull(action.getUkName()); + action.setUkName("fresh"); + assertNotSame(old, action.getKeyConstraint()); + assertNotSame(replacement, action.getKeyConstraint()); + assertNull(action.getKeyConstraint().getColumns()); + assertFalse(action.isUkTypeSpecified()); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void settersRejectCompetingDefinitionsAndNullClearsLeaveThemIntact(boolean primary) { + List competitors = List.of( + new KeyConstraint().withType(primary ? "UNIQUE" : "PRIMARY KEY"), + new CheckConstraint(), new ForeignKeyConstraint(), new ConstraintUsingIndex()); + for (NamedConstraint competitor : competitors) { + AlterExpression action = new AlterExpression().withConstraint(competitor); + setColumns(action, primary, null); + assertSame(competitor, action.getConstraint()); + assertThrows(IllegalStateException.class, + () -> setColumns(action, primary, List.of("id"))); + assertSame(competitor, action.getConstraint()); + } + AlterExpression action = new AlterExpression(); + Index index = new Index().withType("INDEX").withName("ix"); + action.setIndex(index); + setColumns(action, primary, null); + assertThrows(IllegalStateException.class, + () -> setColumns(action, primary, List.of("id"))); + assertSame(index, action.getIndex()); + assertNull(action.getKeyConstraint()); + action.setIndex(null); + action.setFkColumns(List.of("fk_column")); + assertThrows(IllegalStateException.class, + () -> setColumns(action, primary, List.of("id"))); + assertEquals(List.of("fk_column"), action.getFkColumns()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP (\"a.b\", c) CASCADE CONSTRAINTS", + "DROP UNIQUE (\"a.b\", c)", "DROP FOREIGN KEY (\"a.b\", c)"}) + void parsedDropTargetsAreOwnedAndSeparateFromKeyDefinitions(String body) throws Exception { + Alter statement = parse("ALTER TABLE t " + body, null); + AlterExpression action = first(statement); + assertNull(action.getConstraint()); + assertNull(action.getKeyConstraint()); + assertEquals(List.of("\"a.b\"", "c"), action.getDropColumns()); + List snapshot = action.getPkColumns(); + snapshot.set(0, "detached"); + assertEquals("\"a.b\"", action.getDropColumns().get(0)); + action.getDropColumns().set(0, "\"new.name\""); + assertEquals(List.of("\"new.name\"", "c"), action.getPkColumns()); + roundTrip(statement, null); + List replacement = new ArrayList<>(List.of("other")); + action.setPkColumns(replacement); + replacement.add("detached"); + assertEquals(List.of("other"), action.getDropColumns()); + action.addDropColumns("next").addDropColumns(List.of("last")); + assertEquals(List.of("other", "next", "last"), action.getDropColumns()); + roundTrip(statement, null); + action.setPkColumns(null); + assertNull(action.getDropColumns()); + assertNull(action.getConstraint()); + } + + @ParameterizedTest + @EnumSource(value = AlterOperation.class, names = {"DROP", "DROP_UNIQUE", "DROP_FOREIGN_KEY"}) + void newDropBuilderDoesNotDependOnSetterOrder(AlterOperation operation) throws Exception { + AlterExpression action = new AlterExpression().withDropColumns(List.of("\"a.b\"")); + assertNull(action.getConstraint()); + assertNull(action.getPkColumns()); + action.setOperation(operation); + assertEquals(List.of("\"a.b\""), action.getPkColumns()); + roundTrip(statement(action), null); + } + + @Test + void changingOperationDoesNotConvertDefinitionsIntoDropTargets() throws Exception { + AlterExpression action = new AlterExpression().withPkColumns(List.of("id")) + .withDropColumns(List.of("old_id")).withOperation(AlterOperation.ADD); + KeyConstraint key = action.getKeyConstraint(); + assertEquals("ADD PRIMARY KEY (id)", action.toString()); + action.setOperation(AlterOperation.DROP); + assertEquals("DROP (old_id)", action.toString()); + assertEquals(List.of("old_id"), action.getPkColumns()); + action.setPkColumns(List.of("replacement")); + assertEquals(List.of("id"), key.getColumnsNames()); + assertEquals("DROP (replacement)", action.toString()); + action.setOperation(AlterOperation.ADD); + assertEquals("ADD PRIMARY KEY (id)", action.toString()); + assertEquals(List.of("replacement"), action.getDropColumns()); + roundTrip(statement(action), Dialect.POSTGRESQL); + action.setDropColumns(null); + assertSame(key, action.getKeyConstraint()); + assertNull(action.getDropColumns()); + } + + @Test + void namedAndPrimaryKeyDropsDoNotInventColumnTargets() throws Exception { + Alter statement = + parse("ALTER TABLE t DROP FOREIGN KEY fk, DROP PRIMARY KEY", Dialect.MYSQL); + for (AlterExpression action : statement.getAlterExpressions()) { + assertNull(action.getDropColumns()); + assertNull(action.getPkColumns()); + assertNull(action.getKeyConstraint()); + } + roundTrip(statement, Dialect.MYSQL); + } + + private static List columns(AlterExpression action, boolean primary) { + return primary ? action.getPkColumns() : action.getUkColumns(); + } + + private static void setColumns(AlterExpression action, boolean primary, List columns) { + if (primary) { + action.setPkColumns(columns); + } else { + action.setUkColumns(columns); + } + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + + private static AlterExpression first(Alter statement) { + return statement.getAlterExpressions().get(0); + } + + private static Alter statement(AlterExpression action) { + Alter statement = new Alter(); + statement.setTable(new Table("t")); + statement.addAlterExpression(action); + return statement; + } + + private static void roundTrip(Alter statement, Dialect dialect) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql)); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterPartitionMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterPartitionMutationTest.java new file mode 100644 index 0000000000..37319554d4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterPartitionMutationTest.java @@ -0,0 +1,238 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +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.Expression; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.create.table.PartitionDefinition; +import net.sf.jsqlparser.statement.create.table.TablePartitioning; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.api.Test; + +class AlterPartitionMutationTest { + + @Test + void legacyExpressionSetterChangesParsedPartitioning() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY HASH (id) PARTITIONS 8"); + AlterExpression legacy = action(alter); + Column replacement = new Column("other"); + legacy.setPartitionExpression(replacement); + + assertSame(replacement, action(alter).getPartitioning().getExpression()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY HASH (other) PARTITIONS 8"); + } + + @Test + void legacyColumnsReplaceExpressionsWithAppropriateSyntax() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY LINEAR HASH (id) PARTITIONS 8"); + AlterExpression legacy = action(alter); + legacy.setPartitionType("key"); + legacy.setPartitionColumns(List.of("other")); + + assertNull(legacy.getPartitionExpression()); + assertFalse(action(alter).getPartitioning().isColumnsSyntax()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY LINEAR KEY (other) PARTITIONS 8"); + } + + @Test + void legacyRangeColumnsAndExpressionSettersReplaceOneAnother() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION p0 VALUES LESS THAN (100), PARTITION pmax VALUES LESS THAN MAXVALUE)"); + AlterExpression legacy = action(alter); + legacy.setPartitionColumns(List.of("other")); + + assertNull(legacy.getPartitionExpression()); + assertTrue(action(alter).getPartitioning().isColumnsSyntax()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY RANGE COLUMNS (other) " + + "(PARTITION p0 VALUES LESS THAN (100), PARTITION pmax VALUES LESS THAN MAXVALUE)"); + + legacy.setPartitionExpression(new Column("id")); + assertNull(legacy.getPartitionColumns()); + assertFalse(action(alter).getPartitioning().isColumnsSyntax()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION p0 VALUES LESS THAN (100), PARTITION pmax VALUES LESS THAN MAXVALUE)"); + } + + @Test + void legacyColumnNamesAreAMutableViewOfStructuredColumns() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY KEY (`id`, other) PARTITIONS 8"); + AlterExpressionPartition action = action(alter); + List names = action.getPartitionColumns(); + assertEquals("`id`", names.set(0, "`new_id`")); + names.add("extra"); + assertEquals("other", names.remove(1)); + action.getPartitioning().getColumns().get(1).setColumnName("last_id"); + + assertEquals(List.of("`new_id`", "last_id"), names); + assertRoundTrip(alter, + "ALTER TABLE sales PARTITION BY KEY (`new_id`, last_id) PARTITIONS 8"); + names.clear(); + assertTrue(action.getPartitioning().getColumns().isEmpty()); + names.add("id"); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY KEY (id) PARTITIONS 8"); + } + + @Test + void structuredMutationsAreVisibleThroughLegacyAccessors() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY HASH (id) PARTITIONS 8"); + AlterExpressionPartition action = action(alter); + TablePartitioning partitioning = action.getPartitioning(); + partitioning.setType(TablePartitioning.Type.KEY); + partitioning.setColumns(new ExpressionList<>(new Column("other"))); + + assertEquals("KEY", action.getPartitionType()); + assertEquals(List.of("other"), action.getPartitionColumns()); + assertNull(action.getPartitionExpression()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY KEY (other) PARTITIONS 8"); + + partitioning.setType(TablePartitioning.Type.HASH); + Column id = new Column("id"); + partitioning.setExpression(id); + assertSame(id, action.getPartitionExpression()); + assertNull(action.getPartitionColumns()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY HASH (id) PARTITIONS 8"); + } + + @Test + void partitionDefinitionsShareTheStructuredList() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION p0 VALUES LESS THAN (100))"); + AlterExpressionPartition action = action(alter); + List replacements = new ArrayList<>(action(parse( + "ALTER TABLE sales ADD PARTITION (PARTITION p1 VALUES LESS THAN (200))")) + .getPartitionDefinitions()); + action.setPartitionDefinitions(replacements); + assertSame(replacements, action.getPartitioning().getPartitionDefinitions()); + action.addPartitionDefinitions(action(parse("ALTER TABLE sales ADD PARTITION " + + "(PARTITION pmax VALUES LESS THAN MAXVALUE)")).getPartitionDefinitions()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION p1 VALUES LESS THAN (200), PARTITION pmax VALUES LESS THAN MAXVALUE)"); + + action.getPartitioning().setPartitionDefinitions(null); + assertNull(action.getPartitionDefinitions()); + action.setPartitionDefinitions(replacements); + action.getPartitionDefinitions().remove(0); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION pmax VALUES LESS THAN MAXVALUE)"); + } + + @Test + void reorganizeUsesTheSameDefinitionsAsTheStructuredClause() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION p0 VALUES LESS THAN (100))"); + AlterExpressionPartition action = action(alter); + action.setOperation(AlterOperation.REORGANIZE_PARTITION); + action.setPartitionNames(List.of("p_old")); + action.getPartitioning().setPartitionDefinitions(action(parse( + "ALTER TABLE sales ADD PARTITION (PARTITION p1 VALUES LESS THAN (200))")) + .getPartitionDefinitions()); + assertRoundTrip(alter, "ALTER TABLE sales REORGANIZE PARTITION p_old INTO " + + "(PARTITION p1 VALUES LESS THAN (200))"); + } + + @Test + void clearingLegacyExpressionAlsoClearsAKeyListWithoutResurrectingOldKeys() { + AlterExpressionPartition action = new AlterExpressionPartition() + .withPartitioning(new TablePartitioning(TablePartitioning.Type.RANGE)); + ExpressionList keys = + new ExpressionList<>(new Column("id"), new Column("other")); + action.setPartitionExpression(keys); + assertSame(keys, action.getPartitioning().getExpressionList()); + assertSame(keys, action.getPartitionExpression()); + action.setPartitionColumns(null); + assertSame(keys, action.getPartitionExpression()); + action.setPartitionExpression(null); + assertNull(action.getPartitioning().getExpressionList()); + assertNull(action.getPartitionExpression()); + + action.setPartitionColumns(List.of("id")); + action.setPartitionExpression(null); + assertEquals(List.of("id"), action.getPartitionColumns()); + action.setPartitionColumns(null); + assertNull(action.getPartitionColumns()); + } + + @Test + void replacingAndClearingPartitioningDoesNotLeaveLegacySnapshots() throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY RANGE COLUMNS (id) " + + "(PARTITION p0 VALUES LESS THAN (100))"); + AlterExpressionPartition action = action(alter); + TablePartitioning replacement = new TablePartitioning(TablePartitioning.Type.HASH) + .withExpression(new Column("other")).withPartitions(4L); + action.setPartitioning(replacement); + assertNull(action.getPartitionColumns()); + assertNull(action.getPartitionDefinitions()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY HASH (other) PARTITIONS 4"); + + action.setPartitioning(null); + assertNull(action.getPartitionType()); + assertNull(action.getPartitionExpression()); + assertNull(action.getPartitionColumns()); + assertNull(action.getPartitionDefinitions()); + action.setPartitionType("RANGE"); + action.setPartitionExpression(new Column("id")); + action.setPartitionDefinitions(action(parse("ALTER TABLE sales ADD PARTITION " + + "(PARTITION pmax VALUES LESS THAN MAXVALUE)")).getPartitionDefinitions()); + assertRoundTrip(alter, "ALTER TABLE sales PARTITION BY RANGE (id) " + + "(PARTITION pmax VALUES LESS THAN MAXVALUE)"); + } + + @Test + void quotedDotsRemainPartOfTheColumnNameInLegacySettersAndListEdits() + throws JSQLParserException { + Alter alter = parse("ALTER TABLE sales PARTITION BY KEY (id) PARTITIONS 8"); + AlterExpressionPartition action = action(alter); + action.setPartitionColumns(List.of("`event.date`")); + Column column = action.getPartitioning().getColumns().get(0); + assertNull(column.getTable()); + assertEquals("`event.date`", column.getColumnName()); + assertRendering(alter, "ALTER TABLE sales PARTITION BY KEY (`event.date`) PARTITIONS 8"); + + List names = action.getPartitionColumns(); + assertEquals("`event.date`", names.set(0, "`renamed.value`")); + names.add("`other.column`"); + assertEquals(List.of("`renamed.value`", "`other.column`"), names); + action.getPartitioning().getColumns().forEach(item -> assertNull(item.getTable())); + assertRendering(alter, "ALTER TABLE sales PARTITION BY KEY " + + "(`renamed.value`, `other.column`) PARTITIONS 8"); + } + + private static Alter parse(String sql) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)); + } + + private static AlterExpressionPartition action(Alter alter) { + return (AlterExpressionPartition) alter.getAlterExpressions().get(0); + } + + private static void assertRoundTrip(Alter alter, String expected) throws JSQLParserException { + assertRendering(alter, expected); + assertEquals(expected, parse(alter.toString()).toString()); + } + + private static void assertRendering(Alter alter, String expected) { + assertEquals(expected, alter.toString()); + StringBuilder output = new StringBuilder(); + alter.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterRendererDispatchTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterRendererDispatchTest.java new file mode 100644 index 0000000000..26fb12c3c2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterRendererDispatchTest.java @@ -0,0 +1,258 @@ +/*- + * #%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.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.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDataType; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnSetDefault; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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.Arguments; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; + +class AlterRendererDispatchTest { + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "POSTGRESQL"}) + void parsedDefaultsRemainEditableAndUseTheExpressionVisitor(Dialect dialect) + throws JSQLParserException { + Alter statement = parse("ALTER TABLE t ALTER COLUMN amount SET DEFAULT (1 + 2)", dialect); + AlterExpression action = statement.getAlterExpressions().get(0); + addInactiveColumn(action); + ColumnDefaultAction defaultAction = action.getColumnDefaults().get(0); + assertSame(action.getColumnSetDefaultList().get(0), defaultAction); + defaultAction.setColumnName("renamed"); + defaultAction.setDefaultExpression(CCJSqlParserUtil.parseExpression("(3 + 4)")); + assertFalse(action.hasActiveColumnDefinitions()); + String expected = "ALTER TABLE t ALTER COLUMN renamed SET DEFAULT (3 + 4)"; + assertEquals(expected, statement.toString()); + assertRenderersAgree(statement); + assertEquals(expected, parse(expected, dialect).toString()); + + List visited = new ArrayList<>(); + assertEquals("ALTER TABLE t ALTER COLUMN renamed SET DEFAULT (103 + 104)", + deparse(statement, visited)); + assertEquals(List.of(3L, 4L), visited); + } + + @Test + void dropFallbackKeepsIdentityBodyInsteadOfInactiveDefaultMetadata() { + AlterExpressionDrop action = new AlterExpressionDrop(); + action.setOperation(AlterOperation.ALTER); + action.hasColumn(true); + ColumnDataType column = new ColumnDataType(false).withColumnName("id"); + column.setIdentityAlterations( + List.of(new IdentityAlteration(IdentityAlteration.Kind.RESTART))); + action.addColDataType(column); + action.addColSetDefault(ColumnSetDefault.fromExpression("other", new LongValue(1))); + Alter statement = statement(action); + assertTrue(action.hasActiveColumnDefinitions()); + assertTrue(action.getColumnDefaults().isEmpty()); + assertEquals("ALTER TABLE t ALTER COLUMN id RESTART", statement.toString()); + assertRenderersAgree(statement); + List visited = new ArrayList<>(); + assertEquals(statement.toString(), deparse(statement, visited)); + assertTrue(visited.isEmpty()); + } + + @Test + void dropFallbackStillRewritesItsActiveColumnExpressionAndAppendsTailOnce() + throws JSQLParserException { + AlterExpressionDrop action = new AlterExpressionDrop(); + action.setOperation(AlterOperation.ALTER); + action.hasColumn(true); + ColumnDataType column = new ColumnDataType(true).withColumnName("id") + .withColDataType(new ColDataType("INT")); + column.setUsingExpression(CCJSqlParserUtil.parseExpression("id + 2")); + action.addColDataType(column); + action.addColSetDefault(ColumnSetDefault.fromExpression("other", new LongValue(1))); + action.addParameters("CASCADE"); + Alter statement = statement(action); + assertRenderersAgree(statement); + List visited = new ArrayList<>(); + assertEquals("ALTER TABLE t ALTER COLUMN id TYPE INT USING id + 102 CASCADE", + deparse(statement, visited)); + assertEquals(List.of(2L), visited); + } + + static Stream fixedBodies() { + return Stream.of( + Arguments.of("ALTER TABLE t RENAME TO renamed", Dialect.MYSQL, + AlterExpressionRename.class), + Arguments.of("ALTER TABLE t CONVERT TO CHARACTER SET utf8mb4", Dialect.MYSQL, + AlterExpressionCharset.class), + Arguments.of("ALTER TABLE t ENGINE = InnoDB", Dialect.MYSQL, + AlterExpressionTableOption.class), + Arguments.of("ALTER TABLE t ALTER CONSTRAINT ck DEFERRABLE", Dialect.POSTGRESQL, + AlterConstraintAttributes.class), + Arguments.of("ALTER TABLE t ALTER PRIMARY KEY USING COLUMNS (id)", + Dialect.COCKROACHDB, AlterExpressionPrimaryKey.class), + Arguments.of("ALTER TABLE t DETACH PARTITION p", Dialect.POSTGRESQL, + AlterExpressionPartition.class), + Arguments.of("ALTER TABLE t ORDER BY id", Dialect.MYSQL, + AlterExpressionOrderBy.class), + Arguments.of("ALTER TABLE t OWNER TO alice", Dialect.POSTGRESQL, + RelationAlterAction.class), + Arguments.of("ALTER FOREIGN TABLE t OPTIONS (ADD filename 'file')", + Dialect.POSTGRESQL, AlterForeignDataOptions.class)); + } + + @ParameterizedTest + @MethodSource("fixedBodies") + void specializedBodiesIgnoreUnrelatedDefaultAndColumnMetadata(String sql, Dialect dialect, + Class type) throws JSQLParserException { + Alter statement = parse(sql, dialect); + AlterExpression action = assertInstanceOf(type, statement.getAlterExpressions().get(0)); + String expected = statement.toString(); + action.addColSetDefault(ColumnSetDefault.fromExpression("inactive", new LongValue(99))); + addInactiveColumn(action); + assertTrue(action.getColumnDefaults().isEmpty()); + assertFalse(action.hasActiveColumnDefinitions()); + assertEquals(expected, statement.toString()); + assertRenderersAgree(statement); + List visited = new ArrayList<>(); + assertEquals(expected, deparse(statement, visited)); + assertTrue(visited.isEmpty()); + + // A changed operation does not replace a subclass's own body dispatch. + action.setOperation(AlterOperation.ALTER); + assertTrue(action.getColumnDefaults().isEmpty()); + assertFalse(action.hasActiveColumnDefinitions()); + assertRenderersAgree(statement); + assertEquals(statement.toString(), deparse(statement, visited)); + assertTrue(visited.isEmpty()); + } + + static Stream prioritizedBodies() { + return Stream.of( + body(action -> action + .addColDropDefault(new AlterExpression.ColumnDropDefault("id"))), + body(action -> action.addColSetVisibility( + new AlterExpression.ColumnSetVisibility("id", true))), + body(action -> { + action.setConstraintType("CHECK"); + action.setConstraintSymbol("ck"); + action.setEnforced(true); + }), + body(action -> { + action.setOperation(AlterOperation.RENAME_TABLE); + action.setNewTableName("renamed"); + }), + body(action -> action.setOperation(AlterOperation.DROP_PRIMARY_KEY)), + body(action -> { + action.setOperation(AlterOperation.UNSPECIFIC); + action.setOptionalSpecifier("vendor_action"); + }), + body(action -> { + action.setOperation(AlterOperation.COMMENT); + action.setCommentText("'description'"); + })); + } + + private static Arguments body(Consumer configure) { + return Arguments.of(configure); + } + + @ParameterizedTest + @MethodSource("prioritizedBodies") + void baseBodyPrecedencePreventsInactiveColumnExpressionsFromBeingRendered( + Consumer configure) { + AlterExpression action = new AlterExpression(); + action.setOperation(AlterOperation.ALTER); + configure.accept(action); + Alter statement = statement(action); + String expected = statement.toString(); + addInactiveColumn(action); + assertFalse(action.hasActiveColumnDefinitions()); + assertTrue(action.getColumnDefaults().isEmpty()); + assertEquals(expected, statement.toString()); + assertRenderersAgree(statement); + List visited = new ArrayList<>(); + assertEquals(expected, deparse(statement, visited)); + assertTrue(visited.isEmpty()); + } + + @Test + void activeDefaultKeepsPriorityOverStaleRenameMetadata() { + AlterExpression action = new AlterExpression(); + action.setOperation(AlterOperation.ALTER); + action.hasColumn(true); + action.addColSetDefault(ColumnSetDefault.fromExpression("id", new LongValue(1))); + action.setOldIndex(new Index().withName("old_index")); + action.setIndex(new Index().withName("new_index")); + addInactiveColumn(action); + assertEquals(1, action.getColumnDefaults().size()); + assertFalse(action.hasActiveColumnDefinitions()); + Alter statement = statement(action); + assertEquals("ALTER TABLE t ALTER COLUMN id SET DEFAULT 1", statement.toString()); + assertRenderersAgree(statement); + List visited = new ArrayList<>(); + assertEquals("ALTER TABLE t ALTER COLUMN id SET DEFAULT 101", deparse(statement, visited)); + assertEquals(List.of(1L), visited); + } + + private static void addInactiveColumn(AlterExpression action) { + ColumnDataType column = new ColumnDataType(true).withColumnName("inactive") + .withColDataType(new ColDataType("INT")); + column.setUsingExpression(new LongValue(999)); + action.addColDataType(column); + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static Alter statement(AlterExpression action) { + Alter statement = new Alter(); + statement.setTable(new Table("t")); + statement.addAlterExpression(action); + return statement; + } + + private static void assertRenderersAgree(Alter statement) { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + } + + private static String deparse(Alter statement, List visited) { + StringBuilder sql = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + assertNull(context); + visited.add(value.getValue()); + return getBuilder().append(value.getValue() + 100); + } + }; + statement.accept(new StatementDeParser(expressions, new SelectDeParser(), sql), null); + return sql.toString(); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterRoutineTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterRoutineTest.java new file mode 100644 index 0000000000..e0992bae18 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterRoutineTest.java @@ -0,0 +1,334 @@ +/*- + * #%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 net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.ConfigurationParameterChange; +import net.sf.jsqlparser.statement.RoutineCharacteristic; +import net.sf.jsqlparser.statement.RoutineCharacteristic.Kind; +import net.sf.jsqlparser.statement.RoutineCharacteristic.SecurityClause; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.function.CreateFunction; +import net.sf.jsqlparser.statement.create.procedure.CreateProcedure; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterRoutineTest { + + @ParameterizedTest + @ValueSource(strings = {"ALTER FUNCTION f2(int) OWNER TO u1", + "ALTER FUNCTION public.f2(integer, text) OWNER TO CURRENT_ROLE", + "ALTER FUNCTION f2 OWNER TO SESSION_USER", "ALTER FUNCTION f2(int) RENAME TO g2", + "ALTER PROCEDURE p1() SET SCHEMA archive", + "ALTER ROUTINE \"My Func\"(IN a int, VARIADIC b text[]) RENAME TO \"Other\"", + "ALTER FUNCTION f2(int) DEPENDS ON EXTENSION ext", + "ALTER ROUTINE f2(int) NO DEPENDS ON EXTENSION ext", + "ALTER FUNCTION f2(int) SET search_path = public", + "ALTER FUNCTION f2(int) SET search_path TO app, public SET work_mem = '64MB'", + "ALTER FUNCTION f2(int) SET work_mem TO DEFAULT RESET search_path RESET ALL", + "ALTER PROCEDURE p1(int) SET search_path FROM CURRENT", + "ALTER PROCEDURE p1(int) SECURITY DEFINER", + "ALTER PROCEDURE p1 EXTERNAL SECURITY INVOKER", + "ALTER ROUTINE f2(int) IMMUTABLE", "ALTER FUNCTION f2(int) STABLE NOT LEAKPROOF", + "ALTER FUNCTION f2(int) VOLATILE LEAKPROOF STRICT RESTRICT", + "ALTER FUNCTION f2(int) CALLED ON NULL INPUT", + "ALTER FUNCTION f2(int) RETURNS NULL ON NULL INPUT", + "ALTER FUNCTION f2(int) PARALLEL SAFE PARALLEL RESTRICTED PARALLEL UNSAFE", + "ALTER FUNCTION f2(int) COST 100 ROWS 2.5 SUPPORT pg_catalog.my_support", + "ALTER FUNCTION f2(int) COST -1 ROWS +10"}) + void testPostgreSqlForms(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.POSTGRESQL); + assertRoundTrip(sql, null); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER PROCEDURE p1 COMMENT 'x' SQL SECURITY INVOKER", + "ALTER FUNCTION f1 READS SQL DATA", "ALTER FUNCTION db1.f1 LANGUAGE SQL CONTAINS SQL", + "ALTER PROCEDURE `p 1` NO SQL MODIFIES SQL DATA SQL SECURITY DEFINER", + "ALTER FUNCTION f1 COMMENT 'it''s'"}) + void testMySqlForms(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.MYSQL); + assertRoundTrip(sql, Dialect.MARIADB); + assertRoundTrip(sql, null); + } + + @Test + void testPostgreSqlActions() throws JSQLParserException { + AlterRoutine owner = parsePostgreSql("ALTER FUNCTION s.f2(IN a int, text) OWNER TO u1"); + assertEquals(AlterRoutine.RoutineType.FUNCTION, owner.getRoutineType()); + assertEquals(AlterRoutine.Action.OWNER, owner.getAction()); + assertEquals("u1", owner.getOwner()); + RoutineReference routine = owner.getRoutine(); + assertEquals("s.f2", routine.getName()); + assertEquals(2, routine.getArguments().size()); + assertEquals(RoutineReference.Argument.Mode.IN, routine.getArguments().get(0).getMode()); + assertEquals("a", routine.getArguments().get(0).getName()); + assertEquals("text", routine.getArguments().get(1).getDataType().toString()); + assertTrue(owner.getCharacteristics().isEmpty()); + + AlterRoutine rename = parsePostgreSql("ALTER ROUTINE f2 RENAME TO g2"); + assertEquals(AlterRoutine.RoutineType.ROUTINE, rename.getRoutineType()); + assertEquals(AlterRoutine.Action.RENAME, rename.getAction()); + assertEquals("g2", rename.getNewName()); + assertNull(rename.getRoutine().getArguments()); + + AlterRoutine schema = parsePostgreSql("ALTER PROCEDURE p1() SET SCHEMA archive"); + assertEquals(AlterRoutine.RoutineType.PROCEDURE, schema.getRoutineType()); + assertEquals(AlterRoutine.Action.SET_SCHEMA, schema.getAction()); + assertEquals("archive", schema.getSchemaName()); + assertTrue(schema.getRoutine().getArguments().isEmpty()); + + AlterRoutine dependency = + parsePostgreSql("ALTER FUNCTION f2(int) NO DEPENDS ON EXTENSION ext"); + assertEquals(AlterRoutine.Action.DEPENDS_ON_EXTENSION, dependency.getAction()); + assertEquals("ext", dependency.getExtensionName()); + assertTrue(dependency.isNoDependency()); + + // A configuration parameter named "schema" is a SET, not SET SCHEMA. + AlterRoutine parameter = parsePostgreSql("ALTER FUNCTION f2(int) SET schema = 'x'"); + assertEquals(AlterRoutine.Action.CHARACTERISTICS, parameter.getAction()); + assertEquals("schema", parameter.getCharacteristics().get(0).getParameterChange() + .getParameter()); + } + + @Test + void testPostgreSqlCharacteristics() throws JSQLParserException { + AlterRoutine statement = parsePostgreSql("ALTER FUNCTION f2(int) IMMUTABLE STRICT " + + "EXTERNAL SECURITY DEFINER PARALLEL SAFE COST 10 ROWS 5 SUPPORT s.sup " + + "SET search_path TO app, public RESET ALL RESTRICT"); + assertEquals(AlterRoutine.Action.CHARACTERISTICS, statement.getAction()); + assertTrue(statement.isRestrict()); + List characteristics = statement.getCharacteristics(); + assertEquals(List.of(Kind.IMMUTABLE, Kind.STRICT, Kind.SECURITY_DEFINER, + Kind.PARALLEL_SAFE, Kind.COST, Kind.ROWS, Kind.SUPPORT, + Kind.CONFIGURATION_PARAMETER, Kind.CONFIGURATION_PARAMETER), + characteristics.stream().map(RoutineCharacteristic::getKind) + .collect(java.util.stream.Collectors.toList())); + assertNull(characteristics.get(0).getSecurityClause()); + assertEquals(SecurityClause.EXTERNAL_SECURITY, + characteristics.get(2).getSecurityClause()); + assertEquals("10", statement.getCharacteristic(Kind.COST).orElseThrow().getValue()); + assertEquals("5", statement.getCharacteristic(Kind.ROWS).orElseThrow().getValue()); + assertEquals("s.sup", statement.getCharacteristic(Kind.SUPPORT).orElseThrow().getValue()); + + ConfigurationParameterChange set = characteristics.get(7).getParameterChange(); + assertEquals(ConfigurationParameterChange.Action.SET, set.getAction()); + assertEquals("search_path", set.getParameter()); + assertEquals(2, set.getValues().size()); + ConfigurationParameterChange reset = characteristics.get(8).getParameterChange(); + assertEquals(ConfigurationParameterChange.Action.RESET, reset.getAction()); + assertEquals("ALL", reset.getParameter()); + + AlterRoutine plainSecurity = parsePostgreSql("ALTER PROCEDURE p1(int) SECURITY INVOKER"); + RoutineCharacteristic security = plainSecurity.getCharacteristics().get(0); + assertEquals(Kind.SECURITY_INVOKER, security.getKind()); + assertEquals(SecurityClause.SECURITY, security.getSecurityClause()); + assertFalse(plainSecurity.isRestrict()); + } + + @Test + void testMySqlCharacteristics() throws JSQLParserException { + AlterRoutine statement = (AlterRoutine) CCJSqlParserUtil.parse( + "ALTER PROCEDURE db1.p1 COMMENT 'x' LANGUAGE SQL READS SQL DATA SQL SECURITY INVOKER", + parser -> parser.withDialect(Dialect.MYSQL)); + assertEquals(AlterRoutine.RoutineType.PROCEDURE, statement.getRoutineType()); + assertEquals("db1.p1", statement.getRoutine().getName()); + assertNull(statement.getRoutine().getArguments()); + List characteristics = statement.getCharacteristics(); + assertEquals(4, characteristics.size()); + assertEquals(Kind.COMMENT, characteristics.get(0).getKind()); + assertEquals("'x'", characteristics.get(0).getValue()); + assertEquals(Kind.LANGUAGE_SQL, characteristics.get(1).getKind()); + assertEquals(Kind.READS_SQL_DATA, characteristics.get(2).getKind()); + assertEquals(Kind.SECURITY_INVOKER, characteristics.get(3).getKind()); + assertEquals(SecurityClause.SQL_SECURITY, characteristics.get(3).getSecurityClause()); + assertFalse(statement.isRestrict()); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', quoteCharacter = '`', value = { + "'it\\'s'|it's", "'it''s'|it's", "\"dq\"|dq", "'a\\\\b'|a\\b", + "'line1\\nline2'|`line1\nline2`", "'tab\\there'|`tab\there`", + "'percent\\% underscore\\_'|percent\\% underscore\\_", + "'한글 설명 😀'|한글 설명 😀"}) + void testMySqlCommentKeepsLiteralAndStoredText(String literal, String stored) + throws JSQLParserException { + String sql = "ALTER PROCEDURE p1 COMMENT " + literal + " SQL SECURITY INVOKER"; + AlterRoutine statement = (AlterRoutine) assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(Dialect.MYSQL)); + RoutineCharacteristic comment = statement.getCharacteristic(Kind.COMMENT).orElseThrow(); + assertEquals(literal, comment.getValue()); + assertEquals(literal, comment.getComment().toString()); + assertEquals(stored, comment.getComment().getNotExcapedValue()); + } + + @Test + void testCommentMutation() throws JSQLParserException { + AlterRoutine statement = (AlterRoutine) CCJSqlParserUtil.parse( + "ALTER FUNCTION f1 COMMENT 'it\\'s' NO SQL", + parser -> parser.withDialect(Dialect.MYSQL)); + RoutineCharacteristic comment = statement.getCharacteristics().get(0); + assertEquals(StringValue.Escaping.MYSQL_BACKSLASH, comment.getComment().getEscaping()); + + comment.getComment().setValue("changed"); + assertEquals("ALTER FUNCTION f1 COMMENT 'changed' NO SQL", statement.toString()); + comment.setValue("'x''y'"); + assertEquals("x'y", comment.getComment().getNotExcapedValue()); + comment.setComment(new StringValue("plain")); + assertEquals("'plain'", comment.getValue()); + + RoutineCharacteristic created = RoutineCharacteristic.comment(new StringValue("note")); + assertEquals(Kind.COMMENT, created.getKind()); + assertEquals("COMMENT 'note'", created.toString()); + assertEquals("COMMENT 'v'", new RoutineCharacteristic(Kind.COMMENT, "'v'").toString()); + assertNull(new RoutineCharacteristic(Kind.COST, "5").getComment()); + } + + @Test + void testMutationAndActionSwitch() throws JSQLParserException { + AlterRoutine statement = parsePostgreSql("ALTER FUNCTION f2(int) RENAME TO g2"); + statement.setAction(AlterRoutine.Action.OWNER); + statement.setOwner("CURRENT_USER"); + assertEquals("ALTER FUNCTION f2(int) OWNER TO CURRENT_USER", statement.toString()); + statement.setAction(AlterRoutine.Action.RENAME); + assertEquals("ALTER FUNCTION f2(int) RENAME TO g2", statement.toString()); + + statement.setAction(AlterRoutine.Action.CHARACTERISTICS); + statement.setRoutineType(AlterRoutine.RoutineType.ROUTINE); + statement.getCharacteristics().add(new RoutineCharacteristic(Kind.SECURITY_DEFINER)); + statement.getCharacteristics().add(new RoutineCharacteristic(Kind.COST, "5")); + statement.getCharacteristics().add(new RoutineCharacteristic( + new ConfigurationParameterChange(ConfigurationParameterChange.Action.SET, "a") + .withValues(new ExpressionList<>(new StringValue("b"))))); + statement.setRestrict(true); + assertEquals("ALTER ROUTINE f2(int) SECURITY DEFINER COST 5 SET a TO 'b' RESTRICT", + statement.toString()); + + RoutineCharacteristic security = statement.getCharacteristics().get(0); + security.setSecurityClause(SecurityClause.SQL_SECURITY); + security.setKind(Kind.SECURITY_INVOKER); + assertEquals("SQL SECURITY INVOKER", security.toString()); + + RoutineCharacteristic missing = new RoutineCharacteristic(Kind.CONFIGURATION_PARAMETER); + assertThrows(IllegalStateException.class, missing::toString); + } + + @Test + void testVisitorsAndDeparserUseExpressions() throws JSQLParserException { + AlterRoutine statement = + parsePostgreSql("ALTER FUNCTION f2(int) SET search_path TO app, public"); + assertEquals("context:f2", statement.accept(new StatementVisitorAdapter() { + @Override + public String visit(AlterRoutine routine, S context) { + return context + ":" + routine.getRoutine().getName(); + } + }, "context")); + assertTrue(new TablesNamesFinder().getTables((Statement) statement).isEmpty()); + + StringBuilder deparsed = new StringBuilder(); + new StatementDeParser(deparsed).visit(statement, null); + assertEquals("ALTER FUNCTION f2(int) SET search_path TO app, public", + deparsed.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER FUNCTION f", "ALTER PROCEDURE p1", + "ALTER FUNCTION f COMPILE", "ALTER FUNCTION f(int) NOT FENCED", + "ALTER FUNCTION f(int) EXTERNAL NAME 'lib'", "ALTER FUNCTION f(int) SET SECURE", + "ALTER FUNCTION IF EXISTS f(int) RENAME TO g", "ALTER PROCEDURE dbo.p AS SELECT 1", + "ALTER FUNCTION dbo.f(@a int) RETURNS int AS BEGIN RETURN 1 END", + "ALTER FUNCTION f(int) PARALLEL FAST", "ALTER FUNCTION f(int) SECURITY OWNER"}) + void testOtherFormsRemainUnsupported(String sql) throws JSQLParserException { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql)); + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER FUNCTION f(int) IMMUTABLE, STRICT", + "ALTER FUNCTION f(int) RENAME TO g RESTRICT", + "ALTER FUNCTION f(int) OWNER TO u IMMUTABLE", + "ALTER FUNCTION f COMMENT 'x' IMMUTABLE", "ALTER FUNCTION f IMMUTABLE COMMENT 'x'", + "ALTER FUNCTION f(int) COMMENT 'x'", "ALTER ROUTINE r COMMENT 'x'", + "ALTER FUNCTION f COMMENT 'x' RESTRICT"}) + void testRejectInvalidCombinations(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL))); + } + + @Test + void testSqlServerRoutinesAreUnchanged() throws JSQLParserException { + Consumer sqlServer = parser -> parser.withDialect(Dialect.SQLSERVER); + assertInstanceOf(CreateFunction.class, CCJSqlParserUtil.parse( + "ALTER FUNCTION dbo.f(@a int) RETURNS int AS BEGIN RETURN @a END", sqlServer)); + assertInstanceOf(CreateProcedure.class, + CCJSqlParserUtil.parse("ALTER PROCEDURE dbo.p AS SELECT 1", sqlServer)); + } + + @Test + void testValidation() { + validateNoErrors("ALTER FUNCTION f2(int) OWNER TO u1", 1, DatabaseType.POSTGRESQL); + validateNoErrors("ALTER PROCEDURE p1(int) SET search_path = public", 1, + DatabaseType.POSTGRESQL); + validateNoErrors("ALTER ROUTINE f2(int) IMMUTABLE", 1, DatabaseType.POSTGRESQL); + validateNoErrors("ALTER FUNCTION f1 READS SQL DATA", 1, DatabaseType.MYSQL, + DatabaseType.MARIADB); + validateNoErrors("ALTER PROCEDURE p1 COMMENT 'x'", 1, DatabaseType.MYSQL, + DatabaseType.MARIADB); + assertFalse(new Validation(List.of(DatabaseType.MYSQL), "ALTER ROUTINE f2(int) STABLE") + .validate().isEmpty()); + assertFalse(new Validation(List.of(FeaturesAllowed.SELECT), + "ALTER FUNCTION f2(int) STABLE").validate().isEmpty()); + assertTrue(new Validation(List.of(new FeaturesAllowed().add(Feature.alterProcedure)), + "ALTER PROCEDURE p1(int) RESET ALL").validate().isEmpty()); + } + + /** Parses, deparses and reparses with the dialect, or without one if it is null. */ + private static void assertRoundTrip(String sql, Dialect dialect) throws JSQLParserException { + Consumer consumer = dialect == null ? parser -> { + } : parser -> parser.withDialect(dialect); + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, consumer); + assertInstanceOf(AlterRoutine.class, statement); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + assertEquals(sql, CCJSqlParserUtil.parse(deparsed.toString(), consumer).toString()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", consumer).size()); + } + + private static AlterRoutine parsePostgreSql(String sql) throws JSQLParserException { + return (AlterRoutine) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterRuleTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterRuleTest.java new file mode 100644 index 0000000000..55f1e778e2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterRuleTest.java @@ -0,0 +1,152 @@ +/*- + * #%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.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.rule.CreateRule; +import net.sf.jsqlparser.statement.select.FromItemVisitorAdapter; +import net.sf.jsqlparser.statement.select.PivotVisitorAdapter; +import net.sf.jsqlparser.statement.select.SelectItemVisitorAdapter; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL ALTER RULE name ON table RENAME TO new_name, see + * https://www.postgresql.org/docs/18/sql-alterrule.html. + */ +class AlterRuleTest extends ValidationTestAsserts { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + @ParameterizedTest + @ValueSource(strings = { + "ALTER RULE r1 ON t RENAME TO r2", + "ALTER RULE r1 ON s.t RENAME TO r2", + "ALTER RULE \"Rule 1\" ON public.t RENAME TO \"Rule 2\"", + "ALTER RULE r9 ON d.public.t RENAME TO r2", + "ALTER RULE rule ON t RENAME TO rename", + "ALTER RULE int ON t RENAME TO between"}) + void testRenameRule(String sql) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isInstanceOf(AlterRule.class); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(AlterRule.class); + StatementDeParser deparser = new StatementDeParser(new StringBuilder()); + statement.accept(deparser); + assertThat(deparser.getBuilder()).hasToString(sql); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + + Statements script = CCJSqlParserUtil.parseStatements( + sql + "; CREATE RULE r AS ON INSERT TO t DO NOTHING; " + sql, POSTGRESQL); + assertThat(script).hasSize(3); + assertThat(script.get(0)).hasToString(sql); + assertThat(script.get(1)).isInstanceOf(CreateRule.class); + assertThat(script.get(2)).hasToString(sql); + } + + @Test + void testFieldsTablesAndVisitors() throws Exception { + AlterRule rule = (AlterRule) CCJSqlParserUtil.parse( + "ALTER RULE \"Rule 1\" ON app.t RENAME TO r2", POSTGRESQL); + assertThat(rule.getName()).isEqualTo("\"Rule 1\""); + assertThat(rule.getTable().getFullyQualifiedName()).isEqualTo("app.t"); + assertThat(rule.getNewName()).isEqualTo("r2"); + assertThat(new TablesNamesFinder().getTables((Statement) rule)) + .containsExactly("app.t"); + + List visited = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter<>(); + FromItemVisitorAdapter fromItems = new FromItemVisitorAdapter() { + @Override + public Void visit(Table table, S context) { + visited.add(table.getFullyQualifiedName()); + return null; + } + }; + rule.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions, + new PivotVisitorAdapter<>(expressions), new SelectItemVisitorAdapter<>(expressions), + fromItems))); + assertThat(visited).containsExactly("app.t"); + assertThat(rule.accept(new StatementVisitorAdapter() { + @Override + public String visit(AlterRule statement, S context) { + return context + ":" + statement.getName(); + } + }, "context")).isEqualTo("context:\"Rule 1\""); + + rule.getTable().setName("u"); + rule.setNewName("r3"); + assertThat(rule).hasToString("ALTER RULE \"Rule 1\" ON app.u RENAME TO r3"); + assertThat(new AlterRule().withName("a").withTable(new Table("t")).withNewName("b")) + .hasToString("ALTER RULE a ON t RENAME TO b"); + } + + @Test + void testValidation() throws Exception { + String sql = "ALTER RULE r1 ON t RENAME TO r2"; + validateNoErrors(sql, 1, FeaturesAllowed.ALTER); + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, Feature.alterRule); + validate(sql, 1, 1, MySqlVersion.V8_0); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER RULE r9 ON a.b.c.t RENAME TO r2", + "ALTER RULE IF EXISTS r9 ON t RENAME TO r2", + "ALTER RULE r9 ON ONLY t RENAME TO r2", + "ALTER RULE r9 ON t* RENAME TO r2", + "ALTER RULE r9 ON t RENAME r2", + "ALTER RULE r9 RENAME TO r2", + "ALTER RULE s.r9 ON t RENAME TO r2", + "ALTER RULE r9 ON t RENAME TO s.r2", + "ALTER RULE r9 ON t OWNER TO postgres", + "ALTER RULE r9 ON t SET SCHEMA s", + "ALTER RULE r9 ON t RENAME TO r2 CASCADE", + "ALTER RULE select ON t RENAME TO r2", + "ALTER RULE r9 ON t RENAME TO select", + "ALTER RULE left ON t RENAME TO r2", + "ALTER RULE r9 ON t RENAME TO inner", + "ALTER RULE 'r9' ON t RENAME TO r2", + "ALTER RULE r9 ON t RENAME TO 1"}) + void testRejectedForms(String sql) { + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql, POSTGRESQL)) + .isInstanceOf(JSQLParserException.class); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterTest.java index fa82730d41..6472bcb306 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/AlterTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterTest.java @@ -38,10 +38,11 @@ import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDataType; import net.sf.jsqlparser.statement.create.index.CreateIndex; import net.sf.jsqlparser.statement.create.table.CheckConstraint; -import net.sf.jsqlparser.statement.create.table.ForeignKeyIndex; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; import net.sf.jsqlparser.statement.create.table.Index; -import net.sf.jsqlparser.statement.create.table.Index.ColumnParams; -import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.IndexSpecOption; +import net.sf.jsqlparser.statement.create.table.KeyElement; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import net.sf.jsqlparser.statement.create.table.PartitionDefinition; import net.sf.jsqlparser.statement.create.table.PartitionBound; import net.sf.jsqlparser.test.TestUtils; @@ -96,6 +97,49 @@ public void testAlterTableAddColumn_ColumnKeyWordImplicit() throws JSQLParserExc assertEquals("varchar (255)", colDataTypes.get(0).getColDataType().toString()); } + @Test + public void testAlterTableAddColumnListTSql() throws JSQLParserException { + // T-SQL and Snowflake let one ADD list several columns without repeating ADD + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD a int, b varchar(10) NOT NULL, c int", + parser -> parser.withDialect(Dialect.SQLSERVER)); + assertEquals(1, alter.getAlterExpressions().size()); + AlterExpression alterExp = alter.getAlterExpressions().get(0); + assertEquals(AlterOperation.ADD, alterExp.getOperation()); + List colDataTypes = alterExp.getColDataTypeList(); + assertEquals(3, colDataTypes.size()); + assertEquals("a", colDataTypes.get(0).getColumnName()); + assertEquals("b", colDataTypes.get(1).getColumnName()); + assertEquals("varchar (10)", colDataTypes.get(1).getColDataType().toString()); + assertEquals("c", colDataTypes.get(2).getColumnName()); + assertDeparse(alter, "ALTER TABLE t ADD a int, b varchar (10) NOT NULL, c int"); + } + + @Test + public void testAlterTableAddColumnListWithConstraintTSql() throws JSQLParserException { + // T-SQL mixes column definitions and table constraints in one ADD list + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD a int, CONSTRAINT ck CHECK (a > 0)", + parser -> parser.withDialect(Dialect.SQLSERVER)); + assertEquals(1, alter.getAlterExpressions().size()); + AlterExpression alterExp = alter.getAlterExpressions().get(0); + assertEquals(AlterOperation.ADD, alterExp.getOperation()); + assertEquals(1, alterExp.getColDataTypeList().size()); + assertNotNull(alterExp.getConstraint()); + } + + @Test + public void testAlterTableAddColumnListSnowflake() throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD COLUMN a int, b int", + parser -> parser.withDialect(Dialect.SNOWFLAKE)); + assertEquals(1, alter.getAlterExpressions().size()); + List colDataTypes = + alter.getAlterExpressions().get(0).getColDataTypeList(); + assertEquals(2, colDataTypes.size()); + assertDeparse(alter, "ALTER TABLE t ADD COLUMN a int, b int"); + } + @Test public void testAlterTableBackBrackets() throws JSQLParserException { String sql = "ALTER TABLE tablename add column (field string comment 'aaaaa')"; @@ -288,7 +332,8 @@ public void testAlterTablePK() throws JSQLParserException { AlterExpression alterExpression = ((Alter) stmt).getAlterExpressions().get(0); assertNull(alterExpression.getConstraintName()); // TODO: should this pass? ==> assertEquals(alterExpression.getPkColumns().get(0), "ID"); - assertEquals(alterExpression.getIndex().getColumnsNames().get(0), "`ID`"); + assertEquals(((KeyConstraint) alterExpression.getConstraint()).getColumnsNames().get(0), + "`ID`"); } @Test @@ -311,7 +356,7 @@ public void testAlterTableCheckConstraint() throws JSQLParserException { Alter created = new Alter().withTable(new Table("`Author`")) .addAlterExpressions(Collections.singleton( new AlterExpression().withOperation(AlterOperation.ADD) - .withIndex(new CheckConstraint() + .withConstraint(new CheckConstraint() .withName("name_not_empty") .withExpression(new NotEqualsTo() .withLeftExpression(new Column("`NAME`")) @@ -607,12 +652,12 @@ public void testAlterTableAddUniqueIndexWithCommentIssue2503() throws Exception Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed(sql); AlterExpression alterExpression = alter.getAlterExpressions().get(0); - Index index = alterExpression.getIndex(); + KeyConstraint index = (KeyConstraint) alterExpression.getConstraint(); assertNotNull(index); assertEquals("UNIQUE", index.getType()); assertEquals("INDEX", index.getIndexKeyword()); - assertEquals("`index2`", index.getName()); + assertEquals("`index2`", index.getIndexName()); assertEquals(List.of("`report_name` ASC"), index.getColumnsNames()); assertEquals("'唯一索引'", index.getCommentText()); @@ -637,7 +682,7 @@ public void testIssue633_2() throws JSQLParserException { .withTable(new Table("american_football_action_plays")) .withIndex( new Index().withName("idx_american_football_action_plays_1") - .addColumns(new ColumnParams("play_type", null)) + .addColumns(new KeyElement("play_type", null)) .withUsing("btree")); assertDeparse(created, statement); assertEqualsObjectTree(parsed, created); @@ -651,11 +696,11 @@ public void testAlterOnlyIssue928() throws JSQLParserException { Alter created = new Alter().withUseOnly(true).withTable(new Table("categories")) .addAlterExpressions( new AlterExpression().withOperation(AlterOperation.ADD) - .withIndex(new NamedConstraint() + .withConstraint(new KeyConstraint() .withName(Collections.singletonList( "pk_categories")) .withType("PRIMARY KEY") - .addColumns(new ColumnParams("category_id")))); + .addColumns(new KeyElement("category_id")))); assertDeparse(created, statement); assertEqualsObjectTree(parsed, created); } @@ -977,7 +1022,7 @@ public void testAlterTableDefaultValueTrueIssue926() throws JSQLParserException private void assertReferentialActionOnConstraint(Alter parsed, Action onUpdate, Action onDelete) { AlterExpression alterExpression = parsed.getAlterExpressions().get(0); - ForeignKeyIndex index = (ForeignKeyIndex) alterExpression.getIndex(); + ForeignKeyConstraint index = (ForeignKeyConstraint) alterExpression.getConstraint(); // remove line if deprecated methods are removed. index.setOnDeleteReferenceOption(index.getOnDeleteReferenceOption()); @@ -2071,13 +2116,14 @@ public void testAlterTableAddFullTextIndexWithOptions() throws JSQLParserExcepti assertEquals("col1", columnNames.get(0)); assertEquals("col2", columnNames.get(1)); - List indexSpec = index.getIndexSpec(); - assertNotNull(indexSpec); - assertEquals(4, indexSpec.size()); - assertEquals("KEY_BLOCK_SIZE = 8", indexSpec.get(0)); - assertEquals("WITH PARSER ngram", indexSpec.get(1)); - assertEquals("COMMENT 'fulltext'", indexSpec.get(2)); - assertEquals("INVISIBLE", indexSpec.get(3)); + List options = index.getSpecOptions(); + assertEquals(4, options.size()); + assertEquals("KEY_BLOCK_SIZE = 8", options.get(0).toString()); + assertEquals("WITH PARSER ngram", options.get(1).toString()); + assertEquals("COMMENT 'fulltext'", options.get(2).toString()); + assertEquals("INVISIBLE", options.get(3).toString()); + assertEquals(List.of("KEY_BLOCK_SIZE", "=", "8", "WITH", "PARSER", "ngram", "COMMENT", + "'fulltext'", "INVISIBLE"), index.getIndexSpec()); assertSqlCanBeParsedAndDeparsed(sql); } @@ -2133,13 +2179,14 @@ public void testAlterTableAddIndexWithOptions() throws JSQLParserException { assertEquals("idx_lastname", index.getName()); assertEquals("last_name", index.getColumnsNames().get(0)); - List indexSpec = index.getIndexSpec(); - assertNotNull(indexSpec); - assertEquals(4, indexSpec.size()); - assertEquals("USING BTREE", indexSpec.get(0)); - assertEquals("KEY_BLOCK_SIZE = 16", indexSpec.get(1)); - assertEquals("COMMENT 'Performance tuning'", indexSpec.get(2)); - assertEquals("VISIBLE", indexSpec.get(3)); + List options = index.getSpecOptions(); + assertEquals(4, options.size()); + assertEquals("USING BTREE", options.get(0).toString()); + assertEquals("KEY_BLOCK_SIZE = 16", options.get(1).toString()); + assertEquals("COMMENT 'Performance tuning'", options.get(2).toString()); + assertEquals("VISIBLE", options.get(3).toString()); + assertEquals(List.of("USING", "BTREE", "KEY_BLOCK_SIZE", "=", "16", "COMMENT", + "'Performance tuning'", "VISIBLE"), index.getIndexSpec()); assertSqlCanBeParsedAndDeparsed(sql); } @@ -2425,7 +2472,7 @@ public void testAlterTableAddConstraintPrimaryKeyUsingIndexName() throws JSQLPar AlterExpression alterExp = alterExpressions.get(0); assertEquals(AlterOperation.ADD, alterExp.getOperation()); - assertNotNull(alterExp.getIndex()); + assertNotNull(alterExp.getConstraint()); assertEquals(Arrays.asList("USING", "INDEX", "PK_TNWAV"), alterExp.getParameters()); assertSqlCanBeParsedAndDeparsed(sql); diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterTriggerTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterTriggerTest.java new file mode 100644 index 0000000000..cf33ab0f3d --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterTriggerTest.java @@ -0,0 +1,109 @@ +/*- + * #%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 net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterTriggerTest { + + @ParameterizedTest + @ValueSource(strings = {"ALTER TRIGGER trg ON users RENAME TO trg_new", + "ALTER TRIGGER \"Trg\" ON app.\"Users\" RENAME TO \"Trg 2\"", + "ALTER TRIGGER trg ON users DEPENDS ON EXTENSION ext", + "ALTER TRIGGER trg ON users NO DEPENDS ON EXTENSION ext"}) + void testRoundTrip(String sql) throws JSQLParserException { + for (Consumer consumer : List.>of(parser -> { + }, parser -> parser.withDialect(Dialect.POSTGRESQL))) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, consumer); + assertInstanceOf(AlterTrigger.class, statement); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + assertEquals(sql, CCJSqlParserUtil.parse(deparsed.toString(), consumer).toString()); + assertEquals(2, + CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", consumer).size()); + } + } + + @Test + void testActionsAndTable() throws JSQLParserException { + AlterTrigger rename = parse("ALTER TRIGGER trg ON app.users RENAME TO trg_new"); + assertEquals("trg", rename.getName()); + assertEquals("app.users", rename.getTable().getFullyQualifiedName()); + assertEquals(AlterTrigger.Action.RENAME, rename.getAction()); + assertEquals("trg_new", rename.getNewName()); + assertEquals(List.of("app.users"), + List.copyOf(new TablesNamesFinder().getTables((Statement) rename))); + + AlterTrigger dependency = parse("ALTER TRIGGER trg ON users NO DEPENDS ON EXTENSION ext"); + assertEquals(AlterTrigger.Action.DEPENDS_ON_EXTENSION, dependency.getAction()); + assertEquals("ext", dependency.getExtensionName()); + assertTrue(dependency.isNoDependency()); + + dependency.setNoDependency(false); + dependency.setTable(new Table("orders")); + assertEquals("ALTER TRIGGER trg ON orders DEPENDS ON EXTENSION ext", + dependency.toString()); + dependency.setAction(AlterTrigger.Action.RENAME); + dependency.setNewName("trg2"); + assertEquals("ALTER TRIGGER trg ON orders RENAME TO trg2", dependency.toString()); + + assertEquals("context:trg", rename.accept(new StatementVisitorAdapter() { + @Override + public String visit(AlterTrigger trigger, S context) { + return context + ":" + trigger.getName(); + } + }, "context")); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TRIGGER trg ENABLE", "ALTER TRIGGER trg COMPILE", + "ALTER TRIGGER trg ON t AFTER INSERT AS SELECT 1", + "ALTER TRIGGER trg ON t RENAME TO t2 CASCADE", + "ALTER TRIGGER trg ON t DEPENDS ON SCHEMA s"}) + void testOtherFormsRemainUnsupported(String sql) throws JSQLParserException { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql)); + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + } + + @Test + void testValidation() { + validateNoErrors("ALTER TRIGGER trg ON users RENAME TO trg_new", 1, + DatabaseType.POSTGRESQL); + assertFalse(new Validation(List.of(DatabaseType.MYSQL), + "ALTER TRIGGER trg ON users RENAME TO trg_new").validate().isEmpty()); + } + + private static AlterTrigger parse(String sql) throws JSQLParserException { + return (AlterTrigger) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterUserTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterUserTest.java new file mode 100644 index 0000000000..8bd06f22b1 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterUserTest.java @@ -0,0 +1,291 @@ +/*- + * #%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.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.user.PasswordLockOption; +import net.sf.jsqlparser.statement.create.user.RoleSelection; +import net.sf.jsqlparser.statement.create.user.TlsOption; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.statement.create.user.UserAuthentication; +import net.sf.jsqlparser.statement.create.user.UserAuthentication.Mode; +import net.sf.jsqlparser.statement.create.user.UserOptions; +import net.sf.jsqlparser.statement.role.AlterRole; +import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterUserTest { + + private static AlterUser parse(String sql, Dialect dialect) throws JSQLParserException { + AlterUser alterUser = assertInstanceOf(AlterUser.class, + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(dialect))); + Statement reparsed = CCJSqlParserUtil.parse(alterUser.toString(), + parser -> parser.withDialect(dialect)); + assertEquals(sql, assertInstanceOf(AlterUser.class, reparsed).toString()); + return alterUser; + } + + private static AlterUser parse(String sql) throws JSQLParserException { + return parse(sql, Dialect.MYSQL); + } + + private static List names(List accounts) { + return accounts.stream().map(UserAccount::toString).collect(Collectors.toList()); + } + + @Test + void retainsCurrentPassword() throws JSQLParserException { + AlterUser alterUser = + parse("ALTER USER 'app'@'%' IDENTIFIED BY 'newsecret' RETAIN CURRENT PASSWORD"); + + UserAccount account = alterUser.getAccounts().get(0); + assertEquals("app", account.getUser().getValue()); + assertEquals("%", account.getHost().getValue()); + UserAuthentication authentication = account.getAuthentication(); + assertEquals(Mode.BY_PASSWORD, authentication.getMode()); + assertEquals("newsecret", authentication.getCredential().getValue()); + assertTrue(authentication.isRetainCurrentPassword()); + assertNull(authentication.getCurrentCredential()); + assertTrue(alterUser.getOptions().isEmpty()); + assertFalse(alterUser.isIfExists()); + assertFalse(alterUser.isUserFunction()); + } + + @Test + void replacesCurrentPassword() throws JSQLParserException { + UserAuthentication authentication = parse("ALTER USER 'app'@'%' IDENTIFIED WITH " + + "caching_sha2_password BY 'x' REPLACE 'old' RETAIN CURRENT PASSWORD") + .getAccounts().get(0).getAuthentication(); + + assertEquals(Mode.WITH_PLUGIN_BY_PASSWORD, authentication.getMode()); + assertEquals("caching_sha2_password", authentication.getPlugin()); + assertEquals("old", authentication.getCurrentCredential().getValue()); + assertTrue(authentication.isRetainCurrentPassword()); + } + + @Test + void namesTheCurrentUserWithParentheses() throws JSQLParserException { + AlterUser alterUser = parse("ALTER USER CURRENT_USER() IDENTIFIED BY 'x' " + + "RETAIN CURRENT PASSWORD"); + UserAccount account = alterUser.getAccounts().get(0); + + assertEquals("CURRENT_USER", account.getUser().getValue()); + assertTrue(account.isCurrentUserParentheses()); + assertFalse(alterUser.isUserFunction()); + assertFalse(parse("ALTER USER CURRENT_USER IDENTIFIED BY 'x'").getAccounts().get(0) + .isCurrentUserParentheses()); + assertEquals("CURRENT_USER()", new UserAccount() + .withUser(new StringValue("CURRENT_USER").setQuoteStr("")) + .withCurrentUserParentheses(true).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER USER 'CURRENT_USER'() IDENTIFIED BY 'x'", + "ALTER USER app() IDENTIFIED BY 'x'", + "ALTER USER CURRENT_USER()@localhost ACCOUNT LOCK"}) + void takesParenthesesOnlyAfterAnUnquotedCurrentUser(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } + + @Test + void altersTheCurrentUserWithUserFunction() throws JSQLParserException { + AlterUser alterUser = parse("ALTER USER USER() IDENTIFIED BY 'x'"); + + assertTrue(alterUser.isUserFunction()); + assertEquals("USER()", alterUser.getAccounts().get(0).getUser().getValue()); + assertEquals(Mode.BY_PASSWORD, + alterUser.getAccounts().get(0).getAuthentication().getMode()); + + AlterUser random = parse("ALTER USER IF EXISTS USER() IDENTIFIED BY RANDOM PASSWORD " + + "REPLACE 'old' RETAIN CURRENT PASSWORD"); + assertTrue(random.isIfExists()); + assertTrue(random.isUserFunction()); + + assertEquals(Mode.DISCARD_OLD_PASSWORD, + parse("ALTER USER USER() DISCARD OLD PASSWORD").getAccounts().get(0) + .getAuthentication().getMode()); + } + + @Test + void sharesOptionsWithCreateUser() throws JSQLParserException { + AlterUser alterUser = + parse("ALTER USER IF EXISTS 'app'@'%' REQUIRE NONE WITH MAX_USER_CONNECTIONS 10"); + + assertTrue(alterUser.isIfExists()); + UserOptions options = alterUser.getOptions(); + assertEquals(TlsOption.Kind.NONE, options.getTlsOptions().get(0).getKind()); + assertEquals(10, options.getResourceLimits().get(0).getValue()); + + assertEquals(PasswordLockOption.Kind.PASSWORD_EXPIRE, + parse("ALTER USER 'app'@'%' PASSWORD EXPIRE").getOptions() + .getPasswordLockOptions().get(0).getKind()); + assertEquals(PasswordLockOption.Kind.ACCOUNT_UNLOCK, + parse("ALTER USER 'app'@'%' ACCOUNT UNLOCK").getOptions() + .getPasswordLockOptions().get(0).getKind()); + } + + @Test + void altersSeveralAccounts() throws JSQLParserException { + AlterUser alterUser = parse("ALTER USER a IDENTIFIED BY 'x', 'b'@'%' DISCARD OLD PASSWORD, " + + "c ACCOUNT LOCK COMMENT 'locked'"); + + assertEquals(List.of("a IDENTIFIED BY 'x'", "'b'@'%' DISCARD OLD PASSWORD", "c"), + names(alterUser.getAccounts())); + assertEquals(Mode.DISCARD_OLD_PASSWORD, + alterUser.getAccounts().get(1).getAuthentication().getMode()); + assertEquals("locked", alterUser.getOptions().getComment().getValue()); + } + + @Test + void setsDefaultRoles() throws JSQLParserException { + RoleSelection all = parse("ALTER USER 'app'@'%' DEFAULT ROLE ALL").getOptions() + .getDefaultRoles(); + assertEquals(RoleSelection.Kind.ALL, all.getKind()); + assertTrue(all.getRoles().isEmpty()); + + assertEquals(RoleSelection.Kind.NONE, + parse("ALTER USER app DEFAULT ROLE NONE").getOptions().getDefaultRoles() + .getKind()); + + RoleSelection roles = parse("ALTER USER app DEFAULT ROLE r1, 'r2'@'%'").getOptions() + .getDefaultRoles(); + assertEquals(RoleSelection.Kind.ROLES, roles.getKind()); + assertEquals(List.of("r1", "'r2'@'%'"), names(roles.getRoles())); + } + + @Test + void parsesUnquotedAccountNames() throws JSQLParserException { + assertEquals("app", parse("ALTER USER app IDENTIFIED BY 'x'").getAccounts().get(0) + .getUser().getValue()); + UserAccount account = + parse("ALTER USER app@localhost IDENTIFIED BY 'x'").getAccounts().get(0); + assertEquals("app", account.getUser().getValue()); + assertEquals("localhost", account.getHost().getValue()); + assertTrue(parse("ALTER USER app").getOptions().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER USER \"app\"@\"%\" IDENTIFIED BY 'x' ACCOUNT LOCK", + "ALTER USER `app`@'%', app@'%', 'app'@localhost ACCOUNT LOCK", + "RENAME USER \"a\"@\"%\" TO `b`@localhost", + "SET PASSWORD FOR \"app\"@\"%\" = 'x'", + "SET DEFAULT ROLE `r`@'%' TO \"app\"@\"%\"", + "CREATE ROLE \"reader\", `writer`@'%'" + }) + void keepsQuotedAccountNamesInEveryMode(String sql) throws JSQLParserException { + // without a dialect "app" is a quoted identifier, with MySQL a double-quoted string + for (Dialect dialect : new Dialect[] {null, Dialect.MYSQL}) { + Consumer configuration = parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }; + Statement statement = + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false, configuration); + assertEquals(sql, + CCJSqlParserUtil.parse(statement.toString(), configuration).toString()); + } + } + + @Test + void parsesInDefaultModeAndMariaDb() throws JSQLParserException { + String sql = "ALTER USER IF EXISTS 'app'@'%' IDENTIFIED BY 'x' REQUIRE SSL " + + "WITH MAX_QUERIES_PER_HOUR 10 PASSWORD EXPIRE NEVER ACCOUNT UNLOCK"; + parse(sql, Dialect.MARIADB); + assertInstanceOf(AlterUser.class, TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false)); + } + + @Test + void keepsPostgreSqlAlterUser() throws JSQLParserException { + for (String sql : List.of("ALTER USER app WITH LOGIN", "ALTER USER app PASSWORD 'x'", + "ALTER USER app WITH PASSWORD NULL", "ALTER USER app VALID UNTIL '2030-01-01'", + "ALTER USER app CONNECTION LIMIT 5", "ALTER USER app RENAME TO app2", + "ALTER USER app SET search_path TO app, public", "ALTER USER ALL RESET ALL", + "ALTER USER CURRENT_USER WITH PASSWORD NULL", + "ALTER USER SESSION_USER SET enable_seqscan TO on")) { + assertInstanceOf(AlterRole.class, CCJSqlParserUtil.parse(sql), sql); + assertInstanceOf(AlterRole.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)), sql); + } + } + + @Test + void buildsAndDeparses() { + AlterUser alterUser = new AlterUser().withIfExists(true) + .addAccounts(new UserAccount().withUser(new StringValue("app")) + .withAuthentication(new UserAuthentication().withMode(Mode.BY_PASSWORD) + .withCredential(new StringValue("new")) + .withCurrentCredential(new StringValue("old")))) + .withOptions(new UserOptions().addPasswordLockOptions( + new PasswordLockOption(PasswordLockOption.Kind.ACCOUNT_LOCK))); + + assertDeparse(alterUser, + "ALTER USER IF EXISTS 'app' IDENTIFIED BY 'new' REPLACE 'old' ACCOUNT LOCK"); + + alterUser.withUserFunction( + new UserAuthentication().withMode(Mode.DISCARD_OLD_PASSWORD)); + assertTrue(alterUser.isUserFunction()); + assertEquals("ALTER USER IF EXISTS USER() DISCARD OLD PASSWORD ACCOUNT LOCK", + alterUser.toString()); + } + + @Test + void reportsSchemaChangeWithoutTables() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("ALTER USER 'app'@'%' ACCOUNT LOCK"); + + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(TablesNamesFinder.findTables(statement.toString())).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER USER a, b DEFAULT ROLE r", + "ALTER USER app IDENTIFIED BY 'x' DEFAULT ROLE r", + "ALTER USER app DEFAULT ROLE DEFAULT", + "ALTER USER app DEFAULT ROLE ALL EXCEPT r", + "ALTER USER app IDENTIFIED WITH auth_socket REPLACE 'x'", + "ALTER USER app IDENTIFIED WITH auth_socket AS 'h' RETAIN CURRENT PASSWORD", + "ALTER USER app IDENTIFIED BY 'x' REPLACE", + "ALTER USER USER() IDENTIFIED WITH auth_socket BY 'x'", + "ALTER USER USER() ACCOUNT LOCK", + "ALTER USER USER()", + "ALTER USER app DISCARD OLD PASSWORD RETAIN CURRENT PASSWORD", + "ALTER USER app ACCOUNT LOCK REQUIRE SSL" + }) + void rejectsSyntaxOutsideTheStatementDefinition(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/CockroachAlterPrimaryKeyTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/CockroachAlterPrimaryKeyTest.java index 580c5febec..ddbeaec9e4 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/CockroachAlterPrimaryKeyTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/CockroachAlterPrimaryKeyTest.java @@ -9,6 +9,9 @@ */ package net.sf.jsqlparser.statement.alter; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.KeyElement; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNull; @@ -25,7 +28,6 @@ import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.StatementVisitorAdapter; import net.sf.jsqlparser.statement.Statements; -import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; import net.sf.jsqlparser.test.TestUtils; import net.sf.jsqlparser.util.TablesNamesFinder; @@ -54,8 +56,8 @@ void parsesOriginalReproducerIssue1743() throws Exception { parser -> parser.withDialect(Dialect.COCKROACHDB)); AlterExpressionPrimaryKey action = primaryKey(alter); assertEquals(AlterOperation.ALTER_PRIMARY_KEY, action.getOperation()); - assertEquals(Index.Kind.PRIMARY_KEY, action.getIndex().getKind()); - assertEquals(List.of("FEATURE_NAME"), action.getIndex().getColumnsNames()); + assertEquals(ConstraintKind.PRIMARY_KEY, action.getConstraint().getKind()); + assertEquals(List.of("FEATURE_NAME"), action.getConstraint().getColumnsNames()); assertTrue(action.isUsingHash()); assertNull(action.getBucketCount()); assertEquals(Set.of("FEATURE_SWITCH_CONFIG"), new TablesNamesFinder<>().getTables(alter)); @@ -74,7 +76,7 @@ void preservesKeyOrderOptionsAndRoundTrips(String suffix) throws Exception { for (String rendered : List.of(alter.toString(), output.toString())) { AlterExpressionPrimaryKey action = primaryKey(parse(rendered)); assertEquals(List.of("tenant_id ASC", "\"key\" DESC"), - action.getIndex().getColumnsNames()); + action.getConstraint().getColumnsNames()); assertEquals(suffix.contains("USING HASH"), action.isUsingHash()); if (suffix.contains("BUCKET_COUNT")) { assertEquals(8, ((LongValue) action.getBucketCount()).getValue()); @@ -82,7 +84,7 @@ void preservesKeyOrderOptionsAndRoundTrips(String suffix) throws Exception { assertNull(action.getBucketCount()); } if (suffix.contains("WITH (")) { - Index.Option option = action.getIndex().getStorageParameters().get(0); + IndexOption option = action.getConstraint().getStorageParameters().get(0); assertEquals(suffix.contains("bucket_count") ? "bucket_count" : "fillfactor", option.getName()); assertEquals(suffix.contains("bucket_count") ? 8 : 70, @@ -96,12 +98,12 @@ void exposesStructuredExpressionKeysAndSupportsMutation() throws Exception { Alter alter = parse("ALTER TABLE t ALTER PRIMARY KEY USING COLUMNS " + "(lower(name) text_ops DESC, (id + 1) ASC)"); AlterExpressionPrimaryKey action = primaryKey(alter); - Index.ColumnParams first = action.getIndex().getColumns().get(0); + KeyElement first = action.getConstraint().getColumns().get(0); assertTrue(first.getExpression() instanceof Function); assertFalse(first.isExpressionParenthesized()); assertEquals("text_ops", first.getOperatorClass()); assertNull(first.getParams()); - first.setSortOrder(Index.ColumnParams.SortOrder.ASC); + first.setSortOrder(KeyElement.SortOrder.ASC); action.setUsingHash(true); action.setBucketCount(new LongValue(16)); String expected = "ALTER TABLE t ALTER PRIMARY KEY USING COLUMNS " diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/ColumnDefaultActionTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/ColumnDefaultActionTest.java new file mode 100644 index 0000000000..535606803d --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/ColumnDefaultActionTest.java @@ -0,0 +1,219 @@ +/*- + * #%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.assertEquals; +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 net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.NullValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnSetDefault; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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 ColumnDefaultActionTest { + @ParameterizedTest + @ValueSource(strings = {"TABLE", "VIEW"}) + void commonAccessMutatesTheExistingModel(String objectType) throws JSQLParserException { + Statement statement = parse("ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT 1"); + AlterExpression action = actions(statement).get(0); + ColumnDefaultAction column = action.getColumnDefaults().get(0); + assertEquals("a", column.getColumnName()); + assertEquals("1", column.getDefaultValue()); + assertSame(action instanceof RelationAlterAction ? action + : action.getColumnSetDefaultList().get(0), column); + + Expression replacement = CCJSqlParserUtil.parseExpression("(2 + 3)"); + column.setDefaultExpression(replacement); + column.setColumnName("renamed"); + assertSame(replacement, column.getDefaultExpression()); + assertEquals("(2 + 3)", column.getDefaultValue()); + assertEquals("ALTER " + objectType + " t ALTER COLUMN renamed SET DEFAULT (2 + 3)", + statement.toString()); + roundTrip(statement); + + List expressions = new ArrayList<>(); + TableDefinitionTraversal.visit(action, expressions::add, ignored -> { + }); + assertEquals(List.of(replacement), expressions); + + if (action instanceof RelationAlterAction) { + ((RelationAlterAction) action).setDefaultExpression(new LongValue(4)); + } else { + action.getColumnSetDefaultList().get(0).setDefaultExpression(new LongValue(4)); + } + assertEquals("4", column.getDefaultValue()); + roundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = {"TABLE", "VIEW"}) + void sharedRenderingPreservesCustomExpressionVisitors(String objectType) + throws JSQLParserException { + Statement statement = parse("ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT 0"); + actions(statement).get(0).getColumnDefaults().get(0) + .setDefaultExpression(CCJSqlParserUtil.parseExpression("(1 + 2)")); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(value.getValue() + 100); + } + }; + statement.accept(new StatementDeParser(expressions, new SelectDeParser(), output), null); + assertEquals("ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT (101 + 102)", + output.toString()); + assertEquals(output.toString(), parse(output.toString()).toString()); + assertEquals("ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT (1 + 2)", + statement.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"TABLE", "VIEW"}) + void quotedNamesAndExplicitSqlNullRoundTrip(String objectType) throws JSQLParserException { + Statement statement = + parse("ALTER " + objectType + " t ALTER COLUMN \"Old Name\" SET DEFAULT 1"); + ColumnDefaultAction column = actions(statement).get(0).getColumnDefaults().get(0); + column.setColumnName("\"New Name\""); + column.setDefaultExpression(new NullValue()); + assertEquals("NULL", column.getDefaultValue()); + assertEquals("ALTER " + objectType + " t ALTER COLUMN \"New Name\" SET DEFAULT NULL", + statement.toString()); + roundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ADD COLUMN a INT", + "ALTER TABLE t ALTER COLUMN a DROP DEFAULT", "ALTER VIEW v ALTER COLUMN a DROP DEFAULT", + "ALTER VIEW v RENAME COLUMN a TO b", + "ALTER MATERIALIZED VIEW v ALTER COLUMN a SET STATISTICS 100"}) + void unrelatedActionsDoNotAppearAsDefaults(String sql) throws JSQLParserException { + assertTrue(actions(parse(sql)).get(0).getColumnDefaults().isEmpty()); + } + + @Test + void inactiveRelationPropertiesDoNotAppearAsDefaults() { + RelationAlterAction action = new RelationAlterAction(); + action.setColumnName("a"); + action.setDefaultExpression(new LongValue(1)); + action.setColumnAction(RelationAlterAction.ColumnAction.SET_DEFAULT); + assertTrue(action.getColumnDefaults().isEmpty()); + action.setKind(RelationAlterAction.Kind.ALTER_COLUMN); + assertSame(action, action.getColumnDefaults().get(0)); + action.setColumnAction(RelationAlterAction.ColumnAction.DROP_DEFAULT); + assertTrue(action.getColumnDefaults().isEmpty()); + action.setColumnAction(RelationAlterAction.ColumnAction.SET_DEFAULT); + action.setKind(RelationAlterAction.Kind.RENAME_COLUMN); + assertTrue(action.getColumnDefaults().isEmpty()); + } + + @Test + void constraintAlterationTakesPrecedenceOverPreviouslySetDefaults() throws JSQLParserException { + Alter statement = + (Alter) CCJSqlParserUtil.parse("ALTER TABLE t ALTER COLUMN a SET DEFAULT 1"); + AlterExpression action = statement.getAlterExpressions().get(0); + ColumnDefaultAction previousDefault = action.getColumnDefaults().get(0); + action.setConstraintType("CHECK"); + action.setConstraintSymbol("c"); + action.setEnforced(true); + + assertTrue(action.getColumnDefaults().isEmpty()); + assertEquals("ALTER TABLE t ALTER CHECK c ENFORCED", statement.toString()); + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), CCJSqlParserUtil.parse(sql.toString()).toString()); + + action.setConstraintSymbol(null); + assertSame(previousDefault, action.getColumnDefaults().get(0)); + roundTrip(statement); + } + + @Test + void opaqueLegacyConstructorIsNotParsedOrPassedToAnExpressionVisitor() { + ColumnSetDefault legacy = new ColumnSetDefault("a", "vendor_specific(?)::opaque"); + ColumnDefaultAction column = legacy; + assertNull(column.getDefaultExpression()); + assertEquals("vendor_specific(?)::opaque", column.getDefaultValue()); + StringBuilder sql = new StringBuilder(); + column.appendDefaultValueTo(sql, ignored -> { + throw new AssertionError("Opaque defaults must not enter the expression visitor"); + }); + assertEquals("vendor_specific(?)::opaque", sql.toString()); + column.setColumnName("b"); + assertEquals("b SET DEFAULT vendor_specific(?)::opaque", legacy.toString()); + column.setDefaultExpression(new LongValue(2)); + assertEquals("b SET DEFAULT 2", legacy.toString()); + column.setDefaultExpression(null); + assertNull(column.getDefaultValue()); + assertEquals("b SET DEFAULT null", legacy.toString()); + assertEquals("a SET DEFAULT null", new ColumnSetDefault("a", null).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"TABLE", "VIEW"}) + void commonLookupDoesNotExposeStructuralMutations(String objectType) + throws JSQLParserException { + Statement statement = parse("ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT 1"); + List defaults = actions(statement).get(0).getColumnDefaults(); + assertThrows(UnsupportedOperationException.class, defaults::clear); + defaults.get(0).setDefaultExpression(new LongValue(2)); + assertEquals("ALTER " + objectType + " t ALTER COLUMN a SET DEFAULT 2", + statement.toString()); + roundTrip(statement); + } + + @Test + void lookupUsesTheExistingTableListWithoutCopyingItsEntries() { + AlterExpression action = new AlterExpression(); + action.setOperation(AlterOperation.ALTER); + ColumnSetDefault first = new ColumnSetDefault("a", "1"); + action.addColSetDefault(first); + List defaults = action.getColumnDefaults(); + ColumnSetDefault second = ColumnSetDefault.fromExpression("b", new LongValue(2)); + action.addColSetDefault(second); + assertEquals(List.of(first, second), defaults); + action.getColumnSetDefaultList().remove(first); + assertEquals(List.of(second), defaults); + action.setOperation(AlterOperation.DROP); + assertTrue(action.getColumnDefaults().isEmpty()); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static List actions(Statement statement) { + return statement instanceof Alter ? ((Alter) statement).getAlterExpressions() + : ((AlterRelation) statement).getActions(); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/ColumnIdentityActionTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/ColumnIdentityActionTest.java new file mode 100644 index 0000000000..e20f111863 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/ColumnIdentityActionTest.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.alter; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Sequence; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDataType; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.IdentityDefinition; +import net.sf.jsqlparser.statement.create.table.IdentityDefinition.GenerationMode; +import net.sf.jsqlparser.statement.create.table.Index; +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.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class ColumnIdentityActionTest { + @ParameterizedTest + @ValueSource(strings = {"ADD GENERATED ALWAYS AS IDENTITY (CACHE 10)", + "SET GENERATED BY DEFAULT", "SET CACHE 10", "RESTART WITH 20", + "DROP IDENTITY IF EXISTS"}) + void exposesOriginalColumnAndKeepsEachActionKind(String clause) throws JSQLParserException { + Alter statement = parse("ALTER TABLE t ALTER COLUMN id " + clause); + AlterExpression action = first(statement); + ColumnIdentityAction column = action.getColumnIdentityActions().get(0); + assertSame(action.getColDataTypeList().get(0), column); + assertSame(action.getColDataTypeList().get(0).getIdentityAlterations(), + column.getIdentityAlterations()); + assertNull(action.getColDataTypeList().get(0).getColDataType()); + column.setColumnName("\"New Id\""); + assertEquals("ALTER TABLE t ALTER COLUMN \"New Id\" " + clause, statement.toString()); + roundTrip(statement); + } + + @Test + void addModeAndParametersEditTheDefinitionAndFollowReplacements() throws JSQLParserException { + Alter statement = parse("ALTER TABLE t ALTER COLUMN id " + + "ADD GENERATED BY DEFAULT AS IDENTITY (CACHE 10)"); + IdentityAlteration action = identity(statement); + IdentityDefinition original = action.getIdentityDefinition(); + assertEquals(GenerationMode.BY_DEFAULT, action.getGenerationMode()); + assertSame(original.getParameters(), action.getParameters()); + action.setGenerationMode(GenerationMode.ALWAYS); + action.getParameters().get(0).setValue(20L); + assertEquals(GenerationMode.ALWAYS, original.getGenerationMode()); + assertEquals("ALTER TABLE t ALTER COLUMN id " + + "ADD GENERATED ALWAYS AS IDENTITY (CACHE 20)", statement.toString()); + roundTrip(statement); + + IdentityDefinition replacement = new IdentityDefinition(GenerationMode.BY_DEFAULT); + action.setIdentityDefinition(replacement); + assertEquals(GenerationMode.BY_DEFAULT, action.getGenerationMode()); + assertNull(action.getParameters()); + action.setParameters(List.of(cache(30))); + assertSame(replacement.getParameters(), action.getParameters()); + replacement.setGenerationMode(GenerationMode.ALWAYS); + assertEquals(GenerationMode.ALWAYS, action.getGenerationMode()); + assertEquals("ALTER TABLE t ALTER COLUMN id " + + "ADD GENERATED ALWAYS AS IDENTITY (CACHE 30)", statement.toString()); + roundTrip(statement); + + action.setIdentityDefinition(null); + assertNull(action.getGenerationMode()); + assertNull(action.getParameters()); + action.setGenerationMode(GenerationMode.BY_DEFAULT); + assertNotSame(original, action.getIdentityDefinition()); + assertNotSame(replacement, action.getIdentityDefinition()); + assertNull(action.getParameters()); + roundTrip(statement); + } + + @Test + void addBuilderCreatesOnlyTheRequestedDefinition() { + IdentityAlteration action = new IdentityAlteration(IdentityAlteration.Kind.ADD); + assertNull(action.getGenerationMode()); + assertNull(action.getParameters()); + action.setGenerationMode(null); + action.setParameters(null); + assertNull(action.getIdentityDefinition()); + action.setParameters(List.of(cache(10))); + assertEquals(GenerationMode.BY_DEFAULT, action.getGenerationMode()); + assertEquals("ADD GENERATED BY DEFAULT AS IDENTITY (CACHE 10)", action.toString()); + IdentityDefinition definition = action.getIdentityDefinition(); + action.setGenerationMode(GenerationMode.ALWAYS); + action.setParameters(null); + assertSame(definition, action.getIdentityDefinition()); + assertEquals("ADD GENERATED ALWAYS AS IDENTITY", action.toString()); + action.setGenerationMode(null); + assertNull(definition.getGenerationMode()); + } + + @Test + void orderedSetAndRestartActionsRemainIndependentAndEditable() throws JSQLParserException { + Alter statement = parse("ALTER TABLE t ALTER COLUMN id " + + "SET GENERATED BY DEFAULT SET CACHE 10 RESTART 20"); + ColumnIdentityAction column = first(statement).getColumnIdentityActions().get(0); + List actions = column.getIdentityAlterations(); + assertEquals(List.of(IdentityAlteration.Kind.SET_GENERATED, + IdentityAlteration.Kind.SET_PARAMETER, IdentityAlteration.Kind.RESTART), + actions.stream().map(IdentityAlteration::getKind).collect(Collectors.toList())); + actions.get(0).setGenerationMode(GenerationMode.ALWAYS); + actions.get(1).getParameters().get(0).setValue(30L); + actions.get(2).setRestartWith(null); + assertEquals("ALTER TABLE t ALTER COLUMN id SET GENERATED ALWAYS SET CACHE 30 RESTART", + statement.toString()); + roundTrip(statement); + + IdentityAlteration drop = new IdentityAlteration(IdentityAlteration.Kind.DROP); + drop.setIfExists(true); + column.setIdentityAlterations(List.of(drop)); + assertSame(drop, identity(statement)); + assertNotSame(actions, column.getIdentityAlterations()); + assertEquals("ALTER TABLE t ALTER COLUMN id DROP IDENTITY IF EXISTS", statement.toString()); + roundTrip(statement); + drop.setIfExists(false); + assertEquals("ALTER TABLE t ALTER COLUMN id DROP IDENTITY", statement.toString()); + roundTrip(statement); + } + + @Test + void unrelatedIdentityPropertiesDoNotChangeRestartOrDropRendering() { + for (IdentityAlteration.Kind kind : List.of(IdentityAlteration.Kind.RESTART, + IdentityAlteration.Kind.DROP)) { + IdentityAlteration action = new IdentityAlteration(kind); + String before = action.toString(); + action.setIdentityDefinition(new IdentityDefinition(GenerationMode.ALWAYS)); + action.setGenerationMode(GenerationMode.ALWAYS); + action.setParameters(List.of(cache(50))); + assertEquals(before, action.toString()); + } + } + + @Test + void lookupKeepsColumnMembershipSeparateFromMutableActions() throws JSQLParserException { + Alter statement = parse("ALTER TABLE t ALTER COLUMN id RESTART WITH 20, " + + "ALTER COLUMN other TYPE bigint"); + AlterExpression action = first(statement); + List columns = action.getColumnIdentityActions(); + assertEquals(1, columns.size()); + assertTrue(statement.getAlterExpressions().get(1).getColumnIdentityActions().isEmpty()); + assertThrows(UnsupportedOperationException.class, columns::clear); + ColumnIdentityAction column = columns.get(0); + ColumnDataType stored = action.getColDataTypeList().get(0); + stored.setColDataType(new ColDataType("bigint")); + stored.setIdentityAlterations(null); + assertNull(column.getIdentityAlterations()); + assertTrue(action.getColumnIdentityActions().isEmpty()); + assertEquals(1, columns.size()); + column.setIdentityAlterations( + List.of(new IdentityAlteration(IdentityAlteration.Kind.RESTART))); + assertSame(column, action.getColumnIdentityActions().get(0)); + action.setOperation(AlterOperation.DROP); + assertTrue(action.getColumnIdentityActions().isEmpty()); + action.setOperation(AlterOperation.ALTER); + assertSame(column, action.getColumnIdentityActions().get(0)); + roundTrip(statement); + column.getIdentityAlterations().clear(); + assertTrue(action.getColumnIdentityActions().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ADD COLUMN id bigint GENERATED ALWAYS AS IDENTITY", + "ALTER TABLE t ALTER COLUMN id TYPE bigint", + "ALTER TABLE t ALTER COLUMN id SET DEFAULT 1", + "ALTER TABLE t DROP COLUMN id"}) + void excludesDeclarationsAndUnrelatedColumnChanges(String sql) throws JSQLParserException { + Alter statement = parse(sql); + assertTrue(first(statement).getColumnIdentityActions().isEmpty()); + roundTrip(statement); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("inactiveColumnBodies") + void excludesInheritedIdentityPayloadWhenAnotherBodyWins(String description, + Consumer change) throws JSQLParserException { + AlterExpression action = first(parse("ALTER TABLE t ALTER COLUMN id RESTART")); + change.accept(action); + assertTrue(action.getColumnIdentityActions().isEmpty(), description); + } + + static Stream inactiveColumnBodies() { + return Stream.of( + inactive("different operation", action -> action.setOperation(AlterOperation.DROP)), + inactive("named column", action -> action.setColumnName("other")), + inactive("comment", action -> action.setCommentText("'text'")), + inactive("constraint header", action -> { + action.setConstraintType("CONSTRAINT"); + action.setConstraintSymbol("c"); + }), + inactive("index rename", action -> action.setOldIndex(new Index().withName("old"))), + inactive("drop default", action -> action.addColDropDefault( + new AlterExpression.ColumnDropDefault("other"))), + inactive("set default", action -> action.addColSetDefault( + new AlterExpression.ColumnSetDefault("other", "1"))), + inactive("visibility", action -> action.addColSetVisibility( + new AlterExpression.ColumnSetVisibility("other", true)))); + } + + private static Arguments inactive(String description, Consumer change) { + return Arguments.of(description, change); + } + + @Test + void changedDropOperationUsesItsGeneralRendererPrecedence() { + AlterExpressionDrop action = new AlterExpressionDrop(); + action.setOperation(AlterOperation.ALTER); + ColumnDataType column = new ColumnDataType(false).withColumnName("id"); + column.setIdentityAlterations( + List.of(new IdentityAlteration(IdentityAlteration.Kind.RESTART))); + action.addColDataType(column); + assertEquals(List.of(column), action.getColumnIdentityActions()); + action.addColSetDefault(new AlterExpression.ColumnSetDefault("other", "1")); + action.setConstraintType("CONSTRAINT"); + action.setConstraintSymbol("c"); + action.setOldIndex(new Index().withName("old")); + assertEquals("ALTER id RESTART", action.toString()); + assertEquals(List.of(column), action.getColumnIdentityActions()); + column.setColumnName("renamed"); + assertEquals("ALTER renamed RESTART", action.toString()); + action.setColumnName("other"); + assertTrue(action.getColumnIdentityActions().isEmpty()); + assertEquals("ALTER other", action.toString()); + action.setColumnName(null); + action.setOperation(AlterOperation.DROP); + assertTrue(action.getColumnIdentityActions().isEmpty()); + } + + @ParameterizedTest + @MethodSource("fixedBodies") + void fixedActionRenderersDoNotExposeInactiveColumnIdentityData(AlterExpression action) { + action.setOperation(AlterOperation.ALTER); + ColumnDataType column = new ColumnDataType(false).withColumnName("id"); + column.setIdentityAlterations( + List.of(new IdentityAlteration(IdentityAlteration.Kind.RESTART))); + action.addColDataType(column); + assertTrue(action.getColumnIdentityActions().isEmpty()); + } + + static Stream fixedBodies() { + return Stream.of(new AlterConstraintAttributes(), new AlterExpressionCharset(), + new AlterExpressionOrderBy(), new AlterExpressionPartition(), + new AlterExpressionPrimaryKey(), new AlterExpressionRename(), + new AlterExpressionTableOption(), new AlterForeignDataOptions(), + new RelationAlterAction()); + } + + private static Sequence.Parameter cache(long value) { + return new Sequence.Parameter(Sequence.ParameterType.CACHE).withValue(value); + } + + private static Alter parse(String sql) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static AlterExpression first(Alter statement) { + return statement.getAlterExpressions().get(0); + } + + private static IdentityAlteration identity(Alter statement) { + return first(statement).getColumnIdentityActions().get(0).getIdentityAlterations().get(0); + } + + private static void roundTrip(Alter statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/ColumnRenameActionTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/ColumnRenameActionTest.java new file mode 100644 index 0000000000..d3a91e4010 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/ColumnRenameActionTest.java @@ -0,0 +1,165 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +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.CsvSource; + +class ColumnRenameActionTest { + @ParameterizedTest + @CsvSource({"MYSQL, ALTER TABLE t RENAME COLUMN old_col TO new_col", + "POSTGRESQL, ALTER TABLE t RENAME COLUMN old_col TO new_col", + "POSTGRESQL, ALTER TABLE t RENAME old_col TO new_col", + "POSTGRESQL, ALTER VIEW v RENAME COLUMN old_col TO new_col", + "POSTGRESQL, ALTER VIEW v RENAME old_col TO new_col", + "POSTGRESQL, ALTER MATERIALIZED VIEW v RENAME COLUMN old_col TO new_col"}) + void commonAndLegacyAccessorsEditTheSameNames(Dialect dialect, String sql) + throws JSQLParserException { + Statement statement = parse(sql, dialect); + AlterExpression action = action(statement); + ColumnRenameAction rename = action.getColumnRename(); + assertNotNull(rename); + assertEquals("old_col", rename.getSourceName()); + assertEquals("new_col", rename.getTargetName()); + + String quote = dialect == Dialect.MYSQL ? "`" : "\""; + String sourceName = quote + "old column" + quote; + String targetName = quote + "new column" + quote; + rename.setSourceName(sourceName); + rename.setTargetName(targetName); + if (action instanceof RelationAlterAction) { + RelationAlterAction relation = (RelationAlterAction) action; + assertEquals(sourceName, relation.getColumnName()); + assertEquals(targetName, relation.getNewName()); + } else { + assertEquals(sourceName, action.getColumnOldName()); + assertEquals(targetName, action.getColumnName()); + } + assertRoundTrip(sql.replace("old_col", sourceName) + .replace("new_col", targetName), statement, dialect); + + if (action instanceof RelationAlterAction) { + RelationAlterAction relation = (RelationAlterAction) action; + relation.setColumnName("legacy_source"); + relation.setNewName("legacy_target"); + } else { + action.setColumnOldName("legacy_source"); + action.setColumnName("legacy_target"); + } + assertEquals("legacy_source", rename.getSourceName()); + assertEquals("legacy_target", rename.getTargetName()); + assertSame(rename, action.getColumnRename()); + assertRoundTrip(sql.replace("old_col", "legacy_source") + .replace("new_col", "legacy_target"), statement, dialect); + } + + @ParameterizedTest + @CsvSource({"POSTGRESQL, ALTER TABLE t RENAME TO other_table", + "MYSQL, ALTER TABLE t RENAME INDEX old_index TO new_index", + "MYSQL, ALTER TABLE t RENAME KEY old_key TO new_key", + "POSTGRESQL, ALTER TABLE t RENAME CONSTRAINT old_constraint TO new_constraint", + "POSTGRESQL, ALTER VIEW v RENAME TO other_view", + "POSTGRESQL, ALTER INDEX ix RENAME TO other_index", + "POSTGRESQL, ALTER TABLE t ADD COLUMN c INT", + "POSTGRESQL, ALTER VIEW v SET SCHEMA other_schema"}) + void otherOperationsDoNotExposeAColumnRename(Dialect dialect, String sql) + throws JSQLParserException { + Statement statement = parse(sql, dialect); + assertNull(action(statement).getColumnRename()); + assertRoundTrip(statement.toString(), statement, dialect); + } + + @Test + void switchingTableOperationsKeepsInactiveNamesWithoutExposingThem() + throws JSQLParserException { + Statement statement = parse("ALTER TABLE t RENAME COLUMN old_col TO new_col"); + AlterExpression action = action(statement); + ColumnRenameAction rename = action.getColumnRename(); + action.setOperation(AlterOperation.RENAME_TABLE); + action.setNewTableName("other_table"); + assertNull(action.getColumnRename()); + assertEquals("old_col", action.getColumnOldName()); + assertEquals("new_col", action.getColumnName()); + assertRoundTrip("ALTER TABLE t RENAME TO other_table", statement); + + action.setOperation(AlterOperation.RENAME); + assertSame(rename, action.getColumnRename()); + assertRoundTrip("ALTER TABLE t RENAME COLUMN old_col TO new_col", statement); + } + + @Test + void switchingRelationKindsKeepsInactiveNamesWithoutExposingThem() + throws JSQLParserException { + Statement statement = parse("ALTER VIEW v RENAME COLUMN old_col TO new_col"); + RelationAlterAction action = (RelationAlterAction) action(statement); + ColumnRenameAction rename = action.getColumnRename(); + action.setKind(RelationAlterAction.Kind.SET_SCHEMA); + action.setValue("other_schema"); + assertNull(action.getColumnRename()); + assertEquals("old_col", action.getColumnName()); + assertEquals("new_col", action.getNewName()); + assertRoundTrip("ALTER VIEW v SET SCHEMA other_schema", statement); + + action.setKind(RelationAlterAction.Kind.RENAME_COLUMN); + assertSame(rename, action.getColumnRename()); + assertRoundTrip("ALTER VIEW v RENAME COLUMN old_col TO new_col", statement); + } + + 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 -> parser.withDialect(dialect)); + } + + private static AlterExpression action(Statement statement) { + return statement instanceof Alter + ? ((Alter) statement).getAlterExpressions().get(0) + : ((AlterRelation) statement).getActions().get(0); + } + + private static void assertRoundTrip(String expected, Statement statement) + throws JSQLParserException { + assertRoundTrip(expected, statement, Dialect.POSTGRESQL); + } + + private static void assertRoundTrip(String expected, Statement statement, Dialect dialect) + throws JSQLParserException { + assertEquals(expected, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(expected, output.toString()); + Statement reparsed = parse(output.toString(), dialect); + assertEquals(statement.getClass(), reparsed.getClass()); + assertEquals(action(statement).getClass(), action(reparsed).getClass()); + assertEquals(expected, reparsed.toString()); + ColumnRenameAction rename = action(statement).getColumnRename(); + ColumnRenameAction reparsedRename = action(reparsed).getColumnRename(); + if (rename == null) { + assertNull(reparsedRename); + } else { + assertNotNull(reparsedRename); + assertEquals(rename.getSourceName(), reparsedRename.getSourceName()); + assertEquals(rename.getTargetName(), reparsedRename.getTargetName()); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/DeparseWhitespaceTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/DeparseWhitespaceTest.java new file mode 100644 index 0000000000..6dd6bee377 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/DeparseWhitespaceTest.java @@ -0,0 +1,141 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + +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.statement.Statement; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.junit.jupiter.api.Test; + +/** Renderers separate words with exactly one space and add no trailing space. */ +class DeparseWhitespaceTest { + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t DROP PRIMARY KEY", + "ALTER TABLE t DROP PRIMARY KEY CASCADE", + "ALTER TABLE t DROP PRIMARY KEY, DROP COLUMN c", + "RENAME TABLE t TO t2", + "RENAME TABLE a TO b, c TO d", + "RENAME TABLE IF EXISTS a TO b", + "RENAME a TO b", + "ALTER TABLE t ADD INDEX i (body (10))", + "ALTER TABLE t ADD KEY k (a, b)", + "CREATE TABLE t (a INT, INDEX i (a))", + "ALTER TABLE t ALTER COLUMN c SET INVISIBLE", + "ALTER TABLE t ALTER COLUMN c SET VISIBLE", + "ALTER TABLE t ALTER c SET INVISIBLE", + "ALTER TABLE t ALTER INDEX i INVISIBLE", + "ALTER TABLE t ALTER INDEX i VISIBLE", + "ALTER TABLE t ALTER COLUMN c SET VISIBLE, ALTER INDEX i VISIBLE", + "ALTER TABLE t FORCE", + "ALTER TABLE t FORCE, ALGORITHM = INPLACE", + "CREATE TABLE t (a JSON DEFAULT (JSON_ARRAY()))", + "ALTER TABLE t ADD COLUMN j JSON DEFAULT (JSON_OBJECT())"}) + void rendersSingleSpaces(String sql) throws JSQLParserException { + assertRendersExactly(sql, Dialect.MYSQL); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ENABLE ROW LEVEL SECURITY", + "ALTER TABLE t DISABLE ROW LEVEL SECURITY", + "ALTER TABLE t FORCE ROW LEVEL SECURITY", + "ALTER TABLE t NO FORCE ROW LEVEL SECURITY", + "ALTER TABLE t ENABLE ROW LEVEL SECURITY, FORCE ROW LEVEL SECURITY", + "CREATE INDEX ON t (a)"}) + void rendersSingleSpacesForPostgreSql(String sql) throws JSQLParserException { + assertRendersExactly(sql, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t FORCE", + "ALTER TABLE t MODIFY (c INT)", + "ALTER TABLE t MODIFY COLUMN (c INT NOT NULL)", + "ALTER TABLE t ADD (c INT), ADD d INT", + "ALTER TABLE t ADD CONSTRAINT UNIQUE KEY uk (a)", + "SELECT JSON_ARRAY() FROM t", + "SELECT JSON_OBJECT() FROM t"}) + void rendersSingleSpacesWithoutDialect(String sql) throws JSQLParserException { + assertRendersExactly(sql, null); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT JSON_ARRAY(1, 2) AS a FROM t", + "SELECT JSON_ARRAY(NULL ON NULL) AS a FROM t", + "SELECT JSON_OBJECT(KEY 'a' VALUE 1) AS o FROM t", + "SELECT JSON_OBJECT(ABSENT ON NULL) AS o FROM t"}) + void jsonConstructorsAddNoDoubleOrTrailingSpace(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + String rendered = statement.toString(); + assertFalse(rendered.contains(" "), rendered); + assertEquals(rendered, deparse(statement)); + } + + @Test + void columnVisibilityHasSingleSpaces() { + assertEquals("c SET INVISIBLE", + new AlterExpression.ColumnSetVisibility("c", false).toString()); + assertEquals("c SET VISIBLE", + new AlterExpression.ColumnSetVisibility("c", true).toString()); + } + + @Test + void exchangePartitionHasNoTrailingSpace() { + AlterExpression expression = new AlterExpression() + .withOperation(AlterOperation.EXCHANGE_PARTITION); + expression.setPartitions(List.of("p0")); + expression.setExchangePartitionTableName("t2"); + expression.setExchangePartitionWithValidation(true); + assertEquals("EXCHANGE PARTITION p0 WITH TABLE t2 WITH VALIDATION", + expression.toString()); + } + + @Test + void indexWithoutDeclarationHasNoLeadingSpace() throws JSQLParserException { + CreateIndex createIndex = (CreateIndex) CCJSqlParserUtil.parse("CREATE INDEX ON t (a)", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals("(a)", createIndex.getIndex().toString()); + assertEquals("(a)", new Index().withColumnsNames(List.of("a")).toString()); + assertEquals("INDEX i INVISIBLE", new Index().withIndexKeyword("INDEX").withName("i") + .withIndexSpec(List.of("INVISIBLE")).toString()); + } + + private static void assertRendersExactly(String sql, Dialect dialect) + throws JSQLParserException { + Statement statement = dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + assertEquals(sql, statement.toString()); + assertEquals(sql, deparse(statement)); + } + + private static String deparse(Statement statement) { + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + return deparsed.toString(); + } + + @Test + void indexDeclarationHasNoLeadingSpace() { + assertEquals("i2", new Index().withName("i2").toString()); + assertEquals("KEY k (a)", new Index().withIndexKeyword("KEY").withName("k") + .withColumnsNames(java.util.List.of("a")).toString()); + assertEquals("UNIQUE INDEX u (a)", new Index().withType("UNIQUE").withIndexKeyword("INDEX") + .withName("u").withColumnsNames(java.util.List.of("a")).toString()); + } +} 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/IndexOptionBoundaryTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/IndexOptionBoundaryTest.java new file mode 100644 index 0000000000..f53b06491f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/IndexOptionBoundaryTest.java @@ -0,0 +1,96 @@ +/*- + * #%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.statement.Statement; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.Index; +import java.util.List; +import net.sf.jsqlparser.statement.create.table.TableOption; +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 IndexOptionBoundaryTest { + @ParameterizedTest + @ValueSource(strings = {"UNIQUE", "PRIMARY KEY"}) + void tablespaceBelongsToConstraintOptions(String key) throws JSQLParserException { + Alter alter = (Alter) parse("ALTER TABLE t ADD CONSTRAINT k " + key + + " (id) USING INDEX TABLESPACE pg_default DEFERRABLE", Dialect.POSTGRESQL); + KeyConstraint index = (KeyConstraint) alter.getAlterExpressions().get(0).getConstraint(); + assertEquals("pg_default", index.getTableSpace()); + assertNull(index.getUsing()); + assertTrue(index.getConstraintAttributes().getDeferrable()); + index.setTableSpace("other_space"); + assertEquals("ALTER TABLE t ADD CONSTRAINT k " + key + + " (id) USING INDEX TABLESPACE other_space DEFERRABLE", alter.toString()); + assertRoundTrip(alter, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"SECONDARY_ENGINE_ATTRIBUTE = '{}'", + "SECONDARY_ENGINE_ATTRIBUTE '{\"key\": \"value\"}'", + "SECONDARY_ENGINE_ATTRIBUTE = '{}' VISIBLE COMMENT 'index'"}) + void mysqlAddIndexAttributes(String options) throws JSQLParserException { + Alter alter = (Alter) parse("ALTER TABLE t ADD INDEX ix (id) " + options, Dialect.MYSQL); + assertEquals("ix", alter.getAlterExpressions().get(0).getIndex().getName()); + assertEquals("ALTER TABLE t ADD INDEX ix (id) " + options, alter.toString()); + assertRoundTrip(alter, Dialect.MYSQL); + } + + @Test + void permissiveIndexSuffixRemainsAfterItsStructuredOptions() throws JSQLParserException { + String sql = "CREATE TABLE t (id INT, INDEX ix (id) INCLUDE (id) " + + "WITH (fillfactor = 70) USING INDEX TABLESPACE fast DEFERRABLE)"; + CreateTable statement = (CreateTable) CCJSqlParserUtil.parse(sql); + Index index = statement.getIndexes().get(0); + assertEquals(List.of("id"), index.getIncludeColumns()); + assertEquals(List.of("DEFERRABLE"), index.getTailParameters()); + assertEquals(sql, statement.toString()); + index.setTableSpace("other_space"); + assertEquals(sql.replace("TABLESPACE fast", "TABLESPACE other_space"), + statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(statement.toString(), deparsed.toString()); + assertEquals(statement.toString(), CCJSqlParserUtil.parse(deparsed.toString()).toString()); + } + + @Test + void sharedTableAttributeRemainsMutable() throws JSQLParserException { + Alter alter = + (Alter) parse("ALTER TABLE t SECONDARY_ENGINE_ATTRIBUTE = '{}'", Dialect.MYSQL); + AlterExpressionTableOption action = + (AlterExpressionTableOption) alter.getAlterExpressions().get(0); + TableOption option = action.getStructuredTableOption(); + assertEquals(TableOption.Kind.SECONDARY_ENGINE_ATTRIBUTE, option.getKind()); + option.setValue("'{\"key\":1}'"); + assertEquals("ALTER TABLE t SECONDARY_ENGINE_ATTRIBUTE = '{\"key\":1}'", alter.toString()); + assertRoundTrip(alter, Dialect.MYSQL); + } + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertRoundTrip(Statement statement, Dialect dialect) + throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/InformixConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/InformixConstraintTest.java index cc27254d46..64bf857795 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/InformixConstraintTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/InformixConstraintTest.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.alter; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -26,7 +27,7 @@ import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.Statements; -import net.sf.jsqlparser.statement.create.table.ForeignKeyIndex; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.statement.create.table.NamedConstraint.ConstraintNamePosition; import net.sf.jsqlparser.util.deparser.StatementDeParser; @@ -51,7 +52,7 @@ void preservesNamePlacement(String definition) throws Exception { Alter statement = (Alter) TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.INFORMIX)); NamedConstraint constraint = - (NamedConstraint) statement.getAlterExpressions().get(0).getIndex(); + (NamedConstraint) statement.getAlterExpressions().get(0).getConstraint(); assertEquals(ConstraintNamePosition.AFTER, constraint.getConstraintNamePosition()); assertTrue(constraint.isUseConstraintKeyword()); assertEquals(suffix.isEmpty() ? null : suffix.substring(" CONSTRAINT ".length()), @@ -92,7 +93,7 @@ void retainsDefaultInterpretationOfPrimaryAsConstraintName() throws Exception { String sql = "ALTER TABLE t ADD CONSTRAINT PRIMARY KEY (id)"; Alter statement = (Alter) CCJSqlParserUtil.parse(sql); NamedConstraint constraint = - (NamedConstraint) statement.getAlterExpressions().get(0).getIndex(); + (NamedConstraint) statement.getAlterExpressions().get(0).getConstraint(); assertEquals("PRIMARY", constraint.getName()); assertEquals("KEY", constraint.getType()); assertEquals(ConstraintNamePosition.BEFORE, constraint.getConstraintNamePosition()); @@ -104,7 +105,8 @@ void exposesForeignKeyAndMutableName() throws Exception { Alter statement = (Alter) CCJSqlParserUtil.parse( "ALTER TABLE child ADD CONSTRAINT FOREIGN KEY (id) REFERENCES parent(id) CONSTRAINT fk_child", parser -> parser.withDialect(Dialect.INFORMIX)); - ForeignKeyIndex key = (ForeignKeyIndex) statement.getAlterExpressions().get(0).getIndex(); + ForeignKeyConstraint key = + (ForeignKeyConstraint) statement.getAlterExpressions().get(0).getConstraint(); assertEquals(List.of("id"), key.getColumnsNames()); assertEquals("parent", key.getTable().getName()); assertEquals(List.of("id"), key.getReferencedColumnNames()); @@ -128,7 +130,7 @@ void keepsFollowingAlterActionsAndStatements() throws Exception { @Test void retainsLeadingNamesAndBuilders() throws Exception { - NamedConstraint built = new NamedConstraint().withType("PRIMARY KEY").withName("pk_t") + NamedConstraint built = new KeyConstraint().withType("PRIMARY KEY").withName("pk_t") .withColumnsNames(List.of("id")); assertEquals(ConstraintNamePosition.BEFORE, built.getConstraintNamePosition()); assertEquals("CONSTRAINT pk_t PRIMARY KEY (id)", built.toString()); @@ -139,7 +141,7 @@ void retainsLeadingNamesAndBuilders() throws Exception { (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.INFORMIX)))) { assertEquals(ConstraintNamePosition.BEFORE, - ((NamedConstraint) statement.getAlterExpressions().get(0).getIndex()) + ((NamedConstraint) statement.getAlterExpressions().get(0).getConstraint()) .getConstraintNamePosition()); assertTrue(statement.toString().contains("CONSTRAINT c " + definition)); } @@ -153,7 +155,7 @@ void keepsCheckExpressionVisitorAndForeignTableTraversal() throws Exception { parser -> parser.withDialect(Dialect.INFORMIX)); CheckConstraint check = (CheckConstraint) statement - .getAlterExpressions().get(0).getIndex(); + .getAlterExpressions().get(0).getConstraint(); StringBuilder builder = new StringBuilder(); ExpressionDeParser visitor = new ExpressionDeParser() { diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySQLAlterTablePartitionTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySQLAlterTablePartitionTest.java index 75dbb7aedc..1648373a31 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/MySQLAlterTablePartitionTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySQLAlterTablePartitionTest.java @@ -15,17 +15,24 @@ import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; 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.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; import java.util.stream.Stream; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.TableMaintenanceStatement.Modifier; import net.sf.jsqlparser.statement.create.table.PartitionDefinition; import net.sf.jsqlparser.statement.create.table.TablePartitioning; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; /** MySQL 8.4 {@code ALTER TABLE} partition syntax verified against the MySQL manual. */ @@ -52,7 +59,22 @@ public class MySQLAlterTablePartitionTest { "ALTER TABLE sales OPTIMIZE PARTITION p0", "ALTER TABLE sales REBUILD PARTITION p0", "ALTER TABLE sales REPAIR PARTITION ALL", - "ALTER TABLE sales REMOVE PARTITIONING"); + "ALTER TABLE sales REMOVE PARTITIONING", + "ALTER TABLE clients ADD PARTITION PARTITIONS 6", + "ALTER TABLE clients ADD PARTITION NO_WRITE_TO_BINLOG PARTITIONS 6", + "ALTER TABLE clients ADD PARTITION LOCAL PARTITIONS 6", + "ALTER TABLE sales ADD PARTITION NO_WRITE_TO_BINLOG " + + "(PARTITION p2027 VALUES LESS THAN (2028))", + "ALTER TABLE sales ADD PARTITION LOCAL (PARTITION p2027 VALUES LESS THAN (2028))", + "ALTER TABLE clients COALESCE PARTITION NO_WRITE_TO_BINLOG 2", + "ALTER TABLE clients COALESCE PARTITION LOCAL 2", + "ALTER TABLE sales REORGANIZE PARTITION NO_WRITE_TO_BINLOG p0 INTO " + + "(PARTITION p0a VALUES LESS THAN (50), " + + "PARTITION p0b VALUES LESS THAN (100))", + "ALTER TABLE sales ANALYZE PARTITION NO_WRITE_TO_BINLOG p0, p1", + "ALTER TABLE sales OPTIMIZE PARTITION LOCAL ALL", + "ALTER TABLE sales REBUILD PARTITION NO_WRITE_TO_BINLOG ALL", + "ALTER TABLE sales REPAIR PARTITION LOCAL p0"); private static final List MYSQL84_PARTITIONING_CLAUSES = List.of( "ALTER TABLE sales PARTITION BY HASH (id) PARTITIONS 8", @@ -123,6 +145,90 @@ public void testAllPartitionsAndCoalesceCountAst() throws JSQLParserException { assertEquals(2, coalesce.getCoalescePartitionNumber()); } + @Test + public void testAddPartitionCountAst() throws JSQLParserException { + AlterExpressionPartition expression = + parseExpression("ALTER TABLE clients ADD PARTITION PARTITIONS 6"); + + assertEquals(AlterOperation.ADD_PARTITION, expression.getOperation()); + assertEquals(6, expression.getPartitionCount()); + assertNull(expression.getPartitionDefinitions()); + assertNull(expression.getModifier()); + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE clients ADD PARTITION LOCAL PARTITIONS 6", + parser -> parser.withDialect(Dialect.MYSQL)); + AlterExpressionPartition local = assertInstanceOf(AlterExpressionPartition.class, + alter.getAlterExpressions().get(0)); + assertEquals(6, local.getPartitionCount()); + assertEquals(Modifier.LOCAL, local.getModifier()); + } + + @Test + public void testBinlogModifierAst() throws JSQLParserException { + AlterExpressionPartition coalesce = + parseExpression("ALTER TABLE clients COALESCE PARTITION NO_WRITE_TO_BINLOG 2"); + assertEquals(Modifier.NO_WRITE_TO_BINLOG, coalesce.getModifier()); + assertEquals(2, coalesce.getCoalescePartitionCount()); + + AlterExpressionPartition analyze = + parseExpression("ALTER TABLE sales ANALYZE PARTITION LOCAL ALL"); + assertEquals(Modifier.LOCAL, analyze.getModifier()); + assertTrue(analyze.isAllPartitions()); + + AlterExpressionPartition definitions = parseExpression( + "ALTER TABLE sales ADD PARTITION NO_WRITE_TO_BINLOG " + + "(PARTITION p2027 VALUES LESS THAN (2028))"); + assertEquals(Modifier.NO_WRITE_TO_BINLOG, definitions.getModifier()); + assertNull(definitions.getPartitionCount()); + assertEquals("p2027", definitions.getPartitionDefinitions().get(0).getPartitionName()); + } + + @Test + public void testLocalRemainsAPartitionNameWithoutFollowingNames() + throws JSQLParserException { + AlterExpressionPartition single = + parseExpression("ALTER TABLE sales ANALYZE PARTITION local"); + assertNull(single.getModifier()); + assertEquals(List.of("local"), single.getPartitionNames()); + + AlterExpressionPartition list = + parseExpression("ALTER TABLE sales ANALYZE PARTITION local, p1"); + assertNull(list.getModifier()); + assertEquals(List.of("local", "p1"), list.getPartitionNames()); + + AlterExpressionPartition reorganize = parseExpression( + "ALTER TABLE sales REORGANIZE PARTITION local INTO " + + "(PARTITION p0 VALUES LESS THAN (100))"); + assertNull(reorganize.getModifier()); + assertEquals(List.of("local"), reorganize.getPartitionNames()); + } + + @Test + public void testAddPartitionFormsRequireAdd() { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "ALTER TABLE sales MODIFY PARTITION (PARTITION p3 VALUES LESS THAN (2002))")); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "ALTER TABLE sales ALTER PARTITION (PARTITION p3 VALUES LESS THAN (2002))")); + } + + @Test + public void testLegacyCoalesceAccessorsShareThePartitionCount() { + AlterExpressionPartition expression = new AlterExpressionPartition() + .withOperation(AlterOperation.COALESCE_PARTITION); + assertEquals("COALESCE PARTITION 0", expression.toString()); + + expression.setCoalescePartitionNumber(3); + assertEquals(3, expression.getPartitionCount()); + assertEquals(3, expression.getCoalescePartitionCount()); + assertEquals("COALESCE PARTITION 3", expression.toString()); + + expression.setPartitionCount(4); + assertEquals(4, expression.getCoalescePartitionNumber()); + expression.setCoalescePartitionCount(null); + assertEquals(0, expression.getCoalescePartitionNumber()); + } + @Test public void testExchangePartitionAst() throws JSQLParserException { AlterExpressionPartition expression = parseExpression( @@ -161,6 +267,77 @@ public void testPartitionByAst() throws JSQLParserException { assertEquals(partitioning.getPartitionDefinitions(), expression.getPartitionDefinitions()); } + @ParameterizedTest + @MethodSource("partitionOptionsAfterActions") + public void testPartitionOptionsEndTheActionListWithoutComma(String sql, + List operations) throws JSQLParserException { + // with the MySQL dialect and without a dialect + for (Consumer mode : List.>of( + parser -> parser.withDialect(Dialect.MYSQL), parser -> { + })) { + Alter alter = + assertInstanceOf(Alter.class, assertSqlCanBeParsedAndDeparsed(sql, true, mode)); + + assertEquals(operations, alter.getAlterExpressions().stream() + .map(AlterExpression::getOperation).collect(Collectors.toList())); + } + } + + static Stream partitionOptionsAfterActions() { + return Stream.of( + Arguments.of("ALTER TABLE t1 ADD COLUMN d INT PARTITION BY HASH (id) PARTITIONS 4", + List.of(AlterOperation.ADD, AlterOperation.PARTITION_BY)), + Arguments.of("ALTER TABLE t1 ENGINE = InnoDB REMOVE PARTITIONING", + List.of(AlterOperation.ENGINE, AlterOperation.REMOVE_PARTITIONING)), + Arguments.of("ALTER TABLE t1 ENGINE = InnoDB PARTITION BY KEY (id) PARTITIONS 2", + List.of(AlterOperation.ENGINE, AlterOperation.PARTITION_BY)), + Arguments.of("ALTER TABLE t1 ALGORITHM = INPLACE, ADD COLUMN x INT NOT NULL " + + "DEFAULT 0 PARTITION BY KEY (id) PARTITIONS 2", + List.of(AlterOperation.ALGORITHM, AlterOperation.ADD, + AlterOperation.PARTITION_BY)), + Arguments.of("ALTER TABLE t1 MODIFY COLUMN d BIGINT REMOVE PARTITIONING", + List.of(AlterOperation.MODIFY, AlterOperation.REMOVE_PARTITIONING)), + Arguments.of( + "ALTER TABLE t1 CHANGE COLUMN d e INT AFTER id PARTITION BY RANGE (id) " + + "(PARTITION p0 VALUES LESS THAN (10), " + + "PARTITION p1 VALUES LESS THAN MAXVALUE)", + List.of(AlterOperation.CHANGE, AlterOperation.PARTITION_BY)), + Arguments.of("ALTER TABLE t1 ADD INDEX i (a) PARTITION BY HASH (id)", + List.of(AlterOperation.ADD, AlterOperation.PARTITION_BY)), + Arguments.of("ALTER TABLE t1 DROP COLUMN c REMOVE PARTITIONING", + List.of(AlterOperation.DROP, AlterOperation.REMOVE_PARTITIONING))); + } + + @Test + public void testColumnDefinitionStopsBeforePartitionOptions() throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t1 ADD COLUMN d INT PARTITION BY HASH (id) PARTITIONS 4", + parser -> parser.withDialect(Dialect.MYSQL)); + + AlterExpression add = alter.getAlterExpressions().get(0); + assertEquals("d INT", add.getColDataTypeList().get(0).toString()); + assertTrue(add.getColDataTypeList().get(0).getColumnOptions().isEmpty()); + AlterExpressionPartition partitionBy = + assertInstanceOf(AlterExpressionPartition.class, + alter.getAlterExpressions().get(1)); + assertEquals(TablePartitioning.Type.HASH, partitionBy.getPartitioning().getType()); + assertEquals(4L, partitionBy.getPartitioning().getPartitions()); + } + + @Test + public void testPartitionOptionsAreNotPrecededByComma() throws JSQLParserException { + // MySQL rejects a comma before PARTITION BY; the rendering drops it + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t1 ADD COLUMN d INT, PARTITION BY HASH (id)"); + assertEquals("ALTER TABLE t1 ADD COLUMN d INT PARTITION BY HASH (id)", alter.toString()); + assertSqlCanBeParsedAndDeparsed(alter.toString(), true); + assertEquals(" ", Alter.separatorBefore(alter.getAlterExpressions().get(1))); + assertEquals(", ", Alter.separatorBefore(alter.getAlterExpressions().get(0))); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "ALTER TABLE t1 PARTITION BY HASH (id) REMOVE PARTITIONING", + parser -> parser.withDialect(Dialect.MYSQL))); + } + @Test public void testProgrammaticConstruction() { AlterExpressionPartition expression = new AlterExpressionPartition() @@ -172,6 +349,12 @@ public void testProgrammaticConstruction() { assertEquals("EXCHANGE PARTITION p0 WITH TABLE archive.sales_2024 WITHOUT VALIDATION", expression.toString()); + + AlterExpressionPartition add = new AlterExpressionPartition() + .withOperation(AlterOperation.ADD_PARTITION) + .withModifier(Modifier.NO_WRITE_TO_BINLOG) + .withPartitionCount(4); + assertEquals("ADD PARTITION NO_WRITE_TO_BINLOG PARTITIONS 4", add.toString()); } private static AlterExpressionPartition parseExpression(String sql) 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..f6171a26c2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java @@ -0,0 +1,233 @@ +/*- + * #%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); + + 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 + 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterConstraintTest.java index 88997b343f..4946a3aa20 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterConstraintTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterConstraintTest.java @@ -9,6 +9,8 @@ */ package net.sf.jsqlparser.statement.alter; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -21,7 +23,6 @@ import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.create.table.CheckConstraint; import net.sf.jsqlparser.statement.create.table.CreateTable; -import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.util.deparser.ExpressionDeParser; import net.sf.jsqlparser.util.deparser.SelectDeParser; @@ -50,9 +51,9 @@ void createAndAlterExposeTheSameConstraint(String definition) throws JSQLParserE CreateTable create = (CreateTable) CCJSqlParserUtil.parse( "CREATE TABLE t (id INT, " + definition + ")", p -> p.withDialect(Dialect.MYSQL)); Alter alter = parse("ALTER TABLE t ADD " + definition + ", ADD COLUMN other INT"); - Index actual = alter.getAlterExpressions().get(0).getIndex(); - assertEquals(create.getIndexes().get(0).getClass(), actual.getClass()); - assertEquals(create.getIndexes().get(0).toString(), actual.toString()); + NamedConstraint actual = alter.getAlterExpressions().get(0).getConstraint(); + assertEquals(create.getTableConstraints().get(0).getClass(), actual.getClass()); + assertEquals(create.getTableConstraints().get(0).toString(), actual.toString()); assertEquals(2, alter.getAlterExpressions().size()); assertRoundTrip(alter); } @@ -60,11 +61,11 @@ void createAndAlterExposeTheSameConstraint(String definition) throws JSQLParserE @Test void constraintAndIndexNamesCanBeEditedIndependently() throws JSQLParserException { Alter alter = parse("ALTER TABLE t ADD CONSTRAINT uq UNIQUE KEY idx (id)"); - NamedConstraint unique = assertInstanceOf(NamedConstraint.class, - alter.getAlterExpressions().get(0).getIndex()); + KeyConstraint unique = assertInstanceOf(KeyConstraint.class, + alter.getAlterExpressions().get(0).getConstraint()); assertEquals("uq", unique.getName()); assertEquals("idx", unique.getIndexName()); - assertEquals(Index.Kind.UNIQUE, unique.getKind()); + assertEquals(ConstraintKind.UNIQUE, unique.getKind()); unique.setName("new_constraint"); unique.setIndexName("new_index"); assertEquals("ALTER TABLE t ADD CONSTRAINT new_constraint UNIQUE KEY new_index (id)", @@ -76,7 +77,7 @@ void constraintAndIndexNamesCanBeEditedIndependently() throws JSQLParserExceptio void unnamedCheckRetainsKeywordEnforcementAndExpressionVisitor() throws JSQLParserException { Alter alter = parse("ALTER TABLE t ADD CONSTRAINT CHECK (id > 0) NOT ENFORCED"); CheckConstraint check = assertInstanceOf(CheckConstraint.class, - alter.getAlterExpressions().get(0).getIndex()); + alter.getAlterExpressions().get(0).getConstraint()); assertTrue(check.isUseConstraintKeyword()); assertEquals(Boolean.FALSE, check.getEnforced()); StringBuilder buffer = new StringBuilder(); diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterOrderingOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterOrderingOptionsTest.java new file mode 100644 index 0000000000..507a6db0e9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterOrderingOptionsTest.java @@ -0,0 +1,98 @@ +/*- + * #%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 net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +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 MySqlAlterOrderingOptionsTest { + @ParameterizedTest + @ValueSource(strings = {"ORDER BY id DESC, label ASC", "ORDER BY id, label", + "ENGINE = InnoDB, ROW_FORMAT = DYNAMIC, STATS_PERSISTENT = DEFAULT", + "STATS_AUTO_RECALC = 1, STATS_SAMPLE_PAGES = 16", + "ENGINE = InnoDB, ORDER BY id DESC, label ASC", "ROW_FORMAT COMPACT, ORDER BY id DESC"}) + void actionAndOrderListBoundariesRemainSeparate(String actions) throws JSQLParserException { + Alter alter = parse("ALTER TABLE t " + actions); + assertEquals("ALTER TABLE t " + actions, alter.toString()); + alter.getAlterExpressions().forEach( + action -> assertNotEquals(AlterOperation.UNSPECIFIC, action.getOperation())); + assertRoundTrip(alter); + assertEquals(2, CCJSqlParserUtil + .parseStatements(alter + "; SELECT 1", p -> p.withDialect(Dialect.MYSQL)).size()); + } + + @Test + void orderElementsAreMutableAndVisited() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t ORDER BY id DESC, label ASC"); + AlterExpressionOrderBy order = (AlterExpressionOrderBy) alter.getAlterExpressions().get(0); + assertEquals(2, order.getOrderByElements().size()); + order.getOrderByElements().get(0).setExpression(new Column("new_id")); + order.getOrderByElements().get(0).setAsc(true); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(order, visited::add, ignored -> { + }); + assertEquals(2, visited.size()); + assertEquals("ALTER TABLE t ORDER BY new_id ASC, label ASC", alter.toString()); + assertRoundTrip(alter); + } + + @Test + void rowFormatAndStatisticsShareCreateOptions() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t ROW_FORMAT = DYNAMIC, STATS_PERSISTENT = DEFAULT"); + TableOption rowFormat = ((AlterExpressionTableOption) alter.getAlterExpressions().get(0)) + .getStructuredTableOption(); + TableOption statistics = ((AlterExpressionTableOption) alter.getAlterExpressions().get(1)) + .getStructuredTableOption(); + assertEquals(TableOption.Kind.ROW_FORMAT, rowFormat.getKind()); + assertEquals(TableOption.Kind.STATS_PERSISTENT, statistics.getKind()); + rowFormat.setValue("COMPACT"); + statistics.setValue("1"); + assertEquals("ALTER TABLE t ROW_FORMAT = COMPACT, STATS_PERSISTENT = 1", alter.toString()); + CreateTable create = + (CreateTable) CCJSqlParserUtil.parse("CREATE TABLE t (id INT) ROW_FORMAT = COMPACT", + p -> p.withDialect(Dialect.MYSQL)); + assertEquals(rowFormat.toString(), + create.getTableOption(TableOption.Kind.ROW_FORMAT).orElseThrow().toString()); + assertRoundTrip(alter); + } + + @Test + void invalidOptionsAndOrderExpressionsFail() { + for (String actions : new String[] {"ROW_FORMAT = invalid", "STATS_PERSISTENT = 2", + "ORDER BY id + 1", "ORDER BY id, ENGINE = InnoDB", + "ORDER BY id, ADD COLUMN x INT"}) { + assertThrows(JSQLParserException.class, () -> parse("ALTER TABLE t " + actions)); + } + } + + 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterValidationModifierTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterValidationModifierTest.java new file mode 100644 index 0000000000..a3f021617c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterValidationModifierTest.java @@ -0,0 +1,360 @@ +/*- + * #%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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +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.Arrays; +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.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.alter.AlterExpressionPartition.ExchangeValidationMode; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL's WITH | WITHOUT VALIDATION modifier in the ALTER TABLE action list. */ +class MySqlAlterValidationModifierTest { + /** The modifier is read with these dialects or without one. */ + private static final Dialect[] MYSQL = {Dialect.MYSQL, Dialect.MARIADB, null}; + private static final Dialect[] OTHERS = + {Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER, Dialect.H2}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + /** Parses, prints through toString and the deparser, and reparses. */ + private static Alter roundTrip(String sql, Dialect dialect, AlterOperation... operations) + throws Exception { + Alter alter = assertInstanceOf(Alter.class, parse(sql, dialect), sql); + assertEquals(Arrays.asList(operations), operations(alter), dialect + ": " + sql); + assertEquals(sql, alter.toString()); + Node node = alter.getASTNode(); + assertNotNull(node, sql); + assertEquals(sql, sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + StringBuilder output = new StringBuilder(); + alter.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + Alter reparsed = assertInstanceOf(Alter.class, parse(alter.toString(), dialect)); + assertEquals(operations(alter), operations(reparsed)); + assertEquals(sql, reparsed.toString()); + return alter; + } + + private static List operations(Alter alter) { + List operations = new ArrayList<>(); + for (AlterExpression action : alter.getAlterExpressions()) { + operations.add(action.getOperation()); + } + return operations; + } + + private static ExchangeValidationMode mode(Alter alter, int index) { + AlterExpressionTableOption action = assertInstanceOf(AlterExpressionTableOption.class, + alter.getAlterExpressions().get(index)); + assertNull(action.getOptionalSpecifier()); + assertNull(action.getStructuredTableOption()); + return action.getValidationMode(); + } + + @Test + void modifierBeforeExchangePartitionIsItsOwnAction() throws Exception { + for (Dialect dialect : MYSQL) { + Alter alter = roundTrip( + "ALTER TABLE t1 WITHOUT VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2", + dialect, AlterOperation.VALIDATION, AlterOperation.EXCHANGE_PARTITION); + assertEquals(ExchangeValidationMode.WITHOUT, mode(alter, 0)); + AlterExpressionPartition exchange = assertInstanceOf(AlterExpressionPartition.class, + alter.getAlterExpressions().get(1)); + assertEquals(Arrays.asList("p0"), exchange.getPartitions()); + assertEquals("t2", exchange.getExchangeTable().getName()); + assertNull(exchange.getExchangeValidationMode()); + assertEquals(Arrays.asList("t1", "t2"), + new TablesNamesFinder<>().getTableList((Statement) alter)); + + // the mode after WITH TABLE still belongs to the exchange + alter = roundTrip("ALTER TABLE t1 WITH VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2" + + " WITHOUT VALIDATION", dialect, AlterOperation.VALIDATION, + AlterOperation.EXCHANGE_PARTITION); + assertEquals(ExchangeValidationMode.WITH, mode(alter, 0)); + assertEquals(ExchangeValidationMode.WITHOUT, + ((AlterExpressionPartition) alter.getAlterExpressions().get(1)) + .getExchangeValidationMode()); + + alter = roundTrip("ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2 WITH VALIDATION", + dialect, AlterOperation.EXCHANGE_PARTITION); + assertEquals(ExchangeValidationMode.WITH, + ((AlterExpressionPartition) alter.getAlterExpressions().get(0)) + .getExchangeValidationMode()); + + roundTrip("ALTER TABLE t1 WITHOUT VALIDATION, WITH VALIDATION," + + " EXCHANGE PARTITION p0 WITH TABLE t2 WITH VALIDATION", dialect, + AlterOperation.VALIDATION, AlterOperation.VALIDATION, + AlterOperation.EXCHANGE_PARTITION); + roundTrip("ALTER TABLE t1 ALGORITHM = INPLACE, WITHOUT VALIDATION, LOCK = NONE," + + " EXCHANGE PARTITION p0 WITH TABLE t2", dialect, AlterOperation.ALGORITHM, + AlterOperation.VALIDATION, AlterOperation.LOCK, + AlterOperation.EXCHANGE_PARTITION); + } + } + + @Test + void modifierAloneAndAmongModifiers() throws Exception { + for (Dialect dialect : MYSQL) { + assertEquals(ExchangeValidationMode.WITH, + mode(roundTrip("ALTER TABLE t1 WITH VALIDATION", dialect, + AlterOperation.VALIDATION), 0)); + assertEquals(ExchangeValidationMode.WITHOUT, + mode(roundTrip("ALTER TABLE t1 WITHOUT VALIDATION", dialect, + AlterOperation.VALIDATION), 0)); + Alter alter = roundTrip("ALTER TABLE t1 WITH VALIDATION, WITHOUT VALIDATION", dialect, + AlterOperation.VALIDATION, AlterOperation.VALIDATION); + assertEquals(ExchangeValidationMode.WITHOUT, mode(alter, 1)); + roundTrip("ALTER TABLE t1 WITH VALIDATION, ALGORITHM = COPY, LOCK = SHARED", dialect, + AlterOperation.VALIDATION, AlterOperation.ALGORITHM, AlterOperation.LOCK); + roundTrip("ALTER TABLE t1 ALGORITHM = COPY, WITH VALIDATION", dialect, + AlterOperation.ALGORITHM, AlterOperation.VALIDATION); + } + Alter alter = assertInstanceOf(Alter.class, + parse("alter table t1 with validation, add column c int", Dialect.MYSQL)); + assertEquals("ALTER TABLE t1 WITH VALIDATION, ADD COLUMN c int", alter.toString()); + } + + @Test + void modifierBetweenAlterListItems() throws Exception { + for (Dialect dialect : MYSQL) { + Alter alter = roundTrip("ALTER TABLE t1 WITH VALIDATION, ADD COLUMN c INT", dialect, + AlterOperation.VALIDATION, AlterOperation.ADD); + assertEquals(ExchangeValidationMode.WITH, mode(alter, 0)); + assertEquals("c", + alter.getAlterExpressions().get(1).getColDataTypeList().get(0).getColumnName()); + alter = roundTrip("ALTER TABLE t1 ADD COLUMN c INT, WITHOUT VALIDATION", dialect, + AlterOperation.ADD, AlterOperation.VALIDATION); + assertEquals(ExchangeValidationMode.WITHOUT, mode(alter, 1)); + roundTrip("ALTER TABLE t1 WITH VALIDATION, ADD COLUMN c INT, WITHOUT VALIDATION," + + " ADD COLUMN d INT, WITH VALIDATION", dialect, AlterOperation.VALIDATION, + AlterOperation.ADD, AlterOperation.VALIDATION, AlterOperation.ADD, + AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 ADD COLUMN c INT, ALGORITHM = COPY, WITH VALIDATION," + + " LOCK = SHARED", dialect, AlterOperation.ADD, AlterOperation.ALGORITHM, + AlterOperation.VALIDATION, AlterOperation.LOCK); + roundTrip("ALTER TABLE t1 ADD COLUMN g INT AS (a + 1) STORED, WITHOUT VALIDATION", + dialect, AlterOperation.ADD, AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 MODIFY COLUMN a BIGINT, WITH VALIDATION", dialect, + AlterOperation.MODIFY, AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 ENGINE = InnoDB, WITH VALIDATION", dialect, + AlterOperation.ENGINE, AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 WITH VALIDATION, ENGINE = InnoDB", dialect, + AlterOperation.VALIDATION, AlterOperation.ENGINE); + roundTrip("ALTER TABLE t1 WITH VALIDATION, FORCE", dialect, AlterOperation.VALIDATION, + AlterOperation.FORCE); + roundTrip("ALTER TABLE t1 RENAME TO t4, WITH VALIDATION", dialect, + AlterOperation.RENAME_TABLE, AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 ADD INDEX i1 (a), WITHOUT VALIDATION", dialect, + AlterOperation.ADD, AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 DROP COLUMN a, WITH VALIDATION", dialect, + AlterOperation.DROP, AlterOperation.VALIDATION); + roundTrip("ALTER TABLE t1 CONVERT TO CHARACTER SET utf8mb4, WITH VALIDATION", dialect, + AlterOperation.CONVERT, AlterOperation.VALIDATION); + } + } + + @Test + void modifierBeforePartitionOptionsAndStandaloneCommands() throws Exception { + for (Dialect dialect : MYSQL) { + roundTrip("ALTER TABLE t1 WITH VALIDATION PARTITION BY HASH (id) PARTITIONS 2", + dialect, AlterOperation.VALIDATION, AlterOperation.PARTITION_BY); + roundTrip("ALTER TABLE t1 ADD COLUMN c INT, WITH VALIDATION" + + " PARTITION BY HASH (id) PARTITIONS 2", dialect, AlterOperation.ADD, + AlterOperation.VALIDATION, AlterOperation.PARTITION_BY); + roundTrip("ALTER TABLE t1 WITHOUT VALIDATION REMOVE PARTITIONING", dialect, + AlterOperation.VALIDATION, AlterOperation.REMOVE_PARTITIONING); + roundTrip("ALTER TABLE t1 WITH VALIDATION, TRUNCATE PARTITION p0", dialect, + AlterOperation.VALIDATION, AlterOperation.TRUNCATE_PARTITION); + roundTrip("ALTER TABLE t1 WITH VALIDATION, ANALYZE PARTITION p0", dialect, + AlterOperation.VALIDATION, AlterOperation.ANALYZE_PARTITION); + roundTrip("ALTER TABLE t1 WITHOUT VALIDATION, DROP PARTITION p1", dialect, + AlterOperation.VALIDATION, AlterOperation.DROP_PARTITION); + roundTrip("ALTER TABLE t1 WITH VALIDATION," + + " ADD PARTITION (PARTITION p2 VALUES LESS THAN (200))", dialect, + AlterOperation.VALIDATION, AlterOperation.ADD_PARTITION); + roundTrip("ALTER TABLE t1 WITH VALIDATION, REORGANIZE PARTITION p1 INTO" + + " (PARTITION p1 VALUES LESS THAN (200)," + + " PARTITION p2 VALUES LESS THAN MAXVALUE)", dialect, + AlterOperation.VALIDATION, AlterOperation.REORGANIZE_PARTITION); + roundTrip("ALTER TABLE t1 WITH VALIDATION, DISCARD TABLESPACE", dialect, + AlterOperation.VALIDATION, AlterOperation.DISCARD_TABLESPACE); + roundTrip("ALTER TABLE t1 WITHOUT VALIDATION, IMPORT TABLESPACE", dialect, + AlterOperation.VALIDATION, AlterOperation.IMPORT_TABLESPACE); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2, WITHOUT VALIDATION", + "ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2 WITHOUT VALIDATION, WITH VALIDATION", + "ALTER TABLE t1 WITH VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2," + + " WITHOUT VALIDATION", + "ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2 WITHOUT VALIDATION WITH VALIDATION", + "ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2 VALIDATION", + "ALTER TABLE t1 WITHOUT VALIDATION EXCHANGE PARTITION p0 WITH TABLE t2", + "ALTER TABLE t1 TRUNCATE PARTITION p0, WITH VALIDATION", + "ALTER TABLE t1 DROP PARTITION p1, WITH VALIDATION", + "ALTER TABLE t1 COALESCE PARTITION 1, WITH VALIDATION", + "ALTER TABLE t1 ADD PARTITION (PARTITION p2 VALUES LESS THAN (200)), WITH VALIDATION", + "ALTER TABLE t1 REORGANIZE PARTITION p1 INTO (PARTITION p1 VALUES LESS THAN (200)," + + " PARTITION p2 VALUES LESS THAN MAXVALUE), WITH VALIDATION", + "ALTER TABLE t1 DISCARD TABLESPACE, WITH VALIDATION", + "ALTER TABLE t1 IMPORT TABLESPACE, WITHOUT VALIDATION", + "ALTER TABLE t1 PARTITION BY HASH (id) PARTITIONS 2, WITH VALIDATION", + "ALTER TABLE t1 PARTITION BY HASH (id) PARTITIONS 2 WITH VALIDATION", + "ALTER TABLE t1 REMOVE PARTITIONING, WITH VALIDATION", + "ALTER TABLE t1 REMOVE PARTITIONING WITH VALIDATION", + "ALTER TABLE t1 WITH VALIDATION WITHOUT VALIDATION", + "ALTER TABLE t1 WITH VALIDATION ADD COLUMN c INT", + "ALTER TABLE t1 ADD COLUMN c INT WITHOUT VALIDATION", + "ALTER TABLE t1 ADD COLUMN c INT, WITH VALIDATION,", + "ALTER TABLE t1 WITH VALIDATION,", + "ALTER TABLE t1 WITH", + "ALTER TABLE t1 WITHOUT", + "ALTER TABLE t1 WITH NO VALIDATION", + "ALTER TABLE t1 WITH VALIDATION = 1", + "ALTER TABLE t1 ORDER BY a, WITH VALIDATION"}) + void mySqlRejectsWhatTheServerRejects(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + } + + @Test + void mariaDbAndNoDialectKeepWhatTheyAccepted() throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.MARIADB, null}) { + // accepted before, now with a typed modifier + Alter alter = roundTrip( + "ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2, WITHOUT VALIDATION", + dialect, AlterOperation.EXCHANGE_PARTITION, AlterOperation.VALIDATION); + assertEquals(ExchangeValidationMode.WITHOUT, mode(alter, 1)); + // not the whole item of the list: raw text as before + for (String sql : new String[] {"ALTER TABLE t1 WITH VALIDATION foo", + "ALTER TABLE t1 WITH NOCHECK ADD CONSTRAINT c CHECK (a > 1)", + "ALTER TABLE t1 WITH"}) { + alter = assertInstanceOf(Alter.class, parse(sql, dialect)); + assertEquals(Arrays.asList(AlterOperation.UNSPECIFIC), operations(alter), sql); + } + } + } + + @Test + void otherDialectsKeepTheirReading() throws Exception { + for (Dialect dialect : OTHERS) { + Alter alter = assertInstanceOf(Alter.class, parse( + "ALTER TABLE t1 WITHOUT VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2", + dialect)); + assertEquals(Arrays.asList(AlterOperation.UNSPECIFIC), operations(alter)); + assertEquals("WITHOUT VALIDATION , EXCHANGE PARTITION p0 WITH TABLE t2", + alter.getAlterExpressions().get(0).getOptionalSpecifier()); + alter = assertInstanceOf(Alter.class, parse("ALTER TABLE t1 WITH VALIDATION", dialect)); + assertEquals(Arrays.asList(AlterOperation.UNSPECIFIC), operations(alter)); + alter = assertInstanceOf(Alter.class, parse( + "ALTER TABLE t1 EXCHANGE PARTITION p0 WITH TABLE t2 WITHOUT VALIDATION", + dialect)); + assertEquals(Arrays.asList(AlterOperation.EXCHANGE_PARTITION), operations(alter)); + assertEquals(ExchangeValidationMode.WITHOUT, + ((AlterExpressionPartition) alter.getAlterExpressions().get(0)) + .getExchangeValidationMode()); + } + } + + @Test + void statementBoundaries() throws Exception { + for (Dialect dialect : MYSQL) { + String script = + "ALTER TABLE t1 WITHOUT VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2;" + + " ALTER TABLE t1 ADD COLUMN c INT, WITH VALIDATION; SELECT 1;" + + " ALTER TABLE t1 WITH VALIDATION"; + Statements statements = dialect == null ? CCJSqlParserUtil.parseStatements(script) + : CCJSqlParserUtil.parseStatements(script, p -> p.withDialect(dialect)); + assertEquals(4, statements.size()); + assertEquals( + Arrays.asList(AlterOperation.VALIDATION, AlterOperation.EXCHANGE_PARTITION), + operations((Alter) statements.get(0))); + assertEquals(Arrays.asList(AlterOperation.ADD, AlterOperation.VALIDATION), + operations((Alter) statements.get(1))); + assertEquals("SELECT 1", statements.get(2).toString()); + assertEquals(Arrays.asList(AlterOperation.VALIDATION), + operations((Alter) statements.get(3))); + assertEquals(Arrays.asList(AlterOperation.VALIDATION), operations( + (Alter) parse("ALTER TABLE t1 WITH VALIDATION;", dialect))); + } + } + + @Test + void modelBuildsAndReplacesTheModifier() { + AlterExpressionTableOption action = + new AlterExpressionTableOption().withValidationMode(ExchangeValidationMode.WITHOUT); + assertEquals(AlterOperation.VALIDATION, action.getOperation()); + assertEquals("WITHOUT VALIDATION", action.toString()); + action.setValidationMode(ExchangeValidationMode.WITH); + assertEquals("WITH VALIDATION", action.toString()); + assertThrows(NullPointerException.class, () -> action.setValidationMode(null)); + assertEquals(AlterOperation.VALIDATION, AlterOperation.from("validation")); + + Alter alter = new Alter(); + alter.setTable(new net.sf.jsqlparser.schema.Table("t1")); + alter.addAlterExpression(action); + assertEquals("ALTER TABLE t1 WITH VALIDATION", alter.toString()); + + // another table option replaces the modifier, and the modifier replaces it + action.setStructuredTableOption( + new TableOption(TableOption.Kind.ENGINE, "ENGINE", "InnoDB", true)); + assertNull(action.getValidationMode()); + assertEquals(AlterOperation.ENGINE, action.getOperation()); + action.setValidationMode(ExchangeValidationMode.WITHOUT); + assertNull(action.getStructuredTableOption()); + assertEquals("WITHOUT VALIDATION", action.toString()); + assertNull(new AlterExpressionTableOption().getValidationMode()); + } + + @Test + void visitorsAndValidation() throws Exception { + String sql = "ALTER TABLE t1 WITHOUT VALIDATION, EXCHANGE PARTITION p0 WITH TABLE t2"; + List visited = new ArrayList<>(); + parse(sql, Dialect.MYSQL).accept(new StatementVisitorAdapter() { + @Override + public Void visit(Alter alter, S context) { + visited.add(alter.getTable().getName()); + return null; + } + }, null); + assertEquals(Arrays.asList("t1"), visited); + assertTrue(Validation.validate(Arrays.asList(MySqlVersion.V8_0), sql).isEmpty()); + assertTrue(Validation.validate(Arrays.asList(new FeaturesAllowed(Feature.alterTable)), sql) + .isEmpty()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlColumnPositionTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlColumnPositionTest.java new file mode 100644 index 0000000000..b9408cb654 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlColumnPositionTest.java @@ -0,0 +1,171 @@ +/*- + * #%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.*; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +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 MySqlColumnPositionTest { + private static final Dialect[] DIALECTS = {null, Dialect.MYSQL}; + + @ParameterizedTest + @ValueSource(strings = { + "ALTER TABLE t1 ADD COLUMN c1 INT NOT NULL DEFAULT 0 COMMENT 'x' AFTER id", + "ALTER TABLE t1 ADD c2 INT FIRST", + "ALTER TABLE t1 ADD COLUMN c5 INT, ADD COLUMN c6 INT AFTER c5, ADD INDEX idx_c5 (c5), " + + "ALGORITHM = INPLACE, LOCK = NONE", + "ALTER TABLE t1 MODIFY COLUMN name VARCHAR (200) CHARACTER SET utf8mb4 " + + "COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT 'n' AFTER id", + "ALTER TABLE t1 CHANGE name name VARCHAR (10) FIRST", + "ALTER TABLE t1 ADD COLUMN geo POINT NOT NULL SRID 4326 AFTER id", + "ALTER TABLE t1 MODIFY c1 INT FIRST, MODIFY c2 INT AFTER `c1`", + "ALTER TABLE t1 CHANGE COLUMN a b INT UNIQUE KEY AFTER c"}) + void roundTripsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed(sql, true, dialect(dialect)); + for (AlterExpression action : alter.getAlterExpressions()) { + if (action.getColDataTypeList() == null) { + continue; + } + for (AlterExpression.ColumnDataType column : action.getColDataTypeList()) { + assertTrue(column.getColumnOptions().stream() + .noneMatch(option -> option.getKind() == ColumnOption.Kind.OTHER), + sql); + } + } + } + } + + @Test + void exposesPositionSeparatelyFromOptions() throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + Alter alter = parse("ALTER TABLE t1 ADD COLUMN c1 INT NOT NULL AFTER `id`, " + + "MODIFY c2 INT FIRST, MODIFY c3 INT", dialect); + AlterExpression.ColumnDataType after = column(alter, 0); + assertEquals(ColumnPosition.Kind.AFTER, after.getPosition().getKind()); + assertEquals("`id`", after.getPosition().getColumnName()); + assertEquals(List.of(ColumnOption.Kind.NULLABILITY), after.getColumnOptions().stream() + .map(ColumnOption::getKind).collect(Collectors.toList())); + assertEquals(List.of("NOT", "NULL", "AFTER", "`id`"), after.getColumnSpecs()); + + AlterExpression.ColumnDataType first = column(alter, 1); + assertEquals(ColumnPosition.first(), first.getPosition()); + assertNull(first.getPosition().getColumnName()); + assertTrue(first.getColumnOptions().isEmpty()); + assertEquals(List.of("FIRST"), first.getColumnSpecs()); + assertNull(column(alter, 2).getPosition()); + assertEquals(List.of(), column(alter, 2).getColumnSpecs()); + } + } + + @Test + void editsRenderAfterOptionsInBothRenderers() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t1 MODIFY c1 INT NOT NULL FIRST", Dialect.MYSQL); + AlterExpression.ColumnDataType column = column(alter, 0); + List snapshot = column.getColumnSpecs(); + assertThrows(UnsupportedOperationException.class, () -> snapshot.add("AFTER")); + + column.setPosition(ColumnPosition.after("c0")); + column.addColumnSpecs("INVISIBLE"); + assertEquals(List.of("NOT", "NULL", "FIRST"), snapshot); + assertEquals(List.of("NOT", "NULL", "INVISIBLE", "AFTER", "c0"), column.getColumnSpecs()); + assertEquals("ALTER TABLE t1 MODIFY c1 INT NOT NULL INVISIBLE AFTER c0", alter.toString()); + assertRoundTrip(alter); + + column.setPosition(null); + assertEquals("ALTER TABLE t1 MODIFY c1 INT NOT NULL INVISIBLE", alter.toString()); + assertRoundTrip(alter); + } + + @Test + void replacingSpecificationsAlsoReplacesThePosition() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t1 ADD COLUMN c1 INT NOT NULL AFTER id", Dialect.MYSQL); + AlterExpression.ColumnDataType column = column(alter, 0); + column.setColumnSpecs(column.getColumnSpecs()); + assertNull(column.getPosition()); + assertEquals(1, column.getColumnOptions().size()); + assertEquals(ColumnOption.Kind.OTHER, column.getColumnOptions().get(0).getKind()); + assertEquals("ALTER TABLE t1 ADD COLUMN c1 INT NOT NULL AFTER id", alter.toString()); + + column.withColumnSpecs(null).withPosition(ColumnPosition.first()); + assertEquals(List.of("FIRST"), column.getColumnSpecs()); + assertEquals("ALTER TABLE t1 ADD COLUMN c1 INT FIRST", alter.toString()); + assertRoundTrip(alter); + } + + @Test + void buildsPositionedDefinitions() throws JSQLParserException { + AlterExpression action = new AlterExpression(); + action.setOperation(AlterOperation.ADD); + action.hasColumn(true); + action.addColDataType(new AlterExpression.ColumnDataType("c1", false, + new ColDataType("INT"), null).withPosition(ColumnPosition.after("id"))); + Alter alter = new Alter().withTable(new Table("t1")).addAlterExpressions(action); + assertEquals("ALTER TABLE t1 ADD COLUMN c1 INT AFTER id", alter.toString()); + assertRoundTrip(alter); + + assertEquals(ColumnPosition.after("id"), ColumnPosition.after("id")); + assertEquals(ColumnPosition.after("id").hashCode(), + ColumnPosition.after("id").hashCode()); + assertNotEquals(ColumnPosition.after("id"), ColumnPosition.first()); + assertThrows(NullPointerException.class, () -> ColumnPosition.after(null)); + assertThrows(UnsupportedOperationException.class, + () -> ColumnPosition.after("id").getTokens().set(0, "BEFORE")); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t1 ADD COLUMN c1 INT AFTER id NOT NULL", + "ALTER TABLE t1 MODIFY c1 INT FIRST AFTER id"}) + void requiresThePositionToEndTheDefinition(String sql) { + for (Dialect dialect : DIALECTS) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + private static AlterExpression.ColumnDataType column(Alter alter, int action) { + return alter.getAlterExpressions().get(action).getColDataTypeList().get(0); + } + + private static Consumer dialect(Dialect dialect) { + return parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }; + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, dialect(dialect)); + } + + private static void assertRoundTrip(Alter alter) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + alter.accept(new StatementDeParser(sql), null); + assertEquals(alter.toString(), sql.toString()); + for (Dialect dialect : DIALECTS) { + assertEquals(sql.toString(), parse(sql.toString(), dialect).toString()); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlCommonTableOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlCommonTableOptionsTest.java new file mode 100644 index 0000000000..3caea9295c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlCommonTableOptionsTest.java @@ -0,0 +1,163 @@ +/*- + * #%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 java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlCommonTableOptionsTest { + @ParameterizedTest + @ValueSource(strings = {"ENGINE='InnoDB'", "ENGINE=\"InnoDB\"", "AVG_ROW_LENGTH=100", + "MAX_ROWS=18446744073709551615", "MIN_ROWS 0", "KEY_BLOCK_SIZE=8", + "TABLESPACE=innodb_file_per_table", "TABLESPACE `space name` STORAGE DISK", + "TABLESPACE ts STORAGE MEMORY", "UNION=(db.m1,db.m2)", "UNION=()"}) + void sharesTableOptions(String sql) throws JSQLParserException { + CreateTable create = (CreateTable) CCJSqlParserUtil.parse("CREATE TABLE t(id INT) " + sql); + Alter alter = parse(sql + ", ADD COLUMN extra INT"); + AlterExpressionTableOption action = + assertInstanceOf(AlterExpressionTableOption.class, + alter.getAlterExpressions().get(0)); + TableOption option = action.getStructuredTableOption(); + assertNotEquals(TableOption.Kind.OTHER, option.getKind()); + assertEquals(create.getTableOptions().get(0).toString(), option.toString()); + assertEquals(2, alter.getAlterExpressions().size()); + roundTrip(create); + roundTrip(alter); + } + + @Test + void optionPairsKeepActionAndStatementBoundaries() throws JSQLParserException { + List options = List.of("ENGINE='InnoDB'", "ROW_FORMAT=DYNAMIC", + "STATS_PERSISTENT=1", "COMMENT='x,y'", "AVG_ROW_LENGTH=100", + "TABLESPACE=innodb_file_per_table", "UNION=(m1,m2)"); + for (String left : options) { + for (String right : options) { + if (left.equals(right)) { + continue; + } + for (String separator : new String[] {" ", ", "}) { + String sql = "ALTER TABLE t " + left + separator + right + + ", ADD COLUMN z INT, ALGORITHM=DEFAULT, LOCK=DEFAULT"; + Alter alter = (Alter) CCJSqlParserUtil.parse(sql); + assertEquals(5, alter.getAlterExpressions().size(), sql); + assertEquals(AlterOperation.ADD, + alter.getAlterExpressions().get(2).getOperation()); + assertEquals(AlterOperation.ALGORITHM, + alter.getAlterExpressions().get(3).getOperation()); + assertEquals(AlterOperation.LOCK, + alter.getAlterExpressions().get(4).getOperation()); + roundTrip(alter); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"DEFAULT CHARACTER SET", "CHARACTER SET", "CHAR SET", "CHARSET", + "DEFAULT CHARSET", "DEFAULT CHAR SET"}) + void quotedCharsetAndCollationKeepLegacyAccess(String name) throws JSQLParserException { + Alter alter = parse(name + "='utf8mb4' COLLATE='utf8mb4_bin' ROW_FORMAT=DYNAMIC"); + AlterExpression action = alter.getAlterExpressions().get(0); + assertEquals(AlterOperation.CONVERT, action.getOperation()); + assertEquals("'utf8mb4'", action.getCharacterSet()); + assertEquals("'utf8mb4_bin'", action.getCollation()); + assertEquals(2, alter.getAlterExpressions().size()); + action.setCharacterSet("utf8mb4"); + action.setCollation("utf8mb4_general_ci"); + roundTrip(alter); + } + + @Test + void structuredAndLegacyMutationsUseTheSameValues() throws JSQLParserException { + Alter alter = parse("ENGINE=InnoDB KEY_BLOCK_SIZE=8 COMMENT='old'"); + AlterExpressionTableOption engine = + (AlterExpressionTableOption) alter.getAlterExpressions().get(0); + assertEquals(AlterOperation.ENGINE, engine.getOperation()); + engine.setEngineOption("MyISAM"); + assertEquals("MyISAM", engine.getStructuredTableOption().getValue()); + engine.getStructuredTableOption().setValue("InnoDB"); + assertEquals("InnoDB", engine.getEngineOption()); + AlterExpressionTableOption block = + (AlterExpressionTableOption) alter.getAlterExpressions().get(1); + assertEquals(AlterOperation.KEY_BLOCK_SIZE, block.getOperation()); + block.setKeyBlockSize(4); + assertEquals("4", block.getStructuredTableOption().getValue()); + block.getStructuredTableOption().setValue("16"); + assertEquals(16, block.getKeyBlockSize()); + AlterExpressionTableOption comment = + (AlterExpressionTableOption) alter.getAlterExpressions().get(2); + comment.setCommentText("'new'"); + assertEquals("'new'", comment.getStructuredTableOption().getValue()); + comment.getStructuredTableOption().setUseEquals(false); + assertEquals(AlterOperation.COMMENT, comment.getOperation()); + roundTrip(alter); + } + + @Test + void visitsAndChangesUnionSources() throws JSQLParserException { + Alter alter = parse("UNION=(m1,m2)"); + TableOption option = ((AlterExpressionTableOption) alter.getAlterExpressions().get(0)) + .getStructuredTableOption(); + assertEquals(Set.of("t", "m1", "m2"), new TablesNamesFinder().getTables(alter)); + option.getUnionTables().set(1, new Table("m3")); + assertEquals(Set.of("t", "m1", "m3"), new TablesNamesFinder().getTables(alter)); + assertTrue(alter.toString().contains("UNION = (m1, m3)")); + roundTrip(alter); + } + + @Test + void tablespaceStorageHasStructuredAndLegacyProjections() throws JSQLParserException { + CreateTable create = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t(id INT) TABLESPACE=ts STORAGE DISK"); + TableOption option = create.getTableOptions().get(0); + assertEquals("ts", option.getValue()); + assertEquals(ColumnOption.Storage.DISK, option.getTablespaceStorage()); + option.setValue("new_ts"); + option.setTablespaceStorage(ColumnOption.Storage.MEMORY); + assertEquals(List.of("TABLESPACE", "=", "new_ts", "STORAGE", "MEMORY"), option.getTokens()); + roundTrip(create); + option.setKind(TableOption.Kind.ENGINE); + assertNull(option.getTablespaceStorage()); + } + + @ParameterizedTest + @ValueSource(strings = {"ENGINE=", "AVG_ROW_LENGTH=-1", "MAX_ROWS='1'", "TABLESPACE=", + "TABLESPACE ts STORAGE UNKNOWN", "ENGINE=InnoDB ADD COLUMN z INT", + "ENGINE=InnoDB LOCK=NONE", "ALGORITHM=DEFAULT ROW_FORMAT=DYNAMIC"}) + void rejectsIncompleteOptionsAndMissingActionCommas(String option) { + assertThrows(JSQLParserException.class, () -> parse(option)); + } + + private static Alter parse(String sql) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse("ALTER TABLE t " + sql); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), CCJSqlParserUtil.parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlConvertToCharacterSetTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlConvertToCharacterSetTest.java new file mode 100644 index 0000000000..3ea802139f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlConvertToCharacterSetTest.java @@ -0,0 +1,96 @@ +/*- + * #%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.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +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 MySqlConvertToCharacterSetTest { + private static final Consumer MYSQL = p -> p.withDialect(Dialect.MYSQL); + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t CONVERT TO CHARSET utf8mb4", + "ALTER TABLE t CONVERT TO CHARSET utf8mb4 COLLATE utf8mb4_bin", + "ALTER TABLE t CONVERT TO CHARACTER SET DEFAULT", + "ALTER TABLE t CONVERT TO CHARACTER SET DEFAULT COLLATE utf8mb4_bin", + "ALTER TABLE t CONVERT TO CHARACTER SET binary", + "ALTER TABLE t CONVERT TO CHARACTER SET binary COLLATE binary", + "ALTER TABLE t CONVERT TO CHARACTER SET 'utf8mb4'", + "ALTER TABLE t CONVERT TO CHARACTER SET utf8mb4 COLLATE 'utf8mb4_bin'", + "ALTER TABLE t CONVERT TO CHARACTER SET `utf8mb4` COLLATE `utf8mb4_bin`", + "ALTER TABLE t CONVERT TO CHARSET utf8mb4, ADD COLUMN c INT", + "ALTER TABLE t DEFAULT CHARSET utf8mb4", + "ALTER TABLE t CHARSET = utf8mb4 COLLATE = utf8mb4_bin"}) + void keepsEveryCharacterSetForm(String sql) throws JSQLParserException { + for (Statement statement : new Statement[] {CCJSqlParserUtil.parse(sql), + CCJSqlParserUtil.parse(sql, MYSQL)}) { + assertEquals(sql, statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + } + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", MYSQL).size()); + } + + @Test + void exposesCharsetSpellingNameAndCollation() throws JSQLParserException { + AlterExpression action = + parseAction("ALTER TABLE t CONVERT TO CHARSET utf8mb4 COLLATE 'utf8mb4_bin'"); + assertEquals(AlterOperation.CONVERT, action.getOperation()); + assertEquals(AlterExpression.ConvertType.CONVERT_TO, action.getConvertType()); + assertTrue(action.isUseCharsetKeyword()); + assertEquals("utf8mb4", action.getCharacterSet()); + assertEquals("'utf8mb4_bin'", action.getCollation()); + + action.setUseCharsetKeyword(false); + action.setCollation("utf8mb4_0900_ai_ci"); + assertEquals("CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci", + action.toString()); + + AlterExpression standard = parseAction("ALTER TABLE t CONVERT TO CHARACTER SET DEFAULT"); + assertFalse(standard.isUseCharsetKeyword()); + assertEquals("DEFAULT", standard.getCharacterSet()); + assertNull(standard.getCollation()); + } + + @Test + void keepsCharsetSpellingOfTableOptions() throws JSQLParserException { + AlterExpression action = parseAction("ALTER TABLE t DEFAULT CHARSET = utf8mb4"); + assertEquals(AlterExpression.ConvertType.DEFAULT_CHARACTER_SET, action.getConvertType()); + assertTrue(action.isUseCharsetKeyword()); + assertFalse( + parseAction("ALTER TABLE t DEFAULT CHARACTER SET = utf8mb4").isUseCharsetKeyword()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t CONVERT TO CHARSET", + "ALTER TABLE t CONVERT TO utf8mb4", + "ALTER TABLE t CONVERT TO CHARSET = utf8mb4", + "ALTER TABLE t CONVERT TO CHARACTER SET utf8mb4 COLLATE"}) + void rejectsIncompleteForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + private static AlterExpression parseAction(String sql) throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse(sql, MYSQL); + assertEquals(1, alter.getAlterExpressions().size()); + return alter.getAlterExpressions().get(0); + } +} 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..fa35bdf227 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlDropConstraintTest.java @@ -0,0 +1,138 @@ +/*- + * #%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()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP FOREIGN KEY fk1", "DROP FOREIGN KEY `fk name`", + "DROP CHECK c1", "DROP FOREIGN KEY fk1, DROP CHECK c1"}) + void acceptsNamedDropsWithoutDialect(String actions) throws JSQLParserException { + String sql = "ALTER TABLE t " + actions; + Alter alter = (Alter) CCJSqlParserUtil.parse(sql); + + assertEquals(sql, alter.toString()); + for (AlterExpression drop : alter.getAlterExpressions()) { + assertNotNull(drop.getConstraintName()); + assertNull(drop.getDropColumns()); + } + assertEquals(sql, CCJSqlParserUtil.parse(alter.toString()).toString()); + } + + @Test + void mariaDbAcceptsNamedForeignKeyButNotCheckDrops() throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t DROP FOREIGN KEY fk1", + p -> p.withDialect(Dialect.MARIADB)); + assertEquals(AlterOperation.DROP_FOREIGN_KEY, + alter.getAlterExpressions().get(0).getOperation()); + assertEquals("fk1", alter.getAlterExpressions().get(0).getConstraintName()); + + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("ALTER TABLE t DROP CHECK c1", p -> p.withDialect(Dialect.MARIADB))); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP FOREIGN KEY fk1", "DROP CHECK c1"}) + void otherDialectsKeepRejectingMySqlNamedDrops(String action) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("ALTER TABLE t " + action, p -> p.withDialect(dialect)), + dialect.name()); + } + } + + @Test + void parenthesizedForeignKeyDropKeepsColumnsWithoutDialect() throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t DROP FOREIGN KEY (a, b)"); + AlterExpression drop = alter.getAlterExpressions().get(0); + + assertEquals(AlterOperation.DROP_FOREIGN_KEY, drop.getOperation()); + assertEquals(List.of("a", "b"), drop.getDropColumns()); + assertNull(drop.getConstraintName()); + } + + 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlAlterConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlAlterConstraintTest.java index 70e48887fb..d70098e00b 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlAlterConstraintTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlAlterConstraintTest.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.alter; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertInstanceOf; @@ -21,7 +22,6 @@ import net.sf.jsqlparser.statement.create.table.CheckConstraint; import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; -import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.util.TablesNamesFinder; import net.sf.jsqlparser.util.deparser.StatementDeParser; import org.junit.jupiter.api.Test; @@ -58,15 +58,15 @@ void constraintAttributesAndPredicatesRemainStructured() throws JSQLParserExcept Alter alter = parse("ALTER TABLE t ADD CONSTRAINT c CHECK (id > 0) NOT VALID, " + "ADD CONSTRAINT u UNIQUE (id) DEFERRABLE INITIALLY DEFERRED"); CheckConstraint check = assertInstanceOf(CheckConstraint.class, - alter.getAlterExpressions().get(0).getIndex()); + alter.getAlterExpressions().get(0).getConstraint()); assertTrue(check.getConstraintAttributes().isNotValid()); - Index unique = alter.getAlterExpressions().get(1).getIndex(); + NamedConstraint unique = alter.getAlterExpressions().get(1).getConstraint(); assertEquals(ConstraintAttributes.Initially.DEFERRED, unique.getConstraintAttributes().getInitially()); assertEquals(Boolean.TRUE, unique.getConstraintAttributes().getDeferrable()); ExcludeConstraint exclude = assertInstanceOf(ExcludeConstraint.class, parse("ALTER TABLE t ADD EXCLUDE USING gist ((id + 1) WITH =) WHERE (id > 0)") - .getAlterExpressions().get(0).getIndex()); + .getAlterExpressions().get(0).getConstraint()); assertEquals("id > 0", exclude.getExpression().toString()); } diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlCheckNoInheritTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlCheckNoInheritTest.java new file mode 100644 index 0000000000..1c16ba825e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlCheckNoInheritTest.java @@ -0,0 +1,88 @@ +/*- + * #%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 net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.table.CheckConstraint; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +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 PostgreSqlCheckNoInheritTest { + @ParameterizedTest + @ValueSource(strings = { + "ALTER TABLE t ADD CONSTRAINT ck CHECK (id > 0) NO INHERIT", + "ALTER TABLE t ADD CHECK (id > 0) NO INHERIT NOT VALID", + "ALTER TABLE t ADD CONSTRAINT ck CHECK (id > 0) NO INHERIT NOT VALID, ADD COLUMN extra INT", + "CREATE TABLE t (id INT, CONSTRAINT ck CHECK (id > 0) NO INHERIT)", + "CREATE TABLE t (id INT CHECK (id > 0) NO INHERIT)", + "CREATE TABLE t (id INT CONSTRAINT ck CHECK (id > 0) NO INHERIT)"}) + void roundTripsSharedCreateAndAlterCheck(String sql) throws JSQLParserException { + Statement statement = parse(sql); + assertEquals(sql, statement.toString()); + roundTrip(statement); + } + + @Test + void exposesIndependentInheritanceAndValidationFlags() throws JSQLParserException { + Alter alter = (Alter) parse( + "ALTER TABLE t ADD CONSTRAINT ck CHECK (id > 0) NO INHERIT NOT VALID"); + CheckConstraint constraint = + (CheckConstraint) alter.getAlterExpressions().get(0).getConstraint(); + assertTrue(constraint.isNoInherit()); + assertTrue(constraint.getConstraintAttributes().isNotValid()); + constraint.setNoInherit(false); + constraint.setExpression(CCJSqlParserUtil.parseExpression("id > 10")); + assertEquals("ALTER TABLE t ADD CONSTRAINT ck CHECK (id > 10) NOT VALID", alter.toString()); + roundTrip(alter); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(alter.getAlterExpressions().get(0), visited::add, table -> { + }); + assertEquals(List.of(constraint.getExpression()), visited); + alter.getAlterExpressions().get(0).setConstraint(new CheckConstraint().withName("new_ck") + .withExpression(CCJSqlParserUtil.parseExpression("id > 20")).withNoInherit(true)); + assertEquals("ALTER TABLE t ADD CONSTRAINT new_ck CHECK (id > 20) NO INHERIT", + alter.toString()); + roundTrip(alter); + } + + @Test + void preservesExistingCheckOptions() throws JSQLParserException { + CreateTable table = (CreateTable) parse("CREATE TABLE t (id INT, CHECK (id > 0))"); + assertFalse(((CheckConstraint) table.getTableConstraints().get(0)).isNoInherit()); + for (String suffix : new String[] {"", " ENFORCED", " NOT ENFORCED"}) { + String sql = "CREATE TABLE t (id INT, CHECK (id > 0)" + suffix + ")"; + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + assertEquals(sql, + CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)).toString()); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlColumnReplacementTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlColumnReplacementTest.java new file mode 100644 index 0000000000..efee371014 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlColumnReplacementTest.java @@ -0,0 +1,123 @@ +/*- + * #%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 net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.deparser.AlterDeParser; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +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 PostgreSqlColumnReplacementTest { + @ParameterizedTest + @ValueSource(strings = {"BIGINT", "BIGINT USING id::bigint", + "VARCHAR(20) COLLATE \"C\" USING id::text"}) + void sharesTypeChangePrefixes(String type) throws JSQLParserException { + for (String column : new String[] {"COLUMN ", ""}) { + for (String prefix : new String[] {"TYPE ", "SET DATA TYPE "}) { + String sql = "ALTER TABLE t ALTER " + column + "id " + prefix + type; + Alter table = (Alter) parse(sql); + AlterExpression.ColumnDataType definition = table.getAlterExpressions().get(0) + .getColDataTypeList().get(0); + assertTrue(definition.isWithType()); + assertEquals(prefix.startsWith("SET"), definition.isUseSetData()); + assertNotEquals("SET", definition.getColDataType().getDataType()); + if (type.contains("USING")) { + assertNotNull(definition.getUsingExpression()); + } + roundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + definition.setUseSetData(!definition.isUseSetData()); + roundTrip(table); + } + } + for (String prefix : new String[] {"TYPE ", "SET DATA TYPE "}) { + roundTrip(parse("ALTER TYPE row_type ALTER ATTRIBUTE id " + prefix + "BIGINT")); + } + } + + @ParameterizedTest + @ValueSource(strings = {"id + 2", "COALESCE(id, 0) * 2", "CASE WHEN id > 0 THEN id ELSE 0 END"}) + void generatedExpressionIsAnActionAndNotADataType(String expression) + throws JSQLParserException { + for (String column : new String[] {"COLUMN ", ""}) { + String sql = "ALTER TABLE t ALTER " + column + "g SET EXPRESSION AS (" + expression + + "), ADD COLUMN extra INT"; + for (Statement statement : List.of(parse(sql), CCJSqlParserUtil.parse(sql))) { + Alter table = (Alter) statement; + RelationAlterAction action = assertInstanceOf(RelationAlterAction.class, + table.getAlterExpressions().get(0)); + assertEquals(RelationAlterAction.ColumnAction.SET_EXPRESSION, + action.getColumnAction()); + assertEquals("g", action.getColumnName()); + assertNull(action.getColDataTypeList()); + assertNotNull(action.getGenerationExpression()); + List expressions = new ArrayList<>(); + TableDefinitionTraversal.visit(action, expressions::add, ignored -> { + }); + assertEquals(List.of(action.getGenerationExpression()), expressions); + action.setGenerationExpression(new LongValue(42)); + assertTrue(table.toString().contains("SET EXPRESSION AS (42)")); + roundTrip(table); + } + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + } + + @Test + void replacementUsesTheExpressionDeparser() throws JSQLParserException { + Alter table = (Alter) parse("ALTER TABLE t ALTER COLUMN g SET EXPRESSION AS (1)"); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(2); + } + }; + expressions.setBuilder(output); + new AlterDeParser(output, expressions).deParse(table); + assertEquals("ALTER TABLE t ALTER COLUMN g SET EXPRESSION AS (2)", output.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ALTER COLUMN id SET DATA TYPE", + "ALTER TABLE t ALTER COLUMN id SET DATA BIGINT", + "ALTER TABLE t ALTER COLUMN g SET EXPRESSION AS ()", + "ALTER TABLE t ALTER COLUMN g SET EXPRESSION AS id + 2", + "ALTER TABLE t ALTER COLUMN g SET EXPRESSION AS (id+2) STORED", + "ALTER VIEW v ALTER COLUMN g SET EXPRESSION AS (id+2)", + "ALTER INDEX ix ALTER COLUMN 1 SET EXPRESSION AS (id+2)"}) + void rejectsIncompleteOrWrongContextActions(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlColumnStatisticsTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlColumnStatisticsTest.java new file mode 100644 index 0000000000..eadbfa3322 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlColumnStatisticsTest.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.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +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 PostgreSqlColumnStatisticsTest { + @ParameterizedTest + @ValueSource(strings = {"SET STATISTICS DEFAULT", "SET STATISTICS -1", "SET STATISTICS 10000", + "SET (n_distinct = -0.5)", "SET (n_distinct = -1, n_distinct_inherited = 20)", + "RESET (n_distinct)", "RESET (n_distinct, n_distinct_inherited)"}) + void tablesAndMaterializedViewsShareColumnActions(String action) throws JSQLParserException { + for (String object : List.of("TABLE t", "MATERIALIZED VIEW mv")) { + String sql = "ALTER " + object + " ALTER COLUMN id " + action; + Statement statement = parse(sql); + assertRoundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + } + + @Test + void defaultTargetsAndAttributeValuesAreMutable() throws JSQLParserException { + AlterRelation index = + (AlterRelation) parse("ALTER INDEX ix ALTER COLUMN 1 SET STATISTICS DEFAULT"); + RelationAlterAction action = index.getActions().get(0); + assertTrue(action.isStatisticsDefault()); + assertNull(action.getStatistics()); + action.setStatistics(200L); + assertFalse(action.isStatisticsDefault()); + assertEquals("ALTER INDEX ix ALTER COLUMN 1 SET STATISTICS 200", index.toString()); + assertRoundTrip(index); + action.setStatisticsDefault(true); + assertRoundTrip(index); + Alter table = (Alter) parse("ALTER TABLE t ALTER COLUMN id SET (n_distinct=10)"); + action = (RelationAlterAction) table.getAlterExpressions().get(0); + action.getOptions().get(0).setValue(new LongValue(20)); + List visited = new ArrayList<>(); + action.visitExpressions(visited::add); + assertEquals(List.of(new LongValue(20)), visited); + assertEquals("ALTER TABLE t ALTER COLUMN id SET (n_distinct = 20)", table.toString()); + assertRoundTrip(table); + } + + @Test + void invalidTargetsAndCrossObjectActionsFail() { + for (String sql : new String[] {"ALTER VIEW v ALTER COLUMN id SET STATISTICS DEFAULT", + "ALTER INDEX ix ALTER COLUMN 1 SET (n_distinct=10)", + "ALTER TABLE t ALTER COLUMN id SET (n_distinct)", + "ALTER TABLE t ALTER COLUMN id SET STATISTICS 10001"}) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintAttributesChangeTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintAttributesChangeTest.java new file mode 100644 index 0000000000..c9c1d1e1aa --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintAttributesChangeTest.java @@ -0,0 +1,98 @@ +/*- + * #%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.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlConstraintAttributesChangeTest { + @ParameterizedTest + @ValueSource(strings = {"DEFERRABLE", "NOT DEFERRABLE", "INITIALLY DEFERRED", + "INITIALLY IMMEDIATE", "DEFERRABLE INITIALLY DEFERRED", + "INITIALLY DEFERRED DEFERRABLE", "ENFORCED", "NOT ENFORCED", + "DEFERRABLE INITIALLY DEFERRED NOT ENFORCED", + "NOT ENFORCED INITIALLY IMMEDIATE NOT DEFERRABLE"}) + void sharesCreateAddAndAlterAttributes(String attributes) throws JSQLParserException { + String sql = "ALTER TABLE t ALTER CONSTRAINT fk " + attributes + ", ADD COLUMN z INT"; + Alter table = (Alter) parse(sql); + AlterConstraintAttributes change = assertInstanceOf(AlterConstraintAttributes.class, + table.getAlterExpressions().get(0)); + assertEquals(AlterOperation.ALTER, change.getOperation()); + assertEquals("CONSTRAINT", change.getConstraintType()); + assertEquals("fk", change.getConstraintSymbol()); + assertEquals("fk", change.getConstraintName()); + String declaration = "CONSTRAINT fk FOREIGN KEY(id) REFERENCES p(id) " + attributes; + CreateTable create = (CreateTable) parse("CREATE TABLE t(id INT, " + + declaration + ")"); + Alter add = (Alter) parse("ALTER TABLE t ADD " + declaration); + assertEquals(create.getTableConstraints().get(0).getConstraintAttributes().toString(), + change.getAttributes().toString()); + assertEquals( + add.getAlterExpressions().get(0).getConstraint().getConstraintAttributes() + .toString(), + change.getAttributes().toString()); + assertEquals(2, table.getAlterExpressions().size()); + roundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + + @Test + void legacyAndStructuredMutationsStayConsistent() throws JSQLParserException { + Alter table = (Alter) parse("ALTER TABLE t ALTER CONSTRAINT fk ENFORCED"); + AlterConstraintAttributes action = + (AlterConstraintAttributes) table.getAlterExpressions().get(0); + action.setConstraintName("\"new fk\""); + assertEquals("\"new fk\"", action.getConstraintSymbol()); + action.setEnforced(false); + assertEquals(Boolean.FALSE, action.getAttributes().getEnforced()); + action.getAttributes().setDeferrable(true); + action.getAttributes().setInitially(ConstraintAttributes.Initially.DEFERRED); + assertEquals( + "ALTER TABLE t ALTER CONSTRAINT \"new fk\" DEFERRABLE INITIALLY DEFERRED NOT ENFORCED", + table.toString()); + action.getAttributes().setEnforced(true); + assertTrue(action.isEnforced()); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(table)); + roundTrip(table); + } + + @ParameterizedTest + @ValueSource(strings = {"NOT VALID", "DEFERRABLE NOT VALID", "INITIALLY UNKNOWN", + "DEFERRABLE NOT DEFERRABLE", "ENFORCED NOT ENFORCED", + "INITIALLY DEFERRED INITIALLY IMMEDIATE", "DEFERRABLE,"}) + void rejectsWrongOrDuplicateAlterAttributes(String attributes) { + assertThrows(JSQLParserException.class, + () -> parse("ALTER TABLE t ALTER CONSTRAINT fk " + attributes)); + } + + private static net.sf.jsqlparser.statement.Statement parse(String sql) + throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect( + net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect.POSTGRESQL)); + } + + private static void roundTrip(Alter table) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + table.accept(new StatementDeParser(output)); + assertEquals(table.toString(), output.toString()); + assertEquals(output.toString(), parse(output.toString()).toString()); + } +} 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..d606d107d0 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintUsingIndexTest.java @@ -0,0 +1,112 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.ConstraintKind; +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.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).getConstraint()); + assertNull(alter.getAlterExpressions().get(0).getIndex()); + assertEquals(body.endsWith("\"Index Name\"") ? "\"Index Name\"" : "i", + constraint.getExistingIndexName()); + 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).getConstraint(); + assertEquals(Boolean.TRUE, constraint.getConstraintAttributes().getDeferrable()); + constraint.setName("pk"); + constraint.setType("PRIMARY KEY"); + constraint.setExistingIndexName("other_index"); + assertEquals(ConstraintKind.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) + .withConstraint( + 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlExclusionOperatorTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlExclusionOperatorTest.java new file mode 100644 index 0000000000..91490616b2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlExclusionOperatorTest.java @@ -0,0 +1,94 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.KeyElement; +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.statement.Statement; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; +import net.sf.jsqlparser.statement.create.table.ExclusionOperator; +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 PostgreSqlExclusionOperatorTest { + @ParameterizedTest + @ValueSource(strings = {"OPERATOR(pg_catalog.&&)", "OPERATOR(&&)", "OPERATOR(\"My.Schema\".&&)", + "OPERATOR(pg_catalog.=)", "OPERATOR(pg_catalog.-|-)", "OPERATOR(<<=)", "&&"}) + void supportsSharedCreateAndAlterGrammar(String operator) throws JSQLParserException { + for (String sql : new String[] { + "CREATE TABLE t (c INT4RANGE, CONSTRAINT ex EXCLUDE USING gist (c WITH " + operator + + "))", + "ALTER TABLE t ADD CONSTRAINT ex EXCLUDE USING gist (c WITH " + operator + ")"}) { + Statement statement = parse(sql); + assertEquals(sql, statement.toString()); + assertEquals(operator, + constraint(statement).getColumns().get(0).getExclusionOperator()); + roundTrip(statement); + } + } + + @Test + void exposesEditableSchemaAndSymbolAndSupportsLegacySetter() throws JSQLParserException { + Statement statement = parse( + "ALTER TABLE t ADD CONSTRAINT ex EXCLUDE USING gist (c WITH OPERATOR(pg_catalog.&&))"); + KeyElement key = constraint(statement).getColumns().get(0); + ExclusionOperator operator = key.getExclusionOperatorReference(); + assertEquals("pg_catalog", operator.getSchemaName()); + assertEquals("&&", operator.getName()); + assertTrue(operator.isUseOperatorKeyword()); + operator.setSchemaName("\"My.Schema\""); + operator.setName("="); + assertEquals("OPERATOR(\"My.Schema\".=)", key.getExclusionOperator()); + roundTrip(statement); + key.setExclusionOperator("&&"); + assertEquals("&&", key.getExclusionOperator()); + assertNull(key.getExclusionOperatorReference().getSchemaName()); + roundTrip(statement); + key.setExclusionOperator(null); + assertNull(key.getExclusionOperatorReference()); + key.setExclusionOperatorReference(new ExclusionOperator().withSchemaName("pg_catalog") + .withName("&&").withUseOperatorKeyword(true)); + roundTrip(statement); + } + + @Test + void preservesElementOptionsAndMultipleElementsAndDefaultSyntax() throws JSQLParserException { + roundTrip(parse( + "ALTER TABLE t ADD EXCLUDE USING gist (c WITH OPERATOR(pg_catalog.&&), d WITH =) WHERE (c IS NOT NULL) DEFERRABLE INITIALLY DEFERRED" + .replace("\n", ""))); + String legacy = "CREATE TABLE t (c INT4RANGE, EXCLUDE USING gist (c WITH &&))"; + assertEquals(legacy, CCJSqlParserUtil.parse(legacy).toString()); + roundTrip(parse( + "ALTER TABLE t ADD EXCLUDE USING gist ((c) WITH OPERATOR(pg_catalog.&&)), ADD COLUMN extra INT")); + } + + private static ExcludeConstraint constraint(Statement statement) { + return (ExcludeConstraint) (statement instanceof Alter + ? ((Alter) statement).getAlterExpressions().get(0).getConstraint() + : ((CreateTable) statement).getTableConstraints().get(0)); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlNotNullConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlNotNullConstraintTest.java new file mode 100644 index 0000000000..070190bdef --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlNotNullConstraintTest.java @@ -0,0 +1,150 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.ConstraintKind; +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.expression.Expression; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.NotNullConstraint; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.AlterDeParser; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationContext; +import net.sf.jsqlparser.util.validation.metadata.DatabaseMetaDataValidation; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; +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 PostgreSqlNotNullConstraintTest { + @ParameterizedTest + @ValueSource(strings = {"NOT NULL id", "CONSTRAINT nn NOT NULL id", + "CONSTRAINT nn NOT NULL id NO INHERIT", "CONSTRAINT \"NN Name\" NOT NULL \"ID\""}) + void roundTripsCreateAndAlter(String body) throws JSQLParserException { + for (String sql : new String[] {"CREATE TABLE t (id INT, " + body + ")", + "ALTER TABLE t ADD " + body + " NOT VALID"}) { + Statement statement = parse(sql); + assertEquals(sql, statement.toString()); + NotNullConstraint constraint = constraint(statement); + assertEquals(ConstraintKind.NOT_NULL, constraint.getKind()); + assertNotNull(constraint.getColumn()); + roundTrip(statement); + } + } + + @Test + void supportsEditingAndConstruction() throws JSQLParserException { + Alter alter = + (Alter) parse("ALTER TABLE t ADD CONSTRAINT nn NOT NULL id NO INHERIT NOT VALID"); + NotNullConstraint constraint = constraint(alter); + assertTrue(constraint.isNoInherit()); + assertTrue(constraint.getConstraintAttributes().isNotValid()); + constraint.setName("new_nn"); + constraint.getColumn().setColumnName("other_id"); + constraint.setNoInherit(false); + assertEquals("ALTER TABLE t ADD CONSTRAINT new_nn NOT NULL other_id NOT VALID", + alter.toString()); + roundTrip(alter); + ConstraintAttributes attributes = new ConstraintAttributes(); + attributes.setNotValid(true); + alter.getAlterExpressions().get(0).setConstraint(new NotNullConstraint().withName("nn") + .withColumn(new Column("id")).withNoInherit(true) + .withConstraintAttributes(attributes)); + assertEquals("ALTER TABLE t ADD CONSTRAINT nn NOT NULL id NO INHERIT NOT VALID", + alter.toString()); + roundTrip(alter); + assertEquals(ConstraintKind.NOT_NULL, ConstraintKind.fromType("NOT NULL")); + } + + @Test + void visitsTargetColumnAndUsesCustomExpressionDeparser() throws JSQLParserException { + Alter alter = (Alter) parse("ALTER TABLE t ADD CONSTRAINT nn NOT NULL id"); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(alter.getAlterExpressions().get(0), visited::add, table -> { + }); + assertEquals(List.of(constraint(alter).getColumn()), visited); + CreateTable table = (CreateTable) parse("CREATE TABLE t (id INT, NOT NULL id)"); + visited.clear(); + TableDefinitionTraversal.visit(table, visited::add, source -> { + }); + assertEquals(List.of(constraint(table).getColumn()), visited); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(alter)); + StringBuilder sql = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(Column column, S context) { + return getBuilder().append("replacement"); + } + }; + expressions.setBuilder(sql); + new AlterDeParser(sql, expressions).deParse(alter); + assertEquals("ALTER TABLE t ADD CONSTRAINT nn NOT NULL replacement", sql.toString()); + } + + @Test + void validatesNewConstraintAndExistingColumn() throws JSQLParserException { + 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) parse("ALTER TABLE t ADD CONSTRAINT nn NOT NULL id NOT VALID")); + assertTrue(validator.getValidationErrors().isEmpty()); + assertTrue(visited.stream().anyMatch( + n -> n.getNamedObject() == NamedObject.column && "id".equals(n.getFqn()))); + assertTrue(visited.stream().anyMatch( + n -> n.getNamedObject() == NamedObject.constraint && "nn".equals(n.getFqn()))); + assertTrue(visited.stream().noneMatch(n -> n.getNamedObject() == NamedObject.index)); + } + + @Test + void preservesColumnNullabilityAndActionBoundaries() throws JSQLParserException { + roundTrip(parse("ALTER TABLE t ADD NOT NULL id NOT VALID, ADD COLUMN extra INT")); + for (String sql : new String[] {"CREATE TABLE t (id INT NOT NULL)", + "ALTER TABLE t ALTER COLUMN id SET NOT NULL", + "ALTER TABLE t ALTER COLUMN id DROP NOT NULL"}) { + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + roundTrip(parse(sql)); + } + } + + private static NotNullConstraint constraint(Statement statement) { + return (NotNullConstraint) (statement instanceof Alter + ? ((Alter) statement).getAlterExpressions().get(0).getConstraint() + : ((CreateTable) statement).getTableConstraints().get(0)); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlRelationAlterTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlRelationAlterTest.java new file mode 100644 index 0000000000..e7d10cddef --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlRelationAlterTest.java @@ -0,0 +1,259 @@ +/*- + * #%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.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlRelationAlterTest { + @ParameterizedTest + @ValueSource(strings = { + "ALTER TABLE t CLUSTER ON ix", "ALTER TABLE t SET WITHOUT CLUSTER", + "ALTER TABLE t SET WITHOUT OIDS", "ALTER TABLE t SET LOGGED", + "ALTER TABLE t SET UNLOGGED", + "ALTER TABLE t OF public.typ", "ALTER TABLE t NOT OF", + "ALTER TABLE t ENABLE ALWAYS TRIGGER trg", "ALTER TABLE t ENABLE REPLICA TRIGGER trg", + "ALTER TABLE t DISABLE TRIGGER ALL", "ALTER TABLE t ENABLE TRIGGER USER", + "ALTER TABLE t ENABLE TRIGGER \"ALL\"", + "ALTER MATERIALIZED VIEW mv CLUSTER ON ix", + "ALTER MATERIALIZED VIEW mv SET WITHOUT CLUSTER", + "ALTER INDEX ix RENAME TO ix2", + "ALTER INDEX ix SET TABLESPACE pg_default", + "ALTER INDEX ix SET (fillfactor=80)", + "ALTER INDEX ix RESET (fillfactor)", + "ALTER INDEX ix ALTER COLUMN 1 SET STATISTICS 200", + "ALTER INDEX ix ALTER 1 SET STATISTICS 200", + "ALTER INDEX IF EXISTS ix RENAME TO ix2", + "ALTER INDEX IF EXISTS ix SET TABLESPACE pg_default", + "ALTER INDEX IF EXISTS ix SET (fillfactor=80)", + "ALTER INDEX IF EXISTS ix RESET (fillfactor)", + "ALTER INDEX IF EXISTS ix ALTER COLUMN 1 SET STATISTICS 200", + "ALTER INDEX IF EXISTS ix ALTER 1 SET STATISTICS 200", + "ALTER INDEX ix ATTACH PARTITION child_ix", + "ALTER VIEW v ALTER COLUMN id SET DEFAULT 1", + "ALTER VIEW v ALTER COLUMN id DROP DEFAULT", + "ALTER VIEW v SET (security_invoker=true)", + "ALTER VIEW v RESET (security_invoker)", + "ALTER VIEW v OWNER TO CURRENT_USER", + "ALTER VIEW v RENAME COLUMN id TO new_id", + "ALTER VIEW v RENAME TO v2", + "ALTER VIEW v SET SCHEMA ddl_aux", + "ALTER MATERIALIZED VIEW mv RENAME TO mv2", + "ALTER MATERIALIZED VIEW mv RENAME COLUMN id TO new_id", + "ALTER MATERIALIZED VIEW mv OWNER TO CURRENT_USER", + "ALTER MATERIALIZED VIEW mv SET SCHEMA ddl_aux", + "ALTER MATERIALIZED VIEW mv SET (fillfactor=80)", + "ALTER MATERIALIZED VIEW mv RESET (fillfactor)", + "ALTER MATERIALIZED VIEW mv SET TABLESPACE pg_default", + "ALTER MATERIALIZED VIEW mv SET ACCESS METHOD heap", + "ALTER MATERIALIZED VIEW mv ALTER COLUMN id SET STATISTICS 200", + "ALTER MATERIALIZED VIEW mv ALTER COLUMN label SET STORAGE EXTENDED", + "ALTER TABLE t ALTER COLUMN gen DROP EXPRESSION IF EXISTS", + "ALTER TABLE t ALTER CONSTRAINT ck INHERIT", + "ALTER TABLE t ALTER CONSTRAINT ck NO INHERIT", + "ALTER TABLE t ALTER CONSTRAINT nn INHERIT", + "ALTER TABLE t ALTER CONSTRAINT nn NO INHERIT", + "ALTER TABLE t VALIDATE CONSTRAINT ck", + "ALTER TABLE t SET (toast.autovacuum_enabled=false,fillfactor=70)", + "ALTER TABLE t RESET(toast.autovacuum_enabled,fillfactor)", + "ALTER TABLE t INHERIT p", + "ALTER TABLE t NO INHERIT p", + "ALTER TABLE t REPLICA IDENTITY NOTHING", + "ALTER TABLE t REPLICA IDENTITY USING INDEX ix", + "ALTER TABLE t SET ACCESS METHOD heap"}) + void auditedActionsAreStructuredAndRoundTrip(String sql) throws JSQLParserException { + Statement statement = parse(sql); + if (statement instanceof Alter) { + assertInstanceOf(RelationAlterAction.class, + ((Alter) statement).getAlterExpressions().get(0)); + } else { + AlterRelation relation = assertInstanceOf(AlterRelation.class, statement); + assertFalse(relation.getActions().isEmpty()); + } + assertRoundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @ParameterizedTest + @ValueSource(strings = {"DEFAULT", "FULL", "NOTHING"}) + void replicaIdentityModesAreStructuredAndEditable(String mode) throws JSQLParserException { + Alter statement = (Alter) assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t REPLICA IDENTITY " + mode, false, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + RelationAlterAction action = assertInstanceOf(RelationAlterAction.class, + statement.getAlterExpressions().get(0)); + assertEquals(RelationAlterAction.Kind.REPLICA_IDENTITY, action.getKind()); + assertEquals(RelationAlterAction.ReplicaIdentity.valueOf(mode), + action.getReplicaIdentity()); + assertRoundTrip(statement); + + action.setReplicaIdentity(RelationAlterAction.ReplicaIdentity.NOTHING); + assertEquals("ALTER TABLE t REPLICA IDENTITY NOTHING", statement.toString()); + assertRoundTrip(statement); + } + + @Test + void indexNameAndActionParametersCanBeReplaced() throws JSQLParserException { + AlterRelation index = + (AlterRelation) parse("ALTER INDEX IF EXISTS ix ALTER COLUMN 1 SET STATISTICS 200"); + assertEquals(AlterRelation.ObjectType.INDEX, index.getObjectType()); + assertTrue(index.isIfExists()); + assertEquals(1, index.getActions().get(0).getColumnNumber()); + index.setRelation(new Table("new_ix")); + index.getActions().get(0).setStatistics(100L); + assertEquals("ALTER INDEX IF EXISTS new_ix ALTER COLUMN 1 SET STATISTICS 100", + index.toString()); + assertTrue(new TablesNamesFinder().getTables(index).isEmpty()); + assertRoundTrip(index); + assertEquals("INDEX", index.accept(new StatementVisitorAdapter() { + @Override + public String visit(AlterRelation statement, S context) { + return statement.getObjectType().name(); + } + }, null)); + } + + @Test + void tableInheritanceAndGeneratedExpressionFlagsAreEditable() throws JSQLParserException { + Alter inherit = (Alter) parse("ALTER TABLE t NO INHERIT p"); + RelationAlterAction action = (RelationAlterAction) inherit.getAlterExpressions().get(0); + action.setNoInherit(false); + action.setRelation(new Table("parent")); + assertEquals("ALTER TABLE t INHERIT parent", inherit.toString()); + assertEquals(java.util.Set.of("t", "parent"), new TablesNamesFinder().getTables(inherit)); + Alter drop = + (Alter) parse("ALTER TABLE t ALTER COLUMN generated DROP EXPRESSION IF EXISTS"); + action = (RelationAlterAction) drop.getAlterExpressions().get(0); + assertEquals(RelationAlterAction.ColumnAction.DROP_EXPRESSION, action.getColumnAction()); + assertTrue(action.isUsingIfExists()); + action.setUsingIfExists(false); + assertEquals("ALTER TABLE t ALTER COLUMN generated DROP EXPRESSION", drop.toString()); + assertRoundTrip(drop); + } + + @Test + void viewDefaultsAndTableParametersAreVisited() throws JSQLParserException { + AlterRelation view = (AlterRelation) parse("ALTER VIEW v ALTER COLUMN id SET DEFAULT 1"); + RelationAlterAction action = view.getActions().get(0); + action.setDefaultExpression(new LongValue(2)); + assertEquals("ALTER VIEW v ALTER COLUMN id SET DEFAULT 2", view.toString()); + List visited = new ArrayList<>(); + action.visitExpressions(visited::add); + assertEquals(List.of(action.getDefaultExpression()), visited); + assertEquals(java.util.Set.of("v"), new TablesNamesFinder().getTables(view)); + assertRoundTrip(view); + Alter table = + (Alter) parse("ALTER TABLE t SET (toast.autovacuum_enabled=false, fillfactor=70)"); + action = (RelationAlterAction) table.getAlterExpressions().get(0); + assertEquals("toast.autovacuum_enabled", action.getOptions().get(0).getName()); + action.getOptions().get(1).setValue(new LongValue(80)); + visited.clear(); + TableDefinitionTraversal.visit(action, visited::add, ignored -> { + }); + assertEquals(2, visited.size()); + assertTrue(table.toString().endsWith("fillfactor = 80)")); + assertRoundTrip(table); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER INDEX ix OWNER TO me", "ALTER VIEW v SET TABLESPACE pg_default", + "ALTER MATERIALIZED VIEW v ALTER COLUMN id SET DEFAULT 1", + "ALTER INDEX ix ALTER COLUMN id SET STATISTICS 10", + "ALTER TABLE t ALTER COLUMN 1 SET STATISTICS 10", + "ALTER VIEW v RENAME TO v2, SET (security_invoker=true)"}) + void objectBoundariesAreEnforced(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + @Test + void triggerTargetsAndTypeNamesAreMutableWithoutInventingTables() throws JSQLParserException { + Alter statement = (Alter) parse("ALTER TABLE t ENABLE REPLICA TRIGGER trg"); + RelationAlterAction action = (RelationAlterAction) statement.getAlterExpressions().get(0); + assertEquals(RelationAlterAction.EnableState.ENABLE_REPLICA, action.getEnableState()); + action.setEnableState(RelationAlterAction.EnableState.DISABLE); + action.setTriggerTarget(RelationAlterAction.TriggerTarget.USER); + assertEquals("ALTER TABLE t DISABLE TRIGGER USER", statement.toString()); + assertRoundTrip(statement); + statement = (Alter) parse("ALTER TABLE t OF public.typ"); + action = (RelationAlterAction) statement.getAlterExpressions().get(0); + action.setValue("other.typ"); + assertEquals(java.util.Set.of("t"), new TablesNamesFinder().getTables(statement)); + assertRoundTrip(statement); + for (String sql : List.of("ALTER TABLE t ENABLE ALWAYS TRIGGER ALL", + "ALTER INDEX ix SET LOGGED", "ALTER VIEW v CLUSTER ON ix")) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + } + + @ParameterizedTest + @ValueSource(strings = {"TABLE", "INDEX", "MATERIALIZED VIEW"}) + void bulkTablespaceMovesShareOneModel(String objectType) throws JSQLParserException { + AlterTablespaceMove statement = (AlterTablespaceMove) parse("ALTER " + objectType + + " ALL IN TABLESPACE old_space OWNED BY alice, \"Bob\" SET TABLESPACE new_space NOWAIT"); + assertEquals(objectType.replace(' ', '_'), statement.getObjectType().name()); + assertEquals(List.of("alice", "\"Bob\""), statement.getOwners()); + assertEquals("old_space", statement.getSourceTablespace()); + assertTrue(statement.isNoWait()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + statement.setTargetTablespace("pg_default"); + statement.getOwners().clear(); + statement.setNoWait(false); + assertEquals( + "ALTER " + objectType + " ALL IN TABLESPACE old_space SET TABLESPACE pg_default", + statement.toString()); + assertRoundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(statement + "; SELECT 1").size()); + } + + @Test + void validateConstraintIsStructuredWithoutThePostgreSqlDialect() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.ANSI_SQL, Dialect.MYSQL}) { + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t ADD CHECK (c > 0) NOT VALID, VALIDATE CONSTRAINT ck", true, + p -> { + if (dialect != null) { + p.withDialect(dialect); + } + }); + RelationAlterAction validate = assertInstanceOf(RelationAlterAction.class, + alter.getAlterExpressions().get(1)); + assertEquals(RelationAlterAction.Kind.VALIDATE_CONSTRAINT, validate.getKind()); + assertEquals("ck", validate.getConstraintName()); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlRuleStateTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlRuleStateTest.java new file mode 100644 index 0000000000..475a5e5238 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlRuleStateTest.java @@ -0,0 +1,71 @@ +/*- + * #%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.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlRuleStateTest { + @ParameterizedTest + @ValueSource(strings = {"ENABLE", "DISABLE", "ENABLE ALWAYS", "ENABLE REPLICA"}) + void ruleAndTriggerActionsShareStates(String state) throws JSQLParserException { + Alter rule = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t " + state + + " RULE \"my rule\", ADD COLUMN z INT"); + RelationAlterAction action = assertInstanceOf(RelationAlterAction.class, + rule.getAlterExpressions().get(0)); + assertEquals(RelationAlterAction.Kind.RULE_STATE, action.getKind()); + assertEquals(state.replace(' ', '_'), action.getEnableState().name()); + assertEquals("\"my rule\"", action.getValue()); + assertEquals(2, rule.getAlterExpressions().size()); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(rule)); + action.setEnableState(RelationAlterAction.EnableState.DISABLE); + action.setValue("new_rule"); + StringBuilder output = new StringBuilder(); + rule.accept(new StatementDeParser(output)); + assertEquals(rule.toString(), output.toString()); + assertTrue(output.toString().contains("DISABLE RULE new_rule")); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + Alter trigger = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t " + state + " TRIGGER trg", + p -> p.withDialect(Dialect.POSTGRESQL)); + RelationAlterAction triggerAction = + (RelationAlterAction) trigger.getAlterExpressions().get(0); + assertEquals(state.replace(' ', '_'), triggerAction.getEnableState().name()); + triggerAction.setEnableState(null); + assertNull(triggerAction.getEnableState()); + assertEquals(RelationAlterAction.Kind.TRIGGER_STATE, triggerAction.getKind()); + assertEquals(RelationAlterAction.TriggerTarget.NAME, triggerAction.getTriggerTarget()); + assertEquals("trg", triggerAction.getValue()); + triggerAction.setEnableState(RelationAlterAction.EnableState.ENABLE_ALWAYS); + assertEquals(RelationAlterAction.EnableState.ENABLE_ALWAYS, triggerAction.getEnableState()); + StringBuilder triggerSql = new StringBuilder(); + trigger.accept(new StatementDeParser(triggerSql)); + assertEquals("ALTER TABLE t ENABLE ALWAYS TRIGGER trg", triggerSql.toString()); + assertEquals(trigger.toString(), triggerSql.toString()); + assertEquals(triggerSql.toString(), CCJSqlParserUtil.parse(triggerSql.toString(), + p -> p.withDialect(Dialect.POSTGRESQL)).toString()); + assertEquals(2, CCJSqlParserUtil.parseStatements(rule + "; SELECT 1").size()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ENABLE RULE", "ALTER TABLE t DISABLE ALWAYS RULE r", + "ALTER TABLE t DISABLE REPLICA RULE r", "ALTER INDEX ix ENABLE RULE r", + "ALTER TABLE t ENABLE ALWAYS TRIGGER ALL", "ALTER TABLE t ENABLE REPLICA TRIGGER USER"}) + void rejectsWrongStateTargets(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/RenameUserTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/RenameUserTest.java new file mode 100644 index 0000000000..656eb3fd5c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/RenameUserTest.java @@ -0,0 +1,89 @@ +/*- + * #%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.assertDeparse; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +class RenameUserTest { + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "MARIADB"}) + void renamesAccounts(Dialect dialect) throws JSQLParserException { + String sql = "RENAME USER 'a'@'%' TO 'b'@'%', old_name TO `new name`@localhost"; + RenameUser renameUser = assertInstanceOf(RenameUser.class, + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(dialect))); + assertEquals(sql, CCJSqlParserUtil + .parse(renameUser.toString(), parser -> parser.withDialect(dialect)).toString()); + + List renames = renameUser.getRenames(); + assertEquals(2, renames.size()); + assertEquals("a", renames.get(0).getFrom().getUser().getValue()); + assertEquals("%", renames.get(0).getTo().getHost().getValue()); + assertEquals("old_name", renames.get(1).getFrom().toString()); + assertEquals("new name", renames.get(1).getTo().getUser().getValue()); + assertEquals("`", renames.get(1).getTo().getUser().getQuoteStr()); + assertEquals("localhost", renames.get(1).getTo().getHost().getValue()); + } + + @Test + void keepsTableRenames() throws JSQLParserException { + assertInstanceOf(RenameTableStatement.class, + TestUtils.assertSqlCanBeParsedAndDeparsed("RENAME TABLE a TO b")); + // a table named user, renamed without the optional TABLE keyword + assertInstanceOf(RenameTableStatement.class, CCJSqlParserUtil.parse("RENAME user TO b")); + } + + @Test + void buildsAndDeparses() { + RenameUser renameUser = new RenameUser().addRename( + new UserAccount().withUser(new StringValue("a")).withHost(new StringValue("%")), + new UserAccount().withUser(new StringValue("b")).withHost(new StringValue("%"))); + + assertDeparse(renameUser, "RENAME USER 'a'@'%' TO 'b'@'%'"); + renameUser.setRenames(null); + assertEquals(0, renameUser.getRenames().size()); + } + + @Test + void reportsSchemaChangeWithoutTables() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("RENAME USER a TO b"); + + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(TablesNamesFinder.findTables(statement.toString())).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = {"RENAME USER a", "RENAME USER a TO", + "RENAME USER a IDENTIFIED BY 'x' TO b", "RENAME USER a TO b,"}) + void rejectsIncompleteRenames(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/SqlServerDefaultConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/SqlServerDefaultConstraintTest.java index 3516b92f32..fdcc8f5356 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/SqlServerDefaultConstraintTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/SqlServerDefaultConstraintTest.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.alter; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; import static org.junit.jupiter.api.Assertions.*; import java.util.ArrayList; @@ -21,7 +22,6 @@ import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.statement.create.table.DefaultConstraint; -import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.test.TestUtils; import net.sf.jsqlparser.util.TablesNamesFinder; import net.sf.jsqlparser.util.deparser.AlterDeParser; @@ -55,7 +55,8 @@ void roundTrip(String sql) throws JSQLParserException { Alter alter = (Alter) TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withSquareBracketQuotation(true)); assertEquals(alter.toString(), parse(sql).toString()); - assertInstanceOf(DefaultConstraint.class, alter.getAlterExpressions().get(0).getIndex()); + assertInstanceOf(DefaultConstraint.class, + alter.getAlterExpressions().get(0).getConstraint()); } @ParameterizedTest @@ -77,9 +78,9 @@ void rejectMalformedSyntax(String sql) { void inspectAndModifyStructuredConstraint() throws JSQLParserException { Alter alter = parse("ALTER TABLE t ADD CONSTRAINT df DEFAULT 0 FOR c WITH VALUES"); AlterExpression action = alter.getAlterExpressions().get(0); - DefaultConstraint constraint = (DefaultConstraint) action.getIndex(); + DefaultConstraint constraint = (DefaultConstraint) action.getConstraint(); assertEquals(AlterOperation.ADD, action.getOperation()); - assertEquals(Index.Kind.DEFAULT, constraint.getKind()); + assertEquals(ConstraintKind.DEFAULT, constraint.getKind()); assertEquals("DEFAULT", constraint.getType()); assertEquals("df", constraint.getName()); assertEquals("c", constraint.getColumn().getColumnName()); @@ -134,7 +135,7 @@ void existingColumnDefaultsAndCreateTableRemainSupported() throws JSQLParserExce "CREATE TABLE t (c INT DEFAULT ((0)), CONSTRAINT pk PRIMARY KEY CLUSTERED (c))"); TestUtils.assertSqlCanBeParsedAndDeparsed("ALTER TABLE t ALTER COLUMN c SET DEFAULT 0"); TestUtils.assertSqlCanBeParsedAndDeparsed("ALTER TABLE t ALTER COLUMN c DROP DEFAULT"); - assertEquals(Index.Kind.DEFAULT, new Index().withType("DEFAULT").getKind()); + assertEquals(ConstraintKind.DEFAULT, ConstraintKind.fromType("DEFAULT")); } @ParameterizedTest diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/database/AlterDatabaseTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/database/AlterDatabaseTest.java new file mode 100644 index 0000000000..48a10da952 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/database/AlterDatabaseTest.java @@ -0,0 +1,256 @@ +/*- + * #%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.database; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.schema.AlterSchema; +import net.sf.jsqlparser.statement.create.database.DatabaseOption; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +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; + +class AlterDatabaseTest { + @ParameterizedTest + @ValueSource(strings = { + "ALTER DATABASE d CHARACTER SET utf8mb4 COLLATE utf8mb4_bin", + "ALTER SCHEMA `d` DEFAULT CHARACTER SET = utf8mb4 DEFAULT COLLATE = utf8mb4_bin", + "ALTER DATABASE d DEFAULT ENCRYPTION = 'N'", + "ALTER DATABASE d READ ONLY = 0", "ALTER DATABASE d READ ONLY 1", + "ALTER DATABASE READ ONLY = DEFAULT", "ALTER SCHEMA DEFAULT CHARACTER SET utf8mb4"}) + void roundTripAndStatementBoundary(String sql) throws JSQLParserException { + AlterDatabase statement = parse(sql); + assertEquals(sql, statement.toString()); + StringBuilder buffer = new StringBuilder(); + statement.accept(new StatementDeParser(buffer), null); + assertEquals(sql, buffer.toString()); + assertEquals(sql, parse(buffer.toString()).toString()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.MYSQL)).size()); + } + + @Test + void optionMutationAndVisitorDispatch() throws JSQLParserException { + AlterDatabase statement = parse("ALTER DATABASE old_db READ ONLY = 0"); + statement.setDatabaseName("new_db"); + statement.getOption(DatabaseOption.Kind.READ_ONLY).orElseThrow().setValue("1"); + assertEquals("ALTER DATABASE new_db READ ONLY = 1", statement.toString()); + assertEquals("context:new_db", statement.accept(new StatementVisitorAdapter() { + @Override + public String visit(AlterDatabase database, S context) { + return context + ":" + database.getDatabaseName(); + } + }, "context")); + } + + @Test + void rejectIncompleteAndInvalidReadOnly() { + for (String sql : new String[] {"ALTER DATABASE d", "ALTER DATABASE d READ ONLY = 2", + "ALTER DATABASE d DEFAULT READ ONLY = 0"}) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER DATABASE db1 DEFAULT CHARSET = utf8mb4", + "ALTER SCHEMA db1 DEFAULT ENCRYPTION = 'Y'", "ALTER SCHEMA db1 CHAR SET utf8mb4", + "ALTER DATABASE CHARSET utf8mb4 COLLATE utf8mb4_bin", + "ALTER DATABASE charset CHARSET = utf8mb4", + "ALTER DATABASE READ ONLY = DEFAULT", "ALTER SCHEMA DEFAULT CHARACTER SET utf8mb4"}) + void testMySqlOptionsWithAndWithoutDialect(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.MYSQL); + assertRoundTrip(sql, null); + } + + @Test + void testCharsetSpellingAndOmittedName() throws JSQLParserException { + AlterDatabase statement = + (AlterDatabase) CCJSqlParserUtil.parse("ALTER SCHEMA DEFAULT CHARSET utf8mb4"); + assertTrue(statement.isUseSchemaKeyword()); + assertNull(statement.getDatabaseName()); + DatabaseOption charset = + statement.getOption(DatabaseOption.Kind.CHARACTER_SET).orElseThrow(); + assertEquals("CHARSET", charset.getName()); + assertEquals("utf8mb4", charset.getValue()); + assertTrue(charset.isUseDefault()); + + // CHARSET is also a valid database name. + statement = + (AlterDatabase) CCJSqlParserUtil.parse("ALTER DATABASE charset CHARSET utf8mb4"); + assertEquals("charset", statement.getDatabaseName()); + statement = (AlterDatabase) CCJSqlParserUtil.parse("ALTER DATABASE charset RENAME TO c2", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals("charset", statement.getDatabaseName()); + assertEquals("c2", statement.getNewName()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER DATABASE mydb RENAME TO mydb2", + "ALTER DATABASE \"My Db\" RENAME TO \"Other Db\"", "ALTER DATABASE mydb OWNER TO u1", + "ALTER DATABASE mydb OWNER TO CURRENT_USER", + "ALTER DATABASE mydb OWNER TO CURRENT_ROLE", + "ALTER DATABASE mydb OWNER TO SESSION_USER", "ALTER DATABASE mydb SET TABLESPACE fast", + "ALTER DATABASE mydb REFRESH COLLATION VERSION", + "ALTER DATABASE mydb SET search_path TO app, public", + "ALTER DATABASE mydb SET search_path = \"$user\", public", + "ALTER DATABASE mydb SET work_mem = '64MB'", + "ALTER DATABASE mydb SET work_mem TO DEFAULT", + "ALTER DATABASE mydb SET work_mem FROM CURRENT", "ALTER DATABASE mydb RESET work_mem", + "ALTER DATABASE mydb RESET ALL", "ALTER DATABASE mydb WITH ALLOW_CONNECTIONS false", + "ALTER DATABASE mydb CONNECTION LIMIT = -1 IS_TEMPLATE true", + "ALTER DATABASE mydb WITH IS_TEMPLATE = true ALLOW_CONNECTIONS = false CONNECTION LIMIT 5"}) + void testPostgreSqlForms(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.POSTGRESQL); + assertRoundTrip(sql, null); + } + + @Test + void testPostgreSqlActions() throws JSQLParserException { + AlterDatabase rename = parsePostgreSql("ALTER DATABASE mydb RENAME TO mydb2"); + assertEquals(AlterDatabase.Action.RENAME, rename.getAction()); + assertEquals("mydb", rename.getDatabaseName()); + assertEquals("mydb2", rename.getNewName()); + assertTrue(rename.getOptions().isEmpty()); + + AlterDatabase owner = parsePostgreSql("ALTER DATABASE mydb OWNER TO CURRENT_USER"); + assertEquals(AlterDatabase.Action.OWNER, owner.getAction()); + assertEquals("CURRENT_USER", owner.getOwner()); + + AlterDatabase tablespace = parsePostgreSql("ALTER DATABASE mydb SET TABLESPACE fast"); + assertEquals(AlterDatabase.Action.SET_TABLESPACE, tablespace.getAction()); + assertEquals("fast", tablespace.getTablespace()); + assertNull(tablespace.getParameterChange()); + + assertEquals(AlterDatabase.Action.REFRESH_COLLATION_VERSION, + parsePostgreSql("ALTER DATABASE mydb REFRESH COLLATION VERSION").getAction()); + + // A configuration parameter named "tablespace" is a SET, not SET TABLESPACE. + AlterDatabase parameter = parsePostgreSql("ALTER DATABASE mydb SET tablespace = fast"); + assertEquals(AlterDatabase.Action.CONFIGURATION_PARAMETER, parameter.getAction()); + assertEquals("tablespace", parameter.getParameterChange().getParameter()); + } + + @Test + void testPostgreSqlOptions() throws JSQLParserException { + AlterDatabase statement = parsePostgreSql( + "ALTER DATABASE mydb WITH ALLOW_CONNECTIONS false CONNECTION LIMIT = -1 IS_TEMPLATE true"); + assertEquals(AlterDatabase.Action.OPTIONS, statement.getAction()); + assertTrue(statement.isUseWith()); + List options = statement.getOptions(); + assertEquals(3, options.size()); + assertOption(options.get(0), DatabaseOption.Kind.ALLOW_CONNECTIONS, "ALLOW_CONNECTIONS", + "false", false); + assertOption(options.get(1), DatabaseOption.Kind.CONNECTION_LIMIT, "CONNECTION LIMIT", + "-1", true); + assertOption(options.get(2), DatabaseOption.Kind.IS_TEMPLATE, "IS_TEMPLATE", "true", + false); + + statement.getOption(DatabaseOption.Kind.CONNECTION_LIMIT).orElseThrow().setValue("10"); + statement.setUseWith(false); + assertEquals("ALTER DATABASE mydb ALLOW_CONNECTIONS false CONNECTION LIMIT = 10 " + + "IS_TEMPLATE true", statement.toString()); + } + + @Test + void testSwitchingActionsKeepsPayloads() throws JSQLParserException { + AlterDatabase statement = parsePostgreSql("ALTER DATABASE mydb RENAME TO mydb2"); + statement.setAction(AlterDatabase.Action.OWNER); + statement.setOwner("SESSION_USER"); + assertEquals("ALTER DATABASE mydb OWNER TO SESSION_USER", statement.toString()); + statement.setAction(AlterDatabase.Action.RENAME); + assertEquals("ALTER DATABASE mydb RENAME TO mydb2", statement.toString()); + + statement.setAction(AlterDatabase.Action.CONFIGURATION_PARAMETER); + assertThrows(IllegalStateException.class, statement::toString); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER DATABASE d", "ALTER DATABASE d SET TIME ZONE 'UTC'", + "ALTER DATABASE d SET RECOVERY SIMPLE", "ALTER DATABASE d MODIFY NAME = d2", + "ALTER DATABASE WITH ALLOW_CONNECTIONS true"}) + void testUnmodelledFormsRemainUnsupportedOutsideMySql(String sql) + throws JSQLParserException { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql)); + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + @Test + void testPostgreSqlAlterSchemaIsUnchanged() throws JSQLParserException { + assertInstanceOf(AlterSchema.class, CCJSqlParserUtil.parse("ALTER SCHEMA s RENAME TO t")); + assertInstanceOf(AlterSchema.class, + CCJSqlParserUtil.parse("ALTER SCHEMA s OWNER TO CURRENT_USER")); + assertInstanceOf(AlterDatabase.class, + CCJSqlParserUtil.parse("ALTER SCHEMA s DEFAULT ENCRYPTION = 'Y'")); + } + + @Test + void testValidation() { + validateNoErrors("ALTER DATABASE mydb SET work_mem = '64MB'", 1, DatabaseType.POSTGRESQL); + validateNoErrors("ALTER DATABASE mydb OWNER TO CURRENT_USER", 1, DatabaseType.POSTGRESQL); + validateNoErrors("ALTER DATABASE d CHARACTER SET utf8mb4", 1, DatabaseType.MYSQL, + DatabaseType.MARIADB); + assertFalse(new Validation(List.of(FeaturesAllowed.SELECT), + "ALTER DATABASE mydb RESET ALL").validate().isEmpty()); + assertTrue(new Validation(List.of(new FeaturesAllowed().add(Feature.alterDatabase)), + "ALTER DATABASE mydb RESET ALL").validate().isEmpty()); + } + + private static void assertOption(DatabaseOption option, DatabaseOption.Kind kind, String name, + String value, boolean useEquals) { + assertEquals(kind, option.getKind()); + assertEquals(name, option.getName()); + assertEquals(value, option.getValue()); + assertEquals(useEquals, option.isUseEquals()); + assertFalse(option.isUseDefault()); + } + + /** Parses, deparses and reparses with the dialect, or without one if it is null. */ + private static void assertRoundTrip(String sql, Dialect dialect) throws JSQLParserException { + Consumer consumer = + dialect == null ? parser -> { + } : parser -> parser.withDialect(dialect); + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, consumer); + assertInstanceOf(AlterDatabase.class, statement); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, CCJSqlParserUtil.parse(deparsed.toString(), consumer).toString()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", consumer).size()); + } + + private static AlterDatabase parsePostgreSql(String sql) throws JSQLParserException { + return (AlterDatabase) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static AlterDatabase parse(String sql) throws JSQLParserException { + return (AlterDatabase) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/analyze/AnalyzeTest.java b/src/test/java/net/sf/jsqlparser/statement/analyze/AnalyzeTest.java index 578e68fd78..ea00590eae 100644 --- a/src/test/java/net/sf/jsqlparser/statement/analyze/AnalyzeTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/analyze/AnalyzeTest.java @@ -12,15 +12,22 @@ 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 static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.io.StringReader; import java.util.List; import java.util.stream.Collectors; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserManager; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class AnalyzeTest { @@ -83,4 +90,50 @@ public void testMySqlAnalyzeNoWriteToBinlog() throws JSQLParserException { assertEquals(Analyze.Modifier.NO_WRITE_TO_BINLOG, analyze.getModifier()); } + + @Test + public void testMySqlAnalyzeHistogramUpdateMode() throws JSQLParserException { + Analyze auto = (Analyze) assertSqlCanBeParsedAndDeparsed( + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1, c2 WITH 32 BUCKETS AUTO UPDATE"); + assertEquals(32, auto.getHistogramBucketCount()); + assertEquals(Analyze.HistogramUpdateMode.AUTO, auto.getHistogramUpdateMode()); + + Analyze manual = (Analyze) assertSqlCanBeParsedAndDeparsed( + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 MANUAL UPDATE"); + assertNull(manual.getHistogramBucketCount()); + assertEquals(Analyze.HistogramUpdateMode.MANUAL, manual.getHistogramUpdateMode()); + + assertDeparse(new Analyze().withTableKeyword(true).withTable(new Table("t1")) + .withHistogramAction(Analyze.HistogramAction.UPDATE) + .addHistogramColumns(new Column("c1")) + .withHistogramUpdateMode(Analyze.HistogramUpdateMode.AUTO), + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 AUTO UPDATE"); + } + + @Test + public void testMySqlAnalyzeHistogramUsingData() throws JSQLParserException { + String json = "{\"buckets\": [[1, 0.5], [2, 1.0]], \"data-type\": \"int\"}"; + String sql = "ANALYZE NO_WRITE_TO_BINLOG TABLE t1 UPDATE HISTOGRAM ON c1 USING DATA '" + + json + "'"; + Analyze analyze = (Analyze) assertSqlCanBeParsedAndDeparsed(sql); + assertEquals(json, analyze.getHistogramData().getValue()); + assertNull(analyze.getHistogramUpdateMode()); + assertEquals(sql, CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)) + .toString()); + + analyze.setHistogramData(new StringValue("{}")); + assertEquals("ANALYZE NO_WRITE_TO_BINLOG TABLE t1 UPDATE HISTOGRAM ON c1 USING DATA '{}'", + analyze.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"ANALYZE TABLE t1 DROP HISTOGRAM ON c1 AUTO UPDATE", + "ANALYZE TABLE t1 DROP HISTOGRAM ON c1 USING DATA '{}'", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 USING DATA '{}' MANUAL UPDATE", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 MANUAL UPDATE WITH 8 BUCKETS", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 AUTO", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 USING DATA"}) + public void testMySqlAnalyzeRejectsMisplacedHistogramOptions(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/analyze/PostgreSqlAnalyzeTest.java b/src/test/java/net/sf/jsqlparser/statement/analyze/PostgreSqlAnalyzeTest.java new file mode 100644 index 0000000000..bd3bd74411 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/analyze/PostgreSqlAnalyzeTest.java @@ -0,0 +1,312 @@ +/*- + * #%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.analyze; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.UtilityOption; +import net.sf.jsqlparser.statement.analyze.Analyze.OptionKind; +import net.sf.jsqlparser.statement.maintenance.MaintenanceTarget; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlAnalyzeTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Analyze parse(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, POSTGRESQL); + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, true).toString()); + return (Analyze) statement; + } + + private static List columns(MaintenanceTarget target) { + return target.getColumns().stream().map(Column::getColumnName) + .collect(Collectors.toList()); + } + + @Test + void verboseWithColumnList() throws JSQLParserException { + Analyze analyze = parse("ANALYZE VERBOSE t (a)"); + + assertFalse(analyze.isParenthesizedOptions()); + assertEquals(OptionKind.VERBOSE, analyze.getOptions().get(0).getKind(OptionKind.class)); + assertEquals(List.of("a"), columns(analyze.getTargets().get(0))); + assertEquals("t", analyze.getTable().getFullyQualifiedName()); + assertFalse(analyze.isTableKeyword()); + assertNull(analyze.getModifier()); + } + + @Test + void parenthesizedOptionsAndTableList() throws JSQLParserException { + Analyze analyze = parse("ANALYZE (SKIP_LOCKED) t, s"); + + assertTrue(analyze.isParenthesizedOptions()); + assertEquals(OptionKind.SKIP_LOCKED, + analyze.getOptions().get(0).getKind(OptionKind.class)); + assertEquals(List.of("t", "s"), analyze.getTables().stream() + .map(Table::getFullyQualifiedName).collect(Collectors.toList())); + } + + @Test + void everyOptionWithValuesAndOnlyTarget() throws JSQLParserException { + Analyze analyze = parse( + "ANALYZE (VERBOSE false, SKIP_LOCKED, BUFFER_USAGE_LIMIT 256) ONLY s.t (a, b), u *"); + + assertEquals(Boolean.FALSE, analyze.getOptions().get(0).getBooleanValue()); + assertEquals(256L, analyze.getOptions().get(2).getLongValue()); + MaintenanceTarget only = analyze.getTargets().get(0); + assertTrue(only.getReference().isOnly()); + assertEquals(List.of("a", "b"), columns(only)); + assertTrue(analyze.getTargets().get(1).getReference().isIncludeDescendants()); + } + + @Test + void bareAnalyze() throws JSQLParserException { + Analyze analyze = parse("ANALYZE"); + + assertTrue(analyze.getTargets().isEmpty()); + assertNull(analyze.getTable()); + assertTrue(analyze.getTables().isEmpty()); + assertEquals("ANALYZE", analyze.toString()); + assertEquals("ANALYZE (VERBOSE)", parse("ANALYZE (VERBOSE)").toString()); + } + + @Test + void verboseWordDependsOnDialect() throws JSQLParserException { + Analyze postgres = (Analyze) CCJSqlParserUtil.parse("ANALYZE verbose", POSTGRESQL); + assertEquals("verbose", postgres.getOptions().get(0).getName()); + assertTrue(postgres.getTargets().isEmpty()); + + // without a dialect and in other dialects a lone verbose stays a table name + Analyze generic = (Analyze) CCJSqlParserUtil.parse("ANALYZE verbose"); + assertTrue(generic.getOptions().isEmpty()); + assertEquals("verbose", generic.getTable().getFullyQualifiedName()); + Analyze mysql = (Analyze) CCJSqlParserUtil.parse("ANALYZE verbose, t", + parser -> parser.withDialect(Dialect.MYSQL)); + assertEquals(2, mysql.getTables().size()); + + // a following table name selects the option without a dialect too + Analyze option = (Analyze) CCJSqlParserUtil.parse("ANALYZE VERBOSE t"); + assertEquals("VERBOSE", option.getOptions().get(0).getName()); + assertEquals("t", option.getTable().getFullyQualifiedName()); + } + + @Test + void mySqlFormsAreUnchanged() throws JSQLParserException { + for (String sql : List.of("ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1, c2 WITH 64 BUCKETS", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 WITH 32 BUCKETS AUTO UPDATE", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 MANUAL UPDATE", + "ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 USING DATA '{}'", + "ANALYZE NO_WRITE_TO_BINLOG TABLE t, s", + "ANALYZE LOCAL TABLE t DROP HISTOGRAM ON c", + "ANALYZE t1, t2")) { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, + Dialect.POSTGRESQL}) { + Analyze analyze = (Analyze) assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect)); + assertTrue(analyze.getOptions().isEmpty()); + assertTrue(analyze.getTargets().stream().allMatch(MaintenanceTarget::isPlainTable)); + } + } + } + + @Test + void acceptsEveryOptionOfTheGrammar() throws JSQLParserException { + Analyze analyze = parse("ANALYZE (FULL, VERBOSE 2, BUFFER_USAGE_LIMIT) t"); + + assertNull(analyze.getOptions().get(0).getKind(OptionKind.class)); + assertEquals(UtilityOption.ValueType.NUMBER, analyze.getOptions().get(1).getValueType()); + assertNull(analyze.getOptions().get(1).getBooleanValue()); + assertEquals(OptionKind.BUFFER_USAGE_LIMIT, + analyze.getOptions().get(2).getKind(OptionKind.class)); + assertFalse(analyze.getOptions().get(2).hasValue()); + + Analyze option = parse("ANALYZE (t)"); + assertEquals("t", option.getOptions().get(0).getName()); + assertTrue(option.getTargets().isEmpty()); + } + + @Test + void analyseSpelling() throws JSQLParserException { + for (String sql : List.of("ANALYSE", "ANALYSE t", "ANALYSE VERBOSE t (a)", + "ANALYSE (VERBOSE, SKIP_LOCKED) ONLY t, s")) { + Analyze analyze = parse(sql); + assertEquals(Analyze.Command.ANALYSE, analyze.getCommand(), sql); + } + Analyze lower = (Analyze) CCJSqlParserUtil.parse("analyse verbose t", POSTGRESQL); + assertEquals("ANALYSE verbose t", lower.toString()); + assertEquals(Analyze.Command.ANALYZE, parse("ANALYZE t").getCommand()); + + assertDeparse(new Analyze().withCommand(Analyze.Command.ANALYSE) + .addOptions(new UtilityOption("VERBOSE")).addTables(new Table("t")), + "ANALYSE VERBOSE t"); + assertThrows(NullPointerException.class, () -> new Analyze().setCommand(null)); + } + + @Test + void analyseRemainsAnIdentifier() throws JSQLParserException { + for (String sql : List.of("SELECT analyse FROM analyse AS analyse", + "CREATE TABLE analyse (analyse INT)", "INSERT INTO analyse (analyse) VALUES (1)")) { + assertSqlCanBeParsedAndDeparsed(sql, true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed(sql, true); + } + assertSqlCanBeParsedAndDeparsed("SELECT analyse FROM analyse", true, + parser -> parser.withDialect(Dialect.MYSQL)); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t PROCEDURE ANALYSE()", true, + parser -> parser.withDialect(Dialect.MYSQL)); + } + + @Test + void analyseStartsAStatementOnlyInThePostgreSqlForm() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT 1; ANALYSE t\nANALYSE; ANALYSE (VERBOSE)\nSELECT 2", POSTGRESQL); + assertEquals(5, statements.size()); + assertEquals("ANALYSE t", statements.get(1).toString()); + assertEquals("ANALYSE", statements.get(2).toString()); + assertEquals("ANALYSE (VERBOSE)", statements.get(3).toString()); + + // without a dialect other forms stay unsupported statements, and other dialects never + // read ANALYSE as a statement + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse("ANALYSE t FOO", + parser -> parser.withUnsupportedStatements(true))); + assertInstanceOf(Analyze.class, CCJSqlParserUtil.parse("ANALYSE t", + parser -> parser.withUnsupportedStatements(true))); + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse("ANALYSE t", + parser -> parser.withDialect(Dialect.MYSQL).withUnsupportedStatements(true))); + } + + @ParameterizedTest + @ValueSource(strings = { + "ANALYSE TABLE t", + "ANALYSE LOCAL t", + "ANALYSE t UPDATE HISTOGRAM ON a", + "ANALYZE (SELECT) t", + "ANALYZE (TABLE) t", + "ANALYZE (VERBOSE on, SKIP_LOCKED only) t", + "ANALYZE TABLE t (a)", + "ANALYZE LOCAL (VERBOSE) t", + "ANALYZE VERBOSE TABLE t", + "ANALYZE (VERBOSE) t UPDATE HISTOGRAM ON a", + "ANALYZE ONLY t DROP HISTOGRAM ON a", + "ANALYZE (VERBOSE) t UPDATE HISTOGRAM ON a WITH 8 BUCKETS AUTO UPDATE", + "ANALYZE VERBOSE t UPDATE HISTOGRAM ON a MANUAL UPDATE", + "ANALYZE t (a) UPDATE HISTOGRAM ON a USING DATA '{}'", + "ANALYZE t * UPDATE HISTOGRAM ON a", + "ANALYZE UPDATE HISTOGRAM ON a", + "ANALYZE TABLE", + "ANALYZE LOCAL", + "ANALYZE t (a.b)", + "ANALYZE t (a) UPDATE HISTOGRAM ON a" + }) + void rejectsMixedOrInvalidForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"ANALYZE", "ANALYZE (VERBOSE) t", "ANALYZE VERBOSE t (a)", + "ANALYZE t (a)", "ANALYZE ONLY t", "ANALYSE t", "ANALYSE"}) + void otherDialectsKeepTheirReading(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL))); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SHOW search_path; ANALYZE; CHECKPOINT\nANALYZE VERBOSE t (a)\nSELECT 1", + POSTGRESQL); + + assertEquals(5, statements.size()); + assertInstanceOf(Analyze.class, statements.get(1)); + assertEquals("ANALYZE", statements.get(1).toString()); + assertEquals("ANALYZE VERBOSE t (a)", statements.get(3).toString()); + } + + @Test + void legacyAccessorsAreDerivedFromTargets() throws JSQLParserException { + Analyze analyze = parse("ANALYZE (VERBOSE) ONLY t (a), s"); + + List
tables = analyze.getTables(); + assertThrows(UnsupportedOperationException.class, () -> tables.add(new Table("x"))); + analyze.addTables(new Table("x")); + assertEquals(2, tables.size()); + assertEquals(3, analyze.getTables().size()); + + analyze.setTable(new Table("u")); + assertDeparse(analyze, "ANALYZE (VERBOSE) u"); + analyze.setTables(List.of(new Table("a"), new Table("b"))); + assertDeparse(analyze, "ANALYZE (VERBOSE) a, b"); + analyze.setTable(null); + assertDeparse(analyze, "ANALYZE (VERBOSE)"); + } + + @Test + void histogramClauseKeepsPlainTargets() throws JSQLParserException { + Analyze analyze = (Analyze) assertSqlCanBeParsedAndDeparsed( + "ANALYZE TABLE t1, t2 UPDATE HISTOGRAM ON c1 WITH 16 BUCKETS AUTO UPDATE"); + + assertEquals(2, analyze.getTargets().size()); + assertTrue(analyze.getTargets().stream().allMatch(MaintenanceTarget::isPlainTable)); + assertTrue(analyze.getOptions().isEmpty()); + assertEquals(16, analyze.getHistogramBucketCount()); + assertEquals(Analyze.HistogramUpdateMode.AUTO, analyze.getHistogramUpdateMode()); + + analyze.setTable(new Table("u")); + assertDeparse(analyze, + "ANALYZE TABLE u UPDATE HISTOGRAM ON c1 WITH 16 BUCKETS AUTO UPDATE"); + } + + @Test + void buildsAndDeparses() { + Analyze analyze = new Analyze().addOptions(new UtilityOption("VERBOSE")) + .addTargets(new MaintenanceTarget(new Table("t")).addColumns(new Column("a"))); + assertDeparse(analyze, "ANALYZE VERBOSE t (a)"); + + analyze.withParenthesizedOptions(true) + .addOptions(UtilityOption.ofString("BUFFER_USAGE_LIMIT", "1MB")); + assertDeparse(analyze, "ANALYZE (VERBOSE, BUFFER_USAGE_LIMIT '1MB') t (a)"); + + analyze.withOptions(null).withTargets(null); + assertDeparse(analyze, "ANALYZE"); + } + + @Test + void findsTablesButNotColumns() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("ANALYZE VERBOSE a (x), ONLY s.b (y)", + POSTGRESQL); + + assertThat(new TablesNamesFinder<>().getTables(statement)) + .containsExactlyInAnyOrder("a", "s.b"); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/builder/ReflectionModelTest.java b/src/test/java/net/sf/jsqlparser/statement/builder/ReflectionModelTest.java index 64d7d83242..9d9b457613 100644 --- a/src/test/java/net/sf/jsqlparser/statement/builder/ReflectionModelTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/builder/ReflectionModelTest.java @@ -158,10 +158,10 @@ public class ReflectionModelTest { new net.sf.jsqlparser.statement.create.table.ColumnDefinition(), new net.sf.jsqlparser.statement.create.table.CreateTable(), new net.sf.jsqlparser.statement.create.table.ExcludeConstraint(), - new net.sf.jsqlparser.statement.create.table.ForeignKeyIndex(), + new net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint(), new net.sf.jsqlparser.statement.create.table.Index(), - new net.sf.jsqlparser.statement.create.table.Index.ColumnParams("p"), - new net.sf.jsqlparser.statement.create.table.NamedConstraint(), + new net.sf.jsqlparser.statement.create.table.KeyElement("p"), + new net.sf.jsqlparser.statement.create.table.KeyConstraint(), new net.sf.jsqlparser.statement.create.table.RowMovement(), new net.sf.jsqlparser.statement.create.view.AlterView(), new net.sf.jsqlparser.statement.create.view.CreateView(), diff --git a/src/test/java/net/sf/jsqlparser/statement/comment/CommentTargetTest.java b/src/test/java/net/sf/jsqlparser/statement/comment/CommentTargetTest.java index 67f2dddf3f..e48148fac7 100644 --- a/src/test/java/net/sf/jsqlparser/statement/comment/CommentTargetTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/comment/CommentTargetTest.java @@ -14,7 +14,9 @@ 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 static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import java.util.ArrayList; +import java.util.EnumSet; import java.util.List; import java.util.Set; import java.util.stream.Stream; @@ -29,6 +31,8 @@ import net.sf.jsqlparser.statement.StatementVisitorAdapter; import net.sf.jsqlparser.statement.Statements; import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ExclusionOperator; import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; import net.sf.jsqlparser.util.TablesNamesFinder; import net.sf.jsqlparser.util.deparser.ExpressionDeParser; @@ -41,15 +45,32 @@ import org.junit.jupiter.params.provider.ValueSource; class CommentTargetTest { + // PostgreSQL accepts schema-qualified names only for these kinds + private static final Set SCHEMA_QUALIFIED = EnumSet.of( + CommentTarget.Kind.INDEX, CommentTarget.Kind.SEQUENCE, CommentTarget.Kind.DOMAIN, + CommentTarget.Kind.TYPE, CommentTarget.Kind.MATERIALIZED_VIEW, + CommentTarget.Kind.FOREIGN_TABLE, CommentTarget.Kind.COLLATION, + CommentTarget.Kind.STATISTICS, CommentTarget.Kind.CONVERSION, + CommentTarget.Kind.TEXT_SEARCH_CONFIGURATION, CommentTarget.Kind.TEXT_SEARCH_DICTIONARY, + CommentTarget.Kind.TEXT_SEARCH_PARSER, CommentTarget.Kind.TEXT_SEARCH_TEMPLATE); + + private static final Set UNQUALIFIED = EnumSet.of( + CommentTarget.Kind.SCHEMA, CommentTarget.Kind.ACCESS_METHOD, + CommentTarget.Kind.DATABASE, CommentTarget.Kind.EVENT_TRIGGER, + CommentTarget.Kind.EXTENSION, CommentTarget.Kind.FOREIGN_DATA_WRAPPER, + CommentTarget.Kind.LANGUAGE, CommentTarget.Kind.PUBLICATION, CommentTarget.Kind.ROLE, + CommentTarget.Kind.SERVER, CommentTarget.Kind.SUBSCRIPTION, + CommentTarget.Kind.TABLESPACE); + static Stream names() { List cases = new ArrayList<>(); - for (CommentTarget.Kind kind : List.of(CommentTarget.Kind.INDEX, CommentTarget.Kind.SCHEMA, - CommentTarget.Kind.SEQUENCE, CommentTarget.Kind.DOMAIN, CommentTarget.Kind.TYPE, - CommentTarget.Kind.MATERIALIZED_VIEW)) { + Set kinds = EnumSet.copyOf(SCHEMA_QUALIFIED); + kinds.addAll(UNQUALIFIED); + for (CommentTarget.Kind kind : kinds) { for (String name : List.of("obj", "\"a.b\"", "\"a\"\"b.c\"", "\"한.글\"", "\".\"")) { cases.add(Arguments.of(kind, name, null, name)); } - if (kind != CommentTarget.Kind.SCHEMA) { + if (SCHEMA_QUALIFIED.contains(kind)) { cases.add(Arguments.of(kind, "public.\"a.b\"", "public", "\"a.b\"")); cases.add(Arguments.of(kind, "\"s.p\".\"a.b\"", "\"s.p\"", "\"a.b\"")); } @@ -82,14 +103,27 @@ void preservesNamedTargetsAndTheirComponents(CommentTarget.Kind kind, String nam } } + static Stream signatures() { + List cases = new ArrayList<>(); + for (CommentTarget.Kind kind : List.of(CommentTarget.Kind.FUNCTION, + CommentTarget.Kind.PROCEDURE, CommentTarget.Kind.ROUTINE)) { + for (String signature : List.of("f", "f()", "f(integer)", "f(IN arg integer)", + "f(OUT result text)", "f(INOUT arg integer)", "f(VARIADIC args text[])", + "\"s.p\".\"f.x\"(IN \"arg.x\" pg_catalog.int4[])", + "f(timestamp with time zone, double precision)")) { + cases.add(Arguments.of(kind, signature)); + } + } + return cases.stream(); + } + @ParameterizedTest - @ValueSource(strings = {"f", "f()", "f(integer)", "f(IN arg integer)", - "f(OUT result text)", "f(INOUT arg integer)", "f(VARIADIC args text[])", - "\"s.p\".\"f.x\"(IN \"arg.x\" pg_catalog.int4[])", - "f(timestamp with time zone, double precision)"}) - void preservesRoutineSignaturesWithoutTreatingThemAsCalls(String signature) throws Exception { - for (Comment comment : roundTrip("COMMENT ON FUNCTION " + signature + " IS 'body'")) { - assertEquals(CommentTarget.Kind.FUNCTION, comment.getTarget().getKind()); + @MethodSource("signatures") + void preservesRoutineSignaturesWithoutTreatingThemAsCalls(CommentTarget.Kind kind, + String signature) throws Exception { + for (Comment comment : roundTrip("COMMENT ON " + kind + " " + signature + " IS 'body'")) { + assertEquals(kind, comment.getTarget().getKind()); + assertNull(comment.getTarget().getName()); RoutineReference routine = comment.getTarget().getRoutine(); assertEquals( signature.contains("(") ? signature.substring(0, signature.indexOf('(')) @@ -117,6 +151,41 @@ void exposesArgumentModeNameAndDataType() throws Exception { assertEquals("text[]", arguments.get(1).getDataType().toString()); } + @Test + void preservesAggregateSignatures() throws Exception { + RoutineReference star = aggregate("app.agg(*)"); + assertEquals("app.agg", star.getName()); + assertTrue(star.isAllArguments()); + assertNull(star.getOrderByArguments()); + + RoutineReference direct = aggregate("agg(integer, text)"); + assertFalse(direct.isAllArguments()); + assertEquals(2, direct.getArguments().size()); + assertNull(direct.getOrderByArguments()); + + RoutineReference ordered = aggregate("rank(VARIADIC \"any\" ORDER BY VARIADIC \"any\")"); + assertEquals(RoutineReference.Argument.Mode.VARIADIC, + ordered.getArguments().get(0).getMode()); + assertEquals(RoutineReference.Argument.Mode.VARIADIC, + ordered.getOrderByArguments().get(0).getMode()); + + // ORDER is not reserved, so it must not be taken for the name of a direct argument + RoutineReference orderedOnly = aggregate("mode(ORDER BY anyelement)"); + assertTrue(orderedOnly.getArguments().isEmpty()); + assertEquals("anyelement", + orderedOnly.getOrderByArguments().get(0).getDataType().toString()); + } + + private static RoutineReference aggregate(String signature) throws JSQLParserException { + List comments = roundTrip("COMMENT ON AGGREGATE " + signature + " IS NULL"); + for (Comment comment : comments) { + assertEquals(CommentTarget.Kind.AGGREGATE, comment.getTarget().getKind()); + assertEquals(signature, comment.getTarget().getRoutine().toString()); + assertTrue(new TablesNamesFinder().getTables(comment).isEmpty()); + } + return comments.get(0).getTarget().getRoutine(); + } + @ParameterizedTest @ValueSource(strings = {"t", "\"t.x\"", "public.\"t.x\"", "\"s.p\".\"t.x\""}) void distinguishesConstraintTablesFromDomains(String owner) throws Exception { @@ -146,12 +215,355 @@ void domainKeywordCanNameTheConstraintTable(String name) throws Exception { } } + static Stream relationOwnedTargets() { + List cases = new ArrayList<>(); + for (CommentTarget.Kind kind : List.of(CommentTarget.Kind.TRIGGER, + CommentTarget.Kind.POLICY, CommentTarget.Kind.RULE)) { + for (String owner : List.of("t", "\"t.x\"", "public.\"t.x\"", "\"s.p\".\"t.x\"", + "domain")) { + cases.add(Arguments.of(kind, owner)); + } + } + return cases.stream(); + } + + @ParameterizedTest + @MethodSource("relationOwnedTargets") + void namesTriggersPoliciesAndRulesWithinTheirTable(CommentTarget.Kind kind, String owner) + throws Exception { + for (Comment comment : roundTrip( + "COMMENT ON " + kind + " \"o.n\" ON " + owner + " IS 'body'")) { + CommentTarget target = comment.getTarget(); + assertEquals(kind, target.getKind()); + assertEquals("\"o.n\"", target.getName().getName()); + assertNull(target.getName().getSchemaName()); + assertFalse(target.isOnDomain()); + assertEquals(owner, target.getRelation().getFullyQualifiedName()); + assertEquals(Set.of(owner), new TablesNamesFinder().getTables(comment)); + } + } + + @ParameterizedTest + @ValueSource(strings = {"bigint AS int4", "character varying AS text", + "text[] AS app.custom_type", "timestamp with time zone AS date", + "double precision AS time without time zone"}) + void preservesCastSourceAndTargetTypes(String types) throws Exception { + for (Comment comment : roundTrip("COMMENT ON CAST (" + types + ") IS 'body'")) { + CommentTarget target = comment.getTarget(); + assertEquals(CommentTarget.Kind.CAST, target.getKind()); + assertNull(target.getName()); + assertNull(target.getRoutine()); + assertEquals(types, target.getSourceType() + " AS " + target.getTargetType()); + assertTrue(new TablesNamesFinder().getTables(comment).isEmpty()); + } + } + + @Test + void recordsProceduralLanguageSpelling() throws Exception { + for (boolean procedural : List.of(false, true)) { + String sql = "COMMENT ON " + (procedural ? "PROCEDURAL " : "") + + "LANGUAGE plpgsql IS 'body'"; + for (Comment comment : roundTrip(sql)) { + assertEquals(CommentTarget.Kind.LANGUAGE, comment.getTarget().getKind()); + assertEquals(procedural, comment.getTarget().isProcedural()); + assertEquals("plpgsql", comment.getTarget().getName().getName()); + assertEquals(sql, comment.toString()); + } + } + } + + static Stream operators() { + List cases = new ArrayList<>(); + // arithmetic, comparison, bitwise, string, pattern, JSON, array, range and geometric + for (String operator : List.of("+", "-", "*", "/", "%", "^", "|/", "||/", "@", "<", ">", + "=", "<=", ">=", "<>", "!=", "&", "|", "#", "~", "<<", ">>", "||", "~~", "~~*", + "!~~", "!~~*", "~*", "!~", "!~*", "^@", "->", "->>", "#>", "#>>", "#-", "@>", "<@", + "?", "?|", "?&", "@?", "@@", "@@@", "&&", "<->", "<#>", "<=>", "-|-", "<<=", ">>=", + "&<", "&>", "<<|", "|>>", "&<|", "|&>", "<^", ">^", "?#", "?-|", "?||", "~=", + "@-@", "##", "!!", "*=", "*<>", "~>=~")) { + cases.add(Arguments.of(operator, null, operator)); + } + cases.add(Arguments.of("app.+", "app", "+")); + cases.add(Arguments.of("pg_catalog.||", "pg_catalog", "||")); + cases.add(Arguments.of("\"My.Schema\".->>", "\"My.Schema\"", "->>")); + // CLASS and FAMILY only start an operator class or family when no dot follows + cases.add(Arguments.of("class.<<=", "class", "<<=")); + cases.add(Arguments.of("family.-|-", "family", "-|-")); + return cases.stream(); + } + + @ParameterizedTest + @MethodSource("operators") + void preservesOperatorNamesAndOperandTypes(String operator, String schema, String symbol) + throws Exception { + for (Comment comment : roundTrip( + "COMMENT ON OPERATOR " + operator + " (integer, app.t[]) IS 'body'")) { + CommentTarget target = comment.getTarget(); + assertEquals(CommentTarget.Kind.OPERATOR, target.getKind()); + assertNull(target.getName()); + assertEquals(schema, target.getOperator().getSchemaName()); + assertEquals(symbol, target.getOperator().getName()); + assertFalse(target.getOperator().isUseOperatorKeyword()); + assertEquals("integer", target.getLeftOperandType().toString()); + assertEquals("app.t[]", target.getRightOperandType().toString()); + assertTrue(new TablesNamesFinder().getTables(comment).isEmpty()); + } + } + + @Test + void joinsOnlyOperatorPartsThatTouch() throws Exception { + assertEquals("COMMENT ON OPERATOR <<= (inet, inet) IS NULL", + parse("COMMENT ON OPERATOR <<=(inet,inet) IS NULL").toString()); + assertEquals("COMMENT ON OPERATOR - (NONE, integer) IS NULL", + parse("COMMENT ON OPERATOR -/* prefix */(NONE, integer) IS NULL").toString()); + for (String operator : List.of("< =", "< >", "> =", "! =", "+ -", "+/**/-", "-\n|-")) { + assertThrows(JSQLParserException.class, + () -> parse("COMMENT ON OPERATOR " + operator + " (integer, integer) IS NULL"), + operator); + } + } + + @ParameterizedTest + @ValueSource(strings = {"NONE, integer", "integer, NONE", "\"NONE\", none", + "timestamp with time zone, double precision", "NONE, character varying"}) + void representsMissingOperandsAsNull(String operands) throws Exception { + String[] types = operands.split(", "); + for (Comment comment : roundTrip("COMMENT ON OPERATOR - (" + operands + ") IS NULL")) { + CommentTarget target = comment.getTarget(); + assertEquals(types[0].equals("NONE") ? null : types[0], + target.getLeftOperandType() == null ? null + : target.getLeftOperandType().toString()); + assertEquals(types[1].equalsIgnoreCase("NONE") ? null : types[1], + target.getRightOperandType() == null ? null + : target.getRightOperandType().toString()); + assertEquals("OPERATOR - (" + operands.replace("none", "NONE") + ")", + target.toString()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"int4_ops USING btree", "app.\"my.ops\" USING gist", + "\"s.p\".ops USING \"my am\"", "class USING family"}) + void namesOperatorClassesAndFamiliesWithinTheirAccessMethod(String reference) + throws Exception { + String name = reference.substring(0, reference.indexOf(" USING ")); + String method = reference.substring(reference.indexOf(" USING ") + 7); + for (CommentTarget.Kind kind : List.of(CommentTarget.Kind.OPERATOR_CLASS, + CommentTarget.Kind.OPERATOR_FAMILY)) { + String sql = "COMMENT ON " + kind.name().replace('_', ' ') + " " + reference + + " IS 'body'"; + for (Comment comment : roundTrip(sql)) { + CommentTarget target = comment.getTarget(); + assertEquals(kind, target.getKind()); + assertEquals(name, target.getName().getFullyQualifiedName()); + assertEquals(method, target.getAccessMethod()); + assertNull(target.getRelation()); + assertNull(target.getOperator()); + assertEquals(sql, comment.toString()); + assertTrue(new TablesNamesFinder().getTables(comment).isEmpty()); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"0", "4242", "0004242", "4294967295"}) + void storesLargeObjectOids(String oid) throws Exception { + for (Comment comment : roundTrip("COMMENT ON LARGE OBJECT " + oid + " IS 'lo'")) { + CommentTarget target = comment.getTarget(); + assertEquals(CommentTarget.Kind.LARGE_OBJECT, target.getKind()); + assertEquals(Long.valueOf(oid), target.getLargeObjectOid()); + assertNull(target.getName()); + assertEquals("COMMENT ON LARGE OBJECT " + Long.valueOf(oid) + " IS 'lo'", + comment.toString()); + assertTrue(new TablesNamesFinder().getTables(comment).isEmpty()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"int LANGUAGE sql", "hstore LANGUAGE plpython3u", + "app.\"my.type\"[] LANGUAGE \"my lang\"", + "timestamp with time zone LANGUAGE plperl", "language LANGUAGE language"}) + void preservesTransformTypeAndLanguage(String reference) throws Exception { + String type = reference.substring(0, reference.indexOf(" LANGUAGE ")); + String language = reference.substring(reference.indexOf(" LANGUAGE ") + 10); + for (Comment comment : roundTrip("COMMENT ON TRANSFORM FOR " + reference + " IS NULL")) { + CommentTarget target = comment.getTarget(); + assertEquals(CommentTarget.Kind.TRANSFORM, target.getKind()); + assertEquals(type, target.getTransformType().toString()); + assertEquals(language, target.getLanguage()); + assertNull(target.getName()); + assertNull(target.getSourceType()); + assertTrue(new TablesNamesFinder().getTables(comment).isEmpty()); + } + } + + @Test + void kindPredicatesDescribeTheReferenceShape() { + Set routines = EnumSet.noneOf(CommentTarget.Kind.class); + Set owned = EnumSet.noneOf(CommentTarget.Kind.class); + Set accessMethod = EnumSet.noneOf(CommentTarget.Kind.class); + for (CommentTarget.Kind kind : CommentTarget.Kind.values()) { + if (kind.isRoutine()) { + routines.add(kind); + } + if (kind.isOwnedByRelation()) { + owned.add(kind); + } + if (kind.isOwnedByAccessMethod()) { + accessMethod.add(kind); + } + } + assertEquals(EnumSet.of(CommentTarget.Kind.FUNCTION, CommentTarget.Kind.PROCEDURE, + CommentTarget.Kind.ROUTINE, CommentTarget.Kind.AGGREGATE), routines); + assertEquals(EnumSet.of(CommentTarget.Kind.CONSTRAINT, CommentTarget.Kind.TRIGGER, + CommentTarget.Kind.POLICY, CommentTarget.Kind.RULE), owned); + assertEquals(EnumSet.of(CommentTarget.Kind.OPERATOR_CLASS, + CommentTarget.Kind.OPERATOR_FAMILY), accessMethod); + } + + @ParameterizedTest + @ValueSource(strings = {"COMMENT ON TRIGGER trg ON users IS 'x'", + "COMMENT ON POLICY p1 ON users IS 'x'", "COMMENT ON RULE r1 ON app.v IS NULL", + "COMMENT ON EXTENSION postgis IS 'x'", "COMMENT ON DATABASE mydb IS 'x'", + "COMMENT ON ROLE app_read IS 'x'", "COMMENT ON TABLESPACE pg_default IS ''", + "COMMENT ON EVENT TRIGGER et IS 'x'", "COMMENT ON PUBLICATION pub IS 'x'", + "COMMENT ON SUBSCRIPTION sub IS 'x'", "COMMENT ON SERVER srv IS 'x'", + "COMMENT ON FOREIGN DATA WRAPPER postgres_fdw IS 'x'", + "COMMENT ON FOREIGN TABLE app.ft IS 'x'", + "COMMENT ON PROCEDURAL LANGUAGE plpgsql IS 'x'", + "COMMENT ON COLLATION app.\"de-DE\" IS 'x'", "COMMENT ON ACCESS METHOD heap2 IS 'x'", + "COMMENT ON STATISTICS app.st IS 'x'", + "COMMENT ON PROCEDURE app.p(IN a integer, INOUT b text) IS 'x'", + "COMMENT ON ROUTINE r() IS 'x'", + "COMMENT ON AGGREGATE percentile_disc(float8 ORDER BY anyelement) IS 'x'", + "COMMENT ON CAST (bigint AS int4) IS 'x'", + "COMMENT ON OPERATOR + (integer, integer) IS 'op'", + "COMMENT ON OPERATOR - (NONE, integer) IS 'prefix op'", + "COMMENT ON OPERATOR pg_catalog.->> (jsonb, text) IS 'x'", + "COMMENT ON OPERATOR app.-|- (int4range, int4range) IS NULL", + "COMMENT ON OPERATOR CLASS int4_ops USING btree IS 'opclass'", + "COMMENT ON OPERATOR FAMILY integer_ops USING btree IS 'opfamily'", + "COMMENT ON LARGE OBJECT 4242 IS 'lo'", + "COMMENT ON TEXT SEARCH CONFIGURATION english IS 'tscfg'", + "COMMENT ON TEXT SEARCH DICTIONARY english_stem IS 'tsdict'", + "COMMENT ON TEXT SEARCH PARSER \"default\" IS 'tsparser'", + "COMMENT ON TEXT SEARCH TEMPLATE simple IS 'tstemplate'", + "COMMENT ON CONVERSION utf8_to_iso_8859_1 IS 'conversion'", + "COMMENT ON TRANSFORM FOR int LANGUAGE sql IS 'transform'"}) + void parsesAndDeparsesWithAndWithoutPostgreSqlDialect(String sql) throws Exception { + assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertSqlCanBeParsedAndDeparsed(sql, false, null); + } + + @Test + void kindWordsRemainIdentifiers() throws Exception { + assertSqlCanBeParsedAndDeparsed("SELECT role, rule, server, extension, routine, " + + "statistics, collation, publication, subscription, language, procedural, " + + "access, method, wrapper FROM extension"); + Comment rule = roundTrip("COMMENT ON RULE rule ON rule IS NULL").get(0); + assertEquals("rule", rule.getTarget().getName().getName()); + assertEquals("rule", rule.getTarget().getRelation().getName()); + assertEquals("server", roundTrip("COMMENT ON SERVER server IS NULL").get(0).getTarget() + .getName().getName()); + assertEquals("role", roundTrip("COMMENT ON TABLE role IS NULL").get(0).getTable() + .getName()); + assertEquals("server.language", roundTrip("COMMENT ON COLUMN server.language IS NULL") + .get(0).getColumn().getFullyQualifiedName()); + } + + @Test + void operatorAndTextSearchKindWordsRemainIdentifiers() throws Exception { + assertSqlCanBeParsedAndDeparsed("SELECT operator, class, family, large, object, " + + "conversion, transform, configuration, dictionary, parser, template, search, " + + "none FROM operator"); + assertEquals("operator", roundTrip("COMMENT ON TABLE operator IS NULL").get(0).getTable() + .getName()); + assertEquals("conversion.transform", + roundTrip("COMMENT ON COLUMN conversion.transform IS NULL").get(0).getColumn() + .getFullyQualifiedName()); + assertEquals("template", roundTrip("COMMENT ON TEXT SEARCH TEMPLATE template IS NULL") + .get(0).getTarget().getName().getName()); + assertEquals("conversion", roundTrip("COMMENT ON CONVERSION conversion IS NULL").get(0) + .getTarget().getName().getName()); + assertEquals("operator", + roundTrip("COMMENT ON OPERATOR operator.+ (operator, NONE) IS NULL") + .get(0).getTarget().getOperator().getSchemaName()); + } + + @Test + void rendersProgrammaticTargets() { + CommentTarget trigger = new CommentTarget(); + trigger.setKind(CommentTarget.Kind.TRIGGER); + trigger.setName(new Table("trg")); + trigger.setRelation(new Table("app", "t")); + assertEquals("COMMENT ON TRIGGER trg ON app.t IS 'body'", + new Comment().withTarget(trigger).withComment(new StringValue("body")).toString()); + + CommentTarget cast = new CommentTarget(); + cast.setKind(CommentTarget.Kind.CAST); + cast.setSourceType(new ColDataType("integer")); + cast.setTargetType(new ColDataType("text")); + assertEquals("COMMENT ON CAST (integer AS text) IS NULL", + new Comment().withTarget(cast).toString()); + + CommentTarget named = new CommentTarget(); + named.setKind(CommentTarget.Kind.ROLE); + named.setName(new Table("r")); + named.setProcedural(true); + assertEquals("ROLE r", named.toString()); + named.setKind(CommentTarget.Kind.LANGUAGE); + assertEquals("PROCEDURAL LANGUAGE r", named.toString()); + + CommentTarget operator = new CommentTarget(); + operator.setKind(CommentTarget.Kind.OPERATOR); + operator.setOperator(new ExclusionOperator().withSchemaName("app").withName("->>")); + operator.setLeftOperandType(new ColDataType("jsonb")); + assertEquals("OPERATOR app.->> (jsonb, NONE)", operator.toString()); + + CommentTarget operatorClass = new CommentTarget(); + operatorClass.setKind(CommentTarget.Kind.OPERATOR_FAMILY); + operatorClass.setName(new Table("app", "ops")); + operatorClass.setAccessMethod("gist"); + assertEquals("OPERATOR FAMILY app.ops USING gist", operatorClass.toString()); + + CommentTarget largeObject = new CommentTarget(); + largeObject.setKind(CommentTarget.Kind.LARGE_OBJECT); + largeObject.setLargeObjectOid(4242L); + assertEquals("COMMENT ON LARGE OBJECT 4242 IS NULL", + new Comment().withTarget(largeObject).toString()); + + CommentTarget transform = new CommentTarget(); + transform.setKind(CommentTarget.Kind.TRANSFORM); + transform.setTransformType(new ColDataType("hstore")); + transform.setLanguage("plpython3u"); + assertEquals("TRANSFORM FOR hstore LANGUAGE plpython3u", transform.toString()); + } + @ParameterizedTest @ValueSource(strings = {"INDEX", "MATERIALIZED obj", "MATERIALIZED VIEW", "FUNCTION f(*)", "FUNCTION f(integer ORDER BY integer)", "FUNCTION f(IN)", "FUNCTION f(x integer DEFAULT 1)", "CONSTRAINT ck", "CONSTRAINT ck ON", "CONSTRAINT public.ck ON t", + "TRIGGER trg", "TRIGGER trg ON", "TRIGGER app.trg ON t", "TRIGGER trg ON DOMAIN d", + "POLICY p", "RULE r ON DOMAIN d", "PROCEDURE p(*)", + "ROUTINE r(integer ORDER BY integer)", "FUNCTION f(ORDER BY integer)", + "AGGREGATE agg", "CAST (integer)", "CAST integer AS text", "CAST (integer AS text", + "FOREIGN ft", "FOREIGN DATA fdw", "EVENT et", "ACCESS heap", "ACCESS METHOD", + "PROCEDURAL plpgsql", "LANGUAGE", "ROLE", + "OPERATOR", "OPERATOR +", "OPERATOR + ()", "OPERATOR + (integer)", + "OPERATOR + (NONE, NONE)", "OPERATOR + (integer, integer, integer)", + "OPERATOR + integer, integer", "OPERATOR app (integer, integer)", + "OPERATOR app. (integer, integer)", "OPERATOR => (integer, integer)", + "OPERATOR := (integer, integer)", "OPERATOR OPERATOR(pg_catalog.+) (integer, integer)", + "OPERATOR CLASS ops", "OPERATOR CLASS ops USING", "OPERATOR FAMILY ops USING a.b", + "OPERATOR CLASS USING btree", "LARGE OBJECT", "LARGE 42", "LARGE OBJECT lo", + "LARGE OBJECT -1", "LARGE OBJECT 4294967296", "LARGE OBJECT 99999999999999999999", + "LARGE OBJECT 1.5", "LARGE OBJECT 1, 2", "TEXT SEARCH", "TEXT SEARCH english", + "TEXT SEARCH INDEX english", "TEXT CONFIGURATION english", + "TINYTEXT SEARCH PARSER p", "CONVERSION", "TRANSFORM", "TRANSFORM int LANGUAGE sql", + "TRANSFORM FOR int", "TRANSFORM FOR int LANGUAGE", "TRANSFORM FOR int LANGUAGE a.b", "UNKNOWN obj"}) void rejectsIncompleteOrInvalidTargets(String target) { assertThrows(JSQLParserException.class, () -> parse("COMMENT ON " + target + " IS NULL")); @@ -160,12 +572,21 @@ void rejectsIncompleteOrInvalidTargets(String target) { @Test void findsOnlyRelationsExplicitlyNamedByComments() throws Exception { for (String target : List.of("INDEX idx", "SCHEMA app", "SEQUENCE seq", "DOMAIN d", - "TYPE ty", "FUNCTION f(int)")) { + "TYPE ty", "FUNCTION f(int)", "PROCEDURE app.p(int)", "ROUTINE r", + "AGGREGATE a(*)", "CAST (integer AS text)", "COLLATION app.c", + "STATISTICS app.st", "ACCESS METHOD am", "DATABASE d", "EVENT TRIGGER et", + "EXTENSION e", "FOREIGN DATA WRAPPER w", "LANGUAGE l", "PUBLICATION p", "ROLE r", + "SERVER s", "SUBSCRIPTION s", "TABLESPACE ts", "OPERATOR app.+ (integer, NONE)", + "OPERATOR CLASS app.t USING btree", "OPERATOR FAMILY app.t USING btree", + "LARGE OBJECT 42", "CONVERSION app.t", "TEXT SEARCH CONFIGURATION app.t", + "TEXT SEARCH DICTIONARY app.t", "TEXT SEARCH PARSER app.t", + "TEXT SEARCH TEMPLATE app.t", "TRANSFORM FOR app.t LANGUAGE sql")) { assertTrue(new TablesNamesFinder().getTables(parse("COMMENT ON " + target + " IS NULL")) .isEmpty()); } for (String target : List.of("TABLE app.t", "COLUMN app.t.c", "VIEW app.t", - "MATERIALIZED VIEW app.t", "CONSTRAINT ck ON app.t")) { + "MATERIALIZED VIEW app.t", "CONSTRAINT ck ON app.t", "FOREIGN TABLE app.t", + "TRIGGER trg ON app.t", "POLICY p ON app.t", "RULE r ON app.t")) { assertEquals(Set.of("app.t"), new TablesNamesFinder().getTables(parse("COMMENT ON " + target + " IS NULL"))); } @@ -223,9 +644,11 @@ public Void visit(StringValue value, S context) { assertEquals(List.of("body"), values); } - @Test - void customDeparsersCanRewriteRelationsAndLiterals() throws Exception { - Comment comment = parse("COMMENT ON CONSTRAINT ck ON app.t IS 'body'"); + @ParameterizedTest + @ValueSource(strings = {"CONSTRAINT ck ON", "TRIGGER trg ON", "POLICY p ON", "RULE r ON", + "FOREIGN TABLE", "MATERIALIZED VIEW"}) + void customDeparsersCanRewriteRelationsAndLiterals(String target) throws Exception { + Comment comment = parse("COMMENT ON " + target + " app.t IS 'body'"); StringBuilder builder = new StringBuilder(); ExpressionDeParser expressions = new ExpressionDeParser() { @Override @@ -242,8 +665,8 @@ public StringBuilder visit(Table table, S context) { } }; comment.accept(new StatementDeParser(expressions, selects, builder), "context"); - assertEquals("COMMENT ON CONSTRAINT ck ON app.new_t IS 'changed'", builder.toString()); - assertEquals("COMMENT ON CONSTRAINT ck ON app.t IS 'body'", comment.toString()); + assertEquals("COMMENT ON " + target + " app.new_t IS 'changed'", builder.toString()); + assertEquals("COMMENT ON " + target + " app.t IS 'body'", comment.toString()); } private static Comment parse(String sql) throws JSQLParserException { diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ColumnAttributeTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ColumnAttributeTest.java index faf18fdbfc..761976862c 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/ColumnAttributeTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/ColumnAttributeTest.java @@ -121,15 +121,16 @@ void postgresCollationAndCharsetAreSeparateAttributes(String name) throws Except void keepsIdentityReferencesDefaultsAndRawExtensionsDistinct() throws Exception { Statement statement = parse( "CREATE TABLE t (c INT NOT NULL DEFAULT 0 ON UPDATE CURRENT_TIMESTAMP(6) " - + "REFERENCES parent(id) ON UPDATE CASCADE COMMENT 'body' COLUMN_FORMAT FIXED)", + + "REFERENCES parent(id) ON UPDATE CASCADE COMMENT 'body' COLUMN_FORMAT FIXED " + + "NOT SECONDARY)", Dialect.MYSQL); List options = column(statement).getColumnOptions(); assertEquals(List.of(ColumnOption.Kind.NULLABILITY, ColumnOption.Kind.DEFAULT, ColumnOption.Kind.ON_UPDATE, ColumnOption.Kind.REFERENCE, - ColumnOption.Kind.COMMENT), - options.subList(0, 5).stream().map(ColumnOption::getKind) + ColumnOption.Kind.COMMENT, ColumnOption.Kind.COLUMN_FORMAT), + options.subList(0, 6).stream().map(ColumnOption::getKind) .collect(Collectors.toList())); - assertTrue(options.stream().skip(5).allMatch(o -> o.getKind() == ColumnOption.Kind.OTHER)); + assertTrue(options.stream().skip(6).allMatch(o -> o.getKind() == ColumnOption.Kind.OTHER)); for (String definition : List.of("INT GENERATED ALWAYS AS IDENTITY", "INT GENERATED BY DEFAULT AS IDENTITY")) { assertEquals(ColumnOption.Kind.IDENTITY, @@ -156,7 +157,8 @@ void mutationsUpdateLegacyTokensAndBothRenderers() throws Exception { column(statement).addColumnSpecs("CUSTOM"); assertEquals(ColumnOption.Kind.OTHER, options.get(options.size() - 1).getKind()); column(statement).setColumnSpecs(List.of("NOT", "NULL")); - assertNull(column(statement).getColumnOptions()); + assertEquals(ColumnOption.Kind.OTHER, + column(statement).getColumnOptions().get(0).getKind()); assertEquals("CREATE TABLE t (c INT NOT NULL)", statement.toString()); } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefaultExpressionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefaultExpressionTest.java index c99e6a11e1..2e403e5524 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefaultExpressionTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefaultExpressionTest.java @@ -9,27 +9,36 @@ */ package net.sf.jsqlparser.statement.create; +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNotAllowed; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; - import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.CollateExpression; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.parser.feature.Feature; -import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; -import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; 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.AlterDomain; +import net.sf.jsqlparser.statement.alter.AlterRelation; +import net.sf.jsqlparser.statement.create.domain.CreateDomain; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.ColumnOption; import net.sf.jsqlparser.statement.create.table.CreateTable; @@ -37,8 +46,11 @@ 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.feature.FeaturesAllowed; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; class ColumnDefaultExpressionTest { @@ -130,7 +142,7 @@ void replacingDefaultUpdatesLegacyTokensAndBothRenderers(String sql) assertNotNull(defaultOption(column).getDefaultExpression()); assertRoundTrip(statement); column.setColumnSpecs(Arrays.asList("DEFAULT", "9")); - assertNull(column.getColumnOptions()); + assertEquals(ColumnOption.Kind.OTHER, column.getColumnOptions().get(0).getKind()); assertEquals(sql.replace("(1 + 2) NOT NULL", "9"), statement.toString()); assertRoundTrip(statement); } @@ -161,6 +173,94 @@ void neighboringAndLegacyColumnOptionsStillRoundTrip(String sql) throws JSQLPars assertRoundTrip(CCJSqlParserUtil.parse(sql)); } + @ParameterizedTest + @ValueSource( + strings = {"CREATE TABLE t (c VARCHAR(30) ", "ALTER TABLE t ADD COLUMN c VARCHAR(30) ", + "ALTER TABLE t MODIFY COLUMN c VARCHAR(30) ", + "ALTER TABLE t CHANGE COLUMN old_c c VARCHAR(30) "}) + void collateAfterDefaultIsAColumnAttribute(String prefix) throws JSQLParserException { + String sql = prefix + "NOT NULL DEFAULT 'N' COLLATE utf8mb4_unicode_ci COMMENT 'flag'" + + (prefix.startsWith("CREATE") ? ")" : ""); + List> configurations = Arrays.asList(parser -> { + }, parser -> parser.withDialect(Dialect.MYSQL)); + for (Consumer configuration : configurations) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, configuration); + ColumnDefinition column = firstColumn(statement); + assertThat(column.getColumnOptions()).extracting(ColumnOption::getKind) + .containsExactly(ColumnOption.Kind.NULLABILITY, ColumnOption.Kind.DEFAULT, + ColumnOption.Kind.COLLATE, ColumnOption.Kind.COMMENT); + assertInstanceOf(StringValue.class, defaultOption(column).getDefaultExpression()); + assertEquals("utf8mb4_unicode_ci", column.getColumnOptions().get(2).getCollation()); + assertThat(column.getColumnSpecs()).containsExactly("NOT", "NULL", "DEFAULT", "'N'", + "COLLATE", "utf8mb4_unicode_ci", "COMMENT", "'flag'"); + assertRoundTrip(statement); + } + } + + static Stream defaultValuesBeforeCollate() { + return Stream.of(Arguments.of(Dialect.MYSQL, "_utf8mb4'N'", "utf8mb4_bin"), + Arguments.of(Dialect.MYSQL, "'N'", "'utf8mb4_bin'"), + Arguments.of(Dialect.MYSQL, "1", "utf8mb4_bin"), + Arguments.of(Dialect.MYSQL, "-1", "utf8mb4_bin"), + Arguments.of(Dialect.POSTGRESQL, "'a' || 'b'", "\"C\""), + Arguments.of(Dialect.POSTGRESQL, "lower('A' COLLATE \"C\")", "\"C\""), + Arguments.of(Dialect.POSTGRESQL, "CASE WHEN true THEN 'a' END", "\"C\""), + Arguments.of(Dialect.POSTGRESQL, "'x'::text", "\"C\""), + Arguments.of(Dialect.POSTGRESQL, "'x'", "pg_catalog.\"default\"")); + } + + @ParameterizedTest + @MethodSource("defaultValuesBeforeCollate") + void defaultValueEndsBeforeTopLevelCollate(Dialect dialect, String value, String collation) + throws JSQLParserException { + String definition = " VARCHAR(30) DEFAULT " + value + " COLLATE " + collation + " NOT NULL"; + String alter = dialect == Dialect.MYSQL ? "ALTER TABLE t MODIFY COLUMN c" + : "ALTER TABLE t ADD COLUMN c"; + for (String sql : Arrays.asList("CREATE TABLE t (c" + definition + ")", + alter + definition)) { + ColumnDefinition column = firstColumn(assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect))); + assertThat(column.getColumnOptions()).extracting(ColumnOption::getKind) + .containsExactly(ColumnOption.Kind.DEFAULT, ColumnOption.Kind.COLLATE, + ColumnOption.Kind.NULLABILITY); + assertEquals(value, defaultOption(column).getDefaultExpression().toString()); + assertEquals(collation, column.getColumnOptions().get(1).getCollation()); + } + } + + @Test + void parenthesizedCollateStaysInTheDefaultValue() throws JSQLParserException { + ColumnDefinition column = firstColumn(assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t MODIFY COLUMN c VARCHAR(3) DEFAULT ('N' COLLATE utf8mb4_bin) NOT NULL", + true, parser -> parser.withDialect(Dialect.MYSQL))); + assertThat(column.getColumnOptions()).extracting(ColumnOption::getKind) + .containsExactly(ColumnOption.Kind.DEFAULT, ColumnOption.Kind.NULLABILITY); + Expression value = defaultOption(column).getDefaultExpression(); + assertInstanceOf(ParenthesedExpressionList.class, value); + assertInstanceOf(CollateExpression.class, ((ParenthesedExpressionList) value).get(0)); + } + + @Test + void setDefaultAndDomainDefaultsKeepTheExpressionCollate() throws JSQLParserException { + // PostgreSQL's SET DEFAULT takes an a_expr, which includes COLLATE. CREATE DOMAIN is + // unchanged. + Consumer postgres = parser -> parser.withDialect(Dialect.POSTGRESQL); + Alter table = (Alter) assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t ALTER COLUMN c SET DEFAULT 'x' COLLATE \"C\"", true, postgres); + assertInstanceOf(CollateExpression.class, table.getAlterExpressions().get(0) + .getColumnDefaults().get(0).getDefaultExpression()); + AlterRelation view = (AlterRelation) assertSqlCanBeParsedAndDeparsed( + "ALTER VIEW v ALTER COLUMN c SET DEFAULT 'x' COLLATE \"C\"", true, postgres); + assertInstanceOf(CollateExpression.class, + view.getActions().get(0).getDefaultExpression()); + AlterDomain alterDomain = (AlterDomain) assertSqlCanBeParsedAndDeparsed( + "ALTER DOMAIN d SET DEFAULT 'x' COLLATE \"C\"", true, postgres); + assertInstanceOf(CollateExpression.class, alterDomain.getDefaultExpression()); + CreateDomain createDomain = (CreateDomain) assertSqlCanBeParsedAndDeparsed( + "CREATE DOMAIN d AS text DEFAULT 'x' COLLATE \"C\"", true, postgres); + assertInstanceOf(CollateExpression.class, createDomain.getDefaultExpression()); + } + @ParameterizedTest @ValueSource(strings = {"CREATE TABLE t (a INT DEFAULT (1 + 2", "CREATE TABLE t (a INT DEFAULT (1 +))", diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefinitionStateTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefinitionStateTest.java new file mode 100644 index 0000000000..de85eca5bd --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/ColumnDefinitionStateTest.java @@ -0,0 +1,227 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDataType; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignKeyReference; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +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 org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class ColumnDefinitionStateTest { + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (id INT COLUMN_FORMAT COMPRESSED)", + "ALTER TABLE t ADD COLUMN id INT COLUMN_FORMAT COMPRESSED", + "CREATE TABLE t (id INT DEFAULT 1)", "ALTER TABLE t ADD COLUMN id INT DEFAULT 1"}) + void specificationSnapshotsAreReadOnlyForRawAndStructuredOptions(String sql) + throws JSQLParserException { + Statement statement = parse(sql); + ColumnDefinition column = column(statement); + List snapshot = column.getColumnSpecs(); + assertThrows(UnsupportedOperationException.class, () -> snapshot.add("NOT NULL")); + assertThrows(UnsupportedOperationException.class, () -> snapshot.set(0, "changed")); + assertThrows(UnsupportedOperationException.class, snapshot::clear); + ColumnOption option = column.getColumnOptions().get(0); + if (option.getKind() == ColumnOption.Kind.OTHER) { + assertTrue(column.getColumnOptions().stream() + .allMatch(raw -> raw.getKind() == ColumnOption.Kind.OTHER)); + ColumnOption rawOption = column.getColumnOptions().stream() + .filter(raw -> raw.getTokens().contains("COMPRESSED")) + .findFirst().orElseThrow(); + List rawTokens = new ArrayList<>(rawOption.getTokens()); + rawTokens.set(rawTokens.indexOf("COMPRESSED"), "FIXED"); + rawOption.setTokens(rawTokens); + assertEquals(List.of("COLUMN_FORMAT", "COMPRESSED"), snapshot); + assertEquals(List.of("COLUMN_FORMAT", "FIXED"), column.getColumnSpecs()); + } else { + option.setDefaultExpression(new LongValue(2)); + assertEquals(List.of("DEFAULT", "1"), snapshot); + assertEquals(List.of("DEFAULT", "2"), column.getColumnSpecs()); + } + roundTrip(statement); + } + + @Test + void constructorAndRawSettersCopyTokensWithoutParsingThem() { + List input = new ArrayList<>(List.of("DEFAULT", "1")); + ColumnDefinition column = new ColumnDefinition("id", new ColDataType("INT"), input); + input.set(1, "99"); + assertEquals("id INT DEFAULT 1", column.toString()); + assertEquals(ColumnOption.Kind.OTHER, column.getColumnOptions().get(0).getKind()); + assertNull(column.getColumnOptions().get(0).getDefaultExpression()); + List appended = new ArrayList<>(List.of("NOT", "NULL")); + column.addColumnSpecs(appended); + appended.clear(); + assertEquals("id INT DEFAULT 1 NOT NULL", column.toString()); + column.setColumnSpecs(input); + input.clear(); + assertEquals("id INT DEFAULT 99", column.toString()); + assertEquals(1, column.getColumnOptions().size()); + column.setColumnSpecs(column.getColumnSpecs()); + assertEquals("id INT DEFAULT 99", column.toString()); + } + + @Test + void constructorDoesNotDispatchToOverriddenSpecificationSetter() { + ColumnDefinition column = new ColumnDefinition("id", new ColDataType("INT"), + List.of("NOT", "NULL")) { + @Override + public void setColumnSpecs(List specs) { + fail("The constructor must not call an overridable setter"); + } + }; + assertEquals(List.of("NOT", "NULL"), column.getColumnSpecs()); + assertEquals("id INT NOT NULL", column.toString()); + } + + @Test + void optionSettersCopyMembershipAndKeepTheOriginalMutableNodes() { + ColumnOption defaultOption = ColumnOption.defaultValue(new LongValue(1)); + List input = new ArrayList<>(List.of(defaultOption)); + ColumnDefinition column = new ColumnDefinition("id", new ColDataType("INT")) + .withColumnOptions(input); + input.clear(); + assertSame(defaultOption, column.getColumnOptions().get(0)); + List liveOptions = column.getColumnOptions(); + defaultOption.setDefaultExpression(new LongValue(2)); + column.addColumnSpecs("NOT", "NULL"); + column.addColumnOptions(ColumnOption.comment( + new net.sf.jsqlparser.expression.StringValue("description"))); + assertSame(liveOptions, column.getColumnOptions()); + assertEquals(3, liveOptions.size()); + assertEquals("id INT DEFAULT 2 NOT NULL COMMENT 'description'", column.toString()); + column.setColumnOptions(List.of(defaultOption)); + column.addColumnSpecs("NOT", "NULL"); + assertEquals("id INT DEFAULT 2 NOT NULL", column.toString()); + column.getColumnOptions().remove(0); + assertEquals(List.of("NOT", "NULL"), column.getColumnSpecs()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (id INT DEFAULT 1 REFERENCES parent(id))", + "ALTER TABLE t ADD COLUMN id INT DEFAULT 1 REFERENCES parent(id)"}) + void rawAppendPreservesStructuredChildrenVisitorsAndCustomRendering(String sql) + throws JSQLParserException { + Statement statement = parse(sql); + ColumnDefinition column = column(statement); + ColumnOption defaultOption = column.getColumnOptions().get(0); + ForeignKeyReference reference = column.getForeignKeyReference(); + column.addColumnSpecs("NOT", "NULL"); + assertSame(defaultOption, column.getColumnOptions().get(0)); + assertSame(reference, column.getForeignKeyReference()); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(column, visited::add, ignored -> { + }); + assertEquals(List.of(defaultOption.getDefaultExpression()), visited); + assertEquals(Set.of("t", "parent"), new TablesNamesFinder().getTables(statement)); + StringBuilder rewritten = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(7); + } + }; + statement.accept(new StatementDeParser(expressions, new SelectDeParser(), rewritten), null); + assertEquals(statement.toString().replace("DEFAULT 1", "DEFAULT 7"), rewritten.toString()); + assertEquals(rewritten.toString(), parse(rewritten.toString()).toString()); + roundTrip(statement); + + column.setColumnSpecs(List.of("DEFAULT", "2")); + assertNull(column.getForeignKeyReference()); + visited.clear(); + TableDefinitionTraversal.visit(column, visited::add, ignored -> { + }); + assertTrue(visited.isEmpty()); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(statement)); + defaultOption.setDefaultExpression(new LongValue(9)); + assertEquals(List.of("DEFAULT", "2"), column.getColumnSpecs()); + roundTrip(statement); + } + + @Test + void nullEmptyAndAppendContractsRemainDistinct() { + ColumnDefinition column = new ColumnDefinition("id", new ColDataType("INT")); + assertNull(column.getColumnSpecs()); + assertNull(column.getColumnOptions()); + assertThrows(NullPointerException.class, + () -> column.addColumnSpecs((Collection) null)); + assertThrows(NullPointerException.class, + () -> column.addColumnOptions((ColumnOption[]) null)); + assertNull(column.getColumnOptions()); + column.setColumnSpecs(List.of()); + assertTrue(column.getColumnSpecs().isEmpty()); + assertTrue(column.getColumnOptions().isEmpty()); + assertEquals("id INT", column.toString()); + column.setColumnOptions(null); + assertNull(column.getColumnSpecs()); + column.addColumnSpecs(List.of()); + assertTrue(column.getColumnSpecs().isEmpty()); + column.setColumnSpecs(null); + assertNull(column.getColumnOptions()); + column.setColumnOptions(List.of()); + assertTrue(column.getColumnSpecs().isEmpty()); + assertEquals("INT", column.toStringDataTypeAndSpec()); + } + + @Test + void parserKeepsExistingAbsentAndEmptySpecificationBoundaries() throws JSQLParserException { + ColumnDefinition create = column(parse("CREATE TABLE t (id INT)")); + ColumnDefinition alter = column(parse("ALTER TABLE t ADD COLUMN id INT")); + assertNull(create.getColumnSpecs()); + assertNull(create.getColumnOptions()); + assertTrue(alter.getColumnSpecs().isEmpty()); + assertTrue(alter.getColumnOptions().isEmpty()); + ColumnDataType dataType = new ColumnDataType(false); + assertSame(dataType, dataType.withColumnName("id").withColDataType(new ColDataType("INT")) + .withColumnSpecs(List.of("NOT", "NULL"))); + assertSame(dataType, dataType.addColumnSpecs("DEFAULT", "1")); + assertSame(dataType, dataType.addColumnSpecs(List.of("UNIQUE"))); + assertEquals("id INT NOT NULL DEFAULT 1 UNIQUE", dataType.toString()); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)); + } + + private static ColumnDefinition column(Statement statement) { + return statement instanceof CreateTable + ? ((CreateTable) statement).getColumnDefinitions().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql)); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionMutationTest.java index bceb012c4d..3257f93134 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionMutationTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionMutationTest.java @@ -52,7 +52,7 @@ void addingStructuredOptionPreservesExistingRawSpecifications() throws JSQLParse CreateTable table = parse("id INT"); ColumnDefinition column = table.getColumnDefinitions().get(0); column.setColumnSpecs(Arrays.asList("NOT", "NULL")); - assertNull(column.getColumnOptions()); + assertEquals(ColumnOption.Kind.OTHER, column.getColumnOptions().get(0).getKind()); ForeignKeyReference reference = parse("id INT REFERENCES parent(id)") .getColumnDefinitions().get(0).getForeignKeyReference(); column.addColumnOptions(ColumnOption.reference(reference)); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionTokenTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionTokenTest.java new file mode 100644 index 0000000000..289651d33d --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/ColumnOptionTokenTest.java @@ -0,0 +1,247 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.arithmetic.Addition; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.create.table.ForeignKeyReference; +import net.sf.jsqlparser.statement.create.table.GeneratedColumnDefinition; +import net.sf.jsqlparser.statement.create.table.IdentityDefinition; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class ColumnOptionTokenTest { + // Percona Server's COLUMN_FORMAT COMPRESSED is not modeled and stays opaque. + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (id INT COLUMN_FORMAT COMPRESSED)", + "ALTER TABLE t ADD COLUMN id INT COLUMN_FORMAT COMPRESSED"}) + void parsedRawOptionsUseExplicitTokenReplacement(String sql) throws JSQLParserException { + Statement statement = parse(sql); + ColumnOption option = column(statement).getColumnOptions().stream() + .filter(raw -> raw.getTokens().contains("COMPRESSED")).findFirst().orElseThrow(); + List snapshot = option.getTokens(); + assertReadOnly(snapshot); + List replacement = new ArrayList<>(snapshot); + replacement.set(replacement.indexOf("COMPRESSED"), "FIXED"); + option.setTokens(replacement); + replacement.clear(); + assertTrue(snapshot.contains("COMPRESSED")); + assertTrue(option.getTokens().contains("FIXED")); + assertEquals(ColumnOption.Kind.OTHER, option.getKind()); + assertTrue(statement.toString().contains("COLUMN_FORMAT FIXED")); + assertRoundTrip(statement); + } + + @Test + void rawFactoriesAndSetterOwnTheirTokensWithoutParsingThem() { + List input = new ArrayList<>(List.of("DEFAULT", "1")); + ColumnOption option = ColumnOption.raw(input); + input.set(1, "99"); + List snapshot = option.getTokens(); + assertReadOnly(snapshot); + assertEquals(List.of("DEFAULT", "1"), snapshot); + assertNull(option.getDefaultExpression()); + assertEquals(ColumnOption.Kind.OTHER, option.getKind()); + option.setTokens(input); + input.clear(); + assertEquals("DEFAULT 99", option.toString()); + assertEquals(List.of("DEFAULT", "1"), snapshot); + option.setTokens(option.getTokens()); + assertEquals("DEFAULT 99", option.toString()); + + String[] array = {"NOT", "NULL"}; + ColumnOption fromArray = ColumnOption.raw(array); + array[0] = "changed"; + assertEquals("NOT NULL", fromArray.toString()); + assertReadOnly(fromArray.getTokens()); + } + + @Test + void unsetAndEmptyRawTokensRemainDistinct() { + ColumnOption option = ColumnOption.raw((List) null); + assertNull(option.getTokens()); + assertEquals("", option.toString()); + option.setTokens(List.of()); + List empty = option.getTokens(); + assertTrue(empty.isEmpty()); + assertThrows(UnsupportedOperationException.class, () -> empty.add("changed")); + option.setTokens(List.of("CUSTOM")); + assertTrue(empty.isEmpty()); + option.setTokens(null); + assertNull(option.getTokens()); + assertEquals("", option.toString()); + } + + @ParameterizedTest + @MethodSource("structuredOptions") + void tokenReplacementRejectsStructuredOptionsWithoutChangingThem(ColumnOption option) { + ColumnOption.Kind kind = option.getKind(); + String sql = option.toString(); + List snapshot = option.getTokens(); + assertReadOnly(snapshot); + assertThrows(IllegalStateException.class, () -> option.setTokens(List.of("raw"))); + assertThrows(IllegalStateException.class, () -> option.setTokens(null)); + assertEquals(kind, option.getKind()); + assertEquals(sql, option.toString()); + assertEquals(snapshot, option.getTokens()); + } + + private static Stream structuredOptions() { + return Stream.of(ColumnOption.serialDefaultValue(), + ColumnOption.reference(new ForeignKeyReference().withTable(new Table("parent")) + .withReferencedColumnNames(List.of("id"))), + ColumnOption + .identity(new IdentityDefinition(IdentityDefinition.GenerationMode.ALWAYS)), + ColumnOption.constraint(new KeyConstraint().withType("PRIMARY KEY")), + ColumnOption.constraint(new KeyConstraint().withType("UNIQUE")), + ColumnOption.defaultValue(new LongValue(1)), + ColumnOption.nullability(false), ColumnOption.nullability(true), + ColumnOption.collate("utf8mb4_bin"), + ColumnOption.comment(new StringValue("comment")), + ColumnOption.onUpdate(new LongValue(1)), + ColumnOption.generated(new GeneratedColumnDefinition(new LongValue(1))), + ColumnOption.autoIncrement(), ColumnOption.visibility(false), + ColumnOption.storage(ColumnOption.Storage.MEMORY), + ColumnOption.compression("pglz"), + ColumnOption.foreignOptions(List.of( + new ForeignDataOption("column_name", new StringValue("remote_id"))))); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (id INT DEFAULT 1)", + "ALTER TABLE t ADD COLUMN id INT DEFAULT 1"}) + void parsedDefaultsKeepLiveExpressionsAndStableTokenSnapshots(String sql) + throws JSQLParserException { + Statement statement = parse(sql); + ColumnDefinition column = column(statement); + ColumnOption option = column.getColumnOptions().get(0); + List snapshot = option.getTokens(); + assertReadOnly(snapshot); + LongValue original = (LongValue) option.getDefaultExpression(); + original.setValue(7); + assertEquals(List.of("DEFAULT", "7"), option.getTokens()); + assertEquals(List.of("DEFAULT", "1"), snapshot); + LongValue replacement = new LongValue(2); + option.setDefaultExpression(replacement); + original.setValue(99); + assertEquals(List.of("DEFAULT", "2"), option.getTokens()); + assertVisited(column, replacement); + assertCustomRendering(statement, "DEFAULT 2", "DEFAULT 42"); + assertRoundTrip(statement); + + ColumnOption raw = ColumnOption.raw(List.of("DEFAULT", "8")); + column.getColumnOptions().set(0, raw); + assertEquals(ColumnOption.Kind.OTHER, raw.getKind()); + assertNull(raw.getDefaultExpression()); + assertVisited(column); + replacement.setValue(100); + assertEquals(List.of("DEFAULT", "8"), raw.getTokens()); + assertRoundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TABLE t (source INT, computed INT GENERATED ALWAYS AS (source + 1) STORED)", + "ALTER TABLE t ADD COLUMN computed INT GENERATED ALWAYS AS (source + 1) STORED"}) + void generatedDefinitionAndOptionExposeReadOnlySnapshotsWithLiveChildren(String sql) + throws JSQLParserException { + Statement statement = parse(sql); + ColumnDefinition column = column(statement); + ColumnOption option = column.getColumnOptions().get(0); + GeneratedColumnDefinition generated = option.getGeneratedDefinition(); + List snapshot = generated.getTokens(); + List optionSnapshot = option.getTokens(); + assertReadOnly(snapshot); + assertReadOnly(optionSnapshot); + generated.setGeneratedAlways(false); + generated.setStorage(GeneratedColumnDefinition.Storage.VIRTUAL); + Addition expression = (Addition) CCJSqlParserUtil.parseExpression("source + 2"); + generated.setExpression(expression); + ((LongValue) expression.getRightExpression()).setValue(3); + assertSame(generated, option.getGeneratedDefinition()); + assertEquals(List.of("AS", "(source + 3)", "VIRTUAL"), generated.getTokens()); + assertEquals(generated.getTokens(), option.getTokens()); + assertEquals(List.of("GENERATED", "ALWAYS", "AS", "(source + 1)", "STORED"), snapshot); + assertEquals(snapshot, optionSnapshot); + assertVisited(column, expression); + assertCustomRendering(statement, "source + 3", "source + 42"); + assertRoundTrip(statement); + } + + private static void assertReadOnly(List tokens) { + assertThrows(UnsupportedOperationException.class, () -> tokens.set(0, "changed")); + assertThrows(UnsupportedOperationException.class, () -> tokens.add("changed")); + assertThrows(UnsupportedOperationException.class, tokens::clear); + } + + private static void assertVisited(ColumnDefinition column, Expression... expected) { + List expressions = new ArrayList<>(); + TableDefinitionTraversal.visit(column, expressions::add, ignored -> { + }); + assertEquals(List.of(expected), expressions); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)); + } + + private static ColumnDefinition column(Statement statement) { + if (statement instanceof CreateTable) { + List columns = ((CreateTable) statement).getColumnDefinitions(); + return columns.get(columns.size() - 1); + } + return ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0); + } + + private static void assertCustomRendering(Statement statement, String before, String after) + throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(42); + } + }; + statement.accept(new StatementDeParser(expressions, new SelectDeParser(), sql), null); + assertEquals(statement.toString().replace(before, after), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ConstraintInspectionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ConstraintInspectionTest.java new file mode 100644 index 0000000000..dd622c7517 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/ConstraintInspectionTest.java @@ -0,0 +1,414 @@ +/*- + * #%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 java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression; +import net.sf.jsqlparser.statement.alter.AlterOperation; +import net.sf.jsqlparser.statement.alter.AlterExpressionPrimaryKey; +import net.sf.jsqlparser.statement.alter.AlterExpressionDrop; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.ConstraintDeclaration; +import net.sf.jsqlparser.statement.create.table.ConstraintUsingIndex; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.KeyColumnSource; +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.Arguments; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +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; + +class ConstraintInspectionTest { + @Test + void combinesInlineAndTableDeclarationsInSourceOrder() throws Exception { + CreateTable table = table("CREATE TABLE child (id INT CONSTRAINT pk PRIMARY KEY, " + + "UNIQUE (id), parent_id INT REFERENCES parent(id), CHECK (id > 0), " + + "code INT NOT NULL DEFAULT 1)", Dialect.POSTGRESQL); + String before = table.toString(); + List declarations = table.getConstraints(); + assertEquals(List.of(ConstraintKind.PRIMARY_KEY, ConstraintKind.UNIQUE, + ConstraintKind.FOREIGN_KEY, ConstraintKind.CHECK, + ConstraintKind.NOT_NULL), kinds(declarations)); + assertSame(table.getColumnDefinitions().get(0), declarations.get(0).getColumn()); + assertEquals("pk", declarations.get(0).getConstraint().getName()); + assertSame(table.getTableConstraints().get(0), declarations.get(1).getConstraint()); + assertNull(declarations.get(1).getColumn()); + assertNull(declarations.get(1).getColumnOption()); + assertNull(declarations.get(2).getConstraint()); + assertEquals("parent", declarations.get(2).getColumnOption().getForeignKeyReference() + .getTable().getName()); + assertEquals(2, table.getTableConstraints().size()); + assertTrue(table.getIndexes().isEmpty()); + assertEquals(before, table.toString()); + assertRoundTrip(table, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"UNIQUE", "UNIQUE KEY", "UNIQUE INDEX"}) + void includesMySqlTableUniquenessDeclarationsButNotOrdinaryIndexes(String keyword) + throws Exception { + CreateTable table = table("CREATE TABLE t (id INT, " + keyword + + " uk (id), KEY ix (id), FULLTEXT KEY ft (body), body TEXT)", Dialect.MYSQL); + assertEquals(List.of(ConstraintKind.UNIQUE), kinds(table.getConstraints())); + assertEquals(keyword, table.getConstraints().get(0).getConstraint().getType()); + assertRoundTrip(table, Dialect.MYSQL); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "POSTGRESQL"}) + void keepsStandaloneUniqueIndexesInTheirStatementContext(Dialect dialect) throws Exception { + Statement statement = parse("CREATE UNIQUE INDEX uq ON t (id)", dialect); + CreateIndex index = assertInstanceOf(CreateIndex.class, statement); + assertEquals(Index.Kind.UNIQUE, index.getIndex().getKind()); + AlterExpression drop = action("ALTER TABLE t DROP INDEX uq", Dialect.MYSQL); + assertEquals(ConstraintKind.OTHER, drop.getConstraintKind()); + assertRoundTrip(statement, dialect); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "POSTGRESQL"}) + void callersCanFindAndEditPrimaryKeyOwnersWithoutMovingInlineDeclarations(Dialect dialect) + throws Exception { + CreateTable table = table("CREATE TABLE t (id INT PRIMARY KEY, label TEXT)", dialect); + ConstraintDeclaration primary = table.getConstraints().stream() + .filter(declaration -> declaration.getKind() == ConstraintKind.PRIMARY_KEY) + .findFirst().get(); + primary.getColumn().setColumnName("new_id"); + assertEquals("new_id", table.getColumnDefinitions().get(0).getColumnName()); + assertTrue(table.getIndexes() == null || table.getIndexes().isEmpty()); + assertTrue(table.toString().contains("new_id INT PRIMARY KEY")); + assertRoundTrip(table, dialect); + } + + @Test + void membershipIsASnapshotWhileKindsAndOwnersRemainLive() throws Exception { + CreateTable table = table("CREATE TABLE t (id INT, UNIQUE (id))", Dialect.POSTGRESQL); + List snapshot = table.getConstraints(); + ConstraintDeclaration declaration = snapshot.get(0); + NamedConstraint index = declaration.getConstraint(); + assertThrows(UnsupportedOperationException.class, snapshot::clear); + index.setType("PRIMARY KEY"); + assertEquals(ConstraintKind.PRIMARY_KEY, declaration.getKind()); + assertRoundTrip(table, Dialect.POSTGRESQL); + String type = index.getType(); + index.setKind(ConstraintKind.OTHER); + assertEquals(type, index.getType()); + assertEquals(ConstraintKind.OTHER, declaration.getKind()); + assertEquals(1, snapshot.size()); + assertEquals(List.of(ConstraintKind.OTHER), kinds(table.getConstraints())); + assertSame(index, table.getTableConstraints().get(0)); + index.setType("UNIQUE"); + ColumnOption notNull = ColumnOption.nullability(false); + table.getColumnDefinitions().get(0).addColumnOptions(notNull); + assertEquals(1, snapshot.size()); + List refreshed = table.getConstraints(); + assertEquals(List.of(ConstraintKind.NOT_NULL, ConstraintKind.UNIQUE), kinds(refreshed)); + notNull.setNullable(true); + assertEquals(ConstraintKind.OTHER, refreshed.get(0).getKind()); + assertEquals(List.of(ConstraintKind.UNIQUE), kinds(table.getConstraints())); + assertRoundTrip(table, Dialect.POSTGRESQL); + } + + @Test + void physicalIndexAndConstraintViewsMutateIndependently() throws Exception { + CreateTable table = table("CREATE TABLE t (id INT, KEY ix (id), " + + "CONSTRAINT uq UNIQUE (id), CONSTRAINT ck CHECK (id > 0))", Dialect.MYSQL); + Index index = table.getIndexes().get(0); + NamedConstraint check = table.getTableConstraints().get(1); + table.getTableConstraints().remove(0); + assertSame(index, table.getTableElements().get(1)); + assertSame(check, table.getTableConstraints().get(0)); + assertEquals(List.of(ConstraintKind.CHECK), kinds(table.getConstraints())); + KeyConstraint primary = new KeyConstraint().withType("PRIMARY KEY") + .withColumnsNames(List.of("id")); + table.getTableConstraints().add(0, primary); + table.setIndexes(table.getIndexes()); + assertEquals(List.of(ConstraintKind.PRIMARY_KEY, ConstraintKind.CHECK), + kinds(table.getConstraints())); + assertSame(index, table.getTableElements().get(1)); + assertSame(primary, table.getTableElements().get(2)); + assertRoundTrip(table, Dialect.MYSQL); + table.getIndexes().clear(); + assertEquals(2, table.getTableConstraints().size()); + assertRoundTrip(table, Dialect.MYSQL); + } + + @Test + void inlineStructuredConstraintsRemainVisibleWithUnknownKind() throws Exception { + CreateTable table = table("CREATE TABLE t (id INT PRIMARY KEY)", Dialect.POSTGRESQL); + NamedConstraint primary = table.getConstraints().get(0).getConstraint(); + primary.setKind(ConstraintKind.OTHER); + assertEquals(List.of(ConstraintKind.OTHER), kinds(table.getConstraints())); + assertSame(primary, table.getConstraints().get(0).getConstraint()); + assertRoundTrip(table, Dialect.POSTGRESQL); + } + + @Test + void legacyConstructionHasDocumentedOrderingAndDoesNotInterpretRawTokens() { + CreateTable table = new CreateTable(); + ColumnDefinition column = new ColumnDefinition("id", new ColDataType("INT")); + column.setColumnOptions(List.of(ColumnOption.raw("PRIMARY", "KEY"), + ColumnOption.nullability(false), ColumnOption.nullability(true))); + table.setColumnDefinitions(List.of(column)); + KeyConstraint primary = + new KeyConstraint().withType("PRIMARY KEY").withColumnsNames(List.of("id")); + table.setIndexes(List.of(new Index().withType("SPATIAL INDEX"))); + table.setTableConstraints(List.of(primary)); + assertEquals(List.of(ConstraintKind.NOT_NULL, ConstraintKind.PRIMARY_KEY), + kinds(table.getConstraints())); + assertSame(column, table.getConstraints().get(0).getColumn()); + assertSame(primary, table.getConstraints().get(1).getConstraint()); + assertTrue(!Index.class.isAssignableFrom(KeyConstraint.class)); + assertTrue(!Index.class.isAssignableFrom(NamedConstraint.class)); + assertEquals(ConstraintKind.OTHER, ColumnOption.constraint(null).getConstraintKind()); + } + + static Stream alterConstraints() { + return Stream.of( + Arguments.of("ADD PRIMARY KEY (id)", ConstraintKind.PRIMARY_KEY, + Dialect.POSTGRESQL), + Arguments.of("ADD UNIQUE (id)", ConstraintKind.UNIQUE, Dialect.POSTGRESQL), + Arguments.of("ADD UNIQUE KEY uq (id)", ConstraintKind.UNIQUE, Dialect.MYSQL), + Arguments.of("ADD FOREIGN KEY (id) REFERENCES parent(id)", + ConstraintKind.FOREIGN_KEY, + Dialect.POSTGRESQL), + Arguments.of("ADD CHECK (id > 0)", ConstraintKind.CHECK, Dialect.POSTGRESQL), + Arguments.of("ADD CONSTRAINT pk PRIMARY KEY USING INDEX ix", + ConstraintKind.PRIMARY_KEY, + Dialect.POSTGRESQL), + Arguments.of("ADD CONSTRAINT ex EXCLUDE USING gist (id WITH =)", + ConstraintKind.EXCLUDE, + Dialect.POSTGRESQL), + Arguments.of("DROP PRIMARY KEY", ConstraintKind.PRIMARY_KEY, Dialect.MYSQL), + Arguments.of("DROP FOREIGN KEY fk", ConstraintKind.FOREIGN_KEY, Dialect.MYSQL), + Arguments.of("DROP CHECK ck", ConstraintKind.CHECK, Dialect.MYSQL), + Arguments.of("DROP CONSTRAINT pk", ConstraintKind.OTHER, Dialect.POSTGRESQL), + Arguments.of("ALTER CONSTRAINT pk DEFERRABLE", ConstraintKind.OTHER, + Dialect.POSTGRESQL), + Arguments.of("ALTER CHECK ck NOT ENFORCED", ConstraintKind.CHECK, Dialect.MYSQL), + Arguments.of("ALTER CONSTRAINT ck NOT ENFORCED", ConstraintKind.OTHER, + Dialect.MYSQL), + Arguments.of("ADD INDEX ix (id)", ConstraintKind.OTHER, Dialect.MYSQL), + Arguments.of("DROP INDEX ix", ConstraintKind.OTHER, Dialect.MYSQL), + Arguments.of("DROP COLUMN id", ConstraintKind.OTHER, Dialect.POSTGRESQL), + Arguments.of("ADD COLUMN id INT PRIMARY KEY", ConstraintKind.OTHER, + Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @MethodSource("alterConstraints") + void classifiesOnlyTheExplicitKindOfTheActiveAction(String sql, ConstraintKind expected, + Dialect dialect) + throws Exception { + Alter alter = (Alter) parse("ALTER TABLE t " + sql, dialect); + String before = alter.toString(); + assertEquals(expected, alter.getAlterExpressions().get(0).getConstraintKind()); + assertEquals(before, alter.toString()); + assertRoundTrip(alter, dialect); + } + + @Test + void changingOperationDoesNotGuessANamedDropFromAnOldDefinition() throws Exception { + AlterExpression action = action("ALTER TABLE t ADD PRIMARY KEY (id)", Dialect.POSTGRESQL); + assertEquals(ConstraintKind.PRIMARY_KEY, action.getConstraintKind()); + action.setOperation(AlterOperation.DROP); + action.setConstraintName("unrelated_constraint"); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + action.setOperation(AlterOperation.DROP_FOREIGN_KEY); + assertEquals(ConstraintKind.FOREIGN_KEY, action.getConstraintKind()); + action.setOperation(AlterOperation.ADD); + action.setConstraintName(null); + action.getConstraint().setType("UNIQUE"); + assertEquals(ConstraintKind.UNIQUE, action.getConstraintKind()); + } + + @Test + void activeColumnAndCommentPayloadsHideStaleIndexMetadata() throws Exception { + List> edits = List.of( + action -> action.addColSetNotNull(new AlterExpression.ColumnSetNotNull("id")), + action -> action.addColDropNotNull(new AlterExpression.ColumnDropNotNull("id")), + action -> action.addColDropDefault(new AlterExpression.ColumnDropDefault("id")), + action -> action.setCommentText("'description'")); + for (Consumer edit : edits) { + AlterExpression action = action("ALTER TABLE t ADD PRIMARY KEY (id)", + Dialect.POSTGRESQL); + edit.accept(action); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertTrue(!action.toString().contains("PRIMARY KEY")); + } + } + + static Stream specializedActions() { + return Stream.of( + Arguments.of("ALTER TABLE t ALTER CONSTRAINT ck DEFERRABLE", Dialect.POSTGRESQL), + Arguments.of("ALTER TABLE t OWNER TO alice", Dialect.POSTGRESQL), + Arguments.of("ALTER FOREIGN TABLE t OPTIONS (ADD filename 'file')", + Dialect.POSTGRESQL), + Arguments.of("ALTER TABLE t ORDER BY id", Dialect.MYSQL), + Arguments.of("ALTER TABLE t CONVERT TO CHARACTER SET utf8mb4", Dialect.MYSQL), + Arguments.of("ALTER TABLE t DETACH PARTITION p", Dialect.POSTGRESQL), + Arguments.of("ALTER TABLE t ENGINE = InnoDB", Dialect.MYSQL), + Arguments.of("ALTER TABLE t RENAME COLUMN id TO new_id", Dialect.MYSQL)); + } + + @ParameterizedTest + @MethodSource("specializedActions") + void specializedActionsDoNotUseUnrelatedInheritedConstraintFields(String sql, Dialect dialect) + throws Exception { + Alter statement = (Alter) parse(sql, dialect); + AlterExpression action = statement.getAlterExpressions().get(0); + assertRoundTrip(statement, dialect); + action.setConstraint( + new KeyConstraint().withType("PRIMARY KEY").withColumnsNames(List.of("id"))); + action.setConstraintType("CHECK"); + action.setConstraintSymbol("unrelated"); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + action.setOperation(AlterOperation.DROP_FOREIGN_KEY); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + action.setOperation(null); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + } + + @Test + void fixedPrimaryKeyActionKeepsItsKindWhenInheritedMetadataChanges() throws Exception { + AlterExpressionPrimaryKey action = assertInstanceOf(AlterExpressionPrimaryKey.class, + action("ALTER TABLE t ALTER PRIMARY KEY USING COLUMNS (id)", Dialect.COCKROACHDB)); + String before = action.toString(); + action.setOperation(AlterOperation.DROP_FOREIGN_KEY); + action.getConstraint().setKind(ConstraintKind.UNIQUE); + assertEquals(ConstraintKind.PRIMARY_KEY, action.getConstraintKind()); + assertEquals(before, action.toString()); + action.setOperation(null); + assertEquals(ConstraintKind.PRIMARY_KEY, action.getConstraintKind()); + assertEquals(before, action.toString()); + } + + @Test + void dropColumnActionDoesNotBecomeAPrimaryKeyDeclarationFromStaleFields() throws Exception { + Alter statement = (Alter) parse("ALTER TABLE t DROP COLUMN id", Dialect.POSTGRESQL); + AlterExpressionDrop action = assertInstanceOf(AlterExpressionDrop.class, + statement.getAlterExpressions().get(0)); + String before = action.toString(); + action.setConstraint( + new KeyConstraint().withType("PRIMARY KEY").withColumnsNames(List.of("id"))); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertEquals(before, action.toString()); + assertRoundTrip(statement, Dialect.POSTGRESQL); + + // The shared renderer follows an explicitly changed operation; the active payload is + // still a column action rather than the stale PRIMARY KEY definition. + action.setOperation(AlterOperation.ADD); + assertEquals(ConstraintKind.OTHER, action.getConstraintKind()); + assertEquals("ADD COLUMN id", action.toString()); + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals("ALTER TABLE t ADD COLUMN id", sql.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP PRIMARY KEY", "DROP FOREIGN KEY fk", "DROP CHECK ck"}) + void distinguishesBaseRenamePrecedenceFromSpecializedDropRendering(String sql) + throws Exception { + AlterExpression drop = action("ALTER TABLE t " + sql, Dialect.MYSQL); + ConstraintKind expected = drop.getConstraintKind(); + String before = drop.toString(); + Index oldName = new Index().withName("old_name"); + Index newName = new Index().withName("new_name"); + drop.setOldIndex(oldName); + drop.setIndex(newName); + assertEquals(expected, drop.getConstraintKind()); + assertEquals(before, drop.toString()); + + AlterExpression base = new AlterExpression().withOperation(drop.getOperation()); + base.setOldIndex(oldName); + base.setIndex(newName); + assertTrue(base.toString().startsWith("RENAME")); + assertEquals(ConstraintKind.OTHER, base.getConstraintKind()); + + base.setOperation(AlterOperation.ALTER); + base.setConstraintType("CHECK"); + base.setConstraintSymbol("ck"); + assertTrue(base.toString().startsWith("ALTER CHECK ck")); + assertEquals(ConstraintKind.CHECK, base.getConstraintKind()); + } + + @Test + void supportsLegacyOnlyKeysWithoutMistakingDropColumnsForPrimaryKeys() { + AlterExpression legacy = new AlterExpression().withOperation(AlterOperation.ADD) + .withPkColumns(new ArrayList<>(List.of("id"))); + assertEquals(ConstraintKind.PRIMARY_KEY, legacy.getConstraintKind()); + legacy.setOperation(AlterOperation.DROP); + assertEquals(ConstraintKind.OTHER, legacy.getConstraintKind()); + legacy.setOperation(AlterOperation.DROP_UNIQUE); + assertEquals(ConstraintKind.UNIQUE, legacy.getConstraintKind()); + assertEquals(ConstraintKind.OTHER, new AlterExpression().getConstraintKind()); + } + + @Test + void existingIndexConstraintsRetainTheirEditableSourceAndHaveNoInventedKeys() throws Exception { + AlterExpression action = + action("ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY USING INDEX ix", + Dialect.POSTGRESQL); + ConstraintUsingIndex constraint = assertInstanceOf(ConstraintUsingIndex.class, + action.getConstraint()); + assertEquals(ConstraintKind.PRIMARY_KEY, action.getConstraintKind()); + assertTrue(!KeyColumnSource.class.isAssignableFrom(ConstraintUsingIndex.class)); + constraint.setExistingIndexName("new_ix"); + assertTrue(action.toString().contains("USING INDEX new_ix")); + } + + private static List kinds(List declarations) { + return declarations.stream().map(ConstraintDeclaration::getKind) + .collect(Collectors.toList()); + } + + private static Statement parse(String sql, Dialect dialect) throws Exception { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static CreateTable table(String sql, Dialect dialect) throws Exception { + return (CreateTable) parse(sql, dialect); + } + + private static AlterExpression action(String sql, Dialect dialect) throws Exception { + return ((Alter) parse(sql, dialect)).getAlterExpressions().get(0); + } + + private static void assertRoundTrip(Statement statement, Dialect dialect) throws Exception { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/CreateFunctionalStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/create/CreateFunctionalStatementTest.java index 66880938c2..52f250afeb 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/CreateFunctionalStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/CreateFunctionalStatementTest.java @@ -15,8 +15,18 @@ import java.util.Arrays; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.MySqlDefiner; +import net.sf.jsqlparser.statement.CreateFunctionalStatement; import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.create.event.CreateEvent; +import net.sf.jsqlparser.statement.create.view.CreateView; +import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import net.sf.jsqlparser.statement.create.function.CreateFunction; import net.sf.jsqlparser.statement.create.procedure.CreateProcedure; import org.junit.jupiter.api.Test; @@ -89,6 +99,65 @@ public void createOrReplaceFunctionMinimal() throws JSQLParserException { assertDeparse(func, statement); } + @ParameterizedTest + @ValueSource(strings = { + "CREATE DEFINER = CURRENT_USER FUNCTION f2 (s CHAR(20)) RETURNS CHAR(50) " + + "CHARSET utf8mb4 NO SQL RETURN CONCAT('Hello, ', s, '!')", + "CREATE DEFINER = CURRENT_USER PROCEDURE p3 () SELECT 1", + "CREATE DEFINER = `root`@`%` FUNCTION f3 () RETURNS INT RETURN 1", + "CREATE DEFINER = 'admin'@'localhost' PROCEDURE p (IN a INT) BEGIN SELECT a; END", + "CREATE OR REPLACE DEFINER = CURRENT_USER() PROCEDURE p () SELECT 1"}) + public void createRoutineWithMySqlDefiner(String sql) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, null}) { + CreateFunctionalStatement statement = + (CreateFunctionalStatement) assertSqlCanBeParsedAndDeparsed( + sql, true, dialect == null ? parser -> { + } : parser -> parser.withDialect(dialect)); + assertThat(statement.getDefiner()).isNotNull(); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertThat(deparsed.toString()).isEqualTo(statement.toString()); + assertThat(CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1").getStatements()) + .hasSize(2); + } + } + + @Test + public void mySqlDefinerAccount() throws JSQLParserException { + CreateFunction function = (CreateFunction) CCJSqlParserUtil.parse( + "CREATE DEFINER='root'@'%' FUNCTION f3 () RETURNS INT RETURN 1"); + MySqlDefiner definer = function.getDefiner(); + assertThat(definer.getUser().getValue()).isEqualTo("root"); + assertThat(definer.getHost().getValue()).isEqualTo("%"); + assertThat(function.getFunctionDeclarationParts()).startsWith("f3", "(", ")"); + + CreateProcedure procedure = (CreateProcedure) CCJSqlParserUtil + .parse("CREATE DEFINER = CURRENT_USER PROCEDURE p3 () SELECT 1"); + assertThat(procedure.getDefiner().getUser().getValue()).isEqualTo("CURRENT_USER"); + assertThat(procedure.getDefiner().getHost()).isNull(); + + procedure.setDefiner(new MySqlDefiner().withUser(new StringValue("app")) + .withHost(new StringValue("%"))); + assertThat(procedure.toString()) + .isEqualTo("CREATE DEFINER = 'app'@'%' PROCEDURE p3 ( ) SELECT 1"); + procedure.setDefiner(null); + assertThat(procedure.toString()).isEqualTo("CREATE PROCEDURE p3 ( ) SELECT 1"); + } + + @Test + public void definerDispatchKeepsTriggersAndViews() throws JSQLParserException { + assertThat(CCJSqlParserUtil.parse("CREATE DEFINER = CURRENT_USER TRIGGER t " + + "BEFORE INSERT ON t1 FOR EACH ROW SET NEW.a = 1")) + .isInstanceOf(CreateTrigger.class); + assertThat(CCJSqlParserUtil.parse("CREATE DEFINER = CURRENT_USER VIEW v AS SELECT 1")) + .isInstanceOf(CreateView.class); + assertThat(CCJSqlParserUtil.parse("CREATE FUNCTION f() RETURNS int AS 'SELECT 1'")) + .isInstanceOf(CreateFunction.class) + .extracting(statement -> ((CreateFunction) statement).getDefiner()).isNull(); + assertThat(CCJSqlParserUtil.parse("CREATE DEFINER = x EVENT e " + + "ON SCHEDULE EVERY 1 DAY DO SELECT 1")).isInstanceOf(CreateEvent.class); + } + @Test public void createFunctionWithPositionalParametersAcrossStatementsIssue2322() throws JSQLParserException { diff --git a/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexOptionStateTest.java b/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexOptionStateTest.java new file mode 100644 index 0000000000..981b68f210 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexOptionStateTest.java @@ -0,0 +1,240 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.api.Test; + +class CreateIndexOptionStateTest { + private static final String SQL = "CREATE UNIQUE INDEX ix ON t (id) INCLUDE (payload) " + + "NULLS NOT DISTINCT WITH (fillfactor = 80) TABLESPACE fast_space"; + + @Test + void parsedOptionsAreSharedAndIndexEditsReachBothRenderers() throws Exception { + CreateIndex statement = parse(SQL); + Index index = statement.getIndex(); + assertSame(statement.getIncludeColumns(), index.getIncludeColumns()); + assertSame(statement.getStorageParameters(), index.getStorageParameters()); + assertEquals(Boolean.FALSE, index.getNullsDistinct()); + assertEquals("fast_space", index.getTableSpace()); + + index.getIncludeColumns().add("extra"); + index.setNullsDistinct(true); + index.getStorageParameters().get(0).setValue(new LongValue(90)); + index.setTableSpace("other_space"); + + assertEquals(List.of("payload", "extra"), statement.getIncludeColumns()); + assertEquals(Boolean.TRUE, statement.getNullsDistinct()); + assertEquals("other_space", statement.getTableSpace()); + assertRoundTrip("CREATE UNIQUE INDEX ix ON t (id) INCLUDE (payload, extra) " + + "NULLS DISTINCT WITH (fillfactor = 90) TABLESPACE other_space", statement); + } + + @Test + void statementSettersAndClearsUpdateTheIndexDefinition() throws Exception { + CreateIndex statement = parse("CREATE UNIQUE INDEX ix ON t (id)"); + statement.setIncludeColumns(List.of("payload")); + statement.setNullsDistinct(false); + statement.setStorageParameters(List.of(option(80))); + statement.setTableSpace("fast_space"); + Index index = statement.getIndex(); + assertSame(statement.getIncludeColumns(), index.getIncludeColumns()); + assertSame(statement.getStorageParameters(), index.getStorageParameters()); + assertEquals(Boolean.FALSE, index.getNullsDistinct()); + assertEquals("fast_space", index.getTableSpace()); + assertRoundTrip(SQL, statement); + + statement.setIncludeColumns(null); + statement.setNullsDistinct(null); + statement.setStorageParameters(null); + statement.setTableSpace(null); + assertNull(index.getIncludeColumns()); + assertNull(index.getNullsDistinct()); + assertNull(index.getStorageParameters()); + assertNull(index.getTableSpace()); + assertRoundTrip("CREATE UNIQUE INDEX ix ON t (id)", statement); + } + + @Test + void optionsCanBeConfiguredBeforeTheIndexWithoutLosingSuppliedOptions() throws Exception { + CreateIndex statement = new CreateIndex().withTable(new Table("t")) + .withIncludeColumns(List.of("payload")) + .withNullsDistinct(false) + .withStorageParameters(List.of(option(80))) + .withTableSpace("staged_space"); + assertNull(statement.getIndex()); + assertEquals("staged_space", statement.getTableSpace()); + + Index index = new Index().withType("UNIQUE").withName("ix") + .withColumnsNames(List.of("id")); + index.setTableSpace("fast_space"); + statement.setIndex(index); + + assertSame(index, statement.getIndex()); + assertSame(statement.getStorageParameters(), index.getStorageParameters()); + assertRoundTrip(SQL, statement); + } + + @Test + void replacementOptionsTakePrecedenceAndMissingOptionsSurviveDetachment() throws Exception { + CreateIndex statement = parse(SQL); + Index replacement = new Index().withType("UNIQUE").withName("replacement") + .withColumnsNames(List.of("id")); + replacement.setIncludeColumns(List.of("extra")); + replacement.setStorageParameters(List.of(option(90))); + statement.setIndex(replacement); + statement.setIndex(replacement); + assertSame(replacement.getIncludeColumns(), statement.getIncludeColumns()); + assertRoundTrip("CREATE UNIQUE INDEX replacement ON t (id) INCLUDE (extra) " + + "NULLS NOT DISTINCT WITH (fillfactor = 90) TABLESPACE fast_space", statement); + + statement.setIndex(null); + statement.setIndex(null); + assertNull(statement.getIndex()); + assertEquals(List.of("extra"), statement.getIncludeColumns()); + assertEquals(Boolean.FALSE, statement.getNullsDistinct()); + assertEquals("fast_space", statement.getTableSpace()); + statement.setTableSpace(null); + Index reattached = new Index().withType("UNIQUE").withName("reattached") + .withColumnsNames(List.of("id")); + statement.setIndex(reattached); + assertSame(reattached.getStorageParameters(), statement.getStorageParameters()); + assertNull(reattached.getTableSpace()); + assertRoundTrip("CREATE UNIQUE INDEX reattached ON t (id) INCLUDE (extra) " + + "NULLS NOT DISTINCT WITH (fillfactor = 90)", statement); + } + + @Test + void detachedOptionSettersDoNotMutateTheRemovedIndex() throws Exception { + CreateIndex statement = parse(SQL); + Index removed = statement.getIndex(); + statement.setIndex(null); + + assertNotSame(removed.getIncludeColumns(), statement.getIncludeColumns()); + assertNotSame(removed.getStorageParameters(), statement.getStorageParameters()); + assertSame(removed.getStorageParameters().get(0), statement.getStorageParameters().get(0)); + List detachedColumns = statement.getIncludeColumns(); + List detachedParameters = statement.getStorageParameters(); + statement.setIndex(null); + assertSame(detachedColumns, statement.getIncludeColumns()); + assertSame(detachedParameters, statement.getStorageParameters()); + statement.getIncludeColumns().add("extra"); + assertEquals(List.of("payload", "extra"), statement.getIncludeColumns()); + assertEquals(List.of("payload"), removed.getIncludeColumns()); + + statement.setTableSpace("detached_space"); + statement.setNullsDistinct(true); + statement.setIncludeColumns(List.of("detached_payload")); + statement.setStorageParameters(List.of(option(90))); + assertEquals("fast_space", removed.getTableSpace()); + assertEquals(Boolean.FALSE, removed.getNullsDistinct()); + assertEquals(List.of("payload"), removed.getIncludeColumns()); + assertEquals("80", removed.getStorageParameters().get(0).getValue().toString()); + + removed.setTableSpace("external_space"); + removed.setNullsDistinct(null); + assertEquals("detached_space", statement.getTableSpace()); + assertEquals(Boolean.TRUE, statement.getNullsDistinct()); + statement.setIndex(new Index().withType("UNIQUE").withName("reattached") + .withColumnsNames(List.of("id"))); + assertRoundTrip("CREATE UNIQUE INDEX reattached ON t (id) INCLUDE (detached_payload) " + + "NULLS DISTINCT WITH (fillfactor = 90) TABLESPACE detached_space", statement); + } + + @Test + void optionsAreVisitedBeforeAttachmentAndAfterDetachment() throws Exception { + for (CreateIndex statement : List.of(new CreateIndex(), parse(SQL))) { + statement.setIndex(null); + statement.setStorageParameters(List.of(option(80))); + List values = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S context) { + assertEquals("context", context); + values.add(value.getValue()); + return null; + } + }; + statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + "context"); + assertEquals(List.of(80L), values); + } + } + + @Test + void indexOptionEditsAreVisitedOnceAndCanBeDeparsedThroughCustomVisitors() throws Exception { + CreateIndex statement = parse(SQL); + statement.getIndex().setStorageParameters(List.of(option(90))); + List values = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S context) { + assertEquals("context", context); + values.add(value.getValue()); + return null; + } + }; + statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + "context"); + assertEquals(List.of(90L), values); + + StringBuilder output = new StringBuilder(); + ExpressionDeParser deparser = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(value.getValue() + 1); + } + }; + statement.accept(new StatementDeParser(deparser, new SelectDeParser(), output)); + assertEquals(SQL.replace("80", "91"), output.toString()); + assertEquals(output.toString(), parse(output.toString()).toString()); + assertEquals(SQL.replace("80", "90"), statement.toString()); + } + + private static IndexOption option(long value) { + return new IndexOption("fillfactor", new LongValue(value), true); + } + + private static CreateIndex parse(String sql) throws Exception { + return (CreateIndex) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(String expected, CreateIndex statement) throws Exception { + assertEquals(expected, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(expected, output.toString()); + CreateIndex reparsed = parse(expected); + assertEquals(expected, reparsed.toString()); + assertEquals(statement.getIncludeColumns(), reparsed.getIndex().getIncludeColumns()); + assertEquals(statement.getNullsDistinct(), reparsed.getIndex().getNullsDistinct()); + assertEquals(statement.getTableSpace(), reparsed.getIndex().getTableSpace()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexTest.java b/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexTest.java index 32baade27c..7fa9d1bcc5 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/CreateIndexTest.java @@ -9,6 +9,8 @@ */ package net.sf.jsqlparser.statement.create; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.KeyElement; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -21,7 +23,6 @@ import net.sf.jsqlparser.parser.CCJSqlParserManager; import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.statement.create.index.CreateIndex; -import net.sf.jsqlparser.statement.create.table.Index; import org.junit.jupiter.api.Test; public class CreateIndexTest { @@ -193,7 +194,7 @@ public void testCreateIndexKeyPartWithPrefixLengthAndDirectionIssue2490() assertEquals(2, params.size()); assertEquals("(20)", params.get(0)); assertEquals("DESC", params.get(1)); - assertEquals(Index.ColumnParams.SortOrder.DESC, + assertEquals(KeyElement.SortOrder.DESC, createIndex.getIndex().getColumns().get(0).getSortOrder()); assertSqlCanBeParsedAndDeparsed("CREATE INDEX i03 ON t (c1 (20) DESC)"); @@ -251,15 +252,15 @@ public void testPostgreSqlIndexKeyAttributesIssue2525() throws JSQLParserExcepti + "(id DESC NULLS FIRST)"; CreateIndex ordered = (CreateIndex) assertSqlCanBeParsedAndDeparsed( orderSql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); - Index.ColumnParams orderedKey = ordered.getIndex().getColumns().get(0); - assertEquals(Index.ColumnParams.SortOrder.DESC, orderedKey.getSortOrder()); - assertEquals(Index.ColumnParams.NullOrdering.FIRST, orderedKey.getNullOrdering()); + KeyElement orderedKey = ordered.getIndex().getColumns().get(0); + assertEquals(KeyElement.SortOrder.DESC, orderedKey.getSortOrder()); + assertEquals(KeyElement.NullOrdering.FIRST, orderedKey.getNullOrdering()); String operatorClassSql = "CREATE INDEX pg_idx_collate ON pg_index_test " + "(email COLLATE \"C\" text_pattern_ops)"; CreateIndex operatorClassIndex = (CreateIndex) assertSqlCanBeParsedAndDeparsed( operatorClassSql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); - Index.ColumnParams operatorClassKey = + KeyElement operatorClassKey = operatorClassIndex.getIndex().getColumns().get(0); assertEquals("\"C\"", operatorClassKey.getCollation()); assertEquals("text_pattern_ops", operatorClassKey.getOperatorClass()); @@ -268,7 +269,7 @@ public void testPostgreSqlIndexKeyAttributesIssue2525() throws JSQLParserExcepti + "(email text_pattern_ops (example = 1))"; CreateIndex optionIndex = (CreateIndex) assertSqlCanBeParsedAndDeparsed( optionSql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); - Index.Option option = optionIndex.getIndex().getColumns().get(0) + IndexOption option = optionIndex.getIndex().getColumns().get(0) .getOperatorClassParameters().get(0); assertEquals("example", option.getName()); assertEquals("1", option.getValue().toString()); @@ -288,7 +289,7 @@ public void testPostgreSqlIndexTrailingClausesIssue2525() throws JSQLParserExcep + "WITH (fillfactor = 80) TABLESPACE pg_default WHERE active"; CreateIndex trailing = (CreateIndex) assertSqlCanBeParsedAndDeparsed( trailingSql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); - Index.Option fillfactor = trailing.getStorageParameters().get(0); + IndexOption fillfactor = trailing.getStorageParameters().get(0); assertEquals("fillfactor", fillfactor.getName()); assertEquals("80", fillfactor.getValue().toString()); assertTrue(fillfactor.isUseEquals()); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/CreateTableDataPopulationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/CreateTableDataPopulationTest.java new file mode 100644 index 0000000000..8e52932cbd --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/CreateTableDataPopulationTest.java @@ -0,0 +1,86 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.view.CreateView; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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 CreateTableDataPopulationTest { + @ParameterizedTest + @ValueSource(strings = {"SELECT id FROM source", "TABLE source", "VALUES (1), (2)", + "(SELECT id FROM source)", "WITH c AS (SELECT 1 AS id) SELECT id FROM c", + "SELECT id FROM source UNION ALL SELECT id FROM other ORDER BY id LIMIT 4"}) + void preservesDataChoiceForQuerySources(String query) throws JSQLParserException { + for (String suffix : new String[] {"", " WITH DATA", " WITH NO DATA"}) { + CreateTable table = parse("CREATE TABLE t AS " + query + suffix); + assertEquals(suffix.isEmpty() ? null : !suffix.contains("NO"), table.getWithData()); + roundTrip(table); + } + } + + @Test + void sharesOutputAndKeepsCustomQueryVisitor() throws JSQLParserException { + CreateTable table = + parse("CREATE TEMP TABLE t (id) ON COMMIT DROP AS SELECT 7 WITH NO DATA"); + table.setWithData(true); + assertTrue(table.toString().endsWith("WITH DATA")); + ExpressionDeParser expression = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append(value.getValue() + 100); + } + }; + StringBuilder out = new StringBuilder(); + table.accept(new StatementDeParser(expression, new SelectDeParser(), out)); + assertTrue(out.toString().endsWith("SELECT 107 WITH DATA")); + assertTrue(table.toString().contains("SELECT 7")); + table.setWithData(null); + assertFalse(table.toString().contains("WITH DATA")); + roundTrip(table); + } + + @Test + void retainsMaterializedViewTailAndStatementBoundaries() throws JSQLParserException { + CreateView view = (CreateView) CCJSqlParserUtil.parse( + "CREATE MATERIALIZED VIEW v AS SELECT 1 WITH NO DATA"); + assertEquals(Boolean.FALSE, view.getWithData()); + assertEquals(2, CCJSqlParserUtil.parseStatements( + "CREATE TABLE t AS SELECT 1 WITH NO DATA; SELECT 2").size()); + for (String sql : List.of("CREATE TABLE t AS SELECT 1 WITH NO", + "CREATE TABLE t AS SELECT 1 WITH DATA WITH NO DATA", + "SELECT 1 WITH NO DATA")) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + } + + private static CreateTable parse(String sql) throws JSQLParserException { + return (CreateTable) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(CreateTable table) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + table.accept(new StatementDeParser(out)); + assertEquals(table.toString(), out.toString()); + assertEquals(table.getWithData(), parse(out.toString()).getWithData()); + assertEquals(out.toString(), parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/CreateTableTest.java b/src/test/java/net/sf/jsqlparser/statement/create/CreateTableTest.java index 9cd27a797d..fe1cbee377 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/CreateTableTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/CreateTableTest.java @@ -39,9 +39,10 @@ import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; -import net.sf.jsqlparser.statement.create.table.ForeignKeyIndex; -import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; import net.sf.jsqlparser.statement.create.table.PartitionBound; import net.sf.jsqlparser.statement.create.table.RowMovementMode; import net.sf.jsqlparser.statement.create.table.TablePartitioning; @@ -59,6 +60,14 @@ public void testCreateTableOrReplace() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed(statement); } + @Test + public void testCreateTableCopyGrants() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed( + "CREATE OR REPLACE TABLE testtab COPY GRANTS AS (SELECT a FROM tbl)"); + assertSqlCanBeParsedAndDeparsed( + "CREATE OR REPLACE TABLE testtab (a VARCHAR (255)) COPY GRANTS"); + } + @Test public void testCreateTable2() throws JSQLParserException { String statement = "CREATE TABLE testtab (\"test\" varchar (255))"; @@ -95,8 +104,9 @@ public void testCreateTable() throws JSQLParserException { assertFalse(createTable.isUnlogged()); assertEquals("mycol", createTable.getColumnDefinitions().get(0).getColumnName()); assertEquals("mycol2", createTable.getColumnDefinitions().get(1).getColumnName()); - assertEquals("PRIMARY KEY", createTable.getIndexes().get(0).getType()); - assertEquals("mycol", createTable.getIndexes().get(0).getColumnsNames().get(1)); + assertEquals("PRIMARY KEY", createTable.getTableConstraints().get(0).getType()); + assertEquals("mycol", ((KeyConstraint) createTable.getTableConstraints().get(0)) + .getColumnsNames().get(1)); assertEquals(statement, "" + createTable); } @@ -110,8 +120,9 @@ public void testCreateTableUnlogged() throws JSQLParserException { assertTrue(createTable.isUnlogged()); assertEquals("mycol", createTable.getColumnDefinitions().get(0).getColumnName()); assertEquals("mycol2", createTable.getColumnDefinitions().get(1).getColumnName()); - assertEquals("PRIMARY KEY", createTable.getIndexes().get(0).getType()); - assertEquals("mycol", createTable.getIndexes().get(0).getColumnsNames().get(1)); + assertEquals("PRIMARY KEY", createTable.getTableConstraints().get(0).getType()); + assertEquals("mycol", ((KeyConstraint) createTable.getTableConstraints().get(0)) + .getColumnsNames().get(1)); assertEquals(statement, "" + createTable); } @@ -211,9 +222,9 @@ public void testCreateTableUniqueConstraintAfterPrimaryKey() throws JSQLParserEx CreateTable createTable = (CreateTable) CCJSqlParserUtil.parseStatements(sqlStr).getStatements().get(0); - assertEquals("PRIMARY KEY", createTable.getIndexes().get(0).getType()); - assertEquals("UNIQUE", createTable.getIndexes().get(1).getType()); - assertEquals("FOREIGN KEY", createTable.getIndexes().get(2).getType()); + assertEquals("PRIMARY KEY", createTable.getTableConstraints().get(0).getType()); + assertEquals("UNIQUE", createTable.getTableConstraints().get(1).getType()); + assertEquals("FOREIGN KEY", createTable.getTableConstraints().get(2).getType()); } @Test @@ -475,7 +486,7 @@ public void testExcludeWhereConstraint() throws JSQLParserException { assertDeparse( new CreateTable() .withTable(new Table("foo")) - .addIndexes( + .addTableConstraints( new ExcludeConstraint() .withExpression( new GreaterThan() @@ -635,11 +646,15 @@ public void testRUBiSCreateList() throws Exception { .getColumnDefinitions()) { String colName = columnDefinition.getColumnName(); boolean unique = false; - if (createTable.getIndexes() != null) { - for (Index index : createTable.getIndexes()) { - if (index.getType().equals("PRIMARY KEY") - && index.getColumnsNames().size() == 1 - && index.getColumnsNames().get(0).equals(colName)) { + if (createTable.getTableConstraints() != null) { + for (NamedConstraint constraint : createTable + .getTableConstraints()) { + if (constraint instanceof KeyConstraint + && constraint.getKind() == ConstraintKind.PRIMARY_KEY + && ((KeyConstraint) constraint).getColumnsNames() + .size() == 1 + && ((KeyConstraint) constraint).getColumnsNames().get(0) + .equals(colName)) { unique = true; } } @@ -1183,8 +1198,9 @@ void testCreateTableIndexVisibility() throws JSQLParserException { ") ENGINE = InnoDB"; CreateTable createTable = (CreateTable) assertSqlCanBeParsedAndDeparsed(sqlStr, true); - assertEquals(Arrays.asList("INVISIBLE"), createTable.getIndexes().get(1).getIndexSpec()); - assertEquals(Arrays.asList("VISIBLE"), createTable.getIndexes().get(2).getIndexSpec()); + assertEquals(Arrays.asList("INVISIBLE"), createTable.getIndexes().get(0).getIndexSpec()); + assertEquals(Arrays.asList("VISIBLE"), + ((KeyConstraint) createTable.getTableConstraints().get(1)).getIndexSpec()); } @Test @@ -1283,7 +1299,7 @@ void testMySqlConstraintSymbolAndIndexNameIssue1570() throws JSQLParserException String uniqueSql = "CREATE TABLE table1 (col1 INT, col2 INT UNIQUE, " + "CONSTRAINT my_constraint UNIQUE KEY index_name (col1))"; CreateTable uniqueTable = (CreateTable) assertSqlCanBeParsedAndDeparsed(uniqueSql, true); - NamedConstraint unique = (NamedConstraint) uniqueTable.getIndexes().get(0); + KeyConstraint unique = (KeyConstraint) uniqueTable.getTableConstraints().get(0); assertEquals("my_constraint", unique.getName()); assertEquals("index_name", unique.getIndexName()); @@ -1294,7 +1310,8 @@ void testMySqlConstraintSymbolAndIndexNameIssue1570() throws JSQLParserException + "REFERENCES parent (id))"; CreateTable foreignKeyTable = (CreateTable) assertSqlCanBeParsedAndDeparsed(foreignKeySql, true); - ForeignKeyIndex foreignKey = (ForeignKeyIndex) foreignKeyTable.getIndexes().get(0); + ForeignKeyConstraint foreignKey = + (ForeignKeyConstraint) foreignKeyTable.getTableConstraints().get(0); assertEquals("fk_parent", foreignKey.getName()); assertEquals("fk_parent_idx", foreignKey.getIndexName()); @@ -1310,7 +1327,7 @@ void testMySqlUnnamedConstraintAndUniqueIndexOptionsIssues1570And538() + "pay_way VARCHAR (32), UNIQUE uniq_platform_payway USING BTREE " + "(platform_code, pay_way) COMMENT 'should be unique')"; CreateTable createTable = (CreateTable) assertSqlCanBeParsedAndDeparsed(sql, true); - NamedConstraint unique = (NamedConstraint) createTable.getIndexes().get(0); + KeyConstraint unique = (KeyConstraint) createTable.getTableConstraints().get(0); assertNull(unique.getName()); assertEquals("uniq_platform_payway", unique.getIndexName()); @@ -1371,4 +1388,21 @@ void testPostgreSqlDeclarativePartitionChildrenIssue2522() throws JSQLParserExce defaultSql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); assertEquals(PartitionBound.Type.DEFAULT, defaultPartition.getPartitionBound().getType()); } + + @Test + void testCreateOrReplaceTableCopyGrantsAsSelectFromFlattenedVariant() + throws JSQLParserException { + String sql = + "CREATE OR REPLACE TABLE \"MY_DB\".\"MY_SCHEMA\".\"STAGING_TRACES\" COPY GRANTS\n" + + "AS (SELECT\n" + + " *\n" + + "FROM (SELECT\n" + + " \"FLATTEN_VARIANT_INPUT\".\"DATA_VALUE\":id::VARCHAR AS \"id\",\n" + + " \"FLATTEN_VARIANT_INPUT\".\"DATA_VALUE\":input::VARIANT AS \"input\",\n" + + " \"FLATTEN_VARIANT_INPUT\".\"DATA_VALUE\":output::VARIANT AS \"output\"\n" + + "FROM (SELECT\n" + + " \"DATA_VALUE\"\n" + + " FROM \"MY_DB\".\"MY_SCHEMA\".\"RAW_TRACES\") AS \"FLATTEN_VARIANT_INPUT\"))"; + assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SNOWFLAKE)); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/DdlParameterListTest.java b/src/test/java/net/sf/jsqlparser/statement/create/DdlParameterListTest.java new file mode 100644 index 0000000000..5f1dd5f9eb --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/DdlParameterListTest.java @@ -0,0 +1,57 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.assertEquals; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserConstants; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.ParseException; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class DdlParameterListTest { + @ParameterizedTest + @ValueSource(strings = { + "CREATE VECTOR INDEX items_hnsw ON items (embedding) ORGANIZATION INMEMORY NEIGHBOR GRAPH DISTANCE COSINE WITH TARGET ACCURACY 95 PARAMETERS (TYPE HNSW,NEIGHBORS 32,EFCONSTRUCTION 500)", + "CREATE VECTOR INDEX items_ivf ON items (embedding) ORGANIZATION NEIGHBOR PARTITIONS DISTANCE COSINE WITH TARGET ACCURACY 95 PARAMETERS (TYPE IVF,NEIGHBOR PARTITIONS 10)", + "CREATE TABLE samples (id INT) STORAGE (INITIAL 65536,NEXT 131072)"}) + void ddlParametersKeepSeparateWordsAndNumbers(String sql) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.ORACLE}) { + Statement statement = CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + assertEquals(sql, statement.toString()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + assertEquals(sql, CCJSqlParserUtil.parse(output.toString()).toString()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"()", "(1,2,3)", "(name=value,count=32)", + "(TYPE HNSW,NEIGHBORS 32,EFCONSTRUCTION 500)", + "(enabled TRUE,ratio 0.5,disabled FALSE)", + "('keep two spaces','comma,equals=','it''s fine')", + "(\"Quoted Name\" 10,\"dotted.name\" 20)"}) + void preservesLiteralsQuotedNamesAndExplicitDelimiters(String list) throws ParseException { + CCJSqlParser parser = CCJSqlParserUtil.newParser(list); + assertEquals(list, parser.AList()); + assertEquals(CCJSqlParserConstants.EOF, parser.getNextToken().kind); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/DialectIndexDefinitionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/DialectIndexDefinitionTest.java index 69de8156da..c5860a05e3 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/DialectIndexDefinitionTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/DialectIndexDefinitionTest.java @@ -9,6 +9,8 @@ */ package net.sf.jsqlparser.statement.create; +import net.sf.jsqlparser.statement.create.table.IndexOptions; +import net.sf.jsqlparser.statement.create.table.KeyElement; import static net.sf.jsqlparser.test.TestUtils.assertDeparse; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -43,8 +45,8 @@ void parsesSqlServerIndexModifiers(String modifiers) throws Exception { parser -> parser.withDialect(Dialect.SQLSERVER)); Index index = statement.getIndex(); assertEquals(modifiers.contains("UNIQUE") ? "UNIQUE" : null, index.getType()); - assertEquals(modifiers.contains("NONCLUSTERED") ? Index.Clustering.NONCLUSTERED - : modifiers.contains("CLUSTERED") ? Index.Clustering.CLUSTERED : null, + assertEquals(modifiers.contains("NONCLUSTERED") ? IndexOptions.Clustering.NONCLUSTERED + : modifiers.contains("CLUSTERED") ? IndexOptions.Clustering.CLUSTERED : null, index.getClustering()); assertFalse(statement.isNullFiltered()); assertEquals(index.getClustering(), parse(statement.toString(), Dialect.SQLSERVER) @@ -108,7 +110,7 @@ void rejectsDuplicateOrReversedModifiers() { void rendersModifiedClusteringAndNullFiltering() throws Exception { CreateIndex sqlServer = parse("CREATE UNIQUE NONCLUSTERED INDEX ix ON t (id)", Dialect.SQLSERVER); - sqlServer.getIndex().setClustering(Index.Clustering.CLUSTERED); + sqlServer.getIndex().setClustering(IndexOptions.Clustering.CLUSTERED); assertDeparse(sqlServer, "CREATE UNIQUE CLUSTERED INDEX ix ON t (id)"); sqlServer.getIndex().setClustering(null); assertDeparse(sqlServer, "CREATE UNIQUE INDEX ix ON t (id)"); @@ -128,7 +130,7 @@ void parsesSakilaIndexAndFollowingStatementsIssue1563() throws Exception { Statements statements = CCJSqlParserUtil.parseStatements(sql + "\nGO\nSELECT 1;", parser -> parser.withDialect(Dialect.SQLSERVER)); assertEquals(2, statements.size()); - assertEquals(Index.Clustering.NONCLUSTERED, + assertEquals(IndexOptions.Clustering.NONCLUSTERED, ((CreateIndex) statements.get(0)).getIndex().getClustering()); assertEquals("SELECT 1", statements.get(1).toString()); } @@ -139,17 +141,17 @@ void parsesQualifiedPostgreSqlAttributesIssue1994() throws Exception { + "(\"keyword\" COLLATE \"pg_catalog\".\"default\" \"pg_catalog\".\"text_ops\" ASC NULLS LAST)"; CreateIndex statement = (CreateIndex) assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); - Index.ColumnParams key = statement.getIndex().getColumns().get(0); + KeyElement key = statement.getIndex().getColumns().get(0); assertEquals("\"pg_catalog\".\"default\"", key.getCollation()); assertEquals("\"pg_catalog\".\"text_ops\"", key.getOperatorClass()); - assertEquals(Index.ColumnParams.SortOrder.ASC, key.getSortOrder()); - assertEquals(Index.ColumnParams.NullOrdering.LAST, key.getNullOrdering()); + assertEquals(KeyElement.SortOrder.ASC, key.getSortOrder()); + assertEquals(KeyElement.NullOrdering.LAST, key.getNullOrdering()); assertNull(key.getParams()); key.setCollation("public.\"C\""); key.setOperatorClass("public.text_pattern_ops"); - key.setSortOrder(Index.ColumnParams.SortOrder.DESC); - key.setNullOrdering(Index.ColumnParams.NullOrdering.FIRST); + key.setSortOrder(KeyElement.SortOrder.DESC); + key.setNullOrdering(KeyElement.NullOrdering.FIRST); assertDeparse(statement, "CREATE INDEX \"index_keyword\" ON \"inter\".\"inter_ti_rec\" USING btree " + "(\"keyword\" COLLATE public.\"C\" public.text_pattern_ops DESC NULLS FIRST)"); @@ -169,7 +171,7 @@ void preservesQuotedNamePartsAndBareFunctionKeys() throws Exception { + "\"schema\".\"op\"\"class\" DESC NULLS FIRST)"; CreateIndex statement = (CreateIndex) assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.POSTGRESQL)); - Index.ColumnParams key = statement.getIndex().getColumns().get(0); + KeyElement key = statement.getIndex().getColumns().get(0); assertTrue(key.isExpression()); assertFalse(key.isExpressionParenthesized()); assertEquals("\"schema.with.dot\".\"C\"", key.getCollation()); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/ForeignKeyReferenceMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/ForeignKeyReferenceMutationTest.java new file mode 100644 index 0000000000..d86855e797 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/ForeignKeyReferenceMutationTest.java @@ -0,0 +1,197 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.ReferentialAction; +import net.sf.jsqlparser.statement.ReferentialAction.Action; +import net.sf.jsqlparser.statement.ReferentialAction.Type; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.ForeignKeyReference; +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 ForeignKeyReferenceMutationTest { + @Test + void keepsLegacyAndStructuredAccessOnTheSameValues() { + ForeignKeyConstraint index = new ForeignKeyConstraint(); + Table table = new Table("parent"); + List columns = new ArrayList<>(List.of("id")); + index.setTable(table); + index.setReferencedColumnNames(columns); + index.setReferentialAction(Type.DELETE, Action.CASCADE); + + ForeignKeyReference reference = index.getReference(); + assertSame(table, reference.getTable()); + assertSame(columns, reference.getReferencedColumnNames()); + assertEquals(Action.CASCADE, reference.getReferentialAction(Type.DELETE).getAction()); + + Table replacement = new Table("other_parent"); + reference.setTable(replacement); + reference.setReferencedColumnNames(new ArrayList<>(List.of("other_id"))); + reference.setReferentialAction(Type.DELETE, Action.RESTRICT); + assertSame(replacement, index.getTable()); + assertSame(reference.getReferencedColumnNames(), index.getReferencedColumnNames()); + assertEquals(Action.RESTRICT, index.getReferentialAction(Type.DELETE).getAction()); + + index.addReferencedColumnNames("tenant_id"); + index.getReferencedColumnNames().remove("other_id"); + assertEquals(List.of("tenant_id"), reference.getReferencedColumnNames()); + index.removeReferentialAction(Type.DELETE); + assertNull(reference.getReferentialAction(Type.DELETE)); + reference.getReferentialActions().add(new ReferentialAction(Type.UPDATE, Action.CASCADE)); + assertSame(reference.getReferentialAction(Type.UPDATE), + index.getReferentialAction(Type.UPDATE)); + } + + @Test + void preservesNullableLegacyFieldsAndAnEmptyReference() { + ForeignKeyConstraint index = new ForeignKeyConstraint(); + index.setReference(null); + assertNull(index.getTable()); + assertNull(index.getReferencedColumnNames()); + assertNull(index.getReferentialAction(Type.DELETE)); + assertNull(index.getMatchType()); + index.setTable(new Table("parent")); + index.setReferencedColumnNames(new ArrayList<>(List.of("id"))); + index.setTable(null); + index.setReferencedColumnNames(null); + assertNull(index.getReference().getTable()); + assertNull(index.getReference().getReferencedColumnNames()); + } + + @Test + void clearingReferenceRetainsLegacyValuesAndDiscardsReferenceOnlyOptions() { + ForeignKeyReference reference = new ForeignKeyReference() + .withTable(new Table("parent")) + .withReferencedColumnNames(new ArrayList<>(List.of("id"))) + .withMatchType(ForeignKeyReference.MatchType.FULL) + .withUsingPeriod(true) + .withReferentialAction(Type.DELETE, Action.CASCADE); + reference.setConstraintName("column_fk"); + reference.setConstraintAttributes(new ConstraintAttributes()); + ForeignKeyConstraint index = new ForeignKeyConstraint().withReference(reference); + + index.setReference(null); + + assertSame(reference.getTable(), index.getTable()); + assertSame(reference.getReferencedColumnNames(), index.getReferencedColumnNames()); + assertEquals(Action.CASCADE, index.getReferentialAction(Type.DELETE).getAction()); + assertNull(index.getMatchType()); + ForeignKeyReference detached = index.getReference(); + assertNotSame(reference, detached); + assertFalse(detached.isUsingPeriod()); + assertNull(detached.getConstraintName()); + assertNull(detached.getConstraintAttributes()); + } + + @Test + void clearingReferenceRetainsTheLatestStructuredValues() { + ForeignKeyReference reference = new ForeignKeyReference() + .withTable(new Table("parent")) + .withReferencedColumnNames(new ArrayList<>(List.of("id"))); + ForeignKeyConstraint index = new ForeignKeyConstraint().withReference(reference); + Table replacement = new Table("other_parent"); + List columns = new ArrayList<>(List.of("other_id")); + reference.setTable(replacement); + reference.setReferencedColumnNames(columns); + reference.setReferentialAction(Type.DELETE, Action.SET_NULL); + reference.getReferentialAction(Type.DELETE).setColumnNames(List.of("child_id")); + + index.setReference(null); + + assertSame(replacement, index.getTable()); + assertSame(columns, index.getReferencedColumnNames()); + assertEquals(List.of("child_id"), index.getReferentialAction(Type.DELETE).getColumnNames()); + assertEquals(List.of("child_id"), + index.getReference().getReferentialAction(Type.DELETE).getColumnNames()); + } + + @Test + void accessingReferenceDoesNotReplaceActionsOrDiscardTheirColumns() { + ForeignKeyConstraint index = new ForeignKeyConstraint(); + index.setReferentialAction(Type.DELETE, Action.SET_NULL); + ReferentialAction action = index.getReferentialAction(Type.DELETE); + action.setColumnNames(List.of("child_id")); + + assertSame(action, index.getReference().getReferentialAction(Type.DELETE)); + assertEquals(List.of("child_id"), index.getReferentialAction(Type.DELETE).getColumnNames()); + action.setAction(Action.SET_DEFAULT); + assertEquals(Action.SET_DEFAULT, + index.getReference().getReferentialAction(Type.DELETE).getAction()); + } + + @Test + @SuppressWarnings("deprecation") + void deprecatedActionSettersUpdateStructuredReference() { + ForeignKeyConstraint index = new ForeignKeyConstraint(); + ForeignKeyReference reference = index.getReference(); + index.setOnDeleteReferenceOption("CASCADE"); + index.setOnUpdateReferenceOption("RESTRICT"); + assertEquals(Action.CASCADE, reference.getReferentialAction(Type.DELETE).getAction()); + assertEquals("RESTRICT", index.getOnUpdateReferenceOption()); + reference.setReferentialAction(Type.UPDATE, Action.CASCADE); + assertEquals("CASCADE", index.getOnUpdateReferenceOption()); + index.setOnDeleteReferenceOption(null); + index.setOnUpdateReferenceOption(null); + assertNull(reference.getReferentialAction(Type.DELETE)); + assertNull(reference.getReferentialAction(Type.UPDATE)); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void mutationsSurviveBothRenderersAndReparsing(boolean create) throws JSQLParserException { + String prefix = create ? "CREATE TABLE child (parent_id INT, " : "ALTER TABLE child ADD "; + Statement statement = CCJSqlParserUtil.parse(prefix + + "CONSTRAINT fk FOREIGN KEY (parent_id) REFERENCES parent (id) ON DELETE CASCADE" + + (create ? ")" : "")); + ForeignKeyConstraint index = foreignKey(statement); + ForeignKeyReference reference = index.getReference(); + reference.setTable(new Table("other_parent")); + reference.getReferencedColumnNames().set(0, "other_id"); + index.setReferentialAction(Type.DELETE, Action.SET_NULL); + index.getReferentialAction(Type.DELETE).setColumnNames(List.of("parent_id")); + index.setMatchType(ForeignKeyReference.MatchType.SIMPLE); + + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(statement.toString(), deparsed.toString()); + Statement reparsed = CCJSqlParserUtil.parse(deparsed.toString()); + assertEquals(deparsed.toString(), reparsed.toString()); + ForeignKeyConstraint result = foreignKey(reparsed); + assertEquals("other_parent", result.getTable().getName()); + assertEquals(List.of("other_id"), result.getReferencedColumnNames()); + assertEquals(List.of("parent_id"), + result.getReferentialAction(Type.DELETE).getColumnNames()); + assertEquals(ForeignKeyReference.MatchType.SIMPLE, result.getMatchType()); + } + + private static ForeignKeyConstraint foreignKey(Statement statement) { + return (ForeignKeyConstraint) (statement instanceof CreateTable + ? ((CreateTable) statement).getTableConstraints().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getConstraint()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/IdentitySequenceNameTest.java b/src/test/java/net/sf/jsqlparser/statement/create/IdentitySequenceNameTest.java new file mode 100644 index 0000000000..be75c34061 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/IdentitySequenceNameTest.java @@ -0,0 +1,76 @@ +/*- + * #%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 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.schema.Sequence; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.IdentityDefinition; +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 IdentitySequenceNameTest { + @ParameterizedTest + @ValueSource(strings = {"ids", "public.ids", "\"schema.name\".\"seq.name\""}) + void sharesIdentityOptionsAcrossCreateAndAlter(String name) throws JSQLParserException { + String definition = "GENERATED BY DEFAULT AS IDENTITY (START 4 SEQUENCE NAME " + name + + " CACHE 2 NO CYCLE)"; + CreateTable create = (CreateTable) parse("CREATE TABLE t (id INT " + definition + ")"); + IdentityDefinition identity = create.getColumnDefinitions().get(0).getColumnOptions().get(0) + .getIdentityDefinition(); + Alter alter = (Alter) parse("ALTER TABLE t ALTER COLUMN id ADD " + definition); + IdentityDefinition altered = alter.getAlterExpressions().get(0).getColDataTypeList().get(0) + .getIdentityAlterations().get(0).getIdentityDefinition(); + for (IdentityDefinition current : new IdentityDefinition[] {identity, altered}) { + assertEquals(4, current.getParameters().size()); + Sequence.Parameter named = current.getParameters().get(1); + assertEquals(Sequence.ParameterType.SEQUENCE_NAME, named.getOption()); + assertEquals(name, named.getSequenceName().getFullyQualifiedName()); + assertNull(named.getValue()); + named.getSequenceName().setName("renamed"); + } + assertTrue(create.toString().contains("renamed")); + assertTrue(alter.toString().contains("renamed")); + roundTrip(create); + roundTrip(alter); + } + + @Test + void preservesNameOnlyAndDoesNotExtendStandaloneSequenceOptions() throws JSQLParserException { + String sql = "CREATE TABLE t (id INT GENERATED ALWAYS AS IDENTITY (SEQUENCE NAME ids))"; + assertEquals(sql, parse(sql).toString()); + roundTrip(parse(sql)); + for (String invalid : new String[] { + "CREATE TABLE t (id INT GENERATED ALWAYS AS IDENTITY (SEQUENCE NAME))", + "CREATE TABLE t (id INT GENERATED ALWAYS AS IDENTITY ())", + "CREATE SEQUENCE ids SEQUENCE NAME other_ids", + "ALTER TABLE t ALTER COLUMN id SET SEQUENCE NAME other_ids"}) { + assertThrows(JSQLParserException.class, () -> parse(invalid), invalid); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/IndexKindStateTest.java b/src/test/java/net/sf/jsqlparser/statement/create/IndexKindStateTest.java index fbf740fb92..102d52e54d 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/IndexKindStateTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/IndexKindStateTest.java @@ -15,11 +15,13 @@ import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.statement.create.table.CheckConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.DefaultConstraint; import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.statement.create.table.Index.Kind; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; @@ -27,13 +29,10 @@ import org.junit.jupiter.params.provider.ValueSource; class IndexKindStateTest { - @ParameterizedTest - @CsvSource({"PRIMARY KEY, PRIMARY_KEY", "unique key, UNIQUE", "UNIQUE INDEX, UNIQUE", - "KEY, INDEX", "INDEX, INDEX", "FULLTEXT KEY, FULLTEXT", "SPATIAL INDEX, SPATIAL", - "FOREIGN KEY, FOREIGN_KEY", "CHECK, CHECK", "EXCLUDE, EXCLUDE", "DEFAULT, DEFAULT", - "BITMAP INDEX, INDEX"}) - void replacingTypeRefreshesEveryPreviousClassification(String type, Kind expected) { + @CsvSource({"unique key, UNIQUE", "UNIQUE INDEX, UNIQUE", "KEY, INDEX", "INDEX, INDEX", + "FULLTEXT KEY, FULLTEXT", "SPATIAL INDEX, SPATIAL", "BITMAP INDEX, INDEX"}) + void replacingIndexTypeRefreshesEveryPreviousClassification(String type, Kind expected) { for (Kind previous : Kind.values()) { Index index = new Index().withType("UNIQUE").withKind(previous); index.setType(type); @@ -44,58 +43,63 @@ void replacingTypeRefreshesEveryPreviousClassification(String type, Kind expecte @ParameterizedTest @NullAndEmptySource - @ValueSource(strings = {"CUSTOM", "UNIQUE_CUSTOM", "PRIMARY_CUSTOM", "MONKEY", "INDEXED"}) - void clearingOrReplacingWithCustomTypeClearsStaleKind(String type) { + @ValueSource(strings = {"CUSTOM", "UNIQUE_CUSTOM", "PRIMARY_CUSTOM", "MONKEY", "INDEXED", + "PRIMARY KEY", "FOREIGN KEY", "CHECK", "EXCLUDE", "DEFAULT", "NOT NULL"}) + void constraintAndUnknownTypesAreNotPhysicalIndexKinds(String type) { Index index = new Index().withType("UNIQUE").withType(type); assertEquals(type, index.getType()); assertEquals(Kind.OTHER, index.getKind()); } @Test - void classificationDoesNotRewriteSpellingOrDependOnLeadingWhitespace() { + void classificationDoesNotRewriteSpelling() { Index index = new Index().withType(" unique\tkey "); assertEquals(Kind.UNIQUE, index.getKind()); assertEquals(" unique\tkey ", index.getType()); + KeyConstraint constraint = new KeyConstraint().withType(" unique\tkey "); + assertEquals(ConstraintKind.UNIQUE, constraint.getKind()); + constraint.setKind(ConstraintKind.PRIMARY_KEY); + assertEquals(" unique\tkey ", constraint.getType()); + constraint.setType("PRIMARY KEY"); + assertEquals(ConstraintKind.PRIMARY_KEY, constraint.getKind()); } @Test - void explicitMetadataSupportsOmittedTypeAndSpecializedConstraints() { + void metadataAndFixedConstraintKindsRemainSeparate() { Index index = new Index().withKind(Kind.INDEX); assertNull(index.getType()); assertEquals(Kind.INDEX, index.getKind()); - index.setType("UNIQUE"); - assertEquals(Kind.UNIQUE, index.getKind()); - assertEquals(Kind.CHECK, new CheckConstraint().getKind()); - assertEquals(Kind.EXCLUDE, new ExcludeConstraint().getKind()); - assertEquals(Kind.DEFAULT, new DefaultConstraint().getKind()); + assertEquals(ConstraintKind.CHECK, new CheckConstraint().getKind()); + assertEquals(ConstraintKind.EXCLUDE, new ExcludeConstraint().getKind()); + assertEquals(ConstraintKind.DEFAULT, new DefaultConstraint().getKind()); } - // Both the original and rewritten SQL execute on MySQL 8.4 and PostgreSQL 18. @ParameterizedTest @CsvSource({"UNIQUE, PRIMARY KEY, PRIMARY_KEY", "PRIMARY KEY, UNIQUE, UNIQUE"}) - void rewritingPostgreSqlConstraintPreservesKindThroughDeparsing(String before, String after, - Kind expected) throws JSQLParserException { + void rewritingConstraintPreservesKindThroughDeparsing(String before, String after, + ConstraintKind expected) throws JSQLParserException { CreateTable table = (CreateTable) assertSqlCanBeParsedAndDeparsed( "CREATE TABLE index_state (id INT, CONSTRAINT key_state " + before + " (id))"); - Index index = table.getIndexes().get(0); - index.setType(after); - assertEquals(expected, index.getKind()); + KeyConstraint constraint = (KeyConstraint) table.getTableConstraints().get(0); + constraint.setType(after); + assertEquals(expected, constraint.getKind()); CreateTable reparsed = (CreateTable) assertSqlCanBeParsedAndDeparsed(table.toString()); - assertEquals(expected, reparsed.getIndexes().get(0).getKind()); - assertEquals("key_state", reparsed.getIndexes().get(0).getName()); + assertEquals(expected, reparsed.getTableConstraints().get(0).getKind()); + assertEquals("key_state", reparsed.getTableConstraints().get(0).getName()); + assertEquals(0, reparsed.getIndexes().size()); } - // MySQL KEY and INDEX are aliases; UNIQUE changes the constraint's meaning. @ParameterizedTest - @CsvSource({"UNIQUE KEY, KEY, INDEX", "KEY, UNIQUE KEY, UNIQUE", - "UNIQUE INDEX, INDEX, INDEX", "INDEX, UNIQUE INDEX, UNIQUE"}) - void rewritingMySqlIndexPreservesKindThroughDeparsing(String before, String after, - Kind expected) throws JSQLParserException { + @ValueSource(strings = {"UNIQUE", "UNIQUE KEY", "UNIQUE INDEX"}) + void tableUniquenessRequiresAConstraintNodeRatherThanChangingAnIndexType(String type) + throws JSQLParserException { CreateTable table = (CreateTable) assertSqlCanBeParsedAndDeparsed( - "CREATE TABLE index_state (id INT, " + before + " key_state (id))"); - table.getIndexes().get(0).setType(after); - assertEquals(expected, table.getIndexes().get(0).getKind()); + "CREATE TABLE index_state (id INT, KEY key_state (id))"); + table.getIndexes().clear(); + table.getTableConstraints().add(new KeyConstraint().withType(type) + .withIndexName("key_state").withColumnsNames(java.util.List.of("id"))); CreateTable reparsed = (CreateTable) assertSqlCanBeParsedAndDeparsed(table.toString()); - assertEquals(expected, reparsed.getIndexes().get(0).getKind()); + assertEquals(0, reparsed.getIndexes().size()); + assertEquals(ConstraintKind.UNIQUE, reparsed.getTableConstraints().get(0).getKind()); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/KeyColumnSourceMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/KeyColumnSourceMutationTest.java new file mode 100644 index 0000000000..e2dbd4005f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/KeyColumnSourceMutationTest.java @@ -0,0 +1,88 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.*; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class KeyColumnSourceMutationTest { + @ParameterizedTest + @ValueSource(strings = {"INDEX ix (id DESC)", "PRIMARY KEY (id)", "UNIQUE (id DESC)", + "FOREIGN KEY (id) REFERENCES parent (id)", "EXCLUDE USING btree (id WITH =)"}) + void clearedNamesCanBeRepopulatedThroughBothAppendApisAndTheLiveList(String declaration) + throws Exception { + for (boolean nullClear : new boolean[] {true, false}) { + for (boolean collectionAppend : new boolean[] {false, true}) { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT, " + declaration + ")"); + KeyColumnSource key = (KeyColumnSource) table.getTableElements().get(1); + KeyElement element = key.getColumns().get(0); + String expected = table.toString(); + + key.setColumnsNames(nullClear ? null : List.of()); + assertNotNull(key.getColumns()); + assertTrue(key.getColumns().isEmpty()); + assertTrue(key.getColumnsNames().isEmpty()); + append(key, element, collectionAppend); + assertSame(element, key.getColumns().get(0)); + assertSql(table, expected); + + // Clearing and editing through the shared structured API must also work. + key.setColumnsNames(null); + key.getColumns().add(element); + assertSql(table, expected); + } + } + } + + private static void append(KeyColumnSource key, KeyElement element, boolean collection) { + if (key instanceof Index) { + if (collection) { + ((Index) key).addColumns(List.of(element)); + } else { + ((Index) key).addColumns(element); + } + } else if (key instanceof KeyConstraint) { + if (collection) { + ((KeyConstraint) key).addColumns(List.of(element)); + } else { + ((KeyConstraint) key).addColumns(element); + } + } else if (key instanceof ForeignKeyConstraint) { + if (collection) { + ((ForeignKeyConstraint) key).addColumns(List.of(element)); + } else { + ((ForeignKeyConstraint) key).addColumns(element); + } + } else if (key instanceof ExcludeConstraint) { + if (collection) { + ((ExcludeConstraint) key).addColumns(List.of(element)); + } else { + ((ExcludeConstraint) key).addColumns(element); + } + } else { + fail("Unexpected key owner: " + key.getClass()); + } + } + + private static void assertSql(CreateTable table, String expected) throws Exception { + assertEquals(expected, table.toString()); + StringBuilder output = new StringBuilder(); + table.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + assertEquals(expected, CCJSqlParserUtil.parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySQLCreateTableConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySQLCreateTableConstraintTest.java index dc5b70911f..fda2b37a19 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/MySQLCreateTableConstraintTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySQLCreateTableConstraintTest.java @@ -28,11 +28,11 @@ public void testCheckConstraintEnforcement() throws JSQLParserException { CreateTable createTable = (CreateTable) assertSqlCanBeParsedAndDeparsed(sql); - CheckConstraint positive = (CheckConstraint) createTable.getIndexes().get(0); + CheckConstraint positive = (CheckConstraint) createTable.getTableConstraints().get(0); assertEquals(Boolean.TRUE, positive.getEnforced()); assertEquals("chk_positive", positive.getName()); - CheckConstraint cap = (CheckConstraint) createTable.getIndexes().get(1); + CheckConstraint cap = (CheckConstraint) createTable.getTableConstraints().get(1); assertEquals(Boolean.FALSE, cap.getEnforced()); assertEquals("chk_cap", cap.getName()); } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlColumnAttributeTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlColumnAttributeTest.java new file mode 100644 index 0000000000..b535ff5a5e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlColumnAttributeTest.java @@ -0,0 +1,277 @@ +/*- + * #%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.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.ColumnOption.ColumnFormat; +import net.sf.jsqlparser.statement.create.table.ConstraintDeclaration; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +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.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlColumnAttributeTest { + private static final Dialect[] DIALECTS = {null, Dialect.MYSQL}; + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TABLE t4 (id INT PRIMARY KEY, g GEOMETRY NOT NULL SRID 4326)", + "CREATE TABLE ty5 (c3 MULTIPOLYGON SRID 0, c4 LINESTRING)", + "CREATE TABLE t1 (id INT PRIMARY KEY AUTO_INCREMENT, g POINT SRID 4326 NOT NULL)", + "CREATE TABLE t18 (a INT COLUMN_FORMAT FIXED STORAGE DISK, b INT COLUMN_FORMAT DYNAMIC, " + + "c INT COLUMN_FORMAT DEFAULT STORAGE MEMORY)", + "CREATE TABLE t19 (a INT ENGINE_ATTRIBUTE '{\"k\":1}' SECONDARY_ENGINE_ATTRIBUTE '{}', " + + "b JSON ENGINE_ATTRIBUTE = '{}' SECONDARY_ENGINE_ATTRIBUTE = '{}')", + "CREATE TABLE t6 (id INT NOT NULL PRIMARY KEY, code VARCHAR (10) UNIQUE KEY, " + + "qty INT CHECK (qty > 0))", + "CREATE TABLE t1 (code VARCHAR (10) UNIQUE)", "CREATE TABLE t1 (id INT KEY)", + "CREATE TABLE t1 (id INT KEY AUTO_INCREMENT, code INT UNIQUE KEY NOT NULL)", + "ALTER TABLE t1 ADD COLUMN geo POINT NOT NULL SRID 4326", + "ALTER TABLE t1 MODIFY COLUMN c INT COLUMN_FORMAT FIXED ENGINE_ATTRIBUTE = '{}'", + "ALTER TABLE t1 ADD COLUMN code INT UNIQUE KEY", + "ALTER TABLE t1 CHANGE COLUMN a id INT KEY"}) + void roundTripsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, dialect(dialect)); + assertTrue(columns(statement).stream().flatMap(MySqlColumnAttributeTest::options) + .noneMatch(option -> option.getKind() == ColumnOption.Kind.OTHER), sql); + } + } + + @Test + void exposesTypedAttributesWithLegacyTokens() throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + CreateTable table = (CreateTable) parse("CREATE TABLE t (" + + "g GEOMETRY NOT NULL SRID 4326, a INT COLUMN_FORMAT FIXED STORAGE DISK, " + + "b INT COLUMN_FORMAT DEFAULT, c JSON ENGINE_ATTRIBUTE '{\"k\":1}' " + + "SECONDARY_ENGINE_ATTRIBUTE = '{}')", dialect); + List columns = table.getColumnDefinitions(); + + ColumnOption srid = columns.get(0).getColumnOptions().get(1); + assertEquals(ColumnOption.Kind.SRID, srid.getKind()); + assertEquals(4326L, srid.getSrid()); + assertEquals(List.of("NOT", "NULL", "SRID", "4326"), columns.get(0).getColumnSpecs()); + + ColumnOption fixed = columns.get(1).getColumnOptions().get(0); + assertEquals(ColumnOption.Kind.COLUMN_FORMAT, fixed.getKind()); + assertEquals(ColumnFormat.FIXED, fixed.getColumnFormat()); + assertEquals(ColumnOption.Kind.STORAGE, + columns.get(1).getColumnOptions().get(1).getKind()); + assertEquals(ColumnFormat.DEFAULT, + columns.get(2).getColumnOptions().get(0).getColumnFormat()); + assertEquals(List.of("COLUMN_FORMAT", "DEFAULT"), columns.get(2).getColumnSpecs()); + + ColumnOption engine = columns.get(3).getColumnOptions().get(0); + ColumnOption secondary = columns.get(3).getColumnOptions().get(1); + assertEquals(ColumnOption.Kind.ENGINE_ATTRIBUTE, engine.getKind()); + assertEquals("{\"k\":1}", engine.getEngineAttribute().getValue()); + assertFalse(engine.isUseEquals()); + assertEquals(ColumnOption.Kind.SECONDARY_ENGINE_ATTRIBUTE, secondary.getKind()); + assertTrue(secondary.isUseEquals()); + assertEquals(List.of("ENGINE_ATTRIBUTE", "'{\"k\":1}'", "SECONDARY_ENGINE_ATTRIBUTE", + "=", "'{}'"), columns.get(3).getColumnSpecs()); + assertEquals(List.of(ConstraintKind.NOT_NULL), table.getConstraints().stream() + .map(ConstraintDeclaration::getKind).collect(Collectors.toList())); + } + } + + @Test + void typedSettersChangeBothRenderersAndLeaveSnapshotsDetached() throws JSQLParserException { + Statement statement = parse("CREATE TABLE t (g POINT SRID 4326, a INT COLUMN_FORMAT FIXED, " + + "c JSON SECONDARY_ENGINE_ATTRIBUTE '{}')", Dialect.MYSQL); + List columns = columns(statement); + ColumnOption srid = columns.get(0).getColumnOptions().get(0); + ColumnOption format = columns.get(1).getColumnOptions().get(0); + ColumnOption attribute = columns.get(2).getColumnOptions().get(0); + List snapshot = attribute.getTokens(); + assertReadOnly(snapshot); + + srid.setSrid(0); + format.setColumnFormat(ColumnFormat.DYNAMIC); + attribute.setEngineAttribute(new StringValue("{\"k\":2}")); + attribute.setUseEquals(true); + + assertEquals(List.of("SECONDARY_ENGINE_ATTRIBUTE", "'{}'"), snapshot); + assertEquals(List.of("SECONDARY_ENGINE_ATTRIBUTE", "=", "'{\"k\":2}'"), + attribute.getTokens()); + assertEquals("CREATE TABLE t (g POINT SRID 0, a INT COLUMN_FORMAT DYNAMIC, " + + "c JSON SECONDARY_ENGINE_ATTRIBUTE = '{\"k\":2}')", statement.toString()); + assertRoundTrip(statement); + assertThrows(IllegalStateException.class, () -> srid.setTokens(List.of("SRID", "1"))); + assertThrows(NullPointerException.class, () -> format.setColumnFormat(null)); + assertThrows(NullPointerException.class, () -> attribute.setEngineAttribute(null)); + } + + @Test + void engineAttributeLiteralsAreVisitedLikeComments() throws JSQLParserException { + Statement statement = parse( + "ALTER TABLE t ADD COLUMN c JSON COMMENT 'c' ENGINE_ATTRIBUTE '{}'", Dialect.MYSQL); + ColumnDefinition column = columns(statement).get(0); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(column, visited::add, ignored -> { + }); + assertEquals(2, visited.size()); + assertSame(column.getColumnOptions().get(1).getEngineAttribute(), visited.get(1)); + } + + @ParameterizedTest + @MethodSource("factories") + void factoriesRenderCanonicalSql(ColumnOption option, String sql, List tokens) { + assertEquals(sql, option.toString()); + assertEquals(tokens, option.getTokens()); + assertReadOnly(option.getTokens()); + assertThrows(IllegalStateException.class, () -> option.setTokens(List.of("raw"))); + } + + private static Stream factories() { + ColumnOption withEquals = ColumnOption.engineAttribute(new StringValue("{}")); + withEquals.setUseEquals(true); + return Stream.of( + new Object[] {ColumnOption.srid(4326), "SRID 4326", List.of("SRID", "4326")}, + new Object[] {ColumnOption.columnFormat(ColumnFormat.FIXED), "COLUMN_FORMAT FIXED", + List.of("COLUMN_FORMAT", "FIXED")}, + new Object[] {ColumnOption.engineAttribute(new StringValue("{}")), + "ENGINE_ATTRIBUTE '{}'", List.of("ENGINE_ATTRIBUTE", "'{}'")}, + new Object[] {withEquals, "ENGINE_ATTRIBUTE = '{}'", + List.of("ENGINE_ATTRIBUTE", "=", "'{}'")}, + new Object[] {ColumnOption.secondaryEngineAttribute(new StringValue("{}")), + "SECONDARY_ENGINE_ATTRIBUTE '{}'", + List.of("SECONDARY_ENGINE_ATTRIBUTE", "'{}'")}, + new Object[] { + ColumnOption.constraint(new KeyConstraint().withType("KEY") + .withKind(ConstraintKind.PRIMARY_KEY)), + "KEY", List.of("KEY")}, + new Object[] {ColumnOption.constraint(new KeyConstraint().withType("UNIQUE KEY")), + "UNIQUE KEY", List.of("UNIQUE", "KEY")}); + } + + @Test + void unsupportedColumnFormatsStayOpaque() throws JSQLParserException { + // Percona Server's compressed columns are not modeled. + Statement statement = + parse("CREATE TABLE t (c BLOB COLUMN_FORMAT COMPRESSED)", Dialect.MYSQL); + assertTrue(options(columns(statement).get(0)) + .allMatch(option -> option.getKind() == ColumnOption.Kind.OTHER)); + assertEquals("CREATE TABLE t (c BLOB COLUMN_FORMAT COMPRESSED)", statement.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (code VARCHAR(10) UNIQUE KEY NOT NULL)", + "ALTER TABLE t ADD COLUMN code VARCHAR(10) UNIQUE KEY NOT NULL"}) + void uniqueKeyIsOneConstraint(String sql) throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + Statement statement = parse(sql, dialect); + ColumnDefinition column = columns(statement).get(0); + assertEquals(2, column.getColumnOptions().size()); + ColumnOption unique = column.getColumnOptions().get(0); + assertEquals(ColumnOption.Kind.CONSTRAINT, unique.getKind()); + assertEquals(ConstraintKind.UNIQUE, unique.getConstraintKind()); + assertEquals("UNIQUE KEY", unique.getConstraint().getType()); + assertEquals(List.of("UNIQUE", "KEY", "NOT", "NULL"), column.getColumnSpecs()); + assertRoundTrip(statement); + } + } + + @Test + void bareKeyIsAPrimaryKeyThatKeepsItsSpelling() throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + CreateTable table = + (CreateTable) parse("CREATE TABLE t (id INT KEY, name TEXT)", dialect); + ColumnOption key = table.getColumnDefinitions().get(0).getColumnOptions().get(0); + KeyConstraint constraint = assertInstanceOf(KeyConstraint.class, key.getConstraint()); + assertEquals("KEY", constraint.getType()); + assertEquals(ConstraintKind.PRIMARY_KEY, constraint.getKind()); + assertEquals(ConstraintKind.PRIMARY_KEY, key.getConstraintKind()); + assertEquals(List.of("KEY"), key.getTokens()); + ConstraintDeclaration declaration = table.getConstraints().get(0); + assertEquals(ConstraintKind.PRIMARY_KEY, declaration.getKind()); + assertSame(key, declaration.getColumnOption()); + assertEquals("CREATE TABLE t (id INT KEY, name TEXT)", table.toString()); + assertRoundTrip(table); + + constraint.setType("PRIMARY KEY"); + assertEquals(ConstraintKind.PRIMARY_KEY, key.getConstraintKind()); + assertEquals("CREATE TABLE t (id INT PRIMARY KEY, name TEXT)", table.toString()); + } + } + + @Test + void inlineForeignKeyPrefixIsNotAPrimaryKey() throws JSQLParserException { + CreateTable table = (CreateTable) parse( + "CREATE TABLE t (user_id INT FOREIGN KEY REFERENCES ra_user(id))", null); + List options = table.getColumnDefinitions().get(0).getColumnOptions(); + assertEquals(List.of(ColumnOption.Kind.OTHER, ColumnOption.Kind.REFERENCE), + options.stream().map(ColumnOption::getKind).collect(Collectors.toList())); + assertEquals(List.of("FOREIGN", "KEY"), options.get(0).getTokens()); + assertEquals(List.of(ConstraintKind.FOREIGN_KEY), table.getConstraints().stream() + .map(ConstraintDeclaration::getKind).collect(Collectors.toList())); + assertRoundTrip(table); + } + + private static Consumer dialect(Dialect dialect) { + return parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }; + } + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, dialect(dialect)); + } + + private static List columns(Statement statement) { + if (statement instanceof CreateTable) { + return ((CreateTable) statement).getColumnDefinitions(); + } + return new ArrayList<>( + ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList()); + } + + private static Stream options(ColumnDefinition column) { + return column.getColumnOptions() == null ? Stream.empty() + : column.getColumnOptions().stream(); + } + + private static void assertReadOnly(List tokens) { + assertThrows(UnsupportedOperationException.class, () -> tokens.set(0, "changed")); + assertThrows(UnsupportedOperationException.class, () -> tokens.add("changed")); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString(), Dialect.MYSQL).toString()); + assertEquals(sql.toString(), parse(sql.toString(), null).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlCommentLiteralTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlCommentLiteralTest.java new file mode 100644 index 0000000000..f8ffcd23ce --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlCommentLiteralTest.java @@ -0,0 +1,366 @@ +/*- + * #%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 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.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression; +import net.sf.jsqlparser.statement.alter.AlterExpressionTableOption; +import net.sf.jsqlparser.statement.alter.AlterOperation; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.PartitionDefinition; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +/** MySQL table and partition COMMENT literals and the values a server stores for them. */ +class MySqlCommentLiteralTest { + + /** Literals with the comment MySQL 8.4 stores for them. */ + static Stream mySqlLiterals() { + return Stream.of( + Arguments.of("'users'", "users"), + Arguments.of("'사용자 테이블'", "사용자 테이블"), + Arguments.of("'it''s'", "it's"), + Arguments.of("'it\\'s'", "it's"), + Arguments.of("\"dq\"", "dq"), + Arguments.of("\"double \\\"quoted\\\" text\"", "double \"quoted\" text"), + Arguments.of("''", ""), + Arguments.of("'line1\\nline2'", "line1\nline2"), + Arguments.of("'a\\\\b'", "a\\b"), + Arguments.of("'tab\\there'", "tab\there"), + Arguments.of("'percent\\% underscore\\_'", "percent\\% underscore\\_"), + Arguments.of("'emoji 😀'", "emoji 😀"), + Arguments.of("'first line\nsecond line'", "first line\nsecond line")); + } + + /** Literals that read the same with and without a dialect. */ + static Stream portableLiterals() { + return Stream.of( + Arguments.of("'users'", "users"), + Arguments.of("'it''s'", "it's"), + Arguments.of("''", ""), + Arguments.of("'사용자 테이블'", "사용자 테이블"), + Arguments.of("'emoji 😀'", "emoji 😀")); + } + + @ParameterizedTest + @MethodSource("mySqlLiterals") + void tableCommentsDecodeToTheStoredValue(String literal, String stored) + throws JSQLParserException { + assertTableComments(literal, stored, Dialect.MYSQL); + } + + @ParameterizedTest + @MethodSource("portableLiterals") + void tableCommentsDecodeWithoutDialect(String literal, String stored) + throws JSQLParserException { + assertTableComments(literal, stored, null); + } + + private static void assertTableComments(String literal, String stored, Dialect dialect) + throws JSQLParserException { + String sql = "CREATE TABLE t (id INT) ENGINE = InnoDB COMMENT = " + literal + + " DEFAULT CHARSET = utf8mb4"; + CreateTable create = (CreateTable) parse(sql, dialect); + assertComment(create.getTableOptions().get(1), literal, stored); + assertEquals(List.of("ENGINE", "=", "InnoDB", "COMMENT", "=", literal, "DEFAULT", + "CHARSET", "=", "utf8mb4"), create.getTableOptionsStrings()); + assertEquals(sql, create.toString()); + assertRoundTrip(create, dialect); + + String ctas = "CREATE TABLE t (id INT) COMMENT " + literal + " AS SELECT 1 AS id"; + CreateTable query = (CreateTable) parse(ctas, dialect); + assertComment(query.getTableOptions().get(0), literal, stored); + assertEquals(List.of("COMMENT", literal), query.getTableOptionsStrings()); + assertEquals(ctas, query.toString()); + assertRoundTrip(query, dialect); + + Alter alter = (Alter) parse("ALTER TABLE t COMMENT = " + literal, dialect); + AlterExpressionTableOption action = + (AlterExpressionTableOption) alter.getAlterExpressions().get(0); + assertComment(action.getStructuredTableOption(), literal, stored); + assertEquals(literal, action.getCommentText()); + assertEquals(AlterOperation.COMMENT_WITH_EQUAL_SIGN, action.getOperation()); + assertEquals("ALTER TABLE t COMMENT = " + literal, alter.toString()); + assertRoundTrip(alter, dialect); + } + + private static void assertComment(TableOption option, String literal, String stored) { + assertEquals(TableOption.Kind.COMMENT, option.getKind()); + assertEquals(stored, option.getComment().getNotExcapedValue()); + assertEquals(literal, option.getComment().toString()); + assertEquals(literal, option.getValue()); + assertEquals(literal, option.getTokens().get(option.getTokens().size() - 1)); + } + + @Test + void mySqlEscapingIsRecordedOnTheLiteral() throws JSQLParserException { + CreateTable mySql = + (CreateTable) parse("CREATE TABLE t (id INT) COMMENT 'a\\\\b'", Dialect.MYSQL); + assertEquals(StringValue.Escaping.MYSQL_BACKSLASH, + mySql.getTableOptions().get(0).getComment().getEscaping()); + CreateTable standard = (CreateTable) parse("CREATE TABLE t (id INT) COMMENT 'a\\b'", null); + assertEquals(StringValue.Escaping.STANDARD, + standard.getTableOptions().get(0).getComment().getEscaping()); + assertEquals("a\\b", standard.getTableOptions().get(0).getComment().getNotExcapedValue()); + } + + @Test + void alterCommentsKeepTheirPositionAmongOtherActions() throws JSQLParserException { + Alter alter = (Alter) parse( + "ALTER TABLE t MODIFY id INT COMMENT 'col', ENGINE=InnoDB, comment='it\\'s'", + Dialect.MYSQL); + List actions = alter.getAlterExpressions(); + TableOption comment = + ((AlterExpressionTableOption) actions.get(2)).getStructuredTableOption(); + assertEquals("comment", comment.getName()); + assertTrue(comment.isUseEquals()); + assertEquals("it's", comment.getComment().getNotExcapedValue()); + assertNull(((AlterExpressionTableOption) actions.get(1)).getStructuredTableOption() + .getComment()); + assertRoundTrip(alter, Dialect.MYSQL); + + Alter algorithm = + (Alter) parse("ALTER TABLE t COMMENT 'x', ALGORITHM=INSTANT", Dialect.MYSQL); + AlterExpressionTableOption action = + (AlterExpressionTableOption) algorithm.getAlterExpressions().get(0); + assertEquals(AlterOperation.COMMENT, action.getOperation()); + assertEquals("x", action.getStructuredTableOption().getComment().getNotExcapedValue()); + assertRoundTrip(algorithm, Dialect.MYSQL); + } + + @Test + void valuesThatAreNotStringLiteralsRemainPlainValues() throws JSQLParserException { + // Accepted leniently; without the MySQL dialect "x" is a quoted identifier + for (String sql : new String[] {"CREATE TABLE t (id INT) COMMENT = \"x\"", + "CREATE TABLE t (id INT) COMMENT plain"}) { + CreateTable create = (CreateTable) parse(sql, null); + TableOption option = create.getTableOptions().get(0); + assertEquals(TableOption.Kind.COMMENT, option.getKind()); + assertNull(option.getComment()); + assertEquals(sql.substring(sql.lastIndexOf(' ') + 1), option.getValue()); + assertRoundTrip(create, null); + } + CreateTable mySql = + (CreateTable) parse("CREATE TABLE t (id INT) COMMENT = \"x\"", Dialect.MYSQL); + assertEquals("x", mySql.getTableOptions().get(0).getComment().getNotExcapedValue()); + } + + @Test + void commentLiteralEditsAreRenderedAndVisited() throws JSQLParserException { + CreateTable create = + (CreateTable) parse("CREATE TABLE t (id INT) comment = 'old'", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + StringValue replacement = new StringValue("'new'"); + option.setComment(replacement); + assertSame(replacement, option.getComment()); + assertEquals("comment = 'new'", option.toString()); + replacement.setValue("it''s"); + assertEquals("CREATE TABLE t (id INT) comment = 'it''s'", create.toString()); + assertEquals(List.of("comment", "=", "'it''s'"), option.getTokens()); + assertRoundTrip(create, Dialect.MYSQL); + + StringBuilder customized = new StringBuilder(); + option.appendTo(customized, expression -> customized.append("'printed'")); + assertEquals("comment = 'printed'", customized.toString()); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(option, visited::add, table -> { + }); + assertEquals(List.of(replacement), visited); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(create)); + } + + @Test + void commentFactoryAndReplacementOfOtherOptions() throws JSQLParserException { + TableOption created = TableOption.comment(new StringValue("'x'")); + assertEquals(TableOption.Kind.COMMENT, created.getKind()); + assertEquals("COMMENT", created.getName()); + assertFalse(created.isUseEquals()); + assertEquals("COMMENT 'x'", created.toString()); + assertEquals("COMMENT = 'x'", created.withUseEquals(true).toString()); + + CreateTable create = + (CreateTable) parse("CREATE TABLE t (id INT) ENGINE=InnoDB", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + option.withComment(new StringValue("'x'")); + assertEquals(TableOption.Kind.COMMENT, option.getKind()); + assertEquals("COMMENT", option.getName()); + assertTrue(option.isUseEquals()); + assertEquals("CREATE TABLE t (id INT) COMMENT = 'x'", create.toString()); + assertTrue(create.getTableOption(TableOption.Kind.ENGINE).isEmpty()); + assertRoundTrip(create, Dialect.MYSQL); + + option.setComment(null); + assertEquals(TableOption.Kind.COMMENT, option.getKind()); + assertNull(option.getValue()); + assertEquals("COMMENT", option.toString()); + } + + @Test + void scalarAndRawSettersReplaceTheLiteralWithoutParsing() throws JSQLParserException { + CreateTable create = + (CreateTable) parse("CREATE TABLE t (id INT) COMMENT='it\\'s'", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + option.setValue("'plain'"); + assertNull(option.getComment()); + assertEquals(TableOption.Kind.COMMENT, option.getKind()); + assertEquals("COMMENT = 'plain'", option.toString()); + assertRoundTrip(create, Dialect.MYSQL); + + option.setComment(new StringValue("'typed'")); + option.setKind(TableOption.Kind.OTHER); + assertNull(option.getComment()); + assertEquals("'typed'", option.getValue()); + option.setKind(TableOption.Kind.COMMENT); + assertNull(option.getComment()); + assertEquals("COMMENT = 'typed'", option.toString()); + + option.setComment(new StringValue("'typed'")); + List raw = new ArrayList<>(List.of("COMMENT", "'raw'")); + option.setTokens(raw); + assertNull(option.getComment()); + assertEquals(TableOption.Kind.OTHER, option.getKind()); + assertSame(raw, option.getTokens()); + option.setTokens(null); + assertNull(option.getComment()); + + option.setTokens(raw); + option.setComment(new StringValue("'typed'")); + assertEquals(List.of("COMMENT", "'typed'"), option.getTokens()); + assertRoundTrip(create, Dialect.MYSQL); + + AlterExpressionTableOption action = (AlterExpressionTableOption) ((Alter) parse( + "ALTER TABLE t COMMENT 'old'", Dialect.MYSQL)).getAlterExpressions().get(0); + action.setCommentText("'new'"); + assertNull(action.getStructuredTableOption().getComment()); + assertEquals("'new'", action.getCommentText()); + } + + @Test + void partitionAndSubpartitionCommentsDecodeToTheStoredValue() throws JSQLParserException { + String sql = "CREATE TABLE t (id INT, d INT) PARTITION BY RANGE (id) " + + "SUBPARTITION BY HASH (d) (PARTITION p0 VALUES LESS THAN (10) " + + "COMMENT = 'it\\'s' (SUBPARTITION s0 COMMENT 'sub0', " + + "SUBPARTITION s1 COMMENT = 'line1\\nline2'), " + + "PARTITION p1 VALUES LESS THAN MAXVALUE COMMENT '사용자 😀' " + + "(SUBPARTITION s2, SUBPARTITION s3 COMMENT 'a\\\\b'))"; + CreateTable create = (CreateTable) parse(sql, Dialect.MYSQL); + List partitions = + create.getPartitioning().getPartitionDefinitions(); + assertPartitionComment(partitions.get(0), "'it\\'s'", "it's", true); + assertPartitionComment(partitions.get(0).getSubPartitionDefinitions().get(0), "'sub0'", + "sub0", false); + assertPartitionComment(partitions.get(0).getSubPartitionDefinitions().get(1), + "'line1\\nline2'", "line1\nline2", true); + assertPartitionComment(partitions.get(1), "'사용자 😀'", "사용자 😀", false); + assertNull(partitions.get(1).getSubPartitionDefinitions().get(0).getCommentValue()); + assertNull(partitions.get(1).getSubPartitionDefinitions().get(0).getComment()); + assertPartitionComment(partitions.get(1).getSubPartitionDefinitions().get(1), "'a\\\\b'", + "a\\b", false); + assertEquals(StringValue.Escaping.MYSQL_BACKSLASH, + partitions.get(0).getCommentValue().getEscaping()); + assertEquals(sql, create.toString()); + assertRoundTrip(create, Dialect.MYSQL); + } + + @Test + void alterPartitionCommentsDecodeToTheStoredValue() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, null}) { + Alter add = (Alter) parse("ALTER TABLE t ADD PARTITION (PARTITION p1 VALUES " + + "LESS THAN (20) COMMENT 'it''s added')", dialect); + PartitionDefinition added = + add.getAlterExpressions().get(0).getPartitionDefinitions().get(0); + assertPartitionComment(added, "'it''s added'", "it's added", false); + assertRoundTrip(add, dialect); + + Alter reorganize = (Alter) parse("ALTER TABLE t REORGANIZE PARTITION p1 INTO " + + "(PARTITION p1a VALUES LESS THAN (15) COMMENT = 'reorg', " + + "PARTITION p1b VALUES LESS THAN (20))", dialect); + List definitions = + reorganize.getAlterExpressions().get(0).getPartitionDefinitions(); + assertPartitionComment(definitions.get(0), "'reorg'", "reorg", true); + assertNull(definitions.get(1).getCommentValue()); + assertRoundTrip(reorganize, dialect); + } + } + + private static void assertPartitionComment(PartitionDefinition definition, String literal, + String stored, boolean useEquals) { + assertEquals(stored, definition.getCommentValue().getNotExcapedValue()); + assertEquals(literal, definition.getComment()); + assertEquals(useEquals, definition.isCommentUseEquals()); + } + + @Test + void partitionCommentStringAccessorsConvertTheLiteral() throws JSQLParserException { + CreateTable create = (CreateTable) parse("CREATE TABLE t (id INT) PARTITION BY " + + "RANGE (id) (PARTITION p0 VALUES LESS THAN (10) COMMENT 'old')", Dialect.MYSQL); + PartitionDefinition definition = create.getPartitioning().getPartitionDefinitions().get(0); + + definition.setComment("'it''s'"); + assertInstanceOf(StringValue.class, definition.getCommentValue()); + assertEquals(StringValue.Escaping.STANDARD, definition.getCommentValue().getEscaping()); + assertEquals("it's", definition.getCommentValue().getNotExcapedValue()); + assertEquals("'it''s'", definition.getComment()); + assertRoundTrip(create, Dialect.MYSQL); + + StringValue escaped = new StringValue("'a\\nb'") + .withEscaping(StringValue.Escaping.MYSQL_BACKSLASH); + definition.setCommentValue(escaped); + definition.setCommentUseEquals(true); + assertSame(escaped, definition.getCommentValue()); + assertEquals("'a\\nb'", definition.getComment()); + assertEquals("PARTITION p0 VALUES LESS THAN (10) COMMENT = 'a\\nb'", + definition.toString()); + assertRoundTrip(create, Dialect.MYSQL); + + definition.setComment(null); + assertNull(definition.getCommentValue()); + assertEquals("PARTITION p0 VALUES LESS THAN (10)", definition.toString()); + } + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + + private static void assertRoundTrip(Statement statement, Dialect dialect) + throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlCreateTableDuplicatesTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlCreateTableDuplicatesTest.java new file mode 100644 index 0000000000..f6bdff70c4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlCreateTableDuplicatesTest.java @@ -0,0 +1,76 @@ +/*- + * #%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 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.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.CreateTable.DuplicateHandling; +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 MySqlCreateTableDuplicatesTest { + @ParameterizedTest + @ValueSource(strings = {"SELECT id FROM source", "TABLE source", "VALUES ROW(1), ROW(2)", + "(SELECT id FROM source)", "WITH c AS (SELECT 1 AS id) SELECT id FROM c"}) + void retainsModifierAndSourceAfterTableOptions(String query) throws JSQLParserException { + for (DuplicateHandling handling : DuplicateHandling.values()) { + for (boolean useAs : new boolean[] {false, true}) { + CreateTable table = parse("CREATE TABLE t (id INT PRIMARY KEY) ENGINE=InnoDB " + + handling + (useAs ? " AS " : " ") + query); + assertEquals(handling, table.getDuplicateHandling()); + assertEquals(useAs, table.isUseAsKeyword()); + assertNotNull(table.getSelect()); + roundTrip(table); + } + } + } + + @Test + void preservesPartitionAndAllowsAstMutation() throws JSQLParserException { + CreateTable table = parse("CREATE TABLE t (id INT PRIMARY KEY) PARTITION BY HASH(id) " + + "PARTITIONS 2 IGNORE AS SELECT id FROM source"); + assertNotNull(table.getPartitioning()); + assertNull(table.getPartitioning().getPartitionOptions()); + table.setDuplicateHandling(DuplicateHandling.REPLACE); + assertTrue(table.toString().contains(" REPLACE AS SELECT")); + roundTrip(table); + table.setDuplicateHandling(null); + assertFalse(table.toString().contains("REPLACE")); + roundTrip(table); + assertNull(parse("CREATE TABLE t AS SELECT 1").getDuplicateHandling()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t IGNORE", "CREATE TABLE t REPLACE AS", + "CREATE TABLE t IGNORE REPLACE SELECT 1", + "CREATE TABLE t ENGINE=InnoDB, IGNORE SELECT 1"}) + void rejectsMissingQueriesAndConflictingModifiers(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + private static CreateTable parse(String sql) throws JSQLParserException { + return (CreateTable) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + } + + private static void roundTrip(CreateTable table) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + table.accept(new StatementDeParser(out)); + assertEquals(table.toString(), out.toString()); + CreateTable parsed = parse(out.toString()); + assertEquals(table.getDuplicateHandling(), parsed.getDuplicateHandling()); + assertEquals(table.isUseAsKeyword(), parsed.isUseAsKeyword()); + assertEquals(out.toString(), parsed.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlIndexSpecOptionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlIndexSpecOptionTest.java new file mode 100644 index 0000000000..4ea4f93b1b --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlIndexSpecOptionTest.java @@ -0,0 +1,421 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; +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.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression; +import net.sf.jsqlparser.statement.create.index.AlgorithmOrLockOption; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.IndexOptionSource; +import net.sf.jsqlparser.statement.create.table.IndexSpecOption; +import net.sf.jsqlparser.statement.create.table.IndexSpecOption.Kind; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.drop.Drop; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlIndexSpecOptionTest { + private static final String OPTIONS = "KEY_BLOCK_SIZE = 8 USING HASH WITH PARSER ngram " + + "COMMENT 'c' INVISIBLE ENGINE_ATTRIBUTE '{}' SECONDARY_ENGINE_ATTRIBUTE = '{}'"; + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void createIndexKeepsIndexOptionsOnItsIndexAndAlgorithmLockOnTheStatement(boolean mysql) + throws Exception { + String sql = "CREATE UNIQUE INDEX uk ON t1 (a DESC, b (10)) USING BTREE COMMENT 'x' " + + "ALGORITHM = INPLACE LOCK = NONE"; + CreateIndex create = (CreateIndex) roundTrip(sql, mysql); + Index index = create.getIndex(); + + assertNull(index.getUsing()); + assertOptions(index, "INDEX_TYPE BTREE", "COMMENT 'x'"); + assertEquals(2, create.getAlgorithmOrLockOptions().size()); + assertAlgorithmOrLock(create.getAlgorithmOrLockOptions().get(0), + AlgorithmOrLockOption.Kind.ALGORITHM, "INPLACE"); + assertAlgorithmOrLock(create.getAlgorithmOrLockOptions().get(1), + AlgorithmOrLockOption.Kind.LOCK, "NONE"); + assertEquals(List.of("USING", "BTREE", "COMMENT", "'x'"), index.getIndexSpec()); + assertEquals(List.of("USING", "BTREE", "COMMENT", "'x'", "ALGORITHM", "=", "INPLACE", + "LOCK", "=", "NONE"), create.getTailParameters()); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "CREATE FULLTEXT INDEX ft ON t1 (body) WITH PARSER ngram|PARSER ngram", + "CREATE INDEX i ON t1 (a) INVISIBLE|VISIBILITY false", + "CREATE INDEX i ON t1 (a) VISIBLE|VISIBILITY true", + "CREATE INDEX i ON db1.t1 (a, b) KEY_BLOCK_SIZE = 8|KEY_BLOCK_SIZE 8 =", + "CREATE INDEX i ON t1 (a) KEY_BLOCK_SIZE 8 ENGINE_ATTRIBUTE '{}'" + + "|KEY_BLOCK_SIZE 8,ENGINE_ATTRIBUTE '{}'"}) + void createIndexOptionsAreTyped(String sql, String expected) throws Exception { + for (boolean mysql : List.of(true, false)) { + CreateIndex create = (CreateIndex) roundTrip(sql, mysql); + assertOptions(create.getIndex(), expected.split(",")); + assertTrue(create.getAlgorithmOrLockOptions().isEmpty()); + } + } + + @Test + void indexTypeKeepsItsPositionRelativeToTheKeyList() throws Exception { + CreateIndex beforeOn = (CreateIndex) roundTrip("CREATE INDEX i USING HASH ON t1 (a)", true); + assertEquals("HASH", beforeOn.getIndex().getUsing()); + assertTrue(beforeOn.isIndexTypeBeforeOn()); + assertNull(beforeOn.getIndex().getSpecOptions()); + + CreateTable table = (CreateTable) roundTrip("CREATE TABLE t20 (a INT, b VARCHAR (100), " + + "KEY idx_a USING BTREE (a) KEY_BLOCK_SIZE = 4 COMMENT 'idx', " + + "UNIQUE INDEX uk_b (b (20)) USING HASH)", true); + Index key = table.getIndexes().get(0); + assertEquals("BTREE", key.getUsing()); + assertOptions(key, "KEY_BLOCK_SIZE 4 =", "COMMENT 'idx'"); + assertEquals(List.of("KEY_BLOCK_SIZE", "=", "4", "COMMENT", "'idx'"), key.getIndexSpec()); + KeyConstraint unique = (KeyConstraint) table.getTableConstraints().get(0); + assertNull(unique.getUsing()); + assertOptions(unique, "INDEX_TYPE HASH"); + assertEquals(List.of("USING", "HASH"), unique.getIndexSpec()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t1 ADD CONSTRAINT pk_t1 PRIMARY KEY USING BTREE (id)", + "ALTER TABLE t1 ADD PRIMARY KEY USING BTREE (id)", + "ALTER TABLE t1 ADD CONSTRAINT uk UNIQUE KEY uk_idx USING BTREE (id)", + "CREATE TABLE t1 (id INT, PRIMARY KEY USING BTREE (id) COMMENT 'pk')", + "CREATE TABLE t1 (id INT, CONSTRAINT pk_t1 PRIMARY KEY USING HASH (id))"}) + void keysAcceptTheIndexTypeBeforeTheKeyList(String sql) throws Exception { + KeyConstraint key = keyConstraint(roundTrip(sql, true)); + assertEquals(sql.contains("HASH") ? "HASH" : "BTREE", key.getUsing()); + assertEquals(List.of("id"), key.getColumnsNames()); + assertFalse(key.getSpecOptions().stream() + .anyMatch(option -> option.getKind() == Kind.INDEX_TYPE)); + } + + @Test + void defaultModeAcceptsTheIndexTypeBeforeNamedConstraintKeys() throws Exception { + for (String sql : List.of( + "ALTER TABLE t1 ADD CONSTRAINT pk_t1 PRIMARY KEY USING BTREE (id)", + "ALTER TABLE t1 ADD CONSTRAINT uk UNIQUE KEY USING BTREE (id)")) { + Statement statement = roundTrip(sql, false); + KeyConstraint key = keyConstraint(statement); + assertEquals("BTREE", key.getUsing()); + key.setUsing("HASH"); + assertRendered(statement, sql.replace("BTREE", "HASH")); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE INDEX ix ON t (a) %s", + "CREATE TABLE t (a INT, KEY ix (a) %s)", + "CREATE TABLE t (a INT, UNIQUE KEY ix (a) %s)", + "ALTER TABLE t ADD INDEX ix (a) %s", "ALTER TABLE t ADD UNIQUE KEY ix (a) %s", + "ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (a) %s"}) + void everyDefinitionSharesTheSameOptionModel(String template) throws Exception { + IndexOptionSource source = definition(roundTrip(String.format(template, OPTIONS), true)); + assertOptions(source, "KEY_BLOCK_SIZE 8 =", "INDEX_TYPE HASH", "PARSER ngram", + "COMMENT 'c'", "VISIBILITY false", "ENGINE_ATTRIBUTE '{}'", + "SECONDARY_ENGINE_ATTRIBUTE '{}' ="); + assertEquals(List.of("KEY_BLOCK_SIZE", "=", "8", "USING", "HASH", "WITH", "PARSER", + "ngram", "COMMENT", "'c'", "INVISIBLE", "ENGINE_ATTRIBUTE", "'{}'", + "SECONDARY_ENGINE_ATTRIBUTE", "=", "'{}'"), source.getIndexSpec()); + } + + @Test + void alterKeyBlockSizeWithoutEqualsKeepsItsSeparator() throws Exception { + // ALTER used to render this option as KEY_BLOCK_SIZE8 + Alter alter = (Alter) roundTrip("ALTER TABLE t ADD INDEX i (a) KEY_BLOCK_SIZE 8", true); + assertOptions(alter.getAlterExpressions().get(0).getIndex(), "KEY_BLOCK_SIZE 8"); + } + + @Test + void commentsAreStringValuesThatDecodeTheStoredText() throws Exception { + String[][] comments = {{"'it''s'", "it's"}, {"'it\\'s'", "it's"}, {"\"dq\"", "dq"}, + {"'a\\\\b'", "a\\b"}, {"'인덱스 설명'", "인덱스 설명"}}; + for (String template : List.of("CREATE INDEX ix ON t (a) COMMENT %s", + "CREATE TABLE t (a INT, KEY ix (a) COMMENT %s)", + "ALTER TABLE t ADD INDEX ix (a) COMMENT %s")) { + for (String[] comment : comments) { + String sql = String.format(template, comment[0]); + IndexSpecOption option = + definition(roundTrip(sql, true)).getSpecOptions().get(0); + assertEquals(Kind.COMMENT, option.getKind()); + assertEquals(comment[0], option.getValue(), sql); + assertEquals(comment[0], option.getComment().toString(), sql); + assertEquals(comment[1], option.getComment().getNotExcapedValue(), sql); + } + } + + Alter alter = (Alter) roundTrip("ALTER TABLE t ADD INDEX ix (a) COMMENT 'it\\'s'", true); + IndexSpecOption comment = alter.getAlterExpressions().get(0).getIndex() + .getSpecOptions().get(0); + assertEquals(StringValue.Escaping.MYSQL_BACKSLASH, comment.getComment().getEscaping()); + comment.setValue("'don\\'t'"); + assertEquals("don't", comment.getComment().getNotExcapedValue()); + comment.setComment(new StringValue("'changed'")); + assertRendered(alter, "ALTER TABLE t ADD INDEX ix (a) COMMENT 'changed'"); + assertEquals(List.of("COMMENT", "'changed'"), + alter.getAlterExpressions().get(0).getIndex().getIndexSpec()); + } + + @Test + void typedEditsReachBothRenderers() throws Exception { + Alter alter = (Alter) roundTrip( + "ALTER TABLE t1 ADD INDEX i3 (a) USING BTREE COMMENT 'c' INVISIBLE", true); + List options = alter.getAlterExpressions().get(0).getIndex() + .getSpecOptions(); + options.get(0).setValue("HASH"); + options.get(1).setValue("'changed'"); + options.get(2).setVisible(true); + options.add(0, IndexSpecOption.of(Kind.KEY_BLOCK_SIZE, "16", true)); + assertRendered(alter, "ALTER TABLE t1 ADD INDEX i3 (a) KEY_BLOCK_SIZE = 16 USING HASH " + + "COMMENT 'changed' VISIBLE"); + + CreateIndex create = (CreateIndex) roundTrip( + "CREATE INDEX i ON t (a) LOCK EXCLUSIVE ALGORITHM DEFAULT", true); + create.getAlgorithmOrLockOptions().get(0).setValue("SHARED"); + create.getAlgorithmOrLockOptions().get(1).setUseEquals(true); + create.getIndex().getIndexOptions().addSpecOptions(IndexSpecOption.of(Kind.COMMENT, "'x'")); + assertRendered(create, + "CREATE INDEX i ON t (a) COMMENT 'x' LOCK SHARED ALGORITHM = DEFAULT"); + assertEquals(List.of("COMMENT", "'x'", "LOCK", "SHARED", "ALGORITHM", "=", "DEFAULT"), + create.getTailParameters()); + } + + @Test + void legacyAccessorsAreSnapshotsAndSettersReplaceWithOpaqueOptions() throws Exception { + CreateIndex create = (CreateIndex) roundTrip( + "CREATE INDEX i ON t (a) parallel compress nologging", false); + assertEquals(List.of("parallel", "compress", "nologging"), create.getTailParameters()); + assertTrue(create.getIndex().getSpecOptions().stream() + .allMatch(option -> option.getKind() == Kind.OTHER)); + assertThrows(UnsupportedOperationException.class, + () -> create.getTailParameters().add("x")); + assertThrows(UnsupportedOperationException.class, + () -> create.getIndex().getIndexSpec().add("x")); + + create.addAlgorithmOrLockOptions(AlgorithmOrLockOption.lock("NONE")); + List tail = new ArrayList<>(List.of("KEY_BLOCK_SIZE", "=", "4")); + create.setTailParameters(tail); + tail.clear(); + assertTrue(create.getAlgorithmOrLockOptions().isEmpty()); + assertEquals(Kind.OTHER, create.getIndex().getSpecOptions().get(0).getKind()); + assertRendered(create, "CREATE INDEX i ON t (a) KEY_BLOCK_SIZE = 4"); + + Index index = new Index().withName("i").withColumnsNames(List.of("a")); + assertNull(index.getIndexSpec()); + index.setIndexSpec(List.of("USING", "BTREE")); + assertEquals(List.of("USING", "BTREE"), index.getIndexSpec()); + assertEquals("i (a) USING BTREE", index.toString()); + index.setIndexSpec(List.of()); + assertTrue(index.getSpecOptions().isEmpty()); + index.setIndexSpec(null); + assertNull(index.getSpecOptions()); + assertEquals(List.of(), new CreateIndex().getTailParameters()); + } + + @Test + void typedOptionsRejectPayloadsOfOtherKinds() { + IndexSpecOption comment = IndexSpecOption.comment(new StringValue("'c'")); + assertEquals("'c'", comment.getValue()); + assertThrows(IllegalStateException.class, + () -> IndexSpecOption.of(Kind.PARSER, "ngram").setComment(new StringValue("'x'"))); + assertNull(IndexSpecOption.of(Kind.PARSER, "ngram").getComment()); + assertThrows(NullPointerException.class, () -> comment.setComment(null)); + assertThrows(IllegalStateException.class, () -> comment.setTokens(List.of("x"))); + assertThrows(IllegalStateException.class, () -> comment.setUseEquals(true)); + assertThrows(IllegalStateException.class, () -> comment.setVisible(true)); + assertNull(comment.getVisible()); + IndexSpecOption visible = IndexSpecOption.visibility(true); + assertThrows(IllegalStateException.class, () -> visible.setValue("x")); + assertEquals(List.of("VISIBLE"), visible.getTokens()); + assertThrows(IllegalStateException.class, + () -> IndexSpecOption.of(Kind.OTHER, "x")); + assertThrows(NullPointerException.class, () -> IndexSpecOption.of(Kind.PARSER, null)); + + List tokens = new ArrayList<>(List.of("ON", "[PRIMARY]")); + IndexSpecOption raw = IndexSpecOption.raw(tokens); + tokens.set(1, "ignored"); + assertEquals("ON [PRIMARY]", raw.toString()); + assertThrows(UnsupportedOperationException.class, () -> raw.getTokens().add("x")); + assertThrows(IllegalStateException.class, () -> raw.setValue("x")); + raw.setTokens(List.of("ON", "fg")); + assertEquals(List.of("ON", "fg"), raw.getTokens()); + } + + @Test + void dropIndexAlgorithmAndLockAreTyped() throws Exception { + Drop drop = (Drop) roundTrip("DROP INDEX idx ON t1 ALGORITHM = INPLACE LOCK = NONE", true); + assertEquals("t1", drop.getTable().getName()); + assertAlgorithmOrLock(drop.getAlgorithmOrLockOptions().get(0), + AlgorithmOrLockOption.Kind.ALGORITHM, "INPLACE"); + assertAlgorithmOrLock(drop.getAlgorithmOrLockOptions().get(1), + AlgorithmOrLockOption.Kind.LOCK, "NONE"); + assertEquals(List.of("ON", "t1", "ALGORITHM", "=", "INPLACE", "LOCK", "=", "NONE"), + drop.getParameters()); + + drop.getAlgorithmOrLockOptions().remove(1); + drop.getAlgorithmOrLockOptions().get(0).setValue("COPY"); + drop.setBehavior(CascadeBehavior.RESTRICT); + assertRendered(drop, "DROP INDEX idx ON t1 ALGORITHM = COPY RESTRICT"); + assertEquals(List.of("ON", "t1", "ALGORITHM", "=", "COPY", "RESTRICT"), + drop.getParameters()); + + drop.addParameters("legacy"); + drop.setAlgorithmOrLockOptions(List.of(AlgorithmOrLockOption.lock("SHARED"))); + assertRendered(drop, "DROP INDEX idx ON t1 legacy LOCK = SHARED RESTRICT"); + drop.setAlgorithmOrLockOptions(List.of(AlgorithmOrLockOption.lock("SHARED")), 0); + assertEquals(List.of("ON", "t1", "LOCK", "=", "SHARED", "legacy", "RESTRICT"), + drop.getParameters()); + assertThrows(IllegalArgumentException.class, + () -> drop.setAlgorithmOrLockOptions(List.of(), 2)); + + drop.setParameters(List.of("CASCADE")); + assertTrue(drop.getAlgorithmOrLockOptions().isEmpty()); + assertNull(drop.getBehavior()); + assertNull(drop.getTable()); + assertEquals("DROP INDEX idx CASCADE", drop.toString()); + + Drop single = (Drop) roundTrip("DROP INDEX idx ON t1 ALGORITHM = INPLACE", false); + assertEquals(1, single.getAlgorithmOrLockOptions().size()); + } + + @Test + void replacingTheCreateIndexDefinitionKeepsOrInheritsItsOptions() throws Exception { + CreateIndex create = (CreateIndex) roundTrip( + "CREATE INDEX i ON t (a) KEY_BLOCK_SIZE = 8", true); + Index removed = create.getIndex(); + IndexSpecOption keyBlockSize = removed.getSpecOptions().get(0); + create.setIndex(null); + assertEquals(List.of("KEY_BLOCK_SIZE", "=", "8"), create.getTailParameters()); + + create.setIndex(new Index().withName("j").withColumnsNames(List.of("b"))); + assertSame(keyBlockSize, create.getIndex().getSpecOptions().get(0)); + assertNotSame(removed.getSpecOptions(), create.getIndex().getSpecOptions()); + assertRendered(create, "CREATE INDEX j ON t (b) KEY_BLOCK_SIZE = 8"); + + create.setIndex(new Index().withName("k").withColumnsNames(List.of("c")) + .withSpecOptions(List.of(IndexSpecOption.visibility(false)))); + assertRendered(create, "CREATE INDEX k ON t (c) INVISIBLE"); + } + + @Test + void postgreSqlIndexOptionsKeepTheirProperties() throws Exception { + String sql = "CREATE UNIQUE INDEX CONCURRENTLY ix ON ONLY t USING btree (id) " + + "INCLUDE (v) NULLS NOT DISTINCT WITH (fillfactor = 80) TABLESPACE fast " + + "WHERE active"; + CreateIndex create = (CreateIndex) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(sql, create.toString()); + assertEquals("btree", create.getIndex().getUsing()); + assertEquals(List.of("v"), create.getIncludeColumns()); + assertEquals("fast", create.getTableSpace()); + assertNull(create.getIndex().getSpecOptions()); + assertTrue(create.getTailParameters().isEmpty()); + + Alter alter = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t ADD CONSTRAINT uk UNIQUE (id) " + + "INCLUDE (v) WITH (fillfactor = 70) USING INDEX TABLESPACE fast", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + KeyConstraint key = alter.getAlterExpressions().get(0).getKeyConstraint(); + assertEquals("fast", key.getTableSpace()); + assertEquals(1, key.getStorageParameters().size()); + assertTrue(key.getSpecOptions().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ADD PRIMARY KEY USING (id)", + "ALTER TABLE t ADD PRIMARY KEY USING BTREE USING HASH (id)", + "ALTER TABLE t ADD INDEX i (a) KEY_BLOCK_SIZE", + "ALTER TABLE t ADD INDEX i (a) WITH PARSER", + "ALTER TABLE t ADD INDEX i (a) COMMENT", + "CREATE INDEX i ON t (a) LOCK = NONE ALGORITHM"}) + void rejectsIncompleteOptions(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } + + private static void assertOptions(IndexOptionSource source, String... expected) { + List actual = new ArrayList<>(); + for (IndexSpecOption option : source.getSpecOptions()) { + Object payload = option.getKind() == Kind.VISIBILITY ? option.getVisible() + : option.getValue(); + actual.add(option.getKind() + " " + payload + (option.isUseEquals() ? " =" : "")); + } + assertEquals(List.of(expected), actual); + } + + private static void assertAlgorithmOrLock(AlgorithmOrLockOption option, + AlgorithmOrLockOption.Kind kind, String value) { + assertEquals(kind, option.getKind()); + assertEquals(value, option.getValue()); + assertTrue(option.isUseEquals()); + } + + private static IndexOptionSource definition(Statement statement) { + if (statement instanceof CreateIndex) { + return ((CreateIndex) statement).getIndex(); + } + if (statement instanceof CreateTable) { + CreateTable table = (CreateTable) statement; + return (IndexOptionSource) (table.getIndexes().isEmpty() + ? table.getTableConstraints().get(0) + : table.getIndexes().get(0)); + } + AlterExpression action = ((Alter) statement).getAlterExpressions().get(0); + return (IndexOptionSource) (action.getConstraint() != null ? action.getConstraint() + : action.getIndex()); + } + + private static KeyConstraint keyConstraint(Statement statement) { + return (KeyConstraint) definition(statement); + } + + private static Statement roundTrip(String sql, boolean mysql) throws Exception { + Consumer dialect = mysql ? parser -> parser.withDialect(Dialect.MYSQL) + : parser -> { + }; + Statement statement = CCJSqlParserUtil.parse(sql, dialect); + assertEquals(sql, statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + assertEquals(sql, CCJSqlParserUtil.parse(sql, dialect).toString()); + return statement; + } + + private static void assertRendered(Statement statement, String expected) throws Exception { + assertEquals(expected, statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(expected, deparsed.toString()); + assertEquals(expected, CCJSqlParserUtil.parse(expected, + parser -> parser.withDialect(Dialect.MYSQL)).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlInlineCheckTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlInlineCheckTest.java new file mode 100644 index 0000000000..f01a2b08f2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlInlineCheckTest.java @@ -0,0 +1,112 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.CheckConstraint; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlInlineCheckTest { + @ParameterizedTest + @ValueSource(strings = {"", " ENFORCED", " NOT ENFORCED"}) + void sharesChecksAcrossCreateAndColumnAlterations(String enforcement) + throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.MYSQL}) { + for (String prefix : new String[] {"CREATE TABLE t (", "ALTER TABLE t ADD COLUMN ", + "ALTER TABLE t MODIFY COLUMN ", "ALTER TABLE t CHANGE COLUMN old_a "}) { + String sql = prefix + "a INT CONSTRAINT ck CHECK (a > 7)" + enforcement; + if (prefix.startsWith("CREATE")) { + sql += ")"; + } + Statement statement = parse(sql, dialect); + ColumnDefinition column = statement instanceof CreateTable + ? ((CreateTable) statement).getColumnDefinitions().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList() + .get(0); + assertEquals(1, column.getColumnOptions().size()); + ColumnOption option = column.getColumnOptions().get(0); + assertEquals(ColumnOption.Kind.CONSTRAINT, option.getKind()); + CheckConstraint check = + assertInstanceOf(CheckConstraint.class, option.getConstraint()); + assertEquals("ck", check.getName()); + assertEquals(enforcement.isEmpty() ? null : !enforcement.contains("NOT"), + check.getEnforced()); + List seen = new ArrayList<>(); + ExpressionDeParser expression = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + seen.add(value.getValue()); + return getBuilder().append(value.getValue() + 100); + } + }; + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(expression, new SelectDeParser(), out)); + assertEquals(List.of(7L), seen, sql); + assertTrue(out.toString().contains("a > 107")); + assertTrue(statement.toString().contains("a > 7")); + check.setEnforced(false); + check.setExpression(CCJSqlParserUtil.parseExpression("a > 9")); + roundTrip(statement, dialect); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"CHECK (a > 0) NOT NULL", "CHECK (a > 0) CHECK (a < 100)", + "CHECK (a > 0) NOT ENFORCED COMMENT 'check; note'"}) + void preservesFollowingColumnOptions(String tail) throws JSQLParserException { + roundTrip(parse("CREATE TABLE t (a INT " + tail + ", b INT)", Dialect.MYSQL), + Dialect.MYSQL); + } + + @ParameterizedTest + @ValueSource(strings = {"", " NO INHERIT"}) + void preservesPostgreSql18InlineCheckEnforcement(String inheritance) + throws JSQLParserException { + CreateTable table = (CreateTable) parse( + "CREATE TABLE t (a INT CHECK (a > 0)" + inheritance + " NOT ENFORCED)", + Dialect.POSTGRESQL); + CheckConstraint check = assertInstanceOf(CheckConstraint.class, + table.getColumnDefinitions().get(0).getColumnOptions().get(0).getConstraint()); + assertEquals(false, check.getEnforced()); + assertEquals(!inheritance.isEmpty(), check.isNoInherit()); + roundTrip(table, Dialect.POSTGRESQL); + } + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + }); + } + + private static void roundTrip(Statement statement, Dialect dialect) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlRoutineCharacteristicsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlRoutineCharacteristicsTest.java new file mode 100644 index 0000000000..5593ec1835 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlRoutineCharacteristicsTest.java @@ -0,0 +1,168 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.CreateFunctionalStatement; +import net.sf.jsqlparser.statement.RoutineCharacteristic; +import net.sf.jsqlparser.statement.RoutineCharacteristic.Kind; +import net.sf.jsqlparser.statement.RoutineCharacteristic.SecurityClause; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.UnsupportedStatement; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlRoutineCharacteristicsTest { + + @ParameterizedTest + @CsvSource(delimiter = '|', quoteCharacter = '`', value = { + "CREATE PROCEDURE cp1() COMMENT 'proc comment' SELECT 1|COMMENT", + "CREATE FUNCTION cf1() RETURNS INT DETERMINISTIC COMMENT 'fn' RETURN 1" + + "|DETERMINISTIC COMMENT", + "CREATE PROCEDURE gp13() COMMENT 'c' LANGUAGE SQL SQL SECURITY INVOKER SELECT 1" + + "|COMMENT LANGUAGE_SQL SECURITY_INVOKER", + "CREATE FUNCTION gf14() RETURNS INT DETERMINISTIC RETURN 1|DETERMINISTIC", + "CREATE FUNCTION f1 (a INT) RETURNS INT DETERMINISTIC RETURN a + 1|DETERMINISTIC", + "CREATE DEFINER=CURRENT_USER FUNCTION f2 (s CHAR(20)) RETURNS CHAR(50) " + + "CHARSET utf8mb4 NO SQL RETURN CONCAT('Hello, ', s, '!')|NO_SQL", + "CREATE FUNCTION f() RETURNS VARCHAR(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin " + + "READS SQL DATA RETURN 'a'|READS_SQL_DATA", + "CREATE FUNCTION f() RETURNS SET('a', 'b') CHAR SET latin1 MODIFIES SQL DATA " + + "RETURN 'a'|MODIFIES_SQL_DATA", + "CREATE PROCEDURE p (IN a INT) NOT DETERMINISTIC CONTAINS SQL SQL SECURITY DEFINER " + + "BEGIN SELECT a; END|NOT_DETERMINISTIC CONTAINS_SQL SECURITY_DEFINER", + "CREATE FUNCTION f() RETURNS INT not deterministic comment 'x' return 1" + + "|NOT_DETERMINISTIC COMMENT", + "CREATE PROCEDURE p1 (IN a INT, OUT b INT) BEGIN SELECT a INTO b; END|``", + "CREATE DEFINER=CURRENT_USER PROCEDURE p3 () SELECT 1|``", + "CREATE FUNCTION f() RETURNS INT RETURN (SELECT deterministic FROM t)|``", + "CREATE PROCEDURE p() READS SQL DATA BEGIN DECLARE deterministic INT; END" + + "|READS_SQL_DATA"}) + void modelsCharacteristicsWithoutChangingTokens(String sql, String kinds) + throws JSQLParserException { + // Without a dialect, the declaration is only captured as tokens. + CreateFunctionalStatement plain = + (CreateFunctionalStatement) CCJSqlParserUtil.parse(sql); + assertTrue(plain.getCharacteristics().isEmpty()); + + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB}) { + Consumer consumer = parser -> parser.withDialect(dialect); + CreateFunctionalStatement statement = + (CreateFunctionalStatement) CCJSqlParserUtil.parse(sql, consumer); + assertEquals(kinds.isEmpty() ? List.of() : List.of(kinds.split(" ")), + statement.getCharacteristics().stream() + .map(characteristic -> characteristic.getKind().name()) + .collect(Collectors.toList())); + + assertEquals(plain.getFunctionDeclarationParts(), + statement.getFunctionDeclarationParts()); + assertEquals(plain.toString(), statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(plain.toString(), deparsed.toString()); + assertEquals(statement.toString(), + CCJSqlParserUtil.parse(deparsed.toString(), consumer).toString()); + + Statements script = CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", consumer); + assertEquals(2, script.size()); + assertEquals(statement.getCharacteristics().size(), + ((CreateFunctionalStatement) script.get(0)).getCharacteristics().size()); + } + } + + @Test + void exposesCharacteristicValues() throws JSQLParserException { + CreateFunctionalStatement procedure = parse("CREATE PROCEDURE gp13() COMMENT 'c' " + + "LANGUAGE SQL SQL SECURITY INVOKER SELECT 1"); + List characteristics = procedure.getCharacteristics(); + assertEquals("c", characteristics.get(0).getComment().getNotExcapedValue()); + assertEquals("'c'", characteristics.get(0).getValue()); + assertEquals(SecurityClause.SQL_SECURITY, characteristics.get(2).getSecurityClause()); + assertEquals("SQL SECURITY INVOKER", characteristics.get(2).toString()); + assertThrows(UnsupportedOperationException.class, + () -> characteristics.add(new RoutineCharacteristic(Kind.NO_SQL))); + + CreateFunctionalStatement function = + parse("CREATE FUNCTION f() RETURNS INT not deterministic comment 'x' return 1"); + // The tokens keep the spelling; the characteristics render canonical keywords. + assertEquals("CREATE FUNCTION f ( ) RETURNS INT not deterministic comment 'x' return 1", + function.toString()); + assertEquals("NOT DETERMINISTIC", function.getCharacteristics().get(0).toString()); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', quoteCharacter = '`', value = {"'it\\'s'|it's", "'it''s'|it's", + "\"dq\"|dq", "'a\\\\b'|a\\b", "'한글 설명 😀'|한글 설명 😀"}) + void decodesComments(String literal, String stored) throws JSQLParserException { + CreateFunctionalStatement statement = + parse("CREATE PROCEDURE p() COMMENT " + literal + " SELECT 1"); + RoutineCharacteristic comment = statement.getCharacteristics().get(0); + assertEquals(Kind.COMMENT, comment.getKind()); + assertEquals(literal, comment.getValue()); + assertEquals(stored, comment.getComment().getNotExcapedValue()); + assertEquals("CREATE PROCEDURE p ( ) COMMENT " + literal + " SELECT 1", + statement.toString()); + } + + @Test + void replacingTheTokensClearsTheCharacteristics() throws JSQLParserException { + CreateFunctionalStatement statement = + parse("CREATE FUNCTION gf14() RETURNS INT DETERMINISTIC RETURN 1"); + assertEquals(1, statement.getCharacteristics().size()); + + statement.addFunctionDeclarationParts("+", "1"); + assertEquals(1, statement.getCharacteristics().size()); + assertEquals("CREATE FUNCTION gf14 ( ) RETURNS INT DETERMINISTIC RETURN 1 + 1", + statement.toString()); + + statement.setFunctionDeclarationParts(List.of("g", "(", ")", "SELECT", "1")); + assertTrue(statement.getCharacteristics().isEmpty()); + assertEquals("CREATE FUNCTION g ( ) SELECT 1", statement.toString()); + + statement.setFunctionDeclarationParts(List.of("g", "(", ")", "NO", "SQL", "SELECT", "1"), + List.of(new RoutineCharacteristic(Kind.NO_SQL))); + assertEquals(Kind.NO_SQL, statement.getCharacteristics().get(0).getKind()); + assertEquals("CREATE FUNCTION g ( ) NO SQL SELECT 1", statement.toString()); + } + + @Test + void otherDialectsKeepOnlyTokens() throws JSQLParserException { + String postgres = "CREATE FUNCTION add(a integer, b integer) RETURNS integer " + + "LANGUAGE sql IMMUTABLE STRICT AS $$ SELECT a + b $$"; + assertTrue(((CreateFunctionalStatement) CCJSqlParserUtil.parse(postgres, + parser -> parser.withDialect(Dialect.POSTGRESQL))).getCharacteristics().isEmpty()); + assertTrue(((CreateFunctionalStatement) CCJSqlParserUtil.parse(postgres)) + .getCharacteristics().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER FUNCTION f1 DETERMINISTIC", + "ALTER PROCEDURE p1 NOT DETERMINISTIC"}) + void alterKeepsRejectingDeterministic(String sql) throws JSQLParserException { + assertInstanceOf(UnsupportedStatement.class, + CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } + + private static CreateFunctionalStatement parse(String sql) throws JSQLParserException { + return (CreateFunctionalStatement) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlServerTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlServerTest.java new file mode 100644 index 0000000000..ad5f7f1217 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlServerTest.java @@ -0,0 +1,326 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.Arrays; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.DoubleValue; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.alter.AlterServer; +import net.sf.jsqlparser.statement.alter.ForeignObjectAlterAction; +import net.sf.jsqlparser.statement.create.server.CreateServer; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.statement.foreign.ForeignDataStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL CREATE SERVER and ALTER SERVER: numeric option values and quoted names. */ +class MySqlServerTest { + private static final Dialect[] MYSQL_FAMILY = {Dialect.MYSQL, Dialect.MARIADB, null}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertSpans(String expected, String source, ASTNodeAccess access) { + Node node = access.getASTNode(); + assertNotNull(node, expected); + assertEquals(expected, source.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + /** + * Parses {@code sql}, which must print as written, and checks the statement span, the deparser, + * the reparse, the feature analysis and the table finder. + */ + private static ForeignDataStatement roundTrip(String sql, Dialect dialect) throws Exception { + ForeignDataStatement statement = + assertInstanceOf(ForeignDataStatement.class, parse(sql, dialect)); + assertEquals(sql, statement.toString()); + assertSpans(sql, sql, statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + assertEquals(sql, parse(output.toString(), dialect).toString()); + assertEquals(Set.of(StmtFeature.MODIFIES_SCHEMA), statement.getFeatures().getCertain()); + assertTrue(new TablesNamesFinder<>().getTables((Statement) statement).isEmpty()); + return statement; + } + + @Test + void createServerTakesANumericPort() throws Exception { + String sql = "CREATE SERVER s FOREIGN DATA WRAPPER mysql" + + " OPTIONS (USER 'u', HOST 'h', DATABASE 'd', PORT 3306)"; + for (Dialect dialect : MYSQL_FAMILY) { + CreateServer server = (CreateServer) roundTrip(sql, dialect); + assertEquals("s", server.getName()); + assertEquals("mysql", server.getForeignDataWrapper()); + List options = server.getOptions(); + assertEquals(4, options.size()); + assertEquals("USER", options.get(0).getName()); + assertEquals("u", options.get(0).getValue().getValue()); + assertSame(options.get(0).getValue(), options.get(0).getValueExpression()); + ForeignDataOption port = options.get(3); + assertEquals("PORT", port.getName()); + assertNull(port.getAction()); + assertNull(port.getValue()); + LongValue number = assertInstanceOf(LongValue.class, port.getValueExpression()); + assertEquals(3306L, number.getValue()); + assertSpans("3306", sql, number); + assertEquals("PORT 3306", port.toString()); + } + } + + @Test + void alterServerTakesANumericPort() throws Exception { + String sql = "ALTER SERVER s OPTIONS (USER 'u2', PORT 3307)"; + for (Dialect dialect : MYSQL_FAMILY) { + AlterServer server = (AlterServer) roundTrip(sql, dialect); + assertEquals("s", server.getName()); + assertEquals(ForeignObjectAlterAction.OPTIONS, server.getAction()); + assertEquals(3307L, assertInstanceOf(LongValue.class, + server.getOptions().get(1).getValueExpression()).getValue()); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE SERVER s2 FOREIGN DATA WRAPPER mysql OPTIONS (HOST 'h', DATABASE 'db', USER 'u', PASSWORD 'p', PORT 3306, SOCKET '/tmp/mysql.sock', OWNER 'o')", + "CREATE SERVER `s-1` FOREIGN DATA WRAPPER 'mysql' OPTIONS (USER 'u')", + "CREATE SERVER 's3' FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE SERVER s4 FOREIGN DATA WRAPPER `mysql` OPTIONS (user 'u', port 1)", + "CREATE SERVER s5 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'a', USER 'b')", + "CREATE SERVER s6 FOREIGN DATA WRAPPER mysql OPTIONS (PORT 3306.5)", + "CREATE SERVER s7 FOREIGN DATA WRAPPER mysql OPTIONS (PORT 1e3)", + "CREATE SERVER s8 FOREIGN DATA WRAPPER mysql OPTIONS (PORT 0x10)", + "CREATE SERVER s9 FOREIGN DATA WRAPPER mysql OPTIONS (PORT X'10')", + "CREATE SERVER s10 FOREIGN DATA WRAPPER mysql OPTIONS (PORT 99999999999999999999)", + "CREATE SERVER s11 FOREIGN DATA WRAPPER mysql OPTIONS (USER \"u\")", + "CREATE SERVER s12 FOREIGN DATA WRAPPER \"mysql\" OPTIONS (PORT .5)", + "CREATE SERVER \"s13\" FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE SERVER '' FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "ALTER SERVER s OPTIONS (HOST '10.0.0.2', PORT 3307)", + "ALTER SERVER 's3' OPTIONS (SOCKET '/tmp/x')"}) + void mySqlServerFormsRoundTrip(String sql) throws Exception { + roundTrip(sql, Dialect.MYSQL); + } + + @Test + void numericValuesKeepTheirLiteralKind() throws Exception { + String sql = "CREATE SERVER s FOREIGN DATA WRAPPER mysql" + + " OPTIONS (PORT 3306.5, PORT 0x10, PORT X'10')"; + List options = roundTrip(sql, Dialect.MYSQL).getOptions(); + assertSpans("3306.5", sql, + assertInstanceOf(DoubleValue.class, options.get(0).getValueExpression())); + assertSpans("0x10", sql, + assertInstanceOf(HexValue.class, options.get(1).getValueExpression())); + assertSpans("X'10'", sql, + assertInstanceOf(HexValue.class, options.get(2).getValueExpression())); + StringBuilder seen = new StringBuilder(); + ForeignDataOption.visitExpressions(options, expression -> seen.append(expression)); + assertEquals("3306.50x10X'10'", seen.toString()); + } + + @Test + void quotedNamesAreKeptAsWritten() throws Exception { + for (Dialect dialect : MYSQL_FAMILY) { + CreateServer server = (CreateServer) roundTrip( + "CREATE SERVER 's' FOREIGN DATA WRAPPER 'mysql' OPTIONS (PORT 3306)", dialect); + assertEquals("'s'", server.getName()); + assertEquals("'mysql'", server.getForeignDataWrapper()); + assertEquals("'s'", ((AlterServer) roundTrip("ALTER SERVER 's' OPTIONS (PORT 1)", + dialect)).getName()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE SERVER r1 FOREIGN DATA WRAPPER mysql", + "CREATE SERVER r2 FOREIGN DATA WRAPPER mysql OPTIONS ()", + "CREATE SERVER r3 FOREIGN DATA WRAPPER mysql OPTIONS (PORT '3306')", + "CREATE SERVER r4 FOREIGN DATA WRAPPER mysql OPTIONS (PORT -1)", + "CREATE SERVER r5 FOREIGN DATA WRAPPER mysql OPTIONS (USER 1)", + "CREATE SERVER r6 FOREIGN DATA WRAPPER mysql OPTIONS (USER u)", + "CREATE SERVER r7 FOREIGN DATA WRAPPER mysql OPTIONS (USER N'u')", + "CREATE SERVER r8 FOREIGN DATA WRAPPER mysql OPTIONS (USER _utf8mb4'u')", + "CREATE SERVER r9 FOREIGN DATA WRAPPER mysql OPTIONS (dbname 'd')", + "CREATE SERVER r10 FOREIGN DATA WRAPPER mysql OPTIONS (`USER` 'u')", + "CREATE SERVER r11 FOREIGN DATA WRAPPER mysql OPTIONS (ADD USER 'u')", + "CREATE SERVER IF NOT EXISTS r12 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE SERVER r13 TYPE 't' FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE SERVER r14 VERSION '1' FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE SERVER r15 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u',)", + "CREATE SERVER r16 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u' PORT 1)", + "CREATE SERVER db.r17 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE OR REPLACE SERVER r18 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u')", + "CREATE SERVER r19 FOREIGN DATA WRAPPER N'mysql' OPTIONS (USER 'u')", + "CREATE SERVER r20 FOREIGN DATA WRAPPER mysql OPTIONS (PORT 0X10)", + "CREATE SERVER r21 FOREIGN DATA WRAPPER mysql OPTIONS (PORT x'1')", + "CREATE SERVER r22 FOREIGN DATA WRAPPER mysql OPTIONS (PORT 1_0)", + "CREATE SERVER r23 FOREIGN DATA WRAPPER mysql OPTIONS (PORT +1)", + "CREATE SERVER r24 FOREIGN DATA WRAPPER mysql OPTIONS (USER 'u') COMMENT 'c'", + "ALTER SERVER s", "ALTER SERVER s OPTIONS ()", "ALTER SERVER s OPTIONS (SET USER 'u')", + "ALTER SERVER s OPTIONS (DROP USER)", "ALTER SERVER s OPTIONS (PORT '1')", + "ALTER SERVER s VERSION '2'", "ALTER SERVER s VERSION '2' OPTIONS (USER 'u')", + "ALTER SERVER s RENAME TO t", "ALTER SERVER s OWNER TO o"}) + void mySqlRejectsWhatTheServerRejects(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE SERVER IF NOT EXISTS s TYPE 't' VERSION '1' FOREIGN DATA WRAPPER w OPTIONS (host 'h', dbname 'd')", + "CREATE SERVER s FOREIGN DATA WRAPPER w", + "ALTER SERVER s VERSION '2' OPTIONS (SET host 'h', ADD port '5432', DROP dbname)", + "ALTER SERVER s RENAME TO t", "ALTER SERVER s OWNER TO o"}) + void postgreSqlFormsKeepTheirReading(String sql) throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, null}) { + ForeignDataStatement statement = roundTrip(sql, dialect); + if (statement.getOptions() != null) { + for (ForeignDataOption option : statement.getOptions()) { + assertSame(option.getValue(), option.getValueExpression()); + } + } + } + } + + @Test + void mariaDbAndNoDialectKeepTheGenericOptions() throws Exception { + roundTrip("CREATE SERVER IF NOT EXISTS 's' FOREIGN DATA WRAPPER mysql" + + " OPTIONS (USER 'u', PORT 3306)", Dialect.MARIADB); + roundTrip("ALTER SERVER s OPTIONS (PORT 3307)", Dialect.MARIADB); + AlterServer server = (AlterServer) roundTrip( + "ALTER SERVER s VERSION '2' OPTIONS (SET port 5432, ADD host 'h', DROP dbname)", + null); + assertEquals(ForeignDataOption.Action.SET, server.getOptions().get(0).getAction()); + assertEquals(5432L, assertInstanceOf(LongValue.class, + server.getOptions().get(0).getValueExpression()).getValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE SERVER s FOREIGN DATA WRAPPER w OPTIONS (port 5432)", + "ALTER SERVER s OPTIONS (SET port 5432)", "CREATE SERVER 's' FOREIGN DATA WRAPPER w", + "CREATE SERVER s FOREIGN DATA WRAPPER 'w'", "ALTER SERVER 's' OPTIONS (SET host 'h')", + "CREATE USER MAPPING FOR u SERVER s OPTIONS (port 5432)"}) + void postgreSqlKeepsRejectingNumbersAndQuotedNames(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL), sql); + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.ORACLE), sql); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE USER MAPPING FOR u SERVER s OPTIONS (port 5432)", + "ALTER USER MAPPING FOR u SERVER s OPTIONS (SET port 5432)", + "CREATE FOREIGN TABLE t (a INT) SERVER s OPTIONS (port 5432)", + "ALTER FOREIGN TABLE t OPTIONS (ADD port 5432)", + "CREATE FOREIGN DATA WRAPPER w OPTIONS (port 5432)", + "CREATE SERVER s FOREIGN DATA WRAPPER w OPTIONS (port -1)", + "CREATE SERVER s FOREIGN DATA WRAPPER w OPTIONS (port 1 + 1)", + "CREATE SERVER s FOREIGN DATA WRAPPER w OPTIONS (port)", + "CREATE SERVER N's' FOREIGN DATA WRAPPER w"}) + void otherOptionListsKeepStringValues(String sql) { + for (Dialect dialect : MYSQL_FAMILY) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"DROP SERVER IF EXISTS s", "DROP SERVER s2", + "DROP SERVER IF EXISTS 's3'", "DROP SERVER `s-1`"}) + void dropServerKeepsTheGenericDrop(String sql) throws Exception { + for (Dialect dialect : MYSQL_FAMILY) { + Drop drop = assertInstanceOf(Drop.class, parse(sql, dialect)); + assertEquals("SERVER", drop.getType()); + assertEquals(sql, drop.toString()); + } + } + + @Test + void scriptsKeepEachStatement() throws Exception { + String script = "CREATE SERVER s FOREIGN DATA WRAPPER mysql OPTIONS (HOST 'h', PORT 3306);" + + " ALTER SERVER s OPTIONS (PORT 3307); SELECT * FROM t; DROP SERVER IF EXISTS s"; + for (boolean opaque : new boolean[] {false, true}) { + Statements statements = CCJSqlParserUtil.parseStatements(script, + p -> p.withDialect(Dialect.MYSQL).withUnsupportedStatements(opaque)); + assertEquals(4, statements.size()); + assertInstanceOf(CreateServer.class, statements.get(0)); + assertInstanceOf(AlterServer.class, statements.get(1)); + assertEquals(Set.of("t"), new TablesNamesFinder<>().getTables(statements.get(2))); + assertInstanceOf(Drop.class, statements.get(3)); + assertEquals(statements.toString(), CCJSqlParserUtil + .parseStatements(statements.toString(), p -> p.withDialect(Dialect.MYSQL)) + .toString()); + } + } + + private static boolean isValid(Dialect dialect, String sql, + ValidationCapability... capabilities) { + FeatureConfiguration configuration = new FeatureConfiguration(); + if (dialect != null) { + configuration.setValue(Feature.dialect, dialect.name()); + } + return new Validation(configuration, Arrays.asList(capabilities), sql).validate() + .isEmpty(); + } + + @Test + void validationKnowsTheServerStatements() { + String sql = "CREATE SERVER s FOREIGN DATA WRAPPER mysql OPTIONS (PORT 3306);" + + " ALTER SERVER s OPTIONS (PORT 3307)"; + assertTrue(isValid(Dialect.MYSQL, sql, MySqlVersion.V8_0)); + assertTrue(isValid(Dialect.MARIADB, sql, MariaDbVersion.V10_5_4)); + assertTrue(isValid(null, sql, PostgresqlVersion.V14)); + assertTrue(isValid(null, sql, + new FeaturesAllowed(Feature.createServer, Feature.alterServer))); + assertFalse(isValid(null, sql, new FeaturesAllowed(Feature.createServer))); + } + + @Test + void optionValueAccessorsShareOneValue() { + ForeignDataOption option = new ForeignDataOption("PORT", null); + assertNull(option.getValueExpression()); + assertEquals("PORT", option.toString()); + assertSame(option, option.withValueExpression(new LongValue(3306))); + assertNull(option.getValue()); + assertEquals("PORT 3306", option.toString()); + StringValue text = new StringValue("'3306'"); + option.setValue(text); + assertSame(text, option.getValue()); + assertSame(text, option.getValueExpression()); + option.setValueExpression(new LongValue(1)); + option.setAction(ForeignDataOption.Action.DROP); + assertNull(option.getValueExpression()); + assertEquals("DROP PORT", option.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlSharedTableOptionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlSharedTableOptionTest.java new file mode 100644 index 0000000000..c8e456aadc --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlSharedTableOptionTest.java @@ -0,0 +1,112 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create; + +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpressionTableOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.TableOption; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlSharedTableOptionTest { + @ParameterizedTest + @CsvSource(value = {"SECONDARY_ENGINE|NULL|SECONDARY_ENGINE", + "SECONDARY_ENGINE|'engine'|SECONDARY_ENGINE", + "SECONDARY_ENGINE|engine_name|SECONDARY_ENGINE", "AUTOEXTEND_SIZE|4M|AUTOEXTEND_SIZE", + "AUTOEXTEND_SIZE|0|AUTOEXTEND_SIZE", "INSERT_METHOD|NO|INSERT_METHOD", + "INSERT_METHOD|FIRST|INSERT_METHOD", "INSERT_METHOD|LAST|INSERT_METHOD", + "PACK_KEYS|DEFAULT|PACK_KEYS", "PACK_KEYS|1|PACK_KEYS", "PACK_KEYS|0|PACK_KEYS", + "DELAY_KEY_WRITE|2|DELAY_KEY_WRITE", "CHECKSUM|0|CHECKSUM", + "CONNECTION|'mysql://server/db/t'|CONNECTION", "COMPRESSION|'zlib'|COMPRESSION", + "ENCRYPTION|'N'|ENCRYPTION", "PASSWORD|'ignored'|PASSWORD", + "DATA DIRECTORY|'/tmp/data dir'|DATA_DIRECTORY", + "INDEX DIRECTORY|'/tmp/index dir'|INDEX_DIRECTORY", + "AUTO_INCREMENT|18446744073709551614|AUTO_INCREMENT"}, delimiter = '|', + quoteCharacter = '"') + void sharesCreateAndAlterModels(String name, String value, String kind) + throws JSQLParserException { + for (String equals : new String[] {" ", " = "}) { + String optionSql = name + equals + value; + CreateTable create = + (CreateTable) CCJSqlParserUtil.parse("CREATE TABLE t (id BIGINT) " + optionSql); + Alter alter = (Alter) CCJSqlParserUtil + .parse("ALTER TABLE t " + optionSql + ", ADD COLUMN extra INT"); + AlterExpressionTableOption action = assertInstanceOf(AlterExpressionTableOption.class, + alter.getAlterExpressions().get(0)); + TableOption option = action.getStructuredTableOption(); + assertEquals(TableOption.Kind.valueOf(kind), option.getKind()); + assertEquals(create.getTableOptions().get(0).toString(), option.toString()); + assertEquals(value, option.getValue()); + assertEquals(equals.contains("="), action.getUseEqual()); + assertEquals(optionSql, action.getTableOption()); + assertEquals(2, alter.getAlterExpressions().size()); + roundTrip(create); + roundTrip(alter); + option.setUseEquals(!option.isUseEquals()); + assertEquals(option.isUseEquals(), action.getUseEqual()); + roundTrip(alter); + action.setUseEqual(true); + assertTrue(option.isUseEquals()); + action.setTableOption("ENCRYPTION 'N'"); + assertNull(action.getStructuredTableOption()); + assertEquals("ENCRYPTION 'N'", action.toString()); + } + } + + @Test + void commasAndQuerySourceStayOutsideOptions() throws JSQLParserException { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (id INT) ENGINE=InnoDB, ENCRYPTION='N', PASSWORD='a,b' AS SELECT 1 AS id"); + assertEquals(3, table.getTableOptions().size()); + assertNotNull(table.getSelect()); + table.getTableOptions().get(1).setValue("'Y'"); + assertTrue(table.getTableOptionsStrings().contains("'Y'")); + roundTrip(table); + table.setTableOptionsStrings(List.of("ENCRYPTION", "=", "'N'")); + assertNull(table.getTableOptions()); + roundTrip(table); + } + + @ParameterizedTest + @ValueSource(strings = {"ENCRYPTION=", "PASSWORD=1", "DATA DIRECTORY='/tmp' INDEX DIRECTORY=", + "PACK_KEYS=2", "AUTOEXTEND_SIZE=-1", "INSERT_METHOD=UNKNOWN", "COMPRESSION=1", + "SECONDARY_ENGINE=", "AUTO_INCREMENT=-1", "AUTO_INCREMENT='5'", "ENCRYPTION='N',"}) + void rejectsMissingOrWrongCreateValues(String option) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("CREATE TABLE t (id INT) " + option)); + } + + @ParameterizedTest + @ValueSource(strings = {"VECTOR", "VECTOR(0)", "VECTOR(1)", "VECTOR(2048)", "VECTOR(16383)"}) + void preservesMySql9VectorColumnsBeforeTableOptions(String type) throws JSQLParserException { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (v " + type + ") ENCRYPTION='N'"); + assertEquals(type, table.getColumnDefinitions().get(0).getColDataType().toString() + .replace(" ", "")); + assertEquals(TableOption.Kind.ENCRYPTION, table.getTableOptions().get(0).getKind()); + roundTrip(table); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), CCJSqlParserUtil.parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlTableDefinitionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlTableDefinitionTest.java index cc0b580d13..4975f0700b 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/MySqlTableDefinitionTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlTableDefinitionTest.java @@ -24,9 +24,10 @@ import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.ForeignKeyReference; -import net.sf.jsqlparser.statement.create.table.ForeignKeyIndex; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; import net.sf.jsqlparser.statement.create.table.Index; -import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintKind; import net.sf.jsqlparser.statement.create.table.TableOption; import org.junit.jupiter.api.Test; @@ -39,9 +40,9 @@ public void testConstraintBeforeColumnDefinition() throws JSQLParserException { parseMySql("CREATE TABLE inventory (PRIMARY KEY (id), id INT NOT NULL)"); assertEquals(2, table.getTableElements().size()); - assertInstanceOf(Index.class, table.getTableElements().get(0)); + assertInstanceOf(KeyConstraint.class, table.getTableElements().get(0)); assertInstanceOf(ColumnDefinition.class, table.getTableElements().get(1)); - assertEquals("PRIMARY KEY", table.getIndexes().get(0).getType()); + assertEquals("PRIMARY KEY", table.getTableConstraints().get(0).getType()); assertReparse(table); } @@ -51,11 +52,11 @@ public void testNamedPrimaryAndSpecializedIndexes() throws JSQLParserException { + "PRIMARY KEY pk_documents (id), FULLTEXT INDEX ft_body (body), " + "INDEX ((CAST(data AS CHAR(30)))))"); - NamedConstraint primary = (NamedConstraint) table.getIndexes().get(0); + KeyConstraint primary = (KeyConstraint) table.getTableConstraints().get(0); assertEquals("pk_documents", primary.getIndexName()); - assertEquals(Index.Kind.PRIMARY_KEY, primary.getKind()); - assertEquals(Index.Kind.FULLTEXT, table.getIndexes().get(1).getKind()); - assertTrue(table.getIndexes().get(2).getColumns().get(0).isExpression()); + assertEquals(ConstraintKind.PRIMARY_KEY, primary.getKind()); + assertEquals(Index.Kind.FULLTEXT, table.getIndexes().get(0).getKind()); + assertTrue(table.getIndexes().get(1).getColumns().get(0).isExpression()); assertReparse(table); } @@ -168,8 +169,8 @@ public void testTableForeignKeyUsesStructuredReference() throws JSQLParserExcept + "CONSTRAINT fk_customer FOREIGN KEY (customer_id) REFERENCES customer(id) " + "MATCH FULL ON DELETE CASCADE)"); - ForeignKeyIndex foreignKey = (ForeignKeyIndex) table.getIndexes().get(0); - assertEquals(Index.Kind.FOREIGN_KEY, foreignKey.getKind()); + ForeignKeyConstraint foreignKey = (ForeignKeyConstraint) table.getTableConstraints().get(0); + assertEquals(ConstraintKind.FOREIGN_KEY, foreignKey.getKind()); assertEquals("customer", foreignKey.getReference().getTable().getName()); assertEquals(ForeignKeyReference.MatchType.FULL, foreignKey.getMatchType()); assertReparse(table); @@ -198,13 +199,13 @@ public void testCreateAndAlterTableIndexParity() throws JSQLParserException { + "ADD FULLTEXT INDEX ft_body (body)", parser -> parser.withDialect(Dialect.MYSQL)); - assertEquals(create.getIndexes().get(0).getClass(), - alter.getAlterExpressions().get(0).getIndex().getClass()); - assertEquals(create.getIndexes().get(0).getKind(), - alter.getAlterExpressions().get(0).getIndex().getKind()); + assertEquals(create.getTableConstraints().get(0).getClass(), + alter.getAlterExpressions().get(0).getConstraint().getClass()); + assertEquals(create.getTableConstraints().get(0).getKind(), + alter.getAlterExpressions().get(0).getConstraint().getKind()); + assertEquals(create.getTableConstraints().get(0).toString(), + alter.getAlterExpressions().get(0).getConstraint().toString()); assertEquals(create.getIndexes().get(0).toString(), - alter.getAlterExpressions().get(0).getIndex().toString()); - assertEquals(create.getIndexes().get(1).toString(), alter.getAlterExpressions().get(1).getIndex().toString()); CCJSqlParserUtil.parse(alter.toString(), parser -> parser.withDialect(Dialect.MYSQL)); } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/MySqlViewOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/MySqlViewOptionsTest.java new file mode 100644 index 0000000000..29eeb07b89 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/MySqlViewOptionsTest.java @@ -0,0 +1,108 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +import net.sf.jsqlparser.statement.create.view.*; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlViewOptionsTest { + @ParameterizedTest + @ValueSource(strings = {"ALGORITHM = MERGE", "ALGORITHM = TEMPTABLE", + "ALGORITHM = UNDEFINED", "DEFINER = CURRENT_USER", "DEFINER = CURRENT_USER()", + "DEFINER = 'user'@'localhost'", "DEFINER = `user`@`localhost`", + "SQL SECURITY INVOKER", "SQL SECURITY DEFINER", + "ALGORITHM = MERGE DEFINER = CURRENT_USER SQL SECURITY INVOKER"}) + void createAndAlterSharePrefix(String options) throws JSQLParserException { + for (String operation : new String[] {"CREATE", "CREATE OR REPLACE", "ALTER"}) { + String sql = operation + " " + options + " VIEW v AS SELECT id FROM t"; + Statement statement = parse(sql); + assertEquals(sql, statement.toString()); + assertRoundTrip(statement); + assertTrue(new TablesNamesFinder().getTables(statement).contains("t")); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.MYSQL)).size()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CHECK OPTION", "LOCAL CHECK OPTION", "CASCADED CHECK OPTION"}) + void checkOptionTailIsShared(String tail) throws JSQLParserException { + for (String operation : new String[] {"CREATE", "ALTER"}) { + String sql = + operation + " SQL SECURITY INVOKER VIEW v AS SELECT id FROM t WITH " + tail; + Statement statement = parse(sql); + assertEquals(sql, statement.toString()); + assertRoundTrip(statement); + } + } + + @Test + void optionsAndDefinerAreMutable() throws JSQLParserException { + CreateView view = (CreateView) parse( + "CREATE ALGORITHM=MERGE DEFINER=CURRENT_USER() VIEW v AS SELECT 1"); + MySqlViewOptions options = view.getMySqlOptions(); + assertEquals(MySqlViewOptions.Algorithm.MERGE, options.getAlgorithm()); + assertTrue(options.getDefiner().isCurrentUserParentheses()); + options.getDefiner().setUser(new StringValue("owner")); + options.getDefiner().setHost(new StringValue("localhost")); + options.setAlgorithm(MySqlViewOptions.Algorithm.TEMPTABLE); + options.setSecurity(MySqlViewOptions.Security.INVOKER); + assertEquals( + "CREATE ALGORITHM = TEMPTABLE DEFINER = 'owner'@'localhost' SQL SECURITY INVOKER VIEW v AS SELECT 1", + view.toString()); + assertRoundTrip(view); + view.setMySqlOptions(null); + assertEquals("CREATE VIEW v AS SELECT 1", view.toString()); + } + + @Test + void sharedAccountParserPreservesTriggerDispatch() throws JSQLParserException { + for (String account : new String[] {"CURRENT_USER", "CURRENT_USER()", "'u'@'localhost'"}) { + CreateTrigger trigger = (CreateTrigger) parse("CREATE DEFINER = " + account + + " TRIGGER tr BEFORE INSERT ON t FOR EACH ROW SET @a = 1"); + assertEquals(account, trigger.getDefiner().toString()); + assertRoundTrip(trigger); + } + } + + @Test + void invalidPrefixValuesFail() { + for (String sql : new String[] {"CREATE ALGORITHM=INVALID VIEW v AS SELECT 1", + "ALTER SQL SECURITY PUBLIC VIEW v AS SELECT 1"}) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + if (statement instanceof net.sf.jsqlparser.statement.UnsupportedStatement) { + throw new JSQLParserException("Expected a structured statement"); + } + return statement; + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PartitionKeyMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PartitionKeyMutationTest.java new file mode 100644 index 0000000000..3e2689ba8e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PartitionKeyMutationTest.java @@ -0,0 +1,89 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.KeyElement; +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.TablePartitioning; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.api.Test; + +class PartitionKeyMutationTest { + @Test + void replacingSingleKeyWithSeveralKeysChangesBothRenderers() throws JSQLParserException { + CreateTable table = parse("CREATE TABLE t(id INT,other INT) PARTITION BY RANGE(id)", + Dialect.POSTGRESQL); + table.getPartitioning().setExpressionList( + new ExpressionList(new Column("other"), new Column("id"))); + assertRoundTrip(table, + "CREATE TABLE t (id INT, other INT) PARTITION BY RANGE (other, id)", + Dialect.POSTGRESQL); + assertNull(table.getPartitioning().getExpression()); + } + + @Test + void switchingHashToKeyUsesNewColumnNames() throws JSQLParserException { + CreateTable table = parse("CREATE TABLE t(id INT,other INT) PARTITION BY HASH(id)", + Dialect.MYSQL); + TablePartitioning partition = table.getPartitioning(); + partition.setType(TablePartitioning.Type.KEY); + partition.setColumns(new ExpressionList<>(new Column("other"))); + assertRoundTrip(table, "CREATE TABLE t (id INT, other INT) PARTITION BY KEY (other)", + Dialect.MYSQL); + partition.setType(TablePartitioning.Type.HASH); + partition.setExpression(new Column("id")); + assertNull(partition.getColumns()); + assertRoundTrip(table, "CREATE TABLE t (id INT, other INT) PARTITION BY HASH (id)", + Dialect.MYSQL); + } + + @Test + void attributedKeysReplaceAndAreReplacedByPlainKeys() throws JSQLParserException { + CreateTable table = parse("CREATE TABLE t(id INT,other INT) PARTITION BY RANGE(id,other)", + Dialect.POSTGRESQL); + TablePartitioning partition = table.getPartitioning(); + partition.setKeyColumns( + List.of(new KeyElement("other").withOperatorClass("int4_ops"))); + assertNull(partition.getExpressionList()); + assertRoundTrip(table, + "CREATE TABLE t (id INT, other INT) PARTITION BY RANGE (other int4_ops)", + Dialect.POSTGRESQL); + partition.setExpression(new Column("id")); + assertNull(partition.getKeyColumns()); + assertRoundTrip(table, "CREATE TABLE t (id INT, other INT) PARTITION BY RANGE (id)", + Dialect.POSTGRESQL); + partition.setColumns(null); + partition.setExpressionList(null); + partition.setKeyColumns(null); + assertRoundTrip(table, "CREATE TABLE t (id INT, other INT) PARTITION BY RANGE (id)", + Dialect.POSTGRESQL); + } + + private static CreateTable parse(String sql, Dialect dialect) throws JSQLParserException { + return (CreateTable) CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertRoundTrip(CreateTable table, String expected, Dialect dialect) + throws JSQLParserException { + assertEquals(expected, table.toString()); + StringBuilder output = new StringBuilder(); + table.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + assertEquals(expected, parse(output.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessDdlTest.java index 6b8b1e8fb0..c919603b1c 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessDdlTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessDdlTest.java @@ -32,6 +32,7 @@ import net.sf.jsqlparser.schema.Column; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.CascadeBehavior; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitorAdapter; import net.sf.jsqlparser.statement.StmtFeature; @@ -173,7 +174,7 @@ void testRevokeAndDefaults() throws Exception { assertThat(revoke.getOptionFor()).isEqualTo(GrantOption.Kind.ADMIN); assertThat(revoke.getClause().getRoles()).containsExactly("reader", "writer"); assertThat(revoke.getClause().getGrantedBy()).isEqualTo("owner"); - assertThat(revoke.getBehavior()).isEqualTo(Revoke.Behavior.CASCADE); + assertThat(revoke.getBehavior()).isEqualTo(CascadeBehavior.CASCADE); AlterDefaultPrivileges defaults = (AlterDefaultPrivileges) CCJSqlParserUtil.parse( "ALTER DEFAULT PRIVILEGES FOR USER owner IN SCHEMA app GRANT SELECT ON TABLES TO reader"); assertThat(defaults.getRoleKeyword()).isEqualTo(AlterDefaultPrivileges.RoleKeyword.USER); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessMethodTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessMethodTest.java new file mode 100644 index 0000000000..58b6ddc3cc --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAccessMethodTest.java @@ -0,0 +1,85 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlAccessMethodTest { + @ParameterizedTest + @ValueSource(strings = {"TABLE", "INDEX"}) + void preservesAccessMethodKindAndDoesNotInventTableReferences(String type) + throws JSQLParserException { + String sql = "CREATE ACCESS METHOD am TYPE " + type + " HANDLER public.handlerfn"; + CreateAccessMethod statement = assertInstanceOf(CreateAccessMethod.class, + CCJSqlParserUtil.parse(sql)); + assertEquals("am", statement.getName()); + assertEquals(CreateAccessMethod.Type.valueOf(type), statement.getType()); + assertEquals("public.handlerfn", statement.getHandler()); + assertEquals(sql, statement.toString()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + assertTrue(statement.getFeatures().modifiesSchema()); + assertFalse(statement.getFeatures().returnsResultSet()); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(sql, output.toString()); + assertInstanceOf(CreateAccessMethod.class, CCJSqlParserUtil.parse(output.toString())); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty()); + assertTrue(new Validation(List.of(PostgresqlVersion.V12), sql).validate().isEmpty()); + assertFalse(new Validation(List.of(FeaturesAllowed.SELECT), sql).validate().isEmpty()); + assertEquals(type.equals("INDEX"), + new Validation(List.of(PostgresqlVersion.V10), sql).validate().isEmpty()); + } + + @Test + void quotedNamesRemainMutableAndVisitorsReceiveContext() throws JSQLParserException { + CreateAccessMethod statement = assertInstanceOf(CreateAccessMethod.class, + CCJSqlParserUtil.parse( + "CREATE ACCESS METHOD \"my method\" TYPE TABLE HANDLER \"my schema\".\"my handler\"")); + assertEquals("\"my method\"", statement.getName()); + assertEquals("\"my schema\".\"my handler\"", statement.getHandler()); + String actual = statement.accept(new StatementVisitorAdapter() { + @Override + public String visit(CreateAccessMethod method, S context) { + return context + ":" + method.getName(); + } + }, "visited"); + assertEquals("visited:\"my method\"", actual); + statement.setName("other_method"); + statement.setType(CreateAccessMethod.Type.INDEX); + statement.setHandler("other_schema.handler"); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals("CREATE ACCESS METHOD other_method TYPE INDEX HANDLER other_schema.handler", + output.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE ACCESS METHOD am TYPE TABLE", + "CREATE ACCESS METHOD am TYPE VIEW HANDLER fn", + "CREATE OR REPLACE ACCESS METHOD am TYPE TABLE HANDLER fn", + "CREATE ACCESS METHOD am TYPE TABLE HANDLER fn()"}) + void rejectsIncompleteOrInvalidAccessMethodDefinitions(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAggregateDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAggregateDdlTest.java new file mode 100644 index 0000000000..42328e9821 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlAggregateDdlTest.java @@ -0,0 +1,310 @@ +/*- + * #%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.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterAggregate; +import net.sf.jsqlparser.statement.create.aggregate.CreateAggregate; +import net.sf.jsqlparser.statement.create.function.CreateFunction; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL CREATE AGGREGATE and ALTER AGGREGATE, see + * https://www.postgresql.org/docs/18/sql-createaggregate.html and + * https://www.postgresql.org/docs/18/sql-alteraggregate.html. + */ +class PostgreSqlAggregateDdlTest extends ValidationTestAsserts { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Statement assertStatement(String sql, Class type) + throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isInstanceOf(type).hasToString(sql); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(type); + StatementDeParser deparser = new StatementDeParser(new StringBuilder()); + statement.accept(deparser); + assertThat(deparser.getBuilder()).hasToString(sql); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + + Statements script = CCJSqlParserUtil.parseStatements( + sql + "; SELECT 1; " + sql + ";\n" + sql, POSTGRESQL); + assertThat(script).hasSize(4); + assertThat(script.get(0)).isInstanceOf(type).hasToString(sql); + assertThat(script.get(2)).isInstanceOf(type).hasToString(sql); + assertThat(script.get(3)).isInstanceOf(type).hasToString(sql); + return statement; + } + + private static void assertRejected(String sql) { + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql, POSTGRESQL)) + .isInstanceOf(JSQLParserException.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE AGGREGATE agg(int) (SFUNC = f, STYPE = int, INITCOND = '0')", + "CREATE OR REPLACE AGGREGATE agg(ORDER BY int) (SFUNC = f, STYPE = internal, " + + "FINALFUNC = g, HYPOTHETICAL)", + "CREATE AGGREGATE s.agg(*) (SFUNC = f, STYPE = int, PARALLEL = SAFE)", + "CREATE AGGREGATE agg2(int, text) (SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(a int, b text) (SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(VARIADIC a int[]) (SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(VARIADIC \"any\") (SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(IN a int) (SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(float8 ORDER BY float8) (SFUNC = f, STYPE = internal, " + + "FINALFUNC = g, FINALFUNC_EXTRA)", + "CREATE AGGREGATE agg2(a int, b text ORDER BY c int, VARIADIC d text[]) " + + "(SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(varchar (3), int[], double precision) (SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg2(int) (SFUNC = g, STYPE = int, SORTOP = <, MSFUNC = g, " + + "MINVFUNC = g, MSTYPE = int, MSSPACE = 8, SSPACE = 0, " + + "FINALFUNC_MODIFY = READ_ONLY, COMBINEFUNC = g)", + "CREATE AGGREGATE agg2(int) (SFUNC = g, STYPE = int, " + + "SORTOP = OPERATOR(pg_catalog.>), INITCOND = '0')", + "CREATE AGGREGATE agg2(int) (SFUNC = g, stype = int[], initcond = '{}', " + + "parallel = restricted)", + "CREATE AGGREGATE \"Agg\"(int) (\"SFUNC\" = g, STYPE = int)", + "CREATE AGGREGATE d.public.agg3(int) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg7(int) (HYPOTHETICAL)", + // the old form + "CREATE AGGREGATE agg (BASETYPE = int, SFUNC = f, STYPE = int)", + "CREATE AGGREGATE agg4 (sfunc = g, stype = int, basetype = int, initcond = '0')", + "CREATE AGGREGATE agg5 (basetype = 'ANY', sfunc = g, stype = int)", + "CREATE AGGREGATE agg5 (\"parallel\" = safe, sfunc = g, stype = int)", + "CREATE AGGREGATE s.agg6 (sfunc1 = g, basetype = int, stype1 = int)", + "CREATE OR REPLACE AGGREGATE agg (sfunc = g, stype = int, basetype = int)"}) + void testCreateAggregate(String sql) throws Exception { + assertStatement(sql, CreateAggregate.class); + } + + @Test + void testAggregateNamedFunction() throws Exception { + // FUNCTION is no reserved word in PostgreSQL, while MySQL has CREATE AGGREGATE FUNCTION + String sql = "CREATE AGGREGATE function(int) (SFUNC = g, STYPE = int)"; + assertThat(assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL)) + .isInstanceOf(CreateAggregate.class); + assertThat(CCJSqlParserUtil.parse(sql)).isInstanceOf(UnsupportedStatement.class); + } + + @Test + void testCreateAggregateFields() throws Exception { + CreateAggregate aggregate = (CreateAggregate) CCJSqlParserUtil.parse( + "CREATE OR REPLACE AGGREGATE app.agg (a int, VARIADIC b text[] ORDER BY c float8) " + + "(SFUNC = app.f, STYPE = internal, SORTOP = <, INITCOND = '0', " + + "HYPOTHETICAL)", + POSTGRESQL); + assertThat(aggregate.isOrReplace()).isTrue(); + assertThat(aggregate.isOldStyle()).isFalse(); + RoutineReference signature = aggregate.getAggregate(); + assertThat(signature.getName()).isEqualTo("app.agg"); + assertThat(signature.isAllArguments()).isFalse(); + assertThat(signature.getArguments()).hasSize(2); + assertThat(signature.getArguments().get(0).getName()).isEqualTo("a"); + assertThat(signature.getArguments().get(1).getMode()) + .isEqualTo(RoutineReference.Argument.Mode.VARIADIC); + assertThat(signature.getArguments().get(1).getDataType()).hasToString("text[]"); + assertThat(signature.getOrderByArguments()).hasSize(1); + assertThat(aggregate.getDefinition()).hasSize(5); + assertThat(aggregate.getDefinitionElement("sfunc").getArgument().getDataType() + .getDataType()).isEqualTo("app.f"); + assertThat(aggregate.getDefinitionElement("SORTOP").getArgument().getKind()) + .isEqualTo(DefinitionArgument.Kind.OPERATOR); + assertThat(aggregate.getDefinitionElement("INITCOND").getArgument().getString().getValue()) + .isEqualTo("0"); + assertThat(aggregate.getDefinitionElement("HYPOTHETICAL").getArgument()).isNull(); + assertThat(aggregate.getDefinitionElement("FINALFUNC")).isNull(); + assertThat(aggregate.getASTNode()).isNotNull(); + + aggregate.setOrReplace(false); + signature.setOrderByArguments(null); + aggregate.getDefinition().subList(2, 5).clear(); + assertThat(aggregate).hasToString("CREATE AGGREGATE app.agg(a int, VARIADIC b text[]) " + + "(SFUNC = app.f, STYPE = internal)"); + + CreateAggregate all = (CreateAggregate) CCJSqlParserUtil.parse( + "CREATE AGGREGATE cnt (*) (SFUNC = f, STYPE = int8)", POSTGRESQL); + assertThat(all.getAggregate().isAllArguments()).isTrue(); + assertThat(all.isOldStyle()).isFalse(); + + CreateAggregate old = (CreateAggregate) CCJSqlParserUtil.parse( + "CREATE AGGREGATE app.agg (BASETYPE = int, SFUNC = f, STYPE = int)", POSTGRESQL); + assertThat(old.isOldStyle()).isTrue(); + assertThat(old.isOrReplace()).isFalse(); + assertThat(old.getAggregate().getName()).isEqualTo("app.agg"); + assertThat(old.getAggregate().getArguments()).isNull(); + assertThat(old.getDefinitionElement("basetype").getArgument().getDataType()) + .hasToString("int"); + assertThat(new CreateAggregate().isOldStyle()).isFalse(); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE AGGREGATE agg8 () (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg8 (int)", + "CREATE AGGREGATE agg8 (int) ()", + "CREATE AGGREGATE agg8", + "CREATE AGGREGATE agg8 (int) (SFUNC = g, STYPE = )", + "CREATE AGGREGATE agg8 (*, int) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg8 (int ORDER BY) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg8 (ORDER BY int ORDER BY int) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg8 (int DEFAULT 1) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg8 (DISTINCT int) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE IF NOT EXISTS agg8 (int) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE agg8 (int) (SFUNC = g, STYPE = int) OWNER TO u", + "CREATE AGGREGATE agg8 (int) SFUNC = g, STYPE = int", + "CREATE AGGREGATE agg8 (int) (SFUNC = g, STYPE = int) (x = 1)", + "CREATE AGGREGATE FUNCTION agg8 (int) (SFUNC = g, STYPE = int)", + "CREATE AGGREGATE FUNCTION f RETURNS STRING SONAME 'x.so'", + // the old form takes identifiers with values only, and no keyword is an identifier + "CREATE AGGREGATE agg8 (SFUNC = g, STYPE = int, HYPOTHETICAL)", + "CREATE AGGREGATE agg8 (sfunc = g, parallel = safe, stype = int)", + "CREATE AGGREGATE agg8 (parallel = safe, sfunc = g, stype = int)", + "CREATE AGGREGATE agg8 (sfunc = g, type = int)", + "CREATE AGGREGATE agg8 (sfunc = g, int = int)", + "CREATE AGGREGATE agg8 (sfunc = g, between = int)", + "CREATE AGGREGATE agg8 (sfunc = g, left = int)", + "CREATE AGGREGATE agg8 (sfunc = g, select = int)"}) + void testRejectedCreateAggregate(String sql) { + assertRejected(sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER AGGREGATE agg(int) RENAME TO agg2", + "ALTER AGGREGATE agg(VARIADIC a int ORDER BY b text) OWNER TO u", + "ALTER AGGREGATE agg(*) SET SCHEMA s", + "ALTER AGGREGATE s.agg(int, text) OWNER TO CURRENT_USER", + "ALTER AGGREGATE agg(ORDER BY int) RENAME TO \"Agg 2\"", + "ALTER AGGREGATE agg(a int, b int ORDER BY c int) SET SCHEMA t"}) + void testAlterAggregate(String sql) throws Exception { + assertStatement(sql, AlterAggregate.class); + } + + @Test + void testAlterAggregateFields() throws Exception { + AlterAggregate rename = (AlterAggregate) CCJSqlParserUtil.parse( + "ALTER AGGREGATE app.agg (int, text) RENAME TO agg2", POSTGRESQL); + assertThat(rename.getAggregate().getName()).isEqualTo("app.agg"); + assertThat(rename.getAggregate().getArguments()).hasSize(2); + assertThat(rename.getAction()).isEqualTo(AlterAggregate.Action.RENAME); + assertThat(rename.getNewName()).isEqualTo("agg2"); + rename.setAction(AlterAggregate.Action.OWNER); + rename.setNewName("u"); + assertThat(rename).hasToString("ALTER AGGREGATE app.agg(int, text) OWNER TO u"); + rename.setAction(AlterAggregate.Action.SET_SCHEMA); + assertThat(rename).hasToString("ALTER AGGREGATE app.agg(int, text) SET SCHEMA u"); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER AGGREGATE agg RENAME TO agg2", + "ALTER AGGREGATE agg () RENAME TO agg2", + "ALTER AGGREGATE agg (int)", + "ALTER AGGREGATE agg (int) RENAME agg2", + "ALTER AGGREGATE agg (int) RENAME TO s.agg2", + "ALTER AGGREGATE agg (int) SET (x = 1)", + "ALTER AGGREGATE agg (int) SET SCHEMA", + "ALTER AGGREGATE agg (int), agg2 (int) OWNER TO u", + "ALTER AGGREGATE IF EXISTS agg (int) RENAME TO agg2", + "ALTER AGGREGATE agg (int) OWNER TO u, v", + "ALTER AGGREGATE agg (int) DEPENDS ON EXTENSION e", + "ALTER AGGREGATE agg (int) RENAME TO agg2 CASCADE"}) + void testRejectedAlterAggregate(String sql) { + assertRejected(sql); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } + + /** PostgreSQL's aggregate signature is "*" or has an argument, wherever one is read. */ + @ParameterizedTest + @ValueSource(strings = { + "DROP AGGREGATE agg ()", + "DROP AGGREGATE agg (int), agg2 ()", + "COMMENT ON AGGREGATE agg () IS 'x'"}) + void testEmptyAggregateSignatureIsRejected(String sql) { + assertRejected(sql); + } + + @Test + void testOtherDialectsKeepTheirAggregates() throws Exception { + String mysql = "CREATE AGGREGATE FUNCTION f RETURNS STRING SONAME 'x.so'"; + for (Statement statement : new Statement[] {CCJSqlParserUtil.parse(mysql), + CCJSqlParserUtil.parse(mysql, parser -> parser.withDialect(Dialect.MYSQL))}) { + assertThat(statement).isInstanceOf(CreateFunction.class).hasToString(mysql); + assertThat(((CreateFunction) statement).getLoadableFunction()).isNotNull(); + } + String sqlServer = "CREATE AGGREGATE dbo.Concatenate (@input nvarchar(200)) " + + "RETURNS nvarchar(max) EXTERNAL NAME StringUtilities.Concatenate"; + assertThat(CCJSqlParserUtil.parse(sqlServer)).isInstanceOf(UnsupportedStatement.class); + assertThat(CCJSqlParserUtil.parse(sqlServer, + parser -> parser.withDialect(Dialect.SQLSERVER))) + .isInstanceOf(UnsupportedStatement.class); + } + + @Test + void testVisitorsAndValidation() throws Exception { + String create = "CREATE AGGREGATE agg(int) (SFUNC = f, STYPE = int)"; + validateNoErrors(create, 1, FeaturesAllowed.CREATE); + validateNotAllowed(create, 1, 1, FeaturesAllowed.SELECT, Feature.createAggregate); + validate(create, 1, 1, MySqlVersion.V8_0); + String alter = "ALTER AGGREGATE agg(int) RENAME TO agg2"; + validateNoErrors(alter, 1, FeaturesAllowed.ALTER); + validateNotAllowed(alter, 1, 1, FeaturesAllowed.SELECT, Feature.alterAggregate); + validate(alter, 1, 1, MySqlVersion.V8_0); + + StatementVisitorAdapter visitor = new StatementVisitorAdapter() { + @Override + public String visit(CreateAggregate statement, S context) { + return context + ":" + statement.getAggregate().getName(); + } + + @Override + public String visit(AlterAggregate statement, S context) { + return context + ":" + statement.getNewName(); + } + }; + assertThat(CCJSqlParserUtil.parse(create, POSTGRESQL).accept(visitor, "c")) + .isEqualTo("c:agg"); + assertThat(CCJSqlParserUtil.parse(alter, POSTGRESQL).accept(visitor, "c")) + .isEqualTo("c:agg2"); + assertThat(CCJSqlParserUtil.parse(create, POSTGRESQL) + .accept(new StatementVisitorAdapter(), "c")).isNull(); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlBaseTypeTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlBaseTypeTest.java new file mode 100644 index 0000000000..80c60c1b65 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlBaseTypeTest.java @@ -0,0 +1,365 @@ +/*- + * #%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 net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.DoubleValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.SignedExpression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionArgument.Kind; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.alter.AlterType; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.type.BaseTypeDefinition; +import net.sf.jsqlparser.statement.create.type.CompositeTypeDefinition; +import net.sf.jsqlparser.statement.create.type.CreateType; +import net.sf.jsqlparser.statement.create.type.EnumTypeDefinition; +import net.sf.jsqlparser.statement.create.type.RangeTypeDefinition; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL base types: CREATE TYPE name (definition) and ALTER TYPE name SET (definition), see + * https://www.postgresql.org/docs/18/sql-createtype.html and + * https://www.postgresql.org/docs/18/sql-altertype.html. + */ +class PostgreSqlBaseTypeTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static List elements(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql, POSTGRESQL); + return statement instanceof CreateType + ? ((BaseTypeDefinition) ((CreateType) statement).getDefinition()).getElements() + : ((AlterType) statement).getProperties(); + } + + private static String deparse(Statement statement) { + StatementDeParser deparser = new StatementDeParser(new StringBuilder()); + statement.accept(deparser); + return deparser.getBuilder().toString(); + } + + private static DefinitionArgument argument(String value) throws JSQLParserException { + return elements("CREATE TYPE b1 (x = " + value + ")").get(0).getArgument(); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TYPE box3 (INPUT = box3_in, OUTPUT = box3_out, INTERNALLENGTH = 16)", + "CREATE TYPE box3 (INPUT = box3_in, OUTPUT = box3_out, INTERNALLENGTH = 4, PASSEDBYVALUE)", + "CREATE TYPE b1 (INPUT = box3_in, OUTPUT = box3_out, RECEIVE = box3_recv, SEND = box3_send, " + + "TYPMOD_IN = a, TYPMOD_OUT = b, ANALYZE = c, SUBSCRIPT = d, " + + "INTERNALLENGTH = VARIABLE, PASSEDBYVALUE, ALIGNMENT = double, " + + "STORAGE = extended, LIKE = int4, CATEGORY = 'U', PREFERRED = true, " + + "DEFAULT = 'x', ELEMENT = int4, DELIMITER = ',', COLLATABLE = false)", + "CREATE TYPE b1 (INPUT = public.box3_in, OUTPUT = box3_out, ELEMENT = int4[], " + + "LIKE = double precision, DEFAULT = NULL, INTERNALLENGTH = -1)", + "CREATE TYPE s.b1 (INPUT = box3_in)", + "CREATE TYPE a.b.c (x = 1)", + "CREATE TYPE b1 (foo = bar)", + "CREATE TYPE b1 (foo)", + "CREATE TYPE b1 (select = 1, table, from = x)", + "CREATE TYPE b1 (x = NONE, y = +, z = OPERATOR(pg_catalog.<=), w = 1.5, v = +2, u = -3)", + "CREATE TYPE b1 (x = 1e3, y = .5)", + "CREATE TYPE b1 (x = OPERATOR(+), y = operator)", + "CREATE TYPE b1 (x = OPERATOR(a.b.+))", + "CREATE TYPE b1 (x = OPERATOR(=), y = =, z = <>, w = !=, v = <=, u = >=, t = ||, " + + "s = ->>, r = @>, q = ~~*, p = %, o = ^, n = /, m = *, l = <, k = >)", + "CREATE TYPE b1 (x = @)", + "CREATE TYPE b1 (x = <@>)", + "CREATE TYPE b1 (x = select, y = user, z = true, w = null, v = default, u = on, t = table)", + "CREATE TYPE b1 (x = null, y = array, z = any)", + "CREATE TYPE b1 (x = left, y = inner, z = like, w = authorization)", + "CREATE TYPE b1 (x = extended, y = key, z = type, w = value)", + "CREATE TYPE b1 (x = int, y = char, z = bit, w = json, v = interval, u = timestamp)", + "CREATE TYPE b1 (x = a.b.c.d)", + "CREATE TYPE b1 (x = a.b.c%TYPE)", + "CREATE TYPE b1 (x = SETOF int[])", + "CREATE TYPE b1 (x = SETOF int, y = t.a%TYPE, z = SETOF t.a%TYPE, s = int ARRAY[3])", + "CREATE TYPE b1 (x = char varying, z = time without time zone)", + "ALTER TYPE box3 SET (SEND = box3_send, RECEIVE = box3_recv)", + "ALTER TYPE box3 SET (SEND = NONE)", + "ALTER TYPE box3 SET (SEND)", + "ALTER TYPE box3 SET (SEND = NONE, SEND = NONE)", + "ALTER TYPE box3 SET (STORAGE = plain)", + "ALTER TYPE box3 SET (STORAGE = extended)", + "ALTER TYPE box3 SET (STORAGE = 'plain')", + "ALTER TYPE box3 SET (STORAGE = 1)", + "ALTER TYPE box3 SET (ANALYZE = public.box3_an, TYPMOD_IN = NONE, TYPMOD_OUT = NONE, " + + "SUBSCRIPT = NONE)", + "ALTER TYPE box3 SET (SEND = 'x')", + "ALTER TYPE box3 SET (SEND = +)", + "ALTER TYPE box3 SET (SEND = OPERATOR(pg_catalog.+))", + "ALTER TYPE box3 SET (SEND = select)", + "ALTER TYPE box3 SET (SEND = true)", + "ALTER TYPE box3 SET (SEND = int4[])", + "ALTER TYPE box3 SET (SEND = SETOF t.a%TYPE)", + "ALTER TYPE box3 SET (SEND = double precision)", + "ALTER TYPE s.box3 SET (SEND = box3_send)", + "ALTER TYPE nosuch SET (foo = bar)", + "ALTER TYPE nosuch SET (foo)", + "ALTER TYPE nosuch SET (SEND = 1)", + "ALTER TYPE nosuch SET (SEND = -1.5)", + "ALTER TYPE nosuch SET (select = x)"}) + void testBaseTypeDefinitions(String sql) throws Exception { + // the text is kept as written, with the dialect and without one + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isInstanceOfAny(CreateType.class, AlterType.class); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).hasToString(sql); + + assertThat(deparse(statement)).isEqualTo(sql); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + validateNoErrors(sql, 1, DatabaseType.POSTGRESQL); + + Statements script = CCJSqlParserUtil.parseStatements(sql + "; SELECT 1; " + sql, + POSTGRESQL); + assertThat(script).hasSize(3); + assertThat(script.get(0)).hasToString(sql); + assertThat(script.get(1)).isInstanceOf(Select.class); + assertThat(script.get(2)).hasToString(sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TYPE b1(x=1) | CREATE TYPE b1 (x = 1)", + "CREATE TYPE b1 (x = none) | CREATE TYPE b1 (x = NONE)", + "CREATE TYPE \"B 1\" (\"In Put\" = 1) | CREATE TYPE \"B 1\" (\"In Put\" = 1)", + "CREATE TYPE b1 (z = - 1, w = + 2.5) | CREATE TYPE b1 (z = -1, w = +2.5)", + "CREATE TYPE b1 (q = E'a\\nb', r = $$x$$, p = U&'d\\0061t') " + + "| CREATE TYPE b1 (q = E'a\\nb', r = $$x$$, p = U&'d\\0061t')", + "CREATE TYPE b1 (x = setof int, w = varchar(10), q = numeric(10,2), r = \"char\") " + + "| CREATE TYPE b1 (x = SETOF int, w = varchar (10), q = numeric (10, 2), r = \"char\")", + "CREATE TYPE b1 (v = timestamp(3) with time zone, y = character(3), w = \"X\".y) " + + "| CREATE TYPE b1 (v = timestamp(3) with time zone, y = character (3), w = \"X\".y)", + "ALTER TYPE box3 SET (\"send\" = NONE) | ALTER TYPE box3 SET (\"send\" = NONE)", + "ALTER TYPE box3 SET (SEND = varchar(10)) | ALTER TYPE box3 SET (SEND = varchar (10))"}) + void testNormalizedRendering(String pair) throws Exception { + String[] parts = pair.split(" \\| "); + Statement statement = CCJSqlParserUtil.parse(parts[0], POSTGRESQL); + assertThat(statement).hasToString(parts[1]); + assertThat(deparse(statement)).isEqualTo(parts[1]); + assertThat(CCJSqlParserUtil.parse(parts[1], POSTGRESQL)).hasToString(parts[1]); + } + + @Test + void testElementsAndArgumentKinds() throws Exception { + CreateType type = (CreateType) CCJSqlParserUtil.parse( + "CREATE TYPE app.box3 (INPUT = app.box3_in, PASSEDBYVALUE, internallength = 16, " + + "DEFAULT = 'x', PREFERRED = true, SEND = NONE)", + POSTGRESQL); + assertThat(type.getName()).isEqualTo("app.box3"); + BaseTypeDefinition definition = (BaseTypeDefinition) type.getDefinition(); + assertThat(definition.getElements()).extracting(DefinitionElement::getName).containsExactly( + "INPUT", "PASSEDBYVALUE", "internallength", "DEFAULT", "PREFERRED", "SEND"); + assertThat(definition.getElements()).extracting( + element -> element.getArgument() == null ? null : element.getArgument().getKind()) + .containsExactly(Kind.TYPE, null, Kind.NUMBER, Kind.STRING, Kind.KEYWORD, + Kind.NONE); + + DefinitionArgument input = definition.getElement("input").getArgument(); + assertThat(input.getDataType().getDataType()).isEqualTo("app.box3_in"); + assertThat(input.isSetOf()).isFalse(); + assertThat(input.isTypeReference()).isFalse(); + assertThat(definition.getElement("PassedByValue").getArgument()).isNull(); + assertThat(definition.getElement("INTERNALLENGTH").getArgument().getNumber()) + .isEqualTo(new LongValue(16)); + assertThat(definition.getElement("DEFAULT").getArgument().getString().getValue()) + .isEqualTo("x"); + assertThat(definition.getElement("PREFERRED").getArgument().getKeyword()) + .isEqualTo("true"); + assertThat(definition.getElement("OUTPUT")).isNull(); + + // other kinds leave the getters of a kind empty + DefinitionArgument none = definition.getElement("SEND").getArgument(); + assertThat(none.getDataType()).isNull(); + assertThat(none.getKeyword()).isNull(); + assertThat(none.getOperator()).isNull(); + assertThat(none.getNumber()).isNull(); + assertThat(none.getString()).isNull(); + } + + @Test + void testArgumentForms() throws Exception { + assertThat(argument("int4[]").getDataType().getArrayData()).hasSize(1); + assertThat(argument("double precision").getDataType()).hasToString("double precision"); + assertThat(argument("extended").getDataType().getDataType()).isEqualTo("extended"); + assertThat(argument("\"none\"").getKind()).isEqualTo(Kind.TYPE); + + DefinitionArgument reference = argument("setof s.t.a%TYPE"); + assertThat(reference.isSetOf()).isTrue(); + assertThat(reference.isTypeReference()).isTrue(); + assertThat(reference.getDataType().getDataType()).isEqualTo("s.t.a"); + + DefinitionArgument operator = argument("OPERATOR(pg_catalog.<=)"); + assertThat(operator.getKind()).isEqualTo(Kind.OPERATOR); + assertThat(operator.getOperator()).isEqualTo("pg_catalog.<="); + assertThat(operator.isOperatorKeyword()).isTrue(); + assertThat(argument("<=").isOperatorKeyword()).isFalse(); + assertThat(argument("<=").getOperator()).isEqualTo("<="); + + assertThat(argument("1.5").getNumber()).isInstanceOf(DoubleValue.class); + SignedExpression negative = (SignedExpression) argument("- 1").getNumber(); + assertThat(negative.getSign()).isEqualTo('-'); + assertThat(negative.getExpression()).isEqualTo(new LongValue(1)); + + StringValue escaped = argument("E'a\\nb'").getString(); + assertThat(escaped.getPrefix()).isEqualTo("E"); + assertThat(argument("NULL").getKeyword()).isEqualTo("NULL"); + assertThat(argument("None").getKind()).isEqualTo(Kind.NONE); + assertThat(argument("None")).hasToString("NONE"); + } + + @Test + void testAlterTypeProperties() throws Exception { + AlterType alteration = (AlterType) CCJSqlParserUtil.parse( + "ALTER TYPE app.box3 SET (SEND = app.box3_send, RECEIVE = NONE, STORAGE = plain, " + + "SUBSCRIPT)", + POSTGRESQL); + assertThat(alteration.getName()).isEqualTo("app.box3"); + assertThat(alteration.getAction()).isEqualTo(AlterType.Action.SET_PROPERTIES); + assertThat(alteration.getProperties()).extracting(DefinitionElement::getName) + .containsExactly("SEND", "RECEIVE", "STORAGE", "SUBSCRIPT"); + assertThat(alteration.getProperties().get(0).getArgument().getDataType().getDataType()) + .isEqualTo("app.box3_send"); + assertThat(alteration.getProperties().get(1).getArgument().getKind()) + .isEqualTo(Kind.NONE); + assertThat(alteration.getProperties().get(3).getArgument()).isNull(); + + // the other actions carry no properties and keep their reading + AlterType schema = (AlterType) CCJSqlParserUtil.parse("ALTER TYPE box3 SET SCHEMA app"); + assertThat(schema.getAction()).isEqualTo(AlterType.Action.SET_SCHEMA); + assertThat(schema.getNewName()).isEqualTo("app"); + assertThat(schema.getProperties()).isEmpty(); + } + + @Test + void testConstruction() throws Exception { + CreateType type = new CreateType(); + type.setName("box3"); + BaseTypeDefinition definition = new BaseTypeDefinition(); + definition.setElements(Arrays.asList( + new DefinitionElement("INPUT", + DefinitionArgument.type(new ColDataType("box3_in"))), + new DefinitionElement("ELEMENT", + DefinitionArgument.type(new ColDataType("float8"), true, false)), + new DefinitionElement("INTERNALLENGTH", + DefinitionArgument.number(new LongValue(16))), + new DefinitionElement("DELIMITER", DefinitionArgument.string(new StringValue(";"))), + new DefinitionElement("COLLATABLE", DefinitionArgument.keyword("false")), + new DefinitionElement("x", DefinitionArgument.operator("pg_catalog.+", true)), + new DefinitionElement("y", DefinitionArgument.operator("+", false)), + new DefinitionElement("SEND", DefinitionArgument.none()))); + DefinitionElement bare = new DefinitionElement(); + bare.setName("PASSEDBYVALUE"); + bare.setArgument(null); + type.setDefinition(definition); + String sql = "CREATE TYPE box3 (INPUT = box3_in, ELEMENT = SETOF float8, " + + "INTERNALLENGTH = 16, DELIMITER = ';', COLLATABLE = false, " + + "x = OPERATOR(pg_catalog.+), y = +, SEND = NONE)"; + assertThat(type).hasToString(sql); + assertThat(CCJSqlParserUtil.parse(sql, POSTGRESQL)).hasToString(sql); + assertThat(bare).hasToString("PASSEDBYVALUE"); + + AlterType alteration = new AlterType(); + alteration.setName("box3"); + alteration.setAction(AlterType.Action.SET_PROPERTIES); + alteration.setProperties(Arrays.asList(bare, + new DefinitionElement("SEND", DefinitionArgument.none()))); + assertThat(alteration).hasToString("ALTER TYPE box3 SET (PASSEDBYVALUE, SEND = NONE)"); + assertThat(new BaseTypeDefinition(alteration.getProperties())) + .hasToString("(PASSEDBYVALUE, SEND = NONE)"); + } + + @Test + void testOtherTypeDefinitionsKeepTheirReading() throws Exception { + assertThat(((CreateType) assertSqlCanBeParsedAndDeparsed("CREATE TYPE shell_t")) + .getDefinition()).isNull(); + assertThat( + ((CreateType) assertSqlCanBeParsedAndDeparsed("CREATE TYPE c AS (a int, b text)")) + .getDefinition()) + .isInstanceOf(CompositeTypeDefinition.class); + assertThat(((CreateType) assertSqlCanBeParsedAndDeparsed("CREATE TYPE c AS ()")) + .getDefinition()).isInstanceOf(CompositeTypeDefinition.class); + assertThat(((CreateType) assertSqlCanBeParsedAndDeparsed("CREATE TYPE e AS ENUM ('a')")) + .getDefinition()).isInstanceOf(EnumTypeDefinition.class); + assertThat(((CreateType) assertSqlCanBeParsedAndDeparsed( + "CREATE TYPE r AS RANGE (SUBTYPE = int4)")).getDefinition()) + .isInstanceOf(RangeTypeDefinition.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TYPE b1 ()", + "CREATE TYPE b1 (x = 1,)", + "CREATE TYPE b1 (x := 1)", + "CREATE TYPE b1 (x 1)", + "CREATE TYPE b1 (x =)", + "CREATE TYPE b1 (a.b = 1)", + "CREATE TYPE b1 ('x' = 1)", + "CREATE TYPE b1 AS (x = 1)", + "CREATE TYPE IF NOT EXISTS b1 (x = 1)", + "CREATE OR REPLACE TYPE b1 (x = 1)", + "CREATE TYPE b1 (x = 1) WITH (y)", + "CREATE TYPE b1 (x = 'a' 'b')", + "CREATE TYPE b1 (x = a b)", + "CREATE TYPE b1 (x = 1 + 2)", + "CREATE TYPE b1 (x = (1))", + "CREATE TYPE b1 (x = f())", + "CREATE TYPE b1 (x = -x)", + "CREATE TYPE b1 (x = a.+)", + "CREATE TYPE b1 (o = B'101')", + "CREATE TYPE b1 (n = X'1F')", + "CREATE TYPE b1 (n = N'x')", + "CREATE TYPE b1 (x = between)", + "CREATE TYPE b1 (x = values)", + "CREATE TYPE b1 (x = coalesce)", + "CREATE TYPE b1 (x = setof)", + "CREATE TYPE b1 (x = precision)", + "CREATE TYPE b1 (x = national)", + "CREATE TYPE b1 (x = a%TYPE)", + "ALTER TYPE box3 SET ()", + "ALTER TYPE box3 SET (a.b = x)", + "ALTER TYPE box3 SET (SEND = box3_send,)", + "ALTER TYPE box3 SET (SEND = box3_send) CASCADE", + "ALTER TYPE box3 SET SEND = box3_send", + "ALTER TYPE IF EXISTS box3 SET (SEND = box3_send)", + "ALTER TYPE nosuch SET (SEND = between)", + "ALTER TYPE nosuch SET (SEND = B'1')"}) + void testRejectedForms(String sql) { + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql, POSTGRESQL)) + .isInstanceOf(JSQLParserException.class); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlCastTransformConversionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlCastTransformConversionTest.java new file mode 100644 index 0000000000..9ea642513e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlCastTransformConversionTest.java @@ -0,0 +1,526 @@ +/*- + * #%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.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.Arrays; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.CastSignature; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.TransformSignature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterConversion; +import net.sf.jsqlparser.statement.create.cast.CreateCast; +import net.sf.jsqlparser.statement.create.conversion.CreateConversion; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.transform.CreateTransform; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL CREATE CAST, CREATE TRANSFORM, CREATE CONVERSION and ALTER CONVERSION, see + * https://www.postgresql.org/docs/18/sql-createcast.html, + * https://www.postgresql.org/docs/18/sql-createtransform.html, + * https://www.postgresql.org/docs/18/sql-createconversion.html and + * https://www.postgresql.org/docs/18/sql-alterconversion.html. + */ +class PostgreSqlCastTransformConversionTest extends ValidationTestAsserts { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + @ParameterizedTest + @ValueSource(strings = { + "CREATE CAST (int AS text) WITH INOUT AS ASSIGNMENT", + "CREATE CAST (bigint AS int4) WITH FUNCTION int4(bigint) AS IMPLICIT", + "CREATE CAST (a.t AS b.u) WITHOUT FUNCTION", + "CREATE CAST (a.t AS b.u) WITH FUNCTION s.f", + "CREATE CAST (int AS text) WITH FUNCTION f()", + "CREATE CAST (int AS text) WITH FUNCTION \"F\"", + "CREATE CAST (int AS text) WITH FUNCTION left", + "CREATE CAST (int AS text) WITH FUNCTION pg_catalog.int4(bigint)", + "CREATE CAST (int AS int[]) WITH FUNCTION s.f(IN a varchar, integer, boolean) AS ASSIGNMENT", + "CREATE CAST (int AS text) WITH FUNCTION f(VARIADIC int[]) AS ASSIGNMENT", + "CREATE CAST (int AS text) WITH FUNCTION f(OUT a int, INOUT b text)", + "CREATE CAST (timestamp with time zone AS double precision) WITH FUNCTION f(internal)", + "CREATE CAST (\"My T\" AS s.\"U\") WITHOUT FUNCTION AS IMPLICIT", + "CREATE CAST (int AS text) WITH INOUT", + "CREATE TRANSFORM FOR int LANGUAGE plpython3u (FROM SQL WITH FUNCTION f(internal), TO SQL WITH FUNCTION g(internal))", + "CREATE OR REPLACE TRANSFORM FOR hstore LANGUAGE plpython3u (TO SQL WITH FUNCTION g(internal))", + "CREATE TRANSFORM FOR s.hstore LANGUAGE \"L\" (TO SQL WITH FUNCTION s.g(internal), FROM SQL WITH FUNCTION s.f(internal))", + "CREATE OR REPLACE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION g(internal), FROM SQL WITH FUNCTION f(internal))", + "CREATE TRANSFORM FOR int LANGUAGE sql (FROM SQL WITH FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f, TO SQL WITH FUNCTION g)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f(internal, int))", + "CREATE TRANSFORM FOR int[] LANGUAGE l (TO SQL WITH FUNCTION f())", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE DEFAULT CONVERSION s.c FOR 'UTF8' TO 'LATIN1' FROM s.f", + "CREATE CONVERSION \"C 1\" FOR E'UTF8' TO $$LATIN1$$ FROM pg_catalog.utf8_to_iso8859_1", + "CREATE DEFAULT CONVERSION c FOR '' TO '' FROM f", + "CREATE CONVERSION a.b.c FOR 'UTF8' TO 'LATIN1' FROM a.b.f", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM \"F\"", + "ALTER CONVERSION c RENAME TO c2", + "ALTER CONVERSION c OWNER TO CURRENT_USER", + "ALTER CONVERSION c OWNER TO CURRENT_ROLE", + "ALTER CONVERSION c OWNER TO SESSION_USER", + "ALTER CONVERSION c OWNER TO public", + "ALTER CONVERSION c OWNER TO left", + "ALTER CONVERSION c SET SCHEMA s", + "ALTER CONVERSION s.\"C\" OWNER TO \"Role 1\"", + "ALTER CONVERSION a.b.c SET SCHEMA s", + "ALTER CONVERSION c RENAME TO \"select\"", + "ALTER CONVERSION c RENAME TO conversion", + "ALTER CONVERSION conversion SET SCHEMA public"}) + void testTypedStatementsRoundTrip(String sql) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isInstanceOfAny(CreateCast.class, CreateTransform.class, + CreateConversion.class, AlterConversion.class); + // a statement in PostgreSQL's form is read the same without a dialect and in another one + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(statement.getClass()); + assertThat(CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.ORACLE))) + .isInstanceOf(statement.getClass()).hasToString(sql); + + StatementDeParser deparser = new StatementDeParser(new StringBuilder()); + statement.accept(deparser); + assertThat(deparser.getBuilder()).hasToString(sql); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + validateNoErrors(sql, 1, FeaturesAllowed.DDL); + + Node node = ((ASTNodeAccess) statement).getASTNode(); + assertThat(node.jjtGetFirstToken().beginColumn).isEqualTo(1); + assertThat(node.jjtGetLastToken().endColumn).isEqualTo(sql.length()); + } + + @ParameterizedTest + @ValueSource(strings = { + "create cast (int as text) with inout as assignment", + "create or replace transform for int language l (to sql with function g)", + "create default conversion c for 'UTF8' to 'LATIN1' from f", + "alter conversion c owner to r"}) + void testKeywordsInLowerCase(String sql) throws Exception { + Statement statement = CCJSqlParserUtil.parse(sql, POSTGRESQL); + assertThat(statement).isNotInstanceOf(UnsupportedStatement.class); + assertThat(statement.toString()).isEqualToIgnoringCase(sql); + assertThat(CCJSqlParserUtil.parse(statement.toString(), POSTGRESQL)) + .hasToString(statement.toString()); + } + + @Test + void testStatementBoundaries() throws Exception { + String script = "CREATE CAST (int AS text) WITH FUNCTION f; " + + "CREATE CAST (int AS text) WITH INOUT AS IMPLICIT;\n" + + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f);" + + "CREATE DEFAULT CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM s.f; " + + "ALTER CONVERSION c OWNER TO r; ALTER CONVERSION c RENAME TO d; " + + "DROP CAST (int AS text); DROP TRANSFORM FOR int LANGUAGE l; " + + "CREATE OPERATOR === (FUNCTION = f, LEFTARG = int); " + + "CREATE AGGREGATE agg(int) (SFUNC = f, STYPE = int); SELECT 1"; + for (Consumer mode : Arrays.>asList(POSTGRESQL, + parser -> { + })) { + Statements statements = CCJSqlParserUtil.parseStatements(script, mode); + assertThat(statements).hasSize(11); + assertThat(statements).extracting(statement -> statement.getClass().getSimpleName()) + .containsExactly("CreateCast", "CreateCast", "CreateTransform", + "CreateConversion", "AlterConversion", "AlterConversion", "Drop", + "Drop", "CreateOperator", "CreateAggregate", "PlainSelect"); + assertThat(statements.get(0)).hasToString("CREATE CAST (int AS text) WITH FUNCTION f"); + assertThat(statements.get(5)).hasToString("ALTER CONVERSION c RENAME TO d"); + } + } + + @Test + void testCastFields() throws Exception { + CreateCast cast = (CreateCast) CCJSqlParserUtil.parse( + "CREATE CAST (bigint AS s.t) WITH FUNCTION s.f(bigint, integer) AS ASSIGNMENT", + POSTGRESQL); + assertThat(cast.getCast().getSourceType().getDataType()).isEqualTo("bigint"); + assertThat(cast.getCast().getTargetType().getDataType()).isEqualTo("s.t"); + assertThat(cast.getMethod()).isEqualTo(CreateCast.Method.WITH_FUNCTION); + assertThat(cast.getFunction().getName()).isEqualTo("s.f"); + assertThat(cast.getFunction().getArguments()).hasSize(2); + assertThat(cast.getFunction().getArguments().get(1).getDataType().getDataType()) + .isEqualTo("integer"); + assertThat(cast.getContext()).isEqualTo(CreateCast.Context.ASSIGNMENT); + + // the cast is named by the signature object DROP CAST uses, with its own node + Drop drop = (Drop) CCJSqlParserUtil.parse("DROP CAST (bigint AS s.t)", POSTGRESQL); + assertThat(cast.getCast()).isInstanceOf(drop.getCast().getClass()) + .hasToString(drop.getCast().toString()); + Node node = cast.getCast().getASTNode(); + assertThat(node.jjtGetFirstToken().image).isEqualTo("("); + assertThat(node.jjtGetLastToken().image).isEqualTo(")"); + + CreateCast bare = (CreateCast) CCJSqlParserUtil + .parse("CREATE CAST (int AS text) WITH FUNCTION f", POSTGRESQL); + assertThat(bare.getFunction().getArguments()).isNull(); + assertThat(bare.getContext()).isNull(); + + CreateCast inout = (CreateCast) CCJSqlParserUtil + .parse("CREATE CAST (int AS text) WITH INOUT AS IMPLICIT", POSTGRESQL); + assertThat(inout.getMethod()).isEqualTo(CreateCast.Method.WITH_INOUT); + assertThat(inout.getFunction()).isNull(); + assertThat(inout.getContext()).isEqualTo(CreateCast.Context.IMPLICIT); + + CreateCast binary = (CreateCast) CCJSqlParserUtil + .parse("CREATE CAST (int AS text) WITHOUT FUNCTION", POSTGRESQL); + assertThat(binary.getMethod()).isEqualTo(CreateCast.Method.WITHOUT_FUNCTION); + assertThat(binary.getFunction()).isNull(); + } + + @Test + void testCastMethodAndFunctionStayConsistent() { + RoutineReference function = new RoutineReference(); + function.setName("f"); + CreateCast cast = new CreateCast() + .withCast(new CastSignature(new ColDataType("int"), new ColDataType("text"))) + .withFunction(function).withContext(CreateCast.Context.IMPLICIT); + assertThat(cast.getMethod()).isEqualTo(CreateCast.Method.WITH_FUNCTION); + assertThat(cast).hasToString("CREATE CAST (int AS text) WITH FUNCTION f AS IMPLICIT"); + + cast.setMethod(CreateCast.Method.WITH_INOUT); + assertThat(cast.getFunction()).isNull(); + assertThat(cast.withContext(null)).hasToString("CREATE CAST (int AS text) WITH INOUT"); + assertThat(cast.withMethod(CreateCast.Method.WITHOUT_FUNCTION)) + .hasToString("CREATE CAST (int AS text) WITHOUT FUNCTION"); + cast.setFunction(null); + assertThat(cast.getMethod()).isEqualTo(CreateCast.Method.WITHOUT_FUNCTION); + } + + @Test + void testTransformFields() throws Exception { + CreateTransform transform = (CreateTransform) CCJSqlParserUtil.parse( + "CREATE OR REPLACE TRANSFORM FOR public.hstore LANGUAGE plpython3u " + + "(TO SQL WITH FUNCTION g(internal), FROM SQL WITH FUNCTION s.f(internal))", + POSTGRESQL); + assertThat(transform.isOrReplace()).isTrue(); + assertThat(transform.getTransform().getDataType().getDataType()) + .isEqualTo("public.hstore"); + assertThat(transform.getTransform().getLanguage()).isEqualTo("plpython3u"); + assertThat(transform.getFromSqlFunction().getName()).isEqualTo("s.f"); + assertThat(transform.getToSqlFunction().getName()).isEqualTo("g"); + assertThat(transform.getToSqlFunction().getArguments()).hasSize(1); + assertThat(transform.isToSqlFirst()).isTrue(); + + // the transform is named by the signature object DROP TRANSFORM uses, with its own node + Drop drop = (Drop) CCJSqlParserUtil + .parse("DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u", POSTGRESQL); + assertThat(transform.getTransform()).isInstanceOf(drop.getTransform().getClass()) + .hasToString(drop.getTransform().toString()); + Node node = transform.getTransform().getASTNode(); + assertThat(node.jjtGetFirstToken().image).isEqualTo("FOR"); + assertThat(node.jjtGetLastToken().image).isEqualTo("plpython3u"); + + transform.setToSqlFirst(false); + transform.setOrReplace(false); + assertThat(transform).hasToString("CREATE TRANSFORM FOR public.hstore LANGUAGE plpython3u " + + "(FROM SQL WITH FUNCTION s.f(internal), TO SQL WITH FUNCTION g(internal))"); + transform.setFromSqlFunction(null); + assertThat(transform).hasToString("CREATE TRANSFORM FOR public.hstore LANGUAGE plpython3u " + + "(TO SQL WITH FUNCTION g(internal))"); + + CreateTransform single = (CreateTransform) CCJSqlParserUtil.parse( + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f)", POSTGRESQL); + assertThat(single.isOrReplace()).isFalse(); + assertThat(single.getToSqlFunction()).isNull(); + assertThat(single.isToSqlFirst()).isFalse(); + assertThat(single.getFromSqlFunction().getArguments()).isNull(); + + RoutineReference function = new RoutineReference(); + function.setName("g"); + assertThat(new CreateTransform().withOrReplace(true) + .withTransform(new TransformSignature(new ColDataType("int"), "l")) + .withToSqlFunction(function).withFromSqlFunction(function).withToSqlFirst(true)) + .hasToString("CREATE OR REPLACE TRANSFORM FOR int LANGUAGE l " + + "(TO SQL WITH FUNCTION g, FROM SQL WITH FUNCTION g)"); + } + + @Test + void testConversionFields() throws Exception { + CreateConversion conversion = (CreateConversion) CCJSqlParserUtil.parse( + "CREATE DEFAULT CONVERSION s.\"C\" FOR 'UTF8' TO E'LATIN1' FROM pg_catalog.f", + POSTGRESQL); + assertThat(conversion.isDefaultConversion()).isTrue(); + assertThat(conversion.getName()).isEqualTo("s.\"C\""); + assertThat(conversion.getSourceEncoding().getValue()).isEqualTo("UTF8"); + assertThat(conversion.getDestinationEncoding().getValue()).isEqualTo("LATIN1"); + assertThat(conversion.getDestinationEncoding().getPrefix()).isEqualTo("E"); + assertThat(conversion.getFunction()).isEqualTo("pg_catalog.f"); + assertThat(conversion.getSourceEncoding().getASTNode().jjtGetFirstToken().image) + .isEqualTo("'UTF8'"); + + // U&'...' is a string constant only for the PostgreSQL dialect's lexer + String unicode = "CREATE CONVERSION c FOR U&'UTF8' TO $$LATIN1$$ FROM f"; + assertThat(assertSqlCanBeParsedAndDeparsed(unicode, false, POSTGRESQL)) + .isInstanceOf(CreateConversion.class); + + assertThat(((CreateConversion) CCJSqlParserUtil + .parse("CREATE CONVERSION c FOR 'a' TO 'b' FROM f", POSTGRESQL)) + .isDefaultConversion()).isFalse(); + assertThat(new CreateConversion().withName("c").withSourceEncoding(new StringValue("a")) + .withDestinationEncoding(new StringValue("b")).withFunction("f") + .withDefaultConversion(true)) + .hasToString("CREATE DEFAULT CONVERSION c FOR 'a' TO 'b' FROM f"); + } + + @Test + void testAlterConversionFields() throws Exception { + AlterConversion rename = (AlterConversion) CCJSqlParserUtil + .parse("ALTER CONVERSION s.c RENAME TO \"C 2\"", POSTGRESQL); + assertThat(rename.getName()).isEqualTo("s.c"); + assertThat(rename.getAction()).isEqualTo(AlterConversion.Action.RENAME); + assertThat(rename.getNewName()).isEqualTo("\"C 2\""); + assertThat(rename.getOwner()).isNull(); + assertThat(rename.getSchemaName()).isNull(); + + AlterConversion owner = (AlterConversion) CCJSqlParserUtil + .parse("ALTER CONVERSION c OWNER TO CURRENT_USER", POSTGRESQL); + assertThat(owner.getAction()).isEqualTo(AlterConversion.Action.OWNER); + assertThat(owner.getOwner()).isEqualTo("CURRENT_USER"); + + AlterConversion schema = (AlterConversion) CCJSqlParserUtil + .parse("ALTER CONVERSION c SET SCHEMA app", POSTGRESQL); + assertThat(schema.getAction()).isEqualTo(AlterConversion.Action.SET_SCHEMA); + assertThat(schema.getSchemaName()).isEqualTo("app"); + + assertThat(new AlterConversion().withName("c").withAction(AlterConversion.Action.RENAME) + .withNewName("d")).hasToString("ALTER CONVERSION c RENAME TO d"); + assertThat(new AlterConversion().withName("c").withAction(AlterConversion.Action.OWNER) + .withOwner("r")).hasToString("ALTER CONVERSION c OWNER TO r"); + assertThat(new AlterConversion().withName("c") + .withAction(AlterConversion.Action.SET_SCHEMA).withSchemaName("s")) + .hasToString("ALTER CONVERSION c SET SCHEMA s"); + } + + @Test + void testVisitors() throws Exception { + StatementVisitorAdapter visitor = new StatementVisitorAdapter() { + @Override + public String visit(CreateCast statement, S context) { + return context + ":cast"; + } + + @Override + public String visit(CreateTransform statement, S context) { + return context + ":transform"; + } + + @Override + public String visit(CreateConversion statement, S context) { + return context + ":conversion"; + } + + @Override + public String visit(AlterConversion statement, S context) { + return context + ":alter"; + } + }; + assertThat(parse("CREATE CAST (int AS text) WITH INOUT").accept(visitor, "c")) + .isEqualTo("c:cast"); + assertThat(parse("CREATE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION f)") + .accept(visitor, "c")).isEqualTo("c:transform"); + assertThat(parse("CREATE CONVERSION c FOR 'a' TO 'b' FROM f").accept(visitor, "c")) + .isEqualTo("c:conversion"); + assertThat(parse("ALTER CONVERSION c SET SCHEMA s").accept(visitor, "c")) + .isEqualTo("c:alter"); + + // the default visitor methods return nothing and the one-argument forms delegate + StatementVisitorAdapter adapter = new StatementVisitorAdapter<>(); + for (String sql : new String[] {"CREATE CAST (int AS text) WITH INOUT", + "CREATE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION f)", + "CREATE CONVERSION c FOR 'a' TO 'b' FROM f", "ALTER CONVERSION c SET SCHEMA s"}) { + assertThat(parse(sql).accept(adapter, null)).isNull(); + } + adapter.visit((CreateCast) parse("CREATE CAST (int AS text) WITH INOUT")); + adapter.visit((CreateTransform) parse( + "CREATE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION f)")); + adapter.visit((CreateConversion) parse("CREATE CONVERSION c FOR 'a' TO 'b' FROM f")); + adapter.visit((AlterConversion) parse("ALTER CONVERSION c SET SCHEMA s")); + } + + @Test + void testValidation() throws Exception { + String cast = "CREATE CAST (int AS text) WITH INOUT"; + validateNoErrors(cast, 1, FeaturesAllowed.CREATE); + validateNotAllowed(cast, 1, 1, FeaturesAllowed.SELECT, Feature.createCast); + validate(cast, 1, 1, MySqlVersion.V8_0); + + String transform = "CREATE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION f)"; + validateNoErrors(transform, 1, FeaturesAllowed.CREATE); + validateNotAllowed(transform, 1, 1, FeaturesAllowed.SELECT, Feature.createTransform); + validate(transform, 1, 1, MySqlVersion.V8_0); + + String conversion = "CREATE CONVERSION c FOR 'a' TO 'b' FROM f"; + validateNoErrors(conversion, 1, FeaturesAllowed.CREATE); + validateNotAllowed(conversion, 1, 1, FeaturesAllowed.SELECT, Feature.createConversion); + validate(conversion, 1, 1, MySqlVersion.V8_0); + + String alter = "ALTER CONVERSION c RENAME TO d"; + validateNoErrors(alter, 1, FeaturesAllowed.ALTER); + validateNotAllowed(alter, 1, 1, FeaturesAllowed.SELECT, Feature.alterConversion); + validate(alter, 1, 1, MySqlVersion.V8_0); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OR REPLACE CAST (int AS text) WITH INOUT", + "CREATE CAST (int AS text)", + "CREATE CAST (int AS text) WITH FUNCTION", + "CREATE CAST (int AS text) WITHOUT FUNCTION f(int)", + "CREATE CAST (int AS text) WITH INOUT AS EXPLICIT", + "CREATE CAST (int AS text) WITH INOUT AS", + "CREATE CAST (int, text) WITH INOUT", + "CREATE CAST int AS text WITH INOUT", + "CREATE CAST (int AS text) WITH INOUT AS ASSIGNMENT AS IMPLICIT", + "CREATE CAST (int AS text) WITH FUNCTION f AS ASSIGNMENT IMPLICIT", + "CREATE CAST (int AS text) AS ASSIGNMENT WITH INOUT", + "CREATE CAST (int AS text) WITHOUT INOUT", + "CREATE CAST IF NOT EXISTS (int AS text) WITH INOUT", + "CREATE CAST (int AS text) WITH SPECIFIC FUNCTION f", + "CREATE CAST (int AS text) WITH FUNCTION f(*)", + "CREATE CAST (int AS text) WITH FUNCTION f, g", + "CREATE CAST (int AS text) WITH FUNCTION 'f'", + "CREATE CAST (int AS) WITH INOUT", + "CREATE CAST () WITH INOUT", + "CREATE CAST s.c (int AS text) WITH INOUT", + "CREATE CAST (int AS text) WITH INOUT CASCADE", + "CREATE DEFAULT CAST (int AS text) WITH INOUT", + "CREATE TRANSFORM FOR int LANGUAGE l ()", + "CREATE TRANSFORM FOR int LANGUAGE l", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f, FROM SQL WITH FUNCTION g)", + "CREATE TRANSFORM FOR int LANGUAGE l (TO SQL WITH FUNCTION f, TO SQL WITH FUNCTION g)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f, TO SQL WITH FUNCTION g, FROM SQL WITH FUNCTION h)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f TO SQL WITH FUNCTION g)", + "CREATE TRANSFORM FOR int (FROM SQL WITH FUNCTION f)", + "CREATE TRANSFORM int LANGUAGE l (FROM SQL WITH FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE l (WITH FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f,)", + "CREATE TRANSFORM FOR int LANGUAGE l FROM SQL WITH FUNCTION f", + "CREATE TRANSFORM IF NOT EXISTS FOR int LANGUAGE l (FROM SQL WITH FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE 'l' (FROM SQL WITH FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE s.l (FROM SQL WITH FUNCTION f)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITHOUT FUNCTION)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH INOUT)", + "CREATE TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f) CASCADE", + "CREATE DEFAULT TRANSFORM FOR int LANGUAGE l (FROM SQL WITH FUNCTION f)", + "CREATE OR REPLACE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE OR REPLACE DEFAULT CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR UTF8 TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR 'UTF8' TO LATIN1 FROM f", + "CREATE CONVERSION c FOR 'UTF8' 'LATIN1' FROM f", + "CREATE CONVERSION c TO 'LATIN1' FOR 'UTF8' FROM f", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1'", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f(int)", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM 'f'", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f, g", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' WITH FUNCTION f", + "CREATE CONVERSION FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR N'UTF8' TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR B'01' TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR X'01' TO 'LATIN1' FROM f", + "CREATE CONVERSION IF NOT EXISTS c FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE CONVERSION DEFAULT c FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f WITH x", + "CREATE CONVERSION select FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM select", + "ALTER CONVERSION c", + "ALTER CONVERSION c RENAME c2", + "ALTER CONVERSION c RENAME TO s.c2", + "ALTER CONVERSION c RENAME TO left", + "ALTER CONVERSION c RENAME TO select", + "ALTER CONVERSION c SET SCHEMA a.b", + "ALTER CONVERSION c SET SCHEMA user", + "ALTER CONVERSION c SET SCHEMA", + "ALTER CONVERSION c SET (a = 1)", + "ALTER CONVERSION c SET TABLESPACE x", + "ALTER CONVERSION c OWNER TO a, b", + "ALTER CONVERSION c OWNER TO user", + "ALTER CONVERSION c OWNER TO 'r'", + "ALTER CONVERSION c OWNER TO CURRENT_USER()", + "ALTER CONVERSION c OWNER TO CURRENT_USER CASCADE", + "ALTER CONVERSION c OWNER r", + "ALTER CONVERSION c REFRESH VERSION", + "ALTER CONVERSION IF EXISTS c RENAME TO c2", + "ALTER CONVERSION c RENAME TO c2, OWNER TO r", + "ALTER CONVERSION c, d RENAME TO c2", + "ALTER CONVERSION select RENAME TO c2", + "ALTER DEFAULT CONVERSION c RENAME TO c2", + "ALTER CONVERSION c DEPENDS ON EXTENSION e"}) + void testRejectedWithPostgreSqlDialect(String sql) { + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql, POSTGRESQL)) + .isInstanceOf(JSQLParserException.class); + } + + /** + * Without the PostgreSQL dialect, statements of another product that start with the same words + * but do not have PostgreSQL's form stay unsupported statements, as they were before. + */ + @ParameterizedTest + @ValueSource(strings = { + "CREATE CAST (a AS b) WITH SPECIFIC FUNCTION f", + "CREATE CAST (percent AS decimal)", + "CREATE OR REPLACE CAST (a AS b) WITH INOUT", + "CREATE TRANSFORM FOR t g1 (TO SQL WITH FUNCTION f, FROM SQL WITH FUNCTION g)", + "CREATE OR REPLACE CONVERSION c FOR 'UTF8' TO 'LATIN1' FROM f", + "CREATE DEFAULT conversion AS 1", + "CREATE DEFAULT x", + "CREATE CONVERSION c", + "ALTER CONVERSION c REFRESH", + "ALTER CONVERSION c"}) + void testOtherFormsStayUnsupportedWithoutThePostgreSqlDialect(String sql) throws Exception { + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql, POSTGRESQL)) + .isInstanceOf(JSQLParserException.class); + assertThat(CCJSqlParserUtil.parse(sql)).isInstanceOf(UnsupportedStatement.class); + assertThat(CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.ORACLE))) + .isInstanceOf(UnsupportedStatement.class); + } + + /** Only the PostgreSQL dialect applies the name rules of PostgreSQL's grammar. */ + @ParameterizedTest + @ValueSource(strings = { + "ALTER CONVERSION c SET SCHEMA user", + "CREATE CONVERSION c FOR N'UTF8' TO 'LATIN1' FROM f"}) + void testPostgreSqlNameRulesNeedTheDialect(String sql) throws Exception { + assertThat(CCJSqlParserUtil.parse(sql)).isNotInstanceOf(UnsupportedStatement.class) + .hasToString(sql); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, POSTGRESQL); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlCollationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlCollationTest.java new file mode 100644 index 0000000000..8f67fb6bd5 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlCollationTest.java @@ -0,0 +1,87 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.IndexOption; +import static org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.AlterCollation; +import net.sf.jsqlparser.statement.create.collation.CreateCollation; +import net.sf.jsqlparser.util.TablesNamesFinder; +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; + +class PostgreSqlCollationTest { + @ParameterizedTest + @ValueSource(strings = {"CREATE COLLATION c FROM \"C\"", + "CREATE COLLATION IF NOT EXISTS app.c FROM pg_catalog.\"C\"", + "CREATE COLLATION c (locale='C')", + "CREATE COLLATION c (locale='C',deterministic)", + "CREATE COLLATION c (provider=builtin,locale='C.UTF-8')", + "CREATE COLLATION c (lc_collate='C',lc_ctype='C',provider=libc)", + "CREATE COLLATION c (provider=icu,locale='und',deterministic=false,rules='&V << w',version='1')", + "ALTER COLLATION app.c REFRESH VERSION", "ALTER COLLATION app.c RENAME TO c2", + "ALTER COLLATION c OWNER TO CURRENT_USER", "ALTER COLLATION c SET SCHEMA app"}) + void structuredDefinitionsAndChangesRoundTrip(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertTrue(statement instanceof CreateCollation || statement instanceof AlterCollation); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + roundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty()); + } + + @Test + void switchingBetweenCopyAndOptionsClearsInactiveState() throws JSQLParserException { + CreateCollation statement = + (CreateCollation) CCJSqlParserUtil.parse("CREATE COLLATION c FROM \"C\""); + statement.setOptions( + new ArrayList<>(List.of(new IndexOption("locale", new StringValue("C"), true)))); + assertNull(statement.getSourceCollation()); + statement.getOptions().get(0).setValue(new StringValue("C.UTF-8")); + List expressions = new ArrayList<>(); + statement.visitExpressions(expressions::add); + assertEquals(1, expressions.size()); + roundTrip(statement); + statement.setSourceCollation("pg_catalog.\"C\""); + assertNull(statement.getOptions()); + assertEquals("CREATE COLLATION c FROM pg_catalog.\"C\"", statement.toString()); + expressions.clear(); + statement.visitExpressions(expressions::add); + assertTrue(expressions.isEmpty()); + roundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE COLLATION c", "CREATE COLLATION c ()", + "CREATE COLLATION c (locale=)", "CREATE COLLATION c (locale 'C')", + "CREATE OR REPLACE COLLATION c FROM \"C\"", "ALTER COLLATION c REFRESH", + "ALTER COLLATION c RENAME TO c2, SET SCHEMA app"}) + void rejectsIncompleteDefinitions(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnIndexOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnIndexOptionsTest.java new file mode 100644 index 0000000000..a8f457a042 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnIndexOptionsTest.java @@ -0,0 +1,115 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.IndexOption; +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +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 PostgreSqlColumnIndexOptionsTest { + @ParameterizedTest + @ValueSource(strings = {"PRIMARY KEY", "UNIQUE", "UNIQUE NULLS NOT DISTINCT"}) + void columnStorageAndTablespaceStayOnTheConstraint(String kind) throws JSQLParserException { + for (boolean alter : new boolean[] {false, true}) { + String prefix = alter ? "ALTER TABLE t ADD COLUMN " : "CREATE TABLE t ("; + Statement statement = parse(prefix + "id INT CONSTRAINT uq " + kind + + " WITH (fillfactor=70) USING INDEX TABLESPACE old_space DEFERRABLE INITIALLY DEFERRED" + + (alter ? "" : ")")); + ColumnDefinition column = alter + ? ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0) + : ((CreateTable) statement).getColumnDefinitions().get(0); + assertEquals(1, column.getColumnOptions().size()); + ColumnOption option = column.getColumnOptions().get(0); + assertEquals(ColumnOption.Kind.CONSTRAINT, option.getKind()); + KeyConstraint key = (KeyConstraint) option.getConstraint(); + assertEquals("uq", key.getName()); + assertEquals("old_space", key.getTableSpace()); + assertEquals("70", key.getStorageParameters().get(0).getValue().toString()); + assertNotNull(key.getConstraintAttributes()); + key.setStorageParameters( + List.of(new IndexOption("fillfactor", new LongValue(80), true))); + key.setTableSpace("new_space"); + String sql = statement.toString(); + assertTrue(sql.contains("WITH (fillfactor = 80) USING INDEX TABLESPACE new_space")); + assertFalse(sql.contains("70")); + assertFalse(sql.contains("old_space")); + assertRoundTrip(statement); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TABLE t (id INT) WITH (autovacuum_enabled,toast.autovacuum_enabled=false)", + "CREATE TABLE t (id INT PRIMARY KEY WITH (deduplicate_items))", + "CREATE TABLE t (id INT, CONSTRAINT uq UNIQUE(id) WITH (deduplicate_items))", + "ALTER TABLE t ADD CONSTRAINT uq UNIQUE(id) WITH (deduplicate_items)", + "CREATE INDEX ix ON t(id) WITH (deduplicate_items)", + "CREATE INDEX ix ON t USING gin(tags) WITH (fastupdate)", + "CREATE MATERIALIZED VIEW mv WITH (autovacuum_enabled) AS SELECT * FROM t"}) + void bareStorageOptionsRoundTrip(String sql) throws JSQLParserException { + assertRoundTrip(parse(sql)); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void bareOptionsCanBeAssignedAndCleared() throws JSQLParserException { + CreateIndex index = (CreateIndex) parse("CREATE INDEX ix ON t(id) WITH(deduplicate_items)"); + IndexOption option = index.getStorageParameters().get(0); + assertNull(option.getValue()); + assertFalse(option.isUseEquals()); + option.setName("fillfactor"); + option.setValue(new LongValue(80)); + option.setUseEquals(true); + assertTrue(index.toString().contains("WITH (fillfactor = 80)")); + assertRoundTrip(index); + option.setName("deduplicate_items"); + option.setValue(null); + assertTrue(index.toString().contains("WITH (deduplicate_items)")); + assertRoundTrip(index); + } + + @Test + void columnIncludeAndIncompleteParametersAreRejected() { + for (String sql : new String[] { + "CREATE TABLE t(id INT UNIQUE INCLUDE(label),label TEXT)", + "CREATE TABLE t(id INT) WITH (fillfactor=)", + "CREATE TABLE t(id INT) WITH (fillfactor 70)", + "CREATE INDEX ix ON t(id int4_ops(deduplicate_items))"}) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnKeyMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnKeyMutationTest.java new file mode 100644 index 0000000000..736cadb9e2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnKeyMutationTest.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.create; + +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.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.*; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlColumnKeyMutationTest { + @ParameterizedTest + @ValueSource(strings = {"PRIMARY KEY", "UNIQUE", "UNIQUE NULLS NOT DISTINCT"}) + void keyNameAndAttributesAreOwnedByOneNode(String key) throws JSQLParserException { + for (boolean alter : new boolean[] {false, true}) { + String prefix = alter ? "ALTER TABLE t ADD COLUMN " : "CREATE TABLE t ("; + String suffix = alter ? "" : ")"; + Statement statement = parse(prefix + "id INT CONSTRAINT old_name " + key + + " DEFERRABLE INITIALLY DEFERRED NOT NULL" + suffix); + ColumnDefinition column = alter + ? ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0) + : ((CreateTable) statement).getColumnDefinitions().get(0); + assertEquals(2, column.getColumnOptions().size()); + NamedConstraint constraint = column.getColumnOptions().get(0).getConstraint(); + assertEquals("old_name", constraint.getName()); + assertTrue(constraint.getConstraintAttributes().getDeferrable()); + constraint.setName("new_name"); + constraint.getConstraintAttributes().setDeferrable(false); + constraint.getConstraintAttributes() + .setInitially(ConstraintAttributes.Initially.IMMEDIATE); + assertSql(statement, prefix + "id INT CONSTRAINT new_name " + key + + " NOT DEFERRABLE INITIALLY IMMEDIATE NOT NULL" + suffix); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (id INT CONSTRAINT old_fk REFERENCES parent(id))", + "ALTER TABLE t ADD COLUMN id INT CONSTRAINT old_fk REFERENCES parent(id)"}) + void referenceNameCanBeReplacedAndRemoved(String sql) throws JSQLParserException { + Statement statement = parse(sql); + ForeignKeyReference reference = statement instanceof CreateTable + ? ((CreateTable) statement).getColumnDefinitions().get(0).getForeignKeyReference() + : ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0) + .getForeignKeyReference(); + assertEquals("old_fk", reference.getConstraintName()); + reference.setConstraintName("new_fk"); + assertSql(statement, sql.replace("old_fk", "new_fk")); + reference.setConstraintName(null); + assertSql(statement, sql.replace("CONSTRAINT old_fk ", "")); + } + + @ParameterizedTest + @ValueSource(strings = {"NOT ENFORCED NO INHERIT", "NO INHERIT NOT ENFORCED", + "NOT VALID NO INHERIT NOT ENFORCED", "NOT ENFORCED NOT VALID NO INHERIT"}) + void tableCheckAllowsInheritanceAmongAttributes(String attributes) throws JSQLParserException { + Alter alter = (Alter) parse("ALTER TABLE t ADD CHECK (id > 0) " + attributes); + CheckConstraint check = + (CheckConstraint) alter.getAlterExpressions().get(0).getConstraint(); + assertTrue(check.isNoInherit()); + assertFalse(check.getEnforced()); + assertEquals(attributes.contains("NOT VALID"), + check.getConstraintAttributes().isNotValid()); + assertSql(alter, "ALTER TABLE t ADD CHECK (id > 0) NO INHERIT NOT ENFORCED" + + (attributes.contains("NOT VALID") ? " NOT VALID" : "")); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertSql(Statement statement, String expected) throws JSQLParserException { + assertEquals(expected, statement.toString()); + StringBuilder buffer = new StringBuilder(); + statement.accept(new StatementDeParser(buffer), null); + assertEquals(expected, buffer.toString()); + assertEquals(expected, parse(expected).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnNotNullTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnNotNullTest.java new file mode 100644 index 0000000000..1b2b52cdef --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnNotNullTest.java @@ -0,0 +1,100 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.NotNullConstraint; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +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 PostgreSqlColumnNotNullTest { + @ParameterizedTest + @ValueSource(strings = {"NOT NULL NO INHERIT", "CONSTRAINT nn NOT NULL", + "CONSTRAINT nn NOT NULL NO INHERIT", "CONSTRAINT \"Named NN\" NOT NULL NO INHERIT"}) + void reusesNotNullConstraintsInCreateAndAlterColumns(String clause) throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (", "ALTER TABLE t ADD COLUMN ")) { + Statement statement = parse(prefix + "id INT " + clause + " DEFAULT 7" + + (prefix.startsWith("CREATE") ? ", value INT)" : ", ADD COLUMN value INT")); + ColumnDefinition column = column(statement); + NotNullConstraint constraint = assertInstanceOf(NotNullConstraint.class, + column.getColumnOptions().get(0).getConstraint()); + assertTrue(constraint.isColumnConstraint()); + assertNull(constraint.getColumn()); + assertEquals(clause.endsWith("NO INHERIT"), constraint.isNoInherit()); + assertEquals(ColumnOption.Kind.DEFAULT, column.getColumnOptions().get(1).getKind()); + roundTrip(statement); + constraint.setName("replacement"); + constraint.setNoInherit(!constraint.isNoInherit()); + assertTrue(statement.toString().contains("CONSTRAINT replacement NOT NULL")); + roundTrip(statement); + } + } + + @Test + void retainsPlainNullabilityAndUsesTheExistingTableModel() throws JSQLParserException { + ColumnOption option = + column(parse("CREATE TABLE t (id INT NOT NULL)")).getColumnOptions().get(0); + assertEquals(ColumnOption.Kind.NULLABILITY, option.getKind()); + assertEquals(false, option.getNullable()); + NotNullConstraint table = (NotNullConstraint) ((CreateTable) parse( + "CREATE TABLE t (id INT, CONSTRAINT nn NOT NULL id NO INHERIT)")) + .getTableConstraints() + .get(0); + assertFalse(table.isColumnConstraint()); + assertEquals("id", table.getColumn().getColumnName()); + assertEquals("CONSTRAINT nn NOT NULL NO INHERIT", new NotNullConstraint() + .withColumnConstraint(true).withName("nn").withNoInherit(true).toString()); + } + + @Test + void doesNotInventASecondColumnExpressionForAnImplicitTarget() throws JSQLParserException { + CreateTable table = + (CreateTable) parse("CREATE TABLE t (id INT DEFAULT 7 NOT NULL NO INHERIT)"); + List expressions = new ArrayList<>(); + TableDefinitionTraversal.visit(table, expressions::add, t -> { + }); + assertEquals(1, expressions.size()); + assertEquals("7", expressions.get(0).toString()); + roundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(table + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + private static ColumnDefinition column(Statement statement) { + return statement instanceof CreateTable + ? ((CreateTable) statement).getColumnDefinitions().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnTypeOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnTypeOptionsTest.java new file mode 100644 index 0000000000..5946470e7c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlColumnTypeOptionsTest.java @@ -0,0 +1,109 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.Arrays; +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.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.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 PostgreSqlColumnTypeOptionsTest { + @ParameterizedTest + @ValueSource(strings = {"INT", "TEXT", "NUMERIC(10,2)", "TIMESTAMP(3) WITH TIME ZONE", + "DOUBLE PRECISION", "public.mood"}) + void arrayKeywordBelongsToDataType(String type) throws JSQLParserException { + for (boolean alter : new boolean[] {false, true}) { + for (String dimensions : new String[] {"", "[4]"}) { + Statement statement = parse(definition(alter, "a " + type + " ARRAY" + dimensions)); + ColumnDefinition column = column(statement); + ColDataType dataType = column.getColDataType(); + assertTrue(dataType.isUsingArrayKeyword()); + assertEquals(dimensions.isEmpty() ? Arrays.asList((Integer) null) : List.of(4), + dataType.getArrayData()); + if (alter) { + assertTrue(column.getColumnOptions().isEmpty()); + } else { + assertNull(column.getColumnOptions()); + } + dataType.setArrayData(List.of(8)); + assertTrue(statement.toString().contains(" ARRAY[8]")); + assertRoundTrip(statement); + dataType.setUsingArrayKeyword(false); + assertTrue(statement.toString().contains("[8]")); + assertFalse(statement.toString().contains(" ARRAY")); + assertRoundTrip(statement); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"PLAIN", "EXTERNAL", "EXTENDED", "MAIN", "DEFAULT"}) + void storageAndCompressionAreSharedByCreateAndAddColumn(String storage) + throws JSQLParserException { + for (boolean alter : new boolean[] {false, true}) { + Statement statement = parse(definition(alter, + "a TEXT STORAGE " + storage + " COMPRESSION pglz COLLATE \"C\" DEFAULT 'x'")); + List options = column(statement).getColumnOptions(); + assertEquals(ColumnOption.Storage.valueOf(storage), options.get(0).getStorage()); + assertEquals("pglz", options.get(1).getCompression()); + options.get(0).setStorage(ColumnOption.Storage.EXTENDED); + options.get(1).setCompression("default"); + assertTrue(statement.toString().contains("STORAGE EXTENDED COMPRESSION default")); + assertRoundTrip(statement); + options.remove(0); + assertFalse(statement.toString().contains("STORAGE")); + assertRoundTrip(statement); + } + } + + @Test + void bracketArraysAndMysqlColumnStorageRemainValid() throws JSQLParserException { + CreateTable table = (CreateTable) parse("CREATE TABLE t (a INT[3][4], b TEXT[])"); + assertEquals(List.of(3, 4), + table.getColumnDefinitions().get(0).getColDataType().getArrayData()); + assertFalse(table.getColumnDefinitions().get(0).getColDataType().isUsingArrayKeyword()); + for (String value : new String[] {"DISK", "MEMORY"}) { + Statement statement = + CCJSqlParserUtil.parse("CREATE TABLE t (a INT STORAGE " + value + ")", + p -> p.withDialect(Dialect.MYSQL)); + assertTrue(statement.toString().contains("STORAGE " + value)); + } + } + + private static String definition(boolean alter, String column) { + return alter ? "ALTER TABLE t ADD COLUMN " + column : "CREATE TABLE t (" + column + ")"; + } + + private static ColumnDefinition column(Statement statement) { + return statement instanceof CreateTable + ? ((CreateTable) statement).getColumnDefinitions().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlConstraintEnforcementTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlConstraintEnforcementTest.java new file mode 100644 index 0000000000..298d02bfcd --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlConstraintEnforcementTest.java @@ -0,0 +1,135 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.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 PostgreSqlConstraintEnforcementTest { + @ParameterizedTest + @ValueSource(strings = {"ENFORCED", "NOT ENFORCED", + "DEFERRABLE INITIALLY DEFERRED NOT ENFORCED", + "NOT ENFORCED DEFERRABLE INITIALLY DEFERRED", + "INITIALLY IMMEDIATE NOT DEFERRABLE ENFORCED"}) + void sharesForeignKeyAttributesAcrossCreateAndAlter(String attributes) + throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (id INT, ", "ALTER TABLE t ADD ")) { + Statement statement = + parse(prefix + "CONSTRAINT fk FOREIGN KEY (id) REFERENCES public.p (id) " + + "MATCH SIMPLE ON DELETE CASCADE " + attributes + + (prefix.startsWith("CREATE") ? ")" : ", ADD COLUMN extra INT")); + ForeignKeyConstraint fk = (ForeignKeyConstraint) (statement instanceof CreateTable + ? ((CreateTable) statement).getTableConstraints().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getConstraint()); + assertEquals(!attributes.contains("NOT ENFORCED"), + fk.getConstraintAttributes().getEnforced()); + roundTrip(statement); + fk.getConstraintAttributes().setEnforced(true); + roundTrip(statement); + assertFalse(statement.toString().contains("NOT ENFORCED")); + fk.getConstraintAttributes().setEnforced(null); + roundTrip(statement); + assertFalse(statement.toString().contains("ENFORCED")); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ENFORCED", "NOT ENFORCED DEFERRABLE INITIALLY DEFERRED"}) + void columnReferencesRetainTheirOwnAttributesAndFollowingOptions(String attributes) + throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (", "ALTER TABLE t ADD COLUMN ")) { + Statement statement = parse(prefix + "id INT REFERENCES public.p (id) " + attributes + + " NOT NULL" + + (prefix.startsWith("CREATE") ? ", value INT)" : ", ADD COLUMN value INT")); + ColumnDefinition column = statement instanceof CreateTable + ? ((CreateTable) statement).getColumnDefinitions().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getColDataTypeList().get(0); + ForeignKeyReference reference = + column.getColumnOptions().get(0).getForeignKeyReference(); + assertNotNull(reference.getConstraintAttributes()); + assertEquals(!attributes.contains("NOT ENFORCED"), + reference.getConstraintAttributes().getEnforced()); + assertEquals(ColumnOption.Kind.NULLABILITY, column.getColumnOptions().get(1).getKind()); + roundTrip(statement); + reference.getConstraintAttributes().setEnforced(null); + roundTrip(statement); + } + } + + @Test + void checkLegacyAccessorsUseTheSharedAttributeState() throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (id INT, ", "ALTER TABLE t ADD ")) { + Statement statement = parse(prefix + "CHECK (id > 0) NOT ENFORCED" + + (prefix.startsWith("CREATE") ? ")" : " NOT VALID")); + CheckConstraint check = (CheckConstraint) (statement instanceof CreateTable + ? ((CreateTable) statement).getTableConstraints().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getConstraint()); + assertEquals(false, check.getConstraintAttributes().getEnforced()); + check.getConstraintAttributes().setEnforced(true); + assertEquals(true, check.getEnforced()); + check.setEnforced(false); + assertEquals(false, check.getConstraintAttributes().getEnforced()); + roundTrip(statement); + check.setEnforced(null); + assertNull(check.getEnforced()); + roundTrip(statement); + } + assertNull(new CheckConstraint().withEnforced(null).getConstraintAttributes()); + } + + @Test + void preservesAlterEnforcementAndStatementBoundaries() throws JSQLParserException { + for (String flag : List.of("ENFORCED", "NOT ENFORCED")) { + Alter alter = (Alter) parse("ALTER TABLE t ALTER CONSTRAINT fk " + flag); + assertEquals(!flag.startsWith("NOT"), alter.getAlterExpressions().get(0).isEnforced()); + roundTrip(alter); + } + assertEquals(2, CCJSqlParserUtil.parseStatements( + "CREATE TABLE t(id INT REFERENCES p NOT ENFORCED); SELECT 1").size()); + } + + @ParameterizedTest + @ValueSource(strings = {"FOREIGN KEY(id) REFERENCES p ENFORCED NOT ENFORCED", + "FOREIGN KEY(id) REFERENCES p DEFERRABLE NOT DEFERRABLE", + "FOREIGN KEY(id) REFERENCES p ENFORCED INITIALLY wrong", + "PRIMARY KEY(id) NOT ENFORCED", "CHECK(id > 0) ENFORCED ENFORCED"}) + void rejectsMalformedAttributeTails(String constraint) { + assertThrows(JSQLParserException.class, + () -> parse("CREATE TABLE t(id INT, " + constraint + ")")); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t(id INT REFERENCES p ENFORCED NOT VALID)", + "ALTER TABLE t ADD COLUMN id INT REFERENCES p NOT VALID"}) + void rejectsNotValidOnColumnReferences(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString()).toString()); + } +} 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()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlEventTriggerTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlEventTriggerTest.java new file mode 100644 index 0000000000..83810d69a9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlEventTriggerTest.java @@ -0,0 +1,183 @@ +/*- + * #%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.assertDeparse; +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.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.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.alter.AlterEventTrigger; +import net.sf.jsqlparser.statement.alter.RelationAlterAction.EnableState; +import net.sf.jsqlparser.statement.create.event.AlterEvent; +import net.sf.jsqlparser.statement.create.event.CreateEvent; +import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger; +import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlEventTriggerTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static T roundTrip(String sql, Class type) + throws JSQLParserException { + T statement = + assertInstanceOf(type, assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), POSTGRESQL).toString()); + return statement; + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG IN ('CREATE TABLE') " + + "EXECUTE FUNCTION abort_any_command()", + "CREATE EVENT TRIGGER etg ON sql_drop EXECUTE FUNCTION f()", + "CREATE EVENT TRIGGER \"On Login\" ON login EXECUTE FUNCTION app.on_login()", + "CREATE EVENT TRIGGER etg ON table_rewrite EXECUTE PROCEDURE f()"}) + void parsesEventTriggerDefinitions(String sql) throws JSQLParserException { + roundTrip(sql, CreateEventTrigger.class); + assertInstanceOf(CreateEventTrigger.class, CCJSqlParserUtil.parse(sql)); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", POSTGRESQL).size()); + } + + @Test + void keepsEventFiltersAndFunction() throws JSQLParserException { + CreateEventTrigger trigger = roundTrip("CREATE EVENT TRIGGER etg ON ddl_command_end " + + "WHEN TAG IN ('CREATE TABLE', 'DROP TABLE') AND tag IN ('ALTER TABLE') " + + "EXECUTE PROCEDURE audit.log_ddl()", CreateEventTrigger.class); + + assertEquals("etg", trigger.getName()); + assertEquals("ddl_command_end", trigger.getEvent()); + assertEquals(2, trigger.getFilters().size()); + CreateEventTrigger.Filter first = trigger.getFilters().get(0); + assertEquals("TAG", first.getVariable()); + assertEquals(List.of("CREATE TABLE", "DROP TABLE"), first.getValues().stream() + .map(StringValue::getValue).collect(Collectors.toList())); + assertEquals("tag", trigger.getFilters().get(1).getVariable()); + assertEquals(CreateTrigger.ExecuteKeyword.PROCEDURE, trigger.getExecuteKeyword()); + assertEquals("audit.log_ddl", trigger.getFunction().getName()); + assertTrue(trigger.getFunction().getParameters().isEmpty()); + } + + @Test + void buildsAnEventTrigger() { + CreateEventTrigger trigger = new CreateEventTrigger().withName("etg") + .withEvent("ddl_command_start") + .withFunction(new Function().withName("guard") + .withParameters(new ExpressionList<>())) + .addFilters(new CreateEventTrigger.Filter("TAG", + List.of(new StringValue("DROP TABLE")))); + + assertDeparse(trigger, "CREATE EVENT TRIGGER etg ON ddl_command_start " + + "WHEN TAG IN ('DROP TABLE') EXECUTE FUNCTION guard()"); + } + + @ParameterizedTest + @ValueSource(strings = {"DISABLE", "ENABLE", "ENABLE REPLICA", "ENABLE ALWAYS"}) + void alterEventTriggerSharesTheEnableStates(String state) throws JSQLParserException { + AlterEventTrigger alter = + roundTrip("ALTER EVENT TRIGGER etg " + state, AlterEventTrigger.class); + + assertEquals("etg", alter.getName()); + assertEquals(AlterEventTrigger.Action.STATE, alter.getAction()); + assertEquals(EnableState.valueOf(state.replace(' ', '_')), alter.getEnableState()); + } + + @Test + void alterEventTriggerOwnerAndName() throws JSQLParserException { + AlterEventTrigger owner = + roundTrip("ALTER EVENT TRIGGER etg OWNER TO CURRENT_USER", AlterEventTrigger.class); + assertEquals(AlterEventTrigger.Action.OWNER, owner.getAction()); + assertEquals("CURRENT_USER", owner.getOwner()); + + AlterEventTrigger rename = + roundTrip("ALTER EVENT TRIGGER etg RENAME TO etg2", AlterEventTrigger.class); + assertEquals(AlterEventTrigger.Action.RENAME, rename.getAction()); + assertEquals("etg2", rename.getNewName()); + } + + @Test + void settersSelectTheAction() { + AlterEventTrigger alter = new AlterEventTrigger().withName("etg").withOwner("admin"); + alter.setNewName("etg2"); + assertEquals(AlterEventTrigger.Action.RENAME, alter.getAction()); + assertNull(alter.getOwner()); + assertDeparse(alter, "ALTER EVENT TRIGGER etg RENAME TO etg2"); + + alter.setEnableState(EnableState.ENABLE_ALWAYS); + assertNull(alter.getNewName()); + assertDeparse(alter, "ALTER EVENT TRIGGER etg ENABLE ALWAYS"); + } + + @Test + void mySqlEventsNamedTriggerStayEvents() throws JSQLParserException { + Consumer mysql = parser -> parser.withDialect(Dialect.MYSQL); + assertInstanceOf(CreateEvent.class, CCJSqlParserUtil.parse( + "CREATE EVENT trigger ON SCHEDULE EVERY 1 DAY DO SELECT 1", mysql)); + assertInstanceOf(AlterEvent.class, + CCJSqlParserUtil.parse("ALTER EVENT trigger RENAME TO e2", mysql)); + assertInstanceOf(AlterEvent.class, + CCJSqlParserUtil.parse("ALTER EVENT trigger ENABLE", mysql)); + assertInstanceOf(AlterEvent.class, CCJSqlParserUtil.parse("ALTER EVENT e DISABLE", mysql)); + } + + @Test + void visitorsValidationAndFeatures() throws JSQLParserException { + String create = "CREATE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f()"; + String alter = "ALTER EVENT TRIGGER etg DISABLE"; + for (String sql : List.of(create, alter)) { + Statement statement = CCJSqlParserUtil.parse(sql, POSTGRESQL); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertTrue(new Validation(List.of(PostgresqlVersion.V10), sql).validate().isEmpty()); + assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty()); + assertThat(new Validation(List.of(MySqlVersion.V8_0), sql).validate()).isNotEmpty(); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f(1)", + "CREATE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f", + "CREATE OR REPLACE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f()", + "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG IN () EXECUTE FUNCTION f()", + "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG IN (1) EXECUTE FUNCTION f()", + "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG = 'x' EXECUTE FUNCTION f()", + "ALTER EVENT TRIGGER etg", + "ALTER EVENT TRIGGER etg DISABLE ALWAYS", + "ALTER EVENT TRIGGER etg OWNER admin"}) + void rejectsInvalidEventTriggers(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignDataObjectsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignDataObjectsTest.java new file mode 100644 index 0000000000..e7eef7d45a --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignDataObjectsTest.java @@ -0,0 +1,275 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.NullValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.alter.AlterForeignDataWrapper; +import net.sf.jsqlparser.statement.alter.AlterServer; +import net.sf.jsqlparser.statement.alter.AlterUserMapping; +import net.sf.jsqlparser.statement.alter.ForeignObjectAlterAction; +import net.sf.jsqlparser.statement.create.fdw.CreateForeignDataWrapper; +import net.sf.jsqlparser.statement.create.server.CreateServer; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.statement.drop.DropUserMapping; +import net.sf.jsqlparser.statement.foreign.ForeignDataStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +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; + +class PostgreSqlForeignDataObjectsTest { + @ParameterizedTest + @ValueSource(strings = {"CREATE FOREIGN DATA WRAPPER w", + "CREATE FOREIGN DATA WRAPPER w NO HANDLER NO VALIDATOR OPTIONS(x 'y')", + "CREATE FOREIGN DATA WRAPPER w HANDLER public.handler VALIDATOR public.validator", + "CREATE FOREIGN DATA WRAPPER w VALIDATOR public.validator HANDLER public.handler", + "ALTER FOREIGN DATA WRAPPER w OPTIONS(ADD x 'y')", + "ALTER FOREIGN DATA WRAPPER w NO HANDLER NO VALIDATOR", + "ALTER FOREIGN DATA WRAPPER w HANDLER public.handler OPTIONS(SET x 'z',DROP y)", + "ALTER FOREIGN DATA WRAPPER w OWNER TO CURRENT_USER", + "ALTER FOREIGN DATA WRAPPER w RENAME TO w2", + "CREATE SERVER s FOREIGN DATA WRAPPER w OPTIONS(host 'localhost')", + "CREATE SERVER IF NOT EXISTS s TYPE 'postgres' VERSION '18' FOREIGN DATA WRAPPER w", + "CREATE SERVER s VERSION NULL FOREIGN DATA WRAPPER w", + "ALTER SERVER s OPTIONS(SET host '127.0.0.1')", "ALTER SERVER s VERSION NULL", + "ALTER SERVER s VERSION '18' OPTIONS(ADD port '5432',DROP host)", + "ALTER SERVER s OWNER TO CURRENT_ROLE", "ALTER SERVER s RENAME TO s2", + "CREATE USER MAPPING FOR CURRENT_USER SERVER s OPTIONS(user 'u')", + "CREATE USER MAPPING IF NOT EXISTS FOR PUBLIC SERVER s", + "CREATE USER MAPPING FOR USER SERVER s OPTIONS(user 'u',password 'a,b')", + "CREATE USER MAPPING FOR CURRENT_ROLE SERVER s", + "CREATE USER MAPPING FOR \"user name\" SERVER \"server name\"", + "ALTER USER MAPPING FOR CURRENT_USER SERVER s OPTIONS(SET \"user\" 'u2')", + "ALTER USER MAPPING FOR PUBLIC SERVER s OPTIONS(DROP password,ADD user 'u')"}) + void foreignObjectsShareOptionsAndKeepBoundaries(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertInstanceOf(ForeignDataStatement.class, statement); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + roundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty()); + assertFalse(new Validation(List.of(FeaturesAllowed.SELECT), sql).validate().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP FOREIGN DATA WRAPPER w", + "DROP FOREIGN DATA WRAPPER IF EXISTS w1, w2 CASCADE", + "DROP FOREIGN DATA WRAPPER w RESTRICT", + "DROP USER MAPPING FOR CURRENT_USER SERVER s", + "DROP USER MAPPING IF EXISTS FOR PUBLIC SERVER s", + "DROP USER MAPPING FOR USER SERVER s", + "DROP USER MAPPING FOR \"user name\" SERVER \"server name\""}) + void dropsForeignDataObjects(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertEquals(sql, statement.toString()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + roundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty()); + assertFalse(new Validation(List.of(FeaturesAllowed.SELECT), sql).validate().isEmpty()); + } + + @Test + void dropStatementsKeepObjectKindAndMappingKey() throws JSQLParserException { + Drop wrapper = (Drop) CCJSqlParserUtil.parse( + "DROP FOREIGN DATA WRAPPER IF EXISTS w1, w2 CASCADE"); + assertEquals(Drop.ObjectType.FOREIGN_DATA_WRAPPER, wrapper.getObjectType()); + assertEquals(List.of("w1", "w2"), + wrapper.getNames().stream().map(Table::getFullyQualifiedName) + .collect(Collectors.toList())); + assertTrue(wrapper.isIfExists()); + assertEquals(CascadeBehavior.CASCADE, wrapper.getBehavior()); + + DropUserMapping mapping = (DropUserMapping) CCJSqlParserUtil.parse( + "DROP USER MAPPING IF EXISTS FOR CURRENT_USER SERVER s"); + assertTrue(mapping.isIfExists()); + assertEquals("CURRENT_USER", mapping.getUser()); + assertEquals("s", mapping.getServer()); + mapping.setIfExists(false); + mapping.setServer("s2"); + assertEquals("DROP USER MAPPING FOR CURRENT_USER SERVER s2", mapping.toString()); + roundTrip(mapping); + + // MAPPING followed by neither FOR nor IF is still a user name + Drop user = (Drop) CCJSqlParserUtil.parse("DROP USER mapping"); + assertEquals(Drop.ObjectType.USER, user.getObjectType()); + } + + @Test + void omittedAndRemovedHandlersStayDistinct() throws JSQLParserException { + CreateForeignDataWrapper create = (CreateForeignDataWrapper) CCJSqlParserUtil.parse( + "CREATE FOREIGN DATA WRAPPER w"); + assertFalse(create.getFunctions().isHandlerSpecified()); + create.getFunctions().setHandler(null); + assertTrue(create.getFunctions().isHandlerSpecified()); + assertEquals("CREATE FOREIGN DATA WRAPPER w NO HANDLER", create.toString()); + create.getFunctions().setHandler("public.handler"); + roundTrip(create); + create.getFunctions().clearHandler(); + assertEquals("CREATE FOREIGN DATA WRAPPER w", create.toString()); + AlterForeignDataWrapper alter = (AlterForeignDataWrapper) CCJSqlParserUtil.parse( + "ALTER FOREIGN DATA WRAPPER w OPTIONS(SET x 'y')"); + alter.getOptions().get(0).setValue(new StringValue("changed")); + assertTrue(alter.toString().contains("SET x 'changed'")); + roundTrip(alter); + } + + @Test + void serverLiteralsAndOptionsAreVisitedAndMutable() throws JSQLParserException { + CreateServer create = (CreateServer) CCJSqlParserUtil.parse( + "CREATE SERVER s TYPE 'pg' VERSION '18' FOREIGN DATA WRAPPER w OPTIONS(host 'local')"); + List visited = new ArrayList<>(); + create.visitExpressions(visited::add); + assertEquals(3, visited.size()); + create.setVersion(new NullValue()); + create.setForeignDataWrapper("other_wrapper"); + create.getOptions().get(0).setValue(new StringValue("remote")); + assertTrue(create.toString().contains("VERSION NULL FOREIGN DATA WRAPPER other_wrapper")); + roundTrip(create); + AlterServer alter = (AlterServer) CCJSqlParserUtil.parse("ALTER SERVER s VERSION NULL"); + assertInstanceOf(NullValue.class, alter.getVersion()); + alter.setAction(ForeignObjectAlterAction.RENAME); + alter.setNewName("new_server"); + visited.clear(); + alter.visitExpressions(visited::add); + assertTrue(visited.isEmpty()); + assertEquals("ALTER SERVER s RENAME TO new_server", alter.toString()); + } + + @Test + void sharedActionsKeepObjectSpecificOptionsInactiveAndRestorable() throws JSQLParserException { + AlterServer server = (AlterServer) CCJSqlParserUtil.parse( + "ALTER SERVER s VERSION NULL OPTIONS(SET host 'remote')"); + AlterForeignDataWrapper wrapper = (AlterForeignDataWrapper) CCJSqlParserUtil.parse( + "ALTER FOREIGN DATA WRAPPER w NO HANDLER VALIDATOR public.validator " + + "OPTIONS(SET x 'y')"); + assertEquals(ForeignObjectAlterAction.OPTIONS, server.getAction()); + assertSame(server.getAction(), wrapper.getAction()); + String serverOptions = server.toString(); + String wrapperOptions = wrapper.toString(); + + server.setOwner("CURRENT_ROLE"); + wrapper.setOwner("CURRENT_USER"); + server.setAction(ForeignObjectAlterAction.OWNER); + wrapper.setAction(ForeignObjectAlterAction.OWNER); + assertEquals("ALTER SERVER s OWNER TO CURRENT_ROLE", server.toString()); + assertEquals("ALTER FOREIGN DATA WRAPPER w OWNER TO CURRENT_USER", wrapper.toString()); + roundTrip(server); + roundTrip(wrapper); + + server.setNewName("\"new server\""); + wrapper.setNewName("\"new wrapper\""); + server.setAction(ForeignObjectAlterAction.RENAME); + wrapper.setAction(ForeignObjectAlterAction.RENAME); + assertEquals("ALTER SERVER s RENAME TO \"new server\"", server.toString()); + assertEquals("ALTER FOREIGN DATA WRAPPER w RENAME TO \"new wrapper\"", wrapper.toString()); + roundTrip(server); + roundTrip(wrapper); + + List visited = new ArrayList<>(); + server.visitExpressions(visited::add); + wrapper.visitExpressions(visited::add); + assertTrue(visited.isEmpty()); + server.setAction(null); + wrapper.setAction(null); + assertNull(server.getAction()); + assertNull(wrapper.getAction()); + server.visitExpressions(visited::add); + wrapper.visitExpressions(visited::add); + assertTrue(visited.isEmpty()); + + server.setAction(ForeignObjectAlterAction.OPTIONS); + wrapper.setAction(ForeignObjectAlterAction.OPTIONS); + assertEquals(serverOptions, server.toString()); + assertEquals(wrapperOptions, wrapper.toString()); + server.visitExpressions(visited::add); + wrapper.visitExpressions(visited::add); + assertEquals(List.of(server.getOptions().get(0).getValue(), server.getVersion(), + wrapper.getOptions().get(0).getValue()), visited); + assertInstanceOf(NullValue.class, server.getVersion()); + assertTrue(wrapper.getFunctions().isHandlerSpecified()); + assertNull(wrapper.getFunctions().getHandler()); + roundTrip(server); + roundTrip(wrapper); + + server.setVersion(null); + wrapper.getFunctions().clearHandler(); + assertEquals("ALTER SERVER s OPTIONS (SET host 'remote')", server.toString()); + assertEquals("ALTER FOREIGN DATA WRAPPER w VALIDATOR public.validator OPTIONS (SET x 'y')", + wrapper.toString()); + roundTrip(server); + roundTrip(wrapper); + } + + @Test + void userMappingOptionsUseExistingForeignDataNodes() throws JSQLParserException { + CreateUserMapping create = (CreateUserMapping) CCJSqlParserUtil.parse( + "CREATE USER MAPPING FOR CURRENT_USER SERVER s OPTIONS(user 'u')"); + assertNull(create.getOptions().get(0).getAction()); + AlterUserMapping alter = (AlterUserMapping) CCJSqlParserUtil.parse( + "ALTER USER MAPPING FOR CURRENT_USER SERVER s OPTIONS(SET user 'u2')"); + assertEquals(ForeignDataOption.Action.SET, alter.getOptions().get(0).getAction()); + alter.getOptions().get(0).setAction(ForeignDataOption.Action.DROP); + assertNull(alter.getOptions().get(0).getValue()); + List expressions = new ArrayList<>(); + alter.visitExpressions(expressions::add); + assertTrue(expressions.isEmpty()); + roundTrip(alter); + assertEquals("s", create.accept(new StatementVisitorAdapter() { + @Override + public String visit(CreateUserMapping statement, S context) { + return statement.getServer(); + } + }, null)); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE OR REPLACE SERVER s FOREIGN DATA WRAPPER w", + "CREATE OR REPLACE FOREIGN DATA WRAPPER w", "CREATE SERVER s OPTIONS(x 'y')", + "CREATE FOREIGN DATA WRAPPER w HANDLER h HANDLER h2", + "CREATE FOREIGN DATA WRAPPER w NO VALIDATOR VALIDATOR v", + "ALTER FOREIGN DATA WRAPPER w", "ALTER SERVER s", + "ALTER USER MAPPING FOR USER SERVER s", + "CREATE USER MAPPING FOR USER SERVER s OPTIONS(SET x 'y')", + "CREATE SERVER s FOREIGN DATA WRAPPER w OPTIONS(DROP x)", + "ALTER SERVER s OPTIONS(SET x)", "ALTER SERVER s OPTIONS(DROP x 'y')", + "ALTER SERVER s OPTIONS()", "ALTER SERVER s OPTIONS(host = 'localhost')", + "CREATE SERVER s TYPE NULL FOREIGN DATA WRAPPER w", "ALTER SERVER s VERSION 18", + "ALTER SERVER s RENAME TO s2 OPTIONS(x 'y')", + "DROP USER MAPPING FOR u", "DROP USER MAPPING FOR u SERVER s CASCADE", + "DROP USER MAPPING IF EXISTS u SERVER s"}) + void rejectsWrongObjectAndOptionForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignKeyActionColumnsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignKeyActionColumnsTest.java new file mode 100644 index 0000000000..55afa3b0af --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignKeyActionColumnsTest.java @@ -0,0 +1,91 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2023 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create; + +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.ReferentialAction; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.ForeignKeyReference; +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 PostgreSqlForeignKeyActionColumnsTest { + @ParameterizedTest + @ValueSource(strings = {"NULL", "DEFAULT"}) + void sharesActionsAcrossCreateAndAlter(String value) throws JSQLParserException { + for (String columns : new String[] {"author_id", "tenant_id, author_id", "\"Author Id\""}) { + for (boolean updateFirst : new boolean[] {false, true}) { + String delete = "ON DELETE SET " + value + " (" + columns + ")"; + String actions = updateFirst ? "ON UPDATE CASCADE " + delete + : delete + " ON UPDATE CASCADE"; + for (String prefix : new String[] { + "CREATE TABLE posts (tenant_id INT, author_id INT, ", + "ALTER TABLE posts ADD "}) { + String sql = prefix + "CONSTRAINT fk FOREIGN KEY (tenant_id, author_id) " + + "REFERENCES users (tenant_id, id) MATCH SIMPLE " + actions + + (prefix.startsWith("CREATE") ? ")" : ""); + Statement statement = CCJSqlParserUtil.parse(sql); + ForeignKeyConstraint index = + (ForeignKeyConstraint) (statement instanceof CreateTable + ? ((CreateTable) statement).getTableConstraints().get(0) + : ((Alter) statement).getAlterExpressions().get(0) + .getConstraint()); + ReferentialAction action = + index.getReferentialAction(ReferentialAction.Type.DELETE); + assertEquals(List.of(columns.split(", ")), action.getColumnNames()); + assertNull(index.getReferentialAction(ReferentialAction.Type.UPDATE) + .getColumnNames()); + roundTrip(statement); + action.setColumnNames(List.of("author_id")); + roundTrip(statement); + assertTrue(statement.toString().contains("SET " + value + " (author_id)")); + action.setColumnNames(null); + roundTrip(statement); + } + } + } + } + + @Test + void supportsColumnReferencesAndStatementBoundaries() throws JSQLParserException { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE posts (author_id INT REFERENCES users ON DELETE SET NULL (author_id) NOT NULL)"); + ForeignKeyReference reference = table.getColumnDefinitions().get(0) + .getColumnOptions().get(0).getForeignKeyReference(); + assertEquals(List.of("author_id"), + reference.getReferentialAction(ReferentialAction.Type.DELETE).getColumnNames()); + roundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(table + "; SELECT 1").size()); + } + + @ParameterizedTest + @ValueSource(strings = {"ON UPDATE SET NULL (a)", "ON UPDATE SET DEFAULT (a)", + "ON DELETE CASCADE (a)", "ON DELETE SET NULL ()", "ON DELETE SET NULL (a,)", + "ON DELETE SET NULL (a + 1)"}) + void rejectsInvalidActionColumns(String action) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "CREATE TABLE t (a INT, FOREIGN KEY (a) REFERENCES p (a) " + action + ")")); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), CCJSqlParserUtil.parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignTableTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignTableTest.java new file mode 100644 index 0000000000..32e39be1a6 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlForeignTableTest.java @@ -0,0 +1,155 @@ +/*- + * #%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 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.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterForeignDataOptions; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlForeignTableTest { + @ParameterizedTest + @ValueSource(strings = {"CREATE FOREIGN TABLE ft(id INT,label TEXT) SERVER ddl_audit_server", + "CREATE FOREIGN TABLE ft(id INT OPTIONS(column_name 'remote_id'),label TEXT) SERVER ddl_audit_server OPTIONS(schema_name 'remote',table_name 'remote_t')", + "CREATE FOREIGN TABLE ft(id INT CONSTRAINT nn NOT NULL NO INHERIT,label TEXT) SERVER ddl_audit_server", + "CREATE FOREIGN TABLE ft(id INT,label TEXT,CONSTRAINT ck CHECK(id>0)) SERVER ddl_audit_server", + "CREATE FOREIGN TABLE ft(LIKE t INCLUDING ALL) SERVER ddl_audit_server", + "CREATE FOREIGN TABLE ft PARTITION OF t FOR VALUES FROM(0) TO(100) SERVER ddl_audit_server", + "ALTER FOREIGN TABLE ft ADD COLUMN extra INT DEFAULT 1", + "ALTER FOREIGN TABLE ft DROP COLUMN IF EXISTS label", + "ALTER FOREIGN TABLE ft ALTER COLUMN id TYPE BIGINT", + "ALTER FOREIGN TABLE ft ALTER COLUMN id SET DEFAULT 2", + "ALTER FOREIGN TABLE ft ALTER COLUMN id SET NOT NULL", + "ALTER FOREIGN TABLE ft ALTER COLUMN id SET STATISTICS 200", + "ALTER FOREIGN TABLE ft ALTER COLUMN label SET STORAGE MAIN", + "ALTER FOREIGN TABLE ft ALTER COLUMN id OPTIONS(SET column_name 'new_id')", + "ALTER FOREIGN TABLE ft OPTIONS(SET table_name 'renamed', ADD schema_name 'public')", + "ALTER FOREIGN TABLE ft RENAME COLUMN id TO new_id", + "ALTER FOREIGN TABLE ft RENAME TO ft2", + "ALTER FOREIGN TABLE ft SET SCHEMA ddl_aux", + "ALTER FOREIGN TABLE ft ADD CONSTRAINT ck CHECK(id>0) NOT VALID", + "ALTER FOREIGN TABLE ft VALIDATE CONSTRAINT ck", + "DROP FOREIGN TABLE ft", + "DROP FOREIGN TABLE IF EXISTS ft CASCADE", + "ALTER FOREIGN TABLE IF EXISTS ONLY ft ALTER COLUMN id SET DEFAULT 2", + "ALTER FOREIGN TABLE ft * ALTER COLUMN id SET DEFAULT 2", + "ALTER FOREIGN TABLE ft OPTIONS(DROP table_name)", + "ALTER FOREIGN TABLE ft ALTER id OPTIONS(column_name 'remote')", + "ALTER FOREIGN TABLE ft ADD COLUMN id2 INT OPTIONS(column_name 'remote2')", + "CREATE FOREIGN TABLE ft() SERVER srv", + "DROP FOREIGN TABLE ft, public.ft2 RESTRICT"}) + void foreignDefinitionsAndActionsRoundTrip(String sql) throws JSQLParserException { + Statement statement = parse(sql); + assertRoundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + if (statement instanceof CreateTable) { + assertNotNull(((CreateTable) statement).getForeignTableOptions()); + } else if (statement instanceof Alter) { + assertTrue(((Alter) statement).isForeignTable()); + } else { + assertEquals(Drop.ObjectType.FOREIGN_TABLE, ((Drop) statement).getObjectType()); + } + } + + @Test + void serverAndColumnOptionsAreMutableAndVisited() throws JSQLParserException { + CreateTable table = (CreateTable) parse( + "CREATE FOREIGN TABLE ft(id INT OPTIONS(column_name 'remote')) SERVER srv OPTIONS(table_name 'source')"); + table.getForeignTableOptions().setServer("new_srv"); + table.getForeignTableOptions().getOptions().get(0).setValue(new StringValue("target")); + table.getColumnDefinitions().get(0).getColumnOptions().get(0).getForeignOptions() + .get(0).setValue(new StringValue("remote_id")); + assertEquals( + "CREATE FOREIGN TABLE ft (id INT OPTIONS (column_name 'remote_id')) SERVER new_srv OPTIONS (table_name 'target')", + table.toString()); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(table, visited::add, ignored -> { + }); + assertEquals(2, visited.size()); + assertEquals(Set.of("ft"), new TablesNamesFinder().getTables(table)); + assertRoundTrip(table); + } + + @Test + void replacingLegacyOptionsRemovesTheOldServer() throws JSQLParserException { + CreateTable table = (CreateTable) parse( + "CREATE FOREIGN TABLE ft(id INT) SERVER old_srv OPTIONS(table_name 'old')"); + assertTrue(table.getTableOptionsStrings().contains("SERVER")); + table.setTableOptionsStrings(List.of("SERVER", "new_srv")); + assertNull(table.getForeignTableOptions()); + assertEquals("CREATE FOREIGN TABLE ft (id INT) SERVER new_srv", table.toString()); + assertRoundTrip(table); + } + + @Test + void optionActionChangesDropStaleValues() throws JSQLParserException { + Alter alter = (Alter) parse( + "ALTER FOREIGN TABLE ft ALTER COLUMN id OPTIONS(SET column_name 'old')"); + AlterForeignDataOptions action = + (AlterForeignDataOptions) alter.getAlterExpressions().get(0); + assertEquals("id", action.getColumnName()); + ForeignDataOption option = action.getOptions().get(0); + option.setAction(ForeignDataOption.Action.DROP); + assertNull(option.getValue()); + assertEquals("ALTER FOREIGN TABLE ft ALTER COLUMN id OPTIONS (DROP column_name)", + alter.toString()); + assertRoundTrip(alter); + option.setAction(ForeignDataOption.Action.ADD); + option.setValue(new StringValue("new")); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(action, visited::add, ignored -> { + }); + assertEquals(1, visited.size()); + assertRoundTrip(alter); + Drop drop = (Drop) parse("DROP FOREIGN TABLE ft, other.ft2 CASCADE"); + assertEquals(Set.of("ft", "other.ft2"), new TablesNamesFinder().getTables(drop)); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE FOREIGN TABLE ft(id INT)", + "CREATE FOREIGN TABLE ft(id INT) SERVER srv OPTIONS(ADD name 'value')", + "CREATE FOREIGN TABLE ft(id INT OPTIONS(column_name=1)) SERVER srv", + "ALTER FOREIGN TABLE ft OPTIONS(SET name)", + "ALTER FOREIGN TABLE ft OPTIONS(DROP name 'value')", + "ALTER FOREIGN TABLE ft OPTIONS()", "ALTER TABLE t OPTIONS(name 'value')", + "ALTER FOREIGN TABLE ONLY ft * ADD COLUMN extra INT"}) + void invalidForeignOptionsFail(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlMetadataDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlMetadataDdlTest.java new file mode 100644 index 0000000000..b3eb78c592 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlMetadataDdlTest.java @@ -0,0 +1,511 @@ +/*- + * #%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.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.DefinitionElement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterLanguage; +import net.sf.jsqlparser.statement.alter.AlterLargeObject; +import net.sf.jsqlparser.statement.alter.AlterTextSearchDictionary; +import net.sf.jsqlparser.statement.alter.AlterTextSearchParser; +import net.sf.jsqlparser.statement.alter.AlterTextSearchTemplate; +import net.sf.jsqlparser.statement.create.language.CreateLanguage; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchDictionary; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchParser; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchTemplate; +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.ValidationContext; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import net.sf.jsqlparser.util.validation.validator.StatementValidator; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** PostgreSQL 18 language, large-object ownership and text-search metadata DDL. */ +class PostgreSqlMetadataDdlTest extends ValidationTestAsserts { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Statement parse(String sql) throws Exception { + return CCJSqlParserUtil.parse(sql, POSTGRESQL); + } + + static Stream metadataStatements() { + return Stream.of( + Arguments.of( + "CREATE TRUSTED PROCEDURAL LANGUAGE plsample HANDLER plsample_call_handler INLINE plsample_inline_handler VALIDATOR plsample_validator", + "CreateLanguage"), + Arguments.of("ALTER PROCEDURAL LANGUAGE plsample RENAME TO plsample_new", + "AlterLanguage"), + Arguments.of("ALTER LANGUAGE plsample OWNER TO app_owner", "AlterLanguage"), + Arguments.of("ALTER LARGE OBJECT 12345 OWNER TO app_owner", "AlterLargeObject"), + Arguments.of( + "CREATE TEXT SEARCH DICTIONARY public.simple_dict (TEMPLATE = pg_catalog.simple)", + "CreateTextSearchDictionary"), + Arguments.of( + "ALTER TEXT SEARCH DICTIONARY public.simple_dict (STOPWORDS = english)", + "AlterTextSearchDictionary"), + Arguments.of( + "ALTER TEXT SEARCH DICTIONARY public.simple_dict RENAME TO simple_dict2", + "AlterTextSearchDictionary"), + Arguments.of( + "CREATE TEXT SEARCH PARSER public.sample_parser (START = prsd_start, GETTOKEN = prsd_nexttoken, END = prsd_end, LEXTYPES = prsd_lextype)", + "CreateTextSearchParser"), + Arguments.of( + "ALTER TEXT SEARCH PARSER public.sample_parser RENAME TO sample_parser2", + "AlterTextSearchParser"), + Arguments.of( + "CREATE TEXT SEARCH TEMPLATE public.sample_template (LEXIZE = dsimple_lexize)", + "CreateTextSearchTemplate"), + Arguments.of("ALTER TEXT SEARCH TEMPLATE public.sample_template SET SCHEMA app", + "AlterTextSearchTemplate")); + } + + @ParameterizedTest + @MethodSource("metadataStatements") + void parsesTypedMetadataStatements(String sql, String statementClass) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement.getClass().getSimpleName()).isEqualTo(statementClass); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(statement.getClass()); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14); + validateNoErrors(sql, 1, FeaturesAllowed.DDL); + Feature feature = Feature.valueOf(Character.toLowerCase(statementClass.charAt(0)) + + statementClass.substring(1)); + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, feature); + validate(sql, 1, 1, MySqlVersion.V8_0); + Node node = ((ASTNodeAccess) statement).getASTNode(); + assertThat(node.jjtGetFirstToken().beginColumn).isEqualTo(1); + assertThat(node.jjtGetLastToken().endColumn).isEqualTo(sql.length()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE LANGUAGE plsample", + "CREATE OR REPLACE LANGUAGE plsample", + "CREATE TRUSTED LANGUAGE \"Language 1\"", + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"Language 1\" HANDLER s.\"Handler\" INLINE s.inline_fn VALIDATOR s.validator_fn", + "CREATE LANGUAGE plsample HANDLER h", + "CREATE LANGUAGE plsample HANDLER h INLINE i", + "CREATE LANGUAGE plsample HANDLER h VALIDATOR v", + "CREATE LANGUAGE plsample HANDLER h NO VALIDATOR", + "CREATE LANGUAGE plsample HANDLER h INLINE i NO VALIDATOR", + "ALTER LANGUAGE plsample RENAME TO \"New Language\"", + "ALTER LANGUAGE plsample OWNER TO CURRENT_USER", + "ALTER PROCEDURAL LANGUAGE \"Language 1\" OWNER TO CURRENT_ROLE", + "ALTER LANGUAGE plsample OWNER TO SESSION_USER", + "ALTER LARGE OBJECT 4294967295 OWNER TO \"Role 1\"", + "ALTER LARGE OBJECT +12345 OWNER TO CURRENT_ROLE", + "ALTER LARGE OBJECT 0x3039 OWNER TO CURRENT_USER", + "ALTER LARGE OBJECT +0x3039 OWNER TO CURRENT_USER", + "ALTER LARGE OBJECT -1 OWNER TO SESSION_USER", + "CREATE TEXT SEARCH DICTIONARY s.d (STOPWORDS = english, TEMPLATE = pg_catalog.simple, ACCEPT = FALSE)", + "CREATE TEXT SEARCH DICTIONARY s.d (TEMPLATE = s.custom_template, count = -2.5, label = E'value')", + "CREATE TEXT SEARCH DICTIONARY \"S\".\"D\" (\"template\" = pg_catalog.simple)", + "ALTER TEXT SEARCH DICTIONARY s.d (STOPWORDS)", + "ALTER TEXT SEARCH DICTIONARY s.d (language = dutch, STOPWORDS)", + "ALTER TEXT SEARCH DICTIONARY s.d OWNER TO CURRENT_USER", + "ALTER TEXT SEARCH DICTIONARY s.d OWNER TO CURRENT_ROLE", + "ALTER TEXT SEARCH DICTIONARY s.d OWNER TO SESSION_USER", + "ALTER TEXT SEARCH DICTIONARY s.d SET SCHEMA \"New Schema\"", + "CREATE TEXT SEARCH PARSER p (HEADLINE = s.h, LEXTYPES = s.l, END = s.e, GETTOKEN = s.g, START = s.s)", + "CREATE TEXT SEARCH PARSER \"S\".\"P\" (\"start\" = s.s, \"gettoken\" = s.g, \"end\" = s.e, \"lextypes\" = s.l)", + "ALTER TEXT SEARCH PARSER s.p SET SCHEMA \"New Schema\"", + "CREATE TEXT SEARCH TEMPLATE t (INIT = s.i, LEXIZE = s.l)", + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = pg_catalog.dsimple_lexize (1), INIT = s.i)", + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = 'dsimple_lexize')", + "CREATE TEXT SEARCH TEMPLATE t (\"lexize\" = s.l)", + "ALTER TEXT SEARCH TEMPLATE s.t RENAME TO \"New Template\""}) + void preservesSupportedVariants(String sql) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isNotInstanceOf(UnsupportedStatement.class); + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(statement.getClass()); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE LANGUAGE 'plsample' HANDLER h", + "CREATE LANGUAGE s.plsample HANDLER h", + "CREATE PROCEDURAL TRUSTED LANGUAGE plsample HANDLER h", + "CREATE LANGUAGE plsample INLINE i", + "CREATE LANGUAGE plsample NO VALIDATOR", + "CREATE LANGUAGE plsample HANDLER h() VALIDATOR v", + "CREATE LANGUAGE plsample HANDLER h VALIDATOR v INLINE i", + "CREATE LANGUAGE plsample HANDLER h NO VALIDATOR VALIDATOR v", + "CREATE LANGUAGE plsample HANDLER", + "ALTER LANGUAGE plsample SET SCHEMA s", + "ALTER LANGUAGE plsample OWNER TO s.r", + "ALTER LARGE OBJECT name OWNER TO r", + "ALTER LARGE OBJECT '12345' OWNER TO r", + "ALTER LARGE OBJECT X'3039' OWNER TO r", + "ALTER LARGE OBJECT 12345 RENAME TO oid2", + "CREATE OR REPLACE TEXT SEARCH DICTIONARY d (TEMPLATE = simple)", + "CREATE TEXT SEARCH DICTIONARY d ()", + "CREATE TEXT SEARCH DICTIONARY d (STOPWORDS = english)", + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE)", + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, STOPWORDS)", + "CREATE TEXT SEARCH PARSER p (START = f, GETTOKEN = f, END = f)", + "CREATE TEXT SEARCH PARSER p (START = f, GETTOKEN = f, END = f, LEXTYPES = f, UNKNOWN = f)", + "CREATE TEXT SEARCH PARSER p (START, GETTOKEN = f, END = f, LEXTYPES = f)", + "CREATE TEXT SEARCH TEMPLATE t (INIT = f)", + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE)", + "CREATE OR REPLACE TEXT SEARCH TEMPLATE t (LEXIZE = f)", + "ALTER TEXT SEARCH PARSER p OWNER TO r", + "ALTER TEXT SEARCH TEMPLATE t OWNER TO r", + "ALTER TEXT SEARCH PARSER p (START = f)", + "ALTER TEXT SEARCH TEMPLATE t (LEXIZE = f)"}) + void rejectsInvalidMetadataForms(String sql) { + assertThatThrownBy(() -> parse(sql)).isInstanceOf(JSQLParserException.class); + } + + @Test + void readsLanguageFieldsAndMaintainsValidatorAlternatives() throws Exception { + CreateLanguage language = (CreateLanguage) parse( + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"L\" HANDLER s.h INLINE s.i NO VALIDATOR"); + assertThat(language.isOrReplace()).isTrue(); + assertThat(language.isTrusted()).isTrue(); + assertThat(language.isProcedural()).isTrue(); + assertThat(language.getName()).isEqualTo("\"L\""); + assertThat(language.getHandler()).isEqualTo("s.h"); + assertThat(language.getInlineHandler()).isEqualTo("s.i"); + assertThat(language.isNoValidator()).isTrue(); + assertThat(language.getValidator()).isNull(); + language.setValidator("s.v"); + assertThat(language.isNoValidator()).isFalse(); + assertThat(language).hasToString( + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"L\" HANDLER s.h INLINE s.i VALIDATOR s.v"); + language.setNoValidator(true); + assertThat(language.getValidator()).isNull(); + language.setHandler(null); + assertThat(language.getInlineHandler()).isNull(); + assertThat(language.getValidator()).isNull(); + assertThat(language.isNoValidator()).isFalse(); + assertThat(language).hasToString("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE \"L\""); + AlterLanguage alter = + (AlterLanguage) parse("ALTER PROCEDURAL LANGUAGE plsample OWNER TO CURRENT_ROLE"); + assertThat(alter.isProcedural()).isTrue(); + assertThat(alter.getAction()).isEqualTo(AlterLanguage.Action.OWNER); + assertThat(alter.getOwner()).isEqualTo("CURRENT_ROLE"); + } + + @Test + void exposesTypedOrderedDictionaryValuesAndResetOptions() throws Exception { + CreateTextSearchDictionary dictionary = (CreateTextSearchDictionary) parse( + "CREATE TEXT SEARCH DICTIONARY s.d (count = -2.5, TEMPLATE = s.custom_template, label = 'text')"); + assertThat(dictionary.getName()).isEqualTo("s.d"); + assertThat(dictionary.getOptions()).extracting(DefinitionElement::getName) + .containsExactly("count", "TEMPLATE", "label"); + assertThat(dictionary.getTemplate().getKind()).isEqualTo(DefinitionArgument.Kind.TYPE); + assertThat(dictionary.getTemplate().getDataType().getDataType()) + .isEqualTo("s.custom_template"); + assertThat(dictionary.getOption("count").getArgument().getNumber()).hasToString("-2.5"); + assertThat(dictionary.getOption("label").getArgument().getString().getValue()) + .isEqualTo("text"); + AlterTextSearchDictionary alter = (AlterTextSearchDictionary) parse( + "ALTER TEXT SEARCH DICTIONARY s.d (STOPWORDS, language = dutch)"); + assertThat(alter.getAction()).isEqualTo(AlterTextSearchDictionary.Action.OPTIONS); + assertThat(alter.getOption("STOPWORDS").getArgument()).isNull(); + assertThat(alter.getOption("language").getArgument().getDataType().getDataType()) + .isEqualTo("dutch"); + String unicode = "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, label = U&'text')"; + assertThat(assertSqlCanBeParsedAndDeparsed(unicode, false, POSTGRESQL)) + .isInstanceOf(CreateTextSearchDictionary.class); + } + + @Test + void exposesParserAndTemplateFunctionDefinitionsWithoutTableLineage() throws Exception { + CreateTextSearchParser parser = (CreateTextSearchParser) parse( + "CREATE TEXT SEARCH PARSER p (LEXTYPES = s.l, END = s.e, GETTOKEN = s.g, START = s.s, HEADLINE = s.h)"); + assertThat(parser.getFunctions()).extracting(DefinitionElement::getName) + .containsExactly("LEXTYPES", "END", "GETTOKEN", "START", "HEADLINE"); + assertThat(parser.getStartFunction().getDataType().getDataType()).isEqualTo("s.s"); + assertThat(parser.getGetTokenFunction().getDataType().getDataType()).isEqualTo("s.g"); + assertThat(parser.getEndFunction().getDataType().getDataType()).isEqualTo("s.e"); + assertThat(parser.getLexTypesFunction().getDataType().getDataType()).isEqualTo("s.l"); + assertThat(parser.getHeadlineFunction().getDataType().getDataType()).isEqualTo("s.h"); + CreateTextSearchTemplate template = (CreateTextSearchTemplate) parse( + "CREATE TEXT SEARCH TEMPLATE t (\"lexize\" = pg_catalog.dsimple_lexize(1))"); + assertThat(template.getInitFunction()).isNull(); + assertThat(template.getLexizeFunction().getDataType().getDataType()) + .isEqualTo("pg_catalog.dsimple_lexize"); + assertThat(template.getLexizeFunction().getDataType().getArgumentsStringList()) + .containsExactly("1"); + template = (CreateTextSearchTemplate) parse( + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = 'dsimple_lexize')"); + assertThat(template.getLexizeFunction().getKind()) + .isEqualTo(DefinitionArgument.Kind.STRING); + assertThat(template.getLexizeFunction().getString().getValue()).isEqualTo("dsimple_lexize"); + assertThat(new TablesNamesFinder().getTables(parser)).isEmpty(); + assertThat(new TablesNamesFinder().getTables(template)).isEmpty(); + } + + @Test + void preservesDuplicateDefinitionsAndExposesTheLastValue() throws Exception { + String dictionarySql = + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, TEMPLATE = snowball, Language = english)"; + CreateTextSearchDictionary dictionary = + (CreateTextSearchDictionary) assertSqlCanBeParsedAndDeparsed(dictionarySql, false, + POSTGRESQL); + assertThat(dictionary.getOptions()).extracting(DefinitionElement::getName) + .containsExactly("TEMPLATE", "TEMPLATE", "Language"); + assertThat(dictionary.getTemplate().getDataType().getDataType()).isEqualTo("snowball"); + dictionary = (CreateTextSearchDictionary) parse( + "CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple, \"Template\" = custom)"); + assertThat(dictionary.getTemplate().getDataType().getDataType()).isEqualTo("simple"); + assertThat(dictionary.getOption("\"Template\"").getArgument().getDataType().getDataType()) + .isEqualTo("custom"); + String templateSql = + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = dsimple_lexize, LEXIZE = dsynonym_lexize)"; + CreateTextSearchTemplate template = + (CreateTextSearchTemplate) assertSqlCanBeParsedAndDeparsed(templateSql, false, + POSTGRESQL); + assertThat(template.getFunctions()).hasSize(2); + assertThat(template.getLexizeFunction().getDataType().getDataType()) + .isEqualTo("dsynonym_lexize"); + String parserSql = + "CREATE TEXT SEARCH PARSER p (START = prsd_start, START = pg_catalog.prsd_start, GETTOKEN = prsd_nexttoken, END = prsd_end, LEXTYPES = prsd_lextype)"; + CreateTextSearchParser parser = + (CreateTextSearchParser) assertSqlCanBeParsedAndDeparsed(parserSql, false, + POSTGRESQL); + assertThat(parser.getFunctions()).hasSize(5); + assertThat(parser.getStartFunction().getDataType().getDataType()) + .isEqualTo("pg_catalog.prsd_start"); + AlterTextSearchDictionary alter = (AlterTextSearchDictionary) parse( + "ALTER TEXT SEARCH DICTIONARY d (STOPWORDS = english, STOPWORDS)"); + assertThat(alter.getOptions()).hasSize(2); + assertThat(alter.getOption("STOPWORDS").getArgument()).isNull(); + } + + @Test + void preservesStatementBoundariesAndContextualIdentifiers() throws Exception { + String sql = "CREATE LANGUAGE plsample HANDLER h; ALTER LANGUAGE plsample OWNER TO r; " + + "CREATE TEXT SEARCH TEMPLATE t (LEXIZE = f); ALTER TEXT SEARCH TEMPLATE t SET SCHEMA s; " + + "ALTER LARGE OBJECT 12345 OWNER TO r; SELECT language, trusted, procedural, dictionary, template, handler, validator, lexize FROM names"; + Statements statements = CCJSqlParserUtil.parseStatements(sql, POSTGRESQL); + assertThat(statements).hasSize(6); + assertThat(statements.get(0)).isInstanceOf(CreateLanguage.class); + assertThat(statements.get(1)).isInstanceOf(AlterLanguage.class); + assertThat(statements.get(2)).isInstanceOf(CreateTextSearchTemplate.class); + assertThat(statements.get(3)).isInstanceOf(AlterTextSearchTemplate.class); + assertThat(statements.get(4)).isInstanceOf(AlterLargeObject.class); + assertThat(statements.get(5).toString()).contains("language", "handler", "validator"); + assertThat(CCJSqlParserUtil.parse("CREATE LANGUAGE java EXTERNAL NAME 'jar'")) + .isInstanceOf(UnsupportedStatement.class); + assertThat(CCJSqlParserUtil.parse("ALTER LANGUAGE java COMPILE")) + .isInstanceOf(UnsupportedStatement.class); + } + + @Test + void numericOidReachesExpressionVisitorsDeparsersAndValidationWithItsRange() throws Exception { + AlterLargeObject statement = + (AlterLargeObject) parse("ALTER LARGE OBJECT 12345 OWNER TO r"); + LongValue oid = (LongValue) statement.getLargeObjectId(); + assertThat(oid.getASTNode().jjtGetFirstToken().image).isEqualTo("12345"); + assertThat(oid.getASTNode().jjtGetLastToken().image).isEqualTo("12345"); + List visited = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S context) { + assertThat(context).isEqualTo("context"); + visited.add(value); + return null; + } + }; + statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + "context"); + assertThat(visited).containsExactly(oid); + StringBuilder output = new StringBuilder(); + ExpressionDeParser deparser = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + assertThat(context).isEqualTo("context"); + return getBuilder().append(value.getValue() + 1); + } + }; + statement.accept(new StatementDeParser(deparser, new SelectDeParser(), output), "context"); + assertThat(output).hasToString("ALTER LARGE OBJECT 12346 OWNER TO r"); + assertThat(statement).hasToString("ALTER LARGE OBJECT 12345 OWNER TO r"); + visited.clear(); + StatementValidator validator = new StatementValidator() { + @Override + protected void validateOptionalExpression(Expression value) { + visited.add(value); + super.validateOptionalExpression(value); + } + }; + validator.setContext( + new ValidationContext().setCapabilities(Arrays.asList(FeaturesAllowed.DDL))); + validator.validate(statement); + assertThat(visited).containsExactly(oid); + assertThat(validator.getValidationErrors()).isEmpty(); + } + + @ParameterizedTest + @MethodSource("metadataStatements") + void dispatchesTypedVisitorsWithContextAndLegacyOverloads(String sql, String statementClass) + throws Exception { + List visits = new ArrayList<>(); + StatementVisitorAdapter visitor = new StatementVisitorAdapter() { + private String record(Statement statement, S context) { + visits.add(statement.getClass().getSimpleName() + ":" + context); + return String.valueOf(context); + } + + @Override + public String visit(CreateLanguage statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterLanguage statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterLargeObject statement, S context) { + return record(statement, context); + } + + @Override + public String visit(CreateTextSearchDictionary statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterTextSearchDictionary statement, S context) { + return record(statement, context); + } + + @Override + public String visit(CreateTextSearchParser statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterTextSearchParser statement, S context) { + return record(statement, context); + } + + @Override + public String visit(CreateTextSearchTemplate statement, S context) { + return record(statement, context); + } + + @Override + public String visit(AlterTextSearchTemplate statement, S context) { + return record(statement, context); + } + + }; + Statement statement = parse(sql); + assertThat(statement.accept(visitor, "context")).isEqualTo("context"); + if (statement instanceof CreateLanguage) { + visitor.visit((CreateLanguage) statement); + } else if (statement instanceof AlterLanguage) { + visitor.visit((AlterLanguage) statement); + } else if (statement instanceof AlterLargeObject) { + visitor.visit((AlterLargeObject) statement); + } else if (statement instanceof CreateTextSearchDictionary) { + visitor.visit((CreateTextSearchDictionary) statement); + } else if (statement instanceof AlterTextSearchDictionary) { + visitor.visit((AlterTextSearchDictionary) statement); + } else if (statement instanceof CreateTextSearchParser) { + visitor.visit((CreateTextSearchParser) statement); + } else if (statement instanceof AlterTextSearchParser) { + visitor.visit((AlterTextSearchParser) statement); + } else if (statement instanceof CreateTextSearchTemplate) { + visitor.visit((CreateTextSearchTemplate) statement); + } else if (statement instanceof AlterTextSearchTemplate) { + visitor.visit((AlterTextSearchTemplate) statement); + } + assertThat(visits).containsExactly(statementClass + ":context", statementClass + ":null"); + } + + @Test + void buildersRenderTypedMetadataWithoutRawStatementParts() { + CreateLanguage language = new CreateLanguage().withName("l").withOrReplace(true) + .withTrusted(true).withProcedural(true).withHandler("s.h") + .withInlineHandler("s.i").withNoValidator(true); + assertThat(language).hasToString( + "CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE l HANDLER s.h INLINE s.i NO VALIDATOR"); + assertThat(new AlterLanguage().withName("l").withProcedural(true) + .withAction(AlterLanguage.Action.RENAME).withNewName("m")) + .hasToString("ALTER PROCEDURAL LANGUAGE l RENAME TO m"); + assertThat(new AlterLargeObject().withLargeObjectId(new LongValue(12345)).withOwner("r")) + .hasToString("ALTER LARGE OBJECT 12345 OWNER TO r"); + DefinitionElement function = new DefinitionElement("LEXIZE", + DefinitionArgument.type(new ColDataType("s.f"))); + assertThat( + new CreateTextSearchTemplate().withName("t").withFunctions(Arrays.asList(function))) + .hasToString("CREATE TEXT SEARCH TEMPLATE t (LEXIZE = s.f)"); + assertThat(new CreateTextSearchDictionary().withName("d").withOptions(Arrays.asList( + new DefinitionElement("TEMPLATE", + DefinitionArgument.type(new ColDataType("simple")))))) + .hasToString("CREATE TEXT SEARCH DICTIONARY d (TEMPLATE = simple)"); + assertThat(new AlterTextSearchDictionary().withName("d") + .withAction(AlterTextSearchDictionary.Action.OPTIONS) + .withOptions(Arrays.asList(new DefinitionElement("STOPWORDS", null)))) + .hasToString("ALTER TEXT SEARCH DICTIONARY d (STOPWORDS)"); + assertThat(new AlterTextSearchParser().withName("p") + .withAction(AlterTextSearchParser.Action.RENAME).withNewName("q")) + .hasToString("ALTER TEXT SEARCH PARSER p RENAME TO q"); + assertThat(new AlterTextSearchTemplate().withName("t") + .withAction(AlterTextSearchTemplate.Action.SET_SCHEMA).withSchemaName("s")) + .hasToString("ALTER TEXT SEARCH TEMPLATE t SET SCHEMA s"); + } + + @ParameterizedTest + @ValueSource(strings = {"create language l handler h no validator", + "alter language l owner to r", "alter large object 12345 owner to r", + "create text search template t (lexize = f)"}) + void lowerCaseKeywordsNormalizeWithoutChangingNames(String sql) throws Exception { + Statement statement = parse(sql); + assertThat(statement).isNotInstanceOf(UnsupportedStatement.class); + assertThat(statement.toString()).isEqualToIgnoringCase(sql); + assertThat(parse(statement.toString())).hasToString(statement.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlOperatorDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlOperatorDdlTest.java new file mode 100644 index 0000000000..dc69835b2b --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlOperatorDdlTest.java @@ -0,0 +1,719 @@ +/*- + * #%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.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.DefinitionArgument; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterOperator; +import net.sf.jsqlparser.statement.alter.AlterOperatorClass; +import net.sf.jsqlparser.statement.alter.AlterOperatorFamily; +import net.sf.jsqlparser.statement.comment.Comment; +import net.sf.jsqlparser.statement.create.operator.CreateOperator; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorClass; +import net.sf.jsqlparser.statement.create.operator.CreateOperatorFamily; +import net.sf.jsqlparser.statement.create.operator.OperatorClassItem; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL CREATE and ALTER OPERATOR, OPERATOR CLASS and OPERATOR FAMILY, see + * https://www.postgresql.org/docs/18/sql-createoperator.html, + * https://www.postgresql.org/docs/18/sql-alteroperator.html, + * https://www.postgresql.org/docs/18/sql-createopclass.html, + * https://www.postgresql.org/docs/18/sql-alteropclass.html, + * https://www.postgresql.org/docs/18/sql-createopfamily.html and + * https://www.postgresql.org/docs/18/sql-alteropfamily.html. + */ +class PostgreSqlOperatorDdlTest extends ValidationTestAsserts { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Statement assertStatement(String sql, Class type) + throws Exception { + assertThat(assertSqlCanBeParsedAndDeparsed(sql)).isInstanceOf(type); + return assertPostgreSqlStatement(sql, type); + } + + /** For an operator such as ##, which only the PostgreSQL dialect does not lex as a name. */ + private static Statement assertPostgreSqlStatement(String sql, + Class type) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertThat(statement).isInstanceOf(type).hasToString(sql); + StatementDeParser deparser = new StatementDeParser(new StringBuilder()); + statement.accept(deparser); + assertThat(deparser.getBuilder()).hasToString(sql); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA) + .doesNotContain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET); + + Statements script = CCJSqlParserUtil.parseStatements( + sql + "; SELECT 1; " + sql + ";\n" + sql, POSTGRESQL); + assertThat(script).hasSize(4); + assertThat(script.get(0)).isInstanceOf(type).hasToString(sql); + assertThat(script.get(2)).isInstanceOf(type).hasToString(sql); + assertThat(script.get(3)).isInstanceOf(type).hasToString(sql); + return statement; + } + + private static void assertRejected(String sql) { + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql, POSTGRESQL)) + .isInstanceOf(JSQLParserException.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OPERATOR === (FUNCTION = f, LEFTARG = int, RIGHTARG = int)", + "CREATE OPERATOR s.<-> (PROCEDURE = s.f, LEFTARG = point, RIGHTARG = point, " + + "COMMUTATOR = <->, NEGATOR = OPERATOR(s.), RESTRICT = eqsel, " + + "JOIN = eqjoinsel, HASHES, MERGES)", + "CREATE OPERATOR public.!== (function = f, leftarg = int, rightarg = int, negator = ===)", + "CREATE OPERATOR d.public.=== (FUNCTION = f, LEFTARG = int, RIGHTARG = int)", + "CREATE OPERATOR \"s\".@@@ (FUNCTION = f, LEFTARG = int, RIGHTARG = int)", + "CREATE OPERATOR class.+ (FUNCTION = f)", + "CREATE OPERATOR family.+ (FUNCTION = f)", + "CREATE OPERATOR <#> (FUNCTION = f)", + "CREATE OPERATOR <#> (HASHES)", + "CREATE OPERATOR <#> (FUNCTION = f, LEFTARG = varchar (3), RIGHTARG = int[], " + + "\"Quoted\" = 'x', n = 1, m = -1.5, k = true, j = NONE, i = SETOF int)", + "CREATE OPERATOR <#> (select = f, table = int)"}) + void testCreateOperator(String sql) throws Exception { + assertStatement(sql, CreateOperator.class); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + + /** PostgreSQL reads any run of operator characters as one operator. */ + @ParameterizedTest + @ValueSource(strings = { + "+", "-", "*", "/", "%", "^", "<", ">", "=", "~", "!", "@", "#", "&", "|", "?", + "<=", ">=", "<>", "!=", "==", "===", "<->", "<==>", "@@", "@@@", "@#@", "@#", "#@", + "<<|", "&<|", "|>>", "~=", "<^", ">^", "?#", "?-|", "?||", "##", "@-@", "!!", "|/", + "||/", "*<>", "~<~", "^@", "<<=", "-|-", "&&&", "~~*", "!~~*", "#-", "<%", "%>", + "<<%", "->>", "#>>", "?&", "%%", "|&>", "&<", "&>", ">>=", "<<->>", "=*", "*=", + "<=>", "@>", "<@", ">>", "<<", "|>", "||", "&&", "^^", "**", "~*", "^=", "-#", + "@?", "#>", "@-", "~+", "@+", "~-", "-+-|", "+*", "-="}) + void testOperatorNameIsOneNameWithItsExactText(String operator) throws Exception { + String create = "CREATE OPERATOR s." + operator + + " (FUNCTION = f, COMMUTATOR = " + operator + ", NEGATOR = OPERATOR(s." + + operator + "))"; + CreateOperator created = + (CreateOperator) assertPostgreSqlStatement(create, CreateOperator.class); + // without the dialect, the lexer reads # before # or @ as the start of a name + if (!operator.startsWith("##") && !operator.startsWith("#@")) { + assertThat(assertSqlCanBeParsedAndDeparsed(create)).isInstanceOf(CreateOperator.class); + } + assertThat(created.getOperator().getSchemaName()).isEqualTo("s"); + assertThat(created.getOperator().getName()).isEqualTo(operator); + assertThat(created.getDefinitionElement("commutator").getArgument().getOperator()) + .isEqualTo(operator); + assertThat(created.getDefinitionElement("NEGATOR").getArgument().getOperator()) + .isEqualTo("s." + operator); + + String alter = "ALTER OPERATOR " + operator + " (int, int) OWNER TO u"; + AlterOperator altered = + (AlterOperator) assertPostgreSqlStatement(alter, AlterOperator.class); + assertThat(altered.getOperator().getOperator().getName()).isEqualTo(operator); + + String family = "ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 " + operator + + " (int, int), OPERATOR 2 " + operator; + AlterOperatorFamily added = (AlterOperatorFamily) assertPostgreSqlStatement(family, + AlterOperatorFamily.class); + assertThat(added.getItems().get(0).getOperator().getName()).isEqualTo(operator); + assertThat(added.getItems().get(1).getOperator().getName()).isEqualTo(operator); + + String drop = "DROP OPERATOR " + operator + " (int, int)"; + Drop dropped = (Drop) assertSqlCanBeParsedAndDeparsed(drop, false, POSTGRESQL); + assertThat(dropped.getOperators().get(0).getOperator().getName()).isEqualTo(operator); + } + + /** + * Texts PostgreSQL's lexer does not take as one operator: a name of several characters ends in + * + or - only if it has one of ~ ! @ # % ^ & | ` ?, and => is a token of its own. + */ + @ParameterizedTest + @ValueSource(strings = {"=>", "=-", "+-", "*-", "-+-", "<=+", "= =", "< =", "::", ":=", "..", + "myop", "@#x", "OPERATOR(===)", "\"===\"", "'==='", "(", ""}) + void testRejectedOperatorNames(String operator) { + assertRejected("CREATE OPERATOR " + operator + " (FUNCTION = f)"); + assertRejected("CREATE OPERATOR s." + operator + " (FUNCTION = f)"); + assertRejected("CREATE OPERATOR === (FUNCTION = f, COMMUTATOR = OPERATOR(" + operator + + "))"); + assertRejected("ALTER OPERATOR " + operator + " (int, int) OWNER TO u"); + assertRejected("ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 " + operator + + " (int, int)"); + assertRejected("DROP OPERATOR " + operator + " (int, int)"); + assertRejected("COMMENT ON OPERATOR " + operator + " (int, int) IS 'x'"); + } + + @Test + void testOperatorNameLength() throws Exception { + StringBuilder name = new StringBuilder(); + for (int i = 0; i < 63; i++) { + name.append('<'); + } + assertStatement("CREATE OPERATOR " + name + " (FUNCTION = f)", CreateOperator.class); + assertRejected("CREATE OPERATOR " + name + "< (FUNCTION = f)"); + } + + @Test + void testSharedOperatorReaders() throws Exception { + Drop drop = (Drop) assertSqlCanBeParsedAndDeparsed( + "DROP OPERATOR d.public.<==> (int, int), @#@ (NONE, int)", false, POSTGRESQL); + assertThat(drop.getOperators().get(0).getOperator().getSchemaName()) + .isEqualTo("d.public"); + assertThat(drop.getOperators().get(0).getOperator().getName()).isEqualTo("<==>"); + assertThat(drop.getOperators().get(1).getOperator().getName()).isEqualTo("@#@"); + assertThat(assertSqlCanBeParsedAndDeparsed("COMMENT ON OPERATOR d.public.<==> (int, int)" + + " IS 'x'", false, POSTGRESQL)).isInstanceOf(Comment.class); + assertSqlCanBeParsedAndDeparsed("CREATE TYPE t (INPUT = f, x = <==>, y = OPERATOR(a.b.@#))", + false, POSTGRESQL); + // an Oracle operator keeps its name + assertThat(((Drop) CCJSqlParserUtil.parse("DROP OPERATOR a.b.c")).getOperators()) + .isEmpty(); + } + + @Test + void testCreateOperatorFields() throws Exception { + CreateOperator operator = (CreateOperator) CCJSqlParserUtil.parse( + "CREATE OPERATOR app.=== (FUNCTION = app.eq, LEFTARG = int, COMMUTATOR = ===, " + + "NEGATOR = OPERATOR(app.!==), HASHES)", + POSTGRESQL); + assertThat(operator.getOperator().getSchemaName()).isEqualTo("app"); + assertThat(operator.getOperator().getName()).isEqualTo("==="); + assertThat(operator.getOperator().getQualifiedName()).isEqualTo("app.==="); + assertThat(operator.getDefinition()).hasSize(5); + DefinitionArgument function = operator.getDefinitionElement("function").getArgument(); + assertThat(function.getKind()).isEqualTo(DefinitionArgument.Kind.TYPE); + assertThat(function.getDataType().getDataType()).isEqualTo("app.eq"); + DefinitionArgument negator = operator.getDefinitionElement("NEGATOR").getArgument(); + assertThat(negator.getKind()).isEqualTo(DefinitionArgument.Kind.OPERATOR); + assertThat(negator.isOperatorKeyword()).isTrue(); + assertThat(negator.getOperator()).isEqualTo("app.!=="); + assertThat(operator.getDefinitionElement("HASHES").getArgument()).isNull(); + assertThat(operator.getDefinitionElement("MERGES")).isNull(); + assertThat(operator.getASTNode()).isNotNull(); + + operator.getOperator().setName("<=>"); + operator.getDefinition().remove(4); + assertThat(operator).hasToString("CREATE OPERATOR app.<=> (FUNCTION = app.eq, " + + "LEFTARG = int, COMMUTATOR = ===, NEGATOR = OPERATOR(app.!==))"); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OPERATOR === ()", + "CREATE OPERATOR ===", + "CREATE OPERATOR === (FUNCTION = f,)", + "CREATE OPERATOR === (FUNCTION f)", + "CREATE OPERATOR === (FUNCTION = )", + "CREATE OPERATOR === (int, int) (FUNCTION = f)", + "CREATE OPERATOR === (FUNCTION = f) OWNER TO u", + "CREATE OR REPLACE OPERATOR === (FUNCTION = f, LEFTARG = int, RIGHTARG = int)", + "CREATE OPERATOR IF NOT EXISTS === (FUNCTION = f, LEFTARG = int, RIGHTARG = int)", + "CREATE OPERATOR === (FUNCTION = f, COMMUTATOR = +-)", + "CREATE OPERATOR === (FUNCTION = f, COMMUTATOR = =>)", + "CREATE OPERATOR eq BINDING (VARCHAR2, VARCHAR2) RETURN NUMBER USING eq_f"}) + void testRejectedCreateOperator(String sql) { + assertRejected(sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER OPERATOR + (int, int) OWNER TO u", + "ALTER OPERATOR === (int, int) OWNER TO CURRENT_USER", + "ALTER OPERATOR === (int, int) OWNER TO SESSION_USER", + "ALTER OPERATOR === (int, int) OWNER TO CURRENT_ROLE", + "ALTER OPERATOR s.@@ (NONE, text) SET SCHEMA t", + "ALTER OPERATOR t.=== (int, int) SET SCHEMA public", + "ALTER OPERATOR === (int, int) SET (RESTRICT = eqsel, JOIN = NONE, HASHES)", + "ALTER OPERATOR === (int, int) SET (RESTRICT = NONE)", + "ALTER OPERATOR === (int, int) SET (COMMUTATOR = OPERATOR(public.===), NEGATOR = !==, " + + "MERGES = false, HASHES = true)", + "ALTER OPERATOR === (int, int) SET (x = 'a', y = 1, z = s.f2)", + "ALTER OPERATOR - (NONE, int) OWNER TO u", + "ALTER OPERATOR ! (bigint, NONE) OWNER TO u", + "ALTER OPERATOR d.public.=== (int, int) OWNER TO u", + "ALTER OPERATOR family.+ (varchar (3), int[]) OWNER TO u"}) + void testAlterOperator(String sql) throws Exception { + assertStatement(sql, AlterOperator.class); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + + @Test + void testAlterOperatorFields() throws Exception { + AlterOperator owner = (AlterOperator) CCJSqlParserUtil.parse( + "ALTER OPERATOR app.@@ (NONE, text) OWNER TO u", POSTGRESQL); + assertThat(owner.getOperator().getOperator().getQualifiedName()).isEqualTo("app.@@"); + assertThat(owner.getOperator().getLeftType()).isNull(); + assertThat(owner.getOperator().getRightType()).hasToString("text"); + assertThat(owner.getOperator().getASTNode()).isNotNull(); + assertThat(owner.getAction()).isEqualTo(AlterOperator.Action.OWNER); + assertThat(owner.getNewName()).isEqualTo("u"); + assertThat(owner.getProperties()).isEmpty(); + + AlterOperator schema = (AlterOperator) CCJSqlParserUtil.parse( + "ALTER OPERATOR + (int, int) SET SCHEMA \"S\"", POSTGRESQL); + assertThat(schema.getAction()).isEqualTo(AlterOperator.Action.SET_SCHEMA); + assertThat(schema.getNewName()).isEqualTo("\"S\""); + + AlterOperator properties = (AlterOperator) CCJSqlParserUtil.parse( + "ALTER OPERATOR + (int, int) SET (RESTRICT = eqsel, JOIN = NONE, HASHES)", + POSTGRESQL); + assertThat(properties.getAction()).isEqualTo(AlterOperator.Action.SET_PROPERTIES); + assertThat(properties.getNewName()).isNull(); + assertThat(properties.getProperties()).hasSize(3); + assertThat(properties.getProperties().get(1).getArgument().getKind()) + .isEqualTo(DefinitionArgument.Kind.NONE); + properties.getProperties().remove(2); + properties.getOperator().setLeftType(null); + assertThat(properties).hasToString( + "ALTER OPERATOR + (NONE, int) SET (RESTRICT = eqsel, JOIN = NONE)"); + properties.setAction(null); + assertThatThrownBy(properties::toString).isInstanceOf(NullPointerException.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER OPERATOR === (int, int) RENAME TO ====", + "ALTER OPERATOR === (int, int) RENAME TO x", + "ALTER OPERATOR === OWNER TO u", + "ALTER OPERATOR === (int) OWNER TO u", + "ALTER OPERATOR === (NONE, NONE) OWNER TO u", + "ALTER OPERATOR === (int, int, int) OWNER TO u", + "ALTER OPERATOR === (int, int) SET ()", + "ALTER OPERATOR === (int, int) SET (RESTRICT = )", + "ALTER OPERATOR === (int, int) SET RESTRICT = eqsel", + "ALTER OPERATOR === (int, int) OWNER u", + "ALTER OPERATOR === (int, int) SET SCHEMA", + "ALTER OPERATOR === (int, int)", + "ALTER OPERATOR IF EXISTS === (int, int) OWNER TO u", + "ALTER OPERATOR === (int, int), !== (int, int) OWNER TO u", + "ALTER OPERATOR myop (int, int) OWNER TO u", + "ALTER OPERATOR === (int, int) OWNER TO u CASCADE", + "ALTER OPERATOR eq COMPILE"}) + void testRejectedAlterOperator(String sql) { + assertRejected(sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OPERATOR CLASS oc DEFAULT FOR TYPE int USING btree AS OPERATOR 1 <, " + + "FUNCTION 1 f(int, int)", + "CREATE OPERATOR CLASS oc FOR TYPE int USING gist FAMILY fam AS OPERATOR 1 < (int, int) " + + "FOR ORDER BY float_ops, FUNCTION 1 (int, int) f(int, int), STORAGE int", + "CREATE OPERATOR CLASS s.oc2 FOR TYPE int4 USING btree FAMILY public.fam AS " + + "OPERATOR 1 < FOR SEARCH, OPERATOR 2 <=, OPERATOR 3 =, OPERATOR 4 >=, " + + "OPERATOR 5 >, FUNCTION 1 cmp(int, int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE varchar (3) USING hash AS STORAGE int[]", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION 1 cmp", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION 1 s.cmp", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION 1 (int) cmp(int, int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION 1 cmp()", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS " + + "FUNCTION 2 (int, text) s.f(IN a int, VARIADIC b text[])", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS " + + "OPERATOR 1 pg_catalog.< (int, int) FOR ORDER BY pg_catalog.float_ops", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 pg_catalog.<", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 - (NONE, int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 ! (int, NONE)", + "CREATE OPERATOR CLASS oc3 FOR TYPE timestamp with time zone USING btree AS " + + "OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE double precision USING btree AS " + + "STORAGE double precision", + "CREATE OPERATOR CLASS \"Oc\" FOR TYPE s.\"T\" USING \"btree\" AS OPERATOR 1 <", + "CREATE OPERATOR CLASS class FOR TYPE int USING btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS family.oc FOR TYPE int USING btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 0 <"}) + void testCreateOperatorClass(String sql) throws Exception { + assertStatement(sql, CreateOperatorClass.class); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + + @Test + void testCreateOperatorClassFields() throws Exception { + CreateOperatorClass operatorClass = (CreateOperatorClass) CCJSqlParserUtil.parse( + "CREATE OPERATOR CLASS app.oc DEFAULT FOR TYPE varchar(3) USING gist " + + "FAMILY app.fam AS OPERATOR 1 app.<< (NONE, int) FOR ORDER BY s.float_ops, " + + "OPERATOR 2 = FOR SEARCH, OPERATOR 3 <, " + + "FUNCTION 4 (int, text) app.f(int, text), FUNCTION 5 g, STORAGE int[]", + POSTGRESQL); + assertThat(operatorClass.getName()).isEqualTo("app.oc"); + assertThat(operatorClass.isDefaultClass()).isTrue(); + assertThat(operatorClass.getDataType()).hasToString("varchar (3)"); + assertThat(operatorClass.getDataType().getASTNode()).isNotNull(); + assertThat(operatorClass.getAccessMethod()).isEqualTo("gist"); + assertThat(operatorClass.getFamily()).isEqualTo("app.fam"); + assertThat(operatorClass.getItems()).hasSize(6); + + OperatorClassItem ordering = operatorClass.getItems().get(0); + assertThat(ordering.getKind()).isEqualTo(OperatorClassItem.Kind.OPERATOR); + assertThat(ordering.getNumber()).isEqualTo(1); + assertThat(ordering.getOperator().getSchemaName()).isEqualTo("app"); + assertThat(ordering.getOperator().getName()).isEqualTo("<<"); + assertThat(ordering.getOperandTypes()).hasSize(2); + assertThat(ordering.getOperandTypes().get(0)).isNull(); + assertThat(ordering.getOperandTypes().get(1)).hasToString("int"); + assertThat(ordering.getPurpose()).isEqualTo(OperatorClassItem.Purpose.ORDER_BY); + assertThat(ordering.getSortFamily()).isEqualTo("s.float_ops"); + assertThat(ordering.getFunction()).isNull(); + + OperatorClassItem search = operatorClass.getItems().get(1); + assertThat(search.getOperandTypes()).isNull(); + assertThat(search.getPurpose()).isEqualTo(OperatorClassItem.Purpose.SEARCH); + assertThat(search.getSortFamily()).isNull(); + assertThat(operatorClass.getItems().get(2).getPurpose()).isNull(); + + OperatorClassItem function = operatorClass.getItems().get(3); + assertThat(function.getKind()).isEqualTo(OperatorClassItem.Kind.FUNCTION); + assertThat(function.getNumber()).isEqualTo(4); + assertThat(function.getOperandTypes()).hasSize(2); + assertThat(function.getFunction().getName()).isEqualTo("app.f"); + assertThat(function.getFunction().getArguments()).hasSize(2); + assertThat(function.getOperator()).isNull(); + assertThat(operatorClass.getItems().get(4).getFunction().getArguments()).isNull(); + assertThat(operatorClass.getItems().get(4).getOperandTypes()).isNull(); + + OperatorClassItem storage = operatorClass.getItems().get(5); + assertThat(storage.getKind()).isEqualTo(OperatorClassItem.Kind.STORAGE); + assertThat(storage.getNumber()).isNull(); + assertThat(storage.getStorageType()).hasToString("int[]"); + + operatorClass.setDefaultClass(false); + operatorClass.setFamily(null); + operatorClass.getItems().subList(1, 6).clear(); + ordering.setPurpose(null); + OperatorClassItem added = new OperatorClassItem(OperatorClassItem.Kind.STORAGE); + added.setStorageType(storage.getStorageType()); + operatorClass.getItems().add(added); + assertThat(operatorClass).hasToString("CREATE OPERATOR CLASS app.oc FOR TYPE varchar (3) " + + "USING gist AS OPERATOR 1 app.<< (NONE, int), STORAGE int[]"); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS", + "CREATE OPERATOR CLASS oc3 FOR TYPE int AS OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 USING btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 FOR int USING btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int DEFAULT USING btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING s.btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1.5 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR -1 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 99999999999 <", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 < (int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 < (NONE, NONE)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 < FOR ORDER float_ops", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 < FOR", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 < RECHECK", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 OPERATOR(<)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 +-", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION cmp(int, int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION 1", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS FUNCTION 1 () cmp(int, int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS " + + "FUNCTION 1 (NONE, int) cmp(int, int)", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS " + + "FUNCTION 1 cmp(int, int) FOR SEARCH", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS STORAGE", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS STORAGE int,", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 < OPERATOR 2 <=", + "CREATE OPERATOR CLASS oc3 FOR TYPE int USING btree FAMILY AS OPERATOR 1 <", + "CREATE OR REPLACE OPERATOR CLASS oc3 FOR TYPE int USING btree AS OPERATOR 1 <", + "CREATE OPERATOR CLASS IF NOT EXISTS oc3 FOR TYPE int USING btree AS OPERATOR 1 <"}) + void testRejectedCreateOperatorClass(String sql) { + assertRejected(sql); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER OPERATOR CLASS oc USING btree RENAME TO oc2", + "ALTER OPERATOR CLASS s.oc USING btree OWNER TO u", + "ALTER OPERATOR CLASS oc USING btree OWNER TO CURRENT_USER", + "ALTER OPERATOR CLASS oc USING btree SET SCHEMA s", + "ALTER OPERATOR CLASS \"Oc\" USING \"btree\" RENAME TO \"Oc2\"", + "ALTER OPERATOR CLASS class USING btree RENAME TO family"}) + void testAlterOperatorClass(String sql) throws Exception { + assertStatement(sql, AlterOperatorClass.class); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + + @Test + void testAlterOperatorClassFields() throws Exception { + AlterOperatorClass rename = (AlterOperatorClass) CCJSqlParserUtil.parse( + "ALTER OPERATOR CLASS app.oc USING btree RENAME TO oc2", POSTGRESQL); + assertThat(rename.getName()).isEqualTo("app.oc"); + assertThat(rename.getAccessMethod()).isEqualTo("btree"); + assertThat(rename.getAction()).isEqualTo(AlterOperatorClass.Action.RENAME); + assertThat(rename.getNewName()).isEqualTo("oc2"); + rename.setAction(AlterOperatorClass.Action.OWNER); + rename.setNewName("u"); + assertThat(rename).hasToString("ALTER OPERATOR CLASS app.oc USING btree OWNER TO u"); + rename.setAction(AlterOperatorClass.Action.SET_SCHEMA); + rename.setName("oc"); + rename.setAccessMethod("hash"); + assertThat(rename).hasToString("ALTER OPERATOR CLASS oc USING hash SET SCHEMA u"); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER OPERATOR CLASS oc RENAME TO oc2", + "ALTER OPERATOR CLASS oc USING btree", + "ALTER OPERATOR CLASS oc USING btree RENAME oc2", + "ALTER OPERATOR CLASS oc USING btree RENAME TO s.oc2", + "ALTER OPERATOR CLASS oc USING btree SET (x = 1)", + "ALTER OPERATOR CLASS oc USING btree ADD OPERATOR 1 <", + "ALTER OPERATOR CLASS IF EXISTS oc USING btree RENAME TO oc2", + "ALTER OPERATOR CLASS oc USING btree SET SCHEMA s.t", + "ALTER OPERATOR CLASS oc USING btree RENAME TO oc2 CASCADE"}) + void testRejectedAlterOperatorClass(String sql) { + assertRejected(sql); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OPERATOR FAMILY f USING btree", + "CREATE OPERATOR FAMILY s.f USING hash", + "CREATE OPERATOR FAMILY \"F 1\" USING \"btree\"", + "CREATE OPERATOR FAMILY family USING btree"}) + void testCreateOperatorFamily(String sql) throws Exception { + assertStatement(sql, CreateOperatorFamily.class); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OPERATOR FAMILY f", + "CREATE OPERATOR FAMILY f USING", + "CREATE OPERATOR FAMILY f USING s.btree", + "CREATE OPERATOR FAMILY f USING btree AS OPERATOR 1 <", + "CREATE OPERATOR FAMILY IF NOT EXISTS f USING btree", + "CREATE OR REPLACE OPERATOR FAMILY f USING btree", + "CREATE OPERATOR FAMILY f USING btree, hash", + "CREATE OPERATOR FAMILY f FOR TYPE int USING btree"}) + void testRejectedCreateOperatorFamily(String sql) { + assertRejected(sql); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 < (int, int), " + + "FUNCTION 1 (int, int) g(int, int)", + "ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 < (int4, int2) FOR SEARCH, " + + "OPERATOR 2 <= (int4, int2) FOR ORDER BY s.fam2", + "ALTER OPERATOR FAMILY f USING btree ADD FUNCTION 1 cmp(int, int)", + "ALTER OPERATOR FAMILY f USING btree ADD FUNCTION 1 (int4) cmp(int, int), " + + "FUNCTION 2 (int4, int2) s.cmp2(internal)", + "ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 <", + "ALTER OPERATOR FAMILY f USING btree ADD STORAGE int", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 (int, int), FUNCTION 1 (int, int)", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 (int4)", + "ALTER OPERATOR FAMILY f USING btree DROP FUNCTION 2 (int4, int2, int8)", + "ALTER OPERATOR FAMILY s.f USING hash DROP FUNCTION 1 (varchar (3), int[])", + "ALTER OPERATOR FAMILY f USING btree OWNER TO u", + "ALTER OPERATOR FAMILY f USING btree OWNER TO SESSION_USER", + "ALTER OPERATOR FAMILY f USING btree RENAME TO f2", + "ALTER OPERATOR FAMILY f USING btree SET SCHEMA s", + "ALTER OPERATOR FAMILY family USING btree RENAME TO class"}) + void testAlterOperatorFamily(String sql) throws Exception { + assertStatement(sql, AlterOperatorFamily.class); + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + + @Test + void testOperatorFamilyFields() throws Exception { + CreateOperatorFamily family = (CreateOperatorFamily) CCJSqlParserUtil.parse( + "CREATE OPERATOR FAMILY app.fam USING btree", POSTGRESQL); + assertThat(family.getName()).isEqualTo("app.fam"); + assertThat(family.getAccessMethod()).isEqualTo("btree"); + family.setName("fam"); + family.setAccessMethod("hash"); + assertThat(family).hasToString("CREATE OPERATOR FAMILY fam USING hash"); + + AlterOperatorFamily add = (AlterOperatorFamily) CCJSqlParserUtil.parse( + "ALTER OPERATOR FAMILY app.fam USING btree ADD OPERATOR 1 < (int4, int2), " + + "FUNCTION 1 (int4, int2) btint42cmp(int4, int2)", + POSTGRESQL); + assertThat(add.getName()).isEqualTo("app.fam"); + assertThat(add.getAccessMethod()).isEqualTo("btree"); + assertThat(add.getAction()).isEqualTo(AlterOperatorFamily.Action.ADD); + assertThat(add.getNewName()).isNull(); + assertThat(add.getItems()).hasSize(2); + assertThat(add.getItems().get(0).getOperator().getName()).isEqualTo("<"); + assertThat(add.getItems().get(1).getFunction().getName()).isEqualTo("btint42cmp"); + + AlterOperatorFamily drop = (AlterOperatorFamily) CCJSqlParserUtil.parse( + "ALTER OPERATOR FAMILY fam USING btree DROP OPERATOR 1 (int4, int2), " + + "FUNCTION 2 (int4)", + POSTGRESQL); + assertThat(drop.getAction()).isEqualTo(AlterOperatorFamily.Action.DROP); + OperatorClassItem operator = drop.getItems().get(0); + assertThat(operator.getKind()).isEqualTo(OperatorClassItem.Kind.OPERATOR); + assertThat(operator.getNumber()).isEqualTo(1); + assertThat(operator.getOperator()).isNull(); + assertThat(operator.getOperandTypes()).hasSize(2); + OperatorClassItem function = drop.getItems().get(1); + assertThat(function.getKind()).isEqualTo(OperatorClassItem.Kind.FUNCTION); + assertThat(function.getFunction()).isNull(); + assertThat(function.getOperandTypes()).hasSize(1); + drop.getItems().remove(0); + function.setNumber(3); + assertThat(drop) + .hasToString("ALTER OPERATOR FAMILY fam USING btree DROP FUNCTION 3 (int4)"); + + AlterOperatorFamily owner = (AlterOperatorFamily) CCJSqlParserUtil.parse( + "ALTER OPERATOR FAMILY fam USING btree OWNER TO u", POSTGRESQL); + assertThat(owner.getAction()).isEqualTo(AlterOperatorFamily.Action.OWNER); + assertThat(owner.getNewName()).isEqualTo("u"); + assertThat(owner.getItems()).isEmpty(); + owner.setAction(AlterOperatorFamily.Action.RENAME); + assertThat(owner).hasToString("ALTER OPERATOR FAMILY fam USING btree RENAME TO u"); + owner.setAction(AlterOperatorFamily.Action.SET_SCHEMA); + assertThat(owner).hasToString("ALTER OPERATOR FAMILY fam USING btree SET SCHEMA u"); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER OPERATOR FAMILY f USING btree ADD", + "ALTER OPERATOR FAMILY f USING btree DROP", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 < (int, int)", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 ()", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 (NONE, int)", + "ALTER OPERATOR FAMILY f USING btree DROP FUNCTION 1 cmp(int, int)", + "ALTER OPERATOR FAMILY f USING btree DROP FUNCTION (int, int)", + "ALTER OPERATOR FAMILY f USING btree DROP STORAGE int", + "ALTER OPERATOR FAMILY f USING btree DROP OPERATOR 1 (int, int) CASCADE", + "ALTER OPERATOR FAMILY f ADD OPERATOR 1 < (int, int)", + "ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 < (int, int) " + + "DROP OPERATOR 2 (int, int)", + "ALTER OPERATOR FAMILY f USING btree ADD OPERATOR 1 < (int, int), " + + "DROP OPERATOR 2 (int, int)", + "ALTER OPERATOR FAMILY f USING btree SET (x = 1)", + "ALTER OPERATOR FAMILY f USING btree RENAME TO", + "ALTER OPERATOR FAMILY IF EXISTS f USING btree RENAME TO f2", + "ALTER OPERATOR FAMILY f USING btree"}) + void testRejectedAlterOperatorFamily(String sql) { + assertRejected(sql); + assertThatThrownBy(() -> CCJSqlParserUtil.parse(sql)) + .isInstanceOf(JSQLParserException.class); + } + + @Test + void testOtherDialectsKeepOracleOperators() throws Exception { + for (String sql : new String[] { + "CREATE OPERATOR eq_op BINDING (VARCHAR2, VARCHAR2) RETURN NUMBER USING eq_f", + "CREATE OR REPLACE OPERATOR s.eq_op BINDING (VARCHAR2) RETURN NUMBER USING eq_f", + "CREATE OPERATOR class BINDING (VARCHAR2) RETURN NUMBER USING eq_f", + "ALTER OPERATOR eq_op COMPILE", + "ALTER OPERATOR class COMPILE", + "ALTER OPERATOR eq_op ADD BINDING (NUMBER) RETURN NUMBER USING f", + "ALTER OPERATOR family ADD BINDING (NUMBER) RETURN NUMBER USING f"}) { + assertThat(CCJSqlParserUtil.parse(sql)).isInstanceOf(UnsupportedStatement.class); + assertThat(CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.ORACLE))) + .isInstanceOf(UnsupportedStatement.class); + } + } + + @Test + void testVisitorsAndValidation() throws Exception { + String[][] statements = { + {"CREATE OPERATOR === (FUNCTION = f)", "createOperator"}, + {"ALTER OPERATOR === (int, int) OWNER TO u", "alterOperator"}, + {"CREATE OPERATOR CLASS oc FOR TYPE int USING btree AS OPERATOR 1 <", + "createOperatorClass"}, + {"ALTER OPERATOR CLASS oc USING btree RENAME TO oc2", "alterOperatorClass"}, + {"CREATE OPERATOR FAMILY f USING btree", "createOperatorFamily"}, + {"ALTER OPERATOR FAMILY f USING btree RENAME TO f2", "alterOperatorFamily"}}; + for (String[] entry : statements) { + String sql = entry[0]; + Feature feature = Feature.valueOf(entry[1]); + validateNoErrors(sql, 1, + feature.name().startsWith("create") ? FeaturesAllowed.CREATE + : FeaturesAllowed.ALTER); + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, feature); + validate(sql, 1, 1, MySqlVersion.V8_0); + } + + StatementVisitorAdapter visitor = new StatementVisitorAdapter() { + @Override + public String visit(CreateOperator statement, S context) { + return context + ":" + statement.getOperator().getName(); + } + + @Override + public String visit(AlterOperator statement, S context) { + return context + ":" + statement.getAction(); + } + + @Override + public String visit(CreateOperatorClass statement, S context) { + return context + ":" + statement.getName(); + } + + @Override + public String visit(AlterOperatorClass statement, S context) { + return context + ":" + statement.getNewName(); + } + + @Override + public String visit(CreateOperatorFamily statement, S context) { + return context + ":" + statement.getAccessMethod(); + } + + @Override + public String visit(AlterOperatorFamily statement, S context) { + return context + ":" + statement.getAction(); + } + }; + String[] expected = {"c:===", "c:OWNER", "c:oc", "c:oc2", "c:btree", "c:RENAME"}; + for (int i = 0; i < statements.length; i++) { + Statement statement = CCJSqlParserUtil.parse(statements[i][0], POSTGRESQL); + assertThat(statement.accept(visitor, "c")).isEqualTo(expected[i]); + assertThat(statement.accept(new StatementVisitorAdapter(), "c")).isNull(); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlPolicyDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlPolicyDdlTest.java new file mode 100644 index 0000000000..294dc55994 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlPolicyDdlTest.java @@ -0,0 +1,112 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +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.CascadeBehavior; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.AlterPolicy; +import net.sf.jsqlparser.statement.create.policy.CreatePolicy; +import net.sf.jsqlparser.statement.create.policy.PolicyOptions; +import net.sf.jsqlparser.statement.drop.DropPolicy; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlPolicyDdlTest { + @ParameterizedTest + @ValueSource(strings = { + "CREATE POLICY pol ON t", + "CREATE POLICY pol ON t AS RESTRICTIVE FOR SELECT TO PUBLIC USING(id > 0)", + "CREATE POLICY pol ON t FOR INSERT TO CURRENT_USER WITH CHECK(id>0)", + "CREATE POLICY pol ON t FOR UPDATE TO CURRENT_ROLE, SESSION_USER USING(id>0) WITH CHECK(id<100)", + "ALTER POLICY pol ON t RENAME TO pol2", "ALTER POLICY pol ON t TO PUBLIC", + "ALTER POLICY pol ON t TO CURRENT_USER, SESSION_USER", + "ALTER POLICY pol ON t USING(id>1)", + "ALTER POLICY pol ON t WITH CHECK(id<10)", + "ALTER POLICY pol ON t TO CURRENT_ROLE USING(id>0) WITH CHECK(id<100)", + "DROP POLICY pol ON t", "DROP POLICY IF EXISTS pol ON t", + "DROP POLICY pol ON t CASCADE", + "DROP POLICY IF EXISTS pol ON t RESTRICT"}) + void statementsAndFollowingBoundariesRoundTrip(String sql) throws JSQLParserException { + assertRoundTrip(parse(sql)); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void createAndAlterShareRolesAndPredicates() throws JSQLParserException { + CreatePolicy create = (CreatePolicy) parse("CREATE POLICY pol ON t TO PUBLIC USING(id>0)"); + AlterPolicy alter = (AlterPolicy) parse("ALTER POLICY pol ON t TO PUBLIC USING(id>0)"); + assertEquals(create.getRoles(), alter.getOptions().getRoles()); + assertEquals(create.getUsingExpression().toString(), + alter.getOptions().getUsingExpression().toString()); + alter.getOptions().setUsingExpression(CCJSqlParserUtil.parseCondExpression("id > 10")); + alter.setPolicyName("new_policy"); + alter.setTable(new Table("new_table")); + assertEquals("ALTER POLICY new_policy ON new_table TO PUBLIC USING (id > 10)", + alter.toString()); + assertRoundTrip(alter); + alter.setNewName("renamed"); + assertEquals("ALTER POLICY new_policy ON new_table RENAME TO renamed", alter.toString()); + alter.setOptions(new PolicyOptions() + .setUsingExpression(CCJSqlParserUtil.parseCondExpression("id > 1"))); + assertNull(alter.getNewName()); + assertRoundTrip(alter); + } + + @Test + void predicatesAndTargetsParticipateInTraversal() throws JSQLParserException { + String sql = "ALTER POLICY pol ON target USING (EXISTS (SELECT 1 FROM permissions))" + + " WITH CHECK (EXISTS (SELECT 1 FROM allowed_values))"; + assertEquals(Set.of("target", "permissions", "allowed_values"), + TablesNamesFinder.findTables(sql)); + assertEquals(Set.of("target"), TablesNamesFinder.findTables("DROP POLICY pol ON target")); + assertRoundTrip(parse(sql)); + } + + @Test + void dropPolicyNamesAndBehaviorAreMutable() throws JSQLParserException { + DropPolicy drop = (DropPolicy) parse("DROP POLICY IF EXISTS pol ON t CASCADE"); + assertTrue(drop.isIfExists()); + drop.setPolicyName("new_pol").setTable(new Table("new_t")) + .setBehavior(CascadeBehavior.RESTRICT); + assertEquals("DROP POLICY IF EXISTS new_pol ON new_t RESTRICT", drop.toString()); + assertRoundTrip(drop); + } + + @Test + void createOnlyOptionsAndMalformedDropAreRejected() { + for (String sql : new String[] {"ALTER POLICY pol ON t AS RESTRICTIVE", + "ALTER POLICY pol ON t FOR SELECT", + "ALTER POLICY pol ON t RENAME TO pol2 USING(id>0)", "DROP POLICY pol", + "DROP POLICY pol ON t, u"}) { + assertThrows(JSQLParserException.class, () -> parse(sql)); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + assertEquals(statement.toString(), builder.toString()); + assertEquals(statement.toString(), parse(builder.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlRuleTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlRuleTest.java new file mode 100644 index 0000000000..e82a0e8db4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlRuleTest.java @@ -0,0 +1,128 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.create.rule.CreateRule; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.notify.NotifyStatement; +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.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlRuleTest { + @ParameterizedTest + @ValueSource(strings = { + "CREATE RULE r AS ON INSERT TO t DO ALSO NOTIFY ddl_probe", + "CREATE OR REPLACE RULE r AS ON UPDATE TO app.t WHERE NEW.id > 0 DO INSTEAD NOTHING", + "CREATE RULE r AS ON DELETE TO t DO NOTHING", + "CREATE RULE r AS ON INSERT TO t DO INSERT INTO log SELECT NEW.id", + "CREATE RULE r AS ON UPDATE TO t DO UPDATE log SET id=NEW.id WHERE id=OLD.id", + "CREATE RULE r AS ON DELETE TO t DO DELETE FROM log WHERE id=OLD.id", + "CREATE RULE \"_RETURN\" AS ON SELECT TO v DO INSTEAD SELECT * FROM t", + "CREATE RULE r AS ON INSERT TO t DO ALSO (NOTIFY ch, 'updated'; INSERT INTO log VALUES (1);)", + "CREATE RULE r AS ON INSERT TO t DO (;;;NOTIFY ch;;)", + "CREATE RULE r AS ON INSERT TO t DO ()", + "CREATE RULE r AS ON INSERT TO t DO (;)", + "CREATE RULE r AS ON INSERT TO t DO (SELECT 1 UNION ALL SELECT 2)", + "CREATE RULE r AS ON INSERT TO t DO (SELECT 1) UNION ALL SELECT 2", + "CREATE RULE r AS ON INSERT TO t DO TABLE log", + "CREATE RULE r AS ON INSERT TO t DO ((SELECT 1) UNION ALL SELECT 2; NOTIFY ch)", + "CREATE RULE r AS ON INSERT TO t DO WITH x AS (SELECT 1) INSERT INTO log SELECT * FROM x", + "CREATE RULE r AS ON INSERT TO t DO NOTIFY \"Channel\", 'semi;colon'", + "NOTIFY ch", "NOTIFY \"Channel\", 'it''s ready'"}) + void ruleActionsAndStatementBoundaries(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertTrue(statement instanceof CreateRule || statement instanceof NotifyStatement); + roundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + assertTrue(new Validation(List.of(PostgresqlVersion.V14), sql) + .validate().isEmpty()); + } + + @Test + void actionAndPredicateMutationsUseTheExistingAst() throws JSQLParserException { + CreateRule rule = (CreateRule) CCJSqlParserUtil.parse( + "CREATE RULE r AS ON INSERT TO app.t WHERE NEW.id > 0 DO (INSERT INTO log SELECT NEW.id; NOTIFY ch, 'original')"); + assertEquals(Set.of("app.t", "log"), new TablesNamesFinder().getTables(rule)); + rule.setWhereExpression(CCJSqlParserUtil.parseCondExpression("NEW.id > 10")); + Insert insert = (Insert) rule.getActions().get(0); + insert.getTable().setName("audit_log"); + NotifyStatement notify = (NotifyStatement) rule.getActions().get(1); + notify.setPayload(new StringValue("changed")); + assertTrue(rule.toString().contains("NEW.id > 10")); + assertTrue(rule.toString().contains("INSERT INTO audit_log")); + assertTrue(rule.toString().contains("'changed'")); + assertEquals(Set.of("app.t", "audit_log"), new TablesNamesFinder().getTables(rule)); + roundTrip(rule); + rule.setNothing(true); + assertTrue(rule.getActions().isEmpty()); + assertTrue(rule.toString().endsWith("DO NOTHING")); + roundTrip(rule); + } + + @Test + void nestedActionsUseCustomExpressionDeparser() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse( + "CREATE RULE r AS ON INSERT TO t DO (INSERT INTO log VALUES ('before'); NOTIFY ch, 'before')"); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(StringValue value, S context) { + return getBuilder().append("'after'"); + } + }; + SelectDeParser selects = new SelectDeParser(expressions, output); + expressions.setBuilder(output); + expressions.setSelectVisitor(selects); + statement.accept(new StatementDeParser(expressions, selects, output)); + assertFalse(output.toString().contains("'before'")); + assertTrue(output.toString().contains("VALUES ('after')")); + assertTrue(output.toString().contains("NOTIFY ch, 'after'")); + assertTrue(new TablesNamesFinder().getTables(CCJSqlParserUtil.parse("NOTIFY table_name")) + .isEmpty()); + } + + @Test + void notifyRemainsUsableAsAnIdentifier() throws JSQLParserException { + roundTrip(CCJSqlParserUtil.parse("SELECT notify FROM notify")); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE RULE r AS ON TRUNCATE TO t DO NOTHING", + "CREATE RULE r AS ON INSERT TO t DO", "CREATE RULE r AS ON INSERT TO t DO (NOTIFY ch", + "CREATE RULE r AS ON INSERT TO t DO CREATE TABLE x(id int)", + "CREATE RULE r AS ON INSERT TO t DO (NOTIFY ch NOTIFY ch2)", + "CREATE RULE r AS ON INSERT TO t DO (NOTIFY ch; DROP TABLE t)", + "CREATE RULE r AS ON INSERT TO t DO ALSO INSTEAD NOTHING", + "NOTIFY", "NOTIFY ch, 123", "NOTIFY ch, 'a' || 'b'", "NOTIFY app.ch"}) + void rejectsInvalidActionsAndPayloads(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSchemaDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSchemaDdlTest.java index c3ac603f1d..d9044b602f 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSchemaDdlTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSchemaDdlTest.java @@ -31,7 +31,7 @@ import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.ExcludeConstraint; import net.sf.jsqlparser.statement.create.table.IdentityDefinition; -import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; @@ -47,7 +47,7 @@ void testExclusionConstraint() throws JSQLParserException { "CREATE TABLE reservations (room integer, during tsrange," + " CONSTRAINT no_overlap EXCLUDE USING gist (room WITH =, during WITH &&)" + " WHERE (room > 0) DEFERRABLE INITIALLY DEFERRED)"); - ExcludeConstraint constraint = (ExcludeConstraint) table.getIndexes().get(0); + ExcludeConstraint constraint = (ExcludeConstraint) table.getTableConstraints().get(0); assertThat(constraint.getName()).isEqualTo("no_overlap"); assertThat(constraint.getUsing()).isEqualTo("gist"); assertThat(constraint.getColumns().get(0).getExclusionOperator()).isEqualTo("="); @@ -63,7 +63,7 @@ void testExclusionExpressionAndStorage() throws JSQLParserException { CreateTable table = (CreateTable) assertSqlCanBeParsedAndDeparsed( "CREATE TABLE reservations (room text, EXCLUDE USING gist ((lower(room)) WITH =)" + " INCLUDE (room) WITH (fillfactor = 70) USING INDEX TABLESPACE archive)"); - Index constraint = table.getIndexes().get(0); + ExcludeConstraint constraint = (ExcludeConstraint) table.getTableConstraints().get(0); assertThat(constraint.getColumns().get(0).isExpression()).isTrue(); assertThat(constraint.getIncludeColumns()).containsExactly("room"); assertThat(constraint.getStorageParameters()).hasSize(1); @@ -77,18 +77,21 @@ void testUniqueNullTreatment() throws JSQLParserException { + " CONSTRAINT contact_email UNIQUE NULLS DISTINCT (email))"); ColumnOption option = table.getColumnDefinitions().get(0).getColumnOptions().get(0); assertThat(option.getKind()).isEqualTo(ColumnOption.Kind.CONSTRAINT); - assertThat(option.getConstraint().getNullsDistinct()).isFalse(); - assertThat(table.getIndexes().get(0).getNullsDistinct()).isTrue(); + assertThat(((KeyConstraint) option.getConstraint()).getNullsDistinct()).isFalse(); + assertThat(((KeyConstraint) table.getTableConstraints().get(0)).getNullsDistinct()) + .isTrue(); } @Test void testPrimaryKeyInclude() throws JSQLParserException { CreateTable table = (CreateTable) assertSqlCanBeParsedAndDeparsed( "CREATE TABLE contacts (id integer, email text, PRIMARY KEY (id) INCLUDE (email))"); - assertThat(table.getIndexes().get(0).getIncludeColumns()).containsExactly("email"); + assertThat(((KeyConstraint) table.getTableConstraints().get(0)).getIncludeColumns()) + .containsExactly("email"); Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed( "ALTER TABLE contacts ADD PRIMARY KEY (id) INCLUDE (email)"); - assertThat(alter.getAlterExpressions().get(0).getIndex().getIncludeColumns()) + assertThat(((KeyConstraint) alter.getAlterExpressions().get(0).getConstraint()) + .getIncludeColumns()) .containsExactly("email"); } @@ -141,7 +144,7 @@ void testTypedTable() throws JSQLParserException { assertThat(table.getOfType().getDataType()).isEqualTo("employee_type"); assertThat(table.getColumnDefinitions().get(0).isWithOptions()).isTrue(); assertThat(table.getColumnDefinitions().get(0).getColDataType()).isNull(); - assertThat(table.getTableElements().get(0)).isInstanceOf(Index.class); + assertThat(table.getTableElements().get(0)).isInstanceOf(KeyConstraint.class); } @Test diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSequenceDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSequenceDdlTest.java new file mode 100644 index 0000000000..811ba5a67f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlSequenceDdlTest.java @@ -0,0 +1,124 @@ +/*- + * #%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 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.statement.Statement; +import net.sf.jsqlparser.statement.alter.sequence.AlterSequence; +import net.sf.jsqlparser.statement.create.sequence.CreateSequence; +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 PostgreSqlSequenceDdlTest { + @ParameterizedTest + @ValueSource(strings = { + "CREATE SEQUENCE IF NOT EXISTS s AS INTEGER START WITH 3", + "CREATE TEMP SEQUENCE s AS INTEGER START WITH 3", + "CREATE TEMP SEQUENCE IF NOT EXISTS s AS INTEGER START WITH 3", + "CREATE TEMPORARY SEQUENCE s AS INTEGER START WITH 3", + "CREATE TEMPORARY SEQUENCE IF NOT EXISTS s AS INTEGER START WITH 3", + "CREATE UNLOGGED SEQUENCE s AS INTEGER START WITH 3", + "CREATE UNLOGGED SEQUENCE IF NOT EXISTS s AS INTEGER START WITH 3", + "CREATE SEQUENCE s OWNED BY t.id CACHE 5", + "ALTER SEQUENCE s AS SMALLINT", + "ALTER SEQUENCE s OWNED BY t.id INCREMENT BY 3", + "ALTER SEQUENCE s SET UNLOGGED", + "ALTER SEQUENCE s SET LOGGED", + "ALTER SEQUENCE s OWNER TO CURRENT_USER", + "ALTER SEQUENCE s RENAME TO s2", + "ALTER SEQUENCE s SET SCHEMA ddl_aux", + "ALTER SEQUENCE IF EXISTS s AS SMALLINT", + "ALTER SEQUENCE IF EXISTS s RESTART", + "ALTER SEQUENCE IF EXISTS s RESTART WITH 7", + "ALTER SEQUENCE IF EXISTS s INCREMENT BY 2", + "ALTER SEQUENCE IF EXISTS s MINVALUE -5 MAXVALUE 100", + "ALTER SEQUENCE IF EXISTS s CACHE 3 NO CYCLE", + "ALTER SEQUENCE IF EXISTS s OWNED BY t.id", + "ALTER SEQUENCE IF EXISTS s OWNED BY t.id INCREMENT BY 3", + "ALTER SEQUENCE IF EXISTS s SET UNLOGGED", + "ALTER SEQUENCE IF EXISTS s SET LOGGED", + "ALTER SEQUENCE IF EXISTS s OWNER TO CURRENT_USER", + "ALTER SEQUENCE IF EXISTS s RENAME TO s2", + "ALTER SEQUENCE IF EXISTS s SET SCHEMA ddl_aux", + "CREATE SEQUENCE IF NOT EXISTS sequence_test", + "CREATE TEMP SEQUENCE myseq2", + "CREATE TEMP SEQUENCE myseq3", + "CREATE UNLOGGED SEQUENCE sequence_test_unlogged", + "CREATE TEMPORARY SEQUENCE sequence_test_temp1"}) + void postgresFormsRoundTrip(String sql) throws JSQLParserException { + Statement statement = parse(sql); + assertTrue(statement instanceof CreateSequence || statement instanceof AlterSequence); + assertRoundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void createOptionsCanBeModifiedWithoutStaleTokens() throws JSQLParserException { + CreateSequence statement = (CreateSequence) parse( + "CREATE TEMP SEQUENCE IF NOT EXISTS s OWNED BY t.id CACHE 5 AS INTEGER"); + assertTrue(statement.isIfNotExists()); + assertEquals(CreateSequence.Persistence.TEMP, statement.getPersistence()); + assertEquals("t.id", statement.getSequence().getOwnership().getColumn().toString()); + assertEquals("INTEGER", statement.getSequence().getDataType()); + statement.setPersistence(CreateSequence.Persistence.UNLOGGED); + statement.setIfNotExists(false); + statement.getSequence().setName("renamed"); + statement.getSequence().setOwnership(null); + statement.getSequence().getParameters().get(0).setValue(10L); + assertEquals("CREATE UNLOGGED SEQUENCE renamed AS INTEGER CACHE 10", statement.toString()); + assertRoundTrip(statement); + } + + @Test + void alterOptionsAndActionsRemainSeparate() throws JSQLParserException { + AlterSequence statement = (AlterSequence) parse( + "ALTER SEQUENCE IF EXISTS s OWNED BY t.id INCREMENT BY 3 AS SMALLINT"); + assertTrue(statement.isIfExists()); + assertEquals(AlterSequence.Action.PARAMETERS, statement.getAction()); + assertEquals("SMALLINT", statement.getSequence().getDataType()); + assertEquals(3L, statement.getSequence().getParameters().get(0).getValue()); + statement.setAction(AlterSequence.Action.RENAME); + statement.setNewName("new_s"); + assertEquals("ALTER SEQUENCE IF EXISTS s RENAME TO new_s", statement.toString()); + assertRoundTrip(statement); + } + + @ParameterizedTest + @ValueSource(strings = {"LOCAL TEMP", "LOCAL TEMPORARY", "GLOBAL TEMP", "GLOBAL TEMPORARY"}) + void scopedTemporarySequence(String prefix) throws JSQLParserException { + String sql = "CREATE " + prefix + " SEQUENCE s"; + assertEquals(sql, parse(sql).toString()); + } + + @Test + void duplicateScalarOptionsFail() { + assertThrows(JSQLParserException.class, + () -> parse("CREATE SEQUENCE s AS INT AS BIGINT")); + assertThrows(JSQLParserException.class, + () -> parse("ALTER SEQUENCE s OWNED BY NONE OWNED BY t.id")); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlStatisticsDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlStatisticsDdlTest.java new file mode 100644 index 0000000000..290b4239ce --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlStatisticsDdlTest.java @@ -0,0 +1,105 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +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.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.AlterStatistics; +import net.sf.jsqlparser.statement.create.statistics.CreateStatistics; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlStatisticsDdlTest { + @ParameterizedTest + @ValueSource(strings = { + "CREATE STATISTICS st ON id,label FROM t", + "CREATE STATISTICS st ON (lower(label)) FROM t", + "CREATE STATISTICS st ON (id+1),label FROM t", + "CREATE STATISTICS IF NOT EXISTS st ON id,label FROM t", + "CREATE STATISTICS IF NOT EXISTS st ON (lower(label)) FROM t", + "CREATE STATISTICS IF NOT EXISTS st ON (id+1),label FROM t", + "CREATE STATISTICS ON id,label FROM t", "CREATE STATISTICS ON (lower(label)) FROM t", + "CREATE STATISTICS ON (id+1),label FROM t", + "CREATE STATISTICS st(ndistinct) ON id,label FROM t", + "CREATE STATISTICS st(dependencies) ON id,label FROM t", + "CREATE STATISTICS st(mcv) ON id,label FROM t", + "CREATE STATISTICS st(ndistinct,dependencies,mcv) ON id,label FROM t", + "ALTER STATISTICS st OWNER TO CURRENT_USER", "ALTER STATISTICS st RENAME TO st2", + "ALTER STATISTICS st SET SCHEMA ddl_aux", "ALTER STATISTICS st SET STATISTICS 500", + "ALTER STATISTICS st SET STATISTICS DEFAULT", "DROP STATISTICS st", + "DROP STATISTICS IF EXISTS st,st2 RESTRICT"}) + void definitionAndActionsRoundTrip(String sql) throws JSQLParserException { + assertRoundTrip(parse(sql)); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void namesKindsAndKeyExpressionsCanBeChanged() throws JSQLParserException { + CreateStatistics statistics = (CreateStatistics) parse( + "CREATE STATISTICS IF NOT EXISTS old_stats(ndistinct) ON id,label FROM t"); + assertTrue(statistics.isIfNotExists()); + assertEquals(List.of(CreateStatistics.Kind.NDISTINCT), statistics.getKinds()); + statistics.setName("audit.new_stats").setKinds(List.of(CreateStatistics.Kind.DEPENDENCIES)) + .setTable(new Table("other_table")); + statistics.getExpressions().set(0, new Column("new_id")); + assertEquals( + "CREATE STATISTICS IF NOT EXISTS audit.new_stats (dependencies) ON new_id, label FROM other_table", + statistics.toString()); + assertRoundTrip(statistics); + assertEquals(Set.of("other_table"), TablesNamesFinder.findTables(statistics.toString())); + } + + @Test + void statisticsTargetDistinguishesDefault() throws JSQLParserException { + AlterStatistics statistics = + (AlterStatistics) parse("ALTER STATISTICS st SET STATISTICS DEFAULT"); + assertEquals(AlterStatistics.Action.SET_STATISTICS, statistics.getAction()); + assertNull(statistics.getStatistics()); + statistics.setName("new_st").setStatistics(200); + assertEquals("ALTER STATISTICS new_st SET STATISTICS 200", statistics.toString()); + assertRoundTrip(statistics); + assertTrue(TablesNamesFinder.findTables(statistics.toString()).isEmpty()); + } + + @Test + void malformedDefinitionsAndUnknownKindsFail() { + for (String sql : new String[] {"CREATE STATISTICS st ON id FROM t", + "CREATE STATISTICS IF NOT EXISTS ON id,label FROM t", + "CREATE STATISTICS st(unknown) ON id,label FROM t", + "CREATE STATISTICS st(mcv,mcv) ON id,label FROM t", + "CREATE STATISTICS st(mcv) ON (id+1) FROM t", + "CREATE STATISTICS st ON id+1,label FROM t", + "ALTER STATISTICS st SET STATISTICS 10001"}) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(Statement statement) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql), null); + assertEquals(statement.toString(), sql.toString()); + assertEquals(statement.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableColumnOverridesTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableColumnOverridesTest.java new file mode 100644 index 0000000000..0bebf9b354 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableColumnOverridesTest.java @@ -0,0 +1,99 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create; + +import static org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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 PostgreSqlTableColumnOverridesTest { + @ParameterizedTest + @ValueSource(strings = {"row_type", "public.row_type", "\"Type.Schema\".\"Row.Type\""}) + void keepsTypeNameSeparateFromFirstColumn(String type) throws JSQLParserException { + for (String withOptions : new String[] {"", " WITH OPTIONS"}) { + CreateTable table = parse("CREATE TABLE t OF " + type + " (a" + withOptions + + " DEFAULT 7 NOT NULL, b, CHECK (a > 0))"); + assertEquals(type, table.getOfType().getDataType()); + assertNull(table.getOfType().getArgumentsStringList()); + assertEquals(2, table.getColumnDefinitions().size()); + ColumnDefinition first = table.getColumnDefinitions().get(0); + assertNull(first.getColDataType()); + assertEquals(!withOptions.isEmpty(), first.isWithOptions()); + assertEquals("b", table.getColumnDefinitions().get(1).getColumnName()); + assertEquals(ColumnOption.Kind.DEFAULT, first.getColumnOptions().get(0).getKind()); + roundTrip(table); + first.getColumnOptions().get(0).setDefaultExpression(new LongValue(9)); + assertTrue(table.toString().contains("DEFAULT 9 NOT NULL")); + roundTrip(table); + } + } + + @ParameterizedTest + @ValueSource(strings = {"DEFAULT", "FOR VALUES IN (1, 2)", + "FOR VALUES FROM (0) TO (10)", "FOR VALUES WITH (MODULUS 4, REMAINDER 0)"}) + void sharesOverridesForPartitionChildren(String bound) throws JSQLParserException { + for (String options : new String[] {"", " WITH OPTIONS"}) { + CreateTable table = parse("CREATE TABLE child PARTITION OF public.parent (a" + options + + " DEFAULT 7 NOT NULL, b, CHECK (a > 0)) " + bound); + assertNotNull(table.getPartitionBound()); + assertNull(table.getColumnDefinitions().get(0).getColDataType()); + assertNull(table.getColumns()); + roundTrip(table); + List values = new ArrayList<>(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + values.add(value.getValue()); + return getBuilder().append(value.getValue()); + } + }; + StringBuilder out = new StringBuilder(); + table.accept(new StatementDeParser(expressions, new SelectDeParser(), out)); + assertEquals(table.toString(), out.toString()); + assertEquals(1, values.stream().filter(v -> v == 7).count()); + } + } + + @Test + void singleBareOverrideAndOrdinaryTypeParametersRemainDistinct() throws JSQLParserException { + assertNotNull(parse("CREATE TABLE t OF row_type (a)").getColumnDefinitions()); + assertNotNull( + parse("CREATE TABLE child PARTITION OF parent (a) DEFAULT").getColumnDefinitions()); + assertEquals("numeric (10, 2)", parse("CREATE TABLE t (a numeric(10, 2))") + .getColumnDefinitions().get(0).getColDataType().toString()); + assertEquals(List.of("a"), parse("CREATE TABLE t (a) AS SELECT 1").getColumns()); + assertEquals(2, CCJSqlParserUtil + .parseStatements("CREATE TABLE t OF row_type (a DEFAULT 1); SELECT 1").size()); + } + + private static CreateTable parse(String sql) throws JSQLParserException { + return (CreateTable) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(CreateTable table) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + table.accept(new StatementDeParser(out)); + assertEquals(table.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableInheritanceTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableInheritanceTest.java new file mode 100644 index 0000000000..d6d697b737 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableInheritanceTest.java @@ -0,0 +1,78 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.create; + +import static org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlTableInheritanceTest { + @ParameterizedTest + @ValueSource(strings = {"parent", "public.parent", "public.parent, other.parent2", + "\"Odd.Schema\".\"Parent.Name\""}) + void modelsAndVisitsParentTables(String parents) throws JSQLParserException { + for (String definition : new String[] {"()", "(extra INT)", "(LIKE source, extra INT)"}) { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE child " + definition + " INHERITS (" + parents + + ") WITH (fillfactor = 80)"); + List
inherited = table.getInherits(); + assertEquals(parents.split(", ").length, inherited.size()); + assertEquals(parents.split(", ")[0], inherited.get(0).getFullyQualifiedName()); + List
visited = new ArrayList<>(); + TableDefinitionTraversal.visit(table, e -> { + }, visited::add); + for (Table parent : inherited) { + assertTrue(visited.stream().anyMatch(t -> t == parent)); + assertTrue(new TablesNamesFinder().getTables(table) + .contains(parent.getFullyQualifiedName())); + } + roundTrip(table); + inherited.set(0, new Table("replacement")); + assertTrue(table.toString().contains("INHERITS (replacement")); + roundTrip(table); + } + } + + @Test + void preservesEmptyDefinitionsAndCanRemoveInheritance() throws JSQLParserException { + CreateTable table = + (CreateTable) CCJSqlParserUtil.parse("CREATE TABLE child () INHERITS (parent)"); + assertNotNull(table.getTableElements()); + assertTrue(table.getTableElements().isEmpty()); + table.setInherits(null); + assertEquals("CREATE TABLE child ()", table.toString()); + roundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(table + "; SELECT 1").size()); + } + + @ParameterizedTest + @ValueSource(strings = {"()", "(parent,)", "(parent AS p)", "(parent + 1)"}) + void rejectsMalformedParentLists(String parents) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("CREATE TABLE child () INHERITS " + parents)); + } + + private static void roundTrip(CreateTable table) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + table.accept(new StatementDeParser(out)); + assertEquals(table.toString(), out.toString()); + assertEquals(out.toString(), CCJSqlParserUtil.parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableOptionsTest.java new file mode 100644 index 0000000000..22376ee52b --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableOptionsTest.java @@ -0,0 +1,219 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +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.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.statement.create.table.TableOption.Kind; +import net.sf.jsqlparser.statement.create.table.TableOption.OnCommitAction; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlTableOptionsTest { + private static final Dialect[] DIALECTS = {Dialect.POSTGRESQL, null}; + + @ParameterizedTest + @CsvSource(value = {"PRESERVE_ROWS|ON COMMIT PRESERVE ROWS", + "DELETE_ROWS|ON COMMIT DELETE ROWS", "DROP|ON COMMIT DROP"}, delimiter = '|') + void onCommitIsOneTypedOption(OnCommitAction action, String clause) + throws JSQLParserException { + String sql = "CREATE TEMPORARY TABLE t (a INT) " + clause; + for (Dialect dialect : DIALECTS) { + CreateTable table = parse(sql, dialect); + assertEquals(1, table.getTableOptions().size()); + TableOption option = table.getTableOption(Kind.ON_COMMIT).orElseThrow(); + assertEquals(action, option.getOnCommitAction()); + assertEquals("ON COMMIT", option.getName()); + assertEquals(action.toString(), option.getValue()); + assertEquals(Arrays.asList(clause.split(" ")), option.getTokens()); + assertEquals(Arrays.asList(clause.split(" ")), table.getTableOptionsStrings()); + assertRoundTrip(table, sql, dialect); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLE t (a INT) USING heap", + "CREATE TABLE t USING heap AS SELECT 1 AS a", + "CREATE TABLE t (a) USING heap WITH (fillfactor = 70) TABLESPACE ts AS SELECT 1 WITH NO DATA"}) + void accessMethodIsOneTypedOption(String sql) throws JSQLParserException { + for (Dialect dialect : DIALECTS) { + CreateTable table = parse(sql, dialect); + TableOption option = table.getTableOptions().get(0); + assertEquals(Kind.ACCESS_METHOD, option.getKind()); + assertEquals("USING", option.getName()); + assertEquals("heap", option.getValue()); + assertEquals(List.of("USING", "heap"), option.getTokens()); + assertEquals(List.of("USING", "heap"), table.getTableOptionsStrings().subList(0, 2)); + assertEquals(sql.contains(" AS "), table.getSelect() != null); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(table)); + assertRoundTrip(table, sql, dialect); + } + } + + @Test + void postgreSqlClausesKeepTheirOrderAndLegacyTokens() throws JSQLParserException { + String sql = "CREATE TEMP TABLE t (a INT) USING heap WITH (fillfactor = 70) " + + "ON COMMIT DELETE ROWS TABLESPACE ts"; + for (Dialect dialect : DIALECTS) { + CreateTable table = parse(sql, dialect); + assertEquals( + List.of(Kind.ACCESS_METHOD, Kind.STORAGE_PARAMETERS, Kind.ON_COMMIT, + Kind.TABLESPACE), + table.getTableOptions().stream().map(TableOption::getKind) + .collect(Collectors.toList())); + assertEquals(List.of("USING", "heap", "WITH", "(fillfactor = 70)", "ON", "COMMIT", + "DELETE", "ROWS", "TABLESPACE", "ts"), table.getTableOptionsStrings()); + assertRoundTrip(table, sql, dialect); + } + + String query = "CREATE TEMP TABLE t (a) USING heap ON COMMIT DROP AS SELECT 1 WITH NO DATA"; + for (Dialect dialect : DIALECTS) { + CreateTable table = parse(query, dialect); + assertEquals(List.of(Kind.ACCESS_METHOD, Kind.ON_COMMIT), + table.getTableOptions().stream().map(TableOption::getKind) + .collect(Collectors.toList())); + assertEquals(Boolean.FALSE, table.getWithData()); + assertRoundTrip(table, query, dialect); + } + } + + @Test + void accessMethodFollowsPostgreSqlPartitionKey() throws JSQLParserException { + String sql = "CREATE TABLE t (a INT) PARTITION BY RANGE (a) USING heap TABLESPACE ts"; + CreateTable table = parse(sql, Dialect.POSTGRESQL); + assertTrue(table.isTableOptionsAfterPartition()); + assertEquals("heap", + table.getTableOption(Kind.ACCESS_METHOD).orElseThrow().getValue()); + assertRoundTrip(table, sql, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @CsvSource(value = {"PRESERVE_DEFINITION|ON COMMIT PRESERVE DEFINITION", + "DROP_DEFINITION|ON COMMIT DROP DEFINITION"}, delimiter = '|') + void oraclePrivateTemporaryTablesUseTheSameOption(OnCommitAction action, String clause) + throws JSQLParserException { + String sql = "CREATE PRIVATE TEMPORARY TABLE ora$ptt_t (a INT) " + clause; + for (Dialect dialect : new Dialect[] {Dialect.ORACLE, null}) { + CreateTable table = parse(sql, dialect); + assertEquals(1, table.getTableOptions().size()); + assertEquals(action, table.getTableOptions().get(0).getOnCommitAction()); + assertEquals(Arrays.asList(clause.split(" ")), table.getTableOptionsStrings()); + assertRoundTrip(table, sql, dialect); + } + } + + @Test + void usingIndexTablespaceRemainsRaw() throws JSQLParserException { + String sql = "CREATE TABLE t (a INT) USING INDEX TABLESPACE ts"; + CreateTable table = parse(sql, null); + assertEquals(Kind.OTHER, table.getTableOptions().get(0).getKind()); + assertEquals(List.of("USING INDEX", "TABLESPACE ts"), table.getTableOptionsStrings()); + assertRoundTrip(table, sql, null); + } + + @ParameterizedTest + @ValueSource(strings = {"ON COMMIT", "ON COMMIT DELETE", "ON COMMIT PRESERVE", + "ON COMMIT ROWS", "ON COMMIT DELETE DEFINITION"}) + void rejectsIncompleteOnCommitActions(String clause) { + for (Dialect dialect : DIALECTS) { + assertThrows(JSQLParserException.class, + () -> parse("CREATE TEMPORARY TABLE t (a INT) " + clause, dialect)); + } + } + + @Test + void editsReplaceTheOptionContents() throws JSQLParserException { + CreateTable table = parse("CREATE TEMP TABLE t (a INT) USING heap ON COMMIT DROP", + Dialect.POSTGRESQL); + TableOption accessMethod = table.getTableOption(Kind.ACCESS_METHOD).orElseThrow(); + TableOption onCommit = table.getTableOption(Kind.ON_COMMIT).orElseThrow(); + + accessMethod.setValue("columnar"); + onCommit.setOnCommitAction(OnCommitAction.PRESERVE_ROWS); + assertEquals(List.of("USING", "columnar", "ON", "COMMIT", "PRESERVE", "ROWS"), + table.getTableOptionsStrings()); + assertThrows(UnsupportedOperationException.class, () -> onCommit.getTokens().add("x")); + assertRoundTrip(table, + "CREATE TEMP TABLE t (a INT) USING columnar ON COMMIT PRESERVE ROWS", + Dialect.POSTGRESQL); + + // Raw tokens discard the action; a structured setter never restores it. + onCommit.setTokens(new ArrayList<>(List.of("ON", "COMMIT", "DROP"))); + assertEquals(Kind.OTHER, onCommit.getKind()); + assertNull(onCommit.getOnCommitAction()); + assertTrue(table.getTableOption(Kind.ON_COMMIT).isEmpty()); + onCommit.setOnCommitAction(OnCommitAction.DELETE_ROWS); + assertEquals(Kind.ON_COMMIT, onCommit.getKind()); + assertEquals("ON COMMIT DELETE ROWS", onCommit.toString()); + onCommit.setKind(Kind.COMMENT); + assertNull(onCommit.getOnCommitAction()); + onCommit.setOnCommitAction(OnCommitAction.DROP); + onCommit.setValue("DROP"); + assertNull(onCommit.getOnCommitAction()); + assertEquals("ON COMMIT DROP", onCommit.toString()); + + onCommit.setOnCommitAction(null); + assertEquals(Kind.ON_COMMIT, onCommit.getKind()); + assertNull(onCommit.getValue()); + assertEquals(List.of("ON", "COMMIT"), onCommit.getTokens()); + assertEquals("ON COMMIT", onCommit.toString()); + } + + @Test + void factoriesBuildOptionsWithoutParsing() throws JSQLParserException { + CreateTable table = new CreateTable().withTable(new Table("t")) + .withColumnDefinitions(List.of(new ColumnDefinition("a", new ColDataType("INT")))) + .withTableOptions(new ArrayList<>(List.of(TableOption.accessMethod("heap"), + TableOption.onCommit(OnCommitAction.DROP)))); + table.setCreateOptionsStrings(List.of("TEMPORARY")); + assertEquals(Kind.ON_COMMIT, table.getTableOptions().get(1).getKind()); + assertRoundTrip(table, "CREATE TEMPORARY TABLE t (a INT) USING heap ON COMMIT DROP", + Dialect.POSTGRESQL); + } + + private static CreateTable parse(String sql, Dialect dialect) throws JSQLParserException { + return (CreateTable) (dialect == null + ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect))); + } + + private static void assertRoundTrip(CreateTable table, String expected, Dialect dialect) + throws JSQLParserException { + assertEquals(expected, table.toString()); + StringBuilder deparsed = new StringBuilder(); + table.accept(new StatementDeParser(deparsed), null); + assertEquals(expected, deparsed.toString()); + CreateTable reparsed = parse(deparsed.toString(), dialect); + assertEquals(expected, reparsed.toString()); + assertEquals(table.getTableOptionsStrings(), reparsed.getTableOptionsStrings()); + assertEquals(2, (dialect == null + ? CCJSqlParserUtil.parseStatements(expected + "; SELECT 1") + : CCJSqlParserUtil.parseStatements(expected + "; SELECT 1", + parser -> parser.withDialect(dialect))) + .size()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableQueryOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableQueryOptionsTest.java new file mode 100644 index 0000000000..0ab8093a6f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTableQueryOptionsTest.java @@ -0,0 +1,125 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.KeyElement; +import static org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.*; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +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 PostgreSqlTableQueryOptionsTest { + @ParameterizedTest + @ValueSource(strings = { + "CREATE LOCAL TEMP TABLE t (id INT)", + "CREATE LOCAL TEMPORARY TABLE t(a INT) ON COMMIT DROP", + "CREATE LOCAL TEMP TABLE t AS SELECT 1 AS id WITH NO DATA", + "CREATE LOCAL TEMPORARY TABLE t (id INT)", + "CREATE LOCAL TEMPORARY TABLE t AS SELECT 1 AS id WITH NO DATA", + "CREATE TABLE t (id INT, s TEXT) WITH (toast.autovacuum_enabled=false)", + "CREATE TABLE t(a TEXT) WITH(toast.autovacuum_enabled=false,fillfactor=80)", + "CREATE TABLE t (id INT, s TEXT) WITHOUT OIDS", + "CREATE TABLE t(a INT) WITHOUT OIDS", + "CREATE TABLE t (id INT, s TEXT) PARTITION BY RANGE(id int4_ops)", + "CREATE TABLE t(a INT,label TEXT) PARTITION BY RANGE(a int4_ops)", + "CREATE TABLE t(a INT,label TEXT) PARTITION BY RANGE(label COLLATE \"C\" text_ops)", + "CREATE TABLE t AS EXECUTE prepared_source(1)", + "CREATE TABLE t AS EXECUTE q(1) WITH NO DATA"}) + void auditedFormsRoundTrip(String sql) throws JSQLParserException { + CreateTable table = parse(sql); + assertRoundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void storageParametersStayMutableAndVisibleToVisitors() throws JSQLParserException { + CreateTable table = parse("CREATE TABLE t (id INT) WITH (toast.autovacuum_enabled=false)"); + TableOption option = + table.getTableOption(TableOption.Kind.STORAGE_PARAMETERS).orElseThrow(); + IndexOption parameter = option.getStorageParameters().get(0); + assertEquals("toast.autovacuum_enabled", parameter.getName()); + parameter.setName("fillfactor"); + parameter.setValue(new LongValue(70)); + assertEquals("CREATE TABLE t (id INT) WITH (fillfactor = 70)", table.toString()); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(table, visited::add, ignored -> { + }); + assertEquals(List.of(parameter.getValue()), visited); + assertRoundTrip(table); + } + + @Test + void partitionAttributesShareIndexKeyNodes() throws JSQLParserException { + CreateTable table = parse( + "CREATE TABLE t (id INT, other_id INT) PARTITION BY RANGE (id pg_catalog.int4_ops)"); + KeyElement key = table.getPartitioning().getKeyColumns().get(0); + assertEquals("pg_catalog.int4_ops", key.getOperatorClass()); + table.getPartitioning().getKeyColumns().set(0, + new KeyElement("other_id").withOperatorClass("int4_ops")); + assertTrue(table.toString().endsWith("PARTITION BY RANGE (other_id int4_ops)")); + assertRoundTrip(table); + } + + @Test + void partitionPrecedesTableOptions() throws JSQLParserException { + CreateTable table = + parse("CREATE TABLE t (id INT) PARTITION BY RANGE (id int4_ops) WITHOUT OIDS"); + assertTrue(table.isTableOptionsAfterPartition()); + assertEquals("CREATE TABLE t (id INT) PARTITION BY RANGE (id int4_ops) WITHOUT OIDS", + table.toString()); + assertRoundTrip(table); + } + + @Test + void executeSourceAndArgumentsRemainStructured() throws JSQLParserException { + CreateTable table = parse("CREATE TABLE t AS EXECUTE q(1) WITH NO DATA"); + assertNull(table.getSelect()); + assertEquals("q", table.getExecute().getName()); + table.getExecute().setName("q2"); + table.getExecute().getExprList().set(0, new LongValue(2)); + assertEquals("CREATE TABLE t AS EXECUTE q2 (2) WITH NO DATA", table.toString()); + assertRoundTrip(table); + table.setSelect( + (net.sf.jsqlparser.statement.select.Select) CCJSqlParserUtil.parse("SELECT 1"), + false); + assertNull(table.getExecute()); + } + + @Test + void indexOnlyOrderingIsRejectedForPartitionKeys() { + assertThrows(JSQLParserException.class, + () -> parse("CREATE TABLE t (id INT) PARTITION BY RANGE (id DESC)")); + assertThrows(JSQLParserException.class, + () -> parse("CREATE TABLE t (id INT) PARTITION BY RANGE (id NULLS FIRST)")); + } + + private static CreateTable parse(String sql) throws JSQLParserException { + return (CreateTable) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void assertRoundTrip(CreateTable table) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + table.accept(new StatementDeParser(sql), null); + assertEquals(table.toString(), sql.toString()); + assertEquals(table.toString(), parse(sql.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTemporalConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTemporalConstraintTest.java new file mode 100644 index 0000000000..9842a0d603 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTemporalConstraintTest.java @@ -0,0 +1,173 @@ +/*- + * #%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 net.sf.jsqlparser.statement.create.table.KeyElement; +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +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.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.KeyColumnSource; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlTemporalConstraintTest { + @ParameterizedTest + @ValueSource(strings = {"PRIMARY KEY", "UNIQUE", "UNIQUE NULLS NOT DISTINCT"}) + void modelsTemporalKeysAcrossCreateAndAlter(String kind) throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (id INT, valid DATERANGE, ", + "ALTER TABLE t ADD ")) { + Statement statement = parse(prefix + "CONSTRAINT temporal_key " + kind + + " (id, valid WITHOUT OVERLAPS) INCLUDE (label) DEFERRABLE INITIALLY DEFERRED" + + (prefix.startsWith("CREATE") ? ", label TEXT)" : ", ADD COLUMN extra INT")); + KeyConstraint index = (KeyConstraint) index(statement); + assertEquals("temporal_key", index.getName()); + assertTrue(statement.toString().contains("CONSTRAINT temporal_key")); + assertEquals(2, index.getColumns().size()); + assertFalse(index.getColumns().get(0).isWithoutOverlaps()); + KeyElement last = index.getColumns().get(1); + assertTrue(last.isWithoutOverlaps()); + assertEquals("valid", last.getColumnName()); + assertNull(last.getOperatorClass()); + assertEquals(List.of("label"), index.getIncludeColumns()); + roundTrip(statement); + last.setWithoutOverlaps(false); + assertFalse(statement.toString().contains("WITHOUT OVERLAPS")); + roundTrip(statement); + } + } + + @ParameterizedTest + @ValueSource(strings = {"", " (id, PERIOD valid)", " (id, PERIOD \"Valid Range\")"}) + void sharesReferencingAndReferencedPeriodLists(String referenced) throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (id INT, valid DATERANGE, ", + "ALTER TABLE t ADD ")) { + Statement statement = + parse(prefix + "FOREIGN KEY (id, PERIOD valid) REFERENCES app.parent" + + referenced + " ON DELETE NO ACTION ON UPDATE NO ACTION" + + (prefix.startsWith("CREATE") ? ")" : ", ADD COLUMN extra INT")); + ForeignKeyConstraint foreign = (ForeignKeyConstraint) index(statement); + assertFalse(foreign.getColumns().get(0).isPeriod()); + assertTrue(foreign.getColumns().get(1).isPeriod()); + assertEquals("valid", foreign.getColumns().get(1).getColumnName()); + assertEquals(!referenced.isEmpty(), foreign.getReference().isUsingPeriod()); + assertEquals(Set.of("t", "app.parent"), new TablesNamesFinder().getTables(statement)); + roundTrip(statement); + foreign.getColumns().get(1).setPeriod(false); + foreign.getReference().setUsingPeriod(false); + assertFalse(statement.toString().contains("PERIOD")); + roundTrip(statement); + } + } + + @Test + void preservesPeriodAndEnforcementTogether() throws JSQLParserException { + for (String prefix : List.of("CREATE TABLE t (id INT, valid DATERANGE, ", + "ALTER TABLE t ADD ")) { + Statement statement = parse(prefix + + "CONSTRAINT fk FOREIGN KEY (id, PERIOD valid) REFERENCES p(id, PERIOD valid)" + + " ON DELETE NO ACTION NOT ENFORCED" + + (prefix.startsWith("CREATE") ? ")" : "")); + ForeignKeyConstraint foreign = (ForeignKeyConstraint) index(statement); + assertTrue(foreign.getColumns().get(1).isPeriod()); + assertTrue(foreign.getReference().isUsingPeriod()); + assertEquals(false, foreign.getConstraintAttributes().getEnforced()); + assertNull(foreign.getReference().getConstraintAttributes()); + roundTrip(statement); + foreign.getConstraintAttributes().setEnforced(true); + assertTrue(statement.toString().endsWith(prefix.startsWith("CREATE") + ? " ENFORCED)" + : " ENFORCED")); + roundTrip(statement); + } + } + + @Test + void retainsQuotedAndUnquotedIdentifiersAndLegacyProjections() throws JSQLParserException { + CreateTable table = (CreateTable) parse("CREATE TABLE t (id INT, period DATERANGE, " + + "FOREIGN KEY (id, period) REFERENCES p(id, period))"); + ForeignKeyConstraint foreign = (ForeignKeyConstraint) index(table); + assertFalse(foreign.getColumns().get(1).isPeriod()); + assertFalse(foreign.getReference().isUsingPeriod()); + roundTrip(table); + table = (CreateTable) parse("CREATE TABLE t (id INT, \"PERIOD\" DATERANGE, " + + "FOREIGN KEY (id, PERIOD \"PERIOD\") REFERENCES p(id, PERIOD \"PERIOD\"))"); + foreign = (ForeignKeyConstraint) index(table); + assertEquals(List.of("id", "\"PERIOD\""), foreign.getReferencedColumnNames()); + foreign.getReferencedColumnNames().set(1, "replacement"); + assertTrue(table.toString().contains("PERIOD replacement")); + roundTrip(table); + assertEquals(2, CCJSqlParserUtil.parseStatements(table + "; SELECT 1", + p -> p.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void preservesNamedUniqueConstraintsWithAndWithoutTemporalKeys() throws JSQLParserException { + Statement ordinary = parse("ALTER TABLE t ADD CONSTRAINT uq UNIQUE (id)"); + assertEquals("uq", index(ordinary).getName()); + assertEquals("ALTER TABLE t ADD CONSTRAINT uq UNIQUE (id)", ordinary.toString()); + roundTrip(ordinary); + Statement temporal = parse("ALTER TABLE t ADD CONSTRAINT uq " + + "UNIQUE (id, valid WITHOUT OVERLAPS)"); + assertEquals("uq", index(temporal).getName()); + assertTrue(((KeyColumnSource) index(temporal)).getColumns().get(1).isWithoutOverlaps()); + roundTrip(temporal); + } + + @Test + void keepsOrdinaryIndexesAndCrossDialectForeignKeys() throws JSQLParserException { + String mysql = "CREATE TABLE t (id INT, FOREIGN KEY (id) REFERENCES p (id))"; + assertNotNull(CCJSqlParserUtil.parse(mysql)); + assertEquals("valid WITHOUT OVERLAPS", + new KeyElement("valid").withWithoutOverlaps(true).toString()); + assertEquals("PERIOD valid", new KeyElement("valid").withPeriod(true).toString()); + assertThrows(JSQLParserException.class, + () -> parse("CREATE INDEX ix ON t (id, valid WITHOUT OVERLAPS)")); + } + + @ParameterizedTest + @ValueSource(strings = {"UNIQUE (valid WITHOUT OVERLAPS, id)", + "PRIMARY KEY (id, valid WITHOUT)", + "UNIQUE (id, valid WITHOUT OVERLAPS WITHOUT OVERLAPS)", + "FOREIGN KEY (PERIOD valid, id) REFERENCES p(id, valid)", + "FOREIGN KEY (id, PERIOD valid) REFERENCES p(PERIOD valid, id)"}) + void rejectsMalformedTemporalMarkers(String constraint) { + assertThrows(JSQLParserException.class, + () -> parse("CREATE TABLE t (id INT, valid DATERANGE, " + constraint + ")")); + } + + private static NamedConstraint index(Statement statement) { + return statement instanceof CreateTable + ? ((CreateTable) statement).getTableConstraints().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getConstraint(); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTextSearchConfigurationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTextSearchConfigurationTest.java new file mode 100644 index 0000000000..2a2f358cfb --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTextSearchConfigurationTest.java @@ -0,0 +1,98 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration; +import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration; +import net.sf.jsqlparser.util.TablesNamesFinder; +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; + +class PostgreSqlTextSearchConfigurationTest { + @ParameterizedTest + @ValueSource(strings = {"CREATE TEXT SEARCH CONFIGURATION cfg (COPY=pg_catalog.english)", + "CREATE TEXT SEARCH CONFIGURATION cfg (COPY='english')", + "CREATE TEXT SEARCH CONFIGURATION app.cfg (PARSER=pg_catalog.default)", + "ALTER TEXT SEARCH CONFIGURATION cfg ADD MAPPING FOR word WITH simple", + "ALTER TEXT SEARCH CONFIGURATION cfg ADD MAPPING FOR word,asciiword WITH pg_catalog.simple,english_stem", + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING FOR word,asciiword WITH simple", + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING REPLACE english_stem WITH simple", + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING FOR word REPLACE english_stem WITH pg_catalog.simple", + "ALTER TEXT SEARCH CONFIGURATION cfg DROP MAPPING FOR word,asciiword", + "ALTER TEXT SEARCH CONFIGURATION cfg DROP MAPPING IF EXISTS FOR word", + "ALTER TEXT SEARCH CONFIGURATION app.cfg RENAME TO new_cfg", + "ALTER TEXT SEARCH CONFIGURATION cfg OWNER TO CURRENT_USER", + "ALTER TEXT SEARCH CONFIGURATION cfg SET SCHEMA app"}) + void configurationAndMappingActionsRoundTrip(String sql) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertTrue(statement instanceof CreateTextSearchConfiguration + || statement instanceof AlterTextSearchConfiguration); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + roundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty()); + } + + @Test + void sourceAndMappingsCanBeChangedWithoutRawTokens() throws JSQLParserException { + CreateTextSearchConfiguration create = + (CreateTextSearchConfiguration) CCJSqlParserUtil.parse( + "CREATE TEXT SEARCH CONFIGURATION cfg(COPY=pg_catalog.english)"); + assertEquals(CreateTextSearchConfiguration.SourceKind.COPY, create.getSourceKind()); + create.setSourceKind(CreateTextSearchConfiguration.SourceKind.PARSER); + create.setSourceName("pg_catalog.default"); + assertEquals("CREATE TEXT SEARCH CONFIGURATION cfg (PARSER = pg_catalog.default)", + create.toString()); + roundTrip(create); + AlterTextSearchConfiguration alter = (AlterTextSearchConfiguration) CCJSqlParserUtil.parse( + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING FOR word REPLACE english_stem WITH simple"); + assertEquals(AlterTextSearchConfiguration.Action.REPLACE_MAPPING, alter.getAction()); + assertEquals(List.of("word"), alter.getTokenTypes()); + assertEquals("english_stem", alter.getOldDictionary()); + alter.setNewDictionary("pg_catalog.simple"); + alter.getTokenTypes().add("asciiword"); + roundTrip(alter); + alter.getTokenTypes().clear(); + assertEquals( + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING REPLACE english_stem WITH pg_catalog.simple", + alter.toString()); + roundTrip(alter); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TEXT SEARCH CONFIGURATION cfg()", + "CREATE TEXT SEARCH CONFIGURATION cfg(COPY=)", + "CREATE TEXT SEARCH CONFIGURATION cfg(COPY=english,PARSER=default)", + "CREATE OR REPLACE TEXT SEARCH CONFIGURATION cfg(COPY=english)", + "ALTER TEXT SEARCH CONFIGURATION cfg ADD MAPPING WITH simple", + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING WITH simple", + "ALTER TEXT SEARCH CONFIGURATION cfg DROP MAPPING FOR", + "ALTER TEXT SEARCH CONFIGURATION cfg ALTER MAPPING REPLACE simple WITH", + "ALTER TEXT SEARCH CONFIGURATION cfg ADD MAPPING FOR word WITH simple,"}) + void rejectsIncompleteOrIncompatibleForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTypeDdlTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTypeDdlTest.java index 37e2c26676..4db9310631 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTypeDdlTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlTypeDdlTest.java @@ -26,6 +26,7 @@ import net.sf.jsqlparser.expression.StringValue; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.CascadeBehavior; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.StatementVisitorAdapter; import net.sf.jsqlparser.statement.StmtFeature; @@ -124,7 +125,7 @@ void testTypeAlterations() throws Exception { assertThat(attributes.getAttributeChanges()).hasSize(2); assertThat(attributes.getAttributeChanges().get(1).isIfExists()).isTrue(); assertThat(attributes.getAttributeChanges().get(1).getBehavior()) - .isEqualTo(AlterType.Behavior.CASCADE); + .isEqualTo(CascadeBehavior.CASCADE); } @Test diff --git a/src/test/java/net/sf/jsqlparser/statement/create/SqlRoutineBodyBoundaryTest.java b/src/test/java/net/sf/jsqlparser/statement/create/SqlRoutineBodyBoundaryTest.java new file mode 100644 index 0000000000..1461d64894 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/SqlRoutineBodyBoundaryTest.java @@ -0,0 +1,193 @@ +/*- + * #%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 org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserConstants; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.CreateFunctionalStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.create.function.CreateFunction; +import net.sf.jsqlparser.statement.create.procedure.CreateProcedure; +import net.sf.jsqlparser.statement.select.PlainSelect; +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.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class SqlRoutineBodyBoundaryTest { + private static final String FOLLOWING = "SELECT 2718 AS after_routine"; + + static Stream sqlRoutines() { + Stream postgres = Stream.of( + "CREATE FUNCTION f(x int) RETURNS int LANGUAGE SQL IMMUTABLE RETURN x + 1", + "CREATE FUNCTION f(x int) RETURNS int LANGUAGE SQL RETURN " + + "CASE WHEN x IS NULL THEN 0 ELSE x END + CASE WHEN x > 0 THEN 1 ELSE 0 END", + "CREATE FUNCTION f(x int) RETURNS boolean LANGUAGE SQL RETURN x IS NULL", + "CREATE FUNCTION f(x begin) RETURNS begin LANGUAGE SQL RETURN x", + "CREATE FUNCTION f(x public.begin) RETURNS public.begin LANGUAGE SQL RETURN x", + "CREATE FUNCTION f() RETURNS int LANGUAGE SQL BEGIN ATOMIC " + + "SELECT t.end, t.case FROM t; SELECT 42; END", + "CREATE FUNCTION f() RETURNS int LANGUAGE SQL RETURN (SELECT max(id) FROM hidden)", + "CREATE FUNCTION f(x int) RETURNS int LANGUAGE SQL BEGIN ATOMIC " + + "SELECT CASE WHEN x > 0 THEN CASE WHEN x > 1 THEN x ELSE 1 END ELSE 0 END; " + + "SELECT x + 1; END", + "CREATE PROCEDURE p() LANGUAGE SQL BEGIN ATOMIC " + + "INSERT INTO t VALUES (CASE WHEN true THEN 1 ELSE 0 END); SELECT 2; END", + "CREATE FUNCTION f() RETURNS int SET search_path TO public " + + "AS 'SELECT 1;' LANGUAGE sql") + .map(sql -> Arguments.of(Dialect.POSTGRESQL, sql)); + Stream mysql = Stream.of( + "CREATE PROCEDURE p() SELECT 1", + "CREATE PROCEDURE p() SET @result = IF(1, 2, 3)", + "CREATE PROCEDURE p() INSERT INTO t VALUES (1)", + "CREATE FUNCTION f(x int) RETURNS int DETERMINISTIC RETURN x + 1", + "CREATE FUNCTION f(x int) RETURNS int RETURN CASE WHEN x IS NULL THEN 0 ELSE x END", + "CREATE PROCEDURE p() BEGIN SELECT CASE WHEN 1 THEN IF(1, 2, 3) ELSE 0 END; " + + "BEGIN SELECT 'END; SELECT 0;'; END; SELECT 2; END", + "CREATE PROCEDURE p() BEGIN IF (1) THEN SELECT 1; " + + "ELSEIF 2 THEN SELECT 2; ELSE SELECT 3; END IF; SELECT 4; END", + "CREATE PROCEDURE p() BEGIN WHILE (1) DO IF (1) THEN SELECT 1; END IF; " + + "END WHILE; SELECT 2; END", + "CREATE PROCEDURE p() BEGIN REPEAT SELECT 1; " + + "UNTIL CASE WHEN 1 THEN true ELSE false END END REPEAT; SELECT 2; END", + "CREATE PROCEDURE p() BEGIN CASE 1 WHEN 1 THEN IF (1) THEN SELECT 1; END IF; " + + "ELSE SELECT 2; END CASE; SELECT 3; END", + "CREATE PROCEDURE p() outer_block: BEGIN outer_loop: LOOP " + + "IF (1) THEN LEAVE outer_loop; END IF; END LOOP outer_loop; " + + "SELECT 2; END outer_block", + "CREATE PROCEDURE p() IF (1) THEN SELECT 1; ELSE SELECT 2; END IF", + "CREATE PROCEDURE p() CASE WHEN 1 THEN SELECT 1; ELSE SELECT 2; END CASE", + "CREATE PROCEDURE p() BEGIN DECLARE CONTINUE HANDLER FOR NOT FOUND " + + "BEGIN SET @done = 1; END; SELECT 2; END", + "CREATE PROCEDURE p() BEGIN DECLARE CONTINUE HANDLER FOR NOT FOUND " + + "IF @done IS NULL THEN SET @done = 1; END IF; SELECT 2; END", + "CREATE PROCEDURE p() BEGIN DECLARE CONTINUE HANDLER FOR NOT FOUND " + + "SET @done = IF(1, 2, 3); SELECT 2; END") + .map(sql -> Arguments.of(Dialect.MYSQL, sql)); + return Stream.concat(postgres, mysql); + } + + @ParameterizedTest + @MethodSource("sqlRoutines") + void preservesRoutineBodyAndFollowingStatement(Dialect dialect, String sql) throws Exception { + String script = sql + "; " + FOLLOWING + ";"; + Statements statements = parse(script, dialect); + assertRoutineAndFollowing(statements, sql); + assertRoutineAndFollowing(parser(script, dialect).Statements(), sql); + assertRoutineAndFollowing(CCJSqlParserUtil.parseStatements(script), sql); + assertRoutineAndFollowing(parse(statements.toString(), dialect), sql); + + StringBuilder deparsed = new StringBuilder(); + for (Statement statement : statements) { + statement.accept(new StatementDeParser(deparsed), null); + deparsed.append(";\n"); + } + assertRoutineAndFollowing(parse(deparsed.toString(), dialect), sql); + assertThat(parse(deparsed.toString(), dialect).get(0).toString()) + .isEqualTo(statements.get(0).toString()); + assertThat(CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)).toString()) + .isEqualTo(statements.get(0).toString().replaceFirst(";$", "")); + } + + @Test + void directSingleStatementParserLeavesFollowingStatementAvailable() throws Exception { + // walking a script statement by statement is SingleStatement()'s job; Statement() reads + // the input as exactly one statement and rejects whatever is left over + CCJSqlParser parser = parser("CREATE FUNCTION f() RETURNS int LANGUAGE SQL RETURN 1; " + + FOLLOWING + ";", Dialect.POSTGRESQL); + assertThat(parser.SingleStatement()).isInstanceOf(CreateFunction.class); + assertThat(parser.getNextToken().kind).isEqualTo(CCJSqlParserConstants.ST_SEMICOLON); + assertThat(parser.getToken(1).kind).isEqualTo(CCJSqlParserConstants.K_SELECT); + assertThat(parser.SingleStatement().toString()).isEqualTo(FOLLOWING); + assertThat(parser.getNextToken().kind).isEqualTo(CCJSqlParserConstants.ST_SEMICOLON); + assertThat(parser.getToken(1).kind).isEqualTo(CCJSqlParserConstants.EOF); + } + + @Test + void keepsAdjacentRoutinesAndDdlSeparate() throws Exception { + String sql = "CREATE FUNCTION f() RETURNS int LANGUAGE SQL RETURN 1;" + + "CREATE PROCEDURE p() LANGUAGE SQL BEGIN ATOMIC SELECT CASE WHEN true " + + "THEN 1 ELSE 0 END; SELECT 2; END; CREATE TABLE after_routines(id int);" + + FOLLOWING + ";"; + Statements statements = parse(sql, Dialect.POSTGRESQL); + assertThat(statements).hasSize(4); + assertThat(statements.get(0)).isExactlyInstanceOf(CreateFunction.class); + assertThat(statements.get(1)).isExactlyInstanceOf(CreateProcedure.class); + assertThat(statements.get(2).toString()).isEqualTo("CREATE TABLE after_routines (id int)"); + assertThat(statements.get(3).toString()).isEqualTo(FOLLOWING); + assertThat(parse(statements.toString(), Dialect.POSTGRESQL)).hasSize(4); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE FUNCTION f() RETURNS int LANGUAGE SQL BEGIN ATOMIC SELECT 1;", + "CREATE FUNCTION f() RETURNS int LANGUAGE SQL BEGIN ATOMIC " + + "SELECT CASE WHEN true THEN 1 END; SELECT 2;", + "CREATE PROCEDURE p() BEGIN IF 1 THEN SELECT 1; END", + "CREATE PROCEDURE p() BEGIN SELECT CASE WHEN 1 THEN 2; END" + }) + void rejectsUnterminatedBlocks(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parseStatements(sql)); + } + + @Test + void reportsInvalidFollowingStatementInsteadOfCapturingIt() { + assertThrows(JSQLParserException.class, + () -> parse("CREATE FUNCTION f() RETURNS int LANGUAGE SQL RETURN 1; SELEC 2;", + Dialect.POSTGRESQL)); + assertThrows(JSQLParserException.class, + () -> parse("CREATE PROCEDURE p() SELECT 1; SELEC 2;", Dialect.MYSQL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE PROCEDURE p AS v int; BEGIN NULL; END", + "CREATE FUNCTION f(x int) RETURN int IS v int; " + + "BEGIN IF x > 0 THEN RETURN x; END IF; RETURN 0; END", + "CREATE PROCEDURE p AS BEGIN FOR i IN 1 .. 3 LOOP NULL; END LOOP; NULL; END", + "CREATE PROCEDURE p AS BEGIN WHILE 1 = 1 LOOP NULL; END LOOP; NULL; END" + }) + void retainsOracleDeclarationAndBlockBoundaries(String sql) throws Exception { + assertRoutineAndFollowing(CCJSqlParserUtil.parseStatements(sql + "; " + FOLLOWING + ";"), + sql); + } + + private static CCJSqlParser parser(String sql, Dialect dialect) { + return CCJSqlParserUtil.newParser(sql).withDialect(dialect) + .withUnsupportedStatements(false); + } + + private static Statements parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parseStatements(sql, + parser -> parser.withDialect(dialect).withUnsupportedStatements(false)); + } + + private static void assertRoutineAndFollowing(Statements statements, String source) { + assertThat(statements).hasSize(2); + assertThat(statements.get(0)).isInstanceOf(CreateFunctionalStatement.class); + CreateFunctionalStatement routine = (CreateFunctionalStatement) statements.get(0); + assertThat(routine.getFunctionDeclarationParts()).doesNotContain("after_routine", "2718"); + // The entire body must survive, including statements after an inner END. + assertThat(routine.toString().replaceAll("\\s+", "").replaceFirst(";$", "")) + .isEqualTo(source.replaceAll("\\s+", "")); + assertThat(statements.get(1)).isExactlyInstanceOf(PlainSelect.class); + assertThat(statements.get(1).toString()).isEqualTo(FOLLOWING); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/SqlServerConstraintClusteringTest.java b/src/test/java/net/sf/jsqlparser/statement/create/SqlServerConstraintClusteringTest.java index ab16a8e1a3..fdea22d6bf 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/SqlServerConstraintClusteringTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/SqlServerConstraintClusteringTest.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.create; +import net.sf.jsqlparser.statement.create.table.IndexOptions; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -20,8 +21,7 @@ import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.alter.Alter; import net.sf.jsqlparser.statement.create.table.CreateTable; -import net.sf.jsqlparser.statement.create.table.Index; -import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import net.sf.jsqlparser.test.TestUtils; import net.sf.jsqlparser.util.deparser.StatementDeParser; import org.junit.jupiter.api.Test; @@ -29,10 +29,10 @@ import org.junit.jupiter.params.provider.EnumSource; class SqlServerConstraintClusteringTest { - private static Index constraint(Statement statement) { - return statement instanceof CreateTable - ? ((CreateTable) statement).getIndexes().get(0) - : ((Alter) statement).getAlterExpressions().get(0).getIndex(); + private static KeyConstraint constraint(Statement statement) { + return (KeyConstraint) (statement instanceof CreateTable + ? ((CreateTable) statement).getTableConstraints().get(0) + : ((Alter) statement).getAlterExpressions().get(0).getConstraint()); } private static Statement parse(String sql) throws JSQLParserException { @@ -44,16 +44,16 @@ void parsesSakilaReproducerIssue1589() throws Exception { String sql = "CREATE TABLE actor (actor_id INT NOT NULL IDENTITY, " + "first_name VARCHAR (45) NOT NULL, last_name VARCHAR (45) NOT NULL, " + "last_update DATETIME NOT NULL, PRIMARY KEY NONCLUSTERED (actor_id))"; - Index index = constraint(TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, + KeyConstraint index = constraint(TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SQLSERVER))); - assertEquals(Index.Clustering.NONCLUSTERED, index.getClustering()); - assertNull(((NamedConstraint) index).getIndexName()); + assertEquals(IndexOptions.Clustering.NONCLUSTERED, index.getClustering()); + assertNull(((KeyConstraint) index).getIndexName()); assertEquals(List.of("actor_id"), index.getColumnsNames()); } @ParameterizedTest - @EnumSource(Index.Clustering.class) - void sharesClusteringAcrossCreateAndAlter(Index.Clustering clustering) throws Exception { + @EnumSource(IndexOptions.Clustering.class) + void sharesClusteringAcrossCreateAndAlter(IndexOptions.Clustering clustering) throws Exception { for (String type : List.of("PRIMARY KEY", "UNIQUE")) { for (String name : List.of("", "CONSTRAINT [key name] ")) { String definition = name + type + " " + clustering + " (id)"; @@ -61,12 +61,12 @@ void sharesClusteringAcrossCreateAndAlter(Index.Clustering clustering) throws Ex "ALTER TABLE t ADD " + definition)) { Statement statement = TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SQLSERVER)); - Index index = constraint(statement); + KeyConstraint index = constraint(statement); assertEquals(clustering, index.getClustering(), sql); assertEquals(type, index.getType()); assertEquals(name.isEmpty() ? null : "[key name]", index.getName()); - if (index instanceof NamedConstraint) { - assertNull(((NamedConstraint) index).getIndexName()); + if (index instanceof KeyConstraint) { + assertNull(((KeyConstraint) index).getIndexName()); } StringBuilder output = new StringBuilder(); statement.accept(new StatementDeParser(output), null); @@ -82,19 +82,19 @@ void sharesClusteringAcrossCreateAndAlter(Index.Clustering clustering) throws Ex void preservesNamesOutsideSqlServerAndQuotedNames() throws Exception { for (String type : List.of("PRIMARY KEY", "UNIQUE")) { String sql = "CREATE TABLE t (id INT, " + type + " NONCLUSTERED (id))"; - NamedConstraint defaultIndex = - (NamedConstraint) constraint(CCJSqlParserUtil.parse(sql)); + KeyConstraint defaultIndex = + (KeyConstraint) constraint(CCJSqlParserUtil.parse(sql)); assertNull(defaultIndex.getClustering()); assertEquals("NONCLUSTERED", defaultIndex.getIndexName()); for (Dialect dialect : Dialect.values()) { if (dialect != Dialect.SQLSERVER) { - NamedConstraint index = (NamedConstraint) constraint(CCJSqlParserUtil.parse(sql, + KeyConstraint index = (KeyConstraint) constraint(CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect))); assertNull(index.getClustering(), dialect.name()); assertEquals("NONCLUSTERED", index.getIndexName()); } } - NamedConstraint quoted = (NamedConstraint) constraint( + KeyConstraint quoted = (KeyConstraint) constraint( parse("CREATE TABLE t (id INT, " + type + " [NONCLUSTERED] (id))")); assertNull(quoted.getClustering()); assertEquals("[NONCLUSTERED]", quoted.getIndexName()); @@ -104,14 +104,15 @@ void preservesNamesOutsideSqlServerAndQuotedNames() throws Exception { @Test void supportsMutationAndLeavesOmittedOptionUnspecified() throws Exception { Statement statement = parse("CREATE TABLE t (id INT, PRIMARY KEY (id))"); - Index index = constraint(statement); + KeyConstraint index = constraint(statement); assertNull(index.getClustering()); - index.setClustering(Index.Clustering.CLUSTERED); + index.setClustering(IndexOptions.Clustering.CLUSTERED); TestUtils.assertDeparse(statement, "CREATE TABLE t (id INT, PRIMARY KEY CLUSTERED (id))"); index.setClustering(null); TestUtils.assertDeparse(statement, "CREATE TABLE t (id INT, PRIMARY KEY (id))"); - NamedConstraint built = new NamedConstraint().withType("UNIQUE").withName("uq_t") - .withClustering(Index.Clustering.NONCLUSTERED).withColumnsNames(List.of("id")); + KeyConstraint built = new KeyConstraint().withType("UNIQUE").withName("uq_t") + .withClustering(IndexOptions.Clustering.NONCLUSTERED) + .withColumnsNames(List.of("id")); assertEquals("CONSTRAINT uq_t UNIQUE NONCLUSTERED (id)", built.toString()); } @@ -119,7 +120,7 @@ void supportsMutationAndLeavesOmittedOptionUnspecified() throws Exception { void keepsFollowingConstraintsAndRejectsDuplicateModifiers() throws Exception { CreateTable table = (CreateTable) parse("CREATE TABLE t (id INT, other_id INT, " + "PRIMARY KEY NONCLUSTERED (id), UNIQUE (other_id))"); - assertNull(table.getIndexes().get(1).getClustering()); + assertNull(((KeyConstraint) table.getTableConstraints().get(1)).getClustering()); for (String sql : List.of( "CREATE TABLE t (id INT, PRIMARY KEY NONCLUSTERED CLUSTERED (id))", "ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY CLUSTERED NONCLUSTERED (id)", diff --git a/src/test/java/net/sf/jsqlparser/statement/create/SqlServerCreateTableSeparatorTest.java b/src/test/java/net/sf/jsqlparser/statement/create/SqlServerCreateTableSeparatorTest.java index bf850f0209..96db28af94 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/SqlServerCreateTableSeparatorTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/SqlServerCreateTableSeparatorTest.java @@ -9,12 +9,13 @@ */ package net.sf.jsqlparser.statement.create; +import net.sf.jsqlparser.statement.create.table.IndexOptions; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.create.table.ColumnDefinition; import net.sf.jsqlparser.statement.create.table.CreateTable; -import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import net.sf.jsqlparser.util.deparser.StatementDeParser; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -52,9 +53,10 @@ void preservesSakilaColumnsAndNonclusteredPrimaryKey() throws Exception { + "title VARCHAR(255) NOT NULL, description TEXT, PRIMARY KEY NONCLUSTERED (film_id),)"); assertEquals(4, table.getTableElements().size()); assertInstanceOf(ColumnDefinition.class, table.getTableElements().get(0)); - Index primaryKey = assertInstanceOf(Index.class, table.getTableElements().get(3)); + KeyConstraint primaryKey = + assertInstanceOf(KeyConstraint.class, table.getTableElements().get(3)); assertEquals("PRIMARY KEY", primaryKey.getType()); - assertEquals(Index.Clustering.NONCLUSTERED, primaryKey.getClustering()); + assertEquals(IndexOptions.Clustering.NONCLUSTERED, primaryKey.getClustering()); assertEquals(3, table.getColumnDefinitions().size()); table.getColumnDefinitions().get(0).setColumnName("renamed_id"); assertTrue(table.toString().contains("renamed_id INT")); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/StatementIdentifierTest.java b/src/test/java/net/sf/jsqlparser/statement/create/StatementIdentifierTest.java new file mode 100644 index 0000000000..161ff7f4ea --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/StatementIdentifierTest.java @@ -0,0 +1,49 @@ +/*- + * #%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 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.statement.Statement; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +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.EnumSource; + +class StatementIdentifierTest { + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"POSTGRESQL", "MYSQL"}) + void statementIsAnUnquotedIdentifier(Dialect dialect) throws JSQLParserException { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE statement (statement INT)", p -> p.withDialect(dialect)); + assertEquals("statement", table.getTable().getName()); + assertEquals("statement", table.getColumnDefinitions().get(0).getColumnName()); + for (String sql : new String[] {"SELECT statement FROM statement", + "ALTER TABLE statement ADD COLUMN statement INT"}) { + Statement statement = CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + StringBuilder buffer = new StringBuilder(); + statement.accept(new StatementDeParser(buffer), null); + assertEquals(sql, buffer.toString()); + } + } + + @Test + void triggerOrientationRemainsAKeyword() throws JSQLParserException { + CreateTrigger trigger = (CreateTrigger) CCJSqlParserUtil.parse( + "CREATE TRIGGER tr AFTER INSERT ON t FOR EACH STATEMENT EXECUTE FUNCTION f()", + p -> p.withDialect(Dialect.POSTGRESQL)); + assertEquals(CreateTrigger.Orientation.STATEMENT, trigger.getOrientation()); + assertTrue(trigger.toString().contains("FOR EACH STATEMENT")); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/TableElementMutationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/TableElementMutationTest.java index 08240a80c2..d00bdf0b29 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/TableElementMutationTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/TableElementMutationTest.java @@ -34,7 +34,7 @@ class TableElementMutationTest { void legacyListEditsUpdateOrderedElements() throws JSQLParserException { CreateTable table = parse(); table.getColumnDefinitions().remove(1); - table.getIndexes().clear(); + table.getTableConstraints().clear(); table.getColumnDefinitions().add(0, column("first")); table.getColumnDefinitions().set(1, column("last")); assertSql(table, "CREATE TABLE t (LIKE parent INCLUDING DEFAULTS, first INT, last INT)"); @@ -52,7 +52,7 @@ void orderedListEditsRemainVisibleThroughExistingViews() throws JSQLParserExcept assertEquals(2, columns.size()); columns.clear(); assertEquals(2, table.getTableElements().size()); - assertEquals(1, table.getIndexes().size()); + assertEquals(1, table.getTableConstraints().size()); assertEquals(1, table.getTableElements(LikeClause.class).size()); } @@ -64,7 +64,7 @@ void replacingColumnsPreservesOtherElementsAndTheirPositions() throws JSQLParser table.setColumnDefinitions(Collections.singletonList(column("replacement"))); assertSql(table, "CREATE TABLE t (LIKE parent INCLUDING DEFAULTS, replacement INT, " + "CONSTRAINT c CHECK (a > 0))"); - table.setIndexes(null); + table.setTableConstraints(null); table.setColumnDefinitions(null); assertSql(table, "CREATE TABLE t (LIKE parent INCLUDING DEFAULTS)"); } @@ -75,8 +75,8 @@ void fluentAddersCanPassTheirOwnViewsToSetters() throws JSQLParserException { table.addColumnDefinitions(column("extra")); assertEquals(3, table.getColumnDefinitions().size()); assertEquals(1, table.getTableElements(LikeClause.class).size()); - table.setIndexes(table.getIndexes()); - assertEquals(1, table.getIndexes().size()); + table.setTableConstraints(table.getTableConstraints()); + assertEquals(1, table.getTableConstraints().size()); assertSql(table, SQL.substring(0, SQL.length() - 1) + ", extra INT)"); } @@ -94,7 +94,7 @@ void clearingAllElementsKeepsBothRenderersConsistent() throws JSQLParserExceptio table.getTableElements().clear(); assertSql(table, "CREATE TABLE t ()"); assertTrue(table.getColumnDefinitions().isEmpty()); - assertTrue(table.getIndexes().isEmpty()); + assertTrue(table.getTableConstraints().isEmpty()); } private static CreateTable parse() throws JSQLParserException { diff --git a/src/test/java/net/sf/jsqlparser/statement/create/TableOptionStateTest.java b/src/test/java/net/sf/jsqlparser/statement/create/TableOptionStateTest.java new file mode 100644 index 0000000000..4261e65b11 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/TableOptionStateTest.java @@ -0,0 +1,231 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.function.Consumer; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpressionTableOption; +import net.sf.jsqlparser.statement.alter.AlterOperation; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignTableOptions; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.util.TableDefinitionTraversal; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.MethodSource; + +class TableOptionStateTest { + @Test + void replacingTokensUpdatesCreateLookupAndAlterOperation() throws JSQLParserException { + CreateTable create = create("ENGINE=InnoDB", Dialect.MYSQL); + Alter alter = (Alter) parse("ALTER TABLE t ENGINE=InnoDB", Dialect.MYSQL); + AlterExpressionTableOption action = + (AlterExpressionTableOption) alter.getAlterExpressions().get(0); + for (TableOption option : List.of(create.getTableOptions().get(0), + action.getStructuredTableOption())) { + List raw = new ArrayList<>(List.of("ROW_FORMAT", "=", "DYNAMIC")); + option.setTokens(raw); + assertSame(raw, option.getTokens()); + assertEquals(TableOption.Kind.OTHER, option.getKind()); + assertNull(option.getName()); + assertNull(option.getValue()); + assertFalse(option.isUseEquals()); + raw.set(2, "COMPRESSED"); + assertEquals("ROW_FORMAT = COMPRESSED", option.toString()); + } + assertTrue(create.getTableOption(TableOption.Kind.ENGINE).isEmpty()); + assertTrue(create.getTableOption(TableOption.Kind.ROW_FORMAT).isEmpty()); + assertSame(create.getTableOptions().get(0), + create.getTableOption(TableOption.Kind.OTHER).orElseThrow()); + assertEquals(AlterOperation.SET_TABLE_OPTION, action.getOperation()); + assertNull(action.getEngineOption()); + assertRoundTrip(create, Dialect.MYSQL); + assertRoundTrip(alter, Dialect.MYSQL); + } + + @ParameterizedTest + @MethodSource("structuredSetters") + void eachStructuredSetterLeavesOpaqueTokens(Consumer setter) { + TableOption option = TableOption.raw("CUSTOM", "opaque text"); + setter.accept(option); + assertFalse(option.getTokens().contains("CUSTOM")); + assertFalse(option.getTokens().contains("opaque text")); + } + + private static Stream> structuredSetters() { + return Stream.of(option -> option.setKind(TableOption.Kind.COMMENT), + option -> option.setName("COMMENT"), option -> option.setValue("'new'"), + option -> option.setUseEquals(true), + option -> option.setTablespaceStorage(ColumnOption.Storage.MEMORY)); + } + + @Test + void rawToStructuredEditsAreOrderIndependentAndDoNotRestoreOldValues() + throws JSQLParserException { + CreateTable create = create("ENGINE=InnoDB", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + option.setTokens(List.of("ROW_FORMAT", "=", "DYNAMIC")); + option.setValue("'new'"); + assertEquals("'new'", option.getValue()); + assertNull(option.getName()); + assertEquals(TableOption.Kind.OTHER, option.getKind()); + option.withName("COMMENT").withUseEquals(true).withKind(TableOption.Kind.COMMENT); + assertEquals(List.of("COMMENT", "=", "'new'"), option.getTokens()); + assertThrows(UnsupportedOperationException.class, () -> option.getTokens().add("ignored")); + assertEquals("CREATE TABLE t (id INT) COMMENT = 'new'", create.toString()); + assertRoundTrip(create, Dialect.MYSQL); + option.setTokens(null); + assertEquals("COMMENT = 'new'", option.toString()); + option.setTokens(List.of("ENGINE", "CSV")); + option.setTokens(null); + assertEquals(TableOption.Kind.OTHER, option.getKind()); + assertNull(option.getName()); + assertNull(option.getValue()); + assertTrue(option.getTokens().isEmpty()); + } + + @Test + void unionReplacementStopsVisitingDetachedSourcesAndPreservesEmptyLists() + throws JSQLParserException { + CreateTable create = create("UNION=(old_source)", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + List
oldSources = option.getUnionTables(); + option.setTokens(List.of("UNION", "=", "(raw_source)")); + assertNull(option.getUnionTables()); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(create)); + oldSources.get(0).setName("detached"); + assertEquals("UNION = (raw_source)", option.toString()); + assertRoundTrip(create, Dialect.MYSQL); + option.setUnionTables(new ArrayList<>()); + assertEquals("()", option.getValue()); + assertEquals("UNION ()", option.toString()); + option.getUnionTables().add(new Table("new_source")); + assertEquals(Set.of("t", "new_source"), new TablesNamesFinder().getTables(create)); + assertRoundTrip(create, Dialect.MYSQL); + option.setUnionTables(null); + assertNull(option.getUnionTables()); + assertNull(option.getValue()); + assertEquals("UNION", option.toString()); + } + + @Test + void storageSelectionResetsScalarSpellingAndKeepsExpressionRendering() + throws JSQLParserException { + CreateTable create = create("ENGINE=InnoDB", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + LongValue fillFactor = new LongValue(70); + List parameters = new ArrayList<>( + List.of(new IndexOption("fillfactor", fillFactor, true))); + option.setStorageParameters(parameters); + assertSame(parameters, option.getStorageParameters()); + assertFalse(option.isUseEquals()); + assertEquals("WITH (fillfactor = 70)", option.toString()); + assertRoundTrip(create, Dialect.POSTGRESQL); + StringBuilder customized = new StringBuilder(); + option.appendTo(customized, expression -> customized.append("80")); + assertEquals("WITH (fillfactor = 80)", customized.toString()); + List visited = new ArrayList<>(); + TableDefinitionTraversal.visit(option, visited::add, ignored -> { + }); + assertEquals(List.of(fillFactor), visited); + option.setTokens(List.of("WITH", "(fillfactor = 90)")); + assertNull(option.getStorageParameters()); + visited.clear(); + TableDefinitionTraversal.visit(option, visited::add, ignored -> { + }); + assertTrue(visited.isEmpty()); + assertRoundTrip(create, Dialect.POSTGRESQL); + option.setStorageParameters(null); + assertEquals(TableOption.Kind.STORAGE_PARAMETERS, option.getKind()); + assertNull(option.getValue()); + assertEquals("WITH", option.toString()); + } + + @Test + void foreignServerReplacementUpdatesCreateProjectionAndDoesNotReviveOldOptions() + throws JSQLParserException { + CreateTable create = (CreateTable) parse( + "CREATE FOREIGN TABLE t(id INT) SERVER old_srv OPTIONS(table_name 'old')", + Dialect.POSTGRESQL); + TableOption option = create.getTableOptions().get(0); + ForeignTableOptions original = option.getForeignTableOptions(); + option.setTokens(List.of("SERVER", "raw_srv")); + assertNull(create.getForeignTableOptions()); + assertNull(option.getForeignTableOptions()); + original.setServer("detached"); + assertRoundTrip(create, Dialect.POSTGRESQL); + ForeignTableOptions replacement = new ForeignTableOptions(); + replacement.setServer("new_srv"); + option.setForeignTableOptions(replacement); + assertSame(replacement, create.getForeignTableOptions()); + assertEquals(TableOption.Kind.FOREIGN_SERVER, option.getKind()); + assertEquals(List.of("SERVER", "new_srv"), option.getTokens()); + assertRoundTrip(create, Dialect.POSTGRESQL); + option.setValue("scalar_srv"); + assertNull(create.getForeignTableOptions()); + assertEquals("SERVER scalar_srv", option.toString()); + assertRoundTrip(create, Dialect.POSTGRESQL); + } + + @Test + void tablespaceStorageDoesNotLeakAcrossRawAndStructuredReplacements() + throws JSQLParserException { + CreateTable create = create("TABLESPACE=old_ts STORAGE DISK", Dialect.MYSQL); + TableOption option = create.getTableOptions().get(0); + option.setTokens(List.of("TABLESPACE", "raw_ts")); + assertNull(option.getTablespaceStorage()); + option.setTablespaceStorage(ColumnOption.Storage.MEMORY); + assertEquals(TableOption.Kind.TABLESPACE, option.getKind()); + assertEquals("TABLESPACE", option.getName()); + assertNull(option.getValue()); + option.setValue("new_ts"); + assertEquals(List.of("TABLESPACE", "new_ts", "STORAGE", "MEMORY"), option.getTokens()); + assertRoundTrip(create, Dialect.MYSQL); + option.setUnionTables(List.of(new Table("source"))); + assertNull(option.getTablespaceStorage()); + assertRoundTrip(create, Dialect.MYSQL); + assertThrows(IllegalArgumentException.class, + () -> option.setTablespaceStorage(ColumnOption.Storage.PLAIN)); + assertEquals("UNION (source)", option.toString()); + } + + private static CreateTable create(String options, Dialect dialect) throws JSQLParserException { + return (CreateTable) parse("CREATE TABLE t(id INT) " + options, dialect); + } + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static void assertRoundTrip(Statement statement, Dialect dialect) + throws JSQLParserException { + StringBuilder out = new StringBuilder(); + statement.accept(new StatementDeParser(out)); + assertEquals(statement.toString(), out.toString()); + assertEquals(out.toString(), parse(out.toString(), dialect).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/TablespaceStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/create/TablespaceStatementTest.java new file mode 100644 index 0000000000..6182bdef06 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/TablespaceStatementTest.java @@ -0,0 +1,368 @@ +/*- + * #%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.assertDeparse; +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.EnumSet; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterTablespace; +import net.sf.jsqlparser.statement.alter.AlterTablespaceMove; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.statement.create.tablespace.CreateTablespace; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class TablespaceStatementTest { + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + /** Parses with the dialect, compares both renderers with the input and reparses the output. */ + private static T assertRoundTrip(String sql, Dialect dialect, + Class type) throws JSQLParserException { + Statement statement = + assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(dialect)); + assertInstanceOf(type, statement); + Statement reparsed = parse(statement.toString(), dialect); + assertInstanceOf(type, reparsed); + assertEquals(statement.toString(), reparsed.toString()); + return type.cast(statement); + } + + private static List kinds(List options) { + return options.stream().map(TableOption::getKind).collect(Collectors.toList()); + } + + private static List names(List parameters) { + return parameters.stream().map(IndexOption::getName).collect(Collectors.toList()); + } + + @Test + void mysqlCreateTablespaceWithDataFileAndEngine() throws JSQLParserException { + CreateTablespace statement = assertRoundTrip( + "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' ENGINE=InnoDB", Dialect.MYSQL, + CreateTablespace.class); + + assertEquals("ts1", statement.getName()); + assertFalse(statement.isUndo()); + assertEquals("ts1.ibd", statement.getDataFile().getValue()); + TableOption engine = statement.getOption(TableOption.Kind.ENGINE).orElseThrow(); + assertEquals("InnoDB", engine.getValue()); + assertTrue(engine.isUseEquals()); + assertNull(statement.getOwner()); + assertNull(statement.getLocation()); + assertNull(statement.getParameters()); + assertEquals("CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' ENGINE = InnoDB", + statement.toString()); + } + + @Test + void mysqlOptionsKeepSourceOrderAndReuseTableOptionModels() throws JSQLParserException { + CreateTablespace statement = (CreateTablespace) parse( + "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' AUTOEXTEND_SIZE 4M, " + + "FILE_BLOCK_SIZE = 8192 ENCRYPTION 'Y', ENGINE_ATTRIBUTE = '{}' " + + "ENGINE InnoDB", + Dialect.MYSQL); + + assertEquals(List.of(TableOption.Kind.AUTOEXTEND_SIZE, TableOption.Kind.FILE_BLOCK_SIZE, + TableOption.Kind.ENCRYPTION, TableOption.Kind.ENGINE_ATTRIBUTE, + TableOption.Kind.ENGINE), kinds(statement.getOptions())); + assertEquals(List.of("4M", "8192", "'Y'", "'{}'", "InnoDB"), statement.getOptions() + .stream().map(TableOption::getValue).collect(Collectors.toList())); + assertEquals(List.of(false, true, false, true, false), statement.getOptions().stream() + .map(TableOption::isUseEquals).collect(Collectors.toList())); + // commas between options are optional and not retained + String expected = "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' AUTOEXTEND_SIZE 4M " + + "FILE_BLOCK_SIZE = 8192 ENCRYPTION 'Y' ENGINE_ATTRIBUTE = '{}' ENGINE InnoDB"; + assertEquals(expected, statement.toString()); + assertDeparse(statement, expected); + assertRoundTrip(expected, Dialect.MYSQL, CreateTablespace.class); + + CreateTable table = (CreateTable) parse( + "CREATE TABLE t (a INT) AUTOEXTEND_SIZE 4M ENCRYPTION 'Y' ENGINE InnoDB", + Dialect.MYSQL); + for (TableOption tableOption : table.getTableOptions()) { + TableOption tablespaceOption = + statement.getOption(tableOption.getKind()).orElseThrow(); + assertEquals(tableOption.getTokens(), tablespaceOption.getTokens()); + } + } + + @Test + void mysqlDataFileAndOptionsAreOptional() throws JSQLParserException { + CreateTablespace statement = + assertRoundTrip("CREATE TABLESPACE ts1", Dialect.MYSQL, CreateTablespace.class); + assertNull(statement.getDataFile()); + assertTrue(statement.getOptions().isEmpty()); + + statement = assertRoundTrip("CREATE TABLESPACE `ts 1` ENGINE = 'InnoDB'", Dialect.MYSQL, + CreateTablespace.class); + assertEquals("`ts 1`", statement.getName()); + assertNull(statement.getDataFile()); + assertEquals("'InnoDB'", statement.getOption(TableOption.Kind.ENGINE).orElseThrow() + .getValue()); + } + + @Test + void mysqlUndoTablespaces() throws JSQLParserException { + CreateTablespace create = assertRoundTrip( + "CREATE UNDO TABLESPACE u1 ADD DATAFILE 'u1.ibu' ENGINE = InnoDB", Dialect.MYSQL, + CreateTablespace.class); + assertTrue(create.isUndo()); + assertEquals("u1", create.getName()); + assertEquals("u1.ibu", create.getDataFile().getValue()); + assertEquals(List.of(TableOption.Kind.ENGINE), kinds(create.getOptions())); + + AlterTablespace inactive = assertRoundTrip("ALTER UNDO TABLESPACE u1 SET INACTIVE", + Dialect.MYSQL, AlterTablespace.class); + assertTrue(inactive.isUndo()); + assertEquals(AlterTablespace.Action.SET_STATE, inactive.getAction()); + assertEquals(AlterTablespace.State.INACTIVE, inactive.getState()); + assertTrue(inactive.getOptions().isEmpty()); + + AlterTablespace active = assertRoundTrip( + "ALTER UNDO TABLESPACE u1 SET ACTIVE ENGINE = InnoDB", Dialect.MYSQL, + AlterTablespace.class); + assertEquals(AlterTablespace.State.ACTIVE, active.getState()); + assertEquals(List.of(TableOption.Kind.ENGINE), kinds(active.getOptions())); + } + + @Test + void mysqlAlterTablespace() throws JSQLParserException { + AlterTablespace rename = assertRoundTrip("ALTER TABLESPACE ts1 RENAME TO ts2", + Dialect.MYSQL, AlterTablespace.class); + assertEquals("ts1", rename.getName()); + assertFalse(rename.isUndo()); + assertEquals(AlterTablespace.Action.RENAME, rename.getAction()); + assertEquals("ts2", rename.getNewName()); + + AlterTablespace options = (AlterTablespace) parse( + "ALTER TABLESPACE ts1 AUTOEXTEND_SIZE = 64M, ENCRYPTION = 'N' ENGINE = InnoDB " + + "ENGINE_ATTRIBUTE '{}'", + Dialect.MYSQL); + assertEquals(AlterTablespace.Action.OPTIONS, options.getAction()); + assertEquals(List.of(TableOption.Kind.AUTOEXTEND_SIZE, TableOption.Kind.ENCRYPTION, + TableOption.Kind.ENGINE, TableOption.Kind.ENGINE_ATTRIBUTE), + kinds(options.getOptions())); + assertEquals("'N'", options.getOption(TableOption.Kind.ENCRYPTION).orElseThrow() + .getValue()); + String expected = "ALTER TABLESPACE ts1 AUTOEXTEND_SIZE = 64M ENCRYPTION = 'N' " + + "ENGINE = InnoDB ENGINE_ATTRIBUTE '{}'"; + assertEquals(expected, options.toString()); + assertDeparse(options, expected); + assertRoundTrip(expected, Dialect.MYSQL, AlterTablespace.class); + } + + @Test + void postgresqlCreateTablespace() throws JSQLParserException { + CreateTablespace statement = assertRoundTrip( + "CREATE TABLESPACE fast OWNER u1 LOCATION '/ssd1/pg' " + + "WITH (random_page_cost = 1.1, effective_io_concurrency = 200)", + Dialect.POSTGRESQL, CreateTablespace.class); + + assertEquals("fast", statement.getName()); + assertEquals("u1", statement.getOwner()); + assertEquals("/ssd1/pg", statement.getLocation().getValue()); + assertEquals(List.of("random_page_cost", "effective_io_concurrency"), + names(statement.getParameters())); + assertEquals("1.1", statement.getParameters().get(0).getValue().toString()); + assertNull(statement.getDataFile()); + assertTrue(statement.getOptions().isEmpty()); + List values = new ArrayList<>(); + statement.visitExpressions(values::add); + assertEquals(2, values.size()); + + statement = assertRoundTrip("CREATE TABLESPACE fast LOCATION '/ssd1/pg'", + Dialect.POSTGRESQL, CreateTablespace.class); + assertNull(statement.getOwner()); + assertNull(statement.getParameters()); + + statement = assertRoundTrip("CREATE TABLESPACE \"Fast\" OWNER CURRENT_USER LOCATION ''", + Dialect.POSTGRESQL, CreateTablespace.class); + assertEquals("CURRENT_USER", statement.getOwner()); + assertEquals("", statement.getLocation().getValue()); + } + + @Test + void postgresqlAlterTablespace() throws JSQLParserException { + AlterTablespace rename = assertRoundTrip("ALTER TABLESPACE fast RENAME TO faster", + Dialect.POSTGRESQL, AlterTablespace.class); + assertEquals(AlterTablespace.Action.RENAME, rename.getAction()); + assertEquals("faster", rename.getNewName()); + + AlterTablespace owner = assertRoundTrip("ALTER TABLESPACE fast OWNER TO SESSION_USER", + Dialect.POSTGRESQL, AlterTablespace.class); + assertEquals(AlterTablespace.Action.OWNER, owner.getAction()); + assertEquals("SESSION_USER", owner.getOwner()); + + AlterTablespace set = assertRoundTrip( + "ALTER TABLESPACE fast SET (random_page_cost = 1.1, seq_page_cost = 2)", + Dialect.POSTGRESQL, AlterTablespace.class); + assertEquals(AlterTablespace.Action.SET_PARAMETERS, set.getAction()); + assertEquals(List.of("random_page_cost", "seq_page_cost"), names(set.getParameters())); + List values = new ArrayList<>(); + set.visitExpressions(values::add); + assertEquals(2, values.size()); + + AlterTablespace reset = assertRoundTrip( + "ALTER TABLESPACE fast RESET (random_page_cost, seq_page_cost)", + Dialect.POSTGRESQL, AlterTablespace.class); + assertEquals(AlterTablespace.Action.RESET_PARAMETERS, reset.getAction()); + assertEquals(List.of("random_page_cost", "seq_page_cost"), reset.getResetParameters()); + values.clear(); + reset.visitExpressions(values::add); + assertTrue(values.isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' ENGINE = InnoDB", + "CREATE UNDO TABLESPACE u1 ADD DATAFILE 'u1.ibu'", + "CREATE TABLESPACE fast OWNER u1 LOCATION '/ssd1/pg' WITH (seq_page_cost = 1)", + "ALTER TABLESPACE ts1 RENAME TO ts2", "ALTER TABLESPACE ts1 ENCRYPTION = 'Y'", + "ALTER UNDO TABLESPACE u1 SET INACTIVE", "ALTER TABLESPACE fast OWNER TO bob", + "ALTER TABLESPACE fast SET (seq_page_cost = 1)", + "ALTER TABLESPACE fast RESET (seq_page_cost)"}) + void statementsOnlyModifySchemaAndKeepScriptBoundaries(String sql) + throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true); + assertTrue(statement instanceof CreateTablespace || statement instanceof AlterTablespace); + StatementFeatures features = statement.getFeatures(); + assertEquals(EnumSet.of(StmtFeature.MODIFIES_SCHEMA), features.getCertain()); + assertTrue(features.getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder().getTables(statement).isEmpty()); + + Statements script = CCJSqlParserUtil.parseStatements(sql + ";\n" + sql + "; SELECT 1"); + assertEquals(3, script.size()); + assertEquals(statement.getClass(), script.get(0).getClass()); + assertEquals(statement.getClass(), script.get(1).getClass()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE UNDO TABLESPACE u1", + "CREATE UNDO TABLESPACE u1 ADD DATAFILE 'u1.ibu' ENCRYPTION = 'Y'", + "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' KEY_BLOCK_SIZE = 8", + "CREATE TABLESPACE ts1 AUTOEXTEND_SIZE = 4X", + "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd', ENGINE = InnoDB", + "CREATE TABLESPACE ts1 ADD DATAFILE ts1", + "CREATE OR REPLACE TABLESPACE ts1", + "CREATE TABLESPACE fast OWNER u1", + "CREATE TABLESPACE fast LOCATION '/ssd1/pg' ENGINE = InnoDB", + "CREATE TABLESPACE fast ADD DATAFILE 'f.ibd' LOCATION '/ssd1/pg'", + "ALTER TABLESPACE ts1 FILE_BLOCK_SIZE = 8K", + "ALTER UNDO TABLESPACE u1 SET ACTIVE ENCRYPTION = 'Y'"}) + void rejectsFormsOutsideTheStatementDefinitions(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void postgresqlParameterValuesRequireEquals() { + assertThrows(JSQLParserException.class, () -> parse( + "CREATE TABLESPACE fast LOCATION '/ssd1/pg' WITH (random_page_cost 1.1)", + Dialect.POSTGRESQL)); + assertThrows(JSQLParserException.class, + () -> parse("ALTER TABLESPACE fast SET (random_page_cost 1.1)", + Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER TABLESPACE users ADD DATAFILE '/u01/users02.dbf' SIZE 100M AUTOEXTEND ON", + "ALTER TABLESPACE users OFFLINE", "ALTER TABLESPACE users READ ONLY", + "ALTER TABLESPACE users ENCRYPTION ONLINE USING 'AES256' ENCRYPT", + "ALTER TABLESPACE ts1 ADD DATAFILE 'ts1_2.dat' INITIAL_SIZE = 1M", + "ALTER TABLESPACE ts1 ENGINE = NDB WAIT", + "ALTER TABLESPACE ts1 RENAME TO ts2 ENGINE = InnoDB", + "ALTER UNDO TABLESPACE u1 RENAME TO u2"}) + void otherAlterTablespaceFormsRemainUnsupportedStatements(String sql) + throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertInstanceOf(UnsupportedStatement.class, statement); + assertEquals(sql, statement.toString()); + + Statements script = CCJSqlParserUtil.parseStatements( + sql + ";\nALTER TABLESPACE ts1 RENAME TO ts2;"); + assertInstanceOf(UnsupportedStatement.class, script.get(0)); + assertInstanceOf(AlterTablespace.class, script.get(1)); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE ALL IN TABLESPACE slow SET TABLESPACE fast", + "ALTER INDEX ALL IN TABLESPACE slow OWNED BY alice SET TABLESPACE fast NOWAIT", + "ALTER MATERIALIZED VIEW ALL IN TABLESPACE slow SET TABLESPACE fast"}) + void bulkTablespaceMovesRemainSeparate(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.POSTGRESQL, AlterTablespaceMove.class); + } + + @Test + void clauseWordsRemainIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("CREATE TABLE t (undo INT, location INT, datafile INT, " + + "inactive INT, file_block_size INT, owner INT)"); + CreateTablespace create = assertRoundTrip("CREATE TABLESPACE undo ADD DATAFILE 'u.ibd'", + Dialect.MYSQL, CreateTablespace.class); + assertEquals("undo", create.getName()); + assertFalse(create.isUndo()); + AlterTablespace alter = assertRoundTrip("ALTER TABLESPACE location RENAME TO owner", + Dialect.POSTGRESQL, AlterTablespace.class); + assertEquals("location", alter.getName()); + assertEquals("owner", alter.getNewName()); + } + + @Test + void buildsAndDeparses() { + CreateTablespace create = new CreateTablespace(); + create.setName("fast"); + create.setOwner("bob"); + create.setLocation(new StringValue("/data")); + create.setParameters(List.of(new IndexOption("seq_page_cost", new LongValue(2), true))); + String expected = "CREATE TABLESPACE fast OWNER bob LOCATION '/data' " + + "WITH (seq_page_cost = 2)"; + assertEquals(expected, create.toString()); + assertDeparse(create, expected); + + AlterTablespace alter = new AlterTablespace(); + alter.setUndo(true); + alter.setName("u1"); + alter.setAction(AlterTablespace.Action.SET_STATE); + alter.setState(AlterTablespace.State.INACTIVE); + alter.addOptions(new TableOption(TableOption.Kind.ENGINE, "ENGINE", "InnoDB", true)); + expected = "ALTER UNDO TABLESPACE u1 SET INACTIVE ENGINE = InnoDB"; + assertEquals(expected, alter.toString()); + assertDeparse(alter, expected); + + alter.setAction(null); + assertThrows(IllegalStateException.class, alter::toString); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/database/CreateDatabaseTest.java b/src/test/java/net/sf/jsqlparser/statement/create/database/CreateDatabaseTest.java index 20f7db0ee4..edeb7861cb 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/database/CreateDatabaseTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/database/CreateDatabaseTest.java @@ -10,17 +10,29 @@ package net.sf.jsqlparser.statement.create.database; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; import static net.sf.jsqlparser.test.TestUtils.assertDeparse; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; 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.Arrays; +import java.util.List; +import java.util.function.Consumer; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class CreateDatabaseTest { @@ -79,4 +91,176 @@ void testCreateDatabaseAST() throws JSQLParserException { assertEquals("mydb", createDatabase.getDatabaseName()); assertTrue(createDatabase.hasIfNotExists()); } + + @ParameterizedTest + @ValueSource(strings = {"CREATE DATABASE mydb2", + "CREATE DATABASE db1 DEFAULT CHARSET = utf8mb4", + "CREATE DATABASE db1 CHAR SET utf8mb4 DEFAULT ENCRYPTION = 'N'", + "CREATE DATABASE IF NOT EXISTS db1 CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci"}) + void testMySqlForms(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.MYSQL); + assertRoundTrip(sql, null); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE DATABASE mydb WITH OWNER = app ENCODING = 'UTF8' LC_COLLATE = 'C' " + + "LC_CTYPE = 'C' TEMPLATE = template0 CONNECTION LIMIT = 10", + "CREATE DATABASE mydb OWNER app STRATEGY = file_copy LOCALE 'C' " + + "BUILTIN_LOCALE = 'C.UTF-8' LOCALE_PROVIDER = builtin " + + "COLLATION_VERSION = '1' TABLESPACE = fast ALLOW_CONNECTIONS = true " + + "CONNECTION LIMIT = -1 IS_TEMPLATE false OID = 16384", + "CREATE DATABASE mydb WITH TEMPLATE DEFAULT ENCODING UTF8 LOCALE_PROVIDER icu " + + "ICU_LOCALE 'de-DE' ICU_RULES = '&a < b'"}) + void testPostgreSqlForms(String sql) throws JSQLParserException { + assertRoundTrip(sql, Dialect.POSTGRESQL); + assertRoundTrip(sql, null); + } + + @Test + void testPostgreSqlOptionsAreTyped() throws JSQLParserException { + CreateDatabase createDatabase = parse("CREATE DATABASE mydb WITH OWNER = app " + + "ENCODING = 'UTF8' TEMPLATE template0 CONNECTION LIMIT = -1 IS_TEMPLATE false", + Dialect.POSTGRESQL); + assertTrue(createDatabase.isUseWith()); + List options = createDatabase.getOptions(); + assertEquals(Arrays.asList(DatabaseOption.Kind.OWNER, DatabaseOption.Kind.ENCODING, + DatabaseOption.Kind.TEMPLATE, DatabaseOption.Kind.CONNECTION_LIMIT, + DatabaseOption.Kind.IS_TEMPLATE), + options.stream().map(DatabaseOption::getKind).collect( + java.util.stream.Collectors.toList())); + assertEquals("app", options.get(0).getValue()); + assertTrue(options.get(0).isUseEquals()); + assertEquals("'UTF8'", options.get(1).getValue()); + assertFalse(options.get(2).isUseEquals()); + assertEquals("CONNECTION LIMIT", options.get(3).getName()); + assertEquals("-1", options.get(3).getValue()); + assertEquals("false", options.get(4).getValue()); + + createDatabase.getOption(DatabaseOption.Kind.OWNER).orElseThrow().setValue("CURRENT_USER"); + options.remove(4); + assertEquals("CREATE DATABASE mydb WITH OWNER = CURRENT_USER ENCODING = 'UTF8' " + + "TEMPLATE template0 CONNECTION LIMIT = -1", createDatabase.toString()); + } + + @Test + void testCharsetSpellingIsTyped() throws JSQLParserException { + CreateDatabase createDatabase = + parse("CREATE DATABASE db1 DEFAULT CHARSET = utf8mb4", Dialect.MYSQL); + assertEquals(1, createDatabase.getOptions().size()); + DatabaseOption charset = createDatabase.getOptions().get(0); + assertEquals(DatabaseOption.Kind.CHARACTER_SET, charset.getKind()); + assertEquals("CHARSET", charset.getName()); + assertEquals("utf8mb4", charset.getValue()); + assertTrue(charset.isUseDefault()); + assertTrue(charset.isUseEquals()); + } + + @Test + void testNoEmptyRawOption() throws JSQLParserException { + CreateDatabase createDatabase = parse("CREATE DATABASE mydb2", null); + assertTrue(createDatabase.getOptions().isEmpty()); + assertNull(createDatabase.getDatabaseOptions()); + assertEquals("CREATE DATABASE mydb2", createDatabase.toString()); + + createDatabase = parse("CREATE DATABASE db1 CHARACTER SET utf8mb4", Dialect.MYSQL); + assertEquals(1, createDatabase.getOptions().size()); + assertEquals("CREATE DATABASE db1 CHARACTER SET utf8mb4", createDatabase.toString()); + } + + @Test + void testUnknownOptionTextStaysRaw() throws JSQLParserException { + CreateDatabase createDatabase = + assertInstanceOf(CreateDatabase.class, assertSqlCanBeParsedAndDeparsed( + "CREATE DATABASE mydb WITH OWNER app LOCATION 'x'")); + assertEquals(2, createDatabase.getOptions().size()); + assertEquals(DatabaseOption.Kind.OWNER, createDatabase.getOptions().get(0).getKind()); + DatabaseOption raw = createDatabase.getOptions().get(1); + assertEquals(DatabaseOption.Kind.OTHER, raw.getKind()); + assertEquals(Arrays.asList("LOCATION", "'x'"), raw.getTokens()); + + // WITH is kept with the raw text when no known option follows it. + createDatabase = assertInstanceOf(CreateDatabase.class, + assertSqlCanBeParsedAndDeparsed("CREATE DATABASE mydb WITH LOCATION 'x'")); + assertFalse(createDatabase.isUseWith()); + assertEquals(Arrays.asList("WITH", "LOCATION", "'x'"), + createDatabase.getOptions().get(0).getTokens()); + } + + @Test + void testLegacyDatabaseOptionTokens() throws JSQLParserException { + CreateDatabase createDatabase = parse( + "CREATE DATABASE mydb WITH OWNER = app CONNECTION LIMIT 5", Dialect.POSTGRESQL); + List tokens = createDatabase.getDatabaseOptions(); + assertEquals(Arrays.asList("WITH", "OWNER", "=", "app", "CONNECTION", "LIMIT", "5"), + tokens); + assertThrows(UnsupportedOperationException.class, () -> tokens.add("x")); + + createDatabase.getOptions().get(1).setValue("10"); + assertEquals("10", createDatabase.getDatabaseOptions().get(6)); + + createDatabase.addDatabaseOptions("IS_TEMPLATE", "true"); + assertEquals(DatabaseOption.Kind.OWNER, createDatabase.getOptions().get(0).getKind()); + assertEquals(DatabaseOption.Kind.OTHER, createDatabase.getOptions().get(2).getKind()); + assertEquals("CREATE DATABASE mydb WITH OWNER = app CONNECTION LIMIT 10 IS_TEMPLATE true", + createDatabase.toString()); + + List raw = new ArrayList<>(Arrays.asList("ENCODING", "'UTF8'")); + createDatabase.setDatabaseOptions(raw); + assertFalse(createDatabase.isUseWith()); + assertEquals(DatabaseOption.Kind.OTHER, createDatabase.getOptions().get(0).getKind()); + assertEquals("CREATE DATABASE mydb ENCODING 'UTF8'", createDatabase.toString()); + createDatabase.setDatabaseOptions(null); + assertTrue(createDatabase.getOptions().isEmpty()); + assertEquals("CREATE DATABASE mydb", createDatabase.toString()); + } + + @Test + void testOptionListOwnership() { + List options = new ArrayList<>(); + options.add(new DatabaseOption(DatabaseOption.Kind.OWNER, "OWNER", "app", false, true)); + CreateDatabase createDatabase = + new CreateDatabase().withDatabaseName("mydb").withUseWith(true) + .withOptions(options); + options.clear(); + assertEquals("CREATE DATABASE mydb WITH OWNER = app", createDatabase.toString()); + createDatabase.getOptions().add( + new DatabaseOption(DatabaseOption.Kind.IS_TEMPLATE, "IS_TEMPLATE", "true", false, + false)); + assertEquals("CREATE DATABASE mydb WITH OWNER = app IS_TEMPLATE true", + createDatabase.toString()); + createDatabase.setOptions(createDatabase.getOptions()); + assertEquals(2, createDatabase.getOptions().size()); + createDatabase.setOptions(null); + assertTrue(createDatabase.getOptions().isEmpty()); + } + + @Test + void testValidation() { + validateNoErrors("CREATE DATABASE mydb WITH OWNER = app", 1, DatabaseType.POSTGRESQL); + validateNoErrors("CREATE DATABASE db1 DEFAULT CHARSET = utf8mb4", 1, DatabaseType.MYSQL, + DatabaseType.MARIADB); + } + + /** Parses, deparses and reparses with the dialect, or without one if it is null. */ + private static void assertRoundTrip(String sql, Dialect dialect) throws JSQLParserException { + Consumer consumer = consumer(dialect); + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, consumer); + CreateDatabase createDatabase = assertInstanceOf(CreateDatabase.class, statement); + assertTrue(createDatabase.getOptions().stream() + .noneMatch(option -> option.getKind() == DatabaseOption.Kind.OTHER)); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, CCJSqlParserUtil.parse(deparsed.toString(), consumer).toString()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", consumer).size()); + } + + private static CreateDatabase parse(String sql, Dialect dialect) throws JSQLParserException { + return (CreateDatabase) CCJSqlParserUtil.parse(sql, consumer(dialect)); + } + + private static Consumer consumer(Dialect dialect) { + return dialect == null ? parser -> { + } : parser -> parser.withDialect(dialect); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/event/EventStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/create/event/EventStatementTest.java index 95f406388b..06f10422e4 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/event/EventStatementTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/event/EventStatementTest.java @@ -10,16 +10,33 @@ package net.sf.jsqlparser.statement.create.event; import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static net.sf.jsqlparser.test.TestUtils.buildSqlString; 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.assertTrue; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Consumer; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Block; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.delete.Delete; import net.sf.jsqlparser.statement.truncate.Truncate; import net.sf.jsqlparser.statement.update.Update; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; class EventStatementTest { @@ -92,4 +109,88 @@ void parsesCompletionPolicy() throws JSQLParserException { assertFalse(event.getOnCompletionPreserve()); assertEquals(EventStatus.ENABLE, event.getStatus()); } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE DEFINER = `root`@`localhost` EVENT `e_daily` ON SCHEDULE EVERY 1 DAY " + + "STARTS CURRENT_TIMESTAMP + INTERVAL 6 HOUR ON COMPLETION NOT PRESERVE " + + "ENABLE COMMENT 'Saves total number of sessions then clears the table' " + + "DO BEGIN INSERT INTO site_activity.totals (time, total) " + + "SELECT CURRENT_TIMESTAMP, COUNT(*) FROM site_activity.sessions; " + + "DELETE FROM site_activity.sessions; END", + "CREATE DEFINER = 'admin'@'%' EVENT IF NOT EXISTS ev ON SCHEDULE EVERY 1 HOUR " + + "DO SELECT 1", + "CREATE DEFINER = CURRENT_USER() EVENT ev ON SCHEDULE AT CURRENT_TIMESTAMP " + + "DISABLE ON REPLICA DO SELECT 1", + "CREATE EVENT ev ON SCHEDULE EVERY 1 DAY DO BEGIN END", + "CREATE EVENT ev ON SCHEDULE EVERY 1 DAY " + + "DO BEGIN IF @a > 0 THEN DELETE FROM t1; END IF; END", + "ALTER DEFINER = CURRENT_USER EVENT ev ON COMPLETION PRESERVE RENAME TO db2.ev2 " + + "ENABLE COMMENT 'moved' DO SELECT 2", + "ALTER EVENT ev DISABLE ON REPLICA", + "ALTER EVENT ev DISABLE ON SLAVE", + "ALTER EVENT ev DO BEGIN DELETE FROM t1; DELETE FROM t2; END"}) + void parsesMySqlEventForms(String sql) throws JSQLParserException { + for (Consumer consumer : List.>of( + parser -> parser.withDialect(Dialect.MYSQL), parser -> { + })) { + // a statement block prints one statement per line + Statement event = assertSqlCanBeParsedAndDeparsed(sql, true, consumer); + assertInstanceOf(EventStatement.class, event); + Statements script = CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", consumer); + assertEquals(2, script.size()); + assertEquals(buildSqlString(sql, true), + buildSqlString(script.get(0).toString(), true)); + } + } + + @Test + void parsesDefinerAsShowCreateEventPrintsIt() throws JSQLParserException { + CreateEvent event = assertInstanceOf(CreateEvent.class, CCJSqlParserUtil.parse( + "CREATE DEFINER=`root`@`localhost` EVENT `ev` ON SCHEDULE EVERY 1 DAY " + + "STARTS '2026-01-01 00:00:00' ON COMPLETION NOT PRESERVE ENABLE " + + "DO DELETE FROM t1")); + + assertEquals("root", event.getDefiner().getUser().getValue()); + assertEquals("localhost", event.getDefiner().getHost().getValue()); + assertInstanceOf(Delete.class, event.getBody()); + assertEquals("CREATE DEFINER = `root`@`localhost` EVENT `ev` ON SCHEDULE EVERY 1 DAY " + + "STARTS '2026-01-01 00:00:00' ON COMPLETION NOT PRESERVE ENABLE " + + "DO DELETE FROM t1", event.toString()); + + AlterEvent altered = assertInstanceOf(AlterEvent.class, CCJSqlParserUtil.parse( + "ALTER DEFINER = 'admin'@'%' EVENT ev ENABLE")); + assertEquals("admin", altered.getDefiner().getUser().getValue()); + assertEquals("%", altered.getDefiner().getHost().getValue()); + assertEquals(EventStatus.ENABLE, altered.getStatus()); + } + + @Test + void keepsStatementBlockBodiesStructured() throws JSQLParserException { + CreateEvent event = assertInstanceOf(CreateEvent.class, CCJSqlParserUtil.parse( + "CREATE EVENT ev ON SCHEDULE EVERY 1 DAY " + + "DO BEGIN DELETE FROM a; DELETE FROM b; END", + parser -> parser.withDialect(Dialect.MYSQL))); + + Block body = assertInstanceOf(Block.class, event.getBody()); + assertEquals(2, body.getStatements().size()); + assertInstanceOf(Delete.class, body.getStatements().get(0)); + assertEquals(Set.of("a", "b"), + new HashSet<>(new TablesNamesFinder<>().getTables((Statement) event))); + + AlterEvent altered = assertInstanceOf(AlterEvent.class, CCJSqlParserUtil.parse( + "ALTER EVENT ev DO BEGIN IF @a > 0 THEN DELETE FROM t1; END IF; END")); + assertTrue(altered.getBody() instanceof UnsupportedStatement); + } + + @Test + void parsesDisableOnReplica() throws JSQLParserException { + AlterEvent event = assertInstanceOf(AlterEvent.class, + CCJSqlParserUtil.parse("ALTER EVENT ev DISABLE ON REPLICA")); + assertEquals(EventStatus.DISABLE_ON_REPLICA, event.getStatus()); + + event = assertInstanceOf(AlterEvent.class, + CCJSqlParserUtil.parse("ALTER EVENT ev DISABLE ON SLAVE")); + assertEquals(EventStatus.DISABLE_ON_SLAVE, event.getStatus()); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/function/MySqlLoadableFunctionTest.java b/src/test/java/net/sf/jsqlparser/statement/create/function/MySqlLoadableFunctionTest.java new file mode 100644 index 0000000000..7b7ef9263f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/function/MySqlLoadableFunctionTest.java @@ -0,0 +1,362 @@ +/*- + * #%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.function; + +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.assertNotNull; +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.Arrays; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.CreateFunctionalStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.function.LoadableFunction.ReturnType; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.util.TablesNamesFinder; +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; + +/** MySQL CREATE [AGGREGATE] FUNCTION [IF NOT EXISTS] name RETURNS type SONAME 'library'. */ +class MySqlLoadableFunctionTest { + /** The loadable function is read with these dialects or without one. */ + private static final Dialect[] MYSQL = {Dialect.MYSQL, Dialect.MARIADB, null}; + private static final Dialect[] OTHERS = + {Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER, Dialect.H2}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertSpans(String expected, String source, ASTNodeAccess access) { + Node node = access.getASTNode(); + assertNotNull(node, expected); + assertEquals(expected, source.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + /** Parses, prints through toString and the deparser, reparses and finds no tables. */ + private static CreateFunction roundTrip(String sql, Dialect dialect) throws Exception { + CreateFunction function = assertInstanceOf(CreateFunction.class, parse(sql, dialect), sql); + assertNotNull(function.getLoadableFunction(), sql); + assertEquals(sql, function.toString()); + assertSpans(sql, sql, function); + StringBuilder output = new StringBuilder(); + function.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + CreateFunction reparsed = assertInstanceOf(CreateFunction.class, parse(sql, dialect)); + assertEquals(function.isAggregate(), reparsed.isAggregate()); + assertEquals(sql, reparsed.toString()); + assertTrue(new TablesNamesFinder<>().getTables((Statement) function).isEmpty()); + return function; + } + + private static void assertRejected(String sql, Dialect... dialects) { + for (Dialect dialect : dialects) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), + dialect + ": " + sql); + } + } + + @Test + void aggregateFunctionIsACreateFunction() throws Exception { + for (Dialect dialect : MYSQL) { + String sql = "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'"; + CreateFunction function = roundTrip(sql, dialect); + assertTrue(function.isAggregate()); + assertEquals("FUNCTION", function.getKind()); + LoadableFunction definition = function.getLoadableFunction(); + assertFalse(definition.isIfNotExists()); + assertEquals("f", definition.getName()); + assertEquals(ReturnType.INTEGER, definition.getReturnType()); + assertEquals("INTEGER", definition.getReturnTypeKeyword()); + assertEquals("udf.so", definition.getLibrary().getValue()); + assertSpans("'udf.so'", sql, definition.getLibrary()); + assertEquals(Arrays.asList("f", "RETURNS", "INTEGER", "SONAME", "'udf.so'"), + function.getFunctionDeclarationParts()); + assertEquals("f RETURNS INTEGER SONAME 'udf.so'", function.formatDeclaration()); + assertTrue(function.getCharacteristics().isEmpty()); + assertNull(function.getDefiner()); + + definition = roundTrip( + "CREATE AGGREGATE FUNCTION IF NOT EXISTS f RETURNS REAL SONAME 'udf.so'", + dialect).getLoadableFunction(); + assertTrue(definition.isIfNotExists()); + assertEquals(ReturnType.REAL, definition.getReturnType()); + } + } + + @Test + void plainLoadableFunctionGetsTheSameDefinition() throws Exception { + for (Dialect dialect : MYSQL) { + CreateFunction function = roundTrip( + "CREATE FUNCTION IF NOT EXISTS f RETURNS STRING SONAME 'udf.so'", dialect); + assertFalse(function.isAggregate()); + assertTrue(function.getLoadableFunction().isIfNotExists()); + assertEquals(ReturnType.STRING, function.getLoadableFunction().getReturnType()); + assertEquals(ReturnType.DECIMAL, + roundTrip("CREATE FUNCTION f RETURNS DECIMAL SONAME 'udf.so'", dialect) + .getLoadableFunction().getReturnType()); + } + } + + @Test + void returnTypeSynonymsKeepTheirSpelling() throws Exception { + for (Dialect dialect : MYSQL) { + for (String keyword : new String[] {"INT", "INT4", "INTEGER", "integer"}) { + LoadableFunction definition = roundTrip( + "CREATE AGGREGATE FUNCTION f RETURNS " + keyword + " SONAME 'udf.so'", + dialect).getLoadableFunction(); + assertEquals(ReturnType.INTEGER, definition.getReturnType()); + assertEquals(keyword, definition.getReturnTypeKeyword()); + } + assertEquals(ReturnType.DECIMAL, + roundTrip("CREATE FUNCTION f RETURNS DEC SONAME 'udf.so'", dialect) + .getLoadableFunction().getReturnType()); + assertEquals(ReturnType.STRING, + roundTrip("CREATE AGGREGATE FUNCTION f RETURNS STRING SONAME 'udf.so'", dialect) + .getLoadableFunction().getReturnType()); + } + } + + @Test + void namesAndLibrarySpellings() throws Exception { + for (Dialect dialect : MYSQL) { + assertEquals("`my f`", + roundTrip("CREATE AGGREGATE FUNCTION `my f` RETURNS INTEGER SONAME 'udf.so'", + dialect).getLoadableFunction().getName()); + assertEquals("aggregate", + roundTrip("CREATE AGGREGATE FUNCTION aggregate RETURNS INTEGER SONAME 'udf.so'", + dialect).getLoadableFunction().getName()); + assertEquals("soname", + roundTrip("CREATE FUNCTION soname RETURNS REAL SONAME 'udf.so'", dialect) + .getLoadableFunction().getName()); + StringValue library = + roundTrip("CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME \"udf.so\"", + dialect).getLoadableFunction().getLibrary(); + assertEquals("udf.so", library.getValue()); + assertEquals("\"", library.getQuoteStr()); + } + Statement statement = parse("create aggregate function f returns integer soname 'udf.so'", + Dialect.MYSQL); + assertEquals("CREATE AGGREGATE FUNCTION f RETURNS integer SONAME 'udf.so'", + statement.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE AGGREGATE FUNCTION f RETURNS DOUBLE SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS FLOAT SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS VARCHAR(10) SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS NUMERIC SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS FIXED SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS BIGINT SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER(10) SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS DECIMAL(10,2) SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION d.f RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME udf", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME N'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME _utf8mb4'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf' '.so'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 0x7564662e736f", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER", + "CREATE AGGREGATE FUNCTION f SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f() RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f (a INT) RETURNS INTEGER RETURN 1", + "CREATE AGGREGATE FUNCTION IF EXISTS f RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so' COMMENT 'x'", + "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so', 'b.so'", + "CREATE OR REPLACE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE DEFINER = root@localhost FUNCTION f RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE PROCEDURE f RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'", + "CREATE AGGREGATE f RETURNS INTEGER SONAME 'udf.so'", + "CREATE FUNCTION f RETURNS DOUBLE SONAME 'udf.so'", + "CREATE FUNCTION f RETURNS VARCHAR(10) SONAME 'udf.so'", + "CREATE FUNCTION d.f RETURNS INTEGER SONAME 'udf.so'", + "CREATE FUNCTION f RETURNS INTEGER SONAME udf", + "CREATE FUNCTION f RETURNS INTEGER SONAME 'udf.so' COMMENT 'x'", + "CREATE FUNCTION f RETURNS INTEGER", + "CREATE OR REPLACE FUNCTION f RETURNS INTEGER SONAME 'udf.so'", + "CREATE FUNCTION IF NOT EXISTS f RETURNS FLOAT SONAME 'udf.so'"}) + void mySqlRejectsWhatTheServerRejects(String sql) { + assertRejected(sql, Dialect.MYSQL); + } + + @Test + void mariaDbKeepsOrReplaceAndItsOtherAggregateForms() throws Exception { + CreateFunction function = roundTrip( + "CREATE OR REPLACE AGGREGATE FUNCTION IF NOT EXISTS f RETURNS DEC SONAME 'udf.so'", + Dialect.MARIADB); + assertTrue(function.isAggregate()); + function = roundTrip("CREATE OR REPLACE FUNCTION f RETURNS INT SONAME 'udf.so'", null); + assertFalse(function.isAggregate()); + // not a loadable function: today's reading + for (Dialect dialect : new Dialect[] {Dialect.MARIADB, null}) { + assertInstanceOf(UnsupportedStatement.class, + parse("CREATE AGGREGATE FUNCTION f(x INT) RETURNS INT RETURN x", dialect)); + assertInstanceOf(UnsupportedStatement.class, + parse("CREATE AGGREGATE FUNCTION f RETURNS DOUBLE SONAME 'udf.so'", dialect)); + // The PostgreSQL aggregate parser rejects a definition without its signature. + assertRejected("CREATE AGGREGATE f RETURNS INTEGER SONAME 'udf.so'", dialect); + CreateFunction tokens = assertInstanceOf(CreateFunction.class, + parse("CREATE FUNCTION f RETURNS DOUBLE SONAME 'udf.so'", dialect)); + assertNull(tokens.getLoadableFunction()); + assertEquals("CREATE FUNCTION f RETURNS DOUBLE SONAME 'udf.so'", tokens.toString()); + } + } + + @Test + void otherDialectsKeepTheirReading() throws Exception { + for (Dialect dialect : OTHERS) { + String aggregate = "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'"; + if (dialect == Dialect.POSTGRESQL) { + assertRejected(aggregate, dialect); + } else { + Statement statement = parse(aggregate, dialect); + assertInstanceOf(UnsupportedStatement.class, statement, String.valueOf(dialect)); + assertEquals(aggregate, statement.toString()); + } + String plain = "CREATE FUNCTION f RETURNS STRING SONAME 'udf.so'"; + if (dialect == Dialect.SQLSERVER) { + // a SQL Server function needs its parameter parentheses + assertRejected(plain, dialect); + continue; + } + CreateFunction function = assertInstanceOf(CreateFunction.class, parse(plain, dialect)); + assertNull(function.getLoadableFunction()); + assertFalse(function.isAggregate()); + assertEquals(plain, function.toString()); + assertThrows(UnsupportedOperationException.class, + () -> new TablesNamesFinder<>().getTables((Statement) function)); + } + } + + @Test + void storedFunctionsAreNotLoadableFunctions() throws Exception { + for (Dialect dialect : MYSQL) { + String sql = "CREATE FUNCTION f ( a INT ) RETURNS INT DETERMINISTIC RETURN a + 1"; + CreateFunction function = assertInstanceOf(CreateFunction.class, parse(sql, dialect)); + assertNull(function.getLoadableFunction()); + assertFalse(function.isAggregate()); + assertEquals(sql, function.toString()); + function = assertInstanceOf(CreateFunction.class, parse( + "CREATE DEFINER = root@localhost FUNCTION d.f () RETURNS INT RETURN 1", + dialect)); + assertNull(function.getLoadableFunction()); + assertNotNull(function.getDefiner()); + } + } + + @Test + void statementBoundaries() throws Exception { + for (Dialect dialect : MYSQL) { + String script = "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so';" + + " CREATE FUNCTION g RETURNS STRING SONAME 'udf.so';" + + " DROP FUNCTION IF EXISTS f; SELECT f(a) FROM t"; + Statements statements = dialect == null ? CCJSqlParserUtil.parseStatements(script) + : CCJSqlParserUtil.parseStatements(script, p -> p.withDialect(dialect)); + assertEquals(4, statements.size()); + assertTrue(((CreateFunction) statements.get(0)).isAggregate()); + assertEquals("g", + ((CreateFunction) statements.get(1)).getLoadableFunction().getName()); + assertInstanceOf(Drop.class, statements.get(2)); + assertEquals("CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'", + statements.get(0).toString()); + assertEquals("CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'", + parse("CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so';", dialect) + .toString()); + } + } + + @Test + void modelBuildsAndReplacesTheDefinition() { + CreateFunction function = new CreateFunction().withAggregate(true) + .withLoadableFunction(new LoadableFunction("f", ReturnType.DECIMAL, "'udf.so'") + .withIfNotExists(true)); + assertEquals("CREATE AGGREGATE FUNCTION IF NOT EXISTS f RETURNS DECIMAL SONAME 'udf.so'", + function.toString()); + assertEquals("IF NOT EXISTS f RETURNS DECIMAL SONAME 'udf.so'", + function.getLoadableFunction().toString()); + + LoadableFunction definition = function.getLoadableFunction(); + definition.setReturnTypeKeyword("int"); + assertEquals(ReturnType.INTEGER, definition.getReturnType()); + definition.setReturnType(ReturnType.STRING); + assertEquals("STRING", definition.getReturnTypeKeyword()); + definition.setLibrary(new StringValue("'other.so'")); + definition.setName("g"); + definition.setIfNotExists(false); + assertEquals("CREATE AGGREGATE FUNCTION g RETURNS STRING SONAME 'other.so'", + function.toString()); + assertThrows(IllegalArgumentException.class, + () -> definition.setReturnTypeKeyword("DOUBLE")); + assertThrows(NullPointerException.class, () -> definition.setReturnType(null)); + assertNull(new LoadableFunction().getReturnType()); + assertNull(ReturnType.from("FLOAT")); + + // declaration parts are a snapshot; setting parts replaces the definition + List parts = new ArrayList<>(function.getFunctionDeclarationParts()); + function.getFunctionDeclarationParts().clear(); + assertEquals(parts, function.getFunctionDeclarationParts()); + function.addFunctionDeclarationParts("COMMENT", "'x'"); + assertNull(function.getLoadableFunction()); + assertEquals("CREATE AGGREGATE FUNCTION g RETURNS STRING SONAME 'other.so' COMMENT 'x'", + function.toString()); + function.setAggregate(false); + function.setLoadableFunction(definition); + assertEquals("CREATE FUNCTION g RETURNS STRING SONAME 'other.so'", function.toString()); + function.setLoadableFunction(null); + assertNull(function.getFunctionDeclarationParts()); + function.setFunctionDeclarationParts(Arrays.asList("h", "()")); + assertEquals("CREATE FUNCTION h ()", function.toString()); + } + + @Test + void visitorsAndValidation() throws Exception { + String sql = "CREATE AGGREGATE FUNCTION f RETURNS INTEGER SONAME 'udf.so'"; + Statement statement = parse(sql, Dialect.MYSQL); + List visited = new ArrayList<>(); + statement.accept(new StatementVisitorAdapter() { + @Override + public Void visit(CreateFunctionalStatement createFunctionalStatement, S context) { + visited.add(createFunctionalStatement.getKind()); + return null; + } + }, null); + assertEquals(Arrays.asList("FUNCTION"), visited); + assertTrue(Validation.validate( + Arrays.asList(new FeaturesAllowed(Feature.functionalStatement, + Feature.createFunction)), + sql).isEmpty()); + assertFalse(Validation.validate(Arrays.asList(new FeaturesAllowed(Feature.select)), sql) + .isEmpty()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java b/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java index 5d6093f186..2bccbafb4c 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java @@ -11,19 +11,50 @@ import static net.sf.jsqlparser.test.TestUtils.assertDeparse; 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.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.List; +import java.util.function.Consumer; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.StmtFeature; import net.sf.jsqlparser.statement.create.database.DatabaseOption; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.sequence.CreateSequence; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +import net.sf.jsqlparser.statement.create.view.CreateView; +import net.sf.jsqlparser.statement.grant.Grant; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; /** * * @author tw */ public class CreateSchemaTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static CreateSchema roundTrip(String sql) throws JSQLParserException { + CreateSchema schema = assertInstanceOf(CreateSchema.class, + assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL)); + assertEquals(sql, CCJSqlParserUtil.parse(schema.toString(), POSTGRESQL).toString()); + return schema; + } @Test public void testSimpleCreateSchema() throws JSQLParserException { @@ -77,4 +108,95 @@ void testMySqlCreateSchemaOptions() throws JSQLParserException { assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); } + + @Test + void testMySqlCreateSchemaCharset() throws JSQLParserException { + String sql = "CREATE SCHEMA db1 DEFAULT CHARSET = utf8mb4 DEFAULT ENCRYPTION = 'N'"; + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, null}) { + CreateSchema schema = (CreateSchema) assertSqlCanBeParsedAndDeparsed(sql, false, + dialect == null ? parser -> { + } : parser -> parser.withDialect(dialect)); + DatabaseOption charset = + schema.getDatabaseOption(DatabaseOption.Kind.CHARACTER_SET).orElseThrow(); + assertEquals("CHARSET", charset.getName()); + assertEquals("utf8mb4", charset.getValue()); + assertTrue(charset.isUseDefault()); + } + assertSqlCanBeParsedAndDeparsed("CREATE SCHEMA db1 CHAR SET utf8mb4"); + } + + @Test + void keepsSchemaElementsAsWritten() throws JSQLParserException { + CreateSchema schema = roundTrip("CREATE SCHEMA hollywood " + + "CREATE TABLE films (title text, release date, awards text[]) " + + "CREATE VIEW winners AS SELECT title, release FROM films WHERE awards IS NOT NULL"); + + assertEquals("hollywood", schema.getSchemaName()); + assertEquals(2, schema.getStatements().size()); + CreateTable films = assertInstanceOf(CreateTable.class, schema.getStatements().get(0)); + assertEquals("films", films.getTable().getFullyQualifiedName()); + assertNull(films.getTable().getSchemaName()); + CreateView winners = assertInstanceOf(CreateView.class, schema.getStatements().get(1)); + assertEquals("winners", winners.getView().getFullyQualifiedName()); + assertThat(new TablesNamesFinder().getTables(schema)).containsExactlyInAnyOrder("films", + "winners"); + } + + @Test + void acceptsEveryPostgreSqlSchemaElement() throws JSQLParserException { + CreateSchema schema = roundTrip("CREATE SCHEMA app AUTHORIZATION app_owner " + + "CREATE TABLE t (id int) " + + "CREATE VIEW v AS SELECT id FROM t " + + "GRANT SELECT ON v TO PUBLIC " + + "CREATE UNIQUE INDEX i ON t (id) " + + "CREATE SEQUENCE s START WITH 10 " + + "CREATE TRIGGER trg BEFORE INSERT ON t FOR EACH ROW EXECUTE FUNCTION f() " + + "GRANT USAGE ON SEQUENCE s TO app_user"); + + assertEquals("app_owner", schema.getAuthorization()); + assertEquals(List.of(CreateTable.class, CreateView.class, Grant.class, CreateIndex.class, + CreateSequence.class, CreateTrigger.class, Grant.class), + schema.getStatements().stream().map(Object::getClass) + .collect(java.util.stream.Collectors.toList())); + assertThat(new TablesNamesFinder().getTables(schema)).contains("t", "v"); + assertThat(schema.getFeatures().getCertain()).containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertTrue(new Validation(List.of(PostgresqlVersion.V10), schema.toString()).validate() + .isEmpty()); + assertThat(new Validation(List.of(new FeaturesAllowed(Feature.createSchema)), + "CREATE SCHEMA app CREATE TABLE t (id int)").validate()).isNotEmpty(); + } + + @Test + void schemaElementsWithoutAName() throws JSQLParserException { + CreateSchema schema = roundTrip("CREATE SCHEMA AUTHORIZATION joe CREATE TABLE t (a int)"); + assertNull(schema.getSchemaName()); + assertEquals("t", ((CreateTable) schema.getStatements().get(0)).getTable().getName()); + } + + @Test + void grantRemainsAnAliasOutsideSchemaElements() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT a FROM t grant"); + assertEquals(2, CCJSqlParserUtil + .parseStatements("CREATE SCHEMA s;\nCREATE TABLE t (a int);").size()); + } + + @Test + void rendersSchemaPathAndElements() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("CREATE SCHEMA s PATH a, b"); + CreateSchema schema = new CreateSchema().withSchemaName("s"); + schema.addStatement(CCJSqlParserUtil.parse("CREATE TABLE t (a int)")); + assertDeparse(schema, "CREATE SCHEMA s CREATE TABLE t (a int)"); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE SCHEMA IF NOT EXISTS s CREATE TABLE t (a int)", + "CREATE SCHEMA s CREATE MATERIALIZED VIEW v AS SELECT 1", + "CREATE SCHEMA s CREATE FUNCTION f() RETURNS int AS 'SELECT 1' LANGUAGE sql", + "CREATE SCHEMA s CREATE SCHEMA t", + "CREATE SCHEMA s VIEW v AS SELECT 1", + "CREATE SCHEMA s CREATE TABLE t (a int) REVOKE SELECT ON t FROM u"}) + void rejectsOtherSchemaElements(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/spatial/SpatialReferenceSystemTest.java b/src/test/java/net/sf/jsqlparser/statement/create/spatial/SpatialReferenceSystemTest.java new file mode 100644 index 0000000000..c0e10347b7 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/spatial/SpatialReferenceSystemTest.java @@ -0,0 +1,476 @@ +/*- + * #%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.spatial; + +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.assertNotNull; +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.math.BigInteger; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitor; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.spatial.SpatialReferenceSystemAttribute.Kind; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; +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.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL CREATE SPATIAL REFERENCE SYSTEM and DROP SPATIAL REFERENCE SYSTEM. */ +class SpatialReferenceSystemTest { + private static final Dialect[] MYSQL_OR_NONE = {Dialect.MYSQL, null}; + private static final String FULL = "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'Greek' " + + "ORGANIZATION 'EPSG' IDENTIFIED BY 4120 DEFINITION 'GEOGCS[\"Greek\"]' " + + "DESCRIPTION 'd'"; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertSpans(String expected, String source, ASTNodeAccess access) { + Node node = access.getASTNode(); + assertNotNull(node, expected); + assertEquals(expected, source.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + /** + * Parses {@code sql}, which must print as written, and checks the statement span, the deparser, + * the reparse, the feature analysis and the table finder. + */ + private static Statement roundTrip(String sql, Dialect dialect, StmtFeature... features) + throws Exception { + Statement statement = parse(sql, dialect); + assertEquals(sql, statement.toString()); + assertSpans(sql, sql, (ASTNodeAccess) statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(sql, output.toString()); + Statement reparsed = parse(output.toString(), dialect); + assertEquals(statement.getClass(), reparsed.getClass()); + assertEquals(sql, reparsed.toString()); + assertEquals(Set.of(features), statement.getFeatures().getCertain()); + assertTrue(statement.getFeatures().getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder<>().getTables(statement).isEmpty()); + return statement; + } + + private static CreateSpatialReferenceSystem create(String sql, Dialect dialect) + throws Exception { + return assertInstanceOf(CreateSpatialReferenceSystem.class, + roundTrip(sql, dialect, StmtFeature.MODIFIES_SCHEMA)); + } + + private static Drop drop(String sql, Dialect dialect) throws Exception { + return assertInstanceOf(Drop.class, + roundTrip(sql, dialect, StmtFeature.MODIFIES_SCHEMA, StmtFeature.MODIFIES_DATA)); + } + + // ---- CREATE -------------------------------------------------------------------------------- + + @Test + void createKeepsTheSridAndEveryAttribute() throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + CreateSpatialReferenceSystem statement = create(FULL, dialect); + assertFalse(statement.isOrReplace()); + assertFalse(statement.isIfNotExists()); + assertEquals(4120L, assertInstanceOf(LongValue.class, statement.getSrid()).getValue()); + assertSpans("4120", FULL, (ASTNodeAccess) statement.getSrid()); + assertEquals("Greek", statement.getName().getValue()); + assertEquals("EPSG", statement.getOrganization().getValue()); + assertEquals(4120L, assertInstanceOf(LongValue.class, statement.getOrganizationId()) + .getValue()); + assertEquals("GEOGCS[\"Greek\"]", statement.getDefinition().getValue()); + assertEquals("d", statement.getDescription().getValue()); + + List attributes = statement.getAttributes(); + assertEquals(Arrays.asList(Kind.NAME, Kind.ORGANIZATION, Kind.DEFINITION, + Kind.DESCRIPTION), + Arrays.asList(attributes.get(0).getKind(), attributes.get(1).getKind(), + attributes.get(2).getKind(), attributes.get(3).getKind())); + assertEquals(4, attributes.size()); + assertSpans("NAME 'Greek'", FULL, attributes.get(0)); + assertSpans("'Greek'", FULL, attributes.get(0).getValue()); + assertNull(attributes.get(0).getOrganizationId()); + assertSpans("ORGANIZATION 'EPSG' IDENTIFIED BY 4120", FULL, attributes.get(1)); + assertSpans("'EPSG'", FULL, attributes.get(1).getValue()); + assertSame(statement.getOrganizationId(), attributes.get(1).getOrganizationId()); + assertSpans("DEFINITION 'GEOGCS[\"Greek\"]'", FULL, attributes.get(2)); + assertSpans("DESCRIPTION 'd'", FULL, attributes.get(3)); + assertEquals("DESCRIPTION 'd'", attributes.get(3).toString()); + assertSame(attributes.get(2), statement.getAttribute(Kind.DEFINITION)); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 4120 NAME 'Greek' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM IF NOT EXISTS 4120 NAME 'Greek' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 DEFINITION 'x' NAME 'Greek'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 DESCRIPTION 'd' ORGANIZATION 'o' IDENTIFIED BY 1 " + + "DEFINITION 'x' NAME 'n'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME \"n\" DEFINITION \"x\"", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x' ORGANIZATION \"o\" " + + "IDENTIFIED BY 1", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'it''s' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME '' DEFINITION ''", + "CREATE SPATIAL REFERENCE SYSTEM 04120 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4294967296 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x' ORGANIZATION 'o' " + + "IDENTIFIED BY 4294967296", + // the server reports a missing or repeated attribute itself, not as a syntax error + "CREATE SPATIAL REFERENCE SYSTEM 4120", + "CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 4120", + "CREATE SPATIAL REFERENCE SYSTEM IF NOT EXISTS 4120", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 DESCRIPTION 'd'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 ORGANIZATION 'o' IDENTIFIED BY 0", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'a' NAME 'b' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'a' DEFINITION 'x' DEFINITION 'y'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'a' DEFINITION 'x' DESCRIPTION 'd' " + + "DESCRIPTION 'e'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'a' DEFINITION 'x' ORGANIZATION 'o' " + + "IDENTIFIED BY 1 ORGANIZATION 'p' IDENTIFIED BY 2"}) + void createTakesTheAttributesInAnyOrderAndNumber(String sql) throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + CreateSpatialReferenceSystem statement = create(sql, dialect); + assertEquals(sql.startsWith("CREATE OR REPLACE"), statement.isOrReplace()); + assertEquals(sql.contains("IF NOT EXISTS"), statement.isIfNotExists()); + } + } + + @Test + void repeatedAttributesStayInTheListAndTheGettersReturnTheFirst() throws Exception { + CreateSpatialReferenceSystem statement = create( + "CREATE SPATIAL REFERENCE SYSTEM 1 NAME 'a' ORGANIZATION 'o' IDENTIFIED BY 1 " + + "NAME 'b' ORGANIZATION 'p' IDENTIFIED BY 2", + Dialect.MYSQL); + assertEquals(4, statement.getAttributes().size()); + assertEquals("a", statement.getName().getValue()); + assertEquals("o", statement.getOrganization().getValue()); + assertEquals("1", statement.getOrganizationId().toString()); + assertNull(statement.getDefinition()); + assertNull(statement.getDescription()); + + CreateSpatialReferenceSystem bare = + create("CREATE SPATIAL REFERENCE SYSTEM 1", Dialect.MYSQL); + assertTrue(bare.getAttributes().isEmpty()); + assertNull(bare.getName()); + assertNull(bare.getOrganization()); + assertNull(bare.getOrganizationId()); + assertNull(bare.getAttribute(Kind.NAME)); + } + + @Test + void sridAndOrganizationIdAreUnsignedIntegersOrHexadecimalNumbers() throws Exception { + String sql = "CREATE SPATIAL REFERENCE SYSTEM 0x3D0978 NAME 'n' DEFINITION 'x' " + + "ORGANIZATION 'o' IDENTIFIED BY X'10'"; + for (Dialect dialect : MYSQL_OR_NONE) { + CreateSpatialReferenceSystem statement = create(sql, dialect); + assertEquals("0x3D0978", + assertInstanceOf(HexValue.class, statement.getSrid()).getValue()); + assertSpans("0x3D0978", sql, (ASTNodeAccess) statement.getSrid()); + assertEquals("X'10'", + assertInstanceOf(HexValue.class, statement.getOrganizationId()).getValue()); + assertSpans("X'10'", sql, (ASTNodeAccess) statement.getOrganizationId()); + } + create("CREATE SPATIAL REFERENCE SYSTEM x'3D0978' NAME 'n'", Dialect.MYSQL); + create("CREATE SPATIAL REFERENCE SYSTEM X'' NAME 'n'", Dialect.MYSQL); + create("CREATE SPATIAL REFERENCE SYSTEM 0x3d0978 NAME 'n'", Dialect.MYSQL); + + // the grammar takes any 64-bit unsigned integer; the server then checks the SRID range + String largest = "CREATE SPATIAL REFERENCE SYSTEM 18446744073709551615 NAME 'n'"; + assertEquals(new BigInteger("18446744073709551615"), + assertInstanceOf(LongValue.class, create(largest, Dialect.MYSQL).getSrid()) + .getBigIntegerValue()); + create("CREATE SPATIAL REFERENCE SYSTEM 000000000000000000000004000120 NAME 'n'", + Dialect.MYSQL); + } + + @Test + void keywordsAreCaseInsensitiveAndDoubleQuotedStringsAreStrings() throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + Statement statement = parse("create or replace spatial reference system 1 name 'n' " + + "definition 'x' organization 'o' identified by 2 description 'd'", dialect); + assertEquals("CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 1 NAME 'n' DEFINITION 'x' " + + "ORGANIZATION 'o' IDENTIFIED BY 2 DESCRIPTION 'd'", statement.toString()); + + CreateSpatialReferenceSystem quoted = create( + "CREATE SPATIAL REFERENCE SYSTEM 1 NAME \"a b\" DEFINITION 'x'", dialect); + assertEquals("a b", quoted.getName().getValue()); + assertEquals("\"", quoted.getName().getQuoteStr()); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE OR REPLACE SPATIAL REFERENCE SYSTEM IF NOT EXISTS 4120 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM '4120' NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM `4120` NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM srs1 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM -1 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM +1 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM (1) NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 1.5 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 1e3 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 1_000 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 18446744073709551616 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 0X3D0978 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM X'1' NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM B'1' NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 0b101 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120, 4121 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM IF EXISTS 4120 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 IF NOT EXISTS NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME n DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 1 DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME N'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME _utf8'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME _utf8mb4'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME X'41' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'a' 'b' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME ('n') DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME = 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n', DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x' ORGANIZATION 'o'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' ORGANIZATION 'o' IDENTIFIED BY 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' ORGANIZATION 'o' IDENTIFIED BY -1", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' ORGANIZATION 'o' IDENTIFIED BY 1.5", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' ORGANIZATION 'o' IDENTIFIED 1", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' ORGANIZATION 'o' IDENTIFIED WITH 1", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' ORGANIZATION IDENTIFIED BY 1", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x' IDENTIFIED BY 1", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x' COMMENT 'c'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 SRID 1 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x' x"}) + void createRejectsWhatTheServerGrammarRejects(String sql) { + for (Dialect dialect : MYSQL_OR_NONE) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE SPATIAL REFERENCE 4120 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL SYSTEM 4120 NAME 'n' DEFINITION 'x'", + "CREATE SPATIAL REFERENCE SYSTEMS 4120 NAME 'n' DEFINITION 'x'"}) + void mySqlDialectRejectsAMisspelledObjectType(String sql) throws Exception { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + // without a dialect only the exact words select the statement + assertInstanceOf(UnsupportedStatement.class, parse(sql, null)); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MARIADB", "POSTGRESQL", "ORACLE", "SQLSERVER"}) + void otherDialectsKeepTheirReading(Dialect dialect) throws Exception { + assertInstanceOf(UnsupportedStatement.class, parse(FULL, dialect)); + assertThrows(JSQLParserException.class, + () -> parse("DROP SPATIAL REFERENCE SYSTEM 4120", dialect)); + } + + @Test + void spatialIndexStatementsKeepTheirReading() throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + assertInstanceOf(CreateIndex.class, parse("CREATE SPATIAL INDEX i ON t (g)", dialect)); + assertInstanceOf(Alter.class, parse("ALTER TABLE t ADD SPATIAL INDEX i (g)", dialect)); + assertEquals(Drop.ObjectType.INDEX, + ((Drop) parse("DROP INDEX i ON t", dialect)).getObjectType()); + } + TestUtils.assertSqlCanBeParsedAndDeparsed("CREATE SPATIAL INDEX i ON t (g)", true); + } + + @Test + void createCanBeBuiltAndEdited() { + CreateSpatialReferenceSystem statement = + new CreateSpatialReferenceSystem(new LongValue(4120)) + .addAttributes( + new SpatialReferenceSystemAttribute(Kind.NAME, + new StringValue("'Greek'")), + new SpatialReferenceSystemAttribute(new StringValue("'EPSG'"), + new LongValue(4120))) + .withIfNotExists(true); + assertEquals("CREATE SPATIAL REFERENCE SYSTEM IF NOT EXISTS 4120 NAME 'Greek' " + + "ORGANIZATION 'EPSG' IDENTIFIED BY 4120", statement.toString()); + assertThrows(IllegalArgumentException.class, () -> statement.setOrReplace(true)); + + statement.setIfNotExists(false); + statement.withOrReplace(true).withSrid(new HexValue("0x10")); + assertThrows(IllegalArgumentException.class, () -> statement.setIfNotExists(true)); + statement.getAttributes().get(0).withValue(new StringValue("'n'")); + statement.getAttributes().get(1).withOrganizationId(new LongValue(7)); + assertEquals("CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 0x10 NAME 'n' " + + "ORGANIZATION 'EPSG' IDENTIFIED BY 7", statement.toString()); + + statement.withAttributes(Collections.singletonList( + new SpatialReferenceSystemAttribute(Kind.DEFINITION, new StringValue("'x'")))); + assertEquals("CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 0x10 DEFINITION 'x'", + statement.toString()); + statement.setAttributes(null); + assertEquals("CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 0x10", statement.toString()); + + assertThrows(NullPointerException.class, () -> new CreateSpatialReferenceSystem(null)); + assertThrows(IllegalArgumentException.class, + () -> new SpatialReferenceSystemAttribute(Kind.ORGANIZATION, + new StringValue("'o'"))); + assertThrows(IllegalArgumentException.class, + () -> new SpatialReferenceSystemAttribute(Kind.NAME, new StringValue("'n'")) + .setOrganizationId(new LongValue(1))); + assertThrows(NullPointerException.class, + () -> new SpatialReferenceSystemAttribute(Kind.NAME, null)); + assertThrows(NullPointerException.class, + () -> new SpatialReferenceSystemAttribute(new StringValue("'o'"), null)); + } + + // ---- DROP ---------------------------------------------------------------------------------- + + @Test + void dropNamesTheSrid() throws Exception { + for (Dialect dialect : MYSQL_OR_NONE) { + String sql = "DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120"; + Drop drop = drop(sql, dialect); + assertEquals(Drop.ObjectType.SPATIAL_REFERENCE_SYSTEM, drop.getObjectType()); + assertEquals("SPATIAL REFERENCE SYSTEM", drop.getType()); + assertTrue(drop.isIfExists()); + assertEquals(1, drop.getNames().size()); + assertEquals("4120", drop.getName().getName()); + assertSpans("4120", sql, drop.getName()); + assertNull(drop.getParameters()); + assertNull(drop.getBehavior()); + + assertFalse(drop("DROP SPATIAL REFERENCE SYSTEM 4120", dialect).isIfExists()); + assertEquals("0x3D0978", + drop("DROP SPATIAL REFERENCE SYSTEM 0x3D0978", dialect).getName().getName()); + assertEquals("X'10'", + drop("DROP SPATIAL REFERENCE SYSTEM X'10'", dialect).getName().getName()); + drop("DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4294967296", dialect); + assertEquals("DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120", + parse("drop spatial reference system if exists 4120", dialect).toString()); + } + } + + @Test + void dropCanBeBuilt() { + Drop drop = new Drop().withObjectType(Drop.ObjectType.SPATIAL_REFERENCE_SYSTEM) + .withIfExists(true).withName(new Table("4120", false)); + assertEquals("DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120", drop.toString()); + assertEquals(Drop.ObjectType.SPATIAL_REFERENCE_SYSTEM, + new Drop().withType("spatial reference system").getObjectType()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP SPATIAL REFERENCE SYSTEM", + "DROP SPATIAL REFERENCE SYSTEM IF EXISTS", + "DROP SPATIAL REFERENCE SYSTEM IF NOT EXISTS 4120", + "DROP SPATIAL REFERENCE SYSTEM 4120, 4121", + "DROP SPATIAL REFERENCE SYSTEM '4120'", + "DROP SPATIAL REFERENCE SYSTEM `4120`", + "DROP SPATIAL REFERENCE SYSTEM srs1", + "DROP SPATIAL REFERENCE SYSTEM -1", + "DROP SPATIAL REFERENCE SYSTEM 1.5", + "DROP SPATIAL REFERENCE SYSTEM X'1'", + "DROP SPATIAL REFERENCE SYSTEM 0X10", + "DROP SPATIAL REFERENCE SYSTEM 18446744073709551616", + "DROP SPATIAL REFERENCE SYSTEM 4120 CASCADE", + "DROP SPATIAL REFERENCE SYSTEM 4120 RESTRICT", + "DROP SPATIAL REFERENCE SYSTEM 4120 IF EXISTS", + "DROP SPATIAL REFERENCE SYSTEM 4120 x", + "DROP SPATIAL REFERENCE SYSTEM 4120 ON t", + "DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120 NAME 'n'", + "DROP SPATIAL REFERENCE 4120", + "DROP SPATIAL SYSTEM 4120", + "DROP SPATIAL 4120", + "DROP TEMPORARY SPATIAL REFERENCE SYSTEM 4120", + "DROP MATERIALIZED SPATIAL REFERENCE SYSTEM 4120"}) + void dropRejectsWhatTheServerGrammarRejects(String sql) { + for (Dialect dialect : MYSQL_OR_NONE) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + // ---- statement boundaries and visitors ----------------------------------------------------- + + @Test + void statementsEndAtTheBoundary() throws Exception { + String script = "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x';\n" + + "DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120;\n" + + "CREATE OR REPLACE SPATIAL REFERENCE SYSTEM 4120;\n" + + "SELECT 1;\n" + + "CREATE SPATIAL INDEX i ON t (g);\n" + + "DROP SPATIAL REFERENCE SYSTEM 4120"; + for (Dialect dialect : MYSQL_OR_NONE) { + Statements statements = dialect == null ? CCJSqlParserUtil.parseStatements(script) + : CCJSqlParserUtil.parseStatements(script, p -> p.withDialect(dialect)); + assertEquals(6, statements.size()); + assertInstanceOf(CreateSpatialReferenceSystem.class, statements.get(0)); + assertEquals(Drop.ObjectType.SPATIAL_REFERENCE_SYSTEM, + ((Drop) statements.get(1)).getObjectType()); + assertTrue(((CreateSpatialReferenceSystem) statements.get(2)).getAttributes() + .isEmpty()); + assertInstanceOf(Select.class, statements.get(3)); + assertInstanceOf(CreateIndex.class, statements.get(4)); + assertInstanceOf(Drop.class, statements.get(5)); + assertSpans("CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'n' DEFINITION 'x'", script, + (ASTNodeAccess) statements.get(0)); + assertSpans("DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120", script, + (ASTNodeAccess) statements.get(1)); + } + assertEquals("CREATE SPATIAL REFERENCE SYSTEM 1 NAME 'n'", + parse("CREATE SPATIAL REFERENCE SYSTEM 1 NAME 'n';", Dialect.MYSQL).toString()); + } + + @Test + void visitorsReachTheStatement() throws Exception { + CreateSpatialReferenceSystem statement = + (CreateSpatialReferenceSystem) parse(FULL, Dialect.MYSQL); + assertNull(statement.accept(new StatementVisitorAdapter(), null)); + + StringBuilder seen = new StringBuilder(); + StatementVisitor visitor = new StatementVisitorAdapter() { + @Override + public String visit(CreateSpatialReferenceSystem visited, S context) { + seen.append(visited.getSrid()).append(context); + return "visited"; + } + }; + assertEquals("visited", statement.accept(visitor, "!")); + visitor.visit(statement); + assertEquals("4120!4120null", seen.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/table/CharacterSetShorthandTest.java b/src/test/java/net/sf/jsqlparser/statement/create/table/CharacterSetShorthandTest.java new file mode 100644 index 0000000000..e850426276 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/table/CharacterSetShorthandTest.java @@ -0,0 +1,123 @@ +/*- + * #%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 net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.CastExpression; +import net.sf.jsqlparser.expression.JsonFunction; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.ColDataType.CharacterSetSyntax; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.*; + +class CharacterSetShorthandTest { + @ParameterizedTest + @CsvSource({"ASCII,latin1", "UNICODE,ucs2"}) + void shorthandsExposeCharacterSetAndRetainSpelling(String shorthand, String charset) + throws JSQLParserException { + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT CAST('ab' AS CHAR(10) " + shorthand + "), " + + "JSON_VALUE('{\"v\":\"ab\"}', '$.v' RETURNING CHAR(10) " + shorthand + + ")", + true, parser -> parser.withDialect(Dialect.MYSQL)); + ColDataType castType = + ((CastExpression) select.getSelectItem(0).getExpression()).getColDataType(); + ColDataType jsonType = + ((JsonFunction) select.getSelectItem(1).getExpression()).getReturningType(); + for (ColDataType type : new ColDataType[] {castType, jsonType}) { + assertEquals("CHAR", type.getBaseTypeName()); + assertEquals(charset, type.getCharacterSet()); + assertEquals(CharacterSetSyntax.valueOf(shorthand), type.getCharacterSetSyntax()); + } + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString(), false, + parser -> parser.withDialect(Dialect.MYSQL)); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE t (j JSON, g CHAR(10) AS (JSON_VALUE(j, '$.v' RETURNING CHAR(10) " + + shorthand + ")) STORED)", + true, parser -> parser.withDialect(Dialect.MYSQL)); + CreateTable create = (CreateTable) TestUtils.assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE t (c CHAR(10) " + shorthand + ")", true, + parser -> parser.withDialect(Dialect.MYSQL)); + assertEquals(charset, + create.getColumnDefinitions().get(0).getColDataType().getCharacterSet()); + } + + @Test + void parsedReturningTypeCanBeChanged() throws JSQLParserException { + String sql = "SELECT JSON_VALUE('{\"v\":\"ab\"}', '$.v' RETURNING CHAR(10) ASCII)"; + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL)); + ColDataType type = + ((JsonFunction) select.getSelectItem(0).getExpression()).getReturningType(); + type.setCharacterSetSyntax(CharacterSetSyntax.UNICODE); + TestUtils.assertStatementCanBeDeparsedAs(select, sql.replace("ASCII", "UNICODE"), true); + type.setCharacterSet("utf8mb4"); + TestUtils.assertStatementCanBeDeparsedAs(select, + sql.replace("ASCII", "CHARACTER SET utf8mb4"), true); + TestUtils.assertSqlCanBeParsedAndDeparsed(select.toString(), false, + parser -> parser.withDialect(Dialect.MYSQL)); + } + + @Test + void characterSetSyntaxCanBeConstructedChangedAndCleared() throws JSQLParserException { + ColDataType type = new ColDataType("CHAR").addArgumentsStringList("10") + .withCharacterSetSyntax(CharacterSetSyntax.ASCII); + assertEquals("latin1", type.getCharacterSet()); + assertEquals("CHAR (10) ASCII", type.toString()); + type.setCharacterSetSyntax(CharacterSetSyntax.UNICODE); + assertEquals("ucs2", type.getCharacterSet()); + assertEquals("CHAR (10) UNICODE", type.toString()); + type.setCharacterSet("utf8mb4"); + assertEquals(CharacterSetSyntax.CHARACTER_SET, type.getCharacterSetSyntax()); + assertEquals("CHAR (10) CHARACTER SET utf8mb4", type.toString()); + type.setUseCharsetKeyword(true); + assertTrue(type.isUseCharsetKeyword()); + type.setCharacterSet("latin1"); + assertEquals("CHAR (10) CHARSET latin1", type.toString()); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT CAST('ab' AS " + type + ")", true, + parser -> parser.withDialect(Dialect.MYSQL)); + type.setCharacterSetSyntax(CharacterSetSyntax.ASCII); + type.setUseCharsetKeyword(false); + assertEquals("CHAR (10) CHARACTER SET latin1", type.toString()); + type.setCharacterSetSyntax(CharacterSetSyntax.UNICODE); + type.setCharacterSet(null); + assertEquals("CHAR (10)", type.toString()); + } + + @Test + void syntaxParticipatesInEqualityAndHashCode() { + ColDataType ascii = + new ColDataType("CHAR").withCharacterSetSyntax(CharacterSetSyntax.ASCII); + ColDataType same = new ColDataType("char").withCharacterSetSyntax(CharacterSetSyntax.ASCII); + ColDataType explicit = new ColDataType("CHAR").withCharacterSet("latin1"); + assertEquals(ascii, same); + assertEquals(ascii.hashCode(), same.hashCode()); + assertNotEquals(ascii, explicit); + } + + @Test + void shorthandIsMySqlSpecificAndDoesNotReserveIdentifiers() throws JSQLParserException { + for (String shorthand : new String[] {"ASCII", "UNICODE"}) { + String sql = "SELECT CAST('ab' AS CHAR(10) " + shorthand + ")"; + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT " + shorthand + " FROM t", true, + parser -> parser.withDialect(Dialect.MYSQL)); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/table/ColDataTypeTest.java b/src/test/java/net/sf/jsqlparser/statement/create/table/ColDataTypeTest.java index 9a52246864..111b8b5715 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/table/ColDataTypeTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/table/ColDataTypeTest.java @@ -11,6 +11,7 @@ import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.IntervalQualifier; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; @@ -18,6 +19,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; class ColDataTypeTest { @Test @@ -147,6 +149,31 @@ void testStructuredPrecisionForZonedTypes() throws JSQLParserException { assertNull(unparameterized.getPrecision()); } + @Test + void testOracleNumberWithWildcardPrecision() throws JSQLParserException { + ColDataType number = + parseColumnType("CREATE TABLE t (a NUMBER(*, 0), b NUMBER(*), c NUMBER(*, 2))"); + assertEquals("NUMBER (*, 0)", number.getDataType()); + assertEquals("NUMBER", number.getBaseTypeName()); + assertNull(number.getPrecision()); + assertEquals(0, number.getScale()); + + assertSqlCanBeParsedAndDeparsed("SELECT CAST(1.5 AS NUMBER(*, 0)) FROM dual", true); + + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parseColDataType("NUMBER(*, *)")); + } + + @Test + void testOracleRawType() throws JSQLParserException { + ColDataType raw = parseColumnType("CREATE TABLE t (id RAW(16), payload raw(2000))"); + assertEquals("RAW", raw.getDataType()); + assertEquals(16, raw.getPrecision()); + + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t ADD payload RAW(2000)", true); + assertSqlCanBeParsedAndDeparsed("SELECT CAST(HEXTORAW('AB') AS RAW(16)) FROM dual", true); + } + private ColDataType parseColumnType(String sqlStr) throws JSQLParserException { CreateTable create = (CreateTable) assertSqlCanBeParsedAndDeparsed(sqlStr, true); return create.getColumnDefinitions().get(0).getColDataType(); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/trigger/CreateTriggerTest.java b/src/test/java/net/sf/jsqlparser/statement/create/trigger/CreateTriggerTest.java index f199bc293b..ce5e896761 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/trigger/CreateTriggerTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/trigger/CreateTriggerTest.java @@ -11,13 +11,32 @@ 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.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Consumer; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Block; import net.sf.jsqlparser.statement.SetStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 CreateTriggerTest { @@ -71,4 +90,121 @@ void parsesTriggerOrdering() throws JSQLParserException { assertEquals(CreateTrigger.Order.FOLLOWS, trigger.getOrder()); assertEquals("normalize_name", trigger.getOtherTrigger().getFullyQualifiedName()); } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE DEFINER = `root`@`localhost` TRIGGER IF NOT EXISTS trg2 AFTER UPDATE ON t1 " + + "FOR EACH ROW FOLLOWS trg INSERT INTO audit (id) VALUES (NEW.id)", + "CREATE TRIGGER IF NOT EXISTS trg2 AFTER UPDATE ON t1 FOR EACH ROW " + + "INSERT INTO audit (id) VALUES (NEW.id)", + "CREATE OR REPLACE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW SET NEW.a = 1", + "CREATE OR REPLACE DEFINER = CURRENT_USER TRIGGER trg BEFORE INSERT ON t1 " + + "FOR EACH ROW SET NEW.a = 1", + "CREATE TRIGGER trg3 BEFORE UPDATE ON t1 FOR EACH ROW " + + "BEGIN IF NEW.a < 0 THEN SET NEW.a = 0; END IF; END", + "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW lbl: BEGIN " + + "DECLARE x INT DEFAULT 0; WHILE x < 3 DO SET x = x + 1; END WHILE; " + + "LEAVE lbl; END lbl", + "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW " + + "IF NEW.a IS NULL THEN SET NEW.a = 'a.b'; END IF", + "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW CASE WHEN NEW.a > 0 THEN " + + "SET NEW.b = 1; ELSE SET NEW.b = CASE NEW.c WHEN 1 THEN 2 END; END CASE", + "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW BEGIN END"}) + void parsesMySqlTriggerForms(String sql) throws JSQLParserException { + for (Consumer consumer : List.>of( + parser -> parser.withDialect(Dialect.MYSQL), + parser -> parser.withDialect(Dialect.MARIADB), parser -> { + })) { + CreateTrigger trigger = assertInstanceOf(CreateTrigger.class, + assertSqlCanBeParsedAndDeparsed(sql, false, consumer)); + StringBuilder deparsed = new StringBuilder(); + trigger.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + assertEquals(sql, CCJSqlParserUtil.parse(deparsed.toString(), consumer).toString()); + Statements script = CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", consumer); + assertEquals(2, script.size()); + assertEquals(sql, script.get(0).toString()); + } + } + + @Test + void parsesIfNotExistsAndOrReplace() throws JSQLParserException { + CreateTrigger trigger = (CreateTrigger) CCJSqlParserUtil.parse( + "CREATE DEFINER = CURRENT_USER TRIGGER IF NOT EXISTS trg AFTER UPDATE ON t1 " + + "FOR EACH ROW INSERT INTO audit (id) VALUES (NEW.id)"); + assertTrue(trigger.isIfNotExists()); + assertFalse(trigger.isOrReplace()); + assertEquals("trg", trigger.getTrigger().getFullyQualifiedName()); + assertEquals("CURRENT_USER", trigger.getDefiner().getUser().getValue()); + + trigger.setIfNotExists(false); + trigger.setOrReplace(true); + assertEquals("CREATE OR REPLACE DEFINER = CURRENT_USER TRIGGER trg AFTER UPDATE ON t1 " + + "FOR EACH ROW INSERT INTO audit (id) VALUES (NEW.id)", trigger.toString()); + + CreateTrigger replaced = (CreateTrigger) CCJSqlParserUtil.parse( + "CREATE OR REPLACE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW SET NEW.a = 1", + parser -> parser.withDialect(Dialect.MARIADB)); + assertTrue(replaced.isOrReplace()); + assertFalse(replaced.isIfNotExists()); + + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "CREATE OR REPLACE TRIGGER IF NOT EXISTS trg BEFORE INSERT ON t1 " + + "FOR EACH ROW SET NEW.a = 1")); + } + + @Test + void keepsStatementBlocksStructured() throws JSQLParserException { + String sql = "CREATE TRIGGER trg AFTER INSERT ON t1 FOR EACH ROW BEGIN " + + "INSERT INTO audit (id) VALUES (NEW.id); " + + "UPDATE counters SET n = CASE WHEN NEW.a > 0 THEN n + 1 ELSE n END; " + + "DELETE FROM pending WHERE id = NEW.id; END;"; + CreateTrigger trigger = (CreateTrigger) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL)); + Block body = assertInstanceOf(Block.class, trigger.getBody()); + assertEquals(3, body.getStatements().size()); + assertInstanceOf(Insert.class, body.getStatements().get(0)); + // The semicolon after END ends the CREATE TRIGGER statement. + assertFalse(body.hasSemicolonAfterEnd()); + assertEquals(Set.of("t1", "audit", "counters", "pending"), + new HashSet<>(new TablesNamesFinder().getTables((Statement) trigger))); + } + + @Test + void keepsProceduralBodiesAsTokens() throws JSQLParserException { + CreateTrigger trigger = (CreateTrigger) CCJSqlParserUtil.parse( + "CREATE TRIGGER trg3 BEFORE UPDATE ON t1 FOR EACH ROW " + + "BEGIN IF NEW.a < 0 THEN SET NEW.a = 0; END IF; END", + parser -> parser.withDialect(Dialect.MYSQL)); + UnsupportedStatement body = assertInstanceOf(UnsupportedStatement.class, trigger.getBody()); + assertEquals("BEGIN IF NEW.a < 0 THEN SET NEW.a = 0; END IF; END", body.toString()); + assertEquals(Set.of("t1"), + new HashSet<>(new TablesNamesFinder().getTables((Statement) trigger))); + } + + @Test + void splitsScriptsAfterCompoundBodies() throws JSQLParserException { + String script = "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW " + + "BEGIN SET NEW.a = 1; SET NEW.b = 2; END;\n" + + "CREATE TABLE b (y INT);\n" + + "CREATE TRIGGER trg3 BEFORE UPDATE ON t1 FOR EACH ROW " + + "BEGIN IF NEW.a < 0 THEN SET NEW.a = 0; END IF; END;\n" + + "CREATE TABLE c (z INT);"; + Statements statements = CCJSqlParserUtil.parseStatements(script, + parser -> parser.withDialect(Dialect.MYSQL)); + assertEquals(4, statements.size()); + assertInstanceOf(Block.class, ((CreateTrigger) statements.get(0)).getBody()); + assertInstanceOf(CreateTable.class, statements.get(1)); + assertInstanceOf(UnsupportedStatement.class, ((CreateTrigger) statements.get(2)).getBody()); + assertInstanceOf(CreateTable.class, statements.get(3)); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW BEGIN IF NEW.a < 0 THEN SET NEW.a = 0;", + "CREATE TRIGGER trg BEFORE INSERT ON t1 FOR EACH ROW BEGIN SET NEW.a = 1"}) + void rejectsUnterminatedCompoundBodies(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/user/CreateUserTest.java b/src/test/java/net/sf/jsqlparser/statement/create/user/CreateUserTest.java index d0dcbb1af9..c97fe12eb7 100644 --- a/src/test/java/net/sf/jsqlparser/statement/create/user/CreateUserTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/create/user/CreateUserTest.java @@ -9,19 +9,52 @@ */ package net.sf.jsqlparser.statement.create.user; +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; 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.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.List; +import java.util.stream.Collectors; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.user.PasswordLockOption.Kind; +import net.sf.jsqlparser.statement.create.user.PasswordLockOption.Setting; +import net.sf.jsqlparser.statement.role.CreateRole; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; class CreateUserTest { + /** Parses with the dialect, checks both renderers, then reparses the rendered SQL. */ + static T roundTrip(Class type, String sql, Dialect dialect) + throws JSQLParserException { + T statement = assertInstanceOf(type, assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(dialect))); + Statement reparsed = + CCJSqlParserUtil.parse(statement.toString(), parser -> parser.withDialect(dialect)); + assertInstanceOf(type, reparsed); + assertEquals(sql, reparsed.toString()); + return statement; + } + + private static List names(List accounts) { + return accounts.stream().map(UserAccount::toString).collect(Collectors.toList()); + } + @Test void parsesAccountAndPasswordAsStructuredValues() throws JSQLParserException { String sql = "CREATE USER IF NOT EXISTS 'replicator' IDENTIFIED BY 'replpass'"; @@ -68,4 +101,249 @@ void parsesMultipleAccountsAndAuthenticationPlugin() throws JSQLParserException assertEquals(UserAuthentication.Mode.BY_RANDOM_PASSWORD, createUser.getAccounts().get(1).getAuthentication().getMode()); } + + @Test + void parsesQuotedPluginAndHashAsShowCreateUserPrintsThem() throws JSQLParserException { + String sql = "CREATE USER `app`@`%` IDENTIFIED WITH 'caching_sha2_password' " + + "AS '$A$005$hash' REQUIRE NONE PASSWORD EXPIRE DEFAULT ACCOUNT UNLOCK"; + UserAuthentication authentication = + roundTrip(CreateUser.class, sql, Dialect.MYSQL).getAccounts().get(0) + .getAuthentication(); + + assertEquals(UserAuthentication.Mode.WITH_PLUGIN_AS_STRING, authentication.getMode()); + assertEquals("caching_sha2_password", authentication.getPlugin()); + assertEquals("'", authentication.getPluginName().getQuoteStr()); + assertEquals("$A$005$hash", authentication.getCredential().getValue()); + assertSqlCanBeParsedAndDeparsed(sql); + } + + @Test + void parsesHexadecimalHash() throws JSQLParserException { + String sql = "CREATE USER 'app'@'%' IDENTIFIED WITH 'caching_sha2_password' " + + "AS 0x244124303035240A"; + UserAuthentication authentication = + roundTrip(CreateUser.class, sql, Dialect.MYSQL).getAccounts().get(0) + .getAuthentication(); + + assertInstanceOf(HexValue.class, authentication.getCredentialValue()); + assertNull(authentication.getCredential()); + assertEquals("0x244124303035240A", authentication.getCredentialValue().toString()); + roundTrip(CreateUser.class, "CREATE USER app IDENTIFIED WITH mysql_native_password " + + "AS X'2A3132'", Dialect.MYSQL); + } + + @ParameterizedTest + @ValueSource(strings = {"`caching_sha2_password`", "\"caching_sha2_password\"", + "caching_sha2_password"}) + void keepsThePluginQuoteSeparately(String plugin) throws JSQLParserException { + UserAuthentication authentication = roundTrip(CreateUser.class, + "CREATE USER app IDENTIFIED WITH " + plugin, Dialect.MYSQL).getAccounts().get(0) + .getAuthentication(); + + assertEquals("caching_sha2_password", authentication.getPlugin()); + assertEquals(plugin, authentication.getPluginName().toString()); + } + + @Test + void buildsPluginAuthenticationWithHash() { + UserAuthentication authentication = new UserAuthentication() + .withMode(UserAuthentication.Mode.WITH_PLUGIN_AS_STRING) + .withPluginName(new StringValue("'caching_sha2_password'")) + .withCredentialValue(new HexValue("0x2A")); + + assertEquals("IDENTIFIED WITH 'caching_sha2_password' AS 0x2A", authentication.toString()); + assertThrows(IllegalArgumentException.class, + () -> authentication.setCredentialValue(new LongValue(1))); + authentication.setPlugin("mysql_native_password"); + assertEquals("IDENTIFIED WITH mysql_native_password AS 0x2A", authentication.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE USER app IDENTIFIED BY 0x2A", + "CREATE USER app IDENTIFIED WITH caching_sha2_password BY 0x2A"}) + void acceptsHexadecimalOnlyAfterAs(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } + + @Test + void parsesSharedOptionsInClauseOrder() throws JSQLParserException { + String sql = "CREATE USER IF NOT EXISTS 'app'@'10.0.0.%' IDENTIFIED WITH " + + "caching_sha2_password BY 'secret' DEFAULT ROLE 'reader' REQUIRE SSL " + + "WITH MAX_QUERIES_PER_HOUR 100 PASSWORD EXPIRE INTERVAL 90 DAY " + + "FAILED_LOGIN_ATTEMPTS 3 PASSWORD_LOCK_TIME 2 ACCOUNT LOCK COMMENT 'app user'"; + CreateUser createUser = roundTrip(CreateUser.class, sql, Dialect.MYSQL); + + UserOptions options = createUser.getOptions(); + assertEquals(RoleSelection.Kind.ROLES, options.getDefaultRoles().getKind()); + assertEquals(List.of("'reader'"), names(options.getDefaultRoles().getRoles())); + assertEquals(TlsOption.Kind.SSL, options.getTlsOptions().get(0).getKind()); + ResourceLimit limit = options.getResourceLimits().get(0); + assertEquals(ResourceLimit.Kind.MAX_QUERIES_PER_HOUR, limit.getKind()); + assertEquals(100, limit.getValue()); + assertThat(options.getPasswordLockOptions()).extracting(PasswordLockOption::getKind) + .containsExactly(Kind.PASSWORD_EXPIRE, Kind.FAILED_LOGIN_ATTEMPTS, + Kind.PASSWORD_LOCK_TIME, Kind.ACCOUNT_LOCK); + assertThat(options.getPasswordLockOptions()).extracting(PasswordLockOption::getValue) + .containsExactly(90L, 3L, 2L, null); + assertEquals("app user", options.getComment().getValue()); + assertNull(options.getAttribute()); + } + + @Test + void parsesPasswordSettingsAndRepeatedOptions() throws JSQLParserException { + String sql = "CREATE USER app PASSWORD EXPIRE NEVER PASSWORD EXPIRE DEFAULT " + + "PASSWORD EXPIRE PASSWORD HISTORY DEFAULT PASSWORD HISTORY 5 " + + "PASSWORD REUSE INTERVAL DEFAULT PASSWORD REUSE INTERVAL 365 DAY " + + "PASSWORD REQUIRE CURRENT PASSWORD REQUIRE CURRENT DEFAULT " + + "PASSWORD REQUIRE CURRENT OPTIONAL PASSWORD_LOCK_TIME UNBOUNDED " + + "ACCOUNT UNLOCK ACCOUNT LOCK"; + List options = roundTrip(CreateUser.class, sql, Dialect.MYSQL) + .getOptions().getPasswordLockOptions(); + + assertThat(options).extracting(PasswordLockOption::getKind).containsExactly( + Kind.PASSWORD_EXPIRE, Kind.PASSWORD_EXPIRE, Kind.PASSWORD_EXPIRE, + Kind.PASSWORD_HISTORY, Kind.PASSWORD_HISTORY, Kind.PASSWORD_REUSE_INTERVAL, + Kind.PASSWORD_REUSE_INTERVAL, Kind.PASSWORD_REQUIRE_CURRENT, + Kind.PASSWORD_REQUIRE_CURRENT, Kind.PASSWORD_REQUIRE_CURRENT, + Kind.PASSWORD_LOCK_TIME, Kind.ACCOUNT_UNLOCK, Kind.ACCOUNT_LOCK); + assertThat(options).extracting(PasswordLockOption::getSetting).containsExactly( + Setting.NEVER, Setting.DEFAULT, null, Setting.DEFAULT, null, Setting.DEFAULT, + null, null, Setting.DEFAULT, Setting.OPTIONAL, Setting.UNBOUNDED, null, null); + assertEquals(5L, options.get(4).getValue()); + assertEquals(365L, options.get(6).getValue()); + } + + @Test + void parsesTlsOptionsWithOptionalAnd() throws JSQLParserException { + String sql = "CREATE USER 'app'@'%' REQUIRE CIPHER 'EDH-RSA-DES-CBC3-SHA' " + + "AND ISSUER '/C=SE/O=MySQL' SUBJECT '/CN=app'"; + List options = + roundTrip(CreateUser.class, sql, Dialect.MYSQL).getOptions().getTlsOptions(); + + assertThat(options).extracting(TlsOption::getKind).containsExactly(TlsOption.Kind.CIPHER, + TlsOption.Kind.ISSUER, TlsOption.Kind.SUBJECT); + assertThat(options).extracting(TlsOption::isAndKeyword).containsExactly(false, true, + false); + assertEquals("/CN=app", options.get(2).getValue().getValue()); + + assertEquals(TlsOption.Kind.X509, + roundTrip(CreateUser.class, "CREATE USER app REQUIRE X509", Dialect.MYSQL) + .getOptions().getTlsOptions().get(0).getKind()); + assertEquals(TlsOption.Kind.NONE, + roundTrip(CreateUser.class, "CREATE USER app REQUIRE NONE", Dialect.MYSQL) + .getOptions().getTlsOptions().get(0).getKind()); + } + + @Test + void parsesResourceLimitsAndAttribute() throws JSQLParserException { + String sql = "CREATE USER app DEFAULT ROLE r1, 'r2'@'%' WITH MAX_QUERIES_PER_HOUR 10 " + + "MAX_UPDATES_PER_HOUR 5 MAX_CONNECTIONS_PER_HOUR 2 MAX_USER_CONNECTIONS 1 " + + "ATTRIBUTE '{\"team\": \"ops\"}'"; + UserOptions options = roundTrip(CreateUser.class, sql, Dialect.MYSQL).getOptions(); + + assertEquals(List.of("r1", "'r2'@'%'"), names(options.getDefaultRoles().getRoles())); + assertThat(options.getResourceLimits()).extracting(ResourceLimit::getKind) + .containsExactly(ResourceLimit.Kind.MAX_QUERIES_PER_HOUR, + ResourceLimit.Kind.MAX_UPDATES_PER_HOUR, + ResourceLimit.Kind.MAX_CONNECTIONS_PER_HOUR, + ResourceLimit.Kind.MAX_USER_CONNECTIONS); + assertEquals("{\"team\": \"ops\"}", options.getAttribute().getValue()); + assertNull(options.getComment()); + } + + @Test + void parsesMariaDbAccountOptions() throws JSQLParserException { + CreateUser createUser = roundTrip(CreateUser.class, + "CREATE USER 'app'@'%' IDENTIFIED BY 'x' REQUIRE SSL WITH MAX_USER_CONNECTIONS 5 " + + "ACCOUNT LOCK PASSWORD EXPIRE INTERVAL 30 DAY", + Dialect.MARIADB); + + assertEquals(2, createUser.getOptions().getPasswordLockOptions().size()); + } + + @Test + void mySqlOptionsAfterAnUnquotedNameSelectCreateUser() throws JSQLParserException { + for (String sql : List.of("CREATE USER app WITH MAX_USER_CONNECTIONS 1", + "CREATE USER app PASSWORD EXPIRE", "CREATE USER app PASSWORD HISTORY 2", + "CREATE USER app ACCOUNT LOCK", "CREATE USER app COMMENT 'c'")) { + assertInstanceOf(CreateUser.class, CCJSqlParserUtil.parse(sql), sql); + } + // PostgreSQL role attributes keep the PostgreSQL CREATE USER alias + assertInstanceOf(CreateRole.class, CCJSqlParserUtil.parse("CREATE USER app WITH LOGIN")); + assertInstanceOf(CreateRole.class, CCJSqlParserUtil.parse("CREATE USER app PASSWORD 'x'")); + assertInstanceOf(CreateRole.class, CCJSqlParserUtil.parse("CREATE USER app", + parser -> parser.withDialect(Dialect.POSTGRESQL))); + } + + @Test + void omittedOptionsRenderNothing() throws JSQLParserException { + CreateUser createUser = roundTrip(CreateUser.class, "CREATE USER app", Dialect.MYSQL); + + assertTrue(createUser.getOptions().isEmpty()); + createUser.setOptions(null); + assertTrue(createUser.getOptions().isEmpty()); + assertEquals("CREATE USER app", createUser.toString()); + } + + @Test + void buildsOptions() { + CreateUser createUser = new CreateUser() + .addAccounts(new UserAccount().withUser(new StringValue("app")) + .withHost(new StringValue("%"))) + .withOptions(new UserOptions() + .addTlsOptions(new TlsOption(TlsOption.Kind.SUBJECT, + new StringValue("/CN=app"))) + .addResourceLimits( + new ResourceLimit(ResourceLimit.Kind.MAX_USER_CONNECTIONS, 3)) + .addPasswordLockOptions( + new PasswordLockOption(Kind.PASSWORD_EXPIRE).withValue(30L), + new PasswordLockOption(Kind.ACCOUNT_LOCK)) + .withComment(new StringValue("svc"))); + + assertDeparse(createUser, "CREATE USER 'app'@'%' REQUIRE SUBJECT '/CN=app' " + + "WITH MAX_USER_CONNECTIONS 3 PASSWORD EXPIRE INTERVAL 30 DAY ACCOUNT LOCK " + + "COMMENT 'svc'"); + assertEquals("REQUIRE SUBJECT '/CN=app' WITH MAX_USER_CONNECTIONS 3 " + + "PASSWORD EXPIRE INTERVAL 30 DAY ACCOUNT LOCK COMMENT 'svc'", + createUser.getOptions().toString()); + } + + @Test + void reportsSchemaChangeWithoutTables() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("CREATE USER app REQUIRE SSL ACCOUNT LOCK"); + + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(TablesNamesFinder.findTables(statement.toString())).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE USER app DEFAULT ROLE ALL", + "CREATE USER app DEFAULT ROLE NONE", + "CREATE USER app REQUIRE AND SSL", + "CREATE USER app REQUIRE CIPHER", + "CREATE USER app REQUIRE SSL 'x'", + "CREATE USER app REQUIRE NONE AND SSL", + "CREATE USER app PASSWORD EXPIRE INTERVAL 5 MONTH", + "CREATE USER app PASSWORD HISTORY", + "CREATE USER app COMMENT 'x' ATTRIBUTE '{}'", + "CREATE USER app ACCOUNT LOCK REQUIRE SSL", + "CREATE USER app IDENTIFIED BY 'x' REPLACE 'y'", + "CREATE USER app IDENTIFIED BY 'x' RETAIN CURRENT PASSWORD", + "CREATE USER app DISCARD OLD PASSWORD" + }) + void rejectsOptionsOutsideTheGrammar(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + } + + @Test + void optionWordsRemainIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT account, require, expire, reuse, optional, retain, " + + "old, unlock, ssl, x509, cipher, issuer, subject, attribute, " + + "failed_login_attempts, password_lock_time, max_user_connections FROM t"); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/create/user/MySqlAccountNameTest.java b/src/test/java/net/sf/jsqlparser/statement/create/user/MySqlAccountNameTest.java new file mode 100644 index 0000000000..d92850a0a0 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/user/MySqlAccountNameTest.java @@ -0,0 +1,140 @@ +/*- + * #%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.user; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; +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 java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.MySqlDefiner; +import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; +import net.sf.jsqlparser.statement.create.view.CreateView; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import java.util.stream.Stream; + +class MySqlAccountNameTest { + + private static final Consumer MYSQL = p -> p.withDialect(Dialect.MYSQL); + private static final Consumer NO_DIALECT = p -> { + }; + + /** SQL spelling, user value, user quote, host value, host quote. */ + static Stream accounts() { + return Stream.of( + Arguments.of("app", "app", "", null, null), + Arguments.of("app@localhost", "app", "", "localhost", ""), + Arguments.of("app@'%'", "app", "", "%", "'"), + Arguments.of("app@'10.0.0.%'", "app", "", "10.0.0.%", "'"), + Arguments.of("'app'@localhost", "app", "'", "localhost", ""), + Arguments.of("'app'@'%'", "app", "'", "%", "'"), + Arguments.of("`app`@`%`", "app", "`", "%", "`"), + Arguments.of("\"app\"@\"%\"", "app", "\"", "%", "\""), + Arguments.of("'app'", "app", "'", null, null), + Arguments.of("`my app`@'%'", "my app", "`", "%", "'")); + } + + @ParameterizedTest + @MethodSource("accounts") + void createUserSplitsEveryAccountSpelling(String account, String user, String userQuote, + String host, String hostQuote) throws JSQLParserException { + for (Consumer mode : java.util.Arrays.asList(MYSQL, NO_DIALECT)) { + String sql = "CREATE USER " + account + " IDENTIFIED BY 'x'"; + CreateUser createUser = assertInstanceOf(CreateUser.class, + assertSqlCanBeParsedAndDeparsed(sql, true, mode)); + assertEquals(sql, createUser.toString()); + assertEquals(sql, deparse(createUser)); + assertPart(createUser.getAccounts().get(0).getUser(), user, userQuote); + assertPart(createUser.getAccounts().get(0).getHost(), host, hostQuote); + } + } + + @ParameterizedTest + @MethodSource("accounts") + void definerSplitsEveryAccountSpelling(String account, String user, String userQuote, + String host, String hostQuote) throws JSQLParserException { + String view = "CREATE DEFINER = " + account + " VIEW v AS SELECT 1"; + CreateView createView = assertInstanceOf(CreateView.class, + assertSqlCanBeParsedAndDeparsed(view, true, MYSQL)); + MySqlDefiner definer = createView.getMySqlOptions().getDefiner(); + assertPart(definer.getUser(), user, userQuote); + assertPart(definer.getHost(), host, hostQuote); + + String trigger = "CREATE DEFINER = " + account + + " TRIGGER trg BEFORE INSERT ON t FOR EACH ROW SET NEW.a = 1"; + CreateTrigger createTrigger = assertInstanceOf(CreateTrigger.class, + assertSqlCanBeParsedAndDeparsed(trigger, true, MYSQL)); + assertEquals(trigger, createTrigger.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE USER app@", "CREATE USER @host", "CREATE USER 'app'@"}) + void rejectsMalformedAccounts(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @org.junit.jupiter.api.Test + void keepsDoubleQuotesWithoutDialect() throws JSQLParserException { + // before, the double quotes were dropped and the account rendered as app@% + String sql = "CREATE USER \"app\"@\"%\" IDENTIFIED BY 'x'"; + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + assertEquals(sql, CCJSqlParserUtil.parse(sql, MYSQL).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP USER IF EXISTS CURRENT_USER()", + "RENAME USER CURRENT_USER() TO app2", "SET PASSWORD FOR CURRENT_USER() = 'x'", + "GRANT 'reader' TO CURRENT_USER()"}) + void userListsTakeCurrentUserWithParentheses(String sql) throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed(sql, true, MYSQL); + assertEquals(sql, CCJSqlParserUtil.parse(sql, MYSQL).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE ROLE CURRENT_USER()", "DROP ROLE CURRENT_USER()", + "SET ROLE CURRENT_USER()", "SET DEFAULT ROLE ALL TO CURRENT_USER()", + "GRANT CURRENT_USER() TO app", "ALTER USER app DEFAULT ROLE CURRENT_USER()"}) + void roleListsRejectCurrentUserWithParentheses(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @org.junit.jupiter.api.Test + void definerCurrentUserIsUnchanged() throws JSQLParserException { + CreateView view = assertInstanceOf(CreateView.class, assertSqlCanBeParsedAndDeparsed( + "CREATE DEFINER = CURRENT_USER() VIEW v AS SELECT 1", true, MYSQL)); + assertNull(view.getMySqlOptions().getDefiner().getHost()); + } + + private static void assertPart(StringValue part, String value, String quote) { + if (value == null) { + assertNull(part); + return; + } + assertEquals(value, part.getValue()); + assertEquals(quote, part.getQuoteStr()); + } + + private static String deparse(CreateUser createUser) { + StringBuilder builder = new StringBuilder(); + createUser.accept(new StatementDeParser(builder), null); + return builder.toString(); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/create/user/MySqlMultiFactorAuthenticationTest.java b/src/test/java/net/sf/jsqlparser/statement/create/user/MySqlMultiFactorAuthenticationTest.java new file mode 100644 index 0000000000..aace7823bb --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/user/MySqlMultiFactorAuthenticationTest.java @@ -0,0 +1,483 @@ +/*- + * #%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.user; + +import static net.sf.jsqlparser.statement.create.user.CreateUserTest.roundTrip; +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.alter.AlterUser; +import net.sf.jsqlparser.statement.create.user.UserAuthentication.Mode; +import net.sf.jsqlparser.statement.create.user.UserFactorOperation.Operation; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL 8.4 multi-factor authentication clauses of CREATE USER and ALTER USER. */ +class MySqlMultiFactorAuthenticationTest { + + private static List operations(UserAccount account) { + return account.getFactorOperations().stream() + .map(operation -> operation.getOperation() + ":" + operation.getFactor()) + .collect(Collectors.toList()); + } + + private static UserAccount alteredAccount(String sql) throws JSQLParserException { + AlterUser alterUser = roundTrip(AlterUser.class, sql, Dialect.MYSQL); + assertEquals(1, alterUser.getAccounts().size()); + return alterUser.getAccounts().get(0); + } + + @Test + void createsAnAccountWithThreeFactors() throws JSQLParserException { + CreateUser createUser = roundTrip(CreateUser.class, + "CREATE USER u1 IDENTIFIED WITH caching_sha2_password BY 'p' " + + "AND IDENTIFIED WITH authentication_ldap_sasl AS 'uid=u' " + + "AND IDENTIFIED WITH authentication_webauthn", + Dialect.MYSQL); + + UserAccount account = createUser.getAccounts().get(0); + assertEquals(Mode.WITH_PLUGIN_BY_PASSWORD, account.getAuthentication().getMode()); + assertNull(account.getAuthentication().getInitialAuthentication()); + List additional = account.getAdditionalAuthentications(); + assertEquals(2, additional.size()); + assertEquals(Mode.WITH_PLUGIN_AS_STRING, additional.get(0).getMode()); + assertEquals("authentication_ldap_sasl", additional.get(0).getPlugin()); + assertEquals("uid=u", additional.get(0).getCredential().getValue()); + assertEquals(Mode.WITH_PLUGIN, additional.get(1).getMode()); + assertEquals("authentication_webauthn", additional.get(1).getPlugin()); + assertTrue(account.getFactorOperations().isEmpty()); + assertThrows(UnsupportedOperationException.class, () -> additional.add(null)); + } + + @Test + void createsFurtherFactorsWithoutAFirstOne() throws JSQLParserException { + CreateUser createUser = roundTrip(CreateUser.class, + "CREATE USER u3 AND IDENTIFIED BY 'q' AND IDENTIFIED BY RANDOM PASSWORD", + Dialect.MYSQL); + + UserAccount account = createUser.getAccounts().get(0); + assertNull(account.getAuthentication()); + assertEquals(Arrays.asList(Mode.BY_PASSWORD, Mode.BY_RANDOM_PASSWORD), + account.getAdditionalAuthentications().stream().map(UserAuthentication::getMode) + .collect(Collectors.toList())); + } + + @Test + void keepsFactorsPerAccountBeforeTheOptions() throws JSQLParserException { + CreateUser createUser = roundTrip(CreateUser.class, + "CREATE USER IF NOT EXISTS 'u3'@'localhost' IDENTIFIED BY 'p' AND IDENTIFIED BY 'q', " + + "u4 IDENTIFIED BY 'p' AND IDENTIFIED WITH 'authentication_ldap_sasl' AS 0x41, " + + "u5 DEFAULT ROLE r1 REQUIRE SSL ACCOUNT LOCK", + Dialect.MYSQL); + + assertEquals(3, createUser.getAccounts().size()); + assertEquals(1, createUser.getAccounts().get(0).getAdditionalAuthentications().size()); + UserAuthentication second = + createUser.getAccounts().get(1).getAdditionalAuthentications().get(0); + assertEquals("'", second.getPluginName().getQuoteStr()); + assertInstanceOf(HexValue.class, second.getCredentialValue()); + assertTrue(createUser.getAccounts().get(2).getAdditionalAuthentications().isEmpty()); + assertEquals("DEFAULT ROLE r1 REQUIRE SSL ACCOUNT LOCK", + createUser.getOptions().toString()); + } + + @Test + void createsAPasswordlessAccountWithInitialAuthentication() throws JSQLParserException { + CreateUser createUser = roundTrip(CreateUser.class, + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'p'", + Dialect.MYSQL); + + UserAuthentication authentication = createUser.getAccounts().get(0).getAuthentication(); + assertEquals(Mode.WITH_PLUGIN, authentication.getMode()); + assertEquals("authentication_webauthn", authentication.getPlugin()); + UserAuthentication initial = authentication.getInitialAuthentication(); + assertEquals(Mode.BY_PASSWORD, initial.getMode()); + assertEquals("p", initial.getCredential().getValue()); + assertNull(initial.getInitialAuthentication()); + + assertEquals(Mode.BY_RANDOM_PASSWORD, + roundTrip(CreateUser.class, + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY RANDOM PASSWORD, " + + "u4 IDENTIFIED BY 'x' PASSWORD EXPIRE", + Dialect.MYSQL).getAccounts().get(0).getAuthentication() + .getInitialAuthentication().getMode()); + UserAuthentication hash = roundTrip(CreateUser.class, + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED WITH caching_sha2_password AS 0x41", + Dialect.MYSQL).getAccounts().get(0).getAuthentication() + .getInitialAuthentication(); + assertEquals(Mode.WITH_PLUGIN_AS_STRING, hash.getMode()); + assertEquals("caching_sha2_password", hash.getPlugin()); + assertInstanceOf(HexValue.class, hash.getCredentialValue()); + } + + @Test + void addsFactors() throws JSQLParserException { + UserAccount account = alteredAccount( + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED WITH authentication_ldap_sasl AS 'uid=u' " + + "ADD 3 FACTOR IDENTIFIED BY RANDOM PASSWORD"); + + assertNull(account.getAuthentication()); + assertTrue(account.getAdditionalAuthentications().isEmpty()); + assertEquals(Arrays.asList("ADD:2", "ADD:3"), operations(account)); + UserFactorOperation first = account.getFactorOperations().get(0); + assertTrue(first.getOperation().hasAuthentication()); + assertFalse(first.getOperation().isRegistration()); + assertEquals(Mode.WITH_PLUGIN_AS_STRING, first.getAuthentication().getMode()); + assertEquals("authentication_ldap_sasl", first.getAuthentication().getPlugin()); + assertNull(first.getChallengeResponse()); + assertEquals(Mode.BY_RANDOM_PASSWORD, + account.getFactorOperations().get(1).getAuthentication().getMode()); + } + + @Test + void modifiesFactors() throws JSQLParserException { + UserAccount account = alteredAccount( + "ALTER USER u1 MODIFY 2 FACTOR IDENTIFIED WITH authentication_webauthn"); + + assertEquals(Arrays.asList("MODIFY:2"), operations(account)); + assertEquals(Mode.WITH_PLUGIN, + account.getFactorOperations().get(0).getAuthentication().getMode()); + + assertEquals(Arrays.asList("MODIFY:2", "MODIFY:3"), + operations(alteredAccount("ALTER USER u1 MODIFY 2 FACTOR IDENTIFIED BY 'p' " + + "MODIFY 3 FACTOR IDENTIFIED WITH authentication_webauthn BY 'x'"))); + } + + @Test + void dropsFactors() throws JSQLParserException { + UserAccount account = alteredAccount("ALTER USER u1 DROP 2 FACTOR DROP 3 FACTOR"); + + assertEquals(Arrays.asList("DROP:2", "DROP:3"), operations(account)); + UserFactorOperation drop = account.getFactorOperations().get(0); + assertFalse(drop.getOperation().hasAuthentication()); + assertNull(drop.getAuthentication()); + assertEquals(Arrays.asList("DROP:3"), + operations(alteredAccount("ALTER USER CURRENT_USER() DROP 3 FACTOR"))); + } + + @Test + void changesFactorsOfSeveralAccountsBeforeTheOptions() throws JSQLParserException { + AlterUser alterUser = roundTrip(AlterUser.class, + "ALTER USER IF EXISTS 'u1'@'localhost' ADD 2 FACTOR IDENTIFIED BY 'p', " + + "u2 IDENTIFIED BY 'x' REPLACE 'y', u3 DROP 2 FACTOR DROP 3 FACTOR, u4 " + + "REQUIRE NONE PASSWORD EXPIRE NEVER COMMENT 'c'", + Dialect.MYSQL); + + assertTrue(alterUser.isIfExists()); + List accounts = alterUser.getAccounts(); + assertEquals(Arrays.asList("ADD:2"), operations(accounts.get(0))); + assertTrue(accounts.get(1).getFactorOperations().isEmpty()); + assertEquals("y", accounts.get(1).getAuthentication().getCurrentCredential().getValue()); + assertEquals(Arrays.asList("DROP:2", "DROP:3"), operations(accounts.get(2))); + assertTrue(accounts.get(3).getFactorOperations().isEmpty()); + assertEquals("REQUIRE NONE PASSWORD EXPIRE NEVER COMMENT 'c'", + alterUser.getOptions().toString()); + } + + @Test + void registersADevice() throws JSQLParserException { + UserFactorOperation initiate = + alteredAccount("ALTER USER u1 2 FACTOR INITIATE REGISTRATION") + .getFactorOperations().get(0); + assertEquals(Operation.INITIATE_REGISTRATION, initiate.getOperation()); + assertEquals(2, initiate.getFactor()); + assertTrue(initiate.getOperation().isRegistration()); + assertNull(initiate.getAuthentication()); + assertNull(initiate.getChallengeResponse()); + + UserFactorOperation finish = alteredAccount( + "ALTER USER 'u1'@'localhost' 3 FACTOR FINISH REGISTRATION " + + "SET CHALLENGE_RESPONSE AS 'x'") + .getFactorOperations().get(0); + assertEquals(Operation.FINISH_REGISTRATION, finish.getOperation()); + assertEquals(3, finish.getFactor()); + assertEquals("x", ((StringValue) finish.getChallengeResponse()).getValue()); + assertInstanceOf(HexValue.class, alteredAccount( + "ALTER USER u1 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE AS 0x41") + .getFactorOperations().get(0).getChallengeResponse()); + + AlterUser unregister = roundTrip(AlterUser.class, + "ALTER USER IF EXISTS u1 2 FACTOR UNREGISTER", Dialect.MYSQL); + assertTrue(unregister.isIfExists()); + assertTrue(unregister.getOptions().isEmpty()); + assertEquals(Arrays.asList("UNREGISTER:2"), operations(unregister.getAccounts().get(0))); + } + + @ParameterizedTest + @ValueSource(strings = { + "ALTER USER USER() 2 FACTOR INITIATE REGISTRATION", + "ALTER USER USER() 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE AS 'x'", + "ALTER USER USER() 3 FACTOR UNREGISTER" + }) + void registersADeviceOfTheCurrentUser(String sql) throws JSQLParserException { + AlterUser alterUser = roundTrip(AlterUser.class, sql, Dialect.MYSQL); + + assertTrue(alterUser.isUserFunction()); + UserAccount account = alterUser.getAccounts().get(0); + assertNull(account.getAuthentication()); + assertEquals(1, account.getFactorOperations().size()); + assertTrue(account.getFactorOperations().get(0).getOperation().isRegistration()); + + assertEquals(1, roundTrip(AlterUser.class, sql.replace("USER()", "CURRENT_USER()"), + Dialect.MYSQL).getAccounts().get(0).getFactorOperations().size()); + assertEquals(1, roundTrip(AlterUser.class, sql.replace("USER()", "CURRENT_USER"), + Dialect.MYSQL).getAccounts().get(0).getFactorOperations().size()); + } + + @Test + void leavesTheFactorNumberToTheServer() throws JSQLParserException { + // MySQL reads any integer here and reports "Incorrect nth factor value" on execution + assertEquals(Arrays.asList("ADD:1"), + operations(alteredAccount("ALTER USER u1 ADD 1 FACTOR IDENTIFIED BY 'p'"))); + assertEquals(Arrays.asList("DROP:2147483647"), + operations(alteredAccount("ALTER USER u1 DROP 2147483647 FACTOR"))); + assertEquals(Arrays.asList("UNREGISTER:4"), + operations(alteredAccount("ALTER USER u1 4 FACTOR UNREGISTER"))); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE USER u1 IDENTIFIED BY 'p' AND IDENTIFIED WITH authentication_ldap_sasl BY 'q'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED WITH caching_sha2_password AS 'h'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED WITH authentication_ldap_sasl BY RANDOM PASSWORD", + "ALTER USER u1 MODIFY 2 FACTOR IDENTIFIED BY 'p' MODIFY 3 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 DROP 2 FACTOR, u2 DROP 3 FACTOR ACCOUNT UNLOCK", + "ALTER USER u1 2 FACTOR INITIATE REGISTRATION", + "ALTER USER u1 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE AS 'x'", + "ALTER USER u1 2 FACTOR UNREGISTER" + }) + void parsesInDefaultModeAndMariaDb(String sql) throws JSQLParserException { + Class type = + sql.startsWith("CREATE") ? CreateUser.class : AlterUser.class; + roundTrip(type, sql, Dialect.MARIADB); + assertInstanceOf(type, assertSqlCanBeParsedAndDeparsed(sql, false)); + assertEquals(sql.toLowerCase(), assertInstanceOf(type, + CCJSqlParserUtil.parse(sql.toLowerCase())).toString().toLowerCase()); + } + + @Test + void endsAtTheStatementBoundary() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "ALTER USER u1 2 FACTOR INITIATE REGISTRATION; " + + "ALTER USER u1 DROP 2 FACTOR DROP 3 FACTOR; " + + "CREATE USER u2 IDENTIFIED BY 'p' AND IDENTIFIED BY 'q'; " + + "CREATE USER u3 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY RANDOM PASSWORD; SELECT 1", + parser -> parser.withDialect(Dialect.MYSQL)); + + assertEquals(5, statements.size()); + assertInstanceOf(AlterUser.class, statements.get(0)); + assertInstanceOf(AlterUser.class, statements.get(1)); + assertInstanceOf(CreateUser.class, statements.get(2)); + assertInstanceOf(CreateUser.class, statements.get(3)); + assertInstanceOf(PlainSelect.class, statements.get(4)); + } + + @Test + void buildsAndDeparses() { + CreateUser createUser = new CreateUser().addAccounts( + new UserAccount().withUser(new StringValue("app").setQuoteStr("")) + .withAuthentication(new UserAuthentication().withMode(Mode.BY_PASSWORD) + .withCredential(new StringValue("p"))) + .addAdditionalAuthentications(new UserAuthentication() + .withMode(Mode.WITH_PLUGIN).withPlugin("authentication_webauthn")), + new UserAccount().withUser(new StringValue("key").setQuoteStr("")) + .withAuthentication(new UserAuthentication().withMode(Mode.WITH_PLUGIN) + .withPlugin("authentication_webauthn").withInitialAuthentication( + new UserAuthentication() + .withMode(Mode.BY_RANDOM_PASSWORD)))); + assertDeparse(createUser, + "CREATE USER app IDENTIFIED BY 'p' AND IDENTIFIED WITH authentication_webauthn, " + + "key IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY RANDOM PASSWORD"); + + UserAccount account = new UserAccount().withUser(new StringValue("app").setQuoteStr("")) + .addFactorOperations(new UserFactorOperation(Operation.DROP, 2)); + AlterUser alterUser = new AlterUser().addAccounts(account); + assertDeparse(alterUser, "ALTER USER app DROP 2 FACTOR"); + + account.withFactorOperations(Arrays.asList( + new UserFactorOperation().withOperation(Operation.MODIFY).withFactor(3) + .withAuthentication(new UserAuthentication().withMode(Mode.BY_PASSWORD) + .withCredential(new StringValue("p"))))); + assertDeparse(alterUser, "ALTER USER app MODIFY 3 FACTOR IDENTIFIED BY 'p'"); + + account.withFactorOperations(Arrays.asList( + new UserFactorOperation(Operation.FINISH_REGISTRATION, 2) + .withChallengeResponse(new HexValue("0x41")))); + assertDeparse(alterUser, + "ALTER USER app 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE AS 0x41"); + + account.setFactorOperations(null); + account.withAdditionalAuthentications(null); + assertEquals("ALTER USER app", alterUser.toString()); + UserFactorOperation operation = new UserFactorOperation(Operation.UNREGISTER, 2); + assertThrows(IllegalArgumentException.class, + () -> operation.setChallengeResponse(new LongValue(1))); + } + + @Test + void reportsSchemaChangeWithoutTables() throws JSQLParserException { + for (String sql : Arrays.asList( + "CREATE USER u1 IDENTIFIED BY 'p' AND IDENTIFIED BY 'q'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 2 FACTOR UNREGISTER")) { + Statement statement = + CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)); + + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(new TablesNamesFinder().getTables(statement)).isEmpty(); + assertThat(Validation.validate(Arrays.asList(DatabaseType.MYSQL), sql)).isEmpty(); + String[] visited = new String[1]; + statement.accept(new StatementVisitorAdapter() { + @Override + public Void visit(CreateUser createUser, S context) { + visited[0] = createUser.toString(); + return null; + } + + @Override + public Void visit(AlterUser alterUser, S context) { + visited[0] = alterUser.toString(); + return null; + } + }, null); + assertEquals(sql, visited[0]); + } + } + + @ParameterizedTest + @ValueSource(strings = { + // CREATE USER: at most three factors, INITIAL AUTHENTICATION only after a bare plugin + "CREATE USER u1 IDENTIFIED BY 'p' AND IDENTIFIED BY 'q' AND IDENTIFIED BY 'r' " + + "AND IDENTIFIED BY 's'", + "CREATE USER u1 AND IDENTIFIED BY 'p' AND IDENTIFIED BY 'q' AND IDENTIFIED BY 'r'", + "CREATE USER u1 IDENTIFIED BY 'p' AND BY 'q'", + "CREATE USER u1 IDENTIFIED BY 'p' AND", + "CREATE USER u1 IDENTIFIED BY 'p', IDENTIFIED BY 'q'", + "CREATE USER u1 IDENTIFIED BY 'p' AND DISCARD OLD PASSWORD", + "CREATE USER u1 IDENTIFIED BY 'p' ADD 2 FACTOR IDENTIFIED BY 'q'", + "CREATE USER u1 ADD 2 FACTOR IDENTIFIED BY 'q'", + "CREATE USER u1 2 FACTOR INITIATE REGISTRATION", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED WITH caching_sha2_password", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED WITH caching_sha2_password BY 'p'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn BY 'x' " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'p'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn AS 'x' " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'p'", + "CREATE USER u2 IDENTIFIED BY 'x' INITIAL AUTHENTICATION IDENTIFIED BY 'p'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'p' AND IDENTIFIED BY 'q'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'p' " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'q'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn INITIAL AUTHENTICATION BY 'p'", + "CREATE USER u2 IDENTIFIED WITH authentication_webauthn INITIAL IDENTIFIED BY 'p'", + "CREATE USER u2 INITIAL AUTHENTICATION IDENTIFIED BY 'p'", + // ALTER USER: one or two changes of the same kind per account + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' ADD 3 FACTOR IDENTIFIED BY 'q' " + + "ADD 3 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' 3 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p', 3 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' MODIFY 3 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' DROP 3 FACTOR", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' REPLACE 'x'", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' RETAIN CURRENT PASSWORD", + "ALTER USER u1 ADD 2 FACTOR IDENTIFIED BY 'p' AND IDENTIFIED BY 'q'", + "ALTER USER u1 ADD 2 FACTOR", + "ALTER USER u1 ADD 2 FACTOR DISCARD OLD PASSWORD", + "ALTER USER u1 ADD FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 ADD 2.0 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 ADD '2' FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 ADD 0x2 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 ADD 2147483648 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 ADD 99999999999999999999 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 ADD 2 FACTORS IDENTIFIED BY 'p'", + "ALTER USER u1 MODIFY 2 FACTOR", + "ALTER USER u1 MODIFY 2 FACTOR IDENTIFIED BY 'p' ADD 3 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 MODIFY 2 FACTOR IDENTIFIED BY 'p' MODIFY 3 FACTOR IDENTIFIED BY 'p' " + + "MODIFY 3 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 DROP 2 FACTOR 3 FACTOR", + "ALTER USER u1 DROP 2 FACTOR, 3 FACTOR", + "ALTER USER u1 DROP 2 FACTOR DROP 3 FACTOR DROP 3 FACTOR", + "ALTER USER u1 DROP 2 FACTOR ADD 3 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 DROP 2 FACTOR IDENTIFIED BY 'p'", + "ALTER USER u1 DROP FACTOR", + "ALTER USER u1 DROP 2", + "ALTER USER u1 IDENTIFIED BY 'p' ADD 2 FACTOR IDENTIFIED BY 'q'", + "ALTER USER u1 IDENTIFIED BY 'p' AND IDENTIFIED BY 'q'", + "ALTER USER u1 IDENTIFIED WITH authentication_webauthn " + + "INITIAL AUTHENTICATION IDENTIFIED BY 'p'", + "ALTER USER u1 DROP 2 FACTOR DEFAULT ROLE r1", + "ALTER USER USER() ADD 2 FACTOR IDENTIFIED BY 'p'", + "ALTER USER USER() DROP 2 FACTOR", + // registration: one account, one step, nothing else + "ALTER USER u1 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE = 'x'", + "ALTER USER u1 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE 'x'", + "ALTER USER u1 2 FACTOR FINISH REGISTRATION SET CHALLENGE_RESPONSE AS 1", + "ALTER USER u1 2 FACTOR FINISH REGISTRATION", + "ALTER USER u1 2 FACTOR INITIATE REGISTRATION SET CHALLENGE_RESPONSE AS 'x'", + "ALTER USER u1 FACTOR UNREGISTER", + "ALTER USER u1 2 FACTOR REGISTER", + "ALTER USER u1 2 FACTOR INITIATE", + "ALTER USER u1 2 FACTOR", + "ALTER USER u1 2 FACTOR UNREGISTER, u2 2 FACTOR UNREGISTER", + "ALTER USER u1, u2 2 FACTOR UNREGISTER", + "ALTER USER u1 2 FACTOR UNREGISTER ACCOUNT LOCK", + "ALTER USER u1 2 FACTOR UNREGISTER 3 FACTOR UNREGISTER", + "ALTER USER u1 IDENTIFIED BY 'p' 2 FACTOR UNREGISTER", + "ALTER USER u1 DROP 2 FACTOR 3 FACTOR UNREGISTER", + "ALTER USER USER() IDENTIFIED BY 'p' 2 FACTOR UNREGISTER" + }) + void rejectsSyntaxOutsideTheStatementDefinition(String sql) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL))); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void factorWordsRemainIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT factor, initial, authentication, initiate, " + + "registration, finish, unregister, challenge_response FROM t"); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE factor (initial INT, registration INT)"); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/cursor/PostgreSqlCursorTest.java b/src/test/java/net/sf/jsqlparser/statement/cursor/PostgreSqlCursorTest.java new file mode 100644 index 0000000000..1e88d6e576 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/cursor/PostgreSqlCursorTest.java @@ -0,0 +1,524 @@ +/*- + * #%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.cursor; + +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.DeclareStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterSession; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.statement.select.TableStatement; +import net.sf.jsqlparser.statement.select.Values; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlCursorTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + private static final Consumer NO_DIALECT = parser -> { + }; + private static final Consumer UNSUPPORTED = + parser -> parser.withUnsupportedStatements(true); + + @ParameterizedTest + @ValueSource(strings = { + "DECLARE c CURSOR FOR SELECT * FROM t", + "DECLARE c BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR SELECT 1", + "DECLARE c ASENSITIVE SCROLL CURSOR WITHOUT HOLD FOR SELECT a FROM t WHERE a > 0", + "DECLARE c CURSOR FOR VALUES (1), (2)", + "DECLARE c CURSOR FOR TABLE t", + "DECLARE c SCROLL BINARY CURSOR FOR SELECT 1", + "DECLARE c SCROLL NO SCROLL CURSOR FOR SELECT 1", + "DECLARE c BINARY BINARY CURSOR FOR SELECT 1", + "DECLARE c CURSOR WITH HOLD FOR WITH x AS (SELECT a FROM t) SELECT a FROM x", + "DECLARE c CURSOR FOR SELECT a FROM t UNION SELECT a FROM u ORDER BY a", + "DECLARE c CURSOR FOR SELECT a FROM t FOR UPDATE", + "DECLARE c CURSOR FOR (SELECT 1)", + "DECLARE \"Cur\" CURSOR FOR SELECT 1", + "DECLARE scroll SCROLL CURSOR FOR SELECT 1", + "DECLARE cursor CURSOR FOR SELECT 1", + "FETCH c", + "FETCH NEXT FROM c", + "FETCH PRIOR IN c", + "FETCH FIRST FROM c", + "FETCH LAST c", + "FETCH ABSOLUTE -1 FROM c", + "FETCH RELATIVE 3 IN c", + "FETCH RELATIVE 0 c", + "FETCH 5 FROM c", + "FETCH -2 c", + "FETCH ALL c", + "FETCH ALL IN c", + "FETCH FORWARD c", + "FETCH FORWARD 10 IN c", + "FETCH FORWARD ALL FROM c", + "FETCH BACKWARD FROM c", + "FETCH BACKWARD 2 FROM c", + "FETCH BACKWARD ALL c", + "FETCH FROM c", + "FETCH IN c", + "FETCH ABSOLUTE 2147483647 FROM c", + "FETCH ABSOLUTE -2147483647 FROM c", + "FETCH next", + "FETCH NEXT next", + "FETCH FROM next", + "FETCH forward", + "FETCH ABSOLUTE 1 relative", + "FETCH \"c\"", + "MOVE ABSOLUTE 2 IN c", + "MOVE c", + "MOVE BACKWARD ALL FROM c", + "MOVE NEXT c", + "MOVE -1 IN c", + "MOVE LAST FROM c", + "MOVE absolute", + "CLOSE c", + "CLOSE ALL", + "CLOSE \"all\"", + "CLOSE next", + "CLOSE move", + "CLOSE cursor"}) + void parsesWithPostgreSqlAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(POSTGRESQL, NO_DIALECT)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void normalizesSignsLeadingZerosAndKeywordCase() throws JSQLParserException { + assertNormalized("FETCH 5 c", "FETCH +5 c"); + assertNormalized("FETCH -3 c", "FETCH - 3 c"); + assertNormalized("FETCH ABSOLUTE 7 c", "FETCH ABSOLUTE 007 c"); + assertNormalized("MOVE FORWARD ALL IN c", "move forward all in c"); + assertNormalized("DECLARE c NO SCROLL CURSOR WITH HOLD FOR SELECT 1", + "declare c no scroll cursor with hold for select 1"); + assertNormalized("CLOSE ALL", "close all"); + // PostgreSQL 16 and later take digit separators + assertEquals("FETCH 1000 c", + CCJSqlParserUtil.parse("FETCH 1_000 c", POSTGRESQL).toString()); + } + + @Test + void keepsTheDeclareOptionsAndTheQuery() throws JSQLParserException { + DeclareCursorStatement declare = (DeclareCursorStatement) parse( + "DECLARE c BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR SELECT a FROM t"); + assertEquals("c", declare.getCursorName()); + assertEquals(Arrays.asList(CursorOption.BINARY, CursorOption.INSENSITIVE, + CursorOption.NO_SCROLL), declare.getOptions()); + assertEquals(DeclareCursorStatement.Holdability.WITH_HOLD, declare.getHoldability()); + assertInstanceOf(PlainSelect.class, declare.getQuery()); + assertEquals("SELECT a FROM t", declare.getQuery().toString()); + + DeclareCursorStatement plain = (DeclareCursorStatement) parse( + "DECLARE c SCROLL SCROLL CURSOR WITHOUT HOLD FOR VALUES (1)"); + assertEquals(Arrays.asList(CursorOption.SCROLL, CursorOption.SCROLL), plain.getOptions()); + assertEquals(DeclareCursorStatement.Holdability.WITHOUT_HOLD, plain.getHoldability()); + assertInstanceOf(Values.class, plain.getQuery()); + + DeclareCursorStatement table = + (DeclareCursorStatement) parse("DECLARE \"C\" CURSOR FOR TABLE t"); + assertEquals("\"C\"", table.getCursorName()); + assertThat(table.getOptions()).isEmpty(); + assertNull(table.getHoldability()); + assertInstanceOf(TableStatement.class, table.getQuery()); + } + + @Test + void keepsTheFetchDirection() throws JSQLParserException { + assertFetch("FETCH c", FetchCursorStatement.Kind.FETCH, null, null, false, null, "c"); + assertFetch("FETCH NEXT FROM c", FetchCursorStatement.Kind.FETCH, FetchDirection.NEXT, + null, false, FetchCursorStatement.FromKeyword.FROM, "c"); + assertFetch("FETCH ABSOLUTE -1 IN c", FetchCursorStatement.Kind.FETCH, + FetchDirection.ABSOLUTE, -1L, false, FetchCursorStatement.FromKeyword.IN, "c"); + assertFetch("FETCH RELATIVE 3 c", FetchCursorStatement.Kind.FETCH, + FetchDirection.RELATIVE, 3L, false, null, "c"); + assertFetch("FETCH 5 FROM c", FetchCursorStatement.Kind.FETCH, null, 5L, false, + FetchCursorStatement.FromKeyword.FROM, "c"); + assertFetch("FETCH ALL c", FetchCursorStatement.Kind.FETCH, null, null, true, null, "c"); + assertFetch("MOVE FORWARD ALL FROM c", FetchCursorStatement.Kind.MOVE, + FetchDirection.FORWARD, null, true, FetchCursorStatement.FromKeyword.FROM, "c"); + assertFetch("MOVE BACKWARD 2 c", FetchCursorStatement.Kind.MOVE, FetchDirection.BACKWARD, + 2L, false, null, "c"); + assertFetch("MOVE BACKWARD c", FetchCursorStatement.Kind.MOVE, FetchDirection.BACKWARD, + null, false, null, "c"); + assertFetch("FETCH PRIOR prior", FetchCursorStatement.Kind.FETCH, FetchDirection.PRIOR, + null, false, null, "prior"); + // a direction word that ends the statement names the cursor, as in PostgreSQL + assertFetch("FETCH last", FetchCursorStatement.Kind.FETCH, null, null, false, null, + "last"); + assertFetch("MOVE backward", FetchCursorStatement.Kind.MOVE, null, null, false, null, + "backward"); + + assertTrue(FetchDirection.ABSOLUTE.isCountRequired()); + assertFalse(FetchDirection.FORWARD.isCountRequired()); + assertTrue(FetchDirection.BACKWARD.isCountOptional()); + assertFalse(FetchDirection.NEXT.isCountOptional()); + } + + @Test + void keepsTheClosedCursor() throws JSQLParserException { + CloseCursorStatement close = (CloseCursorStatement) parse("CLOSE c"); + assertEquals("c", close.getCursorName()); + assertFalse(close.isAll()); + + CloseCursorStatement all = (CloseCursorStatement) parse("CLOSE ALL"); + assertNull(all.getCursorName()); + assertTrue(all.isAll()); + + CloseCursorStatement quoted = (CloseCursorStatement) parse("CLOSE \"all\""); + assertEquals("\"all\"", quoted.getCursorName()); + assertFalse(quoted.isAll()); + } + + @ParameterizedTest + @ValueSource(strings = { + "DECLARE c", + "DECLARE c CURSOR", + "DECLARE c CURSOR FOR", + "DECLARE c FOR SELECT 1", + "DECLARE c NO CURSOR FOR SELECT 1", + "DECLARE c SENSITIVE CURSOR FOR SELECT 1", + "DECLARE c HOLD CURSOR FOR SELECT 1", + "DECLARE c CURSOR WITH FOR SELECT 1", + "DECLARE c CURSOR HOLD FOR SELECT 1", + "DECLARE c CURSOR WITHOUT HOLD WITH HOLD FOR SELECT 1", + "DECLARE c CURSOR SCROLL FOR SELECT 1", + "DECLARE c CURSOR FOR INSERT INTO t VALUES (1)", + "DECLARE c CURSOR FOR UPDATE t SET a = 1", + "DECLARE c CURSOR FOR DELETE FROM t", + "DECLARE c CURSOR FOR SELECT 1 FETCH", + "DECLARE s.c CURSOR FOR SELECT 1", + "DECLARE binary CURSOR FOR SELECT 1", + "DECLARE table CURSOR FOR SELECT 1", + "DECLARE verbose CURSOR FOR SELECT 1", + "FETCH", + "FETCH FROM", + "FETCH ALL", + "FETCH 5", + "FETCH FORWARD 5", + "FETCH FORWARD ALL", + "FETCH NEXT 5 FROM c", + "FETCH PRIOR ALL c", + "FETCH ABSOLUTE FROM c", + "FETCH ABSOLUTE c", + "FETCH RELATIVE ALL c", + "FETCH 1.5 c", + "FETCH ABSOLUTE 2147483648 c", + "FETCH ABSOLUTE -2147483648 c", + "FETCH c INTO x", + "FETCH NEXT FROM c, d", + "FETCH NEXT FROM s.c", + "FETCH NEXT FROM table", + "FETCH NEXT FROM all", + "FETCH FROM IN c", + "MOVE", + "MOVE ALL", + "MOVE c INTO x", + "CLOSE", + "CLOSE c, d", + "CLOSE ALL c", + "CLOSE s.c", + "CLOSE table", + "CLOSE binary"}) + void rejectsWhatPostgreSqlRejects(String sql) { + for (Consumer dialect : List.of(POSTGRESQL, NO_DIALECT)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "FETCH NEXT FROM c INTO @x", + "FETCH ABSOLUTE @n FROM c", + "FETCH NEXT FROM GLOBAL c", + "FETCH c INTO x", + "MOVE c d", + "CLOSE GLOBAL c", + "CLOSE table"}) + void otherProductsVariantsStayUnsupportedWithoutDialect(String sql) + throws JSQLParserException { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, UNSUPPORTED), + sql); + // the PostgreSQL dialect reads them as cursor statements, which they are not + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + POSTGRESQL.andThen(UNSUPPORTED)), sql); + } + + @ParameterizedTest + @ValueSource(strings = { + "DECLARE c CURSOR FOR SELECT 1", + "FETCH NEXT FROM c", + "FETCH ALL c", + "MOVE c", + "CLOSE c", + "CLOSE ALL"}) + void otherDialectsKeepTheirReadings(String sql) { + for (Dialect dialect : List.of(Dialect.SQLSERVER, Dialect.MYSQL, Dialect.MARIADB, + Dialect.ORACLE, Dialect.H2, Dialect.COCKROACHDB)) { + Consumer consumer = parser -> parser.withDialect(dialect); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, consumer), + sql + " " + dialect); + if (!sql.startsWith("DECLARE")) { + assertDoesParseAsUnsupported(sql, consumer.andThen(UNSUPPORTED)); + } + } + } + + @Test + void sqlServerDeclareKeepsItsReading() throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, POSTGRESQL, + (Consumer) parser -> parser.withDialect(Dialect.SQLSERVER))) { + for (String sql : new String[] {"DECLARE @x INT", "DECLARE @x INT = 1, @y VARCHAR(10)", + "DECLARE @t TABLE (a INT)", "DECLARE @x AS t"}) { + assertInstanceOf(DeclareStatement.class, + assertSqlCanBeParsedAndDeparsed(sql, true, dialect), sql); + } + } + // the cursor forms of other products remain parse errors without a dialect + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("DECLARE c CURSOR LOCAL FAST_FORWARD FOR SELECT 1")); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("DECLARE x INT", UNSUPPORTED)); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + String script = "START TRANSACTION; DECLARE c SCROLL CURSOR FOR SELECT * FROM t;\n" + + "FETCH NEXT FROM c;\n" + + "MOVE c; FETCH PRIOR c; CLOSE c; COMMIT"; + for (Consumer dialect : List.of(POSTGRESQL, NO_DIALECT)) { + assertEquals(List.of("StartTransaction", "DeclareCursorStatement", + "FetchCursorStatement", "FetchCursorStatement", "FetchCursorStatement", + "CloseCursorStatement", "Commit"), classes(script, dialect)); + } + // without a semicolon in the PostgreSQL dialect, as other statements may follow + assertEquals(List.of("PlainSelect", "Update", "FetchCursorStatement", + "FetchCursorStatement", "CloseCursorStatement", "CloseCursorStatement", + "FetchCursorStatement", "PlainSelect"), + classes("SELECT 0; UPDATE t SET a = 1\nFETCH c\nMOVE ALL IN c\nCLOSE c\n" + + "CLOSE ALL\nFETCH next\n;SELECT 1", POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "DECLARE c CURSOR FOR SELECT 1", + "FETCH c", + "FETCH next", + "FETCH FORWARD ALL FROM c", + "MOVE ABSOLUTE -1 c", + "CLOSE c", + "CLOSE ALL"}) + void isAStatementStart(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(POSTGRESQL, NO_DIALECT)) { + Statements statements = + CCJSqlParserUtil.parseStatements("SELECT 1;\n" + sql + ";\nSELECT 2", dialect); + assertEquals(3, statements.size(), sql); + assertEquals(sql, statements.get(1).toString()); + } + Statements unsupported = CCJSqlParserUtil.parseStatements("FOO BAR; " + sql + "; BAZ", + UNSUPPORTED); + assertEquals(3, unsupported.size(), sql); + assertInstanceOf(UnsupportedStatement.class, unsupported.get(0)); + assertEquals(sql, unsupported.get(1).toString()); + assertInstanceOf(UnsupportedStatement.class, unsupported.get(2)); + } + + @Test + void selectFetchAndOtherUsesOfTheWordsAreUnchanged() throws JSQLParserException { + for (Consumer dialect : List.of(POSTGRESQL, NO_DIALECT, + (Consumer) parser -> parser.withDialect(Dialect.MYSQL))) { + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t FETCH FIRST 1 ROWS ONLY", true, + dialect); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY", + true, dialect); + assertSqlCanBeParsedAndDeparsed( + "SELECT move, close, cursor, scroll, hold, absolute, relative, forward, " + + "backward, prior, insensitive, asensitive FROM move AS move", + true, dialect); + assertSqlCanBeParsedAndDeparsed("SELECT move(1), t.move FROM t move", true, dialect); + assertInstanceOf(CreateTable.class, assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE move (move INT, close INT, cursor INT)", true, dialect)); + } + assertInstanceOf(AlterSession.class, CCJSqlParserUtil.parse( + "ALTER SESSION CLOSE DATABASE LINK x", + parser -> parser.withDialect(Dialect.ORACLE))); + } + + @Test + void findsTheTablesOfTheQueryOnly() throws JSQLParserException { + Statement declare = parse("DECLARE c CURSOR FOR WITH x AS (SELECT a FROM t) " + + "SELECT x.a FROM x JOIN s.u ON true"); + assertThat(new TablesNamesFinder<>().getTables(declare)) + .containsExactlyInAnyOrder("t", "s.u"); + assertThat(new TablesNamesFinder<>().getTables(parse("DECLARE c CURSOR FOR TABLE t"))) + .containsExactly("t"); + for (String sql : new String[] {"FETCH NEXT FROM t", "MOVE t", "CLOSE t", "CLOSE ALL"}) { + assertThat(new TablesNamesFinder<>().getTables(parse(sql))).isEmpty(); + } + } + + @Test + void reportsSessionFeatures() throws JSQLParserException { + StatementFeatures declare = parse("DECLARE c CURSOR FOR SELECT a FROM t").getFeatures(); + assertThat(declare.getCertain()).containsExactlyInAnyOrder(StmtFeature.MODIFIES_SESSION, + StmtFeature.READS_DATA); + assertThat(parse("DECLARE c CURSOR FOR SELECT 1").getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + + StatementFeatures fetch = parse("FETCH ALL c").getFeatures(); + assertThat(fetch.getCertain()).containsExactlyInAnyOrder(StmtFeature.RETURNS_RESULT_SET, + StmtFeature.MODIFIES_SESSION); + assertThat(fetch.getUncertain()).containsExactly(StmtFeature.READS_DATA); + + StatementFeatures move = parse("MOVE ALL c").getFeatures(); + assertThat(move.getCertain()).containsExactly(StmtFeature.MODIFIES_SESSION); + assertThat(move.getUncertain()).containsExactly(StmtFeature.READS_DATA); + + assertThat(parse("CLOSE ALL").getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + } + + @Test + void nodesSpanTheStatementsAndTheQuery() throws JSQLParserException { + String sql = "DECLARE c SCROLL CURSOR WITH HOLD FOR SELECT a FROM t"; + DeclareCursorStatement declare = (DeclareCursorStatement) parse(sql); + assertEquals(sql, text(sql, declare)); + assertEquals("SELECT a FROM t", text(sql, declare.getQuery())); + for (String other : new String[] {"FETCH FORWARD 2 FROM c", "MOVE c", "CLOSE ALL"}) { + assertEquals(other, text(other, (ASTNodeAccess) parse(other))); + } + } + + @Test + void buildsStatementsInCode() { + Select query = new PlainSelect().addSelectItems(new Column(new Table("t"), "a")) + .withFromItem(new Table("t")); + DeclareCursorStatement declare = new DeclareCursorStatement("c", query) + .addOptions(CursorOption.BINARY, CursorOption.NO_SCROLL); + declare.setHoldability(DeclareCursorStatement.Holdability.WITH_HOLD); + assertEquals("DECLARE c BINARY NO SCROLL CURSOR WITH HOLD FOR SELECT t.a FROM t", + declare.toString()); + assertEquals(declare.toString(), deparse(declare)); + declare.setOptions(null); + declare.setHoldability(null); + assertEquals("DECLARE c CURSOR FOR SELECT t.a FROM t", deparse(declare)); + + FetchCursorStatement fetch = new FetchCursorStatement(FetchCursorStatement.Kind.MOVE, "c"); + assertEquals("MOVE c", fetch.toString()); + fetch.setDirection(FetchDirection.FORWARD); + fetch.setCount(3L); + fetch.setFromKeyword(FetchCursorStatement.FromKeyword.IN); + assertEquals("MOVE FORWARD 3 IN c", deparse(fetch)); + fetch.setAll(true); + assertNull(fetch.getCount()); + assertEquals("MOVE FORWARD ALL IN c", fetch.toString()); + fetch.setCount(-1L); + assertFalse(fetch.isAll()); + fetch.setKind(FetchCursorStatement.Kind.FETCH); + fetch.setDirection(null); + fetch.setFromKeyword(null); + assertEquals("FETCH -1 c", deparse(fetch)); + assertThrows(NullPointerException.class, () -> fetch.setKind(null)); + FetchCursorStatement plain = new FetchCursorStatement(); + plain.setCursorName("c"); + assertEquals("FETCH c", plain.toString()); + + CloseCursorStatement close = new CloseCursorStatement(); + assertTrue(close.isAll()); + assertEquals("CLOSE ALL", deparse(close)); + close.setCursorName("c"); + assertEquals("CLOSE c", close.toString()); + assertEquals("CLOSE d", deparse(new CloseCursorStatement("d"))); + } + + private static void assertFetch(String sql, FetchCursorStatement.Kind kind, + FetchDirection direction, Long count, boolean all, + FetchCursorStatement.FromKeyword fromKeyword, String name) throws JSQLParserException { + FetchCursorStatement fetch = (FetchCursorStatement) parse(sql); + assertEquals(kind, fetch.getKind(), sql); + assertEquals(direction, fetch.getDirection(), sql); + assertEquals(count, fetch.getCount(), sql); + assertEquals(all, fetch.isAll(), sql); + assertEquals(fromKeyword, fetch.getFromKeyword(), sql); + assertEquals(name, fetch.getCursorName(), sql); + } + + private static void assertNormalized(String expected, String sql) throws JSQLParserException { + for (Consumer dialect : List.of(POSTGRESQL, NO_DIALECT)) { + Statement statement = CCJSqlParserUtil.parse(sql, dialect); + assertEquals(expected, statement.toString()); + assertEquals(expected, deparse(statement)); + } + } + + private static void assertDoesParseAsUnsupported(String sql, Consumer dialect) { + try { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, dialect), + sql); + } catch (JSQLParserException e) { + throw new AssertionError(sql, e); + } + } + + private static Statement parse(String sql) throws JSQLParserException { + return assertSqlCanBeParsedAndDeparsed(sql, true, POSTGRESQL); + } + + private static List classes(String script, Consumer dialect) + throws JSQLParserException { + return CCJSqlParserUtil.parseStatements(script, dialect).stream() + .map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList()); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + private static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/delete/DeleteTest.java b/src/test/java/net/sf/jsqlparser/statement/delete/DeleteTest.java index 2b7bab5e96..f90eeea8e8 100644 --- a/src/test/java/net/sf/jsqlparser/statement/delete/DeleteTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/delete/DeleteTest.java @@ -74,6 +74,20 @@ public void testDeleteDoesNotAllowLimitOffset() { () -> parserManager.parse(new StringReader(statement))); } + @Test + public void testDeleteRequiresTargetTable() { + // a missing target must not parse into a Delete whose toString() + // prints a literal "null" for the absent table + for (String statement : new String[] { + "DELETE", + "DELETE FROM", + "DELETE FROM WHERE a = 1", + "DELETE FROM USING t"}) { + assertThrows(JSQLParserException.class, + () -> parserManager.parse(new StringReader(statement))); + } + } + @Test public void testDeleteWithOrderBy() throws JSQLParserException { String stmt = "DELETE FROM tablename WHERE a = 1 AND b = 1 ORDER BY col"; diff --git a/src/test/java/net/sf/jsqlparser/statement/delete/DeleteUsingJoinTest.java b/src/test/java/net/sf/jsqlparser/statement/delete/DeleteUsingJoinTest.java new file mode 100644 index 0000000000..884790d7f8 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/delete/DeleteUsingJoinTest.java @@ -0,0 +1,228 @@ +/*- + * #%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.delete; + +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 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.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.select.FromItemVisitorAdapter; +import net.sf.jsqlparser.statement.select.Join; +import net.sf.jsqlparser.statement.select.ParenthesedSelect; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class DeleteUsingJoinTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + /** Parses exactly with and without the given dialect and returns the dialect's result. */ + private static Delete parse(String sql, Consumer dialect) + throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed(sql, false); + return (Delete) assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + } + + private static String name(Object fromItem) { + return ((Table) fromItem).getFullyQualifiedName(); + } + + @Test + void mySqlUsingJoin() throws JSQLParserException { + Delete delete = parse("DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id", MYSQL); + + assertEquals("t1", delete.getTable().getName()); + assertTrue(delete.getTables().isEmpty()); + assertNull(delete.getJoins()); + assertEquals(1, delete.getUsingFromItemList().size()); + assertEquals("t1", name(delete.getUsingFromItemList().get(0))); + Join join = delete.getUsingJoins().get(0); + assertEquals("t2", name(join.getFromItem())); + assertEquals("t1.id = t2.id", join.getOnExpressions().iterator().next().toString()); + } + + @Test + void mySqlSeveralTargets() throws JSQLParserException { + Delete delete = parse("DELETE FROM t1, t2 USING t1 INNER JOIN t2 INNER JOIN t3" + + " WHERE t1.id = t2.id AND t2.id = t3.id", MYSQL); + + // the targets keep the existing FROM t1, t2 reading + assertEquals("t1", delete.getTable().getName()); + assertTrue(delete.getJoins().get(0).isSimple()); + assertEquals("t2", name(delete.getJoins().get(0).getFromItem())); + assertEquals("t1", name(delete.getUsingFromItemList().get(0))); + assertEquals(2, delete.getUsingJoins().size()); + assertTrue(delete.getUsingJoins().get(1).isInner()); + assertEquals("t3", name(delete.getUsingJoins().get(1).getFromItem())); + } + + @Test + void targetsBeforeUsingKeepTheirPlace() throws JSQLParserException { + // the target joins were rendered after USING before + Delete delete = parse("DELETE FROM t1, t2 USING t1, t2 WHERE t1.id = t2.id", MYSQL); + + assertEquals(1, delete.getJoins().size()); + assertEquals(2, delete.getUsingFromItemList().size()); + assertNull(delete.getUsingJoins()); + } + + @Test + void commaListFollowedByJoins() throws JSQLParserException { + Delete delete = parse("DELETE FROM t1 USING t1, t2 LEFT JOIN t3 ON t2.a = t3.a, t4" + + " WHERE t1.id = t2.id", MYSQL); + + assertEquals(2, delete.getUsingFromItemList().size()); + assertEquals(2, delete.getUsingJoins().size()); + assertTrue(delete.getUsingJoins().get(0).isLeft()); + assertTrue(delete.getUsingJoins().get(1).isSimple()); + } + + @Test + void postgreSqlUsingJoinWithSubquery() throws JSQLParserException { + Delete delete = parse("DELETE FROM t USING (SELECT id FROM s) AS x JOIN u ON x.id = u.id" + + " WHERE t.id = x.id RETURNING t.id", POSTGRESQL); + + assertInstanceOf(ParenthesedSelect.class, delete.getUsingFromItemList().get(0)); + assertEquals("u", name(delete.getUsingJoins().get(0).getFromItem())); + assertEquals(1, delete.getReturningClause().size()); + } + + @Test + void plainUsingListIsUnchanged() throws JSQLParserException { + Delete delete = parse("DELETE FROM t USING s, u WHERE t.id = s.id", POSTGRESQL); + + assertEquals(2, delete.getUsingFromItemList().size()); + assertNull(delete.getUsingJoins()); + assertNull(delete.getJoins()); + } + + @Test + void existingMultiTableFormIsUnchanged() throws JSQLParserException { + Delete delete = parse("DELETE t1 FROM t1 JOIN t2 ON t1.id = t2.id", MYSQL); + + assertEquals(1, delete.getTables().size()); + assertEquals(1, delete.getJoins().size()); + assertTrue(delete.getUsingFromItemList().isEmpty()); + assertNull(delete.getUsingJoins()); + } + + @Test + void targetAliasesRenderInBothRenderers() throws JSQLParserException { + // the deparser dropped the alias of a target table, which the grammar accepts although + // MySQL takes aliases only after FROM + Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed( + "DELETE t1 x FROM t1 x WHERE x.a = 1", false); + + assertEquals("x", delete.getTables().get(0).getAlias().getName()); + } + + @ParameterizedTest + @ValueSource(strings = { + "DELETE FROM t1 USING", + "DELETE FROM t1 USING t1 JOIN", + "DELETE FROM t1 USING t1 JOIN t2 ON", + "DELETE FROM t1 USING , t1" + }) + void rejectsIncompleteForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @Test + void statementBoundary() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id; SELECT 1", MYSQL); + + assertEquals(2, statements.size()); + assertEquals("DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id", + statements.get(0).toString()); + } + + @Test + void tablesNamesFinderSeesUsingJoins() throws JSQLParserException { + assertEquals(new HashSet<>(Arrays.asList("t1", "t2", "t3")), TablesNamesFinder.findTables( + "DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id JOIN t3 ON t2.id = t3.id")); + assertEquals(new HashSet<>(Arrays.asList("t", "s", "u")), TablesNamesFinder.findTables( + "DELETE FROM t USING (SELECT id FROM s) x JOIN u ON x.id = u.id")); + } + + @Test + void statementVisitorAdapterVisitsUsingItemsAndJoins() throws JSQLParserException { + Delete delete = (Delete) CCJSqlParserUtil.parse( + "DELETE FROM t USING (SELECT id FROM s) x JOIN u ON x.id = u.id"); + List tables = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter<>(); + FromItemVisitorAdapter fromItems = new FromItemVisitorAdapter() { + @Override + public Void visit(Table table, S context) { + tables.add(table.getName()); + return null; + } + }; + SelectVisitorAdapter selects = new SelectVisitorAdapter<>(expressions, fromItems); + expressions.setSelectVisitor(selects); + fromItems.setSelectVisitor(selects).setExpressionVisitor(expressions); + + // a subquery in USING no longer fails the cast in getUsingList() + delete.accept(new StatementVisitorAdapter(selects), null); + + assertEquals(Arrays.asList("t", "s", "u"), tables); + } + + @Test + void validatesForMySqlAndPostgreSql() throws JSQLParserException { + ValidationTestAsserts.validateNoErrors("DELETE FROM t1 USING t1 JOIN t2 ON t1.id = t2.id", + 1, MySqlVersion.V8_0); + ValidationTestAsserts.validateNoErrors( + "DELETE FROM t USING s JOIN u ON s.id = u.id WHERE t.id = s.id", 1, + PostgresqlVersion.V14); + } + + @Test + void buildUsingJoinsOnTheModel() { + Delete delete = new Delete().withTable(new Table("t1")) + .addUsingFromItemList(new Table("t1")); + delete.addUsingJoins(new Join().withInner(true) + .setFromItem(new Table("t2").withAlias(new Alias("b", false)))); + + assertEquals("DELETE FROM t1 USING t1 INNER JOIN t2 b", delete.toString()); + assertDeparse(delete, "DELETE FROM t1 USING t1 INNER JOIN t2 b"); + + // the joins of USING are rendered only with USING items + delete.setUsingFromItemList(null); + assertEquals("DELETE FROM t1", delete.toString()); + assertDeparse(delete, "DELETE FROM t1"); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/DropObjectTypeTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/DropObjectTypeTest.java new file mode 100644 index 0000000000..aeff84ef4a --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/drop/DropObjectTypeTest.java @@ -0,0 +1,294 @@ +/*- + * #%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.drop; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +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.CascadeBehavior; +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 org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class DropObjectTypeTest { + + @ParameterizedTest + @ValueSource(strings = {"DROP TRIGGER IF EXISTS trg ON users CASCADE", + "DROP TRIGGER trg ON app.users", "DROP RULE r1 ON v", + "DROP RULE IF EXISTS r1 ON v RESTRICT"}) + void triggerAndRuleOwnersAreTables(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.POSTGRESQL)) { + assertEquals(sql, drop.toString()); + String owner = sql.replaceAll(".* ON (\\S+).*", "$1"); + assertEquals(owner, drop.getTable().getFullyQualifiedName()); + assertEquals(Set.of(owner), new TablesNamesFinder().getTables(drop)); + } + } + + @Test + void ownerTableReplacesLegacyOnTokens() throws JSQLParserException { + Drop drop = parse("DROP TRIGGER IF EXISTS trg ON users CASCADE", Dialect.POSTGRESQL); + assertEquals("trg", drop.getName().getName()); + assertEquals(CascadeBehavior.CASCADE, drop.getBehavior()); + assertEquals(List.of("ON", "users", "CASCADE"), drop.getParameters()); + + drop.getTable().setName("accounts"); + drop.setBehavior(CascadeBehavior.RESTRICT); + assertEquals("DROP TRIGGER IF EXISTS trg ON accounts RESTRICT", drop.toString()); + assertEquals(List.of("ON", "accounts", "RESTRICT"), drop.getParameters()); + + StringBuilder builder = new StringBuilder(); + SelectDeParser tables = new SelectDeParser() { + @Override + public StringBuilder visit(Table table, S context) { + return getBuilder().append("renamed"); + } + }; + drop.accept(new StatementDeParser(new ExpressionDeParser(), tables, builder), null); + assertEquals("DROP TRIGGER IF EXISTS trg ON renamed RESTRICT", builder.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP TRIGGER safety ON DATABASE", "DROP TRIGGER safety ON ALL SERVER"}) + void sqlServerTriggerScopesAreNotTables(String sql) throws JSQLParserException { + Drop drop = parse(sql, Dialect.SQLSERVER); + assertNull(drop.getTable()); + assertTrue(new TablesNamesFinder().getTables(drop).isEmpty()); + assertEquals(sql, drop.toString()); + } + + @Test + void cascadeAndRestrictAreTyped() throws JSQLParserException { + Drop table = parse("DROP TABLE IF EXISTS t1, t2 RESTRICT", Dialect.MYSQL); + assertEquals(CascadeBehavior.RESTRICT, table.getBehavior()); + assertEquals(List.of("RESTRICT"), table.getParameters()); + + Drop index = parse("DROP INDEX a_idx, b_idx CASCADE", Dialect.POSTGRESQL); + assertEquals(CascadeBehavior.CASCADE, index.getBehavior()); + index.setBehavior(null); + assertEquals("DROP INDEX a_idx, b_idx", index.toString()); + assertNull(index.getParameters()); + + Drop plain = parse("DROP SCHEMA s", Dialect.POSTGRESQL); + assertNull(plain.getBehavior()); + assertNull(plain.getParameters()); + } + + @Test + void rawParametersAndBehaviorFollowExplicitRules() throws JSQLParserException { + Drop drop = parse("DROP INDEX i ON t CASCADE", Dialect.MYSQL); + drop.addParameters("LOCK", "NONE"); + assertEquals(List.of("ON", "t", "LOCK", "NONE", "CASCADE"), drop.getParameters()); + assertEquals("DROP INDEX i ON t LOCK NONE CASCADE", drop.toString()); + + drop.setParameters(List.of("RESTRICT")); + assertNull(drop.getBehavior()); + assertNull(drop.getTable()); + assertEquals("DROP INDEX i RESTRICT", drop.toString()); + + // Raw tokens are not parsed: the builder spelling renders the same SQL. + Drop legacy = new Drop().withType("VIEW").withName(new Table("v")).addParameters("CASCADE"); + assertNull(legacy.getBehavior()); + assertEquals("DROP VIEW v CASCADE", legacy.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP TYPE IF EXISTS mood CASCADE", "DROP TYPE mood, app.color", + "DROP DOMAIN d1", "DROP DOMAIN IF EXISTS d1 RESTRICT", "DROP EVENT TRIGGER etg", + "DROP EVENT TRIGGER IF EXISTS etg CASCADE", "DROP TABLESPACE IF EXISTS fast", + "DROP DATABASE IF EXISTS mydb WITH (FORCE)", "DROP DATABASE mydb WITH (FORCE)"}) + void postgreSqlObjectTypes(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.POSTGRESQL)) { + assertEquals(sql, drop.toString()); + assertNotEquals(Drop.ObjectType.OTHER, drop.getObjectType()); + assertTrue(new TablesNamesFinder().getTables(drop).isEmpty()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"DROP ACCESS METHOD heptree", + "DROP ACCESS METHOD IF EXISTS heptree CASCADE", "DROP PROCEDURAL LANGUAGE plsample", + "DROP PROCEDURAL LANGUAGE IF EXISTS plsample RESTRICT", + "DROP LANGUAGE IF EXISTS plsample CASCADE", + "DROP OPERATOR CLASS IF EXISTS public.myops USING btree CASCADE", + "DROP OPERATOR FAMILY myfam USING hash", + "DROP TEXT SEARCH CONFIGURATION IF EXISTS my_cfg CASCADE", + "DROP TEXT SEARCH DICTIONARY english_stem, public.french_stem", + "DROP TEXT SEARCH PARSER my_parser", + "DROP TEXT SEARCH TEMPLATE IF EXISTS my_tmpl RESTRICT"}) + void postgreSqlMultiWordObjectTypes(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.POSTGRESQL)) { + assertEquals(sql, drop.toString()); + assertNotEquals(Drop.ObjectType.OTHER, drop.getObjectType()); + assertTrue(new TablesNamesFinder().getTables(drop).isEmpty()); + } + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + parser -> parser.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void multiWordObjectTypeFields() throws JSQLParserException { + Drop accessMethod = + parse("DROP ACCESS METHOD IF EXISTS heptree CASCADE", Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.ACCESS_METHOD, accessMethod.getObjectType()); + assertEquals("ACCESS METHOD", accessMethod.getType()); + assertEquals(List.of("heptree"), names(accessMethod)); + assertTrue(accessMethod.isIfExists()); + assertEquals(CascadeBehavior.CASCADE, accessMethod.getBehavior()); + + Drop language = parse("DROP PROCEDURAL LANGUAGE plsample", Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.LANGUAGE, language.getObjectType()); + assertTrue(language.isProcedural()); + assertEquals(List.of("plsample"), names(language)); + language.setProcedural(false); + assertEquals("DROP LANGUAGE plsample", language.toString()); + assertFalse(parse("DROP LANGUAGE plsample", Dialect.POSTGRESQL).isProcedural()); + + Drop operatorClass = parse("DROP OPERATOR CLASS IF EXISTS public.myops USING btree", + Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.OPERATOR_CLASS, operatorClass.getObjectType()); + assertEquals(List.of("public.myops"), names(operatorClass)); + assertEquals("btree", operatorClass.getAccessMethod()); + assertNull(operatorClass.getParameters()); + operatorClass.setAccessMethod("hash"); + assertEquals("DROP OPERATOR CLASS IF EXISTS public.myops USING hash", + operatorClass.toString()); + assertEquals(Drop.ObjectType.OPERATOR_FAMILY, + parse("DROP OPERATOR FAMILY myfam USING gist", Dialect.POSTGRESQL).getObjectType()); + + Drop dictionary = parse("DROP TEXT SEARCH DICTIONARY english_stem, public.french_stem", + Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.TEXT_SEARCH_DICTIONARY, dictionary.getObjectType()); + assertEquals(List.of("english_stem", "public.french_stem"), names(dictionary)); + + assertEquals("DROP OPERATOR FAMILY f USING btree CASCADE", + new Drop().withObjectType(Drop.ObjectType.OPERATOR_FAMILY) + .withName(new Table("f")).withAccessMethod("btree") + .withBehavior(CascadeBehavior.CASCADE).toString()); + assertEquals("DROP PROCEDURAL LANGUAGE l", new Drop() + .withObjectType(Drop.ObjectType.LANGUAGE).withProcedural(true) + .withName(new Table("l")).toString()); + } + + @Test + void multiWordTypeWordsRemainNames() throws JSQLParserException { + assertEquals(List.of("procedural"), + names(parse("DROP LANGUAGE procedural", Dialect.POSTGRESQL))); + assertEquals(List.of("method"), + names(parse("DROP ACCESS METHOD method", Dialect.POSTGRESQL))); + assertEquals(List.of("access"), names(parse("DROP TABLE access", Dialect.POSTGRESQL))); + assertEquals(List.of("family"), + names(parse("DROP OPERATOR CLASS family USING btree", Dialect.POSTGRESQL))); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP OPERATOR CLASS myops", "DROP OPERATOR FAMILY f1, f2 USING btree", + "DROP OPERATOR CLASS myops USING", "DROP ACCESS METHOD", + "DROP ACCESS METHOD IF EXISTS", "DROP TEXT SEARCH INDEX x", "DROP TEXT SEARCH", + "DROP PROCEDURAL LANGUAGE", "DROP ACCESS METHOD heptree USING btree"}) + void rejectsIncompleteMultiWordTypes(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.POSTGRESQL), sql); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP EVENT IF EXISTS ev1", "DROP EVENT db1.ev1", "DROP TABLESPACE ts1", + "DROP TABLESPACE ts1 ENGINE = InnoDB", "DROP UNDO TABLESPACE ts1", + "DROP UNDO TABLESPACE ts1 ENGINE InnoDB"}) + void mySqlObjectTypes(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.MYSQL)) { + assertEquals(sql, drop.toString()); + } + } + + @Test + void objectTypeFields() throws JSQLParserException { + Drop eventTrigger = parse("DROP EVENT TRIGGER etg", Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.EVENT_TRIGGER, eventTrigger.getObjectType()); + assertEquals("EVENT TRIGGER", eventTrigger.getType()); + assertEquals("etg", eventTrigger.getName().getName()); + + Drop event = parse("DROP EVENT IF EXISTS ev1", Dialect.MYSQL); + assertEquals(Drop.ObjectType.EVENT, event.getObjectType()); + + Drop type = parse("DROP TYPE mood, app.color CASCADE", Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.TYPE, type.getObjectType()); + assertEquals("app", type.getNames().get(1).getSchemaName()); + + Drop tablespace = parse("DROP UNDO TABLESPACE ts1 ENGINE=InnoDB", Dialect.MYSQL); + assertEquals(Drop.ObjectType.TABLESPACE, tablespace.getObjectType()); + assertTrue(tablespace.isUndo()); + assertEquals("InnoDB", tablespace.getEngine()); + assertTrue(tablespace.isEngineUseEquals()); + assertEquals("DROP UNDO TABLESPACE ts1 ENGINE = InnoDB", tablespace.toString()); + tablespace.withUndo(false).withEngine("NDB").setEngineUseEquals(false); + assertEquals("DROP TABLESPACE ts1 ENGINE NDB", tablespace.toString()); + + Drop database = parse("DROP DATABASE mydb (FORCE)", Dialect.POSTGRESQL); + assertTrue(database.isForce()); + assertEquals("DROP DATABASE mydb WITH (FORCE)", database.toString()); + database.setForce(false); + assertEquals("DROP DATABASE mydb", database.toString()); + + assertEquals("DROP DATABASE IF EXISTS d WITH (FORCE)", new Drop() + .withObjectType(Drop.ObjectType.DATABASE).withIfExists(true) + .withName(new Table("d")).withForce(true).toString()); + } + + @Test + void clauseWordsRemainNames() throws JSQLParserException { + assertEquals("engine", + parse("DROP TABLESPACE engine", Dialect.MYSQL).getName().getName()); + assertEquals("undo", parse("DROP TABLE undo", Dialect.MYSQL).getName().getName()); + assertEquals("owned", parse("DROP TABLE owned", Dialect.POSTGRESQL).getName().getName()); + assertEquals(2, CCJSqlParserUtil.parseStatements( + "DROP DATABASE d; WITH x AS (SELECT 1) SELECT * FROM x", + parser -> parser.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void rejectsMisplacedClauses() { + for (String sql : List.of("DROP TABLE t WITH (FORCE)", "DROP DATABASE d WITH (FORCE", + "DROP TABLE t ENGINE = InnoDB", "DROP TABLESPACE ts ENGINE", + "DROP TABLE t CASCADE x", + "DROP TRIGGER t ON a ON b", "DROP EVENT TRIGGER", "DROP TYPE")) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + } + } + + private static List names(Drop drop) { + return drop.getNames().stream().map(Table::getFullyQualifiedName) + .collect(Collectors.toList()); + } + + private static Drop parse(String sql, Dialect dialect) throws JSQLParserException { + return (Drop) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static List roundTrip(String sql, Dialect dialect) throws JSQLParserException { + Drop drop = (Drop) assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect)); + StringBuilder builder = new StringBuilder(); + drop.accept(new StatementDeParser(builder), null); + assertEquals(drop.toString(), builder.toString()); + return List.of(drop, parse(drop.toString(), dialect)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/DropRoleTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/DropRoleTest.java new file mode 100644 index 0000000000..4d98a3b42f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/drop/DropRoleTest.java @@ -0,0 +1,178 @@ +/*- + * #%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.drop; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.statement.role.ReassignOwned; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 DropRoleTest { + + @ParameterizedTest + @ValueSource(strings = {"DROP USER IF EXISTS 'app'@'%', 'u2'@'localhost'", "DROP USER app", + "DROP USER 'app'@'%'", "DROP USER app@localhost, `u`@`h`", + "DROP USER IF EXISTS app@'%', 'app'@localhost", + "DROP ROLE IF EXISTS 'reader'", + "DROP ROLE 'r'@'h', r2"}) + void mySqlAccounts(String sql) throws JSQLParserException { + for (Statement statement : roundTrip(sql, Dialect.MYSQL)) { + Drop drop = (Drop) statement; + assertEquals(sql, drop.toString()); + assertTrue(drop.getObjectType().hasAccountTargets()); + assertTrue(new TablesNamesFinder().getTables(drop).isEmpty()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"DROP USER IF EXISTS alice", "DROP USER \"Alice\", bob", + "DROP GROUP staff", "DROP ROLE IF EXISTS app_read, app_rw", + "DROP OWNED BY old_role", "DROP OWNED BY old_role, \"New\" CASCADE", + "DROP OWNED BY CURRENT_USER RESTRICT"}) + void postgreSqlRoles(String sql) throws JSQLParserException { + for (Statement statement : roundTrip(sql, Dialect.POSTGRESQL)) { + assertEquals(sql, statement.toString()); + } + } + + @Test + void accountParts() throws JSQLParserException { + Drop drop = parse("DROP USER IF EXISTS 'app'@'%', u2", Dialect.MYSQL); + assertEquals(Drop.ObjectType.USER, drop.getObjectType()); + assertTrue(drop.isIfExists()); + UserAccount first = drop.getAccounts().get(0); + assertEquals("app", first.getUser().getValue()); + assertEquals("%", first.getHost().getValue()); + assertNull(drop.getAccounts().get(1).getHost()); + + first.setHost(new StringValue("localhost")); + assertEquals("DROP USER IF EXISTS 'app'@'localhost', u2", drop.toString()); + assertEquals(List.of("'app'@'localhost'", "u2"), names(drop)); + assertThrows(UnsupportedOperationException.class, + () -> drop.getAccounts().add(new UserAccount())); + + Drop role = parse("DROP ROLE \"Admin\"", Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.ROLE, role.getObjectType()); + StringValue admin = role.getAccounts().get(0).getUser(); + assertEquals("Admin", admin.getValue()); + assertEquals("\"", admin.getQuoteStr()); + assertNull(role.getAccounts().get(0).getHost()); + assertEquals("\"Admin\"", role.getName().getName()); + assertEquals("DROP ROLE \"Admin\"", role.toString()); + } + + @Test + void dropOwnedKeepsRolesOutOfTheName() throws JSQLParserException { + Drop drop = parse("DROP OWNED BY old_role, other CASCADE", Dialect.POSTGRESQL); + assertEquals(Drop.ObjectType.OWNED, drop.getObjectType()); + assertEquals(List.of("old_role", "other"), drop.getAccounts().stream() + .map(Object::toString).collect(Collectors.toList())); + assertEquals(List.of("old_role", "other"), names(drop)); + assertEquals(CascadeBehavior.CASCADE, drop.getBehavior()); + assertEquals(List.of("CASCADE"), drop.getParameters()); + + drop.setName(new Table("renamed")); + assertEquals("DROP OWNED BY renamed CASCADE", drop.toString()); + + assertEquals("DROP OWNED BY r", new Drop().withObjectType(Drop.ObjectType.OWNED) + .addAccounts(new UserAccount().withUser(new StringValue("r").setQuoteStr(""))) + .toString()); + } + + @Test + void reassignOwned() throws JSQLParserException { + ReassignOwned statement = (ReassignOwned) CCJSqlParserUtil.parse( + "REASSIGN OWNED BY old_role, \"Old\" TO new_role", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(List.of("old_role", "\"Old\""), statement.getRoles().stream() + .map(Object::toString).collect(Collectors.toList())); + assertEquals("new_role", statement.getNewRole().toString()); + assertEquals("Old", statement.getRoles().get(1).getUser().getValue()); + assertEquals("\"", statement.getRoles().get(1).getUser().getQuoteStr()); + + statement.setNewRole(new UserAccount().withUser(new StringValue("CURRENT_USER") + .setQuoteStr(""))); + assertEquals("REASSIGN OWNED BY old_role, \"Old\" TO CURRENT_USER", statement.toString()); + assertThrows(UnsupportedOperationException.class, + () -> statement.getRoles().add(new UserAccount())); + + ReassignOwned built = new ReassignOwned().withRoles(statement.getRoles()) + .withNewRole(statement.getNewRole()); + assertEquals(statement.toString(), built.toString()); + + assertTrue(new TablesNamesFinder().getTables((Statement) statement).isEmpty()); + assertNull(statement.accept(new StatementVisitorAdapter(), null)); + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(parse("DROP OWNED BY r", Dialect.POSTGRESQL).getFeatures().getCertain()) + .contains(StmtFeature.MODIFIES_SCHEMA, StmtFeature.MODIFIES_DATA); + } + + @Test + void ownershipStatementsInScripts() throws JSQLParserException { + List statements = CCJSqlParserUtil.parseStatements( + "REASSIGN OWNED BY a TO b; DROP OWNED BY a; DROP ROLE a", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(3, statements.size()); + assertInstanceOf(ReassignOwned.class, statements.get(0)); + assertEquals("reassign", ((Drop) parse("DROP TABLE reassign", Dialect.POSTGRESQL)) + .getName().getName()); + assertEquals("reassign", CCJSqlParserUtil.parse("SELECT reassign FROM owned") + .toString().split(" ")[1]); + } + + @Test + void rejectsMalformedRoleStatements() { + for (String sql : List.of("DROP OWNED IF EXISTS BY r", "DROP OWNED BY", "DROP USER", + "DROP USER 'app'@", "REASSIGN OWNED BY a", "REASSIGN OWNED a TO b", + "REASSIGN OWNED BY TO b", "DROP ROLE a.b")) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)), sql); + } + } + + private static List names(Drop drop) { + return drop.getNames().stream().map(Table::getFullyQualifiedName) + .collect(Collectors.toList()); + } + + private static Drop parse(String sql, Dialect dialect) throws JSQLParserException { + return (Drop) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static List roundTrip(String sql, Dialect dialect) + throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect)); + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + assertEquals(statement.toString(), builder.toString()); + return List.of(statement, CCJSqlParserUtil.parse(statement.toString(), + parser -> parser.withDialect(dialect))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/DropRoutineSignatureTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/DropRoutineSignatureTest.java new file mode 100644 index 0000000000..4259d3d071 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/drop/DropRoutineSignatureTest.java @@ -0,0 +1,236 @@ +/*- + * #%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.drop; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +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.CascadeBehavior; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 DropRoutineSignatureTest { + + @ParameterizedTest + @ValueSource(strings = {"DROP PROCEDURE p1(int)", "DROP PROCEDURE p1()", + "DROP FUNCTION IF EXISTS f2(int), g2(text) CASCADE", + "DROP FUNCTION f2(int), g2(text)", "DROP FUNCTION a, b(int)", + "DROP ROUTINE f4", "DROP ROUTINE IF EXISTS s.f4(IN a int, OUT b text) RESTRICT", + "DROP FUNCTION f(VARIADIC a int[], double precision)", + "DROP AGGREGATE agg(int)", "DROP AGGREGATE agg(*)", + "DROP AGGREGATE IF EXISTS agg(int ORDER BY text), agg2(*) CASCADE", + "DROP FUNCTION IF EXISTS \"fin\".\"restore_fund_data\"(\"in_fund_id\" int8)"}) + void postgreSqlSignaturesSurviveRoundTrips(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.POSTGRESQL)) { + assertEquals(sql, drop.toString()); + assertFalse(drop.getRoutines().isEmpty()); + assertTrue(drop.getObjectType().hasRoutineTargets()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"DROP PROCEDURE IF EXISTS p1", "DROP FUNCTION IF EXISTS db1.f1", + "DROP PROCEDURE `db.x`.`p.y`"}) + void mySqlRoutinesWithoutSignatures(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.MYSQL)) { + assertEquals(sql, drop.toString()); + assertNull(drop.getRoutines().get(0).getArguments()); + } + } + + @Test + void procedureSignatureIsKeptInTheAst() throws JSQLParserException { + Drop drop = parse("DROP PROCEDURE p1(int)"); + RoutineReference procedure = drop.getRoutines().get(0); + assertEquals("p1", procedure.getName()); + assertEquals(1, procedure.getArguments().size()); + assertEquals("int", procedure.getArguments().get(0).getDataType().toString()); + assertEquals(Drop.ObjectType.PROCEDURE, drop.getObjectType()); + } + + @Test + void everyTargetKeepsItsOwnSignature() throws JSQLParserException { + Drop drop = parse("DROP FUNCTION IF EXISTS f2(int), g2(text), h CASCADE"); + assertEquals(List.of("f2(int)", "g2(text)", "h"), drop.getRoutines().stream() + .map(Object::toString).collect(Collectors.toList())); + assertNull(drop.getRoutines().get(2).getArguments()); + assertTrue(drop.isIfExists()); + assertEquals(CascadeBehavior.CASCADE, drop.getBehavior()); + + RoutineReference.Argument argument = drop.getRoutines().get(1).getArguments().get(0); + argument.setName("label"); + argument.setDataType(new ColDataType("varchar")); + drop.getRoutines().get(0).setName("app.f2"); + assertEquals("DROP FUNCTION IF EXISTS app.f2(int), g2(label varchar), h CASCADE", + drop.toString()); + assertRendersAlike(drop); + } + + @Test + void aggregateSignatureKeepsStarAndOrderBy() throws JSQLParserException { + Drop drop = parse("DROP AGGREGATE agg(int ORDER BY text), agg2(*)"); + assertEquals(Drop.ObjectType.AGGREGATE, drop.getObjectType()); + assertEquals("text", drop.getRoutines().get(0).getOrderByArguments().get(0) + .getDataType().toString()); + assertTrue(drop.getRoutines().get(1).isAllArguments()); + } + + @Test + void legacyNameAndParameterAccessorsAreDerived() throws JSQLParserException { + Drop function = + parse("DROP FUNCTION IF EXISTS \"fin\".\"restore_fund_data\"(in_fund_id int8)"); + Table name = function.getName(); + assertEquals("\"fin\"", name.getSchemaName()); + assertEquals("\"restore_fund_data\"", name.getName()); + assertEquals(List.of("in_fund_id int8"), function.getParamsByType("FUNCTION")); + assertEquals(Map.of("FUNCTION", List.of("in_fund_id int8")), + function.getTypeToParameters()); + assertThrows(UnsupportedOperationException.class, + () -> function.getTypeToParameters().put("FUNCTION", List.of())); + assertThrows(UnsupportedOperationException.class, + () -> function.getNames().add(new Table("x"))); + + // The legacy model holds one signature, written after the last name. + Drop several = parse("DROP FUNCTION a, b(int)"); + assertEquals(List.of("a", "b"), names(several)); + assertEquals(List.of("int"), several.getParamsByType("FUNCTION")); + + assertEquals(List.of("int"), parse("DROP PROCEDURE p1(int)").getParamsByType("PROCEDURE")); + assertEquals(List.of(), parse("DROP FUNCTION f()").getParamsByType("FUNCTION")); + Drop omitted = parse("DROP FUNCTION f"); + assertTrue(omitted.getTypeToParameters().containsKey("FUNCTION")); + assertNull(omitted.getParamsByType("FUNCTION")); + assertEquals(List.of("int"), parse("drop function f(int)").getParamsByType("FUNCTION")); + assertEquals(List.of("*"), parse("DROP AGGREGATE agg(*)").getParamsByType("AGGREGATE")); + } + + @Test + void legacySettersSwitchToTheLegacyRepresentation() throws JSQLParserException { + Drop drop = parse("DROP FUNCTION f(int) CASCADE"); + drop.setName(new Table("g")); + assertTrue(drop.getRoutines().isEmpty()); + assertEquals("DROP FUNCTION g(int) CASCADE", drop.toString()); + drop.getTypeToParameters().put("FUNCTION", List.of("bigint")); + assertEquals("DROP FUNCTION g(bigint) CASCADE", drop.toString()); + + Drop renamed = parse("DROP FUNCTION f(int)"); + renamed.setNames(List.of(new Table("app", "f"), new Table("app", "g"))); + assertEquals("DROP FUNCTION app.f, app.g(int)", renamed.toString()); + + Drop replaced = parse("DROP FUNCTION f(int)"); + replaced.setTypeToParameters(new HashMap<>(Map.of("FUNCTION", List.of("bigint")))); + assertEquals(List.of("f"), names(replaced)); + assertEquals("DROP FUNCTION f(bigint)", replaced.toString()); + + replaced.setRoutines(List.of(routine("f2", "text"))); + assertEquals("DROP FUNCTION f2(text)", replaced.toString()); + assertEquals(Map.of("FUNCTION", List.of("text")), replaced.getTypeToParameters()); + } + + @Test + void buildersRenderBothRepresentations() { + Drop legacy = new Drop().withType("FUNCTION").withName(new Table("myFunc")); + legacy.getTypeToParameters().put("FUNCTION", List.of("integer", "name varchar(255)")); + assertEquals("DROP FUNCTION myFunc(integer, name varchar(255))", legacy.toString()); + assertTrue(legacy.getRoutines().isEmpty()); + + Drop typed = new Drop().withObjectType(Drop.ObjectType.ROUTINE).withIfExists(true) + .addRoutines(routine("r1", "int"), routine("r2")) + .withBehavior(CascadeBehavior.RESTRICT); + assertEquals("DROP ROUTINE IF EXISTS r1(int), r2() RESTRICT", typed.toString()); + assertRendersAlike(typed); + + Drop switched = new Drop().withType("FUNCTION").withName(new Table("old")) + .withRoutines(List.of(routine("f", "int"))); + assertEquals(List.of("f"), names(switched)); + assertEquals("DROP FUNCTION f(int)", switched.toString()); + switched.addRoutines(); + assertEquals("DROP FUNCTION f(int)", switched.toString()); + } + + @Test + void routineNamesAreNotReportedAsTables() throws JSQLParserException { + for (String sql : List.of("DROP FUNCTION f(int)", "DROP PROCEDURE app.p(text)", + "DROP AGGREGATE agg(*)")) { + assertTrue(new TablesNamesFinder().getTables(parse(sql)).isEmpty()); + } + } + + @Test + void rejectsSignaturesOutsideTheirPlace() { + for (String sql : List.of("DROP AGGREGATE agg", "DROP FUNCTION f(*)", + "DROP FUNCTION f(int ORDER BY int)", "DROP TABLE t(int)", "DROP INDEX i(a)", + "DROP FUNCTION f(int) CASCADE RESTRICT", "DROP FUNCTION f(int), ")) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + } + + @Test + void scriptsKeepFollowingStatements() throws JSQLParserException { + assertEquals(3, CCJSqlParserUtil.parseStatements( + "DROP PROCEDURE p1(int); DROP FUNCTION f(int), g(text) CASCADE; SELECT 1", + parser -> parser.withDialect(Dialect.POSTGRESQL)).size()); + assertSqlCanBeParsedAndDeparsed("DROP FUNCTION myFunc(amount integer, name varchar(255))", + true, parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static RoutineReference routine(String name, String... types) { + RoutineReference routine = new RoutineReference(); + routine.setName(name); + List arguments = new ArrayList<>(); + for (String type : types) { + RoutineReference.Argument argument = new RoutineReference.Argument(); + argument.setDataType(new ColDataType(type)); + arguments.add(argument); + } + routine.setArguments(arguments); + return routine; + } + + private static List names(Drop drop) { + return drop.getNames().stream().map(Table::getFullyQualifiedName) + .collect(Collectors.toList()); + } + + private static Drop parse(String sql) throws JSQLParserException { + return parse(sql, Dialect.POSTGRESQL); + } + + private static Drop parse(String sql, Dialect dialect) throws JSQLParserException { + return (Drop) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static void assertRendersAlike(Drop drop) { + StringBuilder builder = new StringBuilder(); + drop.accept(new StatementDeParser(builder), null); + assertEquals(drop.toString(), builder.toString()); + } + + private static List roundTrip(String sql, Dialect dialect) throws JSQLParserException { + Drop drop = (Drop) assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect)); + assertRendersAlike(drop); + return List.of(drop, parse(drop.toString(), dialect)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/DropSignatureTargetTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/DropSignatureTargetTest.java new file mode 100644 index 0000000000..47008ab925 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/drop/DropSignatureTargetTest.java @@ -0,0 +1,315 @@ +/*- + * #%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.drop; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.CastSignature; +import net.sf.jsqlparser.statement.OperatorSignature; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.TransformSignature; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ExclusionOperator; +import net.sf.jsqlparser.util.TablesNamesFinder; +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; + +/** PostgreSQL DROP CAST, DROP OPERATOR and DROP TRANSFORM name their targets by types. */ +class DropSignatureTargetTest { + + @ParameterizedTest + @ValueSource(strings = {"DROP CAST (text AS integer)", + "DROP CAST IF EXISTS (bigint AS int4) CASCADE", + "DROP CAST (int[] AS public.mytype) RESTRICT", + "DROP CAST (double precision AS timestamp with time zone)", + "DROP OPERATOR === (integer, integer)", + "DROP OPERATOR IF EXISTS ~ (NONE, bigint) CASCADE", + "DROP OPERATOR public.=== (integer, integer), ~ (NONE, bigint)", + "DROP OPERATOR @@ (text, text)", "DROP OPERATOR <-> (point, point) RESTRICT", + "DROP OPERATOR ! (bigint, NONE)", "DROP OPERATOR \"my schema\".+ (int, int)", + "DROP OPERATOR - (NONE, integer), || (text, text), ? (jsonb, text)", + "DROP OPERATOR <<= (inet, inet), -|- (int4range, int4range), ?| (jsonb, text[])", + "DROP OPERATOR * (int, int), / (int, int), = (int, int), >= (int, int)", + "DROP OPERATOR @-@ (NONE, lseg), public.#- (jsonb, text[]), <#> (point, point)", + "DROP TRANSFORM FOR hstore LANGUAGE plpython3u", + "DROP TRANSFORM IF EXISTS FOR public.hstore LANGUAGE plpython3u RESTRICT", + "DROP TRANSFORM FOR integer[] LANGUAGE plperl CASCADE", + "DROP TRANSFORM FOR character varying LANGUAGE \"plpython3u\""}) + void signatureTargetsRoundTrip(String sql) throws JSQLParserException { + for (Drop drop : roundTrip(sql, Dialect.POSTGRESQL)) { + assertEquals(sql, drop.toString()); + assertNotEquals(Drop.ObjectType.OTHER, drop.getObjectType()); + // no tokens are left over: CASCADE or RESTRICT is the only legacy parameter + assertEquals(drop.getBehavior() == null ? null : List.of(drop.getBehavior().name()), + drop.getParameters()); + assertTrue(new TablesNamesFinder().getTables(drop).isEmpty()); + } + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", + parser -> parser.withDialect(Dialect.POSTGRESQL)).size()); + } + + @Test + void castFields() throws JSQLParserException { + Drop drop = parse("DROP CAST IF EXISTS (bigint AS int4) CASCADE"); + assertEquals(Drop.ObjectType.CAST, drop.getObjectType()); + assertEquals("CAST", drop.getType()); + assertTrue(drop.isIfExists()); + assertEquals(CascadeBehavior.CASCADE, drop.getBehavior()); + CastSignature cast = drop.getCast(); + assertEquals("bigint", cast.getSourceType().getDataType()); + assertEquals("int4", cast.getTargetType().getDataType()); + assertTrue(drop.getNames().isEmpty()); + assertNull(drop.getName()); + assertTrue(drop.getOperators().isEmpty()); + assertNull(drop.getTransform()); + + cast.setTargetType(new ColDataType("integer")); + assertEquals("DROP CAST IF EXISTS (bigint AS integer) CASCADE", drop.toString()); + assertRendersAlike(drop); + + assertEquals("DROP CAST (text AS integer)", + new Drop().withObjectType(Drop.ObjectType.CAST) + .withCast(new CastSignature(new ColDataType("text"), + new ColDataType("integer"))) + .toString()); + } + + @Test + void operatorFields() throws JSQLParserException { + Drop drop = + parse("DROP OPERATOR IF EXISTS public.=== (integer, integer), ~ (NONE, bigint)"); + assertEquals(Drop.ObjectType.OPERATOR, drop.getObjectType()); + assertEquals(2, drop.getOperators().size()); + + OperatorSignature first = drop.getOperators().get(0); + assertEquals("public", first.getOperator().getSchemaName()); + assertEquals("===", first.getOperator().getName()); + assertFalse(first.getOperator().isUseOperatorKeyword()); + assertEquals("integer", first.getLeftType().getDataType()); + assertEquals("integer", first.getRightType().getDataType()); + + OperatorSignature prefix = drop.getOperators().get(1); + assertNull(prefix.getOperator().getSchemaName()); + assertEquals("~", prefix.getOperator().getName()); + assertNull(prefix.getLeftType(), "NONE is a null operand type"); + assertEquals("bigint", prefix.getRightType().getDataType()); + + assertEquals(List.of("public.===", "~"), names(drop)); + assertThrows(UnsupportedOperationException.class, + () -> drop.getNames().add(new Table("x"))); + assertThrows(UnsupportedOperationException.class, + () -> drop.getOperators().add(new OperatorSignature())); + assertNull(drop.getCast()); + + prefix.setLeftType(new ColDataType("bigint")); + first.setRightType(null); + assertEquals("DROP OPERATOR IF EXISTS public.=== (integer, NONE), ~ (bigint, bigint)", + drop.toString()); + assertRendersAlike(drop); + + // ## is an operator with the PostgreSQL dialect; without one it is an identifier, as in + // SQL Server's ##global_temp + Drop hash = parse("DROP OPERATOR ## (lseg, lseg)"); + assertEquals("##", hash.getOperators().get(0).getOperator().getName()); + assertEquals("DROP OPERATOR ## (lseg, lseg)", hash.toString()); + + assertEquals("DROP OPERATOR @@ (NONE, text) CASCADE", new Drop() + .withObjectType(Drop.ObjectType.OPERATOR) + .addOperators(new OperatorSignature(new ExclusionOperator().withName("@@"), null, + new ColDataType("text"))) + .withBehavior(CascadeBehavior.CASCADE).toString()); + } + + @Test + void transformFields() throws JSQLParserException { + Drop drop = parse( + "DROP TRANSFORM IF EXISTS FOR public.hstore LANGUAGE plpython3u RESTRICT"); + assertEquals(Drop.ObjectType.TRANSFORM, drop.getObjectType()); + TransformSignature transform = drop.getTransform(); + assertEquals("public.hstore", transform.getDataType().getDataType()); + assertEquals("plpython3u", transform.getLanguage()); + assertEquals(CascadeBehavior.RESTRICT, drop.getBehavior()); + assertTrue(drop.getNames().isEmpty()); + + transform.setLanguage("plperl"); + assertEquals("DROP TRANSFORM IF EXISTS FOR public.hstore LANGUAGE plperl RESTRICT", + drop.toString()); + assertRendersAlike(drop); + + assertEquals("DROP TRANSFORM FOR hstore LANGUAGE plperl", + new Drop().withObjectType(Drop.ObjectType.TRANSFORM) + .withTransform(new TransformSignature(new ColDataType("hstore"), "plperl")) + .toString()); + } + + @Test + void signaturesSpanTheirSource() throws JSQLParserException { + String sql = "DROP CAST IF EXISTS (bigint AS int4) CASCADE"; + assertSpans("(bigint AS int4)", sql, parse(sql).getCast()); + + sql = "DROP OPERATOR public.=== (integer, integer), ~ (NONE, bigint) RESTRICT"; + Drop operators = parse(sql); + assertSpans("public.=== (integer, integer)", sql, operators.getOperators().get(0)); + assertSpans("~ (NONE, bigint)", sql, operators.getOperators().get(1)); + assertSpans("bigint", sql, operators.getOperators().get(1).getRightType()); + + sql = "DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u"; + assertSpans("FOR public.hstore LANGUAGE plpython3u", sql, parse(sql).getTransform()); + assertSpans(sql, sql, parse(sql)); + } + + @Test + void targetKindsReplaceEachOther() throws JSQLParserException { + Drop drop = parse("DROP OPERATOR === (integer, integer)"); + drop.withObjectType(Drop.ObjectType.CAST) + .setCast(new CastSignature(new ColDataType("text"), new ColDataType("int"))); + assertTrue(drop.getOperators().isEmpty()); + assertEquals("DROP CAST (text AS int)", drop.toString()); + + drop.withObjectType(Drop.ObjectType.TRANSFORM) + .setTransform(new TransformSignature(new ColDataType("hstore"), "plperl")); + assertNull(drop.getCast()); + assertEquals("DROP TRANSFORM FOR hstore LANGUAGE plperl", drop.toString()); + + drop.withObjectType(Drop.ObjectType.OPERATOR).setOperators(List.of( + new OperatorSignature(new ExclusionOperator().withName("+"), null, + new ColDataType("int")))); + assertNull(drop.getTransform()); + assertEquals("DROP OPERATOR + (NONE, int)", drop.toString()); + + // the legacy name setters switch to plain names + drop.setName(new Table("op")); + assertTrue(drop.getOperators().isEmpty()); + assertEquals("DROP OPERATOR op", drop.toString()); + + Drop cast = parse("DROP CAST (text AS integer) CASCADE"); + cast.addNames(new Table("c")); + assertNull(cast.getCast()); + assertEquals("DROP CAST c CASCADE", cast.toString()); + } + + @Test + void operatorNamesStayNamesOutsidePostgreSql() throws JSQLParserException { + Drop oracle = (Drop) CCJSqlParserUtil.parse("DROP OPERATOR app.eq_op", + parser -> parser.withDialect(Dialect.ORACLE)); + assertEquals(Drop.ObjectType.OPERATOR, oracle.getObjectType()); + assertEquals(List.of("app.eq_op"), names(oracle)); + assertTrue(oracle.getOperators().isEmpty()); + assertEquals("DROP OPERATOR app.eq_op", oracle.toString()); + + for (String sql : List.of("DROP OPERATOR IF EXISTS eq_op CASCADE", "DROP TRANSFORM t")) { + assertSqlCanBeParsedAndDeparsed(sql); + assertThrows(JSQLParserException.class, + () -> parse(sql), sql + " needs a signature in PostgreSQL"); + } + + // identifiers that start with an operator character or a quote are names too + assertEquals(List.of("`eq_op`"), + names((Drop) assertSqlCanBeParsedAndDeparsed("DROP OPERATOR `eq_op`"))); + Drop temporary = (Drop) CCJSqlParserUtil.parse("DROP OPERATOR #tmp", + parser -> parser.withDialect(Dialect.SQLSERVER)); + assertEquals(List.of("#tmp"), names(temporary)); + assertTrue(temporary.getOperators().isEmpty()); + } + + @Test + void schemasNamedLikeTypeWordsQualifyOperators() throws JSQLParserException { + Drop drop = parse("DROP OPERATOR class.+ (int, int), family.- (NONE, int)"); + assertEquals(Drop.ObjectType.OPERATOR, drop.getObjectType()); + assertEquals(List.of("class.+", "family.-"), names(drop)); + assertEquals(Drop.ObjectType.OPERATOR_CLASS, + parse("DROP OPERATOR CLASS c USING btree").getObjectType()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP CAST text AS integer", "DROP CAST (text)", + "DROP CAST (text AS integer), (int AS text)", "DROP CAST (text AS integer) foo", + "DROP CAST IF EXISTS", "DROP CAST (text AS integer) LOCK = NONE", + "DROP CAST (text AS integer) CASCADE RESTRICT", "DROP OPERATOR === (integer)", + "DROP OPERATOR === (NONE, NONE)", "DROP OPERATOR ===", "DROP OPERATOR === ()", + "DROP OPERATOR === (int, int, int)", "DROP OPERATOR foo (int, int)", + "DROP OPERATOR foo", "DROP OPERATOR === (int, int) foo", + "DROP OPERATOR = = (int, int)", "DROP OPERATOR === (int, int) ON t", + "DROP OPERATOR === (int, int),", "DROP OPERATOR === (int, int) USING btree", + "DROP OPERATOR IF EXISTS", "DROP TRANSFORM FOR hstore", + "DROP TRANSFORM hstore LANGUAGE plpython3u", "DROP TRANSFORM FOR hstore LANGUAGE", + "DROP TRANSFORM FOR hstore LANGUAGE a, b", + "DROP TRANSFORM FOR hstore LANGUAGE plpython3u foo", "DROP TRANSFORM foo"}) + void rejectsMalformedSignatures(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + + @Test + void pgDumpCleanScriptParses() throws JSQLParserException { + String script = "SET statement_timeout = 0;\n" + + "SELECT pg_catalog.set_config('search_path', '', false);\n" + + "DROP TRANSFORM IF EXISTS FOR public.hstore LANGUAGE plpython3u;\n" + + "DROP CAST IF EXISTS (text AS public.mood);\n" + + "DROP OPERATOR IF EXISTS public.~ (NONE, bigint);\n" + + "DROP OPERATOR IF EXISTS public.=== (integer, integer);\n" + + "DROP OPERATOR CLASS IF EXISTS public.myops USING btree;\n" + + "DROP FUNCTION IF EXISTS public.mood_from_text(text);\n" + + "DROP TYPE IF EXISTS public.mood;\n" + + "DROP EXTENSION IF EXISTS hstore;\n" + + "DROP SCHEMA IF EXISTS public;\n"; + Statements statements = CCJSqlParserUtil.parseStatements(script, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(11, statements.size()); + assertEquals(List.of(Drop.ObjectType.TRANSFORM, Drop.ObjectType.CAST, + Drop.ObjectType.OPERATOR, Drop.ObjectType.OPERATOR), + statements.subList(2, 6).stream().map(statement -> ((Drop) statement) + .getObjectType()).collect(Collectors.toList())); + assertEquals("DROP OPERATOR IF EXISTS public.=== (integer, integer)", + statements.get(5).toString()); + } + + private static void assertSpans(String expected, String sql, ASTNodeAccess part) { + Node node = part.getASTNode(); + assertEquals(expected, sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + private static List names(Drop drop) { + return drop.getNames().stream().map(Table::getFullyQualifiedName) + .collect(Collectors.toList()); + } + + private static void assertRendersAlike(Drop drop) { + StringBuilder builder = new StringBuilder(); + drop.accept(new StatementDeParser(builder), null); + assertEquals(drop.toString(), builder.toString()); + } + + private static Drop parse(String sql) throws JSQLParserException { + return (Drop) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static List roundTrip(String sql, Dialect dialect) throws JSQLParserException { + Drop drop = (Drop) assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect)); + assertRendersAlike(drop); + return List.of(drop, (Drop) CCJSqlParserUtil.parse(drop.toString(), + parser -> parser.withDialect(dialect))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/DropTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/DropTest.java index a2a25ab6f4..ca35f4640d 100644 --- a/src/test/java/net/sf/jsqlparser/statement/drop/DropTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/drop/DropTest.java @@ -16,6 +16,7 @@ import net.sf.jsqlparser.parser.CCJSqlParserManager; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CascadeBehavior; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.Statements; import static net.sf.jsqlparser.test.TestUtils.*; @@ -47,7 +48,7 @@ public void testDropIndex() throws JSQLParserException { assertEquals("CASCADE", parsed.getParameters().get(0)); assertEquals(statement, "" + parsed); Drop created = new Drop().withType("INDEX").withName(new Table("myindex")) - .addParameters("CASCADE"); + .withBehavior(CascadeBehavior.CASCADE); assertDeparse(created, statement); assertEqualsObjectTree(parsed, created); } @@ -89,7 +90,7 @@ public void testDropRestrictIssue510() throws JSQLParserException { String statement = "DROP TABLE TABLE2 RESTRICT"; Statement parsed = assertSqlCanBeParsedAndDeparsed(statement); Drop created = new Drop().withType("TABLE").withName(new Table("TABLE2")) - .addParameters(asList("RESTRICT")); + .withBehavior(CascadeBehavior.RESTRICT); assertDeparse(created, statement); assertEqualsObjectTree(parsed, created); } diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/OracleDropSynonymTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/OracleDropSynonymTest.java new file mode 100644 index 0000000000..237ed6671f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/drop/OracleDropSynonymTest.java @@ -0,0 +1,109 @@ +/*- + * #%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.drop; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +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 OracleDropSynonymTest { + @ParameterizedTest + @ValueSource(strings = {"sample_syn", "\"Sample.Synonym\""}) + void preservesSynonymModifiers(String name) throws JSQLParserException { + for (String scope : new String[] {"", "PUBLIC "}) { + for (String existence : new String[] {"", "IF EXISTS "}) { + for (String force : new String[] {"", " FORCE"}) { + String sql = "DROP " + scope + "SYNONYM " + existence + name + force; + for (Dialect dialect : new Dialect[] {null, Dialect.ORACLE}) { + Drop drop = parse(sql, dialect); + assertEquals(Drop.ObjectType.SYNONYM, drop.getObjectType()); + assertEquals("SYNONYM", drop.getType()); + assertEquals(!scope.isEmpty(), drop.isPublicSynonym()); + assertEquals(!existence.isEmpty(), drop.isIfExists()); + assertEquals(!force.isEmpty(), drop.isForce()); + assertEquals(1, drop.getNames().size()); + assertEquals(name, drop.getName().getName()); + assertEquals(sql, drop.toString()); + roundTrip(drop, dialect); + assertEquals(2, + CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + } + } + } + } + + @Test + void preservesQualifiedNamesAndSupportsModelChanges() throws JSQLParserException { + Drop drop = parse("DROP SYNONYM IF EXISTS \"hr.schema\".\"sample.syn\" FORCE", + Dialect.ORACLE); + assertEquals("\"hr.schema\"", drop.getName().getSchemaName()); + assertEquals("\"sample.syn\"", drop.getName().getName()); + drop.getName().setName("replacement"); + assertEquals("DROP SYNONYM IF EXISTS \"hr.schema\".replacement FORCE", drop.toString()); + roundTrip(drop, Dialect.ORACLE); + + Drop created = new Drop().withObjectType(Drop.ObjectType.SYNONYM) + .withPublicSynonym(true).withIfExists(true).withName(new Table("s")) + .withForce(true); + assertEquals("DROP PUBLIC SYNONYM IF EXISTS s FORCE", created.toString()); + roundTrip(created, Dialect.ORACLE); + created.setPublicSynonym(false); + created.setForce(false); + assertEquals("DROP SYNONYM IF EXISTS s", created.toString()); + roundTrip(created, null); + } + + @Test + void keepsPostgreSqlForceSyntax() throws JSQLParserException { + Drop database = parse("DROP DATABASE d WITH (FORCE)", Dialect.POSTGRESQL); + assertTrue(database.isForce()); + assertEquals("DROP DATABASE d WITH (FORCE)", database.toString()); + roundTrip(database, Dialect.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP PUBLIC TABLE t", "DROP SYNONYM", + "DROP PUBLIC SYNONYM IF EXISTS", + "DROP SYNONYM s FORCE FORCE", "DROP SYNONYM s WITH (FORCE)", + "DROP TABLE t FORCE"}) + void rejectsMalformedSynonymClauses(String sql) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.ORACLE)); + } + + private static Drop parse(String sql, Dialect dialect) throws JSQLParserException { + return (Drop) CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + + private static void roundTrip(Drop drop, Dialect dialect) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + drop.accept(new StatementDeParser(output), null); + assertEquals(drop.toString(), output.toString()); + Drop reparsed = parse(output.toString(), dialect); + assertEquals(drop.getObjectType(), reparsed.getObjectType()); + assertEquals(drop.isPublicSynonym(), reparsed.isPublicSynonym()); + assertEquals(drop.isIfExists(), reparsed.isIfExists()); + assertEquals(drop.isForce(), reparsed.isForce()); + assertEquals(output.toString(), reparsed.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/drop/PostgreSqlDropIndexTest.java b/src/test/java/net/sf/jsqlparser/statement/drop/PostgreSqlDropIndexTest.java new file mode 100644 index 0000000000..e0fd692a37 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/drop/PostgreSqlDropIndexTest.java @@ -0,0 +1,56 @@ +/*- + * #%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.drop; + +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.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 PostgreSqlDropIndexTest { + @ParameterizedTest + @ValueSource(strings = {"DROP INDEX CONCURRENTLY ix", + "DROP INDEX CONCURRENTLY IF EXISTS ix", + "DROP INDEX CONCURRENTLY IF EXISTS public.ix RESTRICT"}) + void concurrencyIsIndependentOfTarget(String sql) throws JSQLParserException { + Drop drop = (Drop) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + assertTrue(drop.isConcurrently()); + assertEquals(sql.contains("IF EXISTS"), drop.isIfExists()); + assertEquals("ix", drop.getName().getName()); + assertEquals(sql, drop.toString()); + drop.setName(new Table("new_ix")); + String expected = sql.replace("public.ix", "ix").replace("ix", "new_ix"); + assertEquals(expected, drop.toString()); + StringBuilder buffer = new StringBuilder(); + drop.accept(new StatementDeParser(buffer), null); + assertEquals(expected, buffer.toString()); + Drop reparsed = (Drop) CCJSqlParserUtil.parse(expected); + assertEquals("new_ix", reparsed.getName().getName()); + assertTrue(reparsed.isConcurrently()); + assertEquals(2, CCJSqlParserUtil.parseStatements(expected + "; SELECT 1").size()); + drop.setConcurrently(false); + assertEquals(expected.replace("CONCURRENTLY ", ""), drop.toString()); + } + + @Test + void ordinaryAndQuotedConcurrentNamesArePreserved() throws JSQLParserException { + for (String sql : new String[] {"DROP TABLE concurrently", "DROP INDEX \"concurrently\"", + "DROP INDEX ix1, ix2 CASCADE", "DROP INDEX ix ON t ALGORITHM = INPLACE"}) { + Drop drop = (Drop) CCJSqlParserUtil.parse(sql); + assertFalse(drop.isConcurrently()); + assertEquals(sql, drop.toString()); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/foreign/ImportForeignSchemaTest.java b/src/test/java/net/sf/jsqlparser/statement/foreign/ImportForeignSchemaTest.java new file mode 100644 index 0000000000..225534659e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/foreign/ImportForeignSchemaTest.java @@ -0,0 +1,340 @@ +/*- + * #%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.foreign; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertNotNull; +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.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.schema.TableReference; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.foreign.ImportForeignSchema.Qualification; +import net.sf.jsqlparser.statement.imprt.Import; +import net.sf.jsqlparser.statement.select.Select; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class ImportForeignSchemaTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + private static final List> POSTGRESQL_AND_NO_DIALECT = + Arrays.asList(POSTGRESQL, parser -> { + }); + + private static List names(ImportForeignSchema statement) { + return statement.getTables().stream().map(TableReference::toString) + .collect(Collectors.toList()); + } + + @ParameterizedTest + @ValueSource(strings = {"IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1, t2) FROM SERVER srv INTO local " + + "OPTIONS (import_default 'true')", + "IMPORT FOREIGN SCHEMA remote EXCEPT (t3) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote EXCEPT (t1, t2, t3) FROM SERVER srv INTO local " + + "OPTIONS (import_collate 'false', import_not_null 'true')", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local " + + "OPTIONS (import_default 'true', fetch_size '100')", + "IMPORT FOREIGN SCHEMA \"Remote Schema\" LIMIT TO (\"T 1\", t2) " + + "FROM SERVER \"My Srv\" INTO \"Local Schema\"", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (s.t1, d.s.t2) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (ONLY t1, t2 *) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote EXCEPT (ONLY (t1)) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local " + + "OPTIONS (\"Import Default\" 'true')", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local " + + "OPTIONS (import_default E'tr\\165e')", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local " + + "OPTIONS (import_default $$true$$)", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (user 'x')", + "IMPORT FOREIGN SCHEMA server FROM SERVER server INTO server", + "IMPORT FOREIGN SCHEMA options FROM SERVER options INTO options OPTIONS (options 'x')", + "IMPORT FOREIGN SCHEMA import FROM SERVER srv INTO schema"}) + void parsesAndDeparsesWithPostgreSqlAndWithoutDialect(String sql) + throws JSQLParserException { + for (Consumer mode : POSTGRESQL_AND_NO_DIALECT) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, mode); + assertInstanceOf(ImportForeignSchema.class, statement); + assertEquals(sql, statement.toString()); + StringBuilder deparsed = new StringBuilder(); + statement.accept(new StatementDeParser(deparsed)); + assertEquals(sql, deparsed.toString()); + } + } + + @Test + void keepsEveryClause() throws JSQLParserException { + ImportForeignSchema statement = (ImportForeignSchema) CCJSqlParserUtil.parse( + "import foreign schema remote limit to (t1, s.t2) from server srv into local " + + "options (import_default 'true', import_collate 'false')", + POSTGRESQL); + assertEquals("remote", statement.getRemoteSchema()); + assertEquals(Qualification.LIMIT_TO, statement.getQualification()); + assertEquals(List.of("t1", "s.t2"), names(statement)); + assertEquals("s", statement.getTables().get(1).getTable().getSchemaName()); + assertEquals("srv", statement.getServer()); + assertEquals("local", statement.getLocalSchema()); + assertEquals(2, statement.getOptions().size()); + ForeignDataOption option = statement.getOptions().get(0); + assertNull(option.getAction()); + assertEquals("import_default", option.getName()); + assertEquals("true", option.getValue().getValue()); + assertEquals("IMPORT FOREIGN SCHEMA remote LIMIT TO (t1, s.t2) FROM SERVER srv INTO local " + + "OPTIONS (import_default 'true', import_collate 'false')", statement.toString()); + + ImportForeignSchema except = (ImportForeignSchema) CCJSqlParserUtil.parse( + "IMPORT FOREIGN SCHEMA remote EXCEPT (ONLY (t1), t2 *, ONLY t3) " + + "FROM SERVER srv INTO local", + POSTGRESQL); + assertEquals(Qualification.EXCEPT, except.getQualification()); + assertEquals(List.of("ONLY (t1)", "t2 *", "ONLY t3"), names(except)); + assertTrue(except.getTables().get(0).isParenthesized()); + assertTrue(except.getTables().get(1).isIncludeDescendants()); + assertTrue(except.getTables().get(2).isOnly()); + assertNull(except.getOptions()); + + ImportForeignSchema whole = (ImportForeignSchema) CCJSqlParserUtil.parse( + "IMPORT FOREIGN SCHEMA \"Remote\" FROM SERVER \"Srv\" INTO \"Local\""); + assertEquals("\"Remote\"", whole.getRemoteSchema()); + assertEquals("\"Srv\"", whole.getServer()); + assertEquals("\"Local\"", whole.getLocalSchema()); + assertNull(whole.getQualification()); + assertThat(whole.getTables()).isEmpty(); + } + + @Test + void buildsAndDeparses() { + ImportForeignSchema statement = new ImportForeignSchema().withRemoteSchema("remote") + .withServer("srv").withLocalSchema("local"); + assertDeparse(statement, "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local"); + + List tables = new ArrayList<>(); + tables.add(new TableReference(new Table("t1"))); + statement.withTables(Qualification.EXCEPT, tables); + tables.add(new TableReference(new Table("ignored"))); + assertDeparse(statement, + "IMPORT FOREIGN SCHEMA remote EXCEPT (t1) FROM SERVER srv INTO local"); + assertThrows(UnsupportedOperationException.class, + () -> statement.getTables().add(new TableReference(new Table("t2")))); + + statement.setTables(Qualification.LIMIT_TO, tables); + List options = new ArrayList<>(); + options.add(new ForeignDataOption("import_default", new StringValue("true"))); + statement.setOptions(options); + assertDeparse(statement, "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1, ignored) " + + "FROM SERVER srv INTO local OPTIONS (import_default 'true')"); + + assertThrows(IllegalArgumentException.class, + () -> statement.setTables(Qualification.LIMIT_TO, List.of())); + assertThrows(IllegalArgumentException.class, + () -> statement.setTables(Qualification.EXCEPT, null)); + assertThrows(IllegalArgumentException.class, () -> statement.setTables(null, tables)); + assertEquals(Qualification.LIMIT_TO, statement.getQualification()); + + statement.setTables(null, null); + statement.setOptions(null); + assertNull(statement.getQualification()); + assertDeparse(statement, "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local"); + assertThrows(NullPointerException.class, () -> new ImportForeignSchema().toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"IMPORT FOREIGN SCHEMA remote FROM SERVER srv", + "IMPORT FOREIGN SCHEMA remote INTO local", + "IMPORT FOREIGN SCHEMA FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote FROM srv INTO local", + "IMPORT SCHEMA remote FROM SERVER srv INTO local", + "IMPORT FOREIGN TABLE remote FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT (t1) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO t1 FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO () FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote EXCEPT () FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote EXCEPT FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1) EXCEPT (t2) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1,) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO (ONLY t1 *) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote LIMIT TO ((t1)) FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local LIMIT TO (t1)", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS ()", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (import_default)", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (import_default true)", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (import_default 1)", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (a = 'true')", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (ADD a 'true')", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (SET a 'true')", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (DROP a)", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS a 'true'", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local OPTIONS (a 'b') " + + "OPTIONS (c 'd')", + "IMPORT FOREIGN SCHEMA a.remote FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote FROM SERVER a.srv INTO local", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO a.local", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local CASCADE", + "IMPORT FOREIGN SCHEMA IF EXISTS remote FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA limit FROM SERVER srv INTO local", + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO select", + "IMPORT FOREIGN SCHEMA remote FROM SERVER 'srv' INTO local", + "IMPORT FOREIGN SCHEMA remote, remote2 FROM SERVER srv INTO local"}) + void rejectsWhatPostgreSqlRejects(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void otherDialectsAndOtherUsesKeepTheirReading() throws JSQLParserException { + String sql = "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local"; + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER, Dialect.EXASOL}) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + dialect.name()); + } + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL).withUnsupportedStatements(true))); + // IMPORT not followed by FOREIGN stays unsupported outside EXASOL + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'", + parser -> parser.withUnsupportedStatements(true))); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'", + POSTGRESQL)); + + Consumer exasol = parser -> parser.withDialect(Dialect.EXASOL); + assertInstanceOf(Import.class, assertSqlCanBeParsedAndDeparsed( + "IMPORT INTO schemaName.tableName FROM LOCAL CSV FILE 'file.csv'", true, exasol)); + assertInstanceOf(Select.class, assertSqlCanBeParsedAndDeparsed( + "SELECT * FROM (IMPORT INTO (c1 INT) FROM LOCAL CSV FILE 'file.csv')", true, + exasol)); + assertInstanceOf(Alter.class, assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t IMPORT TABLESPACE", true, + parser -> parser.withDialect(Dialect.MYSQL))); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + for (Consumer mode : POSTGRESQL_AND_NO_DIALECT) { + Statements statements = CCJSqlParserUtil.parseStatements( + "IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local; SELECT 1;\n" + + "IMPORT FOREIGN SCHEMA r EXCEPT (t) FROM SERVER s INTO l OPTIONS (a 'b');" + + "IMPORT FOREIGN SCHEMA r FROM SERVER s INTO l\n" + + "IMPORT FOREIGN SCHEMA r FROM SERVER s INTO l OPTIONS (a 'b')\n" + + "SELECT 2; DECLARE c CURSOR FOR SELECT * FROM local.t; " + + "IMPORT FOREIGN SCHEMA r FROM SERVER s INTO l; FETCH NEXT FROM c; CLOSE c", + mode); + assertEquals(10, statements.size()); + assertEquals("IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local", + statements.get(0).toString()); + assertInstanceOf(Select.class, statements.get(1)); + assertEquals("IMPORT FOREIGN SCHEMA r EXCEPT (t) FROM SERVER s INTO l OPTIONS (a 'b')", + statements.get(2).toString()); + assertEquals("IMPORT FOREIGN SCHEMA r FROM SERVER s INTO l", + statements.get(3).toString()); + assertEquals("IMPORT FOREIGN SCHEMA r FROM SERVER s INTO l OPTIONS (a 'b')", + statements.get(4).toString()); + assertInstanceOf(Select.class, statements.get(5)); + assertEquals("DeclareCursorStatement", statements.get(6).getClass().getSimpleName()); + assertInstanceOf(ImportForeignSchema.class, statements.get(7)); + assertEquals("FetchCursorStatement", statements.get(8).getClass().getSimpleName()); + assertEquals("CloseCursorStatement", statements.get(9).getClass().getSimpleName()); + assertThat(new TablesNamesFinder<>().getTables(statements.get(6))) + .containsExactly("local.t"); + assertThat(new TablesNamesFinder<>().getTables(statements.get(7))).isEmpty(); + } + + Statements afterUnsupported = CCJSqlParserUtil.parseStatements( + "FOO bar baz; IMPORT FOREIGN SCHEMA r FROM SERVER s INTO l", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(2, afterUnsupported.size()); + assertInstanceOf(UnsupportedStatement.class, afterUnsupported.get(0)); + assertInstanceOf(ImportForeignSchema.class, afterUnsupported.get(1)); + } + + @Test + void reachesVisitorsAndReportsNoLocalTables() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse( + "IMPORT FOREIGN SCHEMA remote LIMIT TO (t1, t2) FROM SERVER srv INTO local " + + "OPTIONS (import_default 'true')", + POSTGRESQL); + String visited = statement.accept(new StatementVisitorAdapter() { + @Override + public String visit(ImportForeignSchema importForeignSchema, S context) { + return importForeignSchema.getServer(); + } + }, null); + assertEquals("srv", visited); + assertNull(statement.accept(new StatementVisitorAdapter(), null)); + + List expressions = new ArrayList<>(); + ((ImportForeignSchema) statement).visitExpressions(expressions::add); + assertEquals(1, expressions.size()); + assertInstanceOf(StringValue.class, expressions.get(0)); + + // the listed names belong to the remote schema + assertThat(new TablesNamesFinder<>().getTables(statement)).isEmpty(); + assertNotNull(((ImportForeignSchema) statement).getASTNode()); + } + + @Test + void modifiesTheSchema() throws JSQLParserException { + StatementFeatures features = CCJSqlParserUtil + .parse("IMPORT FOREIGN SCHEMA remote FROM SERVER srv INTO local").getFeatures(); + assertThat(features.getCertain()).containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertThat(features.getUncertain()).isEmpty(); + } + + @Test + void validatesTheFeature() { + String sql = "IMPORT FOREIGN SCHEMA remote EXCEPT (t1) FROM SERVER srv INTO local " + + "OPTIONS (import_default 'true')"; + ValidationTestAsserts.validateNoErrors(sql, 1, PostgresqlVersion.V14); + ValidationTestAsserts.validateNoErrors(sql, 1, FeaturesAllowed.DDL); + ValidationTestAsserts.validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, + Feature.importForeignSchema); + assertFalse(new Validation(List.of(MySqlVersion.V8_0), sql).validate().isEmpty()); + assertFalse(new Validation(List.of(FeaturesAllowed.DML), sql).validate().isEmpty()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/grant/GranteeModelTest.java b/src/test/java/net/sf/jsqlparser/statement/grant/GranteeModelTest.java new file mode 100644 index 0000000000..dd26645eed --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/grant/GranteeModelTest.java @@ -0,0 +1,195 @@ +/*- + * #%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.grant; + +import static net.sf.jsqlparser.test.TestUtils.assertEqualsObjectTree; +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Arrays; +import java.util.Collections; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** The grantee model shared by MySQL and PostgreSQL, and the string-based legacy API. */ +class GranteeModelTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Statement parse(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), POSTGRESQL).toString()); + return statement; + } + + @Test + void typesPostgreSqlRoleSpecifications() throws JSQLParserException { + Grant grant = (Grant) parse("GRANT SELECT ON users TO app, GROUP staff, PUBLIC, " + + "CURRENT_USER, CURRENT_ROLE, SESSION_USER, \"Mixed Case\" GRANTED BY CURRENT_ROLE"); + + assertThat(grant.getClause().getGranteeItems()).extracting(Grantee::getKind) + .containsExactly(Grantee.Kind.ACCOUNT, Grantee.Kind.GROUP, Grantee.Kind.PUBLIC, + Grantee.Kind.CURRENT_USER, Grantee.Kind.CURRENT_ROLE, + Grantee.Kind.SESSION_USER, Grantee.Kind.ACCOUNT); + Grantee group = grant.getClause().getGranteeItems().get(1); + assertEquals("staff", group.getAccount().getUser().getValue()); + assertNull(group.getAccount().getHost()); + Grantee quoted = grant.getClause().getGranteeItems().get(6); + assertEquals("Mixed Case", quoted.getAccount().getUser().getValue()); + assertEquals("\"", quoted.getAccount().getUser().getQuoteStr()); + assertEquals(Grantee.Kind.CURRENT_ROLE, grant.getClause().getGrantor().getKind()); + + assertEquals(Arrays.asList("app", "GROUP staff", "PUBLIC", "CURRENT_USER", "CURRENT_ROLE", + "SESSION_USER", "\"Mixed Case\""), grant.getUsers()); + assertEquals("CURRENT_ROLE", grant.getClause().getGrantedBy()); + assertThat(TablesNamesFinder.findTables(grant.toString())).containsExactly("users"); + } + + @Test + void typesMembershipOptionList() throws JSQLParserException { + Grant grant = (Grant) parse( + "GRANT app_read TO alice WITH INHERIT TRUE, SET FALSE, ADMIN OPTION GRANTED BY postgres"); + + assertNull(grant.getTarget()); + assertThat(grant.getOptions()).extracting(GrantOption::getKind).containsExactly( + GrantOption.Kind.INHERIT, GrantOption.Kind.SET, GrantOption.Kind.ADMIN); + assertThat(grant.getOptions()).extracting(GrantOption::getValue).containsExactly( + GrantOption.Value.TRUE, GrantOption.Value.FALSE, GrantOption.Value.OPTION); + assertSame(grant.getOptions().get(0), grant.getOption()); + assertEquals("postgres", grant.getClause().getGrantor().getAccount().getUser().getValue()); + + grant.setOption(new GrantOption(GrantOption.Kind.ADMIN)); + assertEquals("GRANT app_read TO alice WITH ADMIN OPTION GRANTED BY postgres", + grant.toString()); + grant.setOption(null); + assertEquals("GRANT app_read TO alice GRANTED BY postgres", grant.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "GRANT app_read TO alice WITH INHERIT TRUE, INHERIT FALSE", + "GRANT app_read TO alice WITH ADMIN OPTION, GRANT OPTION", + "GRANT SELECT ON users TO alice WITH GRANT OPTION, INHERIT TRUE", + "GRANT SELECT ON users TO alice GRANTED BY PUBLIC", + "GRANT SELECT ON users TO alice GRANTED BY GROUP staff", + "GRANT SELECT ON users TO GROUP" + }) + void rejectsInvalidRoleSpecifications(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @Test + void legacyGranteeStringsWriteThroughTypedState() throws JSQLParserException { + Grant grant = (Grant) CCJSqlParserUtil.parse("GRANT SELECT ON t TO 'app'@'%', app2", + parser -> parser.withDialect(Dialect.MYSQL)); + Grantee typed = grant.getClause().getGranteeItems().get(0); + + grant.getUsers().add("PUBLIC"); + grant.getUsers().set(1, "GROUP staff"); + grant.addUsers("CURRENT_USER()"); + assertSame(typed, grant.getClause().getGranteeItems().get(0)); + assertThat(grant.getClause().getGranteeItems()).extracting(Grantee::getKind) + .containsExactly(Grantee.Kind.ACCOUNT, Grantee.Kind.GROUP, Grantee.Kind.PUBLIC, + Grantee.Kind.CURRENT_USER); + assertEquals("GRANT SELECT ON t TO 'app'@'%', GROUP staff, PUBLIC, CURRENT_USER()", + grant.toString()); + + grant.getUsers().remove(0); + grant.getClause().setGrantedBy("SESSION_USER"); + assertEquals(Grantee.Kind.SESSION_USER, grant.getClause().getGrantor().getKind()); + assertEquals("GRANT SELECT ON t TO GROUP staff, PUBLIC, CURRENT_USER() " + + "GRANTED BY SESSION_USER", grant.toString()); + + grant.setUsers(Collections.singletonList("reader")); + assertEquals(Grantee.Kind.ACCOUNT, grant.getClause().getGranteeItems().get(0).getKind()); + grant.setUsers(null); + assertNull(grant.getUsers()); + assertNull(new Grant().getUsers()); + } + + @Test + void legacyBuildersMatchParsedStatements() throws JSQLParserException { + Grant parsed = + (Grant) CCJSqlParserUtil.parse("GRANT SELECT, CREATE VIEW ON t1 TO u, PUBLIC"); + Grant built = new Grant().addPrivileges("SELECT", "CREATE VIEW").withObjectName("t1") + .addUsers("u", "PUBLIC"); + assertEqualsObjectTree(parsed, built); + assertEquals(Privilege.Kind.CREATE_VIEW, built.getPrivilegeItems().get(1).getKind()); + + Grant role = (Grant) CCJSqlParserUtil.parse("GRANT r1 TO u GRANTED BY CURRENT_USER"); + Grant builtRole = new Grant().withRole("r1").addUsers("u"); + builtRole.getClause().setGrantedBy("CURRENT_USER"); + assertEqualsObjectTree(role, builtRole); + assertNull(builtRole.getTarget()); + + builtRole.getRoles().add("'r2'@'%'"); + assertEquals("GRANT r1, 'r2'@'%' TO u GRANTED BY CURRENT_USER", builtRole.toString()); + assertEquals("r1", builtRole.getRole()); + } + + @Test + void legacyObjectNameReplacesWildcard() throws JSQLParserException { + Grant grant = (Grant) CCJSqlParserUtil.parse("GRANT SELECT ON *.* TO app"); + assertEquals("*.*", grant.getObjectName()); + + grant.setObjectName(Arrays.asList("db1", "t1")); + assertNull(grant.getTarget().getWildcard()); + assertEquals("GRANT SELECT ON db1.t1 TO app", grant.toString()); + + Grant role = (Grant) CCJSqlParserUtil.parse("GRANT reader TO app"); + assertNull(role.getObjectName()); + role.setPrivileges(Collections.singletonList("SELECT")); + role.setObjectName("t1"); + assertEquals("GRANT SELECT ON t1 TO app", role.toString()); + } + + @Test + void legacyPrivilegeNames() { + assertEquals(Privilege.Kind.CREATE_TEMPORARY_TABLES, + new Privilege("CREATE TEMPORARY TABLES").getKind()); + assertEquals(Privilege.Kind.ALTER_SYSTEM, new Privilege("ALTER SYSTEM").getKind()); + Privilege unknown = new Privilege("DYNAMIC"); + assertNull(unknown.getKind()); + assertEquals("DYNAMIC", unknown.toString()); + Privilege text = new Privilege("select (a)"); + assertNull(text.getKind()); + assertEquals("select (a)", text.getName()); + assertFalse(new Privilege(Privilege.Kind.SELECT).isUsePrivileges()); + } + + @Test + void grantedByAndRolesAcceptLegacyText() { + PrivilegeClause clause = new PrivilegeClause(); + clause.setGrantedBy("GROUP admins"); + assertEquals(Grantee.Kind.GROUP, clause.getGrantor().getKind()); + clause.setGrantedBy(null); + assertNull(clause.getGrantor()); + + clause.setRoles(Arrays.asList("a", "b")); + clause.getRoles().set(0, "c"); + assertEquals(Arrays.asList("c", "b"), clause.getRoles()); + clause.setRoles(null); + assertEquals(Collections.emptyList(), clause.getRoleItems()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/grant/MySqlGrantRevokeTest.java b/src/test/java/net/sf/jsqlparser/statement/grant/MySqlGrantRevokeTest.java new file mode 100644 index 0000000000..9e1009ef2c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/grant/MySqlGrantRevokeTest.java @@ -0,0 +1,355 @@ +/*- + * #%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.grant; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.user.RoleSelection; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlGrantRevokeTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + + /** Parses with the MySQL dialect, checks toString and the deparser, and reparses. */ + private static Statement parse(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), MYSQL).toString()); + return statement; + } + + private static Grant grant(String sql) throws JSQLParserException { + return (Grant) parse(sql); + } + + private static Revoke revoke(String sql) throws JSQLParserException { + return (Revoke) parse(sql); + } + + /** The value and quote of the user and host, for example {@code app(')@%(')}. */ + private static String account(UserAccount account) { + StringValue host = account.getHost(); + return account.getUser().getValue() + "(" + account.getUser().getQuoteStr() + ")" + + (host == null ? "" : "@" + host.getValue() + "(" + host.getQuoteStr() + ")"); + } + + @ParameterizedTest + @ValueSource(strings = { + "GRANT SELECT ON db1.* TO 'app'@'%'", + "GRANT SELECT, INSERT, UPDATE, DELETE ON `db1`.`t1` TO 'app'@'%' WITH GRANT OPTION", + "GRANT ALL PRIVILEGES ON *.* TO 'admin'@'localhost' WITH GRANT OPTION", + "GRANT SELECT (id, name), UPDATE (name) ON db1.t1 TO 'app'@'%'", + "GRANT EXECUTE ON PROCEDURE db1.p1 TO 'app'@'%'", + "GRANT EXECUTE ON FUNCTION db1.f1 TO app@'%'", + "GRANT CREATE, ALTER, DROP, INDEX, REFERENCES, CREATE VIEW, SHOW VIEW, TRIGGER, EVENT, " + + "CREATE ROUTINE, ALTER ROUTINE, CREATE TEMPORARY TABLES, LOCK TABLES " + + "ON db1.* TO 'dev'@'%'", + "GRANT SELECT, RELOAD, SHOW DATABASES, REPLICATION SLAVE, REPLICATION CLIENT " + + "ON *.* TO 'cdc'@'%'", + "GRANT PROCESS, SUPER, FILE, SHUTDOWN, CREATE USER, CREATE TABLESPACE, CREATE ROLE, " + + "DROP ROLE, USAGE, GRANT OPTION ON *.* TO 'admin'@'%'", + "GRANT BACKUP_ADMIN, replication_slave_admin ON *.* TO 'admin'@'%'", + "GRANT 'reader', 'writer'@'%' TO 'app'@'%' WITH ADMIN OPTION", + "GRANT reader TO app", + "GRANT PROXY ON 'a'@'%' TO 'b'@'%', CURRENT_USER WITH GRANT OPTION", + "GRANT SELECT ON TABLE db1.* TO `app`@`%`", + "GRANT ALL ON * TO app@localhost", + "GRANT SELECT ON `my-db`.* TO 'app'@localhost, CURRENT_USER()", + "GRANT SELECT ON db1.* TO 'app'@'%' AS 'admin'@'%' WITH ROLE 'r1', r2@'%'", + "GRANT SELECT ON db1.t1 TO app WITH GRANT OPTION AS CURRENT_USER WITH ROLE DEFAULT", + "REVOKE INSERT ON db1.* FROM 'app'@'%', app2", + "REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'app'@'%'", + "REVOKE ALL, GRANT OPTION FROM app", + "REVOKE GRANT OPTION ON *.* FROM app", + "REVOKE 'reader', writer FROM 'app'@'%'", + "REVOKE IF EXISTS SELECT ON db1.t1 FROM 'app'@'%' IGNORE UNKNOWN USER", + "REVOKE IF EXISTS PROXY ON 'a'@'%' FROM 'b'@'%'", + "REVOKE REPLICATION SLAVE, REPLICATION CLIENT ON *.* FROM 'repl'@'%'" + }) + void roundTripsMySqlForms(String sql) throws JSQLParserException { + Statement statement = parse(sql); + + Statement withoutDialect = assertSqlCanBeParsedAndDeparsed(sql, false); + assertEquals(statement.toString(), withoutDialect.toString()); + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "* | DEFAULT_DATABASE | [] | *", + "*.* | GLOBAL | [] | *.*", + "db1.* | DATABASE | [db1] | db1.*", + "`my-db`.* | DATABASE | [`my-db`] | `my-db`.*" + }) + void typesWildcardPrivilegeLevels(String level, PrivilegeTarget.Wildcard wildcard, + String names, String objectName) throws JSQLParserException { + Grant grant = grant("GRANT SELECT ON " + level + " TO app"); + PrivilegeTarget target = grant.getTarget(); + + assertEquals(wildcard, target.getWildcard()); + assertEquals(PrivilegeTarget.Kind.TABLE, target.getKind()); + assertFalse(target.isExplicitKind()); + assertEquals(names, target.getNames().stream().map(name -> name.get(0)) + .collect(Collectors.toList()).toString()); + assertEquals(objectName, grant.getObjectName()); + assertThat(TablesNamesFinder.findTables(grant.toString())).isEmpty(); + } + + @Test + void namedPrivilegeLevelsRemainTables() throws JSQLParserException { + Grant qualified = grant("GRANT SELECT ON TABLE db1.t1 TO app"); + assertNull(qualified.getTarget().getWildcard()); + assertTrue(qualified.getTarget().isExplicitKind()); + assertEquals(Arrays.asList("db1", "t1"), qualified.getTarget().getNames().get(0)); + assertThat(TablesNamesFinder.findTables(qualified.toString())).containsExactly("db1.t1"); + + Grant routine = grant("GRANT EXECUTE ON PROCEDURE db1.p1 TO app"); + assertEquals(PrivilegeTarget.Kind.PROCEDURE, routine.getTarget().getKind()); + assertEquals("db1.p1", routine.getTarget().getRoutines().get(0).getName()); + } + + @Test + void typesStaticAndDynamicPrivileges() throws JSQLParserException { + Grant grant = grant("GRANT CREATE TEMPORARY TABLES, LOCK TABLES, SHOW DATABASES, " + + "REPLICATION SLAVE, REPLICATION CLIENT, ALTER ROUTINE, CREATE VIEW, INDEX, " + + "SHUTDOWN, GRANT OPTION, backup_admin ON *.* TO app"); + + assertThat(grant.getPrivilegeItems()).extracting(Privilege::getKind).containsExactly( + Privilege.Kind.CREATE_TEMPORARY_TABLES, Privilege.Kind.LOCK_TABLES, + Privilege.Kind.SHOW_DATABASES, Privilege.Kind.REPLICATION_SLAVE, + Privilege.Kind.REPLICATION_CLIENT, Privilege.Kind.ALTER_ROUTINE, + Privilege.Kind.CREATE_VIEW, Privilege.Kind.INDEX, Privilege.Kind.SHUTDOWN, + Privilege.Kind.GRANT_OPTION, Privilege.Kind.DYNAMIC); + Privilege dynamic = grant.getPrivilegeItems().get(10); + assertEquals("backup_admin", dynamic.getDynamicName()); + assertEquals("backup_admin", dynamic.getName()); + assertEquals("CREATE TEMPORARY TABLES", grant.getPrivilegeItems().get(0).getName()); + assertEquals("CREATE TEMPORARY TABLES", grant.getPrivileges().get(0)); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', quoteCharacter = '"', value = { + "'app'@'%' | app(')@%(')", + "app@'10.0.0.%' | app()@10.0.0.%(')", + "app@localhost | app()@localhost()", + "'app'@localhost | app(')@localhost()", + "`app`@`%` | app(`)@%(`)", + "'app' | app(')", + "app | app()" + }) + void typesAccountGrantees(String account, String expected) throws JSQLParserException { + Grant grant = grant("GRANT SELECT ON db1.t1 TO " + account); + Grantee grantee = grant.getClause().getGranteeItems().get(0); + + assertEquals(Grantee.Kind.ACCOUNT, grantee.getKind()); + assertEquals(expected, account(grantee.getAccount())); + assertEquals(Collections.singletonList(account), grant.getUsers()); + } + + @Test + void typesCurrentUser() throws JSQLParserException { + Grant grant = grant("GRANT SELECT ON db1.* TO CURRENT_USER, CURRENT_USER()"); + List grantees = grant.getClause().getGranteeItems(); + + assertThat(grantees).extracting(Grantee::getKind) + .containsExactly(Grantee.Kind.CURRENT_USER, Grantee.Kind.CURRENT_USER); + assertFalse(grantees.get(0).isCurrentUserParentheses()); + assertTrue(grantees.get(1).isCurrentUserParentheses()); + assertNull(grantees.get(0).getAccount()); + assertEquals(Arrays.asList("CURRENT_USER", "CURRENT_USER()"), grant.getUsers()); + } + + @Test + void roleGrantsHaveTypedRolesAndNoTarget() throws JSQLParserException { + Grant grant = grant("GRANT 'reader', 'writer'@'%' TO 'app'@'%' WITH ADMIN OPTION"); + + assertNull(grant.getTarget()); + assertNull(grant.getPrivilegeItems()); + assertNull(grant.getObjectName()); + assertThat(grant.getClause().getRoleItems()).extracting(MySqlGrantRevokeTest::account) + .containsExactly("reader(')", "writer(')@%(')"); + assertEquals(Arrays.asList("'reader'", "'writer'@'%'"), grant.getRoles()); + assertEquals("'reader'", grant.getRole()); + assertEquals(GrantOption.Kind.ADMIN, grant.getOption().getKind()); + assertThat(TablesNamesFinder.findTables(grant.toString())).isEmpty(); + + Revoke revoke = revoke("REVOKE 'reader' FROM 'app'@'%'"); + assertNull(revoke.getClause().getTarget()); + assertEquals("reader", revoke.getClause().getRoleItems().get(0).getUser().getValue()); + } + + @Test + void proxyTargetsAnAccount() throws JSQLParserException { + Grant grant = grant("GRANT PROXY ON 'a'@'%' TO 'b'@'%' WITH GRANT OPTION"); + + assertThat(grant.getPrivilegeItems()).extracting(Privilege::getKind) + .containsExactly(Privilege.Kind.PROXY); + PrivilegeTarget target = grant.getTarget(); + assertEquals(PrivilegeTarget.Kind.ACCOUNT, target.getKind()); + assertEquals("a(')@%(')", account(target.getAccount().getAccount())); + assertTrue(target.getNames().isEmpty()); + assertNull(grant.getObjectName()); + assertThat(TablesNamesFinder.findTables(grant.toString())).isEmpty(); + + Revoke revoke = revoke("REVOKE PROXY ON CURRENT_USER FROM 'b'@'%'"); + assertEquals(Grantee.Kind.CURRENT_USER, + revoke.getClause().getTarget().getAccount().getKind()); + } + + @Test + void revokesAllPrivilegesAndGrantOptionWithoutTarget() throws JSQLParserException { + Revoke revoke = revoke("REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'app'@'%', app2"); + PrivilegeClause clause = revoke.getClause(); + + assertThat(clause.getPrivileges()).extracting(Privilege::getKind) + .containsExactly(Privilege.Kind.ALL, Privilege.Kind.GRANT_OPTION); + assertTrue(clause.getPrivileges().get(0).isUsePrivileges()); + assertNull(clause.getTarget()); + assertEquals(Arrays.asList("'app'@'%'", "app2"), clause.getGrantees()); + assertThat(TablesNamesFinder.findTables(revoke.toString())).isEmpty(); + } + + @Test + void revokeIfExistsIgnoreUnknownUser() throws JSQLParserException { + Revoke revoke = + revoke("REVOKE IF EXISTS SELECT ON db1.t1 FROM 'app'@'%' IGNORE UNKNOWN USER"); + assertTrue(revoke.isIfExists()); + assertTrue(revoke.isIgnoreUnknownUser()); + assertThat(TablesNamesFinder.findTables(revoke.toString())).containsExactly("db1.t1"); + + revoke.setIfExists(false); + revoke.setIgnoreUnknownUser(false); + assertEquals("REVOKE SELECT ON db1.t1 FROM 'app'@'%'", revoke.toString()); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', quoteCharacter = '"', value = { + "DEFAULT | DEFAULT | \"\"", + "NONE | NONE | \"\"", + "ALL | ALL | \"\"", + "ALL EXCEPT 'r1', r2@'%' | ALL_EXCEPT | 'r1', r2@'%'", + "'r1', r2 | ROLES | 'r1', r2" + }) + void typesAsUserWithRole(String selection, RoleSelection.Kind kind, String roles) + throws JSQLParserException { + Grant grant = grant("GRANT SELECT ON db1.* TO app AS 'admin'@'%' WITH ROLE " + selection); + + assertEquals(Grantee.Kind.ACCOUNT, grant.getAsUser().getKind()); + assertEquals("admin(')@%(')", account(grant.getAsUser().getAccount())); + assertEquals(kind, grant.getWithRole().getKind()); + assertEquals(roles, grant.getWithRole().getRoles().stream().map(Object::toString) + .collect(Collectors.joining(", "))); + } + + @ParameterizedTest + @ValueSource(strings = { + "GRANT SELECT ON db1.t1.* TO app", + "GRANT SELECT ON db1.*, db2.* TO app", + "GRANT USAGE ON SCHEMA * TO app", + "GRANT EXECUTE ON PROCEDURE db1.* TO app", + "GRANT PROXY ON db1.t1 TO app", + "GRANT PROXY, SELECT ON t1 TO app", + "GRANT PROXY ON PUBLIC TO app", + "GRANT PROXY ON 'a'@'%' TO app AS admin", + "GRANT reader TO app AS admin", + "GRANT SELECT ON t1 TO app AS PUBLIC", + "GRANT SELECT ON t1 TO app WITH ROLE r1", + "GRANT SELECT ON t1 TO app WITH GRANT OPTION, GRANT OPTION", + "GRANT SELECT ON t1 TO 'app'@", + "GRANT SELECT ON t1 TO app@", + "GRANT SELECT ON t1 TO PUBLIC()", + "GRANT BACKUP_ADMIN PRIVILEGES ON *.* TO app", + "GRANT ALL PRIVILEGES, GRANT OPTION TO app", + "REVOKE SELECT ON t1 FROM app IGNORE UNKNOWN", + "ALTER DEFAULT PRIVILEGES GRANT SELECT ON *.* TO app", + "ALTER DEFAULT PRIVILEGES REVOKE IF EXISTS SELECT ON TABLES FROM app", + "ALTER DEFAULT PRIVILEGES REVOKE SELECT ON TABLES FROM app IGNORE UNKNOWN USER", + "ALTER DEFAULT PRIVILEGES GRANT PROXY ON a TO app", + "ALTER DEFAULT PRIVILEGES REVOKE ALL, GRANT OPTION FROM app" + }) + void rejectsInvalidForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @Test + void buildsTypedGrant() { + PrivilegeTarget target = new PrivilegeTarget(); + target.setWildcard(PrivilegeTarget.Wildcard.DATABASE); + target.getNames().add(Collections.singletonList("db1")); + UserAccount app = new UserAccount().withUser(new StringValue("app")) + .withHost(new StringValue("%")); + Grant grant = new Grant(); + grant.setPrivilegeItems(Arrays.asList(new Privilege(Privilege.Kind.SHOW_VIEW), + Privilege.dynamic("BACKUP_ADMIN"))); + grant.setTarget(target); + grant.getClause().setGranteeItems(Arrays.asList(new Grantee(app), + new Grantee(Grantee.Kind.CURRENT_USER).withCurrentUserParentheses(true))); + grant.setOption(new GrantOption(GrantOption.Kind.GRANT)); + grant.setAsUser(new Grantee(new UserAccount().withUser(new StringValue("admin")))); + grant.setWithRole(new RoleSelection(RoleSelection.Kind.ALL_EXCEPT) + .withRoles(Collections.singletonList( + new UserAccount().withUser(new StringValue("r1"))))); + + assertDeparse(grant, "GRANT SHOW VIEW, BACKUP_ADMIN ON db1.* TO 'app'@'%', " + + "CURRENT_USER() WITH GRANT OPTION AS 'admin' WITH ROLE ALL EXCEPT 'r1'"); + + Revoke revoke = new Revoke(); + revoke.setIfExists(true); + revoke.getClause().setPrivileges(Collections.singletonList( + new Privilege(Privilege.Kind.PROXY))); + PrivilegeTarget proxied = new PrivilegeTarget(); + proxied.setKind(PrivilegeTarget.Kind.ACCOUNT); + proxied.setAccount(new Grantee(app)); + revoke.getClause().setTarget(proxied); + revoke.getClause().setGranteeItems( + Collections.singletonList(new Grantee(Grantee.Kind.CURRENT_USER))); + revoke.setIgnoreUnknownUser(true); + assertDeparse(revoke, + "REVOKE IF EXISTS PROXY ON 'app'@'%' FROM CURRENT_USER IGNORE UNKNOWN USER"); + } + + @Test + void validatesWithMySqlAndMariaDbCapabilities() { + for (String sql : Arrays.asList("GRANT SELECT ON db1.* TO 'app'@'%'", + "GRANT 'reader' TO 'app'@'%'", + "REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'app'@'%'", + "REVOKE SELECT ON *.* FROM app")) { + validateNoErrors(sql, 1, DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/handler/MySqlHandlerStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/handler/MySqlHandlerStatementTest.java new file mode 100644 index 0000000000..60708d4250 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/handler/MySqlHandlerStatementTest.java @@ -0,0 +1,340 @@ +/*- + * #%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.handler; + +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.expression.operators.relational.GreaterThan; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod; +import net.sf.jsqlparser.statement.handler.HandlerStatement.Action; +import net.sf.jsqlparser.statement.handler.HandlerStatement.Direction; +import net.sf.jsqlparser.statement.handler.HandlerStatement.KeyComparison; +import net.sf.jsqlparser.statement.select.Limit; +import net.sf.jsqlparser.statement.select.Offset; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlHandlerStatementTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer NO_DIALECT = parser -> { + }; + + @ParameterizedTest + @ValueSource(strings = { + "HANDLER t OPEN", + "HANDLER t OPEN AS h", + "HANDLER db1.t OPEN h2", + "HANDLER `db1`.`t` OPEN AS `h`", + "HANDLER h READ FIRST", + "HANDLER h READ NEXT LIMIT 10", + "HANDLER h READ FIRST WHERE a > 1 LIMIT 5", + "HANDLER h READ i1 = (1)", + "HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3", + "HANDLER h READ i1 <= (1)", + "HANDLER h READ i1 < (1)", + "HANDLER h READ i1 > ('a', 2)", + "HANDLER h READ `PRIMARY` = (1, DEFAULT)", + "HANDLER h READ i1 FIRST", + "HANDLER h READ i1 NEXT", + "HANDLER h READ i1 PREV", + "HANDLER h READ i1 LAST WHERE a IS NULL LIMIT 2, 5", + "HANDLER h READ i1 NEXT LIMIT 5 OFFSET 2", + "HANDLER h READ first NEXT", + "HANDLER `read` READ NEXT", + "HANDLER h CLOSE"}) + void parsesMySqlFormsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(HandlerStatement.class, statement); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void opensATableUnderItsHandlerName() throws JSQLParserException { + HandlerStatement open = parse("HANDLER db1.t OPEN AS h"); + assertEquals(Action.OPEN, open.getAction()); + assertEquals("db1.t", open.getTable().getFullyQualifiedName()); + assertEquals("h", open.getTable().getAlias().getName()); + assertTrue(open.getTable().getAlias().isUseAs()); + assertEquals("h", open.getHandlerName()); + + HandlerStatement withoutAs = parse("HANDLER t OPEN h2"); + assertFalse(withoutAs.getTable().getAlias().isUseAs()); + assertEquals("h2", withoutAs.getHandlerName()); + + HandlerStatement plain = parse("HANDLER t OPEN"); + assertNull(plain.getTable().getAlias()); + assertEquals("t", plain.getHandlerName()); + } + + @Test + void readsThroughAnIndexWithKeyValues() throws JSQLParserException { + HandlerStatement read = parse("HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3"); + assertEquals(Action.READ, read.getAction()); + assertEquals("h", read.getHandlerName()); + assertEquals("i1", read.getIndexName()); + assertEquals(KeyComparison.GREATER_THAN_OR_EQUALS, read.getKeyComparison()); + assertInstanceOf(ParenthesedExpressionList.class, read.getKeyValues()); + assertEquals(List.of("1", "2"), read.getKeyValues().stream().map(Object::toString) + .collect(Collectors.toList())); + assertNull(read.getDirection()); + assertInstanceOf(GreaterThan.class, read.getWhere()); + assertEquals("3", read.getLimit().getRowCount().toString()); + assertNull(read.getOffset()); + + for (KeyComparison comparison : KeyComparison.values()) { + HandlerStatement compared = + parse("HANDLER h READ i1 " + comparison.getOperator() + " (1)"); + assertEquals(comparison, compared.getKeyComparison()); + } + } + + @Test + void readsInIndexOrStorageOrder() throws JSQLParserException { + HandlerStatement index = parse("HANDLER h READ i1 PREV"); + assertEquals("i1", index.getIndexName()); + assertEquals(Direction.PREV, index.getDirection()); + assertNull(index.getKeyComparison()); + assertNull(index.getKeyValues()); + + HandlerStatement storage = parse("HANDLER h READ next WHERE a > 1"); + assertNull(storage.getIndexName()); + assertEquals(Direction.NEXT, storage.getDirection()); + + // a direction after the word makes it the name of an index, as in MySQL's grammar + HandlerStatement named = parse("HANDLER h READ first NEXT"); + assertEquals("first", named.getIndexName()); + assertEquals(Direction.NEXT, named.getDirection()); + + HandlerStatement offset = parse("HANDLER h READ i1 LAST LIMIT 5 OFFSET 2"); + assertEquals(Direction.LAST, offset.getDirection()); + assertEquals("5", offset.getLimit().getRowCount().toString()); + assertEquals("2", offset.getOffset().getOffset().toString()); + + HandlerStatement comma = parse("HANDLER h READ FIRST LIMIT 2, 5"); + assertEquals("2", comma.getLimit().getOffset().toString()); + assertNull(comma.getOffset()); + } + + @Test + void closesAHandler() throws JSQLParserException { + HandlerStatement close = parse("HANDLER h CLOSE"); + assertEquals(Action.CLOSE, close.getAction()); + assertEquals("h", close.getHandlerName()); + assertEquals("h", close.getTable().getName()); + } + + @ParameterizedTest + @ValueSource(strings = { + "HANDLER", + "HANDLER t", + "HANDLER t OPEN AS", + "HANDLER t OPEN h AS x", + "HANDLER t OPEN AS h(a)", + "HANDLER t OPEN AS 'h'", + "HANDLER db1.t CLOSE", + "HANDLER db1.t READ FIRST", + "HANDLER h READ", + "HANDLER h READ PREV", + "HANDLER h READ LAST", + "HANDLER h READ i1", + "HANDLER h READ i1 = 1", + "HANDLER h READ i1 = ()", + "HANDLER h READ i1 != (1)", + "HANDLER h READ i1 <> (1)", + "HANDLER h READ i1 FIRST NEXT", + "HANDLER h READ FIRST OFFSET 2", + "HANDLER h READ FIRST LIMIT 2, 5 OFFSET 1", + "HANDLER h READ FIRST WHERE", + "HANDLER h READ FIRST LIMIT 5 WHERE a > 1", + "HANDLER h CLOSE h", + "HANDLER h OPEN AS x CLOSE", + // MySQL parses HANDLER READ with subqueries disallowed + "HANDLER h READ FIRST WHERE a IN (SELECT b FROM s)", + "HANDLER h READ FIRST WHERE a = (SELECT 1)", + "HANDLER h READ FIRST WHERE EXISTS (SELECT 1)", + "HANDLER h READ FIRST WHERE a IN (TABLE s)", + "HANDLER h READ FIRST WHERE f((SELECT 1)) > 0", + "HANDLER h READ i1 = ((SELECT 1))", + "HANDLER h READ FIRST LIMIT (SELECT 1)"}) + void rejectsFormsMySqlRejects(String sql) { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @ParameterizedTest + @ValueSource(strings = {"HANDLER t OPEN", "HANDLER h READ FIRST", "HANDLER h CLOSE"}) + void otherDialectsKeepRejectingHandler(String sql) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.MARIADB, Dialect.ORACLE, + Dialect.SQLSERVER)) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + sql + " " + dialect); + } + } + + @Test + void wordsRemainUsableAsNames() throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertSqlCanBeParsedAndDeparsed("SELECT handler, prev FROM handler", true, dialect); + assertSqlCanBeParsedAndDeparsed("SELECT handler.a FROM db.handler AS handler", true, + dialect); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t handler", true, dialect); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE handler (handler INT)", true, dialect); + assertSqlCanBeParsedAndDeparsed("HANDLER handler OPEN AS handler", true, dialect); + } + CreateAccessMethod accessMethod = (CreateAccessMethod) assertSqlCanBeParsedAndDeparsed( + "CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler", true, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals("heap_tableam_handler", accessMethod.getHandler()); + } + + @Test + void endsTheStatementsAroundIt() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "HANDLER t OPEN AS h; HANDLER h READ FIRST; HANDLER h CLOSE; SELECT 1", MYSQL); + assertEquals(List.of("HandlerStatement", "HandlerStatement", "HandlerStatement", + "PlainSelect"), names(statements)); + + Statements unsupported = CCJSqlParserUtil.parseStatements( + "FOO; HANDLER t OPEN; BAR; HANDLER t CLOSE", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(List.of("UnsupportedStatement", "HandlerStatement", "UnsupportedStatement", + "HandlerStatement"), names(unsupported)); + + Statements postgres = CCJSqlParserUtil.parseStatements("HANDLER t OPEN", + parser -> parser.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, postgres.get(0)); + } + + @Test + void findsTheOpenedTableButNotTheHandlerName() throws JSQLParserException { + assertThat(new TablesNamesFinder<>() + .getTables(CCJSqlParserUtil.parse("HANDLER db1.t OPEN AS h"))) + .containsExactly("db1.t"); + // READ and CLOSE name the handler, which may be the alias that OPEN gave the table + assertThat(new TablesNamesFinder<>() + .getTables(CCJSqlParserUtil.parse("HANDLER h READ i1 = (1) WHERE a > 1"))) + .isEmpty(); + assertThat(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse("HANDLER h CLOSE"))) + .isEmpty(); + } + + @Test + void reportsReadsAndSessionChanges() throws JSQLParserException { + assertThat(CCJSqlParserUtil.parse("HANDLER h READ FIRST").getFeatures().getCertain()) + .containsExactlyInAnyOrder(StmtFeature.READS_DATA, + StmtFeature.RETURNS_RESULT_SET); + for (String sql : new String[] {"HANDLER t OPEN", "HANDLER h CLOSE"}) { + assertThat(CCJSqlParserUtil.parse(sql).getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + } + } + + @Test + void nodesSpanTheStatementAndItsParts() throws JSQLParserException { + String sql = "HANDLER db1.t OPEN AS h"; + HandlerStatement open = parse(sql); + assertEquals(sql, text(sql, open)); + assertEquals("db1.t", text(sql, open.getTable())); + + sql = "HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3"; + HandlerStatement read = parse(sql); + assertEquals(sql, text(sql, read)); + assertEquals("h", text(sql, read.getTable())); + assertEquals("(1, 2)", text(sql, read.getKeyValues())); + assertEquals("a > 0", text(sql, read.getWhere())); + assertEquals("LIMIT 3", text(sql, read.getLimit())); + } + + @Test + void buildsStatementsInCode() { + Table table = new Table("db", "t"); + table.setAlias(new Alias("h")); + HandlerStatement open = new HandlerStatement(Action.OPEN, table); + assertEquals("HANDLER db.t OPEN AS h", open.toString()); + assertEquals("h", open.getHandlerName()); + assertNull(new HandlerStatement().getHandlerName()); + assertEquals(Action.OPEN, new HandlerStatement().getAction()); + + HandlerStatement read = new HandlerStatement().withAction(Action.READ) + .withTable(new Table("h")).withIndexName("i1") + .withKeyComparison(KeyComparison.EQUALS) + .withKeyValues(new ParenthesedExpressionList<>(new LongValue(1))) + .withWhere(new GreaterThan(new Column("a"), new LongValue(0))) + .withLimit(new Limit().withRowCount(new LongValue(5))) + .withOffset(new Offset().withOffset(new LongValue(2))); + assertEquals("HANDLER h READ i1 = (1) WHERE a > 0 LIMIT 5 OFFSET 2", read.toString()); + assertEquals(read.toString(), deparse(read)); + + read.withKeyComparison(null).withKeyValues((ExpressionList) null) + .withDirection(Direction.FIRST).withIndexName(null).withWhere(null) + .withLimit(null).withOffset(null); + assertEquals("HANDLER h READ FIRST", read.toString()); + + HandlerStatement close = new HandlerStatement(Action.CLOSE, new Table("h")); + assertEquals("HANDLER h CLOSE", deparse(close)); + assertThrows(NullPointerException.class, () -> close.setAction(null)); + } + + private static HandlerStatement parse(String sql) throws JSQLParserException { + return (HandlerStatement) assertSqlCanBeParsedAndDeparsed(sql, true, MYSQL); + } + + private static List names(Statements statements) { + return statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList()); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + private static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/insert/InsertRenderingTest.java b/src/test/java/net/sf/jsqlparser/statement/insert/InsertRenderingTest.java new file mode 100644 index 0000000000..10dd5e3eb8 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/insert/InsertRenderingTest.java @@ -0,0 +1,205 @@ +/*- + * #%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.insert; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +import java.util.Collections; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Partition; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.update.UpdateSet; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.InsertDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +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; + +/** toString() and the deparsers share Insert.appendTo, so both render the same text. */ +class InsertRenderingTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder)); + return builder.toString(); + } + + /** Asserts that toString(), the deparser and a reparse give back exactly {@code sql}. */ + private static Statement assertExact(String sql, Consumer consumer) + throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql, consumer); + assertEquals(sql, statement.toString(), "toString()"); + assertEquals(sql, deparse(statement), "StatementDeParser"); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), consumer).toString(), + "reparse"); + return statement; + } + + /** Renders column names in brackets, to see which parts the deparser visits. */ + private static String deparseWithMarkedColumns(Insert insert) { + StringBuilder builder = new StringBuilder(); + SelectDeParser selects = new SelectDeParser(builder); + ExpressionDeParser expressions = new ExpressionDeParser(selects, builder) { + @Override + public StringBuilder visit(Column column, S context) { + return builder.append('[').append(column.getColumnName()).append(']'); + } + }; + selects.setExpressionVisitor(expressions); + new InsertDeParser(expressions, selects, builder).deParse(insert); + return builder.toString(); + } + + @ParameterizedTest + @ValueSource(strings = { + // MySQL and Hive write PARTITION before the column list + "INSERT INTO t PARTITION (p0) (a) VALUES (1)", + "INSERT INTO t PARTITION (p0, p1) VALUES (1), (2)", + "INSERT IGNORE INTO t PARTITION (p0) (a, b) SELECT a, b FROM s", + "INSERT OVERWRITE TABLE t PARTITION (pt1 = 'pt1', pt2) SELECT * FROM a", + "INSERT INTO TABLE t PARTITION (dt = 1) SELECT * FROM a", + // row aliases + "INSERT INTO t (a, b) VALUES (1, 2) AS new ON DUPLICATE KEY UPDATE b = new.b", + "INSERT INTO t (a, b) VALUES (1, 2) AS new(x, y) ON DUPLICATE KEY UPDATE b = y", + "INSERT INTO t SET a = 1, b = 2 AS new ON DUPLICATE KEY UPDATE b = new.b", + // ON DUPLICATE KEY UPDATE keeps its WHERE in both renderers + "INSERT INTO t (a) VALUES (1) ON DUPLICATE KEY UPDATE a = 2 WHERE a > 1", + "INSERT INTO t (a) VALUES (1) ON DUPLICATE KEY UPDATE NOTHING", + "INSERT LOW_PRIORITY IGNORE INTO t VALUES (1)", + "INSERT INTO t DEFAULT VALUES", + "INSERT INTO t1 OUTPUT inserted.* INTO t2 VALUES (1)", + "INSERT INTO t1 OUTPUT inserted.* DEFAULT VALUES", + "INSERT INTO t AS x (a) OVERRIDING SYSTEM VALUE VALUES (1)" + + " ON CONFLICT ON CONSTRAINT c DO NOTHING RETURNING *", + "INSERT INTO t (a) VALUES (1) ON CONFLICT (a) WHERE a > 0" + + " DO UPDATE SET a = excluded.a WHERE t.a < 5 RETURNING a, b AS c", + "INSERT INTO t BY NAME SELECT * FROM s", + "WITH w AS (SELECT 1 AS a) INSERT INTO t SELECT a FROM w", + "INSERT ALL INTO t1 (a) VALUES (x) INTO t2 VALUES (y) SELECT x, y FROM s", + "INSERT FIRST WHEN x > 1 THEN INTO t1 VALUES (x) ELSE INTO t2 VALUES (y)" + + " SELECT x, y FROM s" + }) + void insertRendersIdentically(String sql) throws JSQLParserException { + assertExact(sql, null); + } + + @ParameterizedTest + @ValueSource(strings = { + "REPLACE INTO t (a, b) VALUES (1, 2)", + "REPLACE t (a) SELECT a FROM s", + "REPLACE INTO t SET a = 1", + "UPSERT INTO t (a) VALUES (1) ON DUPLICATE KEY UPDATE NOTHING", + "UPSERT INTO t (a) VALUES (1) ON DUPLICATE KEY UPDATE a = 2 WHERE a > 1" + }) + void replaceRendersIdentically(String sql) throws JSQLParserException { + assertExact(sql, MYSQL); + } + + @Test + void partitionFollowsTheTable() throws JSQLParserException { + Insert insert = (Insert) assertExact("INSERT INTO t PARTITION (p0) (a) VALUES (1)", MYSQL); + + assertEquals("p0", insert.getPartitions().get(0).getColumn().getColumnName()); + assertEquals("a", insert.getColumns().get(0).getColumnName()); + } + + @Test + void optimizerHintComesBeforeThePriority() throws JSQLParserException { + Insert insert = (Insert) CCJSqlParserUtil + .parse("INSERT /*+ APPEND */ LOW_PRIORITY IGNORE INTO t VALUES (1)"); + + assertEquals("INSERT /*+ APPEND */ LOW_PRIORITY IGNORE INTO t VALUES (1)", + insert.toString()); + assertEquals(insert.toString(), deparse(insert)); + } + + @Test + void deparserVisitsConflictAndDuplicateActions() throws JSQLParserException { + Insert conflict = (Insert) CCJSqlParserUtil.parse("INSERT INTO t (a) VALUES (1)" + + " ON CONFLICT (a) WHERE a > 0 DO UPDATE SET a = excluded.a WHERE t.a < 5" + + " RETURNING a"); + // the conflict target names index columns; its predicate and the action are visited + assertEquals("INSERT INTO t (a) VALUES (1) ON CONFLICT (a) WHERE [a] > 0" + + " DO UPDATE SET [a] = [a] WHERE [a] < 5 RETURNING [a]", + deparseWithMarkedColumns(conflict)); + + Insert duplicate = (Insert) CCJSqlParserUtil.parse( + "INSERT INTO t (a) VALUES (b) ON DUPLICATE KEY UPDATE a = c WHERE d > 1"); + assertEquals("INSERT INTO t (a) VALUES ([b]) ON DUPLICATE KEY UPDATE [a] = [c]" + + " WHERE [d] > 1", deparseWithMarkedColumns(duplicate)); + + Insert set = (Insert) CCJSqlParserUtil.parse("INSERT INTO t SET a = b, (c, d) = (1, e)"); + assertEquals("INSERT INTO t SET [a] = [b], ([c], [d]) = (1, [e])", + deparseWithMarkedColumns(set)); + } + + @Test + void appendToTakesRenderers() throws JSQLParserException { + Insert insert = (Insert) CCJSqlParserUtil.parse( + "WITH w AS (SELECT 1) INSERT INTO t SELECT * FROM w ON DUPLICATE KEY UPDATE a = 1" + + " RETURNING a"); + StringBuilder builder = new StringBuilder(); + + insert.appendTo(builder, item -> builder.append(""), + select -> builder.append(""), expression -> builder.append(""), + item -> builder.append("")); + + assertEquals("WITH INSERT INTO t ON DUPLICATE KEY UPDATE = " + + " RETURNING ", builder.toString()); + } + + @Test + void duplicateUpdateSetsComeFromTheAction() throws JSQLParserException { + Insert insert = (Insert) CCJSqlParserUtil.parse("INSERT INTO t (a) VALUES (1)"); + assertNull(insert.getDuplicateUpdateSets()); + + List sets = + Collections.singletonList(new UpdateSet(new Column("a"), new LongValue(2))); + insert.withDuplicateUpdateSets(sets); + assertSame(sets, insert.getDuplicateUpdateSets()); + assertSame(sets, insert.getDuplicateAction().getUpdateSets()); + assertEquals("INSERT INTO t (a) VALUES (1) ON DUPLICATE KEY UPDATE a = 2", + insert.toString()); + assertEquals(insert.toString(), deparse(insert)); + } + + @Test + void builtInsertRendersPartitionsFirst() { + Insert insert = new Insert().withTable(new Table("t")).addColumns(new Column("a")); + insert.setPartitions(Collections.singletonList(new Partition(new Column("p0"), null))); + insert.setOnlyDefaultValues(true); + + assertEquals("INSERT INTO t PARTITION (p0) (a) DEFAULT VALUES", insert.toString()); + assertEquals(insert.toString(), deparse(insert)); + } + + @Test + void actionsRenderWithoutStraySpaces() { + InsertDuplicateAction nothing = new InsertDuplicateAction(ConflictActionType.NOTHING); + assertEquals("NOTHING", nothing.toString()); + + InsertConflictAction doNothing = new InsertConflictAction(ConflictActionType.DO_NOTHING); + assertEquals(" DO NOTHING", doNothing.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/insert/MySqlInsertSourceTest.java b/src/test/java/net/sf/jsqlparser/statement/insert/MySqlInsertSourceTest.java new file mode 100644 index 0000000000..3ac2a0873b --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/insert/MySqlInsertSourceTest.java @@ -0,0 +1,209 @@ +/*- + * #%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.insert; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +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.Arrays; +import java.util.HashSet; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.TableStatement; +import net.sf.jsqlparser.statement.select.Values; +import net.sf.jsqlparser.statement.upsert.Upsert; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlInsertSourceTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + + /** Parses exactly with and without the MySQL dialect and returns the MySQL result. */ + private static Statement parse(String sql) throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed(sql, false); + return assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + } + + @Test + void valuesRowConstructors() throws JSQLParserException { + Insert insert = (Insert) parse("INSERT INTO t VALUES ROW(1, 2), ROW(3, 4)"); + + assertEquals("t", insert.getTable().getName()); + assertNull(insert.getTable().getAlias()); + assertNull(insert.getColumns()); + Values values = assertInstanceOf(Values.class, insert.getSelect()); + assertEquals(2, values.getExpressions().size()); + Function row = assertInstanceOf(Function.class, values.getExpressions().get(0)); + assertEquals("ROW", row.getName()); + assertEquals(2, row.getParameters().size()); + + // the same model as the query VALUES ROW(1, 2), ROW(3, 4) + Values query = (Values) CCJSqlParserUtil.parse("VALUES ROW(1, 2), ROW(3, 4)", MYSQL); + assertEquals(query.toString(), values.toString()); + } + + @Test + void valuesRowWithColumnsAndDuplicateKeyUpdate() throws JSQLParserException { + Insert insert = (Insert) parse("INSERT INTO t (a, b) VALUES ROW(1, 2), ROW(3, 4)" + + " ON DUPLICATE KEY UPDATE b = 5"); + + assertEquals(2, insert.getColumns().size()); + assertInstanceOf(Values.class, insert.getSelect()); + assertEquals(1, insert.getDuplicateUpdateSets().size()); + } + + @Test + void tableStatementSource() throws JSQLParserException { + Insert insert = (Insert) parse("INSERT INTO t TABLE s"); + + assertNull(insert.getTable().getAlias()); + TableStatement source = assertInstanceOf(TableStatement.class, insert.getSelect()); + assertEquals("s", source.getTable().getName()); + } + + @Test + void tableStatementSourceWithColumnsAndClauses() throws JSQLParserException { + Insert insert = (Insert) parse("INSERT INTO t (a, b) TABLE db.s ORDER BY a LIMIT 2"); + + assertEquals(2, insert.getColumns().size()); + TableStatement source = assertInstanceOf(TableStatement.class, insert.getSelect()); + assertEquals("db.s", source.getTable().getFullyQualifiedName()); + assertNotNull(source.getLimit()); + } + + @Test + void tableStillNamesAnAliasBeforeOtherSources() throws JSQLParserException { + Insert values = (Insert) assertSqlCanBeParsedAndDeparsed("INSERT INTO t table VALUES (1)"); + assertEquals("table", values.getTable().getAlias().getName()); + + Insert columns = + (Insert) assertSqlCanBeParsedAndDeparsed("INSERT INTO t table (a) VALUES (1)"); + assertEquals("table", columns.getTable().getAlias().getName()); + + Insert explicit = + (Insert) assertSqlCanBeParsedAndDeparsed("INSERT INTO t AS table SELECT 1"); + assertEquals("table", explicit.getTable().getAlias().getName()); + } + + @Test + void emptyColumnListAndRow() throws JSQLParserException { + Insert insert = (Insert) parse("INSERT INTO t () VALUES ()"); + + assertNotNull(insert.getColumns()); + assertTrue(insert.getColumns().isEmpty()); + Values values = assertInstanceOf(Values.class, insert.getSelect()); + assertInstanceOf(ParenthesedExpressionList.class, values.getExpressions()); + assertTrue(values.getExpressions().isEmpty()); + + // without a column list the columns stay null + Insert noColumns = (Insert) parse("INSERT INTO t VALUES ()"); + assertNull(noColumns.getColumns()); + } + + @Test + void emptyColumnListWithOtherSources() throws JSQLParserException { + parse("INSERT INTO t () VALUES (), ()"); + parse("INSERT INTO t () TABLE s"); + parse("INSERT IGNORE INTO t PARTITION (p0) () VALUES ()"); + } + + @Test + void replaceSharesTheSources() throws JSQLParserException { + String sql = "REPLACE INTO t () VALUES ()"; + Upsert empty = (Upsert) parse(sql); + assertTrue(empty.getColumns().isEmpty()); + assertInstanceOf(ParenthesedExpressionList.class, empty.getColumns()); + // the list prints its parentheses, so its node spans them + Node node = empty.getColumns().getASTNode(); + assertEquals("()", sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + + Upsert rows = (Upsert) parse("REPLACE INTO t VALUES ROW(1, 2), ROW(3, 4)"); + assertInstanceOf(Values.class, rows.getSelect()); + + Upsert table = (Upsert) parse("REPLACE INTO t (a, b) TABLE s"); + assertInstanceOf(TableStatement.class, table.getSelect()); + } + + @Test + void otherDialectsParseTheSameSources() throws JSQLParserException { + Consumer postgres = parser -> parser.withDialect(Dialect.POSTGRESQL); + Insert table = (Insert) assertSqlCanBeParsedAndDeparsed("INSERT INTO t TABLE s", false, + postgres); + assertInstanceOf(TableStatement.class, table.getSelect()); + + // VALUES before something other than ROW( is still read as before + assertInstanceOf(PlainSelect.class, assertSqlCanBeParsedAndDeparsed( + "SELECT values.a FROM t values WHERE a = 1", false, postgres)); + } + + @ParameterizedTest + @ValueSource(strings = { + "INSERT INTO t (,) VALUES ()", + "INSERT INTO t () VALUES", + "INSERT INTO t TABLE", + "INSERT INTO t VALUES ROW", + "INSERT INTO t VALUES ROW(1, 2) ROW(3, 4)", + // a row constructor list starts with VALUES only + "INSERT INTO t VALUE ROW(1, 2)" + }) + void rejectsIncompleteForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @Test + void statementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "INSERT INTO t TABLE s; INSERT INTO t () VALUES (); " + + "INSERT INTO t VALUES ROW(1, 2); SELECT 1", + MYSQL); + + assertEquals(4, statements.size()); + assertEquals("INSERT INTO t TABLE s", statements.get(0).toString()); + assertEquals("INSERT INTO t VALUES ROW(1, 2)", statements.get(2).toString()); + } + + @Test + void tablesNamesFinderSeesTheSources() throws JSQLParserException { + assertEquals(new HashSet<>(Arrays.asList("t", "s")), + TablesNamesFinder.findTables("INSERT INTO t TABLE s")); + assertEquals(new HashSet<>(Arrays.asList("t", "s")), TablesNamesFinder.findTables( + "INSERT INTO t VALUES ROW((SELECT max(a) FROM s), 2)")); + assertEquals(new HashSet<>(Arrays.asList("t")), + TablesNamesFinder.findTables("INSERT INTO t () VALUES ()")); + } + + @Test + void validatesForMySql() throws JSQLParserException { + for (String sql : new String[] {"INSERT INTO t VALUES ROW(1, 2), ROW(3, 4)", + "INSERT INTO t TABLE s", "INSERT INTO t () VALUES ()"}) { + ValidationTestAsserts.validateNoErrors(sql, 1, MySqlVersion.V8_0); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/insert/PostgreSQLConflictTargetTest.java b/src/test/java/net/sf/jsqlparser/statement/insert/PostgreSQLConflictTargetTest.java index 926f06da1b..189cf81e3a 100644 --- a/src/test/java/net/sf/jsqlparser/statement/insert/PostgreSQLConflictTargetTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/insert/PostgreSQLConflictTargetTest.java @@ -9,6 +9,7 @@ */ package net.sf.jsqlparser.statement.insert; +import net.sf.jsqlparser.statement.create.table.KeyElement; import java.util.ArrayList; import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; import net.sf.jsqlparser.statement.StatementVisitorAdapter; @@ -18,7 +19,6 @@ import net.sf.jsqlparser.expression.Function; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; -import net.sf.jsqlparser.statement.create.table.Index; import net.sf.jsqlparser.test.TestUtils; import net.sf.jsqlparser.util.deparser.ExpressionDeParser; import net.sf.jsqlparser.util.deparser.StatementDeParser; @@ -54,7 +54,7 @@ void preservesFunctionKeyParentheses() throws Exception { Insert insert = (Insert) TestUtils.assertSqlCanBeParsedAndDeparsed( "INSERT INTO users VALUES (1) ON CONFLICT (lower(email), (abs(region))) DO NOTHING", true); - List keys = insert.getConflictTarget().getIndexElements(); + List keys = insert.getConflictTarget().getIndexElements(); assertInstanceOf(Function.class, keys.get(0).getExpression()); assertFalse(keys.get(0).isExpressionParenthesized()); assertTrue(keys.get(1).isExpressionParenthesized()); @@ -82,7 +82,7 @@ void exposesOrderedTypedKeys() throws Exception { + "ON CONFLICT (id, (lower(email)) COLLATE pg_catalog.\"C\" " + "pg_catalog.text_pattern_ops, region) WHERE active DO NOTHING"); InsertConflictTarget target = insert.getConflictTarget(); - List keys = target.getIndexElements(); + List keys = target.getIndexElements(); assertEquals(3, keys.size()); assertEquals("id", keys.get(0).getColumnName()); assertInstanceOf(Function.class, keys.get(1).getExpression()); diff --git a/src/test/java/net/sf/jsqlparser/statement/load/MySqlLoadDataStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/load/MySqlLoadDataStatementTest.java new file mode 100644 index 0000000000..b8f2df58f0 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/load/MySqlLoadDataStatementTest.java @@ -0,0 +1,454 @@ +/*- + * #%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.load; + +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.UserVariable; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.ExtensionStatement; +import net.sf.jsqlparser.statement.MySqlFileFormat; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.select.FromItemVisitorAdapter; +import net.sf.jsqlparser.statement.update.UpdateSet; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlLoadDataStatementTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer MARIADB = + parser -> parser.withDialect(Dialect.MARIADB); + private static final Consumer NO_DIALECT = parser -> { + }; + + @ParameterizedTest + @ValueSource(strings = { + "LOAD DATA INFILE '/tmp/a.csv' INTO TABLE t", + "LOAD DATA LOCAL INFILE 'a.csv' REPLACE INTO TABLE db1.t PARTITION (p0, p1) " + + "CHARACTER SET utf8mb4 FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' " + + "LINES STARTING BY 'x' TERMINATED BY '\\n' IGNORE 1 LINES (a, @b) " + + "SET c = @b + 1, d = DEFAULT", + "LOAD DATA LOW_PRIORITY INFILE 'a' IGNORE INTO TABLE t COLUMNS TERMINATED BY '\\t' " + + "IGNORE 2 ROWS", + "LOAD DATA CONCURRENT INFILE 'a' INTO TABLE t LINES TERMINATED BY '\\r\\n'", + "LOAD DATA CONCURRENT LOCAL INFILE 'a' INTO TABLE t", + "LOAD DATA LOW_PRIORITY LOCAL INFILE 'a' IGNORE INTO TABLE t", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS ENCLOSED BY '\"' ESCAPED BY '\\\\'", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS ESCAPED BY '' LINES STARTING BY ''", + "LOAD DATA INFILE 'a' INTO TABLE t LINES STARTING BY 'x'", + "LOAD DATA INFILE 'a' INTO TABLE t CHARSET latin1", + "LOAD DATA INFILE 'a' INTO TABLE t CHARACTER SET 'utf8mb4'", + "LOAD DATA INFILE 'a' INTO TABLE t CHARACTER SET binary", + "LOAD DATA INFILE 'a' INTO TABLE t ()", + "LOAD DATA INFILE 'a' INTO TABLE db1.t (t.a, db1.t.b, @c, @`d e`)", + "LOAD DATA INFILE 'a' INTO TABLE t SET a = (SELECT MAX(b) FROM u), " + + "c = CURRENT_TIMESTAMP", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 0 LINES", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 2147483647 LINES", + "LOAD DATA INFILE 'a' INTO TABLE t ROWS IDENTIFIED BY ''", + "LOAD XML LOCAL INFILE 'a.xml' INTO TABLE t ROWS IDENTIFIED BY ''", + "LOAD XML INFILE 'a.xml' REPLACE INTO TABLE t CHARACTER SET latin1 " + + "ROWS IDENTIFIED BY '' IGNORE 1 ROWS (a, @x) SET b = @x", + "LOAD XML LOW_PRIORITY INFILE 'a.xml' IGNORE INTO TABLE t PARTITION (p0)", + "LOAD XML INFILE 'a.xml' INTO TABLE t FIELDS TERMINATED BY ',' " + + "LINES TERMINATED BY '\\n'"}) + void parsesMySqlFormsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(MYSQL, MARIADB, NO_DIALECT)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(MySqlLoadDataStatement.class, statement); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void keepsEveryClause() throws JSQLParserException { + MySqlLoadDataStatement load = parse("LOAD DATA LOW_PRIORITY LOCAL INFILE 'a.csv' " + + "REPLACE INTO TABLE db1.t PARTITION (p0, p1) CHARSET 'utf8mb4' " + + "COLUMNS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '^' " + + "LINES STARTING BY 'x' TERMINATED BY ';' IGNORE 3 ROWS (a, @b, t.c) " + + "SET d = @b + 1, e = DEFAULT", MYSQL); + + assertEquals(MySqlLoadDataStatement.Format.DATA, load.getFormat()); + assertEquals(MySqlLoadDataStatement.LockOption.LOW_PRIORITY, load.getLockOption()); + assertTrue(load.isLocal()); + assertEquals("a.csv", load.getFileName().getValue()); + assertEquals(CreateTable.DuplicateHandling.REPLACE, load.getDuplicateHandling()); + assertEquals("db1.t", load.getTable().getFullyQualifiedName()); + assertEquals(Arrays.asList("p0", "p1"), load.getPartitions()); + assertEquals("'utf8mb4'", load.getCharacterSet()); + assertTrue(load.isUseCharsetKeyword()); + assertNull(load.getRowsIdentifiedBy()); + + MySqlFileFormat format = load.getFileFormat(); + assertEquals(MySqlFileFormat.FieldsKeyword.COLUMNS, format.getFieldsKeyword()); + assertEquals(",", format.getFieldsTerminatedBy().getValue()); + assertTrue(format.isFieldsOptionallyEnclosed()); + assertEquals("\"", format.getFieldsEnclosedBy().getValue()); + assertEquals("^", format.getFieldsEscapedBy().getValue()); + assertEquals("x", format.getLinesStartingBy().getValue()); + assertEquals(";", format.getLinesTerminatedBy().getValue()); + + assertEquals(3L, load.getIgnoreCount()); + assertEquals(MySqlLoadDataStatement.IgnoreUnit.ROWS, load.getIgnoreUnit()); + assertEquals(3, load.getColumns().size()); + assertInstanceOf(Column.class, load.getColumns().get(0)); + assertEquals("b", ((UserVariable) load.getColumns().get(1)).getName()); + assertEquals("t.c", ((Column) load.getColumns().get(2)).getFullyQualifiedName()); + assertEquals(2, load.getUpdateSets().size()); + assertEquals("d", load.getUpdateSets().get(0).getColumn(0).getColumnName()); + assertEquals("@b + 1", load.getUpdateSets().get(0).getValue(0).toString()); + assertEquals("DEFAULT", load.getUpdateSets().get(1).getValue(0).toString()); + } + + @Test + void readsLoadXmlAndItsRowTag() throws JSQLParserException { + MySqlLoadDataStatement load = parse( + "LOAD XML CONCURRENT INFILE 'a.xml' IGNORE INTO TABLE t ROWS IDENTIFIED BY ''", + MYSQL); + assertEquals(MySqlLoadDataStatement.Format.XML, load.getFormat()); + assertEquals(MySqlLoadDataStatement.LockOption.CONCURRENT, load.getLockOption()); + assertFalse(load.isLocal()); + assertEquals(CreateTable.DuplicateHandling.IGNORE, load.getDuplicateHandling()); + assertEquals("", load.getRowsIdentifiedBy().getValue()); + assertNull(load.getPartitions()); + assertNull(load.getCharacterSet()); + assertNull(load.getFileFormat()); + assertNull(load.getIgnoreCount()); + assertNull(load.getColumns()); + assertNull(load.getUpdateSets()); + } + + @Test + void keepsAnEmptyColumnListApartFromNone() throws JSQLParserException { + assertTrue(parse("LOAD DATA INFILE 'a' INTO TABLE t ()", MYSQL).getColumns().isEmpty()); + assertNull(parse("LOAD DATA INFILE 'a' INTO TABLE t", MYSQL).getColumns()); + } + + @Test + void acceptsSubclausesInAnyOrderAndKeepsTheLastValue() throws JSQLParserException { + // the server merges repeated subclauses, the last one winning, and keeps OPTIONALLY + assertNormalized( + "LOAD DATA INFILE 'a' INTO TABLE t COLUMNS OPTIONALLY ENCLOSED BY '\"' " + + "TERMINATED BY ','", + "LOAD DATA INFILE 'a' INTO TABLE t COLUMNS TERMINATED BY ',' " + + "OPTIONALLY ENCLOSED BY '\"'"); + assertNormalized( + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS ESCAPED BY '^' TERMINATED BY ',' " + + "TERMINATED BY ';' LINES TERMINATED BY '\\n' STARTING BY '>'", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS TERMINATED BY ';' ESCAPED BY '^' " + + "LINES STARTING BY '>' TERMINATED BY '\\n'"); + assertNormalized( + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS OPTIONALLY ENCLOSED BY '\"' " + + "ENCLOSED BY '|'", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS OPTIONALLY ENCLOSED BY '|'"); + assertNormalized("load data local infile 'a' replace into table t fields terminated by " + + "',' ignore 1 lines (a) set b = 1", + "LOAD DATA LOCAL INFILE 'a' REPLACE INTO TABLE t FIELDS TERMINATED BY ',' " + + "IGNORE 1 LINES (a) SET b = 1"); + assertNormalized("LOAD DATA INFILE 'a' INTO TABLE t IGNORE 007 LINES", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 7 LINES"); + } + + @Test + void readsDoubleQuotedStringsInMySql() throws JSQLParserException { + MySqlLoadDataStatement load = parse( + "LOAD DATA INFILE \"a.csv\" INTO TABLE t FIELDS ENCLOSED BY \"'\"", MYSQL); + assertEquals("a.csv", load.getFileName().getValue()); + assertEquals("'", load.getFileFormat().getFieldsEnclosedBy().getValue()); + } + + @ParameterizedTest + @ValueSource(strings = { + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS", + "LOAD DATA INFILE 'a' INTO TABLE t LINES", + "LOAD DATA INFILE 'a' INTO TABLE t COLUMNS", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS LINES TERMINATED BY '\\n'", + "LOAD DATA INFILE 'a' INTO TABLE t LINES TERMINATED BY '\\n' FIELDS TERMINATED BY ','", + "LOAD DATA INFILE 'a' INTO TABLE t CHARACTER SET utf8mb4 PARTITION (p0)", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS TERMINATED BY ',' ROWS IDENTIFIED BY ''", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 1 LINES FIELDS TERMINATED BY ','", + "LOAD DATA INFILE 'a' INTO TABLE t SET a = 1 (a)", + "LOAD DATA INFILE 'a' INTO t", + "LOAD DATA 'a' INTO TABLE t", + "LOAD DATA LOCAL LOW_PRIORITY INFILE 'a' INTO TABLE t", + "LOAD DATA LOW_PRIORITY CONCURRENT INFILE 'a' INTO TABLE t", + "LOAD DATA INFILE 'a' REPLACE IGNORE INTO TABLE t", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 1", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 2147483648 LINES", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE 99999999999999999999 LINES", + "LOAD DATA INFILE 'a' INTO TABLE t IGNORE -1 LINES", + "LOAD DATA INFILE 'a' INTO TABLE t (a, @@b)", + "LOAD DATA INFILE 'a' INTO TABLE t SET @x = 1", + "LOAD DATA INFILE 'a' INTO TABLE t SET (a, b) = (1, 2)", + "LOAD DATA INFILE a INTO TABLE t", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS TERMINATED ','", + "LOAD DATA INFILE 'a' INTO TABLE t PARTITION ()", + "LOAD XML INFILE 'a' INTO TABLE t ROWS IDENTIFIED ''", + "LOAD DATA INFILE 'a' INTO TABLE t SET a = 1,", + "LOAD DATA INFILE 'a' INTO TABLE t (a,)"}) + void rejectsWhatMySqlRejects(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @ParameterizedTest + @ValueSource(strings = {"LOAD DATA INFILE 'a' INTO TABLE t", + "LOAD XML INFILE 'a.xml' INTO TABLE t", + "LOAD DATA LOCAL INFILE 'a' INTO TABLE t"}) + void otherDialectsKeepRejectingMySqlForms(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.POSTGRESQL, Dialect.ORACLE, + Dialect.SQLSERVER, Dialect.BIGQUERY}) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + dialect.name()); + } + } + + @Test + void otherLoadStatementsKeepTheirReading() throws JSQLParserException { + for (Consumer dialect : List.of(MYSQL, NO_DIALECT)) { + // DuckDB's LOAD of an extension named xml or data stays an extension statement + ExtensionStatement xml = (ExtensionStatement) CCJSqlParserUtil.parse("LOAD xml", + dialect); + assertEquals("xml", xml.getExtensionName()); + assertInstanceOf(ExtensionStatement.class, + CCJSqlParserUtil.parse("LOAD httpfs", dialect)); + assertInstanceOf(LoadDataStatement.class, CCJSqlParserUtil.parse( + "LOAD DATA INTO ds.t FROM FILES (format = 'CSV')", dialect)); + } + ExtensionStatement library = (ExtensionStatement) CCJSqlParserUtil.parse( + "LOAD 'auto_explain'", parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals("'auto_explain'", library.getExtensionName()); + assertInstanceOf(LoadDataStatement.class, + CCJSqlParserUtil.parse("LOAD DATA OVERWRITE ds.t FROM FILES (format = 'CSV') " + + "WITH CONNECTION p.us.c", + parser -> parser.withDialect(Dialect.BIGQUERY))); + } + + @Test + void wordsRemainUsableAsNames() throws JSQLParserException { + // CONCURRENT, XML and CHARSET are names in MySQL too + for (String sql : new String[] {"CREATE TABLE concurrent (xml INT, charset INT)", + "SELECT concurrent, xml, charset FROM t"}) { + assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + } + MySqlLoadDataStatement load = + parse("LOAD DATA INFILE 'a' INTO TABLE concurrent (xml, charset)", MYSQL); + assertEquals("concurrent", load.getTable().getName()); + + // MySQL reserves INFILE, but the parser adds no reserved word + for (String sql : new String[] {"CREATE TABLE infile (a INT)", "SELECT infile FROM t", + "LOAD DATA INFILE 'a' INTO TABLE infile (infile)"}) { + assertSqlCanBeParsedAndDeparsed(sql, false, NO_DIALECT); + } + } + + @Test + void endsTheStatementsAroundIt() throws JSQLParserException { + for (Consumer dialect : List.of(MYSQL, NO_DIALECT)) { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT 1; LOAD DATA INFILE 'a' INTO TABLE t (a) SET b = 1; " + + "LOAD XML INFILE 'b' INTO TABLE u;\nLOAD xml; SELECT 2", + dialect); + assertEquals(List.of("PlainSelect", "MySqlLoadDataStatement", + "MySqlLoadDataStatement", "ExtensionStatement", "PlainSelect"), + statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList())); + } + } + + @Test + void isAStatementStartForUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "FOO BAR; LOAD DATA INFILE 'a' INTO TABLE t; BAZ", + parser -> parser.withDialect(Dialect.MYSQL).withUnsupportedStatements(true)); + assertEquals(3, statements.size()); + assertInstanceOf(UnsupportedStatement.class, statements.get(0)); + assertInstanceOf(MySqlLoadDataStatement.class, statements.get(1)); + assertInstanceOf(UnsupportedStatement.class, statements.get(2)); + } + + @Test + void findsTheTargetAndTheTablesOfSubqueries() throws JSQLParserException { + Statement load = CCJSqlParserUtil.parse("LOAD DATA INFILE 'a' INTO TABLE db1.t (a, @b) " + + "SET c = (SELECT MAX(x) FROM u WHERE u.k = @b)"); + assertThat(new TablesNamesFinder().getTables(load)) + .containsExactlyInAnyOrder("db1.t", "u"); + assertThat(new TablesNamesFinder().getTables( + CCJSqlParserUtil.parse("LOAD XML INFILE 'a' INTO TABLE t"))).containsExactly("t"); + } + + @Test + void reportsDataFeatures() throws JSQLParserException { + Statement plain = CCJSqlParserUtil.parse("LOAD DATA INFILE 'a' INTO TABLE t"); + assertThat(plain.getFeatures().getCertain()).containsExactly(StmtFeature.MODIFIES_DATA); + + Statement subquery = CCJSqlParserUtil.parse( + "LOAD DATA INFILE 'a' INTO TABLE t SET c = (SELECT MAX(x) FROM u)"); + assertThat(subquery.getFeatures().getCertain()) + .contains(StmtFeature.MODIFIES_DATA, StmtFeature.READS_DATA); + } + + @Test + void adapterVisitsTheTableColumnsAndAssignments() throws JSQLParserException { + Statement load = CCJSqlParserUtil.parse( + "LOAD DATA INFILE 'a' INTO TABLE t (a, @b) SET c = @b + 1"); + Object context = new Object(); + List visited = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(Column column, S value) { + visited.add(column.getColumnName()); + return null; + } + + @Override + public Void visit(UserVariable variable, S value) { + visited.add(variable.toString()); + return null; + } + + @Override + public Void visit(LongValue longValue, S value) { + visited.add(longValue.getStringValue()); + return null; + } + }; + FromItemVisitorAdapter tables = new FromItemVisitorAdapter() { + @Override + public Void visit(Table table, S value) { + visited.add("table " + table.getName()); + return null; + } + }; + load.accept(new StatementVisitorAdapter(expressions, null, null, tables, null, null), + context); + assertEquals(List.of("table t", "a", "@b", "c", "@b", "1"), visited); + assertNull(load.accept(new StatementVisitorAdapter<>(), null)); + } + + @Test + void nodesSpanTheStatementAndItsClauses() throws JSQLParserException { + String sql = "LOAD DATA INFILE 'a' INTO TABLE t CHARSET latin1 " + + "FIELDS TERMINATED BY ',' LINES TERMINATED BY ';' IGNORE 1 LINES (a, @b) " + + "SET c = @b"; + MySqlLoadDataStatement load = parse(sql, MYSQL); + assertEquals(sql, text(sql, load)); + assertEquals("'a'", text(sql, load.getFileName())); + assertEquals("t", text(sql, load.getTable())); + assertEquals("FIELDS TERMINATED BY ',' LINES TERMINATED BY ';'", + text(sql, load.getFileFormat())); + assertEquals("','", text(sql, load.getFileFormat().getFieldsTerminatedBy())); + assertEquals("a, @b", text(sql, load.getColumns())); + assertEquals("@b", text(sql, (ASTNodeAccess) load.getUpdateSets().get(0).getValues())); + + String xml = "LOAD XML INFILE 'a' INTO TABLE t LINES STARTING BY '<'"; + MySqlLoadDataStatement lines = parse(xml, MYSQL); + assertEquals("LINES STARTING BY '<'", text(xml, lines.getFileFormat())); + } + + @Test + void buildsStatementsInCode() { + MySqlLoadDataStatement load = new MySqlLoadDataStatement() + .withFileName(new StringValue("data.csv")) + .withTable(new Table("db1", "t")); + assertEquals("LOAD DATA INFILE 'data.csv' INTO TABLE db1.t", load.toString()); + + ExpressionList columns = new ExpressionList<>(); + columns.add(new Column("a")); + columns.add(new UserVariable("b")); + load.withFormat(MySqlLoadDataStatement.Format.XML) + .withLockOption(MySqlLoadDataStatement.LockOption.CONCURRENT) + .withLocal(true) + .withDuplicateHandling(CreateTable.DuplicateHandling.IGNORE) + .withPartitions(Arrays.asList("p0", "p1")) + .withCharacterSet("utf8mb4") + .withUseCharsetKeyword(true) + .withRowsIdentifiedBy(new StringValue("")) + .withFileFormat(new MySqlFileFormat() + .withFieldsTerminatedBy(new StringValue(",")) + .withLinesTerminatedBy(new StringValue("\\n"))) + .withIgnoreCount(1L) + .withIgnoreUnit(MySqlLoadDataStatement.IgnoreUnit.ROWS) + .withColumns(columns) + .withUpdateSets(List.of(new UpdateSet(new Column("c"), new UserVariable("b")))); + String expected = "LOAD XML CONCURRENT LOCAL INFILE 'data.csv' IGNORE INTO TABLE db1.t " + + "PARTITION (p0, p1) CHARSET utf8mb4 ROWS IDENTIFIED BY '' " + + "FIELDS TERMINATED BY ',' LINES TERMINATED BY '\\n' IGNORE 1 ROWS (a, @b) " + + "SET c = @b"; + assertEquals(expected, load.toString()); + assertEquals(expected, deparse(load)); + + load.setFileFormat(new MySqlFileFormat()); + load.setUseCharsetKeyword(false); + assertEquals("LOAD XML CONCURRENT LOCAL INFILE 'data.csv' IGNORE INTO TABLE db1.t " + + "PARTITION (p0, p1) CHARACTER SET utf8mb4 ROWS IDENTIFIED BY '' " + + "IGNORE 1 ROWS (a, @b) SET c = @b", load.toString()); + } + + private static void assertNormalized(String sql, String expected) throws JSQLParserException { + for (Consumer dialect : List.of(MYSQL, NO_DIALECT)) { + Statement statement = CCJSqlParserUtil.parse(sql, dialect); + assertEquals(expected, statement.toString()); + assertEquals(expected, deparse(statement)); + assertEquals(expected, CCJSqlParserUtil.parse(expected, dialect).toString()); + } + } + + private static MySqlLoadDataStatement parse(String sql, Consumer dialect) + throws JSQLParserException { + return (MySqlLoadDataStatement) assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + private static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/lock/MySqlLockTablesTest.java b/src/test/java/net/sf/jsqlparser/statement/lock/MySqlLockTablesTest.java new file mode 100644 index 0000000000..b9e517876f --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/lock/MySqlLockTablesTest.java @@ -0,0 +1,454 @@ +/*- + * #%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.lock; + +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.assertNotNull; +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.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.alter.AlterUser; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlLockTablesTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer MARIADB = + parser -> parser.withDialect(Dialect.MARIADB); + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + private static final Consumer ORACLE = + parser -> parser.withDialect(Dialect.ORACLE); + private static final Consumer NO_DIALECT = parser -> { + }; + + @ParameterizedTest + @ValueSource(strings = { + "LOCK TABLES `t` WRITE", + "LOCK TABLES t READ, s AS x WRITE", + "LOCK TABLES t READ LOCAL", + "LOCK TABLES t AS a READ LOCAL, u LOW_PRIORITY WRITE", + "LOCK TABLES db.t READ, `db`.`u` AS `a` LOW_PRIORITY WRITE", + "LOCK TABLES t a READ, t b WRITE", + "LOCK TABLES nowait WRITE, tables READ", + "LOCK TABLE t READ", + "LOCK TABLE t WRITE", + "UNLOCK TABLES", + "UNLOCK TABLE", + "LOCK INSTANCE FOR BACKUP", + "UNLOCK INSTANCE"}) + void parsesMySqlFormsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void keepsTheLockTypeAndAliasOfEachTable() throws JSQLParserException { + LockStatement lock = + parse("LOCK TABLES t AS a READ LOCAL, db.u LOW_PRIORITY WRITE, v b WRITE", + MYSQL); + + assertTrue(lock.isTablesKeyword()); + assertTrue(lock.isUseTableKeyword()); + assertNull(lock.getLockMode()); + assertFalse(lock.isNoWait()); + assertNull(lock.getWaitSeconds()); + assertEquals(3, lock.getTargets().size()); + + LockStatement.Target first = lock.getTargets().get(0); + assertEquals("t", first.getTable().getName()); + assertEquals("a", first.getTable().getAlias().getName()); + assertTrue(first.getTable().getAlias().isUseAs()); + assertEquals(TableLockType.READ_LOCAL, first.getLockType()); + assertEquals(LockStatement.Scope.DEFAULT, first.getScope()); + assertEquals("t", lock.getTable().getName()); + + LockStatement.Target second = lock.getTargets().get(1); + assertEquals("db.u", second.getTable().getFullyQualifiedName()); + assertNull(second.getTable().getAlias()); + assertEquals(TableLockType.LOW_PRIORITY_WRITE, second.getLockType()); + + LockStatement.Target third = lock.getTargets().get(2); + assertEquals("b", third.getTable().getAlias().getName()); + assertFalse(third.getTable().getAlias().isUseAs()); + assertEquals(TableLockType.WRITE, third.getLockType()); + } + + @Test + void keepsTheSpellingOfTableAndTables() throws JSQLParserException { + LockStatement lock = parse("LOCK TABLE t READ", NO_DIALECT); + assertTrue(lock.isUseTableKeyword()); + assertFalse(lock.isTablesKeyword()); + assertEquals(TableLockType.READ, lock.getTargets().get(0).getLockType()); + + UnlockStatement unlock = (UnlockStatement) CCJSqlParserUtil.parse("UNLOCK TABLE"); + assertFalse(unlock.isTablesKeyword()); + assertTrue(((UnlockStatement) CCJSqlParserUtil.parse("unlock tables")).isTablesKeyword()); + } + + @Test + void parsesBackupLocks() throws JSQLParserException { + BackupLockStatement lock = (BackupLockStatement) CCJSqlParserUtil.parse( + "lock instance for backup", MYSQL); + assertEquals(BackupLockStatement.Action.LOCK, lock.getAction()); + assertEquals("LOCK INSTANCE FOR BACKUP", lock.toString()); + + BackupLockStatement unlock = + (BackupLockStatement) CCJSqlParserUtil.parse("UNLOCK INSTANCE"); + assertEquals(BackupLockStatement.Action.UNLOCK, unlock.getAction()); + } + + @ParameterizedTest + @ValueSource(strings = { + "LOCK TABLES t WRITE CONCURRENT", + "LOCK TABLES t READ, u WRITE CONCURRENT WAIT 10", + "LOCK TABLES t READ NOWAIT", + "LOCK TABLE t AS a WRITE WAIT 5", + "LOCK TABLES t LOW_PRIORITY WRITE", + "UNLOCK TABLES"}) + void parsesMariaDbForms(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, MARIADB); + assertEquals(sql, deparse(statement)); + } + + @Test + void mariaDbWaitReusesTheStatementWait() throws JSQLParserException { + LockStatement lock = parse("LOCK TABLES t READ, u WRITE CONCURRENT WAIT 10", MARIADB); + assertEquals(TableLockType.WRITE_CONCURRENT, lock.getTargets().get(1).getLockType()); + assertEquals(10L, lock.getWaitSeconds()); + + assertTrue(parse("LOCK TABLES t READ NOWAIT", MARIADB).isNoWait()); + } + + @ParameterizedTest + @ValueSource(strings = { + "LOCK TABLES t WRITE CONCURRENT", + "LOCK TABLES t WRITE NOWAIT", + "LOCK TABLES t READ WAIT 5"}) + void rejectsMariaDbOnlyFormsInMySql(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } + + @ParameterizedTest + @ValueSource(strings = {"LOCK INSTANCE FOR BACKUP", "UNLOCK INSTANCE"}) + void rejectsBackupLocksInMariaDb(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MARIADB)); + } + + @ParameterizedTest + @ValueSource(strings = { + "LOCK TABLES t", + "LOCK TABLES t READ,", + "LOCK TABLES t READ, u", + "LOCK TABLES t READ IN SHARE MODE", + "LOCK TABLES t READ LOCAL LOCAL", + "LOCK TABLES t LOW_PRIORITY READ", + "LOCK TABLES t AS READ", + "LOCK TABLES t * WRITE", + "LOCK TABLES only * WRITE", + "UNLOCK", + "UNLOCK TABLES t", + "LOCK INSTANCE FOR", + "UNLOCK INSTANCE FOR BACKUP"}) + void rejectsIncompleteForms(String sql) { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, MARIADB)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "LOCK TABLES t WRITE", + "LOCK TABLE t READ", + "UNLOCK TABLES", + "LOCK INSTANCE FOR BACKUP", + "UNLOCK INSTANCE"}) + void otherDialectsKeepRejectingMySqlForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, ORACLE)); + } + + @ParameterizedTest + @ValueSource(strings = { + "LOCK tables", + "LOCK tables NOWAIT", + "LOCK tables WAIT 5", + "LOCK tables IN SHARE MODE", + "LOCK tables.x IN SHARE MODE", + "LOCK TABLE tables, instance", + "LOCK instance", + "LOCK TABLE t, u IN ACCESS EXCLUSIVE MODE NOWAIT", + "LOCK TABLE ONLY t, u *", + "LOCK TABLE ONLY t IN SHARE MODE", + "LOCK ONLY (t) NOWAIT"}) + void postgreSqlAndOracleReadingsAreUnchanged(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, MARIADB, POSTGRESQL)) { + LockStatement lock = (LockStatement) assertSqlCanBeParsedAndDeparsed(sql, false, + dialect); + assertFalse(lock.isTablesKeyword()); + lock.getTargets().forEach(target -> { + assertNull(target.getLockType()); + assertNull(target.getTable().getAlias()); + }); + } + LockStatement tables = parse("LOCK tables NOWAIT", MYSQL); + assertFalse(tables.isUseTableKeyword()); + assertEquals("tables", tables.getTable().getName()); + assertTrue(tables.isNoWait()); + + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, POSTGRESQL, ORACLE)) { + LockStatement only = (LockStatement) assertSqlCanBeParsedAndDeparsed( + "LOCK TABLE ONLY t IN SHARE MODE", false, dialect); + assertEquals(LockStatement.Scope.ONLY, only.getTargets().get(0).getScope()); + assertEquals("t", only.getTable().getName()); + assertEquals(LockMode.Share, only.getLockMode()); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "LOCK TABLES only WRITE", + "LOCK TABLES only t WRITE", + "LOCK TABLES only AS t READ", + "LOCK TABLES t READ, only WRITE", + "LOCK TABLES only READ LOCAL, only AS o LOW_PRIORITY WRITE", + "LOCK TABLE ONLY t READ", + "LOCK TABLES only.x WRITE", + "LOCK TABLES `only` t WRITE", + "LOCK TABLES t AS only WRITE"}) + void readsOnlyAsATableName(String sql) throws JSQLParserException { + // MySQL has no ONLY keyword in LOCK TABLES, so only is the name of a table + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, MARIADB)) { + LockStatement lock = parse(sql, dialect); + assertEquals(sql, deparse(lock)); + assertEquals(sql, CCJSqlParserUtil.parse(lock.toString(), dialect).toString()); + lock.getTargets().forEach(target -> { + assertEquals(LockStatement.Scope.DEFAULT, target.getScope()); + assertNotNull(target.getLockType()); + }); + } + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, ORACLE)); + } + + @Test + void keepsTheTableNamedOnlyAndItsAlias() throws JSQLParserException { + LockStatement lock = parse("LOCK TABLES only t WRITE, s READ, only AS o READ", MYSQL); + Table first = lock.getTargets().get(0).getTable(); + assertEquals("only", first.getName()); + assertEquals("t", first.getAlias().getName()); + assertFalse(first.getAlias().isUseAs()); + assertEquals("only", lock.getTargets().get(2).getTable().getName()); + assertEquals("o", lock.getTargets().get(2).getTable().getAlias().getName()); + assertThat(new TablesNamesFinder().getTables(lock)) + .containsExactlyInAnyOrder("only", "s"); + + LockStatement keyword = parse("LOCK TABLE ONLY t READ", NO_DIALECT); + assertEquals("ONLY", keyword.getTable().getName()); + assertEquals("t", keyword.getTable().getAlias().getName()); + assertTrue(keyword.isUseTableKeyword()); + assertFalse(keyword.isTablesKeyword()); + + String sql = "LOCK TABLES only t WRITE"; + assertEquals("only", text(sql, parse(sql, MYSQL).getTable())); + } + + @Test + void wordsRemainUsableAsNames() throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, POSTGRESQL)) { + assertSqlCanBeParsedAndDeparsed( + "SELECT unlock, instance, backup, concurrent FROM tables", true, dialect); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t unlock", true, dialect); + assertSqlCanBeParsedAndDeparsed("SELECT unlock.a FROM unlock.unlock AS unlock", true, + dialect); + assertInstanceOf(CreateTable.class, assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE unlock (instance INT, unlock INT)", true, dialect)); + } + AlterUser alter = (AlterUser) assertSqlCanBeParsedAndDeparsed( + "ALTER USER u ACCOUNT UNLOCK", true, MYSQL); + assertEquals("ALTER USER u ACCOUNT UNLOCK", alter.toString()); + } + + @Test + void parsesAMysqldumpScript() throws JSQLParserException { + String script = "--\n-- Table structure for table `t`\n--\n\n" + + "DROP TABLE IF EXISTS `t`;\n" + + "CREATE TABLE `t` (\n" + + " `id` int NOT NULL AUTO_INCREMENT,\n" + + " `name` varchar(20) DEFAULT NULL,\n" + + " PRIMARY KEY (`id`)\n" + + ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;\n\n" + + "--\n-- Dumping data for table `t`\n--\n\n" + + "LOCK TABLES `t` WRITE;\n" + + "/*!40000 ALTER TABLE `t` DISABLE KEYS */;\n" + + "INSERT INTO `t` VALUES (1,'a'),(2,'b');\n" + + "/*!40000 ALTER TABLE `t` ENABLE KEYS */;\n" + + "UNLOCK TABLES;\n"; + // only the MySQL dialect runs the /*!40000 ... */ statements of a server of version 8.4 + assertEquals(List.of("Drop", "CreateTable", "LockStatement", "Alter", "Insert", "Alter", + "UnlockStatement"), dumpStatements(script, MYSQL)); + for (Consumer dialect : List.of(NO_DIALECT, MARIADB)) { + assertEquals(List.of("Drop", "CreateTable", "LockStatement", "Insert", + "UnlockStatement"), dumpStatements(script, dialect)); + } + } + + private static List dumpStatements(String script, Consumer dialect) + throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements(script, + dialect.andThen(parser -> parser.withMySqlServerVersion(80400))); + LockStatement lock = assertInstanceOf(LockStatement.class, statements.get(2)); + assertEquals("LOCK TABLES `t` WRITE", lock.toString()); + assertEquals(TableLockType.WRITE, lock.getTargets().get(0).getLockType()); + assertInstanceOf(UnlockStatement.class, statements.get(statements.size() - 1)); + return statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList()); + } + + @Test + void endsTheStatementsAroundIt() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT 1; LOCK TABLE t READ; UNLOCK TABLES; LOCK INSTANCE FOR BACKUP; UNLOCK INSTANCE"); + assertEquals(List.of("PlainSelect", "LockStatement", "UnlockStatement", + "BackupLockStatement", "BackupLockStatement"), + statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList())); + } + + @Test + void isAStatementStartForUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "FOO BAR; UNLOCK TABLES; BAZ; UNLOCK INSTANCE", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(4, statements.size()); + assertInstanceOf(UnsupportedStatement.class, statements.get(0)); + assertInstanceOf(UnlockStatement.class, statements.get(1)); + assertInstanceOf(UnsupportedStatement.class, statements.get(2)); + assertInstanceOf(BackupLockStatement.class, statements.get(3)); + + Statements postgres = CCJSqlParserUtil.parseStatements("UNLOCK TABLES", + parser -> parser.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, postgres.get(0)); + } + + @Test + void findsTheLockedTablesButNotTheAliases() throws JSQLParserException { + Statement lock = CCJSqlParserUtil.parse("LOCK TABLES t AS a READ, db.u b WRITE, t c READ"); + assertThat(new TablesNamesFinder().getTables(lock)) + .containsExactlyInAnyOrder("t", "db.u"); + assertThat(new TablesNamesFinder().getTables(CCJSqlParserUtil.parse("UNLOCK TABLES"))) + .isEmpty(); + assertThat(new TablesNamesFinder() + .getTables(CCJSqlParserUtil.parse("LOCK INSTANCE FOR BACKUP"))).isEmpty(); + } + + @Test + void reportsTransactionFeatures() throws JSQLParserException { + for (String sql : new String[] {"LOCK TABLES t WRITE", "UNLOCK TABLES", + "LOCK INSTANCE FOR BACKUP", "UNLOCK INSTANCE"}) { + StatementFeatures features = CCJSqlParserUtil.parse(sql).getFeatures(); + assertThat(features.getCertain()).containsExactly(StmtFeature.MODIFIES_TRANSACTION); + } + } + + @Test + void nodesSpanTheStatementAndItsTables() throws JSQLParserException { + String sql = "LOCK TABLES db.t AS a READ LOCAL, u WRITE"; + LockStatement lock = parse(sql, MYSQL); + assertEquals(sql, text(sql, lock)); + assertEquals("db.t", text(sql, lock.getTargets().get(0).getTable())); + assertEquals("u", text(sql, lock.getTargets().get(1).getTable())); + + for (String other : new String[] {"UNLOCK TABLES", "LOCK INSTANCE FOR BACKUP", + "UNLOCK INSTANCE"}) { + assertEquals(other, text(other, (ASTNodeAccess) CCJSqlParserUtil.parse(other))); + } + } + + @Test + void buildsStatementsInCode() { + LockStatement lock = new LockStatement(new Table("t"), null); + lock.setTablesKeyword(true); + lock.getTargets().get(0).setLockType(TableLockType.READ); + Table aliased = new Table("u"); + aliased.setAlias(new Alias("a")); + lock.getTargets().add( + new LockStatement.Target(aliased).withLockType(TableLockType.WRITE_CONCURRENT)); + assertEquals("LOCK TABLES t READ, u AS a WRITE CONCURRENT", lock.toString()); + assertEquals(lock.toString(), deparse(lock)); + + lock.setUseTableKeyword(false); + assertFalse(lock.isTablesKeyword()); + assertEquals("LOCK t READ, u AS a WRITE CONCURRENT", lock.toString()); + lock.setTablesKeyword(true); + assertTrue(lock.isUseTableKeyword()); + + UnlockStatement unlock = new UnlockStatement(); + assertEquals("UNLOCK TABLES", unlock.toString()); + unlock.setTablesKeyword(false); + assertEquals("UNLOCK TABLE", deparse(unlock)); + assertEquals("UNLOCK TABLE", new UnlockStatement(false).toString()); + + BackupLockStatement backup = new BackupLockStatement(); + assertEquals("LOCK INSTANCE FOR BACKUP", deparse(backup)); + backup.setAction(BackupLockStatement.Action.UNLOCK); + assertEquals("UNLOCK INSTANCE", backup.toString()); + assertEquals("UNLOCK INSTANCE", + new BackupLockStatement(BackupLockStatement.Action.UNLOCK).toString()); + assertThrows(NullPointerException.class, () -> backup.setAction(null)); + } + + private static LockStatement parse(String sql, Consumer dialect) + throws JSQLParserException { + return (LockStatement) assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + private static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/maintenance/CheckpointStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/maintenance/CheckpointStatementTest.java new file mode 100644 index 0000000000..bfff0a312d --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/maintenance/CheckpointStatementTest.java @@ -0,0 +1,93 @@ +/*- + * #%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.maintenance; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class CheckpointStatementTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + @Test + void parsesWithPostgreSqlAndWithoutDialect() throws JSQLParserException { + assertInstanceOf(CheckpointStatement.class, + assertSqlCanBeParsedAndDeparsed("CHECKPOINT", true, POSTGRESQL)); + assertInstanceOf(CheckpointStatement.class, + assertSqlCanBeParsedAndDeparsed("checkpoint", true)); + assertDeparse(new CheckpointStatement(), "CHECKPOINT"); + } + + @ParameterizedTest + @ValueSource(strings = {"CHECKPOINT (FLUSH_UNLOGGED)", "CHECKPOINT 10", "CHECKPOINT t"}) + void rejectsArguments(String sql) { + // PostgreSQL 18 accepts no options; CHECKPOINT (...) arrives in a later release + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @Test + void otherProductsVariantsStayUnsupported() throws JSQLParserException { + for (String sql : new String[] {"CHECKPOINT 10", "CHECKPOINT SYNC"}) { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withUnsupportedStatements(true)), sql); + } + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("CHECKPOINT", + parser -> parser.withDialect(Dialect.SQLSERVER))); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SHOW search_path; CHECKPOINT\nCHECKPOINT;CHECKPOINT", POSTGRESQL); + assertEquals(4, statements.size()); + + Statements afterUnsupported = CCJSqlParserUtil.parseStatements( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'; CHECKPOINT", + parser -> parser.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(true)); + assertEquals(2, afterUnsupported.size()); + assertInstanceOf(UnsupportedStatement.class, afterUnsupported.get(0)); + assertInstanceOf(CheckpointStatement.class, afterUnsupported.get(1)); + } + + @Test + void namesNoTableAndModifiesNoData() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("CHECKPOINT", POSTGRESQL); + + assertThat(new TablesNamesFinder<>().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + } + + @Test + void wordRemainsAnIdentifier() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT checkpoint FROM checkpoint AS checkpoint", true, + POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("ALTER SYSTEM CHECKPOINT", true); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/maintenance/ClusterStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/maintenance/ClusterStatementTest.java new file mode 100644 index 0000000000..7e04d45044 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/maintenance/ClusterStatementTest.java @@ -0,0 +1,219 @@ +/*- + * #%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.maintenance; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.UtilityOption; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.maintenance.ClusterStatement.OptionKind; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class ClusterStatementTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static ClusterStatement parse(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, POSTGRESQL); + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, true).toString()); + return (ClusterStatement) statement; + } + + @Test + void tableUsingIndex() throws JSQLParserException { + ClusterStatement cluster = parse("CLUSTER t USING t_pkey"); + + assertEquals("t", cluster.getTable().getFullyQualifiedName()); + assertEquals("t_pkey", cluster.getIndexName()); + assertTrue(cluster.getOptions().isEmpty()); + } + + @Test + void verboseWithoutTable() throws JSQLParserException { + ClusterStatement cluster = parse("CLUSTER VERBOSE"); + + assertNull(cluster.getTable()); + assertFalse(cluster.isParenthesizedOptions()); + assertEquals(OptionKind.VERBOSE, cluster.getOptions().get(0).getKind(OptionKind.class)); + } + + @Test + void otherForms() throws JSQLParserException { + assertNull(parse("CLUSTER").getTable()); + ClusterStatement qualified = parse("CLUSTER VERBOSE s.t"); + assertEquals("s.t", qualified.getTable().getFullyQualifiedName()); + assertNull(qualified.getIndexName()); + + ClusterStatement options = parse("CLUSTER (VERBOSE false) s.t USING i"); + assertTrue(options.isParenthesizedOptions()); + assertEquals(Boolean.FALSE, options.getOptions().get(0).getBooleanValue()); + assertEquals("i", options.getIndexName()); + assertEquals("CLUSTER (VERBOSE)", parse("CLUSTER (VERBOSE)").toString()); + } + + @Test + void indexOnTable() throws JSQLParserException { + ClusterStatement cluster = parse("CLUSTER t_pkey ON t"); + + assertEquals(ClusterStatement.IndexSyntax.ON, cluster.getIndexSyntax()); + assertEquals("t_pkey", cluster.getIndexName()); + assertEquals("t", cluster.getTable().getFullyQualifiedName()); + assertTrue(cluster.getOptions().isEmpty()); + + ClusterStatement verbose = parse("CLUSTER VERBOSE t_pkey ON s.t"); + assertEquals(OptionKind.VERBOSE, verbose.getOptions().get(0).getKind(OptionKind.class)); + assertEquals("s.t", verbose.getTable().getFullyQualifiedName()); + assertEquals(ClusterStatement.IndexSyntax.USING, + parse("CLUSTER t USING t_pkey").getIndexSyntax()); + } + + @Test + void acceptsEveryOptionOfTheGrammar() throws JSQLParserException { + ClusterStatement cluster = parse("CLUSTER (FULL, VERBOSE maybe) t"); + + assertNull(cluster.getOptions().get(0).getKind(OptionKind.class)); + assertEquals(OptionKind.VERBOSE, cluster.getOptions().get(1).getKind(OptionKind.class)); + assertNull(cluster.getOptions().get(1).getBooleanValue()); + } + + @ParameterizedTest + @ValueSource(strings = {"CLUSTER VERBOSE (t)", "CLUSTER ONLY t", "CLUSTER t *", + "CLUSTER t USING", "CLUSTER USING i", "CLUSTER t, s", "CLUSTER t (a)", + "CLUSTER (VERBOSE) idx ON t", "CLUSTER s.idx ON t", "CLUSTER idx ON", + "CLUSTER idx ON t USING i", "CLUSTER t USING s.i"}) + void rejectsFormsOutsidePostgreSqlGrammar(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @Test + void otherDialectsDoNotParseCluster() throws JSQLParserException { + for (String sql : List.of("CLUSTER t", "CLUSTER idx ON t")) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL)), sql); + } + Statement legacy = CCJSqlParserUtil.parse("CLUSTER idx ON t", + parser -> parser.withUnsupportedStatements(true)); + assertInstanceOf(ClusterStatement.class, legacy); + Statement other = CCJSqlParserUtil.parse("CLUSTER idx FOO t", + parser -> parser.withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, other); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SHOW search_path; CLUSTER VERBOSE; CLUSTER t USING i\nCLUSTER i ON t\nSELECT 1", + POSTGRESQL); + + assertEquals(5, statements.size()); + assertEquals("CLUSTER VERBOSE", statements.get(1).toString()); + assertEquals("CLUSTER t USING i", statements.get(2).toString()); + assertEquals("CLUSTER i ON t", statements.get(3).toString()); + } + + @Test + void endsAnUnsupportedStatement() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'; CLUSTER t", + parser -> parser.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(true)); + + assertEquals(2, statements.size()); + assertInstanceOf(ClusterStatement.class, statements.get(1)); + } + + @Test + void buildsAndDeparses() { + ClusterStatement cluster = new ClusterStatement().withTable(new Table("t")) + .withIndexName("i").addOptions(new UtilityOption("VERBOSE")); + assertDeparse(cluster, "CLUSTER VERBOSE t USING i"); + + cluster.withParenthesizedOptions(true); + assertDeparse(cluster, "CLUSTER (VERBOSE) t USING i"); + + cluster.withOptions(List.of(UtilityOption.of("VERBOSE", false))); + assertDeparse(cluster, "CLUSTER (VERBOSE FALSE) t USING i"); + + cluster.setTable(null); + assertNull(cluster.getIndexName()); + assertDeparse(cluster, "CLUSTER (VERBOSE FALSE)"); + assertThrows(IllegalStateException.class, () -> cluster.setIndexName("i")); + } + + @Test + void rendersTheOnFormOnlyWhenItCanExpressTheStatement() { + ClusterStatement cluster = new ClusterStatement().withTable(new Table("t")) + .withIndexName("i").withIndexSyntax(ClusterStatement.IndexSyntax.ON); + assertDeparse(cluster, "CLUSTER i ON t"); + + cluster.addOptions(new UtilityOption("VERBOSE")); + assertDeparse(cluster, "CLUSTER VERBOSE i ON t"); + + // the ON form takes no option list, so the USING form carries it + cluster.withParenthesizedOptions(true); + assertDeparse(cluster, "CLUSTER (VERBOSE) t USING i"); + + cluster.withParenthesizedOptions(false).withIndexName(null); + assertDeparse(cluster, "CLUSTER VERBOSE t"); + assertThrows(NullPointerException.class, () -> cluster.setIndexSyntax(null)); + } + + @Test + void findsTheTableButNotTheIndex() throws JSQLParserException { + assertThat(new TablesNamesFinder<>().getTables( + CCJSqlParserUtil.parse("CLUSTER s.t USING i", POSTGRESQL))) + .containsExactly("s.t"); + assertThat(new TablesNamesFinder<>().getTables( + CCJSqlParserUtil.parse("CLUSTER i ON s.t", POSTGRESQL))) + .containsExactly("s.t"); + assertThat(new TablesNamesFinder<>().getTables( + CCJSqlParserUtil.parse("CLUSTER", POSTGRESQL))).isEmpty(); + } + + @Test + void reportsStatementFeatures() throws JSQLParserException { + assertThat(CCJSqlParserUtil.parse("CLUSTER t").getFeatures().getCertain()) + .containsExactlyInAnyOrder(StmtFeature.MODIFIES_SCHEMA, StmtFeature.READS_DATA); + } + + @Test + void wordRemainsAnIdentifier() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT cluster FROM cluster.cluster AS cluster", true, + POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("CLUSTER cluster USING cluster", true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("CLUSTER cluster ON cluster", true, POSTGRESQL); + assertInstanceOf(Alter.class, assertSqlCanBeParsedAndDeparsed( + "ALTER TABLE t CLUSTER ON ix", true, POSTGRESQL)); + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t SET WITHOUT CLUSTER", true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE ds.t (id INT64) CLUSTER BY id", true); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/maintenance/MaintenanceNodeTest.java b/src/test/java/net/sf/jsqlparser/statement/maintenance/MaintenanceNodeTest.java new file mode 100644 index 0000000000..1e76de82e3 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/maintenance/MaintenanceNodeTest.java @@ -0,0 +1,110 @@ +/*- + * #%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.maintenance; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.analyze.Analyze; +import org.junit.jupiter.api.Test; + +/** The maintenance statements, their options and their targets map back to their source. */ +class MaintenanceNodeTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static String source(String sql, ASTNodeAccess part) { + Node node = part.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } + + private static Statement parse(String sql) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, POSTGRESQL); + } + + @Test + void vacuumOptionsTargetsAndColumns() throws JSQLParserException { + String sql = "VACUUM (VERBOSE, PARALLEL 2) ONLY s.t (a, b), u *"; + VacuumStatement vacuum = (VacuumStatement) parse(sql); + + assertEquals(sql, source(sql, vacuum)); + assertEquals("VERBOSE", source(sql, vacuum.getOptions().get(0))); + assertEquals("PARALLEL 2", source(sql, vacuum.getOptions().get(1))); + MaintenanceTarget only = vacuum.getTargets().get(0); + assertEquals("ONLY s.t (a, b)", source(sql, only)); + assertEquals("s.t", source(sql, only.getTable())); + assertEquals("b", source(sql, only.getColumns().get(1))); + assertEquals("u *", source(sql, vacuum.getTargets().get(1))); + + sql = "VACUUM FULL VERBOSE t"; + vacuum = (VacuumStatement) parse(sql); + assertEquals("FULL", source(sql, vacuum.getOptions().get(0))); + assertEquals("VERBOSE", source(sql, vacuum.getOptions().get(1))); + assertEquals("t", source(sql, vacuum.getTargets().get(0))); + } + + @Test + void analyzeOfBothForms() throws JSQLParserException { + String sql = "ANALYZE VERBOSE t (a)"; + Analyze analyze = (Analyze) parse(sql); + + assertEquals(sql, source(sql, analyze)); + assertEquals("VERBOSE", source(sql, analyze.getOptions().get(0))); + assertEquals("t (a)", source(sql, analyze.getTargets().get(0))); + assertEquals("a", source(sql, analyze.getTargets().get(0).getColumns().get(0))); + + sql = "ANALYZE (SKIP_LOCKED false) t"; + analyze = (Analyze) parse(sql); + assertEquals("SKIP_LOCKED false", source(sql, analyze.getOptions().get(0))); + + sql = "ANALYSE (\"verbose\" on) ONLY t"; + analyze = (Analyze) parse(sql); + assertEquals(sql, source(sql, analyze)); + assertEquals("\"verbose\" on", source(sql, analyze.getOptions().get(0))); + assertEquals("ONLY t", source(sql, analyze.getTargets().get(0))); + + sql = "ANALYZE TABLE t1, t2 UPDATE HISTOGRAM ON c WITH 8 BUCKETS MANUAL UPDATE"; + analyze = (Analyze) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.MYSQL)); + assertEquals(sql, source(sql, analyze)); + assertEquals("t2", source(sql, analyze.getTargets().get(1))); + } + + @Test + void clusterAndCheckpoint() throws JSQLParserException { + String sql = "CLUSTER (VERBOSE) s.t USING i"; + ClusterStatement cluster = (ClusterStatement) parse(sql); + + assertEquals(sql, source(sql, cluster)); + assertEquals("VERBOSE", source(sql, cluster.getOptions().get(0))); + assertEquals("s.t", source(sql, cluster.getTable())); + + sql = "CLUSTER VERBOSE"; + cluster = (ClusterStatement) parse(sql); + assertEquals("VERBOSE", source(sql, cluster.getOptions().get(0))); + + sql = "CLUSTER VERBOSE i ON s.t"; + cluster = (ClusterStatement) parse(sql); + assertEquals(sql, source(sql, cluster)); + assertEquals("s.t", source(sql, cluster.getTable())); + + sql = "CHECKPOINT"; + assertEquals(sql, source(sql, (CheckpointStatement) parse(sql))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/maintenance/VacuumStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/maintenance/VacuumStatementTest.java new file mode 100644 index 0000000000..df55084afc --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/maintenance/VacuumStatementTest.java @@ -0,0 +1,339 @@ +/*- + * #%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.maintenance; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.schema.TableReference; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.UtilityOption; +import net.sf.jsqlparser.statement.UtilityOption.ValueType; +import net.sf.jsqlparser.statement.maintenance.VacuumStatement.OptionKind; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class VacuumStatementTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static VacuumStatement parse(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, POSTGRESQL); + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql, true).toString()); + return (VacuumStatement) statement; + } + + private static List names(List options) { + return options.stream().map(UtilityOption::getName).collect(Collectors.toList()); + } + + @Test + void parenthesizedOptions() throws JSQLParserException { + VacuumStatement vacuum = parse("VACUUM (VERBOSE, ANALYZE) t"); + + assertTrue(vacuum.isParenthesizedOptions()); + assertEquals(List.of("VERBOSE", "ANALYZE"), names(vacuum.getOptions())); + assertEquals(OptionKind.ANALYZE, vacuum.getOptions().get(1).getKind(OptionKind.class)); + assertEquals("t", vacuum.getTargets().get(0).getTable().getFullyQualifiedName()); + } + + @Test + void unparenthesizedKeywordsAreOptions() throws JSQLParserException { + VacuumStatement vacuum = parse("VACUUM FULL t"); + + assertFalse(vacuum.isParenthesizedOptions()); + assertEquals(List.of("FULL"), names(vacuum.getOptions())); + assertFalse(vacuum.getOptions().get(0).hasValue()); + + VacuumStatement all = parse("VACUUM FULL FREEZE VERBOSE ANALYZE t (a, b), s.u"); + assertEquals(List.of(OptionKind.FULL, OptionKind.FREEZE, OptionKind.VERBOSE, + OptionKind.ANALYZE), + all.getOptions().stream().map(o -> o.getKind(OptionKind.class)) + .collect(Collectors.toList())); + assertEquals(2, all.getTargets().size()); + assertEquals("s.u", all.getTargets().get(1).getTable().getFullyQualifiedName()); + } + + @Test + void typedOptionValuesAndColumns() throws JSQLParserException { + VacuumStatement vacuum = parse("VACUUM (PARALLEL 2, INDEX_CLEANUP OFF) t (a)"); + + UtilityOption parallel = vacuum.getOptions().get(0); + assertEquals(OptionKind.PARALLEL, parallel.getKind(OptionKind.class)); + assertEquals(ValueType.NUMBER, parallel.getValueType()); + assertEquals(2L, parallel.getLongValue()); + + UtilityOption cleanup = vacuum.getOptions().get(1); + assertEquals(ValueType.BOOLEAN, cleanup.getValueType()); + assertEquals(Boolean.FALSE, cleanup.getBooleanValue()); + + MaintenanceTarget target = vacuum.getTargets().get(0); + assertEquals(List.of("a"), target.getColumns().stream() + .map(Column::getColumnName).collect(Collectors.toList())); + assertFalse(target.isPlainTable()); + } + + @Test + void everyDocumentedOption() throws JSQLParserException { + VacuumStatement vacuum = parse("VACUUM (FULL, FREEZE true, VERBOSE on, ANALYZE 1, " + + "DISABLE_PAGE_SKIPPING false, SKIP_LOCKED off, INDEX_CLEANUP AUTO, " + + "PROCESS_MAIN 0, PROCESS_TOAST TRUE, TRUNCATE FALSE, PARALLEL 0, " + + "SKIP_DATABASE_STATS, ONLY_DATABASE_STATS 'on', BUFFER_USAGE_LIMIT '256kB')"); + + assertTrue(vacuum.getTargets().isEmpty()); + assertEquals(OptionKind.values().length, vacuum.getOptions().size()); + for (int i = 0; i < OptionKind.values().length; i++) { + assertEquals(OptionKind.values()[i], + vacuum.getOptions().get(i).getKind(OptionKind.class)); + } + UtilityOption cleanup = vacuum.getOptions().get(6); + assertEquals(ValueType.WORD, cleanup.getValueType()); + assertNull(cleanup.getBooleanValue()); + assertEquals(Boolean.TRUE, vacuum.getOptions().get(12).getBooleanValue()); + UtilityOption limit = vacuum.getOptions().get(13); + assertEquals(ValueType.STRING, limit.getValueType()); + assertEquals("'256kB'", limit.getValue()); + assertEquals("256kB", limit.getStringValue()); + } + + @Test + void bareVacuumAndLowerCaseKeywords() throws JSQLParserException { + VacuumStatement bare = parse("VACUUM"); + assertTrue(bare.getOptions().isEmpty()); + assertTrue(bare.getTargets().isEmpty()); + + VacuumStatement lower = (VacuumStatement) CCJSqlParserUtil.parse("vacuum freeze analyse t", + POSTGRESQL); + assertEquals("VACUUM freeze analyse t", lower.toString()); + assertEquals(OptionKind.ANALYZE, lower.getOptions().get(1).getKind(OptionKind.class)); + } + + @Test + void onlyAndDescendantTargets() throws JSQLParserException { + VacuumStatement vacuum = parse("VACUUM (ANALYZE) ONLY t (a), u *, ONLY (v)"); + + TableReference only = vacuum.getTargets().get(0).getReference(); + assertTrue(only.isOnly()); + assertTrue(vacuum.getTargets().get(1).getReference().isIncludeDescendants()); + assertTrue(vacuum.getTargets().get(2).getReference().isParenthesized()); + } + + @Test + void signedAndDecimalNumbers() throws JSQLParserException { + VacuumStatement vacuum = parse("VACUUM (PARALLEL +2, BUFFER_USAGE_LIMIT 1.5) t"); + + assertEquals(2L, vacuum.getOptions().get(0).getLongValue()); + assertNull(vacuum.getOptions().get(1).getLongValue()); + assertEquals("1.5", vacuum.getOptions().get(1).getValue()); + } + + @Test + void acceptsEveryOptionOfTheGrammar() throws JSQLParserException { + // PostgreSQL's grammar takes any name and value; the server checks them when it runs + VacuumStatement vacuum = parse("VACUUM (FOO, PARALLEL -1, PARALLEL 1.5, VERBOSE maybe, " + + "INDEX_CLEANUP full, BUFFER_USAGE_LIMIT, PARALLEL) t"); + + UtilityOption foo = vacuum.getOptions().get(0); + assertNull(foo.getKind(OptionKind.class)); + assertFalse(foo.hasValue()); + UtilityOption negative = vacuum.getOptions().get(1); + assertEquals(ValueType.NUMBER, negative.getValueType()); + assertEquals(-1L, negative.getLongValue()); + UtilityOption decimal = vacuum.getOptions().get(2); + assertEquals(ValueType.NUMBER, decimal.getValueType()); + assertNull(decimal.getLongValue()); + UtilityOption maybe = vacuum.getOptions().get(3); + assertEquals(OptionKind.VERBOSE, maybe.getKind(OptionKind.class)); + assertEquals(ValueType.WORD, maybe.getValueType()); + assertNull(maybe.getBooleanValue()); + assertEquals(ValueType.WORD, vacuum.getOptions().get(4).getValueType()); + assertFalse(vacuum.getOptions().get(5).hasValue()); + + // a lone name in parentheses is an option too, as in PostgreSQL + VacuumStatement option = parse("VACUUM (t)"); + assertEquals("t", option.getOptions().get(0).getName()); + assertTrue(option.getTargets().isEmpty()); + } + + @Test + void quotedNamesAndDollarQuotedValues() throws JSQLParserException { + VacuumStatement vacuum = parse( + "VACUUM (\"verbose\", \"VERBOSE\" off, INDEX_CLEANUP \"auto\", " + + "BUFFER_USAGE_LIMIT $$256kB$$) t"); + + // like PostgreSQL, a quoted name matches only in lower case + assertEquals(OptionKind.VERBOSE, vacuum.getOptions().get(0).getKind(OptionKind.class)); + assertNull(vacuum.getOptions().get(1).getKind(OptionKind.class)); + UtilityOption cleanup = vacuum.getOptions().get(2); + assertEquals(ValueType.WORD, cleanup.getValueType()); + assertEquals("auto", cleanup.getStringValue()); + UtilityOption limit = vacuum.getOptions().get(3); + assertEquals(ValueType.STRING, limit.getValueType()); + assertEquals("256kB", limit.getStringValue()); + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("VACUUM ([verbose]) t", POSTGRESQL)); + + // a quoted name or value may spell a word that PostgreSQL reserves + VacuumStatement reserved = parse("VACUUM (\"table\", VERBOSE \"user\", ANALYSE true) t"); + assertNull(reserved.getOptions().get(0).getKind(OptionKind.class)); + assertEquals("user", reserved.getOptions().get(1).getStringValue()); + assertEquals(OptionKind.ANALYZE, reserved.getOptions().get(2).getKind(OptionKind.class)); + } + + @ParameterizedTest + @ValueSource(strings = { + "VACUUM () t", + "VACUUM (VERBOSE,) t", + "VACUUM (VERBOSE, ) t", + "VACUUM (SELECT) t", + "VACUUM (TABLE) t", + "VACUUM (USER) t", + "VACUUM (VERBOSE analyze) t", + "VACUUM (INDEX_CLEANUP default) t", + "VACUUM (VERBOSE 'a' 'b') t", + "VACUUM VERBOSE FULL t", + "VACUUM ANALYZE VERBOSE t", + "VACUUM ANALYZE FULL t", + "VACUUM t USING x", + "VACUUM FULL (VERBOSE) t", + "VACUUM ONLY t *", + "VACUUM t ()", + "VACUUM t (a.b)", + "VACUUM t, ", + "VACUUM t INTO 'f'" + }) + void rejectsFormsOutsidePostgreSqlGrammar(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @Test + void otherDialectsDoNotParseVacuum() { + for (Dialect dialect : List.of(Dialect.MYSQL, Dialect.ORACLE, Dialect.SQLSERVER)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("VACUUM t", + parser -> parser.withDialect(dialect)), dialect.name()); + } + } + + @Test + void otherProductsVariantsStayUnsupportedWithoutDialect() throws JSQLParserException { + for (String sql : List.of("VACUUM INTO 'backup.db'", "VACUUM main INTO 'backup.db'", + "VACUUM t RETAIN 168 HOURS", "VACUUM SORT ONLY t")) { + Statement statement = CCJSqlParserUtil.parse(sql, + parser -> parser.withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, statement, sql); + } + Statement postgres = CCJSqlParserUtil.parse("VACUUM t", + parser -> parser.withUnsupportedStatements(true)); + assertInstanceOf(VacuumStatement.class, postgres); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SHOW search_path; VACUUM t\nCHECKPOINT\nVACUUM; VACUUM (ANALYZE) a, b (c)\nSELECT 1", + POSTGRESQL); + + assertEquals(6, statements.size()); + assertEquals("VACUUM t", statements.get(1).toString()); + assertEquals("CHECKPOINT", statements.get(2).toString()); + assertEquals("VACUUM", statements.get(3).toString()); + assertEquals("VACUUM (ANALYZE) a, b (c)", statements.get(4).toString()); + assertEquals("SELECT 1", statements.get(5).toString()); + } + + @Test + void endsAnUnsupportedStatement() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'; VACUUM FULL t", + parser -> parser.withDialect(Dialect.POSTGRESQL) + .withUnsupportedStatements(true)); + + assertEquals(2, statements.size()); + assertInstanceOf(UnsupportedStatement.class, statements.get(0)); + assertEquals("VACUUM FULL t", statements.get(1).toString()); + } + + @Test + void buildsAndDeparses() { + VacuumStatement vacuum = new VacuumStatement() + .addOptions(new UtilityOption("VERBOSE"), new UtilityOption("FULL")) + .addTargets(new MaintenanceTarget(new Table("t")).addColumns(new Column("a"))); + // the unparenthesized form is rendered in PostgreSQL's keyword order + assertDeparse(vacuum, "VACUUM FULL VERBOSE t (a)"); + + vacuum.addOptions(UtilityOption.of("PARALLEL", 4)); + assertDeparse(vacuum, "VACUUM (VERBOSE, FULL, PARALLEL 4) t (a)"); + + vacuum.setOptions(List.of(new UtilityOption("FULL"))); + vacuum.setParenthesizedOptions(true); + assertDeparse(vacuum, "VACUUM (FULL) t (a)"); + + vacuum.setOptions(List.of(new UtilityOption("FULL"), new UtilityOption("FULL"))); + vacuum.setParenthesizedOptions(false); + assertDeparse(vacuum, "VACUUM (FULL, FULL) t (a)"); + + vacuum.setOptions(null); + vacuum.withTargets(null); + assertDeparse(vacuum, "VACUUM"); + } + + @Test + void findsTablesButNotColumns() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("VACUUM (ANALYZE) a (x, y), ONLY s.b", + POSTGRESQL); + + assertThat(new TablesNamesFinder<>().getTables(statement)) + .containsExactlyInAnyOrder("a", "s.b"); + assertThat(new TablesNamesFinder<>().getTables( + CCJSqlParserUtil.parse("VACUUM", POSTGRESQL))).isEmpty(); + } + + @Test + void reportsStatementFeatures() throws JSQLParserException { + StatementFeatures features = CCJSqlParserUtil.parse("VACUUM FULL t").getFeatures(); + + assertThat(features.getCertain()).containsExactlyInAnyOrder(StmtFeature.MODIFIES_SCHEMA, + StmtFeature.READS_DATA); + } + + @Test + void wordsRemainIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT vacuum, freeze FROM vacuum.freeze AS vacuum", + true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE vacuum (vacuum INT, freeze INT)", true, + POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("VACUUM vacuum (vacuum)", true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("VACUUM FULL cluster, checkpoint", true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("INSERT INTO vacuum (freeze) VALUES (1)", true); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/notify/ListenStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/notify/ListenStatementTest.java new file mode 100644 index 0000000000..37f0b2eda4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/notify/ListenStatementTest.java @@ -0,0 +1,155 @@ +/*- + * #%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.notify; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.notify.ListenStatement.Action; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class ListenStatementTest { + + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "LISTEN ch | LISTEN | ch", + "LISTEN \"Ch 1\" | LISTEN | \"Ch 1\"", + "UNLISTEN ch | UNLISTEN | ch", + "UNLISTEN \"Ch 1\" | UNLISTEN | \"Ch 1\"", + "UNLISTEN * | UNLISTEN | ", + "LISTEN listen | LISTEN | listen", + "LISTEN \"all\" | LISTEN | \"all\"", + "LISTEN transaction | LISTEN | transaction", + "UNLISTEN unlisten | UNLISTEN | unlisten"}) + void parsesWithPostgreSqlAndWithoutDialect(String sql, Action action, String channel) + throws JSQLParserException { + for (ListenStatement listen : new ListenStatement[] { + (ListenStatement) assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL), + (ListenStatement) assertSqlCanBeParsedAndDeparsed(sql, false)}) { + assertEquals(action, listen.getAction()); + assertEquals(channel, listen.getChannel()); + assertEquals(channel == null, listen.isAllChannels()); + } + } + + @Test + void writesTheKeywordsInUpperCase() throws JSQLParserException { + assertEquals("LISTEN ch", CCJSqlParserUtil.parse("listen ch", POSTGRESQL).toString()); + assertEquals("UNLISTEN *", CCJSqlParserUtil.parse("unlisten *", POSTGRESQL).toString()); + } + + @Test + void buildsAndDeparses() { + ListenStatement listen = new ListenStatement(); + assertEquals(Action.LISTEN, listen.getAction()); + assertDeparse(listen.withChannel("ch"), "LISTEN ch"); + assertDeparse(listen.withAction(Action.UNLISTEN), "UNLISTEN ch"); + ListenStatement all = new ListenStatement(Action.UNLISTEN, null); + assertTrue(all.isAllChannels()); + assertDeparse(all, "UNLISTEN *"); + assertFalse(new ListenStatement(Action.LISTEN, "\"Ch\"").isAllChannels()); + assertThrows(NullPointerException.class, () -> listen.setAction(null)); + } + + @ParameterizedTest + @ValueSource(strings = {"LISTEN", "LISTEN *", "LISTEN a.b", "LISTEN 'ch'", "LISTEN a b", + "LISTEN a, b", "UNLISTEN", "UNLISTEN a, b", "UNLISTEN a.b", "UNLISTEN 'ch'", + "UNLISTEN * *", "UNLISTEN ALL", "LISTEN all", "LISTEN freeze", "UNLISTEN binary", + "LISTEN select"}) + void rejectsWhatPostgreSqlRejects(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } + + @Test + void ruleActionsStayLimitedToNotify() { + // PostgreSQL's RuleActionStmt takes NOTIFY but neither LISTEN nor UNLISTEN + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "CREATE RULE r AS ON INSERT TO t DO ALSO LISTEN ch", POSTGRESQL)); + } + + @Test + void otherDialectsKeepTheirReading() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.ORACLE, Dialect.SQLSERVER}) { + for (String sql : new String[] {"LISTEN ch", "UNLISTEN *"}) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)), + dialect + " " + sql); + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(dialect).withUnsupportedStatements(true))); + } + } + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse("LISTEN 'ch'", + parser -> parser.withUnsupportedStatements(true))); + } + + @Test + void wordsRemainIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT listen, unlisten FROM listen AS unlisten", true, + POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("SELECT listen.unlisten FROM unlisten.listen", true, + parser -> parser.withDialect(Dialect.MYSQL)); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE listen (unlisten INT)", true, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("NOTIFY listen, 'x'", true, POSTGRESQL); + } + + @Test + void endsAtStatementBoundaries() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "LISTEN a; UNLISTEN *\nNOTIFY a, 'x'\nUNLISTEN a;SELECT 1;\nLISTEN b", POSTGRESQL); + assertEquals(6, statements.size()); + assertEquals("UNLISTEN *", statements.get(1).toString()); + assertEquals("NOTIFY a, 'x'", statements.get(2).toString()); + assertEquals("UNLISTEN a", statements.get(3).toString()); + assertEquals("LISTEN b", statements.get(5).toString()); + } + + @Test + void reachesVisitorsAndModifiesTheSession() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("UNLISTEN ch", POSTGRESQL); + Action visited = statement.accept(new StatementVisitorAdapter() { + @Override + public Action visit(ListenStatement listen, S context) { + return listen.getAction(); + } + }, null); + assertEquals(Action.UNLISTEN, visited); + assertNull(statement.accept(new StatementVisitorAdapter(), null)); + + assertThat(new TablesNamesFinder<>().getTables(statement)).isEmpty(); + assertThat(statement.getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + assertThat(CCJSqlParserUtil.parse("LISTEN ch").getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/reindex/ReindexTest.java b/src/test/java/net/sf/jsqlparser/statement/reindex/ReindexTest.java new file mode 100644 index 0000000000..9f69722b06 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/reindex/ReindexTest.java @@ -0,0 +1,166 @@ +/*- + * #%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.reindex; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.reindex.Reindex.Option; +import net.sf.jsqlparser.statement.reindex.Reindex.Target; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class ReindexTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static Reindex roundTrip(String sql) throws JSQLParserException { + Reindex reindex = assertInstanceOf(Reindex.class, + assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL)); + assertEquals(sql, CCJSqlParserUtil.parse(reindex.toString(), POSTGRESQL).toString()); + return reindex; + } + + @ParameterizedTest + @ValueSource(strings = { + "REINDEX INDEX CONCURRENTLY idx", + "REINDEX TABLE users", + "REINDEX TABLE CONCURRENTLY app.users", + "REINDEX (VERBOSE) INDEX app.idx", + "REINDEX (VERBOSE false, TABLESPACE fast_space, CONCURRENTLY) SCHEMA app", + "REINDEX (CONCURRENTLY ON, VERBOSE 1) TABLE t", + "REINDEX (TABLESPACE 'pg_default') TABLE t", + "REINDEX SCHEMA CONCURRENTLY app", + "REINDEX DATABASE", + "REINDEX DATABASE CONCURRENTLY mydb", + "REINDEX SYSTEM", + "REINDEX SYSTEM mydb"}) + void parsesReindexStatements(String sql) throws JSQLParserException { + roundTrip(sql); + assertInstanceOf(Reindex.class, CCJSqlParserUtil.parse(sql)); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", POSTGRESQL).size()); + } + + @Test + void keepsTargetNameAndOptions() throws JSQLParserException { + Reindex reindex = + roundTrip("REINDEX (VERBOSE, TABLESPACE fast_space) TABLE CONCURRENTLY app.users"); + + assertEquals(Target.TABLE, reindex.getTarget()); + assertTrue(reindex.isConcurrently()); + assertEquals("app.users", reindex.getName().getFullyQualifiedName()); + assertEquals("app.users", reindex.getTable().getFullyQualifiedName()); + assertEquals(2, reindex.getOptions().size()); + assertEquals(Option.Name.VERBOSE, reindex.getOptions().get(0).getName()); + assertNull(reindex.getOptions().get(0).getValue()); + assertEquals(Option.Name.TABLESPACE, reindex.getOptions().get(1).getName()); + assertEquals("fast_space", reindex.getOptions().get(1).getValue()); + } + + @Test + void namesOnlyTheReindexedObject() throws JSQLParserException { + Reindex index = roundTrip("REINDEX INDEX CONCURRENTLY idx"); + assertEquals(Target.INDEX, index.getTarget()); + assertEquals("idx", index.getName().getFullyQualifiedName()); + assertNull(index.getTable()); + assertTrue(new TablesNamesFinder().getTables((Statement) index).isEmpty()); + + Reindex database = roundTrip("REINDEX DATABASE"); + assertEquals(Target.DATABASE, database.getTarget()); + assertNull(database.getName()); + assertFalse(database.isConcurrently()); + assertTrue(database.getOptions().isEmpty()); + + assertThat(TablesNamesFinder.findTables("REINDEX TABLE app.users")) + .containsExactly("app.users"); + } + + @Test + void buildsAReindexStatement() { + Reindex reindex = new Reindex(Target.SCHEMA, new Table("app")).withConcurrently(true) + .addOptions(new Option(Option.Name.VERBOSE, null)); + + assertDeparse(reindex, "REINDEX (VERBOSE) SCHEMA CONCURRENTLY app"); + } + + @Test + void validationAndFeatures() throws JSQLParserException { + assertTrue(new Validation(List.of(PostgresqlVersion.V10), "REINDEX TABLE t").validate() + .isEmpty()); + assertThat(new Validation(List.of(PostgresqlVersion.V10), + "REINDEX TABLE CONCURRENTLY t").validate()).isNotEmpty(); + assertThat(new Validation(List.of(PostgresqlVersion.V10), + "REINDEX (CONCURRENTLY) TABLE t").validate()).isNotEmpty(); + assertTrue(new Validation(List.of(PostgresqlVersion.V12), + "REINDEX TABLE CONCURRENTLY t").validate().isEmpty()); + assertThat(new Validation(List.of(MySqlVersion.V8_0), "REINDEX TABLE t").validate()) + .isNotEmpty(); + + assertThat(CCJSqlParserUtil.parse("REINDEX TABLE t").getFeatures().getCertain()) + .containsExactlyInAnyOrder(StmtFeature.MODIFIES_SCHEMA, StmtFeature.READS_DATA); + } + + @Test + void startsAStatementAmongUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'; REINDEX TABLE t; REINDEX t", + parser -> parser.withUnsupportedStatements(true)); + + assertEquals(3, statements.size()); + assertInstanceOf(UnsupportedStatement.class, statements.get(0)); + assertInstanceOf(Reindex.class, statements.get(1)); + assertInstanceOf(UnsupportedStatement.class, statements.get(2)); + } + + @Test + void reindexRemainsAnIdentifier() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT reindex FROM reindex", false, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("CREATE TABLE reindex (reindex int)", false, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("ALTER TABLE t ADD COLUMN reindex int", false, POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = { + "REINDEX TABLE", + "REINDEX SCHEMA", + "REINDEX INDEX CONCURRENTLY", + "REINDEX INDEX a, b", + "REINDEX VIEW v", + "REINDEX () TABLE t", + "REINDEX (FORCE) TABLE t", + "REINDEX (TABLESPACE) TABLE t", + "REINDEX SCHEMA app.sub"}) + void rejectsInvalidReindexStatements(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/replication/MySqlReplicationStatementsTest.java b/src/test/java/net/sf/jsqlparser/statement/replication/MySqlReplicationStatementsTest.java new file mode 100644 index 0000000000..b85813d3cd --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/replication/MySqlReplicationStatementsTest.java @@ -0,0 +1,647 @@ +/*- + * #%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.replication; + +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.DoubleValue; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.NullValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.UserVariable; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.PurgeObjectType; +import net.sf.jsqlparser.statement.PurgeStatement; +import net.sf.jsqlparser.statement.ResetStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.statement.replication.ReplicationSourceOption.GtidAssignment; +import net.sf.jsqlparser.statement.replication.ReplicationSourceOption.Kind; +import net.sf.jsqlparser.statement.replication.ReplicationSourceOption.PrimaryKeyCheck; +import net.sf.jsqlparser.statement.replication.ReplicationSourceOption.ValueType; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 MySqlReplicationStatementsTest { + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + private static final Consumer MARIADB = + parser -> parser.withDialect(Dialect.MARIADB); + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + private static final Consumer ORACLE = + parser -> parser.withDialect(Dialect.ORACLE); + private static final Consumer NO_DIALECT = parser -> { + }; + private static final String UUID = "3E11FA47-71CA-11E1-9E33-C80AA9429562"; + + @ParameterizedTest + @ValueSource(strings = { + "RESET BINARY LOGS AND GTIDS", + "RESET BINARY LOGS AND GTIDS TO 1234", + "RESET REPLICA ALL", + "RESET REPLICA FOR CHANNEL 'c1'", + "RESET REPLICA ALL FOR CHANNEL 'c1'", + "RESET REPLICA, BINARY LOGS AND GTIDS TO 5", + "RESET BINARY LOGS AND GTIDS, REPLICA ALL FOR CHANNEL 'c1'", + "PURGE BINARY LOGS TO 'b.000010'", + "PURGE BINARY LOGS BEFORE '2026-01-01 00:00:00'", + "PURGE BINARY LOGS BEFORE NOW() - INTERVAL 3 DAY", + "PURGE BINARY LOGS BEFORE (NOW())", + "PURGE BINARY LOGS BEFORE @cutoff", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h', SOURCE_PORT = 3306", + "CHANGE REPLICATION SOURCE TO SOURCE_AUTO_POSITION = 1, GET_SOURCE_PUBLIC_KEY = 1" + + " FOR CHANNEL 'c1'", + "CHANGE REPLICATION SOURCE TO SOURCE_LOG_FILE = 'b.000001', SOURCE_LOG_POS = 4," + + " IGNORE_SERVER_IDS = (1, 2)", + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = NULL," + + " REQUIRE_TABLE_PRIMARY_KEY_CHECK = OFF," + + " ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = LOCAL", + "CHANGE REPLICATION SOURCE TO SOURCE_BIND = '10.0.0.1', SOURCE_USER = 'repl'," + + " SOURCE_PASSWORD = 'secret', SOURCE_CONNECT_RETRY = 60," + + " SOURCE_RETRY_COUNT = 10, SOURCE_DELAY = 0," + + " SOURCE_HEARTBEAT_PERIOD = 2.5", + "CHANGE REPLICATION SOURCE TO SOURCE_SSL = 1, SOURCE_SSL_CA = 'ca.pem'," + + " SOURCE_SSL_CAPATH = '/certs', SOURCE_SSL_CERT = 'cert.pem'," + + " SOURCE_SSL_CRL = 'crl.pem', SOURCE_SSL_CRLPATH = '/crl'," + + " SOURCE_SSL_KEY = 'key.pem', SOURCE_SSL_CIPHER = 'AES256-SHA'," + + " SOURCE_SSL_VERIFY_SERVER_CERT = 1", + "CHANGE REPLICATION SOURCE TO SOURCE_TLS_VERSION = 'TLSv1.3'," + + " SOURCE_TLS_CIPHERSUITES = NULL, SOURCE_PUBLIC_KEY_PATH = 'key.pub'," + + " NETWORK_NAMESPACE = 'red'", + "CHANGE REPLICATION SOURCE TO SOURCE_COMPRESSION_ALGORITHMS = 'zstd'," + + " SOURCE_ZSTD_COMPRESSION_LEVEL = 3, REQUIRE_ROW_FORMAT = 1," + + " SOURCE_CONNECTION_AUTO_FAILOVER = 1, GTID_ONLY = 0", + "CHANGE REPLICATION SOURCE TO RELAY_LOG_FILE = 'r.000001', RELAY_LOG_POS = 4," + + " IGNORE_SERVER_IDS = ()", + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = 'priv'@'localhost'," + + " REQUIRE_TABLE_PRIMARY_KEY_CHECK = STREAM," + + " ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = '" + UUID + + "' FOR CHANNEL 'c1'", + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = priv," + + " REQUIRE_TABLE_PRIMARY_KEY_CHECK = GENERATE," + + " SOURCE_TLS_CIPHERSUITES = 'TLS_AES_128_GCM_SHA256'", + "change replication source to source_host = 'h'," + + " require_table_primary_key_check = on," + + " assign_gtids_to_anonymous_transactions = off", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1)", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1, d2), REPLICATE_IGNORE_TABLE = (d1.t1)," + + " REPLICATE_WILD_DO_TABLE = ('d%.t%'), REPLICATE_REWRITE_DB = ((a, b))" + + " FOR CHANNEL 'c1'", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = ()", + "CHANGE REPLICATION FILTER REPLICATE_IGNORE_DB = (), REPLICATE_DO_TABLE = ()," + + " REPLICATE_WILD_IGNORE_TABLE = ('db.%')," + + " REPLICATE_REWRITE_DB = ((a, b), (c, d))", + "CHANGE REPLICATION FILTER REPLICATE_IGNORE_TABLE = (d1.t1, `d 2`.`t 2`)," + + " REPLICATE_REWRITE_DB = ()", + "START REPLICA", + "START REPLICA IO_THREAD, SQL_THREAD", + "START REPLICA SQL_THREAD UNTIL SQL_BEFORE_GTIDS = '" + UUID + ":11-56'", + "START REPLICA UNTIL SOURCE_LOG_FILE = 'b.000002', SOURCE_LOG_POS = 4 USER = 'u'" + + " PASSWORD = 'p' FOR CHANNEL 'c1'", + "START REPLICA UNTIL SQL_AFTER_MTS_GAPS", + "START REPLICA UNTIL RELAY_LOG_FILE = 'r.000001', RELAY_LOG_POS = 10", + "START REPLICA SQL_THREAD UNTIL SQL_AFTER_GTIDS = '" + UUID + ":11-56'" + + " FOR CHANNEL 'c1'", + "START REPLICA UNTIL SQL_BEFORE_GTIDS = '" + UUID + ":1-5', SOURCE_LOG_POS = 4", + "START REPLICA IO_THREAD USER = 'u' PASSWORD = 'p'" + + " DEFAULT_AUTH = 'caching_sha2_password'" + + " PLUGIN_DIR = '/usr/lib/mysql/plugin'", + "START REPLICA FOR CHANNEL 'c1'", + "STOP REPLICA", + "STOP REPLICA IO_THREAD", + "STOP REPLICA IO_THREAD, SQL_THREAD", + "STOP REPLICA SQL_THREAD FOR CHANNEL 'c1'", + "STOP REPLICA FOR CHANNEL 'c1'"}) + void parsesMySqlFormsWithAndWithoutDialect(String sql) throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, dialect); + assertEquals(sql.toUpperCase(), deparse(statement).toUpperCase()); + assertEquals(statement.toString(), + CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + } + } + + @Test + void keepsTheSourceOptionsAndTheirValues() throws JSQLParserException { + ChangeReplicationSourceStatement change = parse( + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h', SOURCE_PORT = 3306," + + " SOURCE_HEARTBEAT_PERIOD = 2.5, IGNORE_SERVER_IDS = (1, 2)," + + " PRIVILEGE_CHECKS_USER = 'priv'@'%'," + + " SOURCE_TLS_CIPHERSUITES = NULL," + + " REQUIRE_TABLE_PRIMARY_KEY_CHECK = GENERATE," + + " ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = '" + UUID + "'" + + " FOR CHANNEL 'c1'", + MYSQL); + List options = change.getOptions(); + assertEquals(List.of(Kind.SOURCE_HOST, Kind.SOURCE_PORT, Kind.SOURCE_HEARTBEAT_PERIOD, + Kind.IGNORE_SERVER_IDS, Kind.PRIVILEGE_CHECKS_USER, Kind.SOURCE_TLS_CIPHERSUITES, + Kind.REQUIRE_TABLE_PRIMARY_KEY_CHECK, + Kind.ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS), + options.stream().map(ReplicationOption::getKind).collect(Collectors.toList())); + assertEquals("h", ((StringValue) options.get(0).getValue()).getValue()); + assertEquals(3306L, ((LongValue) options.get(1).getValue()).getValue()); + assertEquals(2.5, ((DoubleValue) options.get(2).getValue()).getValue()); + ParenthesedExpressionList ids = + (ParenthesedExpressionList) options.get(3).getValue(); + assertEquals("(1, 2)", ids.toString()); + + UserAccount account = options.get(4).getAccount(); + assertEquals("priv", account.getUser().getValue()); + assertEquals("%", account.getHost().getValue()); + assertNull(options.get(4).getValue()); + assertEquals("'priv'@'%'", options.get(4).getValueText()); + + assertInstanceOf(NullValue.class, options.get(5).getValue()); + assertNull(options.get(5).getAccount()); + assertEquals(PrimaryKeyCheck.GENERATE, options.get(6).getPrimaryKeyCheck()); + assertEquals(GtidAssignment.UUID, options.get(7).getGtidAssignment()); + assertEquals(UUID, options.get(7).getValueText()); + assertNull(options.get(0).getPrimaryKeyCheck()); + assertNull(options.get(0).getGtidAssignment()); + assertEquals("c1", change.getChannel().getValue()); + + ChangeReplicationSourceStatement keywords = parse( + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = NULL," + + " REQUIRE_TABLE_PRIMARY_KEY_CHECK = on," + + " ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = LOCAL", + MYSQL); + assertInstanceOf(NullValue.class, keywords.getOptions().get(0).getValue()); + assertNull(keywords.getOptions().get(0).getAccount()); + assertInstanceOf(Column.class, keywords.getOptions().get(1).getValue()); + assertEquals(PrimaryKeyCheck.ON, keywords.getOptions().get(1).getPrimaryKeyCheck()); + assertEquals(GtidAssignment.LOCAL, keywords.getOptions().get(2).getGtidAssignment()); + assertNull(keywords.getChannel()); + } + + @Test + void readsUnquotedAccountsOfPrivilegeChecksUser() throws JSQLParserException { + for (String user : new String[] {"priv", "priv@localhost", "'priv'@localhost", + "priv@'localhost'", "`priv`@`localhost`"}) { + ChangeReplicationSourceStatement change = parse( + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = " + user, MYSQL); + UserAccount account = change.getOptions().get(0).getAccount(); + assertEquals("priv", account.getUser().getValue(), user); + assertEquals(user.contains("@") ? "localhost" : null, + account.getHost() == null ? null : account.getHost().getValue()); + } + } + + @Test + void describesTheValueOfEveryOption() { + assertEquals(ValueType.STRING, Kind.SOURCE_HOST.getValueType()); + assertEquals(ValueType.NUMBER, Kind.SOURCE_LOG_POS.getValueType()); + assertEquals(ValueType.ZERO_OR_ONE, Kind.GTID_ONLY.getValueType()); + assertEquals(ValueType.NUMBER_LIST, Kind.IGNORE_SERVER_IDS.getValueType()); + assertEquals(ValueType.ACCOUNT_OR_NULL, Kind.PRIVILEGE_CHECKS_USER.getValueType()); + assertEquals(ValueType.STRING_OR_NULL, Kind.SOURCE_TLS_CIPHERSUITES.getValueType()); + assertTrue(ValueType.ZERO_OR_ONE.accepts(new LongValue(0))); + assertFalse(ValueType.ZERO_OR_ONE.accepts(new LongValue(2))); + assertFalse(ValueType.STRING.accepts(new NullValue())); + assertTrue(ValueType.NONE.accepts(null)); + assertFalse(ValueType.PRIMARY_KEY_CHECK.accepts(new StringValue("ON"))); + assertTrue(ValueType.GTID_ASSIGNMENT.accepts(new Column("off"))); + } + + @Test + void keepsTheFiltersAndTheirLists() throws JSQLParserException { + ChangeReplicationFilterStatement change = parse( + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1, `d 2`)," + + " REPLICATE_IGNORE_TABLE = (d1.t1), REPLICATE_WILD_DO_TABLE = ('d%.t%')," + + " REPLICATE_REWRITE_DB = ((a, b), (c, d)), REPLICATE_IGNORE_DB = ()" + + " FOR CHANNEL 'c1'", + MYSQL); + List filters = change.getFilters(); + assertEquals(5, filters.size()); + assertEquals(ReplicationFilter.Kind.REPLICATE_DO_DB, filters.get(0).getKind()); + assertEquals(List.of("d1", "`d 2`"), filters.get(0).getDatabases()); + assertEquals(filters.get(0).getDatabases(), filters.get(0).getValues()); + assertThat(filters.get(0).getTables()).isEmpty(); + + Table table = filters.get(1).getTables().get(0); + assertEquals("d1", table.getSchemaName()); + assertEquals("t1", table.getName()); + assertEquals(ReplicationFilter.ValueType.TABLES, + filters.get(1).getKind().getValueType()); + + assertEquals("d%.t%", filters.get(2).getPatterns().get(0).getValue()); + ReplicationFilter.DatabaseRewrite rewrite = filters.get(3).getRewrites().get(1); + assertEquals("c", rewrite.getFrom()); + assertEquals("d", rewrite.getTo()); + assertThat(filters.get(4).getValues()).isEmpty(); + assertEquals("REPLICATE_IGNORE_DB = ()", filters.get(4).toString()); + assertEquals("c1", change.getChannel().getValue()); + } + + @Test + void keepsTheThreadsConditionsAndConnectionOptions() throws JSQLParserException { + StartReplicaStatement start = parse("START REPLICA IO_THREAD, SQL_THREAD" + + " UNTIL SOURCE_LOG_FILE = 'b.000002', SOURCE_LOG_POS = 4 USER = 'u'" + + " PASSWORD = 'p' DEFAULT_AUTH = 'a' PLUGIN_DIR = 'd' FOR CHANNEL 'c1'", MYSQL); + assertEquals(List.of(ReplicaThread.IO_THREAD, ReplicaThread.SQL_THREAD), + start.getThreads()); + assertEquals(ReplicaUntilOption.Kind.SOURCE_LOG_FILE, + start.getUntilOptions().get(0).getKind()); + assertEquals("b.000002", start.getUntilOptions().get(0).getValueText()); + assertEquals(4L, ((LongValue) start.getUntilOptions().get(1).getValue()).getValue()); + assertEquals("u", start.getUser().getValue()); + assertEquals("p", start.getPassword().getValue()); + assertEquals("a", start.getDefaultAuth().getValue()); + assertEquals("d", start.getPluginDir().getValue()); + assertEquals("c1", start.getChannel().getValue()); + + StartReplicaStatement gaps = parse("START REPLICA UNTIL SQL_AFTER_MTS_GAPS", MYSQL); + ReplicaUntilOption condition = gaps.getUntilOptions().get(0); + assertEquals(ReplicaUntilOption.Kind.SQL_AFTER_MTS_GAPS, condition.getKind()); + assertNull(condition.getValue()); + assertFalse(condition.getKind().isLogCoordinate()); + assertThat(gaps.getThreads()).isEmpty(); + assertNull(gaps.getUser()); + assertNull(gaps.getChannel()); + + StopReplicaStatement stop = parse("STOP REPLICA SQL_THREAD FOR CHANNEL 'c1'", MYSQL); + assertEquals(List.of(ReplicaThread.SQL_THREAD), stop.getThreads()); + assertEquals("c1", stop.getChannel().getValue()); + assertThat(((StopReplicaStatement) parse("STOP REPLICA", MYSQL)).getThreads()).isEmpty(); + } + + @Test + void keepsTheResetOptions() throws JSQLParserException { + ResetReplicationStatement reset = parse( + "RESET REPLICA ALL FOR CHANNEL 'c1', BINARY LOGS AND GTIDS TO 1234", MYSQL); + assertEquals(2, reset.getOptions().size()); + ResetReplicationStatement.Option replica = reset.getOptions().get(0); + assertEquals(ResetReplicationStatement.Kind.REPLICA, replica.getKind()); + assertTrue(replica.isAll()); + assertEquals("c1", replica.getChannel().getValue()); + assertNull(replica.getBinaryLogIndex()); + ResetReplicationStatement.Option logs = reset.getOptions().get(1); + assertEquals(ResetReplicationStatement.Kind.BINARY_LOGS_AND_GTIDS, logs.getKind()); + assertEquals(1234L, logs.getBinaryLogIndex().getValue()); + assertFalse(logs.isAll()); + assertNull(logs.getChannel()); + + ResetReplicationStatement bare = parse("RESET REPLICA", MYSQL); + assertFalse(bare.getOptions().get(0).isAll()); + } + + @Test + void extendsPurgeWithBinaryLogs() throws JSQLParserException { + PurgeStatement to = parse("PURGE BINARY LOGS TO 'b.000010'", MYSQL); + assertEquals(PurgeObjectType.BINARY_LOGS, to.getPurgeObjectType()); + assertEquals(PurgeStatement.LogBound.TO, to.getLogBound()); + assertEquals("b.000010", ((StringValue) to.getLogExpression()).getValue()); + assertEquals(to.getLogExpression(), to.getObject()); + + PurgeStatement before = + parse("PURGE BINARY LOGS BEFORE NOW() - INTERVAL 3 DAY", NO_DIALECT); + assertEquals(PurgeStatement.LogBound.BEFORE, before.getLogBound()); + assertEquals("NOW() - INTERVAL 3 DAY", before.getLogExpression().toString()); + assertInstanceOf(UserVariable.class, + ((PurgeStatement) parse("PURGE BINARY LOGS BEFORE @cutoff", MYSQL)) + .getLogExpression()); + + for (String sql : new String[] {"PURGE BINARY LOGS TO 'b.000010'", + "PURGE MASTER LOGS BEFORE '2026-01-01 00:00:00'"}) { + PurgeStatement mariaDb = parse(sql, MARIADB); + assertEquals(sql, deparse(mariaDb)); + } + assertEquals(PurgeObjectType.MASTER_LOGS, + ((PurgeStatement) parse("PURGE MASTER LOGS TO 'b.000010'", MARIADB)) + .getPurgeObjectType()); + // MariaDB disallows subqueries in PURGE ... BEFORE as well + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("PURGE MASTER LOGS BEFORE (SELECT NOW())", MARIADB)); + + PurgeStatement table = parse("PURGE TABLE t", ORACLE); + assertNull(table.getLogBound()); + assertNull(table.getLogExpression()); + } + + @ParameterizedTest + @ValueSource(strings = { + "RESET REPLICA ALL ALL", + "RESET BINARY LOGS AND GTIDS TO 1.5", + "RESET BINARY LOGS AND GTIDS FOR CHANNEL 'c1'", + "RESET REPLICA TO 5", + "RESET REPLICA FOR CHANNEL c1", + "RESET REPLICA FOR CHANNEL N'c1'", + "RESET BINARY LOGS", + "RESET REPLICA ALL,", + "PURGE BINARY LOGS", + "PURGE BINARY LOGS TO b", + "PURGE BINARY LOGS AFTER '2026-01-01'", + "PURGE BINARY LOGS BEFORE (SELECT MAX(ts) FROM t)", + "PURGE BINARY LOGS BEFORE (SELECT NOW())", + "PURGE BINARY LOGS BEFORE NOW() + (SELECT 1)", + "PURGE BINARY LOGS BEFORE DATE_SUB(NOW(), INTERVAL (SELECT 1) DAY)", + "PURGE BINARY LOGS BEFORE CASE WHEN EXISTS (SELECT 1) THEN NOW() END", + "PURGE MASTER LOGS TO 'b.000010'", + "CHANGE MASTER TO MASTER_HOST = 'h'", + "CHANGE REPLICATION SOURCE TO MASTER_HOST = 'h'", + "CHANGE REPLICATION SOURCE TO SOURCE_PORT = '3306'", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 3306", + "CHANGE REPLICATION SOURCE TO SOURCE_PORT = -1", + "CHANGE REPLICATION SOURCE TO GTID_ONLY = 2", + "CHANGE REPLICATION SOURCE TO GTID_ONLY = 1.0", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = NULL", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST", + "CHANGE REPLICATION SOURCE TO `SOURCE_HOST` = 'h'", + "CHANGE REPLICATION SOURCE TO REQUIRE_TABLE_PRIMARY_KEY_CHECK = LOCAL", + "CHANGE REPLICATION SOURCE TO ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = ON", + "CHANGE REPLICATION SOURCE TO IGNORE_SERVER_IDS = 1", + "CHANGE REPLICATION SOURCE TO IGNORE_SERVER_IDS = ('1')", + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = CURRENT_USER", + "CHANGE REPLICATION SOURCE TO PRIVILEGE_CHECKS_USER = CURRENT_USER()", + "CHANGE REPLICATION SOURCE TO", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h' FOR CHANNEL c1", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h',", + "CHANGE REPLICATION SOURCE SOURCE_HOST = 'h'", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = d1", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1.t1)", + "CHANGE REPLICATION FILTER REPLICATE_DO_TABLE = (t1)", + "CHANGE REPLICATION FILTER REPLICATE_DO_TABLE = (d1.t1, t2)", + "CHANGE REPLICATION FILTER REPLICATE_WILD_DO_TABLE = (d1.t1)", + "CHANGE REPLICATION FILTER REPLICATE_REWRITE_DB = (a, b)", + "CHANGE REPLICATION FILTER REPLICATE_REWRITE_DB = ((a))", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = ('d1')", + "CHANGE REPLICATION FILTER REPLICATE_SAME_DB = (d1)", + "CHANGE REPLICATION FILTER", + "START REPLICA UNTIL SOURCE_LOG_POS = 4, SQL_AFTER_MTS_GAPS", + "START REPLICA UNTIL SQL_AFTER_MTS_GAPS = 1", + "START REPLICA UNTIL SQL_BEFORE_GTIDS", + "START REPLICA UNTIL SOURCE_HOST = 'h'", + "START REPLICA UNTIL", + "START REPLICA PASSWORD = 'p' USER = 'u'", + "START REPLICA USER = u", + "START REPLICA IO_THREAD,", + "STOP REPLICA UNTIL SQL_AFTER_MTS_GAPS", + "STOP REPLICA USER = 'u'", + "STOP REPLICA IO_THREAD SQL_THREAD", + "START SLAVE", + "STOP SLAVE"}) + void rejectsFormsMySqlRejects(String sql) { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL)) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect), + sql); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "START REPLICA", + "STOP REPLICA", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h'", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1)", + "RESET BINARY LOGS AND GTIDS", + "RESET REPLICA ALL", + "PURGE BINARY LOGS TO 'b.000010'"}) + void otherDialectsKeepRejectingMySqlForms(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, ORACLE)); + if (!sql.startsWith("PURGE")) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MARIADB)); + } + } + + @Test + void keepsTheOtherReadingsOfResetPurgeAndStart() throws JSQLParserException { + // without the MySQL dialect a bare RESET REPLICA stays a RESET of a parameter + for (Consumer dialect : List.of(NO_DIALECT, POSTGRESQL, MARIADB)) { + ResetStatement reset = (ResetStatement) assertSqlCanBeParsedAndDeparsed( + "RESET REPLICA", true, dialect); + assertEquals("REPLICA", reset.getName()); + } + assertInstanceOf(ResetReplicationStatement.class, + CCJSqlParserUtil.parse("RESET REPLICA", MYSQL)); + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, POSTGRESQL)) { + assertInstanceOf(ResetStatement.class, + assertSqlCanBeParsedAndDeparsed("RESET binary", true, dialect)); + assertInstanceOf(ResetStatement.class, + assertSqlCanBeParsedAndDeparsed("RESET ALL", true, dialect)); + assertSqlCanBeParsedAndDeparsed("START TRANSACTION", true, dialect); + } + for (Consumer dialect : List.of(NO_DIALECT, ORACLE)) { + for (String sql : new String[] {"PURGE TABLE t", "PURGE INDEX i", "PURGE RECYCLEBIN", + "PURGE DBA_RECYCLEBIN", "PURGE TABLESPACE ts USER u"}) { + PurgeStatement purge = + (PurgeStatement) assertSqlCanBeParsedAndDeparsed(sql, true, dialect); + assertNull(purge.getLogBound()); + } + } + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("PURGE MASTER LOGS TO 'b.000010'", NO_DIALECT)); + } + + @Test + void wordsRemainUsableAsNames() throws JSQLParserException { + for (Consumer dialect : List.of(NO_DIALECT, MYSQL, POSTGRESQL)) { + assertSqlCanBeParsedAndDeparsed( + "SELECT stop, replica, replication, channel, source, logs FROM stop", true, + dialect); + assertSqlCanBeParsedAndDeparsed("SELECT stop.stop FROM stop.stop AS stop", true, + dialect); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t stop", true, dialect); + assertInstanceOf(CreateTable.class, assertSqlCanBeParsedAndDeparsed( + "CREATE TABLE stop (stop INT, replica INT)", true, dialect)); + } + for (Consumer dialect : List.of(NO_DIALECT, ORACLE)) { + PurgeStatement purge = (PurgeStatement) assertSqlCanBeParsedAndDeparsed( + "PURGE TABLESPACE stop USER stop", true, dialect); + assertEquals("stop", purge.getObject()); + assertEquals("stop", purge.getUserName()); + } + } + + @Test + void endsTheStatementsAroundIt() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "STOP REPLICA; CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h';" + + " CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1);" + + " RESET REPLICA ALL; RESET BINARY LOGS AND GTIDS;" + + " PURGE BINARY LOGS TO 'b.000001'; START REPLICA; SELECT 1", + MYSQL); + assertEquals(List.of("StopReplicaStatement", "ChangeReplicationSourceStatement", + "ChangeReplicationFilterStatement", "ResetReplicationStatement", + "ResetReplicationStatement", "PurgeStatement", "StartReplicaStatement", + "PlainSelect"), names(statements)); + } + + @Test + void isAStatementStartForUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "FOO BAR; STOP REPLICA; BAZ; CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1)", + parser -> parser.withUnsupportedStatements(true)); + assertEquals(List.of("UnsupportedStatement", "StopReplicaStatement", + "UnsupportedStatement", "ChangeReplicationFilterStatement"), names(statements)); + + Statements postgres = CCJSqlParserUtil.parseStatements("STOP REPLICA", + parser -> parser.withDialect(Dialect.POSTGRESQL).withUnsupportedStatements(true)); + assertInstanceOf(UnsupportedStatement.class, postgres.get(0)); + } + + @Test + void findsTheTablesFiltersName() throws JSQLParserException { + Statement filter = CCJSqlParserUtil.parse("CHANGE REPLICATION FILTER" + + " REPLICATE_DO_TABLE = (d1.t1), REPLICATE_IGNORE_TABLE = (d2.t2)," + + " REPLICATE_WILD_DO_TABLE = ('d3.%'), REPLICATE_DO_DB = (d4)"); + assertThat(new TablesNamesFinder<>().getTables(filter)) + .containsExactlyInAnyOrder("d1.t1", "d2.t2"); + for (String sql : new String[] {"PURGE BINARY LOGS TO 'b.000001'", + "PURGE BINARY LOGS BEFORE NOW()", "START REPLICA", + "STOP REPLICA", "RESET REPLICA ALL", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h'"}) { + assertThat(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse(sql))) + .isEmpty(); + } + } + + @Test + void reportsSessionFeatures() throws JSQLParserException { + for (String sql : new String[] {"START REPLICA", "STOP REPLICA", "RESET REPLICA ALL", + "RESET BINARY LOGS AND GTIDS", "PURGE BINARY LOGS TO 'b.000001'", + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h'", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1)"}) { + assertThat(CCJSqlParserUtil.parse(sql).getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SESSION); + } + assertThat(CCJSqlParserUtil.parse("PURGE TABLE t").getFeatures().getCertain()) + .containsExactlyInAnyOrder(StmtFeature.MODIFIES_SCHEMA, + StmtFeature.MODIFIES_DATA); + } + + @Test + void nodesSpanTheStatementsAndTheirParts() throws JSQLParserException { + String sql = "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h', IGNORE_SERVER_IDS = (1, 2)" + + " FOR CHANNEL 'c1'"; + ChangeReplicationSourceStatement change = parse(sql, MYSQL); + assertEquals(sql, text(sql, change)); + assertEquals("'h'", text(sql, (ASTNodeAccess) change.getOptions().get(0).getValue())); + assertEquals("(1, 2)", text(sql, (ASTNodeAccess) change.getOptions().get(1).getValue())); + assertEquals("'c1'", text(sql, change.getChannel())); + + sql = "CHANGE REPLICATION FILTER REPLICATE_DO_TABLE = (d1.t1)"; + ChangeReplicationFilterStatement filter = parse(sql, MYSQL); + assertEquals("d1.t1", text(sql, filter.getFilters().get(0).getTables().get(0))); + + sql = "PURGE BINARY LOGS BEFORE NOW() - INTERVAL 3 DAY"; + PurgeStatement purge = parse(sql, MYSQL); + assertEquals(sql, text(sql, purge)); + assertEquals("NOW() - INTERVAL 3 DAY", text(sql, (ASTNodeAccess) purge.getLogExpression())); + + sql = "RESET REPLICA ALL FOR CHANNEL 'c1', BINARY LOGS AND GTIDS TO 5"; + ResetReplicationStatement reset = parse(sql, MYSQL); + assertEquals(sql, text(sql, reset)); + assertEquals("5", text(sql, reset.getOptions().get(1).getBinaryLogIndex())); + + for (String other : new String[] {"START REPLICA UNTIL SQL_AFTER_MTS_GAPS", + "STOP REPLICA IO_THREAD FOR CHANNEL 'c1'"}) { + assertEquals(other, text(other, (ASTNodeAccess) CCJSqlParserUtil.parse(other))); + } + } + + @Test + void buildsStatementsInCode() { + ChangeReplicationSourceStatement change = new ChangeReplicationSourceStatement(); + change.getOptions().add(new ReplicationSourceOption("SOURCE_HOST", Kind.SOURCE_HOST, + new StringValue("h"))); + change.getOptions().add(new ReplicationSourceOption("PRIVILEGE_CHECKS_USER", + new UserAccount().withUser(new StringValue("u")).withHost(new StringValue("%")))); + change.setChannel(new StringValue("c1")); + assertEquals("CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h'," + + " PRIVILEGE_CHECKS_USER = 'u'@'%' FOR CHANNEL 'c1'", change.toString()); + assertEquals(change.toString(), deparse(change)); + + ReplicationFilter filter = + new ReplicationFilter(ReplicationFilter.Kind.REPLICATE_REWRITE_DB); + filter.getRewrites().add(new ReplicationFilter.DatabaseRewrite("a", "b")); + ChangeReplicationFilterStatement filters = new ChangeReplicationFilterStatement(); + filters.getFilters().add(filter); + assertEquals("CHANGE REPLICATION FILTER REPLICATE_REWRITE_DB = ((a, b))", + deparse(filters)); + + StartReplicaStatement start = new StartReplicaStatement(); + start.getThreads().add(ReplicaThread.SQL_THREAD); + start.getUntilOptions().add(new ReplicaUntilOption("SQL_AFTER_MTS_GAPS", + ReplicaUntilOption.Kind.SQL_AFTER_MTS_GAPS, null)); + start.setUser(new StringValue("u")); + assertEquals("START REPLICA SQL_THREAD UNTIL SQL_AFTER_MTS_GAPS USER = 'u'", + deparse(start)); + + StopReplicaStatement stop = new StopReplicaStatement(); + stop.setChannel(new StringValue("c1")); + assertEquals("STOP REPLICA FOR CHANNEL 'c1'", stop.toString()); + + ResetReplicationStatement reset = new ResetReplicationStatement(); + ResetReplicationStatement.Option logs = + new ResetReplicationStatement.Option( + ResetReplicationStatement.Kind.BINARY_LOGS_AND_GTIDS); + logs.setBinaryLogIndex(new LongValue(7)); + reset.getOptions().add(logs); + assertEquals("RESET BINARY LOGS AND GTIDS TO 7", deparse(reset)); + + Expression before = new StringValue("2026-01-01"); + PurgeStatement purge = new PurgeStatement(PurgeObjectType.BINARY_LOGS, + PurgeStatement.LogBound.BEFORE, before); + assertEquals("PURGE BINARY LOGS BEFORE '2026-01-01'", deparse(purge)); + assertThrows(IllegalArgumentException.class, () -> new PurgeStatement( + PurgeObjectType.TABLE, PurgeStatement.LogBound.TO, before)); + assertThrows(NullPointerException.class, + () -> new PurgeStatement(PurgeObjectType.MASTER_LOGS, null, before)); + } + + @SuppressWarnings("unchecked") + private static T parse(String sql, Consumer dialect) + throws JSQLParserException { + return (T) assertSqlCanBeParsedAndDeparsed(sql, true, dialect); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder), null); + return builder.toString(); + } + + private static List names(Statements statements) { + return statements.stream().map(statement -> statement.getClass().getSimpleName()) + .collect(Collectors.toList()); + } + + private static String text(String sql, ASTNodeAccess access) { + Node node = access.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/resourcegroup/ResourceGroupTest.java b/src/test/java/net/sf/jsqlparser/statement/resourcegroup/ResourceGroupTest.java new file mode 100644 index 0000000000..40918d18a9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/resourcegroup/ResourceGroupTest.java @@ -0,0 +1,604 @@ +/*- + * #%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.resourcegroup; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.Arrays; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.HexValue; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.operators.relational.ExpressionList; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.statement.SetStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.drop.Drop; +import net.sf.jsqlparser.statement.resourcegroup.ResourceGroupDefinition.State; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** MySQL CREATE, ALTER, DROP and SET RESOURCE GROUP. */ +class ResourceGroupTest { + /** Resource groups are read with the MySQL dialect or without one. */ + private static final Dialect[] MYSQL = {Dialect.MYSQL, null}; + private static final Dialect[] OTHERS = + {Dialect.MARIADB, Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER, Dialect.H2}; + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return dialect == null ? CCJSqlParserUtil.parse(sql) + : CCJSqlParserUtil.parse(sql, p -> p.withDialect(dialect)); + } + + private static void assertSpans(String expected, String source, ASTNodeAccess access) { + Node node = access.getASTNode(); + assertNotNull(node, expected); + assertEquals(expected, source.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1)); + } + + /** + * Parses {@code sql}, which must print as {@code expected}, and checks the statement span, the + * deparser, the reparse, the feature analysis and the table finder. + */ + private static T roundTrip(Class type, String sql, String expected, + Dialect dialect, StmtFeature... features) throws Exception { + T statement = assertInstanceOf(type, parse(sql, dialect), sql); + assertEquals(expected, statement.toString()); + assertSpans(sql, sql, (ASTNodeAccess) statement); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + Statement reparsed = parse(expected, dialect); + assertEquals(type, reparsed.getClass()); + assertEquals(expected, reparsed.toString()); + assertEquals(Set.of(features), statement.getFeatures().getCertain()); + assertTrue(statement.getFeatures().getUncertain().isEmpty()); + assertTrue(new TablesNamesFinder<>().getTables(statement).isEmpty()); + return statement; + } + + private static T roundTrip(Class type, String sql, Dialect dialect) + throws Exception { + return roundTrip(type, sql, sql, dialect, features(type)); + } + + /** DROP RESOURCE GROUP is a Drop, which the analysis reports like every other DROP. */ + private static StmtFeature[] features(Class type) { + if (type == SetResourceGroup.class) { + return new StmtFeature[] {StmtFeature.MODIFIES_SESSION}; + } + return type == Drop.class + ? new StmtFeature[] {StmtFeature.MODIFIES_SCHEMA, StmtFeature.MODIFIES_DATA} + : new StmtFeature[] {StmtFeature.MODIFIES_SCHEMA}; + } + + private static void assertRejected(String sql) { + for (Dialect dialect : MYSQL) { + assertThrows(JSQLParserException.class, () -> parse(sql, dialect), sql); + } + } + + // ---- CREATE RESOURCE GROUP ----------------------------------------------------------------- + + @Test + void createKeepsTypeVcpusPriorityAndState() throws Exception { + for (Dialect dialect : MYSQL) { + CreateResourceGroup group = roundTrip(CreateResourceGroup.class, + "CREATE RESOURCE GROUP rg1 TYPE = USER VCPU = 0-3, 5 THREAD_PRIORITY = 10 ENABLE", + dialect); + assertEquals("rg1", group.getName()); + assertEquals(CreateResourceGroup.Type.USER, group.getType()); + assertEquals(OptionAssignment.EQUALS, group.getTypeAssignment()); + assertEquals(List.of(new VcpuRange(0, 3), new VcpuRange(5)), group.getVcpus()); + assertTrue(group.getVcpus().get(0).isRange()); + assertEquals(3, group.getVcpus().get(0).getLast()); + assertFalse(group.getVcpus().get(1).isRange()); + assertNull(group.getVcpus().get(1).getEnd()); + assertEquals(5, group.getVcpus().get(1).getLast()); + assertEquals(OptionAssignment.EQUALS, group.getVcpuAssignment()); + assertEquals(10, group.getThreadPriority()); + assertEquals(OptionAssignment.EQUALS, group.getThreadPriorityAssignment()); + assertEquals(State.ENABLE, group.getState()); + + group = roundTrip(CreateResourceGroup.class, "CREATE RESOURCE GROUP rg2 TYPE = SYSTEM", + dialect); + assertEquals(CreateResourceGroup.Type.SYSTEM, group.getType()); + assertTrue(group.getVcpus().isEmpty()); + assertNull(group.getThreadPriority()); + assertNull(group.getState()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE RESOURCE GROUP rg3 TYPE = USER VCPU = 0 THREAD_PRIORITY = 19", + "CREATE RESOURCE GROUP rg4 TYPE = SYSTEM THREAD_PRIORITY = -20 DISABLE", + "CREATE RESOURCE GROUP rg6 TYPE USER VCPU 1, 3 THREAD_PRIORITY 5", + "CREATE RESOURCE GROUP rg7 TYPE := USER VCPU := 0 THREAD_PRIORITY := 1", + "CREATE RESOURCE GROUP rg11 TYPE = USER VCPU = 3-1", + "CREATE RESOURCE GROUP rg12 TYPE = USER VCPU = 2147483647", + "CREATE RESOURCE GROUP rg13 TYPE = USER THREAD_PRIORITY = 2147483647", + "CREATE RESOURCE GROUP rg14 TYPE = USER THREAD_PRIORITY = -2147483647", + "CREATE RESOURCE GROUP `rg 16` TYPE = USER", + "CREATE RESOURCE GROUP type TYPE = USER", + "CREATE RESOURCE GROUP vcpu TYPE = USER VCPU = 0", + "CREATE RESOURCE GROUP rg17 TYPE = USER DISABLE"}) + void createPrintsAsWritten(String sql) throws Exception { + for (Dialect dialect : MYSQL) { + roundTrip(CreateResourceGroup.class, sql, dialect); + } + } + + @Test + void optionAssignmentsAreKeptPerOption() throws Exception { + CreateResourceGroup group = roundTrip(CreateResourceGroup.class, + "CREATE RESOURCE GROUP rg TYPE USER VCPU := 1 THREAD_PRIORITY = -5", Dialect.MYSQL); + assertEquals(OptionAssignment.NONE, group.getTypeAssignment()); + assertEquals(OptionAssignment.COLON_EQUALS, group.getVcpuAssignment()); + assertEquals(OptionAssignment.EQUALS, group.getThreadPriorityAssignment()); + assertEquals(-5, group.getThreadPriority()); + assertEquals("", OptionAssignment.NONE.getSymbol()); + assertEquals("=", OptionAssignment.EQUALS.getSymbol()); + assertEquals(":=", OptionAssignment.COLON_EQUALS.getSymbol()); + } + + static Stream normalizedForms() { + return Stream.of( + // the commas of the VCPU and thread ID lists are optional + Arguments.of("CREATE RESOURCE GROUP rg5 TYPE = USER VCPU = 0-3,9-10 ENABLE", + "CREATE RESOURCE GROUP rg5 TYPE = USER VCPU = 0-3, 9-10 ENABLE"), + Arguments.of("CREATE RESOURCE GROUP rg8 TYPE = USER VCPU = 0 1 2-3", + "CREATE RESOURCE GROUP rg8 TYPE = USER VCPU = 0, 1, 2-3"), + Arguments.of("CREATE RESOURCE GROUP rg9 TYPE = USER VCPU = 0 - 1", + "CREATE RESOURCE GROUP rg9 TYPE = USER VCPU = 0-1"), + Arguments.of("CREATE RESOURCE GROUP rg10 TYPE = USER THREAD_PRIORITY = - 5", + "CREATE RESOURCE GROUP rg10 TYPE = USER THREAD_PRIORITY = -5"), + Arguments.of("CREATE RESOURCE GROUP rg15 TYPE = USER VCPU = 007", + "CREATE RESOURCE GROUP rg15 TYPE = USER VCPU = 7"), + Arguments.of( + "create resource group rg18 type = user vcpu = 0 thread_priority = 1 enable", + "CREATE RESOURCE GROUP rg18 TYPE = USER VCPU = 0 THREAD_PRIORITY = 1 ENABLE"), + Arguments.of("ALTER RESOURCE GROUP rg1 VCPU = 2,3 THREAD_PRIORITY = 10", + "ALTER RESOURCE GROUP rg1 VCPU = 2, 3 THREAD_PRIORITY = 10"), + Arguments.of("ALTER RESOURCE GROUP rg1 VCPU 0 1", + "ALTER RESOURCE GROUP rg1 VCPU 0, 1"), + Arguments.of("SET RESOURCE GROUP rg1 FOR 14 78 4", + "SET RESOURCE GROUP rg1 FOR 14, 78, 4"), + Arguments.of("set resource group rg1 for 14", "SET RESOURCE GROUP rg1 FOR 14")); + } + + @ParameterizedTest + @MethodSource("normalizedForms") + void optionalCommasAndSpacingAreNormalized(String sql, String expected) throws Exception { + for (Dialect dialect : MYSQL) { + Statement statement = parse(sql, dialect); + roundTrip(statement.getClass(), sql, expected, dialect, + features(statement.getClass())); + } + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE RESOURCE GROUP rg20", "CREATE RESOURCE GROUP rg20 TYPE = OTHER", + "CREATE RESOURCE GROUP rg20 VCPU = 0 TYPE = USER", + "CREATE RESOURCE GROUP rg20 TYPE = USER THREAD_PRIORITY = 1 VCPU = 0", + "CREATE RESOURCE GROUP rg20 TYPE = USER ENABLE THREAD_PRIORITY = 1", + "CREATE RESOURCE GROUP rg20 TYPE = USER ENABLE DISABLE", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 0-", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 0-1-2", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = -1", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 0,", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 0,,1", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 1.5", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 2147483648", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = 1_0", + "CREATE RESOURCE GROUP rg20 TYPE = USER VCPU = (0)", + "CREATE RESOURCE GROUP rg20 TYPE = USER THREAD_PRIORITY = +5", + "CREATE RESOURCE GROUP rg20 TYPE = USER THREAD_PRIORITY = 2147483648", + "CREATE RESOURCE GROUP rg20 TYPE = USER THREAD_PRIORITY = 1.5", + "CREATE RESOURCE GROUP rg20 TYPE = USER THREAD_PRIORITY", + "CREATE RESOURCE GROUP rg20 TYPE = USER FORCE", + "CREATE RESOURCE GROUP rg20 TYPE = = USER", + "CREATE RESOURCE GROUP IF NOT EXISTS rg20 TYPE = USER", + "CREATE RESOURCE GROUP d.rg20 TYPE = USER", "CREATE RESOURCE GROUP 'rg20' TYPE = USER", + "CREATE RESOURCE GROUP force TYPE = USER", "CREATE RESOURCE GROUP"}) + void createRejectsWhatMySqlRejects(String sql) { + assertRejected(sql); + } + + // ---- ALTER RESOURCE GROUP ------------------------------------------------------------------ + + @Test + void alterKeepsOptionsAndForce() throws Exception { + for (Dialect dialect : MYSQL) { + AlterResourceGroup group = roundTrip(AlterResourceGroup.class, + "ALTER RESOURCE GROUP rg1 VCPU = 0-1 THREAD_PRIORITY = 5 DISABLE FORCE", + dialect); + assertEquals("rg1", group.getName()); + assertEquals(List.of(new VcpuRange(0, 1)), group.getVcpus()); + assertEquals(5, group.getThreadPriority()); + assertEquals(State.DISABLE, group.getState()); + assertTrue(group.isForce()); + + group = roundTrip(AlterResourceGroup.class, "ALTER RESOURCE GROUP rg1", dialect); + assertTrue(group.getVcpus().isEmpty()); + assertNull(group.getThreadPriority()); + assertNull(group.getState()); + assertFalse(group.isForce()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER RESOURCE GROUP rg1 DISABLE FORCE", + "ALTER RESOURCE GROUP rg1 ENABLE", "ALTER RESOURCE GROUP rg1 ENABLE FORCE", + "ALTER RESOURCE GROUP rg1 FORCE", "ALTER RESOURCE GROUP rg1 THREAD_PRIORITY -3", + "ALTER RESOURCE GROUP rg1 VCPU := 0 THREAD_PRIORITY := 2 FORCE", + "ALTER RESOURCE GROUP `rg 16` VCPU = 0, 2-3"}) + void alterPrintsAsWritten(String sql) throws Exception { + for (Dialect dialect : MYSQL) { + roundTrip(AlterResourceGroup.class, sql, dialect); + } + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER RESOURCE GROUP rg1 TYPE = USER", + "ALTER RESOURCE GROUP rg1 FORCE DISABLE", + "ALTER RESOURCE GROUP rg1 THREAD_PRIORITY = 5 VCPU = 0", + "ALTER RESOURCE GROUP rg1 DISABLE VCPU = 0", "ALTER RESOURCE GROUP rg1 FORCE FORCE", + "ALTER RESOURCE GROUP rg1, rg2 DISABLE", "ALTER RESOURCE GROUP", + "ALTER RESOURCE GROUP IF EXISTS rg1 DISABLE", "ALTER RESOURCE GROUP force DISABLE", + "ALTER RESOURCE GROUP rg1 VCPU = 2147483648"}) + void alterRejectsWhatMySqlRejects(String sql) { + assertRejected(sql); + } + + // ---- SET RESOURCE GROUP -------------------------------------------------------------------- + + @Test + void setNamesTheGroupAndTheThreads() throws Exception { + for (Dialect dialect : MYSQL) { + String sql = "SET RESOURCE GROUP rg1 FOR 14, 78, 4"; + SetResourceGroup set = roundTrip(SetResourceGroup.class, sql, dialect); + assertEquals("rg1", set.getName()); + assertEquals(3, set.getThreadIds().size()); + assertEquals(78L, assertInstanceOf(LongValue.class, set.getThreadIds().get(1)) + .getValue()); + assertSpans("78", sql, (ASTNodeAccess) set.getThreadIds().get(1)); + assertSpans("14, 78, 4", sql, set.getThreadIds()); + + set = roundTrip(SetResourceGroup.class, "SET RESOURCE GROUP rg1", dialect); + assertNull(set.getThreadIds()); + + sql = "SET RESOURCE GROUP `rg 16` FOR 0x1F, X'1f', 18446744073709551615"; + set = roundTrip(SetResourceGroup.class, sql, dialect); + assertEquals("`rg 16`", set.getName()); + assertEquals("0x1F", assertInstanceOf(HexValue.class, set.getThreadIds().get(0)) + .getValue()); + assertSpans("X'1f'", sql, (ASTNodeAccess) set.getThreadIds().get(1)); + assertEquals("18446744073709551615", + ((LongValue) set.getThreadIds().get(2)).getStringValue()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SET RESOURCE GROUP", "SET RESOURCE GROUP rg1 FOR", + "SET RESOURCE GROUP rg1 FOR -1", "SET RESOURCE GROUP rg1 FOR 1,", + "SET RESOURCE GROUP rg1 FOR 1.5", "SET RESOURCE GROUP rg1 FOR 18446744073709551616", + "SET RESOURCE GROUP rg1 FOR 0X1F", "SET RESOURCE GROUP rg1 FOR X'1'", + "SET RESOURCE GROUP rg1 FOR '14'", "SET RESOURCE GROUP rg1 FOR (14)", + "SET RESOURCE GROUP rg1 FOR @id", "SET RESOURCE GROUP rg1 FOR 1_0", + "SET RESOURCE GROUP rg1, rg2", "SET RESOURCE GROUP = rg1", + "SET RESOURCE GROUP rg1 FORCE", "SET RESOURCE GROUP force", + "SET GLOBAL RESOURCE GROUP rg1"}) + void setRejectsWhatMySqlRejects(String sql) { + assertRejected(sql); + } + + @Test + void otherSetFormsKeepTheirReading() throws Exception { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, null, Dialect.POSTGRESQL}) { + for (String sql : List.of("SET resource = 1", "SET resource.grp = 1", + "SET @resource = 1", "SET autocommit = 0")) { + assertEquals(sql, assertInstanceOf(SetStatement.class, parse(sql, dialect)) + .toString()); + } + } + } + + // ---- DROP RESOURCE GROUP ------------------------------------------------------------------- + + @Test + void dropIsADropOfAResourceGroup() throws Exception { + for (Dialect dialect : MYSQL) { + Drop drop = roundTrip(Drop.class, "DROP RESOURCE GROUP rg1 FORCE", dialect); + assertEquals(Drop.ObjectType.RESOURCE_GROUP, drop.getObjectType()); + assertEquals("RESOURCE GROUP", drop.getType()); + assertEquals("rg1", drop.getName().getName()); + assertEquals(1, drop.getNames().size()); + assertTrue(drop.isForce()); + assertNull(drop.getParameters()); + + drop = roundTrip(Drop.class, "DROP RESOURCE GROUP rg2", dialect); + assertEquals(Drop.ObjectType.RESOURCE_GROUP, drop.getObjectType()); + assertFalse(drop.isForce()); + + drop = roundTrip(Drop.class, "DROP RESOURCE GROUP `rg 16`", dialect); + assertEquals("`rg 16`", drop.getName().getName()); + roundTrip(Drop.class, "drop resource group rg1 force", "DROP RESOURCE GROUP rg1 FORCE", + dialect, features(Drop.class)); + } + assertEquals("DROP RESOURCE GROUP rg1 FORCE", + new Drop().withObjectType(Drop.ObjectType.RESOURCE_GROUP) + .withName(new net.sf.jsqlparser.schema.Table("rg1")).withForce(true) + .toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP RESOURCE GROUP IF EXISTS rg3", "DROP RESOURCE GROUP rg3, rg4", + "DROP RESOURCE GROUP rg3 FORCE FORCE", "DROP RESOURCE GROUP rg3 CASCADE", + "DROP RESOURCE GROUP rg3 RESTRICT", "DROP RESOURCE GROUP d.rg3", + "DROP RESOURCE GROUP 'rg3'", "DROP RESOURCE GROUP rg3 extra", + "DROP RESOURCE GROUP rg3 ON t", "DROP RESOURCE GROUP FORCE", + "DROP TEMPORARY RESOURCE GROUP rg3", "DROP MATERIALIZED RESOURCE GROUP rg3"}) + void dropRejectsWhatMySqlRejects(String sql) { + assertRejected(sql); + } + + @Test + void dropWithoutANameIsRejectedByMySql() throws Exception { + assertThrows(JSQLParserException.class, () -> parse("DROP RESOURCE GROUP", Dialect.MYSQL)); + // without a dialect it keeps dropping an object called GROUP + Drop drop = assertInstanceOf(Drop.class, parse("DROP RESOURCE GROUP", null)); + assertEquals(Drop.ObjectType.OTHER, drop.getObjectType()); + assertEquals("RESOURCE", drop.getType()); + } + + // ---- other dialects ------------------------------------------------------------------------ + + @Test + void otherDialectsKeepTheirReading() throws Exception { + for (Dialect dialect : OTHERS) { + Drop drop = assertInstanceOf(Drop.class, parse("DROP RESOURCE GROUP rg1", dialect)); + assertEquals(Drop.ObjectType.OTHER, drop.getObjectType()); + assertEquals("RESOURCE", drop.getType()); + assertEquals("GROUP", drop.getName().getName()); + assertEquals(List.of("rg1"), drop.getParameters()); + assertThrows(JSQLParserException.class, + () -> parse("DROP RESOURCE GROUP rg1 FORCE", dialect)); + assertThrows(JSQLParserException.class, + () -> parse("SET RESOURCE GROUP rg1", dialect)); + assertThrows(JSQLParserException.class, + () -> parse("SET RESOURCE GROUP rg1 FOR 14", dialect)); + assertInstanceOf(UnsupportedStatement.class, + parse("CREATE RESOURCE GROUP rg1 TYPE = USER", dialect)); + assertInstanceOf(UnsupportedStatement.class, + parse("ALTER RESOURCE GROUP rg1 DISABLE FORCE", dialect)); + } + } + + @Test + void theWordsRemainIdentifiers() throws Exception { + for (Dialect dialect : MYSQL) { + for (String sql : List.of("SELECT resource, vcpu, thread_priority FROM resource", + "CREATE TABLE resource (vcpu INT, thread_priority INT)", + "ALTER TABLE resource ADD COLUMN vcpu INT", "DROP TABLE resource", + "INSERT INTO resource (vcpu) VALUES (1)")) { + assertEquals(sql, parse(sql, dialect).toString()); + } + } + } + + // ---- statement boundaries, visitors and validation ----------------------------------------- + + static Stream statements() { + return Stream.of( + Arguments.of("CREATE RESOURCE GROUP rg1 TYPE = USER VCPU = 0-3, 5 ENABLE", + CreateResourceGroup.class), + Arguments.of("CREATE RESOURCE GROUP rg1 TYPE = SYSTEM", CreateResourceGroup.class), + Arguments.of("ALTER RESOURCE GROUP rg1 THREAD_PRIORITY = 5 DISABLE FORCE", + AlterResourceGroup.class), + Arguments.of("ALTER RESOURCE GROUP rg1", AlterResourceGroup.class), + Arguments.of("SET RESOURCE GROUP rg1 FOR 14, 78", SetResourceGroup.class), + Arguments.of("SET RESOURCE GROUP rg1", SetResourceGroup.class), + Arguments.of("DROP RESOURCE GROUP rg1 FORCE", Drop.class), + Arguments.of("DROP RESOURCE GROUP rg1", Drop.class)); + } + + @ParameterizedTest + @MethodSource("statements") + void statementsEndAtTheStatementBoundary(String sql, Class type) + throws Exception { + // the statement on its own line is closed by the next statement start + String script = "SELECT 1;\nCOMMIT\n" + sql + "\nSELECT 2;" + sql + ";\nSAVEPOINT sp"; + for (Dialect dialect : MYSQL) { + for (boolean opaque : new boolean[] {false, true}) { + Statements statements = CCJSqlParserUtil.parseStatements(script, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + p.withUnsupportedStatements(opaque); + }); + assertEquals(6, statements.size(), script); + assertEquals("COMMIT", statements.get(1).toString()); + assertInstanceOf(type, statements.get(2)); + assertEquals(sql, statements.get(2).toString()); + assertSpans(sql, script, (ASTNodeAccess) statements.get(2)); + assertEquals("SELECT 2", statements.get(3).toString()); + assertEquals(sql, statements.get(4).toString()); + assertEquals("SAVEPOINT sp", statements.get(5).toString()); + } + } + } + + @Test + void forceInstallStartsTheNextStatement() throws Exception { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT 1; ALTER RESOURCE GROUP rg1 DISABLE\nFORCE INSTALL httpfs"); + assertEquals(3, statements.size()); + assertFalse(((AlterResourceGroup) statements.get(1)).isForce()); + } + + @Test + void scriptsKeepEachStatement() throws Exception { + String script = "CREATE RESOURCE GROUP rg1 TYPE = USER VCPU = 0-3 THREAD_PRIORITY = 10;" + + " SET RESOURCE GROUP rg1; INSERT INTO t VALUES (1);" + + " ALTER RESOURCE GROUP rg1 DISABLE FORCE; DROP RESOURCE GROUP rg1 FORCE"; + Statements statements = + CCJSqlParserUtil.parseStatements(script, p -> p.withDialect(Dialect.MYSQL)); + assertEquals(5, statements.size()); + assertEquals(Set.of("t"), new TablesNamesFinder<>().getTables(statements.get(2))); + assertInstanceOf(AlterResourceGroup.class, statements.get(3)); + assertEquals(statements.toString(), CCJSqlParserUtil + .parseStatements(statements.toString(), p -> p.withDialect(Dialect.MYSQL)) + .toString()); + } + + @Test + void visitorDispatchPassesContextAndResult() throws Exception { + StatementVisitorAdapter visitor = new StatementVisitorAdapter<>() { + @Override + public String visit(CreateResourceGroup statement, S context) { + return context + ":create:" + statement.getType(); + } + + @Override + public String visit(AlterResourceGroup statement, S context) { + return context + ":alter:" + statement.getState(); + } + + @Override + public String visit(SetResourceGroup statement, S context) { + return context + ":set:" + statement.getThreadIds(); + } + }; + String create = "CREATE RESOURCE GROUP rg TYPE = SYSTEM"; + String alter = "ALTER RESOURCE GROUP rg ENABLE"; + String set = "SET RESOURCE GROUP rg FOR 1, 2"; + assertEquals("ctx:create:SYSTEM", parse(create, null).accept(visitor, "ctx")); + assertEquals("ctx:alter:ENABLE", parse(alter, null).accept(visitor, "ctx")); + assertEquals("ctx:set:1, 2", parse(set, null).accept(visitor, "ctx")); + for (String sql : List.of(create, alter, set)) { + assertNull(parse(sql, null).accept(new StatementVisitorAdapter<>(), null)); + Statement statement = parse(sql, null); + statement.accept(new StatementVisitorAdapter()); + } + } + + private static boolean isValid(Dialect dialect, String sql, + ValidationCapability... capabilities) { + FeatureConfiguration configuration = new FeatureConfiguration(); + if (dialect != null) { + configuration.setValue(Feature.dialect, dialect.name()); + } + return new Validation(configuration, Arrays.asList(capabilities), sql).validate() + .isEmpty(); + } + + @Test + void validationKnowsMySqlTakesResourceGroups() { + String script = "CREATE RESOURCE GROUP rg TYPE = USER; ALTER RESOURCE GROUP rg DISABLE;" + + " SET RESOURCE GROUP rg; DROP RESOURCE GROUP rg FORCE"; + assertTrue(isValid(Dialect.MYSQL, script, MySqlVersion.V8_0)); + assertTrue(isValid(null, script, MySqlVersion.V8_0)); + assertTrue(isValid(null, script, new FeaturesAllowed(Feature.createResourceGroup, + Feature.alterResourceGroup, Feature.setResourceGroup, Feature.drop))); + for (String sql : script.split("; ")) { + if (!sql.startsWith("DROP")) { + assertFalse(isValid(null, sql, MariaDbVersion.V10_5_4), sql); + assertFalse(isValid(null, sql, PostgresqlVersion.V14), sql); + } + } + assertFalse(isValid(null, "SET RESOURCE GROUP rg", new FeaturesAllowed(Feature.set))); + assertFalse(isValid(null, "CREATE RESOURCE GROUP rg TYPE = USER", + new FeaturesAllowed(Feature.alterResourceGroup))); + assertFalse(isValid(null, "ALTER RESOURCE GROUP rg ENABLE", + new FeaturesAllowed(Feature.createResourceGroup))); + } + + // ---- the model ----------------------------------------------------------------------------- + + @Test + void statementsAreBuiltWithoutTheParser() { + CreateResourceGroup create = new CreateResourceGroup("rg", CreateResourceGroup.Type.USER) + .withTypeAssignment(OptionAssignment.NONE) + .withVcpus(new java.util.ArrayList<>(List.of(new VcpuRange(0, 3)))) + .addVcpuRanges(List.of(new VcpuRange(5))).withThreadPriority(-3) + .withState(State.DISABLE); + create.setVcpuAssignment(OptionAssignment.NONE); + create.setThreadPriorityAssignment(OptionAssignment.COLON_EQUALS); + assertEquals("CREATE RESOURCE GROUP rg TYPE USER VCPU 0-3, 5 THREAD_PRIORITY := -3 DISABLE", + create.toString()); + create.setVcpus(null); + create.addVcpus(new VcpuRange(1)); + assertEquals(List.of(new VcpuRange(1)), create.getVcpus()); + + AlterResourceGroup alter = new AlterResourceGroup("rg") + .withVcpus(new java.util.ArrayList<>()).addVcpuRanges(List.of(new VcpuRange(2))) + .withThreadPriority(1).withState(State.ENABLE).withForce(true); + assertEquals("ALTER RESOURCE GROUP rg VCPU = 2 THREAD_PRIORITY = 1 ENABLE FORCE", + alter.toString()); + + SetResourceGroup set = new SetResourceGroup("rg").addThreadIds(new LongValue(1)) + .addThreadIds(new HexValue("0x1F")); + assertEquals("SET RESOURCE GROUP rg FOR 1, 0x1F", set.toString()); + set.withThreadIds(new ExpressionList<>(new LongValue(7), new LongValue(8))); + assertEquals("SET RESOURCE GROUP rg FOR 7, 8", set.toString()); + set.setThreadIds(new ExpressionList<>()); + assertEquals("SET RESOURCE GROUP rg", set.toString()); + set.addThreadIds(new LongValue(1), new HexValue("0x1F")); + assertEquals("SET RESOURCE GROUP rg FOR 1, 0x1F", set.toString()); + set.setThreadIds(null); + assertEquals("SET RESOURCE GROUP rg", set.toString()); + + assertThrows(NullPointerException.class, () -> new CreateResourceGroup("rg", null)); + assertThrows(NullPointerException.class, () -> new AlterResourceGroup(null)); + assertThrows(NullPointerException.class, () -> new SetResourceGroup(null)); + } + + @Test + void vcpuRangesCompareByTheirNumbers() { + VcpuRange range = new VcpuRange(0, 3); + assertEquals("0-3", range.toString()); + assertEquals(range, range); + assertEquals(new VcpuRange(0, 3), range); + assertEquals(new VcpuRange(0, 3).hashCode(), range.hashCode()); + assertNotEquals(new VcpuRange(0), range); + assertNotEquals(new VcpuRange(1, 3), range); + assertNotEquals(new VcpuRange(0, 0), new VcpuRange(0)); + assertNotEquals("0-3", range); + range.setStart(2); + range.setEnd(null); + assertEquals("2", range.toString()); + assertThrows(IllegalArgumentException.class, () -> new VcpuRange(-1)); + assertThrows(IllegalArgumentException.class, () -> new VcpuRange(0, -1)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/role/MySqlCreateRoleTest.java b/src/test/java/net/sf/jsqlparser/statement/role/MySqlCreateRoleTest.java new file mode 100644 index 0000000000..29f97556cc --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/role/MySqlCreateRoleTest.java @@ -0,0 +1,115 @@ +/*- + * #%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.role; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.List; +import java.util.stream.Collectors; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlCreateRoleTest { + + private static CreateRole parse(String sql, Dialect dialect) throws JSQLParserException { + CreateRole role = assertInstanceOf(CreateRole.class, TestUtils + .assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(dialect))); + assertEquals(sql, CCJSqlParserUtil + .parse(role.toString(), parser -> parser.withDialect(dialect)).toString()); + return role; + } + + private static List names(CreateRole role) { + return role.getRoles().stream().map(UserAccount::toString).collect(Collectors.toList()); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"MYSQL", "MARIADB"}) + void parsesAccountStyleRoleNames(Dialect dialect) throws JSQLParserException { + CreateRole role = parse("CREATE ROLE 'reader', 'writer'@'localhost'", dialect); + + assertEquals(List.of("'reader'", "'writer'@'localhost'"), names(role)); + assertEquals("localhost", role.getRoles().get(1).getHost().getValue()); + assertNull(role.getName()); + assertFalse(role.isIfNotExists()); + assertTrue(role.getOptions().isEmpty()); + } + + @Test + void parsesIfNotExists() throws JSQLParserException { + CreateRole role = parse("CREATE ROLE IF NOT EXISTS app_read, app_write", Dialect.MYSQL); + + assertTrue(role.isIfNotExists()); + assertEquals(List.of("app_read", "app_write"), names(role)); + assertInstanceOf(CreateRole.class, TestUtils + .assertSqlCanBeParsedAndDeparsed("CREATE ROLE IF NOT EXISTS 'reader'", false)); + } + + @Test + void keepsPostgreSqlRoleName() throws JSQLParserException { + // a single unquoted name means the same in both databases and keeps getName() + for (Dialect dialect : List.of(Dialect.MYSQL, Dialect.POSTGRESQL)) { + CreateRole role = parse("CREATE ROLE reader", dialect); + assertEquals("reader", role.getName()); + assertTrue(role.getRoles().isEmpty()); + } + CreateRole role = parse("CREATE ROLE reader WITH LOGIN", Dialect.POSTGRESQL); + assertEquals(RoleOption.Kind.LOGIN, role.getOptions().get(0).getKind()); + } + + @Test + void splitsAnUnquotedNameAtHostOnlyWithMySqlDialects() throws JSQLParserException { + CreateRole mySql = parse("CREATE ROLE r@localhost", Dialect.MYSQL); + assertEquals("r", mySql.getRoles().get(0).getUser().getValue()); + assertEquals("localhost", mySql.getRoles().get(0).getHost().getValue()); + + // without a dialect the lexer's single identifier stays the PostgreSQL role name + CreateRole role = assertInstanceOf(CreateRole.class, + TestUtils.assertSqlCanBeParsedAndDeparsed("CREATE ROLE r@localhost", false)); + assertEquals("r@localhost", role.getName()); + assertEquals(List.of("r", "'%'"), List.of( + parse("CREATE ROLE r@'%'", Dialect.ANSI_SQL).getRoles().get(0).getUser().getValue(), + parse("CREATE ROLE r@'%'", Dialect.ANSI_SQL).getRoles().get(0).getHost() + .toString())); + } + + @Test + void buildsAndDeparses() { + CreateRole role = new CreateRole(); + role.setIfNotExists(true); + role.setRoles(List.of(new UserAccount().withUser(new StringValue("r1")), + new UserAccount().withUser(new StringValue("r2")).withHost(new StringValue("%")))); + + assertDeparse(role, "CREATE ROLE IF NOT EXISTS 'r1', 'r2'@'%'"); + } + + @ParameterizedTest + @ValueSource(strings = {"CREATE OR REPLACE ROLE 'r'", "CREATE ROLE 'r' WITH LOGIN", + "CREATE ROLE IF NOT EXISTS", "CREATE ROLE 'r'@'h' IDENTIFIED BY 'x'", + "CREATE ROLE r1, r2 LOGIN"}) + void rejectsMixedSyntax(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabelTest.java b/src/test/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabelTest.java new file mode 100644 index 0000000000..c0b2a47778 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabelTest.java @@ -0,0 +1,218 @@ +/*- + * #%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.securitylabel; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.RoutineReference; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.securitylabel.SecurityLabel.ObjectType; +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.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class SecurityLabelTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + private static SecurityLabel roundTrip(String sql) throws JSQLParserException { + SecurityLabel label = assertInstanceOf(SecurityLabel.class, + assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL)); + assertEquals(sql, CCJSqlParserUtil.parse(label.toString(), POSTGRESQL).toString()); + return label; + } + + @ParameterizedTest + @ValueSource(strings = { + "SECURITY LABEL FOR selinux ON TABLE t1 IS 'system_u:object_r:sepgsql_table_t:s0'", + "SECURITY LABEL FOR 'dummy' ON TABLE app.t1 IS NULL", + "SECURITY LABEL ON COLUMN app.t1.c IS 'x'", + "SECURITY LABEL ON SEQUENCE app.s IS 'x'", + "SECURITY LABEL ON VIEW v IS 'x'", + "SECURITY LABEL ON MATERIALIZED VIEW app.mv IS 'x'", + "SECURITY LABEL ON FOREIGN TABLE ft IS 'x'", + "SECURITY LABEL ON FUNCTION app.f(int, text) IS 'x'", + "SECURITY LABEL ON FUNCTION f IS 'x'", + "SECURITY LABEL ON PROCEDURE p() IS 'x'", + "SECURITY LABEL ON ROUTINE r(IN a int) IS 'x'", + "SECURITY LABEL ON AGGREGATE agg(*) IS 'x'", + "SECURITY LABEL ON SCHEMA app IS 'x'", + "SECURITY LABEL ON DATABASE mydb IS 'x'", + "SECURITY LABEL ON ROLE app_user IS 'x'", + "SECURITY LABEL ON TABLESPACE fast_space IS 'x'", + "SECURITY LABEL ON DOMAIN app.positive IS 'x'", + "SECURITY LABEL ON TYPE app.mood IS 'x'", + "SECURITY LABEL ON EVENT TRIGGER etg IS 'x'", + "SECURITY LABEL ON LARGE OBJECT 16385 IS 'x'", + "SECURITY LABEL ON LANGUAGE plpgsql IS 'x'", + "SECURITY LABEL ON PROCEDURAL LANGUAGE plpgsql IS 'x'", + "SECURITY LABEL ON PUBLICATION pub IS 'x'", + "SECURITY LABEL ON SUBSCRIPTION sub IS 'x'"}) + void parsesEveryDocumentedObjectKind(String sql) throws JSQLParserException { + roundTrip(sql); + assertInstanceOf(SecurityLabel.class, CCJSqlParserUtil.parse(sql)); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", POSTGRESQL).size()); + } + + @Test + void keepsProviderTargetAndLabel() throws JSQLParserException { + SecurityLabel label = roundTrip( + "SECURITY LABEL FOR selinux ON TABLE app.t1 IS 'system_u:object_r:sepgsql_table_t:s0'"); + assertEquals("selinux", label.getProvider()); + assertEquals(ObjectType.TABLE, label.getObjectType()); + assertEquals("app.t1", label.getObjectName().getFullyQualifiedName()); + assertEquals("system_u:object_r:sepgsql_table_t:s0", label.getLabel().getValue()); + + SecurityLabel column = roundTrip("SECURITY LABEL ON COLUMN app.t1.c IS NULL"); + assertNull(column.getProvider()); + assertEquals(ObjectType.COLUMN, column.getObjectType()); + assertEquals("c", column.getColumn().getColumnName()); + assertEquals("app.t1", column.getColumn().getTable().getFullyQualifiedName()); + assertNull(column.getLabel()); + + SecurityLabel function = roundTrip("SECURITY LABEL ON FUNCTION f(int, text) IS 'x'"); + assertEquals(ObjectType.FUNCTION, function.getObjectType()); + assertEquals("f", function.getRoutine().getName()); + assertEquals(2, function.getRoutine().getArguments().size()); + assertNull(function.getObjectName()); + + SecurityLabel largeObject = roundTrip("SECURITY LABEL ON LARGE OBJECT 16385 IS 'x'"); + assertEquals(ObjectType.LARGE_OBJECT, largeObject.getObjectType()); + assertEquals(16385L, largeObject.getLargeObjectOid()); + + SecurityLabel language = + roundTrip("SECURITY LABEL ON PROCEDURAL LANGUAGE plpgsql IS 'x'"); + assertEquals(ObjectType.LANGUAGE, language.getObjectType()); + assertTrue(language.isProcedural()); + } + + @Test + void tableVisitorsSeeOnlyRelations() throws JSQLParserException { + assertThat(TablesNamesFinder.findTables("SECURITY LABEL ON TABLE app.t1 IS 'x'")) + .containsExactly("app.t1"); + assertThat(TablesNamesFinder.findTables("SECURITY LABEL ON COLUMN app.t1.c IS 'x'")) + .containsExactly("app.t1"); + assertThat(TablesNamesFinder.findTables("SECURITY LABEL ON FOREIGN TABLE ft IS 'x'")) + .containsExactly("ft"); + for (String sql : List.of("SECURITY LABEL ON FUNCTION f(int) IS 'x'", + "SECURITY LABEL ON SCHEMA app IS 'x'", "SECURITY LABEL ON ROLE r IS 'x'", + "SECURITY LABEL ON TYPE app.t IS 'x'")) { + assertTrue(TablesNamesFinder.findTables(sql).isEmpty(), sql); + } + } + + @Test + void settersSelectTheObjectType() { + SecurityLabel label = new SecurityLabel().withProvider("selinux") + .withObjectName(ObjectType.VIEW, new Table("app", "v")) + .withLabel(new StringValue("x")); + assertDeparse(label, "SECURITY LABEL FOR selinux ON VIEW app.v IS 'x'"); + + RoutineReference routine = new RoutineReference(); + routine.setName("f"); + label.setRoutine(ObjectType.PROCEDURE, routine); + assertNull(label.getObjectName()); + assertDeparse(label, "SECURITY LABEL FOR selinux ON PROCEDURE f IS 'x'"); + + label.setColumn(new Column(new Table("t"), "c")); + assertNull(label.getRoutine()); + label.setLabel(null); + assertDeparse(label, "SECURITY LABEL FOR selinux ON COLUMN t.c IS NULL"); + + assertThrows(IllegalArgumentException.class, + () -> label.setObjectName(ObjectType.FUNCTION, new Table("f"))); + assertThrows(IllegalArgumentException.class, + () -> label.setRoutine(ObjectType.TABLE, routine)); + } + + @Test + void labelUsesTheExpressionDeparser() throws JSQLParserException { + SecurityLabel label = (SecurityLabel) CCJSqlParserUtil + .parse("SECURITY LABEL ON TABLE t IS 'before'"); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(StringValue value, S context) { + return getBuilder().append("'after'"); + } + }; + SelectDeParser selects = new SelectDeParser(expressions, output); + expressions.setBuilder(output); + expressions.setSelectVisitor(selects); + label.accept(new StatementDeParser(expressions, selects, output)); + assertEquals("SECURITY LABEL ON TABLE t IS 'after'", output.toString()); + } + + @Test + void validationAndFeatures() throws JSQLParserException { + String sql = "SECURITY LABEL FOR selinux ON TABLE t1 IS 'x'"; + assertTrue(new Validation(List.of(PostgresqlVersion.V10), sql).validate().isEmpty()); + assertThat(new Validation(List.of(MySqlVersion.V8_0), sql).validate()).isNotEmpty(); + assertThat(CCJSqlParserUtil.parse(sql).getFeatures().getCertain()) + .containsExactly(StmtFeature.MODIFIES_SCHEMA); + assertFalse(CCJSqlParserUtil.parse(sql).getFeatures().may(StmtFeature.READS_DATA)); + } + + @Test + void wordsRemainIdentifiers() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT security, label FROM label", false, POSTGRESQL); + } + + @Test + void startsAStatementAmongUnsupportedStatements() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "IMPORT INTO t FROM LOCAL CSV FILE 'f.csv'; SECURITY LABEL ON TABLE t IS 'x'", + parser -> parser.withUnsupportedStatements(true)); + + assertEquals(2, statements.size()); + assertInstanceOf(UnsupportedStatement.class, statements.get(0)); + assertInstanceOf(SecurityLabel.class, statements.get(1)); + } + + @ParameterizedTest + @ValueSource(strings = { + "SECURITY LABEL ON TABLE t", + "SECURITY LABEL ON TABLE t IS 1", + "SECURITY LABEL ON INDEX i IS 'x'", + "SECURITY LABEL ON ROLE app.r IS 'x'", + "SECURITY LABEL ON AGGREGATE agg IS 'x'", + "SECURITY LABEL ON LARGE OBJECT lo IS 'x'", + "SECURITY LABEL FOR p IS 'x'", + "SECURITY TABLE t IS 'x'"}) + void rejectsInvalidSecurityLabels(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL)); + } +} 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); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/select/ClickHouseTest.java b/src/test/java/net/sf/jsqlparser/statement/select/ClickHouseTest.java index 4bce28de6e..76b92ad67e 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/ClickHouseTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/ClickHouseTest.java @@ -21,9 +21,11 @@ import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; import net.sf.jsqlparser.expression.Function; import net.sf.jsqlparser.expression.LambdaExpression; +import net.sf.jsqlparser.expression.StringValue; import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -358,6 +360,228 @@ public void testAllColumnsChainedTransformersIssue2636() throws JSQLParserExcept assertSqlCanBeParsedAndDeparsed(sql, true); } + @Test + public void testAllColumnsExceptStrictIssue2636() throws JSQLParserException { + // STRICT sits between the EXCEPT keyword and its column list + // (ClickHouse ExpressionElementParsers.cpp, ParserColumnsTransformers) + String sql = "SELECT * EXCEPT STRICT (a, b) FROM t"; + Select select = (Select) CCJSqlParserUtil.parse(sql); + PlainSelect plainSelect = (PlainSelect) select.getSelectBody(); + SelectItem selectItem = plainSelect.getSelectItems().get(0); + AllColumns allColumns = + Assertions.assertInstanceOf(AllColumns.class, selectItem.getExpression()); + ColumnsTransformer transformer = allColumns.getTransformers().get(0); + Assertions.assertEquals(ColumnsTransformer.ColumnsTransformerType.EXCEPT, + transformer.getType()); + Assertions.assertTrue(transformer.isStrict()); + Assertions.assertInstanceOf(ParenthesedExpressionList.class, + transformer.getExceptColumns()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the qualified '*' shares the same transformer production + sql = "SELECT t.* EXCEPT STRICT (a) FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + AllTableColumns allTableColumns = Assertions.assertInstanceOf(AllTableColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertTrue(allTableColumns.getTransformers().get(0).isStrict()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the flag belongs to one transformer of the chain only + sql = "SELECT * EXCEPT STRICT (a) REPLACE(x AS a) FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + allColumns = Assertions.assertInstanceOf(AllColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertEquals(2, allColumns.getTransformers().size()); + Assertions.assertTrue(allColumns.getTransformers().get(0).isStrict()); + Assertions.assertFalse(allColumns.getTransformers().get(1).isStrict()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the transformer survives as the second leg of a set operation + sql = "SELECT 1 UNION SELECT * EXCEPT STRICT (a) FROM t"; + SetOperationList union = (SetOperationList) ((Select) CCJSqlParserUtil.parse(sql)) + .getSelectBody(); + PlainSelect rightLeg = (PlainSelect) union.getSelects().get(1); + AllColumns legColumns = Assertions.assertInstanceOf(AllColumns.class, + rightLeg.getSelectItems().get(0).getExpression()); + Assertions.assertTrue(legColumns.getTransformers().get(0).isStrict()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the COLUMNS(...) matcher accepts the same STRICT form + sql = "SELECT COLUMNS('m') EXCEPT STRICT (a) FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + ColumnsExpression columnsExpression = Assertions.assertInstanceOf(ColumnsExpression.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertTrue(columnsExpression.getTransformers().get(0).isStrict()); + assertSqlCanBeParsedAndDeparsed(sql, true); + } + + @Test + public void testAllColumnsReplaceStrictIssue2636() throws JSQLParserException { + String sql = "SELECT * REPLACE STRICT(1 AS a, 2 AS b) FROM t"; + Select select = (Select) CCJSqlParserUtil.parse(sql); + PlainSelect plainSelect = (PlainSelect) select.getSelectBody(); + AllColumns allColumns = Assertions.assertInstanceOf(AllColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + ColumnsTransformer transformer = allColumns.getTransformers().get(0); + Assertions.assertEquals(ColumnsTransformer.ColumnsTransformerType.REPLACE, + transformer.getType()); + Assertions.assertTrue(transformer.isStrict()); + Assertions.assertEquals(2, transformer.getReplaceItems().size()); + Assertions.assertEquals("a", transformer.getReplaceItems().get(0).getAlias().getName()); + Assertions.assertEquals(sql, select.toString()); + StatementDeParser statementDeParser = new StatementDeParser(new StringBuilder()); + select.accept(statementDeParser, null); + Assertions.assertEquals(sql, statementDeParser.getBuilder().toString()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + sql = "SELECT COLUMNS('m') REPLACE STRICT(x + 1 AS x) FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + Assertions.assertInstanceOf(ColumnsExpression.class, + plainSelect.getSelectItems().get(0).getExpression()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the qualified '*' copies the transformers through its own constructor + sql = "SELECT t.* REPLACE STRICT(x AS x) FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + AllTableColumns qualifiedStar = Assertions.assertInstanceOf(AllTableColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertTrue(qualifiedStar.getTransformers().get(0).isStrict()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // each transformer of the chain carries its own flag + sql = "SELECT * REPLACE STRICT(x AS x) REPLACE(y AS y) FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + allColumns = Assertions.assertInstanceOf(AllColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertEquals(2, allColumns.getTransformers().size()); + Assertions.assertTrue(allColumns.getTransformers().get(0).isStrict()); + Assertions.assertFalse(allColumns.getTransformers().get(1).isStrict()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + sql = "SELECT * EXCEPT (a) REPLACE STRICT(x AS a) APPLY(sum) FROM t"; + assertSqlCanBeParsedAndDeparsed(sql, true); + } + + @Test + public void testAllColumnsExceptPatternIssue2636() throws JSQLParserException { + // ClickHouse accepts a re2 pattern string instead of the column list and always + // prints it without brackets (ASTColumnsTransformers.cpp) + String sql = "SELECT * EXCEPT '^tmp_' FROM t"; + Select select = (Select) CCJSqlParserUtil.parse(sql); + PlainSelect plainSelect = (PlainSelect) select.getSelectBody(); + AllColumns allColumns = Assertions.assertInstanceOf(AllColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + ColumnsTransformer transformer = allColumns.getTransformers().get(0); + Assertions.assertEquals(ColumnsTransformer.ColumnsTransformerType.EXCEPT, + transformer.getType()); + Assertions.assertNull(transformer.getExceptColumns()); + Assertions.assertEquals("^tmp_", transformer.getExceptPattern().getValue()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + sql = "SELECT t.* EXCEPT '^tmp_' FROM t"; + assertSqlCanBeParsedAndDeparsed(sql, true); + + sql = "SELECT COLUMNS('m') EXCEPT '^tmp_' FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + ColumnsExpression columnsExpression = Assertions.assertInstanceOf(ColumnsExpression.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertEquals("^tmp_", + columnsExpression.getTransformers().get(0).getExceptPattern().getValue()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // ClickHouse parses STRICT before a pattern as well (it drops the flag only + // during analysis), so the parser keeps it on the AST + sql = "SELECT * EXCEPT STRICT '^tmp_' FROM t"; + select = (Select) CCJSqlParserUtil.parse(sql); + plainSelect = (PlainSelect) select.getSelectBody(); + allColumns = Assertions.assertInstanceOf(AllColumns.class, + plainSelect.getSelectItems().get(0).getExpression()); + Assertions.assertTrue(allColumns.getTransformers().get(0).isStrict()); + Assertions.assertEquals("^tmp_", + allColumns.getTransformers().get(0).getExceptPattern().getValue()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the same combination reaches the COLUMNS(...) path through its own gate + sql = "SELECT COLUMNS('m') EXCEPT STRICT '^tmp2_' FROM t"; + assertSqlCanBeParsedAndDeparsed(sql, true); + + // the pattern participates in the expression traversal of the COLUMNS side + // (getAllExpressions -> ExpressionVisitorAdapter), like the other payloads + List visitedValues = new ArrayList<>(); + ExpressionVisitorAdapter adapter = new ExpressionVisitorAdapter() { + @Override + public Void visit(StringValue stringValue, Object context) { + visitedValues.add(stringValue.getValue()); + return null; + } + }; + select = (Select) CCJSqlParserUtil.parse("SELECT COLUMNS('m') EXCEPT '^tmp_' FROM t"); + plainSelect = (PlainSelect) select.getSelectBody(); + plainSelect.getSelectItems().get(0).getExpression().accept(adapter, null); + Assertions.assertTrue(visitedValues.contains("^tmp_"), + "the EXCEPT pattern must be reachable for expression visitors"); + + // programmatic construction round-trips through the same output paths + AllColumns built = new AllColumns(); + built.addTransformer( + new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.EXCEPT) + .setStrict(true).setExceptPattern(new StringValue("'inner_.*'"))); + Assertions.assertEquals("* EXCEPT STRICT 'inner_.*'", built.toString()); + } + + @Test + public void testStrictKeywordStaysIdentifierAndAliasIssue2636() throws JSQLParserException { + // STRICT is a non-reserved keyword, so plain identifier uses must keep parsing + assertSqlCanBeParsedAndDeparsed("SELECT strict FROM t", true); + assertSqlCanBeParsedAndDeparsed("SELECT * AS strict FROM t", true); + assertSqlCanBeParsedAndDeparsed("SELECT t.strict FROM t", true); + assertSqlCanBeParsedAndDeparsed("SELECT * EXCEPT (strict) FROM t", true); + + // a trailing STRICT is not part of a transformer: it stays the alias of '*' + String sql = "SELECT * REPLACE(x AS y) STRICT FROM t"; + Select select = (Select) CCJSqlParserUtil.parse(sql); + PlainSelect plainSelect = (PlainSelect) select.getSelectBody(); + SelectItem selectItem = plainSelect.getSelectItems().get(0); + Assertions.assertEquals("STRICT", selectItem.getAlias().getName()); + Assertions.assertInstanceOf(AllColumns.class, selectItem.getExpression()); + assertSqlCanBeParsedAndDeparsed(sql, true); + + // a column named strict and a trailing STRICT alias coexist on one item + assertSqlCanBeParsedAndDeparsed("SELECT * EXCEPT (strict) STRICT FROM t", true); + + // the parenthesized set operation after '*' is unchanged + assertSqlCanBeParsedAndDeparsed("SELECT * EXCEPT (SELECT b FROM u)", true); + } + + @Test + public void testStrictTransformerFormsRejectedIssue2636() { + assertThrowsParseException("SELECT * EXCEPT STRICT FROM t"); + assertThrowsParseException("SELECT * REPLACE STRICT FROM t"); + assertThrowsParseException("SELECT * EXCEPT STRICT a FROM t"); + assertThrowsParseException("SELECT * EXCEPT ('^tmp_') FROM t"); + assertThrowsParseException("SELECT * EXCEPT 5 FROM t"); + // neither APPLY nor EXCLUDE has a STRICT variant + assertThrowsParseException("SELECT * APPLY STRICT (x) FROM t"); + assertThrowsParseException("SELECT * EXCLUDE STRICT (a) FROM t"); + assertThrowsParseException("SELECT COLUMNS('m') EXCEPT STRICT a FROM t"); + assertThrowsParseException("SELECT a EXCEPT STRICT FROM t"); + // the pattern and the parenthesized column list are mutually exclusive payloads + assertThrowsParseException("SELECT * EXCEPT STRICT '^x' (a) FROM t"); + assertThrowsParseException("SELECT * REPLACE STRICT () FROM t"); + } + + private static void assertThrowsParseException(String sql) { + Assertions.assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql), + "Expected a parse failure for: " + sql); + } + @Test public void testColumnsApplyMultiParamLambda() throws JSQLParserException { String sql = "SELECT COLUMNS('m') APPLY((k, v) -> v > 5) FROM metrics"; diff --git a/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java b/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java index 68e98f1019..7d98c6b7c2 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java @@ -10,6 +10,9 @@ package net.sf.jsqlparser.statement.select; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.LambdaExpression; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.insert.Insert; @@ -23,12 +26,18 @@ import net.sf.jsqlparser.statement.PrepareStatement; import net.sf.jsqlparser.statement.DeallocateStatement; import net.sf.jsqlparser.statement.CopyStatement; +import net.sf.jsqlparser.statement.create.function.CreateFunction; import net.sf.jsqlparser.statement.create.macro.CreateMacro; import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository; import net.sf.jsqlparser.statement.create.trigger.CreateTrigger; import net.sf.jsqlparser.test.TestUtils; +import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; + +import java.util.Arrays; +import java.util.HashSet; public class DuckDBTest { @@ -502,6 +511,82 @@ void testCreateTableMacro() throws JSQLParserException { Assertions.assertNotNull(createMacro.getSelect()); } + @Test + void testCreateMacroIfNotExists() throws JSQLParserException { + String sqlStr = "CREATE MACRO IF NOT EXISTS add(a, b) AS a + b"; + CreateMacro createMacro = + (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + + Assertions.assertTrue(createMacro.isIfNotExists()); + Assertions.assertEquals("add", createMacro.getName()); + } + + @Test + void testCreateMacroWithTypedParameters() throws JSQLParserException { + String sqlStr = "CREATE MACRO add(a INTEGER, b DOUBLE, c := 5) AS a + b + c"; + CreateMacro createMacro = + (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + + Assertions.assertEquals("INTEGER", createMacro.getParameters().get(0).getType().toString()); + Assertions.assertEquals("DOUBLE", createMacro.getParameters().get(1).getType().toString()); + Assertions.assertNull(createMacro.getParameters().get(2).getType()); + Assertions.assertEquals("5", + createMacro.getParameters().get(2).getDefaultValue().toString()); + } + + @Test + void testCreateOverloadedMacro() throws JSQLParserException { + String sqlStr = "CREATE OR REPLACE MACRO is_maximal(a TINYINT) AS a = 127, " + + "(a INT) AS a = 2147483647"; + CreateMacro createMacro = + (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + + Assertions.assertEquals(2, createMacro.getOverloads().size()); + Assertions.assertEquals("TINYINT", + createMacro.getOverloads().get(0).getParameters().get(0).getType().toString()); + Assertions.assertEquals("a = 2147483647", + createMacro.getOverloads().get(1).getExpression().toString()); + } + + @Test + void testCreateOverloadedTableMacro() throws JSQLParserException { + String sqlStr = "CREATE MACRO get_t(i) AS TABLE SELECT * FROM t WHERE id = i, " + + "(i, j) AS TABLE SELECT * FROM u WHERE id = i AND x = j"; + CreateMacro createMacro = + (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + + Assertions.assertEquals(2, createMacro.getOverloads().size()); + Assertions.assertTrue(createMacro.getOverloads().get(1).isTable()); + Assertions.assertEquals(2, createMacro.getOverloads().get(1).getParameters().size()); + Assertions.assertEquals(new HashSet<>(Arrays.asList("t", "u")), + TablesNamesFinder.findTables(sqlStr)); + } + + @Test + void testCreateFunctionAsMacro() throws JSQLParserException { + for (String sqlStr : Arrays.asList( + "CREATE FUNCTION add(a, b) AS a + b", + "CREATE OR REPLACE TEMPORARY FUNCTION IF NOT EXISTS add(a INTEGER) AS a + 1", + "CREATE FUNCTION get_t(i) AS TABLE SELECT * FROM t WHERE id = i")) { + CreateMacro createMacro = + (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + + Assertions.assertTrue(createMacro.isFunctionKeyword()); + } + } + + @Test + void testCreateFunctionOfOtherDialectsIsNotAMacro() throws JSQLParserException { + for (String sqlStr : Arrays.asList( + "CREATE FUNCTION add(a integer, b integer) RETURNS integer AS 'select $1 + $2' LANGUAGE SQL", + "CREATE FUNCTION add(IN a integer, OUT b integer) AS 'select $1 + 1' LANGUAGE SQL", + "CREATE FUNCTION add(IN a integer, OUT b integer) AS $$ select $1 + 1 $$ LANGUAGE SQL", + "CREATE FUNCTION add(IN a integer, OUT b integer) AS $function$ select $1 + 1 $function$ LANGUAGE SQL", + "CREATE OR REPLACE FUNCTION ds.add(x INT64) AS (x + 1) OPTIONS (description = 'd')")) { + Assertions.assertInstanceOf(CreateFunction.class, CCJSqlParserUtil.parse(sqlStr)); + } + } + @Test void testCreateExtensionRepository() throws JSQLParserException { String sqlStr = @@ -689,4 +774,336 @@ void testRecursiveCteWithoutUsingKey() throws JSQLParserException { Assertions.assertNull(select.getWithItemsList().get(0).getUsingKeyExpressions()); } + + @Test + void testLambdaKeyword() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT list_transform(l, lambda x : x + 1) FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT list_filter(l, lambda x : x > 0) FROM t", + true); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT list_filter(l, lambda x : x IS NOT NULL AND x <> 'a') FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT list_reduce(l, lambda acc, x : acc + x) FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT list_filter([(CASE WHEN a THEN 1 END)], lambda x : x IS NOT NULL) FROM t", + true); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT list_transform(l, lambda x : list_filter(x, lambda y : y > 1)) FROM t", + true); + } + + @Test + void testLambdaKeywordExpression() throws JSQLParserException { + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT list_reduce(l, lambda acc, x : acc + x) FROM t", true); + Function function = select.getSelectItem(0).getExpression(Function.class); + LambdaExpression lambda = (LambdaExpression) function.getParameters().get(1); + + Assertions.assertTrue(lambda.isLambdaKeyword()); + Assertions.assertEquals(Arrays.asList("acc", "x"), lambda.getIdentifiers()); + } + + @Test + void testLambdaKeywordFollowedByArguments() throws JSQLParserException { + PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT f(l, lambda x : x + 1, 2) FROM t", true); + Function function = select.getSelectItem(0).getExpression(Function.class); + + Assertions.assertEquals(3, function.getParameters().size()); + Assertions.assertEquals("x + 1", + ((LambdaExpression) function.getParameters().get(1)).getExpression().toString()); + } + + @Test + void testLambdaAsIdentifier() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT lambda FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT lambda x, y FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT t.lambda FROM lambda t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT CAST(a AS lambda) FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT 'a' COLLATE lambda FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("CREATE TABLE t (a lambda)", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("ALTER TABLE t DROP COLUMN lambda", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("ALTER TABLE t RENAME lambda TO x", true); + } + + @Test + void testFromFirstAndTableAsQueryOperands() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT * FROM (FROM t)", + "SELECT * FROM (FROM t WHERE a > 1) x JOIN (SELECT 1) y ON true", + "SELECT * FROM t WHERE a IN (FROM u)", "SELECT (FROM u SELECT max(a))", + "FROM a UNION ALL FROM b", "FROM a WHERE x > 1 UNION ALL SELECT 1", + "SELECT 1 EXCEPT FROM b WHERE x", "FROM a SELECT x UNION FROM b SELECT x", + "WITH t AS (SELECT 1), u AS (SELECT 2) TABLE t", "TABLE a UNION TABLE b", + "SELECT 1 UNION TABLE b", "(TABLE a EXCEPT ALL TABLE b)", + "SELECT * FROM TABLE(f(1))"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + + SetOperationList union = (SetOperationList) CCJSqlParserUtil + .parse("TABLE a UNION TABLE b ORDER BY 1 LIMIT 2"); + Assertions.assertEquals("1", union.getOrderByElements().get(0).toString()); + Assertions.assertNotNull(union.getLimit()); + Assertions.assertNull(((TableStatement) union.getSelect(1)).getOrderByElements()); + + union = (SetOperationList) CCJSqlParserUtil.parse("FROM a UNION FROM b ORDER BY 1"); + Assertions.assertTrue(((PlainSelect) union.getSelect(0)).isFromFirst()); + Assertions.assertEquals("1", union.getOrderByElements().get(0).toString()); + } + + @Test + void testTableQueryKeepsTableColumnsAndTrailingClauses() throws JSQLParserException { + // TABLE also names columns, e.g. in ClickHouse's system.parts + for (String sqlStr : new String[] { + "SELECT database, table FROM system.parts WHERE (database = 'default') AND (table = 'hits')", + "SELECT (table), (table.a), (table + 1) FROM t", + "SELECT a FROM t WHERE (table, b) IN ((1, 2))", + "SELECT * FROM (TABLE s.t) x", "TABLE t FETCH FIRST 1 ROWS ONLY", + "WITH a AS (SELECT 1) TABLE a FETCH FIRST 1 ROWS ONLY", + "CREATE TABLE x AS TABLE a UNION TABLE b"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + Assertions.assertInstanceOf(net.sf.jsqlparser.statement.piped.FromQuery.class, + ((ParenthesedSelect) CCJSqlParserUtil.parse("(FROM t)")).getSelect()); + } + + @Test + void testLimitPercent() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT a FROM t LIMIT 10%", + "SELECT a FROM t LIMIT 10.5%", "SELECT a FROM t LIMIT 40 PERCENT", + "SELECT a FROM t LIMIT 50% OFFSET 2", "SELECT a FROM t LIMIT (SELECT 10)%", + "SELECT * FROM (SELECT a FROM t LIMIT 10%) x", + "SELECT a FROM t LIMIT (SELECT a FROM u LIMIT 5%)", "SELECT a FROM t LIMIT NULL%", + // modulo and a column named offset are unchanged + "SELECT a FROM t LIMIT 10 % 3", "SELECT a FROM t LIMIT a % offset", + "SELECT a FROM t LIMIT a % offset + 1", "SELECT a FROM t LIMIT a % offset OFFSET 2", + "SELECT a FROM t LIMIT (SELECT a % offset + 1 FROM u)"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT a FROM t LIMIT 10%"); + Assertions.assertEquals("%", select.getLimit().getPercentUnit()); + Assertions.assertEquals("10", select.getLimit().getRowCount().toString()); + + select = (PlainSelect) CCJSqlParserUtil.parse("SELECT a FROM t LIMIT a % offset + 1"); + Assertions.assertNull(select.getLimit().getPercentUnit()); + Assertions.assertNull(select.getOffset()); + } + + @Test + void testTableSampleWithoutOrWithReservoirMethod() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT a FROM t TABLESAMPLE 10%", + "SELECT a FROM t TABLESAMPLE 10 ROWS", "SELECT a FROM t t1 TABLESAMPLE 10 PERCENT", + "SELECT a FROM t TABLESAMPLE RESERVOIR (10 ROWS) REPEATABLE (1)", + "SELECT a FROM (SELECT 1) TABLESAMPLE 10%", + "SELECT a FROM read_csv('x') TABLESAMPLE 10%", + "SELECT a FROM range(10) r USING SAMPLE 10%"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + // after DuckDB's TABLESAMPLE n, OFFSET belongs to the query + PlainSelect select = (PlainSelect) CCJSqlParserUtil + .parse("SELECT a FROM t TABLESAMPLE 10 OFFSET 3"); + Assertions.assertEquals("3", select.getOffset().getOffset().toString()); + } + + @Test + void testDoubleEqualsOperator() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a FROM t WHERE a == 1 AND b = 2", true); + Assertions.assertEquals("==", + ((net.sf.jsqlparser.expression.operators.relational.EqualsTo) CCJSqlParserUtil + .parseCondExpression("a == 1")).getStringExpression()); + } + + @Test + void testExponentiationOperator() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT 2 ** 3, 2 * 3 ** 2, -2 ** 2", true); + // above the multiplicative operators, left-associative, below the unary sign + Assertions.assertEquals("Multiplication(2, Exponentiation(3, 2))", + tree(CCJSqlParserUtil.parseExpression("2 * 3 ** 2"))); + Assertions.assertEquals("Exponentiation(Exponentiation(2, 3), 2)", + tree(CCJSqlParserUtil.parseExpression("2 ** 3 ** 2"))); + Assertions.assertEquals("Exponentiation(-2, 2)", + tree(CCJSqlParserUtil.parseExpression("-2 ** 2"))); + } + + @Test + void testLikeOperators() throws JSQLParserException { + for (String operator : new String[] {"~~", "~~*", "~~~", "!~~", "!~~*"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT a FROM t WHERE a " + operator + " 'x%'", true); + } + net.sf.jsqlparser.expression.operators.relational.LikeExpression like = + (net.sf.jsqlparser.expression.operators.relational.LikeExpression) CCJSqlParserUtil + .parseCondExpression("a !~~* 'x%'"); + Assertions.assertEquals( + net.sf.jsqlparser.expression.operators.relational.LikeExpression.KeyWord.ILIKE, + like.getLikeKeyWord()); + Assertions.assertTrue(like.isNot()); + // the regular expression operators are unchanged + Assertions.assertInstanceOf( + net.sf.jsqlparser.expression.operators.relational.RegExpMatchOperator.class, + CCJSqlParserUtil.parseCondExpression("a !~* 'x'")); + } + + @Test + void testChainedSigns() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT - -1, +-+1, ++-++-+i, ~ ~a, x - -1 FROM t", + true); + Assertions.assertEquals("- - -a", CCJSqlParserUtil.parseExpression("- - -a").toString()); + } + + @Test + void testLikeOperatorFollowsTheModel() throws JSQLParserException { + net.sf.jsqlparser.expression.operators.relational.LikeExpression like = + (net.sf.jsqlparser.expression.operators.relational.LikeExpression) CCJSqlParserUtil + .parseCondExpression("a ~~ 'x'"); + like.setNot(true); + Assertions.assertEquals("a !~~ 'x'", like.toString()); + like.setLikeKeyWord( + net.sf.jsqlparser.expression.operators.relational.LikeExpression.KeyWord.SIMILAR_TO); + Assertions.assertEquals("a NOT SIMILAR TO 'x'", like.toString()); + Assertions.assertThrows(IllegalArgumentException.class, () -> like.setLikeOperator("!~~~")); + Assertions.assertThrows(IllegalArgumentException.class, () -> like.setLikeOperator(null)); + } + + @Test + void testMixedSignsStaySeparate() throws JSQLParserException { + for (String expression : new String[] {"- ~1", "~ -1", "~ - ~a", "- ~ -a", "+ ~a"}) { + String deparsed = CCJSqlParserUtil.parseExpression(expression).toString(); + Assertions.assertEquals(expression.replace(" ", ""), + deparsed.replace(" ", "")); + Assertions.assertFalse(deparsed.contains("-~") || deparsed.contains("~-") + || deparsed.contains("~~") || deparsed.contains("+~"), deparsed); + } + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT - ~1, ~ -1, -+1", true); + } + + private static String tree(net.sf.jsqlparser.expression.Expression expression) { + if (expression instanceof net.sf.jsqlparser.expression.BinaryExpression) { + net.sf.jsqlparser.expression.BinaryExpression binary = + (net.sf.jsqlparser.expression.BinaryExpression) expression; + return expression.getClass().getSimpleName() + "(" + tree(binary.getLeftExpression()) + + ", " + tree(binary.getRightExpression()) + ")"; + } + return expression.toString(); + } + + @Test + void testListComprehension() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT [x * 2 FOR x IN l] FROM t", + "SELECT [x FOR x IN l IF x > 1] FROM t", "SELECT [x + i FOR x, i IN l] FROM t", + "SELECT [[y FOR y IN x] FOR x IN [[1], [2]]]", + "SELECT [x FOR x IN l IF x IN (1, 2)] FROM t", + "SELECT [x FOR x IN (SELECT list(a) FROM t)]", + "SELECT [x FOR x IN l][1] FROM t"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + + net.sf.jsqlparser.expression.ListComprehension comprehension = + (net.sf.jsqlparser.expression.ListComprehension) CCJSqlParserUtil + .parseExpression("[x + i FOR x, i IN l IF x > 1]"); + Assertions.assertEquals("x + i", comprehension.getExpression().toString()); + Assertions.assertEquals(Arrays.asList("x", "i"), comprehension.getVariables()); + Assertions.assertEquals("l", comprehension.getList().toString()); + Assertions.assertEquals("x > 1", comprehension.getCondition().toString()); + + Assertions.assertEquals(new HashSet<>(Arrays.asList("t", "u")), + new HashSet<>(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse( + "SELECT [x FOR x IN (SELECT list(a) FROM u)] FROM t")))); + } + + @Test + @Timeout(10) + void testLargeArrayIsScannedOnce() throws JSQLParserException { + StringBuilder sql = new StringBuilder("SELECT [0"); + for (int i = 1; i < 20000; i++) { + sql.append(", ").append(i); + } + CCJSqlParserUtil.parse(sql.append("]").toString()); + } + + @Test + void testStarRenameAndUnparenthesizedModifiers() throws JSQLParserException { + for (String sqlStr : new String[] {"SELECT * RENAME (i AS x, j AS y) FROM t", + "SELECT * RENAME i AS x FROM t", "SELECT * EXCLUDE i FROM t", + "SELECT * EXCLUDE t.i FROM t", "SELECT * REPLACE i + 1 AS i FROM t", + "SELECT * EXCLUDE (k) RENAME (i AS x) FROM t", + "SELECT t.* RENAME t.i AS x FROM t", + "SELECT COLUMNS(* REPLACE i + 1 AS i) FROM t"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + + PlainSelect select = (PlainSelect) CCJSqlParserUtil + .parse("SELECT * RENAME (i AS x) FROM t"); + net.sf.jsqlparser.expression.ColumnsTransformer rename = + ((AllColumns) select.getSelectItem(0) + .getExpression()).getTransformers().get(0); + Assertions.assertEquals( + net.sf.jsqlparser.expression.ColumnsTransformer.ColumnsTransformerType.RENAME, + rename.getType()); + Assertions.assertEquals("i AS x", rename.getRenameItems().get(0).toString()); + + // a star aliased rename or replace keeps parsing + for (String sqlStr : new String[] {"SELECT * rename FROM t", "SELECT * replace FROM t", + "SELECT t.* rename, b FROM t", "SELECT * rename(a, b) FROM t"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + // DuckDB reads a parenthesized expression followed by AS as the single item + select = (PlainSelect) CCJSqlParserUtil.parse("SELECT * REPLACE (a + 1) AS a FROM t"); + Assertions.assertEquals("(a + 1) AS a", + ((AllColumns) select.getSelectItem(0) + .getExpression()).getTransformers().get(0).getReplaceItems().get(0) + .toString()); + } + + @Test + void testTrailingCommaInSelectList() throws JSQLParserException { + Assertions.assertEquals("SELECT i, j FROM t WHERE i > 0", + CCJSqlParserUtil.parse("SELECT i, j, FROM t WHERE i > 0").toString()); + Assertions.assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT * RENAME i FROM t")); + Assertions.assertEquals("SELECT 1 LIMIT 1", + CCJSqlParserUtil.parse("SELECT 1, LIMIT 1").toString()); + Assertions.assertEquals("SELECT (SELECT 1)", + CCJSqlParserUtil.parse("SELECT (SELECT 1,)").toString()); + // keywords that may name a column or a function still do + for (String item : new String[] {"limit", "offset", "group", "order", "qualify", + "limit(1)", "offset(1)", "group by", "order by"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a, " + item + " FROM t", true); + } + } + + @Test + void testWindowAndFilterForms() throws JSQLParserException { + for (String sqlStr : new String[] { + "SELECT a FROM t WINDOW w AS (ORDER BY a) QUALIFY row_number() OVER w = 1", + "SELECT a FROM t QUALIFY row_number() OVER w = 1 WINDOW w AS (ORDER BY a)", + "SELECT sum(a) OVER (w ROWS 2 PRECEDING) FROM t WINDOW w AS (ORDER BY b)", + "SELECT sum(a) OVER (w) FROM t WINDOW w AS (ORDER BY b)", + "SELECT sum(a) OVER w2 FROM t WINDOW w AS (PARTITION BY c), w2 AS (w ORDER BY b)", + "SELECT sum(a) OVER (ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) FROM t", + "SELECT sum(a) FILTER (b > 1) FROM t", + "SELECT count(*) FILTER (b > 1) OVER () FROM t", + // window specifications inside syntactic lookahead + "SELECT JSON_VALUE(j, '$.a' DEFAULT sum(a) OVER (PARTITION BY b) ON EMPTY) FROM t", + "SELECT JSON_VALUE(j, '$.a' DEFAULT sum(a) OVER (w ORDER BY b) ON EMPTY) FROM t"}) { + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse( + "SELECT sum(a) FILTER (b > 1) OVER (w ORDER BY c) FROM t WINDOW w AS (PARTITION BY d)"); + net.sf.jsqlparser.expression.AnalyticExpression sum = + (net.sf.jsqlparser.expression.AnalyticExpression) select.getSelectItem(0) + .getExpression(); + Assertions.assertFalse(sum.isFilterWhereKeyword()); + Assertions.assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse( + "SELECT percentile_cont(0.5) WITHIN GROUP (w ORDER BY a) FROM t")); + Assertions.assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT a FROM t ORDER SIBLINGS BY a QUALIFY x = 1")); + // PostgreSQL requires WHERE + Assertions.assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("SELECT sum(a) FILTER (b > 1) FROM t", + parser -> parser.withDialect( + net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect.POSTGRESQL))); + Assertions.assertEquals("w", sum.getWindowDefinition().getBaseWindowName()); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/select/ForUpdateTest.java b/src/test/java/net/sf/jsqlparser/statement/select/ForUpdateTest.java index 23eb3d2297..f082ea4581 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/ForUpdateTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/ForUpdateTest.java @@ -11,10 +11,13 @@ import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; +import java.util.List; + import static org.assertj.core.api.Assertions.assertThat; public class ForUpdateTest { @@ -145,4 +148,50 @@ void testForUpdateWait() throws JSQLParserException { assertThat(forUpdate.getWait()).isNotNull(); assertThat(forUpdate.getWait().getTimeout()).isEqualTo(10L); } + + @Test + void testPostgresMultipleLockingClausesIssue2926() throws JSQLParserException { + String sqlStr = "SELECT * FROM t JOIN u ON u.t_id = t.id FOR UPDATE OF t FOR SHARE OF u"; + Statement stmt = TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + PlainSelect plainSelect = (PlainSelect) stmt; + + assertThat(plainSelect.getForMode()).isEqualTo(ForMode.UPDATE); + assertThat(plainSelect.getForUpdateTables()).extracting(Table::getName) + .containsExactly("t"); + + assertThat(plainSelect.getAdditionalForUpdateClauses()).hasSize(1); + ForUpdateClause second = plainSelect.getAdditionalForUpdateClauses().get(0); + assertThat(second.isForShare()).isTrue(); + assertThat(second.getTables()).extracting(Table::getName).containsExactly("u"); + } + + @Test + void testPostgresMultipleLockingClausesWithOptions() throws JSQLParserException { + String sqlStr = "SELECT * FROM a, b, c, d" + + " FOR NO KEY UPDATE OF a NOWAIT" + + " FOR KEY SHARE OF b, c SKIP LOCKED" + + " FOR SHARE" + + " FOR UPDATE OF d NOWAIT"; + Statement stmt = TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + PlainSelect plainSelect = (PlainSelect) stmt; + + assertThat(plainSelect.getForMode()).isEqualTo(ForMode.NO_KEY_UPDATE); + assertThat(plainSelect.isNoWait()).isTrue(); + + List more = plainSelect.getAdditionalForUpdateClauses(); + assertThat(more).extracting(ForUpdateClause::getMode) + .containsExactly(ForMode.KEY_SHARE, ForMode.SHARE, ForMode.UPDATE); + assertThat(more.get(0).getTables()).extracting(Table::getName) + .containsExactly("b", "c"); + assertThat(more.get(0).isSkipLocked()).isTrue(); + assertThat(more.get(1).getTables()).isNull(); + assertThat(more.get(2).isNoWait()).isTrue(); + } + + @Test + void testSingleLockingClauseHasNoAdditionalClauses() throws JSQLParserException { + PlainSelect plainSelect = + (PlainSelect) CCJSqlParserUtil.parse("SELECT * FROM t FOR UPDATE OF t"); + assertThat(plainSelect.getAdditionalForUpdateClauses()).isNull(); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapterTest.java b/src/test/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapterTest.java new file mode 100644 index 0000000000..4722220676 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/select/FromItemVisitorAdapterTest.java @@ -0,0 +1,150 @@ +/*- + * #%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.select; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.JsonTableFunction; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.StatementFeatureVisitor; +import net.sf.jsqlparser.statement.StatementFeatures; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class FromItemVisitorAdapterTest { + + @Test + void visitsEveryRowsFromFunctionWithTheSameContext() throws JSQLParserException { + PlainSelect select = parse("SELECT * FROM ROWS FROM (f(source_col), g(other_col)) " + + "WITH ORDINALITY AS rows"); + RecordingExpressions expressions = new RecordingExpressions(); + + select.getFromItem().accept(new FromItemVisitorAdapter<>(expressions), + expressions.context); + + assertEquals(List.of("f", "g"), expressions.functions); + assertEquals(List.of("source_col", "other_col"), expressions.columns); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT * FROM f(g(source_col))", + "SELECT * FROM (SELECT * FROM f(g(source_col))) nested", + "SELECT * FROM base JOIN f(g(source_col)) AS derived ON 1 = 1" + }) + void selectAdapterUsesTheSuppliedExpressionVisitorForTableFunctions(String sql) + throws JSQLParserException { + RecordingExpressions expressions = new RecordingExpressions(); + SelectVisitorAdapter visitor = new SelectVisitorAdapter<>(expressions); + + parse(sql).accept(visitor, expressions.context); + + assertEquals(List.of("f", "g"), expressions.functions); + assertEquals(List.of("source_col"), expressions.columns); + } + + @Test + void dispatchesJsonTableAndVisitsItsNestedExpressions() throws JSQLParserException { + PlainSelect select = parse("SELECT * FROM JSON_TABLE(payload, '$' " + + "PASSING filter_expr AS filter COLUMNS (" + + "id INT PATH '$.id' DEFAULT fallback_value ON EMPTY, " + + "NESTED PATH '$.items[*]' COLUMNS (" + + "value INT PATH '$.value' DEFAULT nested_default ON ERROR))) AS jt"); + RecordingExpressions expressions = new RecordingExpressions(); + + select.getFromItem().accept(new FromItemVisitorAdapter<>(expressions), + expressions.context); + + assertEquals(1, expressions.jsonTables.size()); + assertSame(((TableFunction) select.getFromItem()).getFunction(), + expressions.jsonTables.get(0)); + assertEquals(List.of("payload", "filter_expr", "fallback_value", "nested_default"), + expressions.columns); + } + + @Test + void traversesSubqueriesInFunctionArgumentsThroughTheConfiguredVisitorChain() + throws JSQLParserException { + RecordingExpressions expressions = new RecordingExpressions(); + SelectVisitorAdapter visitor = new SelectVisitorAdapter<>(expressions); + expressions.setSelectVisitor(visitor); + + parse("SELECT * FROM f((SELECT selected_col FROM g(argument_col)))") + .accept(visitor, expressions.context); + + assertEquals(List.of("f", "g"), expressions.functions); + assertEquals(List.of("selected_col", "argument_col"), expressions.columns); + } + + @Test + void emptyTableFunctionDoesNotInvokeTheExpressionVisitor() { + RecordingExpressions expressions = new RecordingExpressions(); + TableFunction tableFunction = new TableFunction((Function) null); + + assertNull(tableFunction.accept(new FromItemVisitorAdapter<>(expressions), + expressions.context)); + assertEquals(List.of(), expressions.functions); + } + + @Test + void featureAnalysisChecksEachTableFunctionOnce() throws JSQLParserException { + List checkedFunctions = new ArrayList<>(); + StatementFeatures features = StatementFeatureVisitor.analyse( + CCJSqlParserUtil.parse("SELECT * FROM ROWS FROM (f(g(1)), h(2))"), name -> { + checkedFunctions.add(name); + return true; + }); + + assertEquals(List.of("f", "g", "h"), checkedFunctions); + assertFalse(features.mayModifyData()); + } + + private static PlainSelect parse(String sql) throws JSQLParserException { + return ((Select) CCJSqlParserUtil.parse(sql)).getPlainSelect(); + } + + private static final class RecordingExpressions extends ExpressionVisitorAdapter { + private final Object context = new Object(); + private final List columns = new ArrayList<>(); + private final List functions = new ArrayList<>(); + private final List jsonTables = new ArrayList<>(); + + @Override + public Void visit(Column column, S context) { + assertSame(this.context, context); + columns.add(column.getColumnName()); + return super.visit(column, context); + } + + @Override + public Void visit(Function function, S context) { + assertSame(this.context, context); + functions.add(function.getName()); + return super.visit(function, context); + } + + @Override + public Void visit(JsonTableFunction function, S context) { + assertSame(this.context, context); + jsonTables.add(function); + return super.visit(function, context); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/JoinUsingDeParseTest.java b/src/test/java/net/sf/jsqlparser/statement/select/JoinUsingDeParseTest.java new file mode 100644 index 0000000000..4b5f7d33ce --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/select/JoinUsingDeParseTest.java @@ -0,0 +1,48 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.statement.select; + +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import org.junit.jupiter.api.Test; + +import java.time.Duration; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; + +public class JoinUsingDeParseTest { + + private static String usingSelect(int columnCount) { + StringBuilder sb = new StringBuilder("SELECT * FROM a JOIN b USING ("); + for (int i = 0; i < columnCount; i++) { + if (i > 0) { + sb.append(", "); + } + sb.append("c").append(i); + } + return sb.append(")").toString(); + } + + @Test + void deParseOfLargeUsingColumnListIsLinear() throws Exception { + // usingColumns is a LinkedList, so deparsing the clause through + // Select.appendStringListTo used to read it by index (get(i)), which is O(n^2). + String sql = usingSelect(200000); + Statement statement = CCJSqlParserUtil.parse(sql); + assertEquals(sql, assertTimeoutPreemptively(Duration.ofSeconds(5), statement::toString)); + } + + @Test + void deParseOfUsingColumnListIsUnchanged() throws Exception { + String sql = "SELECT * FROM a JOIN b USING (c0, c1, c2)"; + assertEquals(sql, CCJSqlParserUtil.parse(sql).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/MySqlIndexHintTest.java b/src/test/java/net/sf/jsqlparser/statement/select/MySqlIndexHintTest.java new file mode 100644 index 0000000000..0f1af0d6f1 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/select/MySqlIndexHintTest.java @@ -0,0 +1,239 @@ +/*- + * #%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.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 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.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.MySQLIndexHint; +import net.sf.jsqlparser.expression.MySQLIndexHint.Scope; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.update.Update; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlIndexHintTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + + private static PlainSelect parse(String sql) throws JSQLParserException { + // exact output: single spaces, and the same text from toString() and the deparser + assertSqlCanBeParsedAndDeparsed(sql, false); + return (PlainSelect) assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + } + + private static void assertHint(MySQLIndexHint hint, String action, String qualifier, + Scope scope, String... names) { + assertEquals(action, hint.getAction()); + assertEquals(qualifier, hint.getIndexQualifier()); + assertEquals(scope, hint.getScope()); + assertEquals(Arrays.asList(names), hint.getIndexNames()); + } + + @Test + void ignoreIndexForOrderBy() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t IGNORE INDEX FOR ORDER BY (i1) ORDER BY a"); + + Table table = (Table) select.getFromItem(); + assertEquals(1, table.getIndexHints().size()); + assertHint(table.getIndexHint(), "IGNORE", "INDEX", Scope.ORDER_BY, "i1"); + assertEquals(1, select.getOrderByElements().size()); + } + + @Test + void forceIndexForJoin() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t FORCE INDEX FOR JOIN (i1) JOIN s ON t.a = s.a"); + + assertHint(((Table) select.getFromItem()).getIndexHint(), "FORCE", "INDEX", Scope.JOIN, + "i1"); + assertEquals("s", ((Table) select.getJoins().get(0).getFromItem()).getName()); + assertNull(((Table) select.getJoins().get(0).getFromItem()).getIndexHints()); + } + + @Test + void useKeyForGroupBy() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t USE KEY FOR GROUP BY (i1,i2) GROUP BY a"); + + assertHint(((Table) select.getFromItem()).getIndexHint(), "USE", "KEY", Scope.GROUP_BY, + "i1", "i2"); + } + + @Test + void ignoreKeyIsAHintNotAnAlias() throws JSQLParserException { + // IGNORE before KEY used to be read as an alias of t + PlainSelect select = parse("SELECT a FROM t IGNORE KEY (i1)"); + Table table = (Table) select.getFromItem(); + assertNull(table.getAlias()); + assertHint(table.getIndexHint(), "IGNORE", "KEY", null, "i1"); + + Update update = (Update) assertSqlCanBeParsedAndDeparsed( + "UPDATE t IGNORE KEY FOR ORDER BY (i1) SET a = 1 ORDER BY a LIMIT 1", false, MYSQL); + assertHint(update.getTable().getIndexHint(), "IGNORE", "KEY", Scope.ORDER_BY, "i1"); + } + + @Test + void emptyUseIndexList() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t USE INDEX ()"); + + assertHint(((Table) select.getFromItem()).getIndexHint(), "USE", "INDEX", null); + assertTrue(((Table) select.getFromItem()).getIndexHint().getIndexNames().isEmpty()); + } + + @Test + void severalHintsKeepTheirOrder() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t AS x USE INDEX (i1) IGNORE INDEX FOR ORDER BY" + + " (i2) FORCE KEY FOR JOIN (i3,PRIMARY) WHERE a = 1"); + + Table table = (Table) select.getFromItem(); + assertEquals("x", table.getAlias().getName()); + List hints = table.getIndexHints(); + assertEquals(3, hints.size()); + assertHint(hints.get(0), "USE", "INDEX", null, "i1"); + assertHint(hints.get(1), "IGNORE", "INDEX", Scope.ORDER_BY, "i2"); + assertHint(hints.get(2), "FORCE", "KEY", Scope.JOIN, "i3", "PRIMARY"); + assertSame(hints.get(0), table.getIndexHint()); + } + + @Test + void hintsOnJoinedTables() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t1 USE INDEX (i1) JOIN t2 IGNORE INDEX (i2)" + + " USE INDEX FOR JOIN (i3) ON t1.a = t2.a"); + + Table joined = (Table) select.getJoins().get(0).getFromItem(); + assertEquals(2, joined.getIndexHints().size()); + assertHint(joined.getIndexHints().get(1), "USE", "INDEX", Scope.JOIN, "i3"); + } + + @Test + void updateTargetWithSeveralHints() throws JSQLParserException { + String sql = "UPDATE t USE INDEX (i1) IGNORE INDEX FOR ORDER BY (i2) SET a = 1"; + Update update = (Update) assertSqlCanBeParsedAndDeparsed(sql, false, MYSQL); + + assertEquals(2, update.getTable().getIndexHints().size()); + assertHint(update.getTable().getIndexHints().get(1), "IGNORE", "INDEX", Scope.ORDER_BY, + "i2"); + } + + @Test + void lockingClauseAfterHintsKeepsItsMeaning() throws JSQLParserException { + PlainSelect select = parse("SELECT a FROM t USE INDEX (i1) FOR UPDATE"); + + assertEquals(ForMode.UPDATE, select.getForMode()); + assertNull(((Table) select.getFromItem()).getIndexHint().getScope()); + + PlainSelect plain = parse("SELECT a FROM t FOR UPDATE"); + assertEquals(ForMode.UPDATE, plain.getForMode()); + assertNull(((Table) plain.getFromItem()).getIndexHints()); + } + + @Test + void otherDialectsParseTheSameHints() throws JSQLParserException { + String sql = "SELECT a FROM t IGNORE INDEX FOR ORDER BY (i1) ORDER BY a"; + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + + assertEquals(Scope.ORDER_BY, ((Table) select.getFromItem()).getIndexHint().getScope()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT a FROM t IGNORE INDEX ()", + "SELECT a FROM t FORCE KEY ()", + "SELECT a FROM t IGNORE KEY ()", + "SELECT a FROM t USE INDEX", + "SELECT a FROM t USE INDEX FOR (i1)", + "SELECT a FROM t USE INDEX FOR UPDATE (i1)", + "SELECT a FROM t USE INDEX FOR ORDER (i1)", + "SELECT a FROM t USE INDEX (i1,)" + }) + void rejectsIncompleteHints(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @Test + void statementBoundary() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SELECT a FROM t USE INDEX FOR JOIN (i1); SELECT 1", MYSQL); + + assertEquals(2, statements.size()); + assertEquals("SELECT a FROM t USE INDEX FOR JOIN (i1)", statements.get(0).toString()); + } + + @Test + void tablesNamesFinderIgnoresIndexNames() throws JSQLParserException { + assertEquals(new HashSet<>(Arrays.asList("t", "s")), TablesNamesFinder.findTables( + "SELECT a FROM t FORCE INDEX FOR JOIN (i1) JOIN s USE INDEX () ON t.a = s.a")); + } + + @Test + void validatesForMySql() throws JSQLParserException { + ValidationTestAsserts.validateNoErrors( + "SELECT a FROM t USE INDEX (i1) IGNORE INDEX FOR ORDER BY (i2) ORDER BY a", 1, + MySqlVersion.V8_0); + } + + @Test + void editHintsOnTheModel() throws JSQLParserException { + Table table = new Table("t"); + MySQLIndexHint legacy = new MySQLIndexHint("USE", "INDEX", Arrays.asList("i1")); + assertNull(legacy.getScope()); + + table.setHint(legacy); + assertEquals("t USE INDEX (i1)", table.toString()); + + table.addIndexHint(new MySQLIndexHint("IGNORE", "KEY", Scope.GROUP_BY, + Arrays.asList("i2", "i3"))); + assertEquals("t USE INDEX (i1) IGNORE KEY FOR GROUP BY (i2,i3)", table.toString()); + assertEquals(" USE INDEX (i1) IGNORE KEY FOR GROUP BY (i2,i3)", + table.appendIndexHintsTo(new StringBuilder()).toString()); + + PlainSelect select = new PlainSelect().addSelectItems(new AllColumns()).withFromItem(table); + assertEquals("SELECT * FROM t USE INDEX (i1) IGNORE KEY FOR GROUP BY (i2,i3)", + select.toString()); + assertDeparse(select, + "SELECT * FROM t USE INDEX (i1) IGNORE KEY FOR GROUP BY (i2,i3)"); + assertSqlCanBeParsedAndDeparsed(select.toString(), false, MYSQL); + + // setHint replaces every hint; null removes them + table.setHint(new MySQLIndexHint("FORCE", "INDEX", Scope.ORDER_BY, + Collections.singletonList("i4"))); + assertEquals("t FORCE INDEX FOR ORDER BY (i4)", table.toString()); + table.setHint(null); + assertNull(table.getIndexHint()); + assertNull(table.getIndexHints()); + assertEquals("t", table.toString()); + + table.setIndexHints(Collections.singletonList( + new MySQLIndexHint("USE", "INDEX", Scope.JOIN, Collections.emptyList()))); + assertEquals("t USE INDEX FOR JOIN ()", table.toString()); + assertInstanceOf(MySQLIndexHint.class, table.getIndexHint()); + assertEquals("ORDER BY", Scope.ORDER_BY.getKeywords()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/MySqlSelectModifierTest.java b/src/test/java/net/sf/jsqlparser/statement/select/MySqlSelectModifierTest.java new file mode 100644 index 0000000000..84424742a8 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/select/MySqlSelectModifierTest.java @@ -0,0 +1,211 @@ +/*- + * #%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.select; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +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.EnumSet; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.test.TestUtils; +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 org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; + +class MySqlSelectModifierTest { + private static PlainSelect parse(String sql, Dialect dialect) throws JSQLParserException { + return (PlainSelect) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + @ParameterizedTest + @EnumSource(MySqlSelectModifier.class) + void separatesModifiersFromColumnsAndAliases(MySqlSelectModifier modifier) throws Exception { + String sql = "SELECT " + modifier + " a FROM t"; + for (Dialect dialect : List.of(Dialect.MYSQL, Dialect.MARIADB)) { + PlainSelect select = parse(sql, dialect); + assertEquals(Set.of(modifier), select.getMySqlSelectModifiers()); + SelectItem item = select.getSelectItem(0); + assertEquals("a", ((Column) item.getExpression()).getColumnName()); + assertNull(item.getAlias()); + assertEquals(Set.of("t"), new TablesNamesFinder<>().getTables((Statement) select)); + assertRoundTrip(select, sql, dialect); + } + PlainSelect generic = (PlainSelect) CCJSqlParserUtil.parse(sql); + assertEquals(Set.of(modifier), generic.getMySqlSelectModifiers()); + assertNull(generic.getSelectItem(0).getAlias()); + } + + @Test + void combinesDistinctAndDocumentedModifiers() throws Exception { + String sql = "SELECT DISTINCT HIGH_PRIORITY STRAIGHT_JOIN SQL_SMALL_RESULT SQL_BIG_RESULT " + + "SQL_BUFFER_RESULT SQL_NO_CACHE SQL_CALC_FOUND_ROWS a FROM t LIMIT 1"; + PlainSelect select = parse(sql, Dialect.MYSQL); + EnumSet expected = EnumSet.allOf(MySqlSelectModifier.class); + expected.remove(MySqlSelectModifier.SQL_CACHE); + assertEquals(expected, select.getMySqlSelectModifiers()); + assertTrue(select.getMySqlHintStraightJoin()); + assertTrue(select.getMySqlSqlCalcFoundRows()); + assertEquals(MySqlSqlCacheFlags.SQL_NO_CACHE, select.getMySqlSqlCacheFlag()); + assertRoundTrip(select, sql, Dialect.MYSQL); + assertRoundTrip(parse("SELECT ALL HIGH_PRIORITY SQL_BUFFER_RESULT a FROM t", Dialect.MYSQL), + "SELECT HIGH_PRIORITY SQL_BUFFER_RESULT a FROM t", Dialect.MYSQL); + } + + @Test + void acceptsModifiersBeforeAndAfterDistinctOrAll() throws Exception { + for (String sql : List.of( + "SELECT HIGH_PRIORITY DISTINCT SQL_SMALL_RESULT SQL_BUFFER_RESULT SQL_NO_CACHE a FROM t", + "SELECT SQL_SMALL_RESULT HIGH_PRIORITY DISTINCT SQL_BUFFER_RESULT SQL_NO_CACHE a FROM t", + "SELECT DISTINCT HIGH_PRIORITY SQL_SMALL_RESULT SQL_BUFFER_RESULT SQL_NO_CACHE a FROM t")) { + PlainSelect select = parse(sql, Dialect.MYSQL); + assertTrue(select.getDistinct() != null); + assertNull(select.getSelectItem(0).getAlias()); + assertRoundTrip(select, + "SELECT DISTINCT HIGH_PRIORITY SQL_SMALL_RESULT SQL_BUFFER_RESULT SQL_NO_CACHE a FROM t", + Dialect.MYSQL); + } + assertRoundTrip(parse("SELECT SQL_SMALL_RESULT ALL a FROM t", Dialect.MYSQL), + "SELECT SQL_SMALL_RESULT a FROM t", Dialect.MYSQL); + } + + @Test + void preservesLegacyAccessorsAndBuilders() throws Exception { + PlainSelect select = parse("SELECT STRAIGHT_JOIN SQL_CACHE SQL_CALC_FOUND_ROWS a FROM t", + Dialect.MYSQL); + select.setMySqlSqlCacheFlag(MySqlSqlCacheFlags.SQL_NO_CACHE); + assertFalse(select.getMySqlSelectModifiers().contains(MySqlSelectModifier.SQL_CACHE)); + select.setMySqlHintStraightJoin(false); + select.setMySqlSqlCalcFoundRows(false); + assertEquals(Set.of(MySqlSelectModifier.SQL_NO_CACHE), select.getMySqlSelectModifiers()); + select.setMySqlSqlCacheFlag(null); + assertTrue(select.getMySqlSelectModifiers().isEmpty()); + select.withMySqlHintStraightJoin(true).withMySqlSqlCalcFoundRows(true) + .withMySqlSqlNoCache(MySqlSqlCacheFlags.SQL_CACHE) + .addMySqlSelectModifiers(MySqlSelectModifier.HIGH_PRIORITY); + assertRoundTrip(select, + "SELECT HIGH_PRIORITY STRAIGHT_JOIN SQL_CACHE SQL_CALC_FOUND_ROWS a FROM t", + Dialect.MYSQL); + select.setMySqlSelectModifiers(select.getMySqlSelectModifiers()); + assertEquals(4, select.getMySqlSelectModifiers().size()); + select.withMySqlSelectModifiers(Set.of(MySqlSelectModifier.SQL_BIG_RESULT)); + assertFalse(select.getMySqlHintStraightJoin()); + assertFalse(select.getMySqlSqlCalcFoundRows()); + assertNull(select.getMySqlSqlCacheFlag()); + select.setMySqlSelectModifiers(null); + assertTrue(select.getMySqlSelectModifiers().isEmpty()); + select.setMySqlSqlCacheFlag(MySqlSqlCacheFlags.SQL_CACHE); + assertThrows(IllegalArgumentException.class, + () -> select.addMySqlSelectModifiers(MySqlSelectModifier.SQL_NO_CACHE)); + assertEquals(Set.of(MySqlSelectModifier.SQL_CACHE), select.getMySqlSelectModifiers()); + } + + @Test + void keepsOtherDialectAndQuotedOrQualifiedIdentifiers() throws Exception { + for (String modifier : List.of("HIGH_PRIORITY", "SQL_SMALL_RESULT", "SQL_BIG_RESULT", + "SQL_BUFFER_RESULT")) { + for (Dialect dialect : List.of(Dialect.POSTGRESQL, Dialect.ORACLE, Dialect.SQLSERVER)) { + PlainSelect select = parse("SELECT " + modifier + " a FROM t", dialect); + assertTrue(select.getMySqlSelectModifiers().isEmpty()); + assertEquals(modifier, + ((Column) select.getSelectItem(0).getExpression()).getColumnName()); + assertEquals("a", select.getSelectItem(0).getAlias().getName()); + } + for (String expression : List.of("`" + modifier + "`", "t." + modifier, + modifier + ".a")) { + PlainSelect select = parse("SELECT " + expression + " FROM t", Dialect.MYSQL); + assertTrue(select.getMySqlSelectModifiers().isEmpty()); + assertEquals(expression, select.getSelectItem(0).getExpression().toString()); + } + } + PlainSelect identifier = parse("SELECT SQL_BUFFER_RESULT FROM t", Dialect.MYSQL); + assertTrue(identifier.getMySqlSelectModifiers().isEmpty()); + assertEquals("SQL_BUFFER_RESULT", + ((Column) identifier.getSelectItem(0).getExpression()).getColumnName()); + } + + @Test + void visitsAndRewritesActualProjectionWithoutTreatingModifiersAsColumns() throws Exception { + PlainSelect select = parse("SELECT HIGH_PRIORITY SQL_SMALL_RESULT a FROM t", Dialect.MYSQL); + List columns = new ArrayList<>(); + select.accept(new SelectVisitorAdapter(new ExpressionVisitorAdapter() { + @Override + public Void visit(Column column, S context) { + columns.add(column.getColumnName()); + return null; + } + }), null); + assertEquals(List.of("a"), columns); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(Column column, S context) { + return getBuilder().append("renamed_").append(column.getColumnName()); + } + }; + SelectDeParser selects = new SelectDeParser(expressions, output); + expressions.setSelectVisitor(selects); + expressions.setBuilder(output); + select.accept((SelectVisitor) selects, null); + assertEquals("SELECT HIGH_PRIORITY SQL_SMALL_RESULT renamed_a FROM t", output.toString()); + } + + @Test + void keepsNestedQueriesAndStatementBoundaries() throws Exception { + String sql = "SELECT SQL_SMALL_RESULT a FROM " + + "(SELECT SQL_BIG_RESULT a FROM t) s"; + PlainSelect outer = parse(sql, Dialect.MYSQL); + PlainSelect inner = ((ParenthesedSelect) outer.getFromItem()).getPlainSelect(); + assertEquals(Set.of(MySqlSelectModifier.SQL_SMALL_RESULT), outer.getMySqlSelectModifiers()); + assertEquals(Set.of(MySqlSelectModifier.SQL_BIG_RESULT), inner.getMySqlSelectModifiers()); + assertRoundTrip(outer, sql, Dialect.MYSQL); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT HIGH_PRIORITY b FROM u;", + parser -> parser.withDialect(Dialect.MYSQL)).size()); + } + + @Test + void rejectsConflictingCacheModesAndDistinctQualifiers() { + for (String sql : List.of("SELECT SQL_CACHE SQL_NO_CACHE a FROM t", + "SELECT SQL_NO_CACHE SQL_CACHE a FROM t", + "SELECT DISTINCT ALL a FROM t", "SELECT ALL DISTINCT a FROM t", + "SELECT ALL HIGH_PRIORITY DISTINCT a FROM t", + "SELECT HIGH_PRIORITY DISTINCT SQL_SMALL_RESULT ALL a FROM t")) { + assertThrows(JSQLParserException.class, () -> parse(sql, Dialect.MYSQL), sql); + } + } + + private static void assertRoundTrip(PlainSelect select, String expected, Dialect dialect) + throws Exception { + assertEquals(expected, select.toString()); + StringBuilder output = new StringBuilder(); + select.accept(new StatementDeParser(output), null); + assertEquals(expected, output.toString()); + for (String rendered : List.of(select.toString(), output.toString())) { + PlainSelect reparsed = parse(rendered, dialect); + assertEquals(select.getMySqlSelectModifiers(), reparsed.getMySqlSelectModifiers()); + assertEquals(select.getSelectItems().toString(), reparsed.getSelectItems().toString()); + } + TestUtils.assertDeparse(select, expected); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/PostgreSqlSelectFormsTest.java b/src/test/java/net/sf/jsqlparser/statement/select/PostgreSqlSelectFormsTest.java new file mode 100644 index 0000000000..e554b7d05e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/select/PostgreSqlSelectFormsTest.java @@ -0,0 +1,645 @@ +/*- + * #%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.select; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNoErrors; +import static net.sf.jsqlparser.util.validation.ValidationTestAsserts.validateNotAllowed; +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.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.io.BufferedReader; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.AliasedExpression; +import net.sf.jsqlparser.expression.CastExpression; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.TimezoneExpression; +import net.sf.jsqlparser.expression.operators.conditional.AndExpression; +import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression; +import net.sf.jsqlparser.expression.operators.relational.IsNormalizedExpression.NormalForm; +import net.sf.jsqlparser.expression.operators.relational.IsNullExpression; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.Node; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.select.SelectIntoClause.Persistence; +import net.sf.jsqlparser.statement.select.SelectIntoClause.Position; +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.feature.DatabaseType; +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.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * PostgreSQL SELECT forms: SELECT INTO with a persistence, the alias of JOIN USING, AT LOCAL, IS + * NORMALIZED, XMLATTRIBUTES in XMLELEMENT and the set quantifier of GROUP BY. + */ +class PostgreSqlSelectFormsTest { + private static final Consumer POSTGRESQL = + parser -> parser.withDialect(Dialect.POSTGRESQL); + + static Stream statements() throws Exception { + try (BufferedReader reader = new BufferedReader(new InputStreamReader( + PostgreSqlSelectFormsTest.class + .getResourceAsStream("/postgresql/select-forms.sql"), + StandardCharsets.UTF_8))) { + return reader.lines() + .filter(line -> !line.trim().isEmpty() && !line.trim().startsWith("--")) + .map(line -> line.substring(0, line.length() - 1)) + .collect(Collectors.toList()) + .stream(); + } + } + + private static PlainSelect parse(String sql) throws JSQLParserException { + return (PlainSelect) CCJSqlParserUtil.parse(sql, POSTGRESQL); + } + + private static PlainSelect parse(String sql, Dialect dialect) throws JSQLParserException { + return (PlainSelect) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static Expression item(String sql) throws JSQLParserException { + return parse(sql).getSelectItem(0).getExpression(); + } + + private static String deparse(Statement statement) { + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder)); + return builder.toString(); + } + + private static String source(String sql, ASTNodeAccess part) { + Node node = part.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } + + private static void assertRejected(String sql, Consumer consumer) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, consumer), sql); + } + + @ParameterizedTest + @MethodSource("statements") + void testRoundTripWithAndWithoutDialect(String sql) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertEquals(sql, statement.toString()); + assertEquals(sql, deparse(statement)); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), POSTGRESQL).toString()); + + // the forms are not ambiguous, so that they are read without a dialect as well + assertEquals(sql, assertSqlCanBeParsedAndDeparsed(sql).toString()); + validateNoErrors(sql, 1, DatabaseType.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT a, count(*) FROM t GROUP BY ALL a", + "SELECT a, count(*) FROM t GROUP BY DISTINCT a", + "SELECT a, b, count(*) FROM t GROUP BY ALL a, b", + "SELECT a, b, count(*) FROM t GROUP BY DISTINCT ROLLUP(a, b), ROLLUP(a, c)", + "SELECT a, b, count(*) FROM t GROUP BY ALL ROLLUP(a, b)", + "SELECT a, b, count(*) FROM t GROUP BY DISTINCT CUBE(a, b)", + "SELECT a, b, count(*) FROM t GROUP BY ALL GROUPING SETS ((a), (b), ())", + "SELECT a, b, count(*) FROM t GROUP BY DISTINCT GROUPING SETS ((a, b), a, ())", + "SELECT a, b, count(*) FROM t GROUP BY DISTINCT a, ROLLUP(b), CUBE(c)", + "SELECT count(*) FROM t GROUP BY ALL ()", + "SELECT count(*) FROM t GROUP BY DISTINCT ()", + "SELECT a, count(*) FROM t GROUP BY DISTINCT (a)", + "SELECT a, b, count(*) FROM t GROUP BY ALL (a, b)", + "SELECT a, count(*) FROM t GROUP BY ALL a + 1, (a)", + "SELECT a, b, count(*) FROM t GROUP BY DISTINCT a, b HAVING count(*) > 1"}) + void testGroupBySetQuantifierRoundTrips(String sql) throws Exception { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL); + assertEquals(sql, select.toString()); + assertEquals(sql.contains("GROUP BY ALL"), select.getGroupBy().isAll()); + assertEquals(sql.contains("GROUP BY DISTINCT"), select.getGroupBy().isDistinct()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT a, count(*) FROM t GROUP BY ALL", + "SELECT a, count(*) FROM t GROUP BY DISTINCT", + "SELECT a, count(*) FROM t GROUP BY ALL DISTINCT a", + "SELECT a, count(*) FROM t GROUP BY DISTINCT ALL a", + "SELECT a, count(*) FROM t GROUP BY ALL ALL a", + "SELECT a, count(*) FROM t GROUP BY a ALL", + "SELECT a, count(*) FROM t GROUP BY UNIQUE a"}) + void testGroupBySetQuantifierRejected(String sql) { + assertRejected(sql, POSTGRESQL); + } + + @Test + void testSelectIntoPersistence() throws Exception { + for (Persistence persistence : Persistence.values()) { + for (boolean tableKeyword : new boolean[] {false, true}) { + String sql = "SELECT a INTO " + persistence.getKeywords() + + (tableKeyword ? " TABLE" : "") + " sch.t2 FROM t"; + PlainSelect select = parse(sql); + SelectIntoClause into = select.getIntoClause(); + assertEquals(persistence, into.getPersistence(), sql); + assertEquals(tableKeyword, into.isTableKeyword(), sql); + assertEquals(Position.BEFORE_FROM, into.getPosition()); + assertEquals("sch.t2", into.getTable().getFullyQualifiedName()); + assertEquals(persistence != Persistence.UNLOGGED, persistence.isTemporary()); + assertEquals(sql, select.toString()); + assertEquals(sql, deparse(select)); + // legacy views of the clause + assertSame(into.getTables(), select.getIntoTables()); + assertNull(select.getIntoTempTable()); + assertNull(select.getMySqlSelectIntoClause()); + } + } + assertEquals(Persistence.LOCAL_TEMP, Persistence.from("local temp")); + + SelectIntoClause plain = parse("SELECT * INTO TABLE t2 FROM t").getIntoClause(); + assertNull(plain.getPersistence()); + assertTrue(plain.isTableKeyword()); + + // without a name after it the word is the table + for (String name : Arrays.asList("temp", "temporary", "unlogged", "local", "global")) { + SelectIntoClause into = parse("SELECT * INTO " + name + " FROM t").getIntoClause(); + assertNull(into.getPersistence()); + assertEquals(name, into.getTable().getName()); + } + SelectIntoClause schema = parse("SELECT * INTO temp.t2 FROM t").getIntoClause(); + assertNull(schema.getPersistence()); + assertEquals("temp", schema.getTable().getSchemaName()); + + // an empty select list + assertSqlCanBeParsedAndDeparsed("SELECT INTO t2 FROM t", false, POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("SELECT INTO TEMP t2 FROM t", false, POSTGRESQL); + } + + @Test + void testSelectIntoRangeTablesAndFeatures() throws Exception { + String sql = "SELECT a INTO LOCAL TEMP TABLE t2 FROM t WHERE a > 1"; + PlainSelect select = parse(sql); + assertEquals("INTO LOCAL TEMP TABLE t2", source(sql, select.getIntoClause())); + assertThat(new TablesNamesFinder<>().getTables((Statement) select)) + .containsExactlyInAnyOrder("t", "t2"); + assertThat(select.getFeatures().getCertain()) + .contains(StmtFeature.MODIFIES_SCHEMA, StmtFeature.MODIFIES_DATA, + StmtFeature.READS_DATA) + .doesNotContain(StmtFeature.RETURNS_RESULT_SET); + + List visited = new ArrayList<>(); + select.accept((SelectVisitor) new SelectVisitorAdapter( + new ExpressionVisitorAdapter(), new FromItemVisitorAdapter() { + @Override + public Void visit(Table table, S context) { + visited.add(table.getName()); + return null; + } + }), null); + assertThat(visited).containsExactly("t2", "t"); + + validateNotAllowed("SELECT * INTO UNLOGGED t2 FROM t", 1, 1, FeaturesAllowed.SELECT, + Feature.selectInto); + validateNoErrors("SELECT * INTO UNLOGGED t2 FROM t", 1, DatabaseType.POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT * INTO TABLE FROM t", + "SELECT * INTO TEMP TABLE FROM t", + "SELECT * INTO LOCAL TEMP FROM t", + "SELECT * INTO UNLOGGED TEMP t2 FROM t", + "SELECT * INTO TEMP UNLOGGED t2 FROM t", + "SELECT * INTO LOCAL t2 FROM t", + "SELECT * INTO GLOBAL t2 FROM t", + "SELECT * INTO LOCAL UNLOGGED t2 FROM t", + "SELECT * INTO LOCAL TABLE t2 FROM t", + "SELECT * INTO TEMP TEMP t2 FROM t", + "SELECT * INTO TABLE TEMP t2 FROM t", + "SELECT * INTO TEMP t2, t3 FROM t", + "SELECT * INTO TABLE t2, t3 FROM t", + "SELECT * INTO t2, t3 FROM t", + "SELECT * INTO TEMP t2 AS x FROM t", + "SELECT * FROM t INTO TEMP t2", + "SELECT * FROM t INTO t2", + "SELECT * INTO TEMP TABLE t2 TABLE t3 FROM t", + "SELECT * INTO TEMP IF NOT EXISTS t2 FROM t", + "SELECT * INTO TEMP ONLY t2 FROM t", + "SELECT * INTO t2 INTO t3 FROM t"}) + void testSelectIntoRejected(String sql) { + assertRejected(sql, POSTGRESQL); + } + + @Test + void testSelectIntoInOtherDialects() throws Exception { + // the persistence and TABLE keywords belong to PostgreSQL + for (Dialect dialect : Arrays.asList(Dialect.ORACLE, Dialect.MYSQL, Dialect.SQLSERVER)) { + for (String sql : Arrays.asList("SELECT * INTO TEMP t2 FROM t", + "SELECT * INTO UNLOGGED t2 FROM t", "SELECT * INTO LOCAL TEMP t2 FROM t", + "SELECT * INTO TABLE t2 FROM t", "SELECT INTO t2 FROM t")) { + assertRejected(sql, parser -> parser.withDialect(dialect)); + } + SelectIntoClause into = parse("SELECT * INTO temp FROM t", dialect).getIntoClause(); + assertNull(into.getPersistence()); + assertEquals("temp", into.getTable().getName()); + } + + // target lists of other products and procedural languages + for (Consumer consumer : Arrays.>asList( + parser -> { + }, parser -> parser.withDialect(Dialect.ORACLE))) { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT a, b INTO x, y FROM t", false, consumer); + assertThat(select.getIntoTables()).extracting(Table::getName).containsExactly("x", + "y"); + assertSqlCanBeParsedAndDeparsed("SELECT * INTO #tmp FROM t", false, consumer); + } + + // Informix writes INTO TEMP at the end + String informix = "SELECT a FROM t INTO TEMP t2 WITH NO LOG"; + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(informix); + assertEquals(Position.TRAILING, select.getIntoClause().getPosition()); + assertEquals(Persistence.TEMP, select.getIntoClause().getPersistence()); + assertEquals("t2", select.getIntoTempTable().getName()); + assertNull(select.getIntoTables()); + assertEquals("INTO TEMP t2", source(informix, select.getIntoClause())); + assertThat(new TablesNamesFinder<>().getTables((Statement) select)) + .containsExactlyInAnyOrder("t", "t2"); + assertRejected("SELECT a INTO t3 FROM t INTO TEMP t2", parser -> { + }); + assertRejected("SELECT a INTO OUTFILE 'f' FROM t INTO TEMP t2", parser -> { + }); + } + + @Test + void testSelectIntoLegacyAccessors() { + PlainSelect select = new PlainSelect().addSelectItems(new Column("a")) + .withFromItem(new Table("t")); + assertNull(select.getIntoClause()); + assertNull(select.getIntoTables()); + assertNull(select.getIntoTempTable()); + + select.addIntoTables(new Table("x")); + select.addIntoTables(new Table("y")); + assertEquals("SELECT a INTO x, y FROM t", select.toString()); + assertEquals(Position.BEFORE_FROM, select.getIntoClause().getPosition()); + + select.getIntoClause().setPersistence(Persistence.UNLOGGED); + select.setIntoTables(new ArrayList<>(Arrays.asList(new Table("z")))); + assertEquals("SELECT a INTO UNLOGGED z FROM t", select.toString()); + + select.setIntoTempTable(null); + assertEquals("SELECT a INTO UNLOGGED z FROM t", select.toString()); + select.setIntoTables(null); + assertNull(select.getIntoClause()); + + select.withIntoTempTable(new Table("tmp")); + assertEquals("SELECT a FROM t INTO TEMP tmp", select.toString()); + assertNull(select.getIntoTables()); + select.setIntoTables(null); + assertEquals("tmp", select.getIntoTempTable().getName()); + select.setIntoTempTable(null); + assertNull(select.getIntoClause()); + + select.withIntoClause(new SelectIntoClause(new Table("t2")) + .withPersistence(Persistence.GLOBAL_TEMPORARY).withTableKeyword(true)); + assertEquals("SELECT a INTO GLOBAL TEMPORARY TABLE t2 FROM t", select.toString()); + assertEquals("INTO GLOBAL TEMPORARY TABLE t2", select.getIntoClause().toString()); + assertEquals(new SelectIntoClause().withTables(new ArrayList<>()).addTable(new Table("q")) + .withPosition(Position.TRAILING).toString(), "INTO q"); + } + + @Test + void testJoinUsingAlias() throws Exception { + String sql = "SELECT j.id FROM a LEFT JOIN b USING (id, x) AS j JOIN c USING (id)"; + PlainSelect select = parse(sql); + Join join = select.getJoins().get(0); + assertEquals("j", join.getUsingAlias().getName()); + assertThat(join.getUsingColumns()).extracting(Column::getColumnName).containsExactly("id", + "x"); + assertNull(select.getJoins().get(1).getUsingAlias()); + assertEquals("LEFT JOIN b USING (id, x) AS j", source(sql, join)); + assertEquals(" USING (id, x) AS j", join.appendUsingTo(new StringBuilder()).toString()); + assertThat(new TablesNamesFinder<>().getTables((Statement) select)) + .containsExactlyInAnyOrder("a", "b", "c"); + + join.setUsingAlias(null); + assertEquals("SELECT j.id FROM a LEFT JOIN b USING (id, x) JOIN c USING (id)", + select.toString()); + select.getJoins().get(1).withUsingAlias(new Alias("k")); + assertEquals("SELECT j.id FROM a LEFT JOIN b USING (id, x) JOIN c USING (id) AS k", + deparse(select)); + // the alias belongs to the USING columns + assertEquals("", new Join().withUsingAlias(new Alias("k")) + .appendUsingTo(new StringBuilder()).toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT * FROM a JOIN b USING (id) j", + "SELECT * FROM a JOIN b USING (id) AS j (x)", + "SELECT * FROM a JOIN b USING (id) AS", + "SELECT * FROM a JOIN b ON a.id = b.id AS j", + "SELECT * FROM a CROSS JOIN b USING (id) AS j", + "SELECT * FROM a NATURAL JOIN b USING (id) AS j", + "SELECT * FROM a, b USING (id) AS j", + "SELECT * FROM a JOIN b USING (id) AS j AS k", + "SELECT * FROM a JOIN b USING (id) AS j ON true", + "SELECT * FROM a JOIN b USING (id) AS select", + "SELECT * FROM a JOIN b USING (a.id) AS j", + "SELECT * FROM a JOIN b USING () AS j"}) + void testJoinUsingAliasRejected(String sql) { + assertRejected(sql, POSTGRESQL); + assertRejected(sql, parser -> { + }); + } + + @Test + void testAtLocal() throws Exception { + String sql = "SELECT ts AT LOCAL FROM t"; + TimezoneExpression local = (TimezoneExpression) item(sql); + assertTrue(local.isAtLocal()); + assertThat(local.getTimezoneExpressions()).isEmpty(); + assertEquals("ts", local.getLeftExpression().toString()); + assertEquals("ts AT LOCAL", source(sql, local)); + + // AT LOCAL ends a run of zones + sql = "SELECT ts AT TIME ZONE 'UTC' AT TIME ZONE 'CET' AT LOCAL FROM t"; + TimezoneExpression zones = (TimezoneExpression) item(sql); + assertTrue(zones.isAtLocal()); + assertThat(zones.getTimezoneExpressions()).extracting(Object::toString) + .containsExactly("'UTC'", "'CET'"); + assertThat(zones.getTimezoneExpressions()).allMatch(StringValue.class::isInstance); + assertEquals("ts AT TIME ZONE 'UTC' AT TIME ZONE 'CET' AT LOCAL", source(sql, zones)); + + // and a conversion after it applies to the local value + sql = "SELECT ts AT LOCAL AT TIME ZONE 'UTC' AT LOCAL AT LOCAL FROM t"; + TimezoneExpression outer = (TimezoneExpression) item(sql); + assertTrue(outer.isAtLocal()); + assertThat(outer.getTimezoneExpressions()).isEmpty(); + TimezoneExpression middle = (TimezoneExpression) outer.getLeftExpression(); + assertTrue(middle.isAtLocal()); + assertThat(middle.getTimezoneExpressions()).hasSize(1); + assertEquals("ts AT LOCAL AT TIME ZONE 'UTC' AT LOCAL", source(sql, middle)); + TimezoneExpression inner = (TimezoneExpression) middle.getLeftExpression(); + assertTrue(inner.isAtLocal()); + assertEquals("ts AT LOCAL", source(sql, inner)); + + sql = "SELECT ts AT LOCAL::date AT LOCAL FROM t"; + TimezoneExpression afterCast = (TimezoneExpression) item(sql); + CastExpression cast = (CastExpression) afterCast.getLeftExpression(); + assertEquals("ts AT LOCAL::date", source(sql, cast)); + assertTrue(((TimezoneExpression) cast.getLeftExpression()).isAtLocal()); + + TimezoneExpression plain = (TimezoneExpression) item("SELECT ts AT TIME ZONE 'UTC' FROM t"); + assertFalse(plain.isAtLocal()); + assertEquals("ts AT TIME ZONE 'UTC' AT LOCAL", plain.setAtLocal(true).toString()); + assertEquals("now() AT LOCAL", + new TimezoneExpression(new Function().withName("now")).setAtLocal(true) + .toString()); + + // AT and LOCAL stay identifiers + assertEquals("at", parse("SELECT ts at FROM t").getSelectItem(0).getAlias().getName()); + assertSqlCanBeParsedAndDeparsed("SELECT at, local FROM t", false, POSTGRESQL); + assertEquals("ZONE", parse("SELECT ts AT LOCAL ZONE FROM t").getSelectItem(0).getAlias() + .getName()); + + assertThat(new TablesNamesFinder<>() + .getTables( + CCJSqlParserUtil.parse("SELECT (SELECT max(ts) FROM u) AT LOCAL FROM t"))) + .containsExactlyInAnyOrder("t", "u"); + for (Dialect dialect : Arrays.asList(Dialect.ORACLE, Dialect.MYSQL)) { + assertSqlCanBeParsedAndDeparsed("SELECT ts AT LOCAL FROM t", false, + parser -> parser.withDialect(dialect)); + } + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT ts AT LOCAL TIME ZONE 'UTC' FROM t", + "SELECT ts AT TIME LOCAL FROM t", + "SELECT ts AT ZONE 'UTC' FROM t", + "SELECT ts AT LOCAL LOCAL x FROM t"}) + void testAtLocalRejected(String sql) { + assertRejected(sql, POSTGRESQL); + } + + @Test + void testIsNormalized() throws Exception { + for (boolean not : new boolean[] {false, true}) { + List forms = new ArrayList<>(Arrays.asList(NormalForm.values())); + forms.add(null); + for (NormalForm form : forms) { + String sql = "SELECT s IS " + (not ? "NOT " : "") + + (form == null ? "" : form + " ") + "NORMALIZED FROM t"; + IsNormalizedExpression test = (IsNormalizedExpression) item(sql); + assertEquals(not, test.isNot(), sql); + assertEquals(form, test.getNormalForm(), sql); + assertEquals("s", test.getLeftExpression(Column.class).getColumnName()); + assertEquals(sql.substring(7, sql.length() - 7), source(sql, test)); + assertEquals(sql, deparse(parse(sql))); + } + } + assertEquals(NormalForm.NFKD, + ((IsNormalizedExpression) item("SELECT s is nfkd normalized FROM t")) + .getNormalForm()); + assertTrue(NormalForm.isNormalForm("nfc")); + assertFalse(NormalForm.isNormalForm("nfx")); + + // the test takes the whole operand and chains like the other IS tests + String sql = "SELECT s || 'x' IS NFKC NORMALIZED IS NOT TRUE FROM t"; + IsBooleanExpression chained = (IsBooleanExpression) item(sql); + IsNormalizedExpression test = (IsNormalizedExpression) chained.getLeftExpression(); + assertEquals("s || 'x'", test.getLeftExpression().toString()); + assertEquals("s || 'x' IS NFKC NORMALIZED", source(sql, test)); + + IsNormalizedExpression afterNull = + (IsNormalizedExpression) item("SELECT s IS NOT NULL IS NORMALIZED FROM t"); + assertThat(afterNull.getLeftExpression()).isInstanceOf(IsNullExpression.class); + + AndExpression and = (AndExpression) parse( + "SELECT * FROM t WHERE s IS NFD NORMALIZED AND u IS NOT NORMALIZED").getWhere(); + assertThat(and.getLeftExpression()).isInstanceOf(IsNormalizedExpression.class); + assertThat(and.getRightExpression()).isInstanceOf(IsNormalizedExpression.class); + + assertEquals("'a' IS NOT NFD NORMALIZED", new IsNormalizedExpression(new StringValue("a")) + .withNot(true).withNormalForm(NormalForm.NFD).toString()); + assertEquals("b IS NORMALIZED", + new IsNormalizedExpression().withLeftExpression(new Column("b")).toString()); + + // the words stay identifiers + assertSqlCanBeParsedAndDeparsed("SELECT nfc, nfd, nfkc, nfkd, normalized FROM normalized", + false, POSTGRESQL); + assertEquals("NFC", parse("SELECT s IS NORMALIZED NFC FROM t").getSelectItem(0).getAlias() + .getName()); + for (Dialect dialect : Arrays.asList(Dialect.ORACLE, Dialect.MYSQL)) { + assertSqlCanBeParsedAndDeparsed("SELECT s IS NOT NFC NORMALIZED FROM t", false, + parser -> parser.withDialect(dialect)); + } + } + + @Test + void testIsNormalizedVisitors() throws Exception { + String sql = "SELECT (SELECT max(s) FROM u) IS NFC NORMALIZED FROM t"; + PlainSelect select = parse(sql); + assertThat(new TablesNamesFinder<>().getTables((Statement) select)) + .containsExactlyInAnyOrder("t", "u"); + + List columns = new ArrayList<>(); + ExpressionVisitorAdapter adapter = new ExpressionVisitorAdapter() { + @Override + public Void visit(Column column, S context) { + columns.add(column.getColumnName()); + return null; + } + }; + Expression test = item("SELECT s IS NORMALIZED FROM t"); + test.accept(adapter, null); + adapter.visit((IsNormalizedExpression) test); + assertThat(columns).containsExactly("s", "s"); + + StringBuilder builder = new StringBuilder(); + ExpressionDeParser expressionDeParser = new ExpressionDeParser() { + @Override + public StringBuilder visit(Column column, S context) { + return builder.append('<').append(column.getColumnName()).append('>'); + } + }; + SelectDeParser selectDeParser = new SelectDeParser(expressionDeParser, builder); + expressionDeParser.setSelectVisitor(selectDeParser); + expressionDeParser.setBuilder(builder); + parse("SELECT s IS NOT NFD NORMALIZED, ts AT TIME ZONE z AT LOCAL FROM t") + .accept((SelectVisitor) selectDeParser, null); + assertEquals("SELECT IS NOT NFD NORMALIZED, AT TIME ZONE AT LOCAL FROM t", + builder.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT s IS NFX NORMALIZED FROM t", + "SELECT s IS NFC FROM t", + "SELECT s IS NFC NOT NORMALIZED FROM t", + "SELECT s IS NOT NOT NORMALIZED FROM t", + "SELECT s IS 'NFC' NORMALIZED FROM t", + "SELECT s IS NFC NFD NORMALIZED FROM t", + "SELECT s NOT IS NORMALIZED FROM t", + "SELECT s IS \"NFC\" NORMALIZED FROM t"}) + void testIsNormalizedRejected(String sql) { + assertRejected(sql, POSTGRESQL); + assertRejected(sql, parser -> { + }); + } + + @Test + void testXmlAttributes() throws Exception { + String sql = "SELECT xmlelement(name foo, xmlattributes(a AS x, t.b, a + 1 AS \"y z\")," + + " 'content', s) FROM t"; + Function element = (Function) item(sql); + assertEquals("name", element.getExtraKeyword()); + assertThat(element.getParameters()).hasSize(4); + assertEquals("foo", element.getParameters().get(0).toString()); + Function attributes = (Function) element.getParameters().get(1); + assertEquals("xmlattributes", attributes.getName()); + assertEquals("xmlattributes(a AS x, t.b, a + 1 AS \"y z\")", source(sql, attributes)); + AliasedExpression first = (AliasedExpression) attributes.getParameters().get(0); + assertEquals("x", first.getAlias().getName()); + assertEquals("a", first.getExpression().toString()); + assertThat(attributes.getParameters().get(1)).isInstanceOf(Column.class); + assertEquals("\"y z\"", + ((AliasedExpression) attributes.getParameters().get(2)).getAlias().getName()); + assertEquals("a AS x", source(sql, first)); + + sql = "SELECT xmlelement(name a, xmlattributes((SELECT max(c) FROM u) AS m)," + + " xmlelement(name b, xmlattributes(v.d AS n))) FROM t, v"; + assertThat(new TablesNamesFinder<>().getTables(CCJSqlParserUtil.parse(sql, POSTGRESQL))) + .containsExactlyInAnyOrder("t", "u", "v"); + + // other products write the element name without NAME + for (Consumer consumer : Arrays.>asList( + parser -> { + }, parser -> parser.withDialect(Dialect.ORACLE))) { + assertSqlCanBeParsedAndDeparsed( + "SELECT XMLELEMENT(\"Emp\", XMLATTRIBUTES(e.id AS \"id\"), e.name) FROM e", + false, consumer); + } + // the content and the plain function call are read as before + assertSqlCanBeParsedAndDeparsed("SELECT xmlelement(name foo, s, a) FROM t", false, + POSTGRESQL); + assertSqlCanBeParsedAndDeparsed("SELECT xmlforest(a AS x, b) FROM t", false, POSTGRESQL); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT xmlelement(name foo, xmlattributes()) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a x)) FROM t", + "SELECT xmlelement(name foo, 'content', xmlattributes(a AS x)) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a AS x), xmlattributes(b AS y)) FROM t", + "SELECT xmlelement(foo, xmlattributes(a AS x)) FROM t", + "SELECT xmlelement(name 'foo', xmlattributes(a AS x)) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a AS 'x')) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a AS x.y)) FROM t", + "SELECT xmlattributes(a AS x) FROM t", + "SELECT xmlelement(name foo xmlattributes(a AS x)) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a AS x),) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a AS x), b AS y) FROM t", + "SELECT xmlelement(name foo, xmlattributes(DISTINCT a AS x)) FROM t", + "SELECT xmlelement(name foo, xmlattributes(a AS x) ORDER BY a) FROM t", + "SELECT xmlelement(name foo, s AS x) FROM t"}) + void testXmlAttributesRejected(String sql) { + assertRejected(sql, POSTGRESQL); + } + + @Test + void testStatementBoundaries() throws Exception { + String script = "SELECT * INTO TEMP t2 FROM t; SELECT * FROM a JOIN b USING (id) AS j;" + + " SELECT ts AT LOCAL; SELECT s IS NFC NORMALIZED FROM t;" + + " SELECT xmlelement(name foo, xmlattributes(a AS x)) FROM t;" + + " SELECT a FROM t GROUP BY ALL a; SELECT 1"; + Statements statements = CCJSqlParserUtil.parseStatements(script, POSTGRESQL); + assertThat(statements).hasSize(7).allMatch(PlainSelect.class::isInstance); + assertEquals(script + ";", statements.toString().trim().replace(";\n", "; ")); + assertEquals(Persistence.TEMP, + ((PlainSelect) statements.get(0)).getIntoClause().getPersistence()); + assertNull(((PlainSelect) statements.get(6)).getIntoClause()); + } + + @ParameterizedTest + @EnumSource(value = Dialect.class, names = {"ORACLE", "MYSQL", "SQLSERVER"}) + void testEmptySelectListIntoBelongsToPostgreSql(Dialect dialect) { + assertRejected("SELECT INTO t2 FROM t", parser -> parser.withDialect(dialect)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SQLiteTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SQLiteTest.java index ecb1204956..2bbac7513e 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/SQLiteTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/SQLiteTest.java @@ -10,8 +10,26 @@ package net.sf.jsqlparser.statement.select; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.TableOption; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.insert.InsertConflictAlgorithm; +import net.sf.jsqlparser.statement.update.Update; +import net.sf.jsqlparser.statement.update.UpdateConflictAlgorithm; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.List; +import java.util.Locale; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; public class SQLiteTest { @Test @@ -19,4 +37,119 @@ void testInsertOrReplaceUpsert() throws JSQLParserException { String sqlString = "INSERT OR REPLACE INTO kjobLocks VALUES (?, ?, ?)"; TestUtils.assertSqlCanBeParsedAndDeparsed(sqlString, true); } + + @ParameterizedTest + @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}) + void testInsertOrConflictAlgorithm(String algorithm) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed( + "INSERT OR " + algorithm + " INTO t (a, b) VALUES (1, 2)", true, + parser -> parser.withDialect(Dialect.SQLITE)); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "insert or " + algorithm.toLowerCase(Locale.ROOT) + " into t select * from s", true, + parser -> parser.withDialect(Dialect.SQLITE)); + } + + @ParameterizedTest + @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}) + void testInsertOrConflictAlgorithmIsAnInsert(String algorithm) throws JSQLParserException { + Insert insert = (Insert) TestUtils.assertSqlCanBeParsedAndDeparsed( + "INSERT OR " + algorithm + " INTO t (a) VALUES (1)", true, + parser -> parser.withDialect(Dialect.SQLITE)); + assertEquals(InsertConflictAlgorithm.fromAlgorithm(algorithm), + insert.getConflictAlgorithm()); + } + + // The OR-form keeps the clauses the plain INSERT production reads, which the separate + // Upsert() production never had: SQLite accepts INSERT OR IGNORE with ON CONFLICT and + // RETURNING, and REPLACE is only the REPLACE algorithm without the OR. + @ParameterizedTest + @ValueSource(strings = { + "INSERT OR IGNORE INTO t (a) VALUES (1) ON CONFLICT DO NOTHING", + "INSERT OR IGNORE INTO t (a) VALUES (1) ON CONFLICT (a) DO UPDATE SET a = 2", + "INSERT OR IGNORE INTO t (a) VALUES (1) RETURNING a", + "INSERT OR IGNORE INTO t DEFAULT VALUES", + "INSERT OR IGNORE INTO t AS alias VALUES (1)", + "INSERT OR REPLACE INTO t (a) VALUES (1) RETURNING a"}) + void testInsertOrKeepsTheInsertClauses(String sql) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(Dialect.SQLITE)); + } + + @Test + void testInsertOrKeepsTheOptionalInto() throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed("INSERT OR IGNORE t VALUES (1)", true, + parser -> parser.withDialect(Dialect.SQLITE)); + } + + @ParameterizedTest + @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "ROLLBACK"}) + void testInsertOrConflictAlgorithmNeedsSqliteDialect(String algorithm) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("INSERT OR " + algorithm + " INTO t VALUES (1)")); + } + + @Test + void testInsertOrUnknownAlgorithm() { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("INSERT OR NOTHING INTO t VALUES (1)", + parser -> parser.withDialect(Dialect.SQLITE))); + } + + @ParameterizedTest + @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}) + void testUpdateOrConflictAlgorithm(String algorithm) throws JSQLParserException { + Update update = (Update) TestUtils.assertSqlCanBeParsedAndDeparsed( + "UPDATE OR " + algorithm + " t SET a = 1, b = 2 WHERE c = 3", true, + parser -> parser.withDialect(Dialect.SQLITE)); + assertEquals(UpdateConflictAlgorithm.valueOf(algorithm), update.getConflictAlgorithm()); + + TestUtils.assertSqlCanBeParsedAndDeparsed( + "update or " + algorithm.toLowerCase(Locale.ROOT) + " t set a = 1", true, + parser -> parser.withDialect(Dialect.SQLITE)); + } + + // A parser without any UPDATE OR support throws here too: these cases pin the SQLITE + // dialect guard, they do not show that UPDATE OR parses. + @ParameterizedTest + @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"}) + void testUpdateOrConflictAlgorithmNeedsSqliteDialect(String algorithm) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("UPDATE OR " + algorithm + " t SET a = 1")); + } + + // A parser without any UPDATE OR support throws here too: this case pins the check of the + // word after OR, it does not show that UPDATE OR parses. + @Test + void testUpdateOrUnknownAlgorithm() { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse("UPDATE OR NOTHING t SET a = 1", + parser -> parser.withDialect(Dialect.SQLITE))); + } + + @Test + void testUpdateWithoutConflictAlgorithm() throws JSQLParserException { + Update update = (Update) TestUtils.assertSqlCanBeParsedAndDeparsed( + "UPDATE t SET a = 1", true, parser -> parser.withDialect(Dialect.SQLITE)); + assertNull(update.getConflictAlgorithm()); + } + + @ParameterizedTest + @ValueSource(strings = { + "CREATE TABLE t (a INTEGER PRIMARY KEY, b TEXT) WITHOUT ROWID", + "CREATE TABLE t (a INTEGER PRIMARY KEY, b TEXT) STRICT", + "CREATE TABLE t (a INTEGER PRIMARY KEY, b BLOB) STRICT, WITHOUT ROWID", + "CREATE TABLE t (a INTEGER PRIMARY KEY, b TEXT) WITHOUT ROWID, STRICT", + "create table t (a integer primary key) without rowid"}) + void testCreateTableWithoutRowidAndStrict(String sql) throws JSQLParserException { + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true); + } + + @Test + void testCreateTableOptionKinds() throws JSQLParserException { + CreateTable createTable = (CreateTable) CCJSqlParserUtil.parse( + "CREATE TABLE t (a INTEGER PRIMARY KEY) STRICT, WITHOUT ROWID"); + assertEquals(List.of(TableOption.Kind.STRICT, TableOption.Kind.WITHOUT_ROWID), + createTable.getTableOptions().stream().map(TableOption::getKind) + .collect(Collectors.toList())); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SelectASTTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SelectASTTest.java index 5fd6a79301..f46c1a2384 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/SelectASTTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/SelectASTTest.java @@ -12,6 +12,7 @@ import java.util.ArrayList; import java.util.List; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.BinaryExpression; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.expression.operators.conditional.AndExpression; import net.sf.jsqlparser.parser.ASTNodeAccess; @@ -203,6 +204,27 @@ public void testBinaryConditionNodeStartsAtItsLeftOperand() throws JSQLParserExc } } + @Test + public void testOperatorExpressionNodeSpansItsOperands() throws JSQLParserException { + String sql = "SELECT a - 1 - 2, 1 + 2 * 3, a | | b FROM t WHERE d > CURRENT_DATE - 7"; + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql); + BinaryExpression chain = (BinaryExpression) select.getSelectItem(0).getExpression(); + BinaryExpression precedence = (BinaryExpression) select.getSelectItem(1).getExpression(); + + assertEquals("a - 1 - 2", source(sql, chain)); + assertEquals("a - 1", source(sql, chain.getLeftExpression())); + assertEquals("2 * 3", source(sql, precedence.getRightExpression())); + assertEquals("a | | b", source(sql, select.getSelectItem(2).getExpression())); + assertEquals("CURRENT_DATE - 7", + source(sql, ((BinaryExpression) select.getWhere()).getRightExpression())); + } + + private static String source(String sql, Expression expression) { + Node node = expression.getASTNode(); + return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1, + node.jjtGetLastToken().absoluteEnd - 1); + } + @Test public void testSelectASTExtractWithCommentsIssue1580() throws JSQLParserException { String sql = diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java index bb3fa06562..e36c6d9d0f 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/SelectTest.java @@ -91,6 +91,8 @@ @Execution(ExecutionMode.CONCURRENT) public class SelectTest { + private static final String LONG_CONDITION = "B = 1 AND ".repeat(150) + "B = 1"; + private final CCJSqlParserManager parserManager = new CCJSqlParserManager(); @Test @@ -1004,7 +1006,8 @@ public void testUnion() throws JSQLParserException { assertEquals("mytable2", ((Table) ((PlainSelect) setList.getSelects().get(2)).getFromItem()).getName()); assertEquals(3, - ((LongValue) setList.getSelects().get(2).getLimit().getOffset()).getValue()); + ((LongValue) setList.getLimit().getOffset()).getValue()); + assertNull(setList.getSelects().get(2).getLimit()); // with fetch and with ur @@ -1042,11 +1045,13 @@ public void testUnion2() throws JSQLParserException { assertEquals("mytable2", ((Table) ((PlainSelect) setList.getSelects().get(2)).getFromItem()).getName()); assertEquals(3, - ((LongValue) setList.getSelects().get(2).getLimit().getRowCount()) + ((LongValue) setList.getLimit().getRowCount()) .getValue()); - assertNull(setList.getSelects().get(2).getLimit().getOffset()); + assertNull(setList.getLimit().getOffset()); assertEquals(new LongValue(4), - setList.getSelects().get(2).getOffset().getOffset()); + setList.getOffset().getOffset()); + assertNull(setList.getSelects().get(2).getLimit()); + assertNull(setList.getSelects().get(2).getOffset()); } @@ -2383,6 +2388,45 @@ public void testIsNotFalse() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed(statement); } + @Test + public void testBooleanTestAfterPredicate() throws JSQLParserException { + // SQL:2016 6.39: a boolean test applies to any boolean primary, so an + // IS TRUE/FALSE test chains onto a comparison or predicate result + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t WHERE a > 0 IS TRUE"); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t WHERE a IN (1, 2) IS FALSE"); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t WHERE a IS NULL IS NOT TRUE"); + assertSqlCanBeParsedAndDeparsed("SELECT * FROM t WHERE a IS TRUE IS FALSE"); + } + + @Test + public void testSelectWithoutTargetListPostgreSql() throws JSQLParserException { + // PostgreSQL permits SELECT with no target expressions + Statement stmt = CCJSqlParserUtil.parse( + "SELECT FROM t", parser -> parser.withDialect(Dialect.POSTGRESQL)); + PlainSelect select = (PlainSelect) ((Select) stmt).getSelectBody(); + assertTrue(select.getSelectItems().isEmpty()); + assertDeparse(select, "SELECT FROM t"); + + // the reported case: empty target list inside a derived table + assertSqlCanBeParsedAndDeparsed( + "SELECT count(*) FROM (SELECT FROM (VALUES (1, 'a'), (2, 'b')) AS t(id, label)) AS q", + false, parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + @Test + public void testGroupByAllDistinctPostgreSql() throws JSQLParserException { + // PostgreSQL: GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] + assertSqlCanBeParsedAndDeparsed( + "SELECT 1 GROUP BY DISTINCT GROUPING SETS ((1), (1))", + false, parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertSqlCanBeParsedAndDeparsed( + "SELECT 1 GROUP BY ALL GROUPING SETS ((1), (2))", + false, parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertSqlCanBeParsedAndDeparsed( + "SELECT a FROM t GROUP BY DISTINCT a", + false, parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + @Test public void testIsUnknown() throws JSQLParserException { String statement = "SELECT col FROM tbl WHERE col IS UNKNOWN"; @@ -2684,6 +2728,13 @@ public void testLateral1() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed(stmt); } + @Test + public void testParenthesedLateral() throws JSQLParserException { + String stmt = + "SELECT O.ORDERID, O.CUSTNAME, OL.LINETOTAL FROM ORDERS AS O, (LATERAL(SELECT SUM(NETAMT) AS LINETOTAL FROM ORDERLINES AS LINES WHERE LINES.ORDERID = O.ORDERID)) AS OL"; + assertSqlCanBeParsedAndDeparsed(stmt); + } + @Test public void testLateralComplex1() throws IOException, JSQLParserException { String stmt = IOUtils.toString( @@ -5359,6 +5410,18 @@ public void testSetOperationWithParenthesisIssue1094() throws JSQLParserExceptio "SELECT * FROM ((SELECT A FROM tbl) UNION DISTINCT (SELECT B FROM tbl2)) AS union1"); } + @Test + public void testSetOperationWithParenthesisAndLongFirstBranch() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT * FROM ((SELECT A FROM tbl WHERE " + LONG_CONDITION + + ") UNION ALL (SELECT A FROM tbl2)) AS union1"); + } + + @Test + public void testSetOperationInExpressionWithLongFirstBranch() throws JSQLParserException { + assertSqlCanBeParsedAndDeparsed("SELECT * FROM tbl WHERE A IN ((SELECT A FROM tbl2 WHERE " + + LONG_CONDITION + ") UNION ALL (SELECT A FROM tbl3))"); + } + @Test public void testSetOperationWithParenthesisIssue1094_2() throws JSQLParserException { String sqlStr = @@ -6662,4 +6725,43 @@ void testClickHouseArrayJoin() throws Exception { Assertions.assertFalse(joinInner.isLeft(), "Should not be a left join"); } + @Test + void testQuotedIdentifierContainingNewline() throws Exception { + // the newline is part of the identifier and must survive parse and deparse unchanged + String sql = "SELECT \"Planned/\nUnplanned\" FROM t"; + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true); + + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql); + Column column = (Column) select.getSelectItem(0).getExpression(); + Assertions.assertEquals("\"Planned/\nUnplanned\"", column.getColumnName()); + } + + @Test + void testSnowflakeArrayCastOnVariantPathInFlatten() throws Exception { + String sql = "CREATE OR REPLACE TABLE \"DB\".\"S\".\"T\" COPY GRANTS\n" + + "AS (SELECT * FROM (WITH flattened_users AS (\n" + + " SELECT user.value:subscription_groups::ARRAY AS SUBSCRIPTION_GROUPS\n" + + " FROM (SELECT \"DATA_VALUE\" FROM \"DB\".\"L\".\"STG\"),\n" + + " LATERAL FLATTEN(input => DATA_VALUE:users) user\n" + + ")\n" + + "SELECT * FROM flattened_users))"; + TestUtils.assertSqlCanBeParsedAndDeparsed(sql, true); + } + + @Test + void testSnowflakeArrayCastShapes() throws Exception { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT x::ARRAY FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT x:y::ARRAY FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT CAST(x AS ARRAY) FROM t", true); + } + + @Test + void testSnowflakeCastsAndLateralFlattenRegression() throws Exception { + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT x::INT ARRAY FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT x:y::VARIANT FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT x:y::OBJECT FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT x:y::STRING FROM t", true); + TestUtils.assertSqlCanBeParsedAndDeparsed( + "SELECT user.value FROM t, LATERAL FLATTEN(input => t.data:users) user", true); + } } diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SetOperationLimitTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SetOperationLimitTest.java new file mode 100644 index 0000000000..28bc2a8cde --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/select/SetOperationLimitTest.java @@ -0,0 +1,201 @@ +/*- + * #%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.select; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.*; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class SetOperationLimitTest { + + @ParameterizedTest + @MethodSource("globalLimitCases") + void trailingLimitBelongsToSetOperation(String sql, String rowCount, String limitOffset, + String offset) throws JSQLParserException { + SetOperationList select = (SetOperationList) assertSqlCanBeParsedAndDeparsed(sql); + assertNotNull(select.getLimit(), sql); + assertEquals(rowCount, select.getLimit().getRowCount().toString()); + assertEquals(limitOffset, select.getLimit().getOffset() == null ? null + : select.getLimit().getOffset().toString()); + assertEquals(offset, select.getOffset() == null ? null + : select.getOffset().getOffset().toString()); + Select last = select.getSelects().get(select.getSelects().size() - 1); + assertNull(last.getLimit()); + assertNull(last.getOffset()); + if (sql.contains("ORDER BY")) { + assertNotNull(select.getOrderByElements()); + assertEquals(1, select.getOrderByElements().size()); + assertNull(last.getOrderByElements()); + } + } + + static Stream globalLimitCases() { + return Stream.of( + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT 1", "1", null, null), + Arguments.of("SELECT a FROM t1 UNION ALL SELECT b FROM t2 LIMIT 1", "1", null, + null), + Arguments.of("SELECT a FROM t1 INTERSECT SELECT b FROM t2 LIMIT 1", "1", null, + null), + Arguments.of("SELECT a FROM t1 EXCEPT SELECT b FROM t2 LIMIT 1", "1", null, null), + Arguments.of("SELECT a FROM t1 MINUS SELECT b FROM t2 LIMIT 1", "1", null, null), + Arguments.of("SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 LIMIT 1", "1", null, + null), + Arguments.of("WITH t AS (SELECT 1 AS a) SELECT a FROM t UNION SELECT 2 LIMIT 1", + "1", null, null), + Arguments.of("SELECT a FROM t1 UNION (SELECT b FROM t2) LIMIT 1", "1", null, null), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 ORDER BY b LIMIT 1", "1", + null, null), + Arguments.of( + "SELECT id FROM table1 UNION SELECT id FROM table2 ORDER BY id ASC LIMIT 55", + "55", null, null), + Arguments.of( + "SELECT * FROM table1 UNION SELECT * FROM table2 ORDER BY col LIMIT 4 OFFSET 5", + "4", null, "5"), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT (1 + 2)", "(1 + 2)", + null, null), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT ? OFFSET ?", "?", null, + "?"), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT :cap OFFSET :skip", + ":cap", null, ":skip"), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT ALL OFFSET 2", "ALL", + null, "2"), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT NULL", "NULL", null, + null), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT 2, 3", "3", "2", null), + Arguments.of("SELECT a FROM t1 UNION SELECT b FROM t2 LIMIT 3 OFFSET 2", "3", null, + "2")); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT a FROM t1 UNION SELECT b FROM t2 OFFSET 2", + "SELECT a FROM t1 UNION SELECT b FROM t2 OFFSET 2 ROWS FETCH NEXT 1 ROWS ONLY", + "SELECT a FROM t1 UNION SELECT b FROM t2 ORDER BY b OFFSET 2 ROWS FETCH NEXT 1 ROWS ONLY" + }) + void trailingOffsetBelongsToSetOperation(String sql) throws JSQLParserException { + SetOperationList select = (SetOperationList) assertSqlCanBeParsedAndDeparsed(sql); + assertNotNull(select.getOffset()); + assertEquals(new LongValue(2), select.getOffset().getOffset()); + assertNull(select.getSelects().get(1).getOffset()); + if (sql.contains("FETCH")) { + assertEquals(1, select.getFetch().getRowCount()); + assertNull(select.getSelects().get(1).getFetch()); + } + } + + @Test + void fetchWithoutOffsetStillBelongsToSetOperation() throws JSQLParserException { + SetOperationList select = (SetOperationList) assertSqlCanBeParsedAndDeparsed( + "SELECT a FROM t1 UNION SELECT b FROM t2 FETCH FIRST 1 ROWS ONLY"); + assertEquals(1, select.getFetch().getRowCount()); + assertNull(select.getSelects().get(1).getFetch()); + } + + @Test + void plainSelectKeepsItsLimitAndOffset() throws JSQLParserException { + PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed( + "SELECT a FROM t LIMIT 1 OFFSET 2"); + assertEquals(new LongValue(1), select.getLimit().getRowCount()); + assertEquals(new LongValue(2), select.getOffset().getOffset()); + } + + @ParameterizedTest + @ValueSource(strings = {"LIMIT 1", "LIMIT 1 OFFSET 2", "ORDER BY b LIMIT 1 OFFSET 2", + "OFFSET 2 ROWS FETCH FIRST 1 ROWS ONLY"}) + void parenthesizedBranchKeepsItsOwnClauses(String clauses) throws JSQLParserException { + SetOperationList select = (SetOperationList) assertSqlCanBeParsedAndDeparsed( + "SELECT a FROM t1 UNION (SELECT b FROM t2 " + clauses + ")"); + assertNull(select.getLimit()); + assertNull(select.getOffset()); + assertNull(select.getFetch()); + assertNull(select.getOrderByElements()); + PlainSelect branch = ((ParenthesedSelect) select.getSelects().get(1)).getPlainSelect(); + assertEquals("SELECT b FROM t2 " + clauses, branch.toString()); + if (clauses.contains("LIMIT")) { + assertEquals(new LongValue(1), branch.getLimit().getRowCount()); + } + if (clauses.contains("OFFSET")) { + assertEquals(new LongValue(2), branch.getOffset().getOffset()); + } + if (clauses.contains("FETCH")) { + assertEquals(1, branch.getFetch().getRowCount()); + } + } + + @Test + void branchAndSetOperationCanBothHaveLimits() throws JSQLParserException { + SetOperationList select = (SetOperationList) assertSqlCanBeParsedAndDeparsed( + "(SELECT 1 LIMIT 1) UNION ALL (SELECT 2 LIMIT 2 OFFSET 1) LIMIT 3 OFFSET 4"); + assertEquals(new LongValue(3), select.getLimit().getRowCount()); + assertEquals(new LongValue(4), select.getOffset().getOffset()); + assertEquals(new LongValue(1), + ((ParenthesedSelect) select.getSelects().get(0)).getSelect().getLimit() + .getRowCount()); + Select last = ((ParenthesedSelect) select.getSelects().get(1)).getSelect(); + assertEquals(new LongValue(2), last.getLimit().getRowCount()); + assertEquals(new LongValue(1), last.getOffset().getOffset()); + } + + @Test + void nestedSetOperationLimitsStayInTheirOwnScope() throws JSQLParserException { + SetOperationList select = (SetOperationList) assertSqlCanBeParsedAndDeparsed( + "SELECT 1 UNION ALL (SELECT 2 UNION ALL SELECT 3 LIMIT 1) LIMIT 2"); + assertEquals(new LongValue(2), select.getLimit().getRowCount()); + SetOperationList inner = + ((ParenthesedSelect) select.getSelects().get(1)).getSetOperationList(); + assertEquals(new LongValue(1), inner.getLimit().getRowCount()); + assertNull(inner.getSelects().get(1).getLimit()); + } + + @Test + void rewritingGlobalLimitChangesWholeResult() throws Exception { + SetOperationList select = (SetOperationList) CCJSqlParserUtil.parse( + "SELECT 1 UNION ALL SELECT 2 LIMIT 1"); + assertEquals(1, rowCount(select.toString())); + assertNotNull(select.getLimit()); + select.getLimit().setRowCount(new LongValue(0)); + assertEquals(0, rowCount(select.toString())); + } + + @Test + void rewritingLocalLimitKeepsOtherBranchRows() throws Exception { + SetOperationList select = (SetOperationList) CCJSqlParserUtil.parse( + "SELECT 1 UNION ALL (SELECT 2 LIMIT 1)"); + assertEquals(2, rowCount(select.toString())); + Select branch = ((ParenthesedSelect) select.getSelects().get(1)).getSelect(); + branch.getLimit().setRowCount(new LongValue(0)); + assertNull(select.getLimit()); + assertEquals(1, rowCount(select.toString())); + } + + private static int rowCount(String sql) throws Exception { + try (Connection connection = DriverManager.getConnection("jdbc:h2:mem:"); + java.sql.Statement statement = connection.createStatement(); + ResultSet resultSet = statement.executeQuery(sql)) { + int count = 0; + while (resultSet.next()) { + count++; + } + return count; + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SpecialOracleTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SpecialOracleTest.java index 2650c5cd1a..3f74c7a4d0 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/SpecialOracleTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/SpecialOracleTest.java @@ -82,7 +82,8 @@ public class SpecialOracleTest { "condition07.sql", "condition08.sql", "condition09.sql", "condition10.sql", "condition11.sql", "condition12.sql", - "condition14.sql", "condition15.sql", "condition19.sql", "condition20.sql", + "condition14.sql", "condition15.sql", "condition17.sql", "condition18.sql", + "condition19.sql", "condition20.sql", "connect_by01.sql", "connect_by02.sql", "connect_by03.sql", "connect_by04.sql", "connect_by05.sql", "connect_by06.sql", "connect_by07.sql", "connect_by08.sql", "connect_by09.sql", "connect_by10.sql", "datetime01.sql", diff --git a/src/test/java/net/sf/jsqlparser/statement/select/TableFunctionTest.java b/src/test/java/net/sf/jsqlparser/statement/select/TableFunctionTest.java index 3187e046c7..c39f2f0c89 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/TableFunctionTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/TableFunctionTest.java @@ -33,6 +33,19 @@ void testLateralFlat() throws JSQLParserException { TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + /** + * A LATERAL item may be wrapped in parentheses, in which case it is a parenthesed FROM item + * whose content happens to be lateral, not a bare LateralSubSelect. + */ + @Test + void testParenthesedLateralFlat() throws JSQLParserException { + String sqlStr = "SELECT DIM, count(value) AS COUNT_\n" + + "FROM t a,\n" + + "(LATERAL FLATTEN(input => a.user_items)) b\n" + + "group by 1"; + TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); + } + /** * The SQL keyword "OUTER" is a valid parameter name for Snowflake's FLATTEN table function. */ diff --git a/src/test/java/net/sf/jsqlparser/statement/show/MySqlShowStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/show/MySqlShowStatementTest.java new file mode 100644 index 0000000000..688884e398 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/show/MySqlShowStatementTest.java @@ -0,0 +1,826 @@ +/*- + * #%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.show; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.Arrays; +import java.util.EnumSet; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.DoubleValue; +import net.sf.jsqlparser.expression.JdbcParameter; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.expression.operators.conditional.OrExpression; +import net.sf.jsqlparser.parser.ASTNodeAccess; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.IfElseStatement; +import net.sf.jsqlparser.statement.ShowStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.statement.select.Limit; +import net.sf.jsqlparser.statement.select.Offset; +import net.sf.jsqlparser.statement.show.MySqlShowStatement.EngineInfo; +import net.sf.jsqlparser.statement.show.MySqlShowStatement.Kind; +import net.sf.jsqlparser.statement.show.MySqlShowStatement.Part; +import net.sf.jsqlparser.statement.show.MySqlShowStatement.ProfileType; +import net.sf.jsqlparser.statement.show.MySqlShowStatement.Scope; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlShowStatementTest { + + private static final Consumer MYSQL = parser -> parser.withDialect(Dialect.MYSQL); + + private static final List> DIALECTS = List.of(parser -> { + }, MYSQL, parser -> parser.withDialect(Dialect.MARIADB)); + + /** Parses without a dialect and with MySQL and MariaDB, then deparses and reparses. */ + private static MySqlShowStatement roundTrip(String sql) throws JSQLParserException { + return roundTrip(sql, DIALECTS); + } + + private static MySqlShowStatement roundTrip(String sql, List> dialects) + throws JSQLParserException { + MySqlShowStatement result = null; + for (Consumer dialect : dialects) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(MySqlShowStatement.class, statement); + assertDeparse(statement, sql); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + result = (MySqlShowStatement) statement; + } + return result; + } + + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "SHOW GLOBAL VARIABLES LIKE 'a%' | VARIABLES | VARIABLES", + "SHOW SESSION VARIABLES WHERE Variable_name = 'a' | VARIABLES | VARIABLES", + "SHOW LOCAL VARIABLES | VARIABLES | VARIABLES", + "SHOW SESSION STATUS | STATUS | STATUS", + "SHOW GLOBAL STATUS LIKE 'Com%' | STATUS | STATUS", + "SHOW LOCAL STATUS WHERE Value > 1 | STATUS | STATUS", + "SHOW STATUS WHERE Variable_name LIKE 'a%' AND Value > 0 | STATUS | STATUS", + "SHOW FULL PROCESSLIST | PROCESSLIST | PROCESSLIST", + "SHOW BINARY LOG STATUS | BINARY_LOG_STATUS | BINARY LOG STATUS", + "SHOW BINARY LOGS | BINARY_LOGS | BINARY LOGS", + "SHOW BINLOG EVENTS IN 'f' | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS FROM 4 | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS LIMIT 2 | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS IN 'f' FROM 4 LIMIT 2, 3 | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS IN 'f' FROM 4 LIMIT 3 OFFSET 2 | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS IN \"f\" | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS FROM 1.5 | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS FROM 18446744073709551615 | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW BINLOG EVENTS LIMIT a | BINLOG_EVENTS | BINLOG EVENTS", + "SHOW RELAYLOG EVENTS IN 'f' FROM 4 LIMIT 2, 3 FOR CHANNEL 'c' | RELAYLOG_EVENTS | RELAYLOG EVENTS", + "SHOW RELAYLOG EVENTS FOR CHANNEL 'c' | RELAYLOG_EVENTS | RELAYLOG EVENTS", + "SHOW RELAYLOG EVENTS FOR CHANNEL \"c\" | RELAYLOG_EVENTS | RELAYLOG EVENTS", + "SHOW RELAYLOG EVENTS LIMIT 1 FOR CHANNEL 'c' | RELAYLOG_EVENTS | RELAYLOG EVENTS", + "SHOW GRANTS FOR 'u'@'h' | GRANTS | GRANTS", + "SHOW GRANTS FOR u@h | GRANTS | GRANTS", + "SHOW GRANTS FOR u | GRANTS | GRANTS", + "SHOW GRANTS FOR `u`@`h` | GRANTS | GRANTS", + "SHOW GRANTS FOR CURRENT_USER | GRANTS | GRANTS", + "SHOW GRANTS FOR CURRENT_USER() | GRANTS | GRANTS", + "SHOW GRANTS FOR 'u'@'h' USING 'r1' | GRANTS | GRANTS", + "SHOW GRANTS FOR 'u'@'h' USING 'r1', 'r2'@'h' | GRANTS | GRANTS", + "SHOW GRANTS FOR CURRENT_USER() USING r1, r2@h | GRANTS | GRANTS", + "SHOW WARNINGS LIMIT 5 | WARNINGS | WARNINGS", + "SHOW WARNINGS LIMIT 2, 5 | WARNINGS | WARNINGS", + "SHOW WARNINGS LIMIT 5 OFFSET 2 | WARNINGS | WARNINGS", + "SHOW ERRORS LIMIT 5 | ERRORS | ERRORS", + "SHOW ERRORS LIMIT 2, 5 | ERRORS | ERRORS", + "SHOW ERRORS LIMIT 5 OFFSET 2 | ERRORS | ERRORS", + "SHOW COUNT(*) WARNINGS | WARNINGS | WARNINGS", + "SHOW COUNT(*) ERRORS | ERRORS | ERRORS", + "SHOW ENGINE INNODB STATUS | ENGINE | ENGINE", + "SHOW ENGINE INNODB MUTEX | ENGINE | ENGINE", + "SHOW ENGINE INNODB LOGS | ENGINE | ENGINE", + "SHOW ENGINE PERFORMANCE_SCHEMA STATUS | ENGINE | ENGINE", + "SHOW ENGINE ALL STATUS | ENGINE | ENGINE", + "SHOW ENGINE 'innodb' STATUS | ENGINE | ENGINE", + "SHOW ENGINE `innodb` MUTEX | ENGINE | ENGINE", + "SHOW STORAGE ENGINES | ENGINES | STORAGE ENGINES", + "SHOW TRIGGERS FROM d | TRIGGERS | TRIGGERS", + "SHOW TRIGGERS IN d | TRIGGERS | TRIGGERS", + "SHOW TRIGGERS LIKE 't%' | TRIGGERS | TRIGGERS", + "SHOW TRIGGERS FROM d LIKE 't%' | TRIGGERS | TRIGGERS", + "SHOW TRIGGERS IN d WHERE `Trigger` = 'x' | TRIGGERS | TRIGGERS", + "SHOW FULL TRIGGERS | TRIGGERS | TRIGGERS", + "SHOW FULL TRIGGERS FROM d | TRIGGERS | TRIGGERS", + "SHOW EVENTS FROM d | EVENTS | EVENTS", + "SHOW EVENTS IN d | EVENTS | EVENTS", + "SHOW EVENTS LIKE 'e%' | EVENTS | EVENTS", + "SHOW EVENTS FROM d WHERE Name = 'x' | EVENTS | EVENTS", + "SHOW OPEN TABLES | OPEN_TABLES | OPEN TABLES", + "SHOW OPEN TABLES FROM d | OPEN_TABLES | OPEN TABLES", + "SHOW OPEN TABLES IN d | OPEN_TABLES | OPEN TABLES", + "SHOW OPEN TABLES LIKE 't%' | OPEN_TABLES | OPEN TABLES", + "SHOW OPEN TABLES FROM d WHERE In_use > 0 | OPEN_TABLES | OPEN TABLES", + "SHOW PROCEDURE STATUS | PROCEDURE_STATUS | PROCEDURE STATUS", + "SHOW PROCEDURE STATUS LIKE 'p%' | PROCEDURE_STATUS | PROCEDURE STATUS", + "SHOW PROCEDURE STATUS WHERE Db = 'x' | PROCEDURE_STATUS | PROCEDURE STATUS", + "SHOW FUNCTION STATUS | FUNCTION_STATUS | FUNCTION STATUS", + "SHOW FUNCTION STATUS LIKE 'f%' | FUNCTION_STATUS | FUNCTION STATUS", + "SHOW FUNCTION STATUS WHERE Db = 'x' | FUNCTION_STATUS | FUNCTION STATUS", + "SHOW PROCEDURE CODE p | PROCEDURE_CODE | PROCEDURE CODE", + "SHOW PROCEDURE CODE d.p | PROCEDURE_CODE | PROCEDURE CODE", + "SHOW FUNCTION CODE f | FUNCTION_CODE | FUNCTION CODE", + "SHOW FUNCTION CODE d.`f` | FUNCTION_CODE | FUNCTION CODE", + "SHOW REPLICA STATUS | REPLICA_STATUS | REPLICA STATUS", + "SHOW REPLICA STATUS FOR CHANNEL 'c' | REPLICA_STATUS | REPLICA STATUS", + "SHOW REPLICA STATUS FOR CHANNEL '' | REPLICA_STATUS | REPLICA STATUS", + "SHOW CHARACTER SET | CHARACTER_SET | CHARACTER SET", + "SHOW CHARACTER SET LIKE 'utf8%' | CHARACTER_SET | CHARACTER SET", + "SHOW CHAR SET | CHARACTER_SET | CHAR SET", + "SHOW CHAR SET LIKE 'a' | CHARACTER_SET | CHAR SET", + "SHOW CHARSET WHERE Maxlen > 1 | CHARACTER_SET | CHARSET", + "SHOW COLLATION LIKE 'utf8%' | COLLATION | COLLATION", + "SHOW COLLATION WHERE Charset = 'utf8mb4' | COLLATION | COLLATION", + "SHOW DATABASES LIKE 'd%' | DATABASES | DATABASES", + "SHOW SCHEMAS WHERE `Database` = 'd' | DATABASES | SCHEMAS", + "SHOW PROFILE ALL | PROFILE | PROFILE", + "SHOW PROFILE BLOCK IO | PROFILE | PROFILE", + "SHOW PROFILE CONTEXT SWITCHES | PROFILE | PROFILE", + "SHOW PROFILE CPU | PROFILE | PROFILE", + "SHOW PROFILE IPC | PROFILE | PROFILE", + "SHOW PROFILE MEMORY | PROFILE | PROFILE", + "SHOW PROFILE PAGE FAULTS | PROFILE | PROFILE", + "SHOW PROFILE SOURCE | PROFILE | PROFILE", + "SHOW PROFILE SWAPS | PROFILE | PROFILE", + "SHOW PROFILE CPU, BLOCK IO | PROFILE | PROFILE", + "SHOW PROFILE CPU, CPU | PROFILE | PROFILE", + "SHOW PROFILE CPU, BLOCK IO FOR QUERY 2 | PROFILE | PROFILE", + "SHOW PROFILE FOR QUERY 2 | PROFILE | PROFILE", + "SHOW PROFILE FOR QUERY 2 LIMIT 1 | PROFILE | PROFILE", + "SHOW PROFILE LIMIT 1, 2 | PROFILE | PROFILE", + "SHOW PROFILE ALL, CPU FOR QUERY 2 LIMIT 3 OFFSET 1 | PROFILE | PROFILE" + }) + void mySqlForms(String sql, Kind kind, String keyword) throws JSQLParserException { + MySqlShowStatement show = roundTrip(sql); + + assertEquals(kind, show.getKind()); + assertEquals(keyword, show.getKeyword()); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "SHOW MASTER STATUS | BINARY_LOG_STATUS | MASTER STATUS", + "SHOW MASTER LOGS | BINARY_LOGS | MASTER LOGS", + "SHOW SLAVE HOSTS | REPLICAS | SLAVE HOSTS", + "SHOW SLAVE STATUS | REPLICA_STATUS | SLAVE STATUS", + "SHOW SLAVE STATUS FOR CHANNEL 'c1' | REPLICA_STATUS | SLAVE STATUS" + }) + void spellingsRemovedInMySql84(String sql, Kind kind, String keyword) + throws JSQLParserException { + MySqlShowStatement show = roundTrip(sql, List.of(DIALECTS.get(0), DIALECTS.get(2))); + + assertEquals(kind, show.getKind()); + assertEquals(keyword, show.getKeyword()); + assertInstanceOf(UnsupportedStatement.class, + assertSqlCanBeParsedAndDeparsed(sql, true, MYSQL)); + } + + @Test + void scopeAndFilter() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW GLOBAL STATUS WHERE Variable_name = 'Uptime'"); + + assertEquals(Scope.GLOBAL, show.getScope()); + assertEquals("Variable_name = 'Uptime'", show.getWhereCondition().toString()); + assertNull(show.getLikeExpression()); + assertEquals(ShowFilter.Kind.WHERE, show.getFilter().getKind()); + + show = roundTrip("SHOW VARIABLES LIKE 'sql_mode'"); + assertNull(show.getScope()); + assertEquals("sql_mode", ((StringValue) show.getLikeExpression()).getValue()); + + show = roundTrip("SHOW LOCAL VARIABLES LIKE \"a%\"", List.of(MYSQL)); + assertEquals(Scope.LOCAL, show.getScope()); + assertEquals("a%", ((StringValue) show.getLikeExpression()).getValue()); + } + + @Test + void whereTakesAWholeExpression() throws JSQLParserException { + String sql = "SHOW VARIABLES WHERE Variable_name LIKE 'innodb%' AND Value > 0 " + + "OR Variable_name IN ('a', 'b')"; + MySqlShowStatement show = roundTrip(sql); + + assertInstanceOf(OrExpression.class, show.getWhereCondition()); + // the statements of #2824 read the same filter + for (String other : Arrays.asList("SHOW COLUMNS FROM t WHERE a = 1 AND b = 2", + "SHOW TABLE STATUS WHERE a = 1 OR b = 2", + "SHOW INDEX FROM t WHERE Key_name = 'a' AND Seq_in_index > 1")) { + for (Consumer dialect : DIALECTS) { + assertFalse(assertSqlCanBeParsedAndDeparsed(other, false, + dialect) instanceof UnsupportedStatement, other); + } + } + } + + @Test + void fullProcessListAndTriggers() throws JSQLParserException { + assertTrue(roundTrip("SHOW FULL PROCESSLIST").isFull()); + assertFalse(roundTrip("SHOW PROCESSLIST", List.of(MYSQL)).isFull()); + assertTrue(roundTrip("SHOW FULL TRIGGERS IN d").isFull()); + assertFalse(roundTrip("SHOW TRIGGERS IN d").isFull()); + } + + @Test + void databaseSelection() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW TRIGGERS FROM v LIKE 't%'"); + + assertEquals(SelectionMode.FROM, show.getDbSelection().getSelectionMode()); + assertEquals("v", show.getDbName()); + assertEquals("t%", ((StringValue) show.getLikeExpression()).getValue()); + + show = roundTrip("SHOW OPEN TABLES IN v LIKE 't%'"); + assertEquals(SelectionMode.IN, show.getDbSelection().getSelectionMode()); + } + + @Test + void binaryLogEvents() throws JSQLParserException { + MySqlShowStatement show = + roundTrip("SHOW BINLOG EVENTS IN 'binlog.000001' FROM 4 LIMIT 10"); + + assertEquals("binlog.000001", show.getLogName().getValue()); + assertEquals(4L, ((LongValue) show.getPosition()).getValue()); + assertNull(show.getLimit().getOffset()); + assertEquals("10", show.getLimit().getRowCount().toString()); + assertNull(show.getOffset()); + assertNull(show.getChannel()); + + show = roundTrip("SHOW BINLOG EVENTS IN \"f\" FROM 1.5 LIMIT 3 OFFSET 2"); + assertEquals("f", show.getLogName().getValue()); + assertEquals("\"", show.getLogName().getQuoteStr()); + assertInstanceOf(DoubleValue.class, show.getPosition()); + assertEquals("3", show.getLimit().getRowCount().toString()); + assertEquals("2", show.getOffset().getOffset().toString()); + } + + @Test + void relayLogEvents() throws JSQLParserException { + MySqlShowStatement show = roundTrip( + "SHOW RELAYLOG EVENTS IN 'relay.000002' FROM 4 LIMIT 2, 10 FOR CHANNEL 'c1'"); + + assertEquals("2", show.getLimit().getOffset().toString()); + assertEquals("10", show.getLimit().getRowCount().toString()); + assertEquals("c1", show.getChannel().getValue()); + } + + @Test + void limitValues() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW WARNINGS LIMIT a, 18446744073709551615"); + + assertInstanceOf(Column.class, show.getLimit().getOffset()); + assertEquals("18446744073709551615", + ((LongValue) show.getLimit().getRowCount()).getStringValue()); + + // a ? is a syntax error in the text protocol, but PREPARE reads it + show = roundTrip("SHOW ERRORS LIMIT ? OFFSET ?"); + assertInstanceOf(JdbcParameter.class, show.getLimit().getRowCount()); + assertInstanceOf(JdbcParameter.class, show.getOffset().getOffset()); + } + + @Test + void grantsForAccount() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW GRANTS FOR 'app'@'%'"); + + assertEquals("app", show.getAccount().getUser().getValue()); + assertEquals("%", show.getAccount().getHost().getValue()); + assertTrue(show.getUsingRoles().isEmpty()); + + show = roundTrip("SHOW GRANTS FOR app@localhost USING r1, 'r2'@'%'"); + assertEquals("app", show.getAccount().getUser().getValue()); + assertEquals("localhost", show.getAccount().getHost().getValue()); + assertEquals(2, show.getUsingRoles().size()); + assertEquals("'r2'@'%'", show.getUsingRoles().get(1).toString()); + } + + @Test + void grantsForCurrentUser() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW GRANTS FOR CURRENT_USER"); + + assertEquals("CURRENT_USER", show.getAccount().getUser().getValue()); + assertFalse(show.getAccount().isCurrentUserParentheses()); + + show = roundTrip("SHOW GRANTS FOR CURRENT_USER()"); + assertTrue(show.getAccount().isCurrentUserParentheses()); + + assertNull(roundTrip("SHOW GRANTS", List.of(MYSQL)).getAccount()); + } + + @Test + void diagnostics() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW WARNINGS LIMIT 5"); + + assertFalse(show.isCount()); + assertEquals("5", show.getLimit().getRowCount().toString()); + + show = roundTrip("SHOW COUNT(*) ERRORS"); + assertEquals(Kind.ERRORS, show.getKind()); + assertTrue(show.isCount()); + assertNull(show.getLimit()); + + assertEquals("SHOW COUNT(*) WARNINGS", + CCJSqlParserUtil.parse("SHOW COUNT( * )WARNINGS", MYSQL).toString()); + } + + @Test + void engineAndRoutineCode() throws JSQLParserException { + MySqlShowStatement show = roundTrip("SHOW ENGINE INNODB STATUS"); + + assertEquals("INNODB", show.getEngineName()); + assertEquals(EngineInfo.STATUS, show.getEngineInfo()); + + show = roundTrip("SHOW ENGINE ALL MUTEX"); + assertEquals("ALL", show.getEngineName()); + assertEquals(EngineInfo.MUTEX, show.getEngineInfo()); + + show = roundTrip("SHOW ENGINE 'innodb' LOGS"); + assertEquals("'innodb'", show.getEngineName()); + assertEquals(EngineInfo.LOGS, show.getEngineInfo()); + + show = roundTrip("SHOW PROCEDURE CODE db.p"); + assertEquals("db", show.getRoutineName().getSchemaName()); + assertEquals("p", show.getRoutineName().getName()); + assertNull(roundTrip("SHOW FUNCTION CODE f").getRoutineName().getSchemaName()); + } + + @Test + void profile() throws JSQLParserException { + MySqlShowStatement show = + roundTrip("SHOW PROFILE BLOCK IO, PAGE FAULTS, CPU FOR QUERY 2 LIMIT 3 OFFSET 1"); + + assertEquals(List.of(ProfileType.BLOCK_IO, ProfileType.PAGE_FAULTS, ProfileType.CPU), + show.getProfileTypes()); + assertEquals("2", show.getProfileQuery().toString()); + assertEquals("3", show.getLimit().getRowCount().toString()); + assertEquals("1", show.getOffset().getOffset().toString()); + + show = roundTrip("SHOW PROFILE", List.of(MYSQL)); + assertTrue(show.getProfileTypes().isEmpty()); + assertNull(show.getProfileQuery()); + assertEquals(ProfileType.CONTEXT_SWITCHES, ProfileType.fromKeyword("context switches")); + } + + @Test + void keywordsAreCaseInsensitive() throws JSQLParserException { + assertEquals("SHOW GLOBAL VARIABLES LIKE 'x%'", + CCJSqlParserUtil.parse("show global variables like 'x%'", MYSQL).toString()); + assertEquals("SHOW SLAVE STATUS FOR CHANNEL 'c'", + CCJSqlParserUtil.parse("show slave status for channel 'c'").toString()); + assertEquals("SHOW CHARSET", CCJSqlParserUtil.parse("show charset", MYSQL).toString()); + assertEquals("SHOW PROFILE BLOCK IO, CONTEXT SWITCHES", CCJSqlParserUtil + .parse("show profile block io, Context Switches", MYSQL).toString()); + assertEquals("SHOW ENGINE innodb STATUS", + CCJSqlParserUtil.parse("show engine innodb status", MYSQL).toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW VARIABLES", "SHOW STATUS", "SHOW PROCESSLIST", + "SHOW DATABASES", "SHOW SCHEMAS", "SHOW TRIGGERS", "SHOW EVENTS", "SHOW CHARSET", + "SHOW COLLATION", "SHOW ENGINES", "SHOW PLUGINS", "SHOW PRIVILEGES", "SHOW PROFILES", + "SHOW PROFILE", "SHOW REPLICAS", "SHOW GRANTS", "SHOW WARNINGS", "SHOW ERRORS"}) + void singleWordsAreTypedForMySqlOnly(String sql) throws JSQLParserException { + roundTrip(sql, List.of(MYSQL, parser -> parser.withDialect(Dialect.MARIADB))); + + // without a dialect and in other dialects, a single word stays a ShowStatement + for (Consumer dialect : List.>of(parser -> { + }, parser -> parser.withDialect(Dialect.SNOWFLAKE), + parser -> parser.withDialect(Dialect.POSTGRESQL))) { + Statement statement = CCJSqlParserUtil.parse(sql, dialect); + assertInstanceOf(ShowStatement.class, statement); + assertEquals(sql, statement.toString()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW VARIABLES LIKE 'sql_mode'", "SHOW DATABASES LIKE 'v%'", + "SHOW GRANTS FOR 'app'@'%'", "SHOW FULL PROCESSLIST", "SHOW WARNINGS LIMIT 5", + "SHOW BINARY LOGS", "SHOW ENGINE INNODB STATUS", "SHOW PROFILE CPU", + "SHOW CHARACTER SET", "SHOW REPLICA STATUS"}) + void otherDialectsKeepUnsupportedStatement(String sql) throws JSQLParserException { + for (Dialect dialect : Arrays.asList(Dialect.SNOWFLAKE, Dialect.POSTGRESQL, + Dialect.ORACLE, Dialect.DATABRICKS)) { + Statement statement = + CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + assertInstanceOf(UnsupportedStatement.class, statement, dialect.name()); + } + } + + @Test + void postgreSqlShowIsUnchanged() throws JSQLParserException { + Consumer postgreSql = parser -> parser.withDialect(Dialect.POSTGRESQL); + for (String sql : Arrays.asList("SHOW TIME ZONE", "SHOW TRANSACTION ISOLATION LEVEL", + "SHOW SESSION AUTHORIZATION", "SHOW search_path", "SHOW ALL", "SHOW status")) { + assertInstanceOf(ShowStatement.class, assertSqlCanBeParsedAndDeparsed(sql, true, + postgreSql), sql); + } + for (String sql : Arrays.asList("SHOW TIME ZONE", "SHOW TRANSACTION ISOLATION LEVEL", + "SHOW SESSION AUTHORIZATION")) { + assertInstanceOf(ShowStatement.class, assertSqlCanBeParsedAndDeparsed(sql, true)); + } + } + + /** MySQL 8.4 reports a syntax error for each; the parser keeps them unsupported statements. */ + @ParameterizedTest + @ValueSource(strings = { + "SHOW PERSIST VARIABLES", + "SHOW GLOBAL SESSION VARIABLES", + "SHOW VARIABLES LIKE a", + "SHOW VARIABLES LIKE 1", + "SHOW VARIABLES LIKE N'a%'", + "SHOW VARIABLES LIKE _utf8mb4'a%'", + "SHOW VARIABLES LIKE CONCAT('a', '%')", + "SHOW VARIABLES LIKE ?", + "SHOW VARIABLES LIKE @v", + "SHOW VARIABLES LIKE 'a%' WHERE Value = 1", + "SHOW VARIABLES FROM d", + "SHOW VARIABLES LIMIT 1", + "SHOW FULL VARIABLES", + "SHOW FULL STATUS", + "SHOW PROCESSLIST LIKE 'a'", + "SHOW EXTENDED PROCESSLIST", + "SHOW SESSION PROCESSLIST", + "SHOW BINARY LOG", + "SHOW BINARY LOGS LIKE 'a'", + "SHOW BINLOG EVENTS IN f", + "SHOW BINLOG EVENTS FROM 'x'", + "SHOW BINLOG EVENTS FROM -1", + "SHOW BINLOG EVENTS FROM 0x10", + "SHOW BINLOG EVENTS FROM 4 IN 'f'", + "SHOW BINLOG EVENTS LIMIT 2 FROM 4", + "SHOW BINLOG EVENTS FOR CHANNEL 'c'", + "SHOW BINLOG EVENTS LIMIT @v", + "SHOW BINLOG EVENTS LIMIT 1 + 1", + "SHOW BINLOG EVENTS LIMIT -1", + "SHOW BINLOG EVENTS LIMIT 1, 2, 3", + "SHOW BINLOG EVENTS LIMIT 'a'", + "SHOW RELAYLOG EVENTS FOR CHANNEL c", + "SHOW RELAYLOG EVENTS FOR CHANNEL 'c' LIMIT 1", + "SHOW RELAYLOG EVENTS FOR CHANNEL", + "SHOW GRANTS USING 'r1'", + "SHOW GRANTS FOR", + "SHOW GRANTS FOR 'u'@'h' USING", + "SHOW GRANTS FOR 'u'@'h', 'u2'@'h'", + "SHOW GRANTS ON d.t", + "SHOW COUNT (*) ERRORS", + "SHOW COUNT(*) WARNINGS LIMIT 1", + "SHOW COUNT(1) WARNINGS", + "SHOW COUNT(*) VARIABLES", + "SHOW COUNT(*)", + "SHOW WARNINGS LIKE 'a'", + "SHOW WARNINGS WHERE Code = 1", + "SHOW WARNINGS LIMIT", + "SHOW WARNINGS OFFSET 2", + "SHOW WARNINGS LIMIT \"a\"", + "SHOW WARNINGS LIMIT 1.5", + "SHOW WARNINGS LIMIT 0x10", + "SHOW WARNINGS LIMIT a.b", + "SHOW ENGINE INNODB", + "SHOW ENGINE STATUS", + "SHOW ENGINE INNODB STATUS LIKE 'a'", + "SHOW ENGINE d.innodb STATUS", + "SHOW ENGINE N'innodb' STATUS", + "SHOW ENGINES LIKE 'a'", + "SHOW STORAGE ENGINE INNODB STATUS", + "SHOW EXTENDED TRIGGERS", + "SHOW TRIGGERS FROM d.t", + "SHOW TRIGGERS LIKE 't%' FROM d", + "SHOW TRIGGERS FROM 'd'", + "SHOW FULL EVENTS", + "SHOW EVENTS FROM d.e", + "SHOW FULL OPEN TABLES", + "SHOW OPEN FULL TABLES", + "SHOW OPEN TABLE", + "SHOW PROCEDURE STATUS FROM d", + "SHOW PROCEDURE CODE", + "SHOW PROCEDURE CODE p LIKE 'a'", + "SHOW PROCEDURE CODE a.b.c", + "SHOW PROCEDURE CODE 'p'", + "SHOW PROCEDURE p", + "SHOW MASTER STATUS", + "SHOW MASTER LOGS", + "SHOW MASTER HOSTS", + "SHOW SLAVE STATUS", + "SHOW SLAVE HOSTS", + "SHOW REPLICAS LIKE 'a'", + "SHOW REPLICA STATUS LIKE 'a'", + "SHOW REPLICA STATUS FOR 'c'", + "SHOW REPLICA STATUS FOR CHANNEL c", + "SHOW REPLICA STATUS FOR CHANNEL N'c'", + "SHOW REPLICA STATUS FOR CHANNEL 'c' LIMIT 1", + "SHOW REPLICA HOSTS", + "SHOW CHARACTER SET FROM d", + "SHOW CHARACTER SETS", + "SHOW CHARSET LIKE 'a' LIKE 'b'", + "SHOW COLLATION FROM d", + "SHOW DATABASES FROM d", + "SHOW GLOBAL DATABASES", + "SHOW FULL DATABASES", + "SHOW PLUGINS LIKE 'a'", + "SHOW PLUGINS WHERE Name = 'a'", + "SHOW PRIVILEGES LIKE 'a'", + "SHOW PROFILES LIMIT 1", + "SHOW PROFILE CPU,", + "SHOW PROFILE BLOCK", + "SHOW PROFILE FOR QUERY", + "SHOW PROFILE FOR QUERY 'a'", + "SHOW PROFILE FOR QUERY ?", + "SHOW PROFILE LIMIT 1 FOR QUERY 2", + "SHOW PROFILE FOO", + "SHOW PROFILE CPU CPU", + "SHOW INNODB STATUS", + "SHOW MUTEX STATUS", + "SHOW TABLE TYPES" + }) + void formsMySqlRejectsRemainUnsupported(String sql) throws JSQLParserException { + assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, MYSQL)); + } + + @Test + void textAfterAWhereConditionIsAnError() { + for (String sql : Arrays.asList("SHOW VARIABLES WHERE a = 1 LIMIT 1", + "SHOW EVENTS FROM d WHERE a = 1 LIKE", "SHOW STATUS WHERE a = 1 FROM d")) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, MYSQL), sql); + } + } + + @Test + void withoutADialectLikeTakesAnExpressionAsBefore() throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed("SHOW VARIABLES LIKE a", true); + + assertInstanceOf(Column.class, ((MySqlShowStatement) statement).getLikeExpression()); + assertInstanceOf(ShowTablesStatement.class, + assertSqlCanBeParsedAndDeparsed("SHOW TABLES LIKE 'a' || 'b'", true)); + assertInstanceOf(ShowTablesStatement.class, + assertSqlCanBeParsedAndDeparsed("SHOW TABLES LIKE 'a%'", true, MYSQL)); + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW VARIABLES LIKE 'a%'", "SHOW GLOBAL STATUS", + "SHOW FULL PROCESSLIST", "SHOW SCHEMAS", "SHOW TRIGGERS FROM v", + "SHOW OPEN TABLES", "SHOW PROCEDURE STATUS", "SHOW FUNCTION CODE f", + "SHOW CHARACTER SET", "SHOW STORAGE ENGINES", "SHOW PLUGINS", "SHOW BINARY LOGS", + "SHOW BINARY LOG STATUS", "SHOW REPLICAS", + "SHOW REPLICA STATUS FOR CHANNEL 'c'", "SHOW GRANTS FOR CURRENT_USER()", + "SHOW WARNINGS LIMIT 2, 5", "SHOW ERRORS LIMIT 5 OFFSET a", "SHOW COUNT(*) ERRORS", + "SHOW ENGINE INNODB MUTEX", "SHOW BINLOG EVENTS FROM 4", + "SHOW RELAYLOG EVENTS FOR CHANNEL 'c'", "SHOW PROFILE CPU FOR QUERY 2", + "SHOW STATUS WHERE a = 1 AND b = 2", "SHOW INDEX FROM t FROM v", "SHOW TABLES IN v"}) + void endsAtTheStatementBoundary(String sql) throws JSQLParserException { + for (String script : Arrays.asList(sql + ";\nSELECT 1", sql + ";\nSHOW TABLES", + "SHOW TABLES;\n" + sql)) { + Statements statements = CCJSqlParserUtil.parseStatements(script, MYSQL); + + assertEquals(2, statements.size(), script); + Statement show = statements.get(script.startsWith(sql) ? 0 : 1); + assertEquals(sql, show.toString()); + assertFalse(show instanceof UnsupportedStatement, script); + } + IfElseStatement ifElse = (IfElseStatement) CCJSqlParserUtil + .parse("IF a = 1 " + sql + " ELSE " + sql, MYSQL); + assertEquals(sql, ifElse.getIfStatement().toString()); + assertEquals(sql, ifElse.getElseStatement().toString()); + } + + @Test + void namesNoTable() throws JSQLParserException { + assertThat(TablesNamesFinder.findTables("SHOW OPEN TABLES FROM db LIKE 't%'")).isEmpty(); + assertThat(TablesNamesFinder.findTables("SHOW PROCEDURE CODE db.p")).isEmpty(); + assertThat(TablesNamesFinder.findTables("SHOW GRANTS FOR u")).isEmpty(); + assertThat(new TablesNamesFinder().getTables( + CCJSqlParserUtil.parse("SHOW EVENTS FROM db WHERE Name = 'x'", MYSQL))).isEmpty(); + } + + @Test + void reportsMetadataFeatures() throws JSQLParserException { + StatementFeatures features = + CCJSqlParserUtil.parse("SHOW GLOBAL VARIABLES LIKE 'a%'").getFeatures(); + + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + } + + @Test + void visitorsReceiveTheStatement() throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse("SHOW BINARY LOGS"); + MySqlShowStatement[] visited = new MySqlShowStatement[1]; + statement.accept(new StatementVisitorAdapter() { + @Override + public Void visit(MySqlShowStatement mySqlShow, S context) { + visited[0] = mySqlShow; + return null; + } + }); + + assertSame(statement, visited[0]); + assertNull(statement.accept(new StatementVisitorAdapter(), null)); + } + + @Test + void buildsAndDeparses() { + MySqlShowStatement show = new MySqlShowStatement(Kind.VARIABLES).withScope(Scope.SESSION) + .withFilter(ShowFilter.like(new StringValue("max%"))); + assertDeparse(show, "SHOW SESSION VARIABLES LIKE 'max%'"); + + show = new MySqlShowStatement().withKeyword("slave status") + .withChannel(new StringValue("c1")); + assertEquals(Kind.REPLICA_STATUS, show.getKind()); + assertDeparse(show, "SHOW SLAVE STATUS FOR CHANNEL 'c1'"); + + UserAccount account = new UserAccount().withUser(new StringValue("app")) + .withHost(new StringValue("%")); + show = new MySqlShowStatement(Kind.GRANTS).withAccount(account) + .withUsingRoles(List.of(new UserAccount().withUser(new StringValue("r")))); + assertDeparse(show, "SHOW GRANTS FOR 'app'@'%' USING 'r'"); + + show = new MySqlShowStatement(Kind.BINLOG_EVENTS) + .withLogName(new StringValue("binlog.000002")).withPosition(new LongValue(4)) + .withLimit(new Limit().withOffset(new LongValue(1)).withRowCount(new LongValue(2))); + assertDeparse(show, "SHOW BINLOG EVENTS IN 'binlog.000002' FROM 4 LIMIT 1, 2"); + + show = new MySqlShowStatement(Kind.ENGINE).withEngineName("INNODB") + .withEngineInfo(EngineInfo.MUTEX); + assertDeparse(show, "SHOW ENGINE INNODB MUTEX"); + + show = new MySqlShowStatement(Kind.PROCEDURE_CODE).withRoutineName(new Table("p")); + assertDeparse(show, "SHOW PROCEDURE CODE p"); + + show = new MySqlShowStatement(Kind.TRIGGERS).withFull(true) + .withDbSelection(new ShowDbSelection(SelectionMode.IN, "db")); + assertDeparse(show, "SHOW FULL TRIGGERS IN db"); + + show = new MySqlShowStatement(Kind.PROFILE) + .withProfileTypes(List.of(ProfileType.CPU, ProfileType.BLOCK_IO)) + .withProfileQuery(new LongValue(2)) + .withLimit(new Limit().withRowCount(new LongValue(3))) + .withOffset(new Offset().withOffset(new LongValue(1))); + assertDeparse(show, "SHOW PROFILE CPU, BLOCK IO FOR QUERY 2 LIMIT 3 OFFSET 1"); + } + + @Test + void kindsAllowTheirParts() { + assertTrue(Kind.VARIABLES.allows(Part.SCOPE)); + assertFalse(Kind.DATABASES.allows(Part.SCOPE)); + assertEquals(List.of("BINARY LOG STATUS", "MASTER STATUS"), + Kind.BINARY_LOG_STATUS.getKeywords()); + assertEquals(List.of("CHARACTER SET", "CHARSET", "CHAR SET"), + Kind.CHARACTER_SET.getKeywords()); + assertEquals(EnumSet.of(Part.PROFILE, Part.LIMIT), Kind.PROFILE.getParts()); + assertEquals(Kind.CHARACTER_SET, Kind.fromKeyword(" charset ")); + assertThrows(IllegalArgumentException.class, () -> Kind.fromKeyword("FUNCTIONS")); + + MySqlShowStatement show = new MySqlShowStatement(Kind.DATABASES); + assertThrows(IllegalArgumentException.class, () -> show.setScope(Scope.GLOBAL)); + assertThrows(IllegalArgumentException.class, () -> show.setFull(true)); + assertThrows(IllegalArgumentException.class, + () -> show.setDbSelection(new ShowDbSelection("db"))); + assertThrows(IllegalArgumentException.class, + () -> show.setChannel(new StringValue("c"))); + assertThrows(IllegalArgumentException.class, () -> show.setLimit(new Limit())); + assertThrows(IllegalArgumentException.class, + () -> show.setProfileTypes(List.of(ProfileType.CPU))); + assertThrows(IllegalArgumentException.class, + () -> show.setProfileQuery(new LongValue(1))); + + MySqlShowStatement binlog = new MySqlShowStatement(Kind.BINLOG_EVENTS); + assertThrows(IllegalArgumentException.class, + () -> binlog.setChannel(new StringValue("c"))); + // OFFSET needs LIMIT row_count before it + assertThrows(IllegalArgumentException.class, + () -> binlog.setOffset(new Offset().withOffset(new LongValue(1)))); + binlog.setLimit(new Limit().withOffset(new LongValue(1)).withRowCount(new LongValue(2))); + assertThrows(IllegalArgumentException.class, + () -> binlog.setOffset(new Offset().withOffset(new LongValue(1)))); + } + + @Test + void changingTheKindDropsPartsItDoesNotAllow() { + MySqlShowStatement show = new MySqlShowStatement(Kind.TRIGGERS) + .withDbSelection(new ShowDbSelection("db")) + .withFilter(ShowFilter.like(new StringValue("t%"))); + + show.setKind(Kind.DATABASES); + assertNull(show.getDbSelection()); + assertEquals("SHOW DATABASES LIKE 't%'", show.toString()); + + show.setKeyword("SCHEMAS"); + assertEquals(Kind.DATABASES, show.getKind()); + assertEquals("SHOW SCHEMAS LIKE 't%'", show.toString()); + + show.setKeyword("PLUGINS"); + assertEquals(Kind.PLUGINS, show.getKind()); + assertNull(show.getFilter()); + assertEquals("SHOW PLUGINS", show.toString()); + + show.setKind(Kind.REPLICAS); + assertEquals("REPLICAS", show.getKeyword()); + show.setKeyword(null); + assertEquals("REPLICAS", show.getKeyword()); + } + + @Test + void countAndLimitReplaceEachOther() { + MySqlShowStatement show = new MySqlShowStatement(Kind.WARNINGS) + .withLimit(new Limit().withRowCount(new LongValue(3))); + + show.setCount(true); + assertNull(show.getLimit()); + assertEquals("SHOW COUNT(*) WARNINGS", show.toString()); + + show.setLimit(new Limit().withRowCount(new LongValue(3))); + show.setOffset(new Offset().withOffset(new LongValue(1))); + assertFalse(show.isCount()); + assertEquals("SHOW WARNINGS LIMIT 3 OFFSET 1", show.toString()); + + show.setLimit(null); + assertNull(show.getOffset()); + assertEquals("SHOW WARNINGS", show.toString()); + } + + @Test + void removingTheAccountRemovesTheRoles() { + MySqlShowStatement show = new MySqlShowStatement(Kind.GRANTS) + .withAccount(new UserAccount().withUser(new StringValue("u"))) + .withUsingRoles(List.of(new UserAccount().withUser(new StringValue("r")))); + + show.setAccount(null); + assertTrue(show.getUsingRoles().isEmpty()); + assertEquals("SHOW GRANTS", show.toString()); + assertThrows(UnsupportedOperationException.class, + () -> show.getUsingRoles().add(new UserAccount())); + } + + @Test + void statementDeParserPrintsExpressionsWithTheExpressionDeParser() + throws JSQLParserException { + assertEquals("SHOW VARIABLES LIKE ", + ShowExpressionDeParsing.deparse("SHOW VARIABLES LIKE 'sql_mode'")); + assertEquals("SHOW BINLOG EVENTS IN FROM #4 LIMIT #2, #10", + ShowExpressionDeParsing.deparse( + "SHOW BINLOG EVENTS IN 'b.000001' FROM 4 LIMIT 2, 10")); + assertEquals("SHOW RELAYLOG EVENTS LIMIT #10 OFFSET #2 FOR CHANNEL ", + ShowExpressionDeParsing.deparse( + "SHOW RELAYLOG EVENTS LIMIT 10 OFFSET 2 FOR CHANNEL 'c'")); + assertEquals("SHOW PROFILE CPU FOR QUERY #2", + ShowExpressionDeParsing.deparse("SHOW PROFILE CPU FOR QUERY 2")); + } + + @Test + void parsedObjectsHaveNodes() throws JSQLParserException { + String sql = "SHOW BINLOG EVENTS IN 'f' FROM 4 LIMIT 2, 3"; + MySqlShowStatement show = (MySqlShowStatement) CCJSqlParserUtil.parse(sql, MYSQL); + + assertEquals(sql, span(sql, show)); + assertEquals("'f'", span(sql, show.getLogName())); + assertEquals("4", span(sql, (ASTNodeAccess) show.getPosition())); + assertEquals("LIMIT 2, 3", span(sql, show.getLimit())); + + sql = "SHOW PROCEDURE CODE d.p"; + show = (MySqlShowStatement) CCJSqlParserUtil.parse(sql, MYSQL); + assertEquals("d.p", span(sql, show.getRoutineName())); + + sql = "SHOW WARNINGS LIMIT 5 OFFSET a"; + show = (MySqlShowStatement) CCJSqlParserUtil.parse(sql, MYSQL); + assertEquals("LIMIT 5", span(sql, show.getLimit())); + assertEquals("a", span(sql, (ASTNodeAccess) show.getOffset().getOffset())); + } + + private static String span(String sql, ASTNodeAccess access) { + return sql.substring(access.getASTNode().jjtGetFirstToken().absoluteBegin - 1, + access.getASTNode().jjtGetLastToken().absoluteEnd - 1); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/show/ShowClausesTest.java b/src/test/java/net/sf/jsqlparser/statement/show/ShowClausesTest.java new file mode 100644 index 0000000000..936bb716e1 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/show/ShowClausesTest.java @@ -0,0 +1,185 @@ +/*- + * #%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.show; + +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 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.assertTrue; + +import java.util.EnumSet; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.ShowColumnsStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.Modifiers; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** The shared {FROM | IN} db and LIKE | WHERE clauses of the SHOW statements. */ +class ShowClausesTest { + + @Test + void showTablesHoldsTheSharedClauses() throws JSQLParserException { + ShowTablesStatement show = (ShowTablesStatement) assertSqlCanBeParsedAndDeparsed( + "SHOW FULL TABLES IN v WHERE Table_type = 'VIEW'"); + + assertEquals(SelectionMode.IN, show.getDbSelection().getSelectionMode()); + assertEquals("v", show.getDbSelection().getName()); + assertEquals(SelectionMode.IN, show.getSelectionMode()); + assertEquals("v", show.getDbName()); + assertEquals(ShowFilter.Kind.WHERE, show.getFilter().getKind()); + assertSame(show.getFilter().getExpression(), show.getWhereCondition()); + assertNull(show.getLikeExpression()); + + show = (ShowTablesStatement) assertSqlCanBeParsedAndDeparsed("SHOW TABLES"); + assertNull(show.getSelectionMode()); + assertNull(show.getDbSelection()); + assertNull(show.getFilter()); + } + + @ParameterizedTest + @ValueSource(strings = {"SHOW INDEXES IN TABLE t", "SHOW INDEX FROM t LIMIT 3", + "SHOW INDEX FROM t FROM d FROM e", "SHOW COLUMNS FROM t LIMIT 3"}) + void otherFormsFallBackInsteadOfFailing(String sql) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.SNOWFLAKE, Dialect.MYSQL}) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(dialect)); + assertInstanceOf(UnsupportedStatement.class, statement); + } + } + + @Test + void mySqlTakesAStringAsTheLikePattern() throws JSQLParserException { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.MARIADB}) { + ShowColumnsStatement columns = (ShowColumnsStatement) assertSqlCanBeParsedAndDeparsed( + "SHOW COLUMNS FROM t LIKE \"a%\"", true, + parser -> parser.withDialect(dialect)); + assertEquals("a%", ((StringValue) columns.getLikeExpression()).getValue()); + + // MySQL reports a syntax error for these + for (String sql : new String[] {"SHOW COLUMNS FROM t LIKE a", + "SHOW TABLE STATUS LIKE 1", "SHOW TABLE STATUS LIKE CONCAT('a', '%')"}) { + assertInstanceOf(UnsupportedStatement.class, assertSqlCanBeParsedAndDeparsed(sql, + true, parser -> parser.withDialect(dialect)), sql); + } + } + // without a dialect the pattern is any simple expression, as before + ShowTableStatusStatement status = + (ShowTableStatusStatement) assertSqlCanBeParsedAndDeparsed( + "SHOW TABLE STATUS LIKE CONCAT('a', '%')", true); + assertInstanceOf(Expression.class, status.getLikeExpression()); + } + + @Test + void showTablesRendersWithoutModifiersOrSelectionMode() { + ShowTablesStatement show = new ShowTablesStatement(); + assertEquals("SHOW TABLES", show.toString()); + + show.setDbName("db"); + assertEquals("SHOW TABLES FROM db", show.toString()); + + show.setModifiers(EnumSet.of(Modifiers.FULL)); + show.setSelectionMode(SelectionMode.IN); + assertDeparse(show, "SHOW FULL TABLES IN db"); + } + + @Test + void legacySettersWorkInEitherOrder() { + ShowTablesStatement tables = new ShowTablesStatement(); + tables.setSelectionMode(SelectionMode.IN); + assertEquals(SelectionMode.IN, tables.getSelectionMode()); + assertNull(tables.getDbName()); + assertEquals("SHOW TABLES", tables.toString()); + tables.setDbName("db"); + assertEquals("SHOW TABLES IN db", tables.toString()); + tables.setDbName(null); + tables.setSelectionMode(null); + assertNull(tables.getSelectionMode()); + assertNull(tables.getDbSelection()); + + ShowTableStatusStatement status = new ShowTableStatusStatement().withDbName("db") + .withSelectionMode(SelectionMode.IN); + assertEquals("SHOW TABLE STATUS IN db", status.toString()); + assertEquals(SelectionMode.FROM, new ShowTableStatusStatement().getSelectionMode()); + + ShowColumnsStatement columns = new ShowColumnsStatement("t"); + columns.setDbSelectionMode(SelectionMode.IN); + columns.setDbName("db"); + assertEquals("SHOW COLUMNS FROM t IN db", columns.toString()); + assertEquals(new ShowDbSelection(SelectionMode.IN, "db").toString(), + columns.getDbSelection().toString()); + } + + @Test + void legacyFilterSettersReplaceTheFilter() { + ShowTablesStatement show = new ShowTablesStatement(); + show.setLikeExpression(new StringValue("a%")); + assertEquals("SHOW TABLES LIKE 'a%'", show.toString()); + + Expression condition = new Column("Tables_in_db"); + show.setWhereCondition(condition); + assertNull(show.getLikeExpression()); + assertSame(condition, show.getWhereCondition()); + + // clearing the other kind keeps the filter + show.setLikeExpression(null); + assertSame(condition, show.getWhereCondition()); + show.setWhereCondition(null); + assertNull(show.getFilter()); + + ShowTableStatusStatement status = + new ShowTableStatusStatement().withLikeExpression(new StringValue("t%")); + status.setWhereCondition(new Column("Rows")); + assertEquals("SHOW TABLE STATUS WHERE Rows", status.toString()); + } + + @Test + void sharedClauseValues() { + ShowFilter filter = ShowFilter.where(new Column("a")); + assertEquals(ShowFilter.Kind.WHERE, filter.getKind()); + assertEquals("WHERE a", filter.toString()); + assertNull(ShowFilter.likeExpression(filter)); + assertEquals("a", ShowFilter.whereCondition(filter).toString()); + assertEquals(ShowFilter.Kind.LIKE, new ShowFilter().withKind(null).getKind()); + assertEquals("LIKE 'x'", + new ShowFilter().withExpression(new StringValue("x")).toString()); + + ShowDbSelection selection = new ShowDbSelection(null, "db"); + assertEquals(SelectionMode.FROM, selection.getSelectionMode()); + assertTrue(ShowDbSelection.isPresent(selection)); + assertFalse(ShowDbSelection.isPresent(new ShowDbSelection())); + assertEquals("IN db", selection.withSelectionMode(SelectionMode.IN).toString()); + assertEquals("FROM x", new ShowDbSelection().withName("x").toString()); + } + + @Test + void statementDeParserPrintsFiltersWithTheExpressionDeParser() + throws JSQLParserException { + assertEquals("SHOW TABLES LIKE ", ShowExpressionDeParsing.deparse( + "SHOW TABLES LIKE 'a%'")); + assertEquals("SHOW FULL COLUMNS FROM t LIKE ", ShowExpressionDeParsing.deparse( + "SHOW FULL COLUMNS FROM t LIKE 'c%'")); + assertEquals("SHOW TABLE STATUS FROM db WHERE Comment = ", + ShowExpressionDeParsing.deparse("SHOW TABLE STATUS FROM db WHERE Comment = 'x'")); + assertEquals("SHOW INDEX FROM t WHERE Key_name = ", + ShowExpressionDeParsing.deparse("SHOW INDEX FROM t WHERE Key_name = 'PRIMARY'")); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/show/ShowCreateStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/show/ShowCreateStatementTest.java new file mode 100644 index 0000000000..2d82488e10 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/show/ShowCreateStatementTest.java @@ -0,0 +1,212 @@ +/*- + * #%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.show; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertTrue; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.create.user.UserAccount; +import net.sf.jsqlparser.statement.show.ShowCreateStatement.ObjectType; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class ShowCreateStatementTest { + + private static final List> DIALECTS = List.of(parser -> { + }, parser -> parser.withDialect(Dialect.MYSQL), + parser -> parser.withDialect(Dialect.MARIADB)); + + /** Parses without a dialect and with MySQL and MariaDB, then deparses and reparses. */ + private static ShowCreateStatement roundTrip(String sql) throws JSQLParserException { + ShowCreateStatement result = null; + for (Consumer dialect : DIALECTS) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(ShowCreateStatement.class, statement); + assertDeparse(statement, sql); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + result = (ShowCreateStatement) statement; + } + return result; + } + + @Test + void createTable() throws JSQLParserException { + ShowCreateStatement show = roundTrip("SHOW CREATE TABLE c20"); + + assertEquals(ObjectType.TABLE, show.getObjectType()); + assertEquals("c20", show.getName().getFullyQualifiedName()); + assertNull(show.getDatabaseName()); + assertNull(show.getAccount()); + } + + @ParameterizedTest + @CsvSource({ + "SHOW CREATE TABLE `db`.`t`, TABLE, `db`.`t`", + "SHOW CREATE VIEW db.v, VIEW, db.v", + "SHOW CREATE PROCEDURE gp13, PROCEDURE, gp13", + "SHOW CREATE FUNCTION db.f, FUNCTION, db.f", + "SHOW CREATE TRIGGER tr, TRIGGER, tr", + "SHOW CREATE EVENT db.e, EVENT, db.e" + }) + void namedObjects(String sql, ObjectType type, String name) throws JSQLParserException { + ShowCreateStatement show = roundTrip(sql); + + assertEquals(type, show.getObjectType()); + assertTrue(type.isNamedByTable()); + assertEquals(name, show.getName().getFullyQualifiedName()); + } + + @Test + void createDatabase() throws JSQLParserException { + ShowCreateStatement show = roundTrip("SHOW CREATE DATABASE `shop`"); + + assertEquals(ObjectType.DATABASE, show.getObjectType()); + assertFalse(show.isSchemaKeyword()); + assertFalse(show.isIfNotExists()); + assertEquals("`shop`", show.getDatabaseName()); + assertNull(show.getName()); + } + + @Test + void createSchemaIfNotExists() throws JSQLParserException { + ShowCreateStatement show = roundTrip("SHOW CREATE SCHEMA IF NOT EXISTS shop"); + + assertEquals(ObjectType.DATABASE, show.getObjectType()); + assertTrue(show.isSchemaKeyword()); + assertTrue(show.isIfNotExists()); + assertEquals("shop", show.getDatabaseName()); + } + + @Test + void createUserWithHost() throws JSQLParserException { + ShowCreateStatement show = roundTrip("SHOW CREATE USER 'app'@'%'"); + + assertEquals(ObjectType.USER, show.getObjectType()); + assertEquals("app", show.getAccount().getUser().getNotExcapedValue()); + assertEquals("%", show.getAccount().getHost().getNotExcapedValue()); + assertNull(show.getAccount().getAuthentication()); + assertFalse(show.isCurrentUser()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SHOW CREATE USER app", + "SHOW CREATE USER 'app'", + "SHOW CREATE USER `app`@`localhost`", + "SHOW CREATE USER app@localhost", + "SHOW CREATE USER app@'%'", + "SHOW CREATE USER 'app'@localhost", + "SHOW CREATE USER \"app\"@\"%\"" + }) + void accountSpellings(String sql) throws JSQLParserException { + ShowCreateStatement show = roundTrip(sql); + + assertEquals(ObjectType.USER, show.getObjectType()); + assertFalse(show.isCurrentUser()); + assertEquals("app", show.getAccount().getUser().getValue()); + } + + @Test + void currentUser() throws JSQLParserException { + ShowCreateStatement show = roundTrip("SHOW CREATE USER CURRENT_USER"); + assertTrue(show.isCurrentUser()); + assertFalse(show.isCurrentUserParentheses()); + + show = roundTrip("SHOW CREATE USER CURRENT_USER()"); + assertTrue(show.isCurrentUser()); + assertTrue(show.isCurrentUserParentheses()); + assertNull(show.getAccount().getHost()); + } + + @Test + void keywordsAreCaseInsensitive() throws JSQLParserException { + assertEquals("SHOW CREATE SCHEMA IF NOT EXISTS db", + CCJSqlParserUtil.parse("show create schema if not exists db").toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SHOW CREATE TEMPORARY TABLE t", + "SHOW CREATE TABLE t FORMAT TabSeparated", + "SHOW CREATE TABLE t AS SERDE", + "SHOW CREATE SEQUENCE s", + "SHOW CREATE PACKAGE BODY p", + "SHOW CREATE VIEW IF NOT EXISTS v", + "SHOW CREATE DATABASE IF NOT EXISTS", + "SHOW CREATE USER u IDENTIFIED BY 'x'", + "SHOW CREATE TABLE" + }) + void otherFormsRemainUnsupported(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true); + assertInstanceOf(UnsupportedStatement.class, statement); + } + + @Test + void endsAtTheStatementBoundary() throws JSQLParserException { + Statements statements = CCJSqlParserUtil.parseStatements( + "SHOW CREATE TABLE a;\nSHOW CREATE USER CURRENT_USER();\nSELECT 1", + parser -> parser.withDialect(Dialect.MYSQL)); + + assertEquals(3, statements.size()); + assertInstanceOf(ShowCreateStatement.class, statements.get(0)); + assertInstanceOf(ShowCreateStatement.class, statements.get(1)); + } + + @Test + void findsTablesAndViewsOnly() throws JSQLParserException { + assertThat(TablesNamesFinder.findTables("SHOW CREATE TABLE s.t")).containsExactly("s.t"); + assertThat(TablesNamesFinder.findTables("SHOW CREATE VIEW v")).containsExactly("v"); + assertThat(TablesNamesFinder.findTables("SHOW CREATE TRIGGER tr")).isEmpty(); + assertThat(TablesNamesFinder.findTables("SHOW CREATE DATABASE db")).isEmpty(); + assertThat(TablesNamesFinder.findTables("SHOW CREATE USER u")).isEmpty(); + } + + @Test + void buildsAndDeparses() { + assertDeparse(new ShowCreateStatement(ObjectType.VIEW, new Table("s", "v")), + "SHOW CREATE VIEW s.v"); + assertDeparse(new ShowCreateStatement().withObjectType(ObjectType.DATABASE) + .withSchemaKeyword(true).withIfNotExists(true).withDatabaseName("db"), + "SHOW CREATE SCHEMA IF NOT EXISTS db"); + UserAccount account = new UserAccount().withUser(new StringValue("'app'")) + .withHost(new StringValue("'localhost'")); + assertDeparse(new ShowCreateStatement().withObjectType(ObjectType.USER) + .withAccount(account), "SHOW CREATE USER 'app'@'localhost'"); + } + + @Test + void reportsMetadataFeatures() throws JSQLParserException { + StatementFeatures features = CCJSqlParserUtil.parse("SHOW CREATE TABLE t").getFeatures(); + + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/show/ShowExpressionDeParsing.java b/src/test/java/net/sf/jsqlparser/statement/show/ShowExpressionDeParsing.java new file mode 100644 index 0000000000..f1e0fcf504 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/show/ShowExpressionDeParsing.java @@ -0,0 +1,45 @@ +/*- + * #%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.show; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +import net.sf.jsqlparser.util.deparser.StatementDeParser; + +/** Deparses a SHOW statement with an expression deparser that marks the values it prints. */ +final class ShowExpressionDeParsing { + + private ShowExpressionDeParsing() { + // utility class + } + + /** Strings print as {@code } and numbers as {@code #value}. */ + static String deparse(String sql) throws JSQLParserException { + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(StringValue value, S context) { + return getBuilder().append('<').append(value.getValue()).append('>'); + } + + @Override + public StringBuilder visit(LongValue value, S context) { + return getBuilder().append('#').append(value.getValue()); + } + }; + StringBuilder builder = new StringBuilder(); + CCJSqlParserUtil.parse(sql) + .accept(new StatementDeParser(expressions, new SelectDeParser(), builder)); + return builder.toString(); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/show/ShowTableStatusStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/show/ShowTableStatusStatementTest.java new file mode 100644 index 0000000000..0905f32853 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/show/ShowTableStatusStatementTest.java @@ -0,0 +1,143 @@ +/*- + * #%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.show; + +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +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.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParser; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.ShowStatement; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementFeatures; +import net.sf.jsqlparser.statement.Statements; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.UnsupportedStatement; +import net.sf.jsqlparser.statement.show.ShowTablesStatement.SelectionMode; +import net.sf.jsqlparser.util.TablesNamesFinder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class ShowTableStatusStatementTest { + + private static final List> DIALECTS = List.of(parser -> { + }, parser -> parser.withDialect(Dialect.MYSQL), + parser -> parser.withDialect(Dialect.MARIADB)); + + /** Parses without a dialect and with MySQL and MariaDB, then deparses and reparses. */ + private static ShowTableStatusStatement roundTrip(String sql) throws JSQLParserException { + ShowTableStatusStatement result = null; + for (Consumer dialect : DIALECTS) { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect); + assertInstanceOf(ShowTableStatusStatement.class, statement); + assertDeparse(statement, sql); + assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString()); + result = (ShowTableStatusStatement) statement; + } + return result; + } + + @Test + void currentDatabase() throws JSQLParserException { + ShowTableStatusStatement show = roundTrip("SHOW TABLE STATUS"); + + assertNull(show.getDbName()); + assertNull(show.getLikeExpression()); + assertNull(show.getWhereCondition()); + } + + @Test + void likePattern() throws JSQLParserException { + ShowTableStatusStatement show = roundTrip("SHOW TABLE STATUS LIKE 'c0%'"); + + assertEquals("c0%", ((StringValue) show.getLikeExpression()).getValue()); + } + + @Test + void databaseAndWhere() throws JSQLParserException { + ShowTableStatusStatement show = roundTrip("SHOW TABLE STATUS FROM v WHERE Comment <> ''"); + + assertEquals(SelectionMode.FROM, show.getSelectionMode()); + assertEquals("v", show.getDbName()); + assertEquals("Comment <> ''", show.getWhereCondition().toString()); + } + + @Test + void inDatabaseAndLike() throws JSQLParserException { + ShowTableStatusStatement show = roundTrip("SHOW TABLE STATUS IN `db` LIKE 'a%'"); + + assertEquals(SelectionMode.IN, show.getSelectionMode()); + assertEquals("`db`", show.getDbName()); + } + + @Test + void keywordsAreCaseInsensitive() throws JSQLParserException { + assertEquals("SHOW TABLE STATUS IN db", + CCJSqlParserUtil.parse("show table status in db").toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SHOW TABLE foo", + "SHOW TABLE EXTENDED IN db LIKE 'x'", + "SHOW TABLE STATUS FROM db LIMIT 3" + }) + void otherTableFormsRemainUnsupported(String sql) throws JSQLParserException { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true); + assertInstanceOf(UnsupportedStatement.class, statement); + } + + @Test + void neighbouringShowFormsAreUnchanged() throws JSQLParserException { + assertInstanceOf(ShowTablesStatement.class, CCJSqlParserUtil.parse("SHOW TABLES")); + assertInstanceOf(ShowStatement.class, CCJSqlParserUtil.parse("SHOW STATUS")); + assertSqlCanBeParsedAndDeparsed("SELECT status FROM t WHERE status = 1"); + } + + @Test + void endsAtTheStatementBoundary() throws JSQLParserException { + Statements statements = + CCJSqlParserUtil.parseStatements("SHOW TABLE STATUS;\nSHOW TABLES"); + + assertEquals(2, statements.size()); + assertInstanceOf(ShowTableStatusStatement.class, statements.get(0)); + } + + @Test + void namesNoTable() throws JSQLParserException { + assertThat(TablesNamesFinder.findTables("SHOW TABLE STATUS FROM db LIKE 't%'")).isEmpty(); + } + + @Test + void buildsAndDeparses() { + ShowTableStatusStatement show = new ShowTableStatusStatement() + .withSelectionMode(SelectionMode.IN).withDbName("db") + .withLikeExpression(new StringValue("t%")); + + assertDeparse(show, "SHOW TABLE STATUS IN db LIKE 't%'"); + } + + @Test + void reportsMetadataFeatures() throws JSQLParserException { + StatementFeatures features = CCJSqlParserUtil.parse("SHOW TABLE STATUS").getFeatures(); + + assertThat(features.getCertain()).containsExactly(StmtFeature.RETURNS_RESULT_SET); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/truncate/OracleTruncateTest.java b/src/test/java/net/sf/jsqlparser/statement/truncate/OracleTruncateTest.java new file mode 100644 index 0000000000..1c49a1aff9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/truncate/OracleTruncateTest.java @@ -0,0 +1,108 @@ +/*- + * #%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.truncate; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +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.CascadeBehavior; +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 OracleTruncateTest { + @ParameterizedTest + @ValueSource(strings = {"samples", "hr.\"Sample.Table\""}) + void preservesLogStorageAndCascadeOptions(String table) throws JSQLParserException { + for (Truncate.MaterializedViewLogOption log : new Truncate.MaterializedViewLogOption[] { + null, Truncate.MaterializedViewLogOption.PRESERVE, + Truncate.MaterializedViewLogOption.PURGE}) { + for (Truncate.StorageOption storage : new Truncate.StorageOption[] {null, + Truncate.StorageOption.DROP, Truncate.StorageOption.DROP_ALL, + Truncate.StorageOption.REUSE}) { + for (String cascade : new String[] {"", " CASCADE"}) { + String sql = "TRUNCATE TABLE " + table + + (log == null ? "" : " " + log + " MATERIALIZED VIEW LOG") + + (storage == null ? "" + : storage == Truncate.StorageOption.DROP_ALL + ? " DROP ALL STORAGE" + : " " + storage + " STORAGE") + + cascade; + for (Dialect dialect : new Dialect[] {null, Dialect.ORACLE}) { + Truncate truncate = parse(sql, dialect); + assertEquals(table, truncate.getTable().getFullyQualifiedName()); + assertEquals(log, truncate.getMaterializedViewLogOption()); + assertEquals(storage, truncate.getStorageOption()); + assertEquals(cascade.isEmpty() ? null : CascadeBehavior.CASCADE, + truncate.getDropBehavior()); + assertNull(truncate.getIdentityOption()); + assertEquals(sql, truncate.toString()); + roundTrip(truncate, dialect); + assertEquals(2, + CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + } + } + } + } + + @Test + void supportsModelConstructionAndClearingOptions() throws JSQLParserException { + Truncate truncate = new Truncate().withTableToken(true).withTable(new Table("samples")) + .withMaterializedViewLogOption(Truncate.MaterializedViewLogOption.PURGE) + .withStorageOption(Truncate.StorageOption.DROP_ALL).withCascade(true); + assertEquals("TRUNCATE TABLE samples PURGE MATERIALIZED VIEW LOG DROP ALL STORAGE CASCADE", + truncate.toString()); + roundTrip(truncate, Dialect.ORACLE); + truncate.setMaterializedViewLogOption(Truncate.MaterializedViewLogOption.PRESERVE); + truncate.setStorageOption(Truncate.StorageOption.REUSE); + assertEquals("TRUNCATE TABLE samples PRESERVE MATERIALIZED VIEW LOG REUSE STORAGE CASCADE", + truncate.toString()); + roundTrip(truncate, null); + truncate.setMaterializedViewLogOption(null); + truncate.setStorageOption(null); + assertEquals("TRUNCATE TABLE samples CASCADE", truncate.toString()); + roundTrip(truncate, null); + } + + @ParameterizedTest + @ValueSource(strings = {"DROP", "DROP ALL", "REUSE", "PRESERVE MATERIALIZED VIEW", + "PURGE LOG", "DROP STORAGE REUSE STORAGE", + "REUSE STORAGE PURGE MATERIALIZED VIEW LOG", "CASCADE REUSE STORAGE"}) + void rejectsIncompleteRepeatedAndOutOfOrderOptions(String options) { + assertThrows(JSQLParserException.class, + () -> parse("TRUNCATE TABLE samples " + options, Dialect.ORACLE)); + } + + private static Truncate parse(String sql, Dialect dialect) throws JSQLParserException { + return (Truncate) CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + + private static void roundTrip(Truncate truncate, Dialect dialect) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + truncate.accept(new StatementDeParser(output), null); + assertEquals(truncate.toString(), output.toString()); + Truncate reparsed = parse(output.toString(), dialect); + assertEquals(truncate.getMaterializedViewLogOption(), + reparsed.getMaterializedViewLogOption()); + assertEquals(truncate.getStorageOption(), reparsed.getStorageOption()); + assertEquals(output.toString(), reparsed.toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/truncate/PostgreSqlTruncateTest.java b/src/test/java/net/sf/jsqlparser/statement/truncate/PostgreSqlTruncateTest.java new file mode 100644 index 0000000000..054dab64aa --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/truncate/PostgreSqlTruncateTest.java @@ -0,0 +1,105 @@ +/*- + * #%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.truncate; + +import static org.junit.jupiter.api.Assertions.*; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.CascadeBehavior; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.lock.LockStatement; +import net.sf.jsqlparser.util.TablesNamesFinder; +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 PostgreSqlTruncateTest { + @ParameterizedTest + @ValueSource(strings = {"t", "ONLY t", "t *", "ONLY (public.t)", + "ONLY t, public.u *", "t, ONLY u", "ONLY t, ONLY u"}) + void targetsAndOptionalClausesRoundTrip(String targets) throws JSQLParserException { + for (String identity : new String[] {"", " RESTART IDENTITY", " CONTINUE IDENTITY"}) { + for (String behavior : new String[] {"", " CASCADE", " RESTRICT"}) { + for (String tableKeyword : new String[] {"", " TABLE"}) { + String sql = "TRUNCATE" + tableKeyword + " " + targets + identity + behavior; + Truncate statement = (Truncate) CCJSqlParserUtil.parse(sql); + assertEquals(sql, statement.toString()); + assertEquals(targets.contains(",") ? 2 : 1, statement.getTargets().size()); + assertEquals(identity.contains("RESTART") ? Truncate.IdentityOption.RESTART + : identity.contains("CONTINUE") ? Truncate.IdentityOption.CONTINUE + : null, + statement.getIdentityOption()); + assertEquals(behavior.contains("CASCADE") ? CascadeBehavior.CASCADE + : behavior.contains("RESTRICT") ? CascadeBehavior.RESTRICT : null, + statement.getDropBehavior()); + roundTrip(statement); + assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1").size()); + } + } + } + } + + @Test + void visitsEveryTableAndKeepsLegacyMutationsLive() throws JSQLParserException { + Truncate statement = (Truncate) CCJSqlParserUtil.parse( + "TRUNCATE ONLY a, b *, ONLY c RESTART IDENTITY CASCADE"); + assertEquals(Set.of("a", "b", "c"), new TablesNamesFinder().getTables(statement)); + assertEquals("c", statement.getTable().getName()); + statement.setTable(new Table("x")); + statement.getTables().set(1, new Table("y")); + assertTrue(statement.getTargets().get(1).isIncludeDescendants()); + statement.getTargets().get(2).setOnly(false); + statement.getTables().add(new Table("z")); + statement.setCascade(false); + statement.setDropBehavior(CascadeBehavior.RESTRICT); + assertFalse(statement.getCascade()); + assertEquals("TRUNCATE ONLY a, y *, x, z RESTART IDENTITY RESTRICT", statement.toString()); + assertEquals(Set.of("a", "y", "x", "z"), new TablesNamesFinder().getTables(statement)); + statement.getTables().remove(2); + roundTrip(statement); + statement.setTables(statement.getTables()); + assertEquals(3, statement.getTargets().size()); + statement.setTables(List.of(new Table("replacement"))); + assertTrue(statement.isOnly()); + assertEquals("replacement", statement.getTable().getName()); + } + + @Test + void lockAndTruncateShareRelationTargets() throws JSQLParserException { + LockStatement lock = (LockStatement) CCJSqlParserUtil.parse( + "LOCK TABLE ONLY (public.t), u * IN ACCESS SHARE MODE"); + assertEquals(LockStatement.Scope.ONLY, lock.getTargets().get(0).getScope()); + assertTrue(lock.getTargets().get(0).isParenthesized()); + assertEquals(LockStatement.Scope.INCLUDING_DESCENDANTS, + lock.getTargets().get(1).getScope()); + lock.getTargets().get(0).setScope(LockStatement.Scope.DEFAULT); + assertFalse(lock.getTargets().get(0).isParenthesized()); + roundTrip(lock); + } + + @ParameterizedTest + @ValueSource(strings = {"ONLY t *", "(t)", "t RESTART", "t CONTINUE", + "t RESTART IDENTITY CONTINUE IDENTITY", "t CASCADE RESTRICT", "t,", + "t RESTRICT RESTART IDENTITY"}) + void rejectsMalformedTargetsAndClauses(String sql) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse("TRUNCATE " + sql)); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), CCJSqlParserUtil.parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateMultipleTablesTest.java b/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateMultipleTablesTest.java index 18894c8ca0..494a0cdec4 100644 --- a/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateMultipleTablesTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateMultipleTablesTest.java @@ -13,7 +13,6 @@ import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static org.junit.jupiter.api.Assertions.assertEquals; 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.io.StringReader; @@ -86,8 +85,8 @@ public void testTruncateDeparse() throws JSQLParserException { String statement = "TRUNCATE TABLE foo, bar"; assertSqlCanBeParsedAndDeparsed(statement); assertDeparse(new Truncate() - .withTables(List.of(new Table("foo"), new Table("bar"))) - .withTableToken(true), statement); + .withTables(List.of(new Table("foo"), new Table("bar"))) + .withTableToken(true), statement); } @Test @@ -95,16 +94,18 @@ public void testTruncateCascadeDeparse() throws JSQLParserException { String statement = "TRUNCATE TABLE foo, bar CASCADE"; assertSqlCanBeParsedAndDeparsed(statement); assertDeparse(new Truncate() - .withTables(List.of(new Table("foo"), new Table("bar"))) - .withTableToken(true) - .withCascade(true), statement); + .withTables(List.of(new Table("foo"), new Table("bar"))) + .withTableToken(true) + .withCascade(true), statement); } @Test - public void testTruncateDoesNotAllowOnlyWithMultipleTables() { + public void testTruncateAllowsOnlyForAnIndividualTarget() throws JSQLParserException { String statement = "TRUNCATE TABLE ONLY foo, bar"; - assertThrows(JSQLParserException.class, - () -> parserManager.parse(new StringReader(statement))); + Truncate truncate = (Truncate) parserManager.parse(new StringReader(statement)); + assertEquals(statement, truncate.toString()); + assertTrue(truncate.getTargets().get(0).isOnly()); + assertEquals(2, truncate.getTargets().size()); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateTest.java b/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateTest.java index 698d2a5b84..129b3f43f0 100644 --- a/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/truncate/TruncateTest.java @@ -18,7 +18,6 @@ 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 static org.junit.jupiter.api.Assertions.assertThrows; import org.junit.jupiter.api.Test; @@ -72,8 +71,8 @@ public void testTruncateDeparse() throws JSQLParserException { String statement = "TRUNCATE TABLE foo"; assertSqlCanBeParsedAndDeparsed(statement); assertDeparse(new Truncate() - .withTable(new Table("foo")) - .withTableToken(true), statement); + .withTable(new Table("foo")) + .withTableToken(true), statement); } @Test @@ -81,9 +80,9 @@ public void testTruncateCascadeDeparse() throws JSQLParserException { String statement = "TRUNCATE TABLE foo CASCADE"; assertSqlCanBeParsedAndDeparsed(statement); assertDeparse(new Truncate() - .withTable(new Table("foo")) - .withTableToken(true) - .withCascade(true), statement); + .withTable(new Table("foo")) + .withTableToken(true) + .withCascade(true), statement); } @Test @@ -91,9 +90,9 @@ public void testTruncateOnlyDeparse() throws JSQLParserException { String statement = "TRUNCATE TABLE ONLY foo"; assertSqlCanBeParsedAndDeparsed(statement); assertDeparse(new Truncate() - .withTable(new Table("foo")) - .withTableToken(true) - .withOnly(true), statement); + .withTable(new Table("foo")) + .withTableToken(true) + .withOnly(true), statement); } @Test @@ -101,16 +100,15 @@ public void testTruncateOnlyAndCascadeDeparse() throws JSQLParserException { String statement = "TRUNCATE ONLY foo CASCADE"; assertSqlCanBeParsedAndDeparsed(statement); assertDeparse(new Truncate() - .withTable(new Table("foo")) - .withCascade(true) - .withOnly(true), statement); + .withTable(new Table("foo")) + .withCascade(true) + .withOnly(true), statement); } @Test - public void throwsParseWhenOnlyUsedWithMultipleTables() { + public void onlyAppliesToItsOwnTarget() throws JSQLParserException { String statement = "TRUNCATE TABLE ONLY foo, bar"; - assertThrows(JSQLParserException.class, - () -> parserManager.parse(new StringReader(statement))); + assertSqlCanBeParsedAndDeparsed(statement); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/update/UpdateSetParsingTest.java b/src/test/java/net/sf/jsqlparser/statement/update/UpdateSetParsingTest.java new file mode 100644 index 0000000000..7cdcf228a4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/update/UpdateSetParsingTest.java @@ -0,0 +1,189 @@ +/*- + * #%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.update; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.insert.Insert; +import net.sf.jsqlparser.statement.merge.Merge; +import net.sf.jsqlparser.statement.merge.MergeUpdate; +import net.sf.jsqlparser.statement.piped.FromQuery; +import net.sf.jsqlparser.statement.piped.SetPipeOperator; +import net.sf.jsqlparser.statement.select.ParenthesedSelect; +import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.upsert.Upsert; +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.Arguments; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class UpdateSetParsingTest { + + // These are consumers of the shared grammar, not claims of dialect-specific SQL validity. + enum EntryPoint { + UPDATE("UPDATE t SET "), INSERT_SET("INSERT INTO t SET "), INSERT_DUPLICATE( + "INSERT INTO t VALUES (0) ON DUPLICATE KEY UPDATE "), INSERT_CONFLICT( + "INSERT INTO t VALUES (0) ON CONFLICT (id) DO UPDATE SET "), MERGE_UPDATE( + "MERGE INTO t USING s ON t.id = s.id WHEN MATCHED THEN UPDATE SET "), UPSERT_SET( + "UPSERT INTO t SET "), PIPE_SET( + "FROM t |> SET "), SELECT_SETTINGS( + "SELECT * FROM t SETTINGS "); + + private final String prefix; + + EntryPoint(String prefix) { + this.prefix = prefix; + } + + List getUpdateSets(Statement statement) { + switch (this) { + case UPDATE: + return ((Update) statement).getUpdateSets(); + case INSERT_SET: + return ((Insert) statement).getSetUpdateSets(); + case INSERT_DUPLICATE: + return ((Insert) statement).getDuplicateAction().getUpdateSets(); + case INSERT_CONFLICT: + return ((Insert) statement).getConflictAction().getUpdateSets(); + case MERGE_UPDATE: + return ((MergeUpdate) ((Merge) statement).getOperations().get(0)) + .getUpdateSets(); + case UPSERT_SET: + return ((Upsert) statement).getUpdateSets(); + case PIPE_SET: + return ((SetPipeOperator) ((FromQuery) statement).getPipeOperators().get(0)) + .getUpdateSets(); + case SELECT_SETTINGS: + return ((PlainSelect) statement).getSettings(); + default: + throw new AssertionError(this); + } + } + } + + @ParameterizedTest + @EnumSource(EntryPoint.class) + void scalarAssignments(EntryPoint entryPoint) throws JSQLParserException { + assertAssignments(entryPoint, "a = 1, b = 2, c = 3", + new String[][] {{"a"}, {"b"}, {"c"}}, + new String[][] {{"1"}, {"2"}, {"3"}}); + } + + @ParameterizedTest + @EnumSource(EntryPoint.class) + void singleTupleAssignment(EntryPoint entryPoint) throws JSQLParserException { + assertAssignments(entryPoint, "(b, c) = (2, 3)", + new String[][] {{"b", "c"}}, new String[][] {{"2", "3"}}); + } + + @ParameterizedTest + @EnumSource(EntryPoint.class) + void tupleAssignmentFirst(EntryPoint entryPoint) throws JSQLParserException { + assertAssignments(entryPoint, "(b, c) = (2, 3), a = 1", + new String[][] {{"b", "c"}, {"a"}}, new String[][] {{"2", "3"}, {"1"}}); + } + + static Stream assignmentsAfterScalar() { + return Arrays.stream(EntryPoint.values()).flatMap(entryPoint -> Stream.of( + Arguments.of(entryPoint, "a = 1, (b, c) = (2, 3)", + new String[][] {{"a"}, {"b", "c"}}, + new String[][] {{"1"}, {"2", "3"}}), + Arguments.of(entryPoint, "a = 1, (b, c) = (2, 3), d = 4", + new String[][] {{"a"}, {"b", "c"}, {"d"}}, + new String[][] {{"1"}, {"2", "3"}, {"4"}}), + Arguments.of(entryPoint, "a = 1, (b, c) = (2, 3), (d, e) = (4, 5)", + new String[][] {{"a"}, {"b", "c"}, {"d", "e"}}, + new String[][] {{"1"}, {"2", "3"}, {"4", "5"}}), + Arguments.of(entryPoint, "a = 1, (b, c) = (COALESCE(b, 2), c + 3), d = ?", + new String[][] {{"a"}, {"b", "c"}, {"d"}}, + new String[][] {{"1"}, {"COALESCE(b, 2)", "c + 3"}, {"?"}}), + Arguments.of(entryPoint, "a = 1, (b, c) = (SELECT x, y FROM s), d = 4", + new String[][] {{"a"}, {"b", "c"}, {"d"}}, + new String[][] {{"1"}, {"(SELECT x, y FROM s)"}, {"4"}}))); + } + + @ParameterizedTest + @MethodSource("assignmentsAfterScalar") + void tupleAssignmentsAfterScalar(EntryPoint entryPoint, String assignments, + String[][] columns, String[][] values) throws JSQLParserException { + assertAssignments(entryPoint, assignments, columns, values); + } + + @Test + void tupleSubqueryAndFollowingClauses() throws JSQLParserException { + String sql = "UPDATE t SET a = DEFAULT, (b, c) = (SELECT x, y FROM s WHERE s.id = t.id), " + + "d = 4 WHERE t.id = 1 RETURNING a, b, c, d"; + Statement statement = assertSqlCanBeParsedAndDeparsed(sql); + assertUpdateSets(EntryPoint.UPDATE.getUpdateSets(statement), + new String[][] {{"a"}, {"b", "c"}, {"d"}}, + new String[][] {{"DEFAULT"}, {"(SELECT x, y FROM s WHERE s.id = t.id)"}, {"4"}}); + Update update = (Update) statement; + assertEquals("t.id = 1", update.getWhere().toString()); + assertEquals(" RETURNING a, b, c, d", update.getReturningClause().toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"a = 1 (b, c) = (2, 3)", "(b, c) = (2, 3) (d, e) = (4, 5)", + "a = 1,", "a = 1,, (b, c) = (2, 3)"}) + void rejectsMissingOrExtraSeparators(String assignments) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(EntryPoint.UPDATE.prefix + assignments)); + } + + private static void assertAssignments(EntryPoint entryPoint, String assignments, + String[][] columns, String[][] values) throws JSQLParserException { + Statement statement = + assertSqlCanBeParsedAndDeparsed(entryPoint.prefix + assignments, true); + assertUpdateSets(entryPoint.getUpdateSets(statement), columns, values); + assertUpdateSets(entryPoint.getUpdateSets(CCJSqlParserUtil.parse(statement.toString())), + columns, values); + StringBuilder builder = new StringBuilder(); + statement.accept(new StatementDeParser(builder)); + assertUpdateSets(entryPoint.getUpdateSets(CCJSqlParserUtil.parse(builder.toString())), + columns, values); + } + + private static void assertUpdateSets(List updateSets, String[][] columns, + String[][] values) { + assertEquals(columns.length, updateSets.size()); + for (int i = 0; i < columns.length; i++) { + UpdateSet updateSet = updateSets.get(i); + assertEquals(columns[i].length, updateSet.getColumns().size()); + assertEquals(values[i].length, updateSet.getValues().size()); + for (int j = 0; j < columns[i].length; j++) { + assertEquals(columns[i][j], updateSet.getColumn(j).getColumnName()); + } + for (int j = 0; j < values[i].length; j++) { + assertEquals(values[i][j], updateSet.getValue(j).toString()); + } + if (columns[i].length > 1) { + assertInstanceOf(ParenthesedExpressionList.class, updateSet.getColumns()); + if (values[i][0].startsWith("(SELECT")) { + assertInstanceOf(ParenthesedSelect.class, updateSet.getValue(0)); + } else { + assertInstanceOf(ParenthesedExpressionList.class, updateSet.getValues()); + } + } + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/ActiveTableDefinitionTraversalTest.java b/src/test/java/net/sf/jsqlparser/util/ActiveTableDefinitionTraversalTest.java new file mode 100644 index 0000000000..58e982c23c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/ActiveTableDefinitionTraversalTest.java @@ -0,0 +1,251 @@ +/*- + * #%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.util; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression; +import net.sf.jsqlparser.statement.alter.AlterOperation; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDataType; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnSetDefault; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnDefinition; +import net.sf.jsqlparser.statement.create.table.ColumnOption; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.ForeignDataOption; +import net.sf.jsqlparser.statement.create.table.IndexOption; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.KeyElement; +import net.sf.jsqlparser.statement.create.table.TableElement; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationContext; +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.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +class ActiveTableDefinitionTraversalTest { + @ParameterizedTest + @ValueSource(strings = {"FOREIGN KEY (parent_id) REFERENCES old_parent (id)", + "INDEX old_index (old_id)", "CONSTRAINT hidden_check CHECK (old_id > 0)"}) + void addedColumnHidesStoredDefinitionFromAllConsumers(String definition) throws Exception { + Alter alter = parse("ALTER TABLE child ADD " + definition); + AlterExpression action = first(alter); + TableElement original = action.getActiveTableDefinition(); + action.addColDataType("added", new ColDataType("INT")); + assertEquals("ALTER TABLE child ADD added INT", alter.toString()); + assertNull(action.getActiveTableDefinition()); + assertTrue(original == action.getConstraint() || original == action.getIndex()); + assertEquals(Set.of("child"), new TablesNamesFinder<>().getTables(alter)); + assertTrue(expressions(action).isEmpty()); + assertEquals(List.of("child", "added"), validatedNames(alter, Set.of("child"))); + assertRoundTrip(alter, null); + } + + @Test + void operationChangesKeepForeignKeyStoredButDoNotVisitIt() throws Exception { + Alter alter = parse("ALTER TABLE child ADD FOREIGN KEY (parent_id) REFERENCES parent (id)"); + AlterExpression action = first(alter); + Object original = action.getConstraint(); + action.setOperation(AlterOperation.DROP_FOREIGN_KEY); + action.setConstraintName("fk"); + assertSame(original, action.getConstraint()); + assertNull(action.getActiveTableDefinition()); + assertEquals(Set.of("child"), new TablesNamesFinder<>().getTables(alter)); + assertEquals(List.of("child", "fk"), validatedNames(alter, Set.of("child", "fk"))); + assertRoundTrip(alter, Dialect.MYSQL); + } + + @Test + void activeForeignKeyStillVisitsItsTableAndBothColumnLists() throws Exception { + Alter alter = parse("ALTER TABLE child ADD FOREIGN KEY (parent_id) REFERENCES parent (id)"); + assertEquals(Set.of("child", "parent"), new TablesNamesFinder<>().getTables(alter)); + assertEquals(List.of("child", "parent", "id", "parent_id"), + validatedNames(alter, Set.of("child", "parent", "id", "parent_id"))); + assertRoundTrip(alter, null); + } + + @Test + void storedTableRenameDestinationIsInactiveWhenIndexNamesTakePrecedence() throws Exception { + Alter alter = parse("ALTER TABLE child RENAME INDEX original TO replacement"); + AlterExpression action = first(alter); + action.setOperation(AlterOperation.RENAME_TABLE); + action.setNewTable(new Table("hidden_table")); + assertFalse(alter.toString().contains("hidden_table")); + assertEquals(Set.of("child"), new TablesNamesFinder<>().getTables(alter)); + assertEquals("hidden_table", action.getNewTable().getName()); + } + + @Test + void defaultTraversalUsesTheSameBodyAsTheRenderer() throws Exception { + Alter alter = parse("ALTER TABLE child ALTER COLUMN id SET DEFAULT 1"); + AlterExpression action = first(alter); + ColumnDataType inactive = new ColumnDataType("hidden", false, new ColDataType("INT"), null); + inactive.addColumnOptions(ColumnOption.defaultValue(new LongValue(2))); + action.addColDataType(inactive); + assertEquals(List.of("1"), expressions(action)); + assertFalse(action.hasActiveColumnDefinitions()); + assertRoundTrip(alter, null); + } + + @Test + void dropSubclassCanSelectTheGeneralBodyAfterMutation() throws Exception { + Alter alter = parse("ALTER TABLE child DROP INDEX old_index"); + AlterExpression action = first(alter); + action.setOperation(AlterOperation.ADD); + action.setConstraint(first(parse("ALTER TABLE child ADD FOREIGN KEY (parent_id) " + + "REFERENCES parent (id)")).getConstraint()); + action.addColSetDefault(ColumnSetDefault.fromExpression("hidden", new LongValue(99))); + assertSame(action.getConstraint(), action.getActiveTableDefinition()); + assertEquals(Set.of("child", "parent"), new TablesNamesFinder<>().getTables(alter)); + assertTrue(expressions(action).isEmpty()); + assertEquals(List.of("child", "parent", "id", "parent_id"), + validatedNames(alter, Set.of("child", "parent", "id", "parent_id"))); + assertRoundTrip(alter, null); + } + + @ParameterizedTest + @CsvSource(delimiter = '|', value = { + "ALTER FOREIGN TABLE child OPTIONS (ADD optname 'active')|POSTGRESQL", + "ALTER TABLE child OWNER TO new_owner|POSTGRESQL", + "ALTER TABLE child ORDER BY active_id|MYSQL"}) + void fixedBodiesIgnoreInheritedDefinitionsAndDefaults(String sql, Dialect dialect) + throws Exception { + Alter alter = (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + AlterExpression action = first(alter); + List expectedExpressions = expressions(action); + action.setConstraint(first(parse("ALTER TABLE child ADD FOREIGN KEY (hidden_id) " + + "REFERENCES hidden_parent (id)")).getConstraint()); + action.addColDataType("hidden", new ColDataType("INT")); + action.addColSetDefault(ColumnSetDefault.fromExpression("hidden", new LongValue(99))); + action.setConstraintType("UNIQUE"); + action.setConstraintSymbol("hidden_key"); + action.setOperation(AlterOperation.RENAME_TABLE); + action.setNewTable(new Table("hidden_table")); + assertNull(action.getActiveTableDefinition()); + assertEquals(expectedExpressions, expressions(action)); + assertEquals(Set.of("child"), new TablesNamesFinder<>().getTables(alter)); + assertTrue(validatedNames(alter, Set.of("child", "active_id")).stream() + .noneMatch(name -> name.startsWith("hidden"))); + assertRoundTrip(alter, dialect); + } + + @Test + void identityAlterationDoesNotVisitDormantColumnOptionsOrUsingExpression() throws Exception { + Alter alter = (Alter) CCJSqlParserUtil.parse("ALTER TABLE child ALTER COLUMN id RESTART", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + ColumnDataType column = first(alter).getColDataTypeList().get(0); + column.addColumnOptions(ColumnOption.defaultValue(new LongValue(99))); + column.setUsingExpression(new LongValue(100)); + assertEquals("100", column.getUsingExpression().toString()); + assertTrue(expressions(first(alter)).isEmpty()); + assertRoundTrip(alter, Dialect.POSTGRESQL); + } + + @Test + void legacyConstraintHeaderVisitsKeysWithoutDormantStorageOptions() throws Exception { + Alter alter = parse("ALTER TABLE child ADD CONSTRAINT UNIQUE KEY uq (id)"); + AlterExpression action = first(alter); + KeyConstraint key = (KeyConstraint) action.getConstraint(); + key.setColumns(List.of(new KeyElement(new LongValue(7)))); + key.setStorageParameters(List.of(new IndexOption("hidden", new LongValue(99), true))); + assertTrue(action.hasActiveConstraintHeader()); + assertSame(key, action.getActiveTableDefinition()); + assertEquals(List.of("7"), expressions(action)); + assertFalse(alter.toString().contains("99")); + } + + @Test + void specializedPrimaryKeyKeepsActiveKeysAndHashOptions() throws Exception { + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE child ALTER PRIMARY KEY USING COLUMNS (id) " + + "USING HASH WITH BUCKET_COUNT = 8 WITH (fillfactor = 70)", + parser -> parser.withDialect(Dialect.COCKROACHDB)); + assertEquals(List.of("70", "8"), expressions(first(alter))); + assertSame(first(alter).getConstraint(), first(alter).getActiveTableDefinition()); + assertRoundTrip(alter, Dialect.COCKROACHDB); + } + + @ParameterizedTest + @ValueSource(strings = {"CHECK (hidden_id > 0)", "REFERENCES hidden_parent (id)"}) + void columnOptionKindChangesHidePriorConstraintPayload(String optionSql) throws Exception { + CreateTable table = (CreateTable) CCJSqlParserUtil.parse( + "CREATE FOREIGN TABLE child (id INT " + optionSql + ") SERVER srv"); + ColumnDefinition column = table.getColumnDefinitions().get(0); + ColumnOption option = column.getColumnOptions().get(0); + Object stored = option.getConstraint() != null ? option.getConstraint() + : option.getForeignKeyReference(); + option.setForeignOptions( + List.of(new ForeignDataOption("column_name", new StringValue("active")))); + assertTrue(stored == option.getConstraint() || stored == option.getForeignKeyReference()); + List actual = new ArrayList<>(); + TableDefinitionTraversal.visit(table, expression -> actual.add(expression.toString()), + source -> fail("Inactive reference visited: " + source)); + assertEquals(List.of("'active'"), actual); + assertEquals(Set.of("child"), new TablesNamesFinder<>().getTables(table)); + assertRoundTrip(table, Dialect.POSTGRESQL); + } + + private static Alter parse(String sql) throws Exception { + return (Alter) CCJSqlParserUtil.parse(sql); + } + + private static AlterExpression first(Alter alter) { + return alter.getAlterExpressions().get(0); + } + + private static List expressions(AlterExpression action) { + List result = new ArrayList<>(); + TableDefinitionTraversal.visit(action, expression -> result.add(expression.toString()), + table -> { + }); + return result; + } + + private static List validatedNames(Alter alter, Set existing) { + List names = new ArrayList<>(); + DatabaseMetaDataValidation metadata = name -> { + names.add(name.getFqn()); + return existing.contains(name.getFqn()); + }; + AlterValidator validator = new AlterValidator(); + validator.setContext(new ValidationContext().setCapabilities(List.of(metadata))); + validator.validate(alter); + assertTrue(validator.getValidationErrors().isEmpty(), + validator.getValidationErrors().toString()); + return names; + } + + private static void assertRoundTrip(Statement statement, Dialect dialect) throws Exception { + StringBuilder sql = new StringBuilder(); + statement.accept(new StatementDeParser(sql)); + assertEquals(statement.toString(), sql.toString()); + Statement reparsed = CCJSqlParserUtil.parse(sql.toString(), parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + assertEquals(sql.toString(), reparsed.toString()); + assertEquals(new TablesNamesFinder<>().getTables(reparsed), + new TablesNamesFinder<>().getTables(statement)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/AddAliasesVisitorTest.java b/src/test/java/net/sf/jsqlparser/util/AddAliasesVisitorTest.java index 6a8a919e54..d0975bc50a 100644 --- a/src/test/java/net/sf/jsqlparser/util/AddAliasesVisitorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/AddAliasesVisitorTest.java @@ -15,8 +15,10 @@ import org.junit.jupiter.api.Test; import java.io.StringReader; +import java.time.Duration; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; public class AddAliasesVisitorTest { @@ -68,4 +70,24 @@ public void testVisit_SetOperationList() throws JSQLParserException { assertEquals("SELECT 3 + 4 AS A1 FROM test UNION SELECT 7 + 8 AS A1 FROM test2", setOpList.toString()); } + + @Test + public void testManySelectItemsDoNotScaleQuadratically() throws JSQLParserException { + // Generated aliases were checked against the already-used ones with a linear + // LinkedList.contains, so adding aliases to a select with m items cost O(m^2). + final int m = 50000; + final StringBuilder sb = new StringBuilder("SELECT "); + for (int i = 0; i < m; i++) { + if (i > 0) { + sb.append(", "); + } + sb.append("c").append(i); + } + sb.append(" FROM t"); + + // Parsing is left outside the timed region; only the alias walk is measured. + final Select select = (Select) parserManager.parse(new StringReader(sb.toString())); + assertTimeoutPreemptively(Duration.ofSeconds(2), + () -> select.accept(new AddAliasesVisitor<>(), null)); + } } diff --git a/src/test/java/net/sf/jsqlparser/util/ConnectExpressionsVisitorTest.java b/src/test/java/net/sf/jsqlparser/util/ConnectExpressionsVisitorTest.java index 712e1950f6..827dd56a28 100644 --- a/src/test/java/net/sf/jsqlparser/util/ConnectExpressionsVisitorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/ConnectExpressionsVisitorTest.java @@ -18,8 +18,10 @@ import org.junit.jupiter.api.Test; import java.io.StringReader; +import java.time.Duration; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; public class ConnectExpressionsVisitorTest { @@ -54,4 +56,28 @@ protected BinaryExpression createBinaryExpression() { assertEquals("SELECT a + b + c AS testexpr FROM test", select.toString()); } + + @Test + public void testVisit_PlainSelect_manyItemsIsLinear() throws JSQLParserException { + int itemCount = 200000; + StringBuilder sql = new StringBuilder("select "); + for (int i = 0; i < itemCount; i++) { + if (i > 0) { + sql.append(','); + } + sql.append('c').append(i); + } + sql.append(" from test"); + Select select = (Select) parserManager.parse(new StringReader(sql.toString())); + ConnectExpressionsVisitor instance = new ConnectExpressionsVisitor<>() { + @Override + protected BinaryExpression createBinaryExpression() { + return new Concat(); + } + }; + // itemsExpr is a LinkedList; connecting the items used to index it by position (get(i)), + // which is O(n^2) in the number of select items. + assertTimeoutPreemptively(Duration.ofSeconds(5), () -> select.accept(instance, null)); + assertEquals(1, select.getPlainSelect().getSelectItems().size()); + } } diff --git a/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java b/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java index 79532abbcb..18d6be332f 100644 --- a/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java +++ b/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java @@ -14,12 +14,17 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.time.Duration; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Set; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.Alias; +import net.sf.jsqlparser.expression.LongValue; import net.sf.jsqlparser.expression.OracleHint; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.schema.Column; @@ -27,9 +32,16 @@ import net.sf.jsqlparser.statement.DescribeStatement; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.comment.Comment; +import net.sf.jsqlparser.statement.select.AllColumns; +import net.sf.jsqlparser.statement.select.Join; +import net.sf.jsqlparser.statement.select.ParenthesedSelect; import net.sf.jsqlparser.statement.select.PlainSelect; +import net.sf.jsqlparser.statement.select.SelectItem; +import net.sf.jsqlparser.statement.select.WithItem; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class TablesNamesFinderTest { @@ -382,6 +394,27 @@ public void testAlterSequenceHasNoTableReferences() throws JSQLParserException { assertThat(tablesNamesFinder.getTables(stmt)).isEmpty(); } + @Test + public void testSetStatementFindsTablesInValues() throws JSQLParserException { + assertThat(TablesNamesFinder + .findTables("SET @a = (SELECT MAX(id) FROM MY_TABLE1), @b = 2")) + .containsExactlyInAnyOrder("MY_TABLE1"); + assertThat(TablesNamesFinder.findTables("SET search_path TO s1")).isEmpty(); + } + + @Test + public void testMySqlTriggerWithSetBody() throws JSQLParserException { + String sqlStr = "CREATE TRIGGER trg BEFORE INSERT ON MY_TABLE1 FOR EACH ROW " + + "SET NEW.a = (SELECT MAX(id) FROM MY_TABLE2)"; + assertThat(TablesNamesFinder.findTables(sqlStr)).containsExactlyInAnyOrder("MY_TABLE1", + "MY_TABLE2"); + + sqlStr = "CREATE TRIGGER trg BEFORE UPDATE ON MY_TABLE1 FOR EACH ROW " + + "BEGIN SET NEW.updated_at = NOW(); INSERT INTO MY_TABLE2 VALUES (NEW.id); END"; + assertThat(TablesNamesFinder.findTables(sqlStr)).containsExactlyInAnyOrder("MY_TABLE1", + "MY_TABLE2"); + } + @Test public void testCreateSynonym_throwsException() throws JSQLParserException { String sql = "CREATE SYNONYM foo FOR bar"; @@ -528,13 +561,13 @@ void testSubqueryAliasesIssue1987() throws JSQLParserException { assertThat(tables).containsExactlyInAnyOrder("a", "b"); assertThat(tables).doesNotContain("a1"); + // a sub-select cannot select from an alias: this statement only runs if a1 is a table sqlStr = "SELECT * FROM b, (SELECT * FROM a) as a1 WHERE b.id IN ( SELECT id FROM a1 )"; tables = TablesNamesFinder.findTablesOrOtherSources(sqlStr); assertThat(tables).containsExactlyInAnyOrder("a1", "a", "b"); tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("a", "b"); - assertThat(tables).doesNotContain("a1"); + assertThat(tables).containsExactlyInAnyOrder("a", "a1", "b"); sqlStr = "select (a_alias.col1), b_alias.col2\n" + "from b b_alias, a as a_alias, c join b on c.id = b.id\n" + @@ -558,14 +591,14 @@ void testSubqueryAliasesIssue1987() throws JSQLParserException { + " and a.max > (select max(val) from bc_nested, f) and a.desc like 'abc'"; tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("a", "b", "c", "d", "e", "f"); + assertThat(tables).containsExactlyInAnyOrder("a", "b", "bc_nested", "c", "d", "e", "f"); sqlStr = " select (select max(val) from e) as maxval, id\n" + " from (select * from b, (select * from c) c_alias) as bc_nested, a\n" + " where a.max > (select max(val) from bc_nested, f) and \n" + " a.id in ( select id from (select * from d) d_alias join bc_nested on bc_nested.id = d_alias.id )"; tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("a", "b", "c", "d", "e", "f"); + assertThat(tables).containsExactlyInAnyOrder("a", "b", "bc_nested", "c", "d", "e", "f"); sqlStr = "select a.id, bc_nested.id\n" + " from (select * from b, (select * from c) c_alias) as bc_nested, a\n" + @@ -577,7 +610,7 @@ void testSubqueryAliasesIssue1987() throws JSQLParserException { " on bc_nested_alias.id = d.id\n" + " )))"; tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("a", "b", "c", "d", "e"); + assertThat(tables).containsExactlyInAnyOrder("a", "b", "bc_nested", "c", "d", "e"); sqlStr = "select id\n" + "from (select * from c, (select * from b) b_alias) as bc_nested, a\n" + @@ -587,7 +620,7 @@ void testSubqueryAliasesIssue1987() throws JSQLParserException { "join bc_nested on bc_nested_alias.id = bc_nested.id\n" + ")"; tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("a", "b", "c", "d", "e"); + assertThat(tables).containsExactlyInAnyOrder("a", "b", "bc_nested", "c", "d", "e"); sqlStr = "with\n" + " temp1 as (\n" + @@ -603,7 +636,7 @@ void testSubqueryAliasesIssue1987() throws JSQLParserException { + "where exist ( select * from e, e_alias where e.test = dtest.test ) and temp1.max = (select max(column_1) from g)"; tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("a", "b", "c", "d", "e", "f", "g"); + assertThat(tables).containsExactlyInAnyOrder("a", "b", "c", "d", "e", "e_alias", "f", "g"); } @Test @@ -615,7 +648,110 @@ void testSubqueryAliasesIssue2035() throws JSQLParserException { assertThat(tables).containsExactlyInAnyOrder("A", "B", "C"); tables = TablesNamesFinder.findTables(sqlStr); - assertThat(tables).containsExactlyInAnyOrder("B", "C"); + assertThat(tables).containsExactlyInAnyOrder("A", "B", "C"); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT * FROM (SELECT * FROM secrets) AS secrets", + "SELECT (SELECT max(pw) FROM secrets) FROM (SELECT 1) AS secrets", + "SELECT * FROM (SELECT 1) AS secrets, LATERAL (SELECT * FROM secrets) AS x", + "SELECT * FROM t, LATERAL (SELECT * FROM secrets) AS secrets", + "FROM secrets |> AS secrets", + "DELETE FROM secrets WHERE id IN (SELECT id FROM (SELECT 1 AS id) AS secrets)", + "UPDATE secrets SET pw = 'x' WHERE id IN (SELECT id FROM (SELECT 1 AS id) AS secrets)", + "INSERT INTO secrets (id) SELECT id FROM (SELECT 1 AS id) AS secrets", + "MERGE INTO secrets AS t USING (SELECT 1 AS id) AS secrets ON (t.id = secrets.id)" + + " WHEN MATCHED THEN DELETE"}) + void testAliasDoesNotHideTable(String sqlStr) throws JSQLParserException { + assertThat(TablesNamesFinder.findTables(sqlStr)).contains("secrets"); + } + + @ParameterizedTest + @ValueSource(strings = { + // without RECURSIVE a WITH item does not see itself or the items after it + "WITH secrets AS (SELECT * FROM secrets) SELECT * FROM secrets", + "WITH secrets AS (SELECT 1 AS id UNION ALL SELECT id FROM secrets) SELECT * FROM secrets", + "WITH x AS (SELECT id FROM secrets), secrets AS (SELECT 1 AS id) SELECT * FROM x, secrets", + // a WITH item only exists in the query that declares it + "SELECT * FROM secrets WHERE EXISTS (WITH secrets AS (SELECT 1 AS a) SELECT a FROM secrets)", + "SELECT id FROM secrets UNION ALL (WITH secrets AS (SELECT 1 AS id) SELECT id FROM secrets)", + "SELECT * FROM (WITH secrets AS (SELECT 1 AS id) SELECT * FROM secrets) AS s, secrets", + "WITH a AS (WITH secrets AS (SELECT 1 AS id) SELECT * FROM secrets) SELECT * FROM a, secrets", + // the target of a DML statement is never a WITH item + "WITH secrets AS (SELECT 1 AS id) DELETE FROM secrets", + "WITH secrets AS (SELECT 1 AS id) UPDATE secrets SET pw = 'x'", + "WITH secrets AS (SELECT 1 AS id) INSERT INTO secrets (id) SELECT id FROM secrets", + "WITH secrets AS (SELECT 1 AS id) MERGE INTO secrets USING secrets AS s" + + " ON (s.id = secrets.id) WHEN MATCHED THEN DELETE", + "WITH secrets AS (SELECT 1 AS id), d AS (DELETE FROM secrets RETURNING *) SELECT * FROM d", + "WITH secrets AS (SELECT 1 AS id), d AS (UPDATE secrets SET pw = 'x' RETURNING *)" + + " SELECT * FROM d", + "WITH secrets AS (SELECT 1 AS id), d AS (INSERT INTO secrets (id) VALUES (2) RETURNING *)" + + " SELECT * FROM d", + // WITH on the kinds of select that used to skip it + "SELECT * FROM (WITH a AS (SELECT * FROM secrets) TABLE a) AS s", + "SELECT * FROM (WITH a AS (SELECT id FROM secrets) VALUES ((SELECT max(id) FROM a))) AS s"}) + void testWithItemDoesNotHideTableOutsideItsScope(String sqlStr) throws JSQLParserException { + assertThat(TablesNamesFinder.findTables(sqlStr)).contains("secrets"); + } + + @ParameterizedTest + @ValueSource(strings = { + "WITH RECURSIVE t(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM t WHERE n < 5) SELECT * FROM t", + // RECURSIVE is parsed onto the first item, but covers the whole list + "WITH RECURSIVE a AS (SELECT 1 AS n), t(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM t" + + " WHERE n < 5) SELECT * FROM t, a", + "WITH RECURSIVE x AS (SELECT id FROM y), y AS (SELECT 1 AS id) SELECT * FROM x", + "WITH a AS (SELECT 1 AS id), b AS (SELECT * FROM a) SELECT * FROM b", + "WITH a AS (SELECT 1 AS id) SELECT id FROM a UNION SELECT id FROM a", + "WITH a AS (SELECT 1 AS id) SELECT * FROM a WHERE id IN (SELECT id FROM a)", + "WITH a AS (SELECT 1 AS id) (SELECT * FROM a)", + "WITH a AS (SELECT 1 AS id) SELECT * FROM (SELECT * FROM a) AS s", + // a nested WITH repeating a name does not end the enclosing one + "WITH a AS (SELECT 1 AS id) SELECT * FROM (WITH a AS (SELECT 2 AS id) SELECT * FROM a) AS s, a", + "SELECT * FROM (WITH a AS (SELECT 1 AS id) TABLE a) AS s", + "SELECT * FROM (WITH a AS (SELECT 1 AS id) VALUES ((SELECT max(id) FROM a))) AS s"}) + void testWithItemInScopeIsNoTable(String sqlStr) throws JSQLParserException { + assertThat(TablesNamesFinder.findTables(sqlStr)).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = { + "WITH a AS (SELECT 1 AS id) INSERT INTO t (id) SELECT id FROM a", + "INSERT INTO t (id) WITH a AS (SELECT 1 AS id) SELECT id FROM a", + "WITH a AS (SELECT 1 AS id) UPDATE t SET id = a.id FROM a", + "WITH a AS (SELECT 1 AS id) DELETE FROM t USING a WHERE t.id = a.id", + "WITH a AS (SELECT 1 AS id) MERGE INTO t USING a ON (t.id = a.id) WHEN MATCHED THEN DELETE"}) + void testWithItemInScopeOfDmlIsNoTable(String sqlStr) throws JSQLParserException { + assertThat(TablesNamesFinder.findTables(sqlStr)).containsExactly("t"); + } + + @Test + void testWithItemDoesNotHideQualifiedTable() throws JSQLParserException { + String sqlStr = "WITH secrets AS (SELECT 1 AS id) SELECT * FROM public.secrets"; + assertThat(TablesNamesFinder.findTables(sqlStr)).containsExactly("public.secrets"); + + TablesNamesFinder finderWithoutSchema = new TablesNamesFinder() { + @Override + protected String extractTableName(Table table) { + return table.getName(); + } + }; + assertThat(finderWithoutSchema.getTables(CCJSqlParserUtil.parse(sqlStr))) + .containsExactly("secrets"); + } + + @Test + void testAliasInExpression() throws JSQLParserException { + assertThat(TablesNamesFinder + .findTablesInExpression("(SELECT 1 FROM (SELECT * FROM secrets) AS secrets)")) + .containsExactly("secrets"); + + // an alias still is no table when it qualifies a column + assertThat(TablesNamesFinder + .findTablesInExpression("(SELECT max(id) FROM (SELECT id FROM t) AS x) = x.id")) + .containsExactly("t"); } @Test @@ -1062,4 +1198,52 @@ void testUpdateOrderByLimitSubquery() throws JSQLParserException { "MY_TABLE2"); } + @ParameterizedTest + @ValueSource(strings = { + "SELECT TOP ((SELECT count(*) FROM secrets)) a FROM t", + "SELECT TOP ((SELECT count(*) FROM secrets)) PERCENT a FROM t", + "SELECT * REPLACE ((SELECT max(pw) FROM secrets) AS a) FROM t", + "SELECT * EXCLUDE (b) REPLACE ((SELECT max(pw) FROM secrets) AS a) FROM t", + "SELECT t.* REPLACE ((SELECT max(pw) FROM secrets) AS a) FROM t"}) + void testSubqueryInTopOrStarReplaceIsFound(String sqlStr) throws JSQLParserException { + assertThat(TablesNamesFinder.findTables(sqlStr)).containsExactlyInAnyOrder("t", "secrets"); + } + + @ParameterizedTest + @ValueSource(strings = { + "DECLARE @x INT = (SELECT max(pw) FROM secrets)", + "DECLARE @x INT = 1, @y VARCHAR(10) = (SELECT max(pw) FROM secrets)"}) + void testSubqueryInDeclareIsFound(String sqlStr) throws JSQLParserException { + assertThat(TablesNamesFinder.findTables(sqlStr)).containsExactly("secrets"); + } + + @Test + void testManyDerivedNamesDoNotScaleQuadratically() { + // Every plain table reference used to be matched against the CTE aliases with + // ArrayList.contains, so n aliases and n tables cost O(n^2) to walk. + final int n = 30000; + final PlainSelect statement = new PlainSelect() + .withSelectItems(new SelectItem<>(new AllColumns())) + .withFromItem(new Table("t0")); + final List> withItems = new ArrayList<>(n); + final List joins = new ArrayList<>(n - 1); + for (int i = 0; i < n; i++) { + PlainSelect body = + new PlainSelect().withSelectItems(new SelectItem<>(new LongValue(1))); + withItems.add(new WithItem<>(new ParenthesedSelect().withSelect(body), + new Alias("a" + i))); + if (i > 0) { + joins.add(new Join().withSimple(true).withRightItem(new Table("t" + i))); + } + } + statement.setWithItemsList(withItems); + statement.setJoins(joins); + + // Build the AST directly: this tests table traversal, and parsing a large SQL + // fixture can hit the parser's independent timeout before traversal even starts. + final Set tables = assertTimeoutPreemptively(Duration.ofSeconds(2), + () -> new TablesNamesFinder<>().getTables((Statement) statement)); + assertEquals(n, tables.size()); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTraversalTest.java b/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTraversalTest.java new file mode 100644 index 0000000000..38925bb3de --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTraversalTest.java @@ -0,0 +1,363 @@ +/*- + * #%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.util; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.ArrayExpression; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.upsert.Upsert; +import net.sf.jsqlparser.test.TestUtils; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +class TablesNamesFinderTraversalTest { + private static final String SUBQUERY = "(SELECT max(x) FROM t2)"; + + @ParameterizedTest + @MethodSource("nestedTables") + void findsTablesInNestedChildren(String sql, List expected) throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql); + assertThat(TablesNamesFinder.findTables(sql)).containsExactlyInAnyOrderElementsOf(expected); + assertThat(new TablesNamesFinder<>().getTables(statement)) + .containsExactlyInAnyOrderElementsOf(expected); + } + + private static Stream nestedTables() { + return Stream.of( + tables("SELECT a[(SELECT max(x) FROM t2)] FROM t1", "t1", "t2"), + tables("SELECT a[1][(SELECT max(x) FROM t2)] FROM t1", "t1", "t2"), + tables("SELECT f()[(SELECT max(x) FROM t2)] FROM t1", "t1", "t2"), + tables("SELECT f((SELECT x FROM t2))[(SELECT y FROM t3)] FROM t1", "t1", "t2", + "t3"), + tables("SELECT a[OFFSET(1):2] FROM t1", "t1"), + tables("SELECT f()[OFFSET(1):OFFSET(2)] FROM t1", "t1"), + tables("SELECT f()[1:] FROM t1", "t1"), + tables("SELECT f()[:2] FROM t1", "t1"), + tables("SELECT f()[:] FROM t1", "t1"), + tables("SELECT f()[OFFSET((SELECT x FROM t2)):OFFSET((SELECT y FROM t3))] FROM t1", + "t1", "t2", + "t3"), + tables("FROM t1 JOIN t2 ON t1.id=t2.id |> SELECT t1.id", "t1", "t2"), + tables("FROM t1 JOIN t2 ON t1.id=(SELECT id FROM t3) |> SELECT t1.id", "t1", "t2", + "t3"), + tables("FROM t1 LEFT JOIN (SELECT id FROM t2) q ON t1.id=q.id |> SELECT t1.id", + "t1", "t2"), + tables("FROM t1 LATERAL VIEW explode((SELECT a FROM t2)) e AS x |> SELECT x", "t1", + "t2"), + tables("WITH c AS (SELECT a FROM t2) FROM t1 JOIN c ON t1.a=c.a |> SELECT t1.a", + "t1", "t2"), + tables("UPDATE t1 SET a=1 OUTPUT inserted.* INTO t2", "t1", "t2"), + tables("INSERT INTO t1 OUTPUT inserted.* INTO t2 VALUES (1)", "t1", "t2"), + tables("DELETE t1 OUTPUT deleted.* INTO t2 FROM t1", "t1", "t2"), + tables("MERGE INTO t1 USING t2 ON t1.a=t2.a WHEN MATCHED THEN DELETE OUTPUT deleted.* INTO t3", + "t1", "t2", "t3"), + tables("UPDATE t1 SET a=1 OUTPUT (SELECT x FROM t2) INTO t3", "t1", "t2", "t3"), + tables("MERGE INTO t1 USING t2 ON t1.a=t2.a WHEN MATCHED THEN DELETE OUTPUT (SELECT x FROM t3) INTO t4", + "t1", "t2", "t3", "t4"), + tables("MERGE INTO t1 USING t2 ON t1.a=t2.a WHEN MATCHED THEN DELETE OUTPUT deleted.* INTO @tv", + "t1", "t2"), + tables("UPSERT INTO t1 VALUES (1) ON DUPLICATE KEY UPDATE (a)=(SELECT max(x) FROM t2)", + "t1", "t2"), + tables("UPSERT INTO t1 SELECT a FROM t2 ON DUPLICATE KEY UPDATE b=(SELECT x FROM t3)", + "t1", "t2", "t3"), + tables("SELECT POSITION('x' IN (SELECT max(a) FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT SUBSTRING((SELECT a FROM t2) FROM (SELECT n FROM t3) FOR (SELECT n FROM t4)) FROM t1", + "t1", "t2", "t3", "t4"), + tables("IF (SELECT count(*) FROM t2)>1 DELETE FROM t3", "t2", "t3"), + tables("IF EXISTS (SELECT 1 FROM t1) UPDATE t2 SET a=1 ELSE DELETE FROM t3", "t1", + "t2", "t3"), + tables("SELECT sum(x) OVER (PARTITION BY (SELECT a FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT sum(x) OVER (PARTITION BY (SELECT a FROM t2) ORDER BY (SELECT b FROM t3)) FROM t1", + "t1", "t2", "t3"), + tables("SELECT a[1], f()[1] FROM t1", "t1"), + tables("SELECT a FROM t1 JOIN t2 ON t1.a=t2.a", "t1", "t2"), + tables("SELECT * FROM t1 LATERAL VIEW explode((SELECT a FROM t2)) e AS x", "t1", + "t2"), + tables("FROM t1 |> JOIN t2 ON t1.a=t2.a |> SELECT t1.a", "t1", "t2"), + tables("UPDATE t1 SET a=1 OUTPUT inserted.*, deleted.a INTO @tv", "t1"), + tables("UPDATE t1 SET a=1 OUTPUT inserted.*", "t1"), + tables("INSERT INTO t1 VALUES (1) ON DUPLICATE KEY UPDATE a=(SELECT x FROM t2)", + "t1", "t2"), + tables("UPSERT INTO t1 VALUES (1)", "t1"), + tables("SELECT POSITION('x' IN 'xx') FROM t1", "t1"), + tables("IF a>1 DELETE FROM t3", "t3"), + tables("SELECT sum(x) OVER (ORDER BY (SELECT a FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT max(a) KEEP (DENSE_RANK FIRST ORDER BY (SELECT x FROM t2)) FROM t1", + "t1", "t2"), + tables("SELECT max(a) KEEP (DENSE_RANK FIRST ORDER BY (SELECT x FROM t2)) OVER (PARTITION BY b) FROM t1", + "t1", "t2"), + tables("SELECT array_agg(a LIMIT (SELECT x FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT any_value(a HAVING MAX (SELECT x FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT any_value(a HAVING MAX (SELECT x FROM t2)) OVER () FROM t1", "t1", + "t2"), + tables("SELECT group_concat(a SEPARATOR (SELECT x FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT group_concat(a ORDER BY (SELECT x FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT f(a).g((SELECT x FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT a FROM t1 WHERE (SELECT x FROM t2) IS UNKNOWN", "t1", "t2"), + tables("SELECT a FROM t1 WHERE MATCH (a) AGAINST ((SELECT x FROM t2))", "t1", + "t2"), + tables("SELECT JSON_OBJECTAGG(KEY a VALUE (SELECT x FROM t2)) FROM t1", "t1", + "t2"), + tables("SELECT JSON_ARRAYAGG(a ORDER BY (SELECT x FROM t2)) FROM t1", "t1", "t2"), + tables("SELECT JSON_ARRAYAGG(a) OVER (PARTITION BY (SELECT x FROM t2) ORDER BY (SELECT y FROM t3)) FROM t1", + "t1", "t2", "t3"), + tables("SELECT JSON_ARRAYAGG(a) OVER (ORDER BY b ROWS (SELECT x FROM t2) PRECEDING) FROM t1", + "t1", "t2"), + tables("SELECT * FROM XMLTABLE('/r' PASSING (SELECT x FROM t2) COLUMNS a int PATH 'a') x", + "t2"), + tables("SELECT * FROM JSON_TABLE((SELECT x FROM t2), '$' COLUMNS (a int PATH '$.a')) j", + "t2"), + tables("SELECT * FROM generate_series(1, (SELECT max(x) FROM t2)) g", "t2")); + } + + @ParameterizedTest + @MethodSource("postgresTables") + void findsTablesInPostgresExpressionChildren(String sql, List expected) + throws JSQLParserException { + Statement statement = CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertThat(new TablesNamesFinder<>().getTables(statement)) + .containsExactlyInAnyOrderElementsOf(expected); + assertThat(new TablesNamesFinder<>().getTablesOrOtherSources(statement)) + .containsAll(expected); + } + + private static Stream postgresTables() { + return Stream.of( + // aggregate ORDER BY inside the call + tables("SELECT string_agg(a, ',' ORDER BY " + SUBQUERY + ") FROM t1", "t1", + "t2"), + tables("SELECT array_agg(a ORDER BY " + SUBQUERY + ") FROM t1", "t1", + "t2"), + // LIKE ... ESCAPE + tables("SELECT a FROM t1 WHERE a LIKE 'a' ESCAPE " + SUBQUERY, "t1", + "t2"), + // AT TIME ZONE, zone operand + tables("SELECT now() AT TIME ZONE " + SUBQUERY, "t2"), + // JSON operators, right operand + tables("SELECT j -> " + SUBQUERY + " FROM t1", "t1", "t2"), + tables("SELECT j ->> " + SUBQUERY + " FROM t1", "t1", "t2"), + tables("SELECT j #> ARRAY[" + SUBQUERY + "] FROM t1", "t1", "t2"), + tables("SELECT j #>> ARRAY[" + SUBQUERY + "] FROM t1", "t1", "t2"), + // array slice bounds and subscript + tables("SELECT a[1:(SELECT count(*)::int FROM t2)] FROM t1", "t1", + "t2"), + tables("SELECT a[(SELECT count(*)::int FROM t2):2] FROM t1", "t1", + "t2"), + tables("SELECT a[(SELECT count(*)::int FROM t2)] FROM t1", "t1", + "t2"), + // positions that were already traversed + tables("SELECT f(" + SUBQUERY + ") FROM t1", "t1", "t2"), + tables("SELECT count(*) FILTER (WHERE a = " + SUBQUERY + ") FROM t1", "t1", + "t2"), + tables("SELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY " + SUBQUERY + + ") FROM t1", "t1", "t2"), + tables("SELECT sum(a) OVER (PARTITION BY " + SUBQUERY + ") FROM t1", "t1", + "t2"), + tables("SELECT sum(a) OVER (ORDER BY " + SUBQUERY + ") FROM t1", "t1", + "t2"), + tables("SELECT sum(a) OVER (ORDER BY b ROWS BETWEEN " + SUBQUERY + + " PRECEDING AND CURRENT ROW) FROM t1", "t1", "t2"), + tables("SELECT a FROM t1 LIMIT " + SUBQUERY, "t1", "t2"), + tables("SELECT a FROM t1 OFFSET " + SUBQUERY, "t1", "t2"), + tables("SELECT a FROM t1 FETCH FIRST " + SUBQUERY + " ROWS ONLY", "t1", + "t2"), + tables("SELECT a FROM t1 WHERE a = ANY (SELECT x FROM t2)", "t1", + "t2"), + tables("SELECT a FROM t1 WHERE a > ALL (SELECT x FROM t2)", "t1", + "t2"), + tables("SELECT a FROM t1 WHERE a = SOME (SELECT x FROM t2)", "t1", + "t2"), + tables("SELECT ARRAY(SELECT x FROM t2)", "t2"), + tables("SELECT * FROM (VALUES (" + SUBQUERY + ")) v(x)", "t2"), + tables("SELECT substring(a FROM " + SUBQUERY + ") FROM t1", "t1", "t2"), + tables("SELECT trim(BOTH " + SUBQUERY + " FROM a) FROM t1", "t1", "t2"), + tables("SELECT position(" + SUBQUERY + " IN a) FROM t1", "t1", "t2"), + tables("SELECT overlay(a PLACING " + SUBQUERY + " FROM 1) FROM t1", "t1", + "t2"), + tables("SELECT CASE WHEN a = 1 THEN " + SUBQUERY + " END FROM t1", "t1", + "t2"), + tables("SELECT CAST(" + SUBQUERY + " AS text) FROM t1", "t1", "t2"), + tables("SELECT " + SUBQUERY + "::text FROM t1", "t1", "t2"), + tables("SELECT count(*) FROM t1 GROUP BY " + SUBQUERY, "t1", "t2"), + tables("SELECT count(*) FROM t1 GROUP BY GROUPING SETS ((" + SUBQUERY + "))", "t1", + "t2"), + tables("SELECT DISTINCT ON (" + SUBQUERY + ") a FROM t1", "t1", "t2"), + tables("SELECT * FROM t1, LATERAL (SELECT x FROM t2) p", "t1", + "t2")); + } + + private static Arguments tables(String sql, String... names) { + return Arguments.of(sql, List.of(names)); + } + + @ParameterizedTest + @MethodSource("expressionTables") + void findsTablesThroughExpressionEntryPoints(String sql, List expected) + throws JSQLParserException { + Expression expression = CCJSqlParserUtil.parseExpression(sql); + assertThat(TablesNamesFinder.findTablesInExpression(sql)) + .containsExactlyInAnyOrderElementsOf(expected); + assertThat(new TablesNamesFinder<>().getTables(expression)) + .containsExactlyInAnyOrderElementsOf(expected); + } + + private static Stream expressionTables() { + return Stream.of(tables("a[(SELECT x FROM t2)]", "t2"), + tables("f()[(SELECT x FROM t2)]", "t2"), + tables("f()[OFFSET((SELECT x FROM t2)):OFFSET((SELECT y FROM t3))]", "t2", "t3"), + tables("POSITION('x' IN (SELECT a FROM t2))", "t2"), + tables("sum(x) OVER (PARTITION BY (SELECT a FROM t2))", "t2"), + tables("string_agg(a, ',' ORDER BY (SELECT x FROM t2))", "t2"), + tables("a LIKE 'a' ESCAPE (SELECT x FROM t2)", "t2"), + tables("now() AT TIME ZONE (SELECT x FROM t2)", "t2"), + tables("(SELECT x FROM t2) IS UNKNOWN", "t2"), + tables("a[1]"), tables("f()[1]"), tables("f()[:2]"), tables("f()[:]"), + tables("f(a).b.c")); + } + + @ParameterizedTest + @ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7}) + void visitsArrayOperandsOnce(int fields) throws JSQLParserException { + Expression index = (fields & 1) == 0 ? null + : CCJSqlParserUtil.parseExpression("(SELECT x FROM index_table)"); + Expression start = (fields & 2) == 0 ? null + : CCJSqlParserUtil.parseExpression("(SELECT x FROM start_table)"); + Expression stop = (fields & 4) == 0 ? null + : CCJSqlParserUtil.parseExpression("(SELECT x FROM stop_table)"); + ArrayExpression expression = new ArrayExpression( + CCJSqlParserUtil.parseExpression("f((SELECT x FROM object_table))"), index, start, + stop); + Map expected = new HashMap<>(); + expected.put("object_table", 1); + if (index != null) { + expected.put("index_table", 1); + } + if (start != null) { + expected.put("start_table", 1); + } + if (stop != null) { + expected.put("stop_table", 1); + } + CountingFinder finder = new CountingFinder(); + assertThat(finder.getTables(expression)) + .containsExactlyInAnyOrderElementsOf(expected.keySet()); + assertThat(finder.visits).isEqualTo(expected); + } + + @Test + void visitsNewChildrenWithoutRepeatingExistingChildren() throws JSQLParserException { + CountingFinder finder = new CountingFinder(); + Statement statement = CCJSqlParserUtil.parse( + "FROM t1 JOIN t2 ON t1.a=(SELECT a FROM t3) |> SELECT sum(a) OVER (PARTITION BY (SELECT a FROM t4) ORDER BY (SELECT a FROM t5))"); + assertThat(finder.getTables(statement)).containsExactlyInAnyOrder("t1", "t2", "t3", "t4", + "t5"); + assertThat(finder.visits).isEqualTo(Map.of("t1", 1, "t2", 1, "t3", 1, "t4", 1, "t5", 1)); + } + + @Test + void visitsAggregateChildrenOnce() throws JSQLParserException { + CountingFinder finder = new CountingFinder(); + Statement statement = CCJSqlParserUtil.parse( + "SELECT max(a) KEEP (DENSE_RANK FIRST ORDER BY (SELECT x FROM t2)) OVER (PARTITION BY (SELECT y FROM t3)), string_agg(a, ',' ORDER BY (SELECT z FROM t4)) FROM t1"); + assertThat(finder.getTables(statement)).containsExactlyInAnyOrder("t1", "t2", "t3", + "t4"); + assertThat(finder.visits).isEqualTo(Map.of("t1", 1, "t2", 1, "t3", 1, "t4", 1)); + } + + @Test + void resetsStateBetweenStatementAndExpressionVisits() throws JSQLParserException { + TablesNamesFinder finder = new TablesNamesFinder<>(); + assertThat(finder.getTables(CCJSqlParserUtil.parse("SELECT a FROM t1"))) + .containsExactlyInAnyOrder("t1"); + assertThat(finder.getTables(CCJSqlParserUtil.parseExpression("qualified.a"))) + .containsExactlyInAnyOrder("qualified"); + assertThat(finder + .getTables(CCJSqlParserUtil.parse("UPDATE t3 SET a=1 OUTPUT inserted.* INTO @tv"))) + .containsExactlyInAnyOrder("t3"); + assertThat(finder.getTables(CCJSqlParserUtil.parse("SELECT a FROM t4"))) + .containsExactlyInAnyOrder("t4"); + } + + @Test + void visitsParsedSliceBounds() throws JSQLParserException { + String sql = "f()[OFFSET((SELECT x FROM t1)):OFFSET((SELECT y FROM t2))]"; + Expression expression = CCJSqlParserUtil.parseExpression(sql); + assertThat(expression).isInstanceOf(ArrayExpression.class); + ArrayExpression array = (ArrayExpression) expression; + assertThat(array.getIndexExpression()).isNull(); + assertThat(array.getStartIndexExpression()).isNotNull(); + assertThat(array.getStopIndexExpression()).isNotNull(); + assertThat(new TablesNamesFinder<>().getTables(array)).containsExactlyInAnyOrder("t1", + "t2"); + } + + @Test + void traversesSliceBounds() throws JSQLParserException { + Expression expression = CCJSqlParserUtil.parseExpression("f()[1:2]"); + assertThat(expression).isInstanceOf(ArrayExpression.class); + ArrayExpression slice = (ArrayExpression) expression; + assertThat(slice.getIndexExpression()).isNull(); + assertThat(slice.getStartIndexExpression()).hasToString("1"); + assertThat(slice.getStopIndexExpression()).hasToString("2"); + assertThat(new TablesNamesFinder<>().getTables(expression)).isEmpty(); + } + + @Test + void findsTablesInUpsertActionCondition() throws JSQLParserException { + Upsert upsert = (Upsert) CCJSqlParserUtil + .parse("UPSERT INTO t1 VALUES (1) ON DUPLICATE KEY UPDATE a=(SELECT x FROM t2)"); + upsert.getDuplicateAction().setWhereExpression( + CCJSqlParserUtil.parseCondExpression("EXISTS (SELECT 1 FROM t3)")); + assertThat(new TablesNamesFinder<>().getTables(upsert)).containsExactlyInAnyOrder("t1", + "t2", "t3"); + } + + @Test + void preservesCteNamesInOtherSourcesEntryPoints() throws JSQLParserException { + String sql = "WITH c AS (SELECT a FROM t2) FROM t1 JOIN c ON t1.a=c.a |> SELECT t1.a"; + Statement statement = CCJSqlParserUtil.parse(sql); + assertThat(TablesNamesFinder.findTablesOrOtherSources(sql)).containsExactlyInAnyOrder("t1", + "t2", "c"); + assertThat(new TablesNamesFinder<>().getTablesOrOtherSources(statement)) + .containsExactlyInAnyOrder("t1", "t2", "c"); + } + + @Test + void preservesParseAndDeparse() throws JSQLParserException { + String sql = "SELECT a[(SELECT max(x) FROM t2)] FROM t1"; + Statement statement = TestUtils.assertSqlCanBeParsedAndDeparsed(sql); + assertThat(new TablesNamesFinder<>().getTables(statement)).containsExactlyInAnyOrder("t1", + "t2"); + } + + private static class CountingFinder extends TablesNamesFinder { + private final Map visits = new HashMap<>(); + + @Override + public Void visit(Table table, S context) { + visits.merge(table.getFullyQualifiedName(), 1, Integer::sum); + return super.visit(table, context); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/deparser/JsonExpressionRenderingTest.java b/src/test/java/net/sf/jsqlparser/util/deparser/JsonExpressionRenderingTest.java new file mode 100644 index 0000000000..d824f6b861 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/deparser/JsonExpressionRenderingTest.java @@ -0,0 +1,298 @@ +/*- + * #%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.util.deparser; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.JsonFunction; +import net.sf.jsqlparser.expression.JsonFunctionExpression; +import net.sf.jsqlparser.expression.JsonFunctionType; +import net.sf.jsqlparser.expression.JsonKeyValuePair; +import net.sf.jsqlparser.expression.JsonKeyValuePairSeparator; +import net.sf.jsqlparser.expression.JsonTableFunction; +import net.sf.jsqlparser.expression.StringValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.statement.Statement; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class JsonExpressionRenderingTest { + private static final Object CONTEXT = new Object(); + + @ParameterizedTest + @ValueSource(strings = { + "JSON_VALUE(doc, '$.a' RETURNING CHAR(20) DEFAULT 'old' ON EMPTY DEFAULT 'old' ON ERROR)", + "JSON_QUERY(doc, '$.a' PASSING filter_value RETURNING VARCHAR(20) " + + "FORMAT JSON WITH ARRAY WRAPPER EMPTY ARRAY ON EMPTY ERROR ON ERROR)", + "JSON_EXISTS(doc, '$.a' PASSING filter_value UNKNOWN ON ERROR)", + "JSON_ARRAY(doc, JSON_VALUE(other_doc, '$.a') FORMAT JSON)", + "JSON_OBJECT(KEY key_column VALUE JSON_VALUE(doc, '$.a') FORMAT JSON)" + }) + void rewritesScalarChildrenWithoutMutatingTheAst(String sql) throws Exception { + Expression expression = CCJSqlParserUtil.parseExpression(sql); + String before = expression.toString(); + RecordingDeParser printer = new RecordingDeParser(); + expression.accept(printer, CONTEXT); + String output = printer.getBuilder().toString(); + assertEquals(before.replace("key_column", "r_key_column") + .replace("other_doc", "other_payload").replace("doc", "payload") + .replace("filter_value", "r_filter_value").replace("'$.a'", "'$.b'") + .replace("'old'", "'new'"), output); + assertEquals(output, CCJSqlParserUtil.parseExpression(output).toString()); + assertEquals(before, expression.toString()); + assertTrue(printer.columns.contains("doc")); + assertTrue(printer.strings.contains("$.a")); + } + + @Test + void rewritesMySqlGeneratedColumnExpressions() throws Exception { + String sql = "CREATE TABLE t (doc JSON, payload JSON, value VARCHAR(20) AS " + + "(JSON_VALUE(doc, '$.a' RETURNING CHAR(20) DEFAULT 'old' ON EMPTY)) STORED)"; + Statement statement = CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + String before = statement.toString(); + RecordingDeParser printer = new RecordingDeParser(null); + statement.accept(new StatementDeParser(printer, new SelectDeParser(), printer.getBuilder()), + null); + String output = printer.getBuilder().toString(); + assertEquals(before.replace("JSON_VALUE(doc", "JSON_VALUE(payload") + .replace("'$.a'", "'$.b'").replace("'old'", "'new'"), output); + assertEquals(List.of("doc"), printer.columns); + assertEquals(output, CCJSqlParserUtil.parse(output, + p -> p.withDialect(Dialect.MYSQL)).toString()); + assertEquals(before, statement.toString()); + } + + @Test + void rewritesNestedTablePathsDefaultsAndPassingValuesInSourceOrder() throws Exception { + String sql = "SELECT * FROM JSON_TABLE(doc, '$.a' AS root " + + "PASSING filter_value AS filter COLUMNS (" + + "ord FOR ORDINALITY, value VARCHAR(20) PATH '$.a' " + + "DEFAULT 'old' ON ERROR DEFAULT 'old' ON EMPTY, " + + "NESTED PATH '$.a' AS nested COLUMNS (present INT EXISTS PATH '$.a')) " + + "PLAN (root OUTER nested) EMPTY ON ERROR) AS jt"; + Statement statement = CCJSqlParserUtil.parse(sql); + String before = statement.toString(); + RecordingDeParser printer = new RecordingDeParser(); + statement.accept(new StatementDeParser(printer, new SelectDeParser(), printer.getBuilder()), + CONTEXT); + String output = printer.getBuilder().toString(); + assertEquals(before.replace("JSON_TABLE(doc", "JSON_TABLE(payload") + .replace("filter_value", "r_filter_value").replace("'$.a'", "'$.b'") + .replace("'old'", "'new'"), output); + assertEquals(List.of("doc", "filter_value"), printer.columns); + assertEquals(List.of("$.a", "$.a", "old", "old", "$.a", "$.a"), printer.strings); + assertEquals(output, CCJSqlParserUtil.parse(output).toString()); + assertEquals(before, statement.toString()); + } + + @Test + void passesMySqlJsonTableDefaultsThroughTheExpressionPrinter() throws Exception { + String sql = "SELECT * FROM JSON_TABLE(doc, '$.a' COLUMNS " + + "(value VARCHAR(20) PATH '$.a' DEFAULT 'old' ON EMPTY " + + "DEFAULT 'old' ON ERROR)) AS jt"; + Statement statement = CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + RecordingDeParser printer = new RecordingDeParser(); + statement.accept(new StatementDeParser(printer, new SelectDeParser(), printer.getBuilder()), + CONTEXT); + String expected = statement.toString().replace("JSON_TABLE(doc", "JSON_TABLE(payload") + .replace("'$.a'", "'$.b'").replace("'old'", "'new'"); + assertEquals(expected, printer.getBuilder().toString()); + assertEquals(expected, CCJSqlParserUtil.parse(expected, + p -> p.withDialect(Dialect.MYSQL)).toString()); + } + + @Test + void rendersExpressionPlanTermsWithoutRewritingPathNames() { + JsonTableFunction.JsonTablePlanExpression nested = + new JsonTableFunction.JsonTablePlanExpression() + .addTerm(new JsonTableFunction.JsonTablePlanTerm() + .setExpression(new Column("doc"))); + JsonTableFunction.JsonTablePlanExpression plan = + new JsonTableFunction.JsonTablePlanExpression() + .addTerm(new JsonTableFunction.JsonTablePlanTerm().setName("doc")) + .addOperator(JsonTableFunction.JsonTablePlanOperator.OUTER) + .addTerm(new JsonTableFunction.JsonTablePlanTerm() + .setNestedPlanExpression(nested)); + RecordingDeParser printer = new RecordingDeParser(); + plan.appendTo(printer.getBuilder(), expression -> expression.accept(printer, CONTEXT)); + assertEquals("doc OUTER (payload)", printer.getBuilder().toString()); + assertEquals(List.of("doc"), printer.columns); + assertEquals("doc OUTER (doc)", plan.toString()); + } + + @Test + void leavesOpaqueKeyValueObjectsAndAdditionalQueryPathsUnchanged() throws Exception { + JsonKeyValuePair pair = new JsonKeyValuePair("raw_key", "raw_value", false, + JsonKeyValuePairSeparator.COLON); + RecordingDeParser printer = new RecordingDeParser(); + pair.appendTo(printer.getBuilder(), expression -> expression.accept(printer, CONTEXT)); + assertEquals(pair.toString(), printer.getBuilder().toString()); + assertTrue(printer.columns.isEmpty()); + JsonFunction query = (JsonFunction) CCJSqlParserUtil.parseExpression( + "JSON_QUERY(doc, '$.a' WITH ARRAY WRAPPER, '$.a')"); + RecordingDeParser queryPrinter = new RecordingDeParser(); + query.accept(queryPrinter, CONTEXT); + assertEquals("JSON_QUERY(payload, '$.b' WITH ARRAY WRAPPER, '$.a')", + queryPrinter.getBuilder().toString()); + assertEquals(List.of("$.a"), queryPrinter.strings); + } + + @Test + void rewritesScalarSubqueriesThroughTheConnectedStatementDeparser() throws Exception { + Statement statement = CCJSqlParserUtil.parse( + "SELECT JSON_VALUE((SELECT doc FROM source_table), '$.a')"); + String before = statement.toString(); + RecordingDeParser printer = new RecordingDeParser(null); + statement.accept(new StatementDeParser(printer, new SelectDeParser(), printer.getBuilder()), + null); + + String expected = before.replace("SELECT doc", "SELECT payload") + .replace("'$.a'", "'$.b'"); + assertEquals(expected, printer.getBuilder().toString()); + assertEquals(expected, CCJSqlParserUtil.parse(expected).toString()); + assertEquals(List.of("doc"), printer.columns); + assertEquals(before, statement.toString()); + } + + @Test + void preservesNullPassingExpressionsInIncompleteScalarBuilders() throws Exception { + JsonFunction function = (JsonFunction) CCJSqlParserUtil.parseExpression( + "JSON_VALUE(doc, '$.a')"); + function.addPassingExpression(null); + function.addPassingExpression(new Column("filter_value")); + RecordingDeParser printer = new RecordingDeParser(); + function.accept(printer, CONTEXT); + + assertEquals("JSON_VALUE(doc, '$.a' PASSING null, filter_value)", function.toString()); + assertEquals("JSON_VALUE(payload, '$.b' PASSING null, r_filter_value)", + printer.getBuilder().toString()); + assertEquals(List.of("doc", "filter_value"), printer.columns); + } + + @Test + void preservesNullPassingClausesAndPlanTermsInIncompleteTableBuilders() { + JsonTableFunction function = new JsonTableFunction() + .setJsonInputExpression(new Column("doc")) + .addPassingClause(new JsonTableFunction.JsonTablePassingClause( + new Column("filter_value"), "filter")) + .setPlanClause(new JsonTableFunction.JsonTablePlanClause().setPlanExpression( + new JsonTableFunction.JsonTablePlanExpression().addTerm(null) + .addOperator(JsonTableFunction.JsonTablePlanOperator.OUTER) + .addTerm(null))); + function.getPassingClauses().add(0, null); + RecordingDeParser printer = new RecordingDeParser(); + function.accept(printer, CONTEXT); + + assertEquals("JSON_TABLE(doc PASSING null, filter_value AS filter null " + + "PLAN (null OUTER null))", function.toString()); + assertEquals("JSON_TABLE(payload PASSING null, r_filter_value AS filter null " + + "PLAN (null OUTER null))", printer.getBuilder().toString()); + assertEquals(List.of("doc", "filter_value"), printer.columns); + } + + @Test + void scalarRendererOverloadsCustomizeBothDefaultAndVisitorOutput() { + JsonFunction function = new JsonFunction(JsonFunctionType.VALUE) { + @Override + public StringBuilder appendValue(StringBuilder builder, + Consumer expressionPrinter) { + return super.appendValue(builder, expressionPrinter).append(" /* custom */"); + } + }; + function.setInputExpression(new JsonFunctionExpression(new Column("doc"))); + function.setJsonPathExpression(new StringValue("$.a")); + RecordingDeParser printer = new RecordingDeParser(); + function.accept(printer, CONTEXT); + + assertEquals("JSON_VALUE(doc, '$.a') /* custom */", function.toString()); + assertEquals("JSON_VALUE(payload, '$.b') /* custom */", printer.getBuilder().toString()); + assertEquals(List.of("doc"), printer.columns); + } + + @Test + void columnAppendHookAndOpaqueCustomColumnsWorkInBothRenderers() { + JsonTableFunction.JsonTableColumnDefinition opaque = + new JsonTableFunction.JsonTableColumnDefinition() { + @Override + public void collectExpressions(List expressions) {} + + @Override + public String toString() { + return "legacy FOR ORDINALITY"; + } + }; + JsonTableFunction.JsonTableValueColumnDefinition structured = + new JsonTableFunction.JsonTableValueColumnDefinition() { + @Override + public StringBuilder appendTo(StringBuilder builder, + Consumer expressionPrinter) { + return super.appendTo(builder, expressionPrinter).append(" /* custom */"); + } + }; + structured.setColumnName("value").setPathExpression(new StringValue("$.a")); + JsonTableFunction function = new JsonTableFunction() + .setJsonInputExpression(new Column("doc")) + .setColumnsClause(new JsonTableFunction.JsonTableColumnsClause() + .addColumnDefinition(opaque).addColumnDefinition(structured)); + RecordingDeParser printer = new RecordingDeParser(); + function.accept(printer, CONTEXT); + + assertEquals("JSON_TABLE(doc COLUMNS (legacy FOR ORDINALITY, " + + "value PATH '$.a' /* custom */))", function.toString()); + assertEquals("JSON_TABLE(payload COLUMNS (legacy FOR ORDINALITY, " + + "value PATH '$.b' /* custom */))", printer.getBuilder().toString()); + assertEquals(List.of("doc"), printer.columns); + assertEquals(List.of("$.a"), printer.strings); + } + + private static class RecordingDeParser extends ExpressionDeParser { + private final List columns = new ArrayList<>(); + private final List strings = new ArrayList<>(); + private final Object expectedContext; + + RecordingDeParser() { + this(CONTEXT); + } + + RecordingDeParser(Object expectedContext) { + this.expectedContext = expectedContext; + } + + @Override + public StringBuilder visit(Column column, S context) { + assertSame(expectedContext, context); + columns.add(column.getColumnName()); + String name = column.getColumnName(); + String replacement = "doc".equals(name) ? "payload" + : "other_doc".equals(name) ? "other_payload" : "r_" + name; + return super.visit(new Column(column.getTable(), replacement), context); + } + + @Override + public StringBuilder visit(StringValue value, S context) { + assertSame(expectedContext, context); + strings.add(value.getValue()); + if ("$.a".equals(value.getValue()) || "old".equals(value.getValue())) { + return super.visit(new StringValue("$.a".equals(value.getValue()) ? "$.b" : "new"), + context); + } + return super.visit(value, context); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/deparser/StatementListDeParserTest.java b/src/test/java/net/sf/jsqlparser/util/deparser/StatementListDeParserTest.java index b6015da492..94c434d6e1 100644 --- a/src/test/java/net/sf/jsqlparser/util/deparser/StatementListDeParserTest.java +++ b/src/test/java/net/sf/jsqlparser/util/deparser/StatementListDeParserTest.java @@ -192,9 +192,10 @@ void appendsToExistingBuilderAndKeepsVisitorStateAcrossCalls() throws Exception @Test void rendersUnsupportedStatementsWithoutDroppingAdjacentStatements() throws Exception { Statements statements = CCJSqlParserUtil.parseStatements( - "select 1; select from; select 2;", parser -> parser.withUnsupportedStatements()); + "select 1; shutdown defrag; select 2;", + parser -> parser.withUnsupportedStatements()); assertInstanceOf(UnsupportedStatement.class, statements.get(1)); - assertEquals("SELECT 1;\nselect from;\nSELECT 2;\n", render(statements)); + assertEquals("SELECT 1;\nshutdown defrag;\nSELECT 2;\n", render(statements)); } @Test diff --git a/src/test/java/net/sf/jsqlparser/util/deparser/StructuredStatementVisitorTest.java b/src/test/java/net/sf/jsqlparser/util/deparser/StructuredStatementVisitorTest.java index b4f4232e11..76450f7a5b 100644 --- a/src/test/java/net/sf/jsqlparser/util/deparser/StructuredStatementVisitorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/deparser/StructuredStatementVisitorTest.java @@ -30,7 +30,9 @@ class StructuredStatementVisitorTest { "ASSERT (1 = 1) AS 'expected'", "ASSERT EXISTS (SELECT 7 FROM users WHERE id = 8)", "EXPORT DATA OPTIONS(uri='gs://example/*.csv',format='CSV') AS SELECT 7 FROM users", - "EXPORT DATA OPTIONS(uri='gs://example/*.csv',format='CSV') AS WITH c AS (SELECT 7 AS id) SELECT id FROM c UNION ALL SELECT 8" + "EXPORT DATA OPTIONS(uri='gs://example/*.csv',format='CSV') AS WITH c AS (SELECT 7 AS id) SELECT id FROM c UNION ALL SELECT 8", + "LOAD DATA INTO ds.t OPTIONS (description = 'x') FROM FILES (format = 'CSV', skip_leading_rows = 1)", + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS TERMINATED BY ',' (a, @b) SET c = @b + 1, d = 'x'" }) void defaultDeparserMatchesStatementOutput(String sql) throws Exception { Statement statement = CCJSqlParserUtil.parse(sql); @@ -68,6 +70,23 @@ void visitsExportOptionsAndQuery() throws Exception { "EXPORT DATA OPTIONS (uri = 'changed', format = 'changed') AS SELECT 107 FROM users WHERE id = 108"); } + @Test + void visitsBigQueryLoadOptions() throws Exception { + assertVisited( + "LOAD DATA INTO ds.t OPTIONS (description = 'x') FROM FILES (format = 'CSV', skip_leading_rows = 1)", + List.of("x", "CSV", "1"), + "LOAD DATA INTO ds.t OPTIONS (description = 'changed') FROM FILES (format = 'changed', skip_leading_rows = 101)"); + } + + @Test + void visitsMySqlLoadColumnsAndAssignments() throws Exception { + // the file name and the separators are literal syntax, as in SELECT ... INTO OUTFILE + assertVisited( + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS TERMINATED BY ',' (a, @b) SET c = @b + 1, d = 'x'", + List.of("1", "x"), + "LOAD DATA INFILE 'a' INTO TABLE t FIELDS TERMINATED BY ',' (a, @b) SET c = @b + 101, d = 'changed'"); + } + private void assertVisited(String sql, List expectedVisits, String expectedOutput) throws Exception { List visited = new ArrayList<>(); diff --git a/src/test/java/net/sf/jsqlparser/util/deparser/TableConstraintExpressionDeParserTest.java b/src/test/java/net/sf/jsqlparser/util/deparser/TableConstraintExpressionDeParserTest.java index f3973613ec..1dc4ce9604 100644 --- a/src/test/java/net/sf/jsqlparser/util/deparser/TableConstraintExpressionDeParserTest.java +++ b/src/test/java/net/sf/jsqlparser/util/deparser/TableConstraintExpressionDeParserTest.java @@ -9,18 +9,27 @@ */ package net.sf.jsqlparser.util.deparser; +import net.sf.jsqlparser.statement.create.table.IndexOption; import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; +import java.util.List; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.LongValue; import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ColumnOption; import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.CheckConstraint; import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; @@ -39,7 +48,30 @@ void createAndAlterFunctionalIndexesUseExpressionVisitor() throws JSQLParserExce assertRewrite("CREATE TABLE t (id INT, INDEX idx ((id + 1)))", "CREATE TABLE t (id INT, INDEX idx ((mapped_id + 101)))"); assertRewrite("ALTER TABLE t ADD INDEX idx ((id + 1))", - "ALTER TABLE t ADD INDEX idx ((mapped_id + 101))"); + "ALTER TABLE t ADD INDEX idx ((mapped_id + 101))"); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ADD CHECK (id > 0)", + "ALTER TABLE t ADD INDEX ix ((id + 1))"}) + void inactiveTableDefinitionsDoNotOverrideAddedColumns(String sql) throws JSQLParserException { + Alter alter = + (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)); + AlterExpression action = alter.getAlterExpressions().get(0); + action.addColDataType("new_col", new ColDataType("INT")); + action.getColDataTypeList().get(0) + .addColumnOptions(ColumnOption.defaultValue(new LongValue(7))); + assertEquals("ALTER TABLE t ADD new_col INT DEFAULT 7", alter.toString()); + StringBuilder buffer = new StringBuilder(); + alter.accept(new StatementDeParser(buffer), null); + assertEquals(alter.toString(), buffer.toString()); + assertEquals(alter.toString(), CCJSqlParserUtil.parse(buffer.toString(), + parser -> parser.withDialect(Dialect.MYSQL)).toString()); + assertEquals("ALTER TABLE t ADD new_col INT DEFAULT 107", rewrite(alter)); + action.setCommentText("'description'"); + buffer.setLength(0); + alter.accept(new StatementDeParser(buffer), null); + assertEquals(alter.toString(), buffer.toString()); } @Test @@ -49,7 +81,7 @@ void alterExcludeUsesVisitorForKeysAndPredicate() throws JSQLParserException { + "((id + 1) WITH =) WHERE (id > 0) DEFERRABLE)"); Alter alter = (Alter) CCJSqlParserUtil.parse( "ALTER TABLE t ADD CONSTRAINT placeholder CHECK (id > 0)"); - alter.getAlterExpressions().get(0).setIndex(table.getIndexes().get(0)); + alter.getAlterExpressions().get(0).setConstraint(table.getTableConstraints().get(0)); assertEquals("ALTER TABLE t ADD CONSTRAINT c EXCLUDE USING gist " + "((mapped_id + 101) WITH =) WHERE (mapped_id > 100) DEFERRABLE", rewrite(alter)); } @@ -60,17 +92,42 @@ void checkAttributesRemainAfterExpressionRewrite() throws JSQLParserException { (Alter) CCJSqlParserUtil.parse("ALTER TABLE t ADD CONSTRAINT c CHECK (id > 0)"); ConstraintAttributes attributes = new ConstraintAttributes(); attributes.setNotValid(true); - alter.getAlterExpressions().get(0).getIndex().setConstraintAttributes(attributes); + alter.getAlterExpressions().get(0).getConstraint().setConstraintAttributes(attributes); assertEquals("ALTER TABLE t ADD CONSTRAINT c CHECK (mapped_id > 100) NOT VALID", rewrite(alter)); } + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void builderDefinitionsRenderWithoutAColumnList(boolean emptyColumnList) + throws JSQLParserException { + CheckConstraint check = new CheckConstraint(); + check.setExpression(CCJSqlParserUtil.parseCondExpression("1 > 0")); + CreateTable table = new CreateTable().withTable(new Table("t")) + .withTableConstraints(List.of(check)); + if (emptyColumnList) { + table.setColumnDefinitions(List.of()); + } + assertEquals("CREATE TABLE t (CHECK (1 > 0))", table.toString()); + StringBuilder buffer = new StringBuilder(); + table.accept(new StatementDeParser(buffer), null); + assertEquals(table.toString(), buffer.toString()); + assertEquals("CREATE TABLE t (CHECK (101 > 100))", rewrite(table)); + table.setTableConstraints(null); + table.setIndexes(List.of(new Index().withType("INDEX").withName("ix") + .withColumnsNames(List.of("id")))); + assertEquals("CREATE TABLE t (INDEX ix (id))", table.toString()); + buffer.setLength(0); + table.accept(new StatementDeParser(buffer), null); + assertEquals(table.toString(), buffer.toString()); + } + @Test void constraintStorageOptionsUseExpressionVisitor() throws JSQLParserException { CreateTable table = (CreateTable) CCJSqlParserUtil.parse( "CREATE TABLE t (id INT, CONSTRAINT c UNIQUE (id))"); - table.getIndexes().get(0).setStorageParameters( - Arrays.asList(new Index.Option("fillfactor", new LongValue(70), true))); + ((KeyConstraint) table.getTableConstraints().get(0)).setStorageParameters( + Arrays.asList(new IndexOption("fillfactor", new LongValue(70), true))); assertEquals("CREATE TABLE t (id INT, CONSTRAINT c UNIQUE (id) WITH (fillfactor = 170))", rewrite(table)); } diff --git a/src/test/java/net/sf/jsqlparser/util/deparser/ValuesWithDeParserTest.java b/src/test/java/net/sf/jsqlparser/util/deparser/ValuesWithDeParserTest.java new file mode 100644 index 0000000000..5afe7b72e2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/deparser/ValuesWithDeParserTest.java @@ -0,0 +1,130 @@ +/*- + * #%L + * JSQLParser library + * %% + * Copyright (C) 2004 - 2019 JSQLParser + * %% + * Dual licensed under GNU LGPL 2.1 or Apache License 2.0 + * #L% + */ +package net.sf.jsqlparser.util.deparser; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.expression.ExpressionVisitor; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.select.SelectVisitor; +import net.sf.jsqlparser.statement.select.Values; +import net.sf.jsqlparser.statement.select.WithItem; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class ValuesWithDeParserTest { + private static Statement parse(String sql) throws Exception { + return CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + @ParameterizedTest + @ValueSource(strings = { + "WITH cte(foo) AS (VALUES (42)) VALUES ((SELECT foo FROM cte))", + "WITH a(n) AS (VALUES (1)), b(n) AS (VALUES (2)) " + + "VALUES ((SELECT n FROM a), (SELECT n FROM b))", + "WITH RECURSIVE c(n) AS (VALUES (1) UNION ALL " + + "SELECT n + 1 FROM c WHERE n < 3) VALUES ((SELECT max(n) FROM c))", + "WITH c(n) AS MATERIALIZED (VALUES (1)) VALUES ((SELECT n FROM c))", + "WITH c(n) AS NOT MATERIALIZED (VALUES (1)) VALUES ((SELECT n FROM c))", + "WITH c AS (DELETE FROM t RETURNING id) VALUES ((SELECT count(*) FROM c))" + }) + void preservesWithItemsInStatementAndDirectValuesDeparsers(String sql) throws Exception { + Values values = assertInstanceOf(Values.class, assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(Dialect.POSTGRESQL))); + String original = values.toString(); + for (boolean direct : new boolean[] {false, true}) { + StringBuilder output = new StringBuilder(); + SelectDeParser selects = new SelectDeParser(); + ExpressionDeParser expressions = new ExpressionDeParser(selects, output); + if (direct) { + new ValuesStatementDeParser(expressions, output).deParse(values); + } else { + values.accept(new StatementDeParser(expressions, selects, output), null); + } + Values reparsed = assertInstanceOf(Values.class, parse(output.toString())); + assertEquals(original, reparsed.toString()); + assertEquals(values.getWithItemsList().size(), reparsed.getWithItemsList().size()); + assertEquals(original, values.toString()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"statement", "select", "expression", "direct", "directWithSelect"}) + void preservesCustomVisitorsAndContext(String entryPoint) throws Exception { + Values values = assertInstanceOf(Values.class, + parse("WITH first_cte AS (VALUES (7)), second_cte AS (VALUES (8)) VALUES (9)")); + String original = values.toString(); + Object expectedContext = new Object(); + StringBuilder output = new StringBuilder(); + List withItems = new ArrayList<>(); + List numbers = new ArrayList<>(); + SelectDeParser selects = new SelectDeParser() { + @Override + public StringBuilder visit(WithItem item, S context) { + assertSame(expectedContext, context); + withItems.add(item.getAlias().getName()); + return super.visit(item, context); + } + }; + ExpressionDeParser expressions = new ExpressionDeParser(selects, output) { + @Override + public StringBuilder visit(LongValue value, S context) { + assertSame(expectedContext, context); + numbers.add(value.getValue()); + return output.append(value.getValue() + 100); + } + }; + selects.setExpressionVisitor(expressions); + selects.setBuilder(output); + switch (entryPoint) { + case "statement": + values.accept(new StatementDeParser(expressions, selects, output), expectedContext); + break; + case "select": + values.accept((SelectVisitor) selects, expectedContext); + break; + case "expression": + values.accept((ExpressionVisitor) expressions, expectedContext); + break; + case "direct": + new ValuesStatementDeParser(expressions, output).deParse(values, expectedContext); + break; + default: + new ValuesStatementDeParser(expressions, selects, output) + .deParse(values, expectedContext); + } + assertEquals(List.of("first_cte", "second_cte"), withItems); + assertEquals(List.of(7L, 8L, 9L), numbers); + assertEquals(parse("WITH first_cte AS (VALUES (107)), " + + "second_cte AS (VALUES (108)) VALUES (109)").toString(), + parse(output.toString()).toString()); + assertEquals(original, values.toString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "SELECT (WITH c(n) AS (VALUES (1)) VALUES ((SELECT n FROM c)))", + "VALUES ((WITH c(n) AS (VALUES (1)) VALUES ((SELECT n FROM c))))", + "SELECT * FROM (WITH c(n) AS (VALUES (1)) VALUES ((SELECT n FROM c))) AS v(n)" + }) + void rendersNestedValuesWithItemsOnce(String sql) throws Exception { + Statement statement = assertSqlCanBeParsedAndDeparsed(sql, true, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output), null); + assertEquals(statement.toString(), parse(output.toString()).toString()); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/metadata/DatabaseMetaDataValidationTest.java b/src/test/java/net/sf/jsqlparser/util/validation/metadata/DatabaseMetaDataValidationTest.java index 7c21680f06..1d0aaa81fa 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/metadata/DatabaseMetaDataValidationTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/metadata/DatabaseMetaDataValidationTest.java @@ -156,4 +156,12 @@ public void testValidationMetadataSelectWithColumnsAndAlias2() new JdbcDatabaseMetaDataCapability(connection, NamesLookup.UPPERCASE); validateNoErrors(sql, 1, DatabaseType.H2, meta); // no errors } + + @Test + public void testValidationMetadataSelectListError() throws JSQLParserException, SQLException { + String sql = "select my.id, my.price from mytable as my"; + JdbcDatabaseMetaDataCapability meta = + new JdbcDatabaseMetaDataCapability(connection, NamesLookup.UPPERCASE); + validateMetadata(sql, 1, 1, meta, true, "my.price"); + } } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/AccountManagementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/AccountManagementValidatorTest.java new file mode 100644 index 0000000000..218994770a --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/AccountManagementValidatorTest.java @@ -0,0 +1,53 @@ +/*- + * #%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.util.validation.validator; + +import java.util.Map; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class AccountManagementValidatorTest extends ValidationTestAsserts { + + private static final Map STATEMENTS = Map.of( + "ALTER USER 'app'@'%' IDENTIFIED BY 'x' ACCOUNT LOCK", Feature.alterUser, + "RENAME USER 'a'@'%' TO 'b'@'%'", Feature.renameUser, + "SET ROLE ALL EXCEPT 'writer'", Feature.setRole, + "SET DEFAULT ROLE ALL TO 'app'@'%'", Feature.setDefaultRole, + "SET PASSWORD FOR 'app'@'%' = 'x'", Feature.setPassword, + "CREATE ROLE IF NOT EXISTS 'reader'", Feature.createRole); + + @Test + public void testAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : STATEMENTS.keySet()) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4); + } + validateNoErrors("CREATE USER 'app'@'%' REQUIRE SSL PASSWORD EXPIRE NEVER", 1, + MySqlVersion.V8_0, MariaDbVersion.V10_5_4); + } + + @Test + public void testMySqlAccountStatementsNotAllowedForPostgresql() throws JSQLParserException { + validate("ALTER USER 'app'@'%' ACCOUNT LOCK", 1, 1, PostgresqlVersion.V14); + validate("SET DEFAULT ROLE ALL TO app", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + for (Map.Entry entry : STATEMENTS.entrySet()) { + validateNotAllowed(entry.getKey(), 1, 1, FeaturesAllowed.DDL, entry.getValue()); + } + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterIndexValidationTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterIndexValidationTest.java new file mode 100644 index 0000000000..a6c934ffe7 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterIndexValidationTest.java @@ -0,0 +1,182 @@ +/*- + * #%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.util.validation.validator; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +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.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpression; +import net.sf.jsqlparser.statement.alter.AlterOperation; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationCapability; +import net.sf.jsqlparser.util.validation.ValidationException; +import net.sf.jsqlparser.util.validation.metadata.DatabaseMetaDataValidation; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterIndexValidationTest { + private static final Named CHILD = new Named(NamedObject.table, "child"); + private static final Named ID = new Named(NamedObject.column, "id"); + private static final Named INDEX = new Named(NamedObject.index, "ix"); + + @ParameterizedTest + @ValueSource(strings = {"INDEX", "KEY", "FULLTEXT INDEX", "SPATIAL INDEX"}) + void addIndexRequiresANewNameAndExistingColumns(String type) throws JSQLParserException { + Alter statement = parse("ALTER TABLE child ADD " + type + " ix (id)", Dialect.MYSQL); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, ID), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, INDEX, ID), visited); + + errors = validate(statement, Set.of(CHILD, ID, INDEX), new ArrayList<>()); + assertEquals(1, errors.size()); + assertTrue(errors.toString().contains("ix does exist"), errors.toString()); + + errors = validate(statement, Set.of(CHILD), new ArrayList<>()); + assertEquals(1, errors.size()); + assertTrue(errors.toString().contains("id does not exist"), errors.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"INDEX (id)", "KEY (id)", "INDEX ((id + 1))"}) + void unnamedIndexesSkipNameLookupButKeepColumnValidation(String definition) + throws JSQLParserException { + Alter statement = parse("ALTER TABLE child ADD " + definition, Dialect.MYSQL); + assertNull(statement.getAlterExpressions().get(0).getIndex().getName()); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, ID), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, ID), visited); + errors = validate(statement, Set.of(CHILD), new ArrayList<>()); + assertTrue(errors.toString().contains("id does not exist"), errors.toString()); + } + + @Test + void namedExpressionIndexesValidateTheirExpressionColumnsOnce() throws JSQLParserException { + Alter statement = parse("ALTER TABLE child ADD INDEX ix ((id + 1))", Dialect.MYSQL); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, ID), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, ID, INDEX), visited); + errors = validate(statement, Set.of(CHILD), new ArrayList<>()); + assertTrue(errors.toString().contains("id does not exist"), errors.toString()); + } + + @Test + void quotedNamesReachTheMetadataContractUnchanged() throws JSQLParserException { + Alter statement = parse("ALTER TABLE `child table` ADD INDEX `new index` (`id.column`)", + Dialect.MYSQL); + Named table = new Named(NamedObject.table, "`child table`"); + Named column = new Named(NamedObject.column, "`id.column`"); + Named index = new Named(NamedObject.index, "`new index`"); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(table, column), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(table, index, column), visited); + errors = validate(statement, Set.of(table, column, index), new ArrayList<>()); + assertTrue(errors.toString().contains("`new index` does exist"), errors.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"INDEX", "KEY"}) + void dropIndexStillRequiresAnExistingName(String keyword) throws JSQLParserException { + Alter statement = parse("ALTER TABLE child DROP " + keyword + " ix", Dialect.MYSQL); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, INDEX), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, INDEX), visited); + errors = validate(statement, Set.of(CHILD), new ArrayList<>()); + assertTrue(errors.toString().contains("ix does not exist"), errors.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"INDEX", "KEY"}) + void renameRequiresTheOldNameAndIntroducesTheNewName(String keyword) + throws JSQLParserException { + Alter statement = parse("ALTER TABLE child RENAME " + keyword + + " `old index` TO `new index`", Dialect.MYSQL); + Named oldIndex = new Named(NamedObject.index, "`old index`"); + Named newIndex = new Named(NamedObject.index, "`new index`"); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, oldIndex), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, oldIndex, newIndex), visited); + + errors = validate(statement, Set.of(CHILD), new ArrayList<>()); + assertTrue(errors.toString().contains("`old index` does not exist"), errors.toString()); + errors = validate(statement, Set.of(CHILD, oldIndex, newIndex), new ArrayList<>()); + assertTrue(errors.toString().contains("`new index` does exist"), errors.toString()); + } + + @ParameterizedTest + @ValueSource(strings = {"PRIMARY KEY", "UNIQUE"}) + void constraintUsingIndexStillReferencesAnExistingIndex(String type) + throws JSQLParserException { + Alter statement = parse("ALTER TABLE child ADD CONSTRAINT c " + type + " USING INDEX ix", + Dialect.POSTGRESQL); + assertNull(statement.getAlterExpressions().get(0).getIndex()); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, INDEX), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, new Named(NamedObject.constraint, "c"), INDEX), visited); + errors = validate(statement, Set.of(CHILD), new ArrayList<>()); + assertTrue(errors.toString().contains("ix does not exist"), errors.toString()); + } + + @Test + void buildersUseTheSameDefinitionRole() { + Alter statement = new Alter(); + statement.setTable(new Table("child")); + statement.addAlterExpression(new AlterExpression().withOperation(AlterOperation.ADD) + .withIndex(new Index().withType("INDEX").withName("ix") + .withColumnsNames(List.of("id")))); + List visited = new ArrayList<>(); + Map> errors = + validate(statement, Set.of(CHILD, ID), visited); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(CHILD, INDEX, ID), visited); + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect)); + } + + private static Map> validate(Alter statement, + Set existing, List visited) { + DatabaseMetaDataValidation metadata = name -> { + visited.add(name); + return existing.contains(name); + }; + return Validation.validate(statement, Validation.createValidationContext( + new FeatureConfiguration(), List.of(metadata))); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterValidatorTest.java index 408e0efa5c..dd32018963 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/AlterValidatorTest.java @@ -9,13 +9,139 @@ */ package net.sf.jsqlparser.util.validation.validator; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationError; +import net.sf.jsqlparser.util.validation.metadata.DatabaseMetaDataValidation; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.util.validation.ValidationContext; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class AlterValidatorTest extends ValidationTestAsserts { + @ParameterizedTest + @ValueSource(strings = {"ADD PRIMARY KEY (id)", "DROP FOREIGN KEY fk_name", "DROP COLUMN id"}) + void ignoresStoredDropColumnsWhenTheRenderedActionUsesAnotherTarget(String action) + throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse("ALTER TABLE t " + action, + parser -> parser.withDialect(Dialect.MYSQL)); + alter.getAlterExpressions().get(0).setDropColumns(List.of("old_id")); + assertEquals("ALTER TABLE t " + action, alter.toString()); + List names = new ArrayList<>(); + DatabaseMetaDataValidation metadata = name -> { + names.add(name); + return !"old_id".equals(name.getFqn()); + }; + AlterValidator validator = new AlterValidator(); + validator.setContext(new ValidationContext().setCapabilities(List.of(metadata))); + validator.validate(alter); + assertTrue(validator.getValidationErrors().isEmpty(), + validator.getValidationErrors().toString()); + assertTrue(names.stream().noneMatch(name -> "old_id".equals(name.getFqn()))); + } + + @Test + void validatesKeyDefinitionsAndDropTargetsWithoutDuplicateKeyColumnChecks() { + List names = new ArrayList<>(); + DatabaseMetaDataValidation metadata = name -> { + names.add(name); + return !"uq".equals(name.getFqn()); + }; + List errors = new Validation(List.of(metadata), + "ALTER TABLE t ADD UNIQUE KEY uq (id)").validate(); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(1, names.stream().filter(name -> "id".equals(name.getFqn())).count()); + assertEquals(1, names.stream().filter(name -> "uq".equals(name.getFqn())).count()); + + names.clear(); + errors = new Validation(List.of(metadata), "ALTER TABLE t DROP (old_a, old_b)").validate(); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(new Named(NamedObject.table, "t"), + new Named(NamedObject.column, "old_a"), + new Named(NamedObject.column, "old_b")), names); + } + + @Test + void validatesForeignKeysFromTheirCurrentStructuredDefinition() throws JSQLParserException { + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE child ADD FOREIGN KEY (parent_id) REFERENCES old_parent (id)"); + ForeignKeyConstraint foreignKey = + (ForeignKeyConstraint) alter.getAlterExpressions().get(0).getConstraint(); + foreignKey.setTable(new Table("app", "new_parent")); + foreignKey.setColumnsNames(List.of("new_parent_id")); + foreignKey.setReferencedColumnNames(List.of("new_id")); + List names = new ArrayList<>(); + DatabaseMetaDataValidation metadata = name -> { + names.add(name); + return true; + }; + + assertTrue(Validation.validate(alter, Validation.createValidationContext( + new FeatureConfiguration(), List.of(metadata))).isEmpty()); + assertEquals(List.of(new Named(NamedObject.table, "child"), + new Named(NamedObject.table, "app.new_parent"), + new Named(NamedObject.column, "new_id"), + new Named(NamedObject.column, "new_parent_id")), names); + } + + @Test + void validatesTheColumnNamedByAnAfterPosition() { + List names = new ArrayList<>(); + DatabaseMetaDataValidation metadata = name -> { + names.add(name); + return !"c1".equals(name.getFqn()); + }; + List errors = new Validation(List.of(metadata), + "ALTER TABLE t ADD COLUMN c1 INT AFTER id, MODIFY c2 INT FIRST").validate(); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(new Named(NamedObject.table, "t"), + new Named(NamedObject.column, "c1"), new Named(NamedObject.column, "id"), + new Named(NamedObject.column, "c2")), names); + + DatabaseMetaDataValidation missing = name -> !"id".equals(name.getFqn()) + && !"c1".equals(name.getFqn()); + errors = new Validation(List.of(missing), "ALTER TABLE t ADD COLUMN c1 INT AFTER id") + .validate(); + assertEquals(1, errors.size()); + assertTrue(errors.toString().contains("id does not exist"), errors.toString()); + } + + @Test + void validatesRenamedConstraintTargetAsANewConstraint() { + List names = new ArrayList<>(); + DatabaseMetaDataValidation metadata = name -> { + names.add(name); + return !"replacement".equals(name.getFqn()); + }; + List errors = new Validation(List.of(metadata), + "ALTER TABLE t RENAME CONSTRAINT original TO replacement").validate(); + assertTrue(errors.isEmpty(), errors.toString()); + assertEquals(List.of(new Named(NamedObject.table, "t"), + new Named(NamedObject.constraint, "original"), + new Named(NamedObject.constraint, "replacement")), names); + DatabaseMetaDataValidation allExist = name -> true; + errors = new Validation(List.of(allExist), + "ALTER TABLE t RENAME CONSTRAINT original TO replacement").validate(); + assertEquals(1, errors.size()); + assertTrue(errors.toString().contains("replacement does exist"), errors.toString()); + } + @Test public void testAlterTableAddColumn() throws JSQLParserException { String sql = "ALTER TABLE mytable ADD COLUMN mycolumn varchar (255)"; diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/CommentValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/CommentValidatorTest.java index 276e416e91..5efa977511 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/CommentValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/CommentValidatorTest.java @@ -9,8 +9,15 @@ */ package net.sf.jsqlparser.util.validation.validator; +import static org.junit.jupiter.api.Assertions.assertEquals; +import java.util.EnumSet; +import java.util.Set; +import java.util.stream.Collectors; import java.util.stream.Stream; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.statement.comment.Comment; +import net.sf.jsqlparser.statement.comment.CommentTarget; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; @@ -29,7 +36,51 @@ static Stream targets() { Arguments.of("MATERIALIZED VIEW mv", Feature.commentOnMaterializedView), Arguments.of("FUNCTION f(IN x integer)", Feature.commentOnFunction), Arguments.of("CONSTRAINT ck ON t", Feature.commentOnConstraint), - Arguments.of("CONSTRAINT ck ON DOMAIN d", Feature.commentOnConstraint)); + Arguments.of("CONSTRAINT ck ON DOMAIN d", Feature.commentOnConstraint), + Arguments.of("TRIGGER trg ON t", Feature.commentOnTrigger), + Arguments.of("POLICY p ON t", Feature.commentOnPolicy), + Arguments.of("RULE r ON v", Feature.commentOnRule), + Arguments.of("PROCEDURE p(integer)", Feature.commentOnProcedure), + Arguments.of("ROUTINE r", Feature.commentOnRoutine), + Arguments.of("AGGREGATE a(*)", Feature.commentOnAggregate), + Arguments.of("CAST (integer AS text)", Feature.commentOnCast), + Arguments.of("ACCESS METHOD am", Feature.commentOnAccessMethod), + Arguments.of("COLLATION c", Feature.commentOnCollation), + Arguments.of("DATABASE d", Feature.commentOnDatabase), + Arguments.of("EVENT TRIGGER et", Feature.commentOnEventTrigger), + Arguments.of("EXTENSION e", Feature.commentOnExtension), + Arguments.of("FOREIGN DATA WRAPPER w", Feature.commentOnForeignDataWrapper), + Arguments.of("FOREIGN TABLE ft", Feature.commentOnForeignTable), + Arguments.of("PROCEDURAL LANGUAGE l", Feature.commentOnLanguage), + Arguments.of("PUBLICATION p", Feature.commentOnPublication), + Arguments.of("ROLE r", Feature.commentOnRole), + Arguments.of("SERVER s", Feature.commentOnServer), + Arguments.of("STATISTICS st", Feature.commentOnStatistics), + Arguments.of("SUBSCRIPTION s", Feature.commentOnSubscription), + Arguments.of("TABLESPACE ts", Feature.commentOnTablespace), + Arguments.of("OPERATOR - (NONE, integer)", Feature.commentOnOperator), + Arguments.of("OPERATOR CLASS ops USING btree", Feature.commentOnOperatorClass), + Arguments.of("OPERATOR FAMILY ops USING gist", Feature.commentOnOperatorFamily), + Arguments.of("CONVERSION conv", Feature.commentOnConversion), + Arguments.of("LARGE OBJECT 4242", Feature.commentOnLargeObject), + Arguments.of("TRANSFORM FOR hstore LANGUAGE plpython3u", + Feature.commentOnTransform), + Arguments.of("TEXT SEARCH CONFIGURATION cfg", + Feature.commentOnTextSearchConfiguration), + Arguments.of("TEXT SEARCH DICTIONARY dict", Feature.commentOnTextSearchDictionary), + Arguments.of("TEXT SEARCH PARSER prs", Feature.commentOnTextSearchParser), + Arguments.of("TEXT SEARCH TEMPLATE tmpl", Feature.commentOnTextSearchTemplate)); + } + + @Test + void coversEveryTargetKind() throws Exception { + Set kinds = EnumSet.noneOf(CommentTarget.Kind.class); + for (Arguments arguments : targets().collect(Collectors.toList())) { + Comment comment = (Comment) CCJSqlParserUtil + .parse("COMMENT ON " + arguments.get()[0] + " IS NULL"); + kinds.add(comment.getTarget().getKind()); + } + assertEquals(EnumSet.allOf(CommentTarget.Kind.class), kinds); } @ParameterizedTest diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/CursorValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/CursorValidatorTest.java new file mode 100644 index 0000000000..0073d4f3bf --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/CursorValidatorTest.java @@ -0,0 +1,57 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import net.sf.jsqlparser.util.validation.feature.SqlServerVersion; +import org.junit.jupiter.api.Test; + +public class CursorValidatorTest extends ValidationTestAsserts { + + @Test + public void allowedForPostgresql() { + for (String sql : new String[] {"DECLARE c SCROLL CURSOR WITH HOLD FOR SELECT a FROM t", + "DECLARE c CURSOR FOR VALUES (1)", "FETCH FORWARD 5 FROM c", "MOVE LAST IN c", + "CLOSE c", "CLOSE ALL"}) { + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + } + + @Test + public void notSupportedByMySqlAndSqlServer() { + validateNotSupported("DECLARE c CURSOR FOR SELECT 1", 1, 1, MySqlVersion.V8_0, + Feature.declareCursor); + validateNotSupported("FETCH NEXT FROM c", 1, 1, MySqlVersion.V8_0, Feature.fetchCursor); + validateNotSupported("MOVE c", 1, 1, SqlServerVersion.V2019, Feature.fetchCursor); + validateNotSupported("CLOSE ALL", 1, 1, MySqlVersion.V8_0, Feature.closeCursor); + } + + @Test + public void featureNotAllowed() { + validateNotAllowed("DECLARE c CURSOR FOR SELECT a FROM t", 1, 1, FeaturesAllowed.SELECT, + Feature.declareCursor); + validateNotAllowed("FETCH ALL c", 1, 1, FeaturesAllowed.SELECT, Feature.fetchCursor); + validateNotAllowed("MOVE c", 1, 1, FeaturesAllowed.DML, Feature.fetchCursor); + validateNotAllowed("CLOSE c", 1, 1, FeaturesAllowed.DDL, Feature.closeCursor); + } + + @Test + public void validatesTheQueryOfTheCursor() { + // the query is validated like a SELECT statement + validateNotAllowed("DECLARE c CURSOR FOR SELECT a FROM t", 1, 1, + new FeaturesAllowed(Feature.declareCursor), Feature.select); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/DeleteValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/DeleteValidatorTest.java index 6cd2f33754..17e6427856 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/DeleteValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/DeleteValidatorTest.java @@ -15,6 +15,7 @@ import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; import org.junit.jupiter.api.Test; public class DeleteValidatorTest extends ValidationTestAsserts { @@ -47,4 +48,12 @@ public void testValidationDeleteLimitOrderBy() throws JSQLParserException { validateNoErrors(sql, 1, DatabaseType.MARIADB, DatabaseType.MYSQL); } + @Test + public void testValidateWithItemsOfDelete() { + String sql = "WITH d AS (UPDATE s SET a = 1 RETURNING a) DELETE FROM t"; + validateNotAllowed(sql, 1, 1, FeaturesAllowed.DELETE, Feature.withItem, Feature.update, + Feature.updateReturning); + validateNoErrors(sql, 1, PostgresqlVersion.V14); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/DropValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/DropValidatorTest.java index 5cfa61fe1a..f7cc632f31 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/DropValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/DropValidatorTest.java @@ -14,6 +14,8 @@ import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; import org.junit.jupiter.api.Test; public class DropValidatorTest extends ValidationTestAsserts { @@ -66,4 +68,30 @@ public void testValidationDropSequenceIfExists() throws JSQLParserException { validateNotSupported(sql, 1, 1, DatabaseType.MYSQL, Feature.dropSequence); } + @Test + public void testValidationDropRoutinesAndAccounts() throws JSQLParserException { + validateNoErrors("DROP FUNCTION IF EXISTS f(int), g(text) CASCADE", 1, + DatabaseType.POSTGRESQL); + validateNoErrors("DROP OWNED BY old_role CASCADE", 1, DatabaseType.POSTGRESQL); + validateNoErrors("DROP USER IF EXISTS 'app'@'%', u2", 1, DatabaseType.MYSQL, + DatabaseType.MARIADB); + } + + @Test + public void testValidationDropSignatureTargets() throws JSQLParserException { + String sql = "DROP CAST IF EXISTS (text AS integer) CASCADE;" + + " DROP OPERATOR public.=== (integer, integer), ~ (NONE, bigint);" + + " DROP TRANSFORM FOR hstore LANGUAGE plpython3u"; + validateNoErrors(sql, 3, DatabaseType.POSTGRESQL); + validateNotAllowed(sql, 3, 3, FeaturesAllowed.DML, Feature.drop); + } + + @Test + public void testValidationReassignOwned() throws JSQLParserException { + String sql = "REASSIGN OWNED BY old_role TO new_role"; + validateNoErrors(sql, 1, PostgresqlVersion.V14, DatabaseType.POSTGRESQL); + validateNotSupported(sql, 1, 1, MySqlVersion.V8_0, Feature.reassignOwned); + validateNotAllowed(sql, 1, 1, FeaturesAllowed.DDL, Feature.reassignOwned); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/InsertValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/InsertValidatorTest.java index 7fae82abc3..77309b0e67 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/InsertValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/InsertValidatorTest.java @@ -13,6 +13,7 @@ import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; import org.junit.jupiter.api.Test; import java.util.Arrays; @@ -71,4 +72,20 @@ public void testInsertMultiRowValue() { validateNoErrors(sql, 1, DatabaseType.SQLSERVER); } + @Test + public void testValidateSelectOfInsert() { + validateNotAllowed("INSERT INTO t SELECT pg_read_file('/etc/passwd')", 1, 1, + FeaturesAllowed.INSERT.copy().remove(Feature.function), Feature.function); + validateNotAllowed("INSERT INTO t SELECT a FROM s FOR UPDATE", 1, 1, + FeaturesAllowed.INSERT, Feature.selectForUpdate); + } + + @Test + public void testValidateWithItemsOfInsert() { + String sql = "WITH d AS (DELETE FROM s RETURNING a) INSERT INTO t SELECT a FROM d"; + validateNotAllowed(sql, 1, 1, FeaturesAllowed.INSERT, Feature.withItem, Feature.delete, + Feature.deleteReturningExpressionList); + validateNoErrors(sql, 1, PostgresqlVersion.V14); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/LoadDataValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/LoadDataValidatorTest.java new file mode 100644 index 0000000000..7da35b40d4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/LoadDataValidatorTest.java @@ -0,0 +1,45 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class LoadDataValidatorTest extends ValidationTestAsserts { + + @Test + public void testLoadDataAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : new String[] { + "LOAD DATA LOCAL INFILE 'a.csv' INTO TABLE t FIELDS TERMINATED BY ',' (a, @b) " + + "SET c = @b + 1", + "LOAD XML INFILE 'a.xml' INTO TABLE t ROWS IDENTIFIED BY ''"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void testLoadDataNotAllowedForPostgresql() throws JSQLParserException { + validate("LOAD DATA INFILE 'a.csv' INTO TABLE t", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("LOAD DATA INFILE 'a.csv' INTO TABLE t", 1, 1, FeaturesAllowed.SELECT, + Feature.loadData); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/LockStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/LockStatementValidatorTest.java new file mode 100644 index 0000000000..a68a6ebde4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/LockStatementValidatorTest.java @@ -0,0 +1,60 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.OracleVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class LockStatementValidatorTest extends ValidationTestAsserts { + + @Test + public void testTableLocksAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : new String[] {"LOCK TABLES t READ, u AS a WRITE", "UNLOCK TABLES"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void testBackupLocksAllowedForMySqlOnly() throws JSQLParserException { + for (String sql : new String[] {"LOCK INSTANCE FOR BACKUP", "UNLOCK INSTANCE"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, DatabaseType.MYSQL); + validate(sql, 1, 1, MariaDbVersion.V10_5_4); + } + } + + @Test + public void testPostgresqlAndOracleLocksAllowed() throws JSQLParserException { + validateNoErrors("LOCK TABLE t IN SHARE MODE NOWAIT", 1, PostgresqlVersion.V14, + OracleVersion.V19C, DatabaseType.POSTGRESQL, DatabaseType.ORACLE); + } + + @Test + public void testUnlockNotAllowedForPostgresql() throws JSQLParserException { + validate("UNLOCK TABLES", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("LOCK TABLES t WRITE", 1, 1, FeaturesAllowed.SELECT, + Feature.lock); + validateNotAllowed("UNLOCK TABLES", 1, 1, FeaturesAllowed.SELECT, Feature.unlockTables); + validateNotAllowed("LOCK INSTANCE FOR BACKUP", 1, 1, FeaturesAllowed.SELECT, + Feature.backupLock); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/MaintenanceValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/MaintenanceValidatorTest.java new file mode 100644 index 0000000000..81244cbac3 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/MaintenanceValidatorTest.java @@ -0,0 +1,56 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class MaintenanceValidatorTest extends ValidationTestAsserts { + + @Test + public void allowedForPostgresql() { + for (String sql : new String[] {"VACUUM (VERBOSE, ANALYZE) t", "VACUUM FULL t", + "VACUUM", "ANALYZE VERBOSE t (a)", "ANALYZE (SKIP_LOCKED) t, s", "ANALYZE", + "CLUSTER t USING t_pkey", "CLUSTER VERBOSE", "CHECKPOINT"}) { + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + } + + @Test + public void analyzeAllowedForMySqlAndMariaDb() { + for (String sql : new String[] {"ANALYZE TABLE t1 UPDATE HISTOGRAM ON c1 WITH 4 BUCKETS", + "ANALYZE NO_WRITE_TO_BINLOG TABLE t, s"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void notSupportedByMySql() { + validateNotSupported("VACUUM t", 1, 1, MySqlVersion.V8_0, Feature.vacuum); + validateNotSupported("CLUSTER t", 1, 1, MySqlVersion.V8_0, Feature.cluster); + validateNotSupported("CHECKPOINT", 1, 1, MySqlVersion.V8_0, Feature.checkpoint); + } + + @Test + public void featureNotAllowed() { + validateNotAllowed("VACUUM t", 1, 1, FeaturesAllowed.SELECT, Feature.vacuum); + validateNotAllowed("CLUSTER", 1, 1, FeaturesAllowed.DML, Feature.cluster); + validateNotAllowed("CHECKPOINT", 1, 1, FeaturesAllowed.DDL, Feature.checkpoint); + validateNotAllowed("ANALYZE t", 1, 1, FeaturesAllowed.SELECT, Feature.analyze); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/MergeValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/MergeValidatorTest.java index ddf62f9467..a2214373fc 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/MergeValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/MergeValidatorTest.java @@ -38,4 +38,12 @@ public void testValidateMergeNotAllowed() throws JSQLParserException { } } + @Test + public void testValidateWithItemsOfMerge() { + String sql = "WITH d AS (DELETE FROM s RETURNING a) " + + "MERGE INTO t USING d ON (t.a = d.a) WHEN MATCHED THEN UPDATE SET b = 1"; + validateNotAllowed(sql, 1, 1, FeaturesAllowed.MERGE, Feature.withItem, Feature.delete, + Feature.deleteReturningExpressionList); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlInstanceStatementsValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlInstanceStatementsValidatorTest.java new file mode 100644 index 0000000000..935746fad2 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlInstanceStatementsValidatorTest.java @@ -0,0 +1,52 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +/** MySQL CREATE and DROP SPATIAL REFERENCE SYSTEM and ALTER INSTANCE. */ +public class MySqlInstanceStatementsValidatorTest extends ValidationTestAsserts { + private static final String CREATE = + "CREATE SPATIAL REFERENCE SYSTEM 4120 NAME 'Greek' DEFINITION 'x'"; + private static final String ALTER = "ALTER INSTANCE RELOAD TLS FOR CHANNEL mysql_main"; + + @Test + public void testAllowedForMySql() throws JSQLParserException { + for (String sql : new String[] {CREATE, ALTER, + "DROP SPATIAL REFERENCE SYSTEM IF EXISTS 4120"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, DatabaseType.MYSQL); + } + } + + @Test + public void testNotAllowedForMariaDbAndPostgresql() throws JSQLParserException { + for (String sql : new String[] {CREATE, ALTER}) { + validate(sql, 1, 1, MariaDbVersion.V10_5_4); + validate(sql, 1, 1, PostgresqlVersion.V14); + } + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed(CREATE, 1, 1, FeaturesAllowed.SELECT, + Feature.createSpatialReferenceSystem); + validateNotAllowed(ALTER, 1, 1, FeaturesAllowed.SELECT, Feature.alterInstance); + validateNotAllowed("DROP SPATIAL REFERENCE SYSTEM 4120", 1, 1, FeaturesAllowed.SELECT, + Feature.drop); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlServerAdminValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlServerAdminValidatorTest.java new file mode 100644 index 0000000000..430e667826 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlServerAdminValidatorTest.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.util.validation.validator; + +import java.util.stream.Stream; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public class MySqlServerAdminValidatorTest extends ValidationTestAsserts { + + static Stream statements() { + return Stream.of( + Arguments.of("FLUSH TABLES t WITH READ LOCK", Feature.flush), + Arguments.of("FLUSH LOCAL BINARY LOGS, RELAY LOGS FOR CHANNEL 'c1'", + Feature.flush), + Arguments.of("KILL QUERY 5", Feature.kill), + Arguments.of("HANDLER db1.t OPEN AS h", Feature.handler), + Arguments.of("HANDLER h READ i1 >= (1, 2) WHERE a > 0 LIMIT 3", Feature.handler), + Arguments.of("HANDLER h CLOSE", Feature.handler), + Arguments.of("RESET PERSIST IF EXISTS max_connections", Feature.resetPersist)); + } + + @ParameterizedTest + @MethodSource("statements") + public void testAllowedForMySql(String sql, Feature feature) throws JSQLParserException { + validateNoErrors(sql, 1, MySqlVersion.V8_0, DatabaseType.MYSQL); + } + + @ParameterizedTest + @MethodSource("statements") + public void testNotAllowedForSelect(String sql, Feature feature) { + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, feature); + } + + @ParameterizedTest + @MethodSource("statements") + public void testNotAllowedForPostgresql(String sql, Feature feature) + throws JSQLParserException { + validate(sql, 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testPostgresqlResetStaysAllowed() throws JSQLParserException { + validateNoErrors("RESET ALL", 1, PostgresqlVersion.V14, DatabaseType.POSTGRESQL); + validate("RESET ALL", 1, 1, MySqlVersion.V8_0); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlShowStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlShowStatementValidatorTest.java new file mode 100644 index 0000000000..20771653de --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/MySqlShowStatementValidatorTest.java @@ -0,0 +1,79 @@ +/*- + * #%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.util.validation.validator; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import net.sf.jsqlparser.util.validation.metadata.AbstractDatabaseMetaDataCapability; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamesLookup; +import org.junit.jupiter.api.Test; + +public class MySqlShowStatementValidatorTest extends ValidationTestAsserts { + + @Test + public void testAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : new String[] {"SHOW GLOBAL VARIABLES LIKE 'a%'", "SHOW FULL PROCESSLIST", + "SHOW TRIGGERS FROM db", "SHOW GRANTS FOR 'u'@'%'", "SHOW WARNINGS LIMIT 5", + "SHOW BINLOG EVENTS IN 'b.000001'", "SHOW ENGINE INNODB STATUS", + "SHOW PROCEDURE CODE p", "SHOW BINARY LOGS"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void testNotAllowedForPostgresql() throws JSQLParserException { + validate("SHOW GLOBAL STATUS", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("SHOW DATABASES LIKE 'a%'", 1, 1, FeaturesAllowed.DML, + Feature.mySqlShow); + } + + @Test + public void testMetadataLooksUpDatabasesAndProcedures() throws JSQLParserException { + List names = new ArrayList<>(); + AbstractDatabaseMetaDataCapability metadata = + new AbstractDatabaseMetaDataCapability(null, NamesLookup.NO_TRANSFORMATION) { + @Override + protected boolean databaseExists(Map results, Named named) { + names.add("database " + named.getFqn()); + return true; + } + + @Override + protected boolean procedureExists(Map results, Named named) { + names.add("procedure " + named.getFqn()); + return true; + } + }; + + validateNoErrors("SHOW EVENTS IN db", 1, metadata); + validateNoErrors("SHOW PROCEDURE CODE s.p", 1, metadata); + validateNoErrors("SHOW FUNCTION CODE f", 1, metadata); + validateNoErrors("SHOW GLOBAL STATUS", 1, metadata); + assertEquals(Arrays.asList("database db", "procedure s.p"), names); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/PostgreSqlSessionStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/PostgreSqlSessionStatementValidatorTest.java new file mode 100644 index 0000000000..ac8a71c026 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/PostgreSqlSessionStatementValidatorTest.java @@ -0,0 +1,51 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class PostgreSqlSessionStatementValidatorTest extends ValidationTestAsserts { + + private static final String[] STATEMENTS = {"DISCARD ALL", "DISCARD TEMP", "LISTEN ch", + "UNLISTEN *", "SHOW TIME ZONE", "SHOW TRANSACTION ISOLATION LEVEL", + "SHOW SESSION AUTHORIZATION", "SHOW search_path", "RESET SESSION AUTHORIZATION", + "COPY t TO STDOUT CSV HEADER FORCE QUOTE *", "COPY BINARY t FROM STDIN"}; + + @Test + public void testAllowedForPostgresql() throws JSQLParserException { + for (String sql : STATEMENTS) { + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + DatabaseType.POSTGRESQL); + } + } + + @Test + public void testSessionStatementsNotAllowedForMySql() throws JSQLParserException { + validate("DISCARD PLANS", 1, 1, MySqlVersion.V8_0); + validate("LISTEN ch", 1, 1, MySqlVersion.V8_0); + validate("UNLISTEN ch", 1, 1, MySqlVersion.V8_0); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("DISCARD SEQUENCES", 1, 1, FeaturesAllowed.SELECT, Feature.discard); + validateNotAllowed("LISTEN ch", 1, 1, FeaturesAllowed.SELECT, Feature.listen); + validateNotAllowed("UNLISTEN *", 1, 1, FeaturesAllowed.SELECT, Feature.listen); + validateNotAllowed("SHOW TIME ZONE", 1, 1, FeaturesAllowed.SELECT, Feature.show); + validateNotAllowed("COPY t TO STDOUT CSV", 1, 1, FeaturesAllowed.SELECT, Feature.copy); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/ReplicationStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/ReplicationStatementValidatorTest.java new file mode 100644 index 0000000000..fb86acbfd4 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/ReplicationStatementValidatorTest.java @@ -0,0 +1,64 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.OracleVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class ReplicationStatementValidatorTest extends ValidationTestAsserts { + private static final String[] REPLICATION = { + "CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h', SOURCE_PORT = 3306", + "CHANGE REPLICATION FILTER REPLICATE_DO_DB = (d1)", + "START REPLICA IO_THREAD", + "STOP REPLICA FOR CHANNEL 'c1'", + "RESET BINARY LOGS AND GTIDS", + "RESET REPLICA ALL"}; + + @Test + public void testReplicationStatementsAllowedForMySql() throws JSQLParserException { + for (String sql : REPLICATION) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, DatabaseType.MYSQL); + validate(sql, 1, 1, MariaDbVersion.V10_5_4); + validate(sql, 1, 1, PostgresqlVersion.V14); + } + } + + @Test + public void testPurgeBinaryLogsAllowedForMySqlAndMariaDb() throws JSQLParserException { + validateNoErrors("PURGE BINARY LOGS TO 'b.000001'", 1, MySqlVersion.V8_0, + MariaDbVersion.V10_5_4, DatabaseType.MYSQL, DatabaseType.MARIADB); + validate("PURGE BINARY LOGS TO 'b.000001'", 1, 1, OracleVersion.V19C); + // Oracle's PURGE keeps its own feature + validateNoErrors("PURGE TABLE t", 1, OracleVersion.V19C); + validate("PURGE TABLE t", 1, 1, MySqlVersion.V8_0); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("CHANGE REPLICATION SOURCE TO SOURCE_HOST = 'h'", 1, 1, + FeaturesAllowed.SELECT, Feature.changeReplicationSource); + validateNotAllowed("CHANGE REPLICATION FILTER REPLICATE_DO_DB = ()", 1, 1, + FeaturesAllowed.SELECT, Feature.changeReplicationFilter); + validateNotAllowed("START REPLICA", 1, 1, FeaturesAllowed.SELECT, Feature.startReplica); + validateNotAllowed("STOP REPLICA", 1, 1, FeaturesAllowed.SELECT, Feature.stopReplica); + validateNotAllowed("RESET REPLICA ALL", 1, 1, FeaturesAllowed.SELECT, + Feature.resetReplication); + validateNotAllowed("PURGE BINARY LOGS BEFORE NOW()", 1, 1, FeaturesAllowed.SELECT, + Feature.purgeBinaryLogs); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/SelectValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/SelectValidatorTest.java index 52b7a5396c..5a78561668 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/SelectValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/SelectValidatorTest.java @@ -17,15 +17,49 @@ import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class SelectValidatorTest extends ValidationTestAsserts { + /** + * {@link FeaturesAllowed#SELECT} does not allow {@link Feature#jdbcParameter}, so a {@code ?} + * argument must be reported wherever the function is written. + */ + private static final FeaturesAllowed SELECT_WITH_TABLE_FUNCTIONS = + new FeaturesAllowed("SELECT + tableFunction", Feature.tableFunction) + .add(FeaturesAllowed.SELECT); + @Test public void testValidationSelectNotAllowed() throws JSQLParserException { String sql = "SELECT 1"; validateNotAllowed(sql, 1, 1, FeaturesAllowed.DDL, Feature.select); } + @Test + public void testValidationMySqlSelectModifiers() { + String sql = + "SELECT HIGH_PRIORITY SQL_SMALL_RESULT SQL_BIG_RESULT SQL_BUFFER_RESULT a FROM t"; + validateNoErrors(sql, 1, DatabaseType.MYSQL, DatabaseType.MARIADB); + validateNotSupported(sql, 1, 1, DatabaseType.POSTGRESQL, Feature.mysqlSelectModifiers); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT a INTO OUTFILE '/tmp/a.txt' FROM t", + "SELECT a FROM t INTO OUTFILE '/tmp/a.txt'", + "SELECT a FROM t INTO DUMPFILE '/tmp/a.bin'", + "SELECT a FROM t WHERE a IN (SELECT b FROM u INTO OUTFILE '/tmp/b.txt')", + "SELECT * FROM t INTO TEMP x"}) + public void testValidationSelectIntoNotAllowed(String sql) { + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, Feature.selectInto); + } + + @Test + public void testValidationMySqlSelectIntoOutfile() { + String sql = "SELECT a FROM t INTO OUTFILE '/tmp/a.txt'"; + validateNoErrors(sql, 1, DatabaseType.MYSQL, DatabaseType.MARIADB); + } + @Test public void testValidationSelectDistinct() throws JSQLParserException { String sql = "SELECT DISTINCT a, b FROM tab"; @@ -87,6 +121,16 @@ public void testValidationForPostgresShare() throws JSQLParserException { Feature.selectForNoKeyUpdate); } + @Test + public void testValidationMultipleLockingClauses() throws JSQLParserException { + String sql = "SELECT * FROM t, u FOR UPDATE OF t FOR SHARE OF u"; + validateNoErrors(sql, 1, DatabaseType.POSTGRESQL); + + String sql2 = "SELECT * FROM t FOR UPDATE FOR NO KEY UPDATE"; + validateNotSupported(sql2, 1, 1, DatabaseType.ORACLE, + Feature.selectForNoKeyUpdate); + } + @Test public void testValidationForUpdateNoWait() throws JSQLParserException { String sql = "SELECT * FROM mytable FOR UPDATE NOWAIT"; @@ -198,6 +242,43 @@ public void testValidateTableFunction() { } } + @Test + public void testValidateFunctionArgumentInWhere() { + validateNotAllowed("SELECT * FROM t WHERE a = f(?)", 1, 1, SELECT_WITH_TABLE_FUNCTIONS, + Feature.jdbcParameter); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT * FROM f(?)", + "SELECT * FROM ROWS FROM (f(1), g(?))", + "SELECT * FROM ROWS FROM (f(1), g(?)) WITH ORDINALITY"}) + public void testValidateTableFunctionArguments(String sql) { + validateNotAllowed(sql, 1, 1, SELECT_WITH_TABLE_FUNCTIONS, Feature.jdbcParameter); + } + + @ParameterizedTest + @ValueSource(strings = {"SELECT upper(a) FROM t", + "SELECT DISTINCT ON (upper(a)) a FROM t", + "SELECT TOP (upper(a)) a FROM t", + "SELECT a FROM t QUALIFY upper(a) = 'X'", + "SELECT a FROM t WINDOW w AS (PARTITION BY upper(a))", + "SELECT a FROM t WINDOW w AS (ORDER BY upper(a))", + "SELECT a FROM t LIMIT upper(a)", + "SELECT a FROM t LIMIT 1 OFFSET upper(a)", + "SELECT a FROM t OFFSET upper(a) ROWS", + "SELECT a FROM t FETCH FIRST upper(a) ROWS ONLY", + "SELECT a FROM t UNION SELECT b FROM u LIMIT upper(a)"}) + public void testValidateFunctionOutsideWhere(String sql) { + validateNotAllowed(sql, 1, 1, + new FeaturesAllowed(Feature.values()).remove(Feature.function), Feature.function); + } + + @Test + public void testValidateSubSelectInSelectList() { + validateNotAllowed("SELECT (SELECT a FROM t FOR UPDATE)", 1, 1, FeaturesAllowed.SELECT, + Feature.selectForUpdate); + } + @Test public void testValidateLateral() throws JSQLParserException { validateNoErrors( diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidatorTest.java index 96b85493c7..778479438e 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/SetStatementValidatorTest.java @@ -11,12 +11,22 @@ import java.util.Arrays; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; import org.junit.jupiter.api.Test; public class SetStatementValidatorTest extends ValidationTestAsserts { + @Test + public void validatesToSeparatelyFromTheGeneralSetFeature() { + String sql = "SET LOCAL search_path TO my_schema, public"; + validateNoErrors(sql, 1, DatabaseType.POSTGRESQL); + validateNotAllowed(sql, 1, 1, new FeaturesAllowed("set-only", Feature.set), + Feature.setAssignmentTo); + } + @Test public void testValidateSet() throws JSQLParserException { for (String sql : Arrays.asList( diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidatorTest.java index d0d2f3ac94..24e0ffac59 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowColumnsStatementValidatorTest.java @@ -9,27 +9,55 @@ */ package net.sf.jsqlparser.util.validation.validator; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; import java.util.Arrays; +import java.util.List; +import java.util.Map; import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.metadata.AbstractDatabaseMetaDataCapability; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamesLookup; import org.junit.jupiter.api.Test; public class ShowColumnsStatementValidatorTest extends ValidationTestAsserts { @Test public void testValidationShowTables() throws Exception { - for (String sql : Arrays.asList("SHOW COLUMNS FROM mytable")) { + for (String sql : Arrays.asList("SHOW COLUMNS FROM mytable", + "SHOW FULL COLUMNS FROM mytable FROM db LIKE 'a%'", + "SHOW EXTENDED FIELDS IN db.mytable WHERE `Key` = 'PRI'")) { validateNoErrors(sql, 1, DatabaseType.MARIADB, DatabaseType.MYSQL); } } @Test public void testValidationShowTablesNotAllowed() throws Exception { - for (String sql : Arrays.asList("SHOW COLUMNS FROM mytable")) { + for (String sql : Arrays.asList("SHOW COLUMNS FROM mytable", + "SHOW FULL FIELDS FROM mytable")) { validateNotAllowed(sql, 1, 1, FeaturesAllowed.DML, Feature.showColumns); } } + @Test + public void testMetadataUsesTheDatabaseClause() throws Exception { + List tables = new ArrayList<>(); + AbstractDatabaseMetaDataCapability metadata = + new AbstractDatabaseMetaDataCapability(null, NamesLookup.NO_TRANSFORMATION) { + @Override + protected boolean tableExists(Map results, Named named) { + tables.add(named.getFqn()); + return true; + } + }; + + validateNoErrors("SHOW COLUMNS FROM t FROM db", 1, metadata); + validateNoErrors("SHOW FULL COLUMNS FROM s.t2", 1, metadata); + assertEquals(Arrays.asList("db.t", "s.t2"), tables); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowCreateStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowCreateStatementValidatorTest.java new file mode 100644 index 0000000000..107b78cdcf --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowCreateStatementValidatorTest.java @@ -0,0 +1,77 @@ +/*- + * #%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.util.validation.validator; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import net.sf.jsqlparser.util.validation.metadata.AbstractDatabaseMetaDataCapability; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamesLookup; +import org.junit.jupiter.api.Test; + +public class ShowCreateStatementValidatorTest extends ValidationTestAsserts { + + @Test + public void testAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : new String[] {"SHOW CREATE TABLE t", "SHOW CREATE VIEW db.v", + "SHOW CREATE PROCEDURE p", "SHOW CREATE FUNCTION f", "SHOW CREATE TRIGGER tr", + "SHOW CREATE EVENT e", "SHOW CREATE DATABASE IF NOT EXISTS db", + "SHOW CREATE USER 'u'@'h'"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void testNotAllowedForPostgresql() throws JSQLParserException { + validate("SHOW CREATE TABLE t", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("SHOW CREATE TABLE t", 1, 1, FeaturesAllowed.DML, Feature.showCreate); + } + + @Test + public void testMetadataLooksUpTablesAndViews() throws JSQLParserException { + List names = new ArrayList<>(); + AbstractDatabaseMetaDataCapability metadata = + new AbstractDatabaseMetaDataCapability(null, NamesLookup.NO_TRANSFORMATION) { + @Override + protected boolean tableExists(Map results, Named named) { + names.add("table " + named.getFqn()); + return true; + } + + @Override + protected boolean viewExists(Map results, Named named) { + names.add("view " + named.getFqn()); + return true; + } + }; + + validateNoErrors("SHOW CREATE TABLE s.t", 1, metadata); + validateNoErrors("SHOW CREATE VIEW v", 1, metadata); + validateNoErrors("SHOW CREATE TRIGGER tr", 1, metadata); + assertEquals(Arrays.asList("table s.t", "view v"), names); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidatorTest.java index 26b62d3820..d06fd6f1a8 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowIndexStatementValidatorTest.java @@ -9,7 +9,12 @@ */ package net.sf.jsqlparser.util.validation.validator; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; import java.util.Arrays; +import java.util.List; +import java.util.Map; import org.junit.jupiter.api.Test; @@ -17,6 +22,9 @@ import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.metadata.AbstractDatabaseMetaDataCapability; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamesLookup; /** * @@ -27,7 +35,8 @@ public class ShowIndexStatementValidatorTest extends ValidationTestAsserts { @Test public void testValidationShowIndex() throws Exception { - for (String sql : Arrays.asList("SHOW INDEX FROM mydatabase")) { + for (String sql : Arrays.asList("SHOW INDEX FROM mydatabase", + "SHOW EXTENDED KEYS IN t FROM db WHERE Non_unique = 0")) { validateNoErrors(sql, 1, DatabaseType.MARIADB, DatabaseType.MYSQL); } } @@ -39,4 +48,21 @@ public void testValidationShowIndexNotAllowed() throws Exception { validateNotAllowed(sql, 1, 1, FeaturesAllowed.DML, Feature.showIndex); } } + + @Test + public void testMetadataLooksUpTheTableInTheTrailingDatabase() throws Exception { + List names = new ArrayList<>(); + AbstractDatabaseMetaDataCapability metadata = + new AbstractDatabaseMetaDataCapability(null, NamesLookup.NO_TRANSFORMATION) { + @Override + protected boolean tableExists(Map results, Named named) { + names.add(named.getFqn()); + return true; + } + }; + + validateNoErrors("SHOW INDEX FROM t FROM db", 1, metadata); + validateNoErrors("SHOW INDEXES IN s.t2", 1, metadata); + assertEquals(Arrays.asList("db.t", "s.t2"), names); + } } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowTableStatusStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowTableStatusStatementValidatorTest.java new file mode 100644 index 0000000000..c5412d8c0e --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/ShowTableStatusStatementValidatorTest.java @@ -0,0 +1,43 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class ShowTableStatusStatementValidatorTest extends ValidationTestAsserts { + + @Test + public void testAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : new String[] {"SHOW TABLE STATUS", "SHOW TABLE STATUS LIKE 'a%'", + "SHOW TABLE STATUS IN db WHERE Comment <> ''"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void testNotAllowedForPostgresql() throws JSQLParserException { + validate("SHOW TABLE STATUS", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("SHOW TABLE STATUS FROM db", 1, 1, FeaturesAllowed.DML, + Feature.showTableStatus); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java index 7a7e52888e..8d3f133ad6 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/StatementValidatorTest.java @@ -10,15 +10,119 @@ package net.sf.jsqlparser.util.validation.validator; import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.ValidationError; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; 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.Arguments; +import org.junit.jupiter.params.provider.MethodSource; public class StatementValidatorTest extends ValidationTestAsserts { + static Stream statementsOutsideSelect() { + return Stream.of( + Arguments.of("COPY t TO '/tmp/t.csv'", Feature.copy), + Arguments.of("LOAD DATA INTO ds.t FROM FILES (format = 'CSV')", Feature.loadData), + Arguments.of("LOAD XML INFILE 'a.xml' INTO TABLE t", Feature.loadData), + Arguments.of("EXPORT DATA OPTIONS (uri = 'gs://b/*.csv', format = 'CSV') " + + "AS SELECT a FROM t", Feature.export), + Arguments.of("ATTACH DATABASE '/tmp/x.db' AS x", Feature.attach), + Arguments.of("DETACH DATABASE x", Feature.detach), + Arguments.of("CONNECT 'postgres://localhost/db'", Feature.connect), + Arguments.of("DISCONNECT", Feature.disconnect), + Arguments.of("PRAGMA database_list", Feature.pragma), + Arguments.of("INSTALL httpfs", Feature.installExtension), + Arguments.of("LOAD httpfs", Feature.loadExtension), + Arguments.of("CREATE MACRO m(a) AS a + 1", Feature.createMacro), + Arguments.of("CREATE EXTENSION REPOSITORY my_repo", + Feature.createExtensionRepository), + Arguments.of("ASSERT (1 = 1) AS 'expected'", Feature.assertStatement), + Arguments.of("SESSION START", Feature.session), + Arguments.of("PREPARE p AS SELECT 1", Feature.prepare), + Arguments.of("DEALLOCATE PREPARE p", Feature.deallocate), + Arguments.of("SAVEPOINT s", Feature.savepoint), + Arguments.of("ROLLBACK", Feature.rollback), + Arguments.of("PREPARE TRANSACTION 'x'", Feature.twoPhaseCommit), + Arguments.of("XA RECOVER", Feature.xa), + Arguments.of("CREATE RESOURCE GROUP rg TYPE = USER", Feature.createResourceGroup), + Arguments.of("ALTER RESOURCE GROUP rg DISABLE", Feature.alterResourceGroup), + Arguments.of("SET RESOURCE GROUP rg", Feature.setResourceGroup), + Arguments.of("INSTALL PLUGIN p SONAME 'p.so'", Feature.installPlugin), + Arguments.of("UNINSTALL COMPONENT 'file://c'", Feature.installComponent), + Arguments.of("LOCK TABLE t IN EXCLUSIVE MODE", Feature.lock), + Arguments.of("ALTER SESSION SET CURRENT_SCHEMA = other", Feature.alterSession), + Arguments.of("ALTER SYSTEM SET archive_command = 'cp %p /tmp/%f'", + Feature.alterSystem), + Arguments.of("PURGE TABLE t", Feature.purge), + Arguments.of("RENAME TABLE a TO b", Feature.alterTable), + Arguments.of("ALTER TABLE ALL IN TABLESPACE a SET TABLESPACE b", + Feature.alterTablespace), + Arguments.of("CREATE USER 'app'@'%' REQUIRE SSL", Feature.createUser), + Arguments.of("CREATE POLICY p ON t", Feature.createPolicy), + Arguments.of("ALTER POLICY p ON t RENAME TO q", Feature.alterPolicy), + Arguments.of("CREATE STATISTICS s ON a, b FROM t", Feature.createStatistics), + Arguments.of("ALTER STATISTICS s RENAME TO s2", Feature.alterStatistics), + Arguments.of("CREATE EVENT e ON SCHEDULE EVERY 1 DAY DO SELECT 1", + Feature.createEvent), + Arguments.of("ALTER EVENT e DISABLE", Feature.alterEvent), + Arguments.of("CREATE TRIGGER trg BEFORE INSERT ON t FOR EACH ROW SELECT 1", + Feature.createTrigger), + Arguments.of("CREATE LANGUAGE plperlu", Feature.createLanguage)); + } + + @ParameterizedTest + @MethodSource("statementsOutsideSelect") + public void testValidateStatementNotAllowedForSelect(String sql, Feature feature) { + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, feature); + } + + @Test + public void testValidateExasolImportExportNotAllowedForSelect() { + FeatureConfiguration exasol = + new FeatureConfiguration().setValue(Feature.dialect, Dialect.EXASOL.name()); + for (String sql : Arrays.asList("IMPORT INTO t FROM LOCAL CSV FILE 'file.csv'", + "SELECT * FROM (IMPORT FROM LOCAL CSV FILE 'file.csv')", + "EXPORT t INTO LOCAL CSV FILE 'file.csv'")) { + List errors = + new Validation(exasol, List.of(FeaturesAllowed.SELECT), sql).validate(); + assertErrorsSize(errors, 1); + assertNotAllowed(errors.get(0).getErrors(), + sql.startsWith("EXPORT") ? Feature.export : Feature.imprt); + } + } + + @Test + public void testValidateStatementsForSupportingDatabases() throws JSQLParserException { + validateNoErrors("ROLLBACK", 1, DatabaseType.DATABASES); + validateNoErrors("SAVEPOINT s", 1, DatabaseType.ORACLE, DatabaseType.MYSQL, + DatabaseType.MARIADB, DatabaseType.POSTGRESQL, DatabaseType.H2); + validateNoErrors("LOCK TABLE t IN EXCLUSIVE MODE", 1, DatabaseType.ORACLE, + DatabaseType.POSTGRESQL); + validateNoErrors("ALTER SYSTEM SET x = 1", 1, DatabaseType.ORACLE, + DatabaseType.POSTGRESQL); + validateNoErrors("ALTER SESSION SET CURRENT_SCHEMA = other", 1, DatabaseType.ORACLE); + validateNoErrors("DEALLOCATE PREPARE p", 1, DatabaseType.MYSQL, DatabaseType.MARIADB, + DatabaseType.POSTGRESQL); + for (String sql : Arrays.asList("COPY t FROM '/tmp/t.csv'", "PREPARE p AS SELECT 1", + "CREATE POLICY p ON t", "ALTER POLICY p ON t RENAME TO q", + "CREATE STATISTICS s ON a, b FROM t", "ALTER STATISTICS s RENAME TO s2")) { + validateNoErrors(sql, 1, DatabaseType.POSTGRESQL); + } + for (String sql : Arrays.asList("CREATE EVENT e ON SCHEDULE EVERY 1 DAY DO DELETE FROM t", + "ALTER EVENT e DISABLE")) { + validateNoErrors(sql, 1, DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + @Test public void testValidateCreateSchema() throws JSQLParserException { for (String sql : Arrays.asList("CREATE SCHEMA my_schema", diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java new file mode 100644 index 0000000000..be7b10dd3c --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java @@ -0,0 +1,42 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class TableMaintenanceValidatorTest extends ValidationTestAsserts { + + @Test + public void testAllowedForMySqlAndMariaDb() throws JSQLParserException { + for (String sql : new String[] {"OPTIMIZE TABLE t1, t2", "REPAIR TABLE t QUICK", + "CHECK TABLE t FOR UPGRADE", "CHECKSUM TABLE t1, t2 EXTENDED"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4, + DatabaseType.MYSQL, DatabaseType.MARIADB); + } + } + + @Test + public void testNotAllowedForPostgresql() throws JSQLParserException { + validate("OPTIMIZE TABLE t", 1, 1, PostgresqlVersion.V14); + } + + @Test + public void testFeatureNotAllowed() throws JSQLParserException { + validateNotAllowed("CHECK TABLE t", 1, 1, FeaturesAllowed.SELECT, Feature.tableMaintenance); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/TableStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/TableStatementValidatorTest.java index c71b8448eb..1f4cc9134c 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/TableStatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/TableStatementValidatorTest.java @@ -9,7 +9,6 @@ */ package net.sf.jsqlparser.util.validation.validator; -import java.util.Arrays; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; @@ -23,16 +22,26 @@ public class TableStatementValidatorTest extends ValidationTestAsserts { @Test public void testValidationSelectAllowed() throws JSQLParserException { String sql = "TABLE columns ORDER BY column_name LIMIT 10 OFFSET 10"; - validateNoErrors(sql, 1, MySqlVersion.V8_0); + validateNoErrors(sql, 1, MySqlVersion.V8_0, PostgresqlVersion.V14); } @Test public void testValidationSelectNotAllowed() throws JSQLParserException { String sql = "TABLE columns ORDER BY column_name LIMIT 10 OFFSET 10"; validateNotAllowed(sql, 1, 1, FeaturesAllowed.DDL, Feature.select, Feature.tableStatement); + } - validateNotSupported(sql, 1, 1, Arrays.asList( - PostgresqlVersion.V14), Feature.tableStatement); + @Test + public void testValidationWithItemNotAllowed() throws JSQLParserException { + String sql = "WITH d AS (DELETE FROM t RETURNING a) TABLE d"; + validateNotAllowed(sql, 1, 1, FeaturesAllowed.SELECT, Feature.withItem, Feature.delete, + Feature.deleteReturningExpressionList); + } + + @Test + public void testValidationWithItemAllowed() throws JSQLParserException { + String sql = "WITH d AS (DELETE FROM t RETURNING a) TABLE d"; + validateNoErrors(sql, 1, PostgresqlVersion.V14); } } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/TablespaceValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/TablespaceValidatorTest.java new file mode 100644 index 0000000000..5b230c4674 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/TablespaceValidatorTest.java @@ -0,0 +1,59 @@ +/*- + * #%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.util.validation.validator; + +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.util.validation.ValidationTestAsserts; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.MariaDbVersion; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; +import org.junit.jupiter.api.Test; + +public class TablespaceValidatorTest extends ValidationTestAsserts { + + @Test + public void testMySqlTablespaces() { + for (String sql : new String[] { + "CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd' ENGINE = InnoDB", + "CREATE UNDO TABLESPACE u1 ADD DATAFILE 'u1.ibu'", + "ALTER TABLESPACE ts1 RENAME TO ts2", "ALTER UNDO TABLESPACE u1 SET INACTIVE"}) { + validateNoErrors(sql, 1, MySqlVersion.V8_0, FeaturesAllowed.DDL); + } + } + + @Test + public void testPostgreSqlTablespaces() { + for (String sql : new String[] { + "CREATE TABLESPACE fast OWNER u1 LOCATION '/ssd1/pg' WITH (random_page_cost = 1.1)", + "ALTER TABLESPACE fast OWNER TO bob", + "ALTER TABLESPACE fast SET (seq_page_cost = 2)", + "ALTER TABLESPACE fast RESET (seq_page_cost)"}) { + validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14, + FeaturesAllowed.DDL); + } + } + + @Test + public void testNotSupportedByMariaDb() { + validateNotSupported("CREATE TABLESPACE ts1 ADD DATAFILE 'ts1.ibd'", 1, 1, + MariaDbVersion.V10_5_4, Feature.createTablespace); + validateNotSupported("ALTER TABLESPACE ts1 RENAME TO ts2", 1, 1, + MariaDbVersion.V10_5_4, Feature.alterTablespace); + } + + @Test + public void testFeatureNotAllowed() { + validateNotAllowed("CREATE TABLESPACE fast LOCATION '/ssd1/pg'", 1, 1, + FeaturesAllowed.ALTER, Feature.createTablespace); + validateNotAllowed("ALTER TABLESPACE fast RENAME TO faster", 1, 1, + FeaturesAllowed.CREATE, Feature.alterTablespace); + } +} diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/UpdateValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/UpdateValidatorTest.java index ef8564376e..716f7dcf4b 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/UpdateValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/UpdateValidatorTest.java @@ -14,6 +14,7 @@ import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; +import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion; import org.junit.jupiter.api.Test; public class UpdateValidatorTest extends ValidationTestAsserts { @@ -70,4 +71,12 @@ public void testUpdateWithOrderByAndLimit() throws JSQLParserException { validateNoErrors(sql, 1, DatabaseType.MYSQL, DatabaseType.MARIADB); } + @Test + public void testValidateWithItemsOfUpdate() { + String sql = "WITH d AS (DELETE FROM s RETURNING a) UPDATE t SET b = 1"; + validateNotAllowed(sql, 1, 1, FeaturesAllowed.UPDATE, Feature.withItem, Feature.delete, + Feature.deleteReturningExpressionList); + validateNoErrors(sql, 1, PostgresqlVersion.V14); + } + } diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/ValuesStatementValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/ValuesStatementValidatorTest.java index 66f7209acf..bc511d628b 100644 --- a/src/test/java/net/sf/jsqlparser/util/validation/validator/ValuesStatementValidatorTest.java +++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/ValuesStatementValidatorTest.java @@ -9,8 +9,10 @@ */ package net.sf.jsqlparser.util.validation.validator; +import net.sf.jsqlparser.parser.feature.Feature; import net.sf.jsqlparser.util.validation.ValidationTestAsserts; import net.sf.jsqlparser.util.validation.feature.DatabaseType; +import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed; import org.junit.jupiter.api.Test; public class ValuesStatementValidatorTest extends ValidationTestAsserts { @@ -22,4 +24,11 @@ public void testValidateValuesStatement() { 1, DatabaseType.SQLSERVER); } + @Test + public void testValidateWithItemsOfValues() { + validateNotAllowed("WITH d AS (UPDATE t SET a = 1 RETURNING a) VALUES (1)", 1, 1, + FeaturesAllowed.SELECT.copy().add(Feature.values), Feature.withItem, + Feature.update, Feature.updateReturning); + } + } diff --git a/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition17.sql b/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition17.sql index 29cfb84a0b..ae49ca05c2 100644 --- a/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition17.sql +++ b/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition17.sql @@ -12,4 +12,5 @@ where current of cursor_name --@FAILURE: Encountered unexpected token: "of" "OF" recorded first on Aug 3, 2021, 7:20:08 AM --@FAILURE: Encountered: / "of", at line 11, column 15, in lexical state DEFAULT. recorded first on 15 May 2025, 16:24:08 ---@FAILURE: --- recorded first on 11 Apr 2026, 22:18:19 \ No newline at end of file +--@FAILURE: --- recorded first on 11 Apr 2026, 22:18:19 +--@SUCCESSFULLY_PARSED_AND_DEPARSED first on 12 Nov 2026, 13:22:49 \ No newline at end of file diff --git a/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition18.sql b/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition18.sql index 904ddb779c..3da545cea4 100644 --- a/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition18.sql +++ b/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/condition18.sql @@ -14,4 +14,5 @@ where current of c_cur1 --@FAILURE: Encountered unexpected token: "of" "OF" recorded first on Aug 3, 2021, 7:20:08 AM --@FAILURE: Encountered: / "of", at line 12, column 15, in lexical state DEFAULT. recorded first on 15 May 2025, 16:24:08 ---@FAILURE: --- recorded first on 11 Apr 2026, 22:18:19 \ No newline at end of file +--@FAILURE: --- recorded first on 11 Apr 2026, 22:18:19 +--@SUCCESSFULLY_PARSED_AND_DEPARSED first on 12 Nov 2026, 13:22:49 \ No newline at end of file diff --git a/src/test/resources/postgresql/select-forms.sql b/src/test/resources/postgresql/select-forms.sql new file mode 100644 index 0000000000..1e807801fb --- /dev/null +++ b/src/test/resources/postgresql/select-forms.sql @@ -0,0 +1,122 @@ +--- +-- #%L +-- JSQLParser library +-- %% +-- Copyright (C) 2004 - 2026 JSQLParser +-- %% +-- Dual licensed under GNU LGPL 2.1 or Apache License 2.0 +-- #L% +--- +SELECT * INTO i01 FROM t; +SELECT * INTO TABLE i02 FROM t; +SELECT * INTO TEMP i03 FROM t; +SELECT * INTO TEMPORARY i04 FROM t; +SELECT * INTO TEMP TABLE i05 FROM t; +SELECT * INTO TEMPORARY TABLE i06 FROM t; +SELECT * INTO LOCAL TEMP i07 FROM t; +SELECT * INTO LOCAL TEMPORARY i08 FROM t; +SELECT * INTO LOCAL TEMP TABLE i09 FROM t; +SELECT * INTO LOCAL TEMPORARY TABLE i10 FROM t; +SELECT * INTO GLOBAL TEMP i11 FROM t; +SELECT * INTO GLOBAL TEMPORARY i12 FROM t; +SELECT * INTO GLOBAL TEMP TABLE i13 FROM t; +SELECT * INTO GLOBAL TEMPORARY TABLE i14 FROM t; +SELECT * INTO UNLOGGED i15 FROM t; +SELECT * INTO UNLOGGED TABLE i16 FROM t; +SELECT * INTO sch.i17 FROM t; +SELECT * INTO UNLOGGED sch.i18 FROM t; +SELECT * INTO TABLE sch.i19 FROM t; +SELECT * INTO TEMP sch.i20 FROM t; +SELECT a, b INTO TEMP i21 FROM t WHERE a > 1 GROUP BY a, b ORDER BY a LIMIT 3; +SELECT DISTINCT a INTO TEMP i22 FROM t; +SELECT 1 AS x INTO TEMP i23; +SELECT a INTO UNLOGGED i24 FROM t UNION SELECT b FROM t; +WITH w AS (SELECT 1 AS x) SELECT x INTO TEMP i25 FROM w; +SELECT * INTO TEMP temp FROM t; +SELECT * INTO TEMP "Mixed" FROM t; +SELECT * INTO TABLE temp FROM t; +SELECT * INTO TEMP unlogged FROM t; +SELECT * INTO temp FROM t; +SELECT * INTO temporary FROM t; +SELECT * INTO unlogged FROM t; +SELECT * INTO local FROM t; +SELECT * INTO global FROM t; +SELECT * INTO temp.i26 FROM t; +SELECT 1 INTO temp; +SELECT * FROM a JOIN b USING (id) AS j; +SELECT j.id FROM a JOIN b USING (id) AS j; +SELECT * FROM a INNER JOIN b USING (id) AS j; +SELECT * FROM a LEFT JOIN b USING (id) AS j; +SELECT * FROM a RIGHT OUTER JOIN b USING (id) AS j; +SELECT * FROM a FULL JOIN b USING (id) AS j; +SELECT * FROM a JOIN b USING (id, x) AS j; +SELECT * FROM a JOIN b USING (id) AS j JOIN c USING (id) AS k; +SELECT * FROM a JOIN b USING (id) AS j WHERE j.id = 1; +SELECT * FROM a JOIN b USING (id) AS "J"; +SELECT * FROM a JOIN b AS bb USING (id) AS j; +SELECT * FROM (a JOIN b USING (id) AS j) AS p; +SELECT * FROM a JOIN b USING (id) AS j, c; +SELECT * FROM a JOIN b USING (id) AS j ORDER BY 1; +SELECT * FROM a JOIN b USING (id) AS local; +SELECT ts AT LOCAL FROM t; +SELECT ts AT LOCAL AS l FROM t; +SELECT ts AT TIME ZONE 'UTC' AT LOCAL FROM t; +SELECT ts AT LOCAL AT TIME ZONE 'UTC' FROM t; +SELECT ts AT LOCAL AT LOCAL FROM t; +SELECT ts AT TIME ZONE 'UTC' AT LOCAL AT TIME ZONE 'CET' AT TIME ZONE 'UTC' AT LOCAL FROM t; +SELECT (ts AT LOCAL)::date FROM t; +SELECT ts AT LOCAL::date FROM t; +SELECT ts AT LOCAL::date::text AT LOCAL FROM t; +SELECT ts::timestamp AT LOCAL FROM t; +SELECT now() AT LOCAL; +SELECT TIMESTAMP '2024-01-01 00:00:00' AT LOCAL; +SELECT * FROM t WHERE ts AT LOCAL > now() AT LOCAL; +SELECT ts AT LOCAL + INTERVAL '1 day' FROM t; +SELECT ts + INTERVAL '1 day' AT LOCAL FROM t; +SELECT a FROM t ORDER BY ts AT LOCAL; +SELECT ts AT LOCAL local FROM t; +SELECT CURRENT_TIMESTAMP AT LOCAL; +SELECT -ts AT LOCAL FROM t; +SELECT s IS NORMALIZED FROM t; +SELECT s IS NOT NORMALIZED FROM t; +SELECT s IS NFC NORMALIZED FROM t; +SELECT s IS NFD NORMALIZED FROM t; +SELECT s IS NFKC NORMALIZED FROM t; +SELECT s IS NFKD NORMALIZED FROM t; +SELECT s IS NOT NFC NORMALIZED FROM t; +SELECT s IS NOT NFD NORMALIZED FROM t; +SELECT s IS NOT NFKC NORMALIZED FROM t; +SELECT s IS NOT NFKD NORMALIZED FROM t; +SELECT * FROM t WHERE s IS NFC NORMALIZED; +SELECT * FROM t WHERE s IS NOT NORMALIZED AND a = 1; +SELECT * FROM t WHERE NOT s IS NORMALIZED OR s IS NULL; +SELECT NOT s IS NFC NORMALIZED FROM t; +SELECT 'abc' IS NORMALIZED; +SELECT (s || 'x') IS NFKC NORMALIZED FROM t; +SELECT s || 'x' IS NFKC NORMALIZED FROM t; +SELECT lower(s) IS NFD NORMALIZED AS n FROM t; +SELECT CASE WHEN s IS NORMALIZED THEN 1 ELSE 0 END FROM t; +SELECT s IS NORMALIZED IS TRUE FROM t; +SELECT s IS NOT NFC NORMALIZED IS NOT NULL FROM t; +SELECT s IS NOT NULL IS NORMALIZED FROM t; +SELECT s COLLATE "C" IS NFC NORMALIZED FROM t; +SELECT s IS NORMALIZED AND s IS NFD NORMALIZED FROM t; +SELECT a BETWEEN 1 AND 2 IS NORMALIZED FROM t; +SELECT s LIKE 'a' IS NORMALIZED FROM t; +SELECT a = 1 IS NORMALIZED FROM t; +SELECT (s IS NORMALIZED) = true FROM t; +SELECT s IS NORMALIZED normalized FROM t; +SELECT s IS NORMALIZED NFC FROM t; +SELECT nfc, normalized FROM (SELECT 1 AS nfc, 2 AS normalized) x; +SELECT xmlelement(name foo, xmlattributes(a AS x, b)) FROM t; +SELECT xmlelement(name foo, xmlattributes(a AS x)) FROM t; +SELECT xmlelement(name foo, xmlattributes(a, b, c)) FROM t; +SELECT xmlelement(name foo, xmlattributes(a AS x, b AS y), 'content') FROM t; +SELECT xmlelement(name foo, xmlattributes(a AS x), 'content', s, a + 1) FROM t; +SELECT xmlelement(name "foo$bar", xmlattributes('xyz' AS "a&b")) FROM t; +SELECT xmlelement(name foo, xmlattributes(a + 1 AS x, lower(s) AS y)) FROM t; +SELECT xmlelement(name foo, xmlattributes(current_date AS bar), 'cont', 'ent'); +SELECT xmlelement(name foo, xmlattributes(a AS x), xmlelement(name bar, xmlattributes(b AS y), s)) FROM t; +SELECT xmlelement(NAME foo, XMLATTRIBUTES(a AS x)) FROM t; +SELECT xmlelement(name foo, xmlattributes(t.a, t.b AS y)) FROM t; +SELECT xmlelement(name foo, xmlattributes(a AS x)) AS e FROM t WHERE a = 1; diff --git a/src/test/resources/postgresql/type-ddl.sql b/src/test/resources/postgresql/type-ddl.sql index 375b79446c..a774fdab1a 100644 --- a/src/test/resources/postgresql/type-ddl.sql +++ b/src/test/resources/postgresql/type-ddl.sql @@ -16,6 +16,8 @@ CREATE TYPE empty_composite AS () CREATE TYPE localized AS (label text COLLATE pg_catalog."C", tags text[], created timestamp with time zone) CREATE TYPE float8range AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi) CREATE TYPE app.r AS RANGE (SUBTYPE_OPCLASS = pg_catalog.text_ops, SUBTYPE = text, COLLATION = pg_catalog."C", CANONICAL = app.canonical, MULTIRANGE_TYPE_NAME = app.mr) +CREATE TYPE box3 (INPUT = box3_in, OUTPUT = box3_out, INTERNALLENGTH = 16) +CREATE TYPE app.box3 (INPUT = app.box3_in, OUTPUT = app.box3_out, ELEMENT = float8, LIKE = double precision, DELIMITER = ';', PASSEDBYVALUE, COLLATABLE = false) ALTER TYPE mood ADD VALUE IF NOT EXISTS 'great' AFTER 'happy' ALTER TYPE mood ADD VALUE 'bad' BEFORE 'sad' ALTER TYPE mood ADD VALUE 'new' @@ -23,6 +25,7 @@ ALTER TYPE mood RENAME VALUE 'ok' TO 'fine' ALTER TYPE mood OWNER TO CURRENT_USER ALTER TYPE mood RENAME TO feeling ALTER TYPE mood SET SCHEMA app +ALTER TYPE box3 SET (SEND = box3_send, RECEIVE = NONE, STORAGE = plain) ALTER TYPE inventory_item RENAME ATTRIBUTE name TO title CASCADE ALTER TYPE inventory_item ADD ATTRIBUTE sku text COLLATE "C" RESTRICT ALTER TYPE inventory_item DROP ATTRIBUTE IF EXISTS price CASCADE @@ -82,3 +85,5 @@ ALTER EXTENSION hstore ADD TRANSFORM FOR hstore LANGUAGE plpython3u ALTER EXTENSION hstore ADD OPERATOR app.&& (integer, integer) ALTER EXTENSION hstore DROP OPERATOR = (hstore, hstore) ALTER EXTENSION hstore ADD OPERATOR - (NONE, integer) +ALTER EXTENSION hstore ADD OPERATOR app.-> (hstore, text) +ALTER EXTENSION hstore DROP OPERATOR <<= (inet, inet)