前序：
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） 根蒂根基流程
i.1 关键数据布局
sqlite 里最常用到的是 sqlite3 * 类型。从数据库打开开端，sqlite就要为这个类型筹办好内存，直到数据库封闭，全部过程都须要用到这个类型。当数据库打开时开端，这个类型的变量就代表了你要操纵的数据库。下面再具体介绍。
i.2 打开数据库
int sqlite3_open（ 文件名， sqlite3 ** ）;
用这个函数开端数据库操纵。
须要传入两个参数，一是数据库文件名，比如：c://DongChunGuang_Database.db。
文件名不须要必然存在，若是此文件不存在，sqlite 会主动建树它。若是它存在，就测验测验把它当数据库文件来打开。
sqlite3 ** 参数即前面提到的关键数据布局。这个布局底层细节如何，你不要关它。
函数返回值默示操纵是否正确，若是是 SQLITE_OK 则默示操纵正常。相干的返回值sqlite定义了一些宏。具体这些宏的含义可以参考 sqlite3.h 文件。里面有具体定义（趁便说一下，sqlite3 的代码注释率自称是很是高的，实际上也的确很高。只要你会看英文，sqlite 可以让你学到不少器材）。
下面介绍封闭数据库后，再给一段参考代码。
i.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 语法。
i.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默示你不须要回调。比如你做 操纵，做 操纵，就没有须要应用回调。而当你做 时，就要应用回调，因为 sqlite3 把数据查出来，得经由过程回调告诉你查出了什么数据。
i.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是一个主动增长的类型，今后时可以不去指定这个字段，它会本身从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， “ into MyTable_1（ name ） values （ ‘走路’ ）”， 0， 0， errmsg ）;
if（result != SQLITE_OK ）
{
printf（ “插入记录失败，错误码:％d，错误原因:％s/n”， result， errmsg ）;
}
result = sqlite3_exec（ db， “ into MyTable_1（ name ） values （ ‘骑单车’ ）”， 0， 0， errmsg ）;
if（result != SQLITE_OK ）
{
printf（ “插入记录失败，错误码:％d，错误原因:％s/n”， result， errmsg ）;
}
result = sqlite3_exec（ db， “ into MyTable_1（ name ） values （ ‘坐汽车’ ）”， 0， 0， errmsg ）;
if（result != SQLITE_OK ）
{
printf（ “插入记录失败，错误码:％d，错误原因:％s/n”， result， errmsg ）;
}
//开端查询数据库
result = sqlite3_exec（ db， “ * MyTable_1”， LoadMyInfo， NULL， errmsg ）;
//封闭数据库
sqlite3_close（ db ）;
return 0;
}
经由过程上方的例子，应当可以知道如何打开一个数据库，如何做数据库根蒂根基操纵。
有这些常识，根蒂根基上可以敷衍很多半据库操纵了。
i.3 不应用回查询拜访询数据库
上方介绍的 sqlite3_exec 是应用回调来履行 操纵。还有一个办法可以直接查询而不须要回调。然则，我小我感触感染还是回调好，因为代码可以加倍整洁，只不过用回调很麻烦，你得声明一个函数，若是这个函数是类成员函数，你还不得不把它声明成 static 的（要问为什么？这又是C++根蒂根基了。C++成员函数实际上隐蔽了一个参数：this，C++调用类的成员函数的时辰，隐含把类指针当成函数的第一个参数传递进去。成果，这造成跟前面说的 sqlite 回调函数的参数不相符。只有当把成员函数声明成 static 时，它才没有多余的隐含的this参数）。
固然回调显得代码整洁，但有时辰你还是想要非回调的 查询。这可以经由过程 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， “ * 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 语句，完全可以敷衍绝大多半数据库需求。
但有一种景象，用上方办法是无法实现的：须要、 二进制。当须要处理惩罚二进制数据时，上方的办法就没办法做到。下面这一节申明如何插入二进制数据
（2） 操纵二进制
sqlite 操纵二进制数据须要用一个帮助的数据类型：sqlite3_stmt * 。
这个数据类型记录了一个“sql语句”。为什么我把 “sql语句” 用双引号引起来？因为你可以把 sqlite3_stmt * 所默示的内容算作是 sql语句，然则实际上它不是我们所熟知的sql语句。它是一个已经把sql语句解析了的、用sqlite本身标识表记标帜记录的内部数据布局。
正因为这个布局已经被解析了，所以你可以往这个语句里插入二进制数据。当然，把二进制数据插到 sqlite3_stmt 布局里可不克不及直接 memcpy ，也不克不及像 std::string 那样用 + 号。必须用 sqlite 供给的函数来插入。
i.1 写入二进制
下面说写二进制的步调。
要插入二进制，前提是这个表的字段的类型是 blob 类型。我假设有这么一张表：
create table Tbl_2（ ID integer， file_content blob ）
起首声明
sqlite3_stmt * stat;
然后，把一个 sql 语句解析到 stat 布局里去：
sqlite3_prepare（ db， “ 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 ）; //把刚才分派的内容析构掉
i.2 读出二进制
下面说读二进制的步调。
跟前面一样，先声明 sqlite3_stmt * 类型变量：
sqlite3_stmt * stat;
然后，把一个 sql 语句解析到 stat 布局里去：
sqlite3_prepare（ db， “ * 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 ）; //把刚才分派的内容析构掉
i.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 ）; //回滚事务
一、 给数据库加密
前面所说的内容网上已经有很多材料，固然斗劲零散，然则花点时候也还是可以找到的。如今要说的这个——数据库加密，材料就很难找。也可能是我操纵程度不敷，找不到对应材料。但不管如许，我还是经由过程网上能找到的很有限的材料，摸索出了给sqlite数据库加密的完全步调。
这里要提一下，固然 sqlite 很好用，速度快、体积小巧。然则它保存的文件倒是明文的。若不信可以用 NotePad 打开数据库文件瞧瞧，里面 的内容几乎一目了然。如许赤裸裸的显现本身，可不是我们的初志。当然，若是你在嵌入式体系、智妙手机上应用 sqlite，最好是不加密，因为这些体系运算才能有限，你做为一个新功能供给者，不克不及把用户有限的运算才能全部花掉。
Sqlite为了速度而出生。是以Sqlite本身不合错误数据库加密，要知道，若是你选择标准AES算法加密，那么必然有接近50％的时候消费在加解密算法上，甚至更多（机能首要取决于你算法编写程度以及你是否能应用cpu供给的底层运算才能，比如MMX或sse系列指令可以大幅度提拔运算速度）。
Sqlite免费版本是不供给加密功能的，当然你也可以选择他们的收费版本，那你得付出2000块钱，并且是USD。我这里也不是说付出钱不好，若是只为了数据库加密就去付出2000块，我感觉划不来。因为下面我将要告诉你如何为免费的Sqlite扩大出加密模块——本身下手扩大，这是Sqlite容许，也是它倡导的。
那么，就让我们一路开端为 sqlite3.c 文件扩大出加密模块。
i.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只留了接口罢了，并没有给出实现。
下面就让我来实现这些接口。
i.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_
***********/
int My_DeEncrypt_Func（ unsigned char * pData， unsigned int data_len， const char * key， unsigned int len_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 int len_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"
void sqlite3pager_free_codecarg（void *pArg）;
＃endif
这个函数之所以要在 sqlite3.c 开首声明，是因为下面在 sqlite3.c 里面某些函数里要插入这个函数调用。所以要提前声明。
其次，在sqlite3.c文件里搜刮“sqlite3PagerClose”函数，要找到它的实现代码（而不是声明代码）。
实现代码里一开端是：
＃ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
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 文件下找。找到最后一行：
在这一行后面，接上本文最下面的代码段。
这些代码很长，我不再申明，直接接上去就得了。
独一要提的是 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 文件，并且函数要按我前面定义的请求来做。
i.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 ）;
来完成暗码清空功能。
i.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 0 x33
＃endif
void sqlite3CodecGetKey（sqlite3* db， int nDB， void** Key， int* nKey）
{
return ;
}
int sqlite3CodecAttach（sqlite3 *db， int nDb， const void *pKey， int nKeyLen）;
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;
}
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）;
}
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
联系客服
