src/framework/data-adapter/agent.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <pthread.h>
  19 #include <glib.h>
  20 #include <glib/gprintf.h>
  21
  22 #include "utility/sync_util.h"
  23 #include "data-adapter/common_internal.h"
  24 #include "data-adapter/agent_handler_manager.h"
  25 #include "data-adapter/agent_handler_manager_internal.h"
  26 #include "data-adapter/agent.h"
  27 #include "data-adapter/luid.h"
  28
  29 #include "data-adapter/interface_item.h"
  30 #include "data-adapter/interface_last_anchor.h"
  31 #include "data-adapter/interface_mapping.h"
  32
  33 #ifndef SYNC_AGENT_LOG
  34 #undef LOG_TAG
  35 #define LOG_TAG "AF_DACI"
  36 #endif
  37
  38 /* static function define */
  39 static int _busy_handler(void *pData, int count);
  40 static sync_agent_da_return_e __query_exec(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, char *err_msg);
  41 static daci_stmt __query_prepare(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, int size);
  42 static sync_agent_da_return_e __stmt_bind_text(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const char *value);
  43 static sync_agent_da_return_e _stmt_bind_int(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const int value);
  44 static sync_agent_da_return_e _stmt_bind_blob(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const void *value, int nbyte);
  45 static sync_agent_da_return_e __stmt_bind_null(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index);
  46 static sync_agent_da_return_e _stmt_read_step(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt);
  47 static sync_agent_da_return_e __stmt_write_step(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt);
  48 static sync_agent_da_return_e _stmt_reset(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt);
  49 static sync_agent_da_return_e __stmt_finalize(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt);
  50 static char *_stmt_column_text(daci_stmt stmt, int index);
  51 static int __stmt_column_int(daci_stmt stmt, int index);
  52 static sync_agent_da_return_e _get_table(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, char ***result, int *row_count, int *col_count);
  53 static void __free_table(char **result);
  54
  55 static sync_agent_da_return_e _create_changelog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id);
  56 static sync_agent_da_return_e _drop_changelog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id);
  57 static sync_agent_da_return_e _delete_changlog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id);
  58
  59 static int __exist_table(SYNC_AGENT_DA_HANDLER * daci_handler, const char *table_name);
  60 static int _get_data_count(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, int size);
  61 static char *__replace_table_name(char *old, int account_id, int count);
  62 static char *__get_table_name(sync_agent_da_table_name_e table_name);
  63 static char *_get_column_name(sync_agent_da_column_name_e column_name);
  64 static int _get_next_account_id(void);
  65 static sync_agent_da_return_e _delete_account(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_table_name_e table_name, int account_id);
  66
  67 static char *daci_file_path = 0;
  68 static pthread_t use_transaction_thread_id = 0;
  69 static pthread_mutex_t transaction_lock = PTHREAD_MUTEX_INITIALIZER;
  70 static pthread_mutex_t exec_lock = PTHREAD_MUTEX_INITIALIZER;
  71
  72 static char *g_daci_create_table[] = {
  73         /* 1. create account_tbl */
  74         "create table account_tbl" "(" "account_id integer not null," "email_address varchar(51) not null," "password varchar(51) not null," "enable boolean not null default 1," "last_update date not null default current_timestamp,"
  75             "access_name varchar(64) not null," "constraint account_tbl_pk primary key(account_id)" ");",
  76
  77         /* 2. create folder_tbl */
  78         "create table folder_tbl" "(" "folder_id varchar(64) not null," "data_store_id integer not null," "account_id integer not null," "folder_type_id integer not null," "service_id varchar(20) default null," "parent_folder_id varchar(64) default null,"
  79             "last_update date not null default current_timestamp," "access_name varchar(64) not null," "constraint folder_tbl_pk primary key(folder_id)," "constraint folder_tbl_account_id_fk foreign key(account_id) references account_tbl(account_id)" ");",
  80
  81         /* 3. create item_tbl */
  82         "create table item_tbl"
  83             "("
  84             "item_id varchar(64) not null,"
  85             "data_store_id integer not null," "account_id integer not null," "folder_id varchar(64) not null," "service_id varchar(20) not null," "last_update date not null default current_timestamp," "access_name varchar(64) not null,"
  86             "constraint item_tbl_pk primary key(item_id)," "constraint item_tbl_account_id_fk foreign key(account_id) references account_tbl(account_id)," "constraint itme_tbl_folder_id_fk foreign key(folder_id) references folder_tbl(folder_id),"
  87             "constraint item_tbl_uk unique(data_store_id, account_id, service_id)" ");",
  88
  89         /* 4. create config_tbl */
  90         "create table config_tbl" "(" "config_id integer not null," "key varchar(50) not null," "value varchar(30) default null," "type varchar(10) default null," "last_update date not null default current_timestamp," "access_name varchar(64) not null,"
  91             "constraint config_tbl_pk primary key(config_id, Key)" ");",
  92
  93         /* 5. create account_item_changelog_tbl */
  94         "create table account_%d_item_changelog_tbl" "(" "item_id varchar(64) not null," "operation_id integer not null," "status varchar(15) not null default \'SYNC_REQUIRED\'," "last_update date not null default current_timestamp,"
  95             "access_name varchar(64) not null," "constraint account_%d_item_changelog_tbl_pk primary key(item_id)," "constraint account_%d_item_changelog_tbl_item_id_fk foreign key(item_id) references item_tbl(item_id)" ");",
  96
  97         /* 6. create last_anchor_tbl */
  98         "create table last_anchor_tbl" "(" "account_id integer not null," "data_store_id integer not null," "last_anchor_server varchar(20) default null," "last_anchor_client varchar(20) default null," "last_update date not null default current_timestamp,"
  99             "access_name varchar(64) not null," "constraint last_anchor_tbl_pk primary key(account_id, data_store_id)," "constraint last_anchor_tbl_account_id_fk foreign key(account_id) references account_tbl(account_id)" ");",
 100
 101         /* 7. create mapping_tbl */
 102         "create table mapping_tbl" "(" "account_id integer not null," "data_store_id integer not null," "luid varchar(64) default null," "guid varchar(64) default null," "last_update date not null default current_timestamp,"
 103             "access_name varchar(64) not null," "constraint mapping_tbl_pk primary key(account_id, luid)," "constraint mapping_tbl_account_id_fk foreign key(account_id) references account_tbl(account_id)" ");",
 104
 105         /* 8. create id_provider_tbl */
 106         "create table id_provider_tbl" "(" "id_provider_code integer not null," "id_capacity integer not null," "bit_per_page integer not null," "last_id integer not null," "free_bit_cnt integer not null,"
 107             "constraint id_provider_tbl_pk primary key(id_provider_code)" ");",
 108
 109         /* 9. create id_page_tbl */
 110         "create table id_page_tbl" "(" "page_index integer not null," "id_provider_code integer not null," "page_bit BLOB," "constraint id_page_tbl_pk primary key(page_index, id_provider_code),"
 111             "constraint id_page_tbl_fk foreign key(id_provider_code) references id_provider_tbl(id_provider_code)" ");"
 112 };
 113
 114 static char *g_daci_drop_table[] = {
 115         /* 1. drop account_tbl */
 116         "drop table account_tbl",
 117
 118         /* 2. drop folder_tbl */
 119         "drop table folder_tbl",
 120
 121         /* 3. drop item_tbl */
 122         "drop table item_tbl",
 123
 124         /* 4. drop config_tbl */
 125         "drop table config_tbl",
 126
 127         /* 5. drop account_item_changelog_tbl */
 128         "drop table account_%d_item_changelog_tbl",
 129
 130         /* 6. drop last_anchor_tbl */
 131         "drop table last_anchor_tbl",
 132
 133         /* 7. drop mapping_tbl */
 134         "drop table mapping_tbl",
 135
 136         /* 8. drop id_provider_tbl */
 137         "drop table id_provider_tbl",
 138
 139         /* 9. drop id_page_tbl */
 140         "drop table id_page_tbl"
 141 };
 142
 143 static char *g_daci_delete_table[] = {
 144         /* 1. delete account_tbl */
 145         "delete from account_tbl",
 146
 147         /* 2. delete folder_tbl */
 148         "delete from folder_tbl",
 149
 150         /* 3. delete item_tbl */
 151         "delete from item_tbl",
 152
 153         /* 4. delete config_tbl */
 154         "delete from config_tbl",
 155
 156         /* 5. delete account_item_changelog_tbl */
 157         "delete from account_%d_item_changelog_tbl",
 158
 159         /* 6. delete last_anchor_tbl */
 160         "delete from last_anchor_tbl",
 161
 162         /* 7. delete mapping_tbl */
 163         "delete from mapping_tbl",
 164
 165         /* 8. delete id_provider_tbl */
 166         "delete from id_provider_tbl",
 167
 168         /* 9. delete id_page_tbl */
 169         "delete from id_page_tbl"
 170 };
 171
 172 sync_agent_da_return_e da_open_agent(SYNC_AGENT_DA_HANDLER ** daci_handler)
 173 {
 174         _EXTERN_FUNC_ENTER;
 175
 176         int ret = 0;
 177
 178         if (*daci_handler == NULL) {
 179
 180                 /* db open */
 181                 /*  ret = db_util_open(DACI_FILE_PATH, &(*daci_handler), 0); */
 182
 183                 ret = sqlite3_open(daci_file_path, daci_handler);
 184                 if (ret != SQLITE_OK)
 185                         goto DACI_FINISH;
 186
 187                 /* register busy handler */
 188                 ret = sqlite3_busy_handler(*daci_handler, _busy_handler, 0);
 189                 if (ret != SQLITE_OK) {
 190                         _DEBUG_INFO("Fail to register busy handler");
 191                         goto DACI_FINISH;
 192                 }
 193
 194                 _DEBUG_INFO("agent_db_open_success");
 195
 196         } else {
 197                 _DEBUG_INFO("agent_db_already_opened");
 198         }
 199
 200         _EXTERN_FUNC_EXIT;
 201
 202         return SYNC_AGENT_DA_SUCCESS;
 203
 204  DACI_FINISH:
 205
 206         _DEBUG_ERROR("agent_open failed(%d) : %s", ret, sqlite3_errmsg(*daci_handler));
 207
 208         sqlite3_close(*daci_handler);
 209         *daci_handler = 0;
 210
 211         return SYNC_AGENT_DA_ERR_OPEN_FAILED;
 212 }
 213
 214 sync_agent_da_return_e da_close_Agent(SYNC_AGENT_DA_HANDLER * daci_handler)
 215 {
 216         _EXTERN_FUNC_ENTER;
 217
 218         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_CLOSE_FAILED, "SYNC_AGENT_DA_HANDLER is NULL !!");
 219
 220         int ret = 0;
 221         ret = sqlite3_close(daci_handler);
 222         daci_handler = 0;
 223
 224         if (ret != SQLITE_OK) {
 225                 _DEBUG_ERROR("agent_db_agent_close failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
 226                 return SYNC_AGENT_DA_ERR_CLOSE_FAILED;
 227         }
 228
 229         _DEBUG_INFO("agent_db_agent_close_success");
 230
 231         _EXTERN_FUNC_EXIT;
 232
 233         return SYNC_AGENT_DA_SUCCESS;
 234 }
 235
 236 sync_agent_da_return_e da_begin_transaction(SYNC_AGENT_DA_HANDLER * daci_handler)
 237 {
 238         _EXTERN_FUNC_ENTER;
 239
 240         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_TRANSACTION_FAILED, "SYNC_AGENT_DA_HANDLER is NULL !!");
 241
 242         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 243
 244         int err_mutex = pthread_mutex_lock(&transaction_lock);
 245         if (err_mutex) {
 246                 _DEBUG_INFO("Failed pthread_mutex_lock : %d", err_mutex);
 247         }
 248
 249         use_transaction_thread_id = SYNC_AGENT_DA_GET_THREAD_ID;
 250
 251         ret = __query_exec(daci_handler, "begin immediate", "agent_db_begin_transaction failed");
 252
 253         if (ret == SYNC_AGENT_DA_ERR_QUERY_FAILED)
 254                 ret = SYNC_AGENT_DA_ERR_TRANSACTION_FAILED;
 255
 256         _EXTERN_FUNC_EXIT;
 257
 258         return ret;
 259 }
 260
 261 sync_agent_da_return_e da_end_transaction(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_transaction_e transaction)
 262 {
 263         _EXTERN_FUNC_ENTER;
 264
 265         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_TRANSACTION_FAILED, "SYNC_AGENT_DA_HANDLER is NULL !!");
 266
 267         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 268         char *query = 0;
 269         char *err_msg = 0;
 270
 271         if (transaction == SYNC_AGENT_DA_TRANSACTION_COMMIT) {
 272                 query = "commit transaction";
 273                 err_msg = "agent_db_commit_transaction failed";
 274         } else if (transaction == SYNC_AGENT_DA_TRANSACTION_ROLLBACK) {
 275                 query = "rollback transaction";
 276                 err_msg = "agent_db_rollback_transaction failed";
 277         }
 278
 279         ret = __query_exec(daci_handler, query, err_msg);
 280
 281         use_transaction_thread_id = 0;
 282         int err_mutex = pthread_mutex_unlock(&transaction_lock);
 283         if (err_mutex) {
 284                 _DEBUG_INFO("Failed pthread_mutex_unlock : %d", err_mutex);
 285         }
 286
 287         if (ret == SYNC_AGENT_DA_ERR_QUERY_FAILED) {
 288                 if (transaction == SYNC_AGENT_DA_TRANSACTION_COMMIT) {
 289                         query = "rollback transaction";
 290                         err_msg = "agent_db_rollback_transaction failed";
 291                         ret = __query_exec(daci_handler, query, err_msg);
 292                         if (ret == SYNC_AGENT_DA_SUCCESS)
 293                                 _DEBUG_INFO("agent_db_rollback_transaction success");
 294                 }
 295                 ret = SYNC_AGENT_DA_ERR_TRANSACTION_FAILED;
 296         }
 297
 298         _EXTERN_FUNC_EXIT;
 299
 300         return ret;
 301 }
 302
 303 void da_set_agent_db_file_path(char *file_path)
 304 {
 305         _EXTERN_FUNC_ENTER;
 306
 307         retm_if(file_path == NULL, "file_path is NULL !!");
 308
 309         daci_file_path = file_path;
 310
 311         _EXTERN_FUNC_EXIT;
 312 }
 313
 314 sync_agent_da_return_e da_create_agent_default_table(SYNC_AGENT_DA_HANDLER * daci_handler)
 315 {
 316         _EXTERN_FUNC_ENTER;
 317
 318         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 319
 320         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 321
 322         if ((da_begin_transaction(daci_handler) != SYNC_AGENT_DA_SUCCESS)) {
 323                 _DEBUG_ERROR("agent_db_default_tbl_create failed");
 324                 return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
 325         }
 326
 327         /* 1. create account_tbl */
 328         if (__exist_table(daci_handler, "account_tbl") == 0) {
 329                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT], "account_tbl_create failed");
 330                 if (ret != SYNC_AGENT_DA_SUCCESS)
 331                         goto DACI_FINISH;
 332         }
 333
 334         /* 2. create folder_tbl */
 335         if (__exist_table(daci_handler, "folder_tbl") == 0) {
 336                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_FOLDER], "folder_tbl_create failed");
 337                 if (ret != SYNC_AGENT_DA_SUCCESS)
 338                         goto DACI_FINISH;
 339         }
 340
 341         /* 3. create item_tbl */
 342         if (__exist_table(daci_handler, "item_tbl") == 0) {
 343                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_ITEM], "item_tbl_create failed");
 344                 if (ret != SYNC_AGENT_DA_SUCCESS)
 345                         goto DACI_FINISH;
 346         }
 347
 348         /* 4. create config_tbl */
 349         if (__exist_table(daci_handler, "config_tbl") == 0) {
 350                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_CONFIG], "config_tbl_create failed");
 351                 if (ret != SYNC_AGENT_DA_SUCCESS)
 352                         goto DACI_FINISH;
 353         }
 354
 355         /* 5. create last_anchor_tbl */
 356         if (__exist_table(daci_handler, "last_anchor_tbl") == 0) {
 357                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_LAST_ANCHOR], "last_anchor_tbl_create failed");
 358                 if (ret != SYNC_AGENT_DA_SUCCESS)
 359                         goto DACI_FINISH;
 360         }
 361
 362         /* 6. create mapping_tbl */
 363         if (__exist_table(daci_handler, "mapping_tbl") == 0) {
 364                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_MAPPING], "mapping_tbl_create failed");
 365                 if (ret != SYNC_AGENT_DA_SUCCESS)
 366                         goto DACI_FINISH;
 367         }
 368
 369         /* 7. create id_provider_tbl */
 370         if (__exist_table(daci_handler, "id_provider_tbl") == 0) {
 371                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_ID_PROVIDER], "id_provider_tbl_create failed");
 372                 if (ret != SYNC_AGENT_DA_SUCCESS)
 373                         goto DACI_FINISH;
 374         }
 375
 376         /* 8. create id_page_tbl */
 377         if (__exist_table(daci_handler, "id_page_tbl") == 0) {
 378                 ret = __query_exec(daci_handler, g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_ID_PAGE], "id_page_tbl_create failed");
 379                 if (ret != SYNC_AGENT_DA_SUCCESS)
 380                         goto DACI_FINISH;
 381         }
 382
 383  DACI_FINISH:
 384
 385         if (ret != SYNC_AGENT_DA_SUCCESS) {
 386                 da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
 387                 ret = SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
 388         } else {
 389                 ret = da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_COMMIT);
 390         }
 391
 392         _EXTERN_FUNC_EXIT;
 393
 394         return ret;
 395 }
 396
 397 sync_agent_da_return_e da_empty_agent_default_table(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_table_name_e table_name)
 398 {
 399         _EXTERN_FUNC_ENTER;
 400
 401         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 402
 403         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 404
 405         /* delete default table  */
 406         ret = __query_exec(daci_handler, g_daci_delete_table[table_name], "deleting table failed");
 407         if (ret != SYNC_AGENT_DA_SUCCESS) {
 408                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
 409                 _DEBUG_ERROR("deleting table [query:%s] failed !!!\n", g_daci_delete_table[table_name]);
 410                 da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
 411         }
 412         _DEBUG_INFO("table deleted [query:%s] !!!\n", g_daci_delete_table[table_name]);
 413
 414         _EXTERN_FUNC_EXIT;
 415
 416         return ret;
 417 }
 418
 419 sync_agent_da_return_e da_empty_all_agent_table(SYNC_AGENT_DA_HANDLER * daci_handler)
 420 {
 421         _EXTERN_FUNC_ENTER;
 422
 423         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 424
 425         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 426         int *account_id_list = 0;
 427         int count = 0;
 428         int i = 0;
 429
 430         ret = da_begin_transaction(daci_handler);
 431         if (ret != SYNC_AGENT_DA_SUCCESS) {
 432                 _DEBUG_ERROR("tbl_delete failed");
 433                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 434         }
 435
 436         /* delete all changelog table */
 437         account_id_list = da_get_account_account_id_list(daci_handler, &count);
 438         if (account_id_list == NULL) {
 439                 _DEBUG_INFO("accountIdList empty !!!!!");
 440         } else {
 441                 _DEBUG_INFO("accountListCount : %d", count);
 442                 for (i = 0; i < count; i++) {
 443                         ret = _delete_changlog_table(daci_handler, account_id_list[i]);
 444                         if (ret != SYNC_AGENT_DA_SUCCESS) {
 445                                 /* memory free */
 446                                 if (account_id_list != NULL)
 447                                         free(account_id_list);
 448
 449                                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 450                         }
 451                 }
 452         }
 453
 454         /* delete all default table */
 455         for (i = 0; i < SYNC_AGENT_DA_TABLE_NAME_MAX; i++) {
 456                 if (i == SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG || i == SYNC_AGENT_DA_TABLE_NAME_ID_PROVIDER || i == SYNC_AGENT_DA_TABLE_NAME_ID_PAGE)
 457                         continue;
 458
 459                 ret = __query_exec(daci_handler, g_daci_delete_table[i], "deleting table failed");
 460                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 461                         ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
 462                         _DEBUG_ERROR("deleting table [query:%s] failed !!!\n", g_daci_delete_table[i]);
 463                         goto DACI_FINISH;
 464                 }
 465                 _DEBUG_INFO("table deleted [query:%s] !!!\n", g_daci_delete_table[i]);
 466         }
 467
 468  DACI_FINISH:
 469
 470         if (ret != SYNC_AGENT_DA_SUCCESS)
 471                 ret = da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
 472         else
 473                 ret = da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_COMMIT);
 474
 475         /* memory free */
 476         if (account_id_list != NULL)
 477                 free(account_id_list);
 478
 479         _EXTERN_FUNC_EXIT;
 480
 481         return ret;
 482 }
 483
 484 int da_add_fw_account(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_fw_account_s * account)
 485 {
 486         _EXTERN_FUNC_ENTER;
 487
 488         retvm_if(daci_handler == NULL, -1, "SYNC_AGENT_DA_HANDLER is NULL !!");
 489         retvm_if(account == NULL, -1, "sync_agent_fw_account_s is NULL !!");
 490
 491         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 492         daci_stmt stmt = 0;
 493         char *query = "insert into account_tbl (account_id, email_address, password, enable, access_name) values (?, ?, ?, ?, ?)";
 494
 495         account->account_id = _get_next_account_id();
 496
 497         if (account->account_id > SYNC_AGENT_DA_MAX_ACCOUNT) {
 498                 _DEBUG_ERROR("account registration is full");
 499                 account->account_id = -1;
 500                 goto DACI_FINISH;
 501         }
 502
 503         stmt = __query_prepare(daci_handler, query, strlen(query));
 504         if (stmt == NULL) {
 505                 account->account_id = -1;
 506                 goto DACI_FINISH;
 507         }
 508
 509         _stmt_bind_int(daci_handler, stmt, 1, account->account_id);
 510         __stmt_bind_text(daci_handler, stmt, 2, account->email);
 511         __stmt_bind_text(daci_handler, stmt, 3, account->password);
 512         _stmt_bind_int(daci_handler, stmt, 4, account->enable);
 513         __stmt_bind_text(daci_handler, stmt, 5, account->access_name);
 514
 515         ret = __stmt_write_step(daci_handler, stmt);
 516         if (ret != SYNC_AGENT_DA_SUCCESS)
 517                 account->account_id = -1;
 518
 519         __stmt_finalize(daci_handler, stmt);
 520
 521         if (account->account_id != -1) {
 522                 _create_changelog_table(daci_handler, account->account_id);
 523         }
 524
 525  DACI_FINISH:
 526
 527         _EXTERN_FUNC_EXIT;
 528
 529         return account->account_id;
 530 }
 531
 532 sync_agent_da_return_e da_update_fw_account(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_fw_account_s * account)
 533 {
 534         _EXTERN_FUNC_ENTER;
 535
 536         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 537         retvm_if(account == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_fw_account_s is NULL !!");
 538
 539         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 540         daci_stmt stmt = 0;
 541         char *query = "update account_tbl set email_address = ?, password = ?, enable = ?, last_update = current_timestamp, access_name = ?  where account_id = ?";
 542
 543         stmt = __query_prepare(daci_handler, query, strlen(query));
 544         if (stmt == NULL)
 545                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 546
 547         __stmt_bind_text(daci_handler, stmt, 1, account->email);
 548         __stmt_bind_text(daci_handler, stmt, 2, account->password);
 549         _stmt_bind_int(daci_handler, stmt, 3, account->enable);
 550         __stmt_bind_text(daci_handler, stmt, 4, account->access_name);
 551         _stmt_bind_int(daci_handler, stmt, 5, account->account_id);
 552
 553         ret = __stmt_write_step(daci_handler, stmt);
 554         __stmt_finalize(daci_handler, stmt);
 555
 556         _EXTERN_FUNC_EXIT;
 557
 558         return ret;
 559 }
 560
 561 sync_agent_da_return_e da_delete_fw_account(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
 562 {
 563         _EXTERN_FUNC_ENTER;
 564
 565         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 566
 567         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 568         int i = 0;
 569
 570         /* delete default table by accountId */
 571         for (i = 0; i < SYNC_AGENT_DA_TABLE_NAME_MAX; i++) {
 572                 if (i == SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG) {
 573                         continue;
 574                 }
 575
 576                 ret = _delete_account(daci_handler, i, account_id);
 577                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 578                         ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
 579                         goto DACI_FINISH;
 580                 }
 581         }
 582
 583         /* drop changelog table */
 584         ret = _drop_changelog_table(daci_handler, account_id);
 585         if (ret != SYNC_AGENT_DA_SUCCESS) {
 586                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
 587                 goto DACI_FINISH;
 588         }
 589
 590  DACI_FINISH:
 591
 592         _EXTERN_FUNC_EXIT;
 593
 594         return ret;
 595 }
 596
 597 sync_agent_da_return_e da_get_fw_account(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, sync_agent_fw_account_s ** account)
 598 {
 599         _EXTERN_FUNC_ENTER;
 600
 601         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 602
 603         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 604
 605         daci_stmt stmt = 0;
 606         char *query = "select account_id, email_address, password, enable, access_name from account_tbl where account_id = ?";
 607
 608         stmt = __query_prepare(daci_handler, query, strlen(query));
 609
 610         if (stmt != NULL) {
 611                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
 612
 613                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
 614                         (*account)->account_id = __stmt_column_int(stmt, 0);
 615                         (*account)->email = _stmt_column_text(stmt, 1);
 616                         (*account)->password = _stmt_column_text(stmt, 2);
 617                         (*account)->enable = __stmt_column_int(stmt, 3);
 618                         (*account)->access_name = _stmt_column_text(stmt, 4);
 619                 }
 620
 621                 __stmt_finalize(daci_handler, stmt);
 622         }
 623
 624         _EXTERN_FUNC_EXIT;
 625
 626         return ret;
 627 }
 628
 629 sync_agent_da_return_e da_get_all_fw_account(SYNC_AGENT_DA_HANDLER * daci_handler, GList ** list)
 630 {
 631         _EXTERN_FUNC_ENTER;
 632
 633         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 634
 635         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 636
 637         daci_stmt stmt = 0;
 638         int data_count = 0;
 639         int i = 0;
 640         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 641         sync_agent_fw_account_s *fw_account = NULL;
 642         GList *account_list = NULL;
 643
 644         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from account_tbl");
 645
 646         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
 647
 648         if (data_count != 0) {
 649                 /* query initialize */
 650                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
 651
 652                 snprintf(g_daci_query, sizeof(g_daci_query), "select account_id, email_address, password, enable, access_name from account_tbl");
 653
 654                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
 655                 if (stmt != NULL) {
 656                         for (i = 0; i < data_count; i++) {
 657                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
 658                                         break;
 659
 660                                 fw_account = (sync_agent_fw_account_s *) calloc(1, sizeof(sync_agent_fw_account_s));
 661                                 fw_account->account_id = __stmt_column_int(stmt, 0);
 662                                 fw_account->email = _stmt_column_text(stmt, 1);
 663                                 fw_account->password = _stmt_column_text(stmt, 2);
 664                                 fw_account->enable = __stmt_column_int(stmt, 3);
 665                                 fw_account->access_name = _stmt_column_text(stmt, 4);
 666
 667                                 account_list = g_list_append(account_list, fw_account);
 668                         }
 669                         __stmt_finalize(daci_handler, stmt);
 670                 }
 671         }
 672
 673         *list = account_list;
 674
 675         _EXTERN_FUNC_EXIT;
 676
 677         return ret;
 678 }
 679
 680 sync_agent_da_return_e da_get_fw_account_by_access_name(SYNC_AGENT_DA_HANDLER * daci_handler, char *access_name, GList ** list)
 681 {
 682         _EXTERN_FUNC_ENTER;
 683
 684         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 685         retvm_if(access_name == NULL, SYNC_AGENT_DA_ERRORS, "access name is NULL !!");
 686
 687         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 688
 689         daci_stmt stmt = 0;
 690         int data_count = 0;
 691         int i = 0;
 692         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 693         sync_agent_fw_account_s *fw_account = NULL;
 694         GList *account_list = NULL;
 695
 696         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from account_tbl where access_name = \'%s\'", access_name);
 697
 698         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
 699
 700         if (data_count != 0) {
 701                 /* query initialize */
 702                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
 703
 704                 snprintf(g_daci_query, sizeof(g_daci_query), "select account_id, email_address, password, enable, access_name from account_tbl where access_name = \'%s\'", access_name);
 705
 706                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
 707                 if (stmt != NULL) {
 708                         for (i = 0; i < data_count; i++) {
 709                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
 710                                         break;
 711
 712                                 fw_account = (sync_agent_fw_account_s *) calloc(1, sizeof(sync_agent_fw_account_s));
 713                                 fw_account->account_id = __stmt_column_int(stmt, 0);
 714                                 fw_account->email = _stmt_column_text(stmt, 1);
 715                                 fw_account->password = _stmt_column_text(stmt, 2);
 716                                 fw_account->enable = __stmt_column_int(stmt, 3);
 717                                 fw_account->access_name = _stmt_column_text(stmt, 4);
 718
 719                                 account_list = g_list_append(account_list, fw_account);
 720                         }
 721                         __stmt_finalize(daci_handler, stmt);
 722                 }
 723         }
 724         *list = account_list;
 725
 726         _EXTERN_FUNC_EXIT;
 727
 728         return ret;
 729 }
 730
 731 int *da_get_account_account_id_list(SYNC_AGENT_DA_HANDLER * daci_handler, int *count)
 732 {
 733         _EXTERN_FUNC_ENTER;
 734
 735         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
 736
 737         daci_stmt stmt = 0;
 738         int *account_id_list = 0;
 739         int data_count = 0;
 740         int i = 0;
 741         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 742
 743         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from account_tbl");
 744
 745         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
 746         *count = data_count;
 747
 748         if (data_count != 0) {
 749                 /* query initialize */
 750                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
 751
 752                 account_id_list = SYNC_AGENT_DA_MEMORY_MALLOC(int *, sizeof(int), data_count);
 753                 if (account_id_list == NULL) {
 754                         _DEBUG_ERROR("memory_allocation failed");
 755                         return account_id_list;
 756                 }
 757
 758                 snprintf(g_daci_query, sizeof(g_daci_query), "select account_id from account_tbl");
 759
 760                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
 761                 if (stmt != NULL) {
 762                         for (i = 0; i < data_count; i++) {
 763                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
 764                                         break;
 765
 766                                 account_id_list[i] = __stmt_column_int(stmt, 0);
 767                         }
 768                         __stmt_finalize(daci_handler, stmt);
 769                 }
 770         }
 771
 772         _EXTERN_FUNC_EXIT;
 773
 774         return account_id_list;
 775 }
 776
 777 int da_is_exist_account(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
 778 {
 779         _EXTERN_FUNC_ENTER;
 780
 781         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
 782
 783         int ret = 1;
 784         int data_count = 0;
 785         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 786
 787         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from account_tbl where account_id = %d", account_id);
 788
 789         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
 790
 791         if (data_count == 0)
 792                 ret = 0;
 793
 794         _EXTERN_FUNC_EXIT;
 795
 796         return ret;
 797 }
 798
 799 int da_get_account_count(SYNC_AGENT_DA_HANDLER * daci_handler)
 800 {
 801         _EXTERN_FUNC_ENTER;
 802
 803         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
 804
 805         int data_count = 0;
 806         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 807
 808         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from account_tbl");
 809
 810         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
 811
 812         _EXTERN_FUNC_EXIT;
 813
 814         return data_count;
 815 }
 816
 817 sync_agent_da_return_e da_add_folder(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_folder_s * folder, int count)
 818 {
 819         _EXTERN_FUNC_ENTER;
 820
 821         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 822         retvm_if(folder == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_folder_s is NULL !!");
 823
 824         daci_stmt stmt = 0;
 825         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 826         int i = 0;
 827         char *query = 0;
 828
 829         for (i = 0; i < count; i++) {
 830                 if (da_is_exist_folder(daci_handler, folder[i].account_id, folder[i].folder_id) == 1)
 831                         return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
 832         }
 833
 834         query = "insert into folder_tbl (folder_id, data_store_id, account_id, folder_type_id, service_id, parent_folder_id, access_name) values (?, ?, ?, ?, ?, ?, ?)";
 835
 836         stmt = __query_prepare(daci_handler, query, strlen(query));
 837         if (stmt == NULL)
 838                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 839
 840         for (i = 0; i < count; i++) {
 841                 __stmt_bind_text(daci_handler, stmt, 1, folder[i].folder_id);
 842                 _stmt_bind_int(daci_handler, stmt, 2, folder[i].data_store_id);
 843                 _stmt_bind_int(daci_handler, stmt, 3, folder[i].account_id);
 844                 _stmt_bind_int(daci_handler, stmt, 4, folder[i].folder_type_id);
 845                 __stmt_bind_text(daci_handler, stmt, 5, folder[i].service_id);
 846                 __stmt_bind_text(daci_handler, stmt, 6, folder[i].parent_folder_id);
 847                 __stmt_bind_text(daci_handler, stmt, 7, folder[i].access_name);
 848
 849                 ret = __stmt_write_step(daci_handler, stmt);
 850                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
 851                         __stmt_finalize(daci_handler, stmt);
 852                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 853                 }
 854                 _stmt_reset(daci_handler, stmt);
 855         }
 856         __stmt_finalize(daci_handler, stmt);
 857
 858         _EXTERN_FUNC_EXIT;
 859
 860         return ret;
 861 }
 862
 863 sync_agent_da_return_e da_add_folder_new(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_folder_s * folder, int count, char **folder_id)
 864 {
 865         _EXTERN_FUNC_ENTER;
 866
 867         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 868         retvm_if(folder == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_folder_s is NULL !!");
 869
 870         daci_stmt stmt = 0;
 871         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 872         char *f_id = NULL;
 873         int i;
 874         char *query = NULL;
 875
 876         for (i = 0; i < count; i++) {
 877                 if (folder[i].folder_id != NULL) {
 878                         if (da_is_exist_folder(daci_handler, folder[i].account_id, folder[i].folder_id) == 1)
 879                                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
 880                 }
 881         }
 882
 883         query = "insert into folder_tbl (folder_id, data_store_id, account_id, folder_type_id, service_id, parent_folder_id, access_name) values (?, ?, ?, ?, ?, ?, ?)";
 884
 885         stmt = __query_prepare(daci_handler, query, strlen(query));
 886         if (stmt == NULL)
 887                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 888
 889         for (i = 0; i < count; i++) {
 890                 if (folder[i].folder_id != NULL) {
 891                         __stmt_bind_text(daci_handler, stmt, 1, folder[i].folder_id);
 892                         *folder_id = strdup(folder[i].folder_id);
 893                 } else {
 894                         f_id = sync_agent_generate_folder_luid();
 895                         if (f_id != NULL) {
 896                                 __stmt_bind_text(daci_handler, stmt, 1, f_id);
 897
 898                                 *folder_id = strdup(f_id);
 899
 900                                 if (f_id != NULL) {
 901                                         free(f_id);
 902                                         f_id = NULL;
 903                                 }
 904                         } else {
 905                                 _DEBUG_ERROR("sync_agent_generate_folder_luid() failed !!");
 906                                 return SYNC_AGENT_DA_ERRORS;
 907                         }
 908                 }
 909                 _stmt_bind_int(daci_handler, stmt, 2, folder[i].data_store_id);
 910                 _stmt_bind_int(daci_handler, stmt, 3, folder[i].account_id);
 911                 _stmt_bind_int(daci_handler, stmt, 4, folder[i].folder_type_id);
 912                 __stmt_bind_text(daci_handler, stmt, 5, folder[i].service_id);
 913                 __stmt_bind_text(daci_handler, stmt, 6, folder[i].parent_folder_id);
 914                 __stmt_bind_text(daci_handler, stmt, 7, folder[i].access_name);
 915
 916                 ret = __stmt_write_step(daci_handler, stmt);
 917                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
 918                         __stmt_finalize(daci_handler, stmt);
 919                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 920                 }
 921                 _stmt_reset(daci_handler, stmt);
 922         }
 923         __stmt_finalize(daci_handler, stmt);
 924
 925         _EXTERN_FUNC_EXIT;
 926
 927         return ret;
 928 }
 929
 930 sync_agent_da_return_e da_delete_folder_by_folder_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *folderId)
 931 {
 932         _EXTERN_FUNC_ENTER;
 933
 934         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
 935         retvm_if(folderId == NULL, SYNC_AGENT_DA_ERRORS, "folder Id is NULL !!");
 936
 937         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 938         daci_stmt stmt = 0;
 939         char *query = "delete from folder_tbl where folder_id = ?";
 940
 941         stmt = __query_prepare(daci_handler, query, strlen(query));
 942         if (stmt == NULL)
 943                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
 944
 945         __stmt_bind_text(daci_handler, stmt, 1, folderId);
 946
 947         ret = __stmt_write_step(daci_handler, stmt);
 948         __stmt_finalize(daci_handler, stmt);
 949
 950         _EXTERN_FUNC_EXIT;
 951
 952         return ret;
 953 }
 954
 955 char *da_get_folder_folder_id_by_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, char *serviceId, int folderTypeId)
 956 {
 957         _EXTERN_FUNC_ENTER;
 958
 959         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
 960         retvm_if(serviceId == NULL, NULL, "service Id is NULL !!");
 961
 962         daci_stmt stmt = 0;
 963         char *folder_id = 0;
 964         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 965
 966         snprintf(g_daci_query, sizeof(g_daci_query), "select folder_id from folder_tbl where account_id = %d and data_store_id = %d and service_id = %s and folder_type_id = %d", account_id, itemTypeId, serviceId, folderTypeId);
 967
 968         _DEBUG_INFO("Query : %s", g_daci_query);
 969
 970         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
 971         if (stmt != NULL) {
 972                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
 973                         folder_id = _stmt_column_text(stmt, 0);
 974
 975                 __stmt_finalize(daci_handler, stmt);
 976         }
 977
 978         _EXTERN_FUNC_EXIT;
 979
 980         return folder_id;
 981 }
 982
 983 sync_agent_da_id_list_s *da_get_folder_folder_id_by_folder_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, int folderTypeId)
 984 {
 985         _EXTERN_FUNC_ENTER;
 986
 987         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
 988
 989         daci_stmt stmt = 0;
 990         sync_agent_da_id_list_s *folder_id_list = 0;
 991         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
 992
 993         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from folder_tbl where account_id = %d and folder_type_id = %d and data_store_id = %d", account_id, folderTypeId, itemTypeId);
 994
 995         int data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
 996
 997         if (data_count != 0) {
 998                 snprintf(g_daci_query, sizeof(g_daci_query), "select folder_id from folder_tbl where account_id = %d and folder_type_id = %d and data_store_id = %d", account_id, folderTypeId, itemTypeId);
 999
1000                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
1001                 if (stmt != NULL) {
1002                         folder_id_list = (sync_agent_da_id_list_s *) calloc(1, sizeof(sync_agent_da_id_list_s));
1003                         if (folder_id_list == NULL) {
1004                                 _DEBUG_ERROR("CALLOC failed !!!");
1005                                 return NULL;
1006                         }
1007                         folder_id_list->id = (char **)calloc(data_count, sizeof(char *));
1008                         if (folder_id_list->id == NULL) {
1009
1010                                 if (folder_id_list != NULL)
1011                                         free(folder_id_list);
1012
1013                                 _DEBUG_ERROR("CALLOC failed !!!");
1014                                 return NULL;
1015                         }
1016                         folder_id_list->count = data_count;
1017                         int i = 0;
1018                         for (; i < data_count; i++) {
1019                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
1020                                         break;
1021                                 }
1022
1023                                 folder_id_list->id[i] = _stmt_column_text(stmt, 0);
1024                         }
1025                         __stmt_finalize(daci_handler, stmt);
1026                 }
1027         }
1028
1029         _EXTERN_FUNC_EXIT;
1030
1031         return folder_id_list;
1032 }
1033
1034 sync_agent_da_return_e da_get_folder_folder_id_by_folder_type_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id, int folder_type_id, GList ** list)
1035 {
1036         _EXTERN_FUNC_ENTER;
1037
1038         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1039
1040         daci_stmt stmt = 0;
1041         char *item_id;
1042         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1043
1044         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from folder_tbl where account_id = %d and folder_type_id = %d and data_store_id = %d", account_id, folder_type_id, item_type_id);
1045
1046         int data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
1047
1048         if (data_count != 0) {
1049                 snprintf(g_daci_query, sizeof(g_daci_query), "select folder_id from folder_tbl where account_id = %d and folder_type_id = %d and data_store_id = %d", account_id, folder_type_id, item_type_id);
1050
1051                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
1052                 if (stmt != NULL) {
1053                         int i = 0;
1054                         for (; i < data_count; i++) {
1055                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
1056                                         break;
1057                                 }
1058
1059                                 item_id = NULL;
1060                                 item_id = _stmt_column_text(stmt, 0);
1061
1062                                 *list = g_list_append(*list, item_id);
1063                         }
1064                         __stmt_finalize(daci_handler, stmt);
1065                 }
1066         }
1067
1068         _EXTERN_FUNC_EXIT;
1069
1070         return SYNC_AGENT_DA_SUCCESS;
1071 }
1072
1073 char *da_get_folder_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *folderId)
1074 {
1075         _EXTERN_FUNC_ENTER;
1076
1077         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1078         retvm_if(folderId == NULL, NULL, "folder Id is NULL !!");
1079
1080         daci_stmt stmt = 0;
1081         char *query = "select service_id from folder_tbl where folder_id = ?";
1082         char *service_id = 0;
1083
1084         stmt = __query_prepare(daci_handler, query, strlen(query));
1085         if (stmt != NULL) {
1086                 __stmt_bind_text(daci_handler, stmt, 1, folderId);
1087
1088                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
1089                         service_id = _stmt_column_text(stmt, 0);
1090
1091                 __stmt_finalize(daci_handler, stmt);
1092         }
1093
1094         _EXTERN_FUNC_EXIT;
1095
1096         return service_id;
1097 }
1098
1099 sync_agent_da_id_list_s *da_get_folder_folder_id_list_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
1100 {
1101         _EXTERN_FUNC_ENTER;
1102
1103         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1104
1105         daci_stmt stmt = 0;
1106         sync_agent_da_id_list_s *folder_id_list = 0;
1107         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1108
1109         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from folder_tbl where account_id = %d and data_store_id = %d", account_id, itemTypeId);
1110
1111         int data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
1112
1113         if (data_count != 0) {
1114                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
1115
1116                 snprintf(g_daci_query, sizeof(g_daci_query), "select folder_id from folder_tbl where account_id = %d and data_store_id = %d", account_id, itemTypeId);
1117
1118                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
1119                 if (stmt != NULL) {
1120                         folder_id_list = (sync_agent_da_id_list_s *) calloc(1, sizeof(sync_agent_da_id_list_s));
1121                         if (folder_id_list == NULL) {
1122                                 _DEBUG_ERROR("CALLOC failed !!!");
1123                                 return NULL;
1124                         }
1125                         folder_id_list->id = (char **)calloc(data_count, sizeof(char *));
1126                         if (folder_id_list->id == NULL) {
1127
1128                                 if (folder_id_list != NULL)
1129                                         free(folder_id_list);
1130
1131                                 _DEBUG_ERROR("CALLOC failed !!!");
1132                                 return NULL;
1133                         }
1134                         folder_id_list->count = data_count;
1135                         int i = 0;
1136                         for (; i < data_count; i++) {
1137                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
1138                                         break;
1139                                 }
1140
1141                                 folder_id_list->id[i] = _stmt_column_text(stmt, 0);
1142                         }
1143                         __stmt_finalize(daci_handler, stmt);
1144                 }
1145         }
1146
1147         _EXTERN_FUNC_EXIT;
1148
1149         return folder_id_list;
1150 }
1151
1152 sync_agent_da_return_e da_get_folder_folder_id_list_by_item_type_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id, GList ** list)
1153 {
1154         _EXTERN_FUNC_ENTER;
1155
1156         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1157
1158         daci_stmt stmt = 0;
1159         char *item_id;
1160         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1161
1162         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from folder_tbl where account_id = %d and data_store_id = %d", account_id, item_type_id);
1163
1164         int data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
1165
1166         if (data_count != 0) {
1167                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
1168
1169                 snprintf(g_daci_query, sizeof(g_daci_query), "select folder_id from folder_tbl where account_id = %d and data_store_id = %d", account_id, item_type_id);
1170
1171                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
1172                 if (stmt != NULL) {
1173                         int i = 0;
1174                         for (; i < data_count; i++) {
1175                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
1176                                         break;
1177                                 }
1178
1179                                 item_id = NULL;
1180                                 item_id = _stmt_column_text(stmt, 0);
1181
1182                                 *list = g_list_append(*list, item_id);
1183                         }
1184                         __stmt_finalize(daci_handler, stmt);
1185                 }
1186         }
1187
1188         _EXTERN_FUNC_EXIT;
1189
1190         return SYNC_AGENT_DA_SUCCESS;
1191 }
1192
1193 sync_agent_da_folder_s *da_get_folder_mapping_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *folderId, int *count)
1194 {
1195         _EXTERN_FUNC_ENTER;
1196
1197         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1198         retvm_if(folderId == NULL, NULL, "folder Id is NULL !!");
1199
1200         daci_stmt stmt = 0;
1201         sync_agent_da_folder_s *folder = 0;
1202         int data_count = 0;
1203         int i = 0;
1204         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1205
1206         snprintf(g_daci_query, sizeof(g_daci_query),
1207                  "select count(*) from folder_tbl where folder_type_id in (select folder_type_id from folder_tbl where account_id = %d and folder_id = \'%s\') "
1208                  "and (account_id != %d) and (account_id != %d) and data_store_id in (select data_store_id from folder_tbl where folder_id = \'%s\')", account_id, folderId, account_id, account_id, folderId);
1209
1210         _DEBUG_INFO("[RJW] %s", g_daci_query);
1211
1212         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
1213         *count = data_count;
1214
1215         if (data_count != 0) {
1216                 /* query initialize */
1217                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
1218
1219                 folder = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_folder_s *, sizeof(sync_agent_da_folder_s), data_count);
1220                 if (folder == NULL) {
1221                         _DEBUG_ERROR("memory_allocation failed");
1222                         return folder;
1223                 }
1224
1225                 snprintf(g_daci_query, sizeof(g_daci_query),
1226                          "select * from folder_tbl where folder_type_id in (select folder_type_id from folder_tbl where account_id = %d and folder_id = \'%s\') "
1227                          "and (account_id != %d) and (account_id != %d) and data_store_id in (select data_store_id from folder_tbl where folder_id = \'%s\')", account_id, folderId, account_id, account_id, folderId);
1228
1229                 _DEBUG_INFO("[RJW] %s", g_daci_query);
1230
1231                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
1232                 if (stmt != NULL) {
1233                         for (i = 0; i < data_count; i++) {
1234                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
1235                                         break;
1236
1237                                 folder[i].folder_id = _stmt_column_text(stmt, 0);
1238                                 folder[i].data_store_id = __stmt_column_int(stmt, 1);
1239                                 folder[i].account_id = __stmt_column_int(stmt, 2);
1240                                 folder[i].folder_type_id = __stmt_column_int(stmt, 3);
1241                                 folder[i].service_id = _stmt_column_text(stmt, 4);
1242                                 folder[i].parent_folder_id = _stmt_column_text(stmt, 5);
1243                                 folder[i].access_name = _stmt_column_text(stmt, 7);
1244                         }
1245                         __stmt_finalize(daci_handler, stmt);
1246                 }
1247         }
1248
1249         _EXTERN_FUNC_EXIT;
1250
1251         return folder;
1252 }
1253
1254 sync_agent_da_return_e da_get_folder_mapping_service_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *folder_id, GList ** list)
1255 {
1256         _EXTERN_FUNC_ENTER;
1257
1258         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1259         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
1260
1261         daci_stmt stmt = 0;
1262         sync_agent_da_folder_s *folder;
1263         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
1264         int data_count = 0;
1265         int i = 0;
1266         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1267
1268         snprintf(g_daci_query, sizeof(g_daci_query),
1269                  "select count(*) from folder_tbl where folder_type_id in (select folder_type_id from folder_tbl where account_id = %d and folder_id = \'%s\') "
1270                  "and (account_id != %d) and (account_id != %d) and data_store_id in (select data_store_id from folder_tbl where folder_id = \'%s\')", account_id, folder_id, account_id, account_id, folder_id);
1271
1272         _DEBUG_INFO("[RJW] %s", g_daci_query);
1273
1274         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
1275
1276         if (data_count != 0) {
1277                 /* query initialize */
1278                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
1279
1280                 snprintf(g_daci_query, sizeof(g_daci_query),
1281                          "select * from folder_tbl where folder_type_id in (select folder_type_id from folder_tbl where account_id = %d and folder_id = \'%s\') "
1282                          "and (account_id != %d) and (account_id != %d) and data_store_id in (select data_store_id from folder_tbl where folder_id = \'%s\')", account_id, folder_id, account_id, account_id, folder_id);
1283
1284                 _DEBUG_INFO("[RJW] %s", g_daci_query);
1285
1286                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
1287                 if (stmt != NULL) {
1288                         for (i = 0; i < data_count; i++) {
1289                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
1290                                         break;
1291
1292                                 folder = NULL;
1293                                 ret = sync_agent_create_folder(&folder);
1294                                 if (ret != SYNC_AGENT_DA_SUCCESS) {
1295                                         _DEBUG_ERROR("sync_agent_create_folder() failed !!");
1296                                         return ret;
1297                                 }
1298
1299                                 folder->folder_id = _stmt_column_text(stmt, 0);
1300                                 folder->data_store_id = __stmt_column_int(stmt, 1);
1301                                 folder->account_id = __stmt_column_int(stmt, 2);
1302                                 folder->folder_type_id = __stmt_column_int(stmt, 3);
1303                                 folder->service_id = _stmt_column_text(stmt, 4);
1304                                 folder->parent_folder_id = _stmt_column_text(stmt, 5);
1305                                 folder->access_name = _stmt_column_text(stmt, 7);
1306
1307                                 *list = g_list_append(*list, folder);
1308                         }
1309                         __stmt_finalize(daci_handler, stmt);
1310                 }
1311         } else {
1312                 _DEBUG_INFO("no data !!");
1313                 ret = SYNC_AGENT_DA_SUCCESS;
1314         }
1315
1316         _EXTERN_FUNC_EXIT;
1317
1318         return ret;
1319 }
1320
1321 sync_agent_da_return_e da_get_folder_by_folder_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *folder_id, sync_agent_da_folder_s ** sync_agent_folder)
1322 {
1323         _EXTERN_FUNC_ENTER;
1324
1325         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1326         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
1327
1328         daci_stmt stmt = 0;
1329         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1330         char *query = "select  * from folder_tbl where folder_id = ?";
1331
1332         stmt = __query_prepare(daci_handler, query, strlen(query));
1333         if (stmt != NULL) {
1334                 __stmt_bind_text(daci_handler, stmt, 1, folder_id);
1335
1336                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1337                         (*sync_agent_folder)->folder_id = _stmt_column_text(stmt, 0);
1338                         (*sync_agent_folder)->data_store_id = __stmt_column_int(stmt, 1);
1339                         (*sync_agent_folder)->account_id = __stmt_column_int(stmt, 2);
1340                         (*sync_agent_folder)->folder_type_id = __stmt_column_int(stmt, 3);
1341                         (*sync_agent_folder)->service_id = _stmt_column_text(stmt, 4);
1342                         (*sync_agent_folder)->parent_folder_id = _stmt_column_text(stmt, 5);
1343                         (*sync_agent_folder)->access_name = _stmt_column_text(stmt, 7);
1344                 }
1345                 __stmt_finalize(daci_handler, stmt);
1346         }
1347
1348         _EXTERN_FUNC_EXIT;
1349
1350         return ret;
1351 }
1352
1353 int da_is_exist_folder(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *folderId)
1354 {
1355         _EXTERN_FUNC_ENTER;
1356
1357         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
1358         retvm_if(folderId == NULL, 0, "folder Id is NULL !!");
1359
1360         int ret = 1;
1361         int data_count = 0;
1362         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1363
1364         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from folder_tbl where account_id = %d and folder_id = \'%s\'", account_id, folderId);
1365
1366         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
1367
1368         if (data_count == 0)
1369                 ret = 0;
1370
1371         _DEBUG_INFO("[%s] End !\n", __func__);
1372
1373         _EXTERN_FUNC_EXIT;
1374
1375         return ret;
1376 }
1377
1378 sync_agent_da_return_e da_add_item(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_item_s * item, int count)
1379 {
1380         _EXTERN_FUNC_ENTER;
1381
1382         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1383         retvm_if(item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
1384
1385         daci_stmt stmt = 0;
1386         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1387
1388         int i;
1389         for (i = 0; i < count; i++) {
1390                 if (da_is_exist_item(daci_handler, item[i].item_id) == 1)
1391                         return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
1392         }
1393
1394         char *query = "insert into item_tbl (item_id, data_store_id, account_id, folder_id, service_id, access_name) values (?, ?, ?, ?, ?, ?)";
1395
1396         stmt = __query_prepare(daci_handler, query, strlen(query));
1397         if (stmt == NULL) {
1398                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1399         }
1400
1401         for (i = 0; i < count; i++) {
1402                 __stmt_bind_text(daci_handler, stmt, 1, item[i].item_id);
1403                 _stmt_bind_int(daci_handler, stmt, 2, item[i].data_store_id);
1404                 _stmt_bind_int(daci_handler, stmt, 3, item[i].account_id);
1405                 __stmt_bind_text(daci_handler, stmt, 4, item[i].folder_id);
1406                 __stmt_bind_text(daci_handler, stmt, 5, item[i].service_id);
1407                 __stmt_bind_text(daci_handler, stmt, 6, item[i].access_name);
1408
1409                 ret = __stmt_write_step(daci_handler, stmt);
1410                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
1411                         __stmt_finalize(daci_handler, stmt);
1412                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1413                 }
1414                 _stmt_reset(daci_handler, stmt);
1415         }
1416
1417         __stmt_finalize(daci_handler, stmt);
1418
1419         _EXTERN_FUNC_EXIT;
1420
1421         return ret;
1422 }
1423
1424 sync_agent_da_return_e da_add_item_new(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_item_s * item, int count, char **item_id)
1425 {
1426         _EXTERN_FUNC_ENTER;
1427
1428         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1429         retvm_if(item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
1430
1431         daci_stmt stmt = 0;
1432         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1433         char **id_list = NULL;
1434
1435         int i;
1436         for (i = 0; i < count; i++) {
1437                 if (item[i].item_id != NULL) {
1438                         if (da_is_exist_item(daci_handler, item[i].item_id) == 1)
1439                                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
1440                 }
1441         }
1442
1443         char *query = "insert into item_tbl (item_id, data_store_id, account_id, folder_id, service_id, access_name) values (?, ?, ?, ?, ?, ?)";
1444
1445         stmt = __query_prepare(daci_handler, query, strlen(query));
1446         if (stmt == NULL) {
1447                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1448         }
1449
1450         for (i = 0; i < count; i++) {
1451                 if (item[i].item_id != NULL) {
1452                         __stmt_bind_text(daci_handler, stmt, 1, item[i].item_id);
1453                         *item_id = strdup(item[i].item_id);
1454                 } else {
1455                         id_list = sync_agent_generate_item_luid(1, 1);
1456                         if (id_list != NULL) {
1457                                 __stmt_bind_text(daci_handler, stmt, 1, id_list[0]);
1458
1459                                 *item_id = strdup(id_list[0]);
1460
1461                                 if (id_list[0] != NULL)
1462                                         free(id_list[0]);
1463
1464                                 if (id_list != NULL)
1465                                         free(id_list);
1466
1467                                 id_list = NULL;
1468                         } else {
1469                                 _DEBUG_ERROR("sync_agent_generate_item_luid() failed !!");
1470                                 return SYNC_AGENT_DA_ERRORS;
1471                         }
1472                 }
1473                 _stmt_bind_int(daci_handler, stmt, 2, item[i].data_store_id);
1474                 _stmt_bind_int(daci_handler, stmt, 3, item[i].account_id);
1475                 __stmt_bind_text(daci_handler, stmt, 4, item[i].folder_id);
1476                 __stmt_bind_text(daci_handler, stmt, 5, item[i].service_id);
1477                 __stmt_bind_text(daci_handler, stmt, 6, item[i].access_name);
1478
1479                 ret = __stmt_write_step(daci_handler, stmt);
1480                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
1481                         __stmt_finalize(daci_handler, stmt);
1482                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1483                 }
1484                 _stmt_reset(daci_handler, stmt);
1485         }
1486
1487         __stmt_finalize(daci_handler, stmt);
1488
1489         _EXTERN_FUNC_EXIT;
1490
1491         return ret;
1492 }
1493
1494 sync_agent_da_return_e da_delete_item_by_Item_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
1495 {
1496         _EXTERN_FUNC_ENTER;
1497
1498         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1499         retvm_if(itemId == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
1500
1501         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1502         daci_stmt stmt = 0;
1503         char *query = "delete from item_tbl where item_id = ?";
1504
1505         stmt = __query_prepare(daci_handler, query, strlen(query));
1506         if (stmt == NULL)
1507                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1508
1509         __stmt_bind_text(daci_handler, stmt, 1, itemId);
1510
1511         ret = __stmt_write_step(daci_handler, stmt);
1512         __stmt_finalize(daci_handler, stmt);
1513
1514         _EXTERN_FUNC_EXIT;
1515
1516         return ret;
1517 }
1518
1519 sync_agent_da_return_e da_delete_item_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
1520 {
1521         _EXTERN_FUNC_ENTER;
1522
1523         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1524
1525         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1526         daci_stmt stmt = 0;
1527         int i = 0;
1528         int count = 0;
1529         sync_agent_da_item_info_s *item_info = 0;
1530         char *query = "delete from item_tbl where account_id = ? and data_store_id = ?";
1531
1532         /* delete changelog */
1533         item_info = da_get_item_info_by_item_type_id(daci_handler, account_id, itemTypeId, &count);
1534         if (count != 0) {
1535                 for (i = 0; i < count; i++) {
1536                         ret = da_delete_item_changelog_by_item_id(daci_handler, account_id, item_info[i].itemId);
1537                         if (ret != SYNC_AGENT_DA_SUCCESS)
1538                                 goto DACI_FINISH;
1539                 }
1540         }
1541
1542         stmt = __query_prepare(daci_handler, query, strlen(query));
1543         if (stmt == NULL)
1544                 goto DACI_FINISH;
1545
1546         _stmt_bind_int(daci_handler, stmt, 1, account_id);
1547         _stmt_bind_int(daci_handler, stmt, 2, itemTypeId);
1548
1549         ret = __stmt_write_step(daci_handler, stmt);
1550         if (ret != SYNC_AGENT_DA_SUCCESS) {
1551                 goto DACI_FINISH;
1552         }
1553
1554         sync_agent_free_memory_item_info(item_info, count);
1555
1556         _EXTERN_FUNC_EXIT;
1557
1558         return __stmt_finalize(daci_handler, stmt);
1559
1560  DACI_FINISH:
1561
1562         sync_agent_free_memory_item_info(item_info, count);
1563
1564         if (stmt != NULL)
1565                 __stmt_finalize(daci_handler, stmt);
1566
1567         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1568 }
1569
1570 sync_agent_da_return_e da_delete_item_by_item_type_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id)
1571 {
1572         _EXTERN_FUNC_ENTER;
1573
1574         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1575
1576         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1577         daci_stmt stmt = 0;
1578
1579         char *query = "delete from item_tbl where account_id = ? and data_store_id = ?";
1580
1581         stmt = __query_prepare(daci_handler, query, strlen(query));
1582         if (stmt == NULL)
1583                 goto DACI_FINISH;
1584
1585         _stmt_bind_int(daci_handler, stmt, 1, account_id);
1586         _stmt_bind_int(daci_handler, stmt, 2, item_type_id);
1587
1588         ret = __stmt_write_step(daci_handler, stmt);
1589         if (ret != SYNC_AGENT_DA_SUCCESS) {
1590                 goto DACI_FINISH;
1591         }
1592
1593         _EXTERN_FUNC_EXIT;
1594
1595         return __stmt_finalize(daci_handler, stmt);
1596
1597  DACI_FINISH:
1598
1599         if (stmt != NULL)
1600                 __stmt_finalize(daci_handler, stmt);
1601
1602         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1603 }
1604
1605 sync_agent_da_return_e da_delete_item_by_item_type_id_and_delete_changelog(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
1606 {
1607         _EXTERN_FUNC_ENTER;
1608
1609         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1610
1611         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1612         int i = 0;
1613         int count = 0;
1614         sync_agent_da_item_info_s *item_info = 0;
1615
1616         /* delete changelog */
1617         item_info = da_get_item_info_by_item_type_id_and_operation_id(daci_handler, account_id, itemTypeId, 303, &count);
1618         if (count != 0) {
1619                 for (i = 0; i < count; i++) {
1620                         ret = da_delete_item_by_Item_id(daci_handler, item_info[i].itemId);
1621                         if (ret != SYNC_AGENT_DA_SUCCESS)
1622                                 goto DACI_FINISH;
1623
1624                         ret = da_delete_item_changelog_by_item_id(daci_handler, account_id, item_info[i].itemId);
1625                         if (ret != SYNC_AGENT_DA_SUCCESS)
1626                                 goto DACI_FINISH;
1627                 }
1628         }
1629
1630         sync_agent_free_memory_item_info(item_info, count);
1631
1632         _EXTERN_FUNC_EXIT;
1633
1634         return ret;
1635
1636  DACI_FINISH:
1637
1638         sync_agent_free_memory_item_info(item_info, count);
1639
1640         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1641 }
1642
1643 char *da_get_item_item_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *serviceId, int itemTypeId)
1644 {
1645         _EXTERN_FUNC_ENTER;
1646
1647         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1648         retvm_if(serviceId == NULL, NULL, "service Id is NULL !!");
1649
1650         daci_stmt stmt = 0;
1651         char *query = "select item_id from item_tbl where account_id = ? and service_id = ? and data_store_id = ?";
1652         char *item_id = 0;
1653
1654         stmt = __query_prepare(daci_handler, query, strlen(query));
1655         if (stmt != NULL) {
1656                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
1657                 __stmt_bind_text(daci_handler, stmt, 2, serviceId);
1658                 _stmt_bind_int(daci_handler, stmt, 3, itemTypeId);
1659
1660                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
1661                         item_id = _stmt_column_text(stmt, 0);
1662
1663                 __stmt_finalize(daci_handler, stmt);
1664         }
1665
1666         _EXTERN_FUNC_EXIT;
1667
1668         return item_id;
1669 }
1670
1671 sync_agent_da_return_e da_get_item_item_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *service_id, int item_type_id, char **item_id)
1672 {
1673         _EXTERN_FUNC_ENTER;
1674
1675         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1676         retvm_if(service_id == NULL, SYNC_AGENT_DA_ERRORS, "service Id is NULL !!");
1677
1678         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
1679         daci_stmt stmt = 0;
1680         char *query = "select item_id from item_tbl where account_id = ? and service_id = ? and data_store_id = ?";
1681
1682         stmt = __query_prepare(daci_handler, query, strlen(query));
1683         if (stmt != NULL) {
1684                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
1685                 __stmt_bind_text(daci_handler, stmt, 2, service_id);
1686                 _stmt_bind_int(daci_handler, stmt, 3, item_type_id);
1687
1688                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1689                         *item_id = _stmt_column_text(stmt, 0);
1690                         ret = SYNC_AGENT_DA_SUCCESS;
1691                 }
1692
1693                 __stmt_finalize(daci_handler, stmt);
1694         }
1695
1696         _EXTERN_FUNC_EXIT;
1697
1698         return ret;
1699 }
1700
1701 char *da_get_item_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
1702 {
1703         _EXTERN_FUNC_ENTER;
1704
1705         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1706         retvm_if(itemId == NULL, NULL, "item Id is NULL !!");
1707
1708         daci_stmt stmt = 0;
1709         char *query = "select service_id from item_tbl where item_id = ?";
1710         char *service_id = 0;
1711
1712         stmt = __query_prepare(daci_handler, query, strlen(query));
1713         if (stmt != NULL) {
1714                 __stmt_bind_text(daci_handler, stmt, 1, itemId);
1715
1716                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
1717                         service_id = _stmt_column_text(stmt, 0);
1718
1719                 __stmt_finalize(daci_handler, stmt);
1720         }
1721
1722         _EXTERN_FUNC_EXIT;
1723
1724         return service_id;
1725 }
1726
1727 sync_agent_da_item_s *da_get_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
1728 {
1729         _EXTERN_FUNC_ENTER;
1730
1731         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1732         retvm_if(itemId == NULL, NULL, "item Id is NULL !!");
1733
1734         daci_stmt stmt = 0;
1735         char *query = "select  * from item_tbl where item_id = ?";
1736         sync_agent_da_item_s *item = 0;
1737
1738         stmt = __query_prepare(daci_handler, query, strlen(query));
1739         if (stmt != NULL) {
1740                 __stmt_bind_text(daci_handler, stmt, 1, itemId);
1741
1742                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1743                         item = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_s *, sizeof(sync_agent_da_item_s), 1);
1744                         if (item == NULL) {
1745                                 __stmt_finalize(daci_handler, stmt);
1746
1747                                 _DEBUG_ERROR("memory_allocation failed");
1748                                 return item;
1749                         }
1750
1751                         item->item_id = _stmt_column_text(stmt, 0);
1752                         item->data_store_id = __stmt_column_int(stmt, 1);
1753                         item->account_id = __stmt_column_int(stmt, 2);
1754                         item->folder_id = _stmt_column_text(stmt, 3);
1755                         item->service_id = _stmt_column_text(stmt, 4);
1756                         item->access_name = _stmt_column_text(stmt, 6);
1757                 }
1758                 __stmt_finalize(daci_handler, stmt);
1759         }
1760
1761         _EXTERN_FUNC_EXIT;
1762
1763         return item;
1764 }
1765
1766 sync_agent_da_return_e da_get_item_new(SYNC_AGENT_DA_HANDLER * daci_handler, char *item_id, sync_agent_da_item_s ** sync_agent_item)
1767 {
1768         _EXTERN_FUNC_ENTER;
1769
1770         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1771         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
1772
1773         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1774         daci_stmt stmt = 0;
1775         char *query = "select  * from item_tbl where item_id = ?";
1776
1777         stmt = __query_prepare(daci_handler, query, strlen(query));
1778         if (stmt != NULL) {
1779                 __stmt_bind_text(daci_handler, stmt, 1, item_id);
1780
1781                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1782                         (*sync_agent_item)->item_id = _stmt_column_text(stmt, 0);
1783                         (*sync_agent_item)->data_store_id = __stmt_column_int(stmt, 1);
1784                         (*sync_agent_item)->account_id = __stmt_column_int(stmt, 2);
1785                         (*sync_agent_item)->folder_id = _stmt_column_text(stmt, 3);
1786                         (*sync_agent_item)->service_id = _stmt_column_text(stmt, 4);
1787                         (*sync_agent_item)->access_name = _stmt_column_text(stmt, 6);
1788                 }
1789                 __stmt_finalize(daci_handler, stmt);
1790         }
1791
1792         _EXTERN_FUNC_EXIT;
1793
1794         return ret;
1795 }
1796
1797 sync_agent_da_id_list_s *da_get_all_item_id(SYNC_AGENT_DA_HANDLER * daci_handler)
1798 {
1799         _EXTERN_FUNC_ENTER;
1800
1801         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1802
1803         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1804         sync_agent_da_id_list_s *id_list = 0;
1805         char **result = 0;
1806         int row_count = 0;
1807         int col_count = 0;
1808         int index = 1;
1809         int i = 0;
1810         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1811
1812         snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl");
1813
1814         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
1815
1816         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
1817                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
1818                 if (id_list == NULL) {
1819                         _DEBUG_ERROR("memory_allocation failed");
1820                         goto DACI_FINISH;
1821                 }
1822
1823                 id_list->count = row_count;
1824                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
1825
1826                 for (i = 0; i < row_count; i++) {
1827                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
1828                         index++;
1829                 }
1830         }
1831
1832  DACI_FINISH:
1833
1834         if (result != NULL)
1835                 __free_table(result);
1836
1837         _EXTERN_FUNC_EXIT;
1838
1839         return id_list;
1840 }
1841
1842 sync_agent_da_id_list_s *da_get_item_id_list(SYNC_AGENT_DA_HANDLER * daci_handler, char *folderId, sync_agent_da_column_name_e column_name)
1843 {
1844         _EXTERN_FUNC_ENTER;
1845
1846         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1847         retvm_if(folderId == NULL, NULL, "folder Id is NULL !!");
1848
1849         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1850         sync_agent_da_id_list_s *id_list = 0;
1851         char *column_str = 0;
1852         char **result = 0;
1853         int row_count = 0;
1854         int col_count = 0;
1855         int index = 1;
1856         int i = 0;
1857         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1858
1859         column_str = _get_column_name(column_name);
1860
1861         snprintf(g_daci_query, sizeof(g_daci_query), "select %s from item_tbl where folder_id = \'%s\'", column_str, folderId);
1862
1863         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
1864
1865         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
1866                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
1867                 if (id_list == NULL) {
1868                         _DEBUG_ERROR("memory_allocation failed");
1869                         goto DACI_FINISH;
1870                 }
1871
1872                 id_list->count = row_count;
1873                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
1874
1875                 for (i = 0; i < row_count; i++) {
1876                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
1877                         index++;
1878                 }
1879         }
1880
1881  DACI_FINISH:
1882
1883         if (result != NULL)
1884                 __free_table(result);
1885
1886         _EXTERN_FUNC_EXIT;
1887
1888         return id_list;
1889 }
1890
1891 sync_agent_da_return_e da_get_item_id_list_new(SYNC_AGENT_DA_HANDLER * daci_handler, char *folder_id, sync_agent_da_column_name_e column_name, GList ** list)
1892 {
1893         _EXTERN_FUNC_ENTER;
1894
1895         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1896         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
1897
1898         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
1899         char *item_id;
1900         char *column_str = 0;
1901         char **result = 0;
1902         int row_count = 0;
1903         int col_count = 0;
1904         int index = 1;
1905         int i = 0;
1906         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1907
1908         column_str = _get_column_name(column_name);
1909
1910         snprintf(g_daci_query, sizeof(g_daci_query), "select %s from item_tbl where folder_id = \'%s\'", column_str, folder_id);
1911
1912         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
1913
1914         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
1915                 for (i = 0; i < row_count; i++) {
1916                         item_id = NULL;
1917                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
1918                         index++;
1919
1920                         *list = g_list_append(*list, item_id);
1921                 }
1922         }
1923
1924         if (result != NULL)
1925                 __free_table(result);
1926
1927         _EXTERN_FUNC_EXIT;
1928
1929         return ret;
1930 }
1931
1932 sync_agent_da_item_s *da_get_item_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, int *count)
1933 {
1934         _EXTERN_FUNC_ENTER;
1935
1936         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1937
1938         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1939         sync_agent_da_item_s *item = 0;
1940         char **result = 0;
1941         char *new_table = 0;
1942         int row_count = 0;
1943         int col_count = 0;
1944         int index = 6;
1945         int i = 0;
1946         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1947
1948         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
1949         if (new_table == NULL)
1950                 return item;
1951
1952 //      snprintf(g_daci_query, sizeof(g_daci_query), "select item_id, data_store_id, account_id, folder_id, service_id,  access_name from item_tbl where account_id = %d and data_store_id = %d", accountId, itemTypeId);
1953         snprintf(g_daci_query, sizeof(g_daci_query),
1954                  "select item.item_id, item.data_store_id, item.account_id, item.folder_id, item.service_id, item.access_name " "from item_tbl as item " "left join %s as changelog " "using (item_id) "
1955                  "where item.account_id = %d and item.data_store_id = %d and (changelog.operation_id is null or changelog.operation_id != 303)", new_table, account_id, itemTypeId);
1956         _DEBUG_INFO("g_daci_query = %s", g_daci_query);
1957
1958         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
1959         *count = row_count;
1960
1961         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
1962                 item = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_s *, sizeof(sync_agent_da_item_s), row_count);
1963                 if (item == NULL) {
1964                         _DEBUG_ERROR("memory_allocation failed");
1965                         goto DACI_FINISH;
1966                 }
1967
1968                 for (i = 0; i < row_count; i++) {
1969                         item[i].item_id = SYNC_AGENT_DA_STRDUP(result[index]);
1970                         index++;
1971                         item[i].data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
1972                         index++;
1973                         item[i].account_id = SYNC_AGENT_DA_ATOI(result[index]);
1974                         index++;
1975                         item[i].folder_id = SYNC_AGENT_DA_STRDUP(result[index]);
1976                         index++;
1977                         item[i].service_id = SYNC_AGENT_DA_STRDUP(result[index]);
1978                         index++;
1979                         item[i].access_name = SYNC_AGENT_DA_STRDUP(result[index]);
1980                         index++;
1981                 }
1982         }
1983
1984  DACI_FINISH:
1985         if (result != NULL)
1986                 __free_table(result);
1987
1988         /* memory free */
1989         SYNC_AGENT_DA_MEMORY_FREE(new_table);
1990
1991         _EXTERN_FUNC_EXIT;
1992
1993         return item;
1994 }
1995
1996 sync_agent_da_return_e da_get_item_by_account_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id, GList ** list)
1997 {
1998         _EXTERN_FUNC_ENTER;
1999
2000         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2001
2002         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2003         sync_agent_da_item_s *item;
2004         char **result = 0;
2005         char *new_table = 0;
2006         int row_count = 0;
2007         int col_count = 0;
2008         int index = 6;
2009         int i = 0;
2010         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2011
2012         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2013         if (new_table == NULL)
2014                 return ret;
2015
2016 //      snprintf(g_daci_query, sizeof(g_daci_query), "select item_id, data_store_id, account_id, folder_id, service_id,  access_name from item_tbl where account_id = %d and data_store_id = %d", accountId, itemTypeId);
2017         snprintf(g_daci_query, sizeof(g_daci_query),
2018                  "select item.item_id, item.data_store_id, item.account_id, item.folder_id, item.service_id, item.access_name " "from item_tbl as item " "left join %s as changelog " "using (item_id) "
2019                  "where item.account_id = %d and item.data_store_id = %d and (changelog.operation_id is null or changelog.operation_id != 303)", new_table, account_id, item_type_id);
2020         _DEBUG_INFO("g_daci_query = %s", g_daci_query);
2021
2022         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2023
2024         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2025                 for (i = 0; i < row_count; i++) {
2026                         item = NULL;
2027                         ret = sync_agent_create_item(&item);
2028                         if (ret != SYNC_AGENT_DA_SUCCESS) {
2029                                 _DEBUG_ERROR("sync_agent_create_item() failed !!");
2030                                 goto DACI_FINISH;
2031                         }
2032
2033                         item->item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2034                         index++;
2035                         item->data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
2036                         index++;
2037                         item->account_id = SYNC_AGENT_DA_ATOI(result[index]);
2038                         index++;
2039                         item->folder_id = SYNC_AGENT_DA_STRDUP(result[index]);
2040                         index++;
2041                         item->service_id = SYNC_AGENT_DA_STRDUP(result[index]);
2042                         index++;
2043                         item->access_name = SYNC_AGENT_DA_STRDUP(result[index]);
2044                         index++;
2045
2046                         *list = g_list_append(*list, item);
2047                 }
2048         }
2049
2050  DACI_FINISH:
2051         if (result != NULL)
2052                 __free_table(result);
2053
2054         /* memory free */
2055         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2056
2057         _EXTERN_FUNC_EXIT;
2058
2059         return ret;
2060 }
2061
2062 sync_agent_da_item_info_s *da_get_item_info_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, int *count)
2063 {
2064         _EXTERN_FUNC_ENTER;
2065
2066         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2067
2068         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2069         sync_agent_da_item_info_s *itemInfo = 0;
2070         char *new_table = 0;
2071         char **result = 0;
2072         int row_count = 0;
2073         int col_count = 0;
2074         int i = 0;
2075         int index = 5;
2076         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2077
2078         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2079         if (new_table == NULL)
2080                 return itemInfo;
2081         snprintf(g_daci_query, sizeof(g_daci_query),
2082                  "select item.item_id, item.data_store_id, item.service_id, changelog.operation_id, changelog.status " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d", new_table,
2083                  account_id, itemTypeId);
2084
2085         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2086         *count = row_count;
2087         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2088                 itemInfo = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_info_s *, sizeof(sync_agent_da_item_info_s), row_count);
2089                 if (itemInfo == NULL) {
2090                         _DEBUG_ERROR("memory_allocation failed");
2091                         goto DACI_FINISH;
2092                 }
2093                 for (i = 0; i < row_count; i++) {
2094                         itemInfo[i].itemId = SYNC_AGENT_DA_STRDUP(result[index]);
2095                         index++;
2096                         itemInfo[i].itemTypeId = SYNC_AGENT_DA_ATOI(result[index]);
2097                         index++;
2098                         itemInfo[i].serviceId = SYNC_AGENT_DA_STRDUP(result[index]);
2099                         index++;
2100                         itemInfo[i].operationId = SYNC_AGENT_DA_ATOI(result[index]);
2101                         index++;
2102                         itemInfo[i].syncStatus = SYNC_AGENT_DA_STRDUP(result[index]);
2103                         index++;
2104                 }
2105         }
2106
2107  DACI_FINISH:
2108
2109         if (result != NULL)
2110                 __free_table(result);
2111
2112         /* memory free */
2113         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2114
2115         _EXTERN_FUNC_EXIT;
2116
2117         return itemInfo;
2118 }
2119
2120 sync_agent_da_item_info_s *da_get_item_info_by_item_type_id_and_operation_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, int operationId, int *count)
2121 {
2122         _EXTERN_FUNC_ENTER;
2123
2124         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2125
2126         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2127         sync_agent_da_item_info_s *itemInfo = 0;
2128         char *new_table = 0;
2129         char **result = 0;
2130         int row_count = 0;
2131         int col_count = 0;
2132         int i = 0;
2133         int index = 5;
2134         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2135
2136         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2137         if (new_table == NULL)
2138                 return itemInfo;
2139         snprintf(g_daci_query, sizeof(g_daci_query),
2140                  "select item.item_id, item.data_store_id, item.service_id, changelog.operation_id, changelog.status " "from item_tbl as item " "join %s as changelog " "using (item_id) "
2141                  "where item.account_id = %d and item.data_store_id = %d and changelog.operation_id = %d", new_table, account_id, itemTypeId, operationId);
2142
2143         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2144         *count = row_count;
2145         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2146                 itemInfo = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_info_s *, sizeof(sync_agent_da_item_info_s), row_count);
2147                 if (itemInfo == NULL) {
2148                         _DEBUG_ERROR("memory_allocation failed");
2149                         goto DACI_FINISH;
2150                 }
2151                 for (i = 0; i < row_count; i++) {
2152                         itemInfo[i].itemId = SYNC_AGENT_DA_STRDUP(result[index]);
2153                         index++;
2154                         itemInfo[i].itemTypeId = SYNC_AGENT_DA_ATOI(result[index]);
2155                         index++;
2156                         itemInfo[i].serviceId = SYNC_AGENT_DA_STRDUP(result[index]);
2157                         index++;
2158                         itemInfo[i].operationId = SYNC_AGENT_DA_ATOI(result[index]);
2159                         index++;
2160                         itemInfo[i].syncStatus = SYNC_AGENT_DA_STRDUP(result[index]);
2161                         index++;
2162                 }
2163         }
2164
2165  DACI_FINISH:
2166
2167         if (result != NULL)
2168                 __free_table(result);
2169
2170         /* memory free */
2171         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2172
2173         _EXTERN_FUNC_EXIT;
2174
2175         return itemInfo;
2176 }
2177
2178 sync_agent_da_return_e da_get_item_info_by_item_type_id_and_operation_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id, int operation_id, GList ** list)
2179 {
2180         _EXTERN_FUNC_ENTER;
2181
2182         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2183
2184         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2185         char *new_table = 0;
2186         char **result = 0;
2187         int row_count = 0;
2188         int col_count = 0;
2189         int i = 0;
2190         int index = 5;
2191         char *item_id = NULL;
2192         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2193
2194         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2195         if (new_table == NULL) {
2196                 _DEBUG_ERROR("__replace_table_name() failed !!");
2197                 return SYNC_AGENT_DA_ERRORS;
2198         }
2199         snprintf(g_daci_query, sizeof(g_daci_query), "select item.item_id " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d and changelog.operation_id = %d", new_table, account_id,
2200                  item_type_id, operation_id);
2201
2202         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2203         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2204                 for (i = 0; i < row_count; i++) {
2205                         item_id = NULL;
2206                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2207                         index += 5;
2208
2209                         *list = g_list_append(*list, item_id);
2210                 }
2211         } else {
2212                 _DEBUG_INFO("no data !!");
2213         }
2214
2215         if (result != NULL)
2216                 __free_table(result);
2217
2218         /* memory free */
2219         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2220
2221         _EXTERN_FUNC_EXIT;
2222
2223         return ret;
2224 }
2225
2226 sync_agent_da_item_s *da_get_item_mapping_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *itemId, int *count)
2227 {
2228         _EXTERN_FUNC_ENTER;
2229
2230         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2231         retvm_if(itemId == NULL, NULL, "item Id is NULL !!");
2232
2233         daci_stmt stmt = 0;
2234         sync_agent_da_item_s *item = 0;
2235         int data_count = 0;
2236         int i = 0;
2237         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2238
2239         snprintf(g_daci_query, sizeof(g_daci_query),
2240                  "select count(*) from item_tbl where data_store_id in (select data_store_id from item_tbl where account_id = %d and item_id = \'%s\') " "and service_id in (select service_id from item_tbl where account_id = %d and item_id = \'%s\') "
2241                  "and (account_id != %d and item_id != \'%s\')", account_id, itemId, account_id, itemId, account_id, itemId);
2242
2243         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2244         *count = data_count;
2245
2246         if (data_count != 0) {
2247                 /* query initialize */
2248                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2249
2250                 item = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_s *, sizeof(sync_agent_da_item_s), data_count);
2251                 if (item == NULL) {
2252                         _DEBUG_ERROR("memory_allocation failed");
2253                         return item;
2254                 }
2255
2256                 snprintf(g_daci_query, sizeof(g_daci_query),
2257                          "select * from item_tbl where data_store_id in (select data_store_id from item_tbl where account_id = %d and item_id = \'%s\') " "and service_id in (select service_id from item_tbl where account_id = %d and item_id = \'%s\') "
2258                          "and (account_id != %d and item_id != \'%s\')", account_id, itemId, account_id, itemId, account_id, itemId);
2259
2260                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2261                 if (stmt != NULL) {
2262                         for (i = 0; i < data_count; i++) {
2263                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
2264                                         break;
2265
2266                                 item[i].item_id = _stmt_column_text(stmt, 0);
2267                                 item[i].data_store_id = __stmt_column_int(stmt, 1);
2268                                 item[i].account_id = __stmt_column_int(stmt, 2);
2269                                 item[i].folder_id = _stmt_column_text(stmt, 3);
2270                                 item[i].service_id = _stmt_column_text(stmt, 4);
2271                                 item[i].access_name = _stmt_column_text(stmt, 6);
2272                         }
2273
2274                         __stmt_finalize(daci_handler, stmt);
2275                 }
2276         }
2277
2278         _EXTERN_FUNC_EXIT;
2279
2280         return item;
2281 }
2282
2283 sync_agent_da_return_e da_get_item_mapping_service_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *item_id, GList ** list)
2284 {
2285         _EXTERN_FUNC_ENTER;
2286
2287         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2288         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
2289
2290         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2291         daci_stmt stmt = 0;
2292         sync_agent_da_item_s *item;
2293         int data_count = 0;
2294         int i = 0;
2295         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2296
2297         snprintf(g_daci_query, sizeof(g_daci_query),
2298                  "select count(*) from item_tbl where data_store_id in (select data_store_id from item_tbl where account_id = %d and item_id = \'%s\') " "and service_id in (select service_id from item_tbl where account_id = %d and item_id = \'%s\') "
2299                  "and (account_id != %d and item_id != \'%s\')", account_id, item_id, account_id, item_id, account_id, item_id);
2300
2301         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2302
2303         if (data_count != 0) {
2304                 /* query initialize */
2305                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2306
2307                 snprintf(g_daci_query, sizeof(g_daci_query),
2308                          "select * from item_tbl where data_store_id in (select data_store_id from item_tbl where account_id = %d and item_id = \'%s\') " "and service_id in (select service_id from item_tbl where account_id = %d and item_id = \'%s\') "
2309                          "and (account_id != %d and item_id != \'%s\')", account_id, item_id, account_id, item_id, account_id, item_id);
2310
2311                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2312                 if (stmt != NULL) {
2313                         for (i = 0; i < data_count; i++) {
2314                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
2315                                         break;
2316
2317                                 item = NULL;
2318                                 ret = sync_agent_create_item(&item);
2319                                 if (ret != SYNC_AGENT_DA_SUCCESS) {
2320                                         _DEBUG_ERROR("sync_agent_create_item() failed !!");
2321                                         return ret;
2322                                 }
2323
2324                                 item->item_id = _stmt_column_text(stmt, 0);
2325                                 item->data_store_id = __stmt_column_int(stmt, 1);
2326                                 item->account_id = __stmt_column_int(stmt, 2);
2327                                 item->folder_id = _stmt_column_text(stmt, 3);
2328                                 item->service_id = _stmt_column_text(stmt, 4);
2329                                 item->access_name = _stmt_column_text(stmt, 6);
2330
2331                                 *list = g_list_append(*list, item);
2332                         }
2333
2334                         __stmt_finalize(daci_handler, stmt);
2335                 }
2336         } else {
2337                 _DEBUG_ERROR("no data !!");
2338                 ret = SYNC_AGENT_DA_SUCCESS;
2339         }
2340
2341         _EXTERN_FUNC_EXIT;
2342
2343         return ret;
2344 }
2345
2346 sync_agent_da_id_list_s *da_get_item_id_list_by_datastore_id(SYNC_AGENT_DA_HANDLER * daci_handler, int data_store_id)
2347 {
2348         _EXTERN_FUNC_ENTER;
2349
2350         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2351
2352         daci_stmt stmt = 0;
2353         sync_agent_da_id_list_s *item_id_list = 0;
2354         int data_count = 0;
2355         int i = 0;
2356         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2357
2358         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where data_store_id = %d", data_store_id);
2359
2360         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2361
2362         if (data_count != 0) {
2363                 /* query initialize */
2364                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2365
2366                 item_id_list = (sync_agent_da_id_list_s *) calloc(1, sizeof(sync_agent_da_id_list_s));
2367                 if (item_id_list == NULL) {
2368                         _DEBUG_ERROR("CALLOC failed !!!");
2369                         return NULL;
2370                 }
2371                 item_id_list->id = (char **)calloc(data_count, sizeof(char *));
2372                 if (item_id_list->id == NULL) {
2373
2374                         if (item_id_list != NULL)
2375                                 free(item_id_list);
2376
2377                         _DEBUG_ERROR("CALLOC failed !!!");
2378                         return NULL;
2379                 }
2380                 item_id_list->count = data_count;
2381
2382                 snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl where data_store_id = %d", data_store_id);
2383
2384                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2385                 if (stmt != NULL) {
2386                         for (i = 0; i < data_count; i++) {
2387                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2388                                         break;
2389                                 }
2390
2391                                 item_id_list->id[i] = _stmt_column_text(stmt, 0);
2392                         }
2393
2394                         __stmt_finalize(daci_handler, stmt);
2395                 }
2396         }
2397
2398         _EXTERN_FUNC_EXIT;
2399
2400         return item_id_list;
2401 }
2402
2403 sync_agent_da_return_e da_get_item_id_list_by_datastore_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int data_store_id, GList ** list)
2404 {
2405         _EXTERN_FUNC_ENTER;
2406
2407         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2408
2409         daci_stmt stmt = 0;
2410         char *item_id;
2411         int data_count = 0;
2412         int i = 0;
2413         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2414
2415         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where data_store_id = %d", data_store_id);
2416
2417         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2418
2419         if (data_count != 0) {
2420                 /* query initialize */
2421                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2422
2423                 snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl where data_store_id = %d", data_store_id);
2424
2425                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2426                 if (stmt != NULL) {
2427                         for (i = 0; i < data_count; i++) {
2428                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2429                                         break;
2430                                 }
2431
2432                                 item_id = NULL;
2433                                 item_id = _stmt_column_text(stmt, 0);
2434
2435                                 *list = g_list_append(*list, item_id);
2436                         }
2437
2438                         __stmt_finalize(daci_handler, stmt);
2439                 }
2440         }
2441
2442         _EXTERN_FUNC_EXIT;
2443
2444         return SYNC_AGENT_DA_SUCCESS;
2445 }
2446
2447 sync_agent_da_id_list_s *da_get_item_id_list_by_datastore_id_with_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int data_store_id)
2448 {
2449         _EXTERN_FUNC_ENTER;
2450
2451         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2452
2453         daci_stmt stmt = 0;
2454         sync_agent_da_id_list_s *item_id_list = 0;
2455         int data_count = 0;
2456         int i = 0;
2457         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2458
2459         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where account_id = %d and data_store_id = %d", account_id, data_store_id);
2460
2461         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2462
2463         if (data_count != 0) {
2464                 /* query initialize */
2465                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2466
2467                 item_id_list = (sync_agent_da_id_list_s *) calloc(1, sizeof(sync_agent_da_id_list_s));
2468                 if (item_id_list == NULL) {
2469                         _DEBUG_ERROR("CALLOC failed !!!");
2470                         return NULL;
2471                 }
2472                 item_id_list->id = (char **)calloc(data_count, sizeof(char *));
2473                 if (item_id_list->id == NULL) {
2474
2475                         if (item_id_list != NULL)
2476                                 free(item_id_list);
2477
2478                         _DEBUG_ERROR("CALLOC failed !!!");
2479                         return NULL;
2480                 }
2481                 item_id_list->count = data_count;
2482
2483                 snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl where account_id = %d and data_store_id = %d", account_id, data_store_id);
2484
2485                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2486                 if (stmt != NULL) {
2487                         for (i = 0; i < data_count; i++) {
2488                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2489                                         break;
2490                                 }
2491
2492                                 item_id_list->id[i] = _stmt_column_text(stmt, 0);
2493                         }
2494
2495                         __stmt_finalize(daci_handler, stmt);
2496                 }
2497         }
2498
2499         _EXTERN_FUNC_EXIT;
2500
2501         return item_id_list;
2502 }
2503
2504 sync_agent_da_return_e da_get_item_id_list_by_datastore_id_with_account_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int data_store_id, GList ** list)
2505 {
2506         _EXTERN_FUNC_ENTER;
2507
2508         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2509
2510         daci_stmt stmt = 0;
2511         char *item_id;
2512         int data_count = 0;
2513         int i = 0;
2514         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2515
2516         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where account_id = %d and data_store_id = %d", account_id, data_store_id);
2517
2518         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2519
2520         if (data_count != 0) {
2521                 /* query initialize */
2522                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2523
2524                 snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl where account_id = %d and data_store_id = %d", account_id, data_store_id);
2525
2526                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2527                 if (stmt != NULL) {
2528                         for (i = 0; i < data_count; i++) {
2529                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2530                                         break;
2531                                 }
2532
2533                                 item_id = NULL;
2534                                 item_id = _stmt_column_text(stmt, 0);
2535
2536                                 *list = g_list_append(*list, item_id);
2537                         }
2538
2539                         __stmt_finalize(daci_handler, stmt);
2540                 }
2541         }
2542
2543         _EXTERN_FUNC_EXIT;
2544
2545         return SYNC_AGENT_DA_SUCCESS;
2546 }
2547
2548 sync_agent_da_id_list_s *da_get_item_id_list_by_operation_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int data_store_id, int operation_id)
2549 {
2550         _EXTERN_FUNC_ENTER;
2551
2552         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2553
2554         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2555         sync_agent_da_id_list_s *id_list = 0;
2556         char *new_table = 0;
2557         char **result = 0;
2558         int row_count = 0;
2559         int col_count = 0;
2560         int index = 1;
2561         int i = 0;
2562         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2563
2564         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2565         if (new_table == NULL)
2566                 return id_list;
2567
2568         snprintf(query, sizeof(query), "select item.item_id " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d and changelog.operation_id = %d", new_table, account_id,
2569                  data_store_id, operation_id);
2570
2571         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2572         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2573                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
2574
2575                 if (id_list == NULL) {
2576                         _DEBUG_ERROR("memory_allocation failed");
2577                         goto DACI_FINISH;
2578                 }
2579
2580                 id_list->count = row_count;
2581                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
2582
2583                 for (i = 0; i < row_count; i++) {
2584                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
2585                         index++;
2586                 }
2587         }
2588
2589  DACI_FINISH:
2590         if (result != NULL) {
2591                 __free_table(result);
2592         }
2593         /* memory free */
2594         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2595
2596         _EXTERN_FUNC_EXIT;
2597
2598         return id_list;
2599 }
2600
2601 sync_agent_da_return_e da_get_item_id_list_by_operation_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int data_store_id, int operation_id, GList ** list)
2602 {
2603         _EXTERN_FUNC_ENTER;
2604
2605         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2606
2607         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2608         char *item_id;
2609         char *new_table = 0;
2610         char **result = 0;
2611         int row_count = 0;
2612         int col_count = 0;
2613         int index = 1;
2614         int i = 0;
2615         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2616
2617         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2618         if (new_table == NULL)
2619                 return ret;
2620
2621         snprintf(query, sizeof(query), "select item.item_id " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d and changelog.operation_id = %d", new_table, account_id,
2622                  data_store_id, operation_id);
2623
2624         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2625         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2626                 for (i = 0; i < row_count; i++) {
2627                         item_id = NULL;
2628                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2629                         index++;
2630
2631                         *list = g_list_append(*list, item_id);
2632                 }
2633         }
2634
2635         if (result != NULL) {
2636                 __free_table(result);
2637         }
2638         /* memory free */
2639         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2640
2641         _EXTERN_FUNC_EXIT;
2642
2643         return ret;
2644 }
2645
2646 sync_agent_da_id_list_s *da_get_item_id_list_by_operation_id_and_folder_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *folder_id, int data_store_id, int operation_id)
2647 {
2648         _EXTERN_FUNC_ENTER;
2649
2650         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2651         retvm_if(folder_id == NULL, NULL, "folder id is NULL !!");
2652
2653         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2654         sync_agent_da_id_list_s *id_list = 0;
2655         char *new_table = 0;
2656         char **result = 0;
2657         int row_count = 0;
2658         int col_count = 0;
2659         int index = 1;
2660         int i = 0;
2661         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2662
2663         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2664         if (new_table == NULL)
2665                 return id_list;
2666
2667         snprintf(query, sizeof(query), "select item.item_id " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d and item.folder_id = \'%s\' and changelog.operation_id = %d",
2668                  new_table, account_id, data_store_id, folder_id, operation_id);
2669         _DEBUG_INFO("request quary is [%s]\n", query);
2670
2671         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2672         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2673                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
2674
2675                 if (id_list == NULL) {
2676                         _DEBUG_ERROR("memory_allocation failed");
2677                         goto DACI_FINISH;
2678                 }
2679
2680                 id_list->count = row_count;
2681                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
2682
2683                 for (i = 0; i < row_count; i++) {
2684                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
2685                         index++;
2686                 }
2687         }
2688
2689  DACI_FINISH:
2690         if (result != NULL) {
2691                 __free_table(result);
2692         }
2693         /* memory free */
2694         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2695
2696         _EXTERN_FUNC_EXIT;
2697
2698         return id_list;
2699 }
2700
2701 sync_agent_da_return_e da_get_item_id_list_by_operation_id_and_folder_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *folder_id, int data_store_id, int operation_id, GList ** list)
2702 {
2703         _EXTERN_FUNC_ENTER;
2704
2705         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2706         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
2707
2708         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2709         char *item_id;
2710         char *new_table = 0;
2711         char **result = 0;
2712         int row_count = 0;
2713         int col_count = 0;
2714         int index = 1;
2715         int i = 0;
2716         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2717
2718         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2719         if (new_table == NULL)
2720                 return ret;
2721
2722         snprintf(query, sizeof(query), "select item.item_id " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d and item.folder_id = \'%s\' and changelog.operation_id = %d",
2723                  new_table, account_id, data_store_id, folder_id, operation_id);
2724         _DEBUG_INFO("request quary is [%s]\n", query);
2725
2726         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2727         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2728                 for (i = 0; i < row_count; i++) {
2729                         item_id = NULL;
2730                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2731                         index++;
2732
2733                         *list = g_list_append(*list, item_id);
2734                 }
2735         }
2736
2737         if (result != NULL) {
2738                 __free_table(result);
2739         }
2740         /* memory free */
2741         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2742
2743         _EXTERN_FUNC_EXIT;
2744
2745         return ret;
2746 }
2747
2748 sync_agent_da_return_e da_get_item_id_list_by_folder_id_and_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *folder_id, GList ** list)
2749 {
2750         _EXTERN_FUNC_ENTER;
2751
2752         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2753         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
2754
2755         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2756         char *item_id;
2757         char *new_table = 0;
2758         char **result = 0;
2759         int row_count = 0;
2760         int col_count = 0;
2761         int index = 1;
2762         int i = 0;
2763         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2764
2765         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2766         if (new_table == NULL)
2767                 return ret;
2768
2769         snprintf(query, sizeof(query), "select distinct item_tbl.item_id from item_tbl where item_tbl.account_id = %d and item_tbl.folder_id = \'%s\' and item_tbl.item_id not in (select distinct item.item_id from item_tbl as item join %s as changelog where changelog.item_id = item.item_id and changelog.operation_id = 303)", account_id, folder_id, new_table);
2770         _DEBUG_INFO("request quary is [%s]\n", query);
2771
2772         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2773         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2774                 for (i = 0; i < row_count; i++) {
2775                         item_id = NULL;
2776                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2777                         index++;
2778                         *list = g_list_append(*list, item_id);
2779                 }
2780         }
2781
2782         if (result != NULL) {
2783                 __free_table(result);
2784         }
2785
2786         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2787         _EXTERN_FUNC_EXIT;
2788         return ret;
2789 }
2790
2791 int da_is_exist_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
2792 {
2793         _EXTERN_FUNC_ENTER;
2794
2795         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
2796         retvm_if(itemId == NULL, 0, "item Id is NULL !!");
2797
2798         int ret = 1;
2799         int data_count = 0;
2800         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2801
2802         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where item_id = \'%s\'", itemId);
2803
2804         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2805
2806         if (data_count == 0) {
2807                 ret = 0;
2808         } else {
2809                 _DEBUG_ERROR("itemId [%s] already exist number of [%d]", itemId, data_count);
2810         }
2811
2812         _EXTERN_FUNC_EXIT;
2813
2814         return ret;
2815 }
2816
2817 sync_agent_da_return_e da_add_config(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_config_s * config)
2818 {
2819         _EXTERN_FUNC_ENTER;
2820
2821         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2822         retvm_if(config == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_config_s is NULL !!");
2823
2824         daci_stmt stmt = 0;
2825         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2826         char *query = "insert into config_tbl (config_id, key, value, type, access_name) values (?, ?, ?, ?, ?)";
2827
2828         int exist = 0;
2829         ret = da_is_exist_config(daci_handler, config->config_id, config->key, &exist);
2830         if (ret != SYNC_AGENT_DA_SUCCESS) {
2831                 _DEBUG_ERROR("da_is_exist_config is failed");
2832                 return ret;
2833         }
2834
2835         if (exist == 1)
2836                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
2837
2838         stmt = __query_prepare(daci_handler, query, strlen(query));
2839         if (stmt == NULL)
2840                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
2841
2842         _stmt_bind_int(daci_handler, stmt, 1, config->config_id);
2843         __stmt_bind_text(daci_handler, stmt, 2, config->key);
2844         __stmt_bind_text(daci_handler, stmt, 3, config->value);
2845         __stmt_bind_text(daci_handler, stmt, 4, config->type);
2846         __stmt_bind_text(daci_handler, stmt, 5, config->access_name);
2847
2848         ret = __stmt_write_step(daci_handler, stmt);
2849         __stmt_finalize(daci_handler, stmt);
2850
2851         _EXTERN_FUNC_EXIT;
2852
2853         return ret;
2854 }
2855
2856 sync_agent_da_return_e da_add_config_list(SYNC_AGENT_DA_HANDLER * daci_handler, GList * config_list)
2857 {
2858         _EXTERN_FUNC_ENTER;
2859
2860         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2861         retvm_if(config_list == NULL, SYNC_AGENT_DA_ERRORS, "config_list is NULL !!");
2862
2863         daci_stmt stmt = 0;
2864         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2865
2866         GList *iter = NULL;
2867         sync_agent_da_config_s *config = NULL;
2868
2869         char *query = "insert into config_tbl (config_id, key, value, type, access_name) values (?, ?, ?, ?, ?)";
2870
2871         int exist = 0;
2872         for (iter = config_list; iter != NULL; iter = g_list_next(iter)) {
2873                 config = (sync_agent_da_config_s *) iter->data;
2874                 ret = da_is_exist_config(daci_handler, config->config_id, config->key, &exist);
2875                 if (ret != SYNC_AGENT_DA_SUCCESS) {
2876                         _DEBUG_ERROR("da_is_exist_config is failed");
2877                         return ret;
2878                 }
2879
2880                 if (exist == 1)
2881                         return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
2882         }
2883
2884         stmt = __query_prepare(daci_handler, query, strlen(query));
2885         if (stmt == NULL)
2886                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
2887
2888         for (iter = config_list; iter != NULL; iter = g_list_next(iter)) {
2889                 config = (sync_agent_da_config_s *) iter->data;
2890
2891                 _stmt_bind_int(daci_handler, stmt, 1, config->config_id);
2892                 __stmt_bind_text(daci_handler, stmt, 2, config->key);
2893                 __stmt_bind_text(daci_handler, stmt, 3, config->value);
2894                 __stmt_bind_text(daci_handler, stmt, 4, config->type);
2895                 __stmt_bind_text(daci_handler, stmt, 5, config->access_name);
2896
2897                 ret = __stmt_write_step(daci_handler, stmt);
2898                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
2899                         __stmt_finalize(daci_handler, stmt);
2900                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
2901                 }
2902                 _stmt_reset(daci_handler, stmt);
2903         }
2904         __stmt_finalize(daci_handler, stmt);
2905
2906         _EXTERN_FUNC_EXIT;
2907
2908         return ret;
2909 }
2910
2911 sync_agent_da_return_e da_delete_config_by_key(SYNC_AGENT_DA_HANDLER * daci_handler, int configId, char *key)
2912 {
2913         _EXTERN_FUNC_ENTER;
2914
2915         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2916         retvm_if(key == NULL, SYNC_AGENT_DA_ERRORS, "key is NULL !!");
2917
2918         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2919         daci_stmt stmt = 0;
2920         char *query = "delete from config_tbl where config_id = ? and key = ?";
2921
2922         stmt = __query_prepare(daci_handler, query, strlen(query));
2923         if (stmt == NULL)
2924                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
2925
2926         _stmt_bind_int(daci_handler, stmt, 1, configId);
2927         __stmt_bind_text(daci_handler, stmt, 2, key);
2928
2929         ret = __stmt_write_step(daci_handler, stmt);
2930         __stmt_finalize(daci_handler, stmt);
2931
2932         _EXTERN_FUNC_EXIT;
2933
2934         return ret;
2935 }
2936
2937 sync_agent_da_return_e da_get_config_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, GList ** list)
2938 {
2939         _EXTERN_FUNC_ENTER;
2940
2941         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2942
2943         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2944         daci_stmt stmt = 0;
2945         sync_agent_da_config_s *config = 0;
2946         int data_Count = 0;
2947         int i = 0;
2948         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2949         GList *config_list = NULL;
2950
2951         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from config_tbl where config_id = %d", account_id);
2952
2953         data_Count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2954
2955         if (data_Count != 0) {
2956                 /* query initialize */
2957                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2958
2959                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from config_tbl where config_id = %d", account_id);
2960
2961                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2962                 if (stmt != NULL) {
2963                         for (i = 0; i < data_Count; i++) {
2964                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
2965                                         break;
2966
2967                                 config = (sync_agent_da_config_s *) calloc(1, sizeof(sync_agent_da_config_s));
2968                                 if (config == NULL) {
2969                                         _DEBUG_ERROR("memory_allocation failed");
2970                                         ret = SYNC_AGENT_DA_ERR_MEMORY_FULL;
2971                                         return ret;
2972                                 }
2973
2974                                 config->config_id = __stmt_column_int(stmt, 0);
2975                                 config->key = _stmt_column_text(stmt, 1);
2976                                 config->value = _stmt_column_text(stmt, 2);
2977                                 config->type = _stmt_column_text(stmt, 3);
2978                                 config->access_name = _stmt_column_text(stmt, 5);
2979
2980                                 config_list = g_list_append(config_list, config);
2981                         }
2982                         __stmt_finalize(daci_handler, stmt);
2983                 }
2984         }
2985
2986         *list = config_list;
2987
2988         _EXTERN_FUNC_EXIT;
2989
2990         return ret;
2991 }
2992
2993 sync_agent_da_return_e da_get_config_by_key(SYNC_AGENT_DA_HANDLER * daci_handler, int config_id, char *key, sync_agent_da_config_s ** config)
2994 {
2995         _EXTERN_FUNC_ENTER;
2996
2997         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2998         retvm_if(key == NULL, SYNC_AGENT_DA_ERRORS, "key is NULL !!");
2999
3000         int ret = SYNC_AGENT_DA_SUCCESS;
3001         daci_stmt stmt = 0;
3002         char *query = "select key, value, type, access_name from config_tbl where config_id = ? and key =?";
3003
3004         stmt = __query_prepare(daci_handler, query, strlen(query));
3005         if (stmt == NULL) {
3006                 return SYNC_AGENT_DA_ERRORS;
3007         }
3008
3009         _stmt_bind_int(daci_handler, stmt, 1, config_id);
3010         __stmt_bind_text(daci_handler, stmt, 2, key);
3011
3012         if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
3013                 (*config)->config_id = config_id;
3014                 (*config)->key = _stmt_column_text(stmt, 0);
3015                 (*config)->value = _stmt_column_text(stmt, 1);
3016                 (*config)->type = _stmt_column_text(stmt, 2);
3017                 (*config)->access_name = _stmt_column_text(stmt, 3);
3018         } else {
3019                 ret = SYNC_AGENT_DA_ERR_NO_DATA;
3020         }
3021
3022         __stmt_finalize(daci_handler, stmt);
3023
3024         _EXTERN_FUNC_EXIT;
3025
3026         return ret;
3027 }
3028
3029 sync_agent_da_return_e da_is_exist_config(SYNC_AGENT_DA_HANDLER * daci_handler, int config_id, char *key, int *exist)
3030 {
3031         _EXTERN_FUNC_ENTER;
3032
3033         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3034         retvm_if(key == NULL, SYNC_AGENT_DA_ERRORS, "key is NULL !!");
3035
3036         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3037         int result = 1;
3038         int data_count = 0;
3039         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3040
3041         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from config_tbl where config_id = %d and key = \'%s\'", config_id, key);
3042
3043         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3044
3045         if (data_count == 0)
3046                 result = 0;
3047
3048         *exist = result;
3049
3050         _EXTERN_FUNC_EXIT;
3051
3052         return ret;
3053 }
3054
3055 sync_agent_da_return_e da_update_config(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_config_s * config)
3056 {
3057         _EXTERN_FUNC_ENTER;
3058
3059         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3060         retvm_if(config == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_config_s is NULL !!");
3061
3062         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3063         int exist = 0;
3064
3065         ret = da_is_exist_config(daci_handler, config->config_id, config->key, &exist);
3066         if (ret != SYNC_AGENT_DA_SUCCESS) {
3067                 _DEBUG_ERROR("da_is_exist_config is failed");
3068                 return ret;
3069         }
3070
3071         if (exist == 1)
3072                 ret = da_set_config_value(daci_handler, config);
3073         else
3074                 ret = da_add_config(daci_handler, config);
3075
3076         if (ret != SYNC_AGENT_DA_SUCCESS)
3077                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3078
3079         _EXTERN_FUNC_EXIT;
3080
3081         return ret;
3082 }
3083
3084 sync_agent_da_return_e da_set_config_value(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_config_s * config)
3085 {
3086         _EXTERN_FUNC_ENTER;
3087
3088         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3089         retvm_if(config == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_config_s is NULL !!");
3090
3091         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3092
3093         daci_stmt stmt = 0;
3094         char *query = "update config_tbl set value = ?, type = ?, last_update = current_timestamp, access_name = ? " "where config_id = ? and key = ?";
3095
3096         stmt = __query_prepare(daci_handler, query, strlen(query));
3097         if (stmt == NULL)
3098                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3099
3100         __stmt_bind_text(daci_handler, stmt, 1, config->value);
3101         __stmt_bind_text(daci_handler, stmt, 2, config->type);
3102         __stmt_bind_text(daci_handler, stmt, 3, config->access_name);
3103         _stmt_bind_int(daci_handler, stmt, 4, config->config_id);
3104         __stmt_bind_text(daci_handler, stmt, 5, config->key);
3105
3106         ret = _stmt_read_step(daci_handler, stmt);
3107         __stmt_finalize(daci_handler, stmt);
3108
3109         _EXTERN_FUNC_EXIT;
3110
3111         return ret;
3112 }
3113
3114 sync_agent_da_return_e da_add_item_changelog(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, sync_agent_da_item_changelog_s * itemChangelog, int count)
3115 {
3116         _EXTERN_FUNC_ENTER;
3117
3118         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3119         retvm_if(itemChangelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
3120
3121         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3122         daci_stmt stmt = 0;
3123         int i = 0;
3124         char *new_table = 0;
3125         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3126
3127         for (i = 0; i < count; i++) {
3128                 if (da_is_exist_item_changelog(daci_handler, account_id, itemChangelog[i].item_id) == 1)
3129                         return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3130         }
3131
3132         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3133         if (new_table == NULL)
3134                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3135
3136         snprintf(g_daci_query, sizeof(g_daci_query), "insert into %s (item_id, operation_id, status, access_name) values (?, ?, ?, ?)", new_table);
3137
3138         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3139         if (stmt == NULL) {
3140                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3141                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3142         }
3143
3144         for (i = 0; i < count; i++) {
3145                 __stmt_bind_text(daci_handler, stmt, 1, itemChangelog[i].item_id);
3146                 _stmt_bind_int(daci_handler, stmt, 2, itemChangelog[i].operation_id);
3147                 __stmt_bind_text(daci_handler, stmt, 3, ((itemChangelog[i].status == 0) ? "SYNC_REQUIRED" : itemChangelog[i].status));
3148                 __stmt_bind_text(daci_handler, stmt, 4, itemChangelog[i].access_name);
3149
3150                 ret = __stmt_write_step(daci_handler, stmt);
3151                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
3152                         __stmt_finalize(daci_handler, stmt);
3153                         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3154                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3155                 }
3156                 _stmt_reset(daci_handler, stmt);
3157         }
3158
3159         ret = __stmt_finalize(daci_handler, stmt);
3160
3161         /* memory free */
3162         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3163
3164         _EXTERN_FUNC_EXIT;
3165
3166         return ret;
3167 }
3168
3169 sync_agent_da_return_e da_delete_item_changelog_by_item_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *itemId)
3170 {
3171         _EXTERN_FUNC_ENTER;
3172
3173         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3174         retvm_if(itemId == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
3175
3176         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3177         daci_stmt stmt = 0;
3178         char *new_table = 0;
3179         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3180
3181         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3182         if (new_table == NULL)
3183                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3184
3185         snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where item_id = ?", new_table);
3186
3187         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3188         if (stmt == NULL) {
3189                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3190                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3191         }
3192
3193         __stmt_bind_text(daci_handler, stmt, 1, itemId);
3194
3195         ret = __stmt_write_step(daci_handler, stmt);
3196         __stmt_finalize(daci_handler, stmt);
3197
3198         /* memory free */
3199         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3200
3201         _EXTERN_FUNC_EXIT;
3202
3203         return ret;
3204 }
3205
3206 sync_agent_da_return_e da_delete_item_changelog_by_item_id_list(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char **itemIdList, int count)
3207 {
3208         _EXTERN_FUNC_ENTER;
3209
3210         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3211         retvm_if(itemIdList == NULL, SYNC_AGENT_DA_ERRORS, "item Id List is NULL !!");
3212
3213         daci_stmt stmt = 0;
3214         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3215         char *new_table = 0;
3216         int i;
3217         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3218
3219         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3220         if (new_table == NULL)
3221                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3222
3223         snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where item_id = ?", new_table);
3224
3225         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3226         if (stmt == NULL) {
3227                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3228                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3229         }
3230
3231         for (i = 0; i < count; i++) {
3232                 __stmt_bind_text(daci_handler, stmt, 1, itemIdList[i]);
3233
3234                 ret = __stmt_write_step(daci_handler, stmt);
3235
3236                 if (ret != SYNC_AGENT_DA_SUCCESS) {
3237                         __stmt_finalize(daci_handler, stmt);
3238                         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3239                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3240                 }
3241                 _stmt_reset(daci_handler, stmt);
3242         }
3243         __stmt_finalize(daci_handler, stmt);
3244
3245         /* memory free */
3246         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3247
3248         _EXTERN_FUNC_EXIT;
3249
3250         return ret;
3251 }
3252
3253 sync_agent_da_return_e da_delete_item_changelog_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
3254 {
3255         _EXTERN_FUNC_ENTER;
3256
3257         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3258
3259         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3260         daci_stmt stmt = 0;
3261         char *new_table = 0;
3262         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3263
3264         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3265         if (new_table == NULL) {
3266                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3267                 goto DACI_FINISH;
3268         }
3269
3270         snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s " "where item_id in " "(select item_id " "from %s as changelog " "join item_tbl as item " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d)", new_table,
3271                  new_table, account_id, itemTypeId);
3272
3273         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3274         if (stmt == NULL) {
3275                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3276                 goto DACI_FINISH;
3277         }
3278
3279         ret = __stmt_write_step(daci_handler, stmt);
3280         if (ret != SYNC_AGENT_DA_SUCCESS) {
3281                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3282                 goto DACI_FINISH;
3283         }
3284
3285  DACI_FINISH:
3286
3287         if (stmt != NULL)
3288                 __stmt_finalize(daci_handler, stmt);
3289
3290         /* memory free */
3291         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3292
3293         _EXTERN_FUNC_EXIT;
3294
3295         return ret;
3296 }
3297
3298 sync_agent_da_return_e da_set_item_changelog_operation_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, sync_agent_da_item_changelog_s * itemChangelog)
3299 {
3300         _EXTERN_FUNC_ENTER;
3301
3302         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3303         retvm_if(itemChangelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
3304
3305         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3306         daci_stmt stmt = 0;
3307         char *new_table = 0;
3308         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3309
3310         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3311         if (new_table == NULL)
3312                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3313
3314         snprintf(g_daci_query, sizeof(g_daci_query), "update %s set operation_id = ?, status = ?, last_update = current_timestamp, access_name = ? where item_id = ?", new_table);
3315
3316         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3317         if (stmt == NULL) {
3318                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3319                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3320         }
3321
3322         _stmt_bind_int(daci_handler, stmt, 1, itemChangelog->operation_id);
3323         __stmt_bind_text(daci_handler, stmt, 2, itemChangelog->status);
3324         __stmt_bind_text(daci_handler, stmt, 3, itemChangelog->access_name);
3325         __stmt_bind_text(daci_handler, stmt, 4, itemChangelog->item_id);
3326
3327         ret = __stmt_write_step(daci_handler, stmt);
3328         __stmt_finalize(daci_handler, stmt);
3329
3330         /* memory free */
3331         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3332
3333         _EXTERN_FUNC_EXIT;
3334
3335         return ret;
3336 }
3337
3338 sync_agent_da_return_e da_set_item_changelog_sync_status(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, sync_agent_da_item_changelog_s * itemChangelog)
3339 {
3340         _EXTERN_FUNC_ENTER;
3341
3342         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3343         retvm_if(itemChangelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
3344
3345         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3346         daci_stmt stmt = 0;
3347         char *new_table = 0;
3348         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3349
3350         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3351         if (new_table == NULL)
3352                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3353
3354         snprintf(g_daci_query, sizeof(g_daci_query), "update %s set status = ?, last_update = current_timestamp, access_name = ? where item_id = ?", new_table);
3355
3356         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3357         if (stmt == NULL) {
3358                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3359                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3360         }
3361
3362         __stmt_bind_text(daci_handler, stmt, 1, itemChangelog->status);
3363         __stmt_bind_text(daci_handler, stmt, 2, itemChangelog->access_name);
3364         __stmt_bind_text(daci_handler, stmt, 3, itemChangelog->item_id);
3365
3366         ret = __stmt_write_step(daci_handler, stmt);
3367         __stmt_finalize(daci_handler, stmt);
3368
3369         /* memory free */
3370         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3371
3372         _EXTERN_FUNC_EXIT;
3373
3374         return ret;
3375 }
3376
3377 sync_agent_da_return_e da_set_item_changelog_wait_status(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char **folderIdList, int folderIdCount, int *itemTypeIdList, int itemTypeIdCount)
3378 {
3379         _EXTERN_FUNC_ENTER;
3380
3381         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3382         retvm_if(itemTypeIdList == NULL, SYNC_AGENT_DA_ERRORS, "item Type Id List is NULL !!");
3383
3384         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3385         daci_stmt stmt = 0;
3386         char *new_table = 0;
3387         char temp_str[10];
3388         int i = 0;
3389         int len = 0;
3390         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3391
3392         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3393         if (new_table == NULL)
3394                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3395
3396         snprintf(g_daci_query, sizeof(g_daci_query), "update %s " "set status = \'SYNC_WAIT\' " "where item_id in (select item_id " "from item_tbl as item " "join %s as changelog " "using(item_id) " "where item.account_id = %d and (", new_table, new_table,
3397                  account_id);
3398
3399         for (i = 0; i < folderIdCount; i++) {
3400                 len = g_strlcat(g_daci_query, "item.folder_id = \'", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3401                 len = g_strlcat(g_daci_query, folderIdList[i], SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3402
3403                 if (i < folderIdCount - 1) {
3404                         len = g_strlcat(g_daci_query, "\' or ", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3405                 } else {
3406                         len = g_strlcat(g_daci_query, "\') and (", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3407                 }
3408
3409                 if (len >= SYNC_AGENT_DA_MAX_QUERY_LENGTH) {
3410                         _DEBUG_ERROR("g_daci_query buffer overflow !!");
3411                         /* todo : exception handling */
3412                 }
3413         }
3414
3415         for (i = 0; i < itemTypeIdCount; i++) {
3416                 memset(temp_str, 0x00, sizeof(temp_str));
3417                 snprintf(temp_str, sizeof(temp_str), "%d", itemTypeIdList[i]);
3418
3419                 len = g_strlcat(g_daci_query, "item.data_store_id = ", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3420                 len = g_strlcat(g_daci_query, temp_str, SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3421
3422                 if (i < itemTypeIdCount - 1) {
3423                         len = g_strlcat(g_daci_query, " or ", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3424                 } else {
3425                         len = g_strlcat(g_daci_query, ") )", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3426                 }
3427
3428                 if (len >= SYNC_AGENT_DA_MAX_QUERY_LENGTH) {
3429                         _DEBUG_ERROR("g_daci_query buffer overflow !!");
3430                         /* todo : exception handling */
3431                 }
3432         }
3433
3434         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3435         if (stmt == NULL) {
3436                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3437                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3438         }
3439
3440         ret = __stmt_write_step(daci_handler, stmt);
3441         __stmt_finalize(daci_handler, stmt);
3442
3443         /* memory free */
3444         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3445
3446         _EXTERN_FUNC_EXIT;
3447
3448         return ret;
3449 }
3450
3451 sync_agent_da_return_e da_get_item_changelog_by_item_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, sync_agent_da_item_changelog_s * itemChangelog)
3452 {
3453         _EXTERN_FUNC_ENTER;
3454
3455         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3456
3457         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3458         daci_stmt stmt = 0;
3459         char *new_table = 0;
3460         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3461
3462         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3463         if (new_table == NULL)
3464                 return ret;
3465
3466         snprintf(g_daci_query, sizeof(g_daci_query), "select * from %s where item_id = \'%s\'", new_table, itemChangelog->item_id);
3467
3468         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3469         if (stmt != NULL) {
3470                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
3471                         itemChangelog->operation_id = __stmt_column_int(stmt, 1);
3472                         itemChangelog->status = _stmt_column_text(stmt, 2);
3473                         itemChangelog->access_name = _stmt_column_text(stmt, 4);
3474                         ret = SYNC_AGENT_DA_SUCCESS;
3475                 } else if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_SUCCESS) {
3476                         ret = SYNC_AGENT_DA_ERR_NO_DATA;
3477                 }
3478                 __stmt_finalize(daci_handler, stmt);
3479         }
3480
3481         /* memory free */
3482         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3483
3484         _DEBUG_INFO("[%s] End !\n", __func__);
3485
3486         _EXTERN_FUNC_EXIT;
3487
3488         return ret;
3489 }
3490
3491 sync_agent_da_return_e da_get_item_changelog_by_item_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *item_id, sync_agent_da_item_changelog_s ** sync_agent_changelog)
3492 {
3493         _EXTERN_FUNC_ENTER;
3494
3495         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3496         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
3497
3498         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3499         daci_stmt stmt = 0;
3500         char *new_table = 0;
3501         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3502
3503         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3504         if (new_table == NULL)
3505                 return ret;
3506
3507         snprintf(g_daci_query, sizeof(g_daci_query), "select * from %s where item_id = \'%s\'", new_table, item_id);
3508
3509         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3510         if (stmt != NULL) {
3511                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
3512                         (*sync_agent_changelog)->item_id = SYNC_AGENT_DA_STRDUP(item_id);
3513                         (*sync_agent_changelog)->operation_id = __stmt_column_int(stmt, 1);
3514                         (*sync_agent_changelog)->status = _stmt_column_text(stmt, 2);
3515                         (*sync_agent_changelog)->access_name = _stmt_column_text(stmt, 4);
3516                         ret = SYNC_AGENT_DA_SUCCESS;
3517                 } else if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_SUCCESS) {
3518                         ret = SYNC_AGENT_DA_ERR_NO_DATA;
3519                 }
3520                 __stmt_finalize(daci_handler, stmt);
3521         }
3522
3523         /* memory free */
3524         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3525
3526         _EXTERN_FUNC_EXIT;
3527
3528         return ret;
3529 }
3530
3531 sync_agent_da_return_e da_get_item_changelog_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id, GList ** list)
3532 {
3533         _EXTERN_FUNC_ENTER;
3534
3535         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3536
3537         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
3538         sync_agent_da_item_changelog_s *item_changelog;
3539         char *new_table = 0;
3540         char **result = 0;
3541         int row_count = 0;
3542         int col_count = 0;
3543         int i = 0;
3544         int index = 4;
3545         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3546
3547         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3548         if (new_table == NULL)
3549                 return ret;
3550 //      snprintf(g_daci_query, sizeof(g_daci_query), "select item.item_id, item.data_store_id, item.service_id, changelog.operation_id, changelog.status " "from item_tbl as item " "join %s as changelog " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d", new_table, account_id, itemTypeId);
3551         snprintf(g_daci_query, sizeof(g_daci_query),
3552                  "select changelog.item_id, changelog.operation_id, changelog.status, changelog.access_name from %s as changelog " "join item_tbl as item " "using (item_id) " "where item.account_id = %d and item.data_store_id = %d", new_table, account_id,
3553                  item_type_id);
3554
3555         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
3556         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
3557                 for (i = 0; i < row_count; i++) {
3558                         item_changelog = NULL;
3559                         ret = sync_agent_create_changelog(&item_changelog);
3560                         if (ret != SYNC_AGENT_DA_SUCCESS) {
3561                                 _DEBUG_ERROR("sync_agent_create_changelog() failed !!");
3562                                 goto DACI_FINISH;
3563                         }
3564
3565                         item_changelog->item_id = SYNC_AGENT_DA_STRDUP(result[index]);
3566                         index++;
3567                         item_changelog->operation_id = SYNC_AGENT_DA_ATOI(result[index]);
3568                         index++;
3569                         item_changelog->status = SYNC_AGENT_DA_STRDUP(result[index]);
3570                         index++;
3571                         item_changelog->access_name = SYNC_AGENT_DA_STRDUP(result[index]);
3572                         index++;
3573
3574                         *list = g_list_append(*list, item_changelog);
3575                 }
3576         }
3577
3578  DACI_FINISH:
3579
3580         if (result != NULL)
3581                 __free_table(result);
3582
3583         /* memory free */
3584         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3585
3586         _EXTERN_FUNC_EXIT;
3587
3588         return ret;
3589 }
3590
3591 sync_agent_da_item_changelog_s *get_itemChangelogByOperationId(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int operationId, int *count)
3592 {
3593         _EXTERN_FUNC_ENTER;
3594
3595         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
3596
3597         daci_stmt stmt = 0;
3598         sync_agent_da_item_changelog_s *item_changelog = 0;
3599         char *new_table = 0;
3600         int data_count = 0;
3601         int i = 0;
3602         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3603
3604         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3605         if (new_table == NULL)
3606                 return item_changelog;
3607
3608         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from %s where operation_id = %d", new_table, operationId);
3609
3610         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3611         *count = data_count;
3612
3613         if (data_count != 0) {
3614                 /* query initialize */
3615                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
3616
3617                 item_changelog = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_changelog_s *, sizeof(sync_agent_da_item_changelog_s), data_count);
3618                 if (item_changelog == NULL) {
3619                         _DEBUG_ERROR("memory_allocation failed");
3620
3621                         /* memory free */
3622                         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3623
3624                         return item_changelog;
3625                 }
3626
3627                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from %s where operation_id = %d", new_table, operationId);
3628
3629                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3630                 if (stmt != NULL) {
3631                         for (i = 0; i < data_count; i++) {
3632                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
3633                                         break;
3634
3635                                 item_changelog[i].item_id = _stmt_column_text(stmt, 0);
3636                                 item_changelog[i].operation_id = __stmt_column_int(stmt, 1);
3637                                 item_changelog[i].status = _stmt_column_text(stmt, 2);
3638                                 item_changelog[i].access_name = _stmt_column_text(stmt, 4);
3639                         }
3640                         __stmt_finalize(daci_handler, stmt);
3641                 }
3642         }
3643
3644         /* memory free */
3645         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3646
3647         _EXTERN_FUNC_EXIT;
3648
3649         return item_changelog;
3650 }
3651
3652 int da_is_exist_item_changelog(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *itemId)
3653 {
3654         _EXTERN_FUNC_ENTER;
3655
3656         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
3657         retvm_if(itemId == NULL, 0, "item Id is NULL !!");
3658
3659         int ret = 1;
3660         char *new_table = 0;
3661         int data_count = 0;
3662         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3663
3664         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3665         if (new_table == NULL)
3666                 return 0;
3667
3668         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from %s where item_id = \'%s\'", new_table, itemId);
3669
3670         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3671
3672         if (data_count == 0)
3673                 ret = 0;
3674
3675         /* memory free */
3676         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3677
3678         _EXTERN_FUNC_EXIT;
3679
3680         return ret;
3681 }
3682
3683 sync_agent_da_return_e da_add_last_anchor(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_last_anchor_s * last_anchor)
3684 {
3685         _EXTERN_FUNC_ENTER;
3686
3687         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3688         retvm_if(last_anchor == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_last_anchor_s is NULL !!");
3689
3690         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3691         daci_stmt stmt = 0;
3692         char *query = 0;
3693
3694         if (da_is_exist_last_anchor(daci_handler, last_anchor->account_id, last_anchor->data_store_id) == 1)
3695                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3696
3697         query = "insert into last_anchor_tbl (account_id, data_store_id, last_anchor_server, last_anchor_client, access_name) values (?, ?, ?, ?, ?)";
3698
3699         stmt = __query_prepare(daci_handler, query, strlen(query));
3700         if (stmt == NULL)
3701                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3702
3703         _stmt_bind_int(daci_handler, stmt, 1, last_anchor->account_id);
3704         _stmt_bind_int(daci_handler, stmt, 2, last_anchor->data_store_id);
3705         __stmt_bind_text(daci_handler, stmt, 3, last_anchor->last_anchor_server);
3706         __stmt_bind_text(daci_handler, stmt, 4, last_anchor->last_anchor_client);
3707         __stmt_bind_text(daci_handler, stmt, 5, last_anchor->access_name);
3708
3709         ret = __stmt_write_step(daci_handler, stmt);
3710         __stmt_finalize(daci_handler, stmt);
3711
3712         _EXTERN_FUNC_EXIT;
3713
3714         return ret;
3715 }
3716
3717 sync_agent_da_return_e da_delete_last_anchor_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
3718 {
3719         _EXTERN_FUNC_ENTER;
3720
3721         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3722
3723         sync_agent_da_return_e ret = _delete_account(daci_handler, SYNC_AGENT_DA_TABLE_NAME_LAST_ANCHOR, account_id);
3724         if (ret != SYNC_AGENT_DA_SUCCESS)
3725                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3726
3727         _EXTERN_FUNC_EXIT;
3728
3729         return ret;
3730 }
3731
3732 sync_agent_da_return_e da_delete_last_anchor_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
3733 {
3734         _EXTERN_FUNC_ENTER;
3735
3736         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3737
3738         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3739         daci_stmt stmt = 0;
3740         char *query = "delete from last_anchor_tbl where account_id = ? and data_store_id = ?";
3741
3742         stmt = __query_prepare(daci_handler, query, strlen(query));
3743         if (stmt == NULL)
3744                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3745
3746         _stmt_bind_int(daci_handler, stmt, 1, account_id);
3747         _stmt_bind_int(daci_handler, stmt, 2, itemTypeId);
3748
3749         ret = __stmt_write_step(daci_handler, stmt);
3750         __stmt_finalize(daci_handler, stmt);
3751
3752         _EXTERN_FUNC_EXIT;
3753
3754         return ret;
3755 }
3756
3757 sync_agent_da_return_e da_set_last_anchor(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_last_anchor_s * last_anchor)
3758 {
3759         _EXTERN_FUNC_ENTER;
3760
3761         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3762         retvm_if(last_anchor == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_last_anchor_s is NULL !!");
3763
3764         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3765         daci_stmt stmt = 0;
3766         char *query = "update last_anchor_tbl set last_anchor_server = ?, last_anchor_client = ?, last_update = current_timestamp, access_name = ?" "where account_id = ? and data_store_id = ?";
3767
3768         stmt = __query_prepare(daci_handler, query, strlen(query));
3769         if (stmt == NULL)
3770                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3771
3772         __stmt_bind_text(daci_handler, stmt, 1, last_anchor->last_anchor_server);
3773         __stmt_bind_text(daci_handler, stmt, 2, last_anchor->last_anchor_client);
3774         __stmt_bind_text(daci_handler, stmt, 3, last_anchor->access_name);
3775         _stmt_bind_int(daci_handler, stmt, 4, last_anchor->account_id);
3776         _stmt_bind_int(daci_handler, stmt, 5, last_anchor->data_store_id);
3777
3778         ret = __stmt_write_step(daci_handler, stmt);
3779         __stmt_finalize(daci_handler, stmt);
3780
3781         _EXTERN_FUNC_EXIT;
3782
3783         return ret;
3784 }
3785
3786 sync_agent_da_last_anchor_s *da_get_last_anchor_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int *count)
3787 {
3788         _EXTERN_FUNC_ENTER;
3789
3790         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
3791
3792         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3793         sync_agent_da_last_anchor_s *last_anchor = 0;
3794         char **result = 0;
3795         int row_count = 0;
3796         int col_count = 0;
3797         int i = 0;
3798         int index = 4;
3799         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3800
3801         snprintf(g_daci_query, sizeof(g_daci_query), "select account_id, data_store_id, last_anchor_server, last_anchor_client from last_anchor_tbl where account_id = %d", account_id);
3802
3803         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
3804         *count = row_count;
3805
3806         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
3807                 last_anchor = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_last_anchor_s *, sizeof(sync_agent_da_last_anchor_s), row_count);
3808                 if (last_anchor == NULL) {
3809                         _DEBUG_ERROR("memory_allocation failed");
3810                         goto DACI_FINISH;
3811                 }
3812
3813                 for (i = 0; i < row_count; i++) {
3814                         last_anchor[i].account_id = SYNC_AGENT_DA_ATOI(result[index]);
3815                         index++;
3816                         last_anchor[i].data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
3817                         index++;
3818                         last_anchor[i].last_anchor_server = SYNC_AGENT_DA_STRDUP(result[index]);
3819                         index++;
3820                         last_anchor[i].last_anchor_client = SYNC_AGENT_DA_STRDUP(result[index]);
3821                         index++;
3822                         last_anchor[i].access_name = 0;
3823                 }
3824         }
3825
3826  DACI_FINISH:
3827
3828         if (result != NULL)
3829                 __free_table(result);
3830
3831         _EXTERN_FUNC_EXIT;
3832
3833         return last_anchor;
3834 }
3835
3836 sync_agent_da_last_anchor_s *da_get_last_anchor_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, int *count)
3837 {
3838         _EXTERN_FUNC_ENTER;
3839
3840         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
3841
3842         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3843         sync_agent_da_last_anchor_s *last_anchor = 0;
3844         char **result = 0;
3845         int row_count = 0;
3846         int col_count = 0;
3847         int i = 0;
3848         int index = 4;
3849         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3850
3851         snprintf(g_daci_query, sizeof(g_daci_query), "select account_id, data_store_id, last_anchor_server, last_anchor_client from last_anchor_tbl where account_id = %d and data_store_id = %d", account_id, itemTypeId);
3852
3853         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
3854         *count = row_count;
3855
3856         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
3857                 last_anchor = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_last_anchor_s *, sizeof(sync_agent_da_last_anchor_s), row_count);
3858                 if (last_anchor == NULL) {
3859                         _DEBUG_ERROR("memory_allocation failed");
3860                         goto DACI_FINISH;
3861                 }
3862
3863                 for (i = 0; i < row_count; i++) {
3864                         last_anchor[i].account_id = SYNC_AGENT_DA_ATOI(result[index]);
3865                         index++;
3866                         last_anchor[i].data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
3867                         index++;
3868                         last_anchor[i].last_anchor_server = SYNC_AGENT_DA_STRDUP(result[index]);
3869                         index++;
3870                         last_anchor[i].last_anchor_client = SYNC_AGENT_DA_STRDUP(result[index]);
3871                         index++;
3872                         last_anchor[i].access_name = 0;
3873                 }
3874         }
3875
3876  DACI_FINISH:
3877
3878         if (result != NULL)
3879                 __free_table(result);
3880
3881         _EXTERN_FUNC_EXIT;
3882
3883         return last_anchor;
3884 }
3885
3886 sync_agent_da_return_e da_get_last_anchor_by_item_type_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int item_type_id, GList ** list)
3887 {
3888         _EXTERN_FUNC_ENTER;
3889
3890         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3891
3892         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
3893         sync_agent_da_last_anchor_s *last_anchor = NULL;
3894         char **result = 0;
3895         int row_count = 0;
3896         int col_count = 0;
3897         int i = 0;
3898         int index = 4;
3899         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3900
3901         snprintf(g_daci_query, sizeof(g_daci_query), "select account_id, data_store_id, last_anchor_server, last_anchor_client from last_anchor_tbl where account_id = %d and data_store_id = %d", account_id, item_type_id);
3902
3903         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
3904 //      *count = row_count;
3905
3906         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
3907                 for (i = 0; i < row_count; i++) {
3908                         last_anchor = NULL;
3909                         ret = sync_agent_create_last_anchor(&last_anchor);
3910                         if (ret != SYNC_AGENT_DA_SUCCESS) {
3911                                 _DEBUG_ERROR("sync_agent_create_last_anchor() failed !!");
3912                                 goto DACI_FINISH;
3913                         }
3914
3915                         last_anchor->account_id = SYNC_AGENT_DA_ATOI(result[index]);
3916                         index++;
3917                         last_anchor->data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
3918                         index++;
3919                         last_anchor->last_anchor_server = SYNC_AGENT_DA_STRDUP(result[index]);
3920                         index++;
3921                         last_anchor->last_anchor_client = SYNC_AGENT_DA_STRDUP(result[index]);
3922                         index++;
3923                         last_anchor->access_name = NULL;
3924
3925                         *list = g_list_append(*list, last_anchor);
3926                 }
3927         } else if (ret != SYNC_AGENT_DA_SUCCESS) {
3928                 _DEBUG_ERROR("__get_table() failed !!");
3929                 return ret;
3930         }
3931
3932  DACI_FINISH:
3933
3934         if (result != NULL)
3935                 __free_table(result);
3936
3937         _EXTERN_FUNC_EXIT;
3938
3939         return ret;
3940 }
3941
3942 int da_is_exist_last_anchor(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
3943 {
3944         _EXTERN_FUNC_ENTER;
3945
3946         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
3947
3948         int ret = 1;
3949         int data_count = 0;
3950         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3951
3952         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from last_anchor_tbl where account_id = %d and data_store_id = %d", account_id, itemTypeId);
3953
3954         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3955
3956         if (data_count == 0)
3957                 ret = 0;
3958
3959         _EXTERN_FUNC_EXIT;
3960
3961         return ret;
3962 }
3963
3964 sync_agent_da_return_e da_add_mapping(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_mapping_s * mapping)
3965 {
3966         _EXTERN_FUNC_ENTER;
3967
3968         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3969         retvm_if(mapping == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_mapping_s is NULL !!");
3970
3971         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3972         daci_stmt stmt = 0;
3973         char *query = 0;
3974
3975         if (da_is_exist_mapping_by_luid(daci_handler, mapping->account_id, mapping->luid) == 1) {
3976                 _DEBUG_INFO("exist mapping item");
3977                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3978         }
3979
3980         query = "insert into mapping_tbl (account_id, data_store_id, luid, guid, access_name) values (?, ?, ?, ?, ?)";
3981
3982         stmt = __query_prepare(daci_handler, query, strlen(query));
3983         if (stmt == NULL) {
3984                 _DEBUG_ERROR("stmt is NULL !!");
3985                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3986         }
3987
3988         _DEBUG_INFO("account_id = %d", mapping->account_id);
3989         _DEBUG_INFO("data_store_id = %d", mapping->data_store_id);
3990         _DEBUG_INFO("luid = %s", mapping->luid);
3991         _DEBUG_INFO("guid = %s", mapping->guid);
3992         _DEBUG_INFO("access_name = %s", mapping->access_name);
3993
3994         _stmt_bind_int(daci_handler, stmt, 1, mapping->account_id);
3995         _stmt_bind_int(daci_handler, stmt, 2, mapping->data_store_id);
3996         __stmt_bind_text(daci_handler, stmt, 3, mapping->luid);
3997         __stmt_bind_text(daci_handler, stmt, 4, mapping->guid);
3998         __stmt_bind_text(daci_handler, stmt, 5, mapping->access_name);
3999
4000         _DEBUG_INFO("query = %s", query);
4001
4002         ret = __stmt_write_step(daci_handler, stmt);
4003         __stmt_finalize(daci_handler, stmt);
4004
4005         _EXTERN_FUNC_EXIT;
4006
4007         return ret;
4008 }
4009
4010 sync_agent_da_return_e da_delete_mapping_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4011 {
4012         _EXTERN_FUNC_ENTER;
4013
4014         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4015
4016         sync_agent_da_return_e ret = _delete_account(daci_handler, SYNC_AGENT_DA_TABLE_NAME_MAPPING, account_id);
4017         if (ret != SYNC_AGENT_DA_SUCCESS)
4018                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4019
4020         _EXTERN_FUNC_EXIT;
4021
4022         return ret;
4023 }
4024
4025 sync_agent_da_return_e da_delete_mapping_by_luid(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid)
4026 {
4027         _EXTERN_FUNC_ENTER;
4028
4029         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4030         retvm_if(luid == NULL, SYNC_AGENT_DA_ERRORS, "luid is NULL !!");
4031
4032         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4033         daci_stmt stmt = 0;
4034         char *query = "delete from mapping_tbl where account_id = ? and luid = ?";
4035
4036         stmt = __query_prepare(daci_handler, query, strlen(query));
4037         if (stmt == NULL)
4038                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4039
4040         _stmt_bind_int(daci_handler, stmt, 1, account_id);
4041         __stmt_bind_text(daci_handler, stmt, 2, luid);
4042
4043         ret = __stmt_write_step(daci_handler, stmt);
4044         __stmt_finalize(daci_handler, stmt);
4045
4046         _EXTERN_FUNC_EXIT;
4047
4048         return ret;
4049 }
4050
4051 sync_agent_da_mapping_s *da_get_mapping_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int *count)
4052 {
4053         _EXTERN_FUNC_ENTER;
4054
4055         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4056
4057         daci_stmt stmt = 0;
4058         sync_agent_da_mapping_s *mapping = 0;
4059         int data_count = 0;
4060         int i = 0;
4061         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4062
4063         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d", account_id);
4064
4065         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4066         *count = data_count;
4067
4068         if (data_count != 0) {
4069                 /* query initialize */
4070                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
4071
4072                 mapping = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_mapping_s *, sizeof(sync_agent_da_mapping_s), data_count);
4073                 if (mapping == NULL) {
4074                         _DEBUG_ERROR("memory_allocation failed");
4075                         return mapping;
4076                 }
4077
4078                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from mapping_tbl where account_id = %d", account_id);
4079
4080                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
4081                 if (stmt != NULL) {
4082                         for (i = 0; i < data_count; i++) {
4083                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
4084                                         break;
4085
4086                                 mapping[i].account_id = __stmt_column_int(stmt, 0);
4087                                 mapping[i].data_store_id = __stmt_column_int(stmt, 1);
4088                                 mapping[i].luid = _stmt_column_text(stmt, 2);
4089                                 mapping[i].guid = _stmt_column_text(stmt, 3);
4090                                 mapping[i].access_name = _stmt_column_text(stmt, 5);
4091                         }
4092                         __stmt_finalize(daci_handler, stmt);
4093                 }
4094         }
4095
4096         _EXTERN_FUNC_EXIT;
4097
4098         return mapping;
4099 }
4100
4101 sync_agent_da_return_e da_get_mapping_by_account_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, GList ** list)
4102 {
4103         _EXTERN_FUNC_ENTER;
4104
4105         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4106
4107         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
4108         daci_stmt stmt = 0;
4109         sync_agent_da_mapping_s *mapping;
4110         int data_count = 0;
4111         int i = 0;
4112         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4113
4114         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d", account_id);
4115
4116         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4117
4118         if (data_count != 0) {
4119                 /* query initialize */
4120                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
4121
4122                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from mapping_tbl where account_id = %d", account_id);
4123
4124                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
4125                 if (stmt != NULL) {
4126                         for (i = 0; i < data_count; i++) {
4127                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
4128                                         break;
4129
4130                                 mapping = NULL;
4131                                 ret = sync_agent_create_mapping(&mapping);
4132                                 if (ret != SYNC_AGENT_DA_SUCCESS) {
4133                                         _DEBUG_ERROR("sync_agent_create_mapping() failed !!");
4134                                         return ret;
4135                                 }
4136
4137                                 mapping->account_id = __stmt_column_int(stmt, 0);
4138                                 mapping->data_store_id = __stmt_column_int(stmt, 1);
4139                                 mapping->luid = _stmt_column_text(stmt, 2);
4140                                 mapping->guid = _stmt_column_text(stmt, 3);
4141                                 mapping->access_name = _stmt_column_text(stmt, 5);
4142
4143                                 *list = g_list_append(*list, mapping);
4144                         }
4145                         __stmt_finalize(daci_handler, stmt);
4146                 } else {
4147                         _DEBUG_ERROR("stmt is NULL !!");
4148                 }
4149         } else {
4150                 _DEBUG_INFO("no data !!");
4151                 ret = SYNC_AGENT_DA_SUCCESS;
4152         }
4153
4154         _EXTERN_FUNC_EXIT;
4155
4156         return ret;
4157 }
4158
4159 char *da_get_mapping_guid(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid)
4160 {
4161         _EXTERN_FUNC_ENTER;
4162
4163         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4164         retvm_if(luid == NULL, NULL, "luid is NULL !!");
4165
4166         daci_stmt stmt = 0;
4167         char *query = "select guid from mapping_tbl where account_id = ? and luid = ?";
4168         char *guid = 0;
4169
4170         stmt = __query_prepare(daci_handler, query, strlen(query));
4171         if (stmt != NULL) {
4172                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
4173                 __stmt_bind_text(daci_handler, stmt, 2, luid);
4174
4175                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
4176                         guid = _stmt_column_text(stmt, 0);
4177
4178                 __stmt_finalize(daci_handler, stmt);
4179         }
4180
4181         _EXTERN_FUNC_EXIT;
4182
4183         return guid;
4184 }
4185
4186 sync_agent_da_return_e da_get_mapping_guid_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid, sync_agent_da_mapping_s ** sync_agent_mapping)
4187 {
4188         _EXTERN_FUNC_ENTER;
4189
4190         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4191         retvm_if(luid == NULL, SYNC_AGENT_DA_ERRORS, "luid is NULL !!");
4192
4193         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
4194         daci_stmt stmt = 0;
4195         char *query = "select * from mapping_tbl where account_id = ? and luid = ?";
4196
4197         stmt = __query_prepare(daci_handler, query, strlen(query));
4198         if (stmt != NULL) {
4199                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
4200                 __stmt_bind_text(daci_handler, stmt, 2, luid);
4201
4202                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4203                         (*sync_agent_mapping)->account_id = __stmt_column_int(stmt, 0);
4204                         (*sync_agent_mapping)->data_store_id = __stmt_column_int(stmt, 1);
4205                         (*sync_agent_mapping)->luid = _stmt_column_text(stmt, 2);
4206                         (*sync_agent_mapping)->guid = _stmt_column_text(stmt, 3);
4207                         (*sync_agent_mapping)->access_name = _stmt_column_text(stmt, 5);
4208                         ret = SYNC_AGENT_DA_SUCCESS;
4209                 }
4210
4211                 __stmt_finalize(daci_handler, stmt);
4212         } else {
4213                 _DEBUG_ERROR("stmt is NULL !!");
4214         }
4215
4216         _EXTERN_FUNC_EXIT;
4217
4218         return ret;
4219 }
4220
4221 int da_is_exist_mapping_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4222 {
4223         _EXTERN_FUNC_ENTER;
4224
4225         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
4226
4227         int ret = 1;
4228         int data_count = 0;
4229         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4230
4231         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d", account_id);
4232
4233         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4234
4235         if (data_count == 0)
4236                 ret = 0;
4237
4238         _EXTERN_FUNC_EXIT;
4239
4240         return ret;
4241 }
4242
4243 int da_is_exist_mapping_by_luid(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid)
4244 {
4245         _EXTERN_FUNC_ENTER;
4246
4247         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
4248         retvm_if(luid == NULL, 0, "luid is NULL !!");
4249
4250         int ret = 1;
4251         int data_count = 0;
4252         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4253
4254         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d and luid = \'%s\'", account_id, luid);
4255
4256         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4257
4258         if (data_count == 0)
4259                 ret = 0;
4260
4261         _DEBUG_INFO("ret : %d", ret);
4262
4263         _EXTERN_FUNC_EXIT;
4264
4265         return ret;
4266 }
4267
4268 sync_agent_da_return_e da_add_id_provider(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_id_provider_s * id_provider)
4269 {
4270         _EXTERN_FUNC_ENTER;
4271
4272         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4273         retvm_if(id_provider == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_provider_s is NULL !!");
4274
4275         daci_stmt stmt = 0;
4276         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4277         char *query = 0;
4278
4279         query = "insert into id_provider_tbl (id_provider_code, id_capacity, bit_per_page, last_id, free_bit_cnt) values (?, ?, ?, ?, ?)";
4280
4281         stmt = __query_prepare(daci_handler, query, strlen(query));
4282         if (stmt == NULL) {
4283                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4284         }
4285
4286         _stmt_bind_int(daci_handler, stmt, 1, id_provider->id_provider_code);
4287         _stmt_bind_int(daci_handler, stmt, 2, id_provider->id_capacity);
4288         _stmt_bind_int(daci_handler, stmt, 3, id_provider->bit_per_page);
4289         _stmt_bind_int(daci_handler, stmt, 4, id_provider->last_id);
4290         _stmt_bind_int(daci_handler, stmt, 5, id_provider->free_bit_cnt);
4291
4292         ret = __stmt_write_step(daci_handler, stmt);
4293         if (ret != SYNC_AGENT_DA_SUCCESS) {
4294                 __stmt_finalize(daci_handler, stmt);
4295                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4296         }
4297
4298         __stmt_finalize(daci_handler, stmt);
4299
4300         _EXTERN_FUNC_EXIT;
4301
4302         return ret;
4303 }
4304
4305 sync_agent_da_return_e da_get_id_provider(SYNC_AGENT_DA_HANDLER * daci_handler, unsigned int id_provider_code, sync_agent_da_id_provider_s ** id_provider)
4306 {
4307         _EXTERN_FUNC_ENTER;
4308
4309         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4310
4311         int ret = SYNC_AGENT_DA_SUCCESS;
4312         daci_stmt stmt = 0;
4313         char *query = "select id_capacity, bit_per_page, last_id, free_bit_cnt from id_provider_tbl where id_provider_code = ?";
4314
4315         stmt = __query_prepare(daci_handler, query, strlen(query));
4316         if (stmt != NULL) {
4317                 _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4318
4319                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4320                         *id_provider = (sync_agent_da_id_provider_s *) calloc(1, sizeof(sync_agent_da_id_provider_s));
4321                         if (*id_provider == NULL) {
4322                                 _DEBUG_ERROR("CALLOC failed !!!");
4323                                 return SYNC_AGENT_DA_ERRORS;
4324                         }
4325                         (*id_provider)->id_capacity = __stmt_column_int(stmt, 0);
4326                         (*id_provider)->bit_per_page = __stmt_column_int(stmt, 1);
4327                         (*id_provider)->last_id = __stmt_column_int(stmt, 2);
4328                         (*id_provider)->free_bit_cnt = __stmt_column_int(stmt, 3);
4329                 } else {
4330                         ret = SYNC_AGENT_DA_ERR_NO_DATA;
4331                 }
4332                 __stmt_finalize(daci_handler, stmt);
4333         }
4334
4335         _EXTERN_FUNC_EXIT;
4336
4337         return ret;
4338 }
4339
4340 sync_agent_da_return_e da_update_id_provider(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_id_provider_s * id_provider)
4341 {
4342         _EXTERN_FUNC_ENTER;
4343
4344         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4345         retvm_if(id_provider == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_provider_s is NULL !!");
4346
4347         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4348         daci_stmt stmt = 0;
4349         char *query = "update id_provider_tbl set last_id = ?, free_bit_cnt = ? where id_provider_code = ?";
4350
4351         stmt = __query_prepare(daci_handler, query, strlen(query));
4352         if (stmt == NULL)
4353                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4354
4355         _stmt_bind_int(daci_handler, stmt, 1, id_provider->last_id);
4356         _stmt_bind_int(daci_handler, stmt, 2, id_provider->free_bit_cnt);
4357         _stmt_bind_int(daci_handler, stmt, 3, id_provider->id_provider_code);
4358
4359         ret = __stmt_write_step(daci_handler, stmt);
4360         __stmt_finalize(daci_handler, stmt);
4361
4362         _EXTERN_FUNC_EXIT;
4363
4364         return ret;
4365 }
4366
4367 sync_agent_da_return_e da_add_id_page(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_id_page_s * id_page, unsigned int page_byte_size)
4368 {
4369         _EXTERN_FUNC_ENTER;
4370
4371         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4372         retvm_if(id_page == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_page_s is NULL !!");
4373
4374         daci_stmt stmt = 0;
4375         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4376         char *query = 0;
4377
4378         query = "insert into id_page_tbl (page_index, id_provider_code, page_bit) values (?, ?, ?)";
4379
4380         stmt = __query_prepare(daci_handler, query, strlen(query));
4381         if (stmt == NULL) {
4382                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4383         }
4384
4385         _stmt_bind_int(daci_handler, stmt, 1, id_page->page_index);
4386         _stmt_bind_int(daci_handler, stmt, 2, id_page->id_provider_code);
4387         _stmt_bind_blob(daci_handler, stmt, 3, id_page->page_bit, page_byte_size);
4388         int i = 0;
4389         for (; i < page_byte_size; i++) {
4390                 _DEBUG_INFO("[%d] %d\n", i, (id_page->page_bit)[i]);
4391         }
4392
4393         ret = __stmt_write_step(daci_handler, stmt);
4394         if (ret != SYNC_AGENT_DA_SUCCESS) {
4395                 __stmt_finalize(daci_handler, stmt);
4396                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4397         }
4398
4399         __stmt_finalize(daci_handler, stmt);
4400
4401         _EXTERN_FUNC_EXIT;
4402
4403         return ret;
4404 }
4405
4406 sync_agent_da_return_e da_delete_id_page(SYNC_AGENT_DA_HANDLER * daci_handler, unsigned int id_provider_code, unsigned int page_index)
4407 {
4408         _EXTERN_FUNC_ENTER;
4409
4410         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4411
4412         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4413         daci_stmt stmt = 0;
4414         char *query = "delete from id_page_tbl where id_provider_code = ? and page_index = ?";
4415
4416         stmt = __query_prepare(daci_handler, query, strlen(query));
4417         if (stmt == NULL)
4418                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4419
4420         _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4421         _stmt_bind_int(daci_handler, stmt, 2, page_index);
4422
4423         ret = __stmt_write_step(daci_handler, stmt);
4424         __stmt_finalize(daci_handler, stmt);
4425
4426         _EXTERN_FUNC_EXIT;
4427
4428         return ret;
4429 }
4430
4431 sync_agent_da_return_e da_get_id_page(SYNC_AGENT_DA_HANDLER * daci_handler, unsigned int id_provider_code, unsigned int page_index, char **page_bit)
4432 {
4433         _EXTERN_FUNC_ENTER;
4434
4435         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4436
4437         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4438         daci_stmt stmt = 0;
4439         char *query = "select page_bit from id_page_tbl where id_provider_code = ? and page_index = ?";
4440
4441         stmt = __query_prepare(daci_handler, query, strlen(query));
4442         if (stmt != NULL) {
4443                 _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4444                 _stmt_bind_int(daci_handler, stmt, 2, page_index);
4445
4446                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4447                         int byte_len = sqlite3_column_bytes(stmt, 0);
4448                         byte_len += 1;  /* The count which sqlite3_column_bytes returns doesn't include trailing \0 in case of string. */
4449                         *page_bit = (char *)calloc(byte_len, sizeof(char));
4450                         if (*page_bit == NULL) {
4451                                 _DEBUG_ERROR("CALLOC failed !!!");
4452                                 return SYNC_AGENT_DA_ERRORS;
4453                         }
4454
4455                         const unsigned char *geted_page_bit = sqlite3_column_text(stmt, 0);
4456
4457                         memcpy(*page_bit, geted_page_bit, byte_len);
4458                 } else {
4459                         _DEBUG_INFO("NO DATA");
4460                         *page_bit = 0;
4461                 }
4462                 __stmt_finalize(daci_handler, stmt);
4463         }
4464
4465         _EXTERN_FUNC_EXIT;
4466
4467         return ret;
4468 }
4469
4470 sync_agent_da_return_e da_get_id_page_index(SYNC_AGENT_DA_HANDLER * daci_handler, unsigned int id_provider_code, int *count)
4471 {
4472         _EXTERN_FUNC_ENTER;
4473
4474         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4475
4476         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4477         daci_stmt stmt = 0;
4478         char *query = "select count(*) from id_page_tbl where id_provider_code = ?;";
4479
4480         stmt = __query_prepare(daci_handler, query, strlen(query));
4481         if (stmt != NULL) {
4482                 _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4483
4484                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4485                         *count = __stmt_column_int(stmt, 0);
4486                 } else {
4487                         _DEBUG_INFO("NO DATA");
4488                         *count = 0;
4489                 }
4490                 __stmt_finalize(daci_handler, stmt);
4491         }
4492
4493         _EXTERN_FUNC_EXIT;
4494
4495         return ret;
4496 }
4497
4498 sync_agent_da_return_e da_update_id_page(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_id_page_s * id_page, unsigned int page_byte_size)
4499 {
4500         _EXTERN_FUNC_ENTER;
4501
4502         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4503         retvm_if(id_page == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_page_s is NULL !!");
4504
4505         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4506         daci_stmt stmt = 0;
4507         char *query = "update id_page_tbl set page_bit = ? where id_provider_code = ? and page_index = ?";
4508
4509         stmt = __query_prepare(daci_handler, query, strlen(query));
4510         if (stmt == NULL)
4511                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4512
4513         _stmt_bind_blob(daci_handler, stmt, 1, id_page->page_bit, page_byte_size);
4514         _stmt_bind_int(daci_handler, stmt, 2, id_page->id_provider_code);
4515         _stmt_bind_int(daci_handler, stmt, 3, id_page->page_index);
4516
4517         ret = __stmt_write_step(daci_handler, stmt);
4518         __stmt_finalize(daci_handler, stmt);
4519
4520         _EXTERN_FUNC_EXIT;
4521
4522         return ret;
4523 }
4524
4525 sync_agent_da_return_e da_get_item_count_by_datastore_id(SYNC_AGENT_DA_HANDLER *daci_handler, int data_store_id, int fw_account_id, int *item_count)
4526 {
4527         _EXTERN_FUNC_ENTER;
4528
4529         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4530
4531         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4532         char *new_table = 0;
4533         int data_count = 0;
4534
4535         _DEBUG_INFO("data_store_id = %d", data_store_id);
4536
4537         new_table = __replace_table_name("account_%d_item_changelog_tbl", fw_account_id, 1);
4538         if (new_table == NULL) {
4539                 _DEBUG_ERROR("__replace_table_name is failed");
4540                 *item_count = 0;
4541                 return SYNC_AGENT_DA_ERRORS;
4542         }
4543
4544         snprintf(query, sizeof(query), "select count(distinct item_tbl.item_id) from item_tbl where item_tbl.account_id = %d and item_tbl.data_store_id = %d and"
4545                 " item_tbl.item_id not in (select distinct item.item_id from item_tbl as item join %s as changelog where changelog.item_id = item.item_id and item.data_store_id = %d and changelog.operation_id = 303)", fw_account_id, data_store_id, new_table, data_store_id);
4546         _DEBUG_INFO("query = %s", query);
4547         data_count = _get_data_count(daci_handler, query, strlen(query));
4548
4549         *item_count = data_count;
4550
4551         if (new_table != NULL)
4552                 free(new_table);
4553         new_table = NULL;
4554
4555         _EXTERN_FUNC_EXIT;
4556         return SYNC_AGENT_DA_SUCCESS;
4557 }
4558
4559
4560 int _busy_handler(void *pData, int count)
4561 {
4562         _INNER_FUNC_ENTER;
4563
4564         _DEBUG_TRACE("__busy_handler %d called", count);
4565
4566         /*  sleep time when SQLITE_LOCK */
4567         usleep(100000);
4568
4569         _INNER_FUNC_EXIT;
4570
4571         /* retry will be stopped if  busy handler return 0 */
4572         return SYNC_AGENT_DA_RETRY_COUNT - count;
4573 }
4574
4575 sync_agent_da_return_e __query_exec(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, char *err_msg)
4576 {
4577         _INNER_FUNC_ENTER;
4578
4579         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_NOT_OPENED, "SYNC_AGENT_DA_HANDLER is NULL !!");
4580         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "query is NULL !!");
4581
4582         char *query_msg = 0;
4583         int ret = 0;
4584
4585         int err_mutex = pthread_mutex_lock(&exec_lock);
4586         if (err_mutex) {
4587                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4588         }
4589         ret = sqlite3_exec(daci_handler, query, 0, 0, &query_msg);
4590         err_mutex = pthread_mutex_unlock(&exec_lock);
4591         if (err_mutex) {
4592                 _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4593         }
4594
4595         if (ret != SQLITE_OK) {
4596                 _DEBUG_ERROR("%s(%d) : %s", err_msg, ret, query_msg);
4597
4598                 if (NULL != query_msg)
4599                         sqlite3_free(query_msg);
4600
4601                 if (ret == SQLITE_BUSY)
4602                         return SYNC_AGENT_DA_ERR_LOCKED;
4603
4604                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4605         }
4606
4607         _INNER_FUNC_EXIT;
4608
4609         return SYNC_AGENT_DA_SUCCESS;
4610 }
4611
4612 daci_stmt __query_prepare(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, int size)
4613 {
4614         _INNER_FUNC_ENTER;
4615
4616         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4617         retvm_if(query == NULL, NULL, "query is NULL !!");
4618
4619         int ret = 0;
4620         daci_stmt stmt = 0;
4621
4622         int err_mutex = pthread_mutex_lock(&exec_lock);
4623         if (err_mutex) {
4624                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4625         }
4626         ret = sqlite3_prepare_v2(daci_handler, query, size, &stmt, 0);
4627         err_mutex = pthread_mutex_unlock(&exec_lock);
4628         if (err_mutex) {
4629                 _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4630         }
4631
4632         if (ret != SQLITE_OK)
4633                 _DEBUG_ERROR("sqlite3_query_prepare failed(%d) : %s ", ret, sqlite3_errmsg(daci_handler));
4634
4635         _INNER_FUNC_EXIT;
4636
4637         return stmt;
4638 }
4639
4640 sync_agent_da_return_e __stmt_bind_text(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const char *value)
4641 {
4642         _INNER_FUNC_ENTER;
4643
4644         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4645
4646         int ret = 0;
4647
4648         if (value != NULL) {
4649                 ret = sqlite3_bind_text(stmt, index, value, strlen(value), SQLITE_STATIC);
4650         } else {
4651                 ret = __stmt_bind_null(daci_handler, stmt, index);
4652
4653                 if (ret == SYNC_AGENT_DA_SUCCESS)
4654                         ret = SQLITE_OK;
4655         }
4656
4657         if (ret != SQLITE_OK) {
4658                 _DEBUG_ERROR("sqlite3_stmt_bind_text failed(%d) : %s ", ret, sqlite3_errmsg(daci_handler));
4659                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4660         }
4661
4662         _INNER_FUNC_EXIT;
4663
4664         return SYNC_AGENT_DA_SUCCESS;
4665 }
4666
4667 sync_agent_da_return_e _stmt_bind_int(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const int value)
4668 {
4669         _INNER_FUNC_ENTER;
4670
4671         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4672
4673         int ret = 0;
4674
4675         ret = sqlite3_bind_int(stmt, index, value);
4676         if (ret != SQLITE_OK) {
4677                 _DEBUG_ERROR("sqlite3_stmt_bind_int failed(%d) : %s \n", ret, sqlite3_errmsg(daci_handler));
4678                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4679         }
4680
4681         _INNER_FUNC_EXIT;
4682
4683         return SYNC_AGENT_DA_SUCCESS;
4684 }
4685
4686 static sync_agent_da_return_e _stmt_bind_blob(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const void *value, int nbyte)
4687 {
4688         _INNER_FUNC_ENTER;
4689
4690         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4691
4692         int ret = 0;
4693
4694         ret = sqlite3_bind_blob(stmt, index, value, nbyte, 0);
4695         if (ret != SQLITE_OK) {
4696                 _DEBUG_ERROR("sqlite3_bind_blob failed(%d) : %s \n", ret, sqlite3_errmsg(daci_handler));
4697                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4698         }
4699
4700         _INNER_FUNC_EXIT;
4701
4702         return SYNC_AGENT_DA_SUCCESS;
4703 }
4704
4705 sync_agent_da_return_e __stmt_bind_null(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index)
4706 {
4707         _INNER_FUNC_ENTER;
4708
4709         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4710
4711         int ret = 0;
4712
4713         ret = sqlite3_bind_null(stmt, index);
4714         if (ret != SQLITE_OK) {
4715                 _DEBUG_ERROR("sqlite3_stmt_bind_null failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4716                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4717         }
4718
4719         _INNER_FUNC_EXIT;
4720
4721         return SYNC_AGENT_DA_SUCCESS;
4722 }
4723
4724 sync_agent_da_return_e _stmt_read_step(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
4725 {
4726         _INNER_FUNC_ENTER;
4727
4728         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4729
4730         int ret = 0;
4731 //      int err_mutex = 0;
4732
4733 //      err_mutex = pthread_mutex_lock(&exec_lock);
4734 //      if (err_mutex) {
4735 //              _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4736 //      }
4737
4738         ret = sqlite3_step(stmt);
4739
4740 //      err_mutex = pthread_mutex_unlock(&exec_lock);
4741 //      if (err_mutex) {
4742 //              _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4743 //      }
4744
4745         if (ret == SQLITE_ROW)
4746                 return SYNC_AGENT_DA_ERR_MORE_DATA;
4747
4748         if (ret != SQLITE_DONE) {
4749                 _DEBUG_ERROR("sqlite3_stmt_step failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4750
4751                 if (ret == SQLITE_BUSY)
4752                         return SYNC_AGENT_DA_ERR_LOCKED;
4753
4754                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4755         }
4756
4757         _INNER_FUNC_EXIT;
4758
4759         return SYNC_AGENT_DA_SUCCESS;
4760 }
4761
4762 static sync_agent_da_return_e __stmt_write_step(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
4763 {
4764         _INNER_FUNC_ENTER;
4765
4766         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4767
4768         int transaction_flag = 0;
4769         int err_mutex = 0;
4770
4771         if (use_transaction_thread_id != 0) {
4772                 if (use_transaction_thread_id != SYNC_AGENT_DA_GET_THREAD_ID) {
4773                         err_mutex = pthread_mutex_lock(&transaction_lock);
4774                         if (err_mutex) {
4775                                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4776                         }
4777                         use_transaction_thread_id = SYNC_AGENT_DA_GET_THREAD_ID;
4778                         transaction_flag = 1;
4779                 }
4780         }
4781
4782         err_mutex = pthread_mutex_lock(&exec_lock);
4783         if (err_mutex) {
4784                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4785         }
4786
4787         int ret = sqlite3_step(stmt);
4788
4789         err_mutex = pthread_mutex_unlock(&exec_lock);
4790         if (err_mutex) {
4791                 _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4792         }
4793
4794         if (transaction_flag) {
4795                 use_transaction_thread_id = 0;
4796                 err_mutex = pthread_mutex_unlock(&transaction_lock);
4797                 if (err_mutex) {
4798                         _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4799                 }
4800         }
4801
4802         if (ret == SQLITE_ROW) {
4803                 return SYNC_AGENT_DA_ERR_MORE_DATA;
4804         }
4805
4806         if (ret != SQLITE_DONE) {
4807                 _DEBUG_ERROR("sqlite3_stmt_step failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4808                 if (ret == SQLITE_BUSY) {
4809                         _DEBUG_ERROR("Never reached this line!!");
4810                         return SYNC_AGENT_DA_ERR_LOCKED;
4811                 }
4812                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4813         }
4814
4815         _INNER_FUNC_EXIT;
4816
4817         return SYNC_AGENT_DA_SUCCESS;
4818 }
4819
4820 sync_agent_da_return_e _stmt_reset(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
4821 {
4822         _INNER_FUNC_ENTER;
4823
4824         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4825
4826         int ret = 0;
4827
4828         if (sqlite3_reset(stmt) != SQLITE_OK) {
4829                 _DEBUG_ERROR("sqlite3_stmt_reset failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4830                 return SYNC_AGENT_DA_ERRORS;
4831         }
4832
4833         _INNER_FUNC_EXIT;
4834
4835         return SYNC_AGENT_DA_SUCCESS;
4836 }
4837
4838 sync_agent_da_return_e __stmt_finalize(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
4839 {
4840         _INNER_FUNC_ENTER;
4841
4842         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4843
4844         int ret = 0;
4845
4846         if (sqlite3_finalize(stmt) != SQLITE_OK) {
4847                 _DEBUG_ERROR("sqlite3_stmt_finalize failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4848                 return SYNC_AGENT_DA_ERRORS;
4849         }
4850
4851         _INNER_FUNC_EXIT;
4852
4853         return SYNC_AGENT_DA_SUCCESS;
4854 }
4855
4856 char *_stmt_column_text(daci_stmt stmt, int index)
4857 {
4858         _INNER_FUNC_ENTER;
4859
4860         char *temp = 0;
4861
4862         temp = (char *)sqlite3_column_text(stmt, index);
4863
4864         _INNER_FUNC_EXIT;
4865
4866         return SYNC_AGENT_DA_STRDUP(temp);
4867 }
4868
4869 int __stmt_column_int(daci_stmt stmt, int index)
4870 {
4871         _INNER_FUNC_ENTER;
4872
4873         _INNER_FUNC_EXIT;
4874
4875         return (int)sqlite3_column_int(stmt, index);
4876 }
4877
4878 sync_agent_da_return_e _get_table(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, char ***result, int *row_count, int *col_count)
4879 {
4880         _INNER_FUNC_ENTER;
4881
4882         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_NOT_OPENED, "SYNC_AGENT_DA_HANDLER is NULL !!");
4883         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "query is NULL !!");
4884
4885         int ret = 0;
4886         char *err_msg;
4887
4888         int err_mutex = pthread_mutex_lock(&exec_lock);
4889         if (err_mutex) {
4890                 _DEBUG_TRACE("Failed pthread_mutex_lock : %d", err_mutex);
4891         }
4892         ret = sqlite3_get_table(daci_handler, query, result, row_count, col_count, &err_msg);
4893         err_mutex = pthread_mutex_unlock(&exec_lock);
4894         if (err_mutex) {
4895                 _DEBUG_TRACE("Failed pthread_mutex_lock : %d", err_mutex);
4896         }
4897
4898         if (ret != SQLITE_OK) {
4899                 _DEBUG_ERROR("sqlite3_get_table failed(%d) : %s", ret, err_msg);
4900
4901                 __free_table(*result);
4902                 if (NULL != err_msg)
4903                         sqlite3_free(err_msg);
4904                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4905         }
4906
4907         _INNER_FUNC_EXIT;
4908
4909         return SYNC_AGENT_DA_SUCCESS;
4910 }
4911
4912 void __free_table(char **result)
4913 {
4914         _INNER_FUNC_ENTER;
4915
4916         if (result != NULL)
4917                 sqlite3_free_table(result);
4918
4919         _INNER_FUNC_EXIT;
4920 }
4921
4922 sync_agent_da_return_e _create_changelog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4923 {
4924         _INNER_FUNC_ENTER;
4925
4926         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4927
4928         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4929         char *new_table = 0;
4930         char *new_table_create = 0;
4931
4932         ret = da_begin_transaction(daci_handler);
4933         if (ret != SYNC_AGENT_DA_SUCCESS) {
4934                 _DEBUG_ERROR("agent_db_changelog_tbl_create failed");
4935                 return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
4936         }
4937
4938         /* 9. create account_item_changelog_tbl */
4939         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
4940         if (new_table == NULL) {
4941                 da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
4942                 return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
4943         }
4944
4945         if (__exist_table(daci_handler, new_table) == 0) {
4946                 new_table_create = __replace_table_name(g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG], account_id, 4);
4947
4948                 ret = __query_exec(daci_handler, new_table_create, "Item_changelog_tbl_create failed");
4949
4950                 if (ret != SYNC_AGENT_DA_SUCCESS) {
4951                         da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
4952                         return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
4953                 }
4954         }
4955
4956         /* memory free */
4957         SYNC_AGENT_DA_MEMORY_FREE(new_table);
4958         SYNC_AGENT_DA_MEMORY_FREE(new_table_create);
4959
4960         _INNER_FUNC_EXIT;
4961
4962         return da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_COMMIT);
4963 }
4964
4965 sync_agent_da_return_e _drop_changelog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4966 {
4967         _INNER_FUNC_ENTER;
4968
4969         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4970
4971         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4972         char *new_table_drop = 0;
4973
4974         /* 9. drop account_item_changelog_tbl */
4975         new_table_drop = __replace_table_name(g_daci_drop_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG], account_id, 1);
4976
4977         ret = __query_exec(daci_handler, new_table_drop, "Item_changelog_tbl_drop failed");
4978         if (ret != SYNC_AGENT_DA_SUCCESS) {
4979 /*              da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);*/
4980                 return SYNC_AGENT_DA_ERR_DROP_TABLE_FAILED;
4981         }
4982
4983         /* memory free */
4984         SYNC_AGENT_DA_MEMORY_FREE(new_table_drop);
4985
4986         _INNER_FUNC_EXIT;
4987
4988         return ret;
4989 }
4990
4991 sync_agent_da_return_e _delete_changlog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4992 {
4993         _INNER_FUNC_ENTER;
4994
4995         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4996
4997         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4998         char *new_table_delete = 0;
4999
5000         /* 9. delete account_item_changelog_tbl */
5001         new_table_delete = __replace_table_name(g_daci_delete_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG], account_id, 1);
5002
5003         ret = __query_exec(daci_handler, new_table_delete, "Item_changelog_tbl_delete failed");
5004         if (ret != SYNC_AGENT_DA_SUCCESS) {
5005                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
5006         }
5007
5008         /* memory free */
5009         SYNC_AGENT_DA_MEMORY_FREE(new_table_delete);
5010
5011         _INNER_FUNC_EXIT;
5012
5013         return ret;
5014 }
5015
5016 int __exist_table(SYNC_AGENT_DA_HANDLER * daci_handler, const char *table_name)
5017 {
5018         _INNER_FUNC_ENTER;
5019
5020         daci_stmt stmt = 0;
5021         int table_count = 0;
5022         char *query = "select count(*) from sqlite_master where tbl_name= ?";
5023
5024         stmt = __query_prepare(daci_handler, query, strlen(query));
5025         if ((stmt != NULL) && (__stmt_bind_text(daci_handler, stmt, 1, table_name) == SYNC_AGENT_DA_SUCCESS)) {
5026
5027                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
5028                         table_count = __stmt_column_int(stmt, 0);
5029
5030                 __stmt_finalize(daci_handler, stmt);
5031
5032                 if (table_count > 0) {
5033                         _INNER_FUNC_EXIT;
5034
5035                         return 1;
5036                 }
5037         }
5038
5039         _INNER_FUNC_EXIT;
5040
5041         return 0;
5042 }
5043
5044 int _get_data_count(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, int size)
5045 {
5046         _INNER_FUNC_ENTER;
5047
5048         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
5049         retvm_if(query == NULL, 0, "query is NULL !!");
5050
5051         daci_stmt stmt = 0;
5052         int data_count = 0;
5053
5054         stmt = __query_prepare(daci_handler, query, size);
5055         if (stmt != NULL) {
5056                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
5057                         data_count = __stmt_column_int(stmt, 0);
5058
5059                 __stmt_finalize(daci_handler, stmt);
5060         }
5061
5062         _INNER_FUNC_EXIT;
5063
5064         return data_count;
5065 }
5066
5067 char *__replace_table_name(char *oldTable, int account_id, int count)
5068 {
5069         _INNER_FUNC_ENTER;
5070
5071         retvm_if(oldTable == NULL, NULL, "old Table is NULL !!");
5072
5073         char *new_table = 0;
5074         int length = 0;
5075
5076         /* SVACE : Measure the size for allocation memory. */
5077         if (count == 1)         /* table name convert */
5078                 length = snprintf(0, 0, oldTable, account_id);
5079         else if (count == 4)    /* table create query convert */
5080                 length = snprintf(0, 0, oldTable, account_id, account_id, account_id, account_id);
5081
5082         new_table = SYNC_AGENT_DA_MEMORY_MALLOC(char *, sizeof(char), (length + 1));
5083         if (new_table == NULL) {
5084                 _DEBUG_ERROR("memory_allocation failed");
5085                 return new_table;
5086         }
5087
5088         if (count == 1) {
5089                 snprintf(new_table, length + 1, oldTable, account_id);
5090         } else if (count == 4) {
5091                 snprintf(new_table, length + 1, oldTable, account_id, account_id, account_id, account_id);
5092         }
5093
5094         _INNER_FUNC_EXIT;
5095
5096         return new_table;
5097 }
5098
5099 char *__get_table_name(sync_agent_da_table_name_e table_name)
5100 {
5101         _INNER_FUNC_ENTER;
5102
5103         char *table_str = 0;
5104
5105         switch (table_name) {
5106         case SYNC_AGENT_DA_TABLE_NAME_ACCOUNT:
5107                 {
5108                         table_str = "account_tbl";
5109                 }
5110                 break;
5111         case SYNC_AGENT_DA_TABLE_NAME_FOLDER:
5112                 {
5113                         table_str = "folder_tbl";
5114                 }
5115                 break;
5116         case SYNC_AGENT_DA_TABLE_NAME_ITEM:
5117                 {
5118                         table_str = "item_tbl";
5119                 }
5120                 break;
5121         case SYNC_AGENT_DA_TABLE_NAME_CONFIG:
5122                 {
5123                         table_str = "config_tbl";
5124                 }
5125                 break;
5126         case SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG:
5127                 {
5128                         table_str = "account_item_changelog_tbl";
5129                 }
5130                 break;
5131         case SYNC_AGENT_DA_TABLE_NAME_LAST_ANCHOR:
5132                 {
5133                         table_str = "last_anchor_tbl";
5134                 }
5135                 break;
5136         case SYNC_AGENT_DA_TABLE_NAME_MAPPING:
5137                 {
5138                         table_str = "mapping_tbl";
5139                 }
5140                 break;
5141         case SYNC_AGENT_DA_TABLE_NAME_ID_PROVIDER:
5142                 {
5143                         table_str = "id_provider_tbl";
5144                 }
5145                 break;
5146         case SYNC_AGENT_DA_TABLE_NAME_ID_PAGE:
5147                 {
5148                         table_str = "id_page_tbl";
5149                 }
5150                 break;
5151         default:
5152                 break;
5153         }
5154
5155         _INNER_FUNC_EXIT;
5156
5157         return table_str;
5158 }
5159
5160 char *_get_column_name(sync_agent_da_column_name_e column_name)
5161 {
5162         _INNER_FUNC_ENTER;
5163
5164         char *column_str = 0;
5165
5166         switch (column_name) {
5167         case SYNC_AGENT_DA_COLUMN_NAME_ITEM_ID:
5168                 {
5169                         column_str = "item_id";
5170                 }
5171                 break;
5172         case SYNC_AGENT_DA_COLUMN_NAME_SERVICE_ID:
5173                 {
5174                         column_str = "service_id";
5175                 }
5176                 break;
5177         default:
5178                 break;
5179         }
5180
5181         _INNER_FUNC_EXIT;
5182
5183         return column_str;
5184 }
5185
5186 int _get_next_account_id(void)
5187 {
5188         _INNER_FUNC_ENTER;
5189
5190         int next_account_id = 1;
5191         int *account_id_list = 0;
5192         int count = 0;
5193         int i = 0;
5194
5195         account_id_list = da_get_account_id_list(&count);
5196         if (account_id_list != NULL) {
5197                 for (i = 0; i < count; i++) {
5198                         if ((i + 1) != account_id_list[i])
5199                                 break;
5200
5201                         next_account_id++;
5202                 }
5203
5204                 free(account_id_list);
5205         }
5206
5207         _INNER_FUNC_EXIT;
5208
5209         return next_account_id;
5210 }
5211
5212 sync_agent_da_return_e _delete_account(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_table_name_e table_name, int account_id)
5213 {
5214         _INNER_FUNC_ENTER;
5215
5216         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5217
5218         daci_stmt stmt = 0;
5219         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
5220         char *table_str = 0;
5221         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
5222
5223         table_str = __get_table_name(table_name);
5224
5225         if (!strcmp(table_str, "config_tbl")) {
5226                 snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where config_id = %d", table_str, account_id);
5227         } else if (!strcmp(table_str, "id_provider_tbl") || !strcmp(table_str, "id_page_tbl")) {
5228                 return ret;
5229         } else {
5230                 snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where account_id = %d", table_str, account_id);
5231         }
5232
5233         _DEBUG_TRACE("i = %d, tableName = %s, query = %s", table_name, table_str, g_daci_query);
5234         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
5235         if (stmt == NULL)
5236                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
5237
5238         ret = __stmt_write_step(daci_handler, stmt);
5239         __stmt_finalize(daci_handler, stmt);
5240
5241         _INNER_FUNC_EXIT;
5242
5243         return ret;
5244 }
5245
5246 /*
5247  *=============================================================================================================================
5248  * Testing
5249  *=============================================================================================================================
5250 */
5251 void da_drop_table(SYNC_AGENT_DA_HANDLER * daci_handler, int *accountIdList, int account_count)
5252 {
5253         _EXTERN_FUNC_ENTER;
5254
5255         retm_if(daci_handler == NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
5256         retm_if(accountIdList == NULL, "account Id List is NULL !!");
5257
5258         int i;
5259
5260         for (i = 0; i < account_count; i++)
5261                 _drop_changelog_table(daci_handler, accountIdList[i]);
5262
5263         _EXTERN_FUNC_EXIT;
5264 }
5265
5266 char *da_get_daci_file_path(void)
5267 {
5268         _EXTERN_FUNC_ENTER;
5269
5270         _EXTERN_FUNC_EXIT;
5271
5272         return daci_file_path;
5273 }