MySQL C API开发指南：从基础到高级实践-代码聚汇网

MySQL C API开发指南：从基础到高级实践

菩提风

1. 环境准备与基础配置

在Linux环境下使用MySQL C API进行开发，首先需要搭建好基础开发环境。作为一名长期从事数据库开发的工程师，我建议从以下几个方面着手准备。

1.1 安装MySQL开发库

不同Linux发行版的安装命令有所差异，这里我整理了主流系统的安装方式：

bash复制# Ubuntu/Debian系
sudo apt-get update
sudo apt-get install -y libmysqlclient-dev

# RHEL/CentOS系
sudo yum install -y mysql-community-devel

# Arch Linux
sudo pacman -S mysql-clients

安装完成后，建议进行验证检查：

bash复制# 检查头文件
ls /usr/include/mysql/mysql.h

# 检查库文件（64位系统）
ls /usr/lib64/libmysqlclient.so

# 32位系统检查路径
ls /usr/lib/libmysqlclient.so

注意：在某些较新的发行版中，库文件可能被安装在/usr/lib/x86_64-linux-gnu/目录下。如果找不到文件，可以使用find /usr -name "libmysqlclient.so"进行全局搜索。

1.2 编译链接参数详解

使用gcc编译MySQL C程序时，需要特别注意链接参数。以下是一个完整的编译示例：

bash复制gcc mysql_demo.c -o mysql_demo \
-I/usr/include/mysql \
-L/usr/lib64/mysql \
-lmysqlclient \
-Wall -Wextra -O2

各参数含义如下：

-I：指定头文件搜索路径（如果mysql.h不在默认路径）
-L：指定库文件搜索路径
-lmysqlclient：链接MySQL客户端库（核心必选项）
-Wall -Wextra：开启更多警告提示
-O2：启用优化

在实际项目中，我建议使用Makefile来管理编译过程：

makefile复制CC = gcc
CFLAGS = -Wall -Wextra -O2
LIBS = -lmysqlclient
INCLUDES = -I/usr/include/mysql

mysql_demo: mysql_demo.c
	$(CC) $(CFLAGS) $(INCLUDES) $^ -o $@ $(LIBS)

clean:
	rm -f mysql_demo

2. MySQL C API核心工作机制

2.1 API基本工作流程

MySQL C API的核心工作流程可以分为以下几个阶段：

初始化连接句柄：mysql_init()
建立实际连接：mysql_real_connect()
执行SQL语句：mysql_query()或mysql_real_query()
处理结果集（针对查询语句）
释放资源：mysql_free_result()和mysql_close()

2.2 连接管理最佳实践

建立数据库连接时，有几个关键点需要注意：

c复制MYSQL mysql;
mysql_init(&mysql);

// 设置连接超时为5秒
unsigned int timeout = 5;
mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);

if (!mysql_real_connect(&mysql, "localhost", "user", "password", 
                       "database", 3306, NULL, 0)) {
    fprintf(stderr, "连接失败: %s\n", mysql_error(&mysql));
    return -1;
}

// 设置字符集为utf8mb4以支持完整Unicode
mysql_set_character_set(&mysql, "utf8mb4");

经验分享：生产环境中，建议将连接参数配置在配置文件中，而不是硬编码在代码里。同时，连接超时设置可以避免网络不佳时的长时间阻塞。

3. SQL执行方式深度解析

3.1 静态SQL执行方式

静态SQL适合执行固定不变的SQL语句，典型使用场景包括：

c复制const char *sql = "SELECT * FROM users WHERE status=1";
if (mysql_real_query(&mysql, sql, strlen(sql))) {
    fprintf(stderr, "查询失败: %s\n", mysql_error(&mysql));
    return -1;
}

MYSQL_RES *result = mysql_store_result(&mysql);
if (!result) {
    fprintf(stderr, "获取结果集失败: %s\n", mysql_error(&mysql));
    return -1;
}

// 处理结果集...
mysql_free_result(result);

静态SQL的优点在于简单直接，但有两个主要限制：

无法安全地处理用户输入，容易导致SQL注入
不能高效地处理二进制数据

3.2 预处理语句（动态参数）

预处理语句是更安全、更高效的方式，特别适合处理用户输入和二进制数据。下面是完整的工作流程：

c复制// 1. 初始化预处理语句
MYSQL_STMT *stmt = mysql_stmt_init(&mysql);
if (!stmt) {
    fprintf(stderr, "初始化预处理语句失败\n");
    return -1;
}

