TelegramTizen/db_manager/tg_db_manager.c

   1 /*
   2     This file is part of Telegram application for tizen
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Lesser General Public
   6     License as published by the Free Software Foundation; either
   7     version 2.1 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Lesser General Public License for more details.
  13
  14     You should have received a copy of the GNU Lesser General Public
  15     License along with this library; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19 #include "tg_db_manager.h"
  20 #include <malloc.h>
  21 #include <errno.h>
  22 #include <string.h>
  23 #include "tg_common.h"
  24
  25
  26 sqlite3* create_database(void)
  27 {
  28         int ret;
  29         sqlite3 *db;
  30         char *dbfile;
  31         int dbfile_len;
  32
  33         dbfile_len = strlen(app_get_data_path()) + strlen(DB_FILENAME) + 1;
  34
  35         dbfile = malloc(dbfile_len + 1);
  36         snprintf(dbfile, dbfile_len, "%s" DB_FILENAME, app_get_data_path());
  37
  38         ret = sqlite3_open(dbfile, &db);
  39
  40         free(dbfile);
  41
  42         sqlite3_busy_timeout(db, 3000);
  43         //ret = sqlite3_open_v2(database_name, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
  44         if(ret) {
  45                 return NULL;
  46         }
  47         return db;
  48 }
  49
  50 Eina_Bool close_database(sqlite3* db)
  51 {
  52         if(db) {
  53                 sqlite3_close(db);
  54                 return EINA_TRUE;
  55         }
  56         return EINA_FALSE;
  57 }
  58
  59 Eina_Bool create_table(const char* table_name, Eina_List *column_names, Eina_List *column_types)
  60 {
  61         if(!table_name || ! column_names || !column_types) {
  62                 return EINA_FALSE;
  63         }
  64         sqlite3* db = create_database();
  65         int ret = 0 ;
  66         char* err_msg = 0;
  67         int col_count = eina_list_count(column_names);
  68
  69         Eina_Strbuf *var_query = eina_strbuf_new();
  70         if (!var_query) {
  71                 close_database(db);
  72                 return EINA_FALSE;
  73         }
  74
  75         eina_strbuf_append(var_query, "CREATE TABLE IF NOT EXISTS ");
  76         eina_strbuf_append(var_query, table_name);
  77         eina_strbuf_append(var_query, "(");
  78
  79         for(int col = 0; col < col_count ; col++) {
  80                 eina_strbuf_append_printf(var_query, "%s %s", eina_list_nth(column_names, col), eina_list_nth(column_types, col));
  81
  82                 if (col < col_count - 1)
  83                         eina_strbuf_append(var_query, ", ");
  84                 else
  85                         eina_strbuf_append(var_query, ");");
  86         }
  87
  88         ret = sqlite3_exec(db,eina_strbuf_string_get(var_query), NULL, NULL, &err_msg);
  89         close_database(db);
  90         eina_strbuf_free(var_query);
  91         if( ret != SQLITE_OK ){
  92                 LOGE("table cretion failed, %s", err_msg);
  93                 sqlite3_free(err_msg);
  94                 return EINA_FALSE;
  95         }
  96         return EINA_TRUE;
  97 }
  98
  99 Eina_Bool insert_table(const char* table_name, Eina_List *column_names, Eina_List *column_types, Eina_List *column_values)
 100 {
 101         if( !table_name || ! column_names || !column_types || !column_values)
 102                 return EINA_FALSE;
 103
 104         sqlite3* db = create_database();
 105         int ret = 0 ;
 106         char* err_msg = 0;
 107         int col_count = eina_list_count(column_names);
 108         Eina_Strbuf *var_query = eina_strbuf_new();
 109         if (!var_query) {
 110                 close_database(db);
 111                 return EINA_FALSE;
 112         }
 113
 114         eina_strbuf_append(var_query, "INSERT INTO ");
 115         eina_strbuf_append(var_query, table_name);
 116         eina_strbuf_append(var_query, "(");
 117
 118         for(int col = 0; col < col_count ; col++) {
 119
 120                 char *col_name = eina_list_nth(column_names, col);
 121                 eina_strbuf_append(var_query, col_name);
 122
 123                 if (col < col_count - 1)
 124                         eina_strbuf_append(var_query, ",");
 125                 else
 126                         eina_strbuf_append(var_query, ") VALUES (");
 127         }
 128
 129         int col_val_count = eina_list_count(column_values);
 130
 131         for(int col = 0; col < col_val_count ; col++) {
 132
 133                 char *col_type = eina_list_nth(column_types, col);
 134                 if (!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 135
 136                         eina_strbuf_append_printf(var_query, "%d", *((int*)eina_list_nth(column_values, col)));
 137                 } else if (!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 138
 139                         char* escaped_text = replace(eina_list_nth(column_values, col), '\'', "''");
 140                         if (escaped_text) {
 141                                 eina_strbuf_append_printf(var_query, "'%s'", escaped_text);
 142                                 free(escaped_text);
 143                         }
 144                 }
 145
 146                 if (col < col_count - 1)
 147                         eina_strbuf_append(var_query, ", ");
 148                 else
 149                         eina_strbuf_append(var_query, ");");
 150         }
 151
 152         ret = sqlite3_exec(db,eina_strbuf_string_get(var_query), NULL, NULL, &err_msg);
 153         close_database(db);
 154         eina_strbuf_free(var_query);
 155         if ( ret != SQLITE_OK ) {
 156                 sqlite3_free(err_msg);
 157                 return EINA_FALSE;
 158         }
 159         return EINA_TRUE;
 160 }
 161
 162
 163 Eina_Bool update_table(const char* table_name, Eina_List *column_names, Eina_List *column_types, Eina_List *column_values, const char* where_clause)
 164 {
 165         if(!table_name || ! column_names || !column_types || !column_values) {
 166                 return EINA_FALSE;
 167         }
 168         sqlite3* db = create_database();
 169         int ret = 0 ;
 170         char* err_msg = 0;
 171         int col_count = eina_list_count(column_names);
 172
 173         Eina_Strbuf *var_query = eina_strbuf_new();
 174         if (!var_query) {
 175                 close_database(db);
 176                 return EINA_FALSE;
 177         }
 178
 179         eina_strbuf_append(var_query, "UPDATE ");
 180         eina_strbuf_append(var_query, table_name);
 181         eina_strbuf_append(var_query, " SET ");
 182
 183         int col_val_count = eina_list_count(column_values);
 184
 185         for(int col = 0; col < col_val_count ; col++) {
 186                 char* col_name = eina_list_nth(column_names, col);
 187                 char* col_type = eina_list_nth(column_types, col);
 188
 189                 if(!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 190
 191                         eina_strbuf_append_printf(var_query, "%s = %d", col_name, *((int*)eina_list_nth(column_values, col)));
 192
 193                 } else if(!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 194
 195                         char* escaped_text = replace(eina_list_nth(column_values, col), '\'', "''");
 196                         if (escaped_text) {
 197                                 eina_strbuf_append_printf(var_query, "%s = '%s'", col_name, escaped_text);
 198                                 free(escaped_text);
 199                         }
 200                 }
 201
 202                 if (col < col_count - 1)
 203                         eina_strbuf_append(var_query, ", ");
 204                 else
 205                         eina_strbuf_append(var_query, " ");
 206         }
 207
 208         eina_strbuf_append(var_query, "WHERE ");
 209         eina_strbuf_append(var_query, where_clause);
 210         eina_strbuf_append(var_query, ";");
 211
 212         ret = sqlite3_exec(db, eina_strbuf_string_get(var_query), NULL, NULL, &err_msg);
 213
 214         close_database(db);
 215         eina_strbuf_free(var_query);
 216         if( ret != SQLITE_OK ){
 217                 sqlite3_free(err_msg);
 218                 return EINA_FALSE;
 219         }
 220         return EINA_TRUE;
 221
 222 }
 223
 224 Eina_Bool create_index(const char* table_name, const char *column_name)
 225 {
 226         if (table_name == NULL || column_name == NULL) {
 227                 ERR("Invalid Parameter");
 228                 return EINA_FALSE;
 229         }
 230
 231         char* err_msg = 0;
 232         char *query_format = "CREATE INDEX tg_index_%s_%s ON %s (%s);";
 233         char *query_string = NULL;
 234         int   query_length = strlen(query_format) + strlen(table_name) + (strlen(column_name) * 2) + 20;
 235         int   ret;
 236         Eina_Bool result = EINA_FALSE;
 237
 238         query_string = malloc(query_length);
 239
 240         if (query_string == NULL) {
 241                 ERR("malloc failed");
 242                 return EINA_FALSE;
 243         }
 244
 245         snprintf(query_string, query_length, query_format, table_name, column_name, table_name, column_name);
 246
 247         sqlite3* db = create_database();
 248
 249         if (db == NULL) {
 250                 ERR("open failed");
 251                 goto CLEAN_UP;
 252         }
 253
 254         ret = sqlite3_exec(db, query_string, NULL, NULL, &err_msg);
 255
 256         if (ret != SQLITE_OK) {
 257                 DBG("sqlite3_exec failed [%d][%s]", ret, err_msg);
 258                 goto CLEAN_UP;
 259         }
 260
 261         result = EINA_TRUE;
 262
 263 CLEAN_UP:
 264         if (query_string)
 265                 free(query_string);
 266
 267         if (db)
 268                 close_database(db);
 269
 270         return result;
 271
 272 }
 273
 274 Eina_Bool get_values_from_table(const char* table_name, Eina_List *column_names, int (*callback)(void*,int,char**,char**), const char* where_clause, void* data_to_callback)
 275 {
 276         if (!table_name) {
 277                 return EINA_FALSE;
 278         }
 279
 280         if (get_number_of_rows(table_name, NULL) == 0) {
 281                 DBG("There are no rows on [%s]", table_name);
 282                 return EINA_FALSE;
 283         }
 284
 285         sqlite3* db = create_database();
 286         int ret = 0 ;
 287         char* err_msg = 0;
 288
 289         Eina_Strbuf *var_query = eina_strbuf_new();
 290         if (!var_query) {
 291                 close_database(db);
 292                 return EINA_FALSE;
 293         }
 294
 295         eina_strbuf_append(var_query, "SELECT ");
 296
 297         if(!column_names) {
 298                 var_query = realloc(var_query, strlen(var_query) + 3);
 299                 eina_strbuf_append(var_query, "* ");
 300         } else {
 301
 302                 int col_count = eina_list_count(column_names);
 303                 char* col_name = NULL;
 304                 for(int col = 0; col < col_count ; col++) {
 305                         eina_strbuf_append(var_query, eina_list_nth(column_names, col));
 306                         if (col < col_count - 1)
 307                                 eina_strbuf_append(var_query, ", ");
 308                         else
 309                                 eina_strbuf_append(var_query, " ");
 310                 }
 311         }
 312
 313         eina_strbuf_append(var_query, "FROM ");
 314         eina_strbuf_append(var_query, table_name);
 315
 316         if (where_clause) {
 317                 eina_strbuf_append(var_query, " WHERE ");
 318                 eina_strbuf_append(var_query, where_clause);
 319         }
 320         eina_strbuf_append(var_query, ";");
 321
 322         ret = sqlite3_exec(db, eina_strbuf_string_get(var_query), callback,(void*)data_to_callback, &err_msg);
 323         close_database(db);
 324         eina_strbuf_free(var_query);
 325         if( ret != SQLITE_OK ){
 326                 sqlite3_free(err_msg);
 327                 return EINA_FALSE;
 328         }
 329         return EINA_TRUE;
 330 }
 331
 332 int get_number_of_rows(const char* table_name, char* where_clause)
 333 {
 334         int no_of_rows = 0;
 335         if (!table_name) {
 336                 return no_of_rows;
 337         }
 338         sqlite3* db = create_database();
 339         char* row_cnt_qry = (char *)malloc(strlen("SELECT COUNT(*) FROM ") + strlen(table_name) + 1);
 340         strcpy(row_cnt_qry, "SELECT COUNT(*) FROM ");
 341         strcat(row_cnt_qry, table_name);
 342
 343         if (where_clause) {
 344                 row_cnt_qry = realloc(row_cnt_qry, strlen(row_cnt_qry)+strlen(" WHERE ") + 1);
 345                 strcat(row_cnt_qry, " WHERE ");
 346                 row_cnt_qry = realloc(row_cnt_qry, strlen(row_cnt_qry)+strlen(where_clause) + 1);
 347                 strcat(row_cnt_qry, where_clause);
 348         }
 349         row_cnt_qry = realloc(row_cnt_qry, strlen(row_cnt_qry) + 2);
 350         strcat(row_cnt_qry, ";");
 351
 352         sqlite3_stmt *stmt;
 353         if (sqlite3_prepare_v2(db, row_cnt_qry, -1, &stmt, NULL) == SQLITE_OK) {
 354                 if (sqlite3_step(stmt) == SQLITE_ERROR) {
 355                         no_of_rows = 0;
 356                 } else {
 357                         no_of_rows = sqlite3_column_int(stmt, 0);
 358                 }
 359                 sqlite3_finalize(stmt);
 360         }
 361         close_database(db);
 362         free(row_cnt_qry);
 363         return no_of_rows;
 364 }
 365
 366 Eina_List *get_values_from_table_sync_order_by(const char* table_name, Eina_List *column_names, Eina_List *column_types, const char* order_column, Eina_Bool is_asc, const char* where_clause, unsigned int limit, unsigned int offset)
 367 {
 368         Eina_List *query_vals = NULL;
 369
 370         if (!table_name)
 371                 return NULL;
 372
 373         /*****No rows identification*****/
 374         if (get_number_of_rows(table_name, NULL) == 0) {
 375                 DBG("There are no rows on [%s]", table_name);
 376                 return NULL;
 377         }
 378
 379         /********************************/
 380         sqlite3_stmt *stmt;
 381         sqlite3* db =  create_database();
 382         int ret = 0 ;
 383         char* err_msg = 0;
 384         //int col_count = eina_list_count(column_names);
 385
 386         int str_len = strlen("SELECT ") + 1;
 387         char* var_query = (char *)malloc(str_len);
 388         strcpy(var_query,"SELECT ");
 389         if(!column_names) {
 390                 var_query = realloc(var_query, strlen(var_query) + 3);
 391                 strcat(var_query, "* ");
 392         } else {
 393
 394                 int col_count = eina_list_count(column_names);
 395                 char* col_name = NULL;
 396                 for(int col = 0; col < col_count ; col++) {
 397                         col_name = eina_list_nth(column_names, col);
 398                         var_query = realloc(var_query, strlen(var_query)+strlen(col_name) + 1);
 399                         strcat(var_query, col_name);
 400                         col_name = NULL;
 401                         var_query = realloc(var_query, strlen(var_query)+strlen(" ") + 1);
 402
 403                         if(col < col_count - 1){
 404                                 var_query = realloc(var_query, strlen(var_query) + 3);
 405                                 strcat(var_query, ", ");
 406                         } else {
 407                                 var_query = realloc(var_query, strlen(var_query) + 2);
 408                                 strcat(var_query, " ");
 409                         }
 410                 }
 411
 412         }
 413
 414         var_query = realloc(var_query, strlen(var_query) + strlen("FROM ") + 2);
 415         strcat(var_query, "FROM ");
 416         var_query = realloc(var_query, strlen(var_query) + strlen(table_name) + 1);
 417         strcat(var_query, table_name);
 418
 419         if (where_clause) {
 420                 var_query = realloc(var_query, strlen(var_query)+strlen(" WHERE ") + 1);
 421                 strcat(var_query, " WHERE ");
 422                 var_query = realloc(var_query, strlen(var_query)+strlen(where_clause) + 1);
 423                 strcat(var_query, where_clause);
 424         }
 425
 426         if (order_column) {
 427                 var_query = realloc(var_query, strlen(var_query)+strlen(" ORDER BY ") + 1);
 428                 strcat(var_query, " ORDER BY ");
 429                 var_query = realloc(var_query, strlen(var_query)+strlen(order_column) + 1);
 430                 strcat(var_query, order_column);
 431
 432                 if (strcmp(order_column, "date") != 0) {
 433                         /* If the order column is INTEGER type, removing COLLATE NOCASE and creating index make better performance
 434                            Case 1: SELECT * from tg_9595_msg ORDER BY date COLLATE NOCASE ASC LIMIT 1000 OFFSET 0;
 435                            Run Time: real 1.582
 436                            Case 2: SELECT * from tg_9595_msg ORDER BY date ASC LIMIT 1000 OFFSET 0; + CREATE INDEX msg_idx_date ON tg_9595_msg (date);
 437                            Run Time: real 1.067 */
 438                         var_query = realloc(var_query, strlen(var_query)+strlen(" COLLATE NOCASE ") + 1);
 439                         strcat(var_query, " COLLATE NOCASE ");
 440                 }
 441
 442                 if (is_asc) {
 443                         var_query = realloc(var_query, strlen(var_query)+strlen(" ASC ") + 1);
 444                         strcat(var_query, " ASC ");
 445                 } else {
 446                         var_query = realloc(var_query, strlen(var_query)+strlen(" DESC ") + 1);
 447                         strcat(var_query, " DESC ");
 448                 }
 449         }
 450
 451         if (limit != TG_DBMGR_NOLIMITED) {
 452                 if (limit > 4000000000 && offset > 4000000000) {
 453                         /* too big size to handle. ignore */
 454                 }
 455                 else {
 456                         char limit_clause[50] = { 0, };
 457                         snprintf(limit_clause, 50, " LIMIT %d OFFSET %d ", limit, offset);
 458                         var_query = realloc(var_query, strlen(var_query) + strlen(limit_clause) + 1);
 459                         strcat(var_query, limit_clause);
 460                 }
 461         }
 462
 463         var_query = realloc(var_query, strlen(var_query) + 2);
 464         strcat(var_query, ";");
 465
 466
 467         ret = sqlite3_prepare_v2(db, var_query, -1, &stmt, 0);
 468         free(var_query);
 469         var_query = NULL;
 470         if( ret != SQLITE_OK ){
 471                 sqlite3_free(err_msg);
 472                 return NULL;
 473         }
 474
 475         while(sqlite3_step(stmt) == SQLITE_ROW) {
 476                 int col_val_count = eina_list_count(column_names);
 477                 Eina_List *row_vals = NULL;
 478                 for(int col = 0; col < col_val_count ; col++) {
 479                         char* col_type = eina_list_nth(column_types, col);
 480                         if(!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 481                                 long long temp = sqlite3_column_int64(stmt, col);
 482                                 int* val_int = (int *)malloc(sizeof(int));
 483                                 *val_int = temp;
 484                                 row_vals = eina_list_append(row_vals, val_int);
 485                         } else if(!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 486                                 char *temp_val = (char *)sqlite3_column_text(stmt, col);
 487                                 char *val_text = NULL;
 488                                 if (temp_val) {
 489                                         val_text = strdup(temp_val);
 490                                 } else {
 491                                         val_text = strdup("");
 492                                 }
 493                                 row_vals = eina_list_append(row_vals, val_text);
 494                         }
 495                 }
 496                 query_vals = eina_list_append(query_vals, row_vals);
 497         }
 498     close_database(db);
 499         return query_vals;
 500
 501 }
 502
 503 Eina_List *get_values_from_table_sync(const char* table_name, Eina_List *column_names, Eina_List *column_types, const char* wc, unsigned int limit, unsigned int offset)
 504 {
 505         return get_values_from_table_sync_order_by(table_name, column_names, column_types, NULL, EINA_FALSE, wc, limit, offset);
 506 }
 507
 508
 509 int tg_db_init(void)
 510 {
 511 #if 0
 512         int ret;
 513
 514         if (s_info.db) {
 515                 LOGD("Already initialized");
 516                 return EINA_TRUE;
 517         }
 518
 519         ret = sqlite3_open(s_info.database_name, &s_info.db);
 520         if(ret != SQLITE_OK) {
 521                 return EINA_FALSE;
 522         }
 523 #endif
 524         return EINA_TRUE;
 525
 526 }
 527
 528 int tg_db_fini(void)
 529 {
 530 #if 0
 531         if (!s_info.db) {
 532                 return EINA_FALSE;
 533         }
 534
 535         sqlite3_close(s_info.db);
 536         s_info.db = NULL;
 537 #endif
 538         return EINA_TRUE;
 539 }
 540
 541
 542 Eina_List *tg_db_get_user_info(tgl_peer_id_t *user_id)
 543 {
 544         user_data_s *info;
 545         Eina_List *result;
 546         sqlite3_stmt *stmt;
 547         int ret;
 548         const char *val_text;
 549         sqlite3* db = create_database();
 550         ret = sqlite3_prepare_v2(db, "SELECT " \
 551                                 "print_name, structure_version, " \
 552                                 "photo_path, photo_id, " \
 553                                 "first_name, last_name, " \
 554                                 "phone, access_hash, " \
 555                                 "real_first_name, real_last_name, " \
 556                                 "username, online, last_seen " \
 557                                 "FROM user_info_table WHERE user_id = ?", -1, &stmt, NULL);
 558         if (ret != SQLITE_OK) {
 559                 return NULL;
 560         }
 561
 562         ret = sqlite3_bind_int(stmt, 1, user_id->id);
 563         if (ret != SQLITE_OK) {
 564                 sqlite3_finalize(stmt);
 565                 return NULL;
 566         }
 567
 568         result = NULL;
 569         while (sqlite3_step(stmt) == SQLITE_ROW) {
 570                 info = calloc(1, sizeof(*info));
 571                 if (!info) {
 572                         /**
 573                          * @todo
 574                          * Handling the OOM
 575                          */
 576                         LOGE("calloc: %d", errno);
 577                         continue;
 578                 }
 579
 580                 val_text = (const char *)sqlite3_column_text(stmt, 0);
 581                 if (val_text && val_text[0] != '\0') {
 582                         info->print_name = strdup(val_text);
 583                         if (!info->print_name) {
 584                                 LOGE("strdup: %d", errno);
 585                         }
 586                 }
 587
 588                 info->structure_version = sqlite3_column_int(stmt, 1);
 589                 val_text = (const char *)sqlite3_column_text(stmt, 2);
 590                 if (val_text && val_text[0] != '\0') {
 591                         info->photo_path = strdup(val_text);
 592                         if (!info->photo_path) {
 593                                 LOGE("strdup: %d", errno);
 594                         }
 595                 }
 596
 597                 info->photo_id = sqlite3_column_int(stmt, 3);
 598
 599                 val_text = (const char *)sqlite3_column_text(stmt, 4);
 600                 if (val_text && val_text[0] != '\0') {
 601                         info->first_name = strdup(val_text);
 602                         if (!info->first_name) {
 603                                 LOGE("strdup: %d", errno);
 604                         }
 605                 }
 606
 607                 val_text = (const char *)sqlite3_column_text(stmt, 5);
 608                 if (val_text && val_text[0] != '\0') {
 609                         info->last_name = strdup(val_text);
 610                         if (!info->last_name) {
 611                                 LOGE("strdup: %d", errno);
 612                         }
 613                 }
 614
 615                 val_text = (const char *)sqlite3_column_text(stmt, 6);
 616                 if (val_text && val_text[0] != '\0') {
 617                         info->phone = strdup(val_text);
 618                         if (!info->phone) {
 619                                 LOGE("strdup: %d", errno);
 620                         }
 621                 }
 622
 623                 info->access_hash = sqlite3_column_int(stmt, 7);
 624
 625                 val_text = (const char *)sqlite3_column_text(stmt, 8);
 626                 if (val_text && val_text[0] != '\0') {
 627                         info->real_first_name = strdup(val_text);
 628                         if (!info->real_first_name) {
 629                                 LOGE("strdup: %d", errno);
 630                         }
 631                 }
 632
 633                 val_text = (const char *)sqlite3_column_text(stmt, 9);
 634                 if (val_text && val_text[0] != '\0') {
 635                         info->real_last_name = strdup(val_text);
 636                         if (!info->real_last_name) {
 637                                 LOGE("strdup: %d", errno);
 638                         }
 639                 }
 640
 641                 val_text = (const char *)sqlite3_column_text(stmt, 10);
 642                 if (val_text && val_text[0] != '\0') {
 643                         info->username = strdup(val_text);
 644                         if (!info->username) {
 645                                 LOGE("strdup: %d", errno);
 646                         }
 647                 }
 648
 649                 info->online = sqlite3_column_int(stmt, 11);
 650                 info->last_seen = sqlite3_column_int(stmt, 12);
 651
 652                 memcpy(&info->user_id, user_id, sizeof(*user_id));
 653
 654                 result = eina_list_append(result, info);
 655         }
 656         close_database(db);
 657         sqlite3_finalize(stmt);
 658         return result;
 659 }
 660
 661 Eina_List *tg_db_get_chat_info(const char *table_name)
 662 {
 663         Eina_List *result = NULL;
 664         tg_chat_info_s *info;
 665         sqlite3_stmt *stmt;
 666         const char *tmp;
 667         int ret;
 668         sqlite3* db = create_database();
 669         ret = sqlite3_prepare_v2(db, "SELECT chat_id, " \
 670                         "flags, print_title, struct_version, " \
 671                         "photo_id, photo_path, " \
 672                         "title, " \
 673                         "users_num, user_list_size, user_list_version, " \
 674                         "inviter_id, chat_users, date, version, admin_id FROM ?", -1, &stmt, NULL);
 675
 676         if (ret != SQLITE_OK) {
 677                 LOGE("Failed to create a stmt");
 678                 return NULL;
 679         }
 680
 681         ret = sqlite3_bind_text(stmt, 1, table_name, -1, SQLITE_TRANSIENT);
 682         if (ret != SQLITE_OK) {
 683                 LOGE("Failed to bind a text");
 684                 return NULL;
 685         }
 686
 687         while (sqlite3_step(stmt) == SQLITE_ROW) {
 688                 info = calloc(1, sizeof(*info));
 689                 if (!info) {
 690                         LOGE("calloc: %d", errno);
 691                         continue;
 692                 }
 693                 info->chat_id = sqlite3_column_int(stmt, 0);
 694                 info->flags = sqlite3_column_int(stmt, 1);
 695                 tmp = (const char *)sqlite3_column_text(stmt, 2);
 696                 if (tmp && tmp[0] != '\0') {
 697                         info->print_title = strdup(tmp);
 698                         if (!info->print_title) {
 699                                 LOGE("strdup: %d", errno);
 700                         }
 701                 }
 702                 info->struct_version = sqlite3_column_int(stmt, 3);
 703                 info->photo_id = sqlite3_column_int64(stmt, 4);
 704                 tmp = (const char *)sqlite3_column_text(stmt, 5);
 705                 if (tmp && tmp[0] != '\0') {
 706                         info->photo_path = strdup(tmp);
 707                         if (!info->photo_path) {
 708                                 LOGE("strdup: %d", errno);
 709                         }
 710                 }
 711                 tmp = (const char *)sqlite3_column_text(stmt, 6);
 712                 if (tmp && tmp[0] != '\0') {
 713                         info->title = strdup(tmp);
 714                         if (!info->title) {
 715                                 LOGE("strdup: %d", errno);
 716                         }
 717                 }
 718                 info->users_num = sqlite3_column_int(stmt, 7);
 719                 info->user_list_size = sqlite3_column_int(stmt, 8);
 720                 info->user_list_version = sqlite3_column_int(stmt, 9);
 721                 info->inviter_id = sqlite3_column_int(stmt, 10);
 722
 723                 tmp = (const char *)sqlite3_column_text(stmt, 11);
 724                 if (tmp && tmp[0] != '\0') {
 725                         char *ptr;
 726
 727                         ptr = strdup(tmp);
 728                         if (ptr) {
 729                                 char *tmp_ptr;
 730                                 int i;
 731
 732                                 for (i = 0; i < info->users_num && *ptr && i < (sizeof(info->chat_users) / sizeof(int)); i++) {
 733                                         tmp_ptr = ptr;
 734
 735                                         while (*tmp_ptr != ',' && *tmp_ptr != '\0') {
 736                                                 tmp_ptr++;
 737                                         }
 738                                         *tmp_ptr = '\0';
 739
 740                                         info->chat_users[i] = atoi(ptr);
 741                                         ptr = tmp_ptr + 1;
 742                                 }
 743
 744                                 if (i != info->users_num) {
 745                                         /**
 746                                          * There is some problem.
 747                                          * The count of loaded user is not correct.
 748                                          * Fix it forcely.
 749                                          */
 750                                         LOGD("Update user_num: %d -> %d", info->users_num, i);
 751                                         info->users_num = i;
 752                                 }
 753
 754                                 free(ptr);
 755                         }
 756                 }
 757
 758                 info->date = sqlite3_column_int(stmt, 12);
 759                 info->version = sqlite3_column_int(stmt, 13);
 760                 info->admin_id = sqlite3_column_int(stmt, 14);
 761                 result = eina_list_append(result, info);
 762         }
 763
 764         sqlite3_finalize(stmt);
 765         close_database(db);
 766         return result;
 767 }
 768
 769 tg_peer_info_s *tg_db_get_peer_info(const char *table, int peer_id)
 770 {
 771         tg_peer_info_s *info;
 772         sqlite3_stmt *stmt;
 773         const char *tmp;
 774         int ret;
 775         sqlite3* db = create_database();
 776         ret = sqlite3_prepare_v2(db, "SELECT peer_type, flags, last_msg_id, last_msg_date, print_name, struct_version, no_of_unread_msgs, last_seen_time, photo_path, photo_id FROM ? WHERE peer_id = ?", -1, &stmt, NULL);
 777         if (ret != SQLITE_OK) {
 778                 return NULL;
 779         }
 780
 781         ret = sqlite3_bind_text(stmt, 1, table, -1, SQLITE_TRANSIENT);
 782         if (ret != SQLITE_OK) {
 783                 sqlite3_finalize(stmt);
 784                 return NULL;
 785         }
 786
 787         ret = sqlite3_bind_int(stmt, 2, peer_id);
 788         if (ret != SQLITE_OK) {
 789                 sqlite3_finalize(stmt);
 790                 return NULL;
 791         }
 792
 793         if (sqlite3_step(stmt) != SQLITE_ROW) {
 794                 sqlite3_finalize(stmt);
 795                 return NULL;
 796         }
 797
 798         info = calloc(1, sizeof(*info));
 799         if (!info) {
 800                 sqlite3_finalize(stmt);
 801                 return NULL;
 802         }
 803
 804         info->peer_id = peer_id;
 805         info->peer_type = sqlite3_column_int(stmt, 0);
 806         info->flags = sqlite3_column_int(stmt, 1);
 807         info->last_msg_id = sqlite3_column_int64(stmt, 2);
 808         info->last_msg_date = sqlite3_column_int(stmt, 3);
 809         tmp = (const char *)sqlite3_column_text(stmt, 4);
 810         if (tmp && tmp[0] != '\0') {
 811                 info->print_name = strdup(tmp);
 812                 if (!info->print_name) {
 813                         LOGE("strdup: %d", errno);
 814                 }
 815         }
 816         info->struct_version = sqlite3_column_int(stmt, 5);
 817         info->no_of_unread_msgs = sqlite3_column_int(stmt, 6);
 818         info->last_seen_time = sqlite3_column_int(stmt, 7);
 819
 820         tmp = (const char *)sqlite3_column_text(stmt, 8);
 821         if (tmp && tmp[0] != '\0') {
 822                 info->photo_path = strdup(tmp);
 823                 if (!info->photo_path) {
 824                         LOGE("strdup: %d\n", errno);
 825                 }
 826         }
 827
 828         info->photo_id = sqlite3_column_int64(stmt, 9);
 829
 830         sqlite3_finalize(stmt);
 831         close_database(db);
 832         return info;
 833 }
 834
 835 Eina_List *tg_db_get_messages(const char *table_name)
 836 {
 837         Eina_List *result;
 838         tg_message_s *info;
 839         sqlite3_stmt *stmt;
 840         const char *tmp;
 841         int ret;
 842         sqlite3* db = create_database();
 843         ret = sqlite3_prepare_v2(db, "SELECT msg_id, flags, fwd_from_id, fwd_date, from_id, to_id, out, unread, date, service, message, msg_state, message_len, media_type, media_id, unique_id FROM ?", -1, &stmt, NULL);
 844         if (ret != SQLITE_OK) {
 845                 return NULL;
 846         }
 847
 848         ret = sqlite3_bind_text(stmt, 1, table_name, -1, SQLITE_TRANSIENT);
 849         if (ret != SQLITE_OK) {
 850                 sqlite3_finalize(stmt);
 851                 return NULL;
 852         }
 853
 854         result = NULL;
 855         while (sqlite3_step(stmt) == SQLITE_OK) {
 856                 info = calloc(1, sizeof(*info));
 857                 if (!info) {
 858                         LOGE("calloc: %d", errno);
 859                         continue;
 860                 }
 861
 862                 info->msg_id = sqlite3_column_int(stmt, 0);
 863                 info->flags = sqlite3_column_int(stmt, 1);
 864                 info->fwd_from_id = sqlite3_column_int(stmt, 2);
 865                 info->fwd_date = sqlite3_column_int(stmt, 3);
 866                 info->from_id = sqlite3_column_int(stmt, 4);
 867                 info->to_id = sqlite3_column_int(stmt, 5);
 868                 info->out = sqlite3_column_int(stmt, 6);
 869                 info->unread = sqlite3_column_int(stmt, 7);
 870                 info->date = sqlite3_column_int(stmt, 8);
 871                 info->service = sqlite3_column_int(stmt, 9);
 872                 tmp = (const char *)sqlite3_column_text(stmt, 10);
 873                 if (tmp && tmp[0] != '\0') {
 874                         info->message = strdup(tmp);
 875                         if (!info->message) {
 876                                 LOGE("strdup: %d", errno);
 877                         }
 878                 }
 879                 info->msg_state = sqlite3_column_int(stmt, 11);
 880                 info->message_len = sqlite3_column_int(stmt, 12);
 881                 info->media_type = sqlite3_column_int(stmt, 13);
 882                 tmp = (const char *)sqlite3_column_text(stmt, 14);
 883                 if (tmp && tmp[0] != '\0') {
 884                         info->media_id = strdup(tmp);
 885                         if (!info->media_id) {
 886                                 LOGE("strdup: %d", errno);
 887                         }
 888                 }
 889                 info->unique_id = sqlite3_column_int(stmt, 15);
 890                 result = eina_list_append(result, info);
 891
 892         }
 893         sqlite3_finalize(stmt);
 894         close_database(db);
 895         return result;
 896 }
 897
 898 Eina_Bool delete_all_records(char *tablename)
 899 {
 900         if (!tablename) {
 901                 return EINA_FALSE;
 902         }
 903         char *var_query = (char *)malloc(strlen("DELETE FROM ") + strlen(tablename) + strlen(";") + 1);
 904         strcpy(var_query, "DELETE FROM ");
 905         strcat(var_query, tablename);
 906         strcat(var_query, ";");
 907         int ret;
 908         char* err_msg = 0;
 909         sqlite3* db = create_database();
 910         ret = sqlite3_exec(db,var_query, NULL, NULL, &err_msg);
 911         close_database(db);
 912         free(var_query);
 913         if( ret != SQLITE_OK ){
 914                 sqlite3_free(err_msg);
 915                 return EINA_FALSE;
 916         }
 917         return EINA_TRUE;
 918 }