extern "C"
{
#include "./sqlite3.h"
};
int main( int , char** )
{
return 0;
}

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;
}

//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;
}

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;
}

int result = sqlite3_step( stat );

sqlite3_stmt * stat;

sqlite3_prepare( db, “select * from Tbl_2”, -1, &stat, 0 );

int result = sqlite3_step( stat );

const void * pFileContent = sqlite3_column_blob( stat, 1 );
int len = sqlite3_column_bytes( stat, 1 );

result = sqlite3_reset(stat);

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 ); //回滚事务

 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*);

#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 */

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*);

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*);

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);

#define SQLITE_INTEGER 1
#define SQLITE_FLOAT  2
#define SQLITE_TEXT   3
#define SQLITE_BLOB   4
#define SQLITE_NULL   5

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

 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*);

 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*));

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*));

#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;
}

#ifdef SQLITE_HAS_CODEC
#include "./crypt.h"
/***********

***********/
void sqlite3pager_free_codecarg(void *pArg);
#endif

#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

/***
董淳光定义的加密函数
***/
#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