数据库 sqlite 进阶

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倍以上。

 

网站地图xml地图