Linux c/c++ sqlite3 实用demo

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Acoolbest/article/details/52957238

/* ************************************************************************
 *       Filename:  sqlite3_demo.cpp
 *       g++ sqlite3_demo.cpp -lsqlite3  
 * ************************************************************************/

#include <string.h>
#include <stdio.h>
#include <map>
#include <sqlite3.h>
#include <stdint.h>
#include <iostream>

using namespace std;

#define INSTALL_APP_RESULT_DATABASE_TYPE    0x01
#define DEVICE_INFO_DATABASE_TYPE           0x02
#define CRG_FAIL                            0x0000      
#define CRG_SUCCESS                         0x0001
#define CRG_INVALID_PARAM                   0x0002
#define MAX_BUFF_LEN                        260
#define SQLITE3_DEMO                        "sqlite3_demo.db3"

typedef struct _INSTALL_APP_RESULT_LOG_STRUCT_
{
    uint32_t                                dw_dev_type;
    char                                    sz_log_times[MAX_BUFF_LEN];
}install_app_result_log_info, *p_install_app_result_log_info;

typedef struct _DEVICE_LOG_INFO_STRUCT_
{
    uint32_t                                dw_dev_type;
    char                                    sz_log_times[MAX_BUFF_LEN];
}device_log_info, *p_device_log_info;

typedef map <int, install_app_result_log_info> install_app_result_log_info_map;
typedef map <int, device_log_info> device_log_info_map;

pthread_mutex_t                             device_info_database_mutex;
pthread_mutex_t                             install_app_result_database_mutex;
sqlite3 * gp_db; 


static string get_insert_sql_for_install_app_result()
{
    return ("insert into AppResultLog(DevType, LogTimes) \
            values(?,?)");
}

static string get_insert_sql_for_device_info()
{
    return ("insert into DeviceInfoLog(DevType, LogTimes) \
            values(?,?)");
}

static string get_select_sql_for_install_app_result()
{
    return ("SELECT Id, DevType, LogTimes \
            FROM AppResultLog");
}

static string get_select_sql_for_Device_info()
{
    return ("SELECT Id, DevType, LogTimes \
            FROM DeviceInfoLog");
}

static string get_delete_sql_for_install_app_result(int dw_id)
{
    char sz_del[MAX_BUFF_LEN] = { 0 };
    snprintf(sz_del, MAX_BUFF_LEN, "DELETE FROM AppResultLog where Id = %d", dw_id);
    return string(sz_del);
}

static string get_delete_sql_for_device_info(int dw_id)
{
    char sz_del[MAX_BUFF_LEN] = { 0 };
    snprintf(sz_del, MAX_BUFF_LEN, "DELETE FROM DeviceInfoLog where Id = %d", dw_id);
    return string(sz_del);
}

static int create_database(int dw_type)
{
    string str;
    switch (dw_type)
    {
        case INSTALL_APP_RESULT_DATABASE_TYPE:
            str = "create table if not exists AppResultLog("
                "Id INTEGER  primary key,"
                "DevType int null, "
                "LogTimes string null)";

            break;
        case DEVICE_INFO_DATABASE_TYPE:
            str = "create table if not exists DeviceInfoLog("
                "Id INTEGER  primary key,"
                "DevType int null, "
                "LogTimes string null)";
            break;
        default:
            break;
    }

    char* err_msg;  

    int res= sqlite3_exec(gp_db , str.c_str() , 0 , 0 , &err_msg);  

    if (res != SQLITE_OK) {  
        printf("Execute SQL error : %s\n",err_msg);
        return CRG_FAIL;  
    }

    return CRG_SUCCESS;
}



static int insert_install_app_result_map(install_app_result_log_info_map* p_install_app_result_map, int dw_id, install_app_result_log_info &install_app_result_info)
{
    if (p_install_app_result_map == NULL)
        return CRG_INVALID_PARAM;

    pair<install_app_result_log_info_map::iterator, bool> insert_pair;

    insert_pair = p_install_app_result_map->insert(pair<int, install_app_result_log_info>(dw_id, install_app_result_info));

    return insert_pair.second ? CRG_SUCCESS : CRG_FAIL;
}

static int insert_device_info_map(device_log_info_map* p_dev_info_map, int dw_id, device_log_info &dev_info)
{
    if (p_dev_info_map == NULL)
        return CRG_INVALID_PARAM;

    pair<device_log_info_map::iterator, bool> insert_pair;

    insert_pair = p_dev_info_map->insert(pair<int, device_log_info>(dw_id, dev_info));

    return insert_pair.second ? CRG_SUCCESS : CRG_FAIL;
}

