From 628e25ab80d14ba46e2beae35e79b8bee1eb941d Mon Sep 17 00:00:00 2001
From: minleejae <mmj9808@gmail.com>
Date: Tue, 13 Oct 2026 13:23:07 +0900
Subject: [PATCH] feat: parse MySQL CHECK, OPTIMIZE and REPAIR TABLE statements

Model the MySQL/MariaDB table maintenance statements as
TableMaintenanceStatement with its operation, NO_WRITE_TO_BINLOG/LOCAL
modifier, TABLE/TABLES spelling, table list and per-operation options.
Options outside an operation's definition are rejected, and the option
words remain ordinary identifiers elsewhere.

Wire the statement into the deparser, table finder, validator and
statement feature analysis, and keep a following CHECK TABLE statement
out of CREATE DOMAIN's CHECK constraint loop.

Signed-off-by: minleejae <mmj9808@gmail.com>
---
 README.md                                     |   1 +
 .../sf/jsqlparser/parser/feature/Feature.java |   8 +
 .../statement/StatementFeatureVisitor.java    |  14 ++
 .../statement/StatementVisitor.java           |   8 +
 .../statement/StatementVisitorAdapter.java    |   5 +
 .../statement/TableMaintenanceStatement.java  | 185 ++++++++++++++++++
 .../sf/jsqlparser/util/TablesNamesFinder.java |  12 ++
 .../util/deparser/StatementDeParser.java      |   7 +
 .../validation/feature/MariaDbVersion.java    |   3 +
 .../util/validation/feature/MySqlVersion.java |   3 +
 .../validator/StatementValidator.java         |  12 ++
 .../validator/TableMaintenanceValidator.java  |  26 +++
 .../net/sf/jsqlparser/parser/JSqlParserCC.jjt |  89 ++++++++-
 src/site/sphinx/index.rst                     |   2 +
 src/site/sphinx/usage.rst                     |  24 +++
 .../TableMaintenanceStatementTest.java        | 180 +++++++++++++++++
 .../TableMaintenanceValidatorTest.java        |  42 ++++
 17 files changed, 620 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/net/sf/jsqlparser/statement/TableMaintenanceStatement.java
 create mode 100644 src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java
 create mode 100644 src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java
 create mode 100644 src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java

diff --git a/README.md b/README.md
index 6df4adb091..d39e81ea68 100644
--- a/README.md
+++ b/README.md
@@ -143,6 +143,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 | **ClickHouse column selection** | `COLUMNS('regexp')` select items with chained `APPLY`, `EXCEPT`, and `REPLACE` transformers |
 | **DML** | `INSERT` · `UPDATE` · `UPSERT` · `MERGE` · `DELETE` · `TRUNCATE TABLE` |
 | **DDL** | `CREATE …` · `ALTER …` · `DROP …` |
