src/platform/Tizen/Contact/query-svc/query-utility.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 /**
  18  * @file                query-utility.c
  19  * @author      JihwaPark (82-32-3016262, jh7979.park@samsung.com)
  20  * @version      1.0(2011.10.05)
  21  * @brief       This file serves utility for advanced query.
  22  */
  23
  24 #include "query-service.h"
  25 #include "query-type.h"
  26 #include "query-utility.h"
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <time.h>
  30 #include <unicode/ucol.h>
  31 #include <unicode/ustring.h>
  32
  33 static int transaction_count = 0;
  34 static int db_connnect_count = 0;
  35
  36 clock_t
  37 _get_clock()
  38 {
  39         long curtime;
  40
  41         struct timeval tv;
  42         gettimeofday(&tv, NULL);
  43         curtime = tv.tv_sec * 1000000 + tv.tv_usec;
  44
  45         return curtime;
  46 }
  47
  48 void
  49 _print_time(clock_t begin, clock_t finish, const char* function_name)
  50 {
  51         double totaltime = 0.0;
  52         totaltime=(double) (finish-begin)/CLOCKS_PER_SEC;
  53
  54         PERFORMANCE_TRACE("......................................................................... ");
  55         PERFORMANCE_TRACE("TEST CASE    [%s] ", function_name);
  56 //      PERFORMANCE_TRACE("start time   [%ld us] ", begin);
  57 //      PERFORMANCE_TRACE("finish time  [%ld us] ", finish);
  58         PERFORMANCE_TRACE("total time   [%f s] ", totaltime);
  59         PERFORMANCE_TRACE("......................................................................... ");
  60 }
  61
  62 query_error _contact_db_init()
  63 {
  64         int rc = 0;
  65         query_error error_code = QUERY_SUCCESS;
  66
  67         db_connnect_count++;
  68         if(!g_hDBCt)
  69         {
  70                 rc = db_util_open(QUERY_DB_PATH, &g_hDBCt, 0);
  71                 if(rc != SQLITE_OK)
  72                         error_code = QUERY_FAIL;
  73         }
  74         return error_code;
  75 }
  76
  77 query_error _contact_db_finish()
  78 {
  79         int rc = 0;
  80         query_error error_code = QUERY_SUCCESS;
  81
  82         db_connnect_count--;
  83         if(db_connnect_count == 0)
  84         {
  85                 rc = db_util_close(g_hDBCt);
  86                 if(rc != SQLITE_OK)
  87                         error_code = QUERY_FAIL;
  88                 else
  89                         g_hDBCt = NULL;
  90         }
  91         return error_code;
  92 }
  93
  94 query_error _contact_exec_query(char* query)
  95 {
  96         int rc = -1;
  97         char* pszErrorMsg = NULL;
  98         query_error             error_code = QUERY_SUCCESS;
  99
 100         ADVANCED_SVC_TRACE("query : %s", query);
 101
 102         rc = sqlite3_exec(g_hDBCt, query, NULL, NULL, &pszErrorMsg);
 103
 104         if(SQLITE_OK != rc)
 105         {
 106                 ADVANCED_SVC_TRACE("contact_util_query_exec failed(%d).\n", rc);
 107                 error_code = QUERY_FAIL;
 108         }
 109
 110         if(pszErrorMsg)
 111             sqlite3_free(pszErrorMsg);
 112
 113         return error_code;
 114 }
 115
 116 query_error _trans_begin(void)
 117 {
 118         int     rc = -1;
 119         query_error             error_code = QUERY_SUCCESS;
 120
 121         if(transaction_count == 0)
 122         {
 123                 rc = _contact_exec_query("BEGIN IMMEDIATE TRANSACTION");
 124                 if(SQLITE_OK != rc)
 125                 {
 126                         ADVANCED_SVC_TRACE("contact_util_query_exec failed(%d).\n", rc);
 127                         return QUERY_FAIL;
 128                 }
 129         }
 130         transaction_count++;
 131         ADVANCED_SVC_TRACE("contact transaction_count : %d.\n", transaction_count);
 132
 133         return error_code;
 134 }
 135
 136 query_error _trans_end(int is_success)
 137 {
 138         int     rc = -1;
 139         query_error             error_code = QUERY_SUCCESS;
 140
 141         if(transaction_count == 1)
 142         {
 143                 if(is_success == 1)
 144                         rc = _contact_exec_query("COMMIT TRANSACTION");
 145                 else
 146                         rc = _contact_exec_query("ROLLBACK TRANSACTION");
 147
 148                 if(SQLITE_OK != rc)
 149                 {
 150                         ADVANCED_SVC_TRACE("contact_util_query_exec failed(%d).\n", rc);
 151                         return QUERY_FAIL;
 152                 }
 153
 154         }
 155         transaction_count--;
 156
 157         if(transaction_count < 0)
 158                 transaction_count = 0;
 159
 160         ADVANCED_SVC_TRACE("contact transaction_count : %d.\n", transaction_count);
 161
 162         return error_code;
 163 }
 164
 165
 166 int _contact_query_step(stmt pStmt)
 167 {
 168         return sqlite3_step(pStmt);
 169 }
 170
 171 void _ct_query_finalize(stmt pStmt)
 172 {
 173         int rc = -1;
 174
 175         if(!pStmt)
 176           return;
 177
 178         rc = sqlite3_finalize(pStmt);
 179         if(rc != SQLITE_OK)
 180         {
 181         }
 182 }
 183
 184 int _ct_query_column_int(stmt pStmt, int pos)
 185 {
 186         return (int)sqlite3_column_int(pStmt, pos);
 187 }
 188
 189 char* _ct_query_column_text(stmt pStmt, int pos)
 190 {
 191         return (char *)sqlite3_column_text(pStmt, pos);
 192 }
 193
 194 int _contact_query_bind_double(stmt pStmt, int pos, double num)
 195 {
 196    return sqlite3_bind_double(pStmt, pos, num);
 197 }
 198
 199 int _contact_query_bind_int(stmt pStmt, int pos, int num)
 200 {
 201    return sqlite3_bind_int(pStmt, pos, num);
 202 }
 203
 204 int _contact_query_bind_text(stmt pStmt, int pos, char* str)
 205 {
 206         int len = 0;
 207         if(str != NULL)
 208         {
 209                 len = strlen(str);
 210                 return sqlite3_bind_text(pStmt, pos, (const char*)str, len, SQLITE_STATIC);
 211         }
 212         return -1;
 213 }
 214
 215 void _contact_query_stmt_reset(stmt stmt)
 216 {
 217    sqlite3_reset(stmt);
 218    sqlite3_clear_bindings(stmt);
 219 }
 220
 221 double _contact_query_column_double(stmt pStmt, int pos)
 222 {
 223    return sqlite3_column_double(pStmt, pos);
 224 }
 225
 226 stmt _contact_query_prepare(char *query)
 227 {
 228         int rc = -1;
 229         stmt pStmt = NULL;
 230
 231         ADVANCED_SVC_TRACE("query : %s !!!!\n", query);
 232 //      printf("\nquery : %s !!!!\n", query);
 233
 234         rc = sqlite3_prepare_v2(g_hDBCt, query, strlen(query), &pStmt, NULL);
 235         if(SQLITE_OK != rc)
 236         {
 237                 ADVANCED_SVC_TRACE("rc : %d", rc);
 238                 return NULL;
 239         }
 240
 241         return pStmt;
 242 }
 243
 244 int _convert_person_attribute_to_mimetype_id(contact_attribute_e attribute)
 245 {
 246         int is_person_attr = 0;
 247
 248         switch(attribute)
 249         {
 250                 case NAME_FIRST :
 251                 case NAME_MIDDLE:
 252                 case NAME_LAST:
 253                 case NAME_PREFIX:
 254                 case NAME_PHONETIC:
 255                         is_person_attr = 1;
 256                         break;
 257                 default:
 258                         is_person_attr = 0;
 259         }
 260         ADVANCED_SVC_TRACE("is_person_attr : %d", is_person_attr);
 261
 262         return is_person_attr;
 263 }
 264
 265 predefine_datatype _convert_attribute_to_mimetype_id(contact_attribute_e attribute)
 266 {
 267         predefine_datatype data_type = DATATYPE_INVALID;
 268         switch(attribute)
 269         {
 270                 case NAME_FIRST :
 271                 case NAME_MIDDLE:
 272                 case NAME_LAST:
 273                 case NAME_PREFIX:
 274                 case NAME_PHONETIC:
 275                 case NAME_DISPLAY:
 276                         data_type = DATATYPE_NAME;
 277                         break;
 278                 case NICKNAME_NAME:
 279                         data_type = DATATYPE_NICK_NAME;
 280                         break;
 281                 case NUMBER_ADDRESS:
 282                 case NUMBER_TYPES:
 283                         data_type = DATATYPE_NUMBER;
 284                         break;
 285                 case EMAIL_ADDRESS:
 286                 case EMAIL_TYPE:
 287                         data_type = DATATYPE_EMAIL;
 288                         break;
 289                 case URL_ADDRESS:
 290                 case URL_TYPE:
 291                         data_type = DATATYPE_URL;
 292                         break;
 293                 case EVENT_DATE:
 294                 case EVENT_TYPE:
 295                         data_type = DATATYPE_ANNIVERSARY;
 296                         break;
 297 /*
 298                 case ANNIVERSARY_LABEL:
 299                         data_type = DATATYPE_ANNIVERSARY;
 300                         break;
 301                 case CONTACT_LATITUDE:
 302                 case CONTACT_LONGITUDE:
 303                         data_type = DATATYPE_LBS_INFO;
 304                         break;
 305 */
 306                 case ADDRESS_COUNTRY:
 307                 case ADDRESS_REGION:
 308 //              case ADDRESS_COUNTY:
 309                 case ADDRESS_CITY:
 310                 case ADDRESS_STREET:
 311                 case ADDRESS_POSTAL_CODE:
 312                 case ADDRESS_ADDITIONAL:
 313                 case ADDRESS_TYPE:
 314                         data_type = DATATYPE_ADDRESS;
 315                         break;
 316                 case CATEGORY_INFO:
 317                         data_type = DATATYPE_CATEGORY;
 318                         break;
 319                 case ORGANIZATION_NAME:
 320                 case ORGANIZATION_DEPARTMENT:
 321 //              case ORGANIZATION_OFFICE:
 322                 case ORGANIZATION_TITLE:
 323                 case ORGANIZATION_ROLE:
 324 //              case ORGANIZATION_LOGO_URI:
 325                         data_type = DATATYPE_ORGANIZATION;
 326                         break;
 327                 case CONTACT_IS_FAVORITE:
 328                 case CONTACT_RINGTONE:
 329                 case CONTACT_NOTE:
 330 //              case CONTACT_READ_ONLY:
 331 //              case CONTACT_SEND_TO_VOICE_MAIL:
 332                 case CONTACT_LAST_UPDATED_TIME_STAMP:
 333                 case CONTACT_ID :
 334                 case CONTACT_UID :
 335                 case ACCOUNT_ID :
 336                 default:
 337                         break;
 338         }
 339
 340         ADVANCED_SVC_TRACE("data_type : %d", data_type);
 341
 342         return data_type;
 343 }
 344
 345 char* _convert_person_attribute_to_condition_column_name(contact_attribute_e attribute)
 346 {
 347         char* field_name = NULL;
 348
 349         switch(attribute)
 350         {
 351                 case CONTACT_ID :
 352                         field_name = condition_field_key[FIELD_PERSON_CONTACT_ID];
 353                         break;
 354                 case CONTACT_IS_FAVORITE :
 355                         field_name = condition_field_key[FIELD_PERSON_IS_FAVORITE];
 356                         break;
 357                 case CONTACT_RINGTONE :
 358                         field_name = condition_field_key[FIELD_PERSON_RINGTONE];
 359                         break;
 360                 case CONTACT_PHOTO_URI :
 361                         field_name = condition_field_key[FIELD_PERSON_PHOTO_URI];
 362                         break;
 363 //              case CONTACT_SEND_TO_VOICE_MAIL :
 364 //                      field_name = condition_field_key[FIELD_PERSON_SEND_TO_VOICEMAIL];
 365 //                      break;
 366                 case NAME_FIRST :
 367                         field_name = condition_field_key[FIELD_PERSON_FIRST_NAME];
 368                         break;
 369                 case NAME_MIDDLE :
 370                         field_name = condition_field_key[FIELD_PERSON_MIDDLE_NAME];
 371                         break;
 372                 case NAME_LAST :
 373                         field_name = condition_field_key[FIELD_PERSON_LAST_NAME];
 374                         break;
 375                 case NAME_PREFIX :
 376                         field_name = condition_field_key[FIELD_PERSON_PREFIX_NAME];
 377                         break;
 378                 case NAME_PHONETIC :
 379                         field_name = condition_field_key[FIELD_PERSON_PHONETIC_NAME];
 380                         break;
 381                 case NAME_DISPLAY :
 382                         field_name = condition_field_key[FIELD_PERSON_DISPLAY_NAME];
 383                         break;
 384                 default :
 385                         break;
 386         }
 387         return field_name;
 388 }
 389
 390 char* _convert_person_attribute_to_column_name(contact_attribute_e attribute)
 391 {
 392         char* field_name = NULL;
 393
 394         switch(attribute)
 395         {
 396                 case CONTACT_ID :
 397                         field_name = field_key[FIELD_PERSON_CONTACT_ID];
 398                         break;
 399                 case CONTACT_IS_FAVORITE :
 400                         field_name = field_key[FIELD_PERSON_IS_FAVORITE];
 401                         break;
 402                 case CONTACT_RINGTONE :
 403                         field_name = field_key[FIELD_PERSON_RINGTONE];
 404                         break;
 405                 case CONTACT_PHOTO_URI :
 406                         field_name = field_key[FIELD_PERSON_PHOTO_URI];
 407                         break;
 408 //              case CONTACT_SEND_TO_VOICE_MAIL :
 409 //                      field_name = field_key[FIELD_PERSON_SEND_TO_VOICEMAIL];
 410 //                      break;
 411                 case NAME_FIRST :
 412                         field_name = field_key[FIELD_PERSON_FIRST_NAME];
 413                         break;
 414                 case NAME_MIDDLE :
 415                         field_name = field_key[FIELD_PERSON_MIDDLE_NAME];
 416                         break;
 417                 case NAME_LAST :
 418                         field_name = field_key[FIELD_PERSON_LAST_NAME];
 419                         break;
 420                 case NAME_PREFIX :
 421                         field_name = field_key[FIELD_PERSON_PREFIX_NAME];
 422                         break;
 423                 case NAME_PHONETIC :
 424                         field_name = field_key[FIELD_PERSON_PHONETIC_NAME];
 425                         break;
 426                 case NAME_DISPLAY :
 427                         field_name = field_key[FIELD_PERSON_DISPLAY_NAME];
 428                         break;
 429                 default :
 430                         break;
 431         }
 432         return field_name;
 433 }
 434
 435 char* _convert_attribute_to_condition_normalize_column(contact_attribute_e attribute)
 436 {
 437         char* field_name = NULL;
 438
 439         switch(attribute)
 440         {
 441                 case NAME_DISPLAY:
 442                         field_name = condition_field_key[FIELD_DATA8];
 443                         break;
 444                 default:
 445                         break;
 446         }
 447         return field_name;
 448 }
 449
 450 char* _convert_attribute_to_normalize_column(contact_attribute_e attribute)
 451 {
 452         char* field_name = NULL;
 453
 454         switch(attribute)
 455         {
 456                 case NAME_DISPLAY:
 457                         field_name = field_key[FIELD_DATA8];
 458                         break;
 459                 default:
 460                         break;
 461         }
 462         return field_name;
 463 }
 464
 465 char* _convert_attribute_to_condition_column_name(contact_attribute_e attribute)
 466 {
 467         char* field_name = NULL;
 468
 469         switch(attribute)
 470         {
 471                 case CONTACT_RINGTONE :
 472                         field_name = condition_field_key[FIELD_RINGTONE];
 473                         break;
 474                 case CONTACT_NOTE :
 475                         field_name = condition_field_key[FIELD_NOTE];
 476                         break;
 477                 case CONTACT_ID :
 478                         field_name = condition_field_key[FIELD_DATA_CONTACT_ID];
 479                         break;
 480                 case CONTACT_UID :
 481                         field_name = condition_field_key[FIELD_UID];
 482                         break;
 483                 case ACCOUNT_ID :
 484                         field_name = condition_field_key[FIELD_CONTACT_ACCOUNT_ID];
 485                         break;
 486                 case CONTACT_IS_FAVORITE :
 487                         field_name = condition_field_key[FIELD_IS_FAVORITE];
 488                         break;
 489                 case CONTACT_PHOTO_URI :
 490                         field_name = condition_field_key[FIELD_PHOTO_URI];
 491                         break;
 492                 case CONTACT_LAST_UPDATED_TIME_STAMP :
 493                         field_name = condition_field_key[FIELD_CHANGED_TIME];
 494                         break;
 495 //              case CONTACT_READ_ONLY :
 496 //                      field_name = condition_field_key[FIELD_DATA_CONTACT_ID];
 497 //                      break;
 498 //              case CONTACT_SEND_TO_VOICE_MAIL :
 499 //                      field_name = condition_field_key[FIELD_DATA_CONTACT_ID];
 500 //                      break;
 501 //              case CONTACT_LATITUDE :
 502 //                      field_name = condition_field_key[FIELD_DATA1];
 503 //                      break;
 504 //              case CONTACT_LONGITUDE :
 505 //                      field_name = condition_field_key[FIELD_DATA2];
 506 //                      break;
 507                 case NAME_FIRST :
 508                         field_name = condition_field_key[FIELD_DATA2];
 509                         break;
 510                 case NAME_LAST:
 511                         field_name = condition_field_key[FIELD_DATA3];
 512                         break;
 513                 case NAME_MIDDLE:
 514                         field_name = condition_field_key[FIELD_DATA4];
 515                         break;
 516                 case NAME_DISPLAY:
 517                         field_name = condition_field_key[FIELD_DATA5];
 518                         break;
 519                 case NAME_PREFIX:
 520                         field_name = condition_field_key[FIELD_DATA6];
 521                         break;
 522                 case NAME_PHONETIC:
 523                         field_name = condition_field_key[FIELD_DATA7];
 524                         break;
 525                 case NICKNAME_NAME:
 526                         field_name = condition_field_key[FIELD_DATA2];
 527                         break;
 528                 case NUMBER_ADDRESS:
 529                         field_name = condition_field_key[FIELD_DATA2];
 530                         break;
 531                 case NUMBER_TYPES:
 532                         field_name = condition_field_key[FIELD_DATA1];
 533                         break;
 534                 case EMAIL_ADDRESS:
 535                         field_name = condition_field_key[FIELD_DATA2];
 536                         break;
 537                 case EMAIL_TYPE:
 538                         field_name = condition_field_key[FIELD_DATA1];
 539                         break;
 540                 case URL_ADDRESS:
 541                         field_name = condition_field_key[FIELD_DATA2];
 542                         break;
 543                 case URL_TYPE:
 544                         field_name = condition_field_key[FIELD_DATA1];
 545                         break;
 546                 case ADDRESS_COUNTRY:
 547                         field_name = condition_field_key[FIELD_DATA8];
 548                         break;
 549                 case ADDRESS_REGION:
 550                         field_name = condition_field_key[FIELD_DATA4];
 551                         break;
 552 //              case ADDRESS_COUNTY:
 553 //                      field_name = condition_field_key[FIELD_DATA5];
 554 //                      break;
 555                 case ADDRESS_CITY:
 556                         field_name = condition_field_key[FIELD_DATA5];
 557                         break;
 558                 case ADDRESS_STREET:
 559                         field_name = condition_field_key[FIELD_DATA6];
 560                         break;
 561                 case ADDRESS_POSTAL_CODE:
 562                         field_name = condition_field_key[FIELD_DATA3];
 563                         break;
 564                 case ADDRESS_ADDITIONAL:
 565                         field_name = condition_field_key[FIELD_DATA7];
 566                         break;
 567                 case ADDRESS_TYPE:
 568                         field_name = condition_field_key[FIELD_DATA1];
 569                         break;
 570 //              case CATEGORY_INFO:
 571 //                      field_name = condition_field_key[FIELD_DATA1];
 572 //                      break;
 573                 case EVENT_TYPE:
 574                         field_name = condition_field_key[FIELD_DATA1];
 575                         break;
 576                 case EVENT_DATE:
 577                         field_name = condition_field_key[FIELD_DATA2];
 578                         break;
 579 //              case ANNIVERSARY_LABEL:
 580 //                      field_name = condition_field_key[FIELD_DATA2];
 581 //                      break;
 582                 case ORGANIZATION_NAME:
 583                         field_name = condition_field_key[FIELD_DATA2];
 584                         break;
 585                 case ORGANIZATION_DEPARTMENT:
 586                         field_name = condition_field_key[FIELD_DATA3];
 587                         break;
 588 //              case ORGANIZATION_OFFICE:
 589 //                      field_name = condition_field_key[FIELD_DATA3];
 590 //                      break;
 591                 case ORGANIZATION_TITLE:
 592                         field_name = condition_field_key[FIELD_DATA4];
 593                         break;
 594                 case ORGANIZATION_ROLE:
 595                         field_name = condition_field_key[FIELD_DATA5];
 596                         break;
 597 //              case ORGANIZATION_LOGO_URI:
 598 //                      field_name = condition_field_key[FIELD_DATA6];
 599 //                      break;
 600                 default:
 601                         break;
 602         }
 603         ADVANCED_SVC_TRACE("field_name : %s", field_name);
 604
 605         return field_name;
 606 }
 607
 608 primitive_type _convert_check_attribute_primitive_type(contact_attribute_e attribute)
 609 {
 610         primitive_type type = INTEGER;
 611
 612         switch(attribute)
 613         {
 614                 case CONTACT_ID :
 615                 case ACCOUNT_ID :
 616 //              case CONTACT_READ_ONLY :
 617 //              case CONTACT_SEND_TO_VOICE_MAIL :
 618                 case CONTACT_LAST_UPDATED_TIME_STAMP :
 619                 case CONTACT_IS_FAVORITE :
 620                 case NUMBER_TYPES:
 621                 case EMAIL_TYPE:
 622                 case URL_TYPE:
 623                 case ADDRESS_TYPE:
 624                 case EVENT_TYPE:
 625                         type = INTEGER;
 626                         break;
 627 //              case CONTACT_LATITUDE :
 628 //              case CONTACT_LONGITUDE :
 629 //                      type = REAL;
 630 //                      break;
 631                 case CONTACT_UID :
 632                 case CONTACT_RINGTONE :
 633                 case CONTACT_NOTE :
 634                 case CONTACT_PHOTO_URI :
 635                 case NAME_FIRST :
 636                 case NAME_LAST:
 637                 case NAME_MIDDLE:
 638                 case NAME_DISPLAY:
 639                 case NAME_PREFIX:
 640                 case NAME_PHONETIC:
 641                 case NICKNAME_NAME:
 642                 case NUMBER_ADDRESS:
 643                 case EMAIL_ADDRESS:
 644                 case URL_ADDRESS:
 645                 case ADDRESS_COUNTRY:
 646                 case ADDRESS_REGION:
 647 //              case ADDRESS_COUNTY:
 648                 case ADDRESS_CITY:
 649                 case ADDRESS_STREET:
 650                 case ADDRESS_POSTAL_CODE:
 651                 case ADDRESS_ADDITIONAL:
 652 //              case CATEGORY_INFO:
 653                 case EVENT_DATE:
 654 //              case ANNIVERSARY_LABEL:
 655                 case ORGANIZATION_NAME:
 656                 case ORGANIZATION_DEPARTMENT:
 657 //              case ORGANIZATION_OFFICE:
 658                 case ORGANIZATION_TITLE:
 659                 case ORGANIZATION_ROLE:
 660 //              case ORGANIZATION_LOGO_URI:
 661                         type = STRING;
 662                         break;
 663                 default:
 664                         break;
 665         }
 666         ADVANCED_SVC_TRACE("primitive type : %d", type);
 667
 668         return type;
 669 }
 670
 671 char* _convert_x_attribute_to_condition_column_name(contact_x_attribute_e attribute)
 672 {
 673         char* field_name = NULL;
 674
 675         switch(attribute)
 676         {
 677                 case X_DATA1 :
 678                         field_name = condition_x_field_key[FIELD_X_DATA1];
 679                         break;
 680                 case X_DATA2 :
 681                         field_name = condition_x_field_key[FIELD_X_DATA2];
 682                         break;
 683                 case X_DATA3:
 684                         field_name = condition_x_field_key[FIELD_X_DATA3];
 685                         break;
 686                 case X_DATA4:
 687                         field_name = condition_x_field_key[FIELD_X_DATA4];
 688                         break;
 689                 case X_DATA5:
 690                         field_name = condition_x_field_key[FIELD_X_DATA5];
 691                         break;
 692                 case X_DATA6:
 693                         field_name = condition_x_field_key[FIELD_X_DATA6];
 694                         break;
 695                 case X_DATA7:
 696                         field_name = condition_x_field_key[FIELD_X_DATA7];
 697                         break;
 698                 case X_DATA8:
 699                         field_name = condition_x_field_key[FIELD_X_DATA8];
 700                         break;
 701                 case X_DATA9:
 702                         field_name = condition_x_field_key[FIELD_X_DATA9];
 703                         break;
 704                 case X_DATA10:
 705                         field_name = condition_x_field_key[FIELD_X_DATA10];
 706                         break;
 707                 default:
 708                         break;
 709         }
 710         ADVANCED_SVC_TRACE("field_name : %s", field_name);
 711
 712         return field_name;
 713 }
 714
 715 char* _convert_attribute_to_column_name(contact_attribute_e attribute)
 716 {
 717         char* field_name = NULL;
 718
 719         switch(attribute)
 720         {
 721                 case CONTACT_RINGTONE :
 722                         field_name = field_key[FIELD_RINGTONE];
 723                         break;
 724                 case CONTACT_NOTE :
 725                         field_name = field_key[FIELD_NOTE];
 726                         break;
 727                 case CONTACT_UID :
 728                         field_name = field_key[FIELD_UID];
 729                         break;
 730                 case CONTACT_ID :
 731                         field_name = field_key[FIELD_DATA_CONTACT_ID];
 732                         break;
 733                 case ACCOUNT_ID :
 734                         field_name = field_key[FIELD_CONTACT_ACCOUNT_ID];
 735                         break;
 736                 case CONTACT_IS_FAVORITE :
 737                         field_name = field_key[FIELD_IS_FAVORITE];
 738                         break;
 739                 case CONTACT_PHOTO_URI :
 740                         field_name = field_key[FIELD_PHOTO_URI];
 741                         break;
 742                 case CONTACT_LAST_UPDATED_TIME_STAMP :
 743                         field_name = field_key[FIELD_CHANGED_TIME];
 744                         break;
 745 //              case CONTACT_READ_ONLY :
 746 //                      field_name = field_key[FIELD_DATA_CONTACT_ID];
 747 //                      break;
 748 //              case CONTACT_SEND_TO_VOICE_MAIL :
 749 //                      field_name = field_key[FIELD_DATA_CONTACT_ID];
 750 //                      break;
 751 /*
 752                 case CONTACT_LATITUDE :
 753                         field_name = field_key[FIELD_DATA1];
 754                         break;
 755                 case CONTACT_LONGITUDE :
 756                         field_name = field_key[FIELD_DATA2];
 757                         break;
 758 */
 759                 case NAME_FIRST :
 760                         field_name = field_key[FIELD_DATA2];
 761                         break;
 762                 case NAME_LAST:
 763                         field_name = field_key[FIELD_DATA3];
 764                         break;
 765                 case NAME_MIDDLE:
 766                         field_name = field_key[FIELD_DATA4];
 767                         break;
 768                 case NAME_DISPLAY:
 769                         field_name = field_key[FIELD_DATA5];
 770                         break;
 771                 case NAME_PREFIX:
 772                         field_name = field_key[FIELD_DATA6];
 773                         break;
 774                 case NAME_PHONETIC:
 775                         field_name = field_key[FIELD_DATA7];
 776                         break;
 777                 case NICKNAME_NAME:
 778                         field_name = field_key[FIELD_DATA2];
 779                         break;
 780                 case NUMBER_ADDRESS:
 781                         field_name = field_key[FIELD_DATA2];
 782                         break;
 783                 case NUMBER_TYPES:
 784                         field_name = field_key[FIELD_DATA1];
 785                         break;
 786                 case EMAIL_ADDRESS:
 787                         field_name = field_key[FIELD_DATA1];
 788                         break;
 789                 case EMAIL_TYPE:
 790                         field_name = field_key[FIELD_DATA2];
 791                         break;
 792                 case URL_ADDRESS:
 793                         field_name = field_key[FIELD_DATA1];
 794                         break;
 795                 case URL_TYPE:
 796                         field_name = field_key[FIELD_DATA2];
 797                         break;
 798                 case ADDRESS_COUNTRY:
 799                         field_name = field_key[FIELD_DATA8];
 800                         break;
 801                 case ADDRESS_REGION:
 802                         field_name = field_key[FIELD_DATA4];
 803                         break;
 804 //              case ADDRESS_COUNTY:
 805 //                      field_name = field_key[FIELD_DATA5];
 806 //                      break;
 807                 case ADDRESS_CITY:
 808                         field_name = field_key[FIELD_DATA5];
 809                         break;
 810                 case ADDRESS_STREET:
 811                         field_name = field_key[FIELD_DATA6];
 812                         break;
 813                 case ADDRESS_POSTAL_CODE:
 814                         field_name = field_key[FIELD_DATA3];
 815                         break;
 816                 case ADDRESS_ADDITIONAL:
 817                         field_name = field_key[FIELD_DATA7];
 818                         break;
 819                 case ADDRESS_TYPE:
 820                         field_name = field_key[FIELD_DATA1];
 821                         break;
 822 //              case CATEGORY_INFO:
 823 //                      field_name = field_key[FIELD_DATA1];
 824 //                      break;
 825                 case EVENT_TYPE:
 826                         field_name = field_key[FIELD_DATA1];
 827                         break;
 828                 case EVENT_DATE:
 829                         field_name = field_key[FIELD_DATA2];
 830                         break;
 831 //              case ANNIVERSARY_LABEL:
 832 //                      field_name = field_key[FIELD_DATA2];
 833 //                      break;
 834                 case ORGANIZATION_NAME:
 835                         field_name = field_key[FIELD_DATA2];
 836                         break;
 837                 case ORGANIZATION_DEPARTMENT:
 838                         field_name = field_key[FIELD_DATA3];
 839                         break;
 840 //              case ORGANIZATION_OFFICE:
 841 //                      field_name = field_key[FIELD_DATA3];
 842 //                      break;
 843                 case ORGANIZATION_TITLE:
 844                         field_name = field_key[FIELD_DATA4];
 845                         break;
 846                 case ORGANIZATION_ROLE:
 847                         field_name = field_key[FIELD_DATA5];
 848                         break;
 849 //              case ORGANIZATION_LOGO_URI:
 850 //                      field_name = field_key[FIELD_DATA6];
 851 //                      break;
 852                 default:
 853                         break;
 854         }
 855 //      ADVANCED_SVC_TRACE("field_name : %s", field_name);
 856
 857         return field_name;
 858 }
 859
 860 char* _convert_x_attribute_to_column_name(contact_x_attribute_e attribute)
 861 {
 862         char* field_name = NULL;
 863
 864         switch(attribute)
 865         {
 866                 case X_DATA1 :
 867                         field_name = x_field_key[FIELD_X_DATA1];
 868                         break;
 869                 case X_DATA2 :
 870                         field_name = x_field_key[FIELD_X_DATA2];
 871                         break;
 872                 case X_DATA3 :
 873                         field_name = x_field_key[FIELD_X_DATA3];
 874                         break;
 875                 case X_DATA4 :
 876                         field_name = x_field_key[FIELD_X_DATA4];
 877                         break;
 878                 case X_DATA5 :
 879                         field_name = x_field_key[FIELD_X_DATA5];
 880                         break;
 881                 case X_DATA6 :
 882                         field_name = x_field_key[FIELD_X_DATA6];
 883                         break;
 884                 case X_DATA7 :
 885                         field_name = x_field_key[FIELD_X_DATA7];
 886                         break;
 887                 case X_DATA8 :
 888                         field_name = x_field_key[FIELD_X_DATA8];
 889                         break;
 890                 case X_DATA9 :
 891                         field_name = x_field_key[FIELD_X_DATA9];
 892                         break;
 893                 case X_DATA10 :
 894                         field_name = x_field_key[FIELD_X_DATA10];
 895                         break;
 896                 default:
 897                         break;
 898         }
 899         ADVANCED_SVC_TRACE("field_name : %s", field_name);
 900
 901         return field_name;
 902 }
 903
 904 tables_e _contact_table_name_to_table_type(char* table_name)
 905 {
 906         tables_e table_type = INVALID_TABLE;
 907
 908         if(strcmp(table_name, table_key[TABLE_CONTACT]) == 0)
 909                 table_type = CONTACT_TABLE;
 910         else if(strcmp(table_name, table_key[TABLE_DATA]) == 0)
 911                 table_type = DATA_TABLE;
 912         else if(strcmp(table_name, table_key[TABLE_PERSON]) == 0)
 913                 table_type = PERSON_TABLE;
 914
 915         return table_type;
 916 }
 917
 918 char* _convert_person_attribute_to_table_name(contact_attribute_e attribute)
 919 {
 920         char* table_name = NULL;
 921         switch(attribute)
 922         {
 923                 case CONTACT_PHOTO_URI:
 924 //              case CONTACT_READ_ONLY:
 925 //              case CONTACT_SEND_TO_VOICE_MAIL:
 926                 case CONTACT_LAST_UPDATED_TIME_STAMP:
 927                 case CONTACT_IS_FAVORITE:
 928                 case CONTACT_RINGTONE :
 929                 case CONTACT_ID:
 930                 case NAME_FIRST :
 931                 case NAME_MIDDLE:
 932                 case NAME_LAST:
 933                 case NAME_PHONETIC:
 934                 case NAME_PREFIX:
 935                 case NAME_DISPLAY:
 936                 {
 937                         table_name = table_key[TABLE_PERSON];
 938                 }
 939                         break;
 940                 default:
 941                         break;
 942         }
 943
 944         ADVANCED_SVC_TRACE("table_name : %s", table_name);
 945
 946         return table_name;
 947 }
 948
 949 char* _convert_attribute_to_table_name(contact_attribute_e attribute)
 950 {
 951         char* table_name = NULL;
 952         switch(attribute)
 953         {
 954                 case CONTACT_PHOTO_URI:
 955 //              case CONTACT_READ_ONLY:
 956 //              case CONTACT_SEND_TO_VOICE_MAIL:
 957                 case CONTACT_LAST_UPDATED_TIME_STAMP:
 958                 case CONTACT_IS_FAVORITE:
 959                 case CONTACT_RINGTONE :
 960                 case CONTACT_NOTE :
 961                 case ACCOUNT_ID:
 962                 case CONTACT_UID:
 963                 {
 964                         table_name = table_key[TABLE_CONTACT];
 965                 }
 966                         break;
 967                 case CONTACT_ID:
 968 //              case CONTACT_LATITUDE:
 969 //              case CONTACT_LONGITUDE:
 970                 case NAME_FIRST :
 971                 case NAME_MIDDLE:
 972                 case NAME_LAST:
 973                 case NAME_PHONETIC:
 974                 case NAME_PREFIX:
 975                 case NAME_DISPLAY:
 976                 case NICKNAME_NAME:
 977                 case NUMBER_ADDRESS:
 978                 case NUMBER_TYPES:
 979                 case EMAIL_ADDRESS:
 980                 case EMAIL_TYPE:
 981                 case URL_ADDRESS:
 982                 case URL_TYPE:
 983                 case ADDRESS_COUNTRY:
 984                 case ADDRESS_REGION:
 985 //              case ADDRESS_COUNTY:
 986                 case ADDRESS_CITY:
 987                 case ADDRESS_STREET:
 988                 case ADDRESS_POSTAL_CODE:
 989                 case ADDRESS_ADDITIONAL:
 990                 case ADDRESS_TYPE:
 991 //              case CATEGORY_INFO:
 992                 case EVENT_DATE:
 993                 case EVENT_TYPE:
 994 //              case ANNIVERSARY_LABEL:
 995                 case ORGANIZATION_NAME:
 996                 case ORGANIZATION_DEPARTMENT:
 997 //              case ORGANIZATION_OFFICE:
 998                 case ORGANIZATION_TITLE:
 999                 case ORGANIZATION_ROLE:
1000 //              case ORGANIZATION_LOGO_URI:
1001                 {
1002                         table_name = table_key[TABLE_DATA];
1003                 }
1004                         break;
1005                 default:
1006                         break;
1007         }
1008
1009 //      ADVANCED_SVC_TRACE("table_name : %s", table_name);
1010         return table_name;
1011 }
1012
1013 char* _convert_x_attribute_to_table_name(contact_x_attribute_e attribute)
1014 {
1015         char* table_name = NULL;
1016         table_name = table_key[TABLE_DATA];
1017
1018         return table_name;
1019 }
1020
1021 char* _convert_condition_type_to_string(condition_type_e type)
1022 {
1023         char* string = NULL;
1024
1025         switch(type)
1026         {
1027                 case LEFT_BRACKET :
1028                 {
1029                         string = condition_type_key[0];
1030                 }
1031                         break;
1032                 case RIGHT_BRACKET:
1033                 {
1034                         string = condition_type_key[1];
1035                 }
1036                         break;
1037                 case AND:
1038                 {
1039                         string = condition_type_key[2];
1040                 }
1041                         break;
1042                 case OR:
1043                 {
1044                         string = condition_type_key[3];
1045                 }
1046                         break;
1047                 default:
1048                         break;
1049         }
1050
1051         ADVANCED_SVC_TRACE("condition type string : %s", string);
1052
1053         return string;
1054 }
1055
1056 void _query_get_count(const char* table_name, query_type_e query_type, int* count)
1057 {
1058         char query[128] = {0, };
1059         int rc = -1;
1060         stmt pStmt = NULL;
1061
1062         *count = 0;
1063
1064         memset(query, 0x00, sizeof(query));
1065
1066         switch(query_type)
1067         {
1068                 case QUERY_TO_PERSON:
1069                         snprintf(query, sizeof(query) - 1, "select count(%s) from %s", field_key[FIELD_PERSON_CONTACT_ID], table_name);
1070                         break;
1071                 case QUERY_TO_CONTACT:
1072                 {
1073                         if(strcmp(table_key[TABLE_PRESENCE], table_name) == 0)
1074                                 snprintf(query, sizeof(query) - 1, "select count(%s) from %s", field_key[FIELD_PRESENCE_CONTACT_ID], table_name);
1075                         else if(strcmp(table_key[TABLE_CONTACT], table_name) == 0)
1076                                 snprintf(query, sizeof(query) - 1, "select count(%s) from %s", field_key[FIELD_CONTACT_CONTACT_ID], table_name);
1077                         else if(strcmp(table_key[TABLE_GROUP_RELATION], table_name) == 0)
1078                                 snprintf(query, sizeof(query) - 1, "select count(%s) from %s", relation_field_key[FIELD_GROUP_RELATION_CONTACT_ID], table_name);
1079                 }
1080                         break;
1081                 default:
1082                         break;
1083         }
1084         ADVANCED_SVC_TRACE("query : %s", query);
1085
1086         rc = sqlite3_prepare_v2(g_hDBCt, query, strlen(query), &pStmt, NULL);
1087
1088         rc = sqlite3_step(pStmt);
1089         if(SQLITE_ROW == rc)
1090                 *count = sqlite3_column_int(pStmt, 0);
1091
1092         if(*count < 0)
1093                 *count = 0;
1094         ADVANCED_SVC_TRACE("*count : %d", *count);
1095
1096         sqlite3_finalize(pStmt);
1097 }
1098
1099 void __free_datatype_list(gpointer data, gpointer user_data)
1100 {
1101         ADVANCED_SVC_TRACE("__free_datatype_list");
1102 //      ADVANCED_SVC_TRACE("datatype : %d", ((datatype_t*)data)->datatype);
1103         OBJ_FREE(((datatype_t*)data)->field);
1104         OBJ_FREE(data);
1105 }
1106
1107 void __free_condition_list(gpointer data, gpointer user_data)
1108 {
1109         ADVANCED_SVC_TRACE("__free_condition_list");
1110 //      ADVANCED_SVC_TRACE("field : %s", ((datatype_t*)data)->field);
1111         OBJ_FREE(((condition_list_t*)data)->column_name);
1112         OBJ_FREE(((condition_list_t*)data)->condition);
1113         OBJ_FREE(data);
1114 }
1115
1116 void __free_condition_table_list(gpointer data, gpointer user_data)
1117 {
1118         ADVANCED_SVC_TRACE("__free_condition_table_list");
1119 //      ADVANCED_SVC_TRACE("field : %s", ((datatype_t*)data)->field);
1120         OBJ_FREE(((condition_table_t*)data)->table);
1121         OBJ_FREE(data);
1122 }
1123
1124 void __free_projection_list(gpointer data, gpointer user_data)
1125 {
1126         ADVANCED_SVC_TRACE("__free_projection_list");
1127 //      ADVANCED_SVC_TRACE("field : %s", ((datatype_t*)data)->field);
1128         OBJ_FREE(((projection_t*)data)->field);
1129         OBJ_FREE(data);
1130 }
1131
1132 void __free_condition_value_list(gpointer data, gpointer user_data)
1133 {
1134         ADVANCED_SVC_TRACE("__free_condition_value_list");
1135 //      ADVANCED_SVC_TRACE("field : %s", ((condition_val_t*)data)->value);
1136         OBJ_FREE(((condition_val_t*)data)->value);
1137         OBJ_FREE(data);
1138 }
1139
1140 void __free_email_list(gpointer data, gpointer user_data)
1141 {
1142         ADVANCED_SVC_TRACE("__free_email_list");
1143         OBJ_FREE(((email_t*)data)->email_addr);
1144         OBJ_FREE(((email_t*)data)->email_type);
1145         OBJ_FREE(((email_t*)data)->email_label);
1146         OBJ_FREE(data);
1147 }
1148
1149 void __free_number_list(gpointer data, gpointer user_data)
1150 {
1151         ADVANCED_SVC_TRACE("__free_email_list");
1152         OBJ_FREE(((number_t*)data)->number);
1153         OBJ_FREE(((number_t*)data)->number_type);
1154         OBJ_FREE(((number_t*)data)->number_label);
1155         OBJ_FREE(data);
1156 }
1157
1158 void __free_url_list(gpointer data, gpointer user_data)
1159 {
1160         ADVANCED_SVC_TRACE("__free_url_list");
1161         OBJ_FREE(((url_t*)data)->url_addr);
1162         OBJ_FREE(((url_t*)data)->url_type);
1163         OBJ_FREE(((url_t*)data)->url_label);
1164         OBJ_FREE(data);
1165 }
1166
1167 void __free_nickname_list(gpointer data, gpointer user_data)
1168 {
1169         ADVANCED_SVC_TRACE("__free_nickname_list");
1170         OBJ_FREE(((nick_name_t*)data)->nick_name);
1171         OBJ_FREE(data);
1172 }
1173
1174 void __free_address_list(gpointer data, gpointer user_data)
1175 {
1176         ADVANCED_SVC_TRACE("__free_address_list");
1177         OBJ_FREE(((address_t*)data)->country);
1178         OBJ_FREE(((address_t*)data)->region);
1179         OBJ_FREE(((address_t*)data)->county);
1180         OBJ_FREE(((address_t*)data)->city);
1181         OBJ_FREE(((address_t*)data)->street);
1182         OBJ_FREE(((address_t*)data)->postal_code);
1183         OBJ_FREE(((address_t*)data)->addtional);
1184         OBJ_FREE(((address_t*)data)->type);
1185         OBJ_FREE(data);
1186 }
1187
1188 void __free_organization_list(gpointer data, gpointer user_data)
1189 {
1190         if(data == NULL)
1191                 return;
1192         ADVANCED_SVC_TRACE("__free_organization_list");
1193         OBJ_FREE(((organization_t*)data)->organization_name);
1194         OBJ_FREE(((organization_t*)data)->department);
1195         OBJ_FREE(((organization_t*)data)->office);
1196         OBJ_FREE(((organization_t*)data)->title);
1197         OBJ_FREE(((organization_t*)data)->role);
1198         OBJ_FREE(((organization_t*)data)->logo_uri);
1199         OBJ_FREE(data);
1200 }
1201
1202 void __free_anniversary_list(gpointer data, gpointer user_data)
1203 {
1204         ADVANCED_SVC_TRACE("__free_anniversary_list");
1205         OBJ_FREE(((event_info_t*)data)->date);
1206         OBJ_FREE(((event_info_t*)data)->label);
1207         OBJ_FREE(data);
1208 }
1209
1210 void __free_category_list(gpointer data, gpointer user_data)
1211 {
1212         ADVANCED_SVC_TRACE("__free_category_list");
1213         OBJ_FREE(((category_t*)data)->category);
1214         OBJ_FREE(data);
1215 }
1216
1217 void __free_x_list(gpointer data, gpointer user_data)
1218 {
1219         ADVANCED_SVC_TRACE("__free_x_list");
1220         OBJ_FREE(((x_info_t*)data)->data2);
1221         OBJ_FREE(((x_info_t*)data)->data3);
1222         OBJ_FREE(((x_info_t*)data)->data4);
1223         OBJ_FREE(((x_info_t*)data)->data5);
1224         OBJ_FREE(((x_info_t*)data)->data6);
1225         OBJ_FREE(((x_info_t*)data)->data7);
1226         OBJ_FREE(((x_info_t*)data)->data8);
1227         OBJ_FREE(((x_info_t*)data)->data9);
1228         OBJ_FREE(((x_info_t*)data)->data10);
1229         OBJ_FREE(data);
1230 }
1231
1232 void _free_x_info(x_info_t* x_info)
1233 {
1234         if(x_info == NULL)
1235                 return;
1236
1237         OBJ_FREE(x_info->data2);
1238         OBJ_FREE(x_info->data3);
1239         OBJ_FREE(x_info->data4);
1240         OBJ_FREE(x_info->data5);
1241         OBJ_FREE(x_info->data6);
1242         OBJ_FREE(x_info->data7);
1243         OBJ_FREE(x_info->data8);
1244         OBJ_FREE(x_info->data9);
1245         OBJ_FREE(x_info->data10);
1246         OBJ_FREE(x_info);
1247 }
1248
1249 void _free_category_info(categories_info* category_info)
1250 {
1251         if(category_info == NULL)
1252                 return;
1253
1254         OBJ_FREE(category_info->name);
1255         OBJ_FREE(category_info);
1256 }
1257
1258 void _free_name_info(name_t* name_info)
1259 {
1260         if(name_info == NULL)
1261                 return;
1262
1263         OBJ_FREE(name_info->first_name);
1264         OBJ_FREE(name_info->middle_name);
1265         OBJ_FREE(name_info->last_name);
1266         OBJ_FREE(name_info->prefix);
1267         OBJ_FREE(name_info->phonetic_name);
1268         OBJ_FREE(name_info->display_name);
1269         OBJ_FREE(name_info);
1270 }
1271
1272 void _free_raw_contact_info(raw_contact_t* raw_contact_info)
1273 {
1274         if(raw_contact_info == NULL)
1275                 return;
1276
1277         OBJ_FREE(raw_contact_info->contact_id);
1278         OBJ_FREE(raw_contact_info->ringtone);
1279         OBJ_FREE(raw_contact_info->note);
1280         OBJ_FREE(raw_contact_info->is_favorite);
1281         OBJ_FREE(raw_contact_info->photo_uri);
1282         OBJ_FREE(raw_contact_info->birth_day);
1283         OBJ_FREE(raw_contact_info->last_updated_time_stamp);
1284         OBJ_FREE(raw_contact_info->read_only);
1285         OBJ_FREE(raw_contact_info->send_to_voice_mail);
1286         OBJ_FREE(raw_contact_info->latitude);
1287         OBJ_FREE(raw_contact_info->longitude);
1288         OBJ_FREE(raw_contact_info->account_id);
1289         OBJ_FREE(raw_contact_info->uid);
1290         OBJ_FREE(raw_contact_info);
1291 }
1292
1293 void _free_person_contact_info(person_contact_t* person_info)
1294 {
1295         if(person_info == NULL)
1296                 return;
1297
1298         OBJ_FREE(person_info->contact_id);
1299         OBJ_FREE(person_info->is_self);
1300         OBJ_FREE(person_info->contact_id_for_name);
1301         OBJ_FREE(person_info->contact_id_for_photo);
1302         OBJ_FREE(person_info->contactid_for_ringtone);
1303         OBJ_FREE(person_info->prefix);
1304         OBJ_FREE(person_info->first_name);
1305         OBJ_FREE(person_info->middle_name);
1306         OBJ_FREE(person_info->last_name);
1307         OBJ_FREE(person_info->phonetic_name);
1308         OBJ_FREE(person_info->display_name);
1309         OBJ_FREE(person_info->photo_URI);
1310         OBJ_FREE(person_info->last_updated_timestamp);
1311         OBJ_FREE(person_info->is_favorite);
1312         OBJ_FREE(person_info->send_to_voicemail);
1313         OBJ_FREE(person_info->ringtone);
1314         OBJ_FREE(person_info);
1315 }
1316
1317 void _free_num_info(number_t* num_info)
1318 {
1319         if(num_info == NULL)
1320                 return;
1321
1322         OBJ_FREE(num_info->number);
1323         OBJ_FREE(num_info->number_type);
1324         OBJ_FREE(num_info->number_label);
1325         OBJ_FREE(num_info);
1326 }
1327
1328 void _free_email_info(email_t* email_info)
1329 {
1330         if(email_info == NULL)
1331                 return;
1332
1333         OBJ_FREE(email_info->email_addr);
1334         OBJ_FREE(email_info->email_type);
1335         OBJ_FREE(email_info->email_label);
1336         OBJ_FREE(email_info);
1337 }
1338
1339 void _free_url_info(url_t* url_info)
1340 {
1341         if(url_info == NULL)
1342                 return;
1343
1344         OBJ_FREE(url_info->url_addr);
1345         OBJ_FREE(url_info->url_type);
1346         OBJ_FREE(url_info->url_label);
1347         OBJ_FREE(url_info);
1348 }
1349
1350 void _free_nick_info(nick_name_t* nick_info)
1351 {
1352         if(nick_info == NULL)
1353                 return;
1354
1355         OBJ_FREE(nick_info->nick_name);
1356         OBJ_FREE(nick_info);
1357 }
1358
1359 void _free_anniversary_info(event_info_t* event_info)
1360 {
1361         if(event_info == NULL)
1362                 return;
1363
1364         OBJ_FREE(event_info->date);
1365         OBJ_FREE(event_info->label);
1366         OBJ_FREE(event_info);
1367 }
1368
1369 void _free_organization_info(organization_t* organization_info)
1370 {
1371         if(organization_info == NULL)
1372                 return;
1373
1374         OBJ_FREE(organization_info->organization_name);
1375         OBJ_FREE(organization_info->department);
1376         OBJ_FREE(organization_info->office);
1377         OBJ_FREE(organization_info->title);
1378         OBJ_FREE(organization_info->role);
1379         OBJ_FREE(organization_info->logo_uri);
1380         OBJ_FREE(organization_info);
1381 }
1382
1383 void _free_address_info(address_t* address_info)
1384 {
1385         if(address_info == NULL)
1386                 return;
1387
1388         OBJ_FREE(address_info->country);
1389         OBJ_FREE(address_info->region);
1390         OBJ_FREE(address_info->county);
1391         OBJ_FREE(address_info->city);
1392         OBJ_FREE(address_info->street);
1393         OBJ_FREE(address_info->postal_code);
1394         OBJ_FREE(address_info->addtional);
1395         OBJ_FREE(address_info->type);
1396         OBJ_FREE(address_info);
1397 }
1398
1399 void _free_projection_list(gpointer data, gpointer user_data)
1400 {
1401 //      ADVANCED_SVC_TRACE("__free_projection_list");
1402 //      ADVANCED_SVC_TRACE("field : %s", ((projection_t*)data)->field);
1403         OBJ_FREE(((projection_t*)data)->field);
1404         OBJ_FREE(data);
1405 }
1406
1407 db_datatype _convert_datatype_to_db_type(predefine_datatype datatype)
1408 {
1409         db_datatype db_datatype_id = DB_DATATYPE_INVALID;
1410
1411         switch(datatype)
1412         {
1413                 case DATATYPE_NAME:
1414                         db_datatype_id = DB_DATATYPE_NAME;
1415                         break;
1416                 case DATATYPE_NUMBER:
1417                         db_datatype_id = DB_DATATYPE_NUMBER;
1418                         break;
1419                 case DATATYPE_EMAIL:
1420                         db_datatype_id = DB_DATATYPE_EMAIL;
1421                         break;
1422                 case DATATYPE_URL:
1423                         db_datatype_id = DB_DATATYPE_URL;
1424                         break;
1425                 case DATATYPE_NICK_NAME:
1426                         db_datatype_id = DB_DATATYPE_NICK_NAME;
1427                         break;
1428                 case DATATYPE_ADDRESS:
1429                         db_datatype_id = DB_DATATYPE_ADDRESS;
1430                         break;
1431                 case DATATYPE_ORGANIZATION:
1432                         db_datatype_id = DB_DATATYPE_ORGANIZATION;
1433                         break;
1434                 case DATATYPE_BIRTH_DAY:
1435                         db_datatype_id = DB_DATATYPE_EVENT;
1436                         break;
1437                 case DATATYPE_ANNIVERSARY:
1438                         db_datatype_id = DB_DATATYPE_EVENT;
1439                         break;
1440 /*
1441                 case DATATYPE_LBS_INFO:
1442                         db_datatype_id = DB_DATATYPE_LBS_INFO;
1443                         break;
1444                 case DATATYPE_CATEGORY:
1445                         db_datatype_id = DB_DATATYPE_CATEGORY;
1446                         break;
1447 */
1448                 default:
1449                         break;
1450         }
1451
1452         return db_datatype_id;
1453 }
1454
1455 query_error _set_person_datatype_list(advanced_handle_t* q_handle, contact_attribute_e attribute)
1456 {
1457         query_error error_code = QUERY_SUCCESS;
1458
1459         predefine_datatype datatype = DATATYPE_INVALID;
1460         datatype_t* datatype_info = NULL;
1461
1462         datatype = _convert_attribute_to_mimetype_id(attribute);
1463         ADVANCED_CATCH_SET_ERROR(((q_handle->assigned_datatype & datatype) == DATATYPE_INVALID), {}, QUERY_SUCCESS, ("DUPLICATED DATATYPE"));
1464
1465         datatype_info = g_new0(datatype_t, 1);
1466         ADVANCED_CATCH_SET_ERROR((datatype_info != NULL), {}, QUERY_ALLOCATE_MEMORY_FAIL, ("ALLOCATION FAIL"));
1467         datatype_info->field = g_strdup(field_key[FIELD_DATA_DATATYPE_ID]);
1468
1469         datatype_info->datatype = _convert_datatype_to_db_type(datatype);
1470         q_handle->datatype_list = g_list_append(q_handle->datatype_list, datatype_info);
1471         q_handle->assigned_datatype = (q_handle->assigned_datatype | datatype);
1472         q_handle->all_datatype_in_query = (q_handle->all_datatype_in_query | datatype);
1473
1474         ADVANCED_SVC_TRACE("q_handle->assigned_datatype : %d", q_handle->assigned_datatype);
1475
1476 CATCH:
1477         return error_code;
1478 }
1479
1480 query_error _set_datatype_list(advanced_handle_t* q_handle, contact_attribute_e attribute)
1481 {
1482         query_error error_code = QUERY_SUCCESS;
1483
1484         predefine_datatype datatype = DATATYPE_INVALID;
1485         datatype_t* datatype_info = NULL;
1486
1487         datatype = _convert_attribute_to_mimetype_id(attribute);
1488         ADVANCED_CATCH_SET_ERROR((datatype != DATATYPE_INVALID), {}, QUERY_INVALID_ATTRIBUTE, ("INVALID ATTRIBUTE"));
1489         ADVANCED_CATCH_SET_ERROR(((q_handle->assigned_datatype & datatype) == DATATYPE_INVALID), {}, QUERY_SUCCESS, ("DUPLICATED DATATYPE"));
1490
1491         datatype_info = g_new0(datatype_t, 1);
1492         ADVANCED_CATCH_SET_ERROR((datatype_info != NULL), {}, QUERY_ALLOCATE_MEMORY_FAIL, ("ALLOCATION FAIL"));
1493         datatype_info->field = g_strdup(field_key[FIELD_DATA_DATATYPE_ID]);
1494
1495         datatype_info->datatype = _convert_datatype_to_db_type(datatype);
1496         q_handle->datatype_list = g_list_append(q_handle->datatype_list, datatype_info);
1497         q_handle->assigned_datatype = (q_handle->assigned_datatype | datatype);
1498         q_handle->all_datatype_in_query = (q_handle->all_datatype_in_query | datatype);
1499
1500 //      ADVANCED_SVC_TRACE("q_handle->assigned_datatype : %d", q_handle->assigned_datatype);
1501
1502 CATCH:
1503         return error_code;
1504 }
1505
1506 query_error _set_datatype_list_by_x_attribute(advanced_handle_t* q_handle, int datatype_id, contact_x_attribute_e attribute)
1507 {
1508         query_error error_code = QUERY_SUCCESS;
1509         datatype_t* datatype_info = NULL;
1510
1511         GList* tmp_list = q_handle->datatype_list;
1512         while(tmp_list)
1513         {
1514                 datatype_t* tmp_info = (datatype_t*)tmp_list->data;
1515                 ADVANCED_CATCH_SET_ERROR((tmp_info->datatype != datatype_id), {}, QUERY_SUCCESS, ("DUPLICATED DATATYPE"));
1516                 tmp_list = g_list_next(tmp_list);
1517         }
1518
1519         datatype_info = g_new0(datatype_t, 1);
1520         ADVANCED_CATCH_SET_ERROR((datatype_info != NULL), {}, QUERY_ALLOCATE_MEMORY_FAIL, ("ALLOCATION FAIL"));
1521         datatype_info->field = g_strdup(field_key[FIELD_DATA_DATATYPE_ID]);
1522
1523         datatype_info->datatype = datatype_id;
1524         q_handle->datatype_list = g_list_append(q_handle->datatype_list, datatype_info);
1525         q_handle->assigned_datatype = (q_handle->assigned_datatype | DATATYPE_X_ATTRIBUTE);
1526         q_handle->all_datatype_in_query = (q_handle->all_datatype_in_query | DATATYPE_X_ATTRIBUTE);
1527
1528         ADVANCED_SVC_TRACE("q_handle->assigned_datatype : %d", q_handle->assigned_datatype);
1529
1530 CATCH:
1531         return error_code;
1532 }
1533
1534 char* _convert_condition_to_string(condition_e condition)
1535 {
1536         char* condition_val = NULL;
1537
1538         switch(condition)
1539         {
1540                 case EQUAL :
1541                 {
1542                         condition_val = condition_key[EQUAL];
1543                 }
1544                 break;
1545                 case NOT_EQUAL:
1546                 {
1547                         condition_val = condition_key[NOT_EQUAL];
1548                 }
1549                 break;
1550                 case GREATER_THAN:
1551                 {
1552                         condition_val = condition_key[GREATER_THAN];
1553                 }
1554                 break;
1555                 case LESS_THAN:
1556                 {
1557                         condition_val = condition_key[LESS_THAN];
1558                 }
1559                 break;
1560                 case GREATER_THAN_OR_EQUAL:
1561                 {
1562                         condition_val = condition_key[GREATER_THAN_OR_EQUAL];
1563                 }
1564                 break;
1565                 case LESS_THAN_OR_EQUAL:
1566                 {
1567                         condition_val = condition_key[LESS_THAN_OR_EQUAL];
1568                 }
1569                 break;
1570                 case BITWISE_AND:
1571                 {
1572                         condition_val = condition_key[BITWISE_AND];
1573                 }
1574                 break;
1575                 case BITWISE_OR:
1576                 {
1577                         condition_val = condition_key[BITWISE_OR];
1578                 }
1579                 break;
1580                 case LIKE:
1581                 {
1582                         condition_val = condition_key[LIKE];
1583                 }
1584                 break;
1585                 default:
1586                         break;
1587         }
1588         ADVANCED_SVC_TRACE("condition_val : %s", condition_val);
1589
1590         return condition_val;
1591 }
1592
1593 void _free_handle_info(advanced_handle_t* handle)
1594 {
1595         if(handle == NULL)
1596         {
1597                 ADVANCED_SVC_TRACE("HANDLE IS ALREAD FREE");
1598                 return;
1599         }
1600
1601         int i = 0;
1602
1603 // Free Glist
1604         g_list_foreach(handle->datatype_list, __free_datatype_list, NULL);
1605         g_list_foreach(handle->new_projection, __free_projection_list, NULL);
1606         g_list_foreach(handle->condition_value, __free_condition_value_list, NULL);
1607         g_list_foreach(handle->condition_list, __free_condition_list, NULL);
1608         g_list_foreach(handle->condition_table_list, __free_condition_table_list, NULL);
1609
1610         g_list_free(handle->datatype_list);
1611         g_list_free(handle->new_projection);
1612         g_list_free(handle->condition_value);
1613         g_list_free(handle->condition_list);
1614         g_list_free(handle->condition_table_list);
1615
1616 // Free g_string
1617         g_string_free (handle->table_list, TRUE);
1618         g_string_free (handle->condition_text, TRUE);
1619         g_string_free (handle->use_normal_field_key, TRUE);
1620         g_string_free (handle->use_contact_table_id, TRUE);
1621         g_string_free (handle->order, TRUE);
1622         g_string_free (handle->id_list, TRUE);
1623
1624 // free result set
1625         for(i = 0; i < handle->total_result_set_count; i++)
1626         {
1627                 g_list_foreach(handle->result_set[i].contact_info->number_list, __free_number_list, NULL);
1628                 g_list_foreach(handle->result_set[i].contact_info->email_list, __free_email_list, NULL);
1629
1630                 g_list_foreach(handle->result_set[i].contact_info->url_list, __free_url_list, NULL);
1631                 g_list_foreach(handle->result_set[i].contact_info->nickname_list, __free_nickname_list, NULL);
1632                 g_list_foreach(handle->result_set[i].contact_info->address_list, __free_address_list, NULL);
1633                 g_list_foreach(handle->result_set[i].contact_info->organization_list, __free_organization_list, NULL);
1634                 g_list_foreach(handle->result_set[i].contact_info->event_list, __free_anniversary_list, NULL);
1635                 g_list_foreach(handle->result_set[i].contact_info->category_list, __free_category_list, NULL);
1636                 g_list_foreach(handle->result_set[i].contact_info->x_list, __free_x_list, NULL);
1637
1638                 g_list_free(handle->result_set[i].contact_info->url_list);
1639                 g_list_free(handle->result_set[i].contact_info->nickname_list);
1640                 g_list_free(handle->result_set[i].contact_info->address_list);
1641                 g_list_free(handle->result_set[i].contact_info->organization_list);
1642                 g_list_free(handle->result_set[i].contact_info->event_list);
1643                 g_list_free(handle->result_set[i].contact_info->category_list);
1644                 g_list_free(handle->result_set[i].contact_info->x_list);
1645
1646                 _free_person_contact_info(handle->result_set[i].contact_info->person_info);
1647                 _free_raw_contact_info(handle->result_set[i].contact_info->raw_contact_info);
1648
1649                 _free_name_info(handle->result_set[i].contact_info->name_info);
1650                 _free_num_info(handle->result_set[i].contact_info->num_info);
1651                 _free_email_info(handle->result_set[i].contact_info->email_info);
1652                 _free_url_info(handle->result_set[i].contact_info->url_info);
1653                 _free_nick_info(handle->result_set[i].contact_info->nick_info);
1654                 _free_address_info(handle->result_set[i].contact_info->address_info);
1655                 _free_organization_info(handle->result_set[i].contact_info->organization_info);
1656                 _free_anniversary_info(handle->result_set[i].contact_info->event_info);
1657                 _free_x_info(handle->result_set[i].contact_info->x_info);
1658
1659                 OBJ_FREE(handle->result_set[i].contact_info);
1660         }
1661
1662         OBJ_FREE(handle->result_set);
1663
1664         for(i = 0; i < handle->total_result_set_count; i++)
1665         {
1666                 OBJ_FREE(handle->mapping_id_to_result_set);
1667         }
1668
1669         for(i = 0; i < handle->total_result_set_count; i++)
1670         {
1671                 OBJ_FREE(handle->ordering_list);
1672         }
1673
1674         _free_category_info(handle->category);
1675
1676         OBJ_FREE(handle->query_string);
1677         OBJ_FREE(handle->ordering_list);
1678         OBJ_FREE(handle->full_ordered_contact_id);
1679         OBJ_FREE(handle->condition_category);
1680         OBJ_FREE(handle->condition_category_op);
1681         OBJ_FREE(handle);
1682 }
1683
1684 int _free_for_limit_iter(advanced_handle_t* handle)
1685 {
1686         int i = 0;
1687         int id = 0;
1688         char* contact_id = NULL;
1689
1690 // free result set
1691         for(i = 0; i < handle->total_result_set_count; i++)
1692         {
1693                 if(handle->result_set[i].contact_info->raw_contact_info)
1694                 {
1695                         contact_id = handle->result_set[i].contact_info->raw_contact_info->contact_id;
1696                         char *value = contact_id;
1697                         char *end_ptr = value;
1698                         errno = 0;
1699                         id = (int)strtol(value, &end_ptr, 0);
1700                         if(errno == ERANGE || end_ptr == value)
1701                         {
1702                                 ADVANCED_SVC_TRACE("contact_id is wrong : %s", contact_id);
1703                                 return 0;
1704                         }
1705                         ADVANCED_SVC_TRACE("id : %d", id);
1706                 }
1707
1708                 if(handle->result_set[i].contact_info->person_info)
1709                 {
1710                         contact_id = handle->result_set[i].contact_info->person_info->contact_id;
1711                         if(handle->result_set[i].contact_info->person_info->contact_id)
1712                         {
1713                                 char *value = contact_id;
1714                                 char *end_ptr = value;
1715                                 errno = 0;
1716                                 id = (int)strtol(value, &end_ptr, 0);
1717                                 if(errno == ERANGE || end_ptr == value)
1718                                 {
1719                                         ADVANCED_SVC_TRACE("contact_id is wrong : %s", contact_id);
1720                                         return 0;
1721                                 }
1722                                 ADVANCED_SVC_TRACE("id : %d", id);
1723                         }
1724                 }
1725
1726                 g_list_foreach(handle->result_set[i].contact_info->number_list, __free_number_list, NULL);
1727                 g_list_foreach(handle->result_set[i].contact_info->email_list, __free_email_list, NULL);
1728
1729                 g_list_foreach(handle->result_set[i].contact_info->url_list, __free_url_list, NULL);
1730                 g_list_foreach(handle->result_set[i].contact_info->nickname_list, __free_nickname_list, NULL);
1731                 g_list_foreach(handle->result_set[i].contact_info->address_list, __free_address_list, NULL);
1732                 g_list_foreach(handle->result_set[i].contact_info->organization_list, __free_organization_list, NULL);
1733                 g_list_foreach(handle->result_set[i].contact_info->event_list, __free_anniversary_list, NULL);
1734                 g_list_foreach(handle->result_set[i].contact_info->category_list, __free_category_list, NULL);
1735
1736                 _free_person_contact_info(handle->result_set[i].contact_info->person_info);
1737                 _free_raw_contact_info(handle->result_set[i].contact_info->raw_contact_info);
1738
1739                 _free_name_info(handle->result_set[i].contact_info->name_info);
1740                 _free_num_info(handle->result_set[i].contact_info->num_info);
1741                 _free_email_info(handle->result_set[i].contact_info->email_info);
1742                 _free_url_info(handle->result_set[i].contact_info->url_info);
1743                 _free_nick_info(handle->result_set[i].contact_info->nick_info);
1744                 _free_address_info(handle->result_set[i].contact_info->address_info);
1745                 _free_organization_info(handle->result_set[i].contact_info->organization_info);
1746                 _free_anniversary_info(handle->result_set[i].contact_info->event_info);
1747
1748                 OBJ_FREE(handle->result_set[i].contact_info);
1749         }
1750         OBJ_FREE(handle->result_set);
1751
1752         for(i = 0; i < handle->total_result_set_count; i++)
1753                 OBJ_FREE(handle->mapping_id_to_result_set);
1754
1755         for(i = 0; i < handle->total_result_set_count; i++)
1756                 OBJ_FREE(handle->ordering_list);
1757
1758         return id;
1759 }
1760
1761 query_error _normalize_str(const char* src, char* dest, int dest_size)
1762 {
1763         query_error error_code = QUERY_SUCCESS;
1764
1765         int32_t size = 0;
1766         UErrorCode status = 0;
1767         UChar* tmp_result = NULL;
1768         UChar* result = NULL;
1769
1770         tmp_result = g_new0(UChar, (dest_size + 1));
1771         result = g_new0(UChar, (dest_size + 1));
1772
1773         u_strFromUTF8(tmp_result, dest_size, NULL, src, -1, &status);
1774         ADVANCED_CATCH_SET_ERROR((U_FAILURE(status) == 0), {}, QUERY_NORMALIZATION_ERROR, ("u_strFromUTF8 FAIL(%s)", u_errorName(status)));
1775
1776         u_strToLower(tmp_result, dest_size, tmp_result, -1, NULL, &status);
1777         ADVANCED_CATCH_SET_ERROR((U_FAILURE(status) == 0), {}, QUERY_NORMALIZATION_ERROR, ("u_strToLower FAIL(%s)", u_errorName(status)));
1778
1779         ADVANCED_SVC_TRACE("src : %s", src);
1780
1781         size = unorm_normalize(tmp_result, -1, UNORM_NFD, 0, (UChar *)result, dest_size, &status);
1782         ADVANCED_CATCH_SET_ERROR((U_FAILURE(status) == 0), {}, QUERY_NORMALIZATION_ERROR, ("unorm_normalize FAIL(%s)", u_errorName(status)));
1783
1784         u_strToUTF8(dest, dest_size, &size, result, -1, &status);
1785         ADVANCED_CATCH_SET_ERROR((U_FAILURE(status) == 0), {}, QUERY_NORMALIZATION_ERROR, ("u_strToUTF8 FAIL(%s)", u_errorName(status)));
1786
1787         ADVANCED_SVC_TRACE("dest : %s", (char *)dest);
1788
1789 CATCH:
1790         g_free(tmp_result);
1791         g_free(result);
1792
1793         return error_code;
1794 }
1795
1796 query_error _remove_invalid_chars(char *src, char* desc)
1797 {
1798         ADVANCED_RETURN_VAL((src != NULL), {}, QUERY_NULL_PARAMETER, ("SOURCE STRING IS NULL"));
1799         ADVANCED_SVC_TRACE("%s", src);
1800
1801         int     i = 0;
1802         int     j = 0;
1803         int     nSrc = 0;
1804         query_error error_code = QUERY_SUCCESS;
1805
1806         nSrc = strlen(src);
1807
1808         for(i = 0; i < nSrc; ++i)
1809         {
1810                 switch(src[i])
1811                 {
1812                         case '[':
1813                         case '\\':
1814                         case ']':
1815                         case '^':
1816                         case '_':
1817                         case '`':
1818                         case ' ':
1819 /*
1820                         case '(':
1821                         case ')':
1822                         case '-':
1823                         case ' ':
1824                         case '/':
1825 */
1826                                 break;
1827                         default:
1828                                 desc[j++] = src[i];
1829                                 break;
1830                 }
1831         }
1832         desc[j] = '\0';
1833         ADVANCED_SVC_TRACE("%s", desc);
1834
1835         return error_code;
1836 }
1837
1838 int _convert_type_string_to_int(contact_attribute_e attribute, const char* value)
1839 {
1840         int integer_value = 0;
1841         char* loc = 0;
1842         int i = 0;
1843
1844         switch(attribute)
1845         {
1846                 case CONTACT_ID :
1847                 case ACCOUNT_ID :
1848                 {
1849                         char *end_ptr = value;
1850                         errno = 0;
1851                         integer_value = (int)strtol(value, &end_ptr, 0);
1852                         if(errno == ERANGE || end_ptr == value)
1853                         {
1854                                 ADVANCED_SVC_TRACE("contact_id is wrong : %s", contact_id);
1855                                 return 0;
1856                         }
1857                         ADVANCED_SVC_TRACE("id : %d", id);
1858                 }
1859                         break;
1860                 case CONTACT_LAST_UPDATED_TIME_STAMP :
1861                 {
1862                         char *end_ptr = value;
1863                         errno = 0;
1864                         integer_value = (int)strtol(value, &end_ptr, 0);
1865                         if(errno == ERANGE || end_ptr == value)
1866                         {
1867                                 ADVANCED_SVC_TRACE("contact_id is wrong : %s", contact_id);
1868                                 return 0;
1869                         }
1870                 }
1871                         break;
1872 //              case CONTACT_READ_ONLY :
1873 //              case CONTACT_SEND_TO_VOICE_MAIL :
1874                 case CONTACT_IS_FAVORITE :
1875                 {
1876                         if(strcmp(value, "TRUE") == 0)
1877                                 integer_value = 1;
1878                         else if(strcmp(value, "FALSE") == 0)
1879                                 integer_value = 0;
1880                 }
1881                         break;
1882                 case NUMBER_TYPES:
1883                 {
1884                         for(i = 1; i <= MAX_NUMBER_TYPE; i++)
1885                         {
1886                                 loc = strstr(value, number_type_str[i]);
1887                                 if(loc != NULL)
1888                                 {
1889                                         switch(i)
1890                                         {
1891                                                 case 1:
1892                                                         integer_value = (integer_value | HOME);
1893                                                         break;
1894                                                 case 2:
1895                                                         integer_value = (integer_value | WORK);
1896                                                         break;
1897                                                 case 3:
1898                                                         integer_value = (integer_value | VOICE);
1899                                                         break;
1900                                                 case 4:
1901                                                         integer_value = (integer_value | FAX);
1902                                                         break;
1903                                                 case 5:
1904                                                         integer_value = (integer_value | MSG);
1905                                                         break;
1906                                                 case 6:
1907                                                         integer_value = (integer_value | CELL);
1908                                                         break;
1909                                                 case 7:
1910                                                         integer_value = (integer_value | PAGER);
1911                                                         break;
1912                                                 case 8:
1913                                                         integer_value = (integer_value | BBS);
1914                                                         break;
1915                                                 case 9:
1916                                                         integer_value = (integer_value | MODEM);
1917                                                         break;
1918                                                 case 10:
1919                                                         integer_value = (integer_value | CAR);
1920                                                         break;
1921                                                 case 11:
1922                                                         integer_value = (integer_value | ISDN);
1923                                                         break;
1924                                                 case 12:
1925                                                         integer_value = (integer_value | VIDEO);
1926                                                         break;
1927                                                 case 13:
1928                                                         integer_value = (integer_value | PCS);
1929                                                         break;
1930                                                 default:
1931                                                         break;
1932                                         }
1933                                 }
1934                         }
1935                 }
1936                         break;
1937                 case EMAIL_TYPE:
1938                 {
1939                         for(i = 1; i <= MAX_EMAIL_TYPE; i++)
1940                         {
1941                                 loc = strstr(value, email_type_str[i]);
1942                                 if(loc != NULL)
1943                                 {
1944                                         switch(i)
1945                                         {
1946                                                 case 1:
1947                                                         integer_value = (integer_value | EMAIL_HOME);
1948                                                         break;
1949                                                 case 2:
1950                                                         integer_value = (integer_value | EMAIL_WORK);
1951                                                         break;
1952                                                 default:
1953                                                         break;
1954                                         }
1955                                 }
1956                         }
1957                 }
1958                         break;
1959                 case URL_TYPE:
1960                 {
1961                         for(i = 1; i < URL_TYPE_MAX; i++)
1962                         {
1963                                 if(strcmp(url_type_str[i], value) == 0)
1964                                 {
1965                                         integer_value = URL_HOME;
1966                                         break;
1967                                 }else
1968                                 {
1969                                         integer_value = URL_WORK;
1970                                         break;
1971                                 }
1972                         }
1973                 }
1974                         break;
1975                 case ADDRESS_TYPE:
1976                 {
1977                         for(i = 1; i <= MAX_ADDRESS_TYPE; i++)
1978                         {
1979                                 loc = strstr(value, addr_type_str[i]);
1980                                 if(loc != NULL)
1981                                 {
1982                                         switch(i)
1983                                         {
1984                                                 case 1:
1985                                                         integer_value = (integer_value | ADDRESS_TYPE_HOME);
1986                                                         break;
1987                                                 case 2:
1988                                                         integer_value = (integer_value | ADDRESS_TYPE_WORK);
1989                                                         break;
1990                                                 case 3:
1991                                                         integer_value = (integer_value | ADDRESS_TYPE_DOM);
1992                                                         break;
1993                                                 case 4:
1994                                                         integer_value = (integer_value | ADDRESS_TYPE_INTL);
1995                                                         break;
1996                                                 case 5:
1997                                                         integer_value = (integer_value | ADDRESS_TYPE_POSTAL);
1998                                                         break;
1999                                                 case 6:
2000                                                         integer_value = (integer_value | ADDRESS_TYPE_PARCEL);
2001                                                         break;
2002                                                 default:
2003                                                         break;
2004                                         }
2005                                 }
2006                         }
2007                 }
2008                         break;
2009                 case EVENT_TYPE:
2010                 {
2011                         for(i = 0; i < EVENT_TYPE_MAX; i++)
2012                         {
2013                                 if(strcmp(event_type_str[i], value) == 0)
2014                                 {
2015                                         integer_value = EVENT_BIRTHDAY;
2016                                         break;
2017                                 }else
2018                                 {
2019                                         integer_value = EVENT_ANNIVERSARY;
2020                                         break;
2021                                 }
2022                         }
2023                 }
2024                         break;
2025                 default:
2026                         break;
2027         }
2028 //      ADVANCED_SVC_TRACE("integer_value : %d", integer_value);
2029
2030         return (int)integer_value;
2031 }
2032
2033 int _is_type_bitwise_int(contact_attribute_e attribute)
2034 {
2035         switch(attribute)
2036         {
2037                 case NUMBER_TYPES:
2038                 case EMAIL_TYPE:
2039                 case URL_TYPE:
2040                 case ADDRESS_TYPE:
2041                         return TRUE;
2042                         break;
2043                 default:
2044                         break;
2045         }
2046 //      ADVANCED_SVC_TRACE("integer_value : %d", integer_value);
2047
2048         return FALSE;
2049 }
2050