From e32c7081dcb61ca38a51c4124d90b4f6b5a758ef Mon Sep 17 00:00:00 2001
From: minleejae <mmj9808@gmail.com>
Date: Thu, 5 Nov 2026 13:10:58 +0900
Subject: [PATCH] feat: parse MySQL EXPLAIN options, prepared statements and DO

MySQL's EXPLAIN FORMAT = name, EXPLAIN ANALYZE FORMAT = name,
EXPLAIN ... INTO @var, EXPLAIN FOR CONNECTION and FOR SCHEMA, their
DESCRIBE and DESC spellings, DESCRIBE t col, PREPARE ... FROM,
EXECUTE ... USING, DROP PREPARE and DO expr failed to parse.

Extend the existing models. ExplainStatement keeps ANALYZE and FORMAT as
options, marks FORMAT = name with useEqual and reads it as a Format enum,
and gains the INTO variable, the connection id, the schema, a column
pattern and a derived TargetKind. DescribeStatement gains the column
pattern, PrepareStatement the FROM source, Execute the USING variables,
DeallocateStatement a DROP keyword and DoStatement MySQL's select-list
items. One ExplainableStatement production reads the explained statement
for both EXPLAIN paths, and the user variables reuse MySqlIntoVariable.

The forms are read with the MySQL and MariaDB dialects and without a
dialect, except DESCRIBE TABLE t, DESCRIBE t col and DO before a string,
which other products read differently. Other dialects are unchanged.
Wire the deparser, visitors, table finder (EXPLAIN t now reports t,
PREPARE ... FROM raises like EXECUTE), validation (prepare,
executeExecute, executeUsing and doStatement in the MySQL and MariaDB
capabilities) and feature analysis.

Signed-off-by: minleejae <mmj9808@gmail.com>
---
 README.md                                     |   1 +
 .../sf/jsqlparser/parser/feature/Feature.java |   5 +
 .../statement/DeallocateStatement.java        |  33 +-
 .../statement/DescribeStatement.java          |  45 ++-
 .../sf/jsqlparser/statement/DoStatement.java  |  53 ++-
 .../statement/ExplainStatement.java           | 199 +++++++++-
 .../statement/PrepareStatement.java           |  42 ++-
 .../statement/StatementFeatureVisitor.java    |  12 +-
 .../statement/StatementVisitorAdapter.java    |   4 +-
 .../jsqlparser/statement/execute/Execute.java |  32 ++
 .../sf/jsqlparser/util/TablesNamesFinder.java |  18 +-
 .../util/deparser/StatementDeParser.java      |  28 +-
 .../validation/feature/MariaDbVersion.java    |   7 +
 .../util/validation/feature/MySqlVersion.java |   6 +
 .../validator/ExecuteValidator.java           |   2 +
 .../validator/StatementValidator.java         |   4 +
 .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 309 ++++++++++++++--
 src/site/sphinx/index.rst                     |   2 +
 src/site/sphinx/usage.rst                     |  55 +++
 .../parser/ASTNodeCoverageTest.java           |  10 +-
 .../jsqlparser/statement/DoStatementTest.java | 127 ++++++-
 .../statement/MySqlExplainTest.java           | 346 ++++++++++++++++++
 .../statement/MySqlPreparedStatementTest.java | 220 +++++++++++
 23 files changed, 1477 insertions(+), 83 deletions(-)
 create mode 100644 src/test/java/net/sf/jsqlparser/statement/MySqlExplainTest.java
 create mode 100644 src/test/java/net/sf/jsqlparser/statement/MySqlPreparedStatementTest.java

