前序：
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 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"
/***********
用於在 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標記。正常情況下INSERT, 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設定為NORMAL, SQLite資料庫引擎在大部分緊急時刻會暫停，但不像FULL模式下那麼頻繁。 NORMAL模式下有很小的機率(但不是不存在)發生電源故障導致資料庫損壞的情況。但實際上，在這種情況 下很可能你的硬碟已經不能使用，或者發生了其他的不可恢復的硬體錯誤。 設定為synchronous OFF (0)時，SQLite在傳遞資料給系統以後直接繼續而不暫停。若執行SQLite的應用程式崩潰， 資料不會損傷，但在系統崩潰或寫入資料時意外斷電的情況下資料庫可能會損壞。另一方面，在synchronous OFF時 一些操作可能會快50倍甚至更多。
在SQLite 2中，預設值為NORMAL.而在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來定義儲存臨時表和臨時索引的位置。當設定為MEMORY (2)臨時表和索引存放於記憶體中。 當設定為FILE (1)則存放於檔案中。temp_store_directorypragma 可用於指定存放該檔案的目錄。當改變temp_store設定，所有已存在的臨時表，索引，觸發器及檢視將被立即刪除。
經測試，在類BBS應用上，通過以上調整，效率可以提高2倍以上。