数据库系统

DBMS：data base management system (数据库管理系统)。数据库管理系统通过数据模型对数据进行存储和管理。数据模型三要素：数据结构、数据操作、完整性约束。数据库管理系统采样的数据模型注意有三种：层次模型、网状模型、关系模型。

1. 层次模型：

   • 有且仅有一个节点无父结点，这个节点被称为根节点
   • 其他节点有且仅有一个父节点
   • 同一父节点的子节点被称为兄弟节点
   • 没有子节点的节点被称为页节点

2. 网状模型

   • 允许一个以上的节点无父节点
   • 一个节点可以有多个的父节点

3. 关系模型

   • 每一列的分量是类型相同的数据

   • 列的顺序可以是任意的

   • 行的顺序可以是任意的

   • 表中的分量是不可再分割的最小数据项，即表中不允许有子表。

   • id	name	addr
     1	王五	北京
     2	张三	上海
     3	李四	珠海

常用的数据库：ORACLE、Mysql、SQL server、Access、Sybase、SQLite。

SQLite

SQite是一个开源的、内嵌式的关系型数据库。下载地址：https://www.sqlite.org/download.html 。学习网站菜鸟教程： https://www.runoob.com/sqlite/sqlite-tutorial.html 。

特点：零配置、灵活、可移植、自由授权、紧凑、可靠、简单、易用。

SQLite数据类型

• interger：带符号的整型（最大64位）
• real：8字节表示的浮点类型
• text：字符类型，支持多种编码（UTF-8、UTF-16等），大小无限制
• blob：任意数据类型，大小无限制。BLOB(binary large object)二进制大对象，使用二进制保持数据
• null：null值，表示空

SQLite语句介绍

• 创建打开数据库：splite3 xxx.db、sqlite3>.open test.db。
• 退出数据库：sqlite3>.quit/sqlite3>.exit。
• 查看数据库列表：splite3>.databases。
• 导出完整的数据库在一个文本文件中： sqlite3 testDB.db .dump > testDB.sql，恢复使用：sqlite3 testDB.db < testDB.sql。
• 所有的SQL语句都是使用分号结尾，不区分大小写，两个减号“--”代表注释。

表的创建和查看

create table 数据库.表名称(列名称1 数据类型,列名称2 数据类型,列名称3 数据类型,....);
.tables -- 查看创建的表名称
-- sqlite> .tables
-- tbl
.schema -- 查看表格的语句
-- sqlite> .schema
-- CREATE TABLE tbl(id interger,name text,addr text);
select * from tbl;  -- 查询表中的内容
-- 在设计表时，通过primary key手动设置主键，每个表只能由一个主键，设置主键的列的数据不能重复。
create table persons(id integer primary key,name text,addr text);

表的删除插入和修改

drop table table_name; -- 删除表
-- alter语句，在已有的表中添加或者删除列以及修改表名
alter table 表名 add 列名 数据类型; -- 添加列
alter table persons add column sex text;
alter table 表名 rename to 新表名 -- 修改表名
-- 插入新行 insert into
insert into 表名 values(列值1,列值2,列值3,.....); -- 当列值位字符串要加上‘’号
insert into table_name (column1, column2, ...) values (value1, value2, ...); -- 插入指定列
insert into tbl(102,'ds','ss');
insert into tbl(id,name,addr) values(103,'io','op');
-- 更新update
update tbl set addr='ji' where id=103;
select * from tbl where id<102;
select * from tbl where id between 102 and 105;

表数据的删除

delete from 表名 [匹配条件];
delete from table_name where id=104;
delete from table_name where id=104 and addr='cq';
select * from table_name where id in (102,103,104);
select * from table_name where addr like 'ps%'; -- ps开头的
-- like通配符百分号（%）代表零个、一个或多个数字或字符。下划线（_）代表一个单一的数字或字符
select * from table_name where addr GLOB 'ps%'; -- ps开头的
-- GLOB星号（*）代表零个、一个或多个数字或字符。问号（?）代表一个单一的数字或字符
select * from table_name where id=104 or addr='cq';
select * from tbl where id between 104 and 109;
select * from tbl where id is not 109; -- 当id!=109时
select * from tbl where id is 109; -- 当id=109时
select * from COMPANY limit 3 offset 2; -- limit限制显示的行数，offset偏移量为多少
select * from COMPANY order by NAME, SALARY desc; -- 安装NAME升序 SALARY降序排列 默认升序
-- asc 默认值，从小到大，升序排列  desc 从大到小，降序排列

