#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mysql/mysql.h> // MySQL C API 头文件

// 数据库连接参数宏定义，方便后续修改
#define DB_HOST "localhost"    // 数据库地址，localhost表示本机
#define DB_USER "local_minbit" // 数据库用户名
#define DB_PASS "123456"       // 数据库密码
#define DB_NAME "local-C-test" // 数据库名称


// 错误处理封装函数，当发生数据库错误时，打印错误信息并安全退出
void finish_with_error(MYSQL *con)
{
    // mysql_error(con): 返回最近一次调用MySQL函数失败的错误描述字符串
    fprintf(stderr, "%s\n", mysql_error(con));

    // mysql_close(con): 关闭数据库连接，释放由con指向的结构体
    // 注意：即使连接中间出错了，也需要调用此函数防止内存泄漏
    mysql_close(con);
    exit(1);
}

int main()
{
    // 1. 初始化 MySQL 对象
    // mysql_init(NULL): 初始化一个MYSQL结构体，分配并初始化内存
    // 参数：NULL表示由库自动分配内存
    // 返回值：成功返回新分配的句柄指针，失败返回NULL
    MYSQL *con = mysql_init(NULL);
    if (con == NULL)
    {
        fprintf(stderr, "mysql_init() failed\n");
        exit(1);
    }

    // 2. 连接数据库
    // mysql_real_connect(): 建立与MySQL服务器的物理连接
    // 参数说明：mysql_init返回的句柄, 主机名或IP地址, 用户名, 密码, 数据库名, 端口(0表示默认), socket文件名, 客户端标志
    // 注意：要连接的数据库名如果为NULL，连接后需手动选择库；端口号：0表示使用默认端口3306；
    // Unix Socket文件名或命名管道名，通常设为NULL让系统自动选择；客户端标志位通常设为0
    // 返回值：成功返回con指针，失败返回NULL
    if (mysql_real_connect(con, DB_HOST, DB_USER, DB_PASS, DB_NAME, 0, NULL, 0) == NULL)
    {
        finish_with_error(con);
    }

    // 3. 执行插入操作
    // mysql_query(): 执行由字符串表示的SQL语句
    // 参数：连接句柄，SQL语句字符串
    // 返回值：成功返回0，失败返回非0
    // 注意：该函数会自动检测语句是否需要分号结尾(通常不需要)
    if (mysql_query(con, "INSERT INTO student_score (name, subject, score) VALUES ('张三', '数学', 88.5), ('李四', '英语', 92.0)"))
    {
        finish_with_error(con);
    }

    // mysql_affected_rows(): 获取最近一次INSERT/UPDATE/DELETE操作影响的行数
    // 返回值：my_ulonglong类型（64位无符号整数），如果没有匹配行则返回0
    printf("插入成功，影响行数: %lu\n", (unsigned long)mysql_affected_rows(con));


    // 4. 查询操作
    if (mysql_query(con, "SELECT id, name, subject, score FROM student_score"))
    {
        finish_with_error(con);
    }

    // mysql_store_result(): 将查询的结果从服务器一次性取回到客户端，结果存储在内存中，必须在使用完后手动释放！
    // 返回值：成功返回MYSQL_RES结构体指针，失败或无结果集返回NULL
    MYSQL_RES *result = mysql_store_result(con);
    if (result == NULL)
    {
        finish_with_error(con);
    }

    // mysql_num_fields(): 获取结果中字段（列）的数量
    // 这对于遍历打印数据至关重要，因为我们不知道查回来有几列！
    int num_fields = mysql_num_fields(result);
    MYSQL_ROW row; // MYSQL_ROW 实际上是 char** 类型，代表一行数据的字符串数组

    printf("\n当前成绩表数据:\n");

    // mysql_fetch_row(): 从结果中获取下一行数据，工作原理类似于迭代器，每次调用自动移动到下一行
    // 返回值：成功返回MYSQL_ROW（字符串数组），如果没有更多行则返回NULL
    while ((row = mysql_fetch_row(result)))
    {
        for (int i = 0; i < num_fields; i++)
        {
            // row[i] 访问当前行的第 i 列数据
            // 注意：如果数据库中该字段值为 NULL，row[i] 会是 NULL指针！
            // 这里使用三元运算符防止空指针导致的段错误，如果是NULL则打印 "NULL"
            printf("%s ", row[i] ? row[i] : "NULL");
        }
        printf("\n");
    }

    // mysql_free_result(): 释放结果集占用的内存
    // 防止内存泄漏，非常重要。
    mysql_free_result(result);


    // 5. 更新操作：将张三的数学成绩改为95.0
    if (mysql_query(con, "UPDATE student_score SET score = 95.0 WHERE name = '张三' AND subject = '数学'"))
    {
        finish_with_error(con);
    }
    printf("\n更新成功，影响行数: %lu\n", (unsigned long)mysql_affected_rows(con));


    // 6. 删除操作：删除李四的英语记录
    if (mysql_query(con, "DELETE FROM student_score WHERE name = '李四' AND subject = '英语'"))
    {
        finish_with_error(con);
    }
    printf("删除成功，影响行数: %lu\n", (unsigned long)mysql_affected_rows(con));


    // 7. 再次查询，验证结果
    if (mysql_query(con, "SELECT id, name, subject, score FROM student_score"))
    {
        finish_with_error(con);
    }
    result = mysql_store_result(con);
    if (result == NULL)
    {
        finish_with_error(con);
    }
    printf("\n操作后的数据:\n");

    // 复用之前的遍历逻辑
    while ((row = mysql_fetch_row(result)))
    {
        for (int i = 0; i < num_fields; i++)
        {
            printf("%s ", row[i] ? row[i] : "NULL");
        }
        printf("\n");
    }
    mysql_free_result(result);


    // 8. 关闭连接，mysql_close(): 断开与服务器的连接，并释放连接句柄占用的内存
    // 这是最后一步清理工作！
    mysql_close(con);

    return 0;
}

