parser.c

// parser.c
#define _CRT_NONSTDC_NO_DEPRECATE
#define _CRT_SECURE_NO_WARNINGS
#include "database.h"
#include <ctype.h>

#ifdef _WIN32
    // Windows 下没有 strcasecmp 和 strncasecmp
    // 需要映射到微软特有的 _stricmp 和 _strnicmp
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#endif

// 局部命令常量（parser 层使用）
#ifndef CMD_ALTER
#define CMD_ALTER 14
#endif
#define ALTER_ADD    1
#define ALTER_DROP   2
#define ALTER_RENAME 3

// ==================== 辅助工具函数 ====================

// 1. 去掉前后空格
static char* trim(char* s) {
    if (!s) return NULL;
    while (*s && isspace((unsigned char)*s)) s++; // 跳过前导空格
    if (*s == 0) return s;

    char* end = s + strlen(s) - 1;
    while (end > s && isspace((unsigned char)*end)) end--; // 跳过尾部空格
    *(end + 1) = '\0';
    return s;
}

// 去除尾部逗号和分号等标点
static void strip_trailing_punct(char* s) {
    if (!s) return;
    int len = (int)strlen(s);
    while (len > 0) {
        char c = s[len - 1];
        if (c == ',' || c == ';' || isspace((unsigned char)c)) {
            s[len - 1] = '\0';
            len--;
            continue;
        }
        break;
    }
}

// 2. 提取第一个 Token 并强制转为大写 (用于判断命令类型)
static void get_first_token(const char* input, char* token) {
    if (!input || !token) return;

    // 跳过开头的空格
    while (*input && isspace((unsigned char)*input)) input++;

    int i = 0;
    // 读取直到遇到空格或结束符
    while (*input && !isspace((unsigned char)*input)) {
        // 强制转大写，方便后续 switch/if 判断
        token[i++] = toupper((unsigned char)*input++);
        if (i >= 31) break; // 防止溢出
    }
    token[i] = '\0';
}

// 3. 不区分大小写的字符串查找 (核心函数: 替代 strstr)
// 在 haystack 中查找 needle，忽略大小写
char* stristr(const char* haystack, const char* needle) {
    if (!haystack || !needle) return NULL;
    if (!*needle) return (char*)haystack;

    for (; *haystack; ++haystack) {
        // 如果首字母匹配（忽略大小写）
        if (toupper((unsigned char)*haystack) == toupper((unsigned char)*needle)) {
            const char* h = haystack;
            const char* n = needle;

            // 继续比对后续字符
            while (*h && *n && toupper((unsigned char)*h) == toupper((unsigned char)*n)) {
                h++;
                n++;
            }
            // 如果 needle 走完了，说明匹配成功
            if (!*n) return (char*)haystack;
        }
    }
    return NULL;
}

// 辅助：从给定位置解析一个路径（去除引号与尾部分号/空白），拷贝到 outBuf
static void parse_path_token(const char* pstart, char* outBuf, int maxLen) {
    if (!pstart || !outBuf) return;
    // 跳过空格
    while (*pstart && isspace((unsigned char)*pstart)) pstart++;

    // 拷贝直到末尾或分号
    int i = 0;
    // 如果以引号开始，则匹配对应引号
    if (*pstart == '\'' || *pstart == '\"') {
        char q = *pstart++;
        while (*pstart && *pstart != q && i < maxLen - 1) {
            outBuf[i++] = *pstart++;
        }
        outBuf[i] = '\0';
        return;
    }

    while (*pstart && *pstart != ';' && !isspace((unsigned char)*pstart) && i < maxLen - 1) {
        outBuf[i++] = *pstart++;
    }
    outBuf[i] = '\0';
    strip_trailing_punct(outBuf);
}

// ==================== 主解析入口 ====================

