【发布时间】：2010-12-15 06:15:26
【问题描述】：
优化 SQLite 很棘手。 C 应用程序的批量插入性能从每秒 85 次插入到每秒超过 96,000 次插入不等！
背景：我们使用 SQLite 作为桌面应用程序的一部分。我们有大量的配置数据存储在 XML 文件中，这些数据被解析并加载到 SQLite 数据库中，以便在应用程序初始化时进行进一步处理。 SQLite 非常适合这种情况，因为它速度快，不需要专门的配置，并且数据库作为单个文件存储在磁盘上。
理由： 最初我对所看到的性能感到失望。 结果表明，SQLite 的性能可能会有很大差异（对于批量插入和选择而言） ) 取决于数据库的配置方式以及您使用 API 的方式。弄清楚所有选项和技术是什么并不是一件容易的事，因此我认为创建这个社区 wiki 条目以与 StackOverflow 读者分享结果以节省其他人进行相同调查的麻烦是明智的。
实验：与其简单地谈论一般意义上的性能技巧（即“使用事务！”），我认为最好编写一些 C 代码实际衡量各种选项的影响。我们将从一些简单的数据开始：
- complete transit schedule for the city of Toronto 的 28 MB 制表符分隔的文本文件（大约 865,000 条记录）
- 我的测试机器是运行 Windows XP 的 3.60 GHz P4。
- 代码使用Visual C++ 2005 编译为具有“完全优化”(/Ox) 和Favor Fast Code (/Ot) 的“发布”。
- 我正在使用直接编译到我的测试应用程序中的 SQLite“合并”。我碰巧拥有的 SQLite 版本有点旧（3.6.7），但我怀疑这些结果将与最新版本相当（如果您不这么认为，请发表评论）。
让我们写一些代码吧！
代码： 一个简单的 C 程序，它逐行读取文本文件，将字符串拆分为值，然后将数据插入 SQLite 数据库。在这个“基线”版本的代码中，创建了数据库，但我们不会实际插入数据：
/*************************************************************
Baseline code to experiment with SQLite performance.
Input data is a 28 MB TAB-delimited text file of the
complete Toronto Transit System schedule/route info
from http://www.toronto.ca/open/datasets/ttc-routes/
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "sqlite3.h"
#define INPUTDATA "C:\\TTC_schedule_scheduleitem_10-27-2009.txt"
#define DATABASE "c:\\TTC_schedule_scheduleitem_10-27-2009.sqlite"
#define TABLE "CREATE TABLE IF NOT EXISTS TTC (id INTEGER PRIMARY KEY, Route_ID TEXT, Branch_Code TEXT, Version INTEGER, Stop INTEGER, Vehicle_Index INTEGER, Day Integer, Time TEXT)"
#define BUFFER_SIZE 256
int main(int argc, char **argv) {
sqlite3 * db;
sqlite3_stmt * stmt;
char * sErrMsg = 0;
char * tail = 0;
int nRetCode;
int n = 0;
clock_t cStartClock;
FILE * pFile;
char sInputBuf [BUFFER_SIZE] = "\0";
char * sRT = 0; /* Route */
char * sBR = 0; /* Branch */
char * sVR = 0; /* Version */
char * sST = 0; /* Stop Number */
char * sVI = 0; /* Vehicle */
char * sDT = 0; /* Date */
char * sTM = 0; /* Time */
char sSQL [BUFFER_SIZE] = "\0";
/*********************************************/
/* Open the Database and create the Schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
/*********************************************/
/* Open input file and import into Database*/
cStartClock = clock();
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sRT = strtok (sInputBuf, "\t"); /* Get Route */
sBR = strtok (NULL, "\t"); /* Get Branch */
sVR = strtok (NULL, "\t"); /* Get Version */
sST = strtok (NULL, "\t"); /* Get Stop Number */
sVI = strtok (NULL, "\t"); /* Get Vehicle */
sDT = strtok (NULL, "\t"); /* Get Date */
sTM = strtok (NULL, "\t"); /* Get Time */
/* ACTUAL INSERT WILL GO HERE */
n++;
}
fclose (pFile);
printf("Imported %d records in %4.2f seconds\n", n, (clock() - cStartClock) / (double)CLOCKS_PER_SEC);
sqlite3_close(db);
return 0;
}
“控制”
按原样运行代码实际上并不执行任何数据库操作，但它会让我们了解原始 C 文件 I/O 和字符串处理操作的速度。
0.94 导入 864913 条记录 秒
太棒了！我们每秒可以进行 920,000 次插入，前提是我们实际上不进行任何插入 :-)
“最坏情况”
我们将使用从文件中读取的值生成 SQL 字符串，并使用 sqlite3_exec 调用该 SQL 操作：
sprintf(sSQL, "INSERT INTO TTC VALUES (NULL, '%s', '%s', '%s', '%s', '%s', '%s', '%s')", sRT, sBR, sVR, sST, sVI, sDT, sTM);
sqlite3_exec(db, sSQL, NULL, NULL, &sErrMsg);
这会很慢，因为每次插入的 SQL 都会被编译成 VDBE 代码，而且每次插入都会发生在自己的事务中。 有多慢？
在 9933.61 中导入了 864913 条记录 秒
哎呀！ 2小时45分钟！这只是 每秒 85 次插入。
使用事务
默认情况下，SQLite 将评估唯一事务中的每个 INSERT / UPDATE 语句。如果执行大量插入，建议将您的操作包装在事务中：
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
...
}
fclose (pFile);
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
38.03 导入 864913 条记录 秒
这样更好。只需将我们所有的插入包装在一个事务中即可将我们的性能提高到 每秒 23,000 次插入。
使用准备好的语句
使用事务是一个巨大的改进，但是如果我们一遍又一遍地使用相同的 SQL，那么为每个插入重新编译 SQL 语句就没有意义了。让我们使用sqlite3_prepare_v2 编译一次我们的SQL 语句，然后使用sqlite3_bind_text 将我们的参数绑定到该语句：
/* Open input file and import into the database */
cStartClock = clock();
sprintf(sSQL, "INSERT INTO TTC VALUES (NULL, @RT, @BR, @VR, @ST, @VI, @DT, @TM)");
sqlite3_prepare_v2(db, sSQL, BUFFER_SIZE, &stmt, &tail);
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sRT = strtok (sInputBuf, "\t"); /* Get Route */
sBR = strtok (NULL, "\t"); /* Get Branch */
sVR = strtok (NULL, "\t"); /* Get Version */
sST = strtok (NULL, "\t"); /* Get Stop Number */
sVI = strtok (NULL, "\t"); /* Get Vehicle */
sDT = strtok (NULL, "\t"); /* Get Date */
sTM = strtok (NULL, "\t"); /* Get Time */
sqlite3_bind_text(stmt, 1, sRT, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, sBR, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 3, sVR, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 4, sST, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 5, sVI, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 6, sDT, -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 7, sTM, -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
n++;
}
fclose (pFile);
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
printf("Imported %d records in %4.2f seconds\n", n, (clock() - cStartClock) / (double)CLOCKS_PER_SEC);
sqlite3_finalize(stmt);
sqlite3_close(db);
return 0;
16.27 导入 864913 条记录 秒
不错！还有一点点代码（别忘了调用sqlite3_clear_bindings 和sqlite3_reset），但我们的性能提高了一倍多，达到每秒53,000 次插入。
PRAGMA 同步 = 关闭
默认情况下，SQLite 会在发出操作系统级别的写入命令后暂停。这保证了数据被写入磁盘。通过设置synchronous = OFF，我们指示 SQLite 将数据简单地交给操作系统进行写入，然后继续。如果计算机在数据写入盘片之前发生灾难性崩溃（或电源故障），则数据库文件可能会损坏：
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
12.41 导入 864913 条记录 秒
现在改进幅度较小，但每秒插入次数高达 69,600 次。
PRAGMA journal_mode = MEMORY
考虑通过评估PRAGMA journal_mode = MEMORY 将回滚日志存储在内存中。您的事务会更快，但如果您在事务期间断电或程序崩溃，您的数据库可能会因事务部分完成而处于损坏状态：
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
13.50 导入 864913 条记录 秒
比之前的优化慢一点，每秒 64,000 次插入。
PRAGMA 同步 = 关闭 和 PRAGMA journal_mode = MEMORY
让我们结合前面的两个优化。这有点风险（在崩溃的情况下），但我们只是在导入数据（不是经营银行）：
/* Open the database and create the schema */
sqlite3_open(DATABASE, &db);
sqlite3_exec(db, TABLE, NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
12.00 导入 864913 条记录 秒
太棒了！我们能够进行 每秒 72,000 次插入。
使用内存数据库
只是为了好玩，让我们在之前的所有优化的基础上重新定义数据库文件名，以便我们完全在 RAM 中工作：
#define DATABASE ":memory:"
10.94 导入 864913 条记录 秒
将我们的数据库存储在 RAM 中并不是很实用，但令人印象深刻的是，我们每秒可以执行 79,000 次插入。
重构 C 代码
虽然不是专门的 SQLite 改进，但我不喜欢 while 循环中额外的 char* 赋值操作。让我们快速重构代码，将strtok() 的输出直接传递给sqlite3_bind_text()，并让编译器为我们加快速度：
pFile = fopen (INPUTDATA,"r");
while (!feof(pFile)) {
fgets (sInputBuf, BUFFER_SIZE, pFile);
sqlite3_bind_text(stmt, 1, strtok (sInputBuf, "\t"), -1, SQLITE_TRANSIENT); /* Get Route */
sqlite3_bind_text(stmt, 2, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Branch */
sqlite3_bind_text(stmt, 3, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Version */
sqlite3_bind_text(stmt, 4, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Stop Number */
sqlite3_bind_text(stmt, 5, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Vehicle */
sqlite3_bind_text(stmt, 6, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Date */
sqlite3_bind_text(stmt, 7, strtok (NULL, "\t"), -1, SQLITE_TRANSIENT); /* Get Time */
sqlite3_step(stmt); /* Execute the SQL Statement */
sqlite3_clear_bindings(stmt); /* Clear bindings */
sqlite3_reset(stmt); /* Reset VDBE */
n++;
}
fclose (pFile);
注意：我们又回到了使用真实的数据库文件。内存数据库速度很快，但不一定实用
在 8.94 中导入了 864913 条记录 秒
对参数绑定中使用的字符串处理代码进行轻微重构后，我们可以每秒执行 96,700 次插入。我认为可以肯定地说这是 非常快。当我们开始调整其他变量（即页面大小、索引创建等）时，这将成为我们的基准。
总结（到目前为止）
我希望你还在我身边！ 我们开始走这条路的原因是，SQLite 的批量插入性能变化如此之大，而且需要进行哪些更改并不总是很明显加快我们的操作。使用相同的编译器（和编译器选项）、相同版本的 SQLite 和相同的数据，我们优化了我们的代码和 SQLite 的使用，以 从每秒 85 次插入的最坏情况增加到超过 96,000 次插入每秒！
创建索引然后插入与插入然后创建索引
在我们开始测量SELECT 的性能之前，我们知道我们将创建索引。下面的答案之一建议在进行批量插入时，在插入数据后创建索引更快（而不是先创建索引然后插入数据）。让我们试试吧：
创建索引然后插入数据
sqlite3_exec(db, "CREATE INDEX 'TTC_Stop_Index' ON 'TTC' ('Stop')", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
...
18.13 导入 864913 条记录 秒
插入数据然后创建索引
...
sqlite3_exec(db, "END TRANSACTION", NULL, NULL, &sErrMsg);
sqlite3_exec(db, "CREATE INDEX 'TTC_Stop_Index' ON 'TTC' ('Stop')", NULL, NULL, &sErrMsg);
13.66 导入 864913 条记录 秒
正如预期的那样，如果为一列建立索引，批量插入的速度会变慢，但如果在插入数据后创建索引，它确实会有所不同。我们的无索引基线是每秒 96,000 次插入。 先创建索引然后插入数据，我们每秒可以进行 47,700 次插入，而先插入数据然后创建索引，我们每秒可以进行 63,300 次插入。
我很乐意接受其他方案的建议来尝试...并且很快会为 SELECT 查询编译类似的数据。
【问题讨论】：
-
好点！在我们的例子中，我们正在处理从 XML 和 CSV 文本文件读取到 20 万条记录中的大约 150 万个键/值对。与运行诸如 SO 之类的网站的数据库相比较小 - 但足够大以至于调整 SQLite 性能变得很重要。
-
“我们有大量的配置数据存储在 XML 文件中，这些数据在应用程序初始化时被解析并加载到 SQLite 数据库中以供进一步处理。”为什么不首先将所有内容都保存在 sqlite 数据库中，而不是存储在 XML 中，然后在初始化时加载所有内容？
-
你试过不打电话给
sqlite3_clear_bindings(stmt);吗？每次都设置绑定就足够了： 在第一次调用 sqlite3_step() 之前或在 sqlite3_reset() 之后立即调用 sqlite3_bind() 接口之一以将值附加到参数。对 sqlite3_bind() 的每次调用都会覆盖对同一参数的先前绑定（请参阅：sqlite.org/cintro.html）。 docs for that function 中没有任何内容说您必须调用它。 -
您是否进行了重复测量？避免 7 个本地指针的 4s “胜利”很奇怪，即使假设优化器很混乱。
-
不要使用
feof()来控制输入循环的终止。使用fgets()返回的结果。 stackoverflow.com/a/15485689/827263
标签： c performance sqlite optimization