// 2. 准备SQL模板
const char *sql = "INSERT INTO products (name, price, image) VALUES (?, ?, ?)";
if (mysql_stmt_prepare(stmt, sql, strlen(sql))) {
    fprintf(stderr, "准备预处理语句失败: %s\n", mysql_stmt_error(stmt));
    mysql_stmt_close(stmt);
    return -1;
}

// 3. 绑定参数
MYSQL_BIND bind[3];
memset(bind, 0, sizeof(bind));

char *name = "高级笔记本电脑";
double price = 8999.99;
unsigned long image_size;
char image_buffer[1024*1024]; // 假设图片数据已读入缓冲区

// 绑定name参数
bind[0].buffer_type = MYSQL_TYPE_STRING;
bind[0].buffer = name;
bind[0].buffer_length = strlen(name);

// 绑定price参数
bind[1].buffer_type = MYSQL_TYPE_DOUBLE;
bind[1].buffer = &price;

// 绑定image参数
bind[2].buffer_type = MYSQL_TYPE_LONG_BLOB;
bind[2].buffer = image_buffer;
bind[2].buffer_length = image_size;
bind[2].length = &image_size;

if (mysql_stmt_bind_param(stmt, bind)) {
    fprintf(stderr, "绑定参数失败: %s\n", mysql_stmt_error(stmt));
    mysql_stmt_close(stmt);
    return -1;
}

// 4. 执行语句
if (mysql_stmt_execute(stmt)) {
    fprintf(stderr, "执行预处理语句失败: %s\n", mysql_stmt_error(stmt));
    mysql_stmt_close(stmt);
    return -1;
}

// 5. 释放资源
mysql_stmt_close(stmt);

预处理语句的核心优势：

天然防止SQL注入
二进制数据安全处理
重复执行效率高（特别是批量操作）

4. 高级特性与性能优化

4.1 事务处理

MySQL C API支持完整的事务操作：

c复制// 开启事务
if (mysql_real_query(&mysql, "START TRANSACTION", 16)) {
    fprintf(stderr, "开启事务失败: %s\n", mysql_error(&mysql));
    return -1;
}

// 执行一系列SQL操作...

// 根据执行结果提交或回滚
if (all_operations_success) {
    mysql_commit(&mysql);
} else {
    mysql_rollback(&mysql);
}

重要提示：InnoDB存储引擎才支持完整的事务特性。使用前请确认表的存储引擎类型。

4.2 批量操作优化

对于大量数据插入，有两种优化方式：

方法一：使用多值INSERT语法

c复制const char *sql = "INSERT INTO logs (time, message) VALUES "
                  "('2023-01-01 10:00', '系统启动'),"
                  "('2023-01-01 10:01', '服务初始化'),"
                  "('2023-01-01 10:02', '准备就绪')";

方法二：预处理语句批量执行

c复制// 准备预处理语句
MYSQL_STMT *stmt = mysql_stmt_init(&mysql);
const char *sql = "INSERT INTO logs (time, message) VALUES (?, ?)";
mysql_stmt_prepare(stmt, sql, strlen(sql));

// 绑定参数
MYSQL_BIND bind[2];
// ...参数绑定代码...

// 批量执行
for (int i = 0; i < BATCH_SIZE; i++) {
    // 更新绑定参数的值
    // ...
    
    mysql_stmt_execute(stmt);
}

实测表明，方法二在插入1000条记录时，比普通INSERT快3-5倍。

5. 错误处理与调试技巧

5.1 全面的错误检查

每个MySQL API调用都应该检查返回值：

c复制#define CHECK_MYSQL_ERROR(conn, stmt, ret, msg) \
    do { \
        if (ret) { \
            if (stmt) { \
                fprintf(stderr, "%s (stmt error): %s\n", msg, mysql_stmt_error(stmt)); \
            } else { \
                fprintf(stderr, "%s (conn error): %s\n", msg, mysql_error(conn)); \
            } \
            return -1; \
        } \
    } while(0)

// 使用示例
int ret = mysql_query(&mysql, sql);
CHECK_MYSQL_ERROR(&mysql, NULL, ret, "执行查询失败");

5.2 结果集处理模式

MySQL C API提供两种结果集处理方式：

mysql_store_result：一次性获取所有结果到内存
- 优点：可以随机访问结果行
- 缺点：内存消耗大
mysql_use_result：逐行获取结果
- 优点：内存效率高
- 缺点：必须按顺序处理，且在处理期间连接处于繁忙状态