SqlCommand* sql_parser_main(const char* input) {
    if (!input) return NULL;

    SqlCommand* cmd = (SqlCommand*)malloc(sizeof(SqlCommand));
    memset(cmd, 0, sizeof(SqlCommand));

    char token[32];
    get_first_token(input, token); // 这里获取到的已经是大写，如 "SELECT"

    if (strcmp(token, "CREATE") == 0) {
        cmd->commandType = 1;
        parse_create_statement(input, cmd);
    }
    else if (strcmp(token, "INSERT") == 0) {
        cmd->commandType = 2;
        parse_insert_statement(input, cmd);
    }
    else if (strcmp(token, "SELECT") == 0) {
        cmd->commandType = 3;
        parse_select_statement(input, cmd);
    }
    else if (strcmp(token, "DROP") == 0) {
        cmd->commandType = 4;
        parse_drop_statement(input, cmd);
    }
    else if (strcmp(token, "UPDATE") == 0) {
        cmd->commandType = 5;
        parse_update_statement(input, cmd);
    }
    else if (strcmp(token, "DELETE") == 0) {
        cmd->commandType = 6;
        parse_delete_statement(input, cmd);
    }
    else if (strcmp(token, "ALTER") == 0) {
        cmd->commandType = CMD_ALTER;
        parse_alter_statement(input, cmd);
    }
    else if (strcmp(token, "BACKUP") == 0) {
        cmd->commandType = CMD_BACKUP;
        parse_backup_statement(input, cmd);
    }
    else if (strcmp(token, "RESTORE") == 0) {
        cmd->commandType = CMD_RESTORE;
        parse_restore_statement(input, cmd);
    }
    else {
        // 不支持的命令
        free(cmd);
        return NULL;
    }

    return cmd;
}

// ==================== 各语句解析实现 ====================

// 解析: CREATE TABLE User (id int PRIMARY KEY, name char(20))
void parse_create_statement(const char* sql, SqlCommand* cmd) {
    TableMeta* meta = &cmd->stmtData.createStmt.tableMeta;

    // 1. 查找 "TABLE" 关键字 (忽略大小写)
    char* tableKeyword = stristr(sql, "TABLE");
    if (!tableKeyword) return;

    // 跳过 "TABLE"
    const char* p = tableKeyword + 5;
    while (*p && isspace((unsigned char)*p)) p++;

    // 2. 读取表名 (直到遇到空格或括号)
    int nameLen = 0;
    while (p[nameLen] && !isspace((unsigned char)p[nameLen]) && p[nameLen] != '(') {
        meta->sTableName[nameLen] = p[nameLen];
        nameLen++;
        if (nameLen >= TABLE_NAME_LEN - 1) break;
    }
    meta->sTableName[nameLen] = '\0';

    // 3. 提取括号内容 (...)
    const char* l = strchr(sql, '(');
    const char* r = strrchr(sql, ')');
    if (!l || !r || l > r) return;

    char content[1024]; // 假设字段定义不超过1024
    int contentLen = (int)(r - l - 1);
    if (contentLen >= 1024) contentLen = 1023;

    strncpy(content, l + 1, contentLen);
    content[contentLen] = '\0';

    // 4. 分割字段定义
    char* fieldToken = strtok(content, ",");
    while (fieldToken) {
        if (meta->iFieldCount >= MAX_FIELDS) break;

        TableMode* f = &meta->fields[meta->iFieldCount];

        // 解析格式: "id int PRIMARY KEY" 或 "name char(20)"
        // 这里需要更健壮的解析，因为 strtok 破坏了原字符串，我们用 sscanf 尝试解析

        char fieldName[32] = { 0 };
        char fieldTypeFull[64] = { 0 };

        // 简单提取前两个单词：字段名 和 类型
        // 这里的 fieldToken 类似于 " id int PRIMARY KEY "
        sscanf(fieldToken, "%s %s", fieldName, fieldTypeFull);

        if (strlen(fieldName) > 0 && strlen(fieldTypeFull) > 0) {
            strncpy(f->sFieldName, fieldName, FIELD_NAME_LEN - 1);

            // --- 识别类型 (忽略大小写) ---
            if (strncasecmp(fieldTypeFull, "int", 3) == 0) {
                strcpy(f->sType, "int");
                f->iSize = sizeof(int);
            }
            else if (strncasecmp(fieldTypeFull, "float", 5) == 0) {
                strcpy(f->sType, "float");
                f->iSize = sizeof(float);
            }
            else if (strncasecmp(fieldTypeFull, "char", 4) == 0) {
                strcpy(f->sType, "char");
                // 解析 char(20)
                char* bracket = strchr(fieldTypeFull, '(');
                if (bracket) {
                    f->iSize = atoi(bracket + 1);
                }
                else {
                    f->iSize = 20; // 默认长度
                }
            }
            else {
                // 默认为 char(20) 以防万一
                strcpy(f->sType, "char");
                f->iSize = 20;
            }

            // --- 识别 PRIMARY KEY (忽略大小写) ---
            if (stristr(fieldToken, "PRIMARY KEY")) {
                f->bKey = 1;
                f->bNullFlag = 0; // 主键不能为空
            }
            else {
                f->bKey = 0;
                f->bNullFlag = 1;
            }

            f->bValidFlag = 1;
            meta->iFieldCount++;
        }

        fieldToken = strtok(NULL, ",");
    }
}