+| **MySQL table maintenance** | `ANALYZE` · `CHECK` · `OPTIMIZE` · `REPAIR TABLE` |
 | **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` |
 | **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 9e0bd5ce10..243194bcb7 100644
--- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
+++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
@@ -26,6 +26,7 @@
 import net.sf.jsqlparser.statement.SetStatement;
 import net.sf.jsqlparser.statement.ShowColumnsStatement;
 import net.sf.jsqlparser.statement.ShowStatement;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.UseStatement;
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
@@ -458,6 +459,13 @@ public enum Feature {
      */
     analyze,
 
+    /**
+     * MySQL/MariaDB "CHECK TABLE", "OPTIMIZE TABLE" and "REPAIR TABLE" statements are allowed
+     *
+     * @see TableMaintenanceStatement
+     */
+    tableMaintenance,
+
     /**
      * SQL "TRUNCATE" statement is allowed
      *
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
index d1eac1029a..91b2721249 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
@@ -714,6 +714,20 @@ public <S> Void visit(Analyze analyze, S context) {
         return null;
     }
 
+    @Override
+    public <S> Void visit(TableMaintenanceStatement statement, S context) {
+        analysis.claimTopLevel();
+        analysis.certain(StmtFeature.READS_DATA, StmtFeature.RETURNS_RESULT_SET);
+        if (statement.getOperation() != TableMaintenanceStatement.Operation.CHECK) {
+            // OPTIMIZE rebuilds table storage; REPAIR may also rewrite or discard rows
+            analysis.certain(StmtFeature.MODIFIES_SCHEMA);
+            if (statement.getOperation() == TableMaintenanceStatement.Operation.REPAIR) {
+                analysis.possible(StmtFeature.MODIFIES_DATA);
+            }
+        }
+        return null;
+    }
+
     private Void schemaOnly() {
         analysis.claimTopLevel();
         analysis.certain(StmtFeature.MODIFIES_SCHEMA);
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
index bc5c37b47d..bf0bf3e8b5 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
@@ -269,6 +269,14 @@ default void visit(DoStatement statement) {
         this.visit(statement, null);
     }
 
+    default <S> T visit(TableMaintenanceStatement statement, S context) {
+        return null;
+    }
+
+    default void visit(TableMaintenanceStatement statement) {
+        this.visit(statement, null);
+    }
+
     default void visit(Execute execute) {
         this.visit(execute, null);
     }
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
index 91d772e677..8a80763ca3 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
@@ -622,6 +622,11 @@ public <S> T visit(Analyze analyze, S context) {
         return null;
     }
 
+    @Override
+    public <S> T visit(TableMaintenanceStatement statement, S context) {
+        return null;
+    }
+
     @Override
     public <S> T visit(SavepointStatement savepointStatement, S context) {
         // @todo: do something usefully here
diff --git a/src/main/java/net/sf/jsqlparser/statement/TableMaintenanceStatement.java b/src/main/java/net/sf/jsqlparser/statement/TableMaintenanceStatement.java
new file mode 100644
index 0000000000..d056b699de
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/TableMaintenanceStatement.java
@@ -0,0 +1,185 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import net.sf.jsqlparser.schema.Table;
+
+/**
+ * A MySQL/MariaDB {@code CHECK TABLE}, {@code OPTIMIZE TABLE} or {@code REPAIR TABLE} statement.
+ * {@code ANALYZE TABLE} remains {@link net.sf.jsqlparser.statement.analyze.Analyze}.
+ */
+public class TableMaintenanceStatement implements Statement {
+
+    public enum Operation {
+        CHECK, OPTIMIZE, REPAIR;
+
+        /** Whether this operation accepts the option after its table list. */
+        public boolean allows(Option option) {
+            switch (this) {
+                case CHECK:
+                    return option != Option.USE_FRM;
+                case REPAIR:
+                    return option == Option.QUICK || option == Option.EXTENDED
+                            || option == Option.USE_FRM;
+                default:
+                    return false;
+            }
+        }
+
+        /** Whether this operation accepts {@code NO_WRITE_TO_BINLOG} or {@code LOCAL}. */
+        public boolean allowsModifier() {
+            return this != CHECK;
+        }
+    }
+
+    public enum Modifier {
+        NO_WRITE_TO_BINLOG, LOCAL
+    }
+
+    public enum Option {
+        FOR_UPGRADE, QUICK, FAST, MEDIUM, EXTENDED, CHANGED, USE_FRM;
+
+        /** Returns the SQL spelling, for example {@code FOR UPGRADE}. */
+        public String getKeyword() {
+            return this == FOR_UPGRADE ? "FOR UPGRADE" : name();
+        }
+
+        /** Returns the single-word option spelled by {@code word}, or null. */
+        public static Option fromKeyword(String word) {
+            for (Option option : values()) {
+                if (option != FOR_UPGRADE && option.name().equalsIgnoreCase(word)) {
+                    return option;
+                }
+            }
+            return null;
+        }
+    }
+
+    private Operation operation;
+    private Modifier modifier;
+    private boolean tablesKeyword;
+    private final List<Table> tables = new ArrayList<>();
+    private final List<Option> options = new ArrayList<>();
+
+    public TableMaintenanceStatement() {
+        // empty constructor
+    }
+
+    public TableMaintenanceStatement(Operation operation) {
+        this.operation = operation;
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+
+    public Operation getOperation() {
+        return operation;
+    }
+
+    public void setOperation(Operation operation) {
+        this.operation = operation;
+    }
+
+    public Modifier getModifier() {
+        return modifier;
+    }
+
+    public void setModifier(Modifier modifier) {
+        this.modifier = modifier;
+    }
+
+    /** Whether the statement is spelled with {@code TABLES} instead of {@code TABLE}. */
+    public boolean isTablesKeyword() {
+        return tablesKeyword;
+    }
+
+    public void setTablesKeyword(boolean tablesKeyword) {
+        this.tablesKeyword = tablesKeyword;
+    }
+
+    public List<Table> getTables() {
+        return Collections.unmodifiableList(tables);
+    }
+
+    public void setTables(Collection<? extends Table> tables) {
+        this.tables.clear();
+        if (tables != null) {
+            this.tables.addAll(tables);
+        }
+    }
+
+    /** Returns the options in source order; repeated options are retained as written. */
+    public List<Option> getOptions() {
+        return Collections.unmodifiableList(options);
+    }
+
+    public void setOptions(Collection<Option> options) {
+        this.options.clear();
+        if (options != null) {
+            this.options.addAll(options);
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder().append(operation);
+        if (modifier != null) {
+            builder.append(' ').append(modifier);
+        }
+        builder.append(tablesKeyword ? " TABLES " : " TABLE ")
+                .append(tables.stream().map(Table::toString).collect(Collectors.joining(", ")));
+        for (Option option : options) {
+            builder.append(' ').append(option.getKeyword());
+        }
+        return builder.toString();
+    }
+
+    public TableMaintenanceStatement withOperation(Operation operation) {
+        setOperation(operation);
+        return this;
+    }
+
+    public TableMaintenanceStatement withModifier(Modifier modifier) {
+        setModifier(modifier);
+        return this;
+    }
+
+    public TableMaintenanceStatement withTablesKeyword(boolean tablesKeyword) {
+        setTablesKeyword(tablesKeyword);
+        return this;
+    }
+
+    public TableMaintenanceStatement withTables(Collection<? extends Table> tables) {
+        setTables(tables);
+        return this;
+    }
+
+    public TableMaintenanceStatement addTables(Table... tables) {
+        Collections.addAll(this.tables, tables);
+        return this;
+    }
+
+    public TableMaintenanceStatement withOptions(Collection<Option> options) {
+        setOptions(options);
+        return this;
+    }
+
+    public TableMaintenanceStatement addOptions(Option... options) {
+        Collections.addAll(this.options, options);
+        return this;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
index 0741d1e4de..de27f5559a 100644
--- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
+++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -105,6 +105,7 @@
 import net.sf.jsqlparser.statement.StartTransaction;
 import net.sf.jsqlparser.statement.Statement;
 import net.sf.jsqlparser.statement.StatementVisitor;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.Statements;
 import net.sf.jsqlparser.statement.UnsupportedStatement;
 import net.sf.jsqlparser.statement.UseStatement;
@@ -1635,6 +1636,17 @@ public void visit(Analyze analyze) {
         StatementVisitor.super.visit(analyze);
     }
 
+    @Override
+    public <S> Void visit(TableMaintenanceStatement statement, S context) {
+        statement.getTables().forEach(table -> visit(table, context));
+        return null;
+    }
+
+    @Override
+    public void visit(TableMaintenanceStatement statement) {
+        StatementVisitor.super.visit(statement);
+    }
+
     @Override
     public <S> Void visit(Drop drop, S context) {
         drop.visitTables(table -> visit(table, context));
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 07eef5cbff..2490baa3ec 100644
--- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
+++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
@@ -77,6 +77,7 @@
 import net.sf.jsqlparser.statement.UnsupportedStatement;
 import net.sf.jsqlparser.statement.UseStatement;
 import net.sf.jsqlparser.statement.SetIdentityInsertStatement;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.AlterSession;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
@@ -334,6 +335,12 @@ public <S> StringBuilder visit(Analyze analyzer, S context) {
         return builder;
     }
 
+    @Override
+    public <S> StringBuilder visit(TableMaintenanceStatement statement, S context) {
+        builder.append(statement);
+        return builder;
+    }
+
     @Override
     public <S> StringBuilder visit(Alter alter, S context) {
         AlterDeParser alterDeParser = new AlterDeParser(builder, expressionDeParser);
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 930d78292d..de84d3f823 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
@@ -79,6 +79,9 @@ public enum MariaDbVersion implements Version {
                     // https://mariadb.com/kb/en/truncate-table/
                     Feature.truncate,
 
+                    // https://mariadb.com/kb/en/table-statements/
+                    Feature.tableMaintenance,
+
                     // https://mariadb.com/kb/en/call/
                     Feature.execute, Feature.executeCall,
 
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 49828a406e..6aabf1fe0d 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
@@ -75,6 +75,9 @@ public enum MySqlVersion implements Version {
                     // https://dev.mysql.com/doc/refman/8.0/en/truncate-table.html
                     Feature.truncate,
 
+                    // https://dev.mysql.com/doc/refman/8.0/en/table-maintenance-statements.html
+                    Feature.tableMaintenance,
+
                     // https://dev.mysql.com/doc/refman/8.0/en/call.html
                     Feature.execute, Feature.executeCall,
 
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 3912bac145..1de8380a75 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
@@ -76,6 +76,7 @@
 import net.sf.jsqlparser.statement.UnsupportedStatement;
 import net.sf.jsqlparser.statement.UseStatement;
 import net.sf.jsqlparser.statement.SetIdentityInsertStatement;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.AlterSession;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
@@ -509,6 +510,12 @@ public <S> Void visit(Analyze analyze, S context) {
         return null;
     }
 
+    @Override
+    public <S> Void visit(TableMaintenanceStatement statement, S context) {
+        getValidator(TableMaintenanceValidator.class).validate(statement);
+        return null;
+    }
+
     @Override
     public <S> Void visit(SavepointStatement savepointStatement, S context) {
         // TODO: not yet implemented
@@ -823,6 +830,11 @@ public void visit(Analyze analyze) {
         visit(analyze, null);
     }
 
+    @Override
+    public void visit(TableMaintenanceStatement statement) {
+        visit(statement, null);
+    }
+
     public void visit(SavepointStatement savepointStatement) {
         visit(savepointStatement, null);
     }
diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java
new file mode 100644
index 0000000000..7f022612e1
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidator.java
@@ -0,0 +1,26 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.util.validation.validator;
+
+import net.sf.jsqlparser.parser.feature.Feature;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement;
+import net.sf.jsqlparser.util.validation.ValidationCapability;
+import net.sf.jsqlparser.util.validation.metadata.NamedObject;
+
+public class TableMaintenanceValidator extends AbstractValidator<TableMaintenanceStatement> {
+    @Override
+    public void validate(TableMaintenanceStatement statement) {
+        for (ValidationCapability c : getCapabilities()) {
+            validateFeature(c, Feature.tableMaintenance);
+            statement.getTables().forEach(table -> validateName(c, NamedObject.table,
+                    table.getFullyQualifiedName(), true));
+        }
+    }
+}
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
index eb904885ac..d0975b1f82 100644
--- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
+++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -1616,6 +1616,43 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         return token.kind != EOF && token.image != null && keyword.equalsIgnoreCase(token.image);
     }
 
+    /**
+     * Whether a MySQL CHECK, OPTIMIZE or REPAIR TABLE statement starts here. TABLE or TABLES must
+     * follow, so other uses of these words are unaffected.
+     */
+    private boolean isTableMaintenanceAhead() {
+        int kind = getToken(1).kind;
+        if (kind != K_CHECK && kind != K_OPTIMIZE && kind != K_REPAIR) {
+            return false;
+        }
+        int offset = 2;
+        int modifier = getToken(2).kind;
+        if (kind != K_CHECK && (modifier == K_NO_WRITE_TO_BINLOG || modifier == K_LOCAL)) {
+            offset = 3;
+        }
+        int table = getToken(offset).kind;
+        return table == K_TABLE || table == K_TABLES;
+    }
+
+    /** Whether the next tokens spell an option accepted by this table maintenance operation. */
+    private boolean isTableMaintenanceOptionAhead(TableMaintenanceStatement.Operation operation) {
+        Token token = getToken(1);
+        TableMaintenanceStatement.Option option = null;
+        if (token.kind == K_FOR) {
+            Token next = getToken(2);
+            if (next.kind == S_IDENTIFIER && "UPGRADE".equalsIgnoreCase(next.image)) {
+                option = TableMaintenanceStatement.Option.FOR_UPGRADE;
+            }
+        } else if (token.kind == K_QUICK) {
+            option = TableMaintenanceStatement.Option.QUICK;
+        } else if (token.kind == K_EXTENDED) {
+            option = TableMaintenanceStatement.Option.EXTENDED;
+        } else if (token.kind == S_IDENTIFIER) {
+            option = TableMaintenanceStatement.Option.fromKeyword(token.image);
+        }
+        return option != null && operation.allows(option);
+    }
+
     private boolean isXmlTypeName(String name) {
         return "XML".equalsIgnoreCase(name) || "[XML]".equalsIgnoreCase(name)
                 || "\"XML\"".equalsIgnoreCase(name);
@@ -3429,6 +3466,8 @@ Statement SingleStatement() :
             |
             stm = Analyze()
             |
+            LOOKAHEAD({ isTableMaintenanceAhead() }) stm = TableMaintenanceStatement()
+            |
             stm = Truncate()
             |
             stm = Execute()
@@ -16505,6 +16544,52 @@ ColDataType.TypeModifier MySqlTypeModifier():
     { return modifier; }
 }
 
+/**
+ * Parses MySQL/MariaDB CHECK, OPTIMIZE and REPAIR TABLE statements. Options are accepted only for
+ * the operation that defines them, without reserving the option words.
+ */
+TableMaintenanceStatement TableMaintenanceStatement():
+{
+    TableMaintenanceStatement statement = new TableMaintenanceStatement();
+    TableMaintenanceStatement.Operation operation = null;
+    TableMaintenanceStatement.Option option = null;
+    Token modifier = null;
+    Token word = null;
+    Table table = null;
+}
+{
+    (
+        <K_CHECK> { operation = TableMaintenanceStatement.Operation.CHECK; }
+        | <K_OPTIMIZE> { operation = TableMaintenanceStatement.Operation.OPTIMIZE; }
+        | <K_REPAIR> { operation = TableMaintenanceStatement.Operation.REPAIR; }
+    )
+    { statement.setOperation(operation); }
+    [
+        LOOKAHEAD({ operation.allowsModifier()
+                && (getToken(1).kind == K_NO_WRITE_TO_BINLOG || getToken(1).kind == K_LOCAL) })
+        ( modifier=<K_NO_WRITE_TO_BINLOG> | modifier=<K_LOCAL> )
+        {
+            statement.setModifier(TableMaintenanceStatement.Modifier.valueOf(
+                    modifier.image.toUpperCase(Locale.ROOT)));
+        }
+    ]
+    ( <K_TABLE> | <K_TABLES> { statement.setTablesKeyword(true); } )
+    table=Table() { statement.addTables(table); }
+    ( "," table=Table() { statement.addTables(table); } )*
+    (
+        LOOKAHEAD({ isTableMaintenanceOptionAhead(operation) })
+        (
+            <K_FOR> ContextualKeyword("UPGRADE")
+            { option = TableMaintenanceStatement.Option.FOR_UPGRADE; }
+            | <K_QUICK> { option = TableMaintenanceStatement.Option.QUICK; }
+            | <K_EXTENDED> { option = TableMaintenanceStatement.Option.EXTENDED; }
+            | word=<S_IDENTIFIER> { option = TableMaintenanceStatement.Option.fromKeyword(word.image); }
+        )
+        { statement.addOptions(option); }
+    )*
+    { return statement; }
+}
+
 Analyze Analyze():
 {
     Analyze analyze = new Analyze();
@@ -20531,7 +20616,9 @@ CreateDomain CreateDomain():
     [ <K_AS> { result.setUseAs(true); } ] type=ColDataType() { result.setDataType(type); }
     [ <K_COLLATE> name=TypeDdlName() { result.setCollation(name); } ]
     [ <K_DEFAULT> expression=Expression() { result.setDefaultExpression(expression); } ]
-    ( constraint=DomainConstraint(true) { result.getConstraints().add(constraint); } )*
+    // A following CHECK TABLE statement is not a domain CHECK constraint.
+    ( LOOKAHEAD(1, { !isTableMaintenanceAhead() })
+      constraint=DomainConstraint(true) { result.getConstraints().add(constraint); } )*
     { return result; }
 }
 
diff --git a/src/site/sphinx/index.rst b/src/site/sphinx/index.rst
index 283bc5c4d7..5f3b0157b4 100644
--- a/src/site/sphinx/index.rst
+++ b/src/site/sphinx/index.rst
@@ -156,6 +156,8 @@ One grammar covers the SQL standard plus all major RDBMS. Missing syntax gets ad
       - ``INSERT`` · ``UPDATE`` · ``UPSERT`` · ``MERGE`` · ``DELETE`` · ``TRUNCATE TABLE``
     * - **DDL**
       - ``CREATE …`` · ``ALTER …`` · ``DROP …``
+    * - **MySQL table maintenance**
+      - ``ANALYZE`` · ``CHECK`` · ``OPTIMIZE`` · ``REPAIR TABLE``
     * - **PostgreSQL RLS**
       - ``CREATE POLICY`` · ``ALTER TABLE … ENABLE``/``DISABLE``/``FORCE``/``NO FORCE ROW LEVEL SECURITY``
     * - **Salesforce SOQL**
diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst
index 1d204c6e96..759678c750 100644
--- a/src/site/sphinx/usage.rst
+++ b/src/site/sphinx/usage.rst
@@ -1813,6 +1813,30 @@ visitors, both SQL renderers and metadata validation use this structured target.
 Feature analysis reports ``MODIFIES_SESSION``; the directive itself inserts no rows.
 The dedicated validation capability is ``setIdentityInsert``.
 
+MySQL table maintenance statements
+----------------------------------
+
+``CHECK TABLE``, ``OPTIMIZE TABLE`` and ``REPAIR TABLE`` parse to
+``TableMaintenanceStatement`` in every dialect; ``ANALYZE TABLE`` remains ``Analyze``.
+``getOperation()`` identifies the statement, ``getModifier()`` returns
+``NO_WRITE_TO_BINLOG`` or ``LOCAL`` for OPTIMIZE and REPAIR, and ``isTablesKeyword()``
+records the ``TABLES`` spelling. ``getOptions()`` keeps the trailing options in source
+order. CHECK accepts ``FOR UPGRADE``, ``QUICK``, ``FAST``, ``MEDIUM``, ``EXTENDED`` and
+``CHANGED``; REPAIR accepts ``QUICK``, ``EXTENDED`` and ``USE_FRM``. Other combinations
+are rejected, and the option words remain ordinary identifiers elsewhere.
+
+.. code-block:: java
+
+    TableMaintenanceStatement repair = (TableMaintenanceStatement) CCJSqlParserUtil.parse(
+        "REPAIR NO_WRITE_TO_BINLOG TABLE t1, t2 QUICK");
+    repair.getTables();   // [t1, t2]
+    repair.getOptions();  // [QUICK]
+
+Table visitors and metadata validation use the table list. Validators report the
+``tableMaintenance`` feature, which the MySQL and MariaDB capabilities enable. Feature
+analysis reports ``READS_DATA`` and ``RETURNS_RESULT_SET``; OPTIMIZE and REPAIR also
+report ``MODIFIES_SCHEMA``, and REPAIR may report ``MODIFIES_DATA``.
+
 Legacy MySQL GROUP BY ordering
 ==============================
 
diff --git a/src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java b/src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java
new file mode 100644
index 0000000000..50664b522c
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/statement/TableMaintenanceStatementTest.java
@@ -0,0 +1,180 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+import static net.sf.jsqlparser.test.TestUtils.assertDeparse;
+import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement.Modifier;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement.Operation;
+import net.sf.jsqlparser.statement.TableMaintenanceStatement.Option;
+import net.sf.jsqlparser.util.TablesNamesFinder;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class TableMaintenanceStatementTest {
+
+    private static TableMaintenanceStatement parse(String sql) throws JSQLParserException {
+        return (TableMaintenanceStatement) assertSqlCanBeParsedAndDeparsed(sql, true);
+    }
+
+    private static List<String> tableNames(TableMaintenanceStatement statement) {
+        return statement.getTables().stream().map(Table::getFullyQualifiedName)
+                .collect(Collectors.toList());
+    }
+
+    @Test
+    void optimizeTable() throws JSQLParserException {
+        TableMaintenanceStatement statement = parse("OPTIMIZE TABLE t");
+
+        assertEquals(Operation.OPTIMIZE, statement.getOperation());
+        assertNull(statement.getModifier());
+        assertFalse(statement.isTablesKeyword());
+        assertEquals(List.of("t"), tableNames(statement));
+        assertTrue(statement.getOptions().isEmpty());
+    }
+
+    @Test
+    void optimizeModifierAndTableList() throws JSQLParserException {
+        TableMaintenanceStatement statement =
+                parse("OPTIMIZE NO_WRITE_TO_BINLOG TABLE db.t1, `t 2`");
+
+        assertEquals(Modifier.NO_WRITE_TO_BINLOG, statement.getModifier());
+        assertEquals(List.of("db.t1", "`t 2`"), tableNames(statement));
+    }
+
+    @Test
+    void localModifierAndTablesKeyword() throws JSQLParserException {
+        TableMaintenanceStatement statement = parse("OPTIMIZE LOCAL TABLES t1, t2");
+
+        assertEquals(Modifier.LOCAL, statement.getModifier());
+        assertTrue(statement.isTablesKeyword());
+        assertEquals("OPTIMIZE LOCAL TABLES t1, t2", statement.toString());
+    }
+
+    @Test
+    void repairOptions() throws JSQLParserException {
+        TableMaintenanceStatement statement =
+                parse("REPAIR NO_WRITE_TO_BINLOG TABLE t QUICK EXTENDED USE_FRM");
+
+        assertEquals(Operation.REPAIR, statement.getOperation());
+        assertEquals(List.of(Option.QUICK, Option.EXTENDED, Option.USE_FRM),
+                statement.getOptions());
+    }
+
+    @Test
+    void checkOptionsKeepSourceOrder() throws JSQLParserException {
+        TableMaintenanceStatement statement =
+                parse("CHECK TABLE t1, t2 FOR UPGRADE QUICK FAST MEDIUM EXTENDED CHANGED");
+
+        assertEquals(Operation.CHECK, statement.getOperation());
+        assertEquals(List.of(Option.FOR_UPGRADE, Option.QUICK, Option.FAST, Option.MEDIUM,
+                Option.EXTENDED, Option.CHANGED), statement.getOptions());
+        assertEquals(List.of("t1", "t2"), tableNames(statement));
+    }
+
+    @Test
+    void keywordsAreCaseInsensitive() throws JSQLParserException {
+        Statement statement = CCJSqlParserUtil.parse("check tables t medium for upgrade");
+
+        assertEquals("CHECK TABLES t MEDIUM FOR UPGRADE", statement.toString());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "CHECK NO_WRITE_TO_BINLOG TABLE t",
+            "CHECK LOCAL TABLE t",
+            "CHECK TABLE t USE_FRM",
+            "OPTIMIZE TABLE t QUICK",
+            "REPAIR TABLE t FAST",
+            "REPAIR TABLE t FOR UPGRADE",
+            "OPTIMIZE t",
+            "REPAIR TABLE"
+    })
+    void rejectsSyntaxOutsideTheStatementDefinition(String sql) {
+        assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql));
+    }
+
+    @Test
+    void parsesInMySqlAndMariaDbDialects() throws JSQLParserException {
+        for (Dialect dialect : List.of(Dialect.MYSQL, Dialect.MARIADB)) {
+            Statement statement = CCJSqlParserUtil.parse("OPTIMIZE TABLE t",
+                    parser -> parser.withDialect(dialect));
+            assertInstanceOf(TableMaintenanceStatement.class, statement, dialect.name());
+        }
+    }
+
+    @Test
+    void buildsAndDeparses() {
+        TableMaintenanceStatement statement = new TableMaintenanceStatement(Operation.REPAIR)
+                .withModifier(Modifier.LOCAL).addTables(new Table("t1"), new Table("t2"))
+                .addOptions(Option.QUICK);
+
+        assertDeparse(statement, "REPAIR LOCAL TABLE t1, t2 QUICK");
+    }
+
+    @Test
+    void findsTables() throws JSQLParserException {
+        Statement statement = CCJSqlParserUtil.parse("CHECK TABLE a, s.b QUICK");
+
+        assertThat(TablesNamesFinder.findTables(statement.toString()))
+                .containsExactlyInAnyOrder("a", "s.b");
+    }
+
+    @Test
+    void wordsRemainUsableOutsideTheStatement() throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed("SELECT optimize, repair, quick, fast, medium, changed "
+                + "FROM maintenance");
+        assertSqlCanBeParsedAndDeparsed("ALTER TABLE t OPTIMIZE PARTITION p1");
+        assertSqlCanBeParsedAndDeparsed("ALTER TABLE t CHECK PARTITION p1");
+        assertSqlCanBeParsedAndDeparsed("ALTER TABLE t REPAIR PARTITION p1");
+    }
+
+    @Test
+    void domainCheckConstraintIsNotATableCheck() throws JSQLParserException {
+        Statements statements = CCJSqlParserUtil.parseStatements(
+                "CREATE DOMAIN d AS INT CHECK (VALUE > 0);\nCHECK TABLE t;",
+                parser -> parser.withDialect(Dialect.POSTGRESQL));
+
+        assertEquals(2, statements.size());
+        assertEquals("CREATE DOMAIN d AS INT CHECK (VALUE > 0)",
+                statements.get(0).toString());
+        assertInstanceOf(TableMaintenanceStatement.class, statements.get(1));
+    }
+
+    @Test
+    void reportsStatementFeatures() throws JSQLParserException {
+        StatementFeatures check = CCJSqlParserUtil.parse("CHECK TABLE t").getFeatures();
+        assertThat(check.getCertain()).containsExactlyInAnyOrder(StmtFeature.READS_DATA,
+                StmtFeature.RETURNS_RESULT_SET);
+
+        StatementFeatures optimize = CCJSqlParserUtil.parse("OPTIMIZE TABLE t").getFeatures();
+        assertThat(optimize.getCertain()).contains(StmtFeature.MODIFIES_SCHEMA);
+        assertFalse(optimize.may(StmtFeature.MODIFIES_DATA));
+
+        StatementFeatures repair = CCJSqlParserUtil.parse("REPAIR TABLE t").getFeatures();
+        assertThat(repair.getCertain()).contains(StmtFeature.MODIFIES_SCHEMA);
+        assertThat(repair.getUncertain()).contains(StmtFeature.MODIFIES_DATA);
+    }
+}
diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java
new file mode 100644
index 0000000000..4bc650f30d
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/TableMaintenanceValidatorTest.java
@@ -0,0 +1,42 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.util.validation.validator;
+
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.feature.Feature;
+import net.sf.jsqlparser.util.validation.ValidationTestAsserts;
+import net.sf.jsqlparser.util.validation.feature.DatabaseType;
+import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed;
+import net.sf.jsqlparser.util.validation.feature.MariaDbVersion;
+import net.sf.jsqlparser.util.validation.feature.MySqlVersion;
+import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion;
+import org.junit.jupiter.api.Test;
+
+public class TableMaintenanceValidatorTest extends ValidationTestAsserts {
+
+    @Test
+    public void testAllowedForMySqlAndMariaDb() throws JSQLParserException {
+        for (String sql : new String[] {"OPTIMIZE TABLE t1, t2", "REPAIR TABLE t QUICK",
+                "CHECK TABLE t FOR UPGRADE"}) {
+            validateNoErrors(sql, 1, MySqlVersion.V8_0, MariaDbVersion.V10_5_4,
+                    DatabaseType.MYSQL, DatabaseType.MARIADB);
+        }
+    }
+
+    @Test
+    public void testNotAllowedForPostgresql() throws JSQLParserException {
+        validate("OPTIMIZE TABLE t", 1, 1, PostgresqlVersion.V14);
+    }
+
+    @Test
+    public void testFeatureNotAllowed() throws JSQLParserException {
+        validateNotAllowed("CHECK TABLE t", 1, 1, FeaturesAllowed.SELECT, Feature.tableMaintenance);
+    }
+}