本地数据库 sqlite3 编译和使用-阿里云开发者社区

本地数据库 sqlite3 编译和使用

sqlite3

下载、编译、安装

下载

linux 环境下编译、安装

C/C++ 使用示例

sqlite3 C/C++ 接口

数据库创建/打开操作

数据库正常操作

创建表

删除表

插入语句

查询语句

条件查询语句

运算语句

更新语句

删除语句

关闭数据库操作

代码工程使用

添加 sqlite 库文件到工程下

修改 Cmake 配置文件

工程中代码使用

sqlite3

SQLite是一个C语言库，它实现了一个小型、快速、自包含、高可靠性、功能齐全的SQL数据库引擎。

SQLite是世界上使用最多的数据库引擎。SQLite内置于所有手机和大多数计算机中，并捆绑在人们每天使用的无数其他应用程序中。更多信息。。。

SQLite文件格式稳定、跨平台、向后兼容，开发人员承诺在2050年保持这种格式。SQLite数据库文件通常用作容器，在系统之间传输丰富的内容，并作为数据的长期存档格式[4]。目前有超过1万亿（1e12）个SQLite数据库在使用[5]。

SQLite源代码属于公共领域，每个人都可以自由地用于任何目的。

下载、编译、安装

下载

可以去 sqlite 官方网站：官方网站找到下载版本进行下载，也可以直接点击这里提供的下载链接（sqlite-snapshot-202108231028.tar）

linux 环境下编译、安装

将下载后的压缩包在 linux 操作系统环境下进行解压：

$ tar -xvf sqlite-snapshot-202108231028.tar.gz 
# 这里由于我需要 32 位的静态库，所以添加了 --enable-static 和 CC="gcc -m32" 参数
$ ../configure --enable-static --prefix=/home/ww/ww/gitlabproject/opcodetester/third/sqlite/ CC="gcc -m32"
$ make && make install

编译安装完成后，得到如下目录：

C/C++ 使用示例

使用 sqlite3 的整个过程其实和操作 MySQL 等数据库的方式是相同的，需要先创建或者打开本地数据库，然后就是通过数据库操作语法实现数据库的增删改查操作了。

sqlite3 C/C++ 接口

数据库创建/打开操作

首先，必须了解 sqlite3 的打开/创建数据库接口，具体使用方式参考如下代码：

sqlite3 *sql = NULL; // 一个打开的数据库实例
    const char * path = "test.db";//某个sql文件的路径
    // 根据文件路径打开数据库连接。如果数据库不存在，则创建。
    // 数据库文件的路径必须以C字符串传入。
    int result = sqlite3_open_v2(path, &sql, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL);
    // int result = sqlite3_open(path, &sql);
    if (result == SQLITE_OK) {
        std::cout << "打开数据库连接成功" << endl;;
    }
    else {
        std::cout << "打开数据库连接失败" << endl;
    }

通过函数 sqlite3_open_v2() 能够创建并且打开本地数据库，第一个参数是本地数据库的路径文件名。具体接口的声明如下：

SQLITE_API int sqlite3_open(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb          /* OUT: SQLite db handle */
);
SQLITE_API int sqlite3_open16(
  const void *filename,   /* Database filename (UTF-16) */
  sqlite3 **ppDb          /* OUT: SQLite db handle */
);
SQLITE_API int sqlite3_open_v2(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  int flags,              /* Flags */
  const char *zVfs        /* Name of VFS module to use */
);

数据库正常操作

通过打开数据库操作 sqlite3_open() 获得了 ppDb 的数据库对象（句柄），接下来就是将组织好的数据库操作语言使用接口函数对数据库进行操作

创建表

语法

CREATE TABLE 语句的基本语法如下：