// ==================== 新增: ALTER 语句解析 ====================
// 支持:
//   ALTER TABLE t ADD COLUMN col TYPE [NULL|NOT NULL]
//   ALTER TABLE t DROP COLUMN col
//   ALTER TABLE t RENAME COLUMN old TO new
void parse_alter_statement(const char* sql, SqlCommand* cmd) {
    if (!sql || !cmd) return;

    // 初始化
    memset(&cmd->stmtData.alterStmt, 0, sizeof(cmd->stmtData.alterStmt));
    cmd->stmtData.alterStmt.newSize = 0;
    cmd->stmtData.alterStmt.newNullFlag = 1; // 默认为允许 NULL

    // 找到 TABLE
    char* tablePtr = stristr(sql, "TABLE");
    if (!tablePtr) return;

    const char* p = tablePtr + 5;
    while (*p && isspace((unsigned char)*p)) p++;

    // 读取表名
    int i = 0;
    while (p[i] && !isspace((unsigned char)p[i]) && p[i] != '(' && p[i] != '\0') {
        cmd->stmtData.alterStmt.tableName[i] = p[i];
        i++;
        if (i >= TABLE_NAME_LEN - 1) break;
    }
    cmd->stmtData.alterStmt.tableName[i] = '\0';

    // 判断子句类型
    // RENAME COLUMN
    char* renamePtr = stristr(sql, "RENAME COLUMN");
    if (renamePtr) {
        cmd->stmtData.alterStmt.alterType = ALTER_RENAME;

        // 跳过 "RENAME COLUMN"
        const char* q = renamePtr + strlen("RENAME COLUMN");
        while (*q && isspace((unsigned char)*q)) q++;

        // 读取旧列名
        char oldName[FIELD_NAME_LEN] = {0};
        int oi = 0;
        while (*q && !isspace((unsigned char)*q) && *q != '\0' && *q != ';') {
            oldName[oi++] = *q++;
            if (oi >= FIELD_NAME_LEN - 1) break;
        }
        oldName[oi] = '\0';
        strip_trailing_punct(oldName);
        strncpy(cmd->stmtData.alterStmt.columnName, oldName, FIELD_NAME_LEN - 1);

        // 查找 "TO"
        char* toPtr = stristr(q, "TO");
        if (toPtr) {
            const char* r = toPtr + 2;
            while (*r && isspace((unsigned char)*r)) r++;
            char newName[FIELD_NAME_LEN] = {0};
            int ni = 0;
            while (*r && !isspace((unsigned char)*r) && *r != ';' && *r != '\0') {
                newName[ni++] = *r++;
                if (ni >= FIELD_NAME_LEN - 1) break;
            }
            newName[ni] = '\0';
            strip_trailing_punct(newName);
            strncpy(cmd->stmtData.alterStmt.newColumnName, newName, FIELD_NAME_LEN - 1);
        }

        return;
    }

    // DROP COLUMN
    char* dropPtr = stristr(sql, "DROP COLUMN");
    if (dropPtr) {
        cmd->stmtData.alterStmt.alterType = ALTER_DROP;

        const char* q = dropPtr + strlen("DROP COLUMN");
        while (*q && isspace((unsigned char)*q)) q++;

        char colName[FIELD_NAME_LEN] = {0};
        int ci = 0;
        while (*q && !isspace((unsigned char)*q) && *q != ';' && *q != '\0') {
            colName[ci++] = *q++;
            if (ci >= FIELD_NAME_LEN - 1) break;
        }
        colName[ci] = '\0';
        strip_trailing_punct(colName);
        strncpy(cmd->stmtData.alterStmt.columnName, colName, FIELD_NAME_LEN - 1);
        return;
    }

    // ADD COLUMN
    char* addPtr = stristr(sql, "ADD COLUMN");
    if (addPtr) {
        cmd->stmtData.alterStmt.alterType = ALTER_ADD;

        const char* q = addPtr + strlen("ADD COLUMN");
        while (*q && isspace((unsigned char)*q)) q++;

        // 读取列名
        char colName[FIELD_NAME_LEN] = {0};
        int ci = 0;
        while (*q && !isspace((unsigned char)*q) && *q != '\0' && *q != ',' && *q != ';') {
            colName[ci++] = *q++;
            if (ci >= FIELD_NAME_LEN - 1) break;
        }
        colName[ci] = '\0';
        strip_trailing_punct(colName);
        strncpy(cmd->stmtData.alterStmt.columnName, colName, FIELD_NAME_LEN - 1);

        // 跳过空格
        while (*q && isspace((unsigned char)*q)) q++;

        // 读取类型 token（例如 int, float, char(20)）
        char typeToken[64] = {0};
        int ti = 0;
        while (*q && !isspace((unsigned char)*q) && *q != '\0' && *q != ',' && *q != ';') {
            typeToken[ti++] = *q++;
            if (ti >= (int)sizeof(typeToken)-1) break;
        }
        typeToken[ti] = '\0';
        strip_trailing_punct(typeToken);

        // 解析类型和大小
        if (strncasecmp(typeToken, "int", 3) == 0) {
            strncpy(cmd->stmtData.alterStmt.newType, "int", sizeof(cmd->stmtData.alterStmt.newType)-1);
            cmd->stmtData.alterStmt.newSize = sizeof(int);
        } else if (strncasecmp(typeToken, "float", 5) == 0) {
            strncpy(cmd->stmtData.alterStmt.newType, "float", sizeof(cmd->stmtData.alterStmt.newType)-1);
            cmd->stmtData.alterStmt.newSize = sizeof(float);
        } else if (strncasecmp(typeToken, "char", 4) == 0) {
            strncpy(cmd->stmtData.alterStmt.newType, "char", sizeof(cmd->stmtData.alterStmt.newType)-1);
            // 解析 char(n)
            char* b = strchr(typeToken, '(');
            if (b) {
                int n = atoi(b + 1);
                if (n <= 0) n = 20;
                cmd->stmtData.alterStmt.newSize = n;
            } else {
                cmd->stmtData.alterStmt.newSize = 20;
            }
        } else {
            // 默认当做 char
            strncpy(cmd->stmtData.alterStmt.newType, "char", sizeof(cmd->stmtData.alterStmt.newType)-1);
            cmd->stmtData.alterStmt.newSize = 20;
        }

        // 检查 NULL / NOT NULL
        if (stristr(q, "NOT NULL")) {
            cmd->stmtData.alterStmt.newNullFlag = 0;
        } else if (stristr(q, "NULL")) {
            cmd->stmtData.alterStmt.newNullFlag = 1;
        } else {
            // 默认为允许 NULL
            cmd->stmtData.alterStmt.newNullFlag = 1;
        }

        return;
    }

    // 如果都没有匹配，leave alterType = 0 表示解析失败或不支持
    cmd->stmtData.alterStmt.alterType = 0;
}

