基于sqlitecpp的sqlite3 c++封装

Github: 人富水也甜

感谢GitHub大佬: 

sqlitecpp github:  https://github.com/SRombauts/SQLiteCpp  

sqlite: https://www.sqlite.org/index.html

 

0、特别说明:

  1、因为封装中引入了 c++11 的相关特性,请选择  支持c++11及以上的编译器。  

  2、目前,我是用的sqlite 版本: sqlite-amalgamation-3320300

  3、 目前,封装基于以下的环境: 

1. Visual Studio
    A. Microsoft Visual Studio Enterprise 2015
    B. version- 14.0.25431.01 Update 3
    C. Microsoft .NET Framework
    D. version-4.8.03752

2.OS: 
    A. Microsoft Windows 10 Professional
    B. version-    10.0.18363 version 18363

 

 

1、为什么要做这个封装

  A、截至目前,阅读 SQLitecpp    的源码后 会发现,CMakeLists.txt 没有生成动态库的配置, 我重新配置CMakeLists.txt, 生成了动态库,但是没有导出接口,自然 没有 适用 windows下的lib文件。 

  B、 团队合作,难免环境不太一样,而且还要考虑兼容和代码维护, 静态库 的确不适合我目前的需求。 

  C、 源码编译到项目,当自己有所变更,则需要将源码文件提供给调用者,这就更麻烦了。 每次有所变更都需要重新编译,维护工作量可想而知。

  D、 保护“核心模块”。

  E、 我喜欢用sqlite数据库作为项目的配置文件, 管理方便,个人经验: 相比I NI 和 XML 好多了。 

  F、 2年前就写过基于sqlite3的源码读写封装,但是,存放在了公司,公司不支持导出。 哈哈, 自己手上没有, 当时 还用 QT 做了 基于sqlite数据库的配置工具(可以在这里下载源码: https://github.com/mohistH/sqlite3_database_helper  ), 这个工具是自己写好导入公司的,手头有原件。

 

2、提交到github

  A、截至目前,我之做了 win10下的动态库,晚点会补上 CMake + MAC 的更新。 

  B、 动态库提供的接口基本上都做了测试,但是, 肯定有遗漏,  欢迎 留言指正。

  C、注释的内容可能看不懂(英语太菜) ,但是,正在努力完善。

  D、项目地址: https://github.com/mohistH/SQLiteCpp

 

3、接口说明

  目前,我自己导出了以下接口,可继续扩展。

  A、初始化, 支持 sqlite_open 和 sqlite_open_v2

        /* @ brief: initial some params, and it will call sqlite_open_v2 to open db file
        *  @ const std::string & db_file - where is the .db file. such as: "c:/sqlite/demo.db"
        *  @ const sqlite3_open_with open_type - 1:read_only, 2 - read_write, 4 - create, if this param cannot be found the definition, it will reset 1;
        *  @ const int busy_time_out - busy time out, default is 0;
        *  @ const std::string & vfs - // std::string& out_str_exception
        *  @ std::string& out_str_exception - error msg. out_str_exception will record the error information if initial database occur error
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - db_file is empty
                2 - db_file is not exist
                3 - internal error, create _pdatabase object failed
                4 - initial error, check the param [out_str_exception] to get error information
        */
        int init_v2(const std::string db_file, std::string& out_str_exception, const sqlite3_open_with open_type = OPEN_READONLY, const int busy_time_out = 0, const std::string& vfs = "");
        // this function will call sqlite_open to open db file
        int init(const std::string db_file, std::string& out_str_exception, const sqlite3_open_with open_type = OPEN_READONLY);

  B、 释放, 调用 下面的函数完成 动态库内部的自源释放

       int uninit();

   C、 查询表是否存在

int table_exist(const std::string table_name);

  D、 快速获取 表中某个数据

int get_single_value(const std::string str_query, std::string& str_result, std::string& out_str_exception);

  E、获取当前操作的数据库文件, 含文件全路径

int get_db_file_name(std::string& str_db_file_name, std::string& out_str_exception);

  F、 查询

     1)、查询表的某1列的名称

