feat: multi-table JOIN UPDATE/DELETE distributed execution (#32)

Detect multi-table UPDATE/DELETE in DmlPlanBuilder (via FROM_CLAUSE
or USING clause presence), store original AST in plan node, and emit
full SQL from AST in distributed planner for shard routing.

Author: renecannao

include/sql_engine/distributed_planner.h

@@ -1018,6 +1018,16 @@ class DistributedPlanner {
         const TableInfo* table = up.table;
         if (!table || !shards_.has_table(table->table_name)) return plan;
 
+        // Multi-table UPDATE: emit full SQL from AST, route to primary table's backend
+        if (up.original_ast) {
+            sql_parser::StringRef sql = qb_.build_update_from_ast(up.original_ast);
+            if (!shards_.is_sharded(table->table_name)) {
+                return make_remote_scan(shards_.get_backend(table->table_name), sql, table);
+            }
+            const auto& shard_list = shards_.get_shards(table->table_name);
+            return scatter_dml_to_shards(table, shard_list, [&]() { return sql; });
+        }
+
         // Check for cross-shard subqueries in WHERE and rewrite
         const sql_parser::AstNode* where_expr = up.where_expr;
         if (where_expr && has_subquery(where_expr) && remote_executor_) {
@@ -1057,6 +1067,16 @@ class DistributedPlanner {
         const TableInfo* table = dp.table;
         if (!table || !shards_.has_table(table->table_name)) return plan;
 
+        // Multi-table DELETE: emit full SQL from AST, route to primary table's backend
+        if (dp.original_ast) {
+            sql_parser::StringRef sql = qb_.build_delete_from_ast(dp.original_ast);
+            if (!shards_.is_sharded(table->table_name)) {
+                return make_remote_scan(shards_.get_backend(table->table_name), sql, table);
+            }
+            const auto& shard_list = shards_.get_shards(table->table_name);
+            return scatter_dml_to_shards(table, shard_list, [&]() { return sql; });
+        }
+
         // Check for cross-shard subqueries in WHERE and rewrite
         const sql_parser::AstNode* where_expr = dp.where_expr;
         if (where_expr && has_subquery(where_expr) && remote_executor_) {

include/sql_engine/dml_plan_builder.h

@@ -115,6 +115,12 @@ class DmlPlanBuilder {
             node->update_plan.table = resolve_table(table_ref);
         }
 
+        // Detect multi-table UPDATE: presence of FROM_CLAUSE child means JOINs
+        const sql_parser::AstNode* from_clause = find_child(update_ast, sql_parser::NodeType::NODE_FROM_CLAUSE);
+        if (from_clause) {
+            node->update_plan.original_ast = update_ast;
+        }
+
         // Find UPDATE_SET_CLAUSE -> extract SET items
         const sql_parser::AstNode* set_clause = find_child(update_ast, sql_parser::NodeType::NODE_UPDATE_SET_CLAUSE);
         if (set_clause) {
@@ -166,6 +172,23 @@ class DmlPlanBuilder {
             node->delete_plan.table = resolve_table(table_ref);
         }
 
+        // Detect multi-table DELETE: FROM_CLAUSE (MySQL multi-table) or USING clause
+        const sql_parser::AstNode* from_clause = find_child(delete_ast, sql_parser::NodeType::NODE_FROM_CLAUSE);
+        const sql_parser::AstNode* using_clause = find_child(delete_ast, sql_parser::NodeType::NODE_DELETE_USING_CLAUSE);
+        if (using_clause) {
+            // USING always indicates multi-table
+            node->delete_plan.original_ast = delete_ast;
+        } else if (from_clause) {
+            // FROM_CLAUSE with multiple children indicates multi-table
+            uint16_t child_count = 0;
+            for (const sql_parser::AstNode* c = from_clause->first_child; c; c = c->next_sibling) {
+                ++child_count;
+            }
+            if (child_count > 1) {
+                node->delete_plan.original_ast = delete_ast;
+            }
+        }
+
         // Find WHERE_CLAUSE
         const sql_parser::AstNode* where = find_child(delete_ast, sql_parser::NodeType::NODE_WHERE_CLAUSE);
         if (where && where->first_child) {

include/sql_engine/plan_node.h

@@ -152,11 +152,13 @@ struct PlanNode {
             const sql_parser::AstNode** set_exprs;     // new value expression AST nodes (parallel array)
             uint16_t set_count;
             const sql_parser::AstNode* where_expr;     // WHERE condition (nullable = update all)
+            const sql_parser::AstNode* original_ast;   // non-null for multi-table UPDATE
         } update_plan;
 
         struct {
             const TableInfo* table;
             const sql_parser::AstNode* where_expr;     // WHERE condition (nullable = delete all)
+            const sql_parser::AstNode* original_ast;   // non-null for multi-table DELETE
         } delete_plan;
     };
 };

include/sql_engine/remote_query_builder.h

@@ -188,6 +188,18 @@ class RemoteQueryBuilder {
         return sb.finish();
     }
 
+    sql_parser::StringRef build_update_from_ast(const sql_parser::AstNode* ast) {
+        sql_parser::Emitter<D> emitter(arena_);
+        emitter.emit(ast);
+        return emitter.result();
+    }
+
+    sql_parser::StringRef build_delete_from_ast(const sql_parser::AstNode* ast) {
+        sql_parser::Emitter<D> emitter(arena_);
+        emitter.emit(ast);
+        return emitter.result();
+    }
+
 private:
     sql_parser::Arena& arena_;
 

tests/test_dml.cpp

@@ -251,3 +251,67 @@ TEST_F(DmlTest, InsertWithoutColumnList) {
     auto rs = run_select("SELECT * FROM users");
     EXPECT_EQ(rs.rows[3].get(0).int_val, 6);
 }
+
+// ---- Multi-table UPDATE/DELETE plan node tests ----
+
+// Multi-table UPDATE sets original_ast in the plan node
+TEST_F(DmlTest, MultiTableUpdateSetsOriginalAst) {
+    const char* sql = "UPDATE users u JOIN orders o ON u.id = o.user_id SET u.age = 30 WHERE o.total > 100";
+    parser.reset();
+    auto r = parser.parse(sql, std::strlen(sql));
+    ASSERT_EQ(r.status, ParseResult::OK);
+    ASSERT_NE(r.ast, nullptr);
+
+    DmlPlanBuilder<Dialect::MySQL> dml_builder(catalog, parser.arena());
+    PlanNode* plan = dml_builder.build(r.ast);
+    ASSERT_NE(plan, nullptr);
+    EXPECT_EQ(plan->type, PlanNodeType::UPDATE_PLAN);
+    EXPECT_NE(plan->update_plan.original_ast, nullptr);
+    EXPECT_EQ(plan->update_plan.original_ast, r.ast);
+}
+
+// Single-table UPDATE leaves original_ast as nullptr
+TEST_F(DmlTest, SingleTableUpdateOriginalAstNull) {
+    const char* sql = "UPDATE users SET age = 30 WHERE id = 1";
+    parser.reset();
+    auto r = parser.parse(sql, std::strlen(sql));
+    ASSERT_EQ(r.status, ParseResult::OK);
+    ASSERT_NE(r.ast, nullptr);
+
+    DmlPlanBuilder<Dialect::MySQL> dml_builder(catalog, parser.arena());
+    PlanNode* plan = dml_builder.build(r.ast);
+    ASSERT_NE(plan, nullptr);
+    EXPECT_EQ(plan->type, PlanNodeType::UPDATE_PLAN);
+    EXPECT_EQ(plan->update_plan.original_ast, nullptr);
+}
+
+// Multi-table DELETE (MySQL syntax) sets original_ast
+TEST_F(DmlTest, MultiTableDeleteSetsOriginalAst) {
+    const char* sql = "DELETE u FROM users u JOIN orders o ON u.id = o.user_id WHERE o.total > 100";
+    parser.reset();
+    auto r = parser.parse(sql, std::strlen(sql));
+    ASSERT_EQ(r.status, ParseResult::OK);
+    ASSERT_NE(r.ast, nullptr);
+
+    DmlPlanBuilder<Dialect::MySQL> dml_builder(catalog, parser.arena());
+    PlanNode* plan = dml_builder.build(r.ast);
+    ASSERT_NE(plan, nullptr);
+    EXPECT_EQ(plan->type, PlanNodeType::DELETE_PLAN);
+    EXPECT_NE(plan->delete_plan.original_ast, nullptr);
+    EXPECT_EQ(plan->delete_plan.original_ast, r.ast);
+}
+
+// Single-table DELETE leaves original_ast as nullptr
+TEST_F(DmlTest, SingleTableDeleteOriginalAstNull) {
+    const char* sql = "DELETE FROM users WHERE id = 1";
+    parser.reset();
+    auto r = parser.parse(sql, std::strlen(sql));
+    ASSERT_EQ(r.status, ParseResult::OK);
+    ASSERT_NE(r.ast, nullptr);
+
+    DmlPlanBuilder<Dialect::MySQL> dml_builder(catalog, parser.arena());
+    PlanNode* plan = dml_builder.build(r.ast);
+    ASSERT_NE(plan, nullptr);
+    EXPECT_EQ(plan->type, PlanNodeType::DELETE_PLAN);
+    EXPECT_EQ(plan->delete_plan.original_ast, nullptr);
+}