// 辅助：分割括号内的逗号分隔值 (例如 "1, 'abc', 20")
// 返回分配的字符串数组，outCount 存储数量
static char** parse_value_list(char* content, int* outCount) {
    // 预估最大字段数，分配内存
    char** list = (char**)malloc(sizeof(char*) * MAX_FIELDS);
    int count = 0;

    char* token = strtok(content, ",");
    while (token) {
        char* val = trim(token); // 使用你原有的 trim 函数
        // 去除可能的引号
        if (val[0] == '\'' || val[0] == '\"') {
            val++;
            if (strlen(val) > 0) val[strlen(val) - 1] = '\0';
        }
        list[count++] = strdup(val);
        token = strtok(NULL, ",");
    }
    *outCount = count;
    return list;
}

void parse_insert_statement(const char* sql, SqlCommand* cmd) {
    // 初始化
    cmd->stmtData.insertStmt.targetColumns = NULL;
    cmd->stmtData.insertStmt.targetColCount = 0;
    cmd->stmtData.insertStmt.rows = NULL;
    cmd->stmtData.insertStmt.rowValueCounts = NULL;
    cmd->stmtData.insertStmt.rowCount = 0;

    // 1. 查找 "INTO"
    char* intoPtr = stristr(sql, "INTO");
    if (!intoPtr) return;

    // 指针移到 INTO 之后
    char* p = intoPtr + 4;
    while (*p && isspace((unsigned char)*p)) p++;

    // 2. 解析表名
    int i = 0;
    while (p[i] && !isspace((unsigned char)p[i]) && p[i] != '(') {
        cmd->stmtData.insertStmt.tableName[i] = p[i];
        i++;
        if (i >= TABLE_NAME_LEN - 1) break;
    }
    cmd->stmtData.insertStmt.tableName[i] = '\0';
    p += i;

    // 3. 检查是否有指定列 (column1, column2)
    // 此时 p 可能指向空格，或者 '('，或者 " VALUES"
    char* valuesKeyword = stristr(p, "VALUES");
    if (!valuesKeyword) return; // 必须有 VALUES

    // 检查表名和 VALUES 之间是否有括号
    char* firstParen = strchr(p, '(');

    if (firstParen && firstParen < valuesKeyword) {
        // 确实指定了列
        char* closeParen = strchr(firstParen, ')');
        if (closeParen && closeParen < valuesKeyword) {
            // 提取括号内容
            int len = (int)(closeParen - firstParen - 1);
            char colBuf[1024];
            strncpy(colBuf, firstParen + 1, len);
            colBuf[len] = '\0';

            // 解析列名
            cmd->stmtData.insertStmt.targetColumns = parse_value_list(colBuf, &cmd->stmtData.insertStmt.targetColCount);
        }
    }

    // 4. 解析 VALUES 后的多行数据
    // VALUES (1,2), (3,4), ...
    char* curr = valuesKeyword + 6; // 跳过 "VALUES"

    // 预分配行数组 (假设最多100行，实际应动态扩容)
    cmd->stmtData.insertStmt.rows = (char***)malloc(sizeof(char**) * 100);
    cmd->stmtData.insertStmt.rowValueCounts = (int*)malloc(sizeof(int) * 100);

    while (1) {
        char* rowStart = strchr(curr, '(');
        if (!rowStart) break;
        char* rowEnd = strchr(rowStart, ')');
        if (!rowEnd) break;

        // 提取单行内容
        int len = (int)(rowEnd - rowStart - 1);
        char rowBuf[1024];
        if (len >= 1024) len = 1023;
        strncpy(rowBuf, rowStart + 1, len);
        rowBuf[len] = '\0';

        // 解析该行的值
        int valCount = 0;
        char** vals = parse_value_list(rowBuf, &valCount);

        int rIdx = cmd->stmtData.insertStmt.rowCount;
        cmd->stmtData.insertStmt.rows[rIdx] = vals;
        cmd->stmtData.insertStmt.rowValueCounts[rIdx] = valCount;
        cmd->stmtData.insertStmt.rowCount++;

        // 移动指针继续找下一个
        curr = rowEnd + 1;
        // 如果后面是逗号，继续；如果是分号或结束，退出
        while (*curr && isspace((unsigned char)*curr)) curr++;
        if (*curr == ',') curr++;
        else break;
    }
}

