c++ 11 是如何简化你的数据库访问接口的
之前写过一篇文章专门分析了 c++ 模板编译过程中报的一个错误：《fatal error C1045: 编译器限制 : 链接规范嵌套太深 》，其中涉及到了 qtl —— 一个使用 c++ 11 构建的数据库访问库，当时限于篇幅，没有深入研究它是如何借助 c++ 11 来简化数据库访问接口的，本文现在就来探讨一下这方面的内容。
没有 c++ 11 之前，苦逼的程序员对于 sql 操作的输入输出，只好一行行敲代码，例如在调用数据库接口前设置绑定参数；在调用成功后，循环遍历查询的记录。很多时候数据库表对应在程序中就是一个结构体，程序员需要花费大量的精力将数据库表字段对应到结构体成员上、或反之，完全没有体现出来程序员应有的价值。而 qtl 这种 c++ 11 库的出现，可以极大的简化上面的程序编写，下面还是用之前文章中提到的例子作为演示，让大家感受一下：
插入单条数据
1 uint64_t test_insert_single(qtl::sqlite::database &db) 2 { 3 time_t now = time(0); 4 int tmp = rand() % 1000; 5 uint64_t id = db.insert_direct("insert into popbox_msg(msgid, msgtype, appname, uid, status, count, msgbody, stamp) values(?, ?, ?, ?, ?, ?, ?, ?)", 6 std::to_string(tmp), 108, "GDraw", "1923374929399", 1, 0, "this is msgbody", now); 7 8 printf("insert record with msgid %d return %d\n", tmp, (int)id); 9 return id; 10 }
插入操作需要输入数据，将数据编入 sql 是一种思路，但更好的方法是使用占位符 (?) 和数据绑定 (binding) 来防止 sql 注入问题，而这会给接口带来不定数量的输入参数，幸好 c++ 11 的可变模板参数特性允许用户提供不限数量与类型的输入数据，是不是很方便？下面是 qtl 提供的插入单条数据接口：
1 uint64_t qtl::base_database<T, Command>::insert<Params>(const std::string & query_text, const Params & params); 2 uint64_t qtl::base_database<T, Command>::insert<Params>(const char * query_text, const Params & params); 3 uint64_t qtl::base_database<T, Command>::insert<Params>(const char * query_text, size_t text_length, const Params & params); 4 5 uint64_t qtl::base_database<T, Command>::insert_direct<...Params>(const std::string & query_text, const Params & ...params); 6 uint64_t qtl::base_database<T, Command>::insert_direct<...Params>(const char * query_text, const Params & ...params); 7 uint64_t qtl::base_database<T, Command>::insert_direct<...Params>(const char * query_text, size_t text_length, const Params & ...params);
其中主要分两组：insert 与 insert_direct，前者只提供一个输入绑定参数，后者可以提供多个。而且这些接口会很贴心的将新插入记录的 rowid 返回，方便后续操作这条记录。
更新单条数据
1 void test_update_single(qtl::sqlite::database &db, uint64_t rowid) 2 { 3 time_t now = time(0); 4 uint64_t affected = 0; 5 db.execute_direct("update popbox_msg set status=?, count=?, stamp=? where rowid=?", &affected, 0, 3, now, (int)rowid); 6 printf("update record with rowid %d affected %d records\n", (int)rowid, (int)affected); 7 }
更新操作和插入操作类似，输入数据是必不可少的，但它有时也需要更新符合条件的记录，而这会带来另一坨不定数量的输入参数，不过好在二者都是输入参数，可以合二为一使用一个维度的可变模板参数，依次将更新参数与条件参数罗列在 qtl 接口提供的参数列表中即可：
1 void qtl::base_database<T, Command>::execute<Params>(const std::string & query_text, const Params & params, uint64_t * affected = NULL); 2 void qtl::base_database<T, Command>::execute<Params>(const char * query_text, const Params & params, uint64_t * affected = NULL); 3 void qtl::base_database<T, Command>::execute<Params>(const char * query_text, size_t text_length, const Params & params, uint64_t * affected = NULL); 4 5 void qtl::base_database<T, Command>::execute_direct<...Params>(const std::string & query_text, uint64_t * affected, const Params & ...params); 6 void qtl::base_database<T, Command>::execute_direct<...Params>(const char * query_text, uint64_t * affected, const Params & ...params); 7 void qtl::base_database<T, Command>::execute_direct<...Params>(const char * query_text, size_t text_length, uint64_t * affected, const Params & ...params);
主要也是两组接口：execute 与 execute_direct，前者只提供一个输入绑定参数，后者可以提供多个。由于是插入多条数据，这里没有办法返回某一条记录的 rowid，代之以的是更新的行数 affected，如果这个参数为空，则不返回。
插入多条数据
void test_insert_multi(qtl::sqlite::database &db) { uint64_t affected = 0; int tmp[3] = { 0 }; for (int i=0; i<3; ++i) tmp[i] = rand() % 1000; auto stmt = db.open_command("insert into popbox_msg(msgid, msgtype, appname, uid, status, count, msgbody, stamp) " "values(?, 108, 'GDraw', '1923374929399', 1, 0, 'this is msgbody', strftime('%s','now'))"); qtl::execute(stmt, &affected, std::to_string(tmp[0]), std::to_string(tmp[1]), std::to_string(tmp[2])); printf("insert %d record\n", (int)affected); }
插入多条数据时，可变模板参数列表的每一个参数表示一个输入绑定参数、针对一条新记录，这样一来就不太够用了。例如上面这个例子中，相当于插入了三条不同的 popbox_msg 记录，每个输入参数对应记录的 msgid 字段，如果一条记录有多个字段需要输入就不适用了，那种场景下就需要写个循环多次调用插入单条数据的操作了（其实插入多条的接口底层也是递归为插入单条来执行的，所以这样做性能没有太大损失）。
更新多条数据
1 void test_update_multi(qtl::sqlite::database &db) 2 { 3 uint64_t affected = 0; 4 int id[3] = { 19, 20, 21 }; 5 6 auto stmt = db.open_command("update popbox_msg set status=0, count=2, stamp=strftime('%s','now') where rowid=? "); 7 qtl::execute(stmt, &affected, id[0], id[1], id[2]); 8 printf("update %d record\n", (int)affected); 9 }
其实和插入多条数据非常相似，每条记录只能允许一个输入绑定参数。
删除数据
1 void test_delete(qtl::sqlite::database &db) 2 { 3 uint64_t affected = 0; 4 db.execute_direct("delete from popbox_msg where msgtype=? and appname=? and uid=?", &affected, 108, "GDraw", "1923374929399"); 5 printf("delete record affected %d rows\n", (int)affected); 6 }
删除数据时由于只需要提供删除条件的输入绑定参数，而实际结果可能删除一条、也可能删除多条，所以不在数量上做区分。这里使用的是和更新数据一样的接口：execute 和 execute_direct，同样的，前者只能允许一个输入绑定参数，适合较简单的 sql 语句；后者可以允许多个输入绑定参数，适合较复杂的 sql。最后，删除的行数由 affected 参数返回给调用者。
查询单条数据
1 void test_query_single(qtl::sqlite::database &db, uint64_t rowid) 2 { 3 std::string msg; 4 db.query_first("select msgbody from popbox_msg where rowid=?", (int)rowid, msg); 5 printf("row %d: %s\n", (int)rowid, msg.c_str()); 6 }
查询单条数据时可以直接将查询到的数据以输出参数方式回传，而查询条件往往又需要输入绑定参数，那 qtl 是如何区分可变模板参数列表中哪些是入参、哪些是出参呢？答案是区分不了。因此在接口设计上，qtl 的查询单条数据接口最多允许一个入参：
1 void qtl::base_database<T, Command>::query_first<Values>(const std::string & query_text, Values && values); 2 void qtl::base_database<T, Command>::query_first<Values>(const char * query_text, Values && values); 3 void qtl::base_database<T, Command>::query_first<Values>(const char * query_text, size_t text_length, Values && values); 4 5 void qtl::base_database<T, Command>::query_first<Params, Values>(const std::string & query_text, const Params & params, Values && values); 6 void qtl::base_database<T, Command>::query_first<Params, Values>(const char * query_text, const Params & params, Values && values); 7 void qtl::base_database<T, Command>::query_first<Params, Values>(const char * query_text, size_t text_length, const Params & params, Values && values);
主要分为两组：只带一个出参的 query_first；带一个出参和一个入参的 query_first。这个接口只针对特别简单的 sql 语句，如果想要返回一条记录的多个字段时，就必需使用另一组接口：query_first_direct
1 void qtl::base_database<T, Command>::query_first_direct<...Values>(const std::string & query_text, Values & ...values); 2 void qtl::base_database<T, Command>::query_first_direct<...Values>(const char * query_text, Values & ...values); 3 void qtl::base_database<T, Command>::query_first_direct<...Values>(const char * query_text, size_t text_length, Values & ...values);
遗憾的是这个接口虽然能提供多个出参，却无法提供任何入参，所有入参必需事先构建在 sql 语句中，这十分不优雅，但没有办法。下面是使用的例子：
1 void test_query_single_ex(qtl::sqlite::database &db, uint64_t rowid) 2 { 3 time_t stamp = 0; 4 int status = 0, count = 0; 5 6 std::ostringstream oss; 7 oss << "select status, count, stamp from popbox_msg where rowid=" << rowid; 8 db.query_first_direct(oss.str (), status, count, stamp); 9 printf("row %d: status %d, count %d, stamp %d\n", (int)rowid, status, count, (int)stamp); 10 }
从这个实际例子看，以后 c++ 可变模板参数列表可能需要支持两个参数列，一列是输入参数，一列是输出参数了。但是转念一想，这样好像也不对，因为出参与入参在调用点并无任何区别，编译器如何知道哪个是出参哪个是入参呢？所以这个问题可能还真是无解了。
查询多条数据
1 void test_query_multi(qtl::sqlite::database &db) 2 { 3 int cnt = 0; 4 db.query("select status, count, stamp from popbox_msg where appname=?", "GDraw", 5 [&cnt](int status, int count, time_t stamp){ 6 printf("%d, %d, %d\n", status, count, (int)stamp); 7 cnt++; 8 }); 9 10 printf("query %d records\n", cnt); 11 }
因为可能返回多条数据，这里使用回调函数（一般为 lambda 表达式）来接收读取的记录。回调函数参数列表必需与 select 选择的数据库表列相匹配。
1 void qtl::base_database<T, Command>::query<ValueProc>(const std::string & query_text, ValueProc && proc); 2 void qtl::base_database<T, Command>::query<ValueProc>(const char * query_text, ValueProc && proc); 3 void qtl::base_database<T, Command>::query<ValueProc>(const char * query_text, size_t text_length, ValueProc && proc); 4 5 void qtl::base_database<T, Command>::query<Params, ValueProc>(const std::string & query_text, const Params & params, ValueProc && proc); 6 void qtl::base_database<T, Command>::query<Params, ValueProc>(const char * query_text, const Params & params, ValueProc && proc); 7 void qtl::base_database<T, Command>::query<Params, ValueProc>(const char * query_text, size_t text_length, const Params & params, ValueProc && proc);
query 接口分为两组：一组只提供一个回调函数用于接收数据；另一组还提供一个额外的输入绑定参数。对于复杂的 sql 查询，这个还是不太够用，我不清楚为什么不能在 ValueProc proc 参数后面加一个可变模板参数列表，这样就不可以接收多个输入绑定参数了么？此处存疑。不过这个好歹比 query_first 要么只返回一个字段、要么返回多个字段但不接收输入参数要强一点。除了优点，这个接口也有一个不惹人注意的 bug，请看下面这段代码：
1 void test_query_multi(qtl::sqlite::database &db) 2 { 3 int cnt = 0; 4 db.query("select msgid, msgtype, appname, uid, status, count, msgbody, stamp from popbox_msg where appname=?", "GDraw", 5 [&cnt](std::string const& msgid, int msgtype, std::string const& appname, std::string const& uid, int status, int count, std::string const& msgbody, time_t stamp){ 6 printf("%s, %d, %s, %s, %d, %d, %s, %d\n", msgid.c_str(), msgtype, appname.c_str(), uid.c_str(), status, count, msgbody.c_str(), (int)stamp); 7 cnt++; 8 }); 9 10 printf("query %d records\n", cnt); 11 }
我增加了从数据库表中选取的字段，并相应的增加了 lambda 表达式的参数列表，当数量达到一个阈值时（亲测为8），VS2013 编译器将报错退出：
e:\code\qtl\include\qtl\apply_tuple.h(17): fatal error C1045: 编译器限制 : 链接规范嵌套太深
具体分析请参考我的另一篇文章：《fatal error C1045: 编译器限制 : 链接规范嵌套太深》。这里我着重想说明的是，使用这种方式传递的字段在某些编译器上是有上限的，所以可移植性不太好。相信聪明的你已经猜到了，由于 query_first_direct 使用了和 query 相同的底层机制，query_first_direct 在 VS2013 上也存在相同的问题。幸好 qtl 还有另外一种方法，可以解决上面的问题，这就是结构体成员绑定：
1 class popbox_msg_t 2 { 3 public: 4 void dump(char const* prompt) const; 5 6 int msgtype = 0; // 108 or 402 7 int status = 0; // send to server result, (1:ok; 0:fail) 8 int count = 0; // retry times, if exceed POPBOX_MSG_RETRY_MAX, stop retry 9 time_t stamp = 0; // receive time 10 std::string msgid; 11 std::string msgbody; 12 std::string appname; 13 std::string uid; 14 }; 15 16 17 void popbox_msg_t::dump(char const* prompt) const 18 { 19 tm* t = localtime(&stamp); 20 printf("%s : %s,%s,%s,%d,%d,%d, %04d-%02d-%02d %02d:%02d:%02d, %s\n", 21 prompt, 22 appname.c_str(), 23 uid.c_str(), 24 msgid.c_str(), 25 msgtype, 26 status, 27 count, 28 t->tm_year + 1900, 29 t->tm_mon + 1, 30 t->tm_mday + 1, 31 t->tm_hour, 32 t->tm_min, 33 t->tm_sec, 34 msgbody.c_str()); 35 } 36 37 namespace qtl 38 { 39 template<> 40 inline void bind_record<qtl::sqlite::statement, popbox_msg_t>(qtl::sqlite::statement& command, popbox_msg_t&& v) 41 { 42 int n = 0; 43 qtl::bind_field(command, n++, v.msgid); 44 qtl::bind_field(command, n++, v.msgtype); 45 qtl::bind_field(command, n++, v.appname); 46 qtl::bind_field(command, n++, v.uid); 47 qtl::bind_field(command, n++, v.status); 48 qtl::bind_field(command, n++, v.count); 49 qtl::bind_field(command, n++, v.msgbody); 50 qtl::bind_field(command, n++, v.stamp); 51 } 52 } 53 54 void test_query_multi_ex(qtl::sqlite::database &db) 55 { 56 int cnt = 0; 57 db.query("select msgid, msgtype, appname, uid, status, count, msgbody, stamp from popbox_msg where appname=?", "GDraw", 58 [&cnt](popbox_msg_t const& pm){ 59 pm.dump("msg"); 60 cnt++; 61 }); 62 63 printf("query %d records\n", cnt); 64 }
同样是 query 接口，同样是 lambda 表达式作为回调函数，不同的是，我提前声明了一个结构体 popbox_msg_t，并提供了 qtl::bind_record 模板函数的一个特化、来将数据库表的列与结构体成员二者关联起来，这样我的 lambda 表达式只要接收结构体就够了，qtl 在底层会自动根据 bind_record 将读取的数据初始化到结构体中供我们使用。因为这种方式避免了罗列各个输出参数，所以可以很好的避免上述问题。 另外关于 bind_record 补充一点，最新版本的 qtl 可以在 bind_record 模板特化中使用一个 bind_fields 来指定所有成员的对应关系了（我使用的旧版没有这个接口），类似于这样：
qtl::bind_fields(command, v.msgid, v.msgtype, v.appname, v.uid, v.status, v.count, v.msgbody, v.stamp);
是不是更简单了呢？有了结构体绑定，还可以玩出许多花样，例如直接用结构体的成员函数来代替 lambda 表达式：
1 class popbox_msg_t 2 { 3 public: 4 void dump(char const* prompt) const; 5 void print(); 6 7 int msgtype = 0; // 108 or 402 8 int status = 0; // send to server result, (1:ok; 0:fail) 9 int count = 0; // retry times, if exceed POPBOX_MSG_RETRY_MAX, stop retry 10 time_t stamp = 0; // receive time 11 std::string msgid; 12 std::string msgbody; 13 std::string appname; 14 std::string uid; 15 }; 16 17 18 void popbox_msg_t::dump(char const* prompt) const 19 { 20 tm* t = localtime(&stamp); 21 printf("%s : %s,%s,%s,%d,%d,%d, %04d-%02d-%02d %02d:%02d:%02d, %s\n", 22 prompt, 23 appname.c_str(), 24 uid.c_str(), 25 msgid.c_str(), 26 msgtype, 27 status, 28 count, 29 t->tm_year + 1900, 30 t->tm_mon + 1, 31 t->tm_mday + 1, 32 t->tm_hour, 33 t->tm_min, 34 t->tm_sec, 35 msgbody.c_str()); 36 } 37 38 void popbox_msg_t::print () 39 { 40 dump("msg"); 41 } 42 43 namespace qtl 44 { 45 template<> 46 inline void bind_record<qtl::sqlite::statement, popbox_msg_t>(qtl::sqlite::statement& command, popbox_msg_t&& v) 47 { 48 int n = 0; 49 qtl::bind_field(command, n++, v.msgid); 50 qtl::bind_field(command, n++, v.msgtype); 51 qtl::bind_field(command, n++, v.appname); 52 qtl::bind_field(command, n++, v.uid); 53 qtl::bind_field(command, n++, v.status); 54 qtl::bind_field(command, n++, v.count); 55 qtl::bind_field(command, n++, v.msgbody); 56 qtl::bind_field(command, n++, v.stamp); 57 } 58 } 59 60 void test_query_multi_ex(qtl::sqlite::database &db) 61 { 62 int cnt = 0; 63 db.query("select msgid, msgtype, appname, uid, status, count, msgbody, stamp from popbox_msg where appname=?", "GDraw", 64 &popbox_msg_t::print); 65 66 printf("query %d records\n", cnt); 67 }
代码高亮的部分就是两个版本的差异，这里使用了 popbox_msg_t 的一个成员函数 print 来充当 lambda 表达式的作用，这样做可以将代码集中到结构体中进行维护。不过缺点也是明显的，就是不能自由的选取外部输入参数了，例如对遍历记录数的统计，在新版本中就没办法做到了。除了上面的方式，还有一种新花样：
1 void test_query_multi_ul(qtl::sqlite::database &db) 2 { 3 int cnt = 0; 4 for(auto& pm : db.result<popbox_msg_t>("select msgid, msgtype, appname, uid, status, count, msgbody, stamp from popbox_msg where appname=?", "GDraw")) 5 { 6 pm.dump("msg"); 7 cnt++; 8 } 9 10 printf("query %d records\n", cnt); 11 }
这种方式已经脱离了 query 接口，使用的是 result 接口，虽然壳变了，但是底层机制和 query 是一致的，都是通过 bind_record 将查询到的数据填充到结构体中，下面是 result 的接口定义：
1 query_result<Command,Record> qtl::base_database<T, Command>::result<Record>(const std::string & query_text); 2 query_result<Command,Record> qtl::base_database<T, Command>::result<Record>(const char * query_text); 3 query_result<Command,Record> qtl::base_database<T, Command>::result<Record>(const char * query_text, size_t text_length); 4 5 query_result<Command,Record> qtl::base_database<T, Command>::result<Record, Params>(const std::string & query_text, const Params & params); 6 query_result<Command,Record> qtl::base_database<T, Command>::result<Record, Params>(const char * query_text, const Params & params); 7 query_result<Command,Record> qtl::base_database<T, Command>::result<Record, Params>(const char * query_text, size_t text_length, const Params & params);
主要分为两组：一组只接收 sql 输入；另一组还可以接收一个额外的输入绑定参数。除了返回类型，与 query 接口几乎一模一样，可以理解成是将 query 的回调函数转化成了 result 返回的 query_result 集合。像上面例子那样写代码，几乎找到了之前 c 语言操作数据库的感觉，特别是不用把需要的外部变量在 lambda 表达式里一一捕获了，在循环里就可以直接用它们，就是一个字：爽！
如果有多个操作都从一个表中查询，可能只是选取的字段不同，那么这种情况下一个结构体就不够了，必需为每个查询定义一个独一无二的结构体并提供相应的 bind_record 函数（即使这些结构体拥有近似的成员）。这样简直是重复造轮子，难道不能定义一个包含所有字段的“超集”结构体，让它来包打所有这个表的查询吗？有的人可能会想，你把 sql 语句改造一下，每次选取所有字段、多余的不要用就好了呀！但是这样肯定不是一个优雅的解决方案，qtl 最新版本中包含了关于这方面的解决方案，那就是自定义绑定，请看下面这个例子：
1 void my_bind(popbox_msg_t&& v, qtl::sqlite::statement& command) 2 { 3 int n = 0; 4 qtl::bind_field(command, n++, v.status); 5 qtl::bind_field(command, n++, v.count); 6 qtl::bind_field(command, n++, v.stamp); 7 } 8 9 void test_query_multi_custom(qtl::sqlite::database &db) 10 { 11 int cnt = 0; 12 db.query_explicit("select status, count, stamp from popbox_msg where appname=?", "GDraw", 13 qtl::custom_bind(popbox_msg_t(), my_bind), 14 [&cnt](popbox_msg_t const& pm){ 15 printf("msg: %d, %d, %d\n", pm.status, pm.count, pm.stamp); 16 cnt++; 17 }); 18 19 printf("query %d records\n", cnt); 20 }
这个例子可以和前面的 popbox_msg_t 定义及其默认 bind_record 函数放在一起，由于这里我们使用 query_explicit 接口明确指定了使用的绑定函数是 my_bind，之前定义的默认绑定函数就不再起作用啦。这个查询只要表中的三个字段，因此在查询结束后也只有三个字段可用。我在下载了最新版本的 qtl 并尝试编译这代码时，编译器报错说没有找到 custom_bind 的定义，我全文搜索了一下也确实没有，但是这个例子可是我照着官网写的啊，难不成作者后来修改了代码忘记同步文档了吗？不得而知。
最后，对于数据库应用来说，视图 (view) 和过程 (procedure) 也是数据库经常接触到的概念，有的数据库过程会调用多个 select 语句查询结果，此时我们的接口又该怎么接收这些数据呢？答案就是 query_multi 和 query_multi_with_params，它们允许用户提供多个回调函数，一般就是写多个 lambda 表达式啦，这样就可以按过程中调用 select 语句的顺序来接收对应的查询结果了：
1 void qtl::base_database<T, Command>::query_multi<...ValueProc>(const std::string & query_text, ValueProc && ...proc); 2 void qtl::base_database<T, Command>::query_multi<...ValueProc>(const char * query_text, ValueProc && ...proc); 3 void qtl::base_database<T, Command>::query_multi<...ValueProc>(const char * query_text, size_t text_length, ValueProc && ...proc); 4 5 void qtl::base_database<T, Command>::query_multi_with_params<Params, ...ValueProc>(const std::string & query_text, const Params & params, ValueProc && ...proc); 6 void qtl::base_database<T, Command>::query_multi_with_params<Params, ...ValueProc>(const char * query_text, const Params & params, ValueProc && ...proc); 7 void qtl::base_database<T, Command>::query_multi_with_params<Params, ...ValueProc>(const char * query_text, size_t text_length, const Params & params, ValueProc && ...proc);
query_multi_with_params 顾名思义，就是在 query_multi 的基础上，允许一个额外的输入绑定参数。当然这个功能比较偏门，我没有专门写 demo 去验证。
下载
本文所有测试用例都是基于获取并打开 qtl::sqlite::database 对象的基础，那么这个对象又是如何打开的呢，请看下面框架：
1 int main(int argc, char* argv[]) 2 { 3 int ret = 0; 4 srand(time(0)); 5 uint64_t rowid = 0; 6 qtl::sqlite::database db(SQLITE_TIMEOUT); 7 8 try 9 { 10 // copy of gcm.db, and create following table: 11 // create table popmsg (msgid text not null, msgtype integer not null, cid text not null, uid text not null, 12 // status integer not null, count integer not null, msgbody text not null, stamp timestamp not null, 13 // primary key (msgid, msgtype, cid, uid)); 14 db.open("../data/gcm.db", NULL); 15 printf("open db OK\n"); 16 17 #if 0 18 rowid = test_insert_single(db); 19 #endif 20 21 #if 0 22 test_update_single(db, rowid); 23 #endif 24 25 #if 0 26 test_insert_multi(db); 27 #endif 28 29 #if 0 30 test_update_multi(db); 31 #endif 32 33 #if 0 34 test_delete(db); 35 #endif 36 37 #if 0 38 test_query_single(db, rowid); 39 #endif 40 41 #if 0 42 test_query_single_ex(db, rowid); 43 #endif 44 45 #if 0 46 test_query_multi(db); 47 #endif 48 49 #if 0 50 test_query_multi_ex(db); 51 #endif 52 53 #if 0 54 test_query_multi_ul(db); 55 #endif 56 57 //test_query_multi_custom(db); 58 59 db.close(); 60 } 61 catch (qtl::sqlite::error &e) 62 { 63 printf("manipute db error %d: %s\n", e.code(), e.what()); 64 db.close(); 65 return -1; 66 } 67 68 return 0; 69 }
可以看到数据库的打开、关闭过程。因为 qtl 检测到底层数据库错误时，是通过抛出异常的方式来向上层报告的，所以所有用例都包含在 try_catch 结构中。可以通过编译开关来打开各个用例，多个用例之间可以组合起来使用，例如同时打开 test_insert_single 和 test_query_single 两个用例。所有相关的内容，包括 qtl、sqlite 头文件；sqlite lib 与 dll 和 so；sqlite 样例数据 db 文件；甚至编译好的可执行文件（Win10 x64 与 Linux x64），我都打包上传到博客园了，可以点击 这里下载。
qtl 库最新版本不包含在里面 ，可以从这里获取：https://github.com/goodpaperman/qtl
结语
本文并不是 qtl 的使用指南，qtl 的许多内容（事务、语句对象、blob 类型、异步IO、indicator）都没有介绍。这里只是使用 qtl 这个典型的 c++11 库、以及数据库的“增删改查”四大操作、来说明新技术是如何”颠覆”用户调用接口的，以及在一些特定场景下（例如 query_first 既要不定输入参数，也要不定输出参数）， c++ 新特性是否有可能去满足这种需求。从这里也能看出，c++ 的新需求新特性并不是凭空衍生的，而是从类似 qtl 这种模板库的实际需要产生的（如何写出用户调用更方便的接口），如果我们离开这些场景去学 c++ 新特性，会感到知识点纷繁复杂，而例子又全然不贴切，完全感觉不到新特性解决的痛点。当然 qtl 也不是尽善尽美，例如在使用回调函数处理输出数据的情况下，能不能给输入数据来个“不限量”参数列表？qtl 没有这样做是 c++ 不支持，还是 qtl 懒没有做到这一步，这就暂时不得而知了。