CREATE TABLE database_name.table_name(
   column1 datatype  PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

CREATE TABLE 是告诉数据库系统创建一个新表的关键字。CREATE TABLE 语句后跟着表的唯一的名称或标识。您也可以选择指定带有 table_name 的 database_name。

实例

下面是一个实例，它创建了一个 COMPANY 表，ID 作为主键，NOT NULL 的约束表示在表中创建纪录时这些字段不能为 NULL：

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

下面是一个实例，它创建了一个 COMPANY 表，ID 作为主键，NOT NULL 的约束表示在表中创建纪录时这些字段不能为 NULL：

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

C/C++ 中使用

const char *sqlCreatetable = "CREATE TABLE t_person(name TEXT PRIMARY KEY NOT NULL, age INTEGER);";
    sqlite3_stmt *stmt = NULL;        //stmt语句句柄
    result = sqlite3_prepare_v2(sql, sqlCreatetable, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        std::clog<< "创建数据表成功" << endl;
        //执行该语句
        sqlite3_step(stmt);
    }
    else {
        std::clog << "创建数据表失败" << endl;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);

删除表

SQLite 的 DROP TABLE 语句用来删除表定义及其所有相关数据、索引、触发器、约束和该表的权限规范。（使用此命令时要特别注意，因为一旦一个表被删除，表中所有信息也将永远丢失。）

语法

DROP TABLE 语句的基本语法如下。您可以选择指定带有表名的数据库名称，如下所示：

DROP TABLE database_name.table_name;

实例

让我们先确认 COMPANY 表已经存在，然后我们将其从数据库中删除。

sqlite>.tables
COMPANY       test.COMPANY

这意味着 COMPANY 表已存在数据库中，接下来让我们把它从数据库中删除，如下：

sqlite>DROP TABLE COMPANY;
sqlite>

现在，如果尝试 .TABLES 命令，那么将无法找到 COMPANY 表了：

sqlite>.tables
sqlite>

显示结果为空，意味着已经成功从数据库删除表。

C/C++ 中使用

const char *sqlCreatetable = "DROP  TABLE  t_person;";
    sqlite3_stmt *stmt = NULL;        //stmt语句句柄
    result = sqlite3_prepare_v2(sql, sqlCreatetable, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        std::clog<< "删除数据表成功" << endl;
        //执行该语句
        sqlite3_step(stmt);
    }
    else {
        std::clog << "删除数据表失败" << endl;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);

插入语句

SQLite 的 INSERT INTO 语句用于向数据库的某个表中添加新的数据行。（这个表一定要先创建出来才可以正常执行插入数据）

语法

INSERT INTO 语句有两种基本语法，如下所示：

INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]  
VALUES (value1, value2, value3,...valueN);

在这里，column1, column2,…columnN 是要插入数据的表中的列的名称。

如果要为表中的所有列添加值，您也可以不需要在 SQLite 查询中指定列名称。但要确保值的顺序与列在表中的顺序一致。SQLite 的 INSERT INTO 语法如下：

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

实例

假设您已经在 testDB.db 中创建了 COMPANY表，如下所示：

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

现在，下面的语句将在 COMPANY 表中创建六个记录：

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

您也可以使用第二种语法在 COMPANY 表中创建一个记录，如下所示：

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

上面的所有语句将在 COMPANY 表中创建下列记录。下一章会教您如何从一个表中显示所有这些记录。

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

使用一个表来填充另一个表

您可以通过在一个有一组字段的表上使用 select 语句，填充数据到另一个表中。下面是语法：

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

C/C++ 中使用

const char *sqlSentence = "INSERT INTO t_person(name, age) VALUES('夏明', 22); ";        //SQL语句
    //进行插入前的准备工作——检查语句合法性
    //-1代表系统会自动计算SQL语句的长度
    result = sqlite3_prepare_v2(sql, sqlSentence, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        std::clog<< "添加数据语句OK" << endl;
        //执行该语句
        sqlite3_step(stmt);
    }
    else {
        std::clog << "添加数据语句有问题" << endl;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);

查询语句

SQLite 的 SELECT 语句用于从 SQLite 数据库表中获取数据，以结果表的形式返回数据。这些结果表也被称为结果集。

语法

SQLite 的 SELECT 语句的基本语法如下：

SELECT column1, column2, columnN FROM table_name;

在这里，column1, column2…是表的字段，他们的值即是您要获取的。如果您想获取所有可用的字段，那么可以使用下面的语法：

SELECT * FROM table_name;

实例

假设 COMPANY 表有以下记录：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

