c++ 调用sqlite3

#ifndef SQL3BASE_H
#define SQL3BASE_H

#include 
#include 
#include 

#include "sqlite3.h"


class SQL3Base
{

public:
    using db_ccb = int(*)(void*data, int argc, char** argv, char** azcolname);
    using db_cxxcb = std::function;
    using db_column = std::vector;
    using db_values = std::vector;
public:
    explicit SQL3Base(const std::string& filepath);
    virtual ~SQL3Base();
    //open
    bool open();
    //close
    bool close();
    //set write sync 0 == off, 1 == normal, 2 == full
    bool set_write_sync(int type);

    //transaction
    bool begin_transaction();
    bool commit_transaction();
    bool rollback_transaction();


    //执行回调获取
    bool exec_callback(const std::string& sql, db_ccb cb = nullptr, void* data = nullptr);
    bool exec_callback(const std::string& sql, db_cxxcb cb, void* data = nullptr);
    //执行表获取
    bool exec_table(const std::string &sql, int &row, int &column, db_values & values);
    
    //string err
    std::string err_string();

    //easy function
    std::string sql_string(int value);
    std::string sql_string(const std::string& value);

    void show_db_values(const db_values& value);

private:
    std::string m_filepath;
    sqlite3* m_db;
};

#endif // SQL3BASE_H

#include "sql3base.h"
#include 

using namespace std;

SQL3Base::SQL3Base(const std::string& filepath)
    : m_filepath(filepath), m_db(nullptr)
{

}

SQL3Base::~SQL3Base()
{
    close();
}
bool SQL3Base::open()
{
    int ret = sqlite3_open(m_filepath.c_str(), &m_db);
    if(0 == ret)
        return true;

    cerr << "can't open database:" << sqlite3_errmsg(m_db);
    cerr << m_db << endl;
    sqlite3_close(m_db);
    m_db = nullptr;
    return false;
}

bool SQL3Base::close()
{
    if(!m_db)
        return false;
    sqlite3_close(m_db);
    m_db = nullptr;
    return true;
}

//set write sync 0 == off, 1 == normal, 2 == full
bool SQL3Base::set_write_sync(int type)
{
    if(type < 0 || type > 2)
        return false;

    std::string sql = "PRAGMA synchronous = ";

    if(0 == type)
        sql += "OFF";
    else if(1 == type)
        sql += "NORMAL";
    else if(2 == type)
        sql += "FULL";

    sql += ";";

    return exec_callback(sql);
}

//transaction
bool SQL3Base::begin_transaction()
{
    std::string sql = "BEGIN;";
    return exec_callback(sql);
}
bool SQL3Base::commit_transaction()
{
    std::string sql = "COMMIT;";
    return exec_callback(sql);
}
bool SQL3Base::rollback_transaction()
{
    std::string sql = "ROLLBACK;";
    return exec_callback(sql);
}

bool SQL3Base::exec_callback(const std::string& sql, db_ccb cb, void* data)
{
    if(!m_db)
        return false;
    char* errmsg = nullptr;
    int ret = sqlite3_exec(m_db, sql.c_str(), cb, data, &errmsg);
    if(SQLITE_OK == ret)
        return true;
    //cout << "Error, exec sql:" << sql << ", errmsg: " << errmsg << endl;
    sqlite3_free(errmsg);
    return false;
}


class SQL3CbCxx
{
    using cbcxx = SQL3Base::db_cxxcb;
public:
    SQL3CbCxx(const SQL3Base::db_cxxcb& cb, void* data)
        : m_cbcxx(cb), m_data(data){}
    int do_cxxcb(int argc, char** argv, char** azcolname)
        { return m_cbcxx(m_data, argc, argv, azcolname); }
protected:
    cbcxx m_cbcxx;
    void* m_data;
};

static int sqlbase_callback(void*data, int argc, char** argv, char** azcolname)
{
    if(nullptr == data)
        return -1;
    SQL3CbCxx* p = static_cast(data);
    return p->do_cxxcb(argc, argv, azcolname);
}

bool SQL3Base::exec_callback(const std::string& sql, db_cxxcb cb, void* data)
{
    SQL3CbCxx cb_cxx(cb, data);
    if(!m_db)
        return false;
    char* errmsg = nullptr;
    int ret = sqlite3_exec(m_db, sql.c_str(), sqlbase_callback, &cb_cxx, &errmsg);
    if(SQLITE_OK == ret)
        return true;
    //cout << "Error, exec sql:" << sql << ", errmsg: " << errmsg << endl;
    sqlite3_free(errmsg);
    return false;
}


bool SQL3Base::exec_table(const std::string& sql, int& row, int& column, db_values &values)
{
    if(!m_db)
        return false;

    //cout << sql << endl;

    char* errmsg = nullptr;
    char** result = nullptr;

    int ret =  sqlite3_get_table(m_db, sql.c_str(), &result, &row, &column, &errmsg);
    if(SQLITE_OK != ret)
    {
        //cout << "Error, exec_sync sql: " << sql << ", errmsg: " << errmsg << endl;
        sqlite3_free(errmsg);
        return false;
    }

    //first row is name; if row is 9, data is from row1 to row9
    for(int r = 0; r <= row; ++r)
    {
        db_column dc;
        for(int c = 0; c < column; ++c)
            dc.emplace_back(result[r * column + c]);
        values.push_back(dc);
    }
    sqlite3_free_table(result);
    return true;
}



//string err
std::string SQL3Base::err_string()
{
    if(m_db == nullptr)
        return "database:" + m_filepath + " is not open.";
    return sqlite3_errmsg(m_db);
}

std::string SQL3Base::sql_string(int value)
{
    return std::to_string(value);
}
std::string  SQL3Base::sql_string(const std::string& value)
{
    return "'" + value + "'";
}

void SQL3Base::show_db_values(const db_values& value)
{
    for(const auto& dc : value)
    {
        for(const auto& s : dc)
            cout << s << 't';
        cout << endl;
    }
}

希望能给大家带来帮助，如果有错误的地方烦请留言， 看到了会改的。