复制表和修改表结构

create table tbl2 as select * from tbl; -- 复制一张表
create table tbl3 as select * from tbl where id=103; -- 复制部分
-- 修改表的结构
create table tbl4(id integer primary key,name text,addr text); -- 第一步创建新表
insert into tbl4(id,name,addr) select id,name,addr from tbl; -- 第二步导入数据
drop table tbl;
alter table tbl4 rename to tbl; -- 更该表名

事务处理

begin; -- 开始一个事务
commit; -- 使得begin后的所有命令得到确认
rollback; -- 取消begin后的所有操作
sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

函数操作

length() -- 返回字符串的长度
lower() -- 将字符串转换为小写
upper() -- 将字符串转换为大写
select id,upper(name),length(addr) from tbl;
avg() -- 返回某列的平均值
count() -- 返回某列的函数
max() -- 返回某列的最大值
min() -- 返回某列的最小值
sum() -- 求某列的总和
select id,name,addr,max(scores),avg(scores) from tbl;

数据分组group by

select class,count(*) from tbl group by class; -- group分组
-- where语句必须要在group之前
select class,avg(scores) from tbl where class='class_a' group by class;
-- having语句对结果进行过滤，在group后面
select class,avg(scores) from tbl group by class having avg(scores)>=60;
-- order by 对结果进行排序 放在having后面
select class,avg(scores) from tbl group by class 
	having avg(scores)>=60 order by avg(scores) desc; -- 使用平均成绩降序排序

约束

• NOT NULL 约束：确保某列不能有 NULL 值。
• DEFAULT 约束：当某列没有指定值时，为该列提供默认值。
• UNIQUE 约束：确保某列中的所有值是不同的。是唯一的。
• PRIMARY Key 约束：唯一标识数据库表中的各行/记录。
• CHECK 约束：CHECK 约束确保某列中的所有值满足一定条件。使得输入的数据是合法的。

create table tbln(
	id integer primary key not null autoincrement, -- 主键 非空 自增长
    name text not null unique, -- 唯一
    age integer not null, -- 非空
    address text,
    salary real default 5000.0 check(salary>0) -- 默认5000.0 检查大于0
);

联结表

联结表就是从多个表中查询数据

select 列名1,列名2,.... from 表1,表2,.... where 判断语句;
select perosns.name, persons.addr, grade.score, grade.years from persons, grade where
	persons.id = grade.id and perosns.name = 'lucy';

视图view

通过相关的名称存储在数据库中的一个 SQLite 语句。

-- 创建视图
create view result as select perosns.name, persons.addr, grade.score, grade.years 
from persons, grade where persons.id = grade.id and perosns.name = 'lucy';
-- 删除视图
drop view result;

触发器trigger

SQLite的触发器是数据库的回调函数，他会在指定的数据库事件发生的时候自动的执行调用。SQLite 的触发器（Trigger）可以指定在特定的数据库表发生 delete、insert或 update 时触发，或在一个或多个指定表的列发生更新时触发。

create trigger trigger_name  [before | after] 
[insert | update| delete] on table_name
begin
 -- 触发器逻辑....
end;

create trigger trigger_name  [before | after] 
update on table_name of column_name -- 发生某个列上面
begin
 -- 触发器逻辑....
end;
-- 创建触发器
create trigger tg_delete after delete on persons 
begin 
	delete from grade where id=old.id; -- 回调函数
end;
-- 查看触发器
select name from sqlite_master where type = 'trigger';
select name from sqlite_master where type = 'trigger' and tbl_name = 'COMPANY';
-- 删除触发器
drop trigger trigger_name;

日志操作

create table log(time text, date text, data text); -- 创建日志表
insert into log values(time('now'),date('now'), '日志信息'); -- 添加信息
-- 创建触发器
create trigger log_trigger after update on persons
begin
	insert into log values(time('now'),date('now'), '执行了update');
end;

索引 index

