src/framework/data-adapter/agent.c

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