// 解析: SELECT * FROM User, Order WHERE ...
void parse_select_statement(const char* sql, SqlCommand* cmd) {
    // 初始化
    cmd->stmtData.selectStmt.selectColumns = NULL;
    cmd->stmtData.selectStmt.columnCount = 0;
    cmd->stmtData.selectStmt.tableCount = 0;
    cmd->stmtData.selectStmt.whereCondition = NULL;

    // 1. 查找 FROM
    char* fromPtr = stristr(sql, "FROM");
    if (!fromPtr) return;

    // 2. 解析 SELECT ... FROM 之间的列
    char* selectPtr = stristr(sql, "SELECT");
    if (selectPtr && selectPtr < fromPtr) {
        char* start = selectPtr + 6;
        int len = (int)(fromPtr - start);
        if (len > 0) {
            char* colStr = (char*)malloc(len + 1);
            strncpy(colStr, start, len);
            colStr[len] = '\0';
            char* trimmed = trim(colStr);
            if (strcmp(trimmed, "*") != 0) {
                cmd->stmtData.selectStmt.selectColumns = (char**)malloc(sizeof(char*) * MAX_FIELDS);
                char* token = strtok(colStr, ",");
                while (token) {
                    cmd->stmtData.selectStmt.selectColumns[cmd->stmtData.selectStmt.columnCount++] = strdup(trim(token));
                    token = strtok(NULL, ",");
                }
            }
            free(colStr);
        }
    }

    // 3. 解析表名列表 (FROM aab a, aaa b)
    char* wherePtr = stristr(sql, "WHERE");
    char* endOfTableStr = wherePtr ? wherePtr : (char*)(sql + strlen(sql));

    int tLen = (int)(endOfTableStr - (fromPtr + 4));
    if (tLen > 0) {
        char* tableStr = (char*)malloc(tLen + 1);
        strncpy(tableStr, fromPtr + 4, tLen);
        tableStr[tLen] = '\0';

        // 按逗号分割
        char* token = strtok(tableStr, ",");
        while (token && cmd->stmtData.selectStmt.tableCount < MAX_TABLES_IN_JOIN) {
            char* chunk = trim(token); // chunk 可能是 "aab" 或 "aab a"

            char tName[TABLE_NAME_LEN] = { 0 };
            char tAlias[TABLE_NAME_LEN] = { 0 };

            // 尝试分割表名和别名
            // sscanf 返回成功匹配的参数个数
            int match = sscanf(chunk, "%s %s", tName, tAlias);

            if (match == 2) {
                // 有别名: "aab a"
                strcpy(cmd->stmtData.selectStmt.fromTables[cmd->stmtData.selectStmt.tableCount], tName);
                strcpy(cmd->stmtData.selectStmt.tableAliases[cmd->stmtData.selectStmt.tableCount], tAlias);
            }
            else {
                // 无别名: "aab" -> 别名默认为表名
                strcpy(cmd->stmtData.selectStmt.fromTables[cmd->stmtData.selectStmt.tableCount], tName);
                strcpy(cmd->stmtData.selectStmt.tableAliases[cmd->stmtData.selectStmt.tableCount], tName);
            }

            cmd->stmtData.selectStmt.tableCount++;
            token = strtok(NULL, ",");
        }
        free(tableStr);
    }

    // 4. 提取 WHERE
    if (wherePtr) {
        cmd->stmtData.selectStmt.whereCondition = strdup(trim(wherePtr + 5));
    }
}