#include <iostream>
#include <memory>
#include <mysql/mysql.h> // MySQL C API 头文件，C++ 可以直接调用 C 接口

class StudentDB
{
public:
    StudentDB(const std::string &host, const std::string &user,
              const std::string &pass, const std::string &db)
    {
        // 1. 初始化连接句柄
        // mysql_init(nullptr): 参数为空表示让库自动分配 MYSQL 结构体内存
        conn = mysql_init(nullptr);
        if (conn == nullptr)
        {
            std::cerr << "mysql_init() 失败！" << std::endl;
            exit(1);
        }

        // 2. 建立连接
        // 参数说明：mysql_init返回的句柄, 主机名或IP地址, 用户名, 密码, 数据库名, 端口(0表示默认), socket文件名, 客户端标志
        if (mysql_real_connect(conn, host.c_str(), user.c_str(),
                               pass.c_str(), db.c_str(), 0, nullptr, 0) == nullptr)
        {
            finish_with_error(); // 连接失败，打印错误并退出
        }
    }

    ~StudentDB()
    {
        if (conn)
        {
            mysql_close(conn); // 关闭连接并释放句柄内存
        }
    }

    // 插入操作
    bool insert(const std::string &name, const std::string &subject, double score)
    {
        char query[256]; // 缓冲区，用于存储拼接好的 SQL 语句

        // snprintf: 安全的格式化字符串函数，防止缓冲区溢出
        // 注意：实际更推荐使用 mysql_real_escape_string 处理特殊字符防止 SQL 注入
        snprintf(query, sizeof(query),
                 "INSERT INTO student_score (name, subject, score) VALUES ('%s', '%s', %.2f)",
                 name.c_str(), subject.c_str(), score);

        // mysql_query: 执行 SQL 语句
        // 返回值：非 0 表示执行失败
        if (mysql_query(conn, query))
        {
            std::cerr << "INSERT失败: " << mysql_error(conn) << std::endl;
            return false;
        }

        // mysql_affected_rows: 获取受影响的行数，通常用于验证插入是否真的发生
        std::cout << "插入成功，影响行数: " << mysql_affected_rows(conn) << std::endl;
        return true;
    }