int get_table_column_name(const unsigned int in_column_index, std::string& out_str_name, std::string& out_str_exception);

     2)、 重置statement

int reset(std::string& out_str_exception);

    3)、查询表一共有几列

int get_table_column_count(unsigned int& out_total_column_count, std::string& out_str_err);

    4)、 查询对name对应的索引

int get_index(const std::string name, unsigned int& out_index);

    5)、 下面是关于查询需要用到的绑定,提供了相应的接口

        int bind(const int in_index, const int in_value, std::string& out_str_exception);

        int bind(const int in_index, const unsigned  in_value, std::string& out_str_exception);

        int bind(const int in_index, const long  in_value, std::string& out_str_exception);

        int bind(const int in_index, const long long in_value, std::string& out_str_exception);
        
        int bind(const int in_index, const double   in_value, std::string& out_str_exception);

        int bind(const int in_index, const std::string  in_value, std::string& out_str_exception);

        int bindNoCopy(const int in_index, const std::string in_value, std::string& out_str_exception);

        int bind(const int in_index, std::string& out_str_exception);

        int bind(const std::string name, const int in_value, std::string& out_str_exception);

        int bind(const std::string name, const unsigned   in_value, std::string& out_str_exception);

        int bind(const std::string name, const long   in_value, std::string& out_str_exception);

        int bind(const std::string name, const long long       in_value, std::string& out_str_exception);

        int bind(const std::string name, const double          in_value, std::string& out_str_exception);

        int bind(const std::string name, const std::string    in_value, std::string& out_str_exception);

        int bindNoCopy(const std::string name, const std::string in_value, std::string& out_str_exception);

        int bind(const std::string name, std::string& out_str_exception); 

    6)、 解除绑定,与上面 5) 对应使用

int clear_bindinds(std::string& out_str_exception);

    7)、 执行 查询sql语句专用函数。 必须要调用这个函数,调用  1)  2) 3) 4) 5) 6) 中的函数才能有值

int exec_query_sql(const std::string in_str_query_sql, std::string& out_str_exception);

    8)、 对表的管理: 创建、删除、更新、插入 则需要使用下面的函数:

int exec_db_sql(const std::string in_str_db_sql, int& out_result_row, std::string& out_str_exception);

    9)、 查询数据时使用

bool exec_query_step();
int exec_query_step(std::string& out_str_exception);

  

    10)、 返回查询结果对应的类型

        int get_column_int(const unsigned int in_column_index,        int& out_val,            std::string& out_str_exception);
        int get_column_double(const unsigned int in_column_index,    double& out_val,        std::string& out_str_exception);
        int get_column_uint(const unsigned int in_column_index,        unsigned int& out_val,    std::string& out_str_exception);
        int get_column_int64(const unsigned int in_column_index,    long long& out_val,        std::string& out_str_exception);
        int get_column_string(const unsigned int in_column_index,    std::string& out_val,    std::string& out_str_exception);

    11) 、事务

int commit(std::string& out_str_exception);

    12)、 查询可执行程序当前所在路径,例如: C;\\user\\demo  

static std::string get_exec_path();

 

4、接口头文件源码

#ifndef _hsqlite_db_h
#define _hsqlite_db_h


#include <iostream>
#include <memory>

#if defined (_WIN32) 

    #ifndef _sqlite_db_api_export_
        #define _sqlite_db_api_export_    __declspec(dllexport)
    #else
        #define _sqlite_db_api_export_    __declspec(dllimport)
    #endif // !_sqlite_db_api_export_

#else
    
    #define _sqlite_db_api_export_ __attribute__((visibility ("default")))
#endif // !



namespace sqlite_db
{

    class hsqlite_db_imp;

    /*
    *    @ brief: a helper to use sqlite database. It bases on SQLitecpp , 
                which is an openning source on github [https://github.com/SRombauts/SQLiteCpp]
    */
    class _sqlite_db_api_export_ hsqlite_db
    {

