• SQLite数据库的安装和使用

    SQLite简介

    轻量化，易用的嵌入式数据库，用于设备端的数据管理，可以理解成单点的数据库。传统服务器型数据库用于管理多端设备，更加复杂。

    SQLite是一个无服务器的数据库，是自包含的。这也称为嵌入式数据库，这意味着数据库引擎作
    为应用程序的一部分运行。

    MySQL需要运行服务器，MySQL将需要客户端和服务器架构通过网络进行交互。

    SQLite的优点SQLite的缺点MySQL的优点MySQL的缺点
    基于文件，易于设置
    和使用
    适合基础开发和测试
    轻松携带
    使用标准SQL语法进
    行微小更改
    使用方便    		缺乏用户管理和
    安全功能
    不容易扩展
    不适合大数据库
    无法定制    		使用方便
    提供了许多与数据库相
    关的功能
    良好的安全功能
    易于扩展，适用于大型
    数据库
    提供良好的速度和性能
    提供良好的用户管理和
    多种访问控制    		需要一些技术专业知
    识来设置
    与传统SQL相比，语
    法略有不同

    基于嵌入式的数据库主要有：SQLite，Firebird，Berkeley DB，eXtremeDB
    Firebird 是关系型数据库，功能强大，支持存储过程，SQL兼容等
    SQLite 关系型数据库，体积小，支持ACID事务
    Berkeley DB 并没有数据库服务器的概念，他的程序直接链接到应用程序中
    eXtremeDB 是内存数据库，运行效率高

    SQLite数据库安装

    下载地址
    安装方式一：
                            sudo apt-get -y install sqlite
    安装方式二：
                            https://www.sqlite.org/download.html

     

     1. 把下载的文件sqlite-autoconf-3390000.tar.gz上传到开发板
    2. tar xvf sqlite-autoconf-3390000.tar.gz 解压
    3. cd sqlite-autoconf-3390000 进入文件夹
    4. ./configure --prefix=/usr/local 配置安装路径在/usr/local
    5. make clean 编译//比较久10分钟
    6. sudo make install 安装

     

    如上图，安装成功过，运行sqlite3 进入SQL命令操作流程
     

     SQLite的命令用法

     创建一个数据库

    方式一：
                    1、 sqlite3 进入数据库
                    2.、.open test.db
                    3.、.quit
                    数据库退出后在命令当前路径创建数据库test.db

    方式二：

            sqlite3 test.db //在命令运行当前窗口创建数据库test.db
            在数据库命令下
            .databases 列出当前打开的数据库
            .quit 退出

     创建一张表格

     create table stu2(id Integer,name char,score Integer);

     插入一条记录

    insert into stu values(18130106,'huang',99);
    insert into stu2 values(18130101,"gang",100); ''和""都行
    insert into stu(name,score) values("huanggang",98); 插入部分字段内容

     查看数据库的记录

    select * from stu;//查询所有字段的结果
    select name,score from stu;//查询数据库中部分字段的内容

    删除一条记录

     delete from stu where id = 18130101;

     更改一条记录

     update stu set name = 'huangg' where id = 18130106;

     删除一张表

     drop table stu;

     增加一列

     alter table stu add column sex char;

    SQLite的编程操作

    打开/创建数据库的C接口

    下面的 C 代码段显示了如何连接到一个现有的数据库。如果数据库不存在，那么它就会被创建，最后将返回一个数据库对象。


    sqlite3_open(const char *filename, sqlite3 **ppDb)
    该例程打开一个指向 SQLite 数据库文件的连接，返回一个用于其他 SQLite 程序的数据库连接对象。


    sqlite3_close(sqlite3*)
    该例程关闭之前调用 sqlite3_open() 打开的数据库连接。所有与连接相关的语句都应在连接关闭之前完成。
    如果还有查询没有完成，sqlite3_close() 将返回 SQLITE_BUSY 禁止关闭的错误消息。

    const char *sqlite3_errmsg(sqlite3*);
    sqlite3_errcode() 通常用来获取最近调用的API接口返回的错误代码.

    下面是两个引用案例

    1. #include <stdio.h>
    2. #include <sqlite3.h>
    3. #include <stdlib.h>
    4.  
    5. int main(int argc, char* argv[]) // 声明程序入口函数，接收命令行参数和参数个数
    6. {
    7.      
    8.     sqlite3 *db; // 声明sqlite3类型的数据库指针变量
    9.  
    10.     char *zErrMsg = 0; // 声明用于存储错误消息的指针变量，初始化为0
    11.  
    12.     int rc; // 声明整数变量，用于存储执行SQLite API函数的返回值
    13.  
    14.     rc = sqlite3_open("test.db", &db); // 打开名为"test.db"的数据库文件，并将数据库指针变量指向该文件
    15.  
    16.     if( rc ){ // 如果打开数据库失败
    17.         fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db)); // 打印错误消息到标准错误流
    18.         
    19.         exit(0); // 终止程序执行
    20.     }else{ // 如果打开数据库成功
    21.         fprintf(stderr, "Opened database successfully\n"); // 打印成功消息到标准错误流
    22.     }
    23.  
    24.     // 关闭数据库连接
    25.     sqlite3_close(db);
    26.  
    27.     return 0; // 返回程序执行成功标志
    28. }

    该程序使用SQLite API函数打开名为 "test.db" 的数据库文件，并检查是否成功打开。如果打开失败，则程序将打印错误消息并终止执行；否则，程序将打印成功消息并继续执行。最后，程序将关闭数据库连接并返回成功标志。

    注意编译时要连接 gcc xxx.c -lsqlite

    1. #include <stdio.h>
    2. #include <sqlite3.h>
    3.  
    4. int main(int argc, char **argv) // 声明程序入口函数，接收命令行参数和参数个数
    5. {
    6.     sqlite3 *db; // 声明sqlite3类型的数据库指针变量
    7.  
    8.     if(argc < 2){ // 如果命令行参数个数小于2（即缺少数据库文件名参数）
    9.         printf("Usage: %s xxx.db\n",argv[0]); // 打印程序用法信息
    10.         return -1; // 返回程序执行失败标志
    11.     }
    12.  
    13.     if((ret = sqlite3_open(argv[1],&db)) == SQLITE_OK){ // 打开名为"xxx.db"的数据库文件，并将数据库指针变量指向该文件
    14.         printf("open %s success\n",argv[1]); // 打印成功消息到标准错误流
    15.     }else{ // 如果打开数据库失败
    16.       
    17.         printf("error:%s,%d\n",sqlite3_errmsg(db),ret); // 打印错误消息到标准错误流
    18.         if(ret == 14){ // 如果是权限不足错误
    19.             
    20.             printf("permission den\n"); // 打印提示消息到标准错误流
    21.         }
    22.         sqlite3_close(db); // 关闭数据库连接
    23.         return -1; // 返回程序执行失败标志
    24.     }
    25.  
    26.     // 在这里编写SQL语句创建表的代码
    27.  
    28.     sqlite3_close(db); // 关闭数据库连接
    29.     printf("done\n"); // 打印成功消息到标准错误流
    30.     return 0; // 返回程序执行成功标志
    31. }

    该程序使用SQLite API函数创建名为 "xxx.db" 的数据库文件，并在其中创建一个表。如果打开数据库失败，则程序将打印错误消息和相应的错误代码到标准错误流，并终止执行；否则，程序将在数据库中创建一个表，并打印成功消息到标准错误流。最后，程序将关闭数据库连接，并打印完成消息到标准错误流。

    创建表的C接口

    下面的 C 代码段将用于在先前创建的数据库中创建一个表：
    先看这个API：
    sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg)

    sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg)
    该例程提供了一个执行 SQL 命令的快捷方式，SQL 命令由 sql 参数提供，可以由多个 SQL 命令组成。在这里，第一个参数 sqlite3 是打开的数据库对象，sqlite_callback 是一个回调，data 作为其第一个参数，errmsg 将被返回用来获取程序生成的任何错误。


    sqlite3_exec() 程序解析并执行由 sql 参数所给的每个命令，直到字符串结束或者遇到错误为止。
    int callback(void *arg, int column_size, char *column_value[ ], char *column_name[ ])

    参数分析：void *arg：是sqlite3_exec函数的第四个参数column_size：数据库的字段数
    column_value[]：列的值column_name：字段名字

    案例1

    1. #include <stdio.h>
    2. #include <sqlite3.h>
    3.  
    4. int callback(void *arg, int column_size, char *column_value[], char **column_name)
    5. {
    6.     int i;
    7.     printf("arg=%s\n", (char *)arg);
    8.     for(i = 0; i < column_size; i++) {
    9.         printf("%s = %s\n", column_name[i], column_value[i]);
    10.     }
    11.     printf("=======================\n");
    12.     return 0;//必须返回0，这样数据库中有多少条数据,这个回调函数就会被调用多少次
    13. }
    14.  
    15. int main(int argc, char **argv) // 声明程序入口函数，接收命令行参数和参数个数
    16. {
    17.     sqlite3 *db; //声明sqlite3类型的数据库指针变量
    18.  
    19.     if(argc < 2){ //如果命令行参数个数小于2（即缺少数据库文件名参数）
    20.         printf("Usage: %s xxx.db\n", argv[0]);//打印程序用法信息
    21.         return -1;//返回程序执行失败标志
    22.     }
    23.  
    24.     if ((ret = sqlite3_open(argv[1], &db)) == SQLITE_OK) { //打开名为"xxx.db"的数据库文件，并将数据库指针变量指向该文件
    25.         printf("open %s success\n", argv[1]); //打印成功消息到标准错误流
    26.     } else { //如果打开数据库失败
    27.         printf("error:%s,%d\n", sqlite3_errmsg(db), ret); //打印错误消息到标准错误流
    28.         if (ret == 14) { //如果是权限不足错误
    29.             printf("permission denied\n"); //打印提示消息到标准错误流
    30.         }
    31.         sqlite3_close(db); //关闭数据库连接
    32.         return -1; //返回程序执行失败标志
    33.     }
    34.  
    35.     //在这里编写SQL语句执行的代码
    36.     sqlite3_exec(db, "select * from stu;", callback, "content of sql:", &errorMes); //执行SQL语句，将结果集传递给回调函数处理
    37.     if (errorMes != NULL) {
    38.         printf("SQL error: %s\n", errorMes); //如果发生错误，打印错误消息到标准错误流
    39.     }
    40.     sqlite3_close(db); //关闭数据库连接
    41.     printf("done\n"); //打印成功消息到标准错误流
    42.     return 0; //返回程序执行成功标志
    43. }

    该程序使用 SQLite API 函数打开名为 "xxx.db" 的数据库文件，并在其中执行一条 SELECT 语句，将查询结果集传递给回调函数进行处理。在回调函数中，程序将打印每行查询结果的内容，并将其传递回主函数。如果执行 SQL 语句时发生错误，则程序将打印错误消息到标准错误流。最后，程序将关闭数据库连接，并打印完成消息到标准错误流。 

    案例2

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <sqlite3.h>
    4.  
    5. /* 定义一个回调函数，用于处理 SQL 语句执行结果 */
    6. static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
    7.     int i;
    8.     for(i = 0; i < argc; i++) {
    9.         printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    10.     }
    11.     printf("\n");
    12.     return 0;
    13. }
    14.  
    15. int main(int argc, char* argv[]) {
    16.     sqlite3 *db;
    17.     char *zErrMsg = 0;
    18.     int rc;
    19.     char *sql;
    20.  
    21.     /* 打开数据库 */
    22.     rc = sqlite3_open("test.db", &db);
    23.     if( rc ){
    24.         fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
    25.         exit(0);
    26.     } else {
    27.         fprintf(stdout, "Opened database successfully\n");
    28.     }
    29.  
    30.  
    31.     /* 创建 SQL 语句 */
    32.     sql = "CREATE TABLE COMPANY(" \
    33.         "ID INT PRIMARY KEY NOT NULL," \
    34.         "NAME TEXT NOT NULL," \
    35.         "AGE INT NOT NULL," \
    36.         "ADDRESS CHAR(50)," \
    37.         "SALARY REAL );";
    38.  
    39.     /* 执行 SQL 语句 */
    40.     rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    41.     if( rc != SQLITE_OK ){
    42.         fprintf(stderr, "SQL error: %s\n", zErrMsg);
    43.         sqlite3_free(zErrMsg);
    44.     } else {
    45.         fprintf(stdout, "Table created successfully\n");
    46.     }
    47.  
    48.  
    49.     /* 关闭数据库连接 */
    50.     sqlite3_close(db);
    51.  
    52.     return 0;
    53. }

    插入数据的C接口

    下面的 C 代码段显示了如何在上面创建的 COMPANY 表中创建记录：

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <sqlite3.h>
    4.  
    5. // 回调函数，用于处理查询结果
    6. static int callback(void *NotUsed, int argc, char **argv, char **azColName){
    7.     int i;
    8.     for(i = 0; i < argc; i++){
    9.         printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    10.     }
    11.     printf("\n");
    12.     return 0;
    13. }
    14.  
    15. int main(int argc, char* argv[]) {
    16.     sqlite3 *db;
    17.     char *zErrMsg = 0;
    18.     int rc;
    19.     char *sql;
    20.  
    21.     // 打开数据库
    22.     rc = sqlite3_open("test.db", &db); // 打开名为 "test.db" 的数据库
    23.     if( rc ){ // 如果打开失败
    24.         fprintf(stderr, "无法打开数据库: %s\n", sqlite3_errmsg(db)); // 输出错误信息
    25.         exit(0); // 终止程序
    26.     } else { // 如果成功打开
    27.         fprintf(stderr, "成功打开数据库\n"); // 输出成功信息
    28.     }
    29.  
    30.     // 创建 SQL 语句
    31.     sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " \
    32.           "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
    33.           "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " \
    34.           "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); " \
    35.           "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
    36.           "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
    37.           "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
    38.       
    39.           "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );"; // 创建 SQL 语句
    40.  
    41.     // 执行 SQL 语句
    42.     rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg); // 执行 SQL 语句，使用回调函数处理查询结果
    43.     if( rc != SQLITE_OK ){ // 如果执行失败
    44.         fprintf(stderr, "SQL 错误: %s\n", zErrMsg); // 输出错误信息
    45.         sqlite3_free(zErrMsg); // 释放内存
    46.     } else { // 如果执行成功
    47.         fprintf(stdout, "记录成功创建\n"); // 输出成功信息
    48.     }
    49.  
    50.     sqlite3_close(db); // 关闭数据库连接
    51.     return 0; // 返回 0 表示程序正常结束
    52. }

    这段代码打开一个SQLite数据库（假设已经创建名为 "test.db" 的数据库文件），然后插入了一些数据，最后关闭了数据库连接。callback 函数用于处理查询结果，打印了查询结果的每个列的名称和值。 

    SELECT 操作

     在我们开始讲解获取记录的实例之前，让我们先了解下回调函数的一些细节，这将在我们的实例使用到。这个回调提供了一个从 SELECT 语句获得结果的方式。它声明如下

     ypedef int (*sqlite3_callback)(

    void*,   //sqlite3_exec()的第四个参数传递的内容

    int,   //列

    char**,  //键值对的值

    char**,  //键值对的值

    ）；

    如果上面的回调在 sqlite_exec() 程序中作为第三个参数，那么 SQLite 将为 SQL 参数内执行的每个SELECT 语句中处理的每个记录调用这个回调函数。

    下面的 C 代码段显示了如何从前面创建的 COMPANY 表中获取并显示记录：
     

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <sqlite3.h>
    4.  
    5. // 回调函数，用于处理查询结果
    6. static int callback(void *data, int argc, char **argv, char **azColName) {
    7.     int i;
    8.     fprintf(stderr, "%s: ", (const char*)data);
    9.     
    10.     // 遍历每一列并打印列名和值
    11.     for(i = 0; i < argc; i++) {
    12.         printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    13.     }
    14.     
    15.     printf("\n");
    16.     return 0;
    17. }
    18.  
    19. // SQLdataToLink() 和 LinkToSQL() 函数的定义应在此处添加
    20.  
    21. int main(int argc, char* argv[]) {
    22.     sqlite3 *db;
    23.     char *zErrMsg = 0;
    24.     int rc;
    25.     char *sql;
    26.     const char* data = "回调函数被调用"; // 回调函数的附加数据
    27.  
    28.     /* 打开数据库 */
    29.     rc = sqlite3_open("test.db", &db);
    30.  
    31.     /* 创建 SQL 语句 */
    32.     sql = "SELECT * from COMPANY";
    33.  
    34.     /* 执行 SQL 语句，传递回调函数和附加数据 */
    35.     rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
    36.  
    37.     sqlite3_close(db);
    38.     return 0;
    39. }

    在这段代码中，回调函数 callback 用于处理查询结果，它接收附加数据作为参数并将其打印到标准错误流中。您还可以看到，SQLdataToLink() 和 LinkToSQL() 函数的定义应该在代码中的适当位置添加，以便在主函数中调用它们。

     UPDATE操作

    下面的 C 代码段显示了如何使用 UPDATE 语句来更新任何记录，然后从 COMPANY 表中获取并显示更新的记录：

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <sqlite3.h>
    4.  
    5. // 回调函数，用于处理查询结果
    6. static int callback(void *data, int argc, char **argv, char **azColName) {
    7.     int i;
    8.     fprintf(stderr, "%s: ", (const char*)data);
    9.     
    10.     // 遍历每一列并打印列名和值
    11.     for(i = 0; i < argc; i++) {
    12.         printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    13.     }
    14.     
    15.     printf("\n");
    16.     return 0;
    17. }
    18.  
    19. int main(int argc, char* argv[]) {
    20.     sqlite3 *db;
    21.     char *zErrMsg = 0;
    22.     int rc;
    23.     char *sql;
    24.     const char* data = "回调函数被调用"; // 回调函数的附加数据
    25.  
    26.     /* 打开数据库 */
    27.     rc = sqlite3_open("test.db", &db);
    28.     
    29.     if( rc ){
    30.         fprintf(stderr, "无法打开数据库: %s\n", sqlite3_errmsg(db));
    31.         exit(0);
    32.     } else {
    33.         fprintf(stderr, "成功打开数据库\n");
    34.     }
    35.  
    36.     /* 创建合并的 SQL 语句，包括更新和查询操作 */
    37.     sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
    38.           "SELECT * from COMPANY";
    39.  
    40.     /* 执行 SQL 语句，传递回调函数和附加数据 */
    41.     rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
    42.     
    43.     if( rc != SQLITE_OK ){
    44.         fprintf(stderr, "SQL 错误: %s\n", zErrMsg);
    45.         sqlite3_free(zErrMsg);
    46.     } else {
    47.         fprintf(stdout, "操作成功完成\n");
    48.     }
    49.  
    50.     sqlite3_close(db);
    51.     return 0;
    52. }

     DELETE操作

    下面的 C 代码段显示了如何使用 DELETE 语句删除任何记录，然后从 COMPANY 表中获取并显示剩余的记录：

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <sqlite3.h>
    4.  
    5. // 回调函数，用于处理查询结果
    6. static int callback(void *data, int argc, char **argv, char **azColName){
    7.     int i;
    8.     fprintf(stderr, "%s: ", (const char*)data);
    9.     for(i=0; i<argc; i++){
    10.         printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    11.     }
    12.     printf("\n");
    13.     return 0;
    14. }
    15.  
    16. int main(int argc, char* argv[])
    17. {
    18.     sqlite3 *db;
    19.     char *zErrMsg = 0;
    20.     int rc;
    21.     char *sql;
    22.     const char* data = "Callback function called";
    23.     /* 打开数据库 */
    24.     rc = sqlite3_open("test.db", &db); // 打开名为 "test.db" 的数据库
    25.     if( rc ){ // 如果打开失败
    26.         fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
    27.         exit(0);
    28.     } else { // 如果成功打开
    29.         fprintf(stderr, "Opened database successfully\n");
    30.     }
    31.     
    32.     /* 创建 SQL 语句 */
    33.     sql = "DELETE from COMPANY where ID=2; " \
    34.           "SELECT * from COMPANY";
    35.     /* 执行 SQL 语句 */
    36.     rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg); // 执行 SQL 语句，使用回调函数处理查询结果
    37.     if( rc != SQLITE_OK ){ // 如果执行失败
    38.         fprintf(stderr, "SQL 错误: %s\n", zErrMsg); // 输出错误信息
    39.         sqlite3_free(zErrMsg);
    40.     }else{ // 如果执行成功
    41.         fprintf(stdout, "Operation done successfully\n");
    42.     }
    43.     sqlite3_close(db); // 关闭数据库连接
    44.     
    45.     return 0;
    46. }

    该程序使用 SQLite 库连接到名为 "test.db" 的数据库，并执行一条 SQL 语句。SQL 语句包含两个操作：删除 ID 为 2 的记录和查询所有记录。回调函数 callback 用于处理查询结果，并将其打印到标准输出中。如果 SQL 语句执行失败，则输出错误信息；否则，输出操作成功信息。最后，关闭数据库连接并返回 0。

  • 相关阅读:
    Java学习笔记6.1.3 字节流 - 字节流缓冲区与缓冲字节流
    JMeter(三十九)：selenium怪异的UI自动化测试组合
    汇编语言指令
    赫尔辛基交通安全改善项目部署Velodyne Lidar智能基础设施解决方案
    Java中的异常
    如何检测照片中共有多少张人脸，机器学习
    微信小程序通过获取键盘高度解决键盘弹出挡住输入框问题
    每日一题day7-1652. 拆炸弹
    通信原理 | 宽带：运营商的带宽和实际网速的关系
    接口测试面试题整理​​​​​​​
  • 原文地址：https://blog.csdn.net/Good_go/article/details/132782267