下面是一个实例，使用 SELECT 语句获取并显示所有这些记录。在这里，前两个个命令被用来设置正确格式化的输出。

sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;

最后，将得到以下的结果：

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

如果只想获取 COMPANY 表中指定的字段，则使用下面的查询：

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

上面的查询会产生以下结果：

ID          NAME        SALARY
----------  ----------  ----------
1           Paul        20000.0
2           Allen       15000.0
3           Teddy       20000.0
4           Mark        65000.0
5           David       85000.0
6           Kim         45000.0
7           James       10000.0

设置输出列的宽度

有时，由于要显示的列的默认宽度导致 .mode column，这种情况下，输出被截断。此时，您可以使用 .width num, num… 命令设置显示列的宽度，如下所示：

sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;

上面的 .width 命令设置第一列的宽度为 10，第二列的宽度为 20，第三列的宽度为 10。因此上述 SELECT 语句将得到以下结果：

ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

Schema 信息

因为所有的点命令只在 SQLite 提示符中可用，所以当您进行带有 SQLite 的编程时，您要使用下面的带有 sqlite_master 表的 SELECT 语句来列出所有在数据库中创建的表：

sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';

假设在 testDB.db 中已经存在唯一的 COMPANY 表，则将产生以下结果：

tbl_name
----------
COMPANY

您可以列出关于 COMPANY 表的完整信息，如下所示：

sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';

假设在 testDB.db 中已经存在唯一的 COMPANY 表，则将产生以下结果：

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
)

C/C++ 中使用

result = sqlite3_prepare_v2(sql, sqlSentence1, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        std::clog <<  "查询语句OK";
            // 每调一次sqlite3_step()函数，stmt语句句柄就会指向下一条记录
            while (sqlite3_step(stmt) == SQLITE_ROW) {
                // 取出第0列字段的值
                const unsigned char *name = sqlite3_column_text(stmt, 0);
                // 取出第1列字段的值
                int age = sqlite3_column_int(stmt, 1);
                //输出相关查询的数据
                std::clog << "name = " << name <<", age = "<< age << endl;
            }
    }
    else {
        std::clog << "查询语句有问题" << endl;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);

条件查询语句

运算语句

更新语句

删除语句

关闭数据库操作

在使用完成数据库后，最好正常关闭数据库，而 C/C++ 中关闭数据库的操作接口如下：

SQLITE_API int sqlite3_close(sqlite3*);
SQLITE_API int sqlite3_close_v2(sqlite3*);

代码中操作如下：

if (sql) 
    {
        sqlite3_close_v2(sql);
        sql = nullptr;
    }

代码工程使用

添加 sqlite 库文件到工程下

在工程目录 third 下创建 sqlite 库相关文件存放的目录路径 third/sqlite ，如下：

修改 Cmake 配置文件

# sqlite3
set(SQLITELIB_PATH ${PROJECT_SOURCE_DIR}/third/sqlite)
list(APPEND SQLITE_LIBS_INCLUDE ${SQLITELIB_PATH}/include)
list(APPEND SQLITE_LIBS_INCLUDE ${SQLITELIB_PATH}/include/log4c)
link_directories(${SQLITELIB_PATH}/lib)
link_libraries(sqlite3)
...
#添加头文件引用路径
target_include_directories(opcodetester PUBLIC
                           ${PROJECT_BINARY_DIR}
                           ${EXTRA_INCLUDE}
                           ${SQLITE_LIBS_INCLUDE }
            )

工程中代码使用

这里首先是在一个测试程序中用到了数据库（针对X86 opcode 指令集测试），所以将设计如下的数据表内容：

数据名称类型含义

instruction 字符类型【助记符名称】测试指令对应的助记符名称，例如 “ADD” “SUB” “CMP” 等

opcode 字节类型【opcode】这条指令对应的 opcode ，Opcode 可能存在不止一个字节，所以这里需要存放一组字节数据

true_result 数据类型 REAL 【正确执行结果】该指令在 X86 机器上运行的计算结果，作为测试结果是否正确的评定标准

param1 数据类型 REAL 参数1 该指令在使用时所需的参数1

param2 数据类型 REAL 参数1 该指令在使用时所需的参数2

