Add structured MySQL CREATE and ALTER partition grammar

Parse HASH, LINEAR HASH, KEY, LINEAR KEY, RANGE and LIST methods,
including COLUMNS variants, KEY ALGORITHM, partition counts, HASH/KEY
subpartitioning, partition value lists and recognized definition options.
Represent methods, expressions, names and definitions as traversable AST
nodes and emit canonical SQL without preserving unchecked clause tails.

Add standalone ALTER partition maintenance and EXCHANGE operations with
native modifier placement and action-list boundaries. Parse repartitioning
and REMOVE PARTITIONING tails separately from comma-separated actions.
Preserve destination routing metadata when EXCHANGE names a source table.

Enforce native bit_expr boundaries and numeric-token rules, including wide
hexadecimal metadata. Reject opaque legacy expression fragments and
PostgreSQL array/postfix syntax in partition operands. Treat ARRAY as a
normal MySQL identifier/function token while retaining PostgreSQL behavior.
Append node kinds without changing the 48-byte AST and retain conservative
local-planner and parameterization guards.

Register nine regression groups covering methods, malformed boundaries,
canonical round trips, AST clone/walk/edit behavior and metadata guards.
Remove the obsolete blanket rejection of partitioned CREATE TABLE.

Validation: forced full rebuild and make test passed 1,683 tests with 37
external-database skips; ASan/UBSan with leak detection passed 167 focused
MySQL tests. PostgreSQL harness passed 87 tests and all 5,122 CI cases.
Independent review verified malformed inputs, stable valid emission and
6,138 constrained-arena sanitizer parses. Seven parser/emitter benchmark
smoke cases ran; no benchmark sources or results are included.

Author: renecannao

Makefile

@@ -77,6 +77,8 @@ TEST_SRCS = $(TEST_DIR)/test_main.cpp \
             $(TEST_DIR)/test_mysql_optimizer_hints.cpp \
             $(TEST_DIR)/test_mysql_json_table.cpp \
             $(TEST_DIR)/test_mysql_table_ddl.cpp \
+            $(TEST_DIR)/test_mysql_partition.cpp \
+            $(TEST_DIR)/test_mysql_partition_alter.cpp \
             $(TEST_DIR)/test_mysql_procedure.cpp \
             $(TEST_DIR)/test_mysql_grouping.cpp \
             $(TEST_DIR)/test_mysql_explain.cpp \

include/sql_engine/plan_builder.h

@@ -199,6 +199,10 @@ class PlanBuilder {
             case NodeType::NODE_MYSQL_JSON_AGG_ARGUMENT:
             case NodeType::NODE_MYSQL_CREATE_LIKE:
             case NodeType::NODE_MYSQL_CREATE_QUERY:
+            case NodeType::NODE_MYSQL_PARTITION_CLAUSE:
+            case NodeType::NODE_MYSQL_PARTITION_DEF:
+            case NodeType::NODE_MYSQL_PARTITION_ACTION:
+            case NodeType::NODE_MYSQL_PARTITION_NAMES:
             case NodeType::NODE_MYSQL_CREATE_TABLE:
             case NodeType::NODE_MYSQL_ALTER_TABLE:
             case NodeType::NODE_MYSQL_COLUMN_DEF:

include/sql_parser/common.h

@@ -391,6 +391,11 @@ enum class NodeType : uint16_t {
     NODE_MYSQL_CREATE_LIKE, // LIKE; structured source relation child
     NODE_MYSQL_CREATE_QUERY, // AS / IGNORE AS / REPLACE AS; query AST child
 
+    NODE_MYSQL_PARTITION_CLAUSE, // PARTITION BY; method, counts and partition definitions
+    NODE_MYSQL_PARTITION_DEF, // PARTITION/SUBPARTITION; name, values, options and subpartitions
+    NODE_MYSQL_PARTITION_ACTION, // standalone ALTER partition command; structured operands
+    NODE_MYSQL_PARTITION_NAMES, // comma-separated partition identifiers
+
 };
 
 } // namespace sql_parser

include/sql_parser/emitter.h