diff --git a/README.md b/README.md
index e7a8db4521..7272abda26 100644
--- a/README.md
+++ b/README.md
@@ -155,6 +155,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 | **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` |
 | **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/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
index 447245f4aa..2b7bc6ea9a 100644
--- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
+++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
@@ -537,6 +537,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
diff --git a/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java b/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java
index 58b0fe34cd..e4624f7f89 100644
--- a/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java
+++ b/src/main/java/net/sf/jsqlparser/statement/DeallocateStatement.java
@@ -12,9 +12,14 @@
 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 <a href="https://dev.mysql.com/doc/refman/8.4/en/deallocate-prepare.html">MySQL DEALLOCATE
+ *      PREPARE</a>
  */
 public class DeallocateStatement extends ASTNodeAccessImpl implements Statement {
+    private Keyword keyword = Keyword.DEALLOCATE;
     private String name;
     private boolean usingPrepareKeyword;
 
@@ -37,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) {
@@ -51,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);
@@ -68,4 +88,9 @@ public String toString() {
     public <T, S> T accept(StatementVisitor<T> 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/DescribeStatement.java b/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java
index 2efedba2d1..ad0cadd549 100644
--- a/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java
+++ b/src/main/java/net/sf/jsqlparser/statement/DescribeStatement.java
@@ -9,15 +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;
 
+/**
+ * {@code DESCRIBE} or {@code DESC} of a table, or, in DuckDB, of a query's result.
+ *
+ * @see <a href="https://dev.mysql.com/doc/refman/8.4/en/explain.html">MySQL DESCRIBE</a>
+ */
 public class DescribeStatement extends ASTNodeAccessImpl implements Statement {
 
     private Table table;
     private Select select;
     private String describeType;
+    private Expression columnPattern;
 
     public DescribeStatement() {
         // empty constructor
@@ -49,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<Select> selectPrinter,
+            Consumer<Expression> expressionPrinter) {
+        builder.append(describeType).append(" ");
+        if (select != null) {
+            selectPrinter.accept(select);
+        } else {
+            builder.append(table);
+            if (columnPattern != null) {
+                builder.append(" ");
+                expressionPrinter.accept(columnPattern);
+            }
+        }
+        return builder;
     }
 
     @Override
diff --git a/src/main/java/net/sf/jsqlparser/statement/DoStatement.java b/src/main/java/net/sf/jsqlparser/statement/DoStatement.java
index 4f21c91f6a..c8c87fd4aa 100644
--- a/src/main/java/net/sf/jsqlparser/statement/DoStatement.java
+++ b/src/main/java/net/sf/jsqlparser/statement/DoStatement.java
@@ -9,15 +9,26 @@
  */
 package net.sf.jsqlparser.statement;
 
+import java.util.List;
 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.select.SelectItem;
 
-/** A PostgreSQL anonymous routine. The language-specific body remains a string literal. */
+/**
+ * A {@code DO} statement: a PostgreSQL anonymous routine, whose language-specific body remains a
+ * string literal, or MySQL's {@code DO expr [, expr] ...}, which evaluates expressions without
+ * returning a result. MySQL reads the expressions as a select list, so they can carry aliases.
+ *
+ * @see <a href="https://www.postgresql.org/docs/18/sql-do.html">PostgreSQL DO</a>
+ * @see <a href="https://dev.mysql.com/doc/refman/8.4/en/do.html">MySQL DO</a>
+ */
 public class DoStatement extends ASTNodeAccessImpl implements Statement {
     private StringValue code;
     private String language;
     private boolean languageBeforeCode;
+    private List<SelectItem<?>> selectItems;
 
     public StringValue getCode() {
         return code;
@@ -54,8 +65,48 @@ public void setLanguageBeforeCode(boolean languageBeforeCode) {
         this.languageBeforeCode = languageBeforeCode;
     }
 
+    /** The expressions of MySQL's form, or null for a PostgreSQL code block. */
+    public List<SelectItem<?>> getSelectItems() {
+        return selectItems;
+    }
+
+    public void setSelectItems(List<SelectItem<?>> selectItems) {
+        this.selectItems = selectItems;
+    }
+
+    public DoStatement withSelectItems(List<SelectItem<?>> selectItems) {
+        setSelectItems(selectItems);
+        return this;
+    }
+
+    /** Visits the code block, or the expression of every select item. */
+    public void visitExpressions(Consumer<Expression> visitor) {
+        if (selectItems != null) {
+            for (SelectItem<?> item : selectItems) {
+                visitor.accept(item.getExpression());
+            }
+        } else if (code != null) {
+            visitor.accept(code);
+        }
+    }
+
     public StringBuilder appendTo(StringBuilder builder, Consumer<StringValue> codePrinter) {
+        return appendTo(builder, codePrinter, builder::append);
+    }
+
+    /** Renders the code block or the select items through the caller's writers. */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<StringValue> codePrinter,
+            Consumer<SelectItem<?>> itemPrinter) {
         builder.append("DO ");
+        if (selectItems != null) {
+            for (int i = 0; i < selectItems.size(); i++) {
+                if (i > 0) {
+                    builder.append(", ");
+                }
+                itemPrinter.accept(selectItems.get(i));
+            }
+            return builder;
+        }
         if (languageBeforeCode && language != null) {
             builder.append("LANGUAGE ").append(language).append(' ');
         }
diff --git a/src/main/java/net/sf/jsqlparser/statement/ExplainStatement.java b/src/main/java/net/sf/jsqlparser/statement/ExplainStatement.java
index 22db6859f9..0bdcc1eb77 100644
--- a/src/main/java/net/sf/jsqlparser/statement/ExplainStatement.java
+++ b/src/main/java/net/sf/jsqlparser/statement/ExplainStatement.java
@@ -14,11 +14,17 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.UserVariable;
 import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
 import net.sf.jsqlparser.schema.Table;
 
 /**
- * An {@code EXPLAIN} statement
+ * An {@code EXPLAIN} statement. It explains a statement, describes a table, or, in MySQL, explains
+ * the statement another connection runs.
+ *
+ * @see <a href="https://dev.mysql.com/doc/refman/8.4/en/explain.html">MySQL EXPLAIN</a>
  */
 public class ExplainStatement extends ASTNodeAccessImpl implements Statement {
     private String keyword;
@@ -26,6 +32,11 @@ public class ExplainStatement extends ASTNodeAccessImpl implements Statement {
     private List<Option> options = new ArrayList<>();
     private boolean parenthesizedOptions;
     private Table table;
+    private Expression columnPattern;
+    private UserVariable intoVariable;
+    private String schemaName;
+    private boolean schemaKeyword;
+    private Expression connectionId;
 
     public ExplainStatement(String keyword) {
         this.keyword = keyword;
@@ -59,6 +70,7 @@ public ExplainStatement setTable(Table table) {
         this.table = table;
         if (table != null) {
             this.statement = null;
+            this.connectionId = null;
         }
         return this;
     }
@@ -70,9 +82,106 @@ public Statement getStatement() {
     public ExplainStatement setStatement(Statement statement) {
         this.table = null;
         this.statement = statement;
+        if (statement != null) {
+            this.connectionId = null;
+        }
+        return this;
+    }
+
+    /**
+     * The MySQL column name ({@link net.sf.jsqlparser.schema.Column}) or wildcard string that
+     * limits the columns of {@code EXPLAIN table} to those it matches, or null.
+     */
+    public Expression getColumnPattern() {
+        return columnPattern;
+    }
+
+    public void setColumnPattern(Expression columnPattern) {
+        this.columnPattern = columnPattern;
+    }
+
+    public ExplainStatement withColumnPattern(Expression columnPattern) {
+        setColumnPattern(columnPattern);
+        return this;
+    }
+
+    /** The MySQL {@code INTO @variable} that receives the plan, or null. */
+    public UserVariable getIntoVariable() {
+        return intoVariable;
+    }
+
+    public void setIntoVariable(UserVariable intoVariable) {
+        this.intoVariable = intoVariable;
+    }
+
+    public ExplainStatement withIntoVariable(UserVariable intoVariable) {
+        setIntoVariable(intoVariable);
+        return this;
+    }
+
+    /** The schema of MySQL's {@code FOR {SCHEMA | DATABASE} name}, or null. */
+    public String getSchemaName() {
+        return schemaName;
+    }
+
+    public void setSchemaName(String schemaName) {
+        this.schemaName = schemaName;
+    }
+
+    public ExplainStatement withSchemaName(String schemaName) {
+        setSchemaName(schemaName);
+        return this;
+    }
+
+    /** Whether the schema clause is spelled {@code FOR SCHEMA} rather than {@code FOR DATABASE}. */
+    public boolean isSchemaKeyword() {
+        return schemaKeyword;
+    }
+
+    public void setSchemaKeyword(boolean schemaKeyword) {
+        this.schemaKeyword = schemaKeyword;
+    }
+
+    public ExplainStatement withSchemaKeyword(boolean schemaKeyword) {
+        setSchemaKeyword(schemaKeyword);
+        return this;
+    }
+
+    /**
+     * The connection of MySQL's {@code FOR CONNECTION id}, a
+     * {@link net.sf.jsqlparser.expression.LongValue} or
+     * {@link net.sf.jsqlparser.expression.HexValue}, or null.
+     */
+    public Expression getConnectionId() {
+        return connectionId;
+    }
+
+    public ExplainStatement setConnectionId(Expression connectionId) {
+        this.connectionId = connectionId;
+        if (connectionId != null) {
+            this.table = null;
+            this.statement = null;
+        }
         return this;
     }
 
+    /** What the statement explains, derived from the table, connection and statement it holds. */
+    public TargetKind getTargetKind() {
+        if (table != null) {
+            return TargetKind.TABLE;
+        }
+        return connectionId != null ? TargetKind.CONNECTION : TargetKind.STATEMENT;
+    }
+
+    /**
+     * The output format of the {@code FORMAT} option, or null without one or for a name no dialect
+     * defines.
+     */
+    public Format getFormat() {
+        Option option = getOption(OptionType.FORMAT);
+        return option == null ? null : Format.find(option.getValue());
+    }
+
     public LinkedHashMap<OptionType, Option> getOptions() {
         if (options.isEmpty()) {
             return null;
@@ -140,18 +249,41 @@ public ExplainStatement setKeyword(String keyword) {
 
     @Override
     public String toString() {
-        StringBuilder builder = new StringBuilder(keyword);
+        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<Statement> statementPrinter,
+            Consumer<Expression> expressionPrinter) {
+        builder.append(keyword);
         if (table != null) {
             builder.append(" ").append(table);
-        } else {
-            appendOptionsTo(builder);
-            builder.append(" ");
-            if (statement != null) {
-                builder.append(statement);
+            if (columnPattern != null) {
+                builder.append(" ");
+                expressionPrinter.accept(columnPattern);
             }
+            return builder;
         }
-
-        return builder.toString();
+        appendOptionsTo(builder);
+        if (intoVariable != null) {
+            builder.append(" INTO ");
+            expressionPrinter.accept(intoVariable);
+        }
+        builder.append(" ");
+        if (connectionId != null) {
+            builder.append("FOR CONNECTION ");
+            expressionPrinter.accept(connectionId);
+            return builder;
+        }
+        if (schemaName != null) {
+            builder.append("FOR ").append(schemaKeyword ? "SCHEMA " : "DATABASE ")
+                    .append(schemaName).append(" ");
+        }
+        if (statement != null) {
+            statementPrinter.accept(statement);
+        }
+        return builder;
     }
 
     @Override
@@ -184,10 +316,43 @@ public static OptionType from(String type) {
         }
     }
 
+    /** The thing an {@code EXPLAIN} statement explains. */
+    public enum TargetKind {
+        /** A statement, such as {@code EXPLAIN SELECT ...}. */
+        STATEMENT,
+        /** The columns of a table, such as {@code EXPLAIN t}. */
+        TABLE,
+        /** The statement a MySQL connection runs: {@code EXPLAIN FOR CONNECTION id}. */
+        CONNECTION
+    }
+
+    /**
+     * Output formats: {@code TEXT}, {@code XML}, {@code JSON} and {@code YAML} of PostgreSQL, and
+     * {@code TRADITIONAL}, {@code JSON} and {@code TREE} of MySQL.
+     */
+    public enum Format {
+        TEXT, XML, JSON, YAML, TRADITIONAL, TREE;
+
+        public static Format from(String format) {
+            return Enum.valueOf(Format.class, format.toUpperCase(Locale.ROOT));
+        }
+
+        /** The format of this name in any case, or null for another name. */
+        public static Format find(String format) {
+            for (Format value : values()) {
+                if (value.name().equalsIgnoreCase(format)) {
+                    return value;
+                }
+            }
+            return null;
+        }
+    }
+
     public static class Option implements Serializable {
 
         private final OptionType type;
         private String value;
+        private boolean useEqual;
 
         public Option(OptionType type) {
             this.type = type;
@@ -205,9 +370,18 @@ public void setValue(String value) {
             this.value = value;
         }
 
+        /** Whether the value follows an equals sign, as in MySQL's {@code FORMAT = JSON}. */
+        public boolean isUseEqual() {
+            return useEqual;
+        }
+
+        public void setUseEqual(boolean useEqual) {
+            this.useEqual = useEqual;
+        }
+
         public String formatOption() {
             return (type == OptionType.PLAN_FOR ? "PLAN FOR" : type.name()) + (value != null
-                    ? " " + value
+                    ? (useEqual ? " = " : " ") + value
                     : "");
         }
 
@@ -215,5 +389,10 @@ public Option withValue(String value) {
             this.setValue(value);
             return this;
         }
+
+        public Option withUseEqual(boolean useEqual) {
+            this.setUseEqual(useEqual);
+            return this;
+        }
     }
 }
diff --git a/src/main/java/net/sf/jsqlparser/statement/PrepareStatement.java b/src/main/java/net/sf/jsqlparser/statement/PrepareStatement.java
index 93d66e4ed4..f0baf0177c 100644
--- a/src/main/java/net/sf/jsqlparser/statement/PrepareStatement.java
+++ b/src/main/java/net/sf/jsqlparser/statement/PrepareStatement.java
@@ -11,21 +11,25 @@
 
 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.create.table.ColDataType;
 import net.sf.jsqlparser.statement.select.PlainSelect;
 
 /**
  * {@code PREPARE name [(types)] AS statement}, which stores a parameterised statement for later
- * {@code EXECUTE}.
+ * {@code EXECUTE}, or MySQL's {@code PREPARE name FROM {'text' | @variable}}, which takes the
+ * statement's text from a string literal or a user variable.
  *
  * @see <a href="https://duckdb.org/docs/stable/sql/query_syntax/prepared_statements">Prepared
  *      statements</a>
+ * @see <a href="https://dev.mysql.com/doc/refman/8.4/en/prepare.html">MySQL PREPARE</a>
  */
 public class PrepareStatement extends ASTNodeAccessImpl implements Statement {
     private String name;
     private Statement statement;
     private List<ColDataType> parameterTypes;
+    private Expression source;
 
     public PrepareStatement() {}
 
@@ -53,6 +57,9 @@ public Statement getStatement() {
 
     public void setStatement(Statement statement) {
         this.statement = statement;
+        if (statement != null) {
+            this.source = null;
+        }
     }
 
     public PrepareStatement withStatement(Statement statement) {
@@ -74,13 +81,46 @@ public PrepareStatement withParameterTypes(List<ColDataType> parameterTypes) {
         return this;
     }
 
+    /**
+     * The statement text of MySQL's {@code FROM} form: a string literal
+     * ({@link net.sf.jsqlparser.expression.StringValue}) or a user variable
+     * ({@link net.sf.jsqlparser.expression.UserVariable}). Null for the {@code AS} form.
+     */
+    public Expression getSource() {
+        return source;
+    }
+
+    public void setSource(Expression source) {
+        this.source = source;
+        if (source != null) {
+            this.statement = null;
+            this.parameterTypes = null;
+        }
+    }
+
+    public PrepareStatement withSource(Expression source) {
+        setSource(source);
+        return this;
+    }
+
     public StringBuilder appendTo(StringBuilder builder) {
         return appendTo(builder, builder::append);
     }
 
     /** Renders the nested statement through the caller's statement writer. */
     public StringBuilder appendTo(StringBuilder builder, Consumer<Statement> statementPrinter) {
+        return appendTo(builder, statementPrinter, builder::append);
+    }
+
+    /** Renders the nested statement and the statement text through the caller's writers. */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Statement> statementPrinter,
+            Consumer<Expression> expressionPrinter) {
         builder.append("PREPARE ").append(name);
+        if (source != null) {
+            builder.append(" FROM ");
+            expressionPrinter.accept(source);
+            return builder;
+        }
         if (parameterTypes != null && !parameterTypes.isEmpty()) {
             builder.append(PlainSelect.getStringList(parameterTypes, true, true));
         }
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
index f91ea876a6..c0b50ca301 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
@@ -825,7 +825,12 @@ public <S> Void visit(Execute execute, S context) {
     @Override
     public <S> Void visit(DoStatement statement, S context) {
         analysis.claimTopLevel();
-        analysis.opaque("DO");
+        if (statement.getSelectItems() == null) {
+            analysis.opaque("DO");
+        } else {
+            // MySQL evaluates the expressions and discards their values
+            statement.visitExpressions(expression -> expression.accept(analysis.expressions, null));
+        }
         return null;
     }
 
@@ -849,7 +854,10 @@ public <S> Void visit(UnsupportedStatement unsupportedStatement, S context) {
     @Override
     public <S> Void visit(ExplainStatement explainStatement, S context) {
         if (analysis.claimTopLevel()) {
-            analysis.certain(StmtFeature.RETURNS_RESULT_SET);
+            // MySQL's EXPLAIN ... INTO @variable stores the plan instead of returning it
+            analysis.certain(explainStatement.getIntoVariable() != null
+                    ? StmtFeature.MODIFIES_SESSION
+                    : StmtFeature.RETURNS_RESULT_SET);
         }
         // EXPLAIN ANALYZE executes the statement. The option set is dialect-specific, so the
         // side effects of the explained statement stay in the possible set.
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
index 32a947382e..604b03119a 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
@@ -544,12 +544,13 @@ public <S> T visit(Statements statements, S context) {
     @Override
     public <S> T visit(Execute execute, S context) {
         expressionVisitor.visitExpression(execute.getExprList(), context);
+        expressionVisitor.visitExpression(execute.getUsingVariables(), context);
         return null;
     }
 
     @Override
     public <S> T visit(DoStatement statement, S context) {
-        expressionVisitor.visitExpression(statement.getCode(), context);
+        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
         return null;
     }
 
@@ -822,6 +823,7 @@ public <S> T visit(DisconnectStatement disconnectStatement, S context) {
 
     @Override
     public <S> T visit(PrepareStatement prepareStatement, S context) {
+        expressionVisitor.visitExpression(prepareStatement.getSource(), context);
         return null;
     }
 
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 cde107b66e..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,6 +13,7 @@
 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;
@@ -21,11 +22,19 @@
 
 import java.util.List;
 
+/**
+ * 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 <a href="https://dev.mysql.com/doc/refman/8.4/en/execute.html">MySQL EXECUTE</a>
+ */
 public class Execute extends ASTNodeAccessImpl implements Statement {
 
     private ExecType execType = ExecType.EXECUTE;
     private String name;
     private ExpressionList exprList;
+    private ExpressionList<UserVariable> usingVariables;
 
     public String getName() {
         return name;
@@ -51,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<UserVariable> getUsingVariables() {
+        return usingVariables;
+    }
+
+    public void setUsingVariables(ExpressionList<UserVariable> usingVariables) {
+        this.usingVariables = usingVariables;
+    }
+
+    public Execute withUsingVariables(ExpressionList<UserVariable> usingVariables) {
+        this.setUsingVariables(usingVariables);
+        return this;
+    }
+
     public ExecType getExecType() {
         return execType;
     }
@@ -96,6 +119,15 @@ public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> 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/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
index 87444c8e5f..acbd1708a6 100644
--- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
+++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -1807,7 +1807,12 @@ public <S> Void visit(CreateIndex createIndex, S context) {
 
     @Override
     public <S> 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;
     }
 
@@ -2386,6 +2391,9 @@ public void visit(DescribeStatement describe) {
     public <S> 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;
     }
@@ -2952,7 +2960,13 @@ public void visit(DisconnectStatement disconnectStatement) {
 
     @Override
     public <S> 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;
     }
 
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 c7c959128b..c2b5ff28d0 100644
--- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
+++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
@@ -217,7 +217,8 @@ public <S> StringBuilder visit(CreateIndex createIndex, S context) {
 
     @Override
     public <S> 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
@@ -558,28 +559,14 @@ public <S> StringBuilder visit(Comment comment, S context) {
 
     @Override
     public <S> 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 <S> 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
@@ -754,7 +741,8 @@ public <S> StringBuilder visit(DisconnectStatement disconnectStatement, S contex
 
     @Override
     public <S> 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;
     }
 
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 f4ff88e851..7ada2c3d9d 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
@@ -94,9 +94,16 @@ public enum MariaDbVersion implements Version {
                     // 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/
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 26c630ea34..e0500cfac4 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
@@ -93,9 +93,15 @@ public enum MySqlVersion implements Version {
                     // https://dev.mysql.com/doc/refman/8.0/en/call.html
                     Feature.execute, Feature.executeCall,
 
+                    // 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
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/StatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java
index ee7cfd848f..f18836e961 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
@@ -359,6 +359,9 @@ public <S> Void visit(Execute execute, S context) {
     @Override
     public <S> Void visit(DoStatement statement, S context) {
         validateFeature(Feature.doStatement);
+        if (statement.getSelectItems() != null) {
+            statement.visitExpressions(this::validateOptionalExpression);
+        }
         return null;
     }
 
@@ -801,6 +804,7 @@ public <S> Void visit(DisconnectStatement disconnectStatement, S context) {
     @Override
     public <S> Void visit(PrepareStatement prepareStatement, S context) {
         validateFeature(Feature.prepare);
+        validateOptionalExpression(prepareStatement.getSource());
         return null;
     }
 
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
index 13f4f1b62f..146588cad1 100644
--- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
+++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -167,7 +167,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             case K_PURGE: case K_SESSION: case K_BRANCH: case K_LOCK: case K_IF: case K_TABLE:
                 return true;
             case K_DO:
-                return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect));
+                return isDoStatementAhead();
             case K_SECURITY:
                 return "LABEL".equalsIgnoreCase(getToken(2).image);
             case K_REINDEX:
@@ -3328,6 +3328,93 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         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 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
@@ -3567,7 +3654,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
 
     private static UserVariable requireMySqlIntoVariable(UserVariable variable) throws ParseException {
         if (variable.isDoubleAdd()) {
-            throw new ParseException("INTO requires a user variable with a single @ prefix");
+            throw new ParseException("A user variable with a single @ prefix is required");
         }
         return variable;
     }
@@ -5377,6 +5464,10 @@ Statement SingleStatement() :
                     && (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) })
@@ -5399,8 +5490,7 @@ Statement SingleStatement() :
             |
             stm = Execute()
             |
-            LOOKAHEAD({ getToken(1).kind == K_DO && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) })
-            stm = DoStatement()
+            LOOKAHEAD({ isDoStatementAhead() }) stm = DoStatement()
             |
             LOOKAHEAD({ Dialect.SQLSERVER.name().equals(getAsString(Feature.dialect))
                 && getToken(1).kind == K_SET && getToken(2).kind == S_IDENTIFIER
@@ -5457,6 +5547,8 @@ Statement SingleStatement() :
             |
             LOOKAHEAD({ isKeywordAhead("NOTIFY") }) stm = NotifyStatement()
             |
+            LOOKAHEAD({ isMySqlExplainAhead() }) stm = MySqlExplain()
+            |
             stm = Describe()
             |
             stm = Explain()
@@ -5486,8 +5578,6 @@ Statement SingleStatement() :
             |
             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()
@@ -5594,24 +5684,35 @@ OracleBlock.ExceptionHandler OracleExceptionHandler():
     <K_THEN> 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<SelectItem<?>> items;
 }
 {
     <K_DO>
     (
-        LOOKAHEAD({ isKeywordAhead("LANGUAGE") })
-        AccessKeyword("LANGUAGE") language=RelObjectName() code=<S_CHAR_LITERAL>
-        { statement.setLanguage(language); statement.setLanguageBeforeCode(true); }
+        LOOKAHEAD({ !Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) })
+        items=SelectItemsList() { statement.setSelectItems(items); }
         |
-        code=<S_CHAR_LITERAL>
-        [ LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) AccessKeyword("LANGUAGE")
-            language=RelObjectName() { statement.setLanguage(language); } ]
+        (
+            LOOKAHEAD({ isKeywordAhead("LANGUAGE") })
+            AccessKeyword("LANGUAGE") language=RelObjectName() code=<S_CHAR_LITERAL>
+            { statement.setLanguage(language); statement.setLanguageBeforeCode(true); }
+            |
+            code=<S_CHAR_LITERAL>
+            [ LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) AccessKeyword("LANGUAGE")
+                language=RelObjectName() { statement.setLanguage(language); } ]
+        )
+        { statement.setCode(stringValue(code)); }
     )
-    { statement.setCode(stringValue(code)); return statement; }
+    { return statement; }
 }
 
 Block Block() #Block : {
@@ -7243,7 +7344,8 @@ CopyStatement CopyStatement() #CopyStatement:
 }
 
 /**
- * PREPARE name AS statement, storing a parameterised statement for later EXECUTE.
+ * PREPARE name AS statement, storing a parameterised statement for later EXECUTE, or MySQL's
+ * PREPARE name FROM {'text' | @variable}.
  */
 PrepareStatement PrepareStatement() #PrepareStatement:
 {
@@ -7252,14 +7354,23 @@ PrepareStatement PrepareStatement() #PrepareStatement:
     Statement statement;
     List<ColDataType> parameterTypes = new ArrayList<ColDataType>();
     ColDataType parameterType;
+    Token text;
+    Expression source;
 }
 {
     <K_PREPARE> name=RelObjectNames()
     { prepareStatement.setName(String.join(".", name.getNames())); }
-    [ "(" parameterType=PrepareParameterType() { parameterTypes.add(parameterType); }
-        ( "," parameterType=PrepareParameterType() { parameterTypes.add(parameterType); } )*
-        ")" { prepareStatement.setParameterTypes(parameterTypes); } ]
-    <K_AS> statement=SingleStatement() { prepareStatement.setStatement(statement); }
+    (
+        LOOKAHEAD({ getToken(1).kind == K_FROM && isMySqlUtilityDialect() })
+        <K_FROM>
+        ( text=<S_CHAR_LITERAL> { source = stringValue(text); } | source=MySqlIntoVariable() )
+        { prepareStatement.setSource(source); }
+        |
+        [ "(" parameterType=PrepareParameterType() { parameterTypes.add(parameterType); }
+            ( "," parameterType=PrepareParameterType() { parameterTypes.add(parameterType); } )*
+            ")" { prepareStatement.setParameterTypes(parameterTypes); } ]
+        <K_AS> statement=SingleStatement() { prepareStatement.setStatement(statement); }
+    )
     { return prepareStatement; }
 }
 
@@ -7273,7 +7384,7 @@ ColDataType PrepareParameterType():
 }
 
 /**
- * DEALLOCATE [PREPARE] name.
+ * DEALLOCATE [PREPARE] name, or MySQL's DROP PREPARE name.
  */
 DeallocateStatement DeallocateStatement() #DeallocateStatement:
 {
@@ -7281,8 +7392,12 @@ DeallocateStatement DeallocateStatement() #DeallocateStatement:
     ObjectNames name;
 }
 {
-    <K_DEALLOCATE>
-    [ LOOKAHEAD(2) <K_PREPARE> { deallocateStatement.setUsingPrepareKeyword(true); } ]
+    (
+        <K_DEALLOCATE>
+        [ LOOKAHEAD(2) <K_PREPARE> { deallocateStatement.setUsingPrepareKeyword(true); } ]
+        |
+        <K_DROP> <K_PREPARE> { deallocateStatement.setKeyword(DeallocateStatement.Keyword.DROP); }
+    )
     name=RelObjectNames() { deallocateStatement.setName(String.join(".", name.getNames())); }
     { return deallocateStatement; }
 }
@@ -7579,6 +7694,7 @@ DescribeStatement Describe(): {
     Select select;
     DescribeStatement stmt = new DescribeStatement();
     Token tk = null;
+    Expression pattern;
 } {
     (tk=<K_DESCRIBE> | tk=<K_DESC>)
     (
@@ -7588,22 +7704,125 @@ DescribeStatement Describe(): {
         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=<S_CHAR_LITERAL> { pattern = stringValue(token); }
+        |
+        token=<S_HEX> { 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<ExplainStatement.Option> options = new ArrayList<ExplainStatement.Option>();
+    ExplainStatement.Option option;
+    UserVariable variable;
+    Token token;
+    Expression connection;
+    String schema;
+    Statement statement;
+}
+{
+    ( keyword=<K_EXPLAIN> | keyword=<K_DESCRIBE> | keyword=<K_DESC> )
+    { explain = new ExplainStatement(keyword.image); }
+    (
+        <K_ANALYZE>
+        { options.add(new ExplainStatement.Option(ExplainStatement.OptionType.ANALYZE)); }
+        [ option=MySqlExplainFormat() { options.add(option); } ]
+        |
+        [ option=MySqlExplainFormat() { options.add(option); } ]
+        [ <K_INTO> variable=MySqlIntoVariable() { explain.setIntoVariable(variable); } ]
+    )
+    { explain.setOptionList(options); }
+    (
+        LOOKAHEAD({ getToken(1).kind == K_FOR && "CONNECTION".equalsIgnoreCase(getToken(2).image) })
+        <K_FOR> AccessKeyword("CONNECTION")
+        ( token=<S_LONG> { connection = new LongValue(token.image); }
+          | token=<S_HEX> { connection = new HexValue(token.image); } )
+        { explain.setConnectionId(linkToLastToken(connection)); }
+        |
+        [
+            <K_FOR> ( <K_SCHEMA> { explain.setSchemaKeyword(true); } | <K_DATABASE> )
+            ( schema=RelObjectName() | token=<S_CHAR_LITERAL> { 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;
+}
+{
+    <K_FORMAT> "="
+    ( token=<K_JSON> | token=<S_IDENTIFIER> | token=<S_QUOTED_IDENTIFIER> | token=<S_CHAR_LITERAL> )
+    { return mySqlExplainFormat(token); }
+}
+
+/** The statement EXPLAIN explains: a query or a DML statement. */
+Statement ExplainableStatement():
+{
+    List<WithItem<?>> 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;
-    List<WithItem<?>> with = null;
     Table table;
     List<ExplainStatement.Option> options;
     ExplainStatement es;
     boolean parenthesized = false;
-    Token statementFirst;
+    Expression pattern;
 }
 {
     ( tk=<K_EXPLAIN> | tk = <K_SUMMARIZE> )
@@ -7613,19 +7832,8 @@ ExplainStatement Explain():
                 LOOKAHEAD(2) "(" options = PostgresqlExplainOptions() ")" { parenthesized = true; }
                 | options = ExplainStatementOptions()
             )
-            { statementFirst = getToken(1); }
-            (
-                [ LOOKAHEAD(2) with=WithList() ]
-                (
-                    statement = SelectWithWithItems( with ) { if (with != null) { widen(statement, statementFirst, null); } }
-                    | statement = InsertWithWithItems( with )
-                    | statement = UpdateWithWithItems( with )
-                    | statement = DeleteWithWithItems( with )
-                    | statement = Merge( with )
-                )
-            )
+            statement = ExplainableStatement()
             {
-                linkStatement(statement, statementFirst);
                 es = new ExplainStatement(tk.image, statement, options);
                 es.setParenthesizedOptions(parenthesized);
             }
@@ -7633,6 +7841,12 @@ ExplainStatement Explain():
         |
         (
            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);
+             } ]
         )
     )
     {
@@ -11299,17 +11513,22 @@ MySqlSelectIntoClause MySqlSelectIntoClause(MySqlSelectIntoClause.Position posit
     }
 }
 
+/**
+ * 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():
 {
     UserVariable variable;
+    Token at;
     Token name;
 }
 {
     (
         variable=UserVariable()
         |
-        <K_AT_SIGN> (name=<S_CHAR_LITERAL> | name=<S_QUOTED_IDENTIFIER>)
-        { variable = new UserVariable("@" + name.image); }
+        at=<K_AT_SIGN> (name=<S_CHAR_LITERAL> | name=<S_QUOTED_IDENTIFIER>)
+        { variable = new UserVariable("@" + name.image); linkAST(variable, at, name); }
     )
     { return requireMySqlIntoVariable(variable); }
 }
@@ -15866,6 +16085,8 @@ Execute Execute(): {
     ObjectNames funcName;
     ExpressionList expressionList;
     Execute execute = new Execute();
+    ExpressionList<UserVariable> variables = new ExpressionList<UserVariable>();
+    UserVariable variable;
 }
 {
     (<K_EXEC> { execute.setExecType(Execute.ExecType.EXEC); }
@@ -15874,7 +16095,19 @@ Execute Execute(): {
 
     // 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); } ]
+    [
+        // MySQL's EXECUTE name USING @variable [, @variable] ...
+        LOOKAHEAD({ getToken(1).kind == K_USING && isMySqlUtilityDialect() })
+        <K_USING> variable=MySqlIntoVariable() { variables.add(variable); }
+        ( LOOKAHEAD(2) "," variable=MySqlIntoVariable() { variables.add(variable); } )*
+        {
+            requireDdlSyntax(execute.getExecType() == Execute.ExecType.EXECUTE,
+                    "Only EXECUTE takes a USING clause");
+            execute.setUsingVariables(linkElements(variables));
+        }
+        |
+        LOOKAHEAD(2) expressionList=ExecuteArguments() { execute.setExprList(expressionList); }
+    ]
     { return execute; }
 }
 
diff --git a/src/site/sphinx/index.rst b/src/site/sphinx/index.rst
index e0ff2d8a4d..6e60e16c89 100644
--- a/src/site/sphinx/index.rst
+++ b/src/site/sphinx/index.rst
@@ -174,6 +174,8 @@ One grammar covers the SQL standard plus all major RDBMS. Missing syntax gets ad
       - ``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``
     * - **Salesforce SOQL**
diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst
index 1fe9a87183..e0b6b1d06b 100644
--- a/src/site/sphinx/usage.rst
+++ b/src/site/sphinx/usage.rst
@@ -2942,3 +2942,58 @@ and the table or view of ``SHOW CREATE TABLE`` and ``SHOW CREATE VIEW``; until n
 table. Validators report the ``showColumns``, ``showTableStatus`` and ``showCreate``
 features, which the MySQL and MariaDB capabilities enable. 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 <https://dev.mysql.com/doc/refman/8.4/en/explain.html>`_,
