由于sqlite对多进程操作支持效果不太理想,在项目中,为了避免频繁读写 文件数据库带来的性能损耗,我们可以采用操作sqlite内存数据库,并将内存数据库定时同步到文件数据库中的方法。

实现思路如下:

1、创建文件数据库;

2、创建内存数据库(文件数据库、内存数据库的内幕表结构需要一致);

3、在内存数据库中attach文件数据库,这样可以保证文件数据库中的内容在内存数据库中可见;

4、对于insert、select操作,在内存数据库中完成,对于delete、update操作,需要同时访问内存、文件数据库;

5、定时将内存数据库中的内容flush到文件数据库。

通过sqlite的cAPI实现代码如下:

  1. const char* file_database_path = "/home/tom/test/database/filedb"; //文件数据库存放路径
  2. const char* sql_create_data = "CREATE TABLE testinfo (id TEXT PRIMARY KEY, message TEXT, offset INTEGER, timestamp INTEGER);";
  3. const char* sql_insert_data = "INSERT OR REPLACE INTO MAIN.testinfo VALUES('%s', '%s', %d, %d);";
  4. const char* sql_delete_data = "DELETE FROM MAIN.testinfo WHERE id = '%s'; DELETE FROM filedb.testinfo WHERE id = '%s';"; //删除数据库,需同时删除内存、文件数据库中的内容
  5. const char* sql_update_data = "UPDATE MAIN.testinfo SET message = '%s', offset = %d, timestamp = %d where id = '%s'; UPDATE filedb.testinfo SET message = '%s', offset = %d, timestamp = %d where id = '%s';";//更新数据库,需同时更新内存、文件数据库中的内容
  6. const char* sql_search_data = "SELECT * FROM MAIN.testinfo WHERE timestamp BETWEEN %d AND %d union SELECT * FROM testdb.testinfo WHERE timestamp BETWEEN %d AND %d;"; //查找数据库,将内存、文件数据库中查找出的内容合并
  7. const char* sql_transfer_data = "INSERT OR REPLACE INTO filedb.testinfo SELECT * FROM testinfo;";   //将内存数据库中的信息同步到文件数据库中
  8. const char* sql_delete_memory_table = "DELETE FROM testinfo;";  //内存数据库中的内容同步结束后,清空
  9. int InsertRecord(DATA_TYPE type, const char* id, const char* message, int offset, int timestamp)
  10. {
  11. int      rc              =  0;
  12. char*    errMsg          =  NULL;
  13. char     sqlcmd[512]     =  {0};
  14. time_t   insertTimestamp =  0;
  15. snprintf(sqlcmd, sizeof(sqlcmd), sql_insert_data, id, message, offset, timestamp);
  16. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  17. if (SQLITE_OK != rc) {
  18. fprintf(stderr, "cat't add record to memory database %s, sqlcmd=%s, err:%s\n", map_data_table[type].data_table_name, sqlcmd, errMsg);
  19. return -1;
  20. }
  21. return 0;
  22. }
  23. int UpdateRecord(DATA_TYPE type, const char* id, const char* message, int offset, int timestamp)
  24. {
  25. int      rc              = 0;
  26. char*    errMsg          = NULL;
  27. char     sqlCmd[512]  = {0};
  28. snprintf(sqlCmd, sizeof(sqlCmd), sql_update_data, message, offset, timestamp, id, message, offset, timestamp, id);
  29. rc = sqlite3_exec(memdb, sqlCmd, NULL, NULL, &errMsg);
  30. if (SQLITE_OK != rc) {
  31. fprintf(stderr, "cat't update record %s:%s\n", map_data_table[type].data_table_name, errMsg);
  32. return -1;
  33. }
  34. return 0;
  35. }
  36. int DeleteRecord(DATA_TYPE type, const char* id)
  37. {
  38. int      rc              =  0;
  39. char*    errMsg          =  NULL;
  40. char     sqlcmd[512]     =  {0};
  41. snprintf(sqlcmd, sizeof(sqlcmd), sql_delete_data, id,  id);
  42. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  43. if (SQLITE_OK != rc) {
  44. fprintf(stderr, "cat't delete record %s:%s\n", map_data_table[type].data_table_name, errMsg);
  45. return -1;
  46. }
  47. return 0;
  48. }
  49. int QueryMessage(DATA_TYPE type, int startTime, int endTime)
  50. {
  51. int      rc              = 0;
  52. char     *errMsg         = NULL;
  53. sqlite3  *filedb         = NULL;
  54. char**   pRecord         = NULL;
  55. int      row             = 0;
  56. int      column          = 0;
  57. char     sqlcmd[512]     = {0};
  58. if (type > VEP_NELEMS(map_data_table) || type < 0) {
  59. return -1;
  60. }
  61. rc = sqlite3_open(file_database_path, &filedb);
  62. if (SQLITE_OK != rc) {
  63. fprintf(stderr, "cat't open database:%s\n", sqlite3_errmsg(filedb));
  64. sqlite3_close(filedb);
  65. return -1;
  66. }
  67. snprintf(sqlcmd, sizeof(sqlcmd), sql_search_data,  startTime, endTime,  startTime, endTime);
  68. rc = sqlite3_get_table(filedb, sqlcmd, &pRecord, &row, &column, &errMsg);
  69. if (SQLITE_OK != rc) {
  70. fprintf(stderr, "cat't get table from%s:%s\n", map_data_table[type].data_table_name, errMsg);
  71. return -1;
  72. }
  73. int i;
  74. printf("row = %d, column = %d\n", row, column);
  75. for(i = 0; i < 2*column; i++)
  76. {
  77. printf("%s ", pRecord[i]);
  78. }
  79. printf("\n");
  80. return 0;
  81. }
  82. //定时调用此函数将内存数据中的内容同步到文件数据库
  83. int Flush(){
  84. int      i            = 0;
  85. int      rc           = 0;
  86. char*    errMsg       = NULL;
  87. char     sqlcmd[512]  = {0};
  88. snprintf(sqlcmd, sizeof(sqlcmd), sql_transfer_data);
  89. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  90. if (SQLITE_OK != rc) {
  91. fprintf(stderr, "cat't transfer memory database %s to file databasede:%s\n", map_data_table[i].data_table_name, sqlite3_errmsg(memdb));
  92. sqlite3_close(memdb);
  93. return -1;
  94. }
  95. snprintf(sqlcmd, sizeof(sqlcmd), sql_delete_memory_table);
  96. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  97. return 0;
  98. }
  99. //创建文件数据库
  100. int CreateDbOnFile()
  101. {
  102. sqlite3 *db           = NULL;
  103. int      rc           = 0;
  104. char*    errMsg       = NULL;
  105. char     sqlcmd[512]  = {0};
  106. int      i            = 0;
  107. rc = sqlite3_open(file_database_path, &db);
  108. if (SQLITE_OK != rc) {
  109. fprintf(stderr, "cat't open database:%s\n", sqlite3_errmsg(db));
  110. sqlite3_close(db);
  111. return -1;
  112. }
  113. snprintf(sqlcmd, sizeof(sqlcmd), sql_create_data);
  114. rc = sqlite3_exec(db, sqlcmd, NULL, NULL, &errMsg);
  115. if (SQLITE_OK != rc) {
  116. fprintf(stderr, "cat't create file database testinfo:%s\n", errMsg);
  117. sqlite3_close(db);
  118. return -1;
  119. }
  120. sqlite3_close(db);
  121. return 0;
  122. }
  123. //创建内存数据库
  124. int CreateDbOnMemery()
  125. {
  126. int      rc           = 0;
  127. char*    errMsg       = NULL;
  128. char     sqlcmd[512]  = {0};
  129. int      i            = 0;
  130. rc = sqlite3_open(":memory:", &memdb);
  131. if (SQLITE_OK != rc) {
  132. fprintf(stderr, "cat't open database:%s\n", sqlite3_errmsg(memdb));
  133. sqlite3_close(memdb);
  134. return -1;
  135. }
  136. snprintf(sqlcmd, sizeof(sqlcmd), sql_create_data);
  137. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  138. if (SQLITE_OK != rc) {
  139. fprintf(stderr, "cat't create memory database %s\n", errMsg);
  140. sqlite3_close(memdb);
  141. return -1;
  142. }
  143. return 0;
  144. }
  145. //解绑数据库
  146. int DetachDb()
  147. {
  148. int      rc           =  0;
  149. char*    errMsg       =  NULL;
  150. char     sqlcmd[512]  =  {0};
  151. snprintf(sqlcmd, sizeof(sqlcmd), "DETACH '%s'", "filedb");
  152. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  153. if (SQLITE_OK != rc) {
  154. fprintf(stderr, "detach file database failed:%s:%s\n", file_database_path, errMsg);
  155. sqlite3_close(memdb);
  156. return -1;
  157. }
  158. return 0;
  159. }
  160. //将文件数据库作为内存数据库的附加数据库
  161. int AttachDb()
  162. {
  163. int      rc           =  0;
  164. char*    errMsg       =  NULL;
  165. char     sqlcmd[512]  =  {0};
  166. snprintf(sqlcmd, sizeof(sqlcmd), "ATTACH '%s' AS %s", file_database_path, "filedb");
  167. rc = sqlite3_exec(memdb, sqlcmd, NULL, NULL, &errMsg);
  168. if (SQLITE_OK != rc) {
  169. fprintf(stderr, "cat't attach database %s:%s\n", file_database_path, errMsg);
  170. sqlite3_close(memdb);
  171. return -1;
  172. }
  173. return 0;
  174. }
  175. //初始化数据库,分别创建文件数据库、内存数据库并把文件数据库attach到内存数据库上
  176. int InitSqliteDb()
  177. {
  178. int retval = 0;
  179. retval =  CreateDbOnFile();
  180. if (retval != 0) {
  181. return retval;
  182. }
  183. retval =  CreateDbOnMemery();
  184. if (retval != 0) {
  185. return retval;
  186. }
  187. retval =  AttachDb();
  188. if (retval != 0) {
  189. return retval;
  190. }
  191. return 0;
  192. }
05-11 16:54
查看更多