摘要：目前支持兩種關系型數據庫需要鏈接對應的和，并對其接口進行了封裝，使用更加的方便簡潔并且只需要換個，就可以隨時切換成其他數據庫引擎，而不需要修改接口。

TBOX目前支持sqlite3、mysql兩種關系型數據庫（需要鏈接對應的libsqlite3.a和libmysql.a），并對其接口進行了封裝，使用更加的方便簡潔并且只需要換個url，就可以隨時切換成其他數據庫引擎，而不需要修改接口。

下面先看個簡單的例子：

/* 初始化一個mysql數據庫
 *
 * localhost:   主機名，也可以是ip地址
 * type:        數據庫的類型，目前支持：mysql 和 sqlite3兩種類型
 * username:    數據庫用戶名
 * password:    數據庫用戶密碼
 * database:    要訪問的數據庫名稱， 如果不設置則自動連接默認的數據庫
 *
 * 若果逆向指定個端口，可以顯示傳入：
 * "sql://localhost:3306/?type=mysql&username=xxxx&password=xxxx&database=xxxx"
 *
 * sqlite3的數據庫訪問url為：
 * "sql:///home/file.sqlitedb?type=sqlite3"
 *
 * 或者直接傳文件路徑：
 * "/home/file.sqlite3"
 * "file:///home/file.sqlitedb"
 * "C://home/file.sqlite3"
 */
