server/ctsvc_server_sqlite.c

   1 /*
   2  * Contacts Service
   3  *
   4  * Copyright (c) 2010 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19 #include <unistd.h>
  20 #include <string.h>
  21 #include <db-util.h>
  22 #include <fcntl.h>
  23
  24 #include "ctsvc_internal.h"
  25 #include "contacts.h"
  26 #include "ctsvc_db_schema.h"
  27 #include "ctsvc_db_sqlite.h"
  28 #include "ctsvc_notify.h"
  29 #include "ctsvc_inotify.h"
  30 #include "ctsvc_server_setting.h"
  31 #include "ctsvc_normalize.h"
  32 #include "ctsvc_localize.h"
  33 #include "ctsvc_localize_utils.h"
  34 #include "ctsvc_localize_ch.h"
  35 #include "ctsvc_server_utils.h"
  36 #include "ctsvc_number_utils.h"
  37 #include "ctsvc_server_change_subject.h"
  38
  39 #include "ctsvc_notification.h"
  40 #include "ctsvc_db_query.h"
  41 #include "ctsvc_db_plugin_image_helper.h"
  42 #include "ctsvc_db_plugin_company_helper.h"
  43 #include "ctsvc_db_plugin_group_helper.h"
  44 #include "ctsvc_db_plugin_contact_helper.h"
  45
  46 #include "ctsvc_server_person.h"
  47
  48 #ifdef ENABLE_LOG_FEATURE
  49 #include "ctsvc_server_phonelog.h"
  50 #endif /* ENABLE_LOG_FEATURE */
  51
  52 #define SORT_NAME_UPDATE_BULK_COUNT 100
  53
  54 static sqlite3 *server_db;
  55
  56 /* LCOV_EXCL_START */
  57 int ctsvc_server_db_open(sqlite3 **db, int *sqlite_error)
  58 {
  59         CTS_FN_CALL;
  60         int ret;
  61
  62         if (NULL == server_db) {
  63                 do {
  64                         ret = db_util_open(CTSVC_DB_PATH, &server_db, 0);
  65                         if (ret != SQLITE_OK || NULL == server_db) {
  66                                 ERR("db_util_open() Fail(%d), server_db(%s)", ret, sqlite3_errmsg(server_db));
  67                                 break;
  68                         }
  69
  70                         ret = sqlite3_create_function(server_db, "_DATA_DELETE_", 2, SQLITE_UTF8, NULL,
  71                                         ctsvc_db_data_delete_callback, NULL, NULL);
  72                         if (SQLITE_OK != ret) {
  73                                 ERR("sqlite3_create_function() Fail(%d)", ret);
  74                                 break;
  75                         }
  76
  77                         ret = sqlite3_create_function(server_db, "_DATA_IMAGE_DELETE_", 1, SQLITE_UTF8, NULL,
  78                                         ctsvc_db_image_delete_callback, NULL, NULL);
  79                         if (SQLITE_OK != ret) {
  80                                 ERR("sqlite3_create_function() Fail(%d)", ret);
  81                                 break;
  82                         }
  83
  84                         ret = sqlite3_create_function(server_db, "_DATA_COMPANY_DELETE_", 1, SQLITE_UTF8, NULL,
  85                                         ctsvc_db_company_delete_callback, NULL, NULL);
  86                         if (SQLITE_OK != ret) {
  87                                 ERR("sqlite3_create_function() Fail(%d)", ret);
  88                                 break;
  89                         }
  90
  91 #ifdef ENABLE_LOG_FEATURE
  92                         ret = sqlite3_create_function(server_db, "_PHONE_LOG_DELETE_", 1, SQLITE_UTF8, NULL,
  93                                         ctsvc_db_phone_log_delete_callback, NULL, NULL);
  94                         if (SQLITE_OK != ret) {
  95                                 ERR("sqlite3_create_function() Fail(%d)", ret);
  96                                 break;
  97                         }
  98 #endif /* ENABLE_LOG_FEATURE */
  99
 100                         ret = sqlite3_create_function(server_db, "_PERSON_DELETE_", 1, SQLITE_UTF8, NULL,
 101                                         ctsvc_db_person_delete_callback, NULL, NULL);
 102                         if (SQLITE_OK != ret) {
 103                                 ERR("sqlite3_create_function() Fail(%d)", ret);
 104                                 break;
 105                         }
 106
 107                         ret = sqlite3_create_function(server_db, "_GROUP_DELETE_", 1, SQLITE_UTF8, NULL,
 108                                         ctsvc_db_group_delete_callback, NULL, NULL);
 109                         if (SQLITE_OK != ret) {
 110                                 ERR("sqlite3_create_function() Fail(%d)", ret);
 111                                 break;
 112                         }
 113
 114                         ret = sqlite3_create_function(server_db, "_NUMBER_COMPARE_", 4, SQLITE_UTF8, NULL,
 115                                         ctsvc_db_phone_number_equal_callback, NULL, NULL);
 116                         if (SQLITE_OK != ret) {
 117                                 ERR("sqlite3_create_function() Fail(%d)", ret);
 118                                 break;
 119                         }
 120
 121                         ret = sqlite3_create_collation(server_db, "_NAME_SORT_", SQLITE_UTF8, (void *)SQLITE_UTF8,
 122                                         ctsvc_db_group_name_sort_callback);
 123                         if (SQLITE_OK != ret) {
 124                                 ERR("sqlite3_create_collation() Fail(%d)", ret);
 125                                 break;
 126                         }
 127                 } while (0);
 128
 129                 if (ret != SQLITE_OK || NULL == server_db) {
 130                         if (sqlite_error)
 131                                 *sqlite_error = ret;
 132                         return CONTACTS_ERROR_DB;
 133                 }
 134         }
 135
 136         if (db)
 137                 *db = server_db;
 138         return CONTACTS_ERROR_NONE;
 139 }
 140
 141 int ctsvc_server_db_close(void)
 142 {
 143         if (server_db) {
 144                 db_util_close(server_db);
 145                 server_db = NULL;
 146         }
 147
 148         return CONTACTS_ERROR_NONE;
 149 }
 150
 151 int ctsvc_server_begin_trans(void)
 152 {
 153         int ret = -1;
 154
 155         ret = sqlite3_exec(server_db, "BEGIN IMMEDIATE TRANSACTION",
 156                         NULL, NULL, NULL);
 157
 158         while (SQLITE_BUSY == ret) {
 159                 sleep(1);
 160                 ret = sqlite3_exec(server_db, "BEGIN IMMEDIATE TRANSACTION",
 161                                 NULL, NULL, NULL);
 162         }
 163
 164         if (SQLITE_OK != ret) {
 165                 /* LCOV_EXCL_START */
 166                 ERR("sqlite3_exec() Fail(%d)", ret);
 167                 return CONTACTS_ERROR_DB;
 168                 /* LCOV_EXCL_STOP */
 169         }
 170         return CONTACTS_ERROR_NONE;
 171 }
 172
 173 #define CTS_COMMIT_TRY_MAX 5
 174 int ctsvc_server_end_trans(bool success)
 175 {
 176         int ret = -1, i = 0;
 177         char *errmsg = NULL;
 178
 179         if (success) {
 180                 do {
 181                         ret = sqlite3_exec(server_db, "COMMIT TRANSACTION",
 182                                         NULL, NULL, &errmsg);
 183                         if (SQLITE_OK != ret) {
 184                                 ERR("sqlite3_exec(COMMIT) Fail(%d, %s)", ret, errmsg);
 185                                 sqlite3_free(errmsg);
 186                                 i++;
 187                                 sleep(1);
 188                         } else {
 189                                 INFO("commit end");
 190                                 return CONTACTS_ERROR_NONE;
 191                         }
 192                 } while ((SQLITE_BUSY == ret || SQLITE_LOCKED == ret) && i < CTS_COMMIT_TRY_MAX);
 193
 194                 ERR("Commit error : %d", ret);
 195         }
 196
 197         i = 0;
 198         do {
 199                 ret = sqlite3_exec(server_db, "ROLLBACK TRANSACTION",
 200                                 NULL, NULL, &errmsg);
 201                 if (SQLITE_OK != ret) {
 202                         ERR("sqlite3_exec(ROLLBACK) Fail(%d, %s)", ret, errmsg);
 203                         sqlite3_free(errmsg);
 204                         i++;
 205                         sleep(1);
 206                 }
 207         } while ((SQLITE_BUSY == ret || SQLITE_LOCKED == ret) && i < CTS_COMMIT_TRY_MAX);
 208
 209         if (SQLITE_OK != ret) {
 210                 /* LCOV_EXCL_START */
 211                 ERR("sqlite3_exec(ROLLBACK) Fail(%d) : DB lock", ret);
 212                 return CONTACTS_ERROR_DB;
 213                 /* LCOV_EXCL_STOP */
 214         } else {
 215                 INFO("rollback end");
 216                 return CONTACTS_ERROR_NONE;
 217         }
 218 }
 219
 220 int ctsvc_server_update_sort(int prev_sort_primary, int prev_sort_secondary, int new_sort_primary, int new_sort_secondary)
 221 {
 222         CTS_FN_CALL;
 223         int ret;
 224         sqlite3 *db = NULL;
 225         char *errmsg = NULL;
 226         char query[CTS_SQL_MIN_LEN] = {0};
 227
 228         ret = ctsvc_server_db_open(&db, NULL);
 229         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_server_db_open() Fail(%d)", ret);
 230
 231         ret = ctsvc_server_begin_trans();
 232         RETVM_IF(ret, ret, "ctsvc_server_begin_trans() Fail(%d)", ret);
 233
 234         snprintf(query, sizeof(query), "UPDATE %s SET display_name_language=%d WHERE display_name_language =%d",
 235                         CTS_TABLE_CONTACTS, prev_sort_primary, CTSVC_SORT_PRIMARY);
 236         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 237         if (SQLITE_OK != ret) {
 238                 /* LCOV_EXCL_START */
 239                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 240                 sqlite3_free(errmsg);
 241                 ctsvc_server_end_trans(false);
 242                 ctsvc_server_db_close();
 243                 return CONTACTS_ERROR_DB;
 244                 /* LCOV_EXCL_STOP */
 245         }
 246
 247         snprintf(query, sizeof(query), "UPDATE %s SET display_name_language=%d WHERE display_name_language = %d",
 248                         CTS_TABLE_CONTACTS, prev_sort_secondary, CTSVC_SORT_SECONDARY);
 249         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 250         if (SQLITE_OK != ret) {
 251                 /* LCOV_EXCL_START */
 252                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 253                 sqlite3_free(errmsg);
 254                 ctsvc_server_end_trans(false);
 255                 ctsvc_server_db_close();
 256                 return CONTACTS_ERROR_DB;
 257                 /* LCOV_EXCL_STOP */
 258         }
 259
 260         snprintf(query, sizeof(query), "UPDATE %s SET display_name_language=%d WHERE display_name_language=%d",
 261                         CTS_TABLE_CONTACTS, CTSVC_SORT_PRIMARY, new_sort_primary);
 262         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 263         if (SQLITE_OK != ret) {
 264                 /* LCOV_EXCL_START */
 265                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 266                 sqlite3_free(errmsg);
 267                 ctsvc_server_end_trans(false);
 268                 ctsvc_server_db_close();
 269                 return CONTACTS_ERROR_DB;
 270                 /* LCOV_EXCL_STOP */
 271         }
 272
 273         snprintf(query, sizeof(query), "UPDATE %s SET display_name_language=%d WHERE display_name_language =%d",
 274                         CTS_TABLE_CONTACTS, CTSVC_SORT_SECONDARY, new_sort_secondary);
 275         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 276         if (SQLITE_OK != ret) {
 277                 /* LCOV_EXCL_START */
 278                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 279                 sqlite3_free(errmsg);
 280                 ctsvc_server_end_trans(false);
 281                 ctsvc_server_db_close();
 282                 return CONTACTS_ERROR_DB;
 283                 /* LCOV_EXCL_STOP */
 284         }
 285
 286         snprintf(query, sizeof(query), "UPDATE %s SET reverse_display_name_language=%d WHERE reverse_display_name_language = %d",
 287                         CTS_TABLE_CONTACTS, prev_sort_primary, CTSVC_SORT_PRIMARY);
 288         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 289         if (SQLITE_OK != ret) {
 290                 /* LCOV_EXCL_START */
 291                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 292                 sqlite3_free(errmsg);
 293                 ctsvc_server_end_trans(false);
 294                 ctsvc_server_db_close();
 295                 return CONTACTS_ERROR_DB;
 296                 /* LCOV_EXCL_STOP */
 297         }
 298
 299         snprintf(query, sizeof(query), "UPDATE %s SET reverse_display_name_language=%d WHERE reverse_display_name_language = %d",
 300                         CTS_TABLE_CONTACTS, prev_sort_secondary, CTSVC_SORT_SECONDARY);
 301         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 302         if (SQLITE_OK != ret) {
 303                 /* LCOV_EXCL_START */
 304                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 305                 sqlite3_free(errmsg);
 306                 ctsvc_server_end_trans(false);
 307                 ctsvc_server_db_close();
 308                 return CONTACTS_ERROR_DB;
 309                 /* LCOV_EXCL_STOP */
 310         }
 311
 312         snprintf(query, sizeof(query), "UPDATE %s SET reverse_display_name_language=%d WHERE reverse_display_name_language = %d",
 313                         CTS_TABLE_CONTACTS, CTSVC_SORT_PRIMARY, new_sort_primary);
 314         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 315         if (SQLITE_OK != ret) {
 316                 /* LCOV_EXCL_START */
 317                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 318                 sqlite3_free(errmsg);
 319                 ctsvc_server_end_trans(false);
 320                 ctsvc_server_db_close();
 321                 return CONTACTS_ERROR_DB;
 322                 /* LCOV_EXCL_STOP */
 323         }
 324
 325         snprintf(query, sizeof(query), "UPDATE %s SET reverse_display_name_language=%d WHERE reverse_display_name_language = %d",
 326                         CTS_TABLE_CONTACTS, CTSVC_SORT_SECONDARY, new_sort_secondary);
 327         ret = sqlite3_exec(db, query, NULL, NULL, &errmsg);
 328         if (SQLITE_OK != ret) {
 329                 /* LCOV_EXCL_START */
 330                 ERR("sqlite3_exec(%s) Fail(%d, %s)", query, ret, errmsg);
 331                 sqlite3_free(errmsg);
 332                 ctsvc_server_end_trans(false);
 333                 ctsvc_server_db_close();
 334                 return CONTACTS_ERROR_DB;
 335                 /* LCOV_EXCL_STOP */
 336         }
 337
 338         ret = ctsvc_server_set_default_sort(new_sort_primary);
 339         if (CONTACTS_ERROR_NONE != ret) {
 340                 ctsvc_server_end_trans(false);
 341                 ctsvc_server_db_close();
 342                 return ret;
 343         }
 344         ret = ctsvc_server_end_trans(true);
 345
 346         /* person noti */
 347 #if 0
 348         if (CONTACTS_ERROR_NONE == ret) {
 349                 int fd = open(CTSVC_NOTI_PERSON_CHANGED, O_TRUNC | O_RDWR);
 350                 if (0 <= fd)
 351                         close(fd);
 352         }
 353 #endif
 354         ctsvc_server_db_close();
 355
 356         return ret;
 357 }
 358
 359 int ctsvc_server_insert_sdn_contact(const char *name, const char *number,
 360                 int sim_slot_no)
 361 {
 362         int ret;
 363         sqlite3 *db = NULL;
 364         sqlite3_stmt *stmt = NULL;
 365         char query[CTS_SQL_MIN_LEN] = {0};
 366
 367         ret = ctsvc_server_db_open(&db, NULL);
 368         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_server_db_open() Fail(%d)", ret);
 369
 370         snprintf(query, sizeof(query), "INSERT INTO %s(name, number, sim_slot_no) VALUES(?, ?, ?)",
 371                         CTS_TABLE_SDN);
 372
 373         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 374         if (SQLITE_OK != ret) {
 375                 /* LCOV_EXCL_START */
 376                 ERR("sqlite3_prepare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 377                 ctsvc_server_db_close();
 378                 return CONTACTS_ERROR_DB;
 379                 /* LCOV_EXCL_STOP */
 380         }
 381
 382         sqlite3_bind_text(stmt, 1, name, strlen(name), SQLITE_STATIC);
 383         sqlite3_bind_text(stmt, 2, number, strlen(number), SQLITE_STATIC);
 384         sqlite3_bind_int(stmt, 3, sim_slot_no);
 385
 386         ret = sqlite3_step(stmt);
 387         if (SQLITE_DONE != ret) {
 388                 /* LCOV_EXCL_START */
 389                 ERR("sqlite3_step() Fail(%d)", ret);
 390                 sqlite3_finalize(stmt);
 391                 ctsvc_server_db_close();
 392                 return CONTACTS_ERROR_DB;
 393                 /* LCOV_EXCL_STOP */
 394         }
 395         sqlite3_finalize(stmt);
 396         ctsvc_server_db_close();
 397
 398         return CONTACTS_ERROR_NONE;
 399 }
 400
 401 int ctsvc_server_delete_sdn_contact(int sim_slot_no)
 402 {
 403         int ret;
 404         sqlite3 *db = NULL;
 405         sqlite3_stmt *stmt = NULL;
 406         char query[CTS_SQL_MAX_LEN] = {0};
 407
 408         ret = ctsvc_server_db_open(&db, NULL);
 409         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "helper_db_open() Fail(%d)", ret);
 410
 411         if (sim_slot_no < 0)
 412                 snprintf(query, sizeof(query), "DELETE FROM %s", CTS_TABLE_SDN);
 413         else
 414                 snprintf(query, sizeof(query), "DELETE FROM %s WHERE sim_slot_no = %d", CTS_TABLE_SDN, sim_slot_no);
 415
 416         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 417         if (SQLITE_OK != ret) {
 418                 /* LCOV_EXCL_START */
 419                 ERR("sqlite3_prepare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 420                 ctsvc_server_db_close();
 421                 return CONTACTS_ERROR_DB;
 422                 /* LCOV_EXCL_STOP */
 423         }
 424         ret = sqlite3_step(stmt);
 425         if (SQLITE_DONE != ret) {
 426                 /* LCOV_EXCL_START */
 427                 ERR("sqlite3_step() Fail(%d)", ret);
 428                 sqlite3_finalize(stmt);
 429                 ctsvc_server_db_close();
 430                 return CONTACTS_ERROR_DB;
 431                 /* LCOV_EXCL_STOP */
 432         }
 433         sqlite3_finalize(stmt);
 434
 435         ctsvc_server_db_close();
 436         return CONTACTS_ERROR_NONE;
 437 }
 438
 439 int ctsvc_server_update_collation()
 440 {
 441         int ret = 0;
 442         sqlite3 *db = NULL;
 443         cts_stmt stmt = NULL;
 444         cts_stmt update_stmt = NULL;
 445         char query[CTS_SQL_MIN_LEN] = {0};
 446
 447         ctsvc_db_set_status(CONTACTS_DB_STATUS_CHANGING_COLLATION);
 448
 449         ret = ctsvc_server_db_open(&db, NULL);
 450         if (CONTACTS_ERROR_NONE != ret) {
 451                 /* LCOV_EXCL_START */
 452                 ERR("ctsvc_server_db_open() Fail(%d)", ret);
 453                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 454                 return ret;
 455                 /* LCOV_EXCL_STOP */
 456         }
 457
 458         ret = ctsvc_server_begin_trans();
 459         if (CONTACTS_ERROR_NONE != ret) {
 460                 /* LCOV_EXCL_START */
 461                 ERR("ctsvc_server_begin_trans() Fail(%d)", ret);
 462                 ctsvc_server_db_close();
 463                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 464                 return ret;
 465                 /* LCOV_EXCL_STOP */
 466         }
 467
 468         snprintf(query, sizeof(query),
 469                         "SELECT contact_id, sort_name, reverse_sort_name "
 470                         "FROM "CTS_TABLE_CONTACTS" WHERE deleted = 0");
 471         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 472         if (SQLITE_OK != ret) {
 473                 /* LCOV_EXCL_START */
 474                 ERR("sqlite3_prepare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 475                 ctsvc_server_end_trans(false);
 476                 ctsvc_server_db_close();
 477                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 478                 return CONTACTS_ERROR_DB;
 479                 /* LCOV_EXCL_STOP */
 480         }
 481
 482         snprintf(query, sizeof(query),
 483                         "UPDATE "CTS_TABLE_CONTACTS" SET sortkey=?, reverse_sortkey=? "
 484                         "WHERE contact_id = ?");
 485         ret = sqlite3_prepare_v2(db, query, strlen(query), &update_stmt, NULL);
 486         if (SQLITE_OK != ret) {
 487                 /* LCOV_EXCL_START */
 488                 ERR("sqlite3_prepare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 489                 sqlite3_finalize(stmt);
 490                 ctsvc_server_end_trans(false);
 491                 ctsvc_server_db_close();
 492                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 493                 return CONTACTS_ERROR_DB;
 494                 /* LCOV_EXCL_STOP */
 495         }
 496
 497         while (SQLITE_ROW == (ret = sqlite3_step(stmt))) {
 498                 int contact_id = sqlite3_column_int(stmt, 0);
 499                 char *sort_name = (char*)sqlite3_column_text(stmt, 1);
 500                 char *reverse_sort_name = (char*)sqlite3_column_text(stmt, 2);
 501                 char *sortkey = NULL;
 502                 char *reverse_sortkey = NULL;
 503
 504                 if (sort_name) {
 505                         ret = ctsvc_collation_str(sort_name, &sortkey);
 506                         if (CONTACTS_ERROR_NONE == ret && sortkey)
 507                                 sqlite3_bind_text(update_stmt, 1, sortkey, strlen(sortkey), SQLITE_STATIC);
 508                 }
 509
 510                 if (reverse_sort_name) {
 511                         ret = ctsvc_collation_str(reverse_sort_name, &reverse_sortkey);
 512                         if (CONTACTS_ERROR_NONE == ret && reverse_sortkey)
 513                                 sqlite3_bind_text(update_stmt, 2, reverse_sortkey, strlen(reverse_sortkey), SQLITE_STATIC);
 514                 }
 515
 516                 sqlite3_bind_int(update_stmt, 3, contact_id);
 517
 518                 ret = sqlite3_step(update_stmt);
 519
 520                 free(sortkey);
 521                 free(reverse_sortkey);
 522
 523                 if (SQLITE_DONE != ret) {
 524                         /* LCOV_EXCL_START */
 525                         ERR("sqlite3_step(%s) Fail(%d, %s)", query, ret, sqlite3_errmsg(db));
 526                         sqlite3_finalize(stmt);
 527                         sqlite3_finalize(update_stmt);
 528                         ctsvc_server_end_trans(false);
 529                         ctsvc_server_db_close();
 530                         ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 531                         return CONTACTS_ERROR_DB;
 532                         /* LCOV_EXCL_STOP */
 533                 }
 534
 535                 sqlite3_reset(update_stmt);
 536
 537         }
 538
 539         if (SQLITE_ROW != ret && SQLITE_DONE != ret) {
 540                 /* LCOV_EXCL_START */
 541                 ERR("sqlite3_step() Fail(%d)", ret);
 542                 sqlite3_finalize(update_stmt);
 543                 sqlite3_finalize(stmt);
 544                 ctsvc_server_end_trans(false);
 545                 ctsvc_server_db_close();
 546                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 547                 return CONTACTS_ERROR_DB;
 548                 /* LCOV_EXCL_STOP */
 549         }
 550
 551         sqlite3_finalize(update_stmt);
 552         sqlite3_finalize(stmt);
 553
 554         ret = ctsvc_server_end_trans(true);
 555         if (CONTACTS_ERROR_NONE == ret) {
 556                 int fd;
 557                 char *path = ctsvc_inotify_makepath(CTSVC_NOTI_CONTACT_CHANGED);
 558                 if (NULL != path) {
 559                         fd = open(path, O_TRUNC | O_RDWR);
 560                         if (0 <= fd)
 561                                 close(fd);
 562                 } else {
 563                         ERR("ctsvc_inotify_makepath() fail");
 564                 }
 565                 free(path);
 566
 567                 path = ctsvc_inotify_makepath(CTSVC_NOTI_PERSON_CHANGED);
 568                 if (NULL != path) {
 569                         fd = open(path, O_TRUNC | O_RDWR);
 570                         if (0 <= fd)
 571                                 close(fd);
 572                 } else {
 573                         ERR("ctsvc_inotify_makepath() fail");
 574                 }
 575                 free(path);
 576         }
 577         ctsvc_server_db_close();
 578
 579         ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 580
 581         return ret;
 582 }
 583
 584 int ctsvc_server_get_sim_id(const char *unique_id, int *sim_id)
 585 {
 586         int ret;
 587         int id;
 588         char query[CTS_SQL_MAX_LEN] = {0};
 589
 590         *sim_id = 0;
 591         RETV_IF(unique_id == NULL, CONTACTS_ERROR_INVALID_PARAMETER);
 592
 593         snprintf(query, sizeof(query),
 594                         "SELECT sim_id FROM "CTS_TABLE_SIM_INFO" "
 595                         "WHERE unique_id = '%s'", unique_id);
 596         ret = ctsvc_query_get_first_int_result(query, &id);
 597         if (CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret) {
 598                 /* LCOV_EXCL_START */
 599                 ERR("ctsvc_query_get_first_int_result() Fail(%d)", ret);
 600                 return ret;
 601                 /* LCOV_EXCL_STOP */
 602         }
 603
 604         if (CONTACTS_ERROR_NO_DATA == ret) {
 605                 snprintf(query, sizeof(query),
 606                                 "INSERT INTO "CTS_TABLE_SIM_INFO" (unique_id) VALUES('%s')", unique_id);
 607                 ret = ctsvc_query_exec(query);
 608                 if (ret != CONTACTS_ERROR_NONE) {
 609                         /* LCOV_EXCL_START */
 610                         ERR("ctsvc_query_exec() Fail(%d)", ret);
 611                         return ret;
 612                         /* LCOV_EXCL_STOP */
 613                 }
 614                 id = ctsvc_db_get_last_insert_id();
 615         }
 616         DBG("id :%d, unique_id :%s", id, unique_id);
 617         *sim_id = id;
 618
 619         return CONTACTS_ERROR_NONE;
 620
 621 }
 622
 623 static int __ctsvc_server_db_get_contact_data(sqlite3 *db, int id, ctsvc_contact_s *contact)
 624 {
 625         int ret;
 626         int datatype;
 627         cts_stmt stmt = NULL;
 628         char query[CTS_SQL_MAX_LEN] = {0};
 629
 630         snprintf(query, sizeof(query),
 631                         "SELECT datatype, id, data.contact_id, is_default, data1, data2, "
 632                         "data3, data4, data5, data6, data7, data8, data9, data10, data11, data12 "
 633                         "FROM "CTS_TABLE_DATA", "CTSVC_DB_VIEW_CONTACT" "
 634                         "ON "CTS_TABLE_DATA".contact_id = "CTSVC_DB_VIEW_CONTACT".contact_id "
 635                         "WHERE data.contact_id = %d  AND is_my_profile = 0 "
 636                         "ORDER BY is_default DESC", id);
 637         ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 638         RETVM_IF(SQLITE_OK != ret, ret, "sqlite3_prepare_v2() Fail(%d)", ret);
 639
 640         ret = sqlite3_step(stmt);
 641         if (SQLITE_ROW != ret) {
 642                 /* LCOV_EXCL_START */
 643                 ERR("sqlite3_step() Fail(%d)", ret);
 644                 sqlite3_finalize(stmt);
 645                 return ret;
 646                 /* LCOV_EXCL_STOP */
 647         }
 648
 649         do {
 650                 datatype = ctsvc_stmt_get_int(stmt, 0);
 651                 switch (datatype) {
 652                 case CONTACTS_DATA_TYPE_NAME:
 653                         ctsvc_get_data_info_name(stmt, (contacts_list_h)contact->name);
 654                         break;
 655                 case CONTACTS_DATA_TYPE_NICKNAME:
 656                         ctsvc_get_data_info_nickname(stmt, (contacts_list_h)contact->nicknames);
 657                         break;
 658                 case CONTACTS_DATA_TYPE_NUMBER:
 659                         ctsvc_get_data_info_number(stmt, (contacts_list_h)contact->numbers);
 660                         break;
 661                 case CONTACTS_DATA_TYPE_EMAIL:
 662                         ctsvc_get_data_info_email(stmt, (contacts_list_h)contact->emails);
 663                         break;
 664                 case CONTACTS_DATA_TYPE_COMPANY:
 665                         ctsvc_get_data_info_company(stmt, (contacts_list_h)contact->company);
 666                         break;
 667                 default:
 668                         break;
 669                 }
 670         } while (SQLITE_ROW == sqlite3_step(stmt));
 671
 672         sqlite3_finalize(stmt);
 673
 674         return SQLITE_DONE;
 675 }
 676
 677 static int __ctsvc_server_get_contact_id_list(sqlite3* db, GList** contact_id_list)
 678 {
 679         GList* list = NULL;
 680         cts_stmt stmt = NULL;
 681         char query[CTS_SQL_MIN_LEN] = {0};
 682
 683         snprintf(query, sizeof(query),
 684                         "SELECT contact_id "
 685                                 "FROM "CTS_TABLE_CONTACTS" WHERE deleted = 0");
 686
 687         int ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
 688         if (SQLITE_OK != ret) {
 689                 /* LCOV_EXCL_START */
 690                 ERR("sqlite3_prepare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 691                 return CONTACTS_ERROR_SYSTEM;
 692                 /* LCOV_EXCL_STOP */
 693         }
 694
 695         int contact_id = 0;
 696         while (SQLITE_ROW == (ret = sqlite3_step(stmt))) {
 697                 contact_id = sqlite3_column_int(stmt, 0);
 698                 list = g_list_prepend(list, GINT_TO_POINTER(contact_id));
 699         }
 700
 701         if (NULL == list && SQLITE_DONE == ret) {
 702                 sqlite3_finalize(stmt);
 703                 return CONTACTS_ERROR_NO_DATA;
 704         }
 705
 706         if (SQLITE_ROW != ret && SQLITE_DONE != ret) {
 707                 /* LCOV_EXCL_START */
 708                 ERR("sqlite3_step() Fail(%d)", ret);
 709                 g_list_free(list);
 710                 sqlite3_finalize(stmt);
 711                 return CONTACTS_ERROR_DB;
 712                 /* LCOV_EXCL_STOP */
 713         }
 714
 715         list = g_list_reverse(list);
 716         *contact_id_list = list;
 717
 718         sqlite3_finalize(stmt);
 719
 720         return CONTACTS_ERROR_NONE;
 721 }
 722
 723 int ctsvc_server_update_sort_name()
 724 {
 725         int ret = 0;
 726         sqlite3 *db = NULL;
 727         cts_stmt update_stmt = NULL;
 728         cts_stmt search_name_stmt = NULL;
 729         char query[CTS_SQL_MIN_LEN] = {0};
 730         GList* contact_id_list = NULL;
 731         GList *cursor;
 732
 733         INFO("Start to update sort_name");
 734
 735         ctsvc_db_set_status(CONTACTS_DB_STATUS_CHANGING_COLLATION);
 736
 737         ret = ctsvc_server_db_open(&db, NULL);
 738         if (CONTACTS_ERROR_NONE != ret) {
 739                 /* LCOV_EXCL_START */
 740                 ERR("ctsvc_server_db_open() Fail(%d)", ret);
 741                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 742                 return ret;
 743                 /* LCOV_EXCL_STOP */
 744         }
 745
 746         ret = __ctsvc_server_get_contact_id_list(db, &contact_id_list);
 747         if (ret != CONTACTS_ERROR_NONE) {
 748                 /* LCOV_EXCL_START */
 749                 ERR("__ctsvc_server_get_contact_id_list() Fail(%d)", ret);
 750                 ctsvc_server_db_close();
 751                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 752                 return ret;
 753                 /* LCOV_EXCL_STOP */
 754         }
 755
 756         ret = ctsvc_server_begin_trans();
 757         if (CONTACTS_ERROR_NONE != ret) {
 758                 /* LCOV_EXCL_START */
 759                 ERR("ctsvc_server_begin_trans() Fail(%d)", ret);
 760                 g_list_free(contact_id_list);
 761                 ctsvc_server_db_close();
 762                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 763                 return ret;
 764                 /* LCOV_EXCL_STOP */
 765         }
 766
 767         /* Update sort_name, sortkey, display_name_language of contact table */
 768         snprintf(query, sizeof(query),
 769                         "UPDATE "CTS_TABLE_CONTACTS" "
 770                         "SET sort_name = ?, reverse_sort_name = ?, sortkey = ?, reverse_sortkey = ?, "
 771                         " display_name_language = ?,  reverse_display_name_language = ?, "
 772                         " display_name_source = ? "
 773                         "WHERE contact_id = ?");
 774         ret = sqlite3_prepare_v2(db, query, strlen(query), &update_stmt, NULL);
 775         if (SQLITE_OK != ret) {
 776                 /* LCOV_EXCL_START */
 777                 ERR("sqlite3_propare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 778                 ret = CONTACTS_ERROR_DB;
 779                 goto DATA_FREE;
 780                 /* LCOV_EXCL_STOP */
 781         }
 782
 783         /* Update name of search_index table */
 784         snprintf(query, sizeof(query),
 785                         "UPDATE %s SET name=? WHERE contact_id = ?",
 786                         CTS_TABLE_SEARCH_INDEX);
 787         ret = sqlite3_prepare_v2(db, query, strlen(query), &search_name_stmt, NULL);
 788         if (SQLITE_OK != ret) {
 789                 /* LCOV_EXCL_START */
 790                 ERR("sqlite3_propare_v2(%s) Fail(%s)", query, sqlite3_errmsg(db));
 791                 ret = CONTACTS_ERROR_DB;
 792                 goto DATA_FREE;
 793                 /* LCOV_EXCL_STOP */
 794         }
 795
 796         int count = 0;
 797         int contact_id = 0;
 798         char *search_name = NULL;
 799         cursor = contact_id_list;
 800         while (cursor) {
 801                 contact_id = GPOINTER_TO_INT(cursor->data);
 802
 803                 /* get_contact_info */
 804                 ctsvc_contact_s *contact = NULL;
 805                 contacts_record_create(_contacts_contact._uri, (contacts_record_h*)&contact);
 806                 ret = __ctsvc_server_db_get_contact_data(db, contact_id, contact);
 807                 if (SQLITE_DONE != ret) {
 808                         /* LCOV_EXCL_START */
 809                         ERR("sqlite3_step(%s) Fail(%d, %s)", query, ret, sqlite3_errmsg(db));
 810                         contacts_record_destroy((contacts_record_h)contact, true);
 811                         ret = CONTACTS_ERROR_DB;
 812                         goto DATA_FREE;
 813                         /* LCOV_EXCL_STOP */
 814                 }
 815
 816                 /* update sort_name, sortkey, display_name_language(sort group) */
 817                 ctsvc_contact_make_display_name(contact);
 818                 if (contact->sort_name)
 819                         sqlite3_bind_text(update_stmt, 1, contact->sort_name, strlen(contact->sort_name), SQLITE_STATIC);
 820                 if (contact->reverse_sort_name)
 821                         sqlite3_bind_text(update_stmt, 2, contact->reverse_sort_name, strlen(contact->reverse_sort_name), SQLITE_STATIC);
 822                 if (contact->sortkey)
 823                         sqlite3_bind_text(update_stmt, 3, contact->sortkey, strlen(contact->sortkey), SQLITE_STATIC);
 824                 if (contact->reverse_sortkey)
 825                         sqlite3_bind_text(update_stmt, 4, contact->reverse_sortkey, strlen(contact->reverse_sortkey), SQLITE_STATIC);
 826                 sqlite3_bind_int(update_stmt, 5, contact->display_name_language);
 827                 sqlite3_bind_int(update_stmt, 6, contact->reverse_display_name_language);
 828                 sqlite3_bind_int(update_stmt, 7, contact->display_source_type);
 829                 sqlite3_bind_int(update_stmt, 8, contact_id);
 830
 831                 ret = sqlite3_step(update_stmt);
 832                 if (SQLITE_DONE != ret) {
 833                         /* LCOV_EXCL_START */
 834                         ERR("sqlite3_step(%s) Fail(%d, %s)", query, ret, sqlite3_errmsg(db));
 835                         contacts_record_destroy((contacts_record_h)contact, true);
 836                         ret = CONTACTS_ERROR_DB;
 837                         goto DATA_FREE;
 838                         /* LCOV_EXCL_STOP */
 839                 }
 840                 sqlite3_reset(update_stmt);
 841
 842                 /* update name valud of search_index table */
 843                 ctsvc_contact_make_search_name(contact, &search_name);
 844                 if (search_name) {
 845                         sqlite3_bind_text(search_name_stmt, 1, search_name, strlen(search_name), SQLITE_STATIC);
 846                         sqlite3_bind_int(search_name_stmt, 2, contact_id);
 847                         ret = sqlite3_step(search_name_stmt);
 848                         free(search_name);
 849                         if (SQLITE_DONE != ret) {
 850                                 /* LCOV_EXCL_START */
 851                                 ERR("sqlite3_step(%s) Fail(%d, %s)", query, ret, sqlite3_errmsg(db));
 852                                 contacts_record_destroy((contacts_record_h)contact, true);
 853                                 ret = CONTACTS_ERROR_DB;
 854                                 goto DATA_FREE;
 855                                 /* LCOV_EXCL_STOP */
 856                         }
 857                         sqlite3_reset(search_name_stmt);
 858                 }
 859
 860                 contacts_record_destroy((contacts_record_h)contact, true);
 861
 862                 count++;
 863                 cursor = cursor->next;
 864                 if (cursor && 0 == count % SORT_NAME_UPDATE_BULK_COUNT) {
 865                         DBG("separate transaction");
 866                         ret = ctsvc_server_end_trans(true);
 867                         usleep(100*1000);
 868                         ret = ctsvc_server_begin_trans();
 869                         if (CONTACTS_ERROR_NONE != ret) {
 870                                 /* LCOV_EXCL_START */
 871                                 ERR("ctsvc_server_begin_trans() Fail(%d)", ret);
 872                                 g_list_free(contact_id_list);
 873                                 if (update_stmt)
 874                                         sqlite3_finalize(update_stmt);
 875                                 if (search_name_stmt)
 876                                         sqlite3_finalize(search_name_stmt);
 877                                 ctsvc_server_db_close();
 878                                 ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 879                                 return ret;
 880                                 /* LCOV_EXCL_STOP */
 881                         }
 882                 }
 883         }
 884
 885 DATA_FREE:
 886         g_list_free(contact_id_list);
 887
 888         if (update_stmt)
 889                 sqlite3_finalize(update_stmt);
 890         if (search_name_stmt)
 891                 sqlite3_finalize(search_name_stmt);
 892
 893         /* send notification */
 894         if (CONTACTS_ERROR_DB != ret) {
 895                 ret = ctsvc_server_end_trans(true);
 896                 if (CONTACTS_ERROR_NONE == ret) {
 897                         int fd;
 898                         char *path = ctsvc_inotify_makepath(CTSVC_NOTI_CONTACT_CHANGED);
 899                         if (NULL != path) {
 900                                 fd = open(path, O_TRUNC | O_RDWR);
 901                                 if (0 <= fd)
 902                                         close(fd);
 903                         } else {
 904                                 ERR("ctsvc_inotify_makepath() fail");
 905                         }
 906                         free(path);
 907
 908                         path = ctsvc_inotify_makepath(CTSVC_NOTI_PERSON_CHANGED);
 909                         if (NULL != path) {
 910                                 fd = open(path, O_TRUNC | O_RDWR);
 911                                 if (0 <= fd)
 912                                         close(fd);
 913                         } else {
 914                                 ERR("ctsvc_inotify_makepath() fail");
 915                         }
 916                         free(path);
 917                 }
 918         } else {
 919                 ctsvc_server_end_trans(false);
 920         }
 921
 922         ctsvc_server_db_close();
 923         ctsvc_db_set_status(CONTACTS_DB_STATUS_NORMAL);
 924
 925         INFO("End to update sort_name");
 926
 927         return ret;
 928 }
 929