-- 索引创建建议
-- 在作为主键的列上 在经常需要排列的列上创建索引
-- 在经常使用where子句中的列上面创建索引，加快条件的判断速度
create index index_name on table_name;
create index index_name on table_name(column_name); -- 单列索引
.indices 或者 .indexes -- 查看索引
select * from sqlite_master where type = 'index'; -- 列出数据库的所有索引
drop index 索引名; -- 删除索引
create unique index index_name on table_name (column_name); -- 唯一索引
create index index_name on table_name (column1, column2); -- 组合索引
-- 索引避免使用情况 索引是为了在大数据库中实现收索、查找、条件查找
-- 表的数据量不大，表的大部分操作不是查询，大量出现NULL的不建议使用索引。

SQLite c/c++编程

注意点：sqlite使用了两个动态库 pthread 和 dl。在网站： https://www.sqlite.org/cintro.html 中查看库中的各个函数的具体情况。学习网址：https://www.jb51.net/list/list_215_1.htm 。

sqlite3_open

int sqlite3_open(  // 打开数据库
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb          /* OUT: SQLite db handle */
);
filename: 数据库文件路径
ppDb: 指向sqlite3的句柄指针
返回值： 0 SQLITE_OK 成功 其他错误码(非零值)失败

sqlite3_close

int sqlite3_close(sqlite3* pdb); // 关闭数据库文件
pdb: 关闭的sqlite数据库
返回值： 0 SQLITE_OK 成功 其他错误码失败

sqlite3_exec

int sqlite3_exec( // 执行SQL操作
  sqlite3* pdb,                                  /* An open database */
  const char *sql,                           /* SQL to be evaluated */
  int (*callback)(void*,int,char**,char**),  /* Callback function */
  void *arg,                                    /* 1st argument to callback */
  char **errmsg                              /* Error msg written here */
);
pdb: 数据库句柄
sql: SQL语句
callback: 回调函数，在使用select语句的时候使用，其他忽略
arg: 传递给回调函数的第一个参数
errmsg: 错误信息指针的地址
返回值： 0 SQLITE_OK 成功 其他错误码
// 回调函数 每找到一条记录，自动执行一次回调函数
typedef int (*sqlite3_callback)(void* arg, int f_num, char** f_value, char** f_name); 
arg: 传递给回调函数的参数
f_num: 记录中包含的字段数目
f_value: 包含每个字段值的指针数组
f_name: 包含每个字段名称的指针数组
返回值：0 成功 -1 失败

sqlite3_get_table

// 执行zsql指向的sql语句，将结果集相关数据的地址保存在函数的参数中
int sqlite3_get_table( 
  sqlite3 *db,          /* An open database */
  const char *zSql,     /* SQL to be evaluated */
  char ***pazResult,    /* Results of the query */
  int *pnRow,           /* Number of result rows written here */
  int *pnColumn,        /* Number of result columns written here */
  char **pzErrmsg       /* Error msg written here */
);
db: 数据库的标识
zsql: SQL语句，以分号结尾
pazResult: 指针数组的地址，记录结果集数据。
    内存布局：先依次存放各列的列名，然后是每一行各列的值。
pnRow：行数的指针地址
pnColumn: 列数的指针地址
pzErrmsg: 错误信息指针的地址

void sqlite3_free_table(char **result);
// 释放动态分配的收集结果的sqlite3_get_table参数pazResult

实现数据库操作example1.c

使用上面的函数，实现学生成绩的数据库函数

#include "sqlite3.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

/**
 * @details 实现数据库的打开和创建表的功能
 * @param sqlite3_filename 打开的数据库的路径名称
 * @return 返回打开数据库的句柄指针 NULL 失败 非空 成功
*/
sqlite3* sql_open(const char* sqlite3_filename)
{
    sqlite3 *sqlite3_db = NULL;
    int sqlite3_ret = sqlite3_open(sqlite3_filename, &sqlite3_db);
    if(sqlite3_ret != SQLITE_OK)
    {
        perror("sqlite3_open error");
        return NULL;
    }
    printf("sqlite3_open ok!\r\n");
    return sqlite3_db;
}