int push_device_info_to_database(device_log_info* p_dev_info)
{
    if (p_dev_info == NULL)
        return CRG_INVALID_PARAM;
    int ret = CRG_FAIL;
    pthread_mutex_lock(&device_info_database_mutex);
    sqlite3_stmt* pStmt = NULL;
    int rc = sqlite3_prepare_v2(gp_db , get_insert_sql_for_device_info().c_str() , get_insert_sql_for_device_info().length() , &pStmt , NULL);
    if(rc == SQLITE_OK)
    {
        sqlite3_bind_int(pStmt, 1, p_dev_info->dw_dev_type);
        sqlite3_bind_text(pStmt, 2, p_dev_info->sz_log_times, strlen(p_dev_info->sz_log_times), NULL);
        if(sqlite3_step(pStmt) == SQLITE_DONE)
        {   
            ret = CRG_SUCCESS;
        }else{
            printf("push_device_info_to_database faile\n");
        }       
    }
    if(pStmt)
    {
        sqlite3_finalize(pStmt);
    }
    pthread_mutex_unlock(&device_info_database_mutex);
    return ret;
}

int push_install_app_result_to_database(install_app_result_log_info* p_install_app_result_info)
{
    if (p_install_app_result_info == NULL)
        return CRG_INVALID_PARAM;

    int ret = CRG_FAIL;
    pthread_mutex_lock(&install_app_result_database_mutex);
    sqlite3_stmt* pStmt = NULL;
    int rc = sqlite3_prepare_v2(gp_db , get_insert_sql_for_install_app_result().c_str() ,get_insert_sql_for_install_app_result().length() , &pStmt , NULL);
    if(rc == SQLITE_OK)
    {
        sqlite3_bind_int(pStmt, 1, p_install_app_result_info->dw_dev_type);
        sqlite3_bind_text(pStmt, 2, p_install_app_result_info->sz_log_times, strlen(p_install_app_result_info->sz_log_times), NULL);

        if(sqlite3_step(pStmt) == SQLITE_DONE)
        {   
            ret = CRG_SUCCESS;
        }else{
            printf("push_insert_sql_for_install_app_result faile\n");
        }       
    }
    if(pStmt)
    {
        sqlite3_finalize(pStmt);
    }
    pthread_mutex_unlock(&install_app_result_database_mutex);
    return ret;
}

int pull_all_device_info_from_database(device_log_info_map* p_dev_info_map)
{
    if (p_dev_info_map == NULL)
        return CRG_INVALID_PARAM;

    int ret = CRG_FAIL;

    pthread_mutex_lock(&device_info_database_mutex);

    sqlite3_stmt* stmt = 0;  
    int rc = sqlite3_prepare_v2(gp_db, get_select_sql_for_Device_info().c_str(), -1, &stmt, 0); 
    if (rc != SQLITE_OK)  
    {  
        printf("pull_all_device_info_from_database,  %s\n", sqlite3_errmsg(gp_db));    
        return ret;    
    }  

    //int  ncolumn = sqlite3_column_count(stmt);  

    while (sqlite3_step(stmt) == SQLITE_ROW)
    {
        int dw_id = 0;
        const unsigned char* str = NULL;
        device_log_info DeviceInfo = {0};
        dw_id = sqlite3_column_int(stmt,0);
        DeviceInfo.dw_dev_type = sqlite3_column_int(stmt,1);
        str = sqlite3_column_text(stmt,2);
        if (str != NULL)
            memcpy(DeviceInfo.sz_log_times, str, strlen((const char*)str));

        ret = insert_device_info_map(p_dev_info_map, dw_id, DeviceInfo);
    }

    sqlite3_finalize(stmt); 
    pthread_mutex_unlock(&device_info_database_mutex);
    return ret;
}

int pull_all_install_app_result_from_database(install_app_result_log_info_map* p_install_app_result_map)
{
    if (p_install_app_result_map == NULL)
        return CRG_INVALID_PARAM;

    int ret = CRG_FAIL;

    pthread_mutex_lock(&install_app_result_database_mutex);

    sqlite3_stmt* stmt = 0;  
    int rc = sqlite3_prepare_v2(gp_db, get_select_sql_for_install_app_result().c_str(), -1, &stmt, 0); 
    if (rc != SQLITE_OK)  
    {  
        printf("[LOGERROR] pull_all_install_app_result_from_database,  %s\n", sqlite3_errmsg(gp_db));    
        return ret;    
    }  

    //int  ncolumn = sqlite3_column_count(stmt);  

    while (sqlite3_step(stmt) == SQLITE_ROW)
    {
        int dw_id = 0;
        const unsigned char* str = NULL;
        install_app_result_log_info AppResultInfo = {0};

        dw_id = sqlite3_column_int(stmt,0);
        AppResultInfo.dw_dev_type = sqlite3_column_int(stmt,1);
        str = sqlite3_column_text(stmt,2);
        if (str != NULL)
            memcpy(AppResultInfo.sz_log_times, str, strlen((const char*)str));

        ret = insert_install_app_result_map(p_install_app_result_map, dw_id, AppResultInfo);
    }
    sqlite3_finalize(stmt); 
    pthread_mutex_unlock(&install_app_result_database_mutex);
    return ret;
}