c复制// 方式一：存储整个结果集
MYSQL_RES *result = mysql_store_result(&mysql);
if (result) {
    int num_fields = mysql_num_fields(result);
    MYSQL_ROW row;
    while ((row = mysql_fetch_row(result))) {
        // 处理每一行...
    }
    mysql_free_result(result);
}

// 方式二：逐行获取
MYSQL_RES *result = mysql_use_result(&mysql);
if (result) {
    MYSQL_ROW row;
    while ((row = mysql_fetch_row(result))) {
        // 必须立即处理当前行...
    }
    mysql_free_result(result);
}

6. 实战案例：BLOB数据处理

6.1 图片存储实现

c复制int store_image(MYSQL *mysql, const char *filename, const char *description) {
    // 读取图片文件
    FILE *fp = fopen(filename, "rb");
    if (!fp) return -1;
    
    fseek(fp, 0, SEEK_END);
    long size = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    
    char *buffer = malloc(size);
    if (!buffer) {
        fclose(fp);
        return -1;
    }
    
    fread(buffer, 1, size, fp);
    fclose(fp);
    
    // 准备预处理语句
    MYSQL_STMT *stmt = mysql_stmt_init(mysql);
    const char *sql = "INSERT INTO images (description, data) VALUES (?, ?)";
    mysql_stmt_prepare(stmt, sql, strlen(sql));
    
    // 绑定参数
    MYSQL_BIND bind[2];
    memset(bind, 0, sizeof(bind));
    
    // 描述字段
    bind[0].buffer_type = MYSQL_TYPE_STRING;
    bind[0].buffer = (char *)description;
    bind[0].buffer_length = strlen(description);
    
    // 图片数据
    bind[1].buffer_type = MYSQL_TYPE_LONG_BLOB;
    bind[1].buffer = buffer;
    bind[1].buffer_length = size;
    bind[1].length = &size;
    
    mysql_stmt_bind_param(stmt, bind);
    
    // 执行
    int ret = mysql_stmt_execute(stmt);
    
    // 清理
    free(buffer);
    mysql_stmt_close(stmt);
    
    return ret;
}

6.2 图片读取实现

c复制int load_image(MYSQL *mysql, int image_id, const char *output_filename) {
    MYSQL_STMT *stmt = mysql_stmt_init(mysql);
    char sql[256];
    sprintf(sql, "SELECT data FROM images WHERE id=%d", image_id);
    
    if (mysql_stmt_prepare(stmt, sql, strlen(sql))) {
        mysql_stmt_close(stmt);
        return -1;
    }
    
    // 执行查询
    if (mysql_stmt_execute(stmt)) {
        mysql_stmt_close(stmt);
        return -1;
    }
    
    // 绑定结果
    MYSQL_BIND bind;
    memset(&bind, 0, sizeof(bind));
    
    unsigned long data_length;
    char *buffer = NULL;
    
    bind.buffer_type = MYSQL_TYPE_LONG_BLOB;
    bind.length = &data_length;
    
    mysql_stmt_bind_result(stmt, &bind);
    
    // 获取结果
    if (mysql_stmt_fetch(stmt)) {
        mysql_stmt_close(stmt);
        return -1;
    }
    
    // 分配缓冲区
    buffer = malloc(data_length);
    if (!buffer) {
        mysql_stmt_close(stmt);
        return -1;
    }
    
    bind.buffer = buffer;
    bind.buffer_length = data_length;
    
    // 重新绑定并获取数据
    mysql_stmt_fetch_column(stmt, &bind, 0, 0);
    
    // 写入文件
    FILE *fp = fopen(output_filename, "wb");
    if (!fp) {
        free(buffer);
        mysql_stmt_close(stmt);
        return -1;
    }
    
    fwrite(buffer, 1, data_length, fp);
    fclose(fp);
    free(buffer);
    mysql_stmt_close(stmt);
    
    return 0;
}

7. 性能调优与安全建议

7.1 连接池管理

频繁创建和销毁数据库连接会严重影响性能。建议实现简单的连接池：

c复制#define POOL_SIZE 5

typedef struct {
    MYSQL *conn;
    bool in_use;
} DBConnection;

DBConnection pool[POOL_SIZE];

void init_pool() {
    for (int i = 0; i < POOL_SIZE; i++) {
        pool[i].conn = mysql_init(NULL);
        mysql_real_connect(pool[i].conn, "localhost", "user", 
                          "password", "dbname", 3306, NULL, 0);
        pool[i].in_use = false;
    }
}