    public:
        // 
        enum sqlite3_open_with
        {
            OPEN_READONLY         = 0x00000001,  /* Ok for sqlite3_open_v2() */
            OPEN_READWRITE       = 0x00000002,  /* Ok for sqlite3_open_v2() */
            OPEN_CREATE          = 0x00000004,  /* Ok for sqlite3_open_v2() */
            OPEN_DELETEONCLOSE   = 0x00000008,  /* VFS only */
            OPEN_EXCLUSIVE       = 0x00000010,  /* VFS only */
            OPEN_AUTOPROXY       = 0x00000020,  /* VFS only */
            OPEN_URI             = 0x00000040,  /* Ok for sqlite3_open_v2() */
            OPEN_MEMORY          = 0x00000080,  /* Ok for sqlite3_open_v2() */
            OPEN_MAIN_DB         = 0x00000100,  /* VFS only */
            OPEN_TEMP_DB         = 0x00000200,  /* VFS only */
            OPEN_TRANSIENT_DB    = 0x00000400,  /* VFS only */
            OPEN_MAIN_JOURNAL    = 0x00000800,  /* VFS only */
            OPEN_TEMP_JOURNAL    = 0x00001000,  /* VFS only */
            OPEN_SUBJOURNAL      = 0x00002000,  /* VFS only */
            OPEN_MASTER_JOURNAL  = 0x00004000,  /* VFS only */
            OPEN_NOMUTEX         = 0x00008000,  /* Ok for sqlite3_open_v2() */
            OPEN_FULLMUTEX       = 0x00010000,  /* Ok for sqlite3_open_v2() */
            OPEN_SHAREDCACHE     = 0x00020000,  /* Ok for sqlite3_open_v2() */
            OPEN_PRIVATECACHE    = 0x00040000,  /* Ok for sqlite3_open_v2() */
            OPEN_WAL             = 0x00080000,  /* VFS only */
        };

    public:
        explicit hsqlite_db();

        // it will call  uninit to ensure that _psqlite_db_imp releases
        virtual ~hsqlite_db();

        hsqlite_db(const hsqlite_db &instance) = delete;
        hsqlite_db & operator = (const hsqlite_db &instance) = delete;
        // -------------------------------------------------------------------------------

        // -------------------------------------------------------------------------------
        //
        // initialization
        //
        // -------------------------------------------------------------------------------

        /* @ brief: initial some params, and it will call sqlite_open_v2 to open db file
        *  @ const std::string & db_file - where is the .db file. such as: "c:/sqlite/demo.db"
        *  @ const sqlite3_open_with open_type - 1:read_only, 2 - read_write, 4 - create, if this param cannot be found the definition, it will reset 1;
        *  @ const int busy_time_out - busy time out, default is 0;
        *  @ const std::string & vfs - // std::string& out_str_exception
        *  @ std::string& out_str_exception - error msg. out_str_exception will record the error information if initial database occur error
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - db_file is empty
                2 - db_file is not exist
                3 - internal error, create _pdatabase object failed
                4 - initial error, check the param [out_str_exception] to get error information
        */
        int init_v2(const std::string db_file, std::string& out_str_exception, const sqlite3_open_with open_type = OPEN_READONLY, const int busy_time_out = 0, const std::string& vfs = "");
        // this function will call sqlite_open to open db file
        int init(const std::string db_file, std::string& out_str_exception, const sqlite3_open_with open_type = OPEN_READONLY);



        /* @ brief: call this function to release resource before quitting
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success , the default result is 0;
        */
        int uninit();


        /* @ brief: check if the table_me exists
        *  @ const std::string table_name - table name
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - table is contained in the database
                1 - false, the database doesnt have that table
                2 - failed, the param [tabl_name] is empty
                3 - failed, internal error(_pdatabase is nullptr)
        */
        int table_exist(const std::string table_name);



        /* @ brief: Get a single value result with an easy to use shortcut
        *  @ const std::string str_query - sql string to query, for example, "SELECT value FROM test WHERE id=2"
        *  @ std::string& str_result - the query's result
        *  @ std::string out_str_exception - error msg
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - querry success
                1 - failed, the param [str_query] is empty
                2 - failed, internal error(_pdatabase is nullptr)
        */
        int get_single_value(const std::string str_query, std::string& str_result, std::string& out_str_exception);


