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," "parent_service_id varchar(64) default 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, parent_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].parent_service_id);
1408                 __stmt_bind_text(daci_handler, stmt, 7, item[i].access_name);
1409
1410                 ret = __stmt_write_step(daci_handler, stmt);
1411                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
1412                         __stmt_finalize(daci_handler, stmt);
1413                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1414                 }
1415                 _stmt_reset(daci_handler, stmt);
1416         }
1417
1418         __stmt_finalize(daci_handler, stmt);
1419         _EXTERN_FUNC_EXIT;
1420         return ret;
1421 }
1422
1423 sync_agent_da_return_e da_update_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *fw_id, char *parent_id)
1424 {
1425         _EXTERN_FUNC_ENTER;
1426         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1427         retvm_if(fw_id == NULL, SYNC_AGENT_DA_ERRORS, "fw_id is NULL !!");
1428         retvm_if(parent_id == NULL, SYNC_AGENT_DA_ERRORS, "parent_id is NULL !!");
1429
1430         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1431         daci_stmt stmt = 0;
1432         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1433
1434         snprintf(query, sizeof(query), "update item_tbl set parent_service_id = %s where item_id = %s", parent_id, fw_id);
1435         _DEBUG_INFO("query = %s", query);
1436         stmt = __query_prepare(daci_handler, query, strlen(query));
1437         if (stmt == NULL) {
1438                 _DEBUG_ERROR("stmt is null");
1439                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
1440                 goto return_part;
1441         }
1442
1443         ret = __stmt_write_step(daci_handler, stmt);
1444         if (ret != SYNC_AGENT_DA_SUCCESS) {
1445                 _DEBUG_ERROR("__stmt_write_step() failed !!");
1446                 goto return_part;
1447         }
1448         __stmt_finalize(daci_handler, stmt);
1449
1450 return_part:
1451         _DEBUG_INFO("return_part");
1452         _EXTERN_FUNC_EXIT;
1453         return ret;
1454 }
1455
1456 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)
1457 {
1458         _EXTERN_FUNC_ENTER;
1459
1460         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1461         retvm_if(item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
1462
1463         daci_stmt stmt = 0;
1464         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1465         char **id_list = NULL;
1466
1467         int i;
1468         for (i = 0; i < count; i++) {
1469                 if (item[i].item_id != NULL) {
1470                         if (da_is_exist_item(daci_handler, item[i].item_id) == 1)
1471                                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
1472                 }
1473         }
1474
1475         char *query = "insert into item_tbl (item_id, data_store_id, account_id, folder_id, service_id, parent_service_id, access_name) values (?, ?, ?, ?, ?, ?, ?)";
1476
1477         stmt = __query_prepare(daci_handler, query, strlen(query));
1478         if (stmt == NULL) {
1479                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1480         }
1481
1482         for (i = 0; i < count; i++) {
1483                 if (item[i].item_id != NULL) {
1484                         __stmt_bind_text(daci_handler, stmt, 1, item[i].item_id);
1485                         *item_id = strdup(item[i].item_id);
1486                 } else {
1487                         id_list = sync_agent_generate_item_luid(1, 1);
1488                         if (id_list != NULL) {
1489                                 __stmt_bind_text(daci_handler, stmt, 1, id_list[0]);
1490
1491                                 *item_id = strdup(id_list[0]);
1492
1493                                 if (id_list[0] != NULL)
1494                                         free(id_list[0]);
1495
1496                                 if (id_list != NULL)
1497                                         free(id_list);
1498
1499                                 id_list = NULL;
1500                         } else {
1501                                 _DEBUG_ERROR("sync_agent_generate_item_luid() failed !!");
1502                                 return SYNC_AGENT_DA_ERRORS;
1503                         }
1504                 }
1505                 _stmt_bind_int(daci_handler, stmt, 2, item[i].data_store_id);
1506                 _stmt_bind_int(daci_handler, stmt, 3, item[i].account_id);
1507                 __stmt_bind_text(daci_handler, stmt, 4, item[i].folder_id);
1508                 __stmt_bind_text(daci_handler, stmt, 5, item[i].service_id);
1509                 __stmt_bind_text(daci_handler, stmt, 6, item[i].parent_service_id);
1510                 __stmt_bind_text(daci_handler, stmt, 7, item[i].access_name);
1511
1512                 ret = __stmt_write_step(daci_handler, stmt);
1513                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
1514                         __stmt_finalize(daci_handler, stmt);
1515                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1516                 }
1517                 _stmt_reset(daci_handler, stmt);
1518         }
1519
1520         __stmt_finalize(daci_handler, stmt);
1521
1522         _EXTERN_FUNC_EXIT;
1523
1524         return ret;
1525 }
1526
1527 sync_agent_da_return_e da_delete_item_by_Item_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
1528 {
1529         _EXTERN_FUNC_ENTER;
1530
1531         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1532         retvm_if(itemId == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
1533
1534         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1535         daci_stmt stmt = 0;
1536         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1537         char *service_id = NULL;
1538
1539         snprintf(query, sizeof(query), "select service_id from item_tbl where item_id = %s", itemId);
1540         stmt = __query_prepare(daci_handler, query, strlen(query));
1541         if (stmt == NULL) {
1542                 _DEBUG_ERROR("stmt is null");
1543                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1544         }
1545
1546         if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
1547                 service_id = _stmt_column_text(stmt, 0);
1548         _DEBUG_INFO("[da_delete_item_by_Item_id] service_id = %s", service_id);
1549         __stmt_finalize(daci_handler, stmt);
1550         SYNC_AGENT_DA_MEMORY_SET(query);
1551
1552         snprintf(query, sizeof(query), "delete from item_tbl where parent_service_id = %s", service_id);
1553         stmt = __query_prepare(daci_handler, query, strlen(query));
1554         if (stmt == NULL) {
1555                 _DEBUG_ERROR("stmt is null");
1556                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1557         }
1558
1559         _DEBUG_INFO("[da_delete_item_by_Item_id] before __stmt_write_step()");
1560         ret = __stmt_write_step(daci_handler, stmt);
1561         __stmt_finalize(daci_handler, stmt);
1562         SYNC_AGENT_DA_MEMORY_SET(query);
1563
1564         snprintf(query, sizeof(query), "delete from item_tbl where item_id = %s", itemId);
1565         stmt = __query_prepare(daci_handler, query, strlen(query));
1566         if (stmt == NULL) {
1567                 _DEBUG_ERROR("stmt is null");
1568                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1569         }
1570
1571         ret = __stmt_write_step(daci_handler, stmt);
1572         __stmt_finalize(daci_handler, stmt);
1573
1574         _EXTERN_FUNC_EXIT;
1575         return ret;
1576 }
1577
1578 sync_agent_da_return_e da_delete_item_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
1579 {
1580         _EXTERN_FUNC_ENTER;
1581
1582         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1583
1584         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1585         daci_stmt stmt = 0;
1586         int i = 0;
1587         int count = 0;
1588         sync_agent_da_item_info_s *item_info = 0;
1589         char *query = "delete from item_tbl where account_id = ? and data_store_id = ?";
1590
1591         /* delete changelog */
1592         item_info = da_get_item_info_by_item_type_id(daci_handler, account_id, itemTypeId, &count);
1593         if (count != 0) {
1594                 for (i = 0; i < count; i++) {
1595                         ret = da_delete_item_changelog_by_item_id(daci_handler, account_id, item_info[i].itemId);
1596                         if (ret != SYNC_AGENT_DA_SUCCESS)
1597                                 goto DACI_FINISH;
1598                 }
1599         }
1600
1601         stmt = __query_prepare(daci_handler, query, strlen(query));
1602         if (stmt == NULL)
1603                 goto DACI_FINISH;
1604
1605         _stmt_bind_int(daci_handler, stmt, 1, account_id);
1606         _stmt_bind_int(daci_handler, stmt, 2, itemTypeId);
1607
1608         ret = __stmt_write_step(daci_handler, stmt);
1609         if (ret != SYNC_AGENT_DA_SUCCESS) {
1610                 goto DACI_FINISH;
1611         }
1612
1613         sync_agent_free_memory_item_info(item_info, count);
1614         _EXTERN_FUNC_EXIT;
1615         return __stmt_finalize(daci_handler, stmt);
1616
1617  DACI_FINISH:
1618         sync_agent_free_memory_item_info(item_info, count);
1619         if (stmt != NULL)
1620                 __stmt_finalize(daci_handler, stmt);
1621         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1622 }
1623
1624
1625 sync_agent_da_return_e da_delete_all_child_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *parent_service_id)
1626 {
1627         _EXTERN_FUNC_ENTER;
1628
1629         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1630
1631         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1632         daci_stmt stmt = 0;
1633         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1634
1635         snprintf(query, sizeof(query), "delete from item_tbl where parent_service_id = %s", parent_service_id);
1636         _DEBUG_INFO("query = %s", query);
1637
1638         stmt = __query_prepare(daci_handler, query, strlen(query));
1639         if (stmt == NULL) {
1640                 _DEBUG_ERROR("stmt is null");
1641                 ret = SYNC_AGENT_DA_ERRORS;
1642                 goto return_part;
1643         }
1644
1645         ret = __stmt_write_step(daci_handler, stmt);
1646         if (ret != SYNC_AGENT_DA_SUCCESS) {
1647                 _DEBUG_ERROR("__stmt_write_step failed");
1648                 goto return_part;
1649         }
1650         __stmt_finalize(daci_handler, stmt);
1651
1652  return_part:
1653         _EXTERN_FUNC_EXIT;
1654         return ret;
1655 }
1656
1657 sync_agent_da_return_e da_delete_child_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *parent_service_id, char *child_service_id)
1658 {
1659         _EXTERN_FUNC_ENTER;
1660
1661         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1662
1663         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1664         daci_stmt stmt = 0;
1665         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1666
1667         snprintf(query, sizeof(query), "delete from item_tbl where parent_service_id = %s and service_id = %s", parent_service_id, child_service_id);
1668         _DEBUG_INFO("query = %s", query);
1669
1670         stmt = __query_prepare(daci_handler, query, strlen(query));
1671         if (stmt == NULL) {
1672                 _DEBUG_ERROR("stmt is null");
1673                 ret = SYNC_AGENT_DA_ERRORS;
1674                 goto return_part;
1675         }
1676
1677         ret = __stmt_write_step(daci_handler, stmt);
1678         if (ret != SYNC_AGENT_DA_SUCCESS) {
1679                 _DEBUG_ERROR("__stmt_write_step failed");
1680                 goto return_part;
1681         }
1682         __stmt_finalize(daci_handler, stmt);
1683
1684  return_part:
1685         _EXTERN_FUNC_EXIT;
1686         return ret;
1687 }
1688
1689 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)
1690 {
1691         _EXTERN_FUNC_ENTER;
1692
1693         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1694
1695         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1696         daci_stmt stmt = 0;
1697
1698         char *query = "delete from item_tbl where account_id = ? and data_store_id = ?";
1699
1700         stmt = __query_prepare(daci_handler, query, strlen(query));
1701         if (stmt == NULL)
1702                 goto DACI_FINISH;
1703
1704         _stmt_bind_int(daci_handler, stmt, 1, account_id);
1705         _stmt_bind_int(daci_handler, stmt, 2, item_type_id);
1706
1707         ret = __stmt_write_step(daci_handler, stmt);
1708         if (ret != SYNC_AGENT_DA_SUCCESS) {
1709                 goto DACI_FINISH;
1710         }
1711
1712         _EXTERN_FUNC_EXIT;
1713
1714         return __stmt_finalize(daci_handler, stmt);
1715
1716  DACI_FINISH:
1717
1718         if (stmt != NULL)
1719                 __stmt_finalize(daci_handler, stmt);
1720
1721         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1722 }
1723
1724 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)
1725 {
1726         _EXTERN_FUNC_ENTER;
1727
1728         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1729
1730         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1731         int i = 0;
1732         int count = 0;
1733         sync_agent_da_item_info_s *item_info = 0;
1734
1735         /* delete changelog */
1736         item_info = da_get_item_info_by_item_type_id_and_operation_id(daci_handler, account_id, itemTypeId, 303, &count);
1737         if (count != 0) {
1738                 for (i = 0; i < count; i++) {
1739                         ret = da_delete_item_by_Item_id(daci_handler, item_info[i].itemId);
1740                         if (ret != SYNC_AGENT_DA_SUCCESS)
1741                                 goto DACI_FINISH;
1742
1743                         ret = da_delete_item_changelog_by_item_id(daci_handler, account_id, item_info[i].itemId);
1744                         if (ret != SYNC_AGENT_DA_SUCCESS)
1745                                 goto DACI_FINISH;
1746                 }
1747         }
1748
1749         sync_agent_free_memory_item_info(item_info, count);
1750
1751         _EXTERN_FUNC_EXIT;
1752
1753         return ret;
1754
1755  DACI_FINISH:
1756
1757         sync_agent_free_memory_item_info(item_info, count);
1758
1759         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
1760 }
1761
1762 char *da_get_item_item_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *serviceId, int itemTypeId)
1763 {
1764         _EXTERN_FUNC_ENTER;
1765
1766         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1767         retvm_if(serviceId == NULL, NULL, "service Id is NULL !!");
1768
1769         daci_stmt stmt = 0;
1770         char *query = "select item_id from item_tbl where account_id = ? and service_id = ? and data_store_id = ?";
1771         char *item_id = 0;
1772
1773         stmt = __query_prepare(daci_handler, query, strlen(query));
1774         if (stmt != NULL) {
1775                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
1776                 __stmt_bind_text(daci_handler, stmt, 2, serviceId);
1777                 _stmt_bind_int(daci_handler, stmt, 3, itemTypeId);
1778
1779                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
1780                         item_id = _stmt_column_text(stmt, 0);
1781
1782                 __stmt_finalize(daci_handler, stmt);
1783         }
1784         _EXTERN_FUNC_EXIT;
1785         return item_id;
1786 }
1787
1788 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)
1789 {
1790         _EXTERN_FUNC_ENTER;
1791
1792         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1793         retvm_if(service_id == NULL, SYNC_AGENT_DA_ERRORS, "service Id is NULL !!");
1794
1795         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
1796         daci_stmt stmt = 0;
1797         char *query = "select item_id from item_tbl where account_id = ? and service_id = ? and data_store_id = ?";
1798
1799         stmt = __query_prepare(daci_handler, query, strlen(query));
1800         if (stmt != NULL) {
1801                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
1802                 __stmt_bind_text(daci_handler, stmt, 2, service_id);
1803                 _stmt_bind_int(daci_handler, stmt, 3, item_type_id);
1804
1805                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1806                         *item_id = _stmt_column_text(stmt, 0);
1807                         ret = SYNC_AGENT_DA_SUCCESS;
1808                 }
1809
1810                 __stmt_finalize(daci_handler, stmt);
1811         }
1812
1813         _EXTERN_FUNC_EXIT;
1814
1815         return ret;
1816 }
1817
1818 char *da_get_item_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
1819 {
1820         _EXTERN_FUNC_ENTER;
1821
1822         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1823         retvm_if(itemId == NULL, NULL, "item Id is NULL !!");
1824
1825         daci_stmt stmt = 0;
1826         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1827         char *service_id = 0;
1828
1829         snprintf(query, sizeof(query), "select service_id from item_tbl where item_id = %s", itemId);
1830         //for test
1831         //_DEBUG_INFO("query = [%s]", query);
1832         stmt = __query_prepare(daci_handler, query, strlen(query));
1833         if (stmt != NULL) {
1834                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
1835                         service_id = _stmt_column_text(stmt, 0);
1836
1837                 __stmt_finalize(daci_handler, stmt);
1838         }
1839
1840         _EXTERN_FUNC_EXIT;
1841         return service_id;
1842 }
1843
1844 sync_agent_da_item_s *da_get_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
1845 {
1846         _EXTERN_FUNC_ENTER;
1847
1848         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1849         retvm_if(itemId == NULL, NULL, "item Id is NULL !!");
1850
1851         daci_stmt stmt = 0;
1852         char *query = "select  * from item_tbl where item_id = ?";
1853         sync_agent_da_item_s *item = 0;
1854
1855         stmt = __query_prepare(daci_handler, query, strlen(query));
1856         if (stmt != NULL) {
1857                 __stmt_bind_text(daci_handler, stmt, 1, itemId);
1858
1859                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1860                         item = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_s *, sizeof(sync_agent_da_item_s), 1);
1861                         if (item == NULL) {
1862                                 __stmt_finalize(daci_handler, stmt);
1863
1864                                 _DEBUG_ERROR("memory_allocation failed");
1865                                 return item;
1866                         }
1867
1868                         item->item_id = _stmt_column_text(stmt, 0);
1869                         item->data_store_id = __stmt_column_int(stmt, 1);
1870                         item->account_id = __stmt_column_int(stmt, 2);
1871                         item->folder_id = _stmt_column_text(stmt, 3);
1872                         item->service_id = _stmt_column_text(stmt, 4);
1873                         item->parent_service_id = _stmt_column_text(stmt, 5);
1874                         item->access_name = _stmt_column_text(stmt, 7);
1875                 }
1876                 __stmt_finalize(daci_handler, stmt);
1877         }
1878
1879         _EXTERN_FUNC_EXIT;
1880
1881         return item;
1882 }
1883
1884 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)
1885 {
1886         _EXTERN_FUNC_ENTER;
1887
1888         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1889         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
1890
1891         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1892         daci_stmt stmt = 0;
1893         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1894
1895         snprintf(query, sizeof(query), "select  * from item_tbl where item_id = %s", item_id);
1896         //for test
1897         //_DEBUG_INFO("query = [%s]", query);
1898
1899         stmt = __query_prepare(daci_handler, query, strlen(query));
1900         if (stmt != NULL) {
1901                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1902                         (*sync_agent_item)->item_id = _stmt_column_text(stmt, 0);
1903                         (*sync_agent_item)->data_store_id = __stmt_column_int(stmt, 1);
1904                         (*sync_agent_item)->account_id = __stmt_column_int(stmt, 2);
1905                         (*sync_agent_item)->folder_id = _stmt_column_text(stmt, 3);
1906                         (*sync_agent_item)->service_id = _stmt_column_text(stmt, 4);
1907                         (*sync_agent_item)->parent_service_id = _stmt_column_text(stmt, 5);
1908                         (*sync_agent_item)->access_name = _stmt_column_text(stmt, 7);
1909                 }
1910                 __stmt_finalize(daci_handler, stmt);
1911         }
1912
1913         _EXTERN_FUNC_EXIT;
1914         return ret;
1915 }
1916
1917 sync_agent_da_return_e da_get_item_data_store_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, char *item_id, sync_agent_da_item_s ** sync_agent_item)
1918 {
1919         _EXTERN_FUNC_ENTER;
1920
1921         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1922         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
1923
1924         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1925         daci_stmt stmt = 0;
1926         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1927
1928         snprintf(query, sizeof(query), "select  * from item_tbl where item_id = %s", item_id);
1929         //for test
1930         //_DEBUG_INFO("query = [%s]", query);
1931
1932         stmt = __query_prepare(daci_handler, query, strlen(query));
1933         if (stmt != NULL) {
1934                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1935                         (*sync_agent_item)->data_store_id = __stmt_column_int(stmt, 1);
1936                 }
1937                 __stmt_finalize(daci_handler, stmt);
1938         }
1939
1940         _EXTERN_FUNC_EXIT;
1941         return ret;
1942 }
1943
1944 sync_agent_da_return_e da_get_item_account_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, char *item_id, sync_agent_da_item_s ** sync_agent_item)
1945 {
1946         _EXTERN_FUNC_ENTER;
1947
1948         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
1949         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
1950
1951         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1952         daci_stmt stmt = 0;
1953         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0,};
1954
1955         snprintf(query, sizeof(query), "select  * from item_tbl where item_id = %s", item_id);
1956         //for test
1957         //_DEBUG_INFO("query = [%s]", query);
1958
1959         stmt = __query_prepare(daci_handler, query, strlen(query));
1960         if (stmt != NULL) {
1961                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
1962                         (*sync_agent_item)->account_id = __stmt_column_int(stmt, 2);
1963                 }
1964                 __stmt_finalize(daci_handler, stmt);
1965         }
1966
1967         _EXTERN_FUNC_EXIT;
1968         return ret;
1969 }
1970
1971 sync_agent_da_id_list_s *da_get_all_item_id(SYNC_AGENT_DA_HANDLER * daci_handler)
1972 {
1973         _EXTERN_FUNC_ENTER;
1974
1975         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
1976
1977         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
1978         sync_agent_da_id_list_s *id_list = 0;
1979         char **result = 0;
1980         int row_count = 0;
1981         int col_count = 0;
1982         int index = 1;
1983         int i = 0;
1984         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
1985
1986         snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl");
1987
1988         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
1989
1990         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
1991                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
1992                 if (id_list == NULL) {
1993                         _DEBUG_ERROR("memory_allocation failed");
1994                         goto DACI_FINISH;
1995                 }
1996
1997                 id_list->count = row_count;
1998                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
1999
2000                 for (i = 0; i < row_count; i++) {
2001                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
2002                         index++;
2003                 }
2004         }
2005
2006  DACI_FINISH:
2007
2008         if (result != NULL)
2009                 __free_table(result);
2010
2011         _EXTERN_FUNC_EXIT;
2012
2013         return id_list;
2014 }
2015
2016 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)
2017 {
2018         _EXTERN_FUNC_ENTER;
2019
2020         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2021         retvm_if(folderId == NULL, NULL, "folder Id is NULL !!");
2022
2023         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2024         sync_agent_da_id_list_s *id_list = 0;
2025         char *column_str = 0;
2026         char **result = 0;
2027         int row_count = 0;
2028         int col_count = 0;
2029         int index = 1;
2030         int i = 0;
2031         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2032
2033         column_str = _get_column_name(column_name);
2034
2035         snprintf(g_daci_query, sizeof(g_daci_query), "select %s from item_tbl where folder_id = \'%s\'", column_str, folderId);
2036
2037         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2038
2039         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2040                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
2041                 if (id_list == NULL) {
2042                         _DEBUG_ERROR("memory_allocation failed");
2043                         goto DACI_FINISH;
2044                 }
2045
2046                 id_list->count = row_count;
2047                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
2048
2049                 for (i = 0; i < row_count; i++) {
2050                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
2051                         index++;
2052                 }
2053         }
2054
2055  DACI_FINISH:
2056
2057         if (result != NULL)
2058                 __free_table(result);
2059
2060         _EXTERN_FUNC_EXIT;
2061
2062         return id_list;
2063 }
2064
2065 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)
2066 {
2067         _EXTERN_FUNC_ENTER;
2068
2069         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2070         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
2071
2072         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2073         char *item_id;
2074         char *column_str = 0;
2075         char **result = 0;
2076         int row_count = 0;
2077         int col_count = 0;
2078         int index = 1;
2079         int i = 0;
2080         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2081
2082         column_str = _get_column_name(column_name);
2083
2084         snprintf(g_daci_query, sizeof(g_daci_query), "select %s from item_tbl where folder_id = \'%s\'", column_str, folder_id);
2085
2086         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2087
2088         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2089                 for (i = 0; i < row_count; i++) {
2090                         item_id = NULL;
2091                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2092                         index++;
2093
2094                         *list = g_list_append(*list, item_id);
2095                 }
2096         }
2097
2098         if (result != NULL)
2099                 __free_table(result);
2100
2101         _EXTERN_FUNC_EXIT;
2102
2103         return ret;
2104 }
2105
2106 sync_agent_da_item_s *da_get_item_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId, int *count)
2107 {
2108         _EXTERN_FUNC_ENTER;
2109
2110         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2111
2112         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2113         sync_agent_da_item_s *item = 0;
2114         char **result = 0;
2115         char *new_table = 0;
2116         int row_count = 0;
2117         int col_count = 0;
2118         int index = 7;
2119         int i = 0;
2120         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2121
2122         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2123         if (new_table == NULL)
2124                 return item;
2125
2126         snprintf(g_daci_query, sizeof(g_daci_query),
2127                  "select item.item_id, item.data_store_id, item.account_id, item.folder_id, item.service_id, item.parent_service_id, item.access_name " "from item_tbl as item " "left join %s as changelog " "using (item_id) "
2128                  "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);
2129         _DEBUG_INFO("g_daci_query = %s", g_daci_query);
2130
2131         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2132         *count = row_count;
2133
2134         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2135                 item = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_s *, sizeof(sync_agent_da_item_s), row_count);
2136                 if (item == NULL) {
2137                         _DEBUG_ERROR("memory_allocation failed");
2138                         goto DACI_FINISH;
2139                 }
2140
2141                 for (i = 0; i < row_count; i++) {
2142                         item[i].item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2143                         index++;
2144                         item[i].data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
2145                         index++;
2146                         item[i].account_id = SYNC_AGENT_DA_ATOI(result[index]);
2147                         index++;
2148                         item[i].folder_id = SYNC_AGENT_DA_STRDUP(result[index]);
2149                         index++;
2150                         item[i].service_id = SYNC_AGENT_DA_STRDUP(result[index]);
2151                         index++;
2152                         item[i].parent_service_id = SYNC_AGENT_DA_STRDUP(result[index]);
2153                         index++;
2154                         item[i].access_name = SYNC_AGENT_DA_STRDUP(result[index]);
2155                         index++;
2156                 }
2157         }
2158
2159  DACI_FINISH:
2160         if (result != NULL)
2161                 __free_table(result);
2162
2163         /* memory free */
2164         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2165
2166         _EXTERN_FUNC_EXIT;
2167
2168         return item;
2169 }
2170
2171 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)
2172 {
2173         _EXTERN_FUNC_ENTER;
2174
2175         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2176
2177         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2178         sync_agent_da_item_s *item;
2179         char **result = 0;
2180         char *new_table = 0;
2181         int row_count = 0;
2182         int col_count = 0;
2183         int index = 7;
2184         int i = 0;
2185         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2186
2187         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2188         if (new_table == NULL)
2189                 return ret;
2190
2191 //      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);
2192         snprintf(g_daci_query, sizeof(g_daci_query),
2193                  "select item.item_id, item.data_store_id, item.account_id, item.folder_id, item.service_id, item.parent_service_id, item.access_name " "from item_tbl as item " "left join %s as changelog " "using (item_id) "
2194                  "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);
2195         _DEBUG_INFO("g_daci_query = %s", g_daci_query);
2196
2197         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2198
2199         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2200                 for (i = 0; i < row_count; i++) {
2201                         item = NULL;
2202                         ret = sync_agent_create_item(&item);
2203                         if (ret != SYNC_AGENT_DA_SUCCESS) {
2204                                 _DEBUG_ERROR("sync_agent_create_item() failed !!");
2205                                 goto DACI_FINISH;
2206                         }
2207
2208                         item->item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2209                         index++;
2210                         item->data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
2211                         index++;
2212                         item->account_id = SYNC_AGENT_DA_ATOI(result[index]);
2213                         index++;
2214                         item->folder_id = SYNC_AGENT_DA_STRDUP(result[index]);
2215                         index++;
2216                         item->service_id = SYNC_AGENT_DA_STRDUP(result[index]);
2217                         index++;
2218                         item->parent_service_id = SYNC_AGENT_DA_STRDUP(result[index]);
2219                         index++;
2220                         item->access_name = SYNC_AGENT_DA_STRDUP(result[index]);
2221                         index++;
2222
2223                         *list = g_list_append(*list, item);
2224                 }
2225         }
2226
2227  DACI_FINISH:
2228         if (result != NULL)
2229                 __free_table(result);
2230
2231         /* memory free */
2232         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2233
2234         _EXTERN_FUNC_EXIT;
2235
2236         return ret;
2237 }
2238
2239 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)
2240 {
2241         _EXTERN_FUNC_ENTER;
2242
2243         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2244
2245         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2246         sync_agent_da_item_info_s *itemInfo = 0;
2247         char *new_table = 0;
2248         char **result = 0;
2249         int row_count = 0;
2250         int col_count = 0;
2251         int i = 0;
2252         int index = 5;
2253         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2254
2255         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2256         if (new_table == NULL)
2257                 return itemInfo;
2258         snprintf(g_daci_query, sizeof(g_daci_query),
2259                  "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,
2260                  account_id, itemTypeId);
2261
2262         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2263         *count = row_count;
2264         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2265                 itemInfo = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_info_s *, sizeof(sync_agent_da_item_info_s), row_count);
2266                 if (itemInfo == NULL) {
2267                         _DEBUG_ERROR("memory_allocation failed");
2268                         goto DACI_FINISH;
2269                 }
2270                 for (i = 0; i < row_count; i++) {
2271                         itemInfo[i].itemId = SYNC_AGENT_DA_STRDUP(result[index]);
2272                         index++;
2273                         itemInfo[i].itemTypeId = SYNC_AGENT_DA_ATOI(result[index]);
2274                         index++;
2275                         itemInfo[i].serviceId = SYNC_AGENT_DA_STRDUP(result[index]);
2276                         index++;
2277                         itemInfo[i].operationId = SYNC_AGENT_DA_ATOI(result[index]);
2278                         index++;
2279                         itemInfo[i].syncStatus = SYNC_AGENT_DA_STRDUP(result[index]);
2280                         index++;
2281                 }
2282         }
2283
2284  DACI_FINISH:
2285
2286         if (result != NULL)
2287                 __free_table(result);
2288
2289         /* memory free */
2290         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2291
2292         _EXTERN_FUNC_EXIT;
2293
2294         return itemInfo;
2295 }
2296
2297 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)
2298 {
2299         _EXTERN_FUNC_ENTER;
2300
2301         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2302
2303         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2304         sync_agent_da_item_info_s *itemInfo = 0;
2305         char *new_table = 0;
2306         char **result = 0;
2307         int row_count = 0;
2308         int col_count = 0;
2309         int i = 0;
2310         int index = 5;
2311         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2312
2313         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2314         if (new_table == NULL)
2315                 return itemInfo;
2316         snprintf(g_daci_query, sizeof(g_daci_query),
2317                  "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) "
2318                  "where item.account_id = %d and item.data_store_id = %d and changelog.operation_id = %d", new_table, account_id, itemTypeId, operationId);
2319
2320         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2321         *count = row_count;
2322         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2323                 itemInfo = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_info_s *, sizeof(sync_agent_da_item_info_s), row_count);
2324                 if (itemInfo == NULL) {
2325                         _DEBUG_ERROR("memory_allocation failed");
2326                         goto DACI_FINISH;
2327                 }
2328                 for (i = 0; i < row_count; i++) {
2329                         itemInfo[i].itemId = SYNC_AGENT_DA_STRDUP(result[index]);
2330                         index++;
2331                         itemInfo[i].itemTypeId = SYNC_AGENT_DA_ATOI(result[index]);
2332                         index++;
2333                         itemInfo[i].serviceId = SYNC_AGENT_DA_STRDUP(result[index]);
2334                         index++;
2335                         itemInfo[i].operationId = SYNC_AGENT_DA_ATOI(result[index]);
2336                         index++;
2337                         itemInfo[i].syncStatus = SYNC_AGENT_DA_STRDUP(result[index]);
2338                         index++;
2339                 }
2340         }
2341
2342  DACI_FINISH:
2343
2344         if (result != NULL)
2345                 __free_table(result);
2346
2347         /* memory free */
2348         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2349
2350         _EXTERN_FUNC_EXIT;
2351
2352         return itemInfo;
2353 }
2354
2355 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)
2356 {
2357         _EXTERN_FUNC_ENTER;
2358
2359         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2360
2361         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2362         char *new_table = 0;
2363         char **result = 0;
2364         int row_count = 0;
2365         int col_count = 0;
2366         int i = 0;
2367         int index = 1;
2368         char *item_id = NULL;
2369         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2370
2371         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2372         if (new_table == NULL) {
2373                 _DEBUG_ERROR("__replace_table_name() failed !!");
2374                 return SYNC_AGENT_DA_ERRORS;
2375         }
2376
2377         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,
2378                  item_type_id, operation_id);
2379
2380         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
2381         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2382                 for (i = 0; i < row_count; i++) {
2383                         item_id = NULL;
2384                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2385                         index++;
2386
2387                         *list = g_list_append(*list, item_id);
2388                 }
2389         } else {
2390                 _DEBUG_INFO("no data !!");
2391         }
2392
2393         if (result != NULL)
2394                 __free_table(result);
2395
2396         /* memory free */
2397         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2398
2399         _EXTERN_FUNC_EXIT;
2400
2401         return ret;
2402 }
2403
2404 sync_agent_da_item_s *da_get_item_mapping_service_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *itemId, int *count)
2405 {
2406         _EXTERN_FUNC_ENTER;
2407
2408         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2409         retvm_if(itemId == NULL, NULL, "item Id is NULL !!");
2410
2411         daci_stmt stmt = 0;
2412         sync_agent_da_item_s *item = 0;
2413         int data_count = 0;
2414         int i = 0;
2415         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2416
2417         snprintf(g_daci_query, sizeof(g_daci_query),
2418                  "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\') "
2419                  "and (account_id != %d and item_id != \'%s\')", account_id, itemId, account_id, itemId, account_id, itemId);
2420
2421         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2422         *count = data_count;
2423
2424         if (data_count != 0) {
2425                 /* query initialize */
2426                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2427
2428                 item = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_s *, sizeof(sync_agent_da_item_s), data_count);
2429                 if (item == NULL) {
2430                         _DEBUG_ERROR("memory_allocation failed");
2431                         return item;
2432                 }
2433
2434                 snprintf(g_daci_query, sizeof(g_daci_query),
2435                          "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\') "
2436                          "and (account_id != %d and item_id != \'%s\')", account_id, itemId, account_id, itemId, account_id, itemId);
2437
2438                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2439                 if (stmt != NULL) {
2440                         for (i = 0; i < data_count; i++) {
2441                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
2442                                         break;
2443
2444                                 item[i].item_id = _stmt_column_text(stmt, 0);
2445                                 item[i].data_store_id = __stmt_column_int(stmt, 1);
2446                                 item[i].account_id = __stmt_column_int(stmt, 2);
2447                                 item[i].folder_id = _stmt_column_text(stmt, 3);
2448                                 item[i].service_id = _stmt_column_text(stmt, 4);
2449                                 item[i].access_name = _stmt_column_text(stmt, 6);
2450                         }
2451
2452                         __stmt_finalize(daci_handler, stmt);
2453                 }
2454         }
2455
2456         _EXTERN_FUNC_EXIT;
2457
2458         return item;
2459 }
2460
2461 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)
2462 {
2463         _EXTERN_FUNC_ENTER;
2464
2465         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2466         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
2467
2468         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2469         daci_stmt stmt = 0;
2470         sync_agent_da_item_s *item;
2471         int data_count = 0;
2472         int i = 0;
2473         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2474
2475         snprintf(g_daci_query, sizeof(g_daci_query),
2476                  "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\') "
2477                  "and (account_id != %d and item_id != \'%s\')", account_id, item_id, account_id, item_id, account_id, item_id);
2478
2479         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2480
2481         if (data_count != 0) {
2482                 /* query initialize */
2483                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2484
2485                 snprintf(g_daci_query, sizeof(g_daci_query),
2486                          "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\') "
2487                          "and (account_id != %d and item_id != \'%s\')", account_id, item_id, account_id, item_id, account_id, item_id);
2488
2489                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2490                 if (stmt != NULL) {
2491                         for (i = 0; i < data_count; i++) {
2492                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
2493                                         break;
2494
2495                                 item = NULL;
2496                                 ret = sync_agent_create_item(&item);
2497                                 if (ret != SYNC_AGENT_DA_SUCCESS) {
2498                                         _DEBUG_ERROR("sync_agent_create_item() failed !!");
2499                                         return ret;
2500                                 }
2501
2502                                 item->item_id = _stmt_column_text(stmt, 0);
2503                                 item->data_store_id = __stmt_column_int(stmt, 1);
2504                                 item->account_id = __stmt_column_int(stmt, 2);
2505                                 item->folder_id = _stmt_column_text(stmt, 3);
2506                                 item->service_id = _stmt_column_text(stmt, 4);
2507                                 item->access_name = _stmt_column_text(stmt, 6);
2508
2509                                 *list = g_list_append(*list, item);
2510                         }
2511
2512                         __stmt_finalize(daci_handler, stmt);
2513                 }
2514         } else {
2515                 _DEBUG_ERROR("no data !!");
2516                 ret = SYNC_AGENT_DA_SUCCESS;
2517         }
2518
2519         _EXTERN_FUNC_EXIT;
2520
2521         return ret;
2522 }
2523
2524 sync_agent_da_id_list_s *da_get_item_id_list_by_datastore_id(SYNC_AGENT_DA_HANDLER * daci_handler, int data_store_id)
2525 {
2526         _EXTERN_FUNC_ENTER;
2527
2528         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2529
2530         daci_stmt stmt = 0;
2531         sync_agent_da_id_list_s *item_id_list = 0;
2532         int data_count = 0;
2533         int i = 0;
2534         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2535
2536         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where data_store_id = %d", data_store_id);
2537
2538         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2539
2540         if (data_count != 0) {
2541                 /* query initialize */
2542                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2543
2544                 item_id_list = (sync_agent_da_id_list_s *) calloc(1, sizeof(sync_agent_da_id_list_s));
2545                 if (item_id_list == NULL) {
2546                         _DEBUG_ERROR("CALLOC failed !!!");
2547                         return NULL;
2548                 }
2549                 item_id_list->id = (char **)calloc(data_count, sizeof(char *));
2550                 if (item_id_list->id == NULL) {
2551
2552                         if (item_id_list != NULL)
2553                                 free(item_id_list);
2554
2555                         _DEBUG_ERROR("CALLOC failed !!!");
2556                         return NULL;
2557                 }
2558                 item_id_list->count = data_count;
2559
2560                 snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl where data_store_id = %d", data_store_id);
2561
2562                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2563                 if (stmt != NULL) {
2564                         for (i = 0; i < data_count; i++) {
2565                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2566                                         break;
2567                                 }
2568
2569                                 item_id_list->id[i] = _stmt_column_text(stmt, 0);
2570                         }
2571
2572                         __stmt_finalize(daci_handler, stmt);
2573                 }
2574         }
2575
2576         _EXTERN_FUNC_EXIT;
2577
2578         return item_id_list;
2579 }
2580
2581 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)
2582 {
2583         _EXTERN_FUNC_ENTER;
2584
2585         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2586
2587         daci_stmt stmt = 0;
2588         char *item_id;
2589         int data_count = 0;
2590         int i = 0;
2591         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2592
2593         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where data_store_id = %d", data_store_id);
2594
2595         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2596
2597         if (data_count != 0) {
2598                 /* query initialize */
2599                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2600
2601                 snprintf(g_daci_query, sizeof(g_daci_query), "select item_id from item_tbl where data_store_id = %d", data_store_id);
2602
2603                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2604                 if (stmt != NULL) {
2605                         for (i = 0; i < data_count; i++) {
2606                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2607                                         break;
2608                                 }
2609
2610                                 item_id = NULL;
2611                                 item_id = _stmt_column_text(stmt, 0);
2612
2613                                 *list = g_list_append(*list, item_id);
2614                         }
2615
2616                         __stmt_finalize(daci_handler, stmt);
2617                 }
2618         }
2619
2620         _EXTERN_FUNC_EXIT;
2621
2622         return SYNC_AGENT_DA_SUCCESS;
2623 }
2624
2625 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)
2626 {
2627         _EXTERN_FUNC_ENTER;
2628
2629         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2630
2631         daci_stmt stmt = 0;
2632         sync_agent_da_id_list_s *item_id_list = 0;
2633         int data_count = 0;
2634         int i = 0;
2635         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2636
2637         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);
2638
2639         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2640
2641         if (data_count != 0) {
2642                 /* query initialize */
2643                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2644
2645                 item_id_list = (sync_agent_da_id_list_s *) calloc(1, sizeof(sync_agent_da_id_list_s));
2646                 if (item_id_list == NULL) {
2647                         _DEBUG_ERROR("CALLOC failed !!!");
2648                         return NULL;
2649                 }
2650                 item_id_list->id = (char **)calloc(data_count, sizeof(char *));
2651                 if (item_id_list->id == NULL) {
2652
2653                         if (item_id_list != NULL)
2654                                 free(item_id_list);
2655
2656                         _DEBUG_ERROR("CALLOC failed !!!");
2657                         return NULL;
2658                 }
2659                 item_id_list->count = data_count;
2660
2661                 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);
2662
2663                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2664                 if (stmt != NULL) {
2665                         for (i = 0; i < data_count; i++) {
2666                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2667                                         break;
2668                                 }
2669
2670                                 item_id_list->id[i] = _stmt_column_text(stmt, 0);
2671                         }
2672
2673                         __stmt_finalize(daci_handler, stmt);
2674                 }
2675         }
2676
2677         _EXTERN_FUNC_EXIT;
2678
2679         return item_id_list;
2680 }
2681
2682 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)
2683 {
2684         _EXTERN_FUNC_ENTER;
2685
2686         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2687
2688         daci_stmt stmt = 0;
2689         char *item_id;
2690         int data_count = 0;
2691         int i = 0;
2692         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2693
2694         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);
2695
2696         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2697
2698         if (data_count != 0) {
2699                 /* query initialize */
2700                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
2701
2702                 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);
2703
2704                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
2705                 if (stmt != NULL) {
2706                         for (i = 0; i < data_count; i++) {
2707                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA) {
2708                                         break;
2709                                 }
2710
2711                                 item_id = NULL;
2712                                 item_id = _stmt_column_text(stmt, 0);
2713
2714                                 *list = g_list_append(*list, item_id);
2715                         }
2716
2717                         __stmt_finalize(daci_handler, stmt);
2718                 }
2719         }
2720
2721         _EXTERN_FUNC_EXIT;
2722
2723         return SYNC_AGENT_DA_SUCCESS;
2724 }
2725
2726 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)
2727 {
2728         _EXTERN_FUNC_ENTER;
2729
2730         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2731
2732         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2733         sync_agent_da_id_list_s *id_list = 0;
2734         char *new_table = 0;
2735         char **result = 0;
2736         int row_count = 0;
2737         int col_count = 0;
2738         int index = 1;
2739         int i = 0;
2740         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2741
2742         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2743         if (new_table == NULL)
2744                 return id_list;
2745
2746         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,
2747                  data_store_id, operation_id);
2748
2749         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2750         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2751                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
2752
2753                 if (id_list == NULL) {
2754                         _DEBUG_ERROR("memory_allocation failed");
2755                         goto DACI_FINISH;
2756                 }
2757
2758                 id_list->count = row_count;
2759                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
2760
2761                 for (i = 0; i < row_count; i++) {
2762                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
2763                         index++;
2764                 }
2765         }
2766
2767  DACI_FINISH:
2768         if (result != NULL) {
2769                 __free_table(result);
2770         }
2771         /* memory free */
2772         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2773
2774         _EXTERN_FUNC_EXIT;
2775
2776         return id_list;
2777 }
2778
2779 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)
2780 {
2781         _EXTERN_FUNC_ENTER;
2782
2783         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2784
2785         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2786         char *item_id;
2787         char *new_table = 0;
2788         char **result = 0;
2789         int row_count = 0;
2790         int col_count = 0;
2791         int index = 1;
2792         int i = 0;
2793         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2794
2795         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2796         if (new_table == NULL)
2797                 return ret;
2798
2799         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,
2800                  data_store_id, operation_id);
2801
2802         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2803         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2804                 for (i = 0; i < row_count; i++) {
2805                         item_id = NULL;
2806                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2807                         index++;
2808
2809                         *list = g_list_append(*list, item_id);
2810                 }
2811         }
2812
2813         if (result != NULL) {
2814                 __free_table(result);
2815         }
2816
2817         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2818         _EXTERN_FUNC_EXIT;
2819         return ret;
2820 }
2821
2822 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)
2823 {
2824         _EXTERN_FUNC_ENTER;
2825
2826         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
2827         retvm_if(folder_id == NULL, NULL, "folder id is NULL !!");
2828
2829         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
2830         sync_agent_da_id_list_s *id_list = 0;
2831         char *new_table = 0;
2832         char **result = 0;
2833         int row_count = 0;
2834         int col_count = 0;
2835         int index = 1;
2836         int i = 0;
2837         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2838
2839         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2840         if (new_table == NULL)
2841                 return id_list;
2842
2843         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",
2844                  new_table, account_id, data_store_id, folder_id, operation_id);
2845         _DEBUG_INFO("request quary is [%s]\n", query);
2846
2847         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2848         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2849                 id_list = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_id_list_s *, sizeof(sync_agent_da_id_list_s), 1);
2850
2851                 if (id_list == NULL) {
2852                         _DEBUG_ERROR("memory_allocation failed");
2853                         goto DACI_FINISH;
2854                 }
2855
2856                 id_list->count = row_count;
2857                 id_list->id = SYNC_AGENT_DA_MEMORY_CALLOC(char **, sizeof(char *), row_count);
2858
2859                 for (i = 0; i < row_count; i++) {
2860                         id_list->id[i] = SYNC_AGENT_DA_STRDUP(result[index]);
2861                         index++;
2862                 }
2863         }
2864
2865  DACI_FINISH:
2866         if (result != NULL) {
2867                 __free_table(result);
2868         }
2869         /* memory free */
2870         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2871
2872         _EXTERN_FUNC_EXIT;
2873
2874         return id_list;
2875 }
2876
2877 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)
2878 {
2879         _EXTERN_FUNC_ENTER;
2880
2881         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2882         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
2883
2884         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2885         char *item_id;
2886         char *new_table = 0;
2887         char **result = 0;
2888         int row_count = 0;
2889         int col_count = 0;
2890         int index = 1;
2891         int i = 0;
2892         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2893
2894         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2895         if (new_table == NULL)
2896                 return ret;
2897
2898         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",
2899                  new_table, account_id, data_store_id, folder_id, operation_id);
2900         _DEBUG_INFO("request quary is [%s]\n", query);
2901
2902         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2903         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2904                 for (i = 0; i < row_count; i++) {
2905                         item_id = NULL;
2906                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2907                         index++;
2908
2909                         *list = g_list_append(*list, item_id);
2910                 }
2911         }
2912
2913         if (result != NULL) {
2914                 __free_table(result);
2915         }
2916         /* memory free */
2917         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2918
2919         _EXTERN_FUNC_EXIT;
2920
2921         return ret;
2922 }
2923
2924 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)
2925 {
2926         _EXTERN_FUNC_ENTER;
2927
2928         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
2929         retvm_if(folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
2930
2931         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
2932         char *item_id;
2933         char *new_table = 0;
2934         char **result = 0;
2935         int row_count = 0;
2936         int col_count = 0;
2937         int index = 1;
2938         int i = 0;
2939         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2940
2941         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
2942         if (new_table == NULL)
2943                 return ret;
2944
2945         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);
2946         _DEBUG_INFO("request quary is [%s]\n", query);
2947
2948         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
2949         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
2950                 for (i = 0; i < row_count; i++) {
2951                         item_id = NULL;
2952                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
2953                         index++;
2954                         *list = g_list_append(*list, item_id);
2955                 }
2956         }
2957
2958         if (result != NULL) {
2959                 __free_table(result);
2960         }
2961
2962         SYNC_AGENT_DA_MEMORY_FREE(new_table);
2963         _EXTERN_FUNC_EXIT;
2964         return ret;
2965 }
2966
2967 int da_is_exist_item(SYNC_AGENT_DA_HANDLER * daci_handler, char *itemId)
2968 {
2969         _EXTERN_FUNC_ENTER;
2970
2971         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
2972         retvm_if(itemId == NULL, 0, "item Id is NULL !!");
2973
2974         int ret = 1;
2975         int data_count = 0;
2976         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
2977
2978         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from item_tbl where item_id = \'%s\'", itemId);
2979
2980         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
2981
2982         if (data_count == 0) {
2983                 ret = 0;
2984         } else {
2985                 _DEBUG_ERROR("itemId [%s] already exist number of [%d]", itemId, data_count);
2986         }
2987
2988         _EXTERN_FUNC_EXIT;
2989
2990         return ret;
2991 }
2992
2993 sync_agent_da_return_e da_add_config(SYNC_AGENT_DA_HANDLER * daci_handler, 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(config == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_config_s is NULL !!");
2999
3000         daci_stmt stmt = 0;
3001         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3002         char *query = "insert into config_tbl (config_id, key, value, type, access_name) values (?, ?, ?, ?, ?)";
3003
3004         int exist = 0;
3005         ret = da_is_exist_config(daci_handler, config->config_id, config->key, &exist);
3006         if (ret != SYNC_AGENT_DA_SUCCESS) {
3007                 _DEBUG_ERROR("da_is_exist_config is failed");
3008                 return ret;
3009         }
3010
3011         if (exist == 1)
3012                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3013
3014         stmt = __query_prepare(daci_handler, query, strlen(query));
3015         if (stmt == NULL)
3016                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3017
3018         _stmt_bind_int(daci_handler, stmt, 1, config->config_id);
3019         __stmt_bind_text(daci_handler, stmt, 2, config->key);
3020         __stmt_bind_text(daci_handler, stmt, 3, config->value);
3021         __stmt_bind_text(daci_handler, stmt, 4, config->type);
3022         __stmt_bind_text(daci_handler, stmt, 5, config->access_name);
3023
3024         ret = __stmt_write_step(daci_handler, stmt);
3025         __stmt_finalize(daci_handler, stmt);
3026
3027         _EXTERN_FUNC_EXIT;
3028
3029         return ret;
3030 }
3031
3032 sync_agent_da_return_e da_add_config_list(SYNC_AGENT_DA_HANDLER * daci_handler, GList * config_list)
3033 {
3034         _EXTERN_FUNC_ENTER;
3035
3036         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3037         retvm_if(config_list == NULL, SYNC_AGENT_DA_ERRORS, "config_list is NULL !!");
3038
3039         daci_stmt stmt = 0;
3040         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3041
3042         GList *iter = NULL;
3043         sync_agent_da_config_s *config = NULL;
3044
3045         char *query = "insert into config_tbl (config_id, key, value, type, access_name) values (?, ?, ?, ?, ?)";
3046
3047         int exist = 0;
3048         for (iter = config_list; iter != NULL; iter = g_list_next(iter)) {
3049                 config = (sync_agent_da_config_s *) iter->data;
3050                 ret = da_is_exist_config(daci_handler, config->config_id, config->key, &exist);
3051                 if (ret != SYNC_AGENT_DA_SUCCESS) {
3052                         _DEBUG_ERROR("da_is_exist_config is failed");
3053                         return ret;
3054                 }
3055
3056                 if (exist == 1)
3057                         return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3058         }
3059
3060         stmt = __query_prepare(daci_handler, query, strlen(query));
3061         if (stmt == NULL)
3062                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3063
3064         for (iter = config_list; iter != NULL; iter = g_list_next(iter)) {
3065                 config = (sync_agent_da_config_s *) iter->data;
3066
3067                 _stmt_bind_int(daci_handler, stmt, 1, config->config_id);
3068                 __stmt_bind_text(daci_handler, stmt, 2, config->key);
3069                 __stmt_bind_text(daci_handler, stmt, 3, config->value);
3070                 __stmt_bind_text(daci_handler, stmt, 4, config->type);
3071                 __stmt_bind_text(daci_handler, stmt, 5, config->access_name);
3072
3073                 ret = __stmt_write_step(daci_handler, stmt);
3074                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
3075                         __stmt_finalize(daci_handler, stmt);
3076                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3077                 }
3078                 _stmt_reset(daci_handler, stmt);
3079         }
3080         __stmt_finalize(daci_handler, stmt);
3081
3082         _EXTERN_FUNC_EXIT;
3083
3084         return ret;
3085 }
3086
3087 sync_agent_da_return_e da_delete_config_by_key(SYNC_AGENT_DA_HANDLER * daci_handler, int configId, char *key)
3088 {
3089         _EXTERN_FUNC_ENTER;
3090
3091         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3092         retvm_if(key == NULL, SYNC_AGENT_DA_ERRORS, "key is NULL !!");
3093
3094         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3095         daci_stmt stmt = 0;
3096         char *query = "delete from config_tbl where config_id = ? and key = ?";
3097
3098         stmt = __query_prepare(daci_handler, query, strlen(query));
3099         if (stmt == NULL)
3100                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3101
3102         _stmt_bind_int(daci_handler, stmt, 1, configId);
3103         __stmt_bind_text(daci_handler, stmt, 2, key);
3104
3105         ret = __stmt_write_step(daci_handler, stmt);
3106         __stmt_finalize(daci_handler, stmt);
3107
3108         _EXTERN_FUNC_EXIT;
3109
3110         return ret;
3111 }
3112
3113 sync_agent_da_return_e da_get_config_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, GList ** list)
3114 {
3115         _EXTERN_FUNC_ENTER;
3116
3117         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3118
3119         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3120         daci_stmt stmt = 0;
3121         sync_agent_da_config_s *config = 0;
3122         int data_Count = 0;
3123         int i = 0;
3124         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3125         GList *config_list = NULL;
3126
3127         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from config_tbl where config_id = %d", account_id);
3128
3129         data_Count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3130
3131         if (data_Count != 0) {
3132                 /* query initialize */
3133                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
3134
3135                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from config_tbl where config_id = %d", account_id);
3136
3137                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3138                 if (stmt != NULL) {
3139                         for (i = 0; i < data_Count; i++) {
3140                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
3141                                         break;
3142
3143                                 config = (sync_agent_da_config_s *) calloc(1, sizeof(sync_agent_da_config_s));
3144                                 if (config == NULL) {
3145                                         _DEBUG_ERROR("memory_allocation failed");
3146                                         ret = SYNC_AGENT_DA_ERR_MEMORY_FULL;
3147                                         return ret;
3148                                 }
3149
3150                                 config->config_id = __stmt_column_int(stmt, 0);
3151                                 config->key = _stmt_column_text(stmt, 1);
3152                                 config->value = _stmt_column_text(stmt, 2);
3153                                 config->type = _stmt_column_text(stmt, 3);
3154                                 config->access_name = _stmt_column_text(stmt, 5);
3155
3156                                 config_list = g_list_append(config_list, config);
3157                         }
3158                         __stmt_finalize(daci_handler, stmt);
3159                 }
3160         }
3161
3162         *list = config_list;
3163
3164         _EXTERN_FUNC_EXIT;
3165
3166         return ret;
3167 }
3168
3169 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)
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(key == NULL, SYNC_AGENT_DA_ERRORS, "key is NULL !!");
3175
3176         int ret = SYNC_AGENT_DA_SUCCESS;
3177         daci_stmt stmt = 0;
3178         char *query = "select key, value, type, access_name from config_tbl where config_id = ? and key =?";
3179
3180         stmt = __query_prepare(daci_handler, query, strlen(query));
3181         if (stmt == NULL) {
3182                 return SYNC_AGENT_DA_ERRORS;
3183         }
3184
3185         _stmt_bind_int(daci_handler, stmt, 1, config_id);
3186         __stmt_bind_text(daci_handler, stmt, 2, key);
3187
3188         if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
3189                 (*config)->config_id = config_id;
3190                 (*config)->key = _stmt_column_text(stmt, 0);
3191                 (*config)->value = _stmt_column_text(stmt, 1);
3192                 (*config)->type = _stmt_column_text(stmt, 2);
3193                 (*config)->access_name = _stmt_column_text(stmt, 3);
3194         } else {
3195                 ret = SYNC_AGENT_DA_ERR_NO_DATA;
3196         }
3197
3198         __stmt_finalize(daci_handler, stmt);
3199
3200         _EXTERN_FUNC_EXIT;
3201
3202         return ret;
3203 }
3204
3205 sync_agent_da_return_e da_is_exist_config(SYNC_AGENT_DA_HANDLER * daci_handler, int config_id, char *key, int *exist)
3206 {
3207         _EXTERN_FUNC_ENTER;
3208
3209         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3210         retvm_if(key == NULL, SYNC_AGENT_DA_ERRORS, "key is NULL !!");
3211
3212         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3213         int result = 1;
3214         int data_count = 0;
3215         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3216
3217         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from config_tbl where config_id = %d and key = \'%s\'", config_id, key);
3218
3219         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3220
3221         if (data_count == 0)
3222                 result = 0;
3223
3224         *exist = result;
3225
3226         _EXTERN_FUNC_EXIT;
3227
3228         return ret;
3229 }
3230
3231 sync_agent_da_return_e da_update_config(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_config_s * config)
3232 {
3233         _EXTERN_FUNC_ENTER;
3234
3235         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3236         retvm_if(config == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_config_s is NULL !!");
3237
3238         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3239         int exist = 0;
3240
3241         ret = da_is_exist_config(daci_handler, config->config_id, config->key, &exist);
3242         if (ret != SYNC_AGENT_DA_SUCCESS) {
3243                 _DEBUG_ERROR("da_is_exist_config is failed");
3244                 return ret;
3245         }
3246
3247         if (exist == 1)
3248                 ret = da_set_config_value(daci_handler, config);
3249         else
3250                 ret = da_add_config(daci_handler, config);
3251
3252         if (ret != SYNC_AGENT_DA_SUCCESS)
3253                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3254
3255         _EXTERN_FUNC_EXIT;
3256
3257         return ret;
3258 }
3259
3260 sync_agent_da_return_e da_set_config_value(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_config_s * config)
3261 {
3262         _EXTERN_FUNC_ENTER;
3263
3264         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3265         retvm_if(config == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_config_s is NULL !!");
3266
3267         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3268
3269         daci_stmt stmt = 0;
3270         char *query = "update config_tbl set value = ?, type = ?, last_update = current_timestamp, access_name = ? " "where config_id = ? and key = ?";
3271
3272         stmt = __query_prepare(daci_handler, query, strlen(query));
3273         if (stmt == NULL)
3274                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3275
3276         __stmt_bind_text(daci_handler, stmt, 1, config->value);
3277         __stmt_bind_text(daci_handler, stmt, 2, config->type);
3278         __stmt_bind_text(daci_handler, stmt, 3, config->access_name);
3279         _stmt_bind_int(daci_handler, stmt, 4, config->config_id);
3280         __stmt_bind_text(daci_handler, stmt, 5, config->key);
3281
3282         ret = _stmt_read_step(daci_handler, stmt);
3283         __stmt_finalize(daci_handler, stmt);
3284
3285         _EXTERN_FUNC_EXIT;
3286
3287         return ret;
3288 }
3289
3290 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)
3291 {
3292         _EXTERN_FUNC_ENTER;
3293
3294         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3295         retvm_if(itemChangelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
3296
3297         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3298         daci_stmt stmt = 0;
3299         int i = 0;
3300         char *new_table = 0;
3301         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3302
3303         for (i = 0; i < count; i++) {
3304                 if (da_is_exist_item_changelog(daci_handler, account_id, itemChangelog[i].item_id) == 1)
3305                         return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3306         }
3307
3308         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3309         if (new_table == NULL)
3310                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3311
3312         snprintf(g_daci_query, sizeof(g_daci_query), "insert into %s (item_id, operation_id, status, access_name) values (?, ?, ?, ?)", new_table);
3313
3314         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3315         if (stmt == NULL) {
3316                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3317                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3318         }
3319
3320         for (i = 0; i < count; i++) {
3321                 __stmt_bind_text(daci_handler, stmt, 1, itemChangelog[i].item_id);
3322                 _stmt_bind_int(daci_handler, stmt, 2, itemChangelog[i].operation_id);
3323                 __stmt_bind_text(daci_handler, stmt, 3, ((itemChangelog[i].status == 0) ? "SYNC_REQUIRED" : itemChangelog[i].status));
3324                 __stmt_bind_text(daci_handler, stmt, 4, itemChangelog[i].access_name);
3325
3326                 ret = __stmt_write_step(daci_handler, stmt);
3327                 if ((ret != SYNC_AGENT_DA_ERR_MORE_DATA) && (ret != SYNC_AGENT_DA_SUCCESS)) {
3328                         __stmt_finalize(daci_handler, stmt);
3329                         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3330                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3331                 }
3332                 _stmt_reset(daci_handler, stmt);
3333         }
3334
3335         ret = __stmt_finalize(daci_handler, stmt);
3336
3337         /* memory free */
3338         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3339
3340         _EXTERN_FUNC_EXIT;
3341
3342         return ret;
3343 }
3344
3345 sync_agent_da_return_e da_delete_item_changelog_by_item_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *itemId)
3346 {
3347         _EXTERN_FUNC_ENTER;
3348
3349         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3350         retvm_if(itemId == NULL, SYNC_AGENT_DA_ERRORS, "item Id is NULL !!");
3351
3352         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3353         daci_stmt stmt = 0;
3354         char *new_table = 0;
3355         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3356
3357         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3358         if (new_table == NULL)
3359                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3360
3361         snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where item_id = ?", new_table);
3362
3363         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3364         if (stmt == NULL) {
3365                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3366                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3367         }
3368
3369         __stmt_bind_text(daci_handler, stmt, 1, itemId);
3370
3371         ret = __stmt_write_step(daci_handler, stmt);
3372         __stmt_finalize(daci_handler, stmt);
3373
3374         /* memory free */
3375         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3376
3377         _EXTERN_FUNC_EXIT;
3378
3379         return ret;
3380 }
3381
3382 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)
3383 {
3384         _EXTERN_FUNC_ENTER;
3385
3386         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3387         retvm_if(itemIdList == NULL, SYNC_AGENT_DA_ERRORS, "item Id List is NULL !!");
3388
3389         daci_stmt stmt = 0;
3390         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3391         char *new_table = 0;
3392         int i;
3393         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3394
3395         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3396         if (new_table == NULL)
3397                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3398
3399         snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where item_id = ?", new_table);
3400
3401         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3402         if (stmt == NULL) {
3403                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3404                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3405         }
3406
3407         for (i = 0; i < count; i++) {
3408                 __stmt_bind_text(daci_handler, stmt, 1, itemIdList[i]);
3409
3410                 ret = __stmt_write_step(daci_handler, stmt);
3411
3412                 if (ret != SYNC_AGENT_DA_SUCCESS) {
3413                         __stmt_finalize(daci_handler, stmt);
3414                         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3415                         return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3416                 }
3417                 _stmt_reset(daci_handler, stmt);
3418         }
3419         __stmt_finalize(daci_handler, stmt);
3420
3421         /* memory free */
3422         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3423
3424         _EXTERN_FUNC_EXIT;
3425
3426         return ret;
3427 }
3428
3429 sync_agent_da_return_e da_delete_item_changelog_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
3430 {
3431         _EXTERN_FUNC_ENTER;
3432
3433         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3434
3435         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3436         daci_stmt stmt = 0;
3437         char *new_table = 0;
3438         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3439
3440         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3441         if (new_table == NULL) {
3442                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3443                 goto DACI_FINISH;
3444         }
3445
3446         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,
3447                  new_table, account_id, itemTypeId);
3448
3449         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3450         if (stmt == NULL) {
3451                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3452                 goto DACI_FINISH;
3453         }
3454
3455         ret = __stmt_write_step(daci_handler, stmt);
3456         if (ret != SYNC_AGENT_DA_SUCCESS) {
3457                 ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3458                 goto DACI_FINISH;
3459         }
3460
3461  DACI_FINISH:
3462
3463         if (stmt != NULL)
3464                 __stmt_finalize(daci_handler, stmt);
3465
3466         /* memory free */
3467         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3468
3469         _EXTERN_FUNC_EXIT;
3470
3471         return ret;
3472 }
3473
3474 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)
3475 {
3476         _EXTERN_FUNC_ENTER;
3477
3478         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3479         retvm_if(itemChangelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
3480
3481         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3482         daci_stmt stmt = 0;
3483         char *new_table = 0;
3484         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3485
3486         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3487         if (new_table == NULL)
3488                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3489
3490         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);
3491
3492         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3493         if (stmt == NULL) {
3494                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3495                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3496         }
3497
3498         _stmt_bind_int(daci_handler, stmt, 1, itemChangelog->operation_id);
3499         __stmt_bind_text(daci_handler, stmt, 2, itemChangelog->status);
3500         __stmt_bind_text(daci_handler, stmt, 3, itemChangelog->access_name);
3501         __stmt_bind_text(daci_handler, stmt, 4, itemChangelog->item_id);
3502
3503         ret = __stmt_write_step(daci_handler, stmt);
3504         __stmt_finalize(daci_handler, stmt);
3505
3506         /* memory free */
3507         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3508
3509         _EXTERN_FUNC_EXIT;
3510
3511         return ret;
3512 }
3513
3514 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)
3515 {
3516         _EXTERN_FUNC_ENTER;
3517
3518         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3519         retvm_if(itemChangelog == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_changelog_s is NULL !!");
3520
3521         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3522         daci_stmt stmt = 0;
3523         char *new_table = 0;
3524         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3525
3526         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3527         if (new_table == NULL)
3528                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3529
3530         snprintf(g_daci_query, sizeof(g_daci_query), "update %s set status = ?, last_update = current_timestamp, access_name = ? where item_id = ?", new_table);
3531
3532         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3533         if (stmt == NULL) {
3534                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3535                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3536         }
3537
3538         __stmt_bind_text(daci_handler, stmt, 1, itemChangelog->status);
3539         __stmt_bind_text(daci_handler, stmt, 2, itemChangelog->access_name);
3540         __stmt_bind_text(daci_handler, stmt, 3, itemChangelog->item_id);
3541
3542         ret = __stmt_write_step(daci_handler, stmt);
3543         __stmt_finalize(daci_handler, stmt);
3544
3545         /* memory free */
3546         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3547
3548         _EXTERN_FUNC_EXIT;
3549
3550         return ret;
3551 }
3552
3553 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)
3554 {
3555         _EXTERN_FUNC_ENTER;
3556
3557         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3558         retvm_if(itemTypeIdList == NULL, SYNC_AGENT_DA_ERRORS, "item Type Id List is NULL !!");
3559
3560         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3561         daci_stmt stmt = 0;
3562         char *new_table = 0;
3563         char temp_str[10];
3564         int i = 0;
3565         int len = 0;
3566         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3567
3568         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3569         if (new_table == NULL)
3570                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3571
3572         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,
3573                  account_id);
3574
3575         for (i = 0; i < folderIdCount; i++) {
3576                 len = g_strlcat(g_daci_query, "item.folder_id = \'", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3577                 len = g_strlcat(g_daci_query, folderIdList[i], SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3578
3579                 if (i < folderIdCount - 1) {
3580                         len = g_strlcat(g_daci_query, "\' or ", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3581                 } else {
3582                         len = g_strlcat(g_daci_query, "\') and (", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3583                 }
3584
3585                 if (len >= SYNC_AGENT_DA_MAX_QUERY_LENGTH) {
3586                         _DEBUG_ERROR("g_daci_query buffer overflow !!");
3587                         /* todo : exception handling */
3588                 }
3589         }
3590
3591         for (i = 0; i < itemTypeIdCount; i++) {
3592                 memset(temp_str, 0x00, sizeof(temp_str));
3593                 snprintf(temp_str, sizeof(temp_str), "%d", itemTypeIdList[i]);
3594
3595                 len = g_strlcat(g_daci_query, "item.data_store_id = ", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3596                 len = g_strlcat(g_daci_query, temp_str, SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3597
3598                 if (i < itemTypeIdCount - 1) {
3599                         len = g_strlcat(g_daci_query, " or ", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3600                 } else {
3601                         len = g_strlcat(g_daci_query, ") )", SYNC_AGENT_DA_MAX_QUERY_LENGTH);
3602                 }
3603
3604                 if (len >= SYNC_AGENT_DA_MAX_QUERY_LENGTH) {
3605                         _DEBUG_ERROR("g_daci_query buffer overflow !!");
3606                         /* todo : exception handling */
3607                 }
3608         }
3609
3610         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3611         if (stmt == NULL) {
3612                 SYNC_AGENT_DA_MEMORY_FREE(new_table);
3613                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3614         }
3615
3616         ret = __stmt_write_step(daci_handler, stmt);
3617         __stmt_finalize(daci_handler, stmt);
3618
3619         /* memory free */
3620         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3621
3622         _EXTERN_FUNC_EXIT;
3623
3624         return ret;
3625 }
3626
3627 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)
3628 {
3629         _EXTERN_FUNC_ENTER;
3630
3631         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3632
3633         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3634         daci_stmt stmt = 0;
3635         char *new_table = 0;
3636         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3637
3638         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3639         if (new_table == NULL)
3640                 return ret;
3641
3642         snprintf(g_daci_query, sizeof(g_daci_query), "select * from %s where item_id = \'%s\'", new_table, itemChangelog->item_id);
3643
3644         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3645         if (stmt != NULL) {
3646                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
3647                         itemChangelog->operation_id = __stmt_column_int(stmt, 1);
3648                         itemChangelog->status = _stmt_column_text(stmt, 2);
3649                         itemChangelog->access_name = _stmt_column_text(stmt, 4);
3650                         ret = SYNC_AGENT_DA_SUCCESS;
3651                 } else if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_SUCCESS) {
3652                         ret = SYNC_AGENT_DA_ERR_NO_DATA;
3653                 }
3654                 __stmt_finalize(daci_handler, stmt);
3655         }
3656
3657         /* memory free */
3658         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3659
3660         _DEBUG_INFO("[%s] End !\n", __func__);
3661
3662         _EXTERN_FUNC_EXIT;
3663
3664         return ret;
3665 }
3666
3667 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)
3668 {
3669         _EXTERN_FUNC_ENTER;
3670
3671         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3672         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
3673
3674         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERR_QUERY_FAILED;
3675         daci_stmt stmt = 0;
3676         char *new_table = 0;
3677         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3678
3679         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3680         if (new_table == NULL)
3681                 return ret;
3682
3683         snprintf(g_daci_query, sizeof(g_daci_query), "select * from %s where item_id = \'%s\'", new_table, item_id);
3684
3685         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3686         if (stmt != NULL) {
3687                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
3688                         (*sync_agent_changelog)->item_id = SYNC_AGENT_DA_STRDUP(item_id);
3689                         (*sync_agent_changelog)->operation_id = __stmt_column_int(stmt, 1);
3690                         (*sync_agent_changelog)->status = _stmt_column_text(stmt, 2);
3691                         (*sync_agent_changelog)->access_name = _stmt_column_text(stmt, 4);
3692                         ret = SYNC_AGENT_DA_SUCCESS;
3693                 } else if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_SUCCESS) {
3694                         ret = SYNC_AGENT_DA_ERR_NO_DATA;
3695                 }
3696                 __stmt_finalize(daci_handler, stmt);
3697         }
3698
3699         /* memory free */
3700         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3701
3702         _EXTERN_FUNC_EXIT;
3703
3704         return ret;
3705 }
3706
3707 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)
3708 {
3709         _EXTERN_FUNC_ENTER;
3710
3711         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3712
3713         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
3714         sync_agent_da_item_changelog_s *item_changelog;
3715         char *new_table = 0;
3716         char **result = 0;
3717         int row_count = 0;
3718         int col_count = 0;
3719         int i = 0;
3720         int index = 4;
3721         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3722
3723         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3724         if (new_table == NULL)
3725                 return ret;
3726 //      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);
3727         snprintf(g_daci_query, sizeof(g_daci_query),
3728                  "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,
3729                  item_type_id);
3730
3731         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
3732         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
3733                 for (i = 0; i < row_count; i++) {
3734                         item_changelog = NULL;
3735                         ret = sync_agent_create_changelog(&item_changelog);
3736                         if (ret != SYNC_AGENT_DA_SUCCESS) {
3737                                 _DEBUG_ERROR("sync_agent_create_changelog() failed !!");
3738                                 goto DACI_FINISH;
3739                         }
3740
3741                         item_changelog->item_id = SYNC_AGENT_DA_STRDUP(result[index]);
3742                         index++;
3743                         item_changelog->operation_id = SYNC_AGENT_DA_ATOI(result[index]);
3744                         index++;
3745                         item_changelog->status = SYNC_AGENT_DA_STRDUP(result[index]);
3746                         index++;
3747                         item_changelog->access_name = SYNC_AGENT_DA_STRDUP(result[index]);
3748                         index++;
3749
3750                         *list = g_list_append(*list, item_changelog);
3751                 }
3752         }
3753
3754  DACI_FINISH:
3755
3756         if (result != NULL)
3757                 __free_table(result);
3758
3759         /* memory free */
3760         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3761
3762         _EXTERN_FUNC_EXIT;
3763
3764         return ret;
3765 }
3766
3767 sync_agent_da_item_changelog_s *get_itemChangelogByOperationId(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int operationId, int *count)
3768 {
3769         _EXTERN_FUNC_ENTER;
3770
3771         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
3772
3773         daci_stmt stmt = 0;
3774         sync_agent_da_item_changelog_s *item_changelog = 0;
3775         char *new_table = 0;
3776         int data_count = 0;
3777         int i = 0;
3778         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3779
3780         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3781         if (new_table == NULL)
3782                 return item_changelog;
3783
3784         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from %s where operation_id = %d", new_table, operationId);
3785
3786         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3787         *count = data_count;
3788
3789         if (data_count != 0) {
3790                 /* query initialize */
3791                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
3792
3793                 item_changelog = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_item_changelog_s *, sizeof(sync_agent_da_item_changelog_s), data_count);
3794                 if (item_changelog == NULL) {
3795                         _DEBUG_ERROR("memory_allocation failed");
3796
3797                         /* memory free */
3798                         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3799
3800                         return item_changelog;
3801                 }
3802
3803                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from %s where operation_id = %d", new_table, operationId);
3804
3805                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
3806                 if (stmt != NULL) {
3807                         for (i = 0; i < data_count; i++) {
3808                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
3809                                         break;
3810
3811                                 item_changelog[i].item_id = _stmt_column_text(stmt, 0);
3812                                 item_changelog[i].operation_id = __stmt_column_int(stmt, 1);
3813                                 item_changelog[i].status = _stmt_column_text(stmt, 2);
3814                                 item_changelog[i].access_name = _stmt_column_text(stmt, 4);
3815                         }
3816                         __stmt_finalize(daci_handler, stmt);
3817                 }
3818         }
3819
3820         /* memory free */
3821         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3822
3823         _EXTERN_FUNC_EXIT;
3824
3825         return item_changelog;
3826 }
3827
3828 int da_is_exist_item_changelog(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *itemId)
3829 {
3830         _EXTERN_FUNC_ENTER;
3831
3832         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
3833         retvm_if(itemId == NULL, 0, "item Id is NULL !!");
3834
3835         int ret = 1;
3836         char *new_table = 0;
3837         int data_count = 0;
3838         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3839
3840         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
3841         if (new_table == NULL)
3842                 return 0;
3843
3844         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from %s where item_id = \'%s\'", new_table, itemId);
3845
3846         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
3847
3848         if (data_count == 0)
3849                 ret = 0;
3850
3851         /* memory free */
3852         SYNC_AGENT_DA_MEMORY_FREE(new_table);
3853
3854         _EXTERN_FUNC_EXIT;
3855
3856         return ret;
3857 }
3858
3859 sync_agent_da_return_e da_add_last_anchor(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_last_anchor_s * last_anchor)
3860 {
3861         _EXTERN_FUNC_ENTER;
3862
3863         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3864         retvm_if(last_anchor == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_last_anchor_s is NULL !!");
3865
3866         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3867         daci_stmt stmt = 0;
3868         char *query = 0;
3869
3870         if (da_is_exist_last_anchor(daci_handler, last_anchor->account_id, last_anchor->data_store_id) == 1)
3871                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
3872
3873         query = "insert into last_anchor_tbl (account_id, data_store_id, last_anchor_server, last_anchor_client, access_name) values (?, ?, ?, ?, ?)";
3874
3875         stmt = __query_prepare(daci_handler, query, strlen(query));
3876         if (stmt == NULL)
3877                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3878
3879         _stmt_bind_int(daci_handler, stmt, 1, last_anchor->account_id);
3880         _stmt_bind_int(daci_handler, stmt, 2, last_anchor->data_store_id);
3881         __stmt_bind_text(daci_handler, stmt, 3, last_anchor->last_anchor_server);
3882         __stmt_bind_text(daci_handler, stmt, 4, last_anchor->last_anchor_client);
3883         __stmt_bind_text(daci_handler, stmt, 5, last_anchor->access_name);
3884
3885         ret = __stmt_write_step(daci_handler, stmt);
3886         __stmt_finalize(daci_handler, stmt);
3887
3888         _EXTERN_FUNC_EXIT;
3889
3890         return ret;
3891 }
3892
3893 sync_agent_da_return_e da_delete_last_anchor_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
3894 {
3895         _EXTERN_FUNC_ENTER;
3896
3897         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3898
3899         sync_agent_da_return_e ret = _delete_account(daci_handler, SYNC_AGENT_DA_TABLE_NAME_LAST_ANCHOR, account_id);
3900         if (ret != SYNC_AGENT_DA_SUCCESS)
3901                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3902
3903         _EXTERN_FUNC_EXIT;
3904
3905         return ret;
3906 }
3907
3908 sync_agent_da_return_e da_delete_last_anchor_by_item_type_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
3909 {
3910         _EXTERN_FUNC_ENTER;
3911
3912         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3913
3914         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3915         daci_stmt stmt = 0;
3916         char *query = "delete from last_anchor_tbl where account_id = ? and data_store_id = ?";
3917
3918         stmt = __query_prepare(daci_handler, query, strlen(query));
3919         if (stmt == NULL)
3920                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3921
3922         _stmt_bind_int(daci_handler, stmt, 1, account_id);
3923         _stmt_bind_int(daci_handler, stmt, 2, itemTypeId);
3924
3925         ret = __stmt_write_step(daci_handler, stmt);
3926         __stmt_finalize(daci_handler, stmt);
3927
3928         _EXTERN_FUNC_EXIT;
3929
3930         return ret;
3931 }
3932
3933 sync_agent_da_return_e da_set_last_anchor(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_last_anchor_s * last_anchor)
3934 {
3935         _EXTERN_FUNC_ENTER;
3936
3937         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
3938         retvm_if(last_anchor == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_last_anchor_s is NULL !!");
3939
3940         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3941         daci_stmt stmt = 0;
3942         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 = ?";
3943
3944         stmt = __query_prepare(daci_handler, query, strlen(query));
3945         if (stmt == NULL)
3946                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
3947
3948         __stmt_bind_text(daci_handler, stmt, 1, last_anchor->last_anchor_server);
3949         __stmt_bind_text(daci_handler, stmt, 2, last_anchor->last_anchor_client);
3950         __stmt_bind_text(daci_handler, stmt, 3, last_anchor->access_name);
3951         _stmt_bind_int(daci_handler, stmt, 4, last_anchor->account_id);
3952         _stmt_bind_int(daci_handler, stmt, 5, last_anchor->data_store_id);
3953
3954         ret = __stmt_write_step(daci_handler, stmt);
3955         __stmt_finalize(daci_handler, stmt);
3956
3957         _EXTERN_FUNC_EXIT;
3958
3959         return ret;
3960 }
3961
3962 sync_agent_da_last_anchor_s *da_get_last_anchor_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int *count)
3963 {
3964         _EXTERN_FUNC_ENTER;
3965
3966         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
3967
3968         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
3969         sync_agent_da_last_anchor_s *last_anchor = 0;
3970         char **result = 0;
3971         int row_count = 0;
3972         int col_count = 0;
3973         int i = 0;
3974         int index = 4;
3975         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
3976
3977         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);
3978
3979         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
3980         *count = row_count;
3981
3982         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
3983                 last_anchor = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_last_anchor_s *, sizeof(sync_agent_da_last_anchor_s), row_count);
3984                 if (last_anchor == NULL) {
3985                         _DEBUG_ERROR("memory_allocation failed");
3986                         goto DACI_FINISH;
3987                 }
3988
3989                 for (i = 0; i < row_count; i++) {
3990                         last_anchor[i].account_id = SYNC_AGENT_DA_ATOI(result[index]);
3991                         index++;
3992                         last_anchor[i].data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
3993                         index++;
3994                         last_anchor[i].last_anchor_server = SYNC_AGENT_DA_STRDUP(result[index]);
3995                         index++;
3996                         last_anchor[i].last_anchor_client = SYNC_AGENT_DA_STRDUP(result[index]);
3997                         index++;
3998                         last_anchor[i].access_name = 0;
3999                 }
4000         }
4001
4002  DACI_FINISH:
4003
4004         if (result != NULL)
4005                 __free_table(result);
4006
4007         _EXTERN_FUNC_EXIT;
4008
4009         return last_anchor;
4010 }
4011
4012 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)
4013 {
4014         _EXTERN_FUNC_ENTER;
4015
4016         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4017
4018         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4019         sync_agent_da_last_anchor_s *last_anchor = 0;
4020         char **result = 0;
4021         int row_count = 0;
4022         int col_count = 0;
4023         int i = 0;
4024         int index = 4;
4025         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4026
4027         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);
4028
4029         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
4030         *count = row_count;
4031
4032         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
4033                 last_anchor = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_last_anchor_s *, sizeof(sync_agent_da_last_anchor_s), row_count);
4034                 if (last_anchor == NULL) {
4035                         _DEBUG_ERROR("memory_allocation failed");
4036                         goto DACI_FINISH;
4037                 }
4038
4039                 for (i = 0; i < row_count; i++) {
4040                         last_anchor[i].account_id = SYNC_AGENT_DA_ATOI(result[index]);
4041                         index++;
4042                         last_anchor[i].data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
4043                         index++;
4044                         last_anchor[i].last_anchor_server = SYNC_AGENT_DA_STRDUP(result[index]);
4045                         index++;
4046                         last_anchor[i].last_anchor_client = SYNC_AGENT_DA_STRDUP(result[index]);
4047                         index++;
4048                         last_anchor[i].access_name = 0;
4049                 }
4050         }
4051
4052  DACI_FINISH:
4053
4054         if (result != NULL)
4055                 __free_table(result);
4056
4057         _EXTERN_FUNC_EXIT;
4058
4059         return last_anchor;
4060 }
4061
4062 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)
4063 {
4064         _EXTERN_FUNC_ENTER;
4065
4066         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4067
4068         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
4069         sync_agent_da_last_anchor_s *last_anchor = NULL;
4070         char **result = 0;
4071         int row_count = 0;
4072         int col_count = 0;
4073         int i = 0;
4074         int index = 4;
4075         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4076
4077         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);
4078
4079         ret = _get_table(daci_handler, g_daci_query, &result, &row_count, &col_count);
4080 //      *count = row_count;
4081
4082         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
4083                 for (i = 0; i < row_count; i++) {
4084                         last_anchor = NULL;
4085                         ret = sync_agent_create_last_anchor(&last_anchor);
4086                         if (ret != SYNC_AGENT_DA_SUCCESS) {
4087                                 _DEBUG_ERROR("sync_agent_create_last_anchor() failed !!");
4088                                 goto DACI_FINISH;
4089                         }
4090
4091                         last_anchor->account_id = SYNC_AGENT_DA_ATOI(result[index]);
4092                         index++;
4093                         last_anchor->data_store_id = SYNC_AGENT_DA_ATOI(result[index]);
4094                         index++;
4095                         last_anchor->last_anchor_server = SYNC_AGENT_DA_STRDUP(result[index]);
4096                         index++;
4097                         last_anchor->last_anchor_client = SYNC_AGENT_DA_STRDUP(result[index]);
4098                         index++;
4099                         last_anchor->access_name = NULL;
4100
4101                         *list = g_list_append(*list, last_anchor);
4102                 }
4103         } else if (ret != SYNC_AGENT_DA_SUCCESS) {
4104                 _DEBUG_ERROR("__get_table() failed !!");
4105                 return ret;
4106         }
4107
4108  DACI_FINISH:
4109
4110         if (result != NULL)
4111                 __free_table(result);
4112
4113         _EXTERN_FUNC_EXIT;
4114
4115         return ret;
4116 }
4117
4118 int da_is_exist_last_anchor(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int itemTypeId)
4119 {
4120         _EXTERN_FUNC_ENTER;
4121
4122         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
4123
4124         int ret = 1;
4125         int data_count = 0;
4126         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4127
4128         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);
4129
4130         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4131
4132         if (data_count == 0)
4133                 ret = 0;
4134
4135         _EXTERN_FUNC_EXIT;
4136
4137         return ret;
4138 }
4139
4140 sync_agent_da_return_e da_add_mapping(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_mapping_s * mapping)
4141 {
4142         _EXTERN_FUNC_ENTER;
4143
4144         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4145         retvm_if(mapping == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_mapping_s is NULL !!");
4146
4147         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4148         daci_stmt stmt = 0;
4149         char *query = 0;
4150
4151         if (da_is_exist_mapping_by_luid(daci_handler, mapping->account_id, mapping->luid) == 1) {
4152                 _DEBUG_INFO("exist mapping item");
4153                 return SYNC_AGENT_DA_ERR_PRIMARY_KEY_NOT_UNIQUE;
4154         }
4155
4156         query = "insert into mapping_tbl (account_id, data_store_id, luid, guid, access_name) values (?, ?, ?, ?, ?)";
4157
4158         stmt = __query_prepare(daci_handler, query, strlen(query));
4159         if (stmt == NULL) {
4160                 _DEBUG_ERROR("stmt is NULL !!");
4161                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4162         }
4163
4164         _DEBUG_INFO("account_id = %d", mapping->account_id);
4165         _DEBUG_INFO("data_store_id = %d", mapping->data_store_id);
4166         _DEBUG_INFO("luid = %s", mapping->luid);
4167         _DEBUG_INFO("guid = %s", mapping->guid);
4168         _DEBUG_INFO("access_name = %s", mapping->access_name);
4169
4170         _stmt_bind_int(daci_handler, stmt, 1, mapping->account_id);
4171         _stmt_bind_int(daci_handler, stmt, 2, mapping->data_store_id);
4172         __stmt_bind_text(daci_handler, stmt, 3, mapping->luid);
4173         __stmt_bind_text(daci_handler, stmt, 4, mapping->guid);
4174         __stmt_bind_text(daci_handler, stmt, 5, mapping->access_name);
4175
4176         _DEBUG_INFO("query = %s", query);
4177
4178         ret = __stmt_write_step(daci_handler, stmt);
4179         __stmt_finalize(daci_handler, stmt);
4180
4181         _EXTERN_FUNC_EXIT;
4182
4183         return ret;
4184 }
4185
4186 sync_agent_da_return_e da_delete_mapping_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4187 {
4188         _EXTERN_FUNC_ENTER;
4189
4190         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4191
4192         sync_agent_da_return_e ret = _delete_account(daci_handler, SYNC_AGENT_DA_TABLE_NAME_MAPPING, account_id);
4193         if (ret != SYNC_AGENT_DA_SUCCESS)
4194                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4195
4196         _EXTERN_FUNC_EXIT;
4197
4198         return ret;
4199 }
4200
4201 sync_agent_da_return_e da_delete_mapping_by_luid(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid)
4202 {
4203         _EXTERN_FUNC_ENTER;
4204
4205         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4206         retvm_if(luid == NULL, SYNC_AGENT_DA_ERRORS, "luid is NULL !!");
4207
4208         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4209         daci_stmt stmt = 0;
4210         char *query = "delete from mapping_tbl where account_id = ? and luid = ?";
4211
4212         stmt = __query_prepare(daci_handler, query, strlen(query));
4213         if (stmt == NULL)
4214                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4215
4216         _stmt_bind_int(daci_handler, stmt, 1, account_id);
4217         __stmt_bind_text(daci_handler, stmt, 2, luid);
4218
4219         ret = __stmt_write_step(daci_handler, stmt);
4220         __stmt_finalize(daci_handler, stmt);
4221
4222         _EXTERN_FUNC_EXIT;
4223
4224         return ret;
4225 }
4226
4227 sync_agent_da_mapping_s *da_get_mapping_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, int *count)
4228 {
4229         _EXTERN_FUNC_ENTER;
4230
4231         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4232
4233         daci_stmt stmt = 0;
4234         sync_agent_da_mapping_s *mapping = 0;
4235         int data_count = 0;
4236         int i = 0;
4237         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4238
4239         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d", account_id);
4240
4241         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4242         *count = data_count;
4243
4244         if (data_count != 0) {
4245                 /* query initialize */
4246                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
4247
4248                 mapping = SYNC_AGENT_DA_MEMORY_MALLOC(sync_agent_da_mapping_s *, sizeof(sync_agent_da_mapping_s), data_count);
4249                 if (mapping == NULL) {
4250                         _DEBUG_ERROR("memory_allocation failed");
4251                         return mapping;
4252                 }
4253
4254                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from mapping_tbl where account_id = %d", account_id);
4255
4256                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
4257                 if (stmt != NULL) {
4258                         for (i = 0; i < data_count; i++) {
4259                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
4260                                         break;
4261
4262                                 mapping[i].account_id = __stmt_column_int(stmt, 0);
4263                                 mapping[i].data_store_id = __stmt_column_int(stmt, 1);
4264                                 mapping[i].luid = _stmt_column_text(stmt, 2);
4265                                 mapping[i].guid = _stmt_column_text(stmt, 3);
4266                                 mapping[i].access_name = _stmt_column_text(stmt, 5);
4267                         }
4268                         __stmt_finalize(daci_handler, stmt);
4269                 }
4270         }
4271
4272         _EXTERN_FUNC_EXIT;
4273
4274         return mapping;
4275 }
4276
4277 sync_agent_da_return_e da_get_mapping_by_account_id_new(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, GList ** list)
4278 {
4279         _EXTERN_FUNC_ENTER;
4280
4281         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4282
4283         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
4284         daci_stmt stmt = 0;
4285         sync_agent_da_mapping_s *mapping;
4286         int data_count = 0;
4287         int i = 0;
4288         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4289
4290         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d", account_id);
4291
4292         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4293
4294         if (data_count != 0) {
4295                 /* query initialize */
4296                 SYNC_AGENT_DA_MEMORY_SET(g_daci_query);
4297
4298                 snprintf(g_daci_query, sizeof(g_daci_query), "select * from mapping_tbl where account_id = %d", account_id);
4299
4300                 stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
4301                 if (stmt != NULL) {
4302                         for (i = 0; i < data_count; i++) {
4303                                 if (_stmt_read_step(daci_handler, stmt) != SYNC_AGENT_DA_ERR_MORE_DATA)
4304                                         break;
4305
4306                                 mapping = NULL;
4307                                 ret = sync_agent_create_mapping(&mapping);
4308                                 if (ret != SYNC_AGENT_DA_SUCCESS) {
4309                                         _DEBUG_ERROR("sync_agent_create_mapping() failed !!");
4310                                         return ret;
4311                                 }
4312
4313                                 mapping->account_id = __stmt_column_int(stmt, 0);
4314                                 mapping->data_store_id = __stmt_column_int(stmt, 1);
4315                                 mapping->luid = _stmt_column_text(stmt, 2);
4316                                 mapping->guid = _stmt_column_text(stmt, 3);
4317                                 mapping->access_name = _stmt_column_text(stmt, 5);
4318
4319                                 *list = g_list_append(*list, mapping);
4320                         }
4321                         __stmt_finalize(daci_handler, stmt);
4322                 } else {
4323                         _DEBUG_ERROR("stmt is NULL !!");
4324                 }
4325         } else {
4326                 _DEBUG_INFO("no data !!");
4327                 ret = SYNC_AGENT_DA_SUCCESS;
4328         }
4329
4330         _EXTERN_FUNC_EXIT;
4331
4332         return ret;
4333 }
4334
4335 char *da_get_mapping_guid(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid)
4336 {
4337         _EXTERN_FUNC_ENTER;
4338
4339         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4340         retvm_if(luid == NULL, NULL, "luid is NULL !!");
4341
4342         daci_stmt stmt = 0;
4343         char *query = "select guid from mapping_tbl where account_id = ? and luid = ?";
4344         char *guid = 0;
4345
4346         stmt = __query_prepare(daci_handler, query, strlen(query));
4347         if (stmt != NULL) {
4348                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
4349                 __stmt_bind_text(daci_handler, stmt, 2, luid);
4350
4351                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
4352                         guid = _stmt_column_text(stmt, 0);
4353
4354                 __stmt_finalize(daci_handler, stmt);
4355         }
4356
4357         _EXTERN_FUNC_EXIT;
4358
4359         return guid;
4360 }
4361
4362 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)
4363 {
4364         _EXTERN_FUNC_ENTER;
4365
4366         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4367         retvm_if(luid == NULL, SYNC_AGENT_DA_ERRORS, "luid is NULL !!");
4368
4369         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
4370         daci_stmt stmt = 0;
4371         char *query = "select * from mapping_tbl where account_id = ? and luid = ?";
4372
4373         stmt = __query_prepare(daci_handler, query, strlen(query));
4374         if (stmt != NULL) {
4375                 _stmt_bind_int(daci_handler, stmt, 1, account_id);
4376                 __stmt_bind_text(daci_handler, stmt, 2, luid);
4377
4378                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4379                         (*sync_agent_mapping)->account_id = __stmt_column_int(stmt, 0);
4380                         (*sync_agent_mapping)->data_store_id = __stmt_column_int(stmt, 1);
4381                         (*sync_agent_mapping)->luid = _stmt_column_text(stmt, 2);
4382                         (*sync_agent_mapping)->guid = _stmt_column_text(stmt, 3);
4383                         (*sync_agent_mapping)->access_name = _stmt_column_text(stmt, 5);
4384                         ret = SYNC_AGENT_DA_SUCCESS;
4385                 }
4386
4387                 __stmt_finalize(daci_handler, stmt);
4388         } else {
4389                 _DEBUG_ERROR("stmt is NULL !!");
4390         }
4391
4392         _EXTERN_FUNC_EXIT;
4393
4394         return ret;
4395 }
4396
4397 int da_is_exist_mapping_by_account_id(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
4398 {
4399         _EXTERN_FUNC_ENTER;
4400
4401         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
4402
4403         int ret = 1;
4404         int data_count = 0;
4405         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4406
4407         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d", account_id);
4408
4409         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4410
4411         if (data_count == 0)
4412                 ret = 0;
4413
4414         _EXTERN_FUNC_EXIT;
4415
4416         return ret;
4417 }
4418
4419 int da_is_exist_mapping_by_luid(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id, char *luid)
4420 {
4421         _EXTERN_FUNC_ENTER;
4422
4423         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
4424         retvm_if(luid == NULL, 0, "luid is NULL !!");
4425
4426         int ret = 1;
4427         int data_count = 0;
4428         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4429
4430         snprintf(g_daci_query, sizeof(g_daci_query), "select count(*) from mapping_tbl where account_id = %d and luid = \'%s\'", account_id, luid);
4431
4432         data_count = _get_data_count(daci_handler, g_daci_query, strlen(g_daci_query));
4433
4434         if (data_count == 0)
4435                 ret = 0;
4436
4437         _DEBUG_INFO("ret : %d", ret);
4438
4439         _EXTERN_FUNC_EXIT;
4440
4441         return ret;
4442 }
4443
4444 sync_agent_da_return_e da_add_id_provider(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_id_provider_s * id_provider)
4445 {
4446         _EXTERN_FUNC_ENTER;
4447
4448         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4449         retvm_if(id_provider == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_provider_s is NULL !!");
4450
4451         daci_stmt stmt = 0;
4452         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4453         char *query = 0;
4454
4455         query = "insert into id_provider_tbl (id_provider_code, id_capacity, bit_per_page, last_id, free_bit_cnt) values (?, ?, ?, ?, ?)";
4456
4457         stmt = __query_prepare(daci_handler, query, strlen(query));
4458         if (stmt == NULL) {
4459                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4460         }
4461
4462         _stmt_bind_int(daci_handler, stmt, 1, id_provider->id_provider_code);
4463         _stmt_bind_int(daci_handler, stmt, 2, id_provider->id_capacity);
4464         _stmt_bind_int(daci_handler, stmt, 3, id_provider->bit_per_page);
4465         _stmt_bind_int(daci_handler, stmt, 4, id_provider->last_id);
4466         _stmt_bind_int(daci_handler, stmt, 5, id_provider->free_bit_cnt);
4467
4468         ret = __stmt_write_step(daci_handler, stmt);
4469         if (ret != SYNC_AGENT_DA_SUCCESS) {
4470                 __stmt_finalize(daci_handler, stmt);
4471                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4472         }
4473
4474         __stmt_finalize(daci_handler, stmt);
4475
4476         _EXTERN_FUNC_EXIT;
4477
4478         return ret;
4479 }
4480
4481 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)
4482 {
4483         _EXTERN_FUNC_ENTER;
4484
4485         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4486
4487         int ret = SYNC_AGENT_DA_SUCCESS;
4488         daci_stmt stmt = 0;
4489         char *query = "select id_capacity, bit_per_page, last_id, free_bit_cnt from id_provider_tbl where id_provider_code = ?";
4490
4491         stmt = __query_prepare(daci_handler, query, strlen(query));
4492         if (stmt != NULL) {
4493                 _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4494
4495                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4496                         *id_provider = (sync_agent_da_id_provider_s *) calloc(1, sizeof(sync_agent_da_id_provider_s));
4497                         if (*id_provider == NULL) {
4498                                 _DEBUG_ERROR("CALLOC failed !!!");
4499                                 return SYNC_AGENT_DA_ERRORS;
4500                         }
4501                         (*id_provider)->id_capacity = __stmt_column_int(stmt, 0);
4502                         (*id_provider)->bit_per_page = __stmt_column_int(stmt, 1);
4503                         (*id_provider)->last_id = __stmt_column_int(stmt, 2);
4504                         (*id_provider)->free_bit_cnt = __stmt_column_int(stmt, 3);
4505                 } else {
4506                         ret = SYNC_AGENT_DA_ERR_NO_DATA;
4507                 }
4508                 __stmt_finalize(daci_handler, stmt);
4509         }
4510
4511         _EXTERN_FUNC_EXIT;
4512
4513         return ret;
4514 }
4515
4516 sync_agent_da_return_e da_update_id_provider(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_id_provider_s * id_provider)
4517 {
4518         _EXTERN_FUNC_ENTER;
4519
4520         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4521         retvm_if(id_provider == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_provider_s is NULL !!");
4522
4523         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4524         daci_stmt stmt = 0;
4525         char *query = "update id_provider_tbl set last_id = ?, free_bit_cnt = ? where id_provider_code = ?";
4526
4527         stmt = __query_prepare(daci_handler, query, strlen(query));
4528         if (stmt == NULL)
4529                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4530
4531         _stmt_bind_int(daci_handler, stmt, 1, id_provider->last_id);
4532         _stmt_bind_int(daci_handler, stmt, 2, id_provider->free_bit_cnt);
4533         _stmt_bind_int(daci_handler, stmt, 3, id_provider->id_provider_code);
4534
4535         ret = __stmt_write_step(daci_handler, stmt);
4536         __stmt_finalize(daci_handler, stmt);
4537
4538         _EXTERN_FUNC_EXIT;
4539
4540         return ret;
4541 }
4542
4543 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)
4544 {
4545         _EXTERN_FUNC_ENTER;
4546
4547         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4548         retvm_if(id_page == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_page_s is NULL !!");
4549
4550         daci_stmt stmt = 0;
4551         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4552         char *query = 0;
4553
4554         query = "insert into id_page_tbl (page_index, id_provider_code, page_bit) values (?, ?, ?)";
4555
4556         stmt = __query_prepare(daci_handler, query, strlen(query));
4557         if (stmt == NULL) {
4558                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4559         }
4560
4561         _stmt_bind_int(daci_handler, stmt, 1, id_page->page_index);
4562         _stmt_bind_int(daci_handler, stmt, 2, id_page->id_provider_code);
4563         _stmt_bind_blob(daci_handler, stmt, 3, id_page->page_bit, page_byte_size);
4564         int i = 0;
4565         for (; i < page_byte_size; i++) {
4566                 _DEBUG_INFO("[%d] %d\n", i, (id_page->page_bit)[i]);
4567         }
4568
4569         ret = __stmt_write_step(daci_handler, stmt);
4570         if (ret != SYNC_AGENT_DA_SUCCESS) {
4571                 __stmt_finalize(daci_handler, stmt);
4572                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4573         }
4574
4575         __stmt_finalize(daci_handler, stmt);
4576
4577         _EXTERN_FUNC_EXIT;
4578
4579         return ret;
4580 }
4581
4582 sync_agent_da_return_e da_delete_id_page(SYNC_AGENT_DA_HANDLER * daci_handler, unsigned int id_provider_code, unsigned int page_index)
4583 {
4584         _EXTERN_FUNC_ENTER;
4585
4586         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4587
4588         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4589         daci_stmt stmt = 0;
4590         char *query = "delete from id_page_tbl where id_provider_code = ? and page_index = ?";
4591
4592         stmt = __query_prepare(daci_handler, query, strlen(query));
4593         if (stmt == NULL)
4594                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4595
4596         _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4597         _stmt_bind_int(daci_handler, stmt, 2, page_index);
4598
4599         ret = __stmt_write_step(daci_handler, stmt);
4600         __stmt_finalize(daci_handler, stmt);
4601
4602         _EXTERN_FUNC_EXIT;
4603
4604         return ret;
4605 }
4606
4607 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)
4608 {
4609         _EXTERN_FUNC_ENTER;
4610
4611         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4612
4613         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4614         daci_stmt stmt = 0;
4615         char *query = "select page_bit from id_page_tbl where id_provider_code = ? and page_index = ?";
4616
4617         stmt = __query_prepare(daci_handler, query, strlen(query));
4618         if (stmt != NULL) {
4619                 _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4620                 _stmt_bind_int(daci_handler, stmt, 2, page_index);
4621
4622                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4623                         int byte_len = sqlite3_column_bytes(stmt, 0);
4624                         byte_len += 1;  /* The count which sqlite3_column_bytes returns doesn't include trailing \0 in case of string. */
4625                         *page_bit = (char *)calloc(byte_len, sizeof(char));
4626                         if (*page_bit == NULL) {
4627                                 _DEBUG_ERROR("CALLOC failed !!!");
4628                                 return SYNC_AGENT_DA_ERRORS;
4629                         }
4630
4631                         const unsigned char *geted_page_bit = sqlite3_column_text(stmt, 0);
4632
4633                         memcpy(*page_bit, geted_page_bit, byte_len);
4634                 } else {
4635                         _DEBUG_INFO("NO DATA");
4636                         *page_bit = 0;
4637                 }
4638                 __stmt_finalize(daci_handler, stmt);
4639         }
4640
4641         _EXTERN_FUNC_EXIT;
4642
4643         return ret;
4644 }
4645
4646 sync_agent_da_return_e da_get_id_page_index(SYNC_AGENT_DA_HANDLER * daci_handler, unsigned int id_provider_code, int *count)
4647 {
4648         _EXTERN_FUNC_ENTER;
4649
4650         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4651
4652         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4653         daci_stmt stmt = 0;
4654         char *query = "select count(*) from id_page_tbl where id_provider_code = ?;";
4655
4656         stmt = __query_prepare(daci_handler, query, strlen(query));
4657         if (stmt != NULL) {
4658                 _stmt_bind_int(daci_handler, stmt, 1, id_provider_code);
4659
4660                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA) {
4661                         *count = __stmt_column_int(stmt, 0);
4662                 } else {
4663                         _DEBUG_INFO("NO DATA");
4664                         *count = 0;
4665                 }
4666                 __stmt_finalize(daci_handler, stmt);
4667         }
4668
4669         _EXTERN_FUNC_EXIT;
4670
4671         return ret;
4672 }
4673
4674 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)
4675 {
4676         _EXTERN_FUNC_ENTER;
4677
4678         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4679         retvm_if(id_page == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_id_page_s is NULL !!");
4680
4681         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
4682         daci_stmt stmt = 0;
4683         char *query = "update id_page_tbl set page_bit = ? where id_provider_code = ? and page_index = ?";
4684
4685         stmt = __query_prepare(daci_handler, query, strlen(query));
4686         if (stmt == NULL)
4687                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4688
4689         _stmt_bind_blob(daci_handler, stmt, 1, id_page->page_bit, page_byte_size);
4690         _stmt_bind_int(daci_handler, stmt, 2, id_page->id_provider_code);
4691         _stmt_bind_int(daci_handler, stmt, 3, id_page->page_index);
4692
4693         ret = __stmt_write_step(daci_handler, stmt);
4694         __stmt_finalize(daci_handler, stmt);
4695
4696         _EXTERN_FUNC_EXIT;
4697
4698         return ret;
4699 }
4700
4701 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)
4702 {
4703         _EXTERN_FUNC_ENTER;
4704
4705         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4706
4707         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
4708         char *new_table = 0;
4709         int data_count = 0;
4710
4711         _DEBUG_INFO("data_store_id = %d", data_store_id);
4712
4713         new_table = __replace_table_name("account_%d_item_changelog_tbl", fw_account_id, 1);
4714         if (new_table == NULL) {
4715                 _DEBUG_ERROR("__replace_table_name is failed");
4716                 *item_count = 0;
4717                 return SYNC_AGENT_DA_ERRORS;
4718         }
4719
4720         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"
4721                 " 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);
4722         _DEBUG_INFO("query = %s", query);
4723         data_count = _get_data_count(daci_handler, query, strlen(query));
4724
4725         *item_count = data_count;
4726
4727         if (new_table != NULL)
4728                 free(new_table);
4729         new_table = NULL;
4730
4731         _EXTERN_FUNC_EXIT;
4732         return SYNC_AGENT_DA_SUCCESS;
4733 }
4734
4735 sync_agent_da_return_e da_get_updated_exdate_item_id_list(SYNC_AGENT_DA_HANDLER *daci_handler, char *fw_id, GList ** list)
4736 {
4737         _EXTERN_FUNC_ENTER;
4738
4739         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4740         retvm_if(fw_id == NULL, SYNC_AGENT_DA_ERRORS, "fw_id is NULL !!");
4741
4742         char **result = 0;
4743         char *parent_service_id = NULL;
4744         char *item_id;
4745         char query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = {0, };
4746         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
4747         int row_count = 0;
4748         int col_count = 0;
4749         int index = 1;
4750         int i = 0;
4751         daci_stmt stmt = 0;
4752
4753         snprintf(query, sizeof(query), "select service_id from item_tbl where item_id = %s", fw_id);
4754         _DEBUG_INFO("query : %s", query);
4755         stmt = __query_prepare(daci_handler, query, strlen(query));
4756         if (stmt != NULL) {
4757                 ret = _stmt_read_step(daci_handler, stmt);
4758                 if (ret == SYNC_AGENT_DA_ERR_MORE_DATA)
4759                         parent_service_id = _stmt_column_text(stmt, 0);
4760                 else {
4761                         _DEBUG_ERROR("_stmt_read_step() failed");
4762                         __stmt_finalize(daci_handler, stmt);
4763                         goto return_part;
4764                 }
4765                 __stmt_finalize(daci_handler, stmt);
4766         }
4767         SYNC_AGENT_DA_MEMORY_SET(query);
4768
4769         snprintf(query, sizeof(query), "select item_id from item_tbl where parent_service_id = \'%s\'", parent_service_id);
4770         _DEBUG_INFO("query : %s", query);
4771
4772         ret = _get_table(daci_handler, query, &result, &row_count, &col_count);
4773         if ((ret == SYNC_AGENT_DA_SUCCESS) && (row_count != 0) && (result != 0)) {
4774                 for (i = 0; i < row_count; i++) {
4775                         item_id = NULL;
4776                         item_id = SYNC_AGENT_DA_STRDUP(result[index]);
4777                         index++;
4778                         *list = g_list_append(*list, item_id);
4779                 }
4780         }
4781
4782         if (result != NULL) {
4783                 __free_table(result);
4784         }
4785
4786 return_part:
4787         _EXTERN_FUNC_EXIT;
4788         return ret;
4789 }
4790
4791
4792 int _busy_handler(void *pData, int count)
4793 {
4794         _INNER_FUNC_ENTER;
4795
4796         _DEBUG_TRACE("__busy_handler %d called", count);
4797
4798         /*  sleep time when SQLITE_LOCK */
4799         usleep(100000);
4800
4801         _INNER_FUNC_EXIT;
4802
4803         /* retry will be stopped if  busy handler return 0 */
4804         return SYNC_AGENT_DA_RETRY_COUNT - count;
4805 }
4806
4807 sync_agent_da_return_e __query_exec(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, char *err_msg)
4808 {
4809         _INNER_FUNC_ENTER;
4810
4811         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_NOT_OPENED, "SYNC_AGENT_DA_HANDLER is NULL !!");
4812         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "query is NULL !!");
4813
4814         char *query_msg = 0;
4815         int ret = 0;
4816
4817         int err_mutex = pthread_mutex_lock(&exec_lock);
4818         if (err_mutex) {
4819                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4820         }
4821         ret = sqlite3_exec(daci_handler, query, 0, 0, &query_msg);
4822         err_mutex = pthread_mutex_unlock(&exec_lock);
4823         if (err_mutex) {
4824                 _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4825         }
4826
4827         if (ret != SQLITE_OK) {
4828                 _DEBUG_ERROR("%s(%d) : %s", err_msg, ret, query_msg);
4829
4830                 if (NULL != query_msg)
4831                         sqlite3_free(query_msg);
4832
4833                 if (ret == SQLITE_BUSY)
4834                         return SYNC_AGENT_DA_ERR_LOCKED;
4835
4836                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4837         }
4838
4839         _INNER_FUNC_EXIT;
4840
4841         return SYNC_AGENT_DA_SUCCESS;
4842 }
4843
4844 daci_stmt __query_prepare(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, int size)
4845 {
4846         _INNER_FUNC_ENTER;
4847
4848         retvm_if(daci_handler == NULL, NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
4849         retvm_if(query == NULL, NULL, "query is NULL !!");
4850
4851         int ret = 0;
4852         daci_stmt stmt = 0;
4853
4854         int err_mutex = pthread_mutex_lock(&exec_lock);
4855         if (err_mutex) {
4856                 _DEBUG_ERROR("Failed pthread_mutex_lock : [%d]", err_mutex);
4857         }
4858
4859         //for test
4860         //_DEBUG_INFO("query = [%s], size = [%d]", query, size);
4861         ret = sqlite3_prepare_v2(daci_handler, query, size, &stmt, 0);
4862         if (ret != SQLITE_OK) {
4863                 _DEBUG_ERROR("sqlite3_query_prepare failed[%d] : [%s]", ret, sqlite3_errmsg(daci_handler));
4864         }
4865
4866         err_mutex = pthread_mutex_unlock(&exec_lock);
4867         if (err_mutex) {
4868                 _DEBUG_ERROR("Failed pthread_mutex_unlock : [%d]", err_mutex);
4869         }
4870
4871         _INNER_FUNC_EXIT;
4872         return stmt;
4873 }
4874
4875 sync_agent_da_return_e __stmt_bind_text(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const char *value)
4876 {
4877         _INNER_FUNC_ENTER;
4878
4879         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4880
4881         int ret = 0;
4882
4883         if (value != NULL) {
4884                 ret = sqlite3_bind_text(stmt, index, value, strlen(value), SQLITE_STATIC);
4885         } else {
4886                 ret = __stmt_bind_null(daci_handler, stmt, index);
4887
4888                 if (ret == SYNC_AGENT_DA_SUCCESS)
4889                         ret = SQLITE_OK;
4890         }
4891
4892         if (ret != SQLITE_OK) {
4893                 _DEBUG_ERROR("sqlite3_stmt_bind_text failed(%d) : %s ", ret, sqlite3_errmsg(daci_handler));
4894                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4895         }
4896
4897         _INNER_FUNC_EXIT;
4898
4899         return SYNC_AGENT_DA_SUCCESS;
4900 }
4901
4902 sync_agent_da_return_e _stmt_bind_int(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index, const int value)
4903 {
4904         _INNER_FUNC_ENTER;
4905
4906         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4907
4908         int ret = 0;
4909
4910         ret = sqlite3_bind_int(stmt, index, value);
4911         if (ret != SQLITE_OK) {
4912                 _DEBUG_ERROR("sqlite3_stmt_bind_int failed(%d) : %s \n", ret, sqlite3_errmsg(daci_handler));
4913                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4914         }
4915
4916         _INNER_FUNC_EXIT;
4917
4918         return SYNC_AGENT_DA_SUCCESS;
4919 }
4920
4921 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)
4922 {
4923         _INNER_FUNC_ENTER;
4924
4925         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4926
4927         int ret = 0;
4928
4929         ret = sqlite3_bind_blob(stmt, index, value, nbyte, 0);
4930         if (ret != SQLITE_OK) {
4931                 _DEBUG_ERROR("sqlite3_bind_blob failed(%d) : %s \n", ret, sqlite3_errmsg(daci_handler));
4932                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4933         }
4934
4935         _INNER_FUNC_EXIT;
4936
4937         return SYNC_AGENT_DA_SUCCESS;
4938 }
4939
4940 sync_agent_da_return_e __stmt_bind_null(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt, int index)
4941 {
4942         _INNER_FUNC_ENTER;
4943
4944         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4945
4946         int ret = 0;
4947
4948         ret = sqlite3_bind_null(stmt, index);
4949         if (ret != SQLITE_OK) {
4950                 _DEBUG_ERROR("sqlite3_stmt_bind_null failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4951                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4952         }
4953
4954         _INNER_FUNC_EXIT;
4955
4956         return SYNC_AGENT_DA_SUCCESS;
4957 }
4958
4959 sync_agent_da_return_e _stmt_read_step(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
4960 {
4961         _INNER_FUNC_ENTER;
4962
4963         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
4964
4965         int ret = 0;
4966 //      int err_mutex = 0;
4967
4968 //      err_mutex = pthread_mutex_lock(&exec_lock);
4969 //      if (err_mutex) {
4970 //              _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
4971 //      }
4972
4973         ret = sqlite3_step(stmt);
4974
4975 //      err_mutex = pthread_mutex_unlock(&exec_lock);
4976 //      if (err_mutex) {
4977 //              _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
4978 //      }
4979
4980         if (ret == SQLITE_ROW)
4981                 return SYNC_AGENT_DA_ERR_MORE_DATA;
4982
4983         if (ret != SQLITE_DONE) {
4984                 _DEBUG_ERROR("sqlite3_stmt_step failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
4985
4986                 if (ret == SQLITE_BUSY)
4987                         return SYNC_AGENT_DA_ERR_LOCKED;
4988
4989                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
4990         }
4991
4992         _INNER_FUNC_EXIT;
4993
4994         return SYNC_AGENT_DA_SUCCESS;
4995 }
4996
4997 static sync_agent_da_return_e __stmt_write_step(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
4998 {
4999         _INNER_FUNC_ENTER;
5000
5001         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5002
5003         int transaction_flag = 0;
5004         int err_mutex = 0;
5005
5006         if (use_transaction_thread_id != 0) {
5007                 if (use_transaction_thread_id != SYNC_AGENT_DA_GET_THREAD_ID) {
5008                         err_mutex = pthread_mutex_lock(&transaction_lock);
5009                         if (err_mutex) {
5010                                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
5011                         }
5012                         use_transaction_thread_id = SYNC_AGENT_DA_GET_THREAD_ID;
5013                         transaction_flag = 1;
5014                 }
5015         }
5016
5017         err_mutex = pthread_mutex_lock(&exec_lock);
5018         if (err_mutex) {
5019                 _DEBUG_ERROR("Failed pthread_mutex_lock : %d", err_mutex);
5020         }
5021
5022         int ret = sqlite3_step(stmt);
5023
5024         err_mutex = pthread_mutex_unlock(&exec_lock);
5025         if (err_mutex) {
5026                 _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
5027         }
5028
5029         if (transaction_flag) {
5030                 use_transaction_thread_id = 0;
5031                 err_mutex = pthread_mutex_unlock(&transaction_lock);
5032                 if (err_mutex) {
5033                         _DEBUG_ERROR("Failed pthread_mutex_unlock : %d", err_mutex);
5034                 }
5035         }
5036
5037         if (ret == SQLITE_ROW) {
5038                 return SYNC_AGENT_DA_ERR_MORE_DATA;
5039         }
5040
5041         if (ret != SQLITE_DONE) {
5042                 _DEBUG_ERROR("sqlite3_stmt_step failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
5043                 if (ret == SQLITE_BUSY) {
5044                         _DEBUG_ERROR("Never reached this line!!");
5045                         return SYNC_AGENT_DA_ERR_LOCKED;
5046                 }
5047                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
5048         }
5049
5050         _INNER_FUNC_EXIT;
5051
5052         return SYNC_AGENT_DA_SUCCESS;
5053 }
5054
5055 sync_agent_da_return_e _stmt_reset(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
5056 {
5057         _INNER_FUNC_ENTER;
5058
5059         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5060
5061         int ret = 0;
5062
5063         if (sqlite3_reset(stmt) != SQLITE_OK) {
5064                 _DEBUG_ERROR("sqlite3_stmt_reset failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
5065                 return SYNC_AGENT_DA_ERRORS;
5066         }
5067
5068         _INNER_FUNC_EXIT;
5069
5070         return SYNC_AGENT_DA_SUCCESS;
5071 }
5072
5073 sync_agent_da_return_e __stmt_finalize(SYNC_AGENT_DA_HANDLER * daci_handler, daci_stmt stmt)
5074 {
5075         _INNER_FUNC_ENTER;
5076
5077         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5078
5079         int ret = 0;
5080
5081         if (sqlite3_finalize(stmt) != SQLITE_OK) {
5082                 _DEBUG_ERROR("sqlite3_stmt_finalize failed(%d) : %s", ret, sqlite3_errmsg(daci_handler));
5083                 return SYNC_AGENT_DA_ERRORS;
5084         }
5085
5086         _INNER_FUNC_EXIT;
5087
5088         return SYNC_AGENT_DA_SUCCESS;
5089 }
5090
5091 char *_stmt_column_text(daci_stmt stmt, int index)
5092 {
5093         _INNER_FUNC_ENTER;
5094
5095         char *temp = 0;
5096
5097         temp = (char *)sqlite3_column_text(stmt, index);
5098
5099         _INNER_FUNC_EXIT;
5100
5101         return SYNC_AGENT_DA_STRDUP(temp);
5102 }
5103
5104 int __stmt_column_int(daci_stmt stmt, int index)
5105 {
5106         _INNER_FUNC_ENTER;
5107
5108         _INNER_FUNC_EXIT;
5109
5110         return (int)sqlite3_column_int(stmt, index);
5111 }
5112
5113 sync_agent_da_return_e _get_table(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, char ***result, int *row_count, int *col_count)
5114 {
5115         _INNER_FUNC_ENTER;
5116
5117         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERR_NOT_OPENED, "SYNC_AGENT_DA_HANDLER is NULL !!");
5118         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "query is NULL !!");
5119
5120         int ret = 0;
5121         char *err_msg;
5122
5123         int err_mutex = pthread_mutex_lock(&exec_lock);
5124         if (err_mutex) {
5125                 _DEBUG_TRACE("Failed pthread_mutex_lock : %d", err_mutex);
5126         }
5127         ret = sqlite3_get_table(daci_handler, query, result, row_count, col_count, &err_msg);
5128         err_mutex = pthread_mutex_unlock(&exec_lock);
5129         if (err_mutex) {
5130                 _DEBUG_TRACE("Failed pthread_mutex_lock : %d", err_mutex);
5131         }
5132
5133         if (ret != SQLITE_OK) {
5134                 _DEBUG_ERROR("sqlite3_get_table failed(%d) : %s", ret, err_msg);
5135
5136                 __free_table(*result);
5137                 if (NULL != err_msg)
5138                         sqlite3_free(err_msg);
5139                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
5140         }
5141
5142         _INNER_FUNC_EXIT;
5143
5144         return SYNC_AGENT_DA_SUCCESS;
5145 }
5146
5147 void __free_table(char **result)
5148 {
5149         _INNER_FUNC_ENTER;
5150
5151         if (result != NULL)
5152                 sqlite3_free_table(result);
5153
5154         _INNER_FUNC_EXIT;
5155 }
5156
5157 sync_agent_da_return_e _create_changelog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
5158 {
5159         _INNER_FUNC_ENTER;
5160
5161         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5162
5163         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
5164         char *new_table = 0;
5165         char *new_table_create = 0;
5166
5167         ret = da_begin_transaction(daci_handler);
5168         if (ret != SYNC_AGENT_DA_SUCCESS) {
5169                 _DEBUG_ERROR("agent_db_changelog_tbl_create failed");
5170                 return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
5171         }
5172
5173         /* 9. create account_item_changelog_tbl */
5174         new_table = __replace_table_name("account_%d_item_changelog_tbl", account_id, 1);
5175         if (new_table == NULL) {
5176                 da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
5177                 return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
5178         }
5179
5180         if (__exist_table(daci_handler, new_table) == 0) {
5181                 new_table_create = __replace_table_name(g_daci_create_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG], account_id, 4);
5182
5183                 ret = __query_exec(daci_handler, new_table_create, "Item_changelog_tbl_create failed");
5184
5185                 if (ret != SYNC_AGENT_DA_SUCCESS) {
5186                         da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);
5187                         return SYNC_AGENT_DA_ERR_CREATE_TABLE_FAILED;
5188                 }
5189         }
5190
5191         /* memory free */
5192         SYNC_AGENT_DA_MEMORY_FREE(new_table);
5193         SYNC_AGENT_DA_MEMORY_FREE(new_table_create);
5194
5195         _INNER_FUNC_EXIT;
5196
5197         return da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_COMMIT);
5198 }
5199
5200 sync_agent_da_return_e _drop_changelog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
5201 {
5202         _INNER_FUNC_ENTER;
5203
5204         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5205
5206         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
5207         char *new_table_drop = 0;
5208
5209         /* 9. drop account_item_changelog_tbl */
5210         new_table_drop = __replace_table_name(g_daci_drop_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG], account_id, 1);
5211
5212         ret = __query_exec(daci_handler, new_table_drop, "Item_changelog_tbl_drop failed");
5213         if (ret != SYNC_AGENT_DA_SUCCESS) {
5214 /*              da_end_transaction(daci_handler, SYNC_AGENT_DA_TRANSACTION_ROLLBACK);*/
5215                 return SYNC_AGENT_DA_ERR_DROP_TABLE_FAILED;
5216         }
5217
5218         /* memory free */
5219         SYNC_AGENT_DA_MEMORY_FREE(new_table_drop);
5220
5221         _INNER_FUNC_EXIT;
5222
5223         return ret;
5224 }
5225
5226 sync_agent_da_return_e _delete_changlog_table(SYNC_AGENT_DA_HANDLER * daci_handler, int account_id)
5227 {
5228         _INNER_FUNC_ENTER;
5229
5230         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5231
5232         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
5233         char *new_table_delete = 0;
5234
5235         /* 9. delete account_item_changelog_tbl */
5236         new_table_delete = __replace_table_name(g_daci_delete_table[SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG], account_id, 1);
5237
5238         ret = __query_exec(daci_handler, new_table_delete, "Item_changelog_tbl_delete failed");
5239         if (ret != SYNC_AGENT_DA_SUCCESS) {
5240                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
5241         }
5242
5243         /* memory free */
5244         SYNC_AGENT_DA_MEMORY_FREE(new_table_delete);
5245
5246         _INNER_FUNC_EXIT;
5247
5248         return ret;
5249 }
5250
5251 int __exist_table(SYNC_AGENT_DA_HANDLER * daci_handler, const char *table_name)
5252 {
5253         _INNER_FUNC_ENTER;
5254
5255         daci_stmt stmt = 0;
5256         int table_count = 0;
5257         char *query = "select count(*) from sqlite_master where tbl_name= ?";
5258
5259         stmt = __query_prepare(daci_handler, query, strlen(query));
5260         if ((stmt != NULL) && (__stmt_bind_text(daci_handler, stmt, 1, table_name) == SYNC_AGENT_DA_SUCCESS)) {
5261
5262                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
5263                         table_count = __stmt_column_int(stmt, 0);
5264
5265                 __stmt_finalize(daci_handler, stmt);
5266
5267                 if (table_count > 0) {
5268                         _INNER_FUNC_EXIT;
5269
5270                         return 1;
5271                 }
5272         }
5273
5274         _INNER_FUNC_EXIT;
5275
5276         return 0;
5277 }
5278
5279 int _get_data_count(SYNC_AGENT_DA_HANDLER * daci_handler, char *query, int size)
5280 {
5281         _INNER_FUNC_ENTER;
5282
5283         retvm_if(daci_handler == NULL, 0, "SYNC_AGENT_DA_HANDLER is NULL !!");
5284         retvm_if(query == NULL, 0, "query is NULL !!");
5285
5286         daci_stmt stmt = 0;
5287         int data_count = 0;
5288
5289         stmt = __query_prepare(daci_handler, query, size);
5290         if (stmt != NULL) {
5291                 if (_stmt_read_step(daci_handler, stmt) == SYNC_AGENT_DA_ERR_MORE_DATA)
5292                         data_count = __stmt_column_int(stmt, 0);
5293
5294                 __stmt_finalize(daci_handler, stmt);
5295         }
5296
5297         _INNER_FUNC_EXIT;
5298
5299         return data_count;
5300 }
5301
5302 char *__replace_table_name(char *oldTable, int account_id, int count)
5303 {
5304         _INNER_FUNC_ENTER;
5305
5306         retvm_if(oldTable == NULL, NULL, "old Table is NULL !!");
5307
5308         char *new_table = 0;
5309         int length = 0;
5310
5311         /* SVACE : Measure the size for allocation memory. */
5312         if (count == 1)         /* table name convert */
5313                 length = snprintf(0, 0, oldTable, account_id);
5314         else if (count == 4)    /* table create query convert */
5315                 length = snprintf(0, 0, oldTable, account_id, account_id, account_id, account_id);
5316
5317         new_table = SYNC_AGENT_DA_MEMORY_MALLOC(char *, sizeof(char), (length + 1));
5318         if (new_table == NULL) {
5319                 _DEBUG_ERROR("memory_allocation failed");
5320                 return new_table;
5321         }
5322
5323         if (count == 1) {
5324                 snprintf(new_table, length + 1, oldTable, account_id);
5325         } else if (count == 4) {
5326                 snprintf(new_table, length + 1, oldTable, account_id, account_id, account_id, account_id);
5327         }
5328
5329         _INNER_FUNC_EXIT;
5330
5331         return new_table;
5332 }
5333
5334 char *__get_table_name(sync_agent_da_table_name_e table_name)
5335 {
5336         _INNER_FUNC_ENTER;
5337
5338         char *table_str = 0;
5339
5340         switch (table_name) {
5341         case SYNC_AGENT_DA_TABLE_NAME_ACCOUNT:
5342                 {
5343                         table_str = "account_tbl";
5344                 }
5345                 break;
5346         case SYNC_AGENT_DA_TABLE_NAME_FOLDER:
5347                 {
5348                         table_str = "folder_tbl";
5349                 }
5350                 break;
5351         case SYNC_AGENT_DA_TABLE_NAME_ITEM:
5352                 {
5353                         table_str = "item_tbl";
5354                 }
5355                 break;
5356         case SYNC_AGENT_DA_TABLE_NAME_CONFIG:
5357                 {
5358                         table_str = "config_tbl";
5359                 }
5360                 break;
5361         case SYNC_AGENT_DA_TABLE_NAME_ACCOUNT_ITEM_CHANGELOG:
5362                 {
5363                         table_str = "account_item_changelog_tbl";
5364                 }
5365                 break;
5366         case SYNC_AGENT_DA_TABLE_NAME_LAST_ANCHOR:
5367                 {
5368                         table_str = "last_anchor_tbl";
5369                 }
5370                 break;
5371         case SYNC_AGENT_DA_TABLE_NAME_MAPPING:
5372                 {
5373                         table_str = "mapping_tbl";
5374                 }
5375                 break;
5376         case SYNC_AGENT_DA_TABLE_NAME_ID_PROVIDER:
5377                 {
5378                         table_str = "id_provider_tbl";
5379                 }
5380                 break;
5381         case SYNC_AGENT_DA_TABLE_NAME_ID_PAGE:
5382                 {
5383                         table_str = "id_page_tbl";
5384                 }
5385                 break;
5386         default:
5387                 break;
5388         }
5389
5390         _INNER_FUNC_EXIT;
5391
5392         return table_str;
5393 }
5394
5395 char *_get_column_name(sync_agent_da_column_name_e column_name)
5396 {
5397         _INNER_FUNC_ENTER;
5398
5399         char *column_str = 0;
5400
5401         switch (column_name) {
5402         case SYNC_AGENT_DA_COLUMN_NAME_ITEM_ID:
5403                 {
5404                         column_str = "item_id";
5405                 }
5406                 break;
5407         case SYNC_AGENT_DA_COLUMN_NAME_SERVICE_ID:
5408                 {
5409                         column_str = "service_id";
5410                 }
5411                 break;
5412         default:
5413                 break;
5414         }
5415
5416         _INNER_FUNC_EXIT;
5417
5418         return column_str;
5419 }
5420
5421 int _get_next_account_id(void)
5422 {
5423         _INNER_FUNC_ENTER;
5424
5425         int next_account_id = 1;
5426         int *account_id_list = 0;
5427         int count = 0;
5428         int i = 0;
5429
5430         account_id_list = da_get_account_id_list(&count);
5431         if (account_id_list != NULL) {
5432                 for (i = 0; i < count; i++) {
5433                         if ((i + 1) != account_id_list[i])
5434                                 break;
5435
5436                         next_account_id++;
5437                 }
5438
5439                 free(account_id_list);
5440         }
5441
5442         _INNER_FUNC_EXIT;
5443
5444         return next_account_id;
5445 }
5446
5447 sync_agent_da_return_e _delete_account(SYNC_AGENT_DA_HANDLER * daci_handler, sync_agent_da_table_name_e table_name, int account_id)
5448 {
5449         _INNER_FUNC_ENTER;
5450
5451         retvm_if(daci_handler == NULL, SYNC_AGENT_DA_ERRORS, "SYNC_AGENT_DA_HANDLER is NULL !!");
5452
5453         daci_stmt stmt = 0;
5454         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
5455         char *table_str = 0;
5456         char g_daci_query[SYNC_AGENT_DA_MAX_QUERY_LENGTH] = { 0, };
5457
5458         table_str = __get_table_name(table_name);
5459
5460         if (!strcmp(table_str, "config_tbl")) {
5461                 snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where config_id = %d", table_str, account_id);
5462         } else if (!strcmp(table_str, "id_provider_tbl") || !strcmp(table_str, "id_page_tbl")) {
5463                 return ret;
5464         } else {
5465                 snprintf(g_daci_query, sizeof(g_daci_query), "delete from %s where account_id = %d", table_str, account_id);
5466         }
5467
5468         _DEBUG_TRACE("i = %d, tableName = %s, query = %s", table_name, table_str, g_daci_query);
5469         stmt = __query_prepare(daci_handler, g_daci_query, strlen(g_daci_query));
5470         if (stmt == NULL)
5471                 return SYNC_AGENT_DA_ERR_QUERY_FAILED;
5472
5473         ret = __stmt_write_step(daci_handler, stmt);
5474         __stmt_finalize(daci_handler, stmt);
5475
5476         _INNER_FUNC_EXIT;
5477
5478         return ret;
5479 }
5480
5481 /*
5482  *=============================================================================================================================
5483  * Testing
5484  *=============================================================================================================================
5485 */
5486 void da_drop_table(SYNC_AGENT_DA_HANDLER * daci_handler, int *accountIdList, int account_count)
5487 {
5488         _EXTERN_FUNC_ENTER;
5489
5490         retm_if(daci_handler == NULL, "SYNC_AGENT_DA_HANDLER is NULL !!");
5491         retm_if(accountIdList == NULL, "account Id List is NULL !!");
5492
5493         int i;
5494
5495         for (i = 0; i < account_count; i++)
5496                 _drop_changelog_table(daci_handler, accountIdList[i]);
5497
5498         _EXTERN_FUNC_EXIT;
5499 }
5500
5501 char *da_get_daci_file_path(void)
5502 {
5503         _EXTERN_FUNC_ENTER;
5504
5505         _EXTERN_FUNC_EXIT;
5506
5507         return daci_file_path;
5508 }