MYSQL *get_connection() {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (!pool[i].in_use) {
            pool[i].in_use = true;
            return pool[i].conn;
        }
    }
    return NULL;
}

void release_connection(MYSQL *conn) {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (pool[i].conn == conn) {
            pool[i].in_use = false;
            break;
        }
    }
}

7.2 安全最佳实践

永远不要拼接SQL语句：即使参数不是来自用户输入，也使用预处理语句
验证所有输入数据：包括长度检查和内容过滤
使用最小权限原则：应用程序使用的数据库账号只应具有必要权限
加密敏感数据：不要在数据库中存储明文密码
定期更新MySQL客户端库：确保使用最新版本修复已知漏洞

8. 常见问题解决方案

8.1 中文乱码问题

解决方案：

连接后立即设置字符集：

c复制mysql_set_character_set(&mysql, "utf8mb4");

确保数据库、表和字段的字符集也是utf8mb4

在SQL语句中使用明确的字符集声明：

c复制const char *sql = "SET NAMES utf8mb4";
mysql_real_query(&mysql, sql, strlen(sql));

8.2 连接超时问题

MySQL服务器默认会在8小时不活动后断开连接。解决方案：

在连接字符串中添加重连选项：

c复制my_bool reconnect = 1;
mysql_options(&mysql, MYSQL_OPT_RECONNECT, &reconnect);

或者在代码中捕获错误并手动重连：

c复制if (mysql_ping(&mysql)) {
    // 重新建立连接
    mysql_close(&mysql);
    mysql_init(&mysql);
    mysql_real_connect(...);
}

8.3 大结果集内存消耗

处理大型查询结果时，可以采用以下策略：

使用mysql_use_result替代mysql_store_result
增加查询条件限制结果集大小

实现分页查询：

c复制const char *sql = "SELECT * FROM large_table LIMIT %d OFFSET %d";
char query[256];
sprintf(query, sql, page_size, page_num * page_size);

9. 现代开发实践

9.1 使用ORM框架

对于复杂项目，可以考虑使用ORM框架如：

libzdb
SOCI

这些框架提供了更高层次的抽象，同时仍然保持对C API的访问能力。

9.2 异步操作

对于高性能应用，可以使用MySQL的非阻塞API：

c复制// 启用异步模式
mysql_options(&mysql, MYSQL_OPT_NONBLOCK, 0);

// 开始查询
mysql_real_query_start(&ret, &mysql, sql, length);
while (ret == EINPROGRESS) {
    // 使用select/poll等待socket可写
    mysql_real_query_cont(&ret, &mysql, status);
}

// 获取结果
mysql_store_result_start(&result, &mysql);
while (result == NULL && mysql_errno(&mysql) == EINPROGRESS) {
    // 使用select/poll等待socket可读
    mysql_store_result_cont(&result, &mysql, status);
}

10. 调试与性能分析

10.1 启用查询日志

可以在MySQL服务器端启用查询日志：

sql复制SET GLOBAL general_log = 'ON';
SET GLOBAL general_log_file = '/var/log/mysql/mysql-query.log';

10.2 使用性能分析工具

valgrind：检测内存泄漏

bash复制valgrind --leak-check=full ./mysql_app

gprof：性能分析

bash复制gcc -pg ... # 编译时加上-pg选项
./mysql_app
gprof ./mysql_app gmon.out > analysis.txt

strace：系统调用跟踪

bash复制strace -o trace.log -tt -T ./mysql_app

11. 跨平台开发注意事项

11.1 Windows平台差异

在Windows上开发时需要注意：

使用mysql.h需要包含winsock2.h在windows.h之前：

c复制#include <winsock2.h>
#include <windows.h>
#include <mysql.h>

链接libmysql.lib而不是libmysqlclient.a
路径分隔符使用双反斜杠或正斜杠

11.2 32/64位兼容性

处理大结果集或BLOB数据时，注意：

使用size_t和uint64_t等可移植类型
检查sizeof(long)在不同平台的差异
使用固定宽度整数类型处理网络传输数据

12. 扩展功能实现

12.1 多语句执行

MySQL C API支持一次执行多个SQL语句：

c复制mysql_real_connect(&mysql, ..., CLIENT_MULTI_STATEMENTS);

const char *sql = "INSERT INTO table1 VALUES (...); "
                  "UPDATE table2 SET ...; "
                  "SELECT * FROM table3";
mysql_real_query(&mysql, sql, strlen(sql));