tb_database_sql_ref_t database = tb_database_sql_init("sql://localhost/?type=mysql&username=xxxx&password=xxxx&database=test");
if (database)
{
    // 打開數據庫
    if (tb_database_sql_open(database))
    {
        // 執行sql語句，進行查詢
        if (tb_database_sql_done(database, "select * from test"))
        {
            /* 加載結果集
             *
             * 如果是insert, update等非select語句執行，這個時候返回tb_null， 說明沒有結果集
             *
             * 這個結果集完全采用迭代器模式，方便快速迭代訪問。
             *
             * 后面的參數tb_true指示盡量一次性加載所有結果到內存，如果成功
             * 就可以通過tb_iterator_size(result)獲取實際的結果集行數。
             *
             * 如果一次性加載失敗或者傳入的是tb_false， 說明只能通過fetch，一行行的回滾數據行
             * 這樣占用內存的資源較少，但是沒法提前獲取到實際的行數，這個時候tb_iterator_size(result)
             * 返回的是一個超大值
             */
            tb_iterator_ref_t result = tb_database_sql_result_load(database, tb_true);
            if (result)
            {
                // 如果一次性加載成功，返回實際的結果行數
                tb_trace_i("row: size: %lu", tb_iterator_size(result));
                
                // 遍歷所有行
                tb_for_all_if (tb_iterator_ref_t, row, result, row)
                {
                    // 顯示行的列數
                    tb_trace_i("[row: %lu, col: size: %lu]: ", row_itor, tb_iterator_size(row));
                    
                    // 遍歷這一行中的所有值
                    tb_for_all_if (tb_database_sql_value_t*, value, row, value)
                    {
                        /* tb_database_sql_value_name(value): 獲取值所對應列名
                         * tb_database_sql_value_text(value)：獲取值的文本數據，如果是text類型的話
                         * tb_database_sql_value_type(value)：獲取值的類型
                         *
                         * ...
                         */
                        tb_tracet_i("[%s:%s] ", tb_database_sql_value_name(value), tb_database_sql_value_text(value));
                    }
                }
                
                // 釋放結果集數據
                tb_database_sql_result_exit(database, result);
            }
        }
        else
        {
            // 執行失敗，顯示失敗狀態和原因
            tb_trace_e("done %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
        }
    }
    else
    {
        // 打開失敗，顯示失敗狀態和原因
        tb_trace_e("open failed: %s", tb_state_cstr(tb_database_sql_state(database)));
    }
    
    // 退出數據庫
    tb_database_sql_exit(database);
}

上面的例子沒法處理二進制數據，如果要處理二進制數據，比如插入一個圖像數據什么的可以使用statement模式，預編譯一個sql語句，bind每個參數來實現，這種方式更加的靈活而且對于頻繁處理某個sql語句的情況，效率更高，因為省去每次都要解析一遍sql語法的過程。

具體使用過程也很簡單，下面先看個insert二進制數據的例子：

// done
tb_database_sql_statement_ref_t     stmt = tb_null;
tb_stream_ref_t                     stream = tb_null;
do
{
    // 初始化一個插入語句，需要自定義傳入的參數用?代替， 并進行預編譯處理
    if (!(stmt = tb_database_sql_statement_init(database, "insert into table2 values(?, ?, ?, ?, ?, ?, ?)")))
    {
        // trace
        tb_trace_e("stmt: init %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
        break ;
    }
    
    // 初始化一個超大圖像數據流
    stream = tb_stream_init_from_url("/tmp/large_image.png");
    tb_assert_and_check_break(stream);
    
    // 打開流
    if (!tb_stream_open(stream)) break;
    
    // 參數列表
    tb_database_sql_value_t list[7];

    // 綁定一個text類型的參數，sql中對應：text
    tb_database_sql_value_set_text(&list[0], "hello", 0);

    // 綁定一個uint16大小的blob數據參數，由于是小塊數據，不用使用stream，sql中對應：blob
    tb_database_sql_value_set_blob16(&list[1], data, size);

    // 綁定一個uint8大小的超小數據塊，節省存儲空間，sql中對應：tinyblob
    tb_database_sql_value_set_blob8(&list[2], data, size);

    // 綁定一個uint32大小的超大數據塊，sql中對應：longblob
    tb_database_sql_value_set_blob32(&list[3], data, size, tb_null);

    // 綁定一個uint32大小的超大數據流，這樣比較節省內存，不會一次性加載數據到內存中來處理，sql中對應：longblob
    tb_database_sql_value_set_blob32(&list[4], tb_null, 0, stream);

    // 綁定一個int32整數，sql中對應int
    tb_database_sql_value_set_int32(&list[5], number);

    // 綁定一個int16整數，sql中對應smallint
    tb_database_sql_value_set_int16(&list[6], snumber);
    
    // 綁定參數列表
    if (!tb_database_sql_statement_bind(database, stmt, list, tb_arrayn(list)))
    {
        // trace
        tb_trace_e("stmt: bind %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
        break ;
    }
    
    // 執行預編譯的sql語句
    if (!tb_database_sql_statement_done(database, stmt))
    {
        // trace
        tb_trace_e("stmt: done %s failed, error: %s", sql, tb_state_cstr(tb_database_sql_state(database)));
        break ;
    }
    
} while (0);

// 刪除sql語句對象
if (stmt) tb_database_sql_statement_exit(database, stmt);

// 退出數據流
if (stream) tb_stream_exit(stream);

對于獲取對應結果集數據，使用的接口和第一個例子一樣，可以直接進行迭代
也可以通過索引直接訪問其中某列的數據：

// 按回滾方式加載結果集
tb_iterator_ref_t result = tb_database_sql_result_load(database, tb_false);
if (result)
{
    // 遍歷行
    tb_for_all_if (tb_iterator_ref_t, row, result, row)
    {
        // 獲取text數據
        tb_database_sql_value_t const* name = tb_iterator_item(row, 0);
        tb_assert_and_check_break(name);
        tb_tracet_i("[%s:%s] ", tb_database_sql_value_name(name), tb_database_sql_value_text(name));
        
        // 獲取blob16數據
        tb_database_sql_value_t const* data = tb_iterator_item(row, 1);
        tb_assert_and_check_break(data);
        tb_tracet_i("[%s:%s] ", tb_database_sql_value_name(data), tb_database_sql_value_blob(data));
        
        // 獲取blob32數據
        tb_database_sql_value_t const* ldata = tb_iterator_item(row, 4);
        tb_assert_and_check_break(ldata);
        {
            /* 優先嘗試獲取數據buffer，如果存在的話
             *
             * 針對小塊數據進行了優化，就算是blob32的數據，如果數據大小
             * 本身不大，會直接存到內存buffer中去，來快速讀取
             */
            tb_stream_ref_t     stream = tb_null;
            if (tb_database_sql_value_blob(ldata))
            {
                // 獲取數據和大小
                tb_byte_t const*    data = tb_database_sql_value_blob(ldata);
                tb_size             size = tb_database_sql_value_size(ldata);
                // ...

            }
            // 如果獲取不到數據buffer，說明數據量很大，嘗試獲取數據流來處理
            else if ((stream = tb_database_sql_value_blob_stream(ldata)))
            {
                // 進行stream的數據讀取，注：這個流不支持寫操作，只能用來讀
                // ...

            }
        }
        
        // 獲取int32數據，如果是int8, int16 或者float類型的數據，會自動進行強轉
        tb_database_sql_value_t const* number = tb_iterator_item(row, 5);
        tb_assert_and_check_break(number);
        tb_tracet_i("[%s:%d] ", tb_database_sql_value_name(number), tb_database_sql_value_int32(number));
        
    }
    
    // 退出結果集
    tb_database_sql_result_exit(database, result);
}

TBOX項目詳情

TBOX項目源碼

TBOX項目文檔

原文出處：http://tboox.org/cn/2016/09/18/database-usage/