int remove_install_app_result_from_database(int dw_id)
{
    int ret = CRG_FAIL;
    pthread_mutex_lock(&install_app_result_database_mutex);
    char* err_msg; 
    char sz_del[MAX_BUFF_LEN] = { 0 };
    snprintf(sz_del, MAX_BUFF_LEN, "%s", get_delete_sql_for_install_app_result(dw_id).c_str());
    int res= sqlite3_exec(gp_db , sz_del , 0 , 0 , &err_msg);  

    if (res != SQLITE_OK)  
    {  
        printf("Execute SQL error : %s\n",err_msg);
        return CRG_FAIL;  
    }else{
        ret = CRG_SUCCESS;
    }
    pthread_mutex_unlock(&install_app_result_database_mutex);

    return ret;
}

int remove_device_info_from_database(int dw_id)
{
    int ret = CRG_FAIL;
    pthread_mutex_lock(&device_info_database_mutex);
    char* err_msg; 
    char sz_del[MAX_BUFF_LEN] = { 0 };
    snprintf(sz_del, MAX_BUFF_LEN, "%s", get_delete_sql_for_device_info(dw_id).c_str());
    int res= sqlite3_exec(gp_db , sz_del , 0 , 0 , &err_msg);
    if (res != SQLITE_OK)  
    {  
        printf("Execute SQL error : %s\n",err_msg);
        return CRG_FAIL;  
    }else{
        ret = CRG_SUCCESS;
    }
    pthread_mutex_unlock(&device_info_database_mutex);
    return ret;
}

uint32_t init_database(char* p_db_name)
{   
    int res = sqlite3_open(p_db_name, &gp_db);
    if (res != SQLITE_OK){  
        printf("can't open database: %s\n",sqlite3_errmsg(gp_db));
        sqlite3_close(gp_db); 
        return CRG_FAIL;
    } 
    if (create_database(INSTALL_APP_RESULT_DATABASE_TYPE) == CRG_SUCCESS
            && create_database(DEVICE_INFO_DATABASE_TYPE) == CRG_SUCCESS)
    {
        pthread_mutex_init(&device_info_database_mutex, NULL);
        pthread_mutex_init(&install_app_result_database_mutex, NULL);
        return CRG_SUCCESS;
    }
    else 
    {
        sqlite3_close(gp_db);
        return CRG_FAIL;
    }
}

void destory_database()
{
    if(gp_db != NULL) sqlite3_close(gp_db);
    pthread_mutex_destroy(&device_info_database_mutex);
    pthread_mutex_destroy(&install_app_result_database_mutex);
}

int main()
{
    if(init_database((char *)SQLITE3_DEMO) != CRG_SUCCESS) return 1;

    char dev_log_time[] = "2016-10-28 14:12:16";
    char install_log_time[] = "2016-10-28 14:12:18";

    device_log_info p_dev_info;
    p_dev_info.dw_dev_type = 1;
    strcpy(p_dev_info.sz_log_times, dev_log_time);

    install_app_result_log_info p_install_app_result_info;
    p_install_app_result_info.dw_dev_type = 2;
    strcpy(p_install_app_result_info.sz_log_times, install_log_time);

//insert
    for(int i=0; i<3; i++)
    {
        push_install_app_result_to_database(&p_install_app_result_info);
        push_device_info_to_database(&p_dev_info);
    }
    getchar();
//select
    install_app_result_log_info_map install_app_result_map;

    if (pull_all_install_app_result_from_database(&install_app_result_map) == CRG_SUCCESS)
    {
        install_app_result_log_info_map::iterator iter;
        for (iter = install_app_result_map.begin(); iter != install_app_result_map.end();)
        {
//delete
            remove_install_app_result_from_database(iter->first);
            printf("delete install from sqlite3 : %d, %s\n", iter->second.dw_dev_type, iter->second.sz_log_times);
            install_app_result_map.erase(iter++);
            getchar();
        }
        install_app_result_map.clear();
        install_app_result_log_info_map(install_app_result_map).swap(install_app_result_map);
    }

    getchar();
//select
    device_log_info_map dev_info_map;

    if (pull_all_device_info_from_database(&dev_info_map) == CRG_SUCCESS)
    {
        device_log_info_map::iterator iter1;
        for (iter1 = dev_info_map.begin(); iter1 != dev_info_map.end();)
        {
//delete
            remove_device_info_from_database(iter1->first);
            printf("delete device from sqlite3 : %d, %s\n", iter1->second.dw_dev_type, iter1->second.sz_log_times);
            dev_info_map.erase(iter1++);
            getchar();
        }
        dev_info_map.clear();
        device_log_info_map(dev_info_map).swap(dev_info_map);
    }

    getchar();

    destory_database();
    return 0;
}