Integrate UPDATE deep parser with emitter and classifier

Add emit_update_stmt and emit_update_set_clause to emitter. Replace
extract_update() Tier 2 extractor with parse_update() Tier 1 parser
in classifier dispatch. Handles MySQL multi-table emission without
FROM keyword and PostgreSQL FROM clause with keyword.

Author: renecannao

include/sql_parser/emitter.h

@@ -68,6 +68,10 @@ class Emitter {
             case NodeType::NODE_STMT_OPTIONS:    emit_stmt_options(node); break;
             case NodeType::NODE_UPDATE_SET_ITEM: emit_update_set_item(node); break;
 
+            // ---- UPDATE statement ----
+            case NodeType::NODE_UPDATE_STMT:     emit_update_stmt(node); break;
+            case NodeType::NODE_UPDATE_SET_CLAUSE: emit_update_set_clause(node); break;
+
             // ---- Table references ----
             case NodeType::NODE_TABLE_REF:       emit_table_ref(node); break;
             case NodeType::NODE_ALIAS:           emit_alias(node); break;
@@ -585,6 +589,91 @@ class Emitter {
         }
     }
 
+    // ---- UPDATE ----
+
+    void emit_update_stmt(const AstNode* node) {
+        sb_.append("UPDATE");
+
+        for (const AstNode* child = node->first_child; child; child = child->next_sibling) {
+            switch (child->type) {
+                case NodeType::NODE_STMT_OPTIONS:
+                    sb_.append_char(' ');
+                    emit_node(child);
+                    break;
+                case NodeType::NODE_TABLE_REF:
+                    sb_.append_char(' ');
+                    emit_node(child);
+                    break;
+                case NodeType::NODE_FROM_CLAUSE:
+                    {
+                        // Check if FROM_CLAUSE is before SET_CLAUSE (MySQL multi-table)
+                        // or after (PostgreSQL FROM)
+                        bool is_before_set = false;
+                        for (const AstNode* s = child->next_sibling; s; s = s->next_sibling) {
+                            if (s->type == NodeType::NODE_UPDATE_SET_CLAUSE) {
+                                is_before_set = true;
+                                break;
+                            }
+                        }
+                        if (is_before_set) {
+                            // MySQL multi-table: emit table refs without FROM keyword
+                            sb_.append_char(' ');
+                            bool first = true;
+                            for (const AstNode* c = child->first_child; c; c = c->next_sibling) {
+                                if (c->type == NodeType::NODE_JOIN_CLAUSE) {
+                                    sb_.append_char(' ');
+                                    emit_node(c);
+                                } else {
+                                    if (!first) sb_.append(", ");
+                                    first = false;
+                                    emit_node(c);
+                                }
+                            }
+                        } else {
+                            // PostgreSQL FROM clause (emit_from_clause adds " FROM " prefix)
+                            emit_node(child);
+                        }
+                    }
+                    break;
+                case NodeType::NODE_UPDATE_SET_CLAUSE:
+                    sb_.append(" SET ");
+                    emit_update_set_clause_inner(child);
+                    break;
+                case NodeType::NODE_WHERE_CLAUSE:
+                    emit_node(child);
+                    break;
+                case NodeType::NODE_ORDER_BY_CLAUSE:
+                    emit_node(child);
+                    break;
+                case NodeType::NODE_LIMIT_CLAUSE:
+                    emit_node(child);
+                    break;
+                case NodeType::NODE_RETURNING_CLAUSE:
+                    sb_.append_char(' ');
+                    emit_node(child);
+                    break;
+                default:
+                    sb_.append_char(' ');
+                    emit_node(child);
+                    break;
+            }
+        }
+    }
+
+    void emit_update_set_clause(const AstNode* node) {
+        sb_.append("SET ");
+        emit_update_set_clause_inner(node);
+    }
+
+    void emit_update_set_clause_inner(const AstNode* node) {
+        bool first = true;
+        for (const AstNode* child = node->first_child; child; child = child->next_sibling) {
+            if (!first) sb_.append(", ");
+            first = false;
+            emit_node(child);
+        }
+    }
+
     // ---- Expressions ----
 
     void emit_binary_op(const AstNode* node) {

include/sql_parser/parser.h

@@ -54,6 +54,7 @@ class Parser {
     ParseResult parse_select();
     ParseResult parse_set();
     ParseResult parse_insert(bool is_replace = false);
+    ParseResult parse_update();
 
     // Tier 2 extractors
     ParseResult extract_insert(const Token& first);

src/sql_parser/parser.cpp

@@ -3,6 +3,7 @@
 #include "sql_parser/set_parser.h"
 #include "sql_parser/select_parser.h"
 #include "sql_parser/insert_parser.h"
+#include "sql_parser/update_parser.h"
 
 namespace sql_parser {
 
@@ -38,7 +39,7 @@ ParseResult Parser<D>::classify_and_dispatch() {
         case TokenType::TK_SELECT:   return parse_select();
         case TokenType::TK_SET:      return parse_set();
         case TokenType::TK_INSERT:   return parse_insert(false);
-        case TokenType::TK_UPDATE:   return extract_update(first);
+        case TokenType::TK_UPDATE:   return parse_update();
         case TokenType::TK_DELETE:   return extract_delete(first);
         case TokenType::TK_REPLACE:  return parse_insert(true);
         case TokenType::TK_BEGIN:
@@ -141,6 +142,41 @@ ParseResult Parser<D>::parse_insert(bool is_replace) {
     return r;
 }
 
+template <Dialect D>
+ParseResult Parser<D>::parse_update() {
+    ParseResult r;
+    r.stmt_type = StmtType::UPDATE;
+
+    UpdateParser<D> update_parser(tokenizer_, arena_);
+    AstNode* ast = update_parser.parse();
+
+    if (ast) {
+        r.status = ParseResult::OK;
+        r.ast = ast;
+
+        // Extract table_name/schema_name from AST for backward compatibility
+        for (const AstNode* child = ast->first_child; child; child = child->next_sibling) {
+            if (child->type == NodeType::NODE_TABLE_REF) {
+                const AstNode* name_node = child->first_child;
+                if (name_node && name_node->type == NodeType::NODE_QUALIFIED_NAME) {
+                    const AstNode* schema = name_node->first_child;
+                    const AstNode* table = schema ? schema->next_sibling : nullptr;
+                    if (schema) r.schema_name = schema->value();
+                    if (table) r.table_name = table->value();
+                } else if (name_node && name_node->type == NodeType::NODE_IDENTIFIER) {
+                    r.table_name = name_node->value();
+                }
+                break;
+            }
+        }
+    } else {
+        r.status = ParseResult::PARTIAL;
+    }
+
+    scan_to_end(r);
+    return r;
+}
+
 // ---- Helpers ----
 
 template <Dialect D>