// 解析: DELETE FROM User WHERE id=1
void parse_delete_statement(const char* sql, SqlCommand* cmd) {
    // 1. 查找 FROM
    char* fromPtr = stristr(sql, "FROM");
    if (!fromPtr) {
        // 有些写成 DELETE User WHERE...
        fromPtr = stristr(sql, "DELETE");
        if (fromPtr) fromPtr += 6;
    }
    else {
        fromPtr += 4;
    }

    if (!fromPtr) return;

    const char* p = fromPtr;
    while (*p && isspace((unsigned char)*p)) p++;

    int i = 0;
    while (p[i] && !isspace((unsigned char)p[i])) {
        cmd->stmtData.deleteStmt.tableName[i] = p[i];
        i++;
        if (i >= TABLE_NAME_LEN - 1) break;
    }
    cmd->stmtData.deleteStmt.tableName[i] = '\0';

    // 2. 提取 WHERE
    char* wherePtr = stristr(sql, "WHERE");
    if (wherePtr) {
        cmd->stmtData.deleteStmt.whereCondition = strdup(trim(wherePtr + 5));
    }
}

// 解析: DROP TABLE User
void parse_drop_statement(const char* sql, SqlCommand* cmd) {
    // 查找 TABLE
    char* tablePtr = stristr(sql, "TABLE");
    if (!tablePtr) return;

    const char* p = tablePtr + 5;
    while (*p && isspace((unsigned char)*p)) p++;

    sscanf(p, "%s", cmd->stmtData.dropStmt.tableName);
}