param3 数据类型 REAL 参数1 该指令在使用时所需的参数3

param4 数据类型 REAL 参数1 该指令在使用时所需的参数4

创建数据库和构造的相关代码如下：

#ifndef     _COMMON_DATABASE__H
#define     _COMMON_DATABASE__H
#include "sqlite3.h"
#include "base.hpp"
#include "debug.hpp"
class Database
{
private:
    sqlite3         *sql;
    sqlite3_stmt    *stmt;
    char            *mydbfilename;
public:
    Database(const char *dbfilename = "test.db");
    ~Database();
    int insert(const char *ins, const char *op, double *result);
    int selectIns(const char *ins, const char *opcode, double* &result);
private:
    int myDataOpen(const char *dbfilename);
    bool myDataClose(void);
    bool myDataCreateTable(void);
    bool myDataDropTable(void);
    bool myDataInsetData(const char *instruction, const char *opcode, double *true_reslut);
    bool myDataSelectData(void);
};
int Database::selectIns(const char *ins, const char *opcode, double* &result)
{
    int ret = 0;
    const char *sqlSentence1 = "SELECT * FROM t_opcode WHERE instruction == '%s' AND  opcode == '%s';";    //SQL语句
    char select_buf[1024] = {0};
    sprintf(select_buf, sqlSentence1, ins, opcode);
    //进行查询前的准备工作——检查语句合法性
    //-1代表系统会自动计算SQL语句的长度
    ret = sqlite3_prepare_v2(sql, select_buf, -1, &stmt, NULL);
    if (ret == SQLITE_OK) {
        Log.INFO("查询语句OK");
        // 每调一次sqlite3_step()函数，stmt语句句柄就会指向下一条记录
        while (sqlite3_step(stmt) == SQLITE_ROW) 
        {
            result[0] = sqlite3_column_double(stmt, 2);
            result[1] = sqlite3_column_double(stmt, 3);
            result[2] = sqlite3_column_double(stmt, 4);
            result[3] = sqlite3_column_double(stmt, 5);
        }
    }
    else {
        Log.INFO("查询语句有问题");
        return -1;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);
    return 0;
}
int Database::insert(const char *ins, const char *op, double *result)
{
    myDataInsetData(ins, op, result);
    return 0;
}
bool Database::myDataSelectData(void)
{
    int result = 0;
    const char *sqlSentence1 = "SELECT * FROM t_opcode WHERE age < 30;";    //SQL语句
    std::string tmp;
    char buf[1024] = {0};
    //进行查询前的准备工作——检查语句合法性
    //-1代表系统会自动计算SQL语句的长度
    result = sqlite3_prepare_v2(sql, sqlSentence1, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        Log.INFO("查询语句OK");
        // 每调一次sqlite3_step()函数，stmt语句句柄就会指向下一条记录
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            // 取出第0列字段的值
            const unsigned char *Instruction = sqlite3_column_text(stmt, 0);
            // 取出第1列字段的值
            const unsigned char *opcode = sqlite3_column_text(stmt, 1);
            float true_result0 = sqlite3_column_double(stmt, 2);
            float true_result1 = sqlite3_column_double(stmt, 2);
            float true_result2 = sqlite3_column_double(stmt, 2);
            float true_result3 = sqlite3_column_double(stmt, 2);
            //输出相关查询的数据
            sprintf(buf, "Instruction = [%s], opcode = [%s] true_result = %f - %f - %f - %f ", \
                        Instruction, opcode, true_result0, true_result1, true_result2, true_result3);
            tmp = std::string(buf);
            Log.INFO(tmp);
        }
    }
    else {
        Log.INFO("查询语句有问题");
        return false;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);
    return true;
}
bool Database::myDataInsetData(const char *instruction, const char *opcode, double *true_reslut)
{
    int result = 0;
    const char *sqlSentence = \
        "INSERT INTO t_opcode(instruction, opcode, true_result0, true_result1, true_result2, true_result3) VALUES ('%s', '%s', %f, %f, %f, %f);";        //SQL语句
    char insert_buf[1024] = {0};
    sprintf(insert_buf, sqlSentence, instruction, opcode, true_reslut[0], true_reslut[1], true_reslut[2], true_reslut[3]);
    //进行插入前的准备工作——检查语句合法性
    //-1代表系统会自动计算SQL语句的长度
    result = sqlite3_prepare_v2(sql, insert_buf, -1, &stmt, NULL);
    if (result == SQLITE_OK) 
    {
        Log.INFO("添加数据语句OK");
        //执行该语句
        sqlite3_step(stmt);
    }
    else 
    {
        Log.INFO("添加数据语句有问题");
        return false;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);
    return true;
}
bool Database::myDataDropTable()
{
    int result = 0;
    const char *sqlCreatetable = "DROP  TABLE  t_opcode;";
    sqlite3_stmt *stmt = NULL;        //stmt语句句柄
    result = sqlite3_prepare_v2(sql, sqlCreatetable, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        Log.INFO("删除数据表成功");
        //执行该语句
        sqlite3_step(stmt);
    }
    else {
        Log.INFO("删除数据表失败");
        return false;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);
    return true;
}
bool Database::myDataCreateTable()
{
    int result = 0;
    /*
    instruction     指令助记符
    opcode          二进制opcode
    true_result0     保存计算结果
    true_result1     保存计算结果
    true_result2     保存计算结果
    true_result3     保存计算结果
    param1          计算参数。。。
    param2
    param3
    param4
    */
    const char *sqlCreatetable = 
        "CREATE TABLE t_opcode(\
            instruction TEXT PRIMARY KEY NOT NULL,\
            opcode TEXT,\
            true_result0  REAL,\
            true_result1  REAL,\
            true_result2  REAL,\
            true_result3  REAL,\
            param1 REAL,\
            param2 REAL,\
            param3 REAL,\
            param4 REAL);";
    result = sqlite3_prepare_v2(sql, sqlCreatetable, -1, &stmt, NULL);
    if (result == SQLITE_OK) {
        Log.INFO("创建数据表成功");
        //执行该语句
        sqlite3_step(stmt);
    }
    else {
        Log.INFO("创建数据表失败");
        return false;
    }
    //清理语句句柄，准备执行下一个语句
    sqlite3_finalize(stmt);
    return true;
}
bool Database::myDataClose()
{
    if(!sql)
    {
        return false;
    }
    sqlite3_close_v2(sql);
    sql = NULL;
    return true;
}
int Database::myDataOpen(const char *dbfilename)
{
    int ret = 0;
    int result = 0;
    /* 判断数据库文件是否存在, 不存在则创建，存在则仅打开 */
    if(!access(dbfilename, F_OK))
    {
        //文件存在
        result = sqlite3_open_v2(dbfilename, &sql, SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL);
    }
    else
    {
        result = sqlite3_open_v2(dbfilename, &sql, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL);
        ret = 1;
    }
    if (result != SQLITE_OK) {
        Log.INFO("打开数据库连接失败");
        return -1;
    }
    Log.INFO("打开数据库连接成功");
    return ret;
}
Database::Database(const char *dbfilename)
{
    int ret = 0;
    sql = NULL;
    stmt = NULL;
    mydbfilename = strdup(dbfilename);
    if(!mydbfilename)
    {
        Log.INFO("数据库文件名初始化失败!");
    }
    else
    {
        Log.INFO("数据库文件名初始化成功!");
    }
    ret = myDataOpen(mydbfilename);
    if(ret < 0)
    {
        Log.INFO("数据库打开失败!");
    }
    else if (ret != 0)
    {    
        myDataCreateTable();
    }
    Log.INFO("数据库打开成功!");
}
Database::~Database()
{
    if(!myDataClose())
    {
        Log.INFO("数据库关闭失败!");
    }
    else
    {
        Log.INFO("数据库关闭成功!");
    }
}
#endif

使用方式：

Database data;
  data.insert("add", "66 83 0f", result);
  data.insert("addc", "83 0f", result);
  data.selectIns("add", "66 83 0f", p);
  printf("temp  %f - %f - %f - %f \n", temp[0], temp[1], temp[2], temp[3]);

执行结果：

本地数据库 sqlite3 编译和使用