TBOX目前支持sqlite3、mysql两种关系型数据库，并对其接口进行了封装，使用更加的方便简洁并且只需要换个url，就可以随时切换成其他数据库引擎，而不需要修改接口。

    下面先看个简单的例子：

    1. /* 初始化一个mysql数据库
    2.  *
    3.  * localhost:   主机名，也可以是ip地址
    4.  * type:        数据库的类型，目前支持：mysql 和 sqlite3两种类型
    5.  * username:    数据库用户名
    6.  * password:    数据库用户密码
    7.  * database:    要访问的数据库名称， 如果不设置则自动连接默认的数据库
    8.  *
    9.  * 若果逆向指定个端口，可以显示传入：
    10.  * "sql://localhost:3306/?type=mysql&username=xxxx&password=xxxx&database=xxxx"
    11.  *
    12.  * sqlite3的数据库访问url为：
    13.  * "sql:///home/file.sqlitedb?type=sqlite3"
    14.  *
    15.  * 或者直接传文件路径：
    16.  * "/home/file.sqlite3"
    17.  * "file:///home/file.sqlitedb"
    18.  * "C://home/file.sqlite3"
    19.  */
    20. tb_database_sql_ref_t database = tb_database_sql_init("sql://localhost/?type=mysql&username=xxxx&password=xxxx&database=test");
    21. if (database)
    22. {
    23.     // 打开数据库
    24.     if (tb_database_sql_open(database))
    25.     {
    26.         // 执行sql语句，进行查询
    27.         if (tb_database_sql_done(database, "select * from test"))
    28.         {
    29.             /* 加载结果集
    30.              *
    31.              * 如果是insert, update等非select语句执行，这个时候返回tb_null， 说明没有结果集
    32.              *
    33.              * 这个结果集完全采用迭代器模式，方便快速迭代访问。
    34.              *
    35.              * 后面的参数tb_true指示尽量一次性加载所有结果到内存，如果成功
    36.              * 就可以通过tb_iterator_size(result)获取实际的结果集行数。
    37.              *
    38.              * 如果一次性加载失败或者传入的是tb_false， 说明只能通过fetch，一行行的回滚数据行
    39.              * 这样占用内存的资源较少，但是没法提前获取到实际的行数，这个时候tb_iterator_size(result)
    40.              * 返回的是一个超大值
    41.              */
    42.             tb_iterator_ref_t result = tb_database_sql_result_load(database, tb_true);
    43.             if (result)
    44.             {
    45.                 // 如果一次性加载成功，返回实际的结果行数
    46.                 tb_trace_i("row: size: %lu", tb_iterator_size(result));
    47.  
    48.                 // 遍历所有行
    49.                 tb_for_all_if (tb_iterator_ref_t, row, result, row)
    50.                 {
    51.                     // 显示行的列数
    52.                     tb_trace_i("[row: %lu, col: size: %lu]: ", row_itor, tb_iterator_size(row));
    53.  
    54.                     // 遍历这一行中的所有值
    55.                     tb_for_all_if (tb_database_sql_value_t*, value, row, value)
    56.                     {
    57.                         /* tb_database_sql_value_name(value): 获取值所对应列名
    58.                          * tb_database_sql_value_text(value)：获取值的文本数据，如果是text类型的话
    59.                          * tb_database_sql_value_type(value)：获取值的类型
    60.                          *
    61.                          * ...
    62.                          */
    63.                         tb_tracet_i("[%s:%s] ", tb_database_sql_value_name(value), tb_database_sql_value_text(value));
    64.                     }
    65.                 }
    66.  
    67.                 // 释放结果集数据
    68.                 tb_database_sql_result_exit(database, result);
    69.             }
    70.         }
    71.         else
    72.         {
    73.             // 执行失败，显示失败状态和原因
    74.             tb_trace_e("done %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
    75.         }
    76.     }
    77.     else
    78.     {
    79.         // 打开失败，显示失败状态和原因
    80.         tb_trace_e("open failed: %s", tb_state_cstr(tb_database_sql_state(database)));
    81.     }
    82.  
    83.     // 退出数据库
    84.     tb_database_sql_exit(database);
    85. }

    上面的例子没法处理二进制数据，如果要处理二进制数据，比如插入一个图像数据什么的可以使用statement模式，预编译一个sql语句，bind每个参数来实现，这种方式更加的灵活而且对于频繁处理某个sql语句的情况，效率更高，因为省去每次都要解析一遍sql语法的过程。

    具体使用过程也很简单，下面先看个insert二进制数据的例子：

    1. // done
    2. tb_database_sql_statement_ref_t     stmt = tb_null;
    3. tb_stream_ref_t                     stream = tb_null;
    4. do
    5. {
    6.     // 初始化一个插入语句，需要自定义传入的参数用?代替， 并进行预编译处理
    7.     if (!(stmt = tb_database_sql_statement_init(database, "insert into table2 values(?, ?, ?, ?, ?, ?, ?)")))
    8.     {
    9.         // trace
    10.         tb_trace_e("stmt: init %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
    11.         break ;
    12.     }
    13.  
    14.     // 初始化一个超大图像数据流
    15.     stream = tb_stream_init_from_url("/tmp/large_image.png");
    16.     tb_assert_and_check_break(stream);
    17.  
    18.     // 打开流
    19.     if (!tb_stream_open(stream)) break;
    20.  
    21.     // 参数列表
    22.     tb_database_sql_value_t list[7];
    23.  
    24.     // 绑定一个text类型的参数，sql中对应：text
    25.     tb_database_sql_value_set_text(&list[0], "hello", 0);
    26.  
    27.     // 绑定一个uint16大小的blob数据参数，由于是小块数据，不用使用stream，sql中对应：blob
    28.     tb_database_sql_value_set_blob16(&list[1], data, size);
    29.  
    30.     // 绑定一个uint8大小的超小数据块，节省存储空间，sql中对应：tinyblob
    31.     tb_database_sql_value_set_blob8(&list[2], data, size);
    32.  
    33.     // 绑定一个uint32大小的超大数据块，sql中对应：longblob
    34.     tb_database_sql_value_set_blob32(&list[3], data, size, tb_null);
    35.  
    36.     // 绑定一个uint32大小的超大数据流，这样比较节省内存，不会一次性加载数据到内存中来处理，sql中对应：longblob
    37.     tb_database_sql_value_set_blob32(&list[4], tb_null, 0, stream);
    38.  
    39.     // 绑定一个int32整数，sql中对应int
    40.     tb_database_sql_value_set_int32(&list[5], number);
    41.  
    42.     // 绑定一个int16整数，sql中对应smallint
    43.     tb_database_sql_value_set_int16(&list[6], snumber);
    44.  
    45.     // 绑定参数列表
    46.     if (!tb_database_sql_statement_bind(database, stmt, list, tb_arrayn(list)))
    47.     {
    48.         // trace
    49.         tb_trace_e("stmt: bind %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
    50.         break ;
    51.     }
    52.  
    53.     // 执行预编译的sql语句
    54.     if (!tb_database_sql_statement_done(database, stmt))
    55.     {
    56.         // trace
    57.         tb_trace_e("stmt: done %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
    58.         break ;
    59.     }
    60.  
    61. } while (0);
    62.  
    63. // 删除sql语句对象
    64. if (stmt) tb_database_sql_statement_exit(database, stmt);
    65.  
    66. // 退出数据流
    67. if (stream) tb_stream_exit(stream);

    对于获取对应结果集数据，使用的接口和第一个例子一样，可以直接进行迭代 也可以通过索引直接访问其中某列的数据：

    1. // 按回滚方式加载结果集
    2. tb_iterator_ref_t result = tb_database_sql_result_load(database, tb_false);
    3. if (result)
    4. {
    5.     // 遍历行
    6.     tb_for_all_if (tb_iterator_ref_t, row, result, row)
    7.     {
    8.         // 获取text数据
    9.         tb_database_sql_value_t const* name = tb_iterator_item(row, 0);
    10.         tb_assert_and_check_break(name);
    11.         tb_tracet_i("[%s:%s] ", tb_database_sql_value_name(name), tb_database_sql_value_text(name));
    12.  
    13.         // 获取blob16数据
    14.         tb_database_sql_value_t const* data = tb_iterator_item(row, 1);
    15.         tb_assert_and_check_break(data);
    16.         tb_tracet_i("[%s:%s] ", tb_database_sql_value_name(data), tb_database_sql_value_blob(data));
    17.  
    18.         // 获取blob32数据
    19.         tb_database_sql_value_t const* ldata = tb_iterator_item(row, 4);
    20.         tb_assert_and_check_break(ldata);
    21.         {
    22.             /* 优先尝试获取数据buffer，如果存在的话
    23.              *
    24.              * 针对小块数据进行了优化，就算是blob32的数据，如果数据大小
    25.              * 本身不大，会直接存到内存buffer中去，来快速读取
    26.              */
    27.             tb_stream_ref_t     stream = tb_null;
    28.             if (tb_database_sql_value_blob(ldata))
    29.             {
    30.                 // 获取数据和大小
    31.                 tb_byte_t const*    data = tb_database_sql_value_blob(ldata);
    32.                 tb_size             size = tb_database_sql_value_size(ldata);
    33.                 // ...
    34.             }
    35.             // 如果获取不到数据buffer，说明数据量很大，尝试获取数据流来处理
    36.             else if ((stream = tb_database_sql_value_blob_stream(ldata)))
    37.             {
    38.                 // 进行stream的数据读取，注：这个流不支持写操作，只能用来读
    39.                 // ...
    40.             }
    41.         }
    42.  
    43.         // 获取int32数据，如果是int8, int16 或者float类型的数据，会自动进行强转
    44.         tb_database_sql_value_t const* number = tb_iterator_item(row, 5);
    45.         tb_assert_and_check_break(number);
    46.         tb_tracet_i("[%s:%d] ", tb_database_sql_value_name(number), tb_database_sql_value_int32(number));
    47.  
    48.     }
    49.  
    50.     // 退出结果集
    51.     tb_database_sql_result_exit(database, result);
    52. }