        /* @ brief: query the database's name of current operation
        *  @ std::string & str_db_file_name - return the name of db file's name
        *  @ std::string & out_str_exception - save error msg if sth gets wrong
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success, and this is a flag to open db file successfully
                1 - failed, internal error, the object of the db file is nullptr
        */
        int get_db_file_name(std::string& str_db_file_name, std::string& out_str_exception);


        // -------------------------------------------------------------------------------

        /* @ brief: Reset the statement to make it ready for a new execution
        *  @ std::string & out_str_exception - error msg
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, please check [out_str_exception] to get more details
        */
        int reset(std::string& out_str_exception);


        /* @ brief: get column's name
        *  @ const unsigned int & in_column_index - index of column
        *  @ std::string & out_str_name - column's name
        *  @ std::string & out_str_exception - error msg
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - an error occurs, please check [out_str_exception] to get more details
        */
        int get_table_column_name(const unsigned int in_column_index, std::string& out_str_name, std::string& out_str_exception);

        /* @ brief: get total rows of the table.
        *  @ unsigned int & out_total_column_count - the total row count
        *  @ std::string & out_str_exception - error msg
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - an error occur, please check [out_str_exception] to get more details
        */
        int get_table_column_count(unsigned int& out_total_column_count, std::string& out_str_err);

        /* @ brief: get name's index
        *  @ const std::string & name - the name of idex 
        *  @ unsigned int& out_index - the result of index
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - falied, it doesnt initialize db file
                2 - failed, name is empty
        */
        int get_index(const std::string name, unsigned int& out_index);


        ///------------------------ bind start---------------------------------------------

        /* @ brief: Bind an int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *  std::string& out_str_erre -
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, const int in_value, std::string& out_str_exception);

        /**  
        * @brief Bind a 32bits unsigned int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, const unsigned  in_value, std::string& out_str_exception);

        /**
        * @brief Bind a 32bits long value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, const long  in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a 64bits int value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, const long long in_value, std::string& out_str_exception);


        /** 
        * @brief Bind a double (64bits float) value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, const double   in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a string value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *
        * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
        * @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, const std::string  in_value, std::string& out_str_exception);


        /** 
        * @brief Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *
        * Main usage is with null-terminated literal text (aka in code static strings)
        *
        * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement.
        * @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bindNoCopy(const int in_index, const std::string in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a NULL value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *
        * @see clearBindings() to set all bound parameters to NULL.
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const int in_index, std::string& out_str_exception);


        /**   
        * @brief Bind an int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, const int in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a 32bits unsigned int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, const unsigned   in_value, std::string& out_str_exception);


        /** 
        * @brief Bind a 32bits long value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, const long   in_value, std::string& out_str_exception);

        /* @brief Bind a 64bits int value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, const long long       in_value, std::string& out_str_exception);

        /* @brief Bind a double (64bits float) value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, const double          in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *
        * @note Uses the SQLITE_TRANSIENT flag, making a copy of the data, for SQLite internal use
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, const std::string    in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a string value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *
        * The string can contain null characters as it is binded using its size.
        *
        * @warning Uses the SQLITE_STATIC flag, avoiding a copy of the data. The string must remains unchanged while executing the statement.
        * @ return - int
            -1 - failed, _psqlite_db_imp is nullptr
            0 - success
            1 - failed, it doesnt initialize db file
            2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bindNoCopy(const std::string name, const std::string in_value, std::string& out_str_exception);

        /** 
        * @brief Bind a NULL value to a named parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement (in_index >= 1)
        *
        * @see clearBindings() to set all bound parameters to NULL.
        * @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, it doesnt initialize db file
                2 - failed, an error occurs, check [out_str_exception] to get more details
        */
        int bind(const std::string name, std::string& out_str_exception); // bind NULL value

        // ------------- bind end    ----------------------------------------------------



        /* @ brief: clear bindings
        *  @ std::string & out_str_exception - error msg
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed,  it doesnt initialize db file
                2 - failed, an error occurs, please check [out_str_exception] to get more details
        */
        int clear_bindinds(std::string& out_str_exception);




