src/download-provider-db.c

   1 /*
   2  * Copyright (c) 2012 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <db-util.h>
  18
  19 #include <string.h>
  20 #include <errno.h>
  21
  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"
  27
  28 //BASIC
  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 = ?"
  33
  34 // COND
  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 = ?"
  37
  38 typedef enum {
  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
  43 } db_query_type;
  44
  45 sqlite3 *g_dp_db_handle = 0;
  46
  47 // called when terminating process
  48 void dp_db_close()
  49 {
  50         if (g_dp_db_handle)
  51                 db_util_close(g_dp_db_handle);
  52         g_dp_db_handle = 0;
  53 }
  54
  55 // called when launching process or in every API
  56 int dp_db_open()
  57 {
  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));
  63                         dp_db_close();
  64                         return -1;
  65                 }
  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);
  68         }
  69         return g_dp_db_handle ? 0 : -1;
  70 }
  71
  72 static int __dp_sql_open()
  73 {
  74         return dp_db_open();
  75 }
  76
  77 static void __dp_finalize(sqlite3_stmt *stmt)
  78 {
  79         if (sqlite3_finalize(stmt) != SQLITE_OK)
  80                 TRACE_ERROR("failed sqlite3_finalize [%s]",
  81                         sqlite3_errmsg(g_dp_db_handle));
  82 }
  83
  84 int dp_db_get_count_by_limit_time()
  85 {
  86         int errorcode = SQLITE_OK;
  87         sqlite3_stmt *stmt = NULL;
  88
  89         if (__dp_sql_open() < 0) {
  90                 TRACE_ERROR("db_util_open is failed [%s]",
  91                         sqlite3_errmsg(g_dp_db_handle));
  92                 return -1;
  93         }
  94
  95         errorcode =
  96                 sqlite3_prepare_v2(g_dp_db_handle,
  97                         "SELECT count(id) FROM logging \
  98                         WHERE createtime < DATETIME('now','-48 hours')",
  99                         -1, &stmt, NULL);
 100         if (errorcode != SQLITE_OK) {
 101                 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
 102                         sqlite3_errmsg(g_dp_db_handle));
 103                 __dp_finalize(stmt);
 104                 return -1;
 105         }
 106         errorcode = sqlite3_step(stmt);
 107         if (errorcode == SQLITE_ROW) {
 108                 int count = sqlite3_column_int(stmt, 0);
 109                 __dp_finalize(stmt);
 110                 return count;
 111         }
 112         __dp_finalize(stmt);
 113         return 0;
 114 }
 115
 116 int dp_db_get_list_by_limit_time(dp_request_slots *requests, int limit)
 117 {
 118         int errorcode = SQLITE_OK;
 119         int i = 0;
 120         sqlite3_stmt *stmt = NULL;
 121
 122         if (__dp_sql_open() < 0) {
 123                 TRACE_ERROR("db_util_open is failed [%s]",
 124                         sqlite3_errmsg(g_dp_db_handle));
 125                 return -1;
 126         }
 127
 128         errorcode =
 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 ?",
 133                         -1, &stmt, NULL);
 134         if (errorcode != SQLITE_OK) {
 135                 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
 136                         sqlite3_errmsg(g_dp_db_handle));
 137                 __dp_finalize(stmt);
 138                 return -1;
 139         }
 140         if (sqlite3_bind_int(stmt, 1, limit)
 141                 != SQLITE_OK) {
 142                 TRACE_ERROR("sqlite3_bind_int[%s]",
 143                         sqlite3_errmsg(g_dp_db_handle));
 144                 __dp_finalize(stmt);
 145                 return -1;
 146         }
 147
 148         while ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW && i < limit) {
 149                 // allocation & initialization
 150                 requests[i].request = dp_request_new();
 151                 // ID
 152                 requests[i].request->id = sqlite3_column_int(stmt, 0);
 153                 // state
 154                 requests[i].request->state = sqlite3_column_int(stmt, 1);
 155
 156                 TRACE_INFO("ID : %d",  requests[i].request->id);
 157                 TRACE_INFO("state : %d",  requests[i].request->state);
 158                 i++;
 159         }
 160
 161         __dp_finalize(stmt);
 162         return i;
 163 }
 164
 165 int dp_db_crashed_list(dp_request_slots *requests, int limit)
 166 {
 167         int errorcode = SQLITE_OK;
 168         int i = 0;
 169         int buffer_length = 0;
 170         sqlite3_stmt *stmt = NULL;
 171         char *buffer = NULL;
 172
 173         if (__dp_sql_open() < 0) {
 174                 TRACE_ERROR("db_util_open is failed [%s]",
 175                         sqlite3_errmsg(g_dp_db_handle));
 176                 return -1;
 177         }
 178
 179         errorcode =
 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 ?",
 184                         -1, &stmt, NULL);
 185         if (errorcode != SQLITE_OK) {
 186                 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
 187                         sqlite3_errmsg(g_dp_db_handle));
 188                 __dp_finalize(stmt);
 189                 return -1;
 190         }
 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));
 194                 __dp_finalize(stmt);
 195                 return -1;
 196         }
 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));
 200                 __dp_finalize(stmt);
 201                 return -1;
 202         }
 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));
 206                 __dp_finalize(stmt);
 207                 return -1;
 208         }
 209
 210         if (sqlite3_bind_int(stmt, 4, limit)
 211                 != SQLITE_OK) {
 212                 TRACE_ERROR("sqlite3_bind_int[%s]",
 213                         sqlite3_errmsg(g_dp_db_handle));
 214                 __dp_finalize(stmt);
 215                 return -1;
 216         }
 217
 218         while ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
 219                 // allocation & initialization
 220                 requests[i].request = dp_request_new();
 221                 // ID
 222                 requests[i].request->id = sqlite3_column_int(stmt, 0);
 223                 // state
 224                 requests[i].request->state = sqlite3_column_int(stmt, 1);
 225                 // packagename
 226                 buffer = (char *)(sqlite3_column_text(stmt, 2));
 227                 requests[i].request->packagename = NULL;
 228                 if (buffer) {
 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';
 236                         }
 237                 }
 238
 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);
 242                 i++;
 243         }
 244
 245         __dp_finalize(stmt);
 246         return i;
 247 }
 248
 249 int dp_db_limit_rows(int limit)
 250 {
 251         int errorcode = SQLITE_OK;
 252         sqlite3_stmt *stmt = NULL;
 253
 254         if (limit <= 0) {
 255                 TRACE_ERROR("[CHECK LIMIT] %d", limit);
 256                 return -1;
 257         }
 258
 259         if (__dp_sql_open() < 0) {
 260                 TRACE_ERROR("__dp_sql_open[%s]", sqlite3_errmsg(g_dp_db_handle));
 261                 return -1;
 262         }
 263
 264         // apply "ON DELETE CASCADE"
 265         errorcode =
 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 ?)",
 269                         -1, &stmt, NULL);
 270         if (errorcode != SQLITE_OK) {
 271                 TRACE_ERROR("sqlite3_prepare_v2 [%s]",
 272                                 sqlite3_errmsg(g_dp_db_handle));
 273                 __dp_finalize(stmt);
 274                 return -1;
 275         }
 276         if (sqlite3_bind_int(stmt, 1, limit)
 277                 != SQLITE_OK) {
 278                 TRACE_ERROR("sqlite3_bind_int[%s]",
 279                         sqlite3_errmsg(g_dp_db_handle));
 280                 __dp_finalize(stmt);
 281                 return -1;
 282         }
 283         errorcode = sqlite3_step(stmt);
 284         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 285                 __dp_finalize(stmt);
 286                 return 0;
 287         }
 288         __dp_finalize(stmt);
 289         return -1;
 290 }
 291
 292 dp_request *dp_db_load_logging_request(int id)
 293 {
 294         int errorcode = SQLITE_OK;
 295         int buffer_length = 0;
 296         sqlite3_stmt *stmt = NULL;
 297         char *buffer = NULL;
 298         dp_request *request = NULL;
 299
 300         if (id <= 0) {
 301                 TRACE_ERROR("[CHECK ID]");
 302                 return NULL;
 303         }
 304
 305         if (__dp_sql_open() < 0) {
 306                 TRACE_ERROR("db_util_open is failed [%s]",
 307                                 sqlite3_errmsg(g_dp_db_handle));
 308                 return NULL;
 309         }
 310
 311         errorcode =
 312                 sqlite3_prepare_v2(g_dp_db_handle,
 313                         "SELECT state, errorcode, startcount, packagename \
 314                         FROM logging WHERE id = ?",
 315                         -1, &stmt, NULL);
 316         if (errorcode != SQLITE_OK) {
 317                 TRACE_ERROR("sqlite3_prepare_v2 is failed. [%s]",
 318                                 sqlite3_errmsg(g_dp_db_handle));
 319                 __dp_finalize(stmt);
 320                 return NULL;
 321         }
 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));
 325                 __dp_finalize(stmt);
 326                 return NULL;
 327         }
 328
 329         if ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
 330                 request = dp_request_new();
 331                 if (request == NULL) {
 332                         TRACE_ERROR("dp_request_new failed");
 333                         __dp_finalize(stmt);
 334                         return NULL;
 335                 }
 336                 request->id = id;
 337                 request->state = sqlite3_column_int(stmt, 0);
 338                 request->error = sqlite3_column_int(stmt, 1);
 339                 request->startcount = sqlite3_column_int(stmt, 2);
 340
 341                 buffer = (char *)(sqlite3_column_text(stmt, 3));
 342                 if (buffer) {
 343                         buffer_length = strlen(buffer);
 344                         if (buffer_length > 1) {
 345                                 request->packagename
 346                                         = (char *)calloc(buffer_length + 1, sizeof(char));
 347                                 memcpy(request->packagename, buffer,
 348                                         buffer_length * sizeof(char));
 349                                 request->packagename[buffer_length] = '\0';
 350                         }
 351                 }
 352         } else {
 353                 TRACE_ERROR("sqlite3_step is failed. [%s] errorcode[%d]",
 354                                 sqlite3_errmsg(g_dp_db_handle), errorcode);
 355                 __dp_finalize(stmt);
 356                 return NULL;
 357         }
 358         __dp_finalize(stmt);
 359         return request;
 360 }
 361
 362 int dp_db_remove_all(int id)
 363 {
 364         #if 0
 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);
 369         #endif
 370         // apply "ON DELETE CASCADE"
 371         dp_db_remove(id, DP_DB_TABLE_LOG);
 372         return -1;
 373 }
 374
 375 int dp_db_remove(int id, char *table)
 376 {
 377         int errorcode = SQLITE_OK;
 378         int query_len = 0;
 379         int ret = -1;
 380         sqlite3_stmt *stmt = NULL;
 381         char *query_format = NULL;
 382         char *query = NULL;
 383
 384         if (__dp_sql_open() < 0) {
 385                 TRACE_ERROR("__dp_sql_open[%s]", sqlite3_errmsg(g_dp_db_handle));
 386                 return -1;
 387         }
 388
 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);
 395                 return -1;
 396         }
 397
 398         query = (char *)calloc((query_len + 1), sizeof(char));
 399         if (query == NULL) {
 400                 TRACE_STRERROR("[CALLOC]");
 401                 return -1;
 402         }
 403         query[query_len] = '\0';
 404
 405         ret = snprintf(query, query_len + 1, query_format, table);
 406
 407         if (ret < 0) {
 408                 TRACE_STRERROR("[CHECK COMBINE] [%s]", query);
 409                 free(query);
 410                 return -1;
 411         }
 412
 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));
 417                 __dp_finalize(stmt);
 418                 free(query);
 419                 return -1;
 420         }
 421         free(query);
 422
 423         if (sqlite3_bind_int(stmt, 1, id)
 424                 != SQLITE_OK) {
 425                 TRACE_ERROR("sqlite3_bind_int[%s]",
 426                         sqlite3_errmsg(g_dp_db_handle));
 427                 __dp_finalize(stmt);
 428                 return -1;
 429         }
 430         errorcode = sqlite3_step(stmt);
 431         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 432                 __dp_finalize(stmt);
 433                 return 0;
 434         }
 435         __dp_finalize(stmt);
 436         return -1;
 437 }
 438
 439 static sqlite3_stmt *__prepare_query(sqlite3 *handle,
 440                 db_query_type type, char *table, char *column)
 441 {
 442         sqlite3_stmt *stmt = NULL;
 443         char *query_format = NULL;
 444         char *query = NULL;
 445         int ret = -1;
 446
 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;
 455         } else {
 456                 TRACE_ERROR("[CHECK QUERY TYPE] [%d]", type);
 457                 return NULL;
 458         }
 459
 460         if (type == DP_DB_QUERY_TYPE_GET)
 461                 query = sqlite3_mprintf(query_format, column, table);
 462         else
 463                 query = sqlite3_mprintf(query_format, table, column);
 464         if (query == NULL) {
 465                 TRACE_ERROR("[CHECK COMBINE] [%s]", query_format);
 466                 return NULL;
 467         }
 468
 469         TRACE_INFO("[QUERY] %s", query);
 470
 471         ret = sqlite3_prepare_v2(handle, query, -1, &stmt, NULL);
 472         sqlite3_free(query);
 473         if ( ret != SQLITE_OK) {
 474                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(handle));
 475                 __dp_finalize(stmt);
 476                 return NULL;
 477         }
 478         return stmt;
 479 }
 480
 481 int dp_db_insert_column(int id, char *table, char *column,
 482                                                 db_column_data_type datatype, void *value)
 483 {
 484         sqlite3_stmt *stmt = NULL;
 485
 486         if (id <= 0) {
 487                 TRACE_ERROR("[CHECK ID]");
 488                 return -1;
 489         }
 490
 491         if (!table) {
 492                 TRACE_ERROR("[CHECK TABLE NAME]");
 493                 return -1;
 494         }
 495
 496         if (!column) {
 497                 TRACE_ERROR("[CHECK COLUMN NAME]");
 498                 return -1;
 499         }
 500
 501         if (__dp_sql_open() < 0) {
 502                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
 503                 return -1;
 504         }
 505
 506         stmt = __prepare_query
 507                         (g_dp_db_handle, DP_DB_QUERY_TYPE_INSERT, table, column);
 508         if (stmt == NULL) {
 509                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 510                 return -1;
 511         }
 512
 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);
 521 #else
 522                 int *cast_value = value;
 523                 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
 524 #endif
 525         } else if (datatype == DP_DB_COL_TYPE_TEXT) {
 526                 errorcode = sqlite3_bind_text(stmt, 2, (char*)value, -1, NULL);
 527         } else {
 528                 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", datatype);
 529                 __dp_finalize(stmt);
 530                 return -1;
 531         }
 532
 533         if (errorcode != SQLITE_OK) {
 534                 TRACE_ERROR("[BIND] [%d] [%s]",
 535                         datatype, sqlite3_errmsg(g_dp_db_handle));
 536                 __dp_finalize(stmt);
 537                 return -1;
 538         }
 539
 540         // VALUES ( id )
 541         if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
 542                 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
 543                 __dp_finalize(stmt);
 544                 return -1;
 545         }
 546
 547         errorcode = sqlite3_step(stmt);
 548         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 549                 __dp_finalize(stmt);
 550                 return 0;
 551         }
 552         __dp_finalize(stmt);
 553         return -1;
 554 }
 555
 556 int dp_db_set_column(int id, char *table, char *column,
 557                                                 db_column_data_type datatype, void *value)
 558 {
 559         sqlite3_stmt *stmt = NULL;
 560
 561         if (id <= 0) {
 562                 TRACE_ERROR("[CHECK ID]");
 563                 return -1;
 564         }
 565
 566         if (!table) {
 567                 TRACE_ERROR("[CHECK TABLE NAME]");
 568                 return -1;
 569         }
 570
 571         if (!column) {
 572                 TRACE_ERROR("[CHECK COLUMN NAME]");
 573                 return -1;
 574         }
 575
 576         if (__dp_sql_open() < 0) {
 577                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
 578                 return -1;
 579         }
 580
 581         stmt = __prepare_query
 582                         (g_dp_db_handle, DP_DB_QUERY_TYPE_SET, table, column);
 583         if (stmt == NULL) {
 584                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 585                 return -1;
 586         }
 587
 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);
 596 #else
 597                 int *cast_value = value;
 598                 errorcode = sqlite3_bind_int(stmt, 1, *cast_value);
 599 #endif
 600         } else if (datatype == DP_DB_COL_TYPE_TEXT) {
 601                 errorcode = sqlite3_bind_text(stmt, 1, (char*)value, -1, NULL);
 602         } else {
 603                 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", datatype);
 604                 __dp_finalize(stmt);
 605                 return -1;
 606         }
 607
 608         if (errorcode != SQLITE_OK) {
 609                 TRACE_ERROR("[BIND] [%d] [%s]",
 610                         datatype, sqlite3_errmsg(g_dp_db_handle));
 611                 __dp_finalize(stmt);
 612                 return -1;
 613         }
 614
 615         // WHERE id = ?
 616         if (sqlite3_bind_int(stmt, 2, id) != SQLITE_OK) {
 617                 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
 618                 __dp_finalize(stmt);
 619                 return -1;
 620         }
 621
 622         errorcode = sqlite3_step(stmt);
 623         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 624                 __dp_finalize(stmt);
 625                 return 0;
 626         }
 627         __dp_finalize(stmt);
 628         return -1;
 629 }
 630
 631 int dp_db_replace_column(int id, char *table, char *column,
 632                                                 db_column_data_type datatype, void *value)
 633 {
 634         if (id <= 0) {
 635                 TRACE_ERROR("[CHECK ID]");
 636                 return -1;
 637         }
 638
 639         if (!table) {
 640                 TRACE_ERROR("[CHECK TABLE NAME]");
 641                 return -1;
 642         }
 643
 644         if (!column) {
 645                 TRACE_ERROR("[CHECK COLUMN NAME]");
 646                 return -1;
 647         }
 648
 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);
 652         // UPDATE
 653         return dp_db_set_column(id, table, column, datatype, value);
 654 }
 655
 656 // success : 0
 657 // error   : -1
 658 char *dp_db_get_text_column(int id, char *table, char *column)
 659 {
 660         sqlite3_stmt *stmt = NULL;
 661
 662         if (id <= 0) {
 663                 TRACE_ERROR("[CHECK ID]");
 664                 return NULL;
 665         }
 666
 667         if (!table) {
 668                 TRACE_ERROR("[CHECK TABLE NAME]");
 669                 return NULL;
 670         }
 671
 672         if (!column) {
 673                 TRACE_ERROR("[CHECK COLUMN NAME]");
 674                 return NULL;
 675         }
 676
 677         if (__dp_sql_open() < 0) {
 678                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
 679                 return NULL;
 680         }
 681
 682         stmt = __prepare_query
 683                         (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column);
 684         if (stmt == NULL) {
 685                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 686                 return NULL;
 687         }
 688
 689         // WHERE id = ?
 690         if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
 691                 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
 692                 __dp_finalize(stmt);
 693                 return NULL;
 694         }
 695
 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';
 704                 }
 705                 __dp_finalize(stmt);
 706                 return columntext;
 707         }
 708         __dp_finalize(stmt);
 709         return NULL;
 710 }
 711
 712 int dp_db_get_int_column(int id, char *table, char *column)
 713 {
 714         sqlite3_stmt *stmt = NULL;
 715
 716         if (id <= 0) {
 717                 TRACE_ERROR("[CHECK ID]");
 718                 return -1;
 719         }
 720
 721         if (!table) {
 722                 TRACE_ERROR("[CHECK TABLE NAME]");
 723                 return -1;
 724         }
 725
 726         if (!column) {
 727                 TRACE_ERROR("[CHECK COLUMN NAME]");
 728                 return -1;
 729         }
 730
 731         if (__dp_sql_open() < 0) {
 732                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
 733                 return -1;
 734         }
 735
 736         stmt = __prepare_query
 737                         (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column);
 738         if (stmt == NULL) {
 739                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 740                 return -1;
 741         }
 742
 743         // WHERE id = ?
 744         if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
 745                 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
 746                 __dp_finalize(stmt);
 747                 return -1;
 748         }
 749
 750         if (sqlite3_step(stmt) == SQLITE_ROW) {
 751                 int columnvalue = sqlite3_column_int(stmt, 0);
 752                 __dp_finalize(stmt);
 753                 return columnvalue;
 754         }
 755         __dp_finalize(stmt);
 756         return -1;
 757 }
 758
 759 long long dp_db_get_int64_column(int id, char *table, char *column)
 760 {
 761         sqlite3_stmt *stmt = NULL;
 762
 763         if (id <= 0) {
 764                 TRACE_ERROR("[CHECK ID]");
 765                 return -1;
 766         }
 767
 768         if (!table) {
 769                 TRACE_ERROR("[CHECK TABLE NAME]");
 770                 return -1;
 771         }
 772
 773         if (!column) {
 774                 TRACE_ERROR("[CHECK COLUMN NAME]");
 775                 return -1;
 776         }
 777
 778         if (__dp_sql_open() < 0) {
 779                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
 780                 return -1;
 781         }
 782
 783         stmt = __prepare_query
 784                         (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column);
 785         if (stmt == NULL) {
 786                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 787                 return -1;
 788         }
 789
 790         // WHERE id = ?
 791         if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
 792                 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
 793                 __dp_finalize(stmt);
 794                 return -1;
 795         }
 796
 797         if (sqlite3_step(stmt) == SQLITE_ROW) {
 798                 long long columnvalue = sqlite3_column_int64(stmt, 0);
 799                 __dp_finalize(stmt);
 800                 return columnvalue;
 801         }
 802         __dp_finalize(stmt);
 803         return -1;
 804 }
 805
 806 int dp_db_update_date(int id, char *table, char *column)
 807 {
 808         int errorcode = SQLITE_OK;
 809         sqlite3_stmt *stmt = NULL;
 810
 811         if (id <= 0) {
 812                 TRACE_ERROR("[CHECK ID]");
 813                 return -1;
 814         }
 815
 816         if (__dp_sql_open() < 0) {
 817                 TRACE_ERROR("__dp_sql_open [%s]", sqlite3_errmsg(g_dp_db_handle));
 818                 return -1;
 819         }
 820
 821         stmt = __prepare_query
 822                         (g_dp_db_handle, DP_DB_QUERY_TYPE_NOW_DATE, table, column);
 823         if (stmt == NULL) {
 824                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 825                 return -1;
 826         }
 827
 828         // WHERE id = ?
 829         if (sqlite3_bind_int(stmt, 1, id) != SQLITE_OK) {
 830                 TRACE_ERROR("sqlite3_bind_int [%s]",
 831                         sqlite3_errmsg(g_dp_db_handle));
 832                 __dp_finalize(stmt);
 833                 return -1;
 834         }
 835
 836         errorcode = sqlite3_step(stmt);
 837         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 838                 __dp_finalize(stmt);
 839                 return 0;
 840         }
 841         TRACE_ERROR("Failed : [%s]", sqlite3_errmsg(g_dp_db_handle));
 842         __dp_finalize(stmt);
 843         return -1;
 844 }
 845
 846 static sqlite3_stmt *__prepare_cond_query(sqlite3 *handle,
 847                 db_query_type type, char *table,
 848                 char *column, char *cond_column)
 849 {
 850         sqlite3_stmt *stmt = NULL;
 851         char *query_format = NULL;
 852         char *query = NULL;
 853         int ret = -1;
 854
 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;
 859         } else {
 860                 TRACE_ERROR("[CHECK QUERY TYPE] [%d]", type);
 861                 return NULL;
 862         }
 863
 864         if (type == DP_DB_QUERY_TYPE_GET)
 865                 query = sqlite3_mprintf(query_format, column, table, cond_column);
 866         else
 867                 query = sqlite3_mprintf(query_format, table, column, cond_column);
 868         if (query == NULL) {
 869                 TRACE_ERROR("[CHECK COMBINE] [%s]", query_format);
 870                 return NULL;
 871         }
 872
 873         TRACE_INFO("[QUERY] %s", query);
 874
 875         ret = sqlite3_prepare_v2(handle, query, -1, &stmt, NULL);
 876         sqlite3_free(query);
 877         if ( ret != SQLITE_OK) {
 878                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(handle));
 879                 __dp_finalize(stmt);
 880                 return NULL;
 881         }
 882         return stmt;
 883
 884 }
 885
 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)
 889 {
 890         int errorcode = SQLITE_OK;
 891         sqlite3_stmt *stmt = NULL;
 892
 893         if (id <= 0) {
 894                 TRACE_ERROR("[CHECK ID]");
 895                 return -1;
 896         }
 897
 898         if (!table) {
 899                 TRACE_ERROR("[CHECK TABLE NAME]");
 900                 return -1;
 901         }
 902
 903         if (!column) {
 904                 TRACE_ERROR("[CHECK COLUMN NAME]");
 905                 return -1;
 906         }
 907
 908         if (!condcolumn) {
 909                 TRACE_ERROR("[CHECK COLUMN NAME]");
 910                 return -1;
 911         }
 912
 913         if (__dp_sql_open() < 0) {
 914                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
 915                 return -1;
 916         }
 917
 918         stmt = __prepare_cond_query
 919                         (g_dp_db_handle, DP_DB_QUERY_TYPE_SET, table, column, condcolumn);
 920         if (stmt == NULL) {
 921                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
 922                 return -1;
 923         }
 924
 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);
 932 #else
 933                 int *cast_value = value;
 934                 errorcode = sqlite3_bind_int(stmt, 1, *cast_value);
 935 #endif
 936         } else if (datatype == DP_DB_COL_TYPE_TEXT) {
 937                 errorcode = sqlite3_bind_text(stmt, 1, (char*)value, -1, NULL);
 938         } else {
 939                 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", datatype);
 940                 __dp_finalize(stmt);
 941                 return -1;
 942         }
 943         if (errorcode != SQLITE_OK) {
 944                 TRACE_ERROR("[BIND] [%d] [%s]",
 945                         datatype, sqlite3_errmsg(g_dp_db_handle));
 946                 __dp_finalize(stmt);
 947                 return -1;
 948         }
 949
 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);
 957 #else
 958                 int *cast_value = condvalue;
 959                 errorcode = sqlite3_bind_int(stmt, 3, *cast_value);
 960 #endif
 961         } else if (condtype == DP_DB_COL_TYPE_TEXT) {
 962                 errorcode = sqlite3_bind_text(stmt, 3, (char*)condvalue, -1, NULL);
 963         } else {
 964                 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
 965                 __dp_finalize(stmt);
 966                 return -1;
 967         }
 968
 969         if (errorcode != SQLITE_OK) {
 970                 TRACE_ERROR("[BIND] [%d] [%s]",
 971                         datatype, sqlite3_errmsg(g_dp_db_handle));
 972                 __dp_finalize(stmt);
 973                 return -1;
 974         }
 975
 976         // WHERE id = ?
 977         if (sqlite3_bind_int(stmt, 2, id) != SQLITE_OK) {
 978                 TRACE_ERROR("[BIND] [%s]", sqlite3_errmsg(g_dp_db_handle));
 979                 __dp_finalize(stmt);
 980                 return -1;
 981         }
 982
 983         errorcode = sqlite3_step(stmt);
 984         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 985                 __dp_finalize(stmt);
 986                 return 0;
 987         }
 988         __dp_finalize(stmt);
 989         return -1;
 990 }
 991
 992 char *dp_db_cond_get_text_column(int id, char *table, char *column,
 993                                                 char *condcolumn, db_column_data_type condtype,
 994                                                 void *condvalue)
 995 {
 996         sqlite3_stmt *stmt = NULL;
 997
 998         if (id <= 0) {
 999                 TRACE_ERROR("[CHECK ID]");
1000                 return NULL;
1001         }
1002
1003         if (!table) {
1004                 TRACE_ERROR("[CHECK TABLE NAME]");
1005                 return NULL;
1006         }
1007
1008         if (!column) {
1009                 TRACE_ERROR("[CHECK COLUMN NAME]");
1010                 return NULL;
1011         }
1012
1013         if (__dp_sql_open() < 0) {
1014                 TRACE_ERROR("[OPEN] [%s]", sqlite3_errmsg(g_dp_db_handle));
1015                 return NULL;
1016         }
1017
1018         stmt = __prepare_cond_query
1019                         (g_dp_db_handle, DP_DB_QUERY_TYPE_GET, table, column, condcolumn);
1020         if (stmt == NULL) {
1021                 TRACE_ERROR("[PREPARE] [%s]", sqlite3_errmsg(g_dp_db_handle));
1022                 return NULL;
1023         }
1024
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);
1033 #else
1034                 int *cast_value = condvalue;
1035                 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1036 #endif
1037         } else if (condtype == DP_DB_COL_TYPE_TEXT) {
1038                 errorcode = sqlite3_bind_text(stmt, 2, (char*)condvalue, -1, NULL);
1039         } else {
1040                 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
1041                 __dp_finalize(stmt);
1042                 return NULL;
1043         }
1044         if (errorcode != SQLITE_OK) {
1045                 TRACE_ERROR("[BIND] [%d] [%s]",
1046                         condtype, sqlite3_errmsg(g_dp_db_handle));
1047                 __dp_finalize(stmt);
1048                 return NULL;
1049         }
1050
1051         // WHERE id = ?
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);
1055                 return NULL;
1056         }
1057
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';
1066                 }
1067                 __dp_finalize(stmt);
1068                 return columntext;
1069         }
1070         __dp_finalize(stmt);
1071         return NULL;
1072 }
1073
1074 int dp_db_cond_remove(int id, char *table,
1075                                                 char *condcolumn, db_column_data_type condtype,
1076                                                 void *condvalue)
1077 {
1078         int errorcode = SQLITE_OK;
1079         int ret = -1;
1080         sqlite3_stmt *stmt = NULL;
1081         char *query_format = NULL;
1082         char *query = NULL;
1083
1084         if (id <= 0) {
1085                 TRACE_ERROR("[CHECK ID]");
1086                 return -1;
1087         }
1088
1089         if (!table) {
1090                 TRACE_ERROR("[CHECK TABLE NAME]");
1091                 return -1;
1092         }
1093
1094         if (!condcolumn) {
1095                 TRACE_ERROR("[CHECK COLUMN NAME]");
1096                 return -1;
1097         }
1098
1099         if (__dp_sql_open() < 0) {
1100                 TRACE_ERROR("__dp_sql_open[%s]", sqlite3_errmsg(g_dp_db_handle));
1101                 return -1;
1102         }
1103
1104         query_format = "DELETE FROM %s WHERE id = ? AND %s = ?";
1105
1106         query = sqlite3_mprintf(query_format, table, condcolumn);
1107         if (query == NULL) {
1108                 TRACE_ERROR("[CHECK COMBINE] [%s]", query_format);
1109                 return -1;
1110         }
1111
1112         TRACE_INFO("[QUERY] %s", query);
1113
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);
1119                 return -1;
1120         }
1121
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);
1129 #else
1130                 int *cast_value = condvalue;
1131                 errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1132 #endif
1133         } else if (condtype == DP_DB_COL_TYPE_TEXT) {
1134                 errorcode = sqlite3_bind_text(stmt, 2, (char*)condvalue, -1, NULL);
1135         } else {
1136                 TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
1137                 __dp_finalize(stmt);
1138                 return -1;
1139         }
1140         if (errorcode != SQLITE_OK) {
1141                 TRACE_ERROR("[BIND] [%d] [%s]",
1142                         condtype, sqlite3_errmsg(g_dp_db_handle));
1143                 __dp_finalize(stmt);
1144                 return -1;
1145         }
1146
1147         if (sqlite3_bind_int(stmt, 1, id)
1148                 != SQLITE_OK) {
1149                 TRACE_ERROR("sqlite3_bind_int[%s]",
1150                         sqlite3_errmsg(g_dp_db_handle));
1151                 __dp_finalize(stmt);
1152                 return -1;
1153         }
1154         errorcode = sqlite3_step(stmt);
1155         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
1156                 __dp_finalize(stmt);
1157                 return 0;
1158         }
1159         __dp_finalize(stmt);
1160         return -1;
1161 }
1162
1163 int dp_db_get_cond_rows_count(int id, char *table,
1164                                                 char *condcolumn, db_column_data_type condtype,
1165                                                 void *condvalue)
1166 {
1167         int errorcode = SQLITE_OK;
1168         int ret = -1;
1169         sqlite3_stmt *stmt = NULL;
1170         char *query = NULL;
1171
1172         if (id <= 0) {
1173                 TRACE_ERROR("[CHECK ID]");
1174                 return -1;
1175         }
1176
1177         if (!table) {
1178                 TRACE_ERROR("[CHECK TABLE NAME]");
1179                 return -1;
1180         }
1181
1182         if (__dp_sql_open() < 0) {
1183                 TRACE_ERROR("db_util_open is failed [%s]",
1184                         sqlite3_errmsg(g_dp_db_handle));
1185                 return -1;
1186         }
1187
1188         if (condcolumn)
1189                 query =
1190                         sqlite3_mprintf
1191                                 ("SELECT count(id) FROM %s WHERE id = ? AND %s = ?",
1192                                 table, condcolumn);
1193         else
1194                 query =
1195                         sqlite3_mprintf
1196                                 ("SELECT count(id) FROM %s WHERE id = ?", table);
1197
1198         if (query == NULL) {
1199                 TRACE_ERROR("[CHECK COMBINE]");
1200                 return -1;
1201         }
1202
1203         TRACE_INFO("[QUERY] %s", query);
1204
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);
1210                 return -1;
1211         }
1212
1213         if (condcolumn) {
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);
1221 #else
1222                         int *cast_value = condvalue;
1223                         errorcode = sqlite3_bind_int(stmt, 2, *cast_value);
1224 #endif
1225                 } else if (condtype == DP_DB_COL_TYPE_TEXT) {
1226                         errorcode = sqlite3_bind_text(stmt, 2, (char*)condvalue, -1, NULL);
1227                 } else {
1228                         TRACE_ERROR("[CHECK TYPE] Not Support [%d]", condtype);
1229                         __dp_finalize(stmt);
1230                         return -1;
1231                 }
1232                 if (errorcode != SQLITE_OK) {
1233                         TRACE_ERROR("[BIND] [%d] [%s]",
1234                                 condtype, sqlite3_errmsg(g_dp_db_handle));
1235                         __dp_finalize(stmt);
1236                         return -1;
1237                 }
1238         }
1239
1240         if (sqlite3_bind_int(stmt, 1, id)
1241                 != SQLITE_OK) {
1242                 TRACE_ERROR("sqlite3_bind_int[%s]",
1243                         sqlite3_errmsg(g_dp_db_handle));
1244                 __dp_finalize(stmt);
1245                 return -1;
1246         }
1247
1248         errorcode = sqlite3_step(stmt);
1249         if (errorcode == SQLITE_ROW) {
1250                 int count = sqlite3_column_int(stmt, 0);
1251                 __dp_finalize(stmt);
1252                 return count;
1253         }
1254         __dp_finalize(stmt);
1255         return 0;
1256 }
1257
1258 int dp_db_get_http_headers_list(int id, char **headers)
1259 {
1260         int errorcode = SQLITE_OK;
1261         int i = 0;
1262         int headers_index = 0;
1263         sqlite3_stmt *stmt = NULL;
1264
1265         if (id <= 0) {
1266                 TRACE_ERROR("[CHECK ID]");
1267                 return -1;
1268         }
1269
1270         if (__dp_sql_open() < 0) {
1271                 TRACE_ERROR("db_util_open is failed [%s]",
1272                         sqlite3_errmsg(g_dp_db_handle));
1273                 return -1;
1274         }
1275
1276         errorcode =
1277                 sqlite3_prepare_v2(g_dp_db_handle,
1278                         "SELECT header_field, header_data FROM httpheaders WHERE id = ?",
1279                         -1, &stmt, NULL);
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);
1284                 return -1;
1285         }
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);
1290                 return -1;
1291         }
1292
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));
1297                 i++;
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");
1303                         continue;
1304                 }
1305                 int len = snprintf(headers_buffer, buffer_length + 1,
1306                                 "%s:%s", header_field, header_data);
1307                 if (len <= 0) {
1308                         if (headers_buffer)
1309                                 free(headers_buffer);
1310                                 continue;
1311                 } else {
1312                         headers_buffer[len] = '\0';
1313                 }
1314                 headers[headers_index++] = headers_buffer;
1315         }
1316
1317         __dp_finalize(stmt);
1318         return headers_index;
1319 }