/**
 * @details 创建一个表
 * @param sqlite3_db 打开的数据库句柄
 * @param tbname 创建的表的名字
 * @return -1失败 0成功
*/
int create_table(sqlite3 *sqlite3_db, const char* tbname)
{
    char *sql = (char*)sqlite3_malloc(100);
    if(sql == NULL)
        return -1;
    memset(sql, '\0', 100); /*初始化申请的内存都为'\0'*/
    sprintf(sql, "create table %s (id int primary key not null,name text,score float);", tbname);

    char *mesg_error = NULL;
    int ret = sqlite3_exec(sqlite3_db, sql, NULL, NULL, &mesg_error);
    if(ret != SQLITE_OK)
    {
        if(strcmp(mesg_error, "table stu already exists") != 0)
        {
            printf("%s\n", mesg_error);
            sqlite3_free(mesg_error);
            sqlite3_free(sql);
            return -1;
        }
    }
    printf("create ok\n");
    if(sql != NULL)
        sqlite3_free(sql);
    sqlite3_free(mesg_error);

    return 0;
}

/**
 * @details 给数据库中插入数据
 * @param sqlite3_db 数据库句柄
 * @param tbname 表名
 * @return 0 成功 -1 失败
*/
int insert_data(sqlite3 *sqlite3_db, const char* tbname)
{
    char *sql = (char*)sqlite3_malloc(100);
    int id;
    char name[10] = {'\0'};
    float score;
    if(sql == NULL)
        return -1;
    memset(sql, '\0', 100); /*初始化申请的内存都为'\0'*/
    printf("请分别输入你的id name score\n");
    scanf("%d%s%f",&id, name, &score);
    sprintf(sql, "insert into %s values(%d,'%s',%.1f);", tbname, id, name, score);
    printf("%s\n",sql);

    char *mesg_error = NULL;
    int ret = sqlite3_exec(sqlite3_db, sql, NULL, NULL, &mesg_error);
    if(ret != SQLITE_OK)
    {
        printf("%s\n", mesg_error);
        sqlite3_free(mesg_error);
        sqlite3_free(sql);
        return -1;
    }
    printf("insert ok\n");
    if(sql != NULL)
        sqlite3_free(sql);
    sqlite3_free(mesg_error);

    return 0;
}

/**
 * @details select查询的回调函数，每查询到一个执行一次回调函数
 * @param data 传递给回调函数的参数
 * @param column_num 列数
 * @param column_value 存放列值的数组
 * @param column_name 存放列名的数组
 * @return 0 成功 其他 失败
*/
int callback(void* data, int column_num, char* column_value[], char* column_name[])
{

    printf("%d, %s, %.1f\n", atoi(column_value[0]), column_value[1], atof(column_value[2]));    
    return 0;
}

/**
 * @details 查询显示表的数据
 * @param sqlite3_db 数据库句柄
 * @param tbname 表的名称
 * @return 0 成功 -1 失败
*/
int select_data(sqlite3 *sqlite3_db, const char* tbname)
{
    char *sql = (char*)sqlite3_malloc(100);
    if(sql == NULL)
        return -1;
    memset(sql, '\0', 100); /*初始化申请的内存都为'\0'*/

    sprintf(sql, "select * from %s;", tbname);
    printf("%s\n",sql);

    char *mesg_error = NULL;
    int ret = sqlite3_exec(sqlite3_db, sql, callback, NULL, &mesg_error);
    if(ret != SQLITE_OK)
    {
        printf("%s\n", mesg_error);
        sqlite3_free(mesg_error);
        sqlite3_free(sql);
        return -1;
    }
    printf("select ok\n");
    if(sql != NULL)
        sqlite3_free(sql);
    sqlite3_free(mesg_error);

    return 0;
}