do {
    MYSQL_RES *result = mysql_store_result(&mysql);
    if (result) {
        // 处理结果集...
        mysql_free_result(result);
    }
} while (!mysql_next_result(&mysql));

12.2 存储过程调用

调用存储过程的示例：

c复制const char *call = "CALL get_user_details(?)";
MYSQL_STMT *stmt = mysql_stmt_init(&mysql);
mysql_stmt_prepare(stmt, call, strlen(call));

// 绑定输入参数
MYSQL_BIND in_bind;
int user_id = 123;
in_bind.buffer_type = MYSQL_TYPE_LONG;
in_bind.buffer = &user_id;
mysql_stmt_bind_param(stmt, &in_bind);

// 执行
mysql_stmt_execute(stmt);

// 处理输出参数和结果集...

13. 资源管理与错误恢复

13.1 内存泄漏预防

确保每个分配的资源都有对应的释放：

mysql_init() ↔ mysql_close()
mysql_store_result() ↔ mysql_free_result()
mysql_stmt_init() ↔ mysql_stmt_close()

建议使用RAII模式封装：

c复制typedef struct {
    MYSQL *conn;
    MYSQL_STMT *stmt;
    MYSQL_RES *res;
} MySQLContext;

void mysql_context_cleanup(MySQLContext *ctx) {
    if (ctx->res) mysql_free_result(ctx->res);
    if (ctx->stmt) mysql_stmt_close(ctx->stmt);
    if (ctx->conn) mysql_close(ctx->conn);
    memset(ctx, 0, sizeof(*ctx));
}

13.2 事务恢复模式

实现健壮的事务恢复：

c复制int perform_transaction(MYSQL *mysql) {
    if (mysql_real_query(mysql, "START TRANSACTION", 16)) return -1;
    
    int ret = 0;
    do {
        // 操作1
        if (mysql_real_query(mysql, sql1, strlen(sql1))) {
            ret = -1;
            break;
        }
        
        // 操作2
        if (mysql_real_query(mysql, sql2, strlen(sql2))) {
            ret = -1;
            break;
        }
        
        // 更多操作...
    } while(0);
    
    if (ret == 0) {
        mysql_commit(mysql);
    } else {
        mysql_rollback(mysql);
    }
    
    return ret;
}

14. 现代C++封装示例

对于使用C++的项目，可以创建更安全的封装类：

cpp复制class MySQLConnection {
public:
    MySQLConnection(const std::string &host, ...) {
        conn_ = mysql_init(nullptr);
        if (!mysql_real_connect(conn_, ...)) {
            throw std::runtime_error(mysql_error(conn_));
        }
    }
    
    ~MySQLConnection() {
        if (conn_) mysql_close(conn_);
    }
    
    class Statement {
    public:
        Statement(MYSQL *conn, const std::string &sql) {
            stmt_ = mysql_stmt_init(conn);
            if (!stmt_) throw std::runtime_error("init failed");
            if (mysql_stmt_prepare(stmt_, sql.c_str(), sql.size())) {
                throw std::runtime_error(mysql_stmt_error(stmt_));
            }
        }
        
        ~Statement() {
            if (stmt_) mysql_stmt_close(stmt_);
        }
        
        // 绑定参数、执行等方法...
        
    private:
        MYSQL_STMT *stmt_ = nullptr;
    };
    
private:
    MYSQL *conn_ = nullptr;
};

15. 项目结构建议

对于大型项目，建议采用如下目录结构：

code复制project/
├── include/
│   ├── db/
│   │   ├── connection.h
│   │   ├── statement.h
│   │   └── result.h
├── src/
│   ├── db/
│   │   ├── connection.c
│   │   ├── statement.c
│   │   └── result.c
├── tests/
│   ├── db_test.c
├── Makefile
└── README.md

关键设计原则：

将数据库操作封装在单独的模块中
提供简洁的API接口
实现资源自动管理
包含完整的错误处理
提供单元测试

16. 持续集成与测试

建议为数据库相关代码建立自动化测试：

c复制// 使用Check单元测试框架示例
#include <check.h>

START_TEST(test_mysql_connection) {
    MYSQL mysql;
    mysql_init(&mysql);
    
    ck_assert_msg(mysql_real_connect(&mysql, "localhost", ...),
                 "连接数据库失败");
    
    // 测试查询
    ck_assert_int_eq(mysql_real_query(&mysql, "SELECT 1", 7), 0);
    
    MYSQL_RES *res = mysql_store_result(&mysql);
    ck_assert_ptr_nonnull(res);
    
    mysql_free_result(res);
    mysql_close(&mysql);
}
END_TEST

