Merge branch 'master' into fix/snowflake-json-path-keywords

Author: manticore-projects

README.md

@@ -151,13 +151,17 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 | **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` |
 | **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` |
 | **MySQL account management** | `CREATE`/`ALTER`/`RENAME USER` · `CREATE ROLE` · `SET ROLE` · `SET DEFAULT ROLE` · `SET PASSWORD` |
 | **Tablespaces** | MySQL and PostgreSQL `CREATE TABLESPACE` · `ALTER TABLESPACE` |
 | **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 TABLE STATUS` · `SHOW CREATE TABLE`/`VIEW`/`PROCEDURE`/`FUNCTION`/`TRIGGER`/`EVENT`/`DATABASE`/`USER` |
+| **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` |
 | **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` |
 

src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java

@@ -45,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;
@@ -395,6 +396,14 @@ default void visit(IsUnknownExpression isUnknownExpression) {
         this.visit(isUnknownExpression, null);
     }
 
+    default <S> T visit(IsNormalizedExpression isNormalizedExpression, S context) {
+        return isNormalizedExpression.getLeftExpression().accept(this, context);
+    }
+
+    default void visit(IsNormalizedExpression isNormalizedExpression) {
+        this.visit(isNormalizedExpression, null);
+    }
+
     <S> T visit(LikeExpression likeExpression, S context);
 
     default void visit(LikeExpression likeExpression) {

src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java

@@ -48,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;
@@ -296,6 +297,11 @@ public <S> T visit(IsUnknownExpression isUnknownExpression, S context) {
         return isUnknownExpression.getLeftExpression().accept(this, context);
     }
 
+    @Override
+    public <S> T visit(IsNormalizedExpression isNormalizedExpression, S context) {
+        return isNormalizedExpression.getLeftExpression().accept(this, context);
+    }
+
     @Override
     public <S> T visit(LikeExpression likeExpression, S context) {
         return visitExpressions(likeExpression, context, likeExpression.getLeftExpression(),

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<Expression> 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<Expression> 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();
     }
 }

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 extends Expression> E getLeftExpression(Class<E> 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, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
+        return expressionVisitor.visit(this, context);
+    }
+
+    /** Appends the test, rendering the operand through the renderer. */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> 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();
+    }
+}

src/main/java/net/sf/jsqlparser/parser/RoutineBodyBoundary.java

@@ -248,7 +248,7 @@ private void acceptStatementToken(Token token, Token next) {
         if (statementStart) {
             statementKind = kind;
         }
-        if (statementKind == K_DECLARE && keyword(token, "HANDLER")) {
+        if (statementKind == K_DECLARE && token.kind == K_HANDLER) {
             handlerAction = true;
         }
         statementStart = false;

src/main/java/net/sf/jsqlparser/parser/feature/Feature.java

@@ -32,6 +32,8 @@
 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;
@@ -55,11 +57,15 @@
 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;
@@ -494,6 +500,27 @@ public enum Feature {
      */
     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
      *
@@ -539,6 +566,11 @@ 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
@@ -796,6 +828,24 @@ public enum Feature {
      * @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,
     /**
      * SQL "COMMENT ON" statement is allowed
      *
@@ -945,6 +995,12 @@ public enum Feature {
      * @see net.sf.jsqlparser.statement.alter.AlterTrigger
      */
     alterTrigger,
+    /**
+     * PostgreSQL "ALTER RULE" statement is allowed
+     *
+     * @see net.sf.jsqlparser.statement.alter.AlterRule
+     */
+    alterRule,
     /**
      * SQL block starting with "BEGIN" and ends with "END" statement is allowed
      *
@@ -982,6 +1038,12 @@ public enum Feature {
      * @see net.sf.jsqlparser.statement.notify.ListenStatement
      */
     listen,
+    /**
+     * MySQL "RESET PERSIST" statement is allowed
+     *
+     * @see ResetStatement#isPersist()
+     */
+    resetPersist,
     /**
      * @see Pivot
      */

src/main/java/net/sf/jsqlparser/schema/TableReference.java

@@ -11,7 +11,10 @@
 
 import java.io.Serializable;
 
-/** A relation target with optional PostgreSQL inheritance scope, shared by LOCK and TRUNCATE. */
+/**
+ * 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;
@@ -84,6 +87,27 @@ public StringBuilder appendTo(StringBuilder builder) {
         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();