+  ``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} <https://dev.mysql.com/doc/refman/8.4/en/prepare.html>`_
+  extends ``PrepareStatement``: ``getSource()`` is the ``StringValue`` or ``UserVariable`` and
+  ``getStatement()`` is null. The statement text is not parsed.
+* `EXECUTE name USING @a, @b <https://dev.mysql.com/doc/refman/8.4/en/execute.html>`_ fills
+  ``Execute.getUsingVariables()``.
+* `DROP PREPARE name <https://dev.mysql.com/doc/refman/8.4/en/deallocate-prepare.html>`_ parses
+  to ``DeallocateStatement`` with ``getKeyword()`` ``DROP``.
+* `DO expr [, expr] ... <https://dev.mysql.com/doc/refman/8.4/en/do.html>`_ 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/parser/ASTNodeCoverageTest.java b/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java
index 25dd26d38d..ceeb6c2d0b 100644
--- a/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java
+++ b/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java
@@ -149,9 +149,17 @@ public void testStatementsTheCorpusLacks() throws JSQLParserException {
                 "CHECKPOINT",
                 "DROP CAST IF EXISTS (int[] AS public.t) CASCADE",
                 "DROP OPERATOR public.=== (integer, integer), ~ (NONE, bigint)",
-                "DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u"}) {
+                "DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u",
+                "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)"}) {
             new Walk(sql, sql, problems).check(CCJSqlParserUtil.parseStatements(sql));
         }
+        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)));
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<SelectItem<?>> 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<String> functions = new ArrayList<>();
+        CCJSqlParserUtil.parse("DO SLEEP(1), RELEASE_LOCK('l')").accept(
+                new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(
+                        new ExpressionVisitorAdapter<Void>() {
+                            @Override
+                            public <S> 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/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/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<String> names = new ArrayList<>();
+        StatementVisitorAdapter<Void> visitor = new StatementVisitorAdapter<>(
+                new SelectVisitorAdapter<>(new ExpressionVisitorAdapter<Void>() {
+                    @Override
+                    public <S> 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<ValidationError> 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()));
+    }
+}