/**
 * @details 查询显示表的数据
 * @param sqlite3_db 数据库句柄
 * @param tbname 表的名称
 * @return 0 成功 -1 失败
*/
int select_data_by_get_table(sqlite3 *sqlite3_db, const char* tbname)
{
    char *sql = (char*)sqlite3_malloc(100);
    if(sql == NULL)
        return -1;
    memset(sql, '\0', 100); /*初始化申请的内存都为'\0'*/

    sprintf(sql, "select * from %s;", tbname);
    printf("%s\n",sql);

    char *mesg_error = NULL;
    char **dbResult;
    int nRow, nColumn, i, j, index;

    int ret = sqlite3_get_table(sqlite3_db, sql, &dbResult, &nRow, &nColumn, &mesg_error);
    if(ret != SQLITE_OK)
    {
        printf("%s\n", mesg_error);
        sqlite3_free_table( dbResult );
        sqlite3_free(mesg_error);
        sqlite3_free(sql);
        return -1;
    }
    printf("select ok\n");
    printf("nRow = %d, nColumn = %d \n", nRow, nColumn);
    index = nColumn;

    for(i = 0; i < nRow; i++)
    {
        printf("第%d条记录\n", i + 1);
        for(j = 0; j < nColumn; j++)
        {
            printf("字段名：%s 字段值：%s\n", dbResult[j], dbResult[index]);
            ++index;
        }
        printf("\n");
    }

    if(sql != NULL)
        sqlite3_free(sql);
    sqlite3_free(mesg_error);

    return 0;
}

/**
 * @details 更新表的数据，成绩
 * @param sqlite3_db 数据库句柄
 * @param tbname 表的名称
 * @param score 成绩
 * @param name 谁的成绩
 * @return 0 成功 -1 失败
*/
int update_data(sqlite3 *sqlite3_db, const char* tbname, float score, char *name)
{
    char *sql = (char*)sqlite3_malloc(100);
    if(sql == NULL)
        return -1;
    memset(sql, '\0', 100); /*初始化申请的内存都为'\0'*/

    sprintf(sql, "update %s set score = %.1f where name = '%s'", tbname, score, name);
    printf("%s\n",sql);

    char *mesg_error = NULL;
    int ret = sqlite3_exec(sqlite3_db, sql, NULL, NULL, &mesg_error);
    if(ret != SQLITE_OK)
    {
        printf("%s\n", mesg_error);
        sqlite3_free(mesg_error);
        sqlite3_free(sql);
        return -1;
    }
    printf("update ok\n");
    if(sql != NULL)
        sqlite3_free(sql);
    sqlite3_free(mesg_error);

    return 0;
}

/**
 * @details 删除数据
 * @param sqlite3_db 数据库句柄
 * @param tbname 表的名称
 * @param id 删除谁的数据
 * @return 0 成功 -1 失败
*/
int delete_data(sqlite3 *sqlite3_db, const char* tbname, int id)
{
    char *sql = (char*)sqlite3_malloc(100);
    if(sql == NULL)
        return -1;
    memset(sql, '\0', 100); /*初始化申请的内存都为'\0'*/

    sprintf(sql, "delete from %s where id = %d", tbname, id);
    printf("%s\n",sql);

    char *mesg_error = NULL;
    int ret = sqlite3_exec(sqlite3_db, sql, NULL, NULL, &mesg_error);
    if(ret != SQLITE_OK)
    {
        printf("%s\n", mesg_error);
        sqlite3_free(mesg_error);
        sqlite3_free(sql);
        return -1;
    }
    printf("delete ok\n");
    if(sql != NULL)
        sqlite3_free(sql);
    sqlite3_free(mesg_error);

    return 0;
}

void print_menu()
{
    printf("\t\t\t 输入你的操作: \t\t\t\n");
    printf("\t\t\t 1.insert \t\t\t\n");
    printf("\t\t\t 2.delete \t\t\t\n");
    printf("\t\t\t 3.update \t\t\t\n");
    printf("\t\t\t 4.select_by_exec \t\t\t\n");
    printf("\t\t\t 5.select_by_table \t\t\t\n");
    printf("\t\t\t -1.exit \t\t\t\n");
}

int main(int argc, char* argv[])
{

    sqlite3 *db;
    char tbname[20] = "stu";
    char name[10] = {'\0'};
    int id;
    float score;

    db = sql_open("test.db");
    create_table(db, tbname);

    int option;

    while(1)
    {
        print_menu();
        scanf("%d",&option);
        switch(option)
        {
            case -1:
            {
                exit(-1);
                break;
            }
            case 1:
            {
                insert_data(db, tbname);
                break;
            }
            case 2:
            {
                printf("请输入你的id\n");
                scanf("%d", &id);
                delete_data(db, tbname, id);
                break;
            }
            case 3:
            {
                printf("请输入你的姓名以及成绩");
                scanf("%s%f", name, &score);
                update_data(db, tbname, score, name);
                break;
            }
            case 4:
            {
                select_data(db, tbname);
                break;
            }
            case 5:
            {
                select_data_by_get_table(db,tbname);
                break;
            }
            default:
                break;
        }
        sleep(1);
    }

    return 0;
}

