diff --git a/README.md b/README.md
index e7a8db452..7272abda2 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 447245f4a..2b7bc6ea9 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 58b0fe34c..e4624f7f8 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 2efedba2d..ad0cadd54 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 4f21c91f6..c8c87fd4a 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 22db6859f..0bdcc1eb7 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 93d66e4ed..f0baf0177 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 f91ea876a..c0b50ca30 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 32a947382..604b03119 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 cde107b66..7a16384b7 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 87444c8e5..acbd1708a 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 c7c959128..c2b5ff28d 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 f4ff88e85..7ada2c3d9 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 26c630ea3..e0500cfac 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 968bd13b1..2b9ec640b 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 ee7cfd848..f18836e96 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 13f4f1b62..146588cad 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 e0ff2d8a4..6e60e16c8 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 1fe9a8718..e0b6b1d06 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 25dd26d38..ceeb6c2d0 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 6c5b495ec..666e5ebef 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 000000000..b11c8ca4e
--- /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 000000000..c37fcae31
--- /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()));
+    }
+}