@@ -68,6 +68,7 @@ TEST_SRCS = $(TEST_DIR)/test_main.cpp \
             $(TEST_DIR)/test_mysql_grammar.cpp \
             $(TEST_DIR)/test_mysql_tables.cpp \
             $(TEST_DIR)/test_mysql_query_expressions.cpp \
+            $(TEST_DIR)/test_mysql_cte_dml.cpp \
             $(TEST_DIR)/test_review_ast.cpp \
             $(TEST_DIR)/test_review_transactions.cpp \
             $(TEST_DIR)/test_review_runtime.cpp \
 
@@ -8,6 +8,8 @@ ParserSQL also preserves partition lists, `USE`/`FORCE`/`IGNORE INDEX` or `KEY`,
 
 MySQL query expressions also preserve explicit `TABLE name` and `VALUES ROW(...)` constructors in standalone, compound, derived, LATERAL, scalar, IN, EXISTS, and query-only CTE contexts. `INTERSECT` binds more tightly than `UNION` and `EXCEPT`; explicit parentheses and branch-local ordering/limits are retained. Recursive CTEs retain their keyword and optional column lists. Query locking clauses, including `LOCK IN SHARE MODE`, remain structured. This is parser/AST coverage; the local engine rejects unsupported query forms.
 
+Top-level MySQL `WITH` and `WITH RECURSIVE` also retain structured UPDATE and DELETE main statements, including join/comma UPDATEs, both multi-table DELETE target-list forms, quoted CTE names, partitions, statement options, and single-table ordering/limits. CTE bodies and subqueries remain query-only; DML inside them and a leading `WITH ... INSERT` are rejected. UPDATE assignments require one-, two-, or three-part column names and accept both `=` and `:=` (emitted as `=`), including `DEFAULT` values. UPDATE options follow `LOW_PRIORITY` then `IGNORE`; DELETE options may appear in any order and repeat. The [8.4.8 UPDATE/DELETE productions](https://github.com/mysql/mysql-server/blob/0896fcd61dec11a0904166911a0126f59daaa1bf/sql/sql_yacc.yy#L13389) and [9.7.2 UPDATE/DELETE productions](https://github.com/mysql/mysql-server/blob/008e09c2834b98143a8c067d4d225c90953050cf/sql/sql_yacc.yy#L13945) attach an optional WITH clause to each main statement. Routing metadata identifies the main DML target, including wildcard DELETE targets. JOIN conditions require complete ON/USING operands and retain quoted USING column names. These are parser/AST guarantees; the local engine rejects CTE-prefixed DML.
+
 The native grammar permits empty `VALUES ROW()`, `VALUES ROW(DEFAULT)`, and repeated locking clauses. Both pinned servers return semantic errors 3942, 3943, and 3569 respectively for the curated standalone or overlapping-lock witnesses. These remain `SERVER_ERROR` observations, not syntax rejections, while ParserSQL preserves the grammar-valid ASTs. `TABLE` takes a table identifier and query-level tails; aliases, partitions, index hints, and WHERE clauses directly after its table name are malformed controls. The [8.4.8 query-primary productions](https://github.com/mysql/mysql-server/blob/0896fcd61dec11a0904166911a0126f59daaa1bf/sql/sql_yacc.yy#L9831) and [9.7.2 query-primary productions](https://github.com/mysql/mysql-server/blob/008e09c2834b98143a8c067d4d225c90953050cf/sql/sql_yacc.yy#L10145) include both constructors. The corpus records exact anchors for their rows, subquery contexts, locking, CTEs, and malformed controls.
 
 Table identifiers and aliases use the common 259-word reserved baseline observed in the pinned 8.4.8 and 9.7.2 releases. ParserSQL has no MySQL version setting, so the five 9.7-only reserved additions (`CUBE`, `EXTERNAL`, `LIBRARY`, `QUALIFY`, and `TABLESAMPLE`) remain accepted as names. Strict version-specific identifier rules remain a gap.
@@ -46,7 +48,7 @@ Malformed controls are handled separately: a complete AST is `MALFORMED_ACCEPTED
 
 Every fixture freezes one exact expected outcome. Known gaps do not make arbitrary failures acceptable. Both regression and unexpected improvement cause exit status 1, so a fixed gap must be reviewed and explicitly promoted in the corpus. When promoting, add an independently derived `expected_sql`, set `known_gap=false`, and require `CHECKED`. Harness/transport/source errors return 2. Exit status 0 means the expected baseline matched, including its documented known gaps.
 
-The 113-case baseline has 62 `CHECKED` witnesses and 34 `REJECTED` negative controls. Its remaining known gaps are ten `TRAILING_INPUT`, three `NO_AST`, two `ERROR`, one `PARTIAL`, and one `EMISSION_MISMATCH`. The two `ERROR` witnesses are CTE-prefixed UPDATE/DELETE: the query-only WITH parser now rejects these unsupported main statements directly. Source verification checks 110 exact grammar anchors per pinned release. These counts describe this corpus only.
+The 137-case baseline has 72 `CHECKED` witnesses and 50 `REJECTED` negative controls. Its 15 remaining known gaps are ten `TRAILING_INPUT`, three `NO_AST`, one `PARTIAL`, and one `EMISSION_MISMATCH`. CTE-prefixed UPDATE/DELETE now pass complete parse, exact emission, and stable reparse checks. Source verification checks 134 exact grammar anchors per pinned release. These counts describe this corpus only.
 
 The JSON report includes all original and reparsed records, source verification counts, pinned revisions, SQL-mode metadata, and SHA-256 hashes of the corpus and probe. Counts apply only to these witnesses. The probe uses hex-line input and hex fields in its TSV response, preserving tabs, newlines and embedded NUL bytes. It emits while both the input string and parser arena are alive; Python reparses owned copies in a second probe invocation.
 
@@ -65,9 +67,9 @@ Each curated case explicitly chooses direct query execution, `EXPLAIN` for DML (
 
 Native results are stored separately in `native_oracle`: `ACCEPTED`, `SYNTAX_REJECTED` (1064/1149), `SERVER_ERROR`, `CLIENT_ERROR`, or **NOT VERIFIED**. For example, a derived table missing its required alias returns error 1248; this remains a server error, even though the corpus requires ParserSQL to reject that input. Accepted invalid controls and syntax-rejected valid controls count as expectation mismatches, using per-version validity when specified. Server errors remain explicitly unresolved; client errors return status 2. Thus exit status 0 still does not mean all native cases were verified. The default corpus metadata remains **NOT VERIFIED**, while the optional report describes the actual native observations.
 
-A native check of all 113 witnesses under `ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION` found no native expectation mismatches. MySQL 8.4.8 accepted 69, syntax-rejected 36, and returned five server errors (two 1248 missing-alias errors, 3942, 3943, and 3569); MySQL 9.7.2 accepted 71, syntax-rejected 32, and returned seven server errors (the same five plus 1235 and 3889). Both runs skipped the three DDL/procedure witnesses and cleaned up their owned schemas. All shared positive query/DML witnesses except the three explicitly grammar-valid semantic-error controls were accepted, including partition selection, index hints, query constructors, and recursive CTEs. Re-run the command on each isolated socket to reproduce current observations; reports are intentionally not committed.
+A native check of all 137 witnesses under `ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION` found no native expectation mismatches. MySQL 8.4.8 accepted 77, syntax-rejected 52, and returned five server errors (two 1248 missing-alias errors, 3942, 3943, and 3569); MySQL 9.7.2 accepted 79, syntax-rejected 48, and returned seven server errors (the same five plus 1235 and 3889). Both runs skipped the three DDL/procedure witnesses and cleaned up their owned schemas. All shared positive query/DML witnesses except the three explicitly grammar-valid semantic-error controls were accepted, including partition selection, index hints, query constructors, recursive CTEs, and CTE-prefixed UPDATE/DELETE. Re-run the command on each isolated socket to reproduce current observations; reports are intentionally not committed.
 
-The corpus is deliberately selected and is not a representative workload. It contains 109 shared witnesses and four version-specific query witnesses; this does not imply identical dialects in 8.4.8 and 9.7.2. The version-specific entries record `applicability`, source productions for both versions, `native_validity` per version, and observed native outcomes. Their generic `validity=valid` denotes the 9.7.2 grammar target. The native helper selects the intended validity using the actual server version, so an expected 8.4.8 syntax rejection is not treated as a corpus error. Stored native observations are context, not substitutes for a current run. These additions remain ParserSQL gaps. The following differences include those four query witnesses and two separate DDL spot checks:
+The corpus is deliberately selected and is not a representative workload. It contains 133 shared witnesses and four version-specific query witnesses; this does not imply identical dialects in 8.4.8 and 9.7.2. The version-specific entries record `applicability`, source productions for both versions, `native_validity` per version, and observed native outcomes. Their generic `validity=valid` denotes the 9.7.2 grammar target. The native helper selects the intended validity using the actual server version, so an expected 8.4.8 syntax rejection is not treated as a corpus error. Stored native observations are context, not substitutes for a current run. These additions remain ParserSQL gaps. The following differences include those four query witnesses and two separate DDL spot checks:
 
 | Reduced feature | MySQL 8.4.8 observation | MySQL 9.7.2 observation |
 | --- | --- | --- |
 
@@ -2,6 +2,7 @@
 #define SQL_PARSER_COMPOUND_QUERY_PARSER_H
 
 #include "sql_parser/select_parser.h"
+#include "sql_parser/mysql_value_syntax.h"
 #include "sql_parser/pg_query_clauses.h"
 #include <limits>
 
@@ -268,47 +269,6 @@ class CompoundQueryParser {
         return order_by;
     }
 
-    // DEFAULT is a complete row value, not an arbitrary expression operand.
-    // Qualified identifier components can themselves be reserved words.
-    static bool mysql_value_expression(const AstNode* node, bool allow_default = false,
-                                       bool allow_star = false) {
-        if (node->type == NodeType::NODE_SUBQUERY) return true; // validated by its query parser
-        if (node->type == NodeType::NODE_ASTERISK) return allow_star;
-        if (node->type == NodeType::NODE_IDENTIFIER && !(node->flags & FLAG_IDENT_DELIMITED) &&
-            node->value().equals_ci("DEFAULT", 7)) return allow_default;
-        if (node->type == NodeType::NODE_QUALIFIED_NAME) {
-            for (const auto* child = node->first_child; child; child = child->next_sibling)
-                if (!(child->flags & FLAG_IDENT_DELIMITED) && child->value().equals_ci("*", 1)) return false;
-            return true;
-        }
-        bool count = node->type == NodeType::NODE_FUNCTION_CALL && node->value().equals_ci("COUNT", 5);
-        for (const auto* child = node->first_child; child; child = child->next_sibling)
-            if (!mysql_value_expression(child, false, count)) return false;
-        return true;
-    }
-
-    AstNode* parse_mysql_limit_value() {
-        Token token = tok_.next_token();
-        NodeType kind;
-        uint16_t flags = 0;
-        if (token.type == TokenType::TK_INTEGER) {
-            uint64_t value = 0;
-            for (uint32_t i = 0; i < token.text.len; ++i) {
-                unsigned digit = static_cast<unsigned char>(token.text.ptr[i]) - '0';
-                if (digit > 9 || value > (std::numeric_limits<uint64_t>::max() - digit) / 10)
-                    return expr_parser_.syntax_error();
-                value = value * 10 + digit;
-            }
-            kind = NodeType::NODE_LITERAL_INT;
-        } else if (token.type == TokenType::TK_QUESTION) kind = NodeType::NODE_PLACEHOLDER;
-        else if (mysql_identifier_token(token)) {
-            kind = NodeType::NODE_COLUMN_REF;
-            if (token.source.ptr != token.text.ptr) flags |= FLAG_IDENT_DELIMITED;
-        } else return expr_parser_.syntax_error();
-        auto* value = make_node_from_token(arena_, kind, token, flags);
-        return value ? value : expr_parser_.syntax_error();
-    }
-
     // Parse trailing LIMIT for compound result
     AstNode* parse_limit(bool require_operands) {
         ExpressionParser<D> expressions(tok_, arena_, require_operands);
@@ -317,7 +277,10 @@ class CompoundQueryParser {
         if (!limit) return nullptr;
 
         auto operand = [&]() -> AstNode* {
-            if constexpr (D == Dialect::MySQL) return parse_mysql_limit_value();
+            if constexpr (D == Dialect::MySQL) {
+                auto* value = mysql_limit_value(tok_, arena_);
+                return value ? value : expr_parser_.syntax_error();
+            }
             else return expressions.parse();
         };
         AstNode* first = operand();