tg-engine-service/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 <stdio.h>
  20 #include <malloc.h>
  21 #include <errno.h>
  22 #include <string.h>
  23 #include "tg_db_manager.h"
  24 #include "tg_common.h"
  25 #include "tg_engine.h"
  26 #include "logger.h"
  27
  28 static const Eina_Bool is_use_persistent_db_open = EINA_FALSE;
  29
  30 static struct _info {
  31         sqlite3 *db;
  32 } tg_db_info = {
  33                 .db = NULL,
  34 };
  35
  36 sqlite3 *create_database()
  37 {
  38         int ret;
  39         sqlite3 *db = NULL;
  40         static char dbfile[PATH_MAX];
  41
  42         snprintf(dbfile, sizeof(dbfile), "%s" DB_FILENAME, app_get_data_path());
  43         if (is_use_persistent_db_open) {
  44                 if (tg_db_info.db)
  45                         return tg_db_info.db;
  46
  47                 ret = sqlite3_open(dbfile, &tg_db_info.db);
  48                 if (ret) {
  49                         LOGE("DB creation failed in the persistent connection");
  50                         return tg_db_info.db = NULL;
  51                 }
  52         } else {
  53                 ret = sqlite3_open(dbfile, &db);
  54                 sqlite3_busy_timeout(db, 3000);
  55                 if (ret) {
  56                         LOGE("DB creation failed");
  57                         return NULL;
  58                 }
  59         }
  60
  61         if (is_use_persistent_db_open)
  62                 return tg_db_info.db;
  63         else
  64                 return db;
  65 }
  66
  67 void close_database(sqlite3 *db)
  68 {
  69         if (!is_use_persistent_db_open)
  70                 if (db)
  71                         sqlite3_close(db);
  72 }
  73
  74 int tg_db_init(void)
  75 {
  76         if (is_use_persistent_db_open)
  77                 create_database();
  78         return EINA_TRUE;
  79 }
  80
  81 void tg_db_fini(void)
  82 {
  83         if (is_use_persistent_db_open) {
  84                 if (tg_db_info.db)
  85                         sqlite3_close(tg_db_info.db);
  86                 tg_db_info.db = NULL;
  87         }
  88 }
  89
  90 Eina_Bool create_table(const char *table_name, Eina_List *column_names, Eina_List *column_types)
  91 {
  92         if (!table_name || ! column_names || !column_types)
  93                 return EINA_FALSE;
  94
  95         sqlite3 *db = create_database();
  96         if (!db)
  97                 return EINA_FALSE;
  98
  99         int ret = 0 ;
 100         char *err_msg = 0;
 101         int col_count = eina_list_count(column_names);
 102
 103         Eina_Strbuf *var_query = eina_strbuf_new();
 104         if (!var_query) {
 105                 close_database(db);
 106                 return EINA_FALSE;
 107         }
 108
 109         eina_strbuf_append(var_query, "CREATE TABLE IF NOT EXISTS ");
 110         eina_strbuf_append(var_query, table_name);
 111         eina_strbuf_append(var_query, "(");
 112
 113         for(int col = 0; col < col_count ; col++) {
 114                 eina_strbuf_append_printf(var_query, "%s %s", eina_list_nth(column_names, col), eina_list_nth(column_types, col));
 115
 116                 if (col < col_count - 1)
 117                         eina_strbuf_append(var_query, ", ");
 118                 else
 119                         eina_strbuf_append(var_query, ");");
 120         }
 121
 122         ret = sqlite3_exec(db,eina_strbuf_string_get(var_query), NULL, NULL, &err_msg);
 123         close_database(db);
 124         eina_strbuf_free(var_query);
 125         if( ret != SQLITE_OK ){
 126                 LOGE("table cretion failed, %s", err_msg);
 127                 sqlite3_free(err_msg);
 128                 return EINA_FALSE;
 129         }
 130 }
 131
 132 Eina_Bool insert_table(const char *table_name, Eina_List *column_names, Eina_List *column_types, Eina_List *column_values)
 133 {
 134         if (!table_name || ! column_names || !column_types || !column_values)
 135                 return EINA_FALSE;
 136
 137         sqlite3 *db = create_database();
 138         if (!db)
 139                 return EINA_FALSE;
 140
 141         int ret = 0 ;
 142         char *err_msg = 0;
 143         int col_count = eina_list_count(column_names);
 144
 145         Eina_Strbuf *var_query = eina_strbuf_new();
 146         if (!var_query) {
 147                 close_database(db);
 148                 return EINA_FALSE;
 149         }
 150
 151         eina_strbuf_append(var_query, "INSERT INTO ");
 152         eina_strbuf_append(var_query, table_name);
 153         eina_strbuf_append(var_query, "(");
 154
 155         for (int col = 0; col < col_count; col++) {
 156
 157                 char *col_name = eina_list_nth(column_names, col);
 158                 eina_strbuf_append(var_query, col_name);
 159
 160                 if (col < col_count - 1)
 161                         eina_strbuf_append(var_query, ",");
 162                 else
 163                         eina_strbuf_append(var_query, ") VALUES (");
 164         }
 165
 166         int col_val_count = eina_list_count(column_names);
 167
 168         for (int col = 0; col < col_val_count; col++) {
 169
 170                 char *col_type = eina_list_nth(column_types, col);
 171                 if (!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 172
 173                         eina_strbuf_append_printf(var_query, "%d", *((int*)eina_list_nth(column_values, col)));
 174                 } else if (!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 175
 176                         char* escaped_text = replace(eina_list_nth(column_values, col), '\'', "''");
 177                         if (escaped_text) {
 178                                 eina_strbuf_append_printf(var_query, "'%s'", escaped_text);
 179                                 free(escaped_text);
 180                         }
 181                 }
 182
 183                 if (col < col_count - 1)
 184                         eina_strbuf_append(var_query, ", ");
 185                 else
 186                         eina_strbuf_append(var_query, ");");
 187         }
 188
 189         ret = sqlite3_exec(db, eina_strbuf_string_get(var_query), NULL, NULL, &err_msg);
 190         close_database(db);
 191         eina_strbuf_free(var_query);
 192         if (ret != SQLITE_OK) {
 193                 sqlite3_free(err_msg);
 194                 return EINA_FALSE;
 195         }
 196         return EINA_TRUE;
 197
 198 }
 199
 200
 201 Eina_Bool update_table(const char *table_name, Eina_List *column_names, Eina_List *column_types, Eina_List *column_values, const char *where_clause)
 202 {
 203         if (!table_name || ! column_names || !column_types || !column_values)
 204                 return EINA_FALSE;
 205
 206         sqlite3 *db = create_database();
 207         if (!db)
 208                 return EINA_FALSE;
 209
 210         int ret = 0 ;
 211         char *err_msg = 0;
 212         int col_count = eina_list_count(column_names);
 213
 214         Eina_Strbuf *var_query = eina_strbuf_new();
 215         if (!var_query) {
 216                 close_database(db);
 217                 return EINA_FALSE;
 218         }
 219
 220         eina_strbuf_append(var_query, "UPDATE ");
 221         eina_strbuf_append(var_query, table_name);
 222         eina_strbuf_append(var_query, " SET ");
 223
 224         int col_val_count = eina_list_count(column_values);
 225
 226         for(int col = 0; col < col_val_count ; col++) {
 227                 char* col_name = eina_list_nth(column_names, col);
 228                 char* col_type = eina_list_nth(column_types, col);
 229
 230                 if(!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 231
 232                         eina_strbuf_append_printf(var_query, "%s = %d", col_name, *((int*)eina_list_nth(column_values, col)));
 233
 234                 } else if(!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 235
 236                         char* escaped_text = replace(eina_list_nth(column_values, col), '\'', "''");
 237                         if (escaped_text) {
 238                                 eina_strbuf_append_printf(var_query, "%s = '%s'", col_name, escaped_text);
 239                                 free(escaped_text);
 240                         }
 241                 }
 242
 243                 if (col < col_count - 1)
 244                         eina_strbuf_append(var_query, ", ");
 245                 else
 246                         eina_strbuf_append(var_query, " ");
 247         }
 248
 249         eina_strbuf_append(var_query, " WHERE ");
 250         eina_strbuf_append(var_query, where_clause);
 251         eina_strbuf_append(var_query, "; ");
 252
 253         ret = sqlite3_exec(db, eina_strbuf_string_get(var_query), NULL, NULL, &err_msg);
 254
 255         close_database(db);
 256         eina_strbuf_free(var_query);
 257         if( ret != SQLITE_OK ){
 258                 sqlite3_free(err_msg);
 259                 return EINA_FALSE;
 260         }
 261         return EINA_TRUE;
 262 }
 263
 264 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)
 265 {
 266         if (!table_name)
 267                 return EINA_FALSE;
 268
 269         if (get_number_of_rows(table_name, NULL) == 0) {
 270                         DBG("There are no rows on [%s]", table_name);
 271                         return EINA_FALSE;
 272                 }
 273
 274                 sqlite3* db = create_database();
 275                 int ret = 0 ;
 276                 char* err_msg = 0;
 277
 278                 Eina_Strbuf *var_query = eina_strbuf_new();
 279                 if (!var_query) {
 280                         close_database(db);
 281                         return EINA_FALSE;
 282                 }
 283
 284                 eina_strbuf_append(var_query, "SELECT ");
 285
 286                 if(!column_names) {
 287                         var_query = realloc(var_query, strlen(var_query) + 3);
 288                         eina_strbuf_append(var_query, "* ");
 289                 } else {
 290
 291                         int col_count = eina_list_count(column_names);
 292                         char* col_name = NULL;
 293                         for(int col = 0; col < col_count ; col++) {
 294                                 eina_strbuf_append(var_query, eina_list_nth(column_names, col));
 295                                 if (col < col_count - 1)
 296                                         eina_strbuf_append(var_query, ", ");
 297                                 else
 298                                         eina_strbuf_append(var_query, " ");
 299                         }
 300                 }
 301
 302                 eina_strbuf_append(var_query, "FROM ");
 303                 eina_strbuf_append(var_query, table_name);
 304
 305                 if (where_clause) {
 306                         eina_strbuf_append(var_query, " WHERE ");
 307                         eina_strbuf_append(var_query, where_clause);
 308                 }
 309                 eina_strbuf_append(var_query, ";");
 310
 311                 ret = sqlite3_exec(db, eina_strbuf_string_get(var_query), callback,(void*)data_to_callback, &err_msg);
 312                 close_database(db);
 313                 eina_strbuf_free(var_query);
 314                 if( ret != SQLITE_OK ){
 315                         sqlite3_free(err_msg);
 316                         return EINA_FALSE;
 317                 }
 318                 return EINA_TRUE;
 319 }
 320
 321 Eina_List *get_values_from_table_sync(const char *table_name, Eina_List *column_names, Eina_List *column_types, const char *where_clause)
 322 {
 323         Eina_List *query_vals = NULL;
 324
 325         if (!table_name)
 326                 return (Eina_List *)NULL;
 327
 328         sqlite3 *db = create_database();
 329         if (!db)
 330                 return NULL;
 331         /*****No rows identification*****/
 332
 333         char *row_cnt_qry = (char *)malloc(strlen("SELECT COUNT(*) FROM ") + strlen(table_name) + strlen(";") +1);
 334         if (!row_cnt_qry) {
 335                 close_database(db);
 336                 return NULL;
 337         }
 338
 339         strcpy(row_cnt_qry, "SELECT COUNT(*) FROM ");
 340         strcat(row_cnt_qry, table_name);
 341         strcat(row_cnt_qry, ";");
 342
 343         int no_of_rows = 0;
 344         sqlite3_stmt *stmt;
 345         if (sqlite3_prepare_v2(db, row_cnt_qry, -1, &stmt, NULL) == SQLITE_OK) {
 346                 if (sqlite3_step(stmt) == SQLITE_ERROR)
 347                         no_of_rows = 0;
 348                 else
 349                         no_of_rows = sqlite3_column_int(stmt, 0);
 350
 351                 sqlite3_finalize(stmt);
 352         }
 353         close_database(db);
 354         db = NULL;
 355         free(row_cnt_qry);
 356         if (no_of_rows <= 0)
 357                 return (Eina_List *)NULL;
 358
 359         /********************************/
 360         db = create_database();
 361         if (!db)
 362                 return NULL;
 363
 364         int ret = 0 ;
 365         char *err_msg = 0;
 366         int str_len = strlen("SELECT ") + 1;
 367         char *var_query = (char*)malloc(str_len);
 368         if (!var_query) {
 369                 close_database(db);
 370                 return NULL;
 371         }
 372
 373         strcpy(var_query, "SELECT ");
 374         if (!column_names) {
 375                 var_query = realloc(var_query, strlen(var_query) + 3);
 376                 strcat(var_query, " *");
 377         } else {
 378
 379                 int col_count = eina_list_count(column_names);
 380                 char *col_name = NULL;
 381                 for (int col = 0; col < col_count; col++) {
 382                         col_name = eina_list_nth(column_names, col);
 383                         var_query = realloc(var_query, strlen(var_query)+strlen(col_name) + 1);
 384                         strcat(var_query, col_name);
 385                         col_name = NULL;
 386                         var_query = realloc(var_query, strlen(var_query)+strlen(" ") + 1);
 387
 388                         if (col < col_count - 1) {
 389                                 var_query = realloc(var_query, strlen(var_query) + 3);
 390                                 strcat(var_query, ", ");
 391                         } else {
 392                                 var_query = realloc(var_query, strlen(var_query) + 2);
 393                                 strcat(var_query, " ");
 394                         }
 395                 }
 396
 397         }
 398
 399         var_query = realloc(var_query, strlen(var_query) + strlen("FROM ") + 2);
 400         strcat(var_query, "FROM ");
 401         var_query = realloc(var_query, strlen(var_query) + strlen(table_name) + 1);
 402         strcat(var_query, table_name);
 403
 404         if (where_clause) {
 405                 var_query = realloc(var_query, strlen(var_query)+strlen(" WHERE ") + 1);
 406                 strcat(var_query, " WHERE ");
 407                 var_query = realloc(var_query, strlen(var_query)+strlen(where_clause) + 1);
 408                 strcat(var_query, where_clause);
 409         }
 410
 411         var_query = realloc(var_query, strlen(var_query) + 2);
 412         strcat(var_query, ";");
 413
 414
 415         ret = sqlite3_prepare_v2(db, var_query, -1, &stmt, 0);
 416         close_database(db);
 417         db = NULL;
 418         free(var_query);
 419         if (ret != SQLITE_OK) {
 420                 sqlite3_free(err_msg);
 421                 return NULL;
 422         }
 423
 424         while (sqlite3_step(stmt) == SQLITE_ROW) {
 425                 int col_val_count = eina_list_count(column_names);
 426                 Eina_List *row_vals = NULL;
 427                 for (int col = 0; col < col_val_count; col++) {
 428                         char *col_type = eina_list_nth(column_types, col);
 429                         if (!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 430                                 long long temp = sqlite3_column_int64(stmt, col);
 431                                 int *val_int = (int *)malloc(sizeof(int));
 432                                 *val_int = temp;
 433                                 row_vals = eina_list_append(row_vals, val_int);
 434                         } else if (!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 435                                 const char *text = (const char *)sqlite3_column_text(stmt, col);
 436                                 char *val_text;
 437
 438                                 val_text = strdup(text);
 439                                 if (!val_text) {
 440                                         /**
 441                                          *Handling me.
 442                                          */
 443                                 } else {
 444                                         row_vals = eina_list_append(row_vals, val_text);
 445                                 }
 446                         }
 447                 }
 448                 query_vals = eina_list_append(query_vals, row_vals);
 449         }
 450
 451         return query_vals;
 452 }
 453
 454 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)
 455 {
 456         Eina_List *query_vals = NULL;
 457
 458         if (!table_name)
 459                 return NULL;
 460
 461         sqlite3 *db = create_database();
 462         if (!db)
 463                 return NULL;
 464
 465         char *row_cnt_qry = (char*)malloc(strlen("SELECT COUNT(*) FROM ") + strlen(table_name) + strlen(";") +1);
 466         if (!row_cnt_qry) {
 467                 close_database(db);
 468                 return NULL;
 469         }
 470
 471         strcpy(row_cnt_qry, "SELECT COUNT(*) FROM ");
 472         strcat(row_cnt_qry, table_name);
 473         strcat(row_cnt_qry, ";");
 474
 475         int no_of_rows = 0;
 476         sqlite3_stmt *stmt;
 477         if (sqlite3_prepare_v2(db, row_cnt_qry, -1, &stmt, NULL) == SQLITE_OK) {
 478                 if (sqlite3_step(stmt) == SQLITE_ERROR)
 479                         no_of_rows = 0;
 480                 else
 481                         no_of_rows = sqlite3_column_int(stmt, 0);
 482
 483                 sqlite3_finalize(stmt);
 484         }
 485         close_database(db);
 486         free(row_cnt_qry);
 487         if (no_of_rows <= 0)
 488                 return NULL;
 489
 490         /********************************/
 491         db = create_database();
 492         if (!db)
 493                 return NULL;
 494         int ret = 0 ;
 495
 496         int str_len = strlen("SELECT ") + 1;
 497         char *var_query = (char*)malloc(str_len);
 498         if (!var_query) {
 499                 close_database(db);
 500                 return NULL;
 501         }
 502
 503         strcpy(var_query, "SELECT ");
 504         if (!column_names) {
 505                 var_query = realloc(var_query, strlen(var_query) + 3);
 506                 strcat(var_query, " *");
 507         } else {
 508
 509                 int col_count = eina_list_count(column_names);
 510                 char *col_name = NULL;
 511                 for (int col = 0; col < col_count; col++) {
 512                         col_name = eina_list_nth(column_names, col);
 513                         var_query = realloc(var_query, strlen(var_query)+strlen(col_name) + 1);
 514                         strcat(var_query, col_name);
 515                         col_name = NULL;
 516                         var_query = realloc(var_query, strlen(var_query)+strlen(" ") + 1);
 517
 518                         if (col < col_count - 1) {
 519                                 var_query = realloc(var_query, strlen(var_query) + 3);
 520                                 strcat(var_query, ", ");
 521                         } else {
 522                                 var_query = realloc(var_query, strlen(var_query) + 2);
 523                                 strcat(var_query, " ");
 524                         }
 525                 }
 526
 527         }
 528
 529         var_query = realloc(var_query, strlen(var_query) + strlen("FROM ") + 2);
 530         strcat(var_query, "FROM ");
 531         var_query = realloc(var_query, strlen(var_query) + strlen(table_name) + 1);
 532         strcat(var_query, table_name);
 533
 534         if (where_clause) {
 535                 var_query = realloc(var_query, strlen(var_query)+strlen(" WHERE ") + 1);
 536                 strcat(var_query, " WHERE ");
 537                 var_query = realloc(var_query, strlen(var_query)+strlen(where_clause) + 1);
 538                 strcat(var_query, where_clause);
 539         }
 540
 541         if (order_column) {
 542                 var_query = realloc(var_query, strlen(var_query)+strlen(" ORDER BY ") + 1);
 543                 strcat(var_query, " ORDER BY ");
 544                 var_query = realloc(var_query, strlen(var_query)+strlen(order_column) + 1);
 545                 strcat(var_query, order_column);
 546                 if (is_asc) {
 547                         var_query = realloc(var_query, strlen(var_query)+strlen(" ASC ") + 1);
 548                         strcat(var_query, " ASC ");
 549                 } else {
 550                         var_query = realloc(var_query, strlen(var_query)+strlen(" DESC ") + 1);
 551                         strcat(var_query, " DESC ");
 552                 }
 553         }
 554
 555
 556
 557         var_query = realloc(var_query, strlen(var_query) + 2);
 558         strcat(var_query, ";");
 559
 560         ret = sqlite3_prepare_v2(db, var_query, -1, &stmt, 0);
 561         close_database(db);
 562         free(var_query);
 563         if (ret != SQLITE_OK)
 564                 return NULL;
 565
 566         while (sqlite3_step(stmt) == SQLITE_ROW) {
 567                 int col_val_count = eina_list_count(column_names);
 568                 Eina_List *row_vals = NULL;
 569                 for (int col = 0; col < col_val_count; col++) {
 570                         char *col_type = eina_list_nth(column_types, col);
 571                         if (!strcmp(col_type, "INTEGER") || !strcmp(col_type, "INTEGER PRIMARY KEY NOT NULL")) {
 572                                 long long temp = sqlite3_column_int64(stmt, col);
 573                                 int *val_int = (int*)malloc(sizeof(int));
 574                                 *val_int = temp;
 575                                 row_vals = eina_list_append(row_vals, val_int);
 576                         } else if (!strcmp(col_type, "TEXT") || !strcmp(col_type, "TEXT PRIMARY KEY NOT NULL")) {
 577                                 char *val_text = strdup((const char *)sqlite3_column_text(stmt, col));
 578                                 row_vals = eina_list_append(row_vals, val_text);
 579                         }
 580                 }
 581                 query_vals = eina_list_append(query_vals, row_vals);
 582         }
 583         return query_vals;
 584 }
 585
 586 Eina_Bool delete_record(char *tablename, const char *where_clause)
 587 {
 588         if (!tablename)
 589                 return EINA_FALSE;
 590
 591         sqlite3 *db = create_database();
 592         if (!db)
 593                 return EINA_FALSE;
 594
 595         char *var_query = (char*)malloc(strlen("DELETE FROM ") + strlen(tablename) + 1);
 596         if (!var_query) {
 597                 close_database(db);
 598                 return EINA_FALSE;
 599         }
 600
 601         strcpy(var_query, "DELETE FROM ");
 602         strcat(var_query, tablename);
 603
 604         if (where_clause) {
 605                 var_query = realloc(var_query, strlen(var_query)+strlen(" WHERE ") + 1);
 606                 strcat(var_query, " WHERE ");
 607                 var_query = realloc(var_query, strlen(var_query)+strlen(where_clause) + 1);
 608                 strcat(var_query, where_clause);
 609         }
 610
 611         var_query = realloc(var_query, strlen(var_query) + 2);
 612         strcat(var_query, ";");
 613
 614         int ret;
 615         char *err_msg = 0;
 616         ret = sqlite3_exec(db, var_query, NULL, NULL, &err_msg);
 617         close_database(db);
 618         free(var_query);
 619         if (ret != SQLITE_OK) {
 620                 sqlite3_free(err_msg);
 621                 return EINA_FALSE;
 622         }
 623         return EINA_TRUE;
 624 }
 625
 626 Eina_Bool drop_table(char *tablename)
 627 {
 628         if (!tablename)
 629                 return EINA_FALSE;
 630
 631         sqlite3 *db = create_database();
 632         if (!db)
 633                 return EINA_FALSE;
 634
 635         char *var_query = (char*)malloc(strlen("DROP TABLE ") + strlen(tablename) + strlen(";") + 1);
 636         if (!var_query) {
 637                 close_database(db);
 638                 return EINA_FALSE;
 639         }
 640
 641         strcpy(var_query, "DROP TABLE ");
 642         strcat(var_query, tablename);
 643         strcat(var_query, ";");
 644         int ret;
 645         char *err_msg = 0;
 646         ret = sqlite3_exec(db, var_query, NULL, NULL, &err_msg);
 647         close_database(db);
 648         free(var_query);
 649         if (ret != SQLITE_OK) {
 650                 sqlite3_free(err_msg);
 651                 return EINA_FALSE;
 652         }
 653         return EINA_TRUE;
 654 }
 655
 656 int get_number_of_rows(char *table_name, char *where_clause)
 657 {
 658         int no_of_rows = 0;
 659         if (!table_name || !where_clause)
 660                 return no_of_rows;
 661
 662         sqlite3 *db = create_database();
 663         if (!db)
 664                 return EINA_FALSE;
 665
 666         char *row_cnt_qry = (char*)malloc(strlen("SELECT COUNT(*) FROM ") + strlen(table_name) + 1);
 667         if (!row_cnt_qry) {
 668                 close_database(db);
 669                 return EINA_FALSE;
 670         }
 671
 672         strcpy(row_cnt_qry, "SELECT COUNT(*) FROM ");
 673         strcat(row_cnt_qry, table_name);
 674
 675         if (where_clause) {
 676                 row_cnt_qry = realloc(row_cnt_qry, strlen(row_cnt_qry)+strlen(" WHERE ") + 1);
 677                 strcat(row_cnt_qry, " WHERE ");
 678                 row_cnt_qry = realloc(row_cnt_qry, strlen(row_cnt_qry)+strlen(where_clause) + 1);
 679                 strcat(row_cnt_qry, where_clause);
 680         }
 681         row_cnt_qry = realloc(row_cnt_qry, strlen(row_cnt_qry) + 2);
 682         strcat(row_cnt_qry, ";");
 683
 684         sqlite3_stmt *stmt;
 685         if (sqlite3_prepare_v2(db, row_cnt_qry, -1, &stmt, NULL) == SQLITE_OK) {
 686                 if (sqlite3_step(stmt) == SQLITE_ERROR)
 687                         no_of_rows = 0;
 688                 else
 689                         no_of_rows = sqlite3_column_int(stmt, 0);
 690                 sqlite3_finalize(stmt);
 691         }
 692         close_database(db);
 693         free(row_cnt_qry);
 694         return no_of_rows;
 695 }