        // -------------------------------------------------------------------------------
        //
        // excutes sql string
        //
        // -------------------------------------------------------------------------------

        /* @ brief: the following function has the these functioms:  create and drop tables, insert and update a row.
        and it will not work with querying data
        *  @ const std::string  in_str_db_sql - sql string
        *  @ std::string & out_str_exception - exceptional string
        *  @ int& out_result_row - Return the number of rows modified by those SQL statements (INSERT, UPDATE or DELETE only)
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                -2 - failed, there is no database file from initialising
                -3 - falied, [in_str_db_sql] is empty
                -4 - failed, internal error, the object to communicate with database file was created failed
        */
        int exec_db_sql(const std::string in_str_db_sql, int& out_result_row, std::string& out_str_exception);



        /* @ brief: query data only
        *  @ const std::string in_str_query_sql - query string of sql
        *  @ std::string & out_str_exception - if an excpetion occurs, you could check the param to get error's detail
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
        */
        int exec_query_sql(const std::string in_str_query_sql, std::string& out_str_exception);


        /* @ brief: you must run the function [exc_query_sql] , then you could call the following function ,
        it will get the next column after  returnning true;
        Note: if the object do not created, it also returns false
        *  @ return - bool
                true 
                false - failed, _psqlite_db_imp is nullptr
                false - it gets end, or dont initialise the db file and call the [exc_query_sql] function
        */
        bool exec_query_step();

        /* @ brief: to query the data from the next column
        *  @ std::string & out_str_exception - if an error occurs, you could check the param [out_str_exception] to get details
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, dont initialise the db file and call the [exc_query_sql] function firstly
                2 - failed, please to check the param out_str_exception to get details
        */
        int exec_query_step(std::string& out_str_exception);

        /*    @ brief: get the column value
        *    @ const unsigned int in_column_index - which column do you wanna get, it starts zero
        *    @ T& out_val - the value
        *    @ std::string& out_str_exception - if an error occurs, check it to get more details
        *    return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, dont initialise the db file and call the [exc_query_sql] function firstly
                2 - failed, an error occured, please check the [out_str_exception] to get details
                3 - failed, it doesnt get any column or in_column_index is out of this range
        */
        int get_column_int(const unsigned int in_column_index,        int& out_val,            std::string& out_str_exception);
        int get_column_double(const unsigned int in_column_index,    double& out_val,        std::string& out_str_exception);
        int get_column_uint(const unsigned int in_column_index,        unsigned int& out_val,    std::string& out_str_exception);
        int get_column_int64(const unsigned int in_column_index,    long long& out_val,        std::string& out_str_exception);
        int get_column_string(const unsigned int in_column_index,    std::string& out_val,    std::string& out_str_exception);


        // -------------------------------------------------------------------------------
        //
        //  transaction
        //
        // -------------------------------------------------------------------------------

        /* @ brief: Commit the transaction
        *  @ std::string & out_str_exception - if an error occurs, check this param to get more details
        *  @ return - int
                -1 - failed, _psqlite_db_imp is nullptr
                0 - success
                1 - failed, do not initialize database file
                2 - failed, an error occurs, please check the [out_str_exception] to get more details
        */
        int commit(std::string& out_str_exception);

    private:
        hsqlite_db_imp *_psqlite_db_imp = nullptr;
        //std::unique_ptr<hsqlite_db_imp > _psqlite_db_imp;

    };





    // -------------------------------------------------------------------------------
    //
    // util's set 
    //
    // -------------------------------------------------------------------------------

    class _sqlite_db_api_export_ util_set
    {
    public:
        enum
        {
            // the max length of path
            path_max_len_256 = 256,
        };

        util_set(const util_set& instance) = delete;
        util_set& operator = (const util_set& instance) = delete;
        // -------------------------------------------------------------------------------
        
        /* @ brief: it will return the path of executables, such as on windows: c:\demo\sqlite3
                    on linux or mac: Users/xx/Desktop/sqlite.
        *  @ return - std::string
                the  executables' path. the max lenth is 255 chars.
        */
        static std::string get_exec_path();