@@ -203,6 +203,9 @@ class Emitter {
                 sb_.append("ALL "); emit_node(node->first_child); break;
             case NodeType::NODE_MYSQL_CREATE_LIKE:
             case NodeType::NODE_MYSQL_CREATE_QUERY:
+            case NodeType::NODE_MYSQL_PARTITION_CLAUSE:
+            case NodeType::NODE_MYSQL_PARTITION_DEF:
+            case NodeType::NODE_MYSQL_PARTITION_ACTION:
             case NodeType::NODE_MYSQL_CREATE_TABLE:
             case NodeType::NODE_MYSQL_ALTER_TABLE:
             case NodeType::NODE_MYSQL_COLUMN_DEF:
@@ -219,6 +222,7 @@ class Emitter {
             case NodeType::NODE_MYSQL_DDL_LIST:
             case NodeType::NODE_MYSQL_PROCEDURE_PARAMS:
                 sb_.append_char('('); emit_list(node, ", "); sb_.append_char(')'); break;
+            case NodeType::NODE_MYSQL_PARTITION_NAMES:
             case NodeType::NODE_MYSQL_ALTER_ACTIONS:
                 emit_list(node, ", "); break;
             case NodeType::NODE_MYSQL_JSON_TABLE: {

include/sql_parser/expression_parser.h

@@ -652,6 +652,8 @@ class ExpressionParser {
             }
             case TokenType::TK_ARRAY: {
                 tok_.skip();
+                // ARRAY is a nonreserved MySQL identifier/function name.
+                if constexpr (D == Dialect::MySQL) return parse_identifier_or_function(t);
                 return parse_array_constructor();
             }
             case TokenType::TK_ROW: {

include/sql_parser/mysql_ddl_parser.h

@@ -3,14 +3,15 @@
 
 #include "sql_parser/expression_parser.h"
 #include "sql_parser/mysql_type_parser.h"
+#include "sql_parser/mysql_partition_parser.h"
 #include "sql_parser/mysql_value_syntax.h"
 #include "sql_parser/parse_result.h"
 #include "sql_parser/subquery_parse_callback.h"
 
 namespace sql_parser {
 
-// Bounded native CREATE/ALTER TABLE grammar. Unsupported partitioning and
-// specialized index options remain explicit errors.
+// Bounded native CREATE/ALTER TABLE grammar. Unsupported specialized table
+// and index options remain explicit errors.
 // Lists, columns, expressions, constraints and options have separate AST nodes;
 // syntax leaves are only emitted after matching their native production.
 class MySQLDdlParser {
@@ -36,9 +37,7 @@ class MySQLDdlParser {
         if (create) {
             create_body(root);
         } else {
-            auto* actions = node(NodeType::NODE_MYSQL_ALTER_ACTIONS);
-            do { add(actions, action()); } while (!failed_ && take(TokenType::TK_COMMA));
-            add(root, actions);
+            alter_body(root);
         }
         if (!terminal()) fail();
         ParseResult result;
@@ -144,11 +143,13 @@ class MySQLDdlParser {
             require(TokenType::TK_RPAREN);
             add(root, definitions);
         }
-        while (!failed_ && !terminal() && !query_suffix()) {
+        while (!failed_ && !terminal() && !query_suffix() && !is("PARTITION")) {
             add(root, table_option());
             // A comma separates table options, never the following query.
-            if (take(TokenType::TK_COMMA) && (terminal() || query_suffix())) fail();
+            if (take(TokenType::TK_COMMA) && (terminal() || query_suffix() || is("PARTITION"))) fail();
         }
+        if (!failed_ && is("PARTITION"))
+            add(root, MySQLPartitionParser(tok_, arena_, callback_).parse());
         if (failed_ || terminal()) return;
         const char* prefix = "AS";
         if (take("IGNORE")) prefix = "IGNORE AS";
@@ -165,6 +166,87 @@ class MySQLDdlParser {
         add(root, source);
     }
 
+    bool partition_tail() { return is("PARTITION") || is("REMOVE"); }
+    bool partition_action_start() {
+        if (!one_of({"ADD", "DROP", "REBUILD", "OPTIMIZE", "ANALYZE", "CHECK",
+                     "REPAIR", "COALESCE", "TRUNCATE", "REORGANIZE", "EXCHANGE"})) return false;
+        auto look = tok_; look.skip();
+        return word(look.peek(), "PARTITION");
+    }
+    bool alter_modifier() { return one_of({"ALGORITHM", "LOCK", "WITH", "WITHOUT"}); }
+    AstNode* validation() {
+        auto* result = clause();
+        if (!take("WITH", result) && !take("WITHOUT", result)) fail();
+        require("VALIDATION", result); return result;
+    }
+    AstNode* partition_names(bool allow_all) {
+        if (allow_all && is("ALL")) return token_node(NodeType::NODE_MYSQL_DDL_SYNTAX);
+        auto* names = node(NodeType::NODE_MYSQL_PARTITION_NAMES);
+        do { add(names, identifier()); } while (!failed_ && take(TokenType::TK_COMMA));
+        return names;
+    }
+    AstNode* partition_action() {
+        const Token first = tok_.peek();
+        auto* result = token_node(NodeType::NODE_MYSQL_PARTITION_ACTION);
+        require("PARTITION", result);
+        const bool binlog = word(first, "ADD") || word(first, "REBUILD") || word(first, "OPTIMIZE") ||
+            word(first, "ANALYZE") || word(first, "REPAIR") || word(first, "COALESCE") ||
+            word(first, "REORGANIZE");
+        if (binlog && !take("NO_WRITE_TO_BINLOG", result)) take("LOCAL", result);
+        MySQLPartitionParser partition(tok_, arena_, callback_);
+        if (word(first, "ADD")) {
+            if (take("PARTITIONS", result)) add(result, partition.number());
+            else if (at(TokenType::TK_LPAREN)) add(result, partition.definitions());
+        } else if (word(first, "COALESCE")) add(result, partition.number());
+        else if (word(first, "REORGANIZE")) {
+            if (!terminal()) {
+                add(result, partition_names(false)); require("INTO", result);
+                add(result, partition.definitions());
+            }
+        } else if (word(first, "EXCHANGE")) {
+            add(result, identifier()); require("WITH", result); require("TABLE", result);
+            add(result, name());
+            if (one_of({"WITH", "WITHOUT"})) add(result, validation());
+        } else {
+            add(result, partition_names(!word(first, "DROP")));
+            if (word(first, "CHECK")) {
+                while (!failed_ && one_of({"QUICK", "FAST", "MEDIUM", "EXTENDED", "CHANGED", "FOR"})) {
+                    if (take("FOR", result)) require("UPGRADE", result); else syntax(result);
+                }
+            } else if (word(first, "REPAIR")) {
+                while (!failed_ && one_of({"QUICK", "EXTENDED", "USE_FRM"})) syntax(result);
+            }
+        }
+        return result;
+    }
+    void alter_body(AstNode* root) {
+        auto* actions = node(NodeType::NODE_MYSQL_ALTER_ACTIONS);
+        bool modifiers_only = true;
+        while (!failed_ && !partition_tail()) {
+            if (partition_action_start()) {
+                if (!modifiers_only) { fail(); break; }
+                add(actions, partition_action());
+                // Standalone partition actions cannot have trailing modifiers
+                // or ordinary column/index actions.
+                if (!terminal()) fail();
+                break;
+            }
+            const bool modifier = alter_modifier();
+            add(actions, one_of({"WITH", "WITHOUT"}) ? validation() : action());
+            modifiers_only = modifiers_only && modifier;
+            if (!take(TokenType::TK_COMMA)) break;
+            if (partition_tail()) { fail(); break; }
+        }
+        if (actions && actions->first_child) add(root, actions);
+        if (failed_) return;
+        // Native repartition/removal follows ordinary actions without a comma.
+        if (is("PARTITION")) add(root, MySQLPartitionParser(tok_, arena_, callback_).parse());
+        else if (is("REMOVE")) {
+            auto* remove = clause(); require("REMOVE", remove); require("PARTITIONING", remove);
+            add(root, remove);
+        }
+    }
+
     AstNode* expression() {
         ExpressionParser<Dialect::MySQL> parser(tok_, arena_, true);
         if (callback_) parser.set_subquery_callback(callback_);