2 * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #include "download-provider-config.h"
23 #include "download-provider-db.h"
24 #include "download-provider-slots.h"
25 #include "download-provider-log.h"
26 #include "download-provider-pthread.h"
29 #define DP_DB_BASIC_GET_QUERY_FORMAT "SELECT %s FROM %s WHERE id = ?"
30 #define DP_DB_BASIC_SET_QUERY_FORMAT "UPDATE %s SET %s = ? WHERE id = ?"
31 #define DP_DB_BASIC_INSERT_QUERY_FORMAT "INSERT INTO %s (id, %s) VALUES (?, ?)"
32 #define DP_DB_BASIC_NOW_DATE_QUERY_FORMAT "UPDATE %s SET %s = DATETIME('now') WHERE id = ?"
35 #define DP_DB_COND_GET_QUERY_FORMAT "SELECT %s FROM %s WHERE id = ? AND %s = ?"
36 #define DP_DB_COND_SET_QUERY_FORMAT "UPDATE %s SET %s = ? WHERE id = ? AND %s = ?"
39 DP_DB_QUERY_TYPE_GET = 10,
40 DP_DB_QUERY_TYPE_SET = 20,
41 DP_DB_QUERY_TYPE_INSERT = 30,
42 DP_DB_QUERY_TYPE_NOW_DATE = 40
45 sqlite3 *g_dp_db_handle = 0;
47 // called when terminating process
51 db_util_close(g_dp_db_handle);
55 // called when launching process or in every API
58 if (g_dp_db_handle == 0) {
59 if (db_util_open(DATABASE_FILE, &g_dp_db_handle,
60 DB_UTIL_REGISTER_HOOK_METHOD) != SQLITE_OK) {
61 TRACE_ERROR("failed db_util_open [%s][%s]", DATABASE_FILE,
62 sqlite3_errmsg(g_dp_db_handle));
66 sqlite3_exec(g_dp_db_handle, "PRAGMA journal_mode=PERSIST;", 0, 0, 0);
67 sqlite3_exec(g_dp_db_handle, "PRAGMA foreign_keys=ON;", 0, 0, 0);
69 return g_dp_db_handle ? 0 : -1;
72 static int __dp_sql_open()
77 static void __dp_finalize(sqlite3_stmt *stmt)
79 if (sqlite3_finalize(stmt) != SQLITE_OK)
80 TRACE_ERROR("failed sqlite3_finalize [%s]",
81 sqlite3_errmsg(g_dp_db_handle));
84 int dp_db_get_count_by_limit_time()
86 int errorcode = SQLITE_OK;
87 sqlite3_stmt *stmt = NULL;
89 if (__dp_sql_open() < 0) {
90 TRACE_ERROR("db_util_open is failed [%s]",
91 sqlite3_errmsg(g_dp_db_handle));
96 sqlite3_prepare_v2(g_dp_db_handle,
97 "SELECT count(id) FROM logging \
98 WHERE createtime < DATETIME('now','-48 hours')",
100 if (errorcode != SQLITE_OK) {
101 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
102 sqlite3_errmsg(g_dp_db_handle));
106 errorcode = sqlite3_step(stmt);
107 if (errorcode == SQLITE_ROW) {
108 int count = sqlite3_column_int(stmt, 0);
116 int dp_db_get_list_by_limit_time(dp_request_slots *requests, int limit)
118 int errorcode = SQLITE_OK;
120 sqlite3_stmt *stmt = NULL;
122 if (__dp_sql_open() < 0) {
123 TRACE_ERROR("db_util_open is failed [%s]",
124 sqlite3_errmsg(g_dp_db_handle));
129 sqlite3_prepare_v2(g_dp_db_handle,
130 "SELECT id, state FROM logging WHERE \
131 createtime < DATETIME('now','-48 hours') \
132 ORDER BY createtime ASC LIMIT ?",
134 if (errorcode != SQLITE_OK) {
135 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
136 sqlite3_errmsg(g_dp_db_handle));
140 if (sqlite3_bind_int(stmt, 1, limit)
142 TRACE_ERROR("sqlite3_bind_int[%s]",
143 sqlite3_errmsg(g_dp_db_handle));
148 while ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW && i < limit) {
149 // allocation & initialization
150 requests[i].request = dp_request_new();
152 requests[i].request->id = sqlite3_column_int(stmt, 0);
154 requests[i].request->state = sqlite3_column_int(stmt, 1);
156 TRACE_INFO("ID : %d", requests[i].request->id);
157 TRACE_INFO("state : %d", requests[i].request->state);
165 int dp_db_crashed_list(dp_request_slots *requests, int limit)
167 int errorcode = SQLITE_OK;
169 int buffer_length = 0;
170 sqlite3_stmt *stmt = NULL;
173 if (__dp_sql_open() < 0) {
174 TRACE_ERROR("db_util_open is failed [%s]",
175 sqlite3_errmsg(g_dp_db_handle));
180 sqlite3_prepare_v2(g_dp_db_handle,
181 "SELECT id, state, packagename FROM logging WHERE \
182 (state = ? OR state = ? OR state = ?) \
183 AND createtime > DATETIME('now','-48 hours') LIMIT ?",
185 if (errorcode != SQLITE_OK) {
186 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
187 sqlite3_errmsg(g_dp_db_handle));
191 if (sqlite3_bind_int(stmt, 1, DP_STATE_QUEUED) != SQLITE_OK) {
192 TRACE_ERROR("sqlite3_bind_int [%s]",
193 sqlite3_errmsg(g_dp_db_handle));
197 if (sqlite3_bind_int(stmt, 2, DP_STATE_DOWNLOADING) != SQLITE_OK) {
198 TRACE_ERROR("sqlite3_bind_int [%s]",
199 sqlite3_errmsg(g_dp_db_handle));
203 if (sqlite3_bind_int(stmt, 3, DP_STATE_CONNECTING) != SQLITE_OK) {
204 TRACE_ERROR("sqlite3_bind_int [%s]",
205 sqlite3_errmsg(g_dp_db_handle));
210 if (sqlite3_bind_int(stmt, 4, limit)
212 TRACE_ERROR("sqlite3_bind_int[%s]",
213 sqlite3_errmsg(g_dp_db_handle));
218 while ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
219 // allocation & initialization
220 requests[i].request = dp_request_new();
222 requests[i].request->id = sqlite3_column_int(stmt, 0);
224 requests[i].request->state = sqlite3_column_int(stmt, 1);
226 buffer = (char *)(sqlite3_column_text(stmt, 2));
227 requests[i].request->packagename = NULL;
229 buffer_length = strlen(buffer);
230 if (buffer_length > 1) {
231 requests[i].request->packagename
232 = (char *)calloc(buffer_length + 1, sizeof(char));
233 memcpy(requests[i].request->packagename, buffer,
234 buffer_length * sizeof(char));
235 requests[i].request->packagename[buffer_length] = '\0';
239 TRACE_INFO("ID : %d", requests[i].request->id);
240 TRACE_INFO("state : %d", requests[i].request->state);
241 TRACE_INFO("packagename : %s", requests[i].request->packagename);
249 int dp_db_limit_rows(int limit)
251 int errorcode = SQLITE_OK;
252 sqlite3_stmt *stmt = NULL;
255 TRACE_ERROR("[CHECK LIMIT] %d", limit);
259 if (__dp_sql_open() < 0) {
260 TRACE_ERROR("__dp_sql_open[%s]", sqlite3_errmsg(g_dp_db_handle));
264 // apply "ON DELETE CASCADE"
266 sqlite3_prepare_v2(g_dp_db_handle,
267 "DELETE FROM logging WHERE id NOT IN \
268 (SELECT id FROM logging ORDER BY createtime ASC LIMIT ?)",
270 if (errorcode != SQLITE_OK) {
271 TRACE_ERROR("sqlite3_prepare_v2 [%s]",
272 sqlite3_errmsg(g_dp_db_handle));
276 if (sqlite3_bind_int(stmt, 1, limit)
278 TRACE_ERROR("sqlite3_bind_int[%s]",
279 sqlite3_errmsg(g_dp_db_handle));
283 errorcode = sqlite3_step(stmt);
284 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
292 dp_request *dp_db_load_logging_request(int id)
294 int errorcode = SQLITE_OK;
295 int buffer_length = 0;
296 sqlite3_stmt *stmt = NULL;
298 dp_request *request = NULL;
301 TRACE_ERROR("[CHECK ID]");
305 if (__dp_sql_open() < 0) {
306 TRACE_ERROR("db_util_open is failed [%s]",
307 sqlite3_errmsg(g_dp_db_handle));
312 sqlite3_prepare_v2(g_dp_db_handle,
313 "SELECT state, errorcode, startcount, packagename \
314 FROM logging WHERE id = ?",
316 if (errorcode != SQLITE_OK) {
317 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
318 sqlite3_errmsg(g_dp_db_handle));
322 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
323 TRACE_ERROR("sqlite3_bind_int is failed. [%s]",
324 sqlite3_errmsg(g_dp_db_handle));
329 if ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
330 request = dp_request_new();
331 if (request == NULL) {
332 TRACE_ERROR("dp_request_new failed");
337 request->state = sqlite3_column_int(stmt, 0);
338 request->error = sqlite3_column_int(stmt, 1);
339 request->startcount = sqlite3_column_int(stmt, 2);
341 buffer = (char *)(sqlite3_column_text(stmt, 3));
343 buffer_length = strlen(buffer);
344 if (buffer_length > 1) {
346 = (char *)calloc(buffer_length + 1, sizeof(char));
347 memcpy(request->packagename, buffer,
348 buffer_length * sizeof(char));
349 request->packagename[buffer_length] = '\0';
353 TRACE_ERROR("sqlite3_step is failed. [%s] errorcode[%d]",
354 sqlite3_errmsg(g_dp_db_handle), errorcode);
362 int dp_db_remove_all(int id)
365 dp_db_remove(id, DP_DB_TABLE_REQUEST_INFO);
366 dp_db_remove(id, DP_DB_TABLE_DOWNLOAD_INFO);
367 dp_db_remove(id, DP_DB_TABLE_HTTP_HEADERS);
368 dp_db_remove(id, DP_DB_TABLE_NOTIFICATION);
370 // apply "ON DELETE CASCADE"
371 dp_db_remove(id, DP_DB_TABLE_LOG);
375 int dp_db_remove(int id, char *table)
377 int errorcode = SQLITE_OK;
380 sqlite3_stmt *stmt = NULL;
381 char *query_format = NULL;
384 if (__dp_sql_open() < 0) {
385 TRACE_ERROR("__dp_sql_open[%s]", sqlite3_errmsg(g_dp_db_handle));
389 query_format = "DELETE FROM %s WHERE id = ? ";
390 // 2 means the length of one %s
391 query_len = strlen(query_format) - 2 + strlen(table);
392 if (query_len < strlen(query_format)) {
393 TRACE_ERROR("[CHECK QUERY FORMAT] [%s][%s]",
394 query_format, table);
398 query = (char *)calloc((query_len + 1), sizeof(char));
400 TRACE_STRERROR("[CALLOC]");
403 query[query_len] = '\0';
405 ret = snprintf(query, query_len + 1, query_format, table);
408 TRACE_STRERROR("[CHECK COMBINE] [%s]", query);
413 // check error of sqlite3_prepare_v2
414 if (sqlite3_prepare_v2
415 (g_dp_db_handle, query, -1, &stmt, NULL) != SQLITE_OK) {
416 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
423 if (sqlite3_bind_int(stmt, 1, id)
425 TRACE_ERROR("sqlite3_bind_int[%s]",
426 sqlite3_errmsg(g_dp_db_handle));
430 errorcode = sqlite3_step(stmt);
431 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
439 static sqlite3_stmt *__prepare_query(sqlite3 *handle,
440 db_query_type type, char *table, char *column)
442 sqlite3_stmt *stmt = NULL;
443 char *query_format = NULL;
447 if (type == DP_DB_QUERY_TYPE_GET) {
448 query_format = DP_DB_BASIC_GET_QUERY_FORMAT;
449 } else if (type == DP_DB_QUERY_TYPE_SET) {
450 query_format = DP_DB_BASIC_SET_QUERY_FORMAT;
451 } else if (type == DP_DB_QUERY_TYPE_INSERT) {
452 query_format = DP_DB_BASIC_INSERT_QUERY_FORMAT;
453 } else if (type == DP_DB_QUERY_TYPE_NOW_DATE) {
454 query_format = DP_DB_BASIC_NOW_DATE_QUERY_FORMAT;
456 TRACE_ERROR("[CHECK QUERY TYPE] [%d]", type);
460 if (type == DP_DB_QUERY_TYPE_GET)
461 query = sqlite3_mprintf(query_format, column, table);
463 query = sqlite3_mprintf(query_format, table, column);
465 TRACE_ERROR("[CHECK COMBINE] [%s]", query_format);
469 TRACE_INFO("[QUERY] %s", query);
471 ret = sqlite3_prepare_v2(handle, query, -1, &stmt, NULL);
473 if ( ret != SQLITE_OK) {
474 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(handle));
481 int dp_db_insert_column(int id, char *table, char *column,
482 db_column_data_type datatype, void *value)
484 sqlite3_stmt *stmt = NULL;
487 TRACE_ERROR("[CHECK ID]");
492 TRACE_ERROR("[CHECK TABLE NAME]");
497 TRACE_ERROR("[CHECK COLUMN NAME]");
501 if (__dp_sql_open() < 0) {
502 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
506 stmt = __prepare_query
507 (g_dp_db_handle, DP_DB_QUERY_TYPE_INSERT, table, column);
509 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
513 int errorcode = SQLITE_OK;
514 if (datatype == DP_DB_COL_TYPE_INT) {
515 int *cast_value = value;
516 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
517 } else if (datatype == DP_DB_COL_TYPE_INT64) {
518 #ifdef SQLITE_INT64_TYPE
519 sqlite3_int64 *cast_value = value;
520 errorcode = sqlite3_bind_int64(stmt, 2, *cast_value);
522 int *cast_value = value;
523 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
525 } else if (datatype == DP_DB_COL_TYPE_TEXT) {
526 errorcode = sqlite3_bind_text(stmt, 2, (char*)value, -1, NULL);
528 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", datatype);
533 if (errorcode != SQLITE_OK) {
534 TRACE_ERROR("[BIND] [%d] [%s]",
535 datatype, sqlite3_errmsg(g_dp_db_handle));
541 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
542 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
547 errorcode = sqlite3_step(stmt);
548 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
556 int dp_db_set_column(int id, char *table, char *column,
557 db_column_data_type datatype, void *value)
559 sqlite3_stmt *stmt = NULL;
562 TRACE_ERROR("[CHECK ID]");
567 TRACE_ERROR("[CHECK TABLE NAME]");
572 TRACE_ERROR("[CHECK COLUMN NAME]");
576 if (__dp_sql_open() < 0) {
577 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
581 stmt = __prepare_query
582 (g_dp_db_handle, DP_DB_QUERY_TYPE_SET, table, column);
584 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
588 int errorcode = SQLITE_OK;
589 if (datatype == DP_DB_COL_TYPE_INT) {
590 int *cast_value = value;
591 errorcode = sqlite3_bind_int(stmt, 1, *cast_value);
592 } else if (datatype == DP_DB_COL_TYPE_INT64) {
593 #ifdef SQLITE_INT64_TYPE
594 sqlite3_int64 *cast_value = value;
595 errorcode = sqlite3_bind_int64(stmt, 1, *cast_value);
597 int *cast_value = value;
598 errorcode = sqlite3_bind_int(stmt, 1, *cast_value);
600 } else if (datatype == DP_DB_COL_TYPE_TEXT) {
601 errorcode = sqlite3_bind_text(stmt, 1, (char*)value, -1, NULL);
603 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", datatype);
608 if (errorcode != SQLITE_OK) {
609 TRACE_ERROR("[BIND] [%d] [%s]",
610 datatype, sqlite3_errmsg(g_dp_db_handle));
616 if (sqlite3_bind_int(stmt, 2, id) != SQLITE_OK) {
617 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
622 errorcode = sqlite3_step(stmt);
623 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
631 int dp_db_replace_column(int id, char *table, char *column,
632 db_column_data_type datatype, void *value)
635 TRACE_ERROR("[CHECK ID]");
640 TRACE_ERROR("[CHECK TABLE NAME]");
645 TRACE_ERROR("[CHECK COLUMN NAME]");
649 int check_id = dp_db_get_int_column(id, table, DP_DB_COL_ID);
650 if (check_id != id) // INSERT
651 return dp_db_insert_column(id, table, column, datatype, value);
653 return dp_db_set_column(id, table, column, datatype, value);
658 char *dp_db_get_text_column(int id, char *table, char *column)
660 sqlite3_stmt *stmt = NULL;
663 TRACE_ERROR("[CHECK ID]");
668 TRACE_ERROR("[CHECK TABLE NAME]");
673 TRACE_ERROR("[CHECK COLUMN NAME]");
677 if (__dp_sql_open() < 0) {
678 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
682 stmt = __prepare_query
683 (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column);
685 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
690 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
691 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
696 if (sqlite3_step(stmt) == SQLITE_ROW) {
697 int buffer_length = 0;
698 char *columntext = NULL;
699 char *buffer = (char *)(sqlite3_column_text(stmt, 0));
700 if (buffer && (buffer_length = strlen(buffer)) > 1) {
701 columntext = (char *)calloc(buffer_length + 1, sizeof(char));
702 memcpy(columntext, buffer, buffer_length * sizeof(char));
703 columntext[buffer_length] = '\0';
712 int dp_db_get_int_column(int id, char *table, char *column)
714 sqlite3_stmt *stmt = NULL;
717 TRACE_ERROR("[CHECK ID]");
722 TRACE_ERROR("[CHECK TABLE NAME]");
727 TRACE_ERROR("[CHECK COLUMN NAME]");
731 if (__dp_sql_open() < 0) {
732 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
736 stmt = __prepare_query
737 (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column);
739 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
744 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
745 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
750 if (sqlite3_step(stmt) == SQLITE_ROW) {
751 int columnvalue = sqlite3_column_int(stmt, 0);
759 long long dp_db_get_int64_column(int id, char *table, char *column)
761 sqlite3_stmt *stmt = NULL;
764 TRACE_ERROR("[CHECK ID]");
769 TRACE_ERROR("[CHECK TABLE NAME]");
774 TRACE_ERROR("[CHECK COLUMN NAME]");
778 if (__dp_sql_open() < 0) {
779 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
783 stmt = __prepare_query
784 (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column);
786 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
791 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
792 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
797 if (sqlite3_step(stmt) == SQLITE_ROW) {
798 long long columnvalue = sqlite3_column_int64(stmt, 0);
806 int dp_db_update_date(int id, char *table, char *column)
808 int errorcode = SQLITE_OK;
809 sqlite3_stmt *stmt = NULL;
812 TRACE_ERROR("[CHECK ID]");
816 if (__dp_sql_open() < 0) {
817 TRACE_ERROR("__dp_sql_open [%s]", sqlite3_errmsg(g_dp_db_handle));
821 stmt = __prepare_query
822 (g_dp_db_handle, DP_DB_QUERY_TYPE_NOW_DATE, table, column);
824 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
829 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
830 TRACE_ERROR("sqlite3_bind_int [%s]",
831 sqlite3_errmsg(g_dp_db_handle));
836 errorcode = sqlite3_step(stmt);
837 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
841 TRACE_ERROR("Failed : [%s]", sqlite3_errmsg(g_dp_db_handle));
846 static sqlite3_stmt *__prepare_cond_query(sqlite3 *handle,
847 db_query_type type, char *table,
848 char *column, char *cond_column)
850 sqlite3_stmt *stmt = NULL;
851 char *query_format = NULL;
855 if (type == DP_DB_QUERY_TYPE_GET) {
856 query_format = DP_DB_COND_GET_QUERY_FORMAT;
857 } else if (type == DP_DB_QUERY_TYPE_SET) {
858 query_format = DP_DB_COND_SET_QUERY_FORMAT;
860 TRACE_ERROR("[CHECK QUERY TYPE] [%d]", type);
864 if (type == DP_DB_QUERY_TYPE_GET)
865 query = sqlite3_mprintf(query_format, column, table, cond_column);
867 query = sqlite3_mprintf(query_format, table, column, cond_column);
869 TRACE_ERROR("[CHECK COMBINE] [%s]", query_format);
873 TRACE_INFO("[QUERY] %s", query);
875 ret = sqlite3_prepare_v2(handle, query, -1, &stmt, NULL);
877 if ( ret != SQLITE_OK) {
878 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(handle));
886 int dp_db_cond_set_column(int id, char *table, char *column,
887 db_column_data_type datatype, void *value,
888 char *condcolumn, db_column_data_type condtype, void *condvalue)
890 int errorcode = SQLITE_OK;
891 sqlite3_stmt *stmt = NULL;
894 TRACE_ERROR("[CHECK ID]");
899 TRACE_ERROR("[CHECK TABLE NAME]");
904 TRACE_ERROR("[CHECK COLUMN NAME]");
909 TRACE_ERROR("[CHECK COLUMN NAME]");
913 if (__dp_sql_open() < 0) {
914 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
918 stmt = __prepare_cond_query
919 (g_dp_db_handle, DP_DB_QUERY_TYPE_SET, table, column, condcolumn);
921 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
925 if (datatype == DP_DB_COL_TYPE_INT) {
926 int *cast_value = value;
927 errorcode = sqlite3_bind_int(stmt, 1, *cast_value);
928 } else if (datatype == DP_DB_COL_TYPE_INT64) {
929 #ifdef SQLITE_INT64_TYPE
930 sqlite3_int64 *cast_value = value;
931 errorcode = sqlite3_bind_int64(stmt, 1, *cast_value);
933 int *cast_value = value;
934 errorcode = sqlite3_bind_int(stmt, 1, *cast_value);
936 } else if (datatype == DP_DB_COL_TYPE_TEXT) {
937 errorcode = sqlite3_bind_text(stmt, 1, (char*)value, -1, NULL);
939 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", datatype);
943 if (errorcode != SQLITE_OK) {
944 TRACE_ERROR("[BIND] [%d] [%s]",
945 datatype, sqlite3_errmsg(g_dp_db_handle));
950 if (condtype == DP_DB_COL_TYPE_INT) {
951 int *cast_value = condvalue;
952 errorcode = sqlite3_bind_int(stmt, 3, *cast_value);
953 } else if (condtype == DP_DB_COL_TYPE_INT64) {
954 #ifdef SQLITE_INT64_TYPE
955 sqlite3_int64 *cast_value = condvalue;
956 errorcode = sqlite3_bind_int64(stmt, 3, *cast_value);
958 int *cast_value = condvalue;
959 errorcode = sqlite3_bind_int(stmt, 3, *cast_value);
961 } else if (condtype == DP_DB_COL_TYPE_TEXT) {
962 errorcode = sqlite3_bind_text(stmt, 3, (char*)condvalue, -1, NULL);
964 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
969 if (errorcode != SQLITE_OK) {
970 TRACE_ERROR("[BIND] [%d] [%s]",
971 datatype, sqlite3_errmsg(g_dp_db_handle));
977 if (sqlite3_bind_int(stmt, 2, id) != SQLITE_OK) {
978 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
983 errorcode = sqlite3_step(stmt);
984 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
992 char *dp_db_cond_get_text_column(int id, char *table, char *column,
993 char *condcolumn, db_column_data_type condtype,
996 sqlite3_stmt *stmt = NULL;
999 TRACE_ERROR("[CHECK ID]");
1004 TRACE_ERROR("[CHECK TABLE NAME]");
1009 TRACE_ERROR("[CHECK COLUMN NAME]");
1013 if (__dp_sql_open() < 0) {
1014 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
1018 stmt = __prepare_cond_query
1019 (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column, condcolumn);
1021 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
1025 int errorcode = SQLITE_OK;
1026 if (condtype == DP_DB_COL_TYPE_INT) {
1027 int *cast_value = condvalue;
1028 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1029 } else if (condtype == DP_DB_COL_TYPE_INT64) {
1030 #ifdef SQLITE_INT64_TYPE
1031 sqlite3_int64 *cast_value = condvalue;
1032 errorcode = sqlite3_bind_int64(stmt, 2, *cast_value);
1034 int *cast_value = condvalue;
1035 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1037 } else if (condtype == DP_DB_COL_TYPE_TEXT) {
1038 errorcode = sqlite3_bind_text(stmt, 2, (char*)condvalue, -1, NULL);
1040 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
1041 __dp_finalize(stmt);
1044 if (errorcode != SQLITE_OK) {
1045 TRACE_ERROR("[BIND] [%d] [%s]",
1046 condtype, sqlite3_errmsg(g_dp_db_handle));
1047 __dp_finalize(stmt);
1052 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
1053 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
1054 __dp_finalize(stmt);
1058 if (sqlite3_step(stmt) == SQLITE_ROW) {
1059 int buffer_length = 0;
1060 char *columntext = NULL;
1061 char *buffer = (char *)(sqlite3_column_text(stmt, 0));
1062 if (buffer && (buffer_length = strlen(buffer)) > 1) {
1063 columntext = (char *)calloc(buffer_length + 1, sizeof(char));
1064 memcpy(columntext, buffer, buffer_length * sizeof(char));
1065 columntext[buffer_length] = '\0';
1067 __dp_finalize(stmt);
1070 __dp_finalize(stmt);
1074 int dp_db_cond_remove(int id, char *table,
1075 char *condcolumn, db_column_data_type condtype,
1078 int errorcode = SQLITE_OK;
1080 sqlite3_stmt *stmt = NULL;
1081 char *query_format = NULL;
1085 TRACE_ERROR("[CHECK ID]");
1090 TRACE_ERROR("[CHECK TABLE NAME]");
1095 TRACE_ERROR("[CHECK COLUMN NAME]");
1099 if (__dp_sql_open() < 0) {
1100 TRACE_ERROR("__dp_sql_open[%s]", sqlite3_errmsg(g_dp_db_handle));
1104 query_format = "DELETE FROM %s WHERE id = ? AND %s = ?";
1106 query = sqlite3_mprintf(query_format, table, condcolumn);
1107 if (query == NULL) {
1108 TRACE_ERROR("[CHECK COMBINE] [%s]", query_format);
1112 TRACE_INFO("[QUERY] %s", query);
1114 ret = sqlite3_prepare_v2(g_dp_db_handle, query, -1, &stmt, NULL);
1115 sqlite3_free(query);
1116 if ( ret != SQLITE_OK) {
1117 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
1118 __dp_finalize(stmt);
1122 if (condtype == DP_DB_COL_TYPE_INT) {
1123 int *cast_value = condvalue;
1124 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1125 } else if (condtype == DP_DB_COL_TYPE_INT64) {
1126 #ifdef SQLITE_INT64_TYPE
1127 sqlite3_int64 *cast_value = condvalue;
1128 errorcode = sqlite3_bind_int64(stmt, 2, *cast_value);
1130 int *cast_value = condvalue;
1131 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1133 } else if (condtype == DP_DB_COL_TYPE_TEXT) {
1134 errorcode = sqlite3_bind_text(stmt, 2, (char*)condvalue, -1, NULL);
1136 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
1137 __dp_finalize(stmt);
1140 if (errorcode != SQLITE_OK) {
1141 TRACE_ERROR("[BIND] [%d] [%s]",
1142 condtype, sqlite3_errmsg(g_dp_db_handle));
1143 __dp_finalize(stmt);
1147 if (sqlite3_bind_int(stmt, 1, id)
1149 TRACE_ERROR("sqlite3_bind_int[%s]",
1150 sqlite3_errmsg(g_dp_db_handle));
1151 __dp_finalize(stmt);
1154 errorcode = sqlite3_step(stmt);
1155 if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
1156 __dp_finalize(stmt);
1159 __dp_finalize(stmt);
1163 int dp_db_get_cond_rows_count(int id, char *table,
1164 char *condcolumn, db_column_data_type condtype,
1167 int errorcode = SQLITE_OK;
1169 sqlite3_stmt *stmt = NULL;
1173 TRACE_ERROR("[CHECK ID]");
1178 TRACE_ERROR("[CHECK TABLE NAME]");
1182 if (__dp_sql_open() < 0) {
1183 TRACE_ERROR("db_util_open is failed [%s]",
1184 sqlite3_errmsg(g_dp_db_handle));
1191 ("SELECT count(id) FROM %s WHERE id = ? AND %s = ?",
1196 ("SELECT count(id) FROM %s WHERE id = ?", table);
1198 if (query == NULL) {
1199 TRACE_ERROR("[CHECK COMBINE]");
1203 TRACE_INFO("[QUERY] %s", query);
1205 ret = sqlite3_prepare_v2(g_dp_db_handle, query, -1, &stmt, NULL);
1206 sqlite3_free(query);
1207 if ( ret != SQLITE_OK) {
1208 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
1209 __dp_finalize(stmt);
1214 if (condtype == DP_DB_COL_TYPE_INT) {
1215 int *cast_value = condvalue;
1216 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1217 } else if (condtype == DP_DB_COL_TYPE_INT64) {
1218 #ifdef SQLITE_INT64_TYPE
1219 sqlite3_int64 *cast_value = condvalue;
1220 errorcode = sqlite3_bind_int64(stmt, 2, *cast_value);
1222 int *cast_value = condvalue;
1223 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1225 } else if (condtype == DP_DB_COL_TYPE_TEXT) {
1226 errorcode = sqlite3_bind_text(stmt, 2, (char*)condvalue, -1, NULL);
1228 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
1229 __dp_finalize(stmt);
1232 if (errorcode != SQLITE_OK) {
1233 TRACE_ERROR("[BIND] [%d] [%s]",
1234 condtype, sqlite3_errmsg(g_dp_db_handle));
1235 __dp_finalize(stmt);
1240 if (sqlite3_bind_int(stmt, 1, id)
1242 TRACE_ERROR("sqlite3_bind_int[%s]",
1243 sqlite3_errmsg(g_dp_db_handle));
1244 __dp_finalize(stmt);
1248 errorcode = sqlite3_step(stmt);
1249 if (errorcode == SQLITE_ROW) {
1250 int count = sqlite3_column_int(stmt, 0);
1251 __dp_finalize(stmt);
1254 __dp_finalize(stmt);
1258 int dp_db_get_http_headers_list(int id, char **headers)
1260 int errorcode = SQLITE_OK;
1262 int headers_index = 0;
1263 sqlite3_stmt *stmt = NULL;
1266 TRACE_ERROR("[CHECK ID]");
1270 if (__dp_sql_open() < 0) {
1271 TRACE_ERROR("db_util_open is failed [%s]",
1272 sqlite3_errmsg(g_dp_db_handle));
1277 sqlite3_prepare_v2(g_dp_db_handle,
1278 "SELECT header_field, header_data FROM httpheaders WHERE id = ?",
1280 if (errorcode != SQLITE_OK) {
1281 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
1282 sqlite3_errmsg(g_dp_db_handle));
1283 __dp_finalize(stmt);
1286 if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
1287 TRACE_ERROR("sqlite3_bind_int [%s]",
1288 sqlite3_errmsg(g_dp_db_handle));
1289 __dp_finalize(stmt);
1293 while ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
1294 int buffer_length = 0;
1295 char *header_field = (char *)(sqlite3_column_text(stmt, 0));
1296 char *header_data = (char *)(sqlite3_column_text(stmt, 1));
1298 // REF : http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
1299 buffer_length = strlen(header_field) + strlen(header_data) + 1;
1300 char *headers_buffer = calloc(buffer_length + 1, sizeof(char));
1301 if (headers_buffer == NULL) {
1302 TRACE_ERROR("[CALLOC] headers_buffer");
1305 int len = snprintf(headers_buffer, buffer_length + 1,
1306 "%s:%s", header_field, header_data);
1309 free(headers_buffer);
1312 headers_buffer[len] = '\0';
1314 headers[headers_index++] = headers_buffer;
1317 __dp_finalize(stmt);
1318 return headers_index;