// 解析: UPDATE User SET age=30, name='Bob' WHERE id=1
void parse_update_statement(const char* sql, SqlCommand* cmd) {
    // 1. 初始化
    cmd->stmtData.updateStmt.setColumns = NULL;
    cmd->stmtData.updateStmt.setValues = NULL;
    cmd->stmtData.updateStmt.setCount = 0;
    cmd->stmtData.updateStmt.whereCondition = NULL;

    // 2. 解析表名 (UPDATE table SET ...)
    char* updatePtr = stristr(sql, "UPDATE");
    if (!updatePtr) return;

    char* setPtr = stristr(sql, " SET ");
    if (!setPtr) return;

    // 提取表名
    char* p = updatePtr + 6;
    while (*p && isspace((unsigned char)*p)) p++;

    int i = 0;
    while (p < setPtr && !isspace((unsigned char)*p)) {
        cmd->stmtData.updateStmt.tableName[i++] = *p++;
        if (i >= TABLE_NAME_LEN - 1) break;
    }
    cmd->stmtData.updateStmt.tableName[i] = '\0';

    // 3. 提取 WHERE 子句 (如果有)
    char* wherePtr = stristr(setPtr, " WHERE ");
    if (wherePtr) {
        cmd->stmtData.updateStmt.whereCondition = strdup(trim(wherePtr + 7));
    }

    // 4. 解析 SET 子句 (位于 SET 和 WHERE 之间)
    // 计算 SET 内容的长度
    char* startSet = setPtr + 5; // 跳过 " SET "
    char* endSet = wherePtr ? wherePtr : (char*)(sql + strlen(sql));

    int len = (int)(endSet - startSet);
    if (len <= 0) return;

    char* setContent = (char*)malloc(len + 1);
    strncpy(setContent, startSet, len);
    setContent[len] = '\0';

    // 预分配内存
    cmd->stmtData.updateStmt.setColumns = (char**)malloc(sizeof(char*) * MAX_FIELDS);
    cmd->stmtData.updateStmt.setValues = (char**)malloc(sizeof(char*) * MAX_FIELDS);

    // 按逗号分割 "age=30, name='Bob'"
    char* pair = strtok(setContent, ",");
    while (pair) {
        char* eq = strchr(pair, '=');
        if (eq) {
            *eq = '\0'; // 将 = 替换为结束符，分割 key 和 value
            char* col = trim(pair);
            char* val = trim(eq + 1);

            // 去除值的引号
            if (val[0] == '\'' || val[0] == '\"') {
                val++;
                if (strlen(val) > 0) val[strlen(val) - 1] = '\0';
            }

            cmd->stmtData.updateStmt.setColumns[cmd->stmtData.updateStmt.setCount] = strdup(col);
            cmd->stmtData.updateStmt.setValues[cmd->stmtData.updateStmt.setCount] = strdup(val);
            cmd->stmtData.updateStmt.setCount++;
        }
        pair = strtok(NULL, ",");
    }

    free(setContent);
}

// 新增: 解析 BACKUP TO 'dir'，简单支持不带引号或单/双引号包裹
void parse_backup_statement(const char* sql, SqlCommand* cmd) {
    if (!sql || !cmd) return;
    memset(&cmd->stmtData.backupStmt, 0, sizeof(cmd->stmtData.backupStmt));

    // 查找 "TO"
    char* toPtr = stristr(sql, " TO ");
    if (!toPtr) {
        // 也允许 "BACKUP 'dir'"
        const char* p = sql + strlen("BACKUP");
        parse_path_token(p, cmd->stmtData.backupStmt.dir, (int)sizeof(cmd->stmtData.backupStmt.dir));
        return;
    }

    const char* pathStart = toPtr + 4;
    parse_path_token(pathStart, cmd->stmtData.backupStmt.dir, (int)sizeof(cmd->stmtData.backupStmt.dir));
}

// 新增: 解析 RESTORE FROM 'dir'
void parse_restore_statement(const char* sql, SqlCommand* cmd) {
    if (!sql || !cmd) return;
    memset(&cmd->stmtData.backupStmt, 0, sizeof(cmd->stmtData.backupStmt));

    // 查找 "FROM"
    char* fromPtr = stristr(sql, " FROM ");
    if (!fromPtr) {
        // 也允许 "RESTORE 'dir'"
        const char* p = sql + strlen("RESTORE");
        parse_path_token(p, cmd->stmtData.backupStmt.dir, (int)sizeof(cmd->stmtData.backupStmt.dir));
        return;
    }

    const char* pathStart = fromPtr + 6;
    parse_path_token(pathStart, cmd->stmtData.backupStmt.dir, (int)sizeof(cmd->stmtData.backupStmt.dir));
}

// ==================== 其余解析函数继续沿用原实现 ====================