在CI流程中运行测试：

yaml复制# .gitlab-ci.yml示例
test:
  script:
    - apt-get install -y libmysqlclient-dev check
    - make test

17. 性能基准测试

对不同操作进行性能测试：

c复制#include <time.h>

void benchmark_insert(int count) {
    MYSQL mysql;
    mysql_init(&mysql);
    mysql_real_connect(&mysql, ...);
    
    clock_t start = clock();
    
    // 测试普通INSERT
    for (int i = 0; i < count; i++) {
        char sql[256];
        sprintf(sql, "INSERT INTO test VALUES (%d)", i);
        mysql_real_query(&mysql, sql, strlen(sql));
    }
    
    clock_t end = clock();
    printf("普通INSERT %d次耗时: %.2f秒\n", 
           count, (double)(end - start)/CLOCKS_PER_SEC);
    
    // 测试预处理语句
    MYSQL_STMT *stmt = mysql_stmt_init(&mysql);
    const char *sql = "INSERT INTO test VALUES (?)";
    mysql_stmt_prepare(stmt, sql, strlen(sql));
    
    MYSQL_BIND bind;
    int value;
    bind.buffer_type = MYSQL_TYPE_LONG;
    bind.buffer = &value;
    
    mysql_stmt_bind_param(stmt, &bind);
    
    start = clock();
    for (int i = 0; i < count; i++) {
        value = i;
        mysql_stmt_execute(stmt);
    }
    end = clock();
    
    printf("预处理INSERT %d次耗时: %.2f秒\n", 
           count, (double)(end - start)/CLOCKS_PER_SEC);
    
    mysql_stmt_close(stmt);
    mysql_close(&mysql);
}

18. 安全加固措施

18.1 连接加密

启用SSL加密连接：

c复制mysql_ssl_set(&mysql, 
             "/path/to/client-key.pem",
             "/path/to/client-cert.pem",
             "/path/to/ca-cert.pem",
             NULL, NULL);
             
if (!mysql_real_connect(&mysql, ...)) {
    // 处理错误
}

// 验证SSL是否实际启用
if (mysql_get_ssl_cipher(&mysql) == NULL) {
    fprintf(stderr, "SSL连接未建立\n");
}

18.2 密码安全

避免在代码中硬编码密码：

从配置文件中读取
使用环境变量
运行时从安全存储获取

c复制const char *password = getenv("DB_PASSWORD");
if (!password) {
    fprintf(stderr, "请设置DB_PASSWORD环境变量\n");
    exit(1);
}

19. 高级特性探索

19.1 批量参数绑定

MySQL C API支持一次绑定多组参数：

c复制MYSQL_BIND bind[3][100]; // 3列，100行

// 初始化所有绑定...
// 设置bind_param_array属性
my_bool is_null[100] = {0};
unsigned long length[100] = {sizeof(int)};

bind[0].u.indicator = is_null;
bind[0].length = length;
bind[0].u.bind_array = bind[0];

// 执行批量插入
mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
mysql_stmt_bind_param(stmt, bind[0]);
mysql_stmt_execute(stmt);

19.2 流式结果处理

对于超大结果集，可以使用流式处理：

c复制MYSQL_STMT *stmt = mysql_stmt_init(&mysql);
mysql_stmt_prepare(stmt, "SELECT * FROM huge_table", ...);

// 绑定结果列
MYSQL_BIND bind[COL_COUNT];
// ...初始化bind...

mysql_stmt_bind_result(stmt, bind);
mysql_stmt_execute(stmt);

while (!mysql_stmt_fetch(stmt)) {
    // 处理当前行
    if (mysql_stmt_fetch_column(stmt, &bind[0], 0, 0)) {
        break;
    }
    // ...
}

20. 总结与进阶方向

经过上述全面介绍，我们已经涵盖了MySQL C API开发的各个方面。作为进阶方向，可以考虑：

连接池优化：实现更高效的连接管理
异步API：结合libevent/libuv实现非阻塞操作
ORM扩展：开发更符合项目需求的数据库抽象层
分布式支持：实现分库分表访问逻辑
监控集成：添加Prometheus等监控指标

在实际项目中，我强烈建议从简单封装开始，随着项目复杂度增加逐步引入更高级的特性。记住，可维护性和可靠性应该始终是首要考虑因素。