    private:
        explicit util_set();
        virtual ~util_set() {};
    };

}

#endif // !_hsqlite_db_h

 

5、示例:

  A、 测试的表内容:

    B、示例源码

    unique_ptr<sqlite_db::hsqlite_db> psqlite_db(new sqlite_db::hsqlite_db);

    if (nullptr == psqlite_db)
    {
        std::cout << "error, create psqlite_db failed" << std::endl;
        return 0;
    }

    // get the current executable path    
    std::string str_path = sqlite_db::util_set::get_exec_path();
    str_path += std::string("\\mydatabase.sqlite");
    std::string str_err;

    // 2、inittial 
    int ret_val = psqlite_db->init(str_path, str_err);

#ifndef _use_example_2_

    if (0 != ret_val)
    {
        cout << "initialise database failed, ret = " << ret_val << endl;
    }
    else
    {
        std::string str_query("SELECT * FROM test");
        std::string str_err;

        // 当前表的总列数
        unsigned int total_count_row = 0;
            
        // 执行查询sql
        int ret_query = psqlite_db->exec_query_sql(str_query, str_err);
        if (0 != ret_query)
        {
            cout << " query failed, ret_val = " << ret_query << endl;
        }
        else
        {
            // 获取表的列总数
            ret_val = psqlite_db->get_table_column_count(total_count_row, str_err);
            cout << "ret_val = " << ret_val << ",     total_row_count = " << total_count_row << "\n\n\n";

            std::string str_value;
            std::string str_name;
            std::string str_mark;
            std::string str_id;
            
            // 查询表内容
            cout << "\n\n\n first time to query:\n";
            while (psqlite_db->exec_query_step())
            {
                ret_query = psqlite_db->get_column_string(0, str_id,    str_err);
                ret_query = psqlite_db->get_column_string(1, str_name,    str_err);
                ret_query = psqlite_db->get_column_string(2, str_value, str_err);
                ret_query = psqlite_db->get_column_string(3, str_mark,    str_err);


                cout << "id = " << str_id.c_str() << ",        ";
                cout << "name = " << str_name.c_str() << ",        ";
                cout << "value = " << str_value.c_str() << ",    ";
                cout << "mark = " << str_mark.c_str() << endl;
            }

            // 重置以待再次查询该表 
            psqlite_db->reset(str_err);

            // 第二次查询
            cout << "\n\n\n second time to query:\n";
            bool ret_val2 = psqlite_db->exec_query_step();
            while (ret_val2)
            {
                ret_query = psqlite_db->get_column_string(0, str_id, str_err);
                ret_query = psqlite_db->get_column_string(1, str_name, str_err);
                ret_query = psqlite_db->get_column_string(2, str_value, str_err);
                ret_query = psqlite_db->get_column_string(3, str_mark, str_err);


                cout << "id = " << str_id.c_str() << ",        ";
                cout << "name = " << str_name.c_str() << ",        ";
                cout << "value = " << str_value.c_str() << ",    ";
                cout << "mark = " << str_mark.c_str() << endl;

                ret_val2 = psqlite_db->exec_query_step();
            }
        }
    }

  psqlite_db->uninit();

  C、 程序执行结果:

    

6、第一版release

  编译环境及版本:

   字符集: Unicode 字符集

the dynamic library bases on the following environment:

1. Visual Studio
    A. Microsoft Visual Studio Enterprise 2015
    B. version- 14.0.25431.01 Update 3
    C. Microsoft .NET Framework
    D. version-4.8.03752

2.OS: 
    A. Microsoft Windows 10 Professional
    B. version-    10.0.18363 version 18363
    
3. slqite version
    sqlite-amalgamation-3320300

4. Note
    Please select the compiler, which supports c++11 or upper

 

  符合上面的条件,直接下载使用吧。下载地址:https://github.com/mohistH/SQLiteCpp/releases/tag/3.0.1 

 

posted @ 2020-08-08 13:40  mohist  阅读(5885)  评论(1编辑  收藏  举报