sqlite3_prepare_v2

int sqlite3_prepare_v2(
  sqlite3 *db,              // 数据库连接对象
  const char *zSql,         // SQL 查询语句
  int nByte,                // SQL 查询语句的字节数 -1 自动计算
  sqlite3_stmt **ppStmt,    // 编译后的语句对象指针
  const char **pzTail       // 剩余未编译部分的指针 一般填0
);
// 将准备的sql语句解析到ppStmt结构体中去
int sqlite3_finalize(sqlite3_stmt *pStmt);
// 释放已经准备好的sqlite3_stmt sql解析好的结构体数据

sqlite3_prepare_v2(db, “insert into tbl(ID,file_content) values( 10, ?)”, -1, &stat, 0);
// 上面的？号表示不确定 需要使用sqlite3_bind_xxx类函数来确定，
// 该类型的函数其中的第二个参数就是表示第几个？号
// sqlite3_reset(pStmt) 重新初始化绑定的数据
sqlite3_bind_double(pStmt, 1, 10.9); // 绑定数据10.9

int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
                        void(*)(void*));
int sqlite3_bind_double(sqlite3_stmt*, int, double);
int sqlite3_bind_int(sqlite3_stmt*, int, int);
int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
int sqlite3_bind_null(sqlite3_stmt*, int);
int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
// 一般最后一个参数填写 SQLITE_TRANSIENT 自动管理释放内存
int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
                         void(*)(void*), unsigned char encoding);
int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
int sqlite3_bind_pointer(sqlite3_stmt*, int, void*, const char*,void(*)(void*));
int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
int sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64);

sqlite3_step

int sqlite3_step(sqlite3_stmt* pStmt); // 执行结构体pStmt中解析的sql语句
// 执行完一般需要执行 sqlite3_finalize 释放pStmt内存

sqlite3_colmun_xxx

// 获取sqlite3_stmt的当前结果行中的列的各种结果。
const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); // 获取二进制数据
double sqlite3_column_double(sqlite3_stmt*, int iCol);
int sqlite3_column_int(sqlite3_stmt*, int iCol);
sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
int sqlite3_column_type(sqlite3_stmt*, int iCol);
int sqlite3_column_count(sqlite3_stmt*) // 获取列的数量

实现数据库操作example2.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sqlite3.h"

sqlite3* do_test_open(const char * datebase)
{
    sqlite3* db = NULL;
    int result = sqlite3_open(datebase, &db);
    if(result != SQLITE_OK)
    {
        sqlite3_close(db);
        return NULL;
    }
    return db;
}

int do_test_create(sqlite3* db)
{
    const char* create_table_sql = 
                "create table testtable(int_col int,float_col real,string_col text);";
    sqlite3_stmt* stmt = NULL;
    // int len = strlen(create_table_sql);

    if(sqlite3_prepare_v2(db, create_table_sql, -1, &stmt, NULL) != SQLITE_OK)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }

    if(sqlite3_step(stmt) != SQLITE_DONE)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }
    if(stmt)
        sqlite3_finalize(stmt);
    printf("create\r\n");
    return 0;
}

int do_test_begin(sqlite3* db)
{
    const char* create_table_sql = 
                "begin;";
    sqlite3_stmt* stmt = NULL;
    // int len = strlen(create_table_sql);

    if(sqlite3_prepare_v2(db, create_table_sql, -1, &stmt, NULL) != SQLITE_OK)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }

    if(sqlite3_step(stmt) != SQLITE_DONE)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }
    if(stmt)
        sqlite3_finalize(stmt);
    printf("begin\r\n");
    
    return 0;
}

int do_test_insert(sqlite3* db)
{
    const char* create_table_sql = 
                "insert into testtable values(?,?,?);";
    sqlite3_stmt* stmt = NULL;
    // int len = strlen(create_table_sql);

    if(sqlite3_prepare_v2(db, create_table_sql, -1, &stmt, NULL) != SQLITE_OK)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }

    int insertCount = 10, i = 0;
    const char* strData = "This is a test.";
    printf("start insert \r\n");
    for(i = 0; i < insertCount; i++)
    {
        sqlite3_bind_int(stmt, 1, i);
        sqlite3_bind_double(stmt, 2, i * 1.0);
        sqlite3_bind_text(stmt, 3, strData, strlen(strData), SQLITE_TRANSIENT);
        // printf("%s\n", sqlite3_sql(stmt));

        if(sqlite3_step(stmt) != SQLITE_DONE)
        {
            if(stmt)
                sqlite3_finalize(stmt);
            return -1;
        }
        // printf("%s\n", sqlite3_sql(stmt));

        sqlite3_reset(stmt); // 重新初始化 sqlite3_stmt 对象绑定的变量
        printf("insert ok!\r\n");
    }

    if(stmt)
    sqlite3_finalize(stmt);

    return 0;
}

int do_test_commit(sqlite3* db)
{
    const char* create_table_sql = 
                "commit";
    sqlite3_stmt* stmt = NULL;
    // int len = strlen(create_table_sql);

    if(sqlite3_prepare_v2(db, create_table_sql, -1, &stmt, NULL) != SQLITE_OK)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }

    if(sqlite3_step(stmt) != SQLITE_DONE)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }
    if(stmt)
        sqlite3_finalize(stmt);

    printf("commit\r\n");
    
    return 0;
}

int do_test_select(sqlite3* db)
{
    const char* create_table_sql = 
                "select * from testtable;";
    sqlite3_stmt* stmt = NULL;
    // int len = strlen(create_table_sql);

    if(sqlite3_prepare_v2(db, create_table_sql, -1, &stmt, NULL) != SQLITE_OK)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }

    int fieldCount = sqlite3_column_count(stmt); // 获取列数
    int i = 0;

    while(1)
    {
        int r = sqlite3_step(stmt);
        if(r == SQLITE_ROW) // 执行成功，返回一条结果
        {
            for (i = 0; i < fieldCount; ++i) 
            {
                int vtype = sqlite3_column_type(stmt, i);
                if(vtype == SQLITE_INTEGER)
                {
                    printf("the interger value is %d\n", sqlite3_column_int(stmt, i));
                }
                else if(vtype == SQLITE_FLOAT)
                {
                    printf("the float value is %.2f\n", sqlite3_column_double(stmt, i));
                }else if(vtype == SQLITE_TEXT)
                {
                    printf("the text value is %s\n", sqlite3_column_text(stmt, i));
                }else if(vtype == SQLITE_NULL)
                {
                    printf("the value is null\n");
                }
            }
        }
        else if(r == SQLITE_DONE) // 执行成功，没有返回结果
        {
            printf("Select Finished.\n");
            break;
        }
        else 
        {
            if(stmt)
                sqlite3_finalize(stmt);
            break;
        }
    }

    if(stmt)
        sqlite3_finalize(stmt);
    
    return 0;
}

int do_test_drop(sqlite3* db)
{
    const char* create_table_sql = 
                "drop table testtable;";
    sqlite3_stmt* stmt = NULL;
    // int len = strlen(create_table_sql);

    if(sqlite3_prepare_v2(db, create_table_sql, -1, &stmt, NULL) != SQLITE_OK)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }

    if(sqlite3_step(stmt) != SQLITE_DONE)
    {
        if(stmt)
            sqlite3_finalize(stmt);
        return -1;
    }
    if(stmt)
        sqlite3_finalize(stmt);

    printf("dropped table testtable!!!\r\n");
    
    return 0;
}

int do_test_close(sqlite3* db)
{
    int result = sqlite3_close(db);
    if(result != SQLITE_OK)
    {
        return -1;
    }
    return 0;
}


int main(int argc, char **argv)
{
    sqlite3* db = do_test_open("test.db"); // 打开数据库，无则创建

    do_test_create(db); // 创建表

    do_test_select(db); // 查询表

    /*使用begin commit来实现高效的多条语句的插入，避免多次的写入内存，减少写入的操作*/
    do_test_begin(db); // 开始执行begin

    do_test_insert(db); // 插入表

    do_test_commit(db); // commit

    do_test_select(db); // 查询表

    // do_test_drop(db); // 删除testtable表

    do_test_close(db); // 关闭数据库
    
    return 0;
}