http://www.cppblog.com/czy463/archive/2013/12/16/204816.html 董淳光
前序：
Sqlite3 的确很好用。小巧、速度快。不过因为非微软的制品，协理文档总觉得不够。这个天再一次商量它，又有一些收获，那里把自家对 sqlite3 的钻研列出来，以备忘记。
此地要注解，我是一个跨平台专注者，并不爱好只用 windows 平台。小编原先的劳作就是为 unix 平台写代码。上边小编所写的东西，固然没有表明，可是本身已尽量不使用其余 windows 的东西，只利用规范 C 或标准C++。然则，作者从不尝试过在其余系统、其余编译器下编译，由此下边的叙述假如不得法，则留待以往修改。
上面小编的代码依然用 VC 编写，因为本人以为VC是一个很科学的IDE，可以加快代码编写速度（例如协作 Vassist ）。上面小编所说的编译环境，是VC2003。如若读者觉得温馨习惯于 unix 下用 vi 编写代码速度较快，能够不用管小编的印证，只要求符合自身习惯即可，因为本人用的是正规 C 或 C++ 。不会给任何人带来不方便。
一、版本
从 www.sqlite.org 网站可下载到最新的 sqlite 代码和编译版本。我写此小说时，最新代码是 3.3.17 版本。
很久没有去下载 sqlite 新代码，由此也不知情 sqlite 变化如此大。之前很多文本，今后整个合并成一个 sqlite3.c 文件。假诺单独用此文件，是挺好的，省去拷贝一堆文件还操心有没有遗漏。可是也带来一个题材：此文件太大，快接近7万行代码，VC开它整个机器都慢下来了。借使不需求改它代码，也就不需求开辟 sqlite3.c 文件，机器不会慢。不过，下边小编要写通过改动 sqlite 代码完毕加密成效，那时候就相比痛心了。假设个人水平较高，提出用些不难的编辑器来编排，例如UltraEdit 或 Notepad 。速度会快很多。
二、基本编译
以此不想多说了，在 VC 里新建 dos 控制台空白工程，把 sqlite3.c 和 sqlite3.h 添加到工程，再新建一个 main.cpp文件。在里边写:
extern “C”
{
#include “./sqlite3.h”
};
int main( int , char** )
{
return 0;
}
干什么要 extern
“C” ？倘若问这么些难题，作者不想说太多，这是C++的基本功。要在 C++ 里应用一段 C 的代码，必须要用 extern
“C” 括起来。C++跟 C纵然语法上有重叠，不过它们是四个不等的东西，内存里的布局是一心差别的，在C++编译器里不用extern
“C”括起C代码，会造成编译器不明了该怎么为 C 代码描述内存布局。
或是在 sqlite3.c 里人家已经把整段代码都 extern
“C” 括起来了，可是你赶上一个 .c 文件就自觉的再括一次，也没怎么不佳。
宗旨工程就这么树立起来了。编译，可以经过。不过有一堆的 warning。可以不管它。
三、SQLITE操作入门
sqlite提供的是部分C函数接口，你可以用这一个函数操作数据库。通过应用这么些接口，传递一些业内 sql 语句（以 char
* 类型）给 sqlite 函数，sqlite 就会为您操作数据库。
sqlite 跟MS的access一样是文件型数据库，就是说，一个数据库就是一个文本，此数据库里可以创建很多的表，可以建立目录、触发器等等，可是，它实在得到的就是一个文书。备份那些文件就备份了任何数据库。
sqlite 不须要任何数据库引擎，这象征一旦您须求 sqlite 来保存一些用户数量，甚至都不要求安装数据库(假如您做个小软件还须要住户必须装了sqlserver 才能运行，那也太惨毒了)。
下边开头介绍数据库基本操作。
1 基本流程（1）关键数据结构
sqlite 里最常用到的是 sqlite3
* 类型。从数据库打开开始，sqlite就要为那几个类型准备好内存，直到数据库关闭，整个进程都亟待用到那些连串。当数据库打开时先导，那几个类型的变量就象征了您要操作的数据库。上边再详尽介绍。
（2）打开数据库
int sqlite3_open( 文件名, sqlite3 ** );
用这些函数开端数据库操作。
亟需传入两个参数，一是数据库文件名，比如：c://DongChunGuang_Database.db。
文件名不需求一定存在，就算此文件不存在，sqlite 会自动建立它。若是它存在，就尝试把它当数据库文件来开辟。
sqlite3
** 参数即目前提到的重中之重数据结构。那个结构底层细节怎么着，你不要关它。
函数再次回到值表示操作是还是不是正确，假如是 SQLITE_OK 则意味操作正常。相关的归来值sqlite定义了有些宏。具体那几个宏的意思可以参照 sqlite3.h 文件。里面有详实定义（顺便说一下，sqlite3 的代码注释率自称是丰盛高的，实际上也实在很高。只要你会看英文，sqlite 可以让你学到不少东西）。
上面介绍关闭数据库后，再给一段参考代码。
（3）关闭数据库
int sqlite3_close(sqlite3 *);
面前假如用 sqlite3_open 开启了一个数据库，结尾时毫无忘了用这几个函数关闭数据库。
下边给段简单的代码：
extern “C”
{
#include “./sqlite3.h”
};
int main( int , char** )
{
sqlite3 * db = NULL; //注明sqlite关键结构指针
int result;
//打开数据库
//需求传入 db 那一个指针的指针，因为 sqlite3_open 函数要为这么些指针分配内存，还要让db指针指向那一个内存区
result = sqlite3_open( “c://Dcg_database.db”, &db );
if( result != SQLITE_OK )
{
//数据库打开战败
return -1;
}
//数据库操作代码
//…
//数据库打开成功
//关闭数据库
sqlite3_close( db );
return 0;
}
那就是三遍数据库操作进度。
2 SQL语句操作
本节介绍如何用sqlite 执行标准 sql 语法。
（1）执行sql语句
int sqlite3_exec(sqlite3*, const char *sql,
sqlite3_callback, void *, char **errmsg );
那就是推行一条 sql 语句的函数。
第1个参数不再说了，是日前open函数得到的指针。说了是非同寻常数据结构。
第2个参数const char *sql 是一条 sql 语句，以/0结尾。
第3个参数sqlite3_callback 是回调，当这条语句执行之后，sqlite3会去调用你提供的这几个函数。（什么是回调函数，自身找其他资料学习）
第4个参数void
* 是您所提供的指针，你能够传递任何一个指针参数到那里，那些参数最终会传到回调函数里面，如若不须要传递指针给回调函数，可以填NULL。等下大家再看回调函数的写法，以及这一个参数的使用。
第5个参数char **
errmsg 是错误音信。注意是指针的指针。sqlite3里面有许多固定的错误音讯。执行 sqlite3_exec 之后，执行破产时得以查阅那么些指针（直接 printf(“%s/n”,errmsg)）拿到一串字符串消息，那串音讯告知你错在哪些地点。sqlite3_exec函数通过修改你传入的指针的指针，把您提供的指针指向错误提醒音讯，那样sqlite3_exec函数外面就可以通过这几个 char*得到具体错误指示。
说明：通常，sqlite3_callback 和它背后的 void
* 那五个地方都能够填 NULL。填NULL代表你不需求回调。比如你做insert 操作，做 delete 操作，就一贯不要求运用回调。而当你做 select 时，就要采用回调，因为 sqlite3 把数据查出来，得经过回调告诉你查出了什么样数据。
（2）exec 的回调
typedef int (*sqlite3_callback)(void*,int,char**, char**);
你的回调函数必须定义成上边那几个函数的花色。下边给个差不多的例证：
//sqlite3的回调函数
// sqlite 每查到一条记下，就调用一回这几个回调
int LoadMyInfo( void * para, int n_column, char **
column_value, char ** column_name )
{
//para是你在 sqlite3_exec 里传来的 void * 参数
//通过para参数，你可以流传一些奇特的指针（比如类指针、结构指针），然后在那里面强制转换成对应的类型（那些中是void*品类，必须强制转换成你的花色才可用）。然后操作这些数据
//n_column是这一条记下有微微个字段 (即那条记下有些许列)
// char **
column_value 是个重点值，查出来的数额都封存在那里，它事实上是个1维数组（不要认为是2维数组），每种因素都以一个 char
* 值，是一个字段内容（用字符串来表示，以/0结尾）
//char **
column_name 跟 column_value是对应的，表示这几个字段的字段名称
//那里，我不行使 para 参数。忽略它的存在.
int i;
printf( “记录包涵 %d 个字段/n”, n_column );
for( i = 0 ; i < n_column; i ++ )
{
printf( “字段名:%s ß> 字段值:%s/n”, column_name[i],
column_value[i] );
}
printf( “——————/n“ );
return 0;
}
int main( int , char ** )
{
sqlite3 * db;
int result;
char * errmsg = NULL;
result = sqlite3_open( “c://Dcg_database.db”, &db );
if( result != SQLITE_OK )
{
//数据库打开失败
return -1;
}
//数据库操作代码
//创设一个测试表，表名叫 MyTable_1，有2个字段： ID 和 name。其中ID是一个自动增加的花色，今后insert时得以不去指定那几个字段，它会友善从0初阶增多
result = sqlite3_exec( db, “create table MyTable_1( ID integer primary
key autoincrement, name nvarchar(32) )”, NULL, NULL, errmsg );
if(result != SQLITE_OK )
{
printf( “创设表败北，错误码:%d，错误原因:%s/n”, result, errmsg );
}
//插入一些记录
result = sqlite3_exec( db, “insert into MyTable_1( name ) values
( ‘走路’ )”, 0, 0, errmsg );
if(result != SQLITE_OK )
{
printf( “插入记录失败，错误码:%d，错误原因:%s/n”, result, errmsg );
}
result = sqlite3_exec( db, “insert into MyTable_1( name ) values
( ‘骑单车’ )”, 0, 0, errmsg );
if(result != SQLITE_OK )
{
printf( “插入记录退步，错误码:%d，错误原因:%s/n”, result, errmsg );
}
result = sqlite3_exec( db, “insert into MyTable_1( name ) values
( ‘坐汽车’ )”, 0, 0, errmsg );
if(result != SQLITE_OK )
{
printf( “插入记录战败，错误码:%d，错误原因:%s/n”, result, errmsg );
}
//开头查询数据库
result = sqlite3_exec( db, “select * from MyTable_1”, LoadMyInfo,
NULL, errmsg );
//关闭数据库
sqlite3_close( db );
return 0;
}
由此地方的例子，应该可以精通怎么打开一个数据库，咋办数据库基本操作。
有那么些知识，基本上可以应付很多数据库操作了。
（3）不采纳回调查询数据库
地点介绍的 sqlite3_exec 是选拔回调来实施 select 操作。还有一个措施可以一向询问而不须要回调。可是，作者个人感觉依旧回调好，因为代码能够更进一步整齐，只然而用回调很麻烦，你得声圣元个函数，即便这一个函数是类成员函数，你还不得不把它表明成 static 的（要问怎么？那又是C++基础了。C++成员函数实际上隐藏了一个参数：this，C++调用类的成员函数的时候，隐含把类指针当成函数的率先个参数传递进去。结果，那造成跟前面说的 sqlite 回调函数的参数不切合。唯有当把成员函数表明成 static 时，它才没有多余的隐含的this参数）。
固然回调显得代码整齐，但有时你要么想要非回调的 select 查询。那能够透过 sqlite3_get_table 函数做到。
int sqlite3_get_table(sqlite3*, const char *sql, char ***resultp, int *nrow, int *ncolumn, char **errmsg
);
第1个参数不再多说，看眼下的例证。
第2个参数是 sql 语句，跟 sqlite3_exec 里的 sql 是一律的。是一个很一般的以/0结尾的char
*字符串。
第3个参数是询问结果，它依旧一维数组（不要以为是二维数组，更毫不觉得是三维数组）。它内存布局是：第一行是字段名称，后边是随着是各类字段的值。上边用例子来说事。
第4个参数是询问出多少条记下（即查出多少行）。
第5个参数是有点个字段（多少列）。
第6个参数是错误消息，跟后边一样，那里不多说了。
上边给个大致例子:
int main( int , char ** )
{
sqlite3 * db;
int result;
char * errmsg = NULL;
char **dbResult; //是 char ** 类型，两个*号
int nRow, nColumn;
int i , j;
int index;
result = sqlite3_open( “c://Dcg_database.db”, &db );
if( result != SQLITE_OK )
{
//数据库打开战败
return -1;
}
//数据库操作代码
//假设后面已经创办了 MyTable_1 表
//开端询问，传入的 dbResult 已经是 char
**，那里又加了一个 & 取地址符，传递进入的就成了 char ***
result = sqlite3_get_table( db, “select * from MyTable_1”,
&dbResult, &nRow, &nColumn, &errmsg );
if( SQLITE_OK == result )
{
//查询成功
index =
nColumn; //后面说过 dbResult 后面第一行数据是字段名称，从 nColumn 索引开端才是当真的数据
printf( “查到%d条记录/n”, nRow );
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; //
dbResult 的字段值是连连的，从第0索引到第 nColumn –
1索引都是字段名称，从第 nColumn 索引开始，前面都是字段值，它把一个二维的表（古板的连串表示法）用一个扁平的形式来表示
}
printf( “——-/n” );
}
}
//到此地，不论数据库查询是不是成功，都放出 char** 查询结果，使用 sqlite 提供的效果来刑释解教
sqlite3_free_table( dbResult );
//关闭数据库
sqlite3_close( db );
return 0;
}
到这么些事例甘休，sqlite3 的常用用法都介绍完了。
用上述的法子，再配上 sql 语句，完全可以应付绝一大半数据库须求。
但有一种情状，用地点方法是无能为力兑现的：须要insert、select 二进制。当需求处理二进制数据时，上边的不二法门就不或然已毕。下边这一节表达怎样插入二进制数据
3 操作二进制
sqlite 操作二进制数据须要用一个帮扶的数据类型：sqlite3_stmt * 。
本条数据类型记录了一个“sql语句”。为何自身把 “sql语句” 用双引号引起来？因为你可以把 sqlite3_stmt
* 所表示的故事情节作为是 sql语句，可是实际上它不是大家所了解的sql语句。它是一个已经把sql语句解析了的、用sqlite本人标记记录的中间数据结构。
正因为那个布局早已被解析了，所以你可以后那个讲话里插入二进制数据。当然，把二进制数据插到 sqlite3_stmt 结构里可无法平素 memcpy ，也无法像 std::string 那样用 + 号。必须用 sqlite 提供的函数来插入。
（1）写入二进制
下边说写二进制的步调。
要插入二进制，前提是以此表的字段的品种是 blob 类型。作者倘使有这么一张表：
create table Tbl_2( ID integer, file_content blob )
先是声明
sqlite3_stmt * stat;
接下来，把一个 sql 语句解析到 stat 结构里去：
sqlite3_prepare( db, “insert into Tbl_2( ID, file_content) values(
10, ? )”, -1, &stat, 0 );
下面的函数达成 sql 语句的辨析。第四个参数跟前边一样，是个 sqlite3
* 类型变量，第三个参数是一个 sql 语句。
本条 sql 语句尤其之处在于 values 里面有个 ? 号。在sqlite3_prepare函数里，?号表示一个未定的值，它的值等下才插入。
其五个参数我写的是-1，这些参数含义是眼下 sql 语句的长短。如若小于0，sqlite会自动测算它的尺寸（把sql语句正是以/0尾声的字符串）。
第七个参数是 sqlite3_stmt 的指针的指针。解析今后的sql语句就位于那一个布局里。
第二个参数作者也不精通是为啥的。为0就能够了。
假若那个函数执行成功（再次来到值是 SQLITE_OK 且 stat 不为NULL ），那么下边就足以先导插入二进制数据。
sqlite3_bind_blob( stat, 1, pdata, (int)(length_of_data_in_bytes),
NULL
); // pdata为数据缓冲区，length_of_data_in_bytes为多少大小，以字节为单位
其一函数一共有5个参数。
第1个参数：是前面prepare得到的 sqlite3_stmt * 类型变量。
第2个参数：?号的目录。后边prepare的sql语句里有一个?号，若是有几个?号怎么插入？方法就是改变 bind_blob 函数第2个参数。这么些参数小编写1，表示那里插入的值要替换 stat 的首先个?号（那里的目录从1起首计数，而非从0早先）。即使您有八个?号，就写多个 bind_blob 语句，并转移它们的第2个参数就替换来区其余?号。倘使有?号没有替换，sqlite为它取值null。
第3个参数：二进制数据伊始指针。
第4个参数：二进制数据的长短，以字节为单位。
第5个参数：是个析够回调函数，告诉sqlite当把多少处理完后调用此函数来析够你的多少。这一个参数小编还不曾利用过，因而了然也不深入。不过一般都填NULL，须求释放的内存自个儿用代码来刑释解教。
bind完了后来，二进制数据就进来了您的“sql语句”里了。你以后可以把它保存到数据库里：
int result = sqlite3_step( stat );
经过这一个讲话，stat 代表的sql语句就被写到了数据库里。
最后，要把 sqlite3_stmt 结构给自由：
sqlite3_finalize( stat ); //把刚才分配的故事情节析构掉
（2）读出二进制
上边说读二进制的步子。
跟前边一样，先申明 sqlite3_stmt * 类型变量：
sqlite3_stmt * stat;
然后，把一个 sql 语句解析到 stat 结构里去：
sqlite3_prepare( db, “select * from Tbl_2”, -1, &stat, 0 );
当 prepare 成功未来（重临值是 SQLITE_OK ），初叶询问数据。
int result = sqlite3_step( stat );
这一句的再次来到值是SQLITE_ROW 时表示成功（不是 SQLITE_OK ）。
您可以循环执行sqlite3_step 函数，五次step查询出一条记下。直到再次回到值不为 SQLITE_ROW 时表示查询截止。
下一场初步得到首个字段：ID 的值。ID是个整数，用上面这些讲话拿到它的值：
int id = sqlite3_column_int( stat, 0
); //第2个参数表示收获第多少个字段内容，从0先河盘算，因为自己的表的ID字段是率先个字段，由此这里我填0
下边初阶得到 file_content 的值，因为 file_content 是二进制，因而我索要获得它的指针，还有它的长短：
const void * pFileContent = sqlite3_column_blob( stat, 1 );
int len = sqlite3_column_bytes( stat, 1 );
那样就赢得了二进制的值。
把 pFileContent 的内容保留出来之后，不要忘了释放 sqlite3_stmt 结构：
sqlite3_finalize( stat ); //把刚才分配的内容析构掉
（3）重复使用 sqlite3_stmt 结构
万一您须要重复使用 sqlite3_prepare 解析好的 sqlite3_stmt 结构，须要用函数： sqlite3_reset。
result = sqlite3_reset(stat);
如此那般， stat 结构又变成 sqlite3_prepare 落成时的情状，你可以再次为它 bind 内容。
4 事务处理
sqlite 是支撑事务处理的。如果您通晓您要联合删除很多数据，不仿把它们做成一个联结的政工。
普普通通四次 sqlite3_exec 就是五次事情，假使你要删减1万条数据，sqlite就做了1万次：初叶新业务->删除一条数据->提交业务->发轫新业务->… 的进度。那个操作是很慢的。因为时间都花在了始于事务、提交业务上。
您可以把那几个同类操作做成一个政工，那样如若操作错误，还是能回滚事务。
事务的操作没有尤其的接口函数，它就是一个家常便饭的 sql 语句而已：
独家如下：
int result;
result = sqlite3_exec( db, “begin transaction”, 0, 0, &zErrorMsg );
//先河一个事情
result = sqlite3_exec( db, “commit transaction”, 0, 0, &zErrorMsg );
//提交事务
result = sqlite3_exec( db, “rollback transaction”, 0, 0, &zErrorMsg );
//回滚事务
四、C/C++开发接口简介1 总览
SQLite3是SQLite一个崭新的本子,它固然是在SQLite
2.8.13的代码基础之上开发的,可是利用了和在此以前的版本不合作的数据库格式和API.
SQLite3是为着满意以下的急需而开发的:
- 支持UTF-16编码.
- 用户自定义的文本排序方法.
- 可以对BLOBs字段建立索引.
故而为了帮衬这个特点小编改变了数据库的格式,建立了一个与事先版本不同盟的3.0版. 至于其余的包容性的更改,例如全新的API等等,都将在辩论介绍之后向你验证,那样可以使您最快的一次性摆脱包容性难点.
3.0版的和2.X版的API分外相似,不过有一些根本的更改须求注意. 所有API接口函数和数据结构的前缀都由”sqlite_”改为了”sqlite3_”. 这是为了避免同时选择SQLite
2.X和SQLite 3.0那多少个版本的时候暴发链接争辨.
是因为对于C语言应该用如何数据类型来存放UTF-16编码的字符串并没有一样的规范. 因而SQLite使用了普通的void* 类型来指向UTF-16编码的字符串. 客户端选拔进程中得以把void*映射成适合他们的体系的此外数据类型.
2 C/C++接口
SQLite 3.0一共有83个API函数,别的还有一些数据结构和预订义(#defines).
(完整的API介绍请参考另一份文档.) 可是你们可以放心,这一个接口使用起来不会像它的多寡所暗示的那么复杂. 最简便易行的程序如故接纳多个函数就足以做到:
sqlite3_open(),
sqlite3_exec(), 和 sqlite3_close(). 若是想更好的决定数据库引擎的施行,可以选拔提供的sqlite3_prepare()函数把SQL语句编译成字节码,然后在选择sqlite3_step()函数来执行编译后的字节码. 以sqlite3_column_开首的一组API函数用来取得查询结果集中的音信. 许多接口函数都以成对出现的,同时有UTF-8和UTF-16八个版本. 并且提供了一组函数用来施行用户自定义的SQL函数和文件排序函数.
（1）怎样打开关闭数据库
typedef struct sqlite3 sqlite3;
int sqlite3_open(const char*, sqlite3**);
int sqlite3_open16(const void*, sqlite3**);
int sqlite3_close(sqlite3*);
const char *sqlite3_errmsg(sqlite3*);
const void *sqlite3_errmsg16(sqlite3*);
int sqlite3_errcode(sqlite3*);
sqlite3_open() 函数重临一个整数错误代码,而不是像第二版中一律重临一个对准sqlite3结构体的指针.
sqlite3_open() 和sqlite3_open16() 的不一样之处在于sqlite3_open16() 使用UTF-16编码(使用当地主机字节顺序)传递数据库文件名. 借使要成立新数据库,
sqlite3_open16() 将中间文件转换为UTF-16编码, 反之sqlite3_open() 将文件转换为UTF-8编码.
开辟恐怕创建数据库的吩咐会被缓存,直到那一个数据库真正被调用的时候才会被执行. 而且允许利用PRAGMA申明来设置如本半夏件编码或暗中认同内存页面大小等采取和参数.
sqlite3_errcode() 平常用来博取近日调用的API接口重返的荒谬代码.
sqlite3_errmsg() 则用来拿到那一个错误代码所对应的文字表达. 这一个错误音讯将以 UTF-8 的编码再次回到,并且在下一遍调用其余SQLite
API函数的时候被清除.
sqlite3_errmsg16() 和sqlite3_errmsg() 大体上同一,除了回到的错误音讯将以 UTF-16 本机字节顺序编码.
SQLite3的错误代码比较SQLite2没有任何的变更,它们各自是:
#define SQLITE_OK 0 /* Successful result */
#define SQLITE_ERROR 1 /* SQL error or missing database */
#define SQLITE_INTERNAL 2 /* An internal logic error in SQLite
*/
#define SQLITE_PERM 3 /* Access permission denied */
#define SQLITE_ABORT 4 /* Callback routine requested an
abort */
#define SQLITE_BUSY 5 /* The database file is locked */
#define SQLITE_LOCKED 6 /* A table in the database is locked
*/
#define SQLITE_NOMEM 7 /* A malloc() failed */
#define SQLITE_READONLY 8 /* Attempt to write a readonly
database */
#define SQLITE_INTERRUPT 9 /* Operation terminated by
sqlite_interrupt() */
#define SQLITE_IOERR 10 /* Some kind of disk I/O error
occurred */
#define SQLITE_CORRUPT 11 /* The database disk image is
malformed */
#define SQLITE_NOTFOUND 12 /* (Internal Only) Table or record
not found */
#define SQLITE_FULL 13 /* Insertion failed because database
is full */
#define SQLITE_CANTOPEN 14 /* Unable to open the database file
*/
#define SQLITE_PROTOCOL 15 /* Database lock protocol error */
#define SQLITE_EMPTY 16 /* (Internal Only) Database table is
empty */
#define SQLITE_SCHEMA 17 /* The database schema changed */
#define SQLITE_TOOBIG 18 /* Too much data for one row of a
table */
#define SQLITE_CONSTRAINT 19 /* Abort due to contraint violation
*/
#define SQLITE_MISMATCH 20 /* Data type mismatch */
#define SQLITE_MISUSE 21 /* Library used incorrectly */
#define SQLITE_NOLFS 22 /* Uses OS features not supported on
host */
#define SQLITE_AUTH 23 /* Authorization denied */
#define SQLITE_ROW 100 /* sqlite_step() has another row
ready */
#define SQLITE_DONE 101 /* sqlite_step() has finished
executing */
（2）执行 SQL 语句
typedef int (*sqlite_callback)(void*,int,char**, char**);
int sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void*,
char**);
sqlite3_exec 函数依然像它在SQLite2中一律承受着诸多的工作. 该函数的首个参数中得以编译和实施零个或三个SQL语句. 查询的结果重返给回调函数. 更加多地音讯方可查看API 参考.
在SQLite3里,sqlite3_exec一般是被准备SQL语句接口封装起来使用的.
typedef struct sqlite3_stmt sqlite3_stmt;
int sqlite3_prepare(sqlite3*, const char*, int, sqlite3_stmt**,
const char**);
int sqlite3_prepare16(sqlite3*, const void*, int, sqlite3_stmt**,
const void**);
int sqlite3_finalize(sqlite3_stmt*);
int sqlite3_reset(sqlite3_stmt*);
sqlite3_prepare 接口把一条SQL语句编译成字节码留给前面的进行函数. 使用该接口访问数据库是日前可比好的的一种方法.
sqlite3_prepare() 处理的SQL语句应该是UTF-8编码的. 而sqlite3_prepare16() 则须要是UTF-16编码的. 输入的参数中唯有首先个SQL语句会被编译. 第五个参数则用来指向输入参数中下一个索要编译的SQL语句存放的SQLite
statement对象的指针,任曾几何时候倘若调用 sqlite3_finalize() 将销毁一个准备好的SQL注解. 在数据库关闭在此以前，所有准备好的评释都必须被保释销毁.
sqlite3_reset() 函数用来重置一个SQL评释的情景，使得它可以被再一次执行.
SQL表明能够涵盖部分型如”?” 或 “?nnn” 或 “:aaa”的号子， 其中”nnn” 是一个平头，”aaa” 是一个字符串. 这个标记代表有些不确定的字符值（可能说是通配符），能够在前边用sqlite3_bind 接口来填充那几个值. 每一种通配符都被分配了一个数码（由它在SQL表明中的地方决定，从1开端），别的也足以用 “nnn” 来表示 “?nnn” 那种意况. 允许同一的通配符在同一个SQL声明中冒出反复, 在这种意况下所有同样的通配符都会被替换成相同的值. 没有被绑定的通配符将机关取NULL值.
int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n,
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, long long int);
int sqlite3_bind_null(sqlite3_stmt*, int);
int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n,
void(*)(void*));
int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int n,
void(*)(void*));
int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
以上是 sqlite3_bind 所涵盖的任何接口，它们是用来给SQL讲明中的通配符赋值的. 没有绑定的通配符则被认为是空值.绑定上的值不会被sqlite3_reset()函数重置. 不过在调用了sqlite3_reset()之后所有的通配符都足以被再一次赋值.
在SQL阐明准备好以往(其中绑定的步骤是可选的), 需求调用以下的法门来举办:
int sqlite3_step(sqlite3_stmt*);
就算SQL再次回到了一个单行结果集，sqlite3_step() 函数将赶回 SQLITE_ROW
, 如若SQL语句执行成功或许正常将回来SQLITE_DONE
, 否则将回到错误代码. 假使无法开拓数据库文件则会重回 SQLITE_BUSY
. 假使函数的重返值是SQLITE_ROW, 那么下边的这一个方法可以用来取得记录集行中的数据:
const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
int sqlite3_column_count(sqlite3_stmt*);
const char *sqlite3_column_decltype(sqlite3_stmt *, int iCol);
const void *sqlite3_column_decltype16(sqlite3_stmt *, int iCol);
double sqlite3_column_double(sqlite3_stmt*, int iCol);
int sqlite3_column_int(sqlite3_stmt*, int iCol);
long long int sqlite3_column_int64(sqlite3_stmt*, int iCol);
const char *sqlite3_column_name(sqlite3_stmt*, int iCol);
const void *sqlite3_column_name16(sqlite3_stmt*, int iCol);
const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
int sqlite3_column_type(sqlite3_stmt*, int iCol);
sqlite3_column_count()函数再次来到结果集中包蕴的列数.
sqlite3_column_count() 能够在举行了 sqlite3_prepare()之后的任曾几何时刻调用.
sqlite3_data_count()除了必须求在sqlite3_step()之后调用之外，其余跟sqlite3_column_count() 盘锦小异. 假如调用sqlite3_step() 重回值是 SQLITE_DONE 大概一个错误代码, 则此时调用sqlite3_data_count() 将返回 0 ，然而sqlite3_column_count() 依然会回去结果集中包罗的列数.
回到的记录集通过行使别的的多少个 sqlite3_column_***() 函数来领取, 所有的那一个函数都把列的数码作为第一个参数. 列编号从左到右以零初阶. 请小心它和后边这一个从1初步的参数的不一致.
sqlite3_column_type()函数重临第N列的值的数据类型. 具体的重返值如下:
#define SQLITE_INTEGER 1
#define SQLITE_FLOAT 2
#define SQLITE_TEXT 3
#define SQLITE_BLOB 4
#define SQLITE_NULL 5
sqlite3_column_decltype() 则用来回到该列在 CREATE
TABLE 语句中评释的类型. 它可以用在当重临类型是空字符串的时候.
sqlite3_column_name() 重返第N列的字段名.
sqlite3_column_bytes() 用来回到 UTF-8 编码的BLOBs列的字节数可能TEXT字符串的字节数.
sqlite3_column_bytes16() 对于BLOBs列再次来到同样的结果，不过对于TEXT字符串则按 UTF-16 的编码来总计字节数.
sqlite3_column_blob() 返回 BLOB 数据.
sqlite3_column_text() 返回 UTF-8 编码的 TEXT 数据.
sqlite3_column_text16() 返回 UTF-16 编码的 TEXT 数据.
sqlite3_column_int() 以本土主机的整数格式重临一个整数值.
sqlite3_column_int64() 再次回到一个64位的整数. 最终,
sqlite3_column_double() 重临浮点数.
不自然非要依照sqlite3_column_type()接口重临的数据类型来收获数据. 数据类型不相同时软件将自行转换.
（3）用户自定义函数
可以应用以下的法子来创设用户自定义的SQL函数:
typedef struct sqlite3_value sqlite3_value;
int sqlite3_create_function(
sqlite3 *,
const char *zFunctionName,
int nArg,
int eTextRep,
void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*)
);
int sqlite3_create_function16(
sqlite3*,
const void *zFunctionName,
int nArg,
int eTextRep,
void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*)
);
#define SQLITE_UTF8 1
#define SQLITE_UTF16 2
#define SQLITE_UTF16BE 3
#define SQLITE_UTF16LE 4
#define SQLITE_ANY 5
nArg 参数用来声明自定义函数的参数个数. 倘诺参数值为0，则象征接受任意个数的参数. 用 eTextRep 参数来注解传入参数的编码格局. 参数值可以是地点的三种预订义值.
SQLite3 允许同一个自定义函数有各样不一样的编码参数的版本. 数据库引擎会自动选拔更换参数编码个数最少的版本使用.
普普通通的函数只须要设置 xFunc 参数，而把 xStep 和 xFinal 设为NULL. 聚合函数则须求安装 xStep 和 xFinal 参数，然后把 xFunc 设为NULL. 该办法和行使sqlite3_create_aggregate()
API一样.
sqlite3_create_function16()和sqlite_create_function()的不等就在于自定义的函数名一个须要是 UTF-16 编码，而另一个则必要是 UTF-8.
请小心自定函数的参数如今利用了sqlite3_value结构体指针替代了SQLite
version
2.X中的字符串指针. 上面的函数用来从sqlite3_value结构体中提取数据:
const void *sqlite3_value_blob(sqlite3_value*);
int sqlite3_value_bytes(sqlite3_value*);
int sqlite3_value_bytes16(sqlite3_value*);
double sqlite3_value_double(sqlite3_value*);
int sqlite3_value_int(sqlite3_value*);
long long int sqlite3_value_int64(sqlite3_value*);
const unsigned char *sqlite3_value_text(sqlite3_value*);
const void *sqlite3_value_text16(sqlite3_value*);
int sqlite3_value_type(sqlite3_value*);
地点的函数调用以下的API来收获上下文内容和重临结果:
void *sqlite3_aggregate_context(sqlite3_context*, int nbyte);
void *sqlite3_user_data(sqlite3_context*);
void sqlite3_result_blob(sqlite3_context*, const void*, int n,
void(*)(void*));
void qlite3_result_double(sqlite3_context*, double);
void sqlite3_result_error(sqlite3_context*, const char*, int);
void sqlite3_result_error16(sqlite3_context*, const void*, int);
void sqlite3_result_int(sqlite3_context*, int);
void sqlite3_result_int64(sqlite3_context*, long long int);
void sqlite3_result_null(sqlite3_context*);
void sqlite3_result_text(sqlite3_context*, const char*, int n,
void(*)(void*));
void sqlite3_result_text16(sqlite3_context*, const void*, int n,
void(*)(void*));
void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
void *sqlite3_get_auxdata(sqlite3_context*, int);
void sqlite3_set_auxdata(sqlite3_context*, int, void*, void
(*)(void*));
（4）用户自定义排序规则
上边的函数用来落成用户自定义的排序规则:
sqlite3_create_collation(sqlite3*, const char *zName, int eTextRep,
void*,
int(*xCompare)(void*,int,const void*,int,const void*));
sqlite3_create_collation16(sqlite3*, const void *zName, int
eTextRep, void*,
int(*xCompare)(void*,int,const void*,int,const void*));
sqlite3_collation_needed(sqlite3*, void*,
void(*)(void*,sqlite3*,int eTextRep,const char*));
sqlite3_collation_needed16(sqlite3*, void*,
void(*)(void*,sqlite3*,int eTextRep,const void*));
sqlite3_create_collation() 函数用来声称一个排序系列和完成它的可比函数. 相比函数只可以用来做文本的相比较.
eTextRep 参数可以取如下的预定义值 SQLITE_UTF8, SQLITE_UTF16LE,
SQLITE_UTF16BE,
SQLITE_ANY，用来表示相比较函数所拍卖的文书的编码格局. 同一个自定义的排序规则的同一个相比函数可以有 UTF-8,
UTF-16LE 和 UTF-16BE 等多个编码的版本.
sqlite3_create_collation16()和sqlite3_create_collation() 的分别也单独在于排序名称的编码是 UTF-16 仍旧 UTF-8.
可以行使 sqlite3_collation_needed() 函数来注册一个回调函数，当数据库引擎蒙受未知的排序规则时会自动调用该函数. 在回调函数中得以查找一个貌似的相比函数，并激活相应的sqlite_3_create_collation()函数. 回调函数的第两个参数是排序规则的名称，同样sqlite3_collation_needed采用 UTF-8 编码.
sqlite3_collation_need16() 采用 UTF-16 编码.
五、给数据库加密
前面所说的内容网上早已有许多材质，尽管相比较零碎，可是花点时间也仍能找到的。现在要说的那一个——数据库加密，资料就很难找。也恐怕是自个儿操作水平不够，找不到对应资料。但不论那样，作者大概通过网上能找到的很单薄的材质，探索出了给sqlite数据库加密的总体步骤。
此处要提一下，即使 sqlite 很好用，速度快、体量小巧。可是它保存的文书却是明文的。若不信可以用 NotePad 打开数据库文件瞧瞧，里面 insert 的情节大概一览无余。这样赤裸裸的变现本人，可不是我们的初衷。当然，若是您在嵌入式系统、智能手机上接纳 sqlite，最好是不加密，因为那些系统运算能力简单，你做为一个新成效提供者，不可以把用户有限的运算能力总体花掉。
Sqlite为了速度而诞生。因而Sqlite自身不对数据库加密，要精通，如若您采纳标准AES算法加密，那么肯定有类似50%的时间开支在加解密算法上，甚至更加多（品质主要取决于你算法编写水平以及你是否能运用cpu提供的底层运算能力，比如MMX或sse连串指令可以极大提高运算速度）。
Sqlite免费版本是不提供加密效率的，当然你也可以挑选他们的收费版本，那您得付出2000块钱，而且是USD。小编那边也不是说支付钱不佳，假诺只为了数据库加密就去开发2000块，我以为划不来。因为下边作者快要告诉您什么样为免费的Sqlite扩充出加密模块——自身下手增添，那是Sqlite允许，也是它提倡的。
那就是说，就让大家共同起先为 sqlite3.c 文件扩充出加密模块。
1 必要的宏
透过阅读 Sqlite 代码（当然没有任何观望完，6万多行代码，没有一行是自我习惯的品格，小编可没那么多眼神去看），小编搞精通了两件事：
Sqlite是永葆加密扩展的；
需要 #define 一个宏才能动用加密扩充。
本条宏就是 SQLITE_HAS_CODEC。
你在代码最前头（也足以在 sqlite3.h 文件首先行）定义：
#ifndef SQLITE_HAS_CODEC
#define SQLITE_HAS_CODEC
#endif
比方你在代码里定义了此宏，不过还是可以健康编译，那么相应是操作没有马到功成。因为你应当会被编译器指示有局地函数不能链接才对。假诺您用的是 VC
2003，你可以在“化解方案”里右键点击你的工程，然后选“属性”，找到“C/C++”，再找到“命令行”，在其间手工添加“/D
“SQLITE_HAS_CODEC””。
概念了这些宏，一些被 Sqlite 故意屏蔽掉的代码就被利用了。那么些代码就是加解密的接口。
尝试编译，vc会指示您有一些函数不可以链接，因为找不到她们的兑现。
一经你也用的是VC2003，那么会取得下面的指示：
error
LNK2019: 不可以解析的外表符号 _sqlite3CodecGetKey ，该符号在函数 _attachFunc 中被引述
error
LNK2019: 不只怕解析的外表符号 _sqlite3CodecAttach ，该符号在函数 _attachFunc 中被引述
error
LNK2019: 不可以解析的外表符号 _sqlite3_activate_see ，该符号在函数 _sqlite3Pragma 中被引述
error
LNK2019: 不或然解析的外表符号 _sqlite3_key ，该符号在函数 _sqlite3Pragma 中被引用
fatal error LNK1120: 4 个无法解析的外部命令
那是正规的，因为Sqlite只留了接口而已，并不曾付诸完毕。
下边就让作者来完成那一个接口。
2融洽落成加解密接口函数
只要真要作者从一份 www.sqlite.org 网上down下来的 sqlite3.c 文件，直接搜索出这个接口的完结，作者认为本身还未曾那些力量。
好在网上还有一对代码已经落实了那一个效应。通过参考他们的代码以及持续编译中vc给出的一无所长提醒，最后自个儿把整个接口整理出来。
达成这个留给接口不是那么不难，要重头说四遍怎么回事很难堪。作者把代码都写好了，直接把她们按小编上边的讲明拷贝到 sqlite3.c 文件对应地点即可。笔者在底下也提供了sqlite3.c 文件，可以一向参考或取下来使用。
此处要说一些的是，小编此外新建了五个文本：crypt.c和crypt.h。
里头crypt.h如此定义：
#ifndef DCG_SQLITE_CRYPT_FUNC_
#define DCG_SQLITE_CRYPT_FUNC_
/***********
董淳光写的 SQLITE 加密重点函数库
***********/
/***********
重点加密函数
***********/
int My_Encrypt_Func( unsigned char *
pData, unsigned int data_len, const char *
key, unsigned int len_of_key );
/***********
根本解密函数
***********/
int My_DeEncrypt_Func( unsigned char *
pData, unsigned int data_len, const char *
key, unsigned intlen_of_key );
#endif
其间的 crypt.c 如此定义：
#include “./crypt.h”
#include “memory.h”
/***********
重视加密函数
***********/
int My_Encrypt_Func( unsigned char *
pData, unsigned int data_len, const char *
key, unsigned int len_of_key )
{
return 0;
}
/***********
最首要解密函数
***********/
int My_DeEncrypt_Func( unsigned char *
pData, unsigned int data_len, const char *
key, unsigned intlen_of_key )
{
return 0;
}
其一文件很简单看，就两函数，一个加密一个解密。传进来的参数分别是待处理的数额、数据长度、密钥、密钥长度。
拍卖时直接把结果效果于 pData 指针指向的内容。
您必要定义本人的加解密进程，就改动那八个函数，别的一些不用动。扩充起来很粗略。
此间有个特色，data_len 一般总是 1024 字节。正因为那样，你可以在您的算法里应用部分特定长度的加密算法，比如AES须求被加密数据一定是128位（16字节）长。那一个1024不是刚刚，而是 Sqlite 的页定义是1024字节，在sqlite3.c文件里有定义:
# define SQLITE_DEFAULT_PAGE_SIZE 1024
您可以变更那些值，可是依旧提出没有须要不要去改它。
地点写了五个扩展函数，怎么样把增加函数跟 Sqlite 挂接起来，这几个历程说起来相比麻烦。笔者直接贴代码。
分3个步骤。
首先，在 sqlite3.c 文件顶部，添加底下内容：
#ifdef SQLITE_HAS_CODEC
#include “./crypt.h”
/***********
用以在 sqlite3 最终关闭时释放部分内存
***********/
void sqlite3pager_free_codecarg(void *pArg);
#endif
以此函数之所以要在 sqlite3.c 起首注解，是因为上面在 sqlite3.c 里面某些函数里要插入这一个函数调用。所以要提早申明。
说不上，在sqlite3.c文件里搜索“sqlite3PagerClose”函数，要找到它的已毕代码（而不是宣称代码）。
达成代码里一初步是：
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
/* A malloc() cannot fail in sqlite3ThreadData() as one or more calls
to
** malloc() must have already been made by this thread before it
gets
** to this point. This means the ThreadData must have been allocated
already
** so that ThreadData.nAlloc can be set.
*/
ThreadData *pTsd = sqlite3ThreadData();
assert( pPager );
assert( pTsd && pTsd->nAlloc );
#endif
急需在那有些后边随着插入：
#ifdef SQLITE_HAS_CODEC
sqlite3pager_free_codecarg(pPager->pCodecArg);
#endif
那里要注意，sqlite3PagerClose 函数大约也是 3.3.17本子左右才改名的，之前版本里是叫 “sqlite3pager_close”。因此你在老版本sqlite代码里寻找“sqlite3PagerClose”是搜不到的。
看似的还有“sqlite3pager_get”、“sqlite3pager_unref”、“sqlite3pager_write”、“sqlite3pager_pagecount”等都以老版本函数，它们在 pager.h 文件里定义。新本子对应函数是在 sqlite3.h 里定义（因为都统一到 sqlite3.c和sqlite3.h两文件了）。所以，如若您在拔取老版本的sqlite，先看看 pager.h 文件，这一个函数不是泯灭了，也不是新蹦出来的，而是老版本函数改名拿到的。
末段，往sqlite3.c 文件下找。找到最终一行：
/************** End of main.c
************************************************/
在这一行后边，接上本文最上边的代码段。
那些代码相当短，我不再解释，直接接上去就得了。
唯一要提的是 DeriveKey 函数。那么些函数是对密钥的扩大。比如，你须求密钥是128位，即是16字节，可是一旦用户只输入 1个字节呢？2个字节呢？或输入50个字节呢？你得对密钥举行伸张，使之符合16字节的要求。
DeriveKey 函数就是做这一个扩充的。有人把接收到的密钥求md5，这也是一个方法，因为md5运算结果一定16字节，不论你有些许字符，最后就是16字节。那是md5算法的表征。不过本人不想用md5，因为还得为它添加包罗部分 md5 的.c或.cpp文件。小编不想这么做。作者要好写了一个算法来扩张密钥，很简短的算法。当然，你也得以使用你的伸张方法，也而得以应用md5 算法。只要修改 DeriveKey 函数就足以了。
在 DeriveKey 函数里，只管申请空间社团所急需的密钥，不必要释放，因为在另一个函数里有自由进程，而不行函数会在数据库关闭时被调用。参考作者的 DeriveKey 函数来报名内存。
那里自个儿付诸作者曾经修改好的 sqlite3.c 和 sqlite3.h 文件。
只要太懒，就径直利用那五个文本，编译肯定能通过，运行也正常。当然，你不大概不按小编后边提的，新建 crypt.h 和crypt.c 文件，而且函数要按本身目前定义的渴求来做。
3 加密应用格局
当今，你代码已经有了加密功效。
你要把加密效果给用上，除了改 sqlite3.c 文件、给您工程添加 SQLITE_HAS_CODEC 宏，还得修改你的数据库调用函数。
面前提到过，要从头一个数据库操作，必须先 sqlite3_open 。
加解密进度就在 sqlite3_open 后边操作。
一经你早已 sqlite3_open 成功了，紧接着写上面的代码：
int i;
//添加、使用密码
i = sqlite3_key( db, “dcg”, 3 );
//修改密码
i = sqlite3_rekey( db, “dcg”, 0 );
用 sqlite3_key 函数来交给密码。
第1个参数是 sqlite3
* 类型变量，代表着用 sqlite3_open 打开的数据库（或新建数据库）。
第2个参数是密钥。
第3个参数是密钥长度。
用 sqlite3_rekey 来修改密码。参数含义同 sqlite3_key。
事实上，你可以在sqlite3_open函数之后，到 sqlite3_close 函数在此以前任意地方调用 sqlite3_key 来设置密码。
而是只要您没有安装密码，而数据库此前是有密码的，那么您做其它操作都会获得一个再次来到值：SQLITE_NOTADB，并且取得错误提醒：“file
is encrypted or is not a database”。
除非当你用 sqlite3_key 设置了不错的密码，数据库才会健康工作。
假诺您要修改密码，前提是您必须先 sqlite3_open 打开数据库成功，然后 sqlite3_key 设置密钥成功，之后才能用sqlite3_rekey 来修改密码。
只要数据库有密码，但您未曾用 sqlite3_key 设置密码，那么当您品尝用 sqlite3_rekey 来修改密码时会得到SQLITE_NOTADB 返回值。
假设您须求清空密码，可以利用：
//修改密码
i = sqlite3_rekey( db, NULL, 0 );
来形成密码清空效能。
4 sqlite3.c 最终添加代码段
/***
董淳光定义的加密函数
***/
#ifdef SQLITE_HAS_CODEC
/***
加密结构
***/
#define CRYPT_OFFSET 8
typedef struct _CryptBlock
{
BYTE* ReadKey; // 读数据库和写入事务的密钥
BYTE* WriteKey; // 写入数据库的密钥
int PageSize; // 页的分寸
BYTE* Data;
} CryptBlock, *LPCryptBlock;
#ifndef DB_KEY_LENGTH_BYTE /*密钥长度*/
#define DB_KEY_LENGTH_BYTE 16 /*密钥长度*/
#endif
#ifndef DB_KEY_PADDING /*密钥位数相差时补充的字符*/
#define DB_KEY_PADDING 0x33 /*密钥位数相差时补充的字符*/
#endif
/*** 上面是编译时指示缺乏的函数 ***/
/** 那个函数不须求做任何处理，获取密钥的局部在底下 DeriveKey 函数里达成 **/
void sqlite3CodecGetKey(sqlite3* db, int nDB, void** Key, int* nKey)
{
return ;
}
/*被sqlite 和 sqlite3_key_interop 调用, 附加密钥到数量库.*/
int sqlite3CodecAttach(sqlite3
*db, int nDb, const void *pKey, int nKeyLen);
/**
那几个函数好像是 sqlite
3.3.17前不久才加的，在此此前版本的sqlite里没有见到那么些函数
这么些函数笔者还尚未搞了解是做什么的，它里面什么都不做间接再次回到，对加解密从不影响
**/
void sqlite3_activate_see(const char* right )
{
return;
}
int sqlite3_key(sqlite3 *db, const void *pKey, int nKey);
int sqlite3_rekey(sqlite3 *db, const void *pKey, int nKey);
/***
下边是上边的函数的协理处理函数
***/
// 从用户提供的缓冲区中获取一个加密密钥
// 用户提供的密钥或许位数上知足不断须要，使用那么些函数来形成密钥扩大
static unsigned char * DeriveKey(const void *pKey, int nKeyLen);
//创制或更新一个页的加密算法索引.此函数会申请缓冲区.
static LPCryptBlock CreateCryptBlock(unsigned char* hKey, Pager
*pager, LPCryptBlock pExisting);
//加密/解密函数, 被pager调用
void * sqlite3Codec(void *pArg, unsigned char *data, Pgno
nPageNum, int nMode);
//设置密码函数
int __stdcall sqlite3_key_interop(sqlite3
*db, const void *pKey, int nKeySize);
// 修改密码函数
int __stdcall sqlite3_rekey_interop(sqlite3
*db, const void *pKey, int nKeySize);
//销毁一个加密块及连锁的缓冲区,密钥.
static void DestroyCryptBlock(LPCryptBlock pBlock);
static void * sqlite3pager_get_codecarg(Pager *pPager);
void sqlite3pager_set_codec(Pager
*pPager,void *(*xCodec)(void*,void*,Pgno,int),void *pCodecArg );
//加密/解密函数, 被pager调用
void * sqlite3Codec(void *pArg, unsigned char *data, Pgno
nPageNum, int nMode)
{
LPCryptBlock pBlock = (LPCryptBlock)pArg;
unsigned int dwPageSize = 0;
if (!pBlock) return data;
// 确保pager的页长度和加密块的页长度相等.若是改变,就须要调整.
if (nMode != 2)
{
PgHdr *pageHeader;
pageHeader = DATA_TO_PGHDR(data);
if (pageHeader->pPager->pageSize != pBlock->PageSize)
{
CreateCryptBlock(0, pageHeader->pPager, pBlock);
}
}
switch(nMode)
{
case 0: // Undo a “case 7” journal file encryption
case 2: //重载一个页
case 3: //载入一个页
if (!pBlock->ReadKey) break;
dwPageSize = pBlock->PageSize;
My_DeEncrypt_Func(data, dwPageSize, pBlock->ReadKey,
DB_KEY_LENGTH_BYTE ); /*调用我的解密函数*/
break;
case 6: //加密一个主数据库文件的页
if (!pBlock->WriteKey) break;
memcpy(pBlock->Data + CRYPT_OFFSET, data, pBlock->PageSize);
data = pBlock->Data + CRYPT_OFFSET;
dwPageSize = pBlock->PageSize;
My_Encrypt_Func(data , dwPageSize, pBlock->WriteKey,
DB_KEY_LENGTH_BYTE ); /*调用我的加密函数*/
break;
case 7: //加密事务文件的页
/*在健康环境下, 读密钥和写密钥相同. 当数据库是被重新加密的,读密钥和写密钥未必相同.
回滚事务须要用数据库文件的原来密钥写入.因而,当两遍回滚被写入,总是用数据库的读密钥,
这是为着确保与读取原始数据的密钥相同.
*/
if (!pBlock->ReadKey) break;
memcpy(pBlock->Data + CRYPT_OFFSET, data, pBlock->PageSize);
data = pBlock->Data + CRYPT_OFFSET;
dwPageSize = pBlock->PageSize;
My_Encrypt_Func( data, dwPageSize, pBlock->ReadKey,
DB_KEY_LENGTH_BYTE ); /*调用小编的加密函数*/
break;
}
return data;
}
//销毁一个加密块及有关的缓冲区,密钥.
static void DestroyCryptBlock(LPCryptBlock pBlock)
{
//销毁读密钥.
if (pBlock->ReadKey){
sqliteFree(pBlock->ReadKey);
}
//若是写密钥存在并且不对等读密钥,也销毁.
if (pBlock->WriteKey && pBlock->WriteKey != pBlock->ReadKey){
sqliteFree(pBlock->WriteKey);
}
if(pBlock->Data){
sqliteFree(pBlock->Data);
}
//释放加密块.
sqliteFree(pBlock);
}
static void * sqlite3pager_get_codecarg(Pager *pPager)
{
return (pPager->xCodec) ? pPager->pCodecArg: NULL;
}
// 从用户提供的缓冲区中收获一个加密密钥
static unsigned char * DeriveKey(const void *pKey, int nKeyLen)
{
unsigned char * hKey = NULL;
int j;
if( pKey == NULL || nKeyLen == 0 )
{
return NULL;
}
hKey = sqliteMalloc( DB_KEY_LENGTH_BYTE + 1 );
if( hKey == NULL )
{
return NULL;
}
hKey[ DB_KEY_LENGTH_BYTE ] = 0;
if( nKeyLen < DB_KEY_LENGTH_BYTE )
{
memcpy( hKey, pKey, nKeyLen ); //先拷贝拿到密钥后边的部分
j = DB_KEY_LENGTH_BYTE – nKeyLen;
//补充密钥前面的有的
memset( hKey + nKeyLen, DB_KEY_PADDING, j );
}
else
{ //密钥位数已经充足,间接把密钥取过来
memcpy( hKey, pKey, DB_KEY_LENGTH_BYTE );
}
return hKey;
}
//创设或更新一个页的加密算法索引.此函数会申请缓冲区.
static LPCryptBlock CreateCryptBlock(unsigned char* hKey, Pager
*pager, LPCryptBlock pExisting)
{
LPCryptBlock pBlock;
if (!pExisting) //成立新加密块
{
pBlock = sqliteMalloc(sizeof(CryptBlock));
memset(pBlock, 0, sizeof(CryptBlock));
pBlock->ReadKey = hKey;
pBlock->WriteKey = hKey;
pBlock->PageSize = pager->pageSize;
pBlock->Data = (unsigned char*)sqliteMalloc(pBlock->PageSize
- CRYPT_OFFSET);
}
else //更新存在的加密块
{
pBlock = pExisting;
if ( pBlock->PageSize != pager->pageSize &&
!pBlock->Data){
sqliteFree(pBlock->Data);
pBlock->PageSize = pager->pageSize;
pBlock->Data =
(unsigned char*)sqliteMalloc(pBlock->PageSize + CRYPT_OFFSET);
}
}
memset(pBlock->Data, 0, pBlock->PageSize + CRYPT_OFFSET);
return pBlock;
}
/*
** Set the codec for this pager
*/
void sqlite3pager_set_codec(
Pager *pPager,
void *(*xCodec)(void*,void*,Pgno,int),
void *pCodecArg
)
{
pPager->xCodec = xCodec;
pPager->pCodecArg = pCodecArg;
}
int sqlite3_key(sqlite3 *db, const void *pKey, int nKey)
{
return sqlite3_key_interop(db, pKey, nKey);
}
int sqlite3_rekey(sqlite3 *db, const void *pKey, int nKey)
{
return sqlite3_rekey_interop(db, pKey, nKey);
}
/*被sqlite 和 sqlite3_key_interop 调用, 附加密钥到数码库.*/
int sqlite3CodecAttach(sqlite3
*db, int nDb, const void *pKey, int nKeyLen)
{
int rc = SQLITE_ERROR;
unsigned char* hKey = 0;
//假设没有点名密匙,大概标识用了主数据库的加密或没加密.
if (!pKey || !nKeyLen)
{
if (!nDb)
{
return SQLITE_OK; //主数据库, 没有点名密钥所以没有加密.
}
else //附加数据库,使用主数据库的密钥.
{
//获取主数据库的加密块并复制密钥给附加数据库使用
LPCryptBlock pBlock =
(LPCryptBlock)sqlite3pager_get_codecarg(sqlite3BtreePager(db->aDb[0].pBt));
if (!pBlock) return SQLITE_OK; //主数据库没有加密
if (!pBlock->ReadKey) return SQLITE_OK; //没有加密
memcpy(pBlock->ReadKey, &hKey, 16);
}
}
else //用户提供了密码,从中创设密钥.
{
hKey = DeriveKey(pKey, nKeyLen);
}
//创设一个新的加密块,并将解码器指向新的叠加数据库.
if (hKey)
{
LPCryptBlock pBlock = CreateCryptBlock(hKey,
sqlite3BtreePager(db->aDb[nDb].pBt), NULL);
sqlite3pager_set_codec(sqlite3BtreePager(db->aDb[nDb].pBt),
sqlite3Codec, pBlock);
rc = SQLITE_OK;
}
return rc;
}
// Changes the encryption key for an existing database.
int __stdcall sqlite3_rekey_interop(sqlite3
*db, const void *pKey, int nKeySize)
{
Btree *pbt = db->aDb[0].pBt;
Pager *p = sqlite3BtreePager(pbt);
LPCryptBlock pBlock = (LPCryptBlock)sqlite3pager_get_codecarg(p);
unsigned char * hKey = DeriveKey(pKey, nKeySize);
int rc = SQLITE_ERROR;
if (!pBlock && !hKey) return SQLITE_OK;
//重新加密一个数据库,改变pager的写密钥, 读密钥依然保留.
if (!pBlock) //加密一个未加密的数据库
{
pBlock = CreateCryptBlock(hKey, p, NULL);
pBlock->ReadKey = 0; // 原始数据库未加密
sqlite3pager_set_codec(sqlite3BtreePager(pbt), sqlite3Codec,
pBlock);
}
else // 改变已加密数据库的写密钥
{
pBlock->WriteKey = hKey;
}
// 开始一个作业
rc = sqlite3BtreeBeginTrans(pbt, 1);
if (!rc)
{
// 用新密钥重写所有的页到数据库。
Pgno nPage = sqlite3PagerPagecount(p);
Pgno nSkip = PAGER_MJ_PGNO(p);
void *pPage;
Pgno n;
for(n = 1; rc == SQLITE_OK && n <= nPage; n ++)
{
if (n == nSkip) continue;
rc = sqlite3PagerGet(p, n, &pPage);
if(!rc)
{
rc = sqlite3PagerWrite(pPage);
sqlite3PagerUnref(pPage);
}
}
}
// 假设成功，提交业务。
if (!rc)
{
rc = sqlite3BtreeCommit(pbt);
}
// 如若退步，回滚。
if (rc)
{
sqlite3BtreeRollback(pbt);
}
// 假若成功，销毁先前的读密钥。并使读密钥等于当前的写密钥。
if (!rc)
{
if (pBlock->ReadKey)
{
sqliteFree(pBlock->ReadKey);
}
pBlock->ReadKey = pBlock->WriteKey;
}
else// 假使战败，销毁当前的写密钥，并上升为当下的读密钥。
{
if (pBlock->WriteKey)
{
sqliteFree(pBlock->WriteKey);
}
pBlock->WriteKey = pBlock->ReadKey;
}
// 假诺读密钥和写密钥皆为空，就不要求再对页举办编解码。
// 销毁加密块并移除页的编解码器
if (!pBlock->ReadKey && !pBlock->WriteKey)
{
sqlite3pager_set_codec(p, NULL, NULL);
DestroyCryptBlock(pBlock);
}
return rc;
}
/***
上面是加密函数的主体
***/
int __stdcall sqlite3_key_interop(sqlite3
*db, const void *pKey, int nKeySize)
{
return sqlite3CodecAttach(db, 0, pKey, nKeySize);
}
// 释放与一个页相关的加密块
void sqlite3pager_free_codecarg(void *pArg)
{
if (pArg)
DestroyCryptBlock((LPCryptBlock)pArg);
}
#endif //#ifdef SQLITE_HAS_CODEC
五、品质优化
许多个人直接就使用了，并未在意到SQLite也有安顿参数，可以对品质举办调整。有时候，发生的结果会有很大影响。
重大通过pragma指令来兑现。
譬如： 空间释放、磁盘同步、Cache大小等。
不要打开。前文升高了，Vacuum的频率万分低！
1 auto_vacuum
PRAGMA auto_vacuum;
PRAGMA auto_vacuum = 0 | 1;
询问或设置数据库的auto-vacuum标记。
健康情况下，当提交一个从数据库中删去数据的事务时，数据库文件不转移大小。未采纳的公文页被标记并在未来的拉长操作中重新利用。那种意况下利用VACUUM命令释放删除得到的长空。
当开启auto-vacuum，当提交一个从数据库中删去数据的事务时，数据库文件自动减弱， (VACUUM命令在auto-vacuum开启的数据库中不起作用)。数据库会在里头存储一些新闻以便帮助这一意义，这使得数据库文件比不开启该选拔时有点大片段。
唯有在数据库中未建其余表时才能改变auto-vacuum标记。试图在已有表的气象下修改不会招致报错。
2 cache_size
指出改为8000
PRAGMA cache_size;
PRAGMA cache_size = Number-of-pages;
询问或修改SQLite一遍存储在内存中的数据库文件页数。每页使用约1.5K内存，缺省的缓存大小是2000. 若须要选择改变大批量多行的UPDATE或DELETE命令，并且不介意SQLite使用更加多的内存的话，能够叠加缓存以增加质量。
当使用cache_size
pragma改变缓存大时辰，改变仅对近日对话有效，当数据库关闭重新打开时缓存大小苏醒到缺省大小。 要想永远改变缓存大小，使用default_cache_size pragma.
3 case_sensitive_like
打开。不然搜索中文字串会出错。
PRAGMA case_sensitive_like;
PRAGMA case_sensitive_like = 0 | 1;
LIKE运算符的缺省行为是忽略latin1字符的尺寸写。因而在缺省气象下’a’ LIKE
‘A’的值为真。可以透过打开case_sensitive_like
pragma来改变这一缺省作为。当启用case_sensitive_like，’a’ LIKE
‘A’为假而 ‘a’ LIKE ‘a’如故为真。
4 count_changes
开辟。便于调试
PRAGMA count_changes;
PRAGMA count_changes = 0 | 1;
询问或转移count-changes标记。正常状态下INSE昂科威T,
UPDATE和DELETE语句不回来数据。 当开启count-changes，以上语句重回一行含一个整数值的数额——该语句插入，修改或删除的行数。 重返的行数不包蕴由触发器爆发的插入，修改或删除等转移的行数。
5 page_size
PRAGMA page_size;
PRAGMA page_size = bytes;
询问或设置page-size值。只有在未创制数据库时才能安装page-size。页面大小必须是2的平头倍且高于等于512低于等于8192。 上限可以经过在编译时修改宏定义SQLITE_MAX_PAGE_SIZE的值来改变。上限的上限是32768.
6 synchronous
只要有时限备份的体制，而且少量数额丢失可承受，用OFF
PRAGMA synchronous;
PRAGMA synchronous = FULL; (2)
PRAGMA synchronous = NORMAL; (1)
PRAGMA synchronous = OFF; (0)
询问或转移”synchronous”标记的设定。第一种样式(查询)重临整数值。 当synchronous设置为FULL
(2),
SQLite数据库引擎在迫切时刻会搁浅以确定数据现已写入磁盘。 那使系统崩溃或电源出标题时能保险数据库在重起后不会破坏。FULL
synchronous很安全但很慢。 当synchronous设置为NOTucsonMAL,
SQLite数据库引擎在大部分殷切时刻会搁浅，但不像FULL情势下那么频仍。 NO奔驰G级MAL格局下有很小的可能率(但不是不存在)发生电源故障造成数据库损坏的景况。但实在，在那种情况下很恐怕你的硬盘已经无法利用，或许发生了其他的不可復苏的硬件错误。 设置为synchronous
OFF
(0)时，SQLite在传递数据给系统以后直接接轨而不间歇。若运行SQLite的应用程序崩溃， 数据不会挫伤，但在系统崩溃或写入数据时意外断电的意况下数据库或者会破坏。另一方面，在synchronous
OFF时 一些操作只怕会快50倍甚至更多。
在SQLite 2中，缺省值为NO冠道MAL.而在3中修改为FULL.
7 temp_store
利用2，内存格局。
PRAGMA temp_store;
PRAGMA temp_store = DEFAULT; (0)
PRAGMA temp_store = FILE; (1)
PRAGMA temp_store = MEMORY; (2)
查询或改变”temp_store”参数的设置。当temp_store设置为DEFAULT
(0),使用编译时的C预处理宏 TEMP_STORE来定义储存临时表和暂时索引的地点。当设置为MEMO翼虎Y
(2)临时表和目录存放于内存中。 当设置为FILE
(1)则存放于文件中。temp_store_directorypragma 可用以指定存放该文件的目录。当改变temp_store设置，所有已存在的临时表，索引，触发器及视图将被及时删除。
经测试，在类BBS应用上，通过上述调整，作用可以增强2倍以上。