    // 查询并打印所有记录：流程：执行 SQL -> 获取结果集 -> 遍历行 -> 释放结果集
    void queryAll()
    {
        // 执行查询语句
        if (mysql_query(conn, "SELECT id, name, subject, score FROM student_score"))
        {
            std::cerr << "SELECT失败: " << mysql_error(conn) << std::endl;
            return;
        }

        // mysql_store_result: 将查询结果从服务器全部取回并存储在本地内存
        // 返回值：MYSQL_RES 指针，失败返回 NULL
        MYSQL_RES *result = mysql_store_result(conn);
        if (result == nullptr)
        {
            std::cerr << "mysql_store_result()失败: " << mysql_error(conn) << std::endl;
            return;
        }

        // mysql_num_fields: 获取结果集中的列数（字段数量）
        int num_fields = mysql_num_fields(result);
        MYSQL_ROW row; // MYSQL_ROW 实际上是 char** 类型，代表一行数据

        std::cout << "-----------------------------------" << std::endl;

        // mysql_fetch_row: 从结果集中逐行获取数据
        // 返回值：下一行的数据，如果没有更多行则返回 NULL
        while ((row = mysql_fetch_row(result)))
        {
            for (int i = 0; i < num_fields; i++)
            {
                // row[i]: 访问当前行的第 i 列
                // 注意：如果数据库字段值为 NULL，row[i] 指针也是 NULL
                // 这里使用三元运算符进行 NULL 指针保护
                std::cout << (row[i] ? row[i] : "NULL") << "\t";
            }
            std::cout << std::endl;
        }
        std::cout << "-----------------------------------" << std::endl;

        // mysql_free_result: 释放 result 占用的内存
        // 非常重要：每次查询后必须释放，否则会造成严重的内存泄漏
        mysql_free_result(result);
    }

    // 更新数据
    bool update(const std::string &name, const std::string &subject, double newScore)
    {
        char query[256];
        snprintf(query, sizeof(query),
                 "UPDATE student_score SET score = %.2f WHERE name = '%s' AND subject = '%s'",
                 newScore, name.c_str(), subject.c_str());

        if (mysql_query(conn, query))
        {
            std::cerr << "UPDATE失败: " << mysql_error(conn) << std::endl;
            return false;
        }
        std::cout << "更新成功，影响行数: " << mysql_affected_rows(conn) << std::endl;
        return true;
    }

    // 删除数据
    bool remove(const std::string &name, const std::string &subject)
    {
        char query[256];
        snprintf(query, sizeof(query),
                 "DELETE FROM student_score WHERE name = '%s' AND subject = '%s'",
                 name.c_str(), subject.c_str());

        if (mysql_query(conn, query))
        {
            std::cerr << "DELETE失败: " << mysql_error(conn) << std::endl;
            return false;
        }
        std::cout << "删除成功，影响行数: " << mysql_affected_rows(conn) << std::endl;
        return true;
    }

private:
    MYSQL *conn; // MySQL 连接句柄指针，操作数据库的核心对象

    // 内部错误处理函数，打印错误信息、关闭连接并退出程序
    // 注意：在构造函数失败时调用，因为对象可能未完全构造，无法依赖析构函数
    void finish_with_error()
    {
        std::cerr << mysql_error(conn) << std::endl;
        mysql_close(conn); // 发生错误时手动关闭连接，防止资源泄漏
        exit(1);
    }
};

int main()
{
    // 1. 实例化数据库对象
    // 构造函数会自动执行 mysql_init 和 mysql_real_connect
    StudentDB db("localhost", "local_minbit", "123456", "local-C-test");

    // 2. 插入测试数据
    db.insert("张三", "数学", 88.5);
    db.insert("李四", "英语", 92.0);

    std::cout << "\n初始数据:" << std::endl;
    db.queryAll();

    // 3. 更新数据：将张三数学成绩修改为 95.0
    db.update("张三", "数学", 95.0);

    // 4. 删除数据：删除李四的英语成绩
    db.remove("李四", "英语");

    std::cout << "\n操作后数据:" << std::endl;
    db.queryAll();

    // 5. 程序结束
    // main 函数结束时，局部变量 db 会被销毁，自动调用析构函数 ~StudentDB()
    // 析构函数会执行 mysql_close(conn)，确保连接安全关闭
    return 0;
}

#include <iostream>
#include <mysql.h>   // 注意头文件名为 mysql.h

int main()
{
    MYSQL* conn = mysql_init(nullptr);
    if (conn == nullptr)
    {
        std::cerr << "mysql_init failed" << std::endl;
        return 1;
    }

    // 尝试连接远程Linux MySQL（替换为实际IP、用户、密码）
    if (mysql_real_connect(conn, "122.51.165.8", "win_test", "123456", "local-C-test", 3306, nullptr, 0) == nullptr)
    {
        std::cerr << "Connection error: " << mysql_error(conn) << std::endl;
        mysql_close(conn);
        return 1;
    }

    std::cout << "Connected successfully!" << std::endl;

    mysql_query(conn, "SELECT VERSION()");
    MYSQL_RES* res = mysql_store_result(conn);
    MYSQL_ROW row = mysql_fetch_row(res);
    std::cout << "MySQL version: " << row[0] << std::endl;
    mysql_free_result(res);

    mysql_close(conn);
    return 0;
}