diff --git a/README.md b/README.md
index 6df4adb09..d39e81ea6 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 9e0bd5ce1..243194bcb 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 d1eac1029..91b272124 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 bc5c37b47..bf0bf3e8b 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 91d772e67..8a80763ca 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 000000000..d056b699d
--- /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 0741d1e4d..de27f5559 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 07eef5cbf..2490baa3e 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 930d78292..de84d3f82 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 49828a406..6aabf1fe0 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 3912bac14..1de8380a7 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 000000000..7f022612e
--- /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 eb904885a..d0975b1f8 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 283bc5c4d..5f3b0157b 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 1d204c6e9..759678c75 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 000000000..50664b522
--- /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 000000000..4bc650f30
--- /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);
+    }
+}