src/common/media-svc-db-utils.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <unistd.h>
  23 #include <media-util.h>
  24 #include <errno.h>
  25 #include "media-svc-env.h"
  26 #include "media-svc-debug.h"
  27 #include "media-svc-util.h"
  28 #include "media-svc-db-utils.h"
  29 #include "media-util-err.h"
  30 #include "media-util-db.h"
  31 #include "media-svc-media.h"
  32
  33 static int __media_svc_db_upgrade(sqlite3 *db_handle, int cur_version, uid_t uid);
  34 static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid);
  35 static int __media_svc_query_direct(sqlite3 *handle, const char *query, uid_t uid);
  36
  37
  38 static GHashTable *table;
  39 static GSList *column_list[MEDIA_SVC_DB_LIST_MAX];
  40
  41 int __media_svc_add_table_info(const char *name, const char *trigger_name, const char *event_table, const char *action_table, const char *view_name)
  42 {
  43         table_info_s *tbl = NULL;
  44
  45         media_svc_retvm_if(!STRING_VALID(name), MS_MEDIA_ERR_INVALID_PARAMETER, "name is NULL");
  46
  47         if (STRING_VALID(trigger_name)) {
  48                 media_svc_retvm_if(!STRING_VALID(event_table), MS_MEDIA_ERR_INVALID_PARAMETER, "event_table is NULL");
  49                 media_svc_retvm_if(!STRING_VALID(action_table), MS_MEDIA_ERR_INVALID_PARAMETER, "action_table is NULL");
  50         }
  51
  52         tbl = malloc(sizeof(table_info_s));
  53         if (tbl == NULL) {
  54                 media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
  55                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
  56         }
  57
  58         memset(tbl, 0x00, sizeof(table_info_s));
  59
  60         if (STRING_VALID(trigger_name)) {
  61                 tbl->trigger_name = malloc(MEDIA_SVC_PATHNAME_SIZE);
  62                 if (tbl->trigger_name == NULL) {
  63                         media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
  64                         SAFE_FREE(tbl);
  65                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
  66                 }
  67
  68                 memset(tbl->trigger_name, 0x00, MEDIA_SVC_PATHNAME_SIZE);
  69                 snprintf(tbl->trigger_name, MEDIA_SVC_PATHNAME_SIZE, "%s_%s", trigger_name, event_table);
  70
  71                 tbl->event_table = strndup(event_table, strlen(event_table));
  72                 tbl->action_table = strndup(action_table, strlen(action_table));
  73         }
  74
  75         if (STRING_VALID(view_name))
  76                 tbl->view_name = strndup(view_name, strlen(view_name));
  77
  78         g_hash_table_insert(table, (gpointer)name, (gpointer)tbl);
  79
  80         return MS_MEDIA_ERR_NONE;
  81 }
  82
  83 int __media_svc_add_column_info(GSList **slist, const char *name, const char *type, const char *option, int version, const char *index_name, bool is_unique, bool is_trigger, bool is_view)
  84 {
  85         column_info_s *col = NULL;
  86         col = malloc(sizeof(column_info_s));
  87         if (col == NULL) {
  88                 media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
  89                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
  90         }
  91         memset(col, 0, sizeof(column_info_s));
  92
  93         col->name = strndup(name, strlen(name));
  94         col->type = strndup(type, strlen(type));
  95         if (option != NULL) {
  96                 col->has_option = true;
  97                 col->option = strndup(option, strlen(option));
  98         } else {
  99                 col->has_option = false;
 100         }
 101         col->version = version;
 102         if (index_name != NULL) {
 103                 col->is_index = true;
 104                 col->index_name = strndup(index_name, strlen(index_name));
 105         } else {
 106                 col->is_index = false;
 107         }
 108         col->is_unique = is_unique;
 109         col->is_trigger = is_trigger;
 110         col->is_view = is_view;
 111         *slist = g_slist_append(*slist, col);
 112
 113         return MS_MEDIA_ERR_NONE;
 114 }
 115
 116 static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 117 {
 118         int ret = MS_MEDIA_ERR_NONE;
 119         column_info_s *col_ptr = NULL;
 120         char *sql = NULL;
 121         char table_query[MEDIA_SVC_QUERY_LEN_NORMAL] = {0, };
 122         char temp[1024] = {0, };
 123         bool sflag = false;
 124         int i, len;
 125         /*media */
 126         _media_svc_update_media_view(db_handle, uid);
 127
 128         /*drop playlist_view, tag_view */
 129         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_DROP_VIEW, MEDIA_SVC_DB_VIEW_PLAYLIST);
 130         ret = _media_svc_sql_query(sql, uid);
 131         SQLITE3_SAFE_FREE(sql);
 132         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 133
 134         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_DROP_VIEW, MEDIA_SVC_DB_VIEW_TAG);
 135         ret = _media_svc_sql_query(sql, uid);
 136         SQLITE3_SAFE_FREE(sql);
 137         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 138
 139         /*create playlist_view */
 140         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
 141         for (i = 1; i < len; i++) {
 142                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 143                 if (col_ptr->is_view) {
 144                         if (sflag == true) {
 145                                 if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_THUMBNAIL, strlen(MEDIA_SVC_DB_COLUMN_THUMBNAIL)) == 0)
 146                                         snprintf(temp, sizeof(temp), ", playlist.%s AS p_thumbnail_path", col_ptr->name);
 147                                 else
 148                                         snprintf(temp, sizeof(temp), ", playlist.%s", col_ptr->name);
 149                         } else {
 150                                 snprintf(temp, sizeof(temp), "playlist.%s", col_ptr->name);
 151                                 sflag = true;
 152                         }
 153                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 154                 }
 155                 memset(temp, 0, sizeof(temp));
 156         }
 157         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
 158         for (i = 1; i < len; i++) {
 159                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
 160                 if (col_ptr->is_view) {
 161                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 162                                 snprintf(temp, sizeof(temp), ", playlist_media_count IS NOT NULL AS playlist_media_count, playlist_map.%s AS pm_id", col_ptr->name);
 163                         else
 164                                 snprintf(temp, sizeof(temp), ", playlist_map.%s", col_ptr->name);
 165                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 166                 }
 167                 memset(temp, 0, sizeof(temp));
 168         }
 169
 170         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 171         for (i = 1; i < len; i++) {
 172                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 173                 if (col_ptr->is_view) {
 174                         snprintf(temp, sizeof(temp), ", media_view.%s", col_ptr->name);
 175                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 176                 }
 177                 memset(temp, 0, sizeof(temp));
 178         }
 179         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_PLAYLIST, MEDIA_SVC_DB_VIEW_PLAYLIST, table_query);
 180         ret = _media_svc_sql_query(sql, uid);
 181         SQLITE3_SAFE_FREE(sql);
 182         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 183
 184         /*create tag_view */
 185         sflag = false;
 186         memset(table_query, 0, sizeof(table_query));
 187
 188         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 189         for (i = 1; i < len; i++) {
 190                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 191                 if (col_ptr->is_view) {
 192                         if (sflag == true) {
 193                                 snprintf(temp, sizeof(temp), ", tag.%s", col_ptr->name);
 194                         } else {
 195                                 snprintf(temp, sizeof(temp), "tag.%s", col_ptr->name);
 196                                 sflag = true;
 197                         }
 198                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 199                 }
 200                 memset(temp, 0, sizeof(temp));
 201         }
 202         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
 203         for (i = 1; i < len; i++) {
 204                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
 205                 if (col_ptr->is_view) {
 206                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 207                                 snprintf(temp, sizeof(temp), ", tag_media_count IS NOT NULL AS tag_media_count, tag_map.%s AS tm_id", col_ptr->name);
 208                         else
 209                                 snprintf(temp, sizeof(temp), ", tag_map.%s", col_ptr->name);
 210                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 211                 }
 212                 memset(temp, 0, sizeof(temp));
 213         }
 214
 215         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 216         for (i = 1; i < len; i++) {
 217                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 218                 if (col_ptr->is_view) {
 219                         snprintf(temp, sizeof(temp), ", media_view.%s", col_ptr->name);
 220                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 221                 }
 222                 memset(temp, 0, sizeof(temp));
 223         }
 224         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_TAG, MEDIA_SVC_DB_VIEW_TAG, table_query);
 225         ret = _media_svc_sql_query(sql, uid);
 226         SQLITE3_SAFE_FREE(sql);
 227         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 228
 229         return MS_MEDIA_ERR_NONE;
 230 }
 231
 232 int _media_svc_make_table_query(const char *table_name, media_svc_table_slist_e list, uid_t uid)
 233 {
 234         int ret = MS_MEDIA_ERR_NONE;
 235         table_info_s *tb = NULL;
 236         column_info_s *col_ptr = NULL;
 237         char *sql = NULL;
 238         char table_query[MEDIA_SVC_QUERY_LEN_NORMAL] = {0, };
 239         char index_query[MEDIA_SVC_QUERY_LEN_NORMAL] = {0, };
 240         char trigger_query[MEDIA_SVC_QUERY_LEN_NORMAL] = {0, };
 241         char table_query_sub[1024] = {0, };
 242         char temp[1024] = {0 ,};
 243         bool flag = false;
 244         bool sub_flag = false;
 245         int len = 0;
 246         int i = 0;
 247
 248         tb = g_hash_table_lookup(table, table_name);
 249         if (tb == NULL) {
 250                 media_svc_debug("lookup fail.. table name [%s] ", table_name);
 251                 tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_MEDIA);
 252         }
 253
 254         len = g_slist_length(column_list[list]);
 255
 256         if (len == 0) {
 257                 media_svc_error("Invalid column");
 258                 return MS_MEDIA_ERR_INTERNAL;
 259         }
 260
 261         for (i = 1; i < len; i++) {
 262                 col_ptr = g_slist_nth_data(column_list[list], i);
 263                 /*create table */
 264                 if (col_ptr->has_option) {
 265                         if (flag == true) {
 266                                 snprintf(temp, sizeof(temp), ", %s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 267                         } else {
 268                                 snprintf(temp, sizeof(temp), "%s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 269                                 flag = true;
 270                         }
 271                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 272                 } else {
 273                         if (flag == true) {
 274                                 snprintf(temp, sizeof(temp), ", %s %s", col_ptr->name, col_ptr->type);
 275                         } else {
 276                                 snprintf(temp, sizeof(temp), "%s %s", col_ptr->name, col_ptr->type);
 277                                 flag = true;
 278                         }
 279                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 280                 }
 281                 memset(temp, 0, sizeof(temp));
 282
 283                 /*unique */
 284                 if (col_ptr->is_unique) {
 285                         if (sub_flag == true) {
 286                                 snprintf(temp, sizeof(temp), ", %s", col_ptr->name);
 287                         } else {
 288                                 snprintf(temp, sizeof(temp), "%s", col_ptr->name);
 289                                 sub_flag = true;
 290                         }
 291                         SAFE_STRLCAT(table_query_sub, temp, sizeof(table_query_sub));
 292                 }
 293                 memset(temp, 0, sizeof(temp));
 294
 295                 /*create index */
 296                 if (col_ptr->is_index) {
 297                         snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_INDEX, col_ptr->index_name, table_name, col_ptr->name);
 298                         SAFE_STRLCAT(index_query, temp, sizeof(index_query));
 299                 }
 300                 memset(temp, 0, sizeof(temp));
 301
 302                 /*create trigger */
 303                 if (col_ptr->is_trigger) {
 304                         if (STRING_VALID(tb->trigger_name)) {
 305                                 if (strncmp(table_name, MEDIA_SVC_DB_TABLE_ALBUM, strlen(MEDIA_SVC_DB_TABLE_ALBUM)) == 0)
 306                                         snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER_WITH_COUNT, tb->trigger_name, tb->event_table, tb->action_table, tb->event_table, col_ptr->name, col_ptr->name, col_ptr->name, col_ptr->name);
 307                                 else
 308                                         snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER, tb->trigger_name, tb->event_table, tb->action_table, col_ptr->name, col_ptr->name);
 309
 310                                 SAFE_STRLCAT(trigger_query, temp, sizeof(trigger_query));
 311                         } else {
 312                                 media_svc_error("invalid trigger name");
 313                         }
 314                 }
 315                 memset(temp, 0, sizeof(temp));
 316         }
 317
 318         /*send queries */
 319         if (sub_flag == true) {
 320                 sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_TABLE_WITH_UNIQUE, table_name, table_query, table_query_sub);
 321                 ret = _media_svc_sql_query(sql, uid);
 322                 SQLITE3_SAFE_FREE(sql);
 323                 memset(table_query, 0, sizeof(table_query));
 324                 memset(table_query_sub, 0, sizeof(table_query_sub));
 325                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 326         } else {
 327                 sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_TABLE, table_name, table_query);
 328                 ret = _media_svc_sql_query(sql, uid);
 329                 SQLITE3_SAFE_FREE(sql);
 330                 memset(table_query, 0, sizeof(table_query));
 331                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 332         }
 333
 334         if (STRING_VALID(index_query)) {
 335                 ret = _media_svc_sql_query(index_query, uid);
 336                 memset(index_query, 0, sizeof(index_query));
 337                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 338         }
 339
 340         if (STRING_VALID(trigger_query)) {
 341                 ret = _media_svc_sql_query(trigger_query, uid);
 342                 memset(trigger_query, 0, sizeof(trigger_query));
 343                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 344         }
 345
 346         /*create view */
 347         flag = false;
 348         if (tb != NULL && tb->view_name != NULL) {
 349                 if (strncmp(table_name, MEDIA_SVC_DB_TABLE_MEDIA, strlen(MEDIA_SVC_DB_TABLE_MEDIA)) == 0) {
 350                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_MEDIA, tb->view_name, table_name);
 351                         ret = _media_svc_sql_query(sql, uid);
 352                         SQLITE3_SAFE_FREE(sql);
 353                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 354
 355                 } else if (strncmp(table_name, MEDIA_SVC_DB_TABLE_PLAYLIST, strlen(MEDIA_SVC_DB_TABLE_PLAYLIST)) == 0) {
 356                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
 357                         for (i = 1; i < len; i++) {
 358                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 359                                 if (col_ptr->is_view) {
 360                                         if (flag == true) {
 361                                                 if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_THUMBNAIL, strlen(MEDIA_SVC_DB_COLUMN_THUMBNAIL)) == 0)
 362                                                         snprintf(temp, sizeof(temp), ", playlist.%s AS p_thumbnail_path", col_ptr->name);
 363                                                 else
 364                                                         snprintf(temp, sizeof(temp), ", playlist.%s", col_ptr->name);
 365                                         } else {
 366                                                 snprintf(temp, sizeof(temp), "playlist.%s", col_ptr->name);
 367                                                 flag = true;
 368                                         }
 369                                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 370                                 }
 371                                 memset(temp, 0, sizeof(temp));
 372                         }
 373                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
 374                         for (i = 1; i < len; i++) {
 375                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
 376                                 if (col_ptr->is_view) {
 377                                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 378                                                 snprintf(temp, sizeof(temp), ", playlist_media_count IS NOT NULL AS playlist_media_count, playlist_map.%s AS pm_id", col_ptr->name);
 379                                         else
 380                                                 snprintf(temp, sizeof(temp), ", playlist_map.%s", col_ptr->name);
 381                                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 382                                 }
 383                                 memset(temp, 0, sizeof(temp));
 384                         }
 385
 386                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 387                         for (i = 1; i < len; i++) {
 388                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 389                                 if (col_ptr->is_view) {
 390                                         snprintf(temp, sizeof(temp), ", media_view.%s", col_ptr->name);
 391                                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 392                                 }
 393                                 memset(temp, 0, sizeof(temp));
 394                         }
 395                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_PLAYLIST, tb->view_name, table_query);
 396                         ret = _media_svc_sql_query(sql, uid);
 397                         SQLITE3_SAFE_FREE(sql);
 398                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 399
 400                 } else {
 401                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 402                         for (i = 1; i < len; i++) {
 403                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 404                                 if (col_ptr->is_view) {
 405                                         if (flag == true) {
 406                                                 snprintf(temp, sizeof(temp), ", tag.%s", col_ptr->name);
 407                                         } else {
 408                                                 snprintf(temp, sizeof(temp), "tag.%s", col_ptr->name);
 409                                                 flag = true;
 410                                         }
 411                                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 412                                 }
 413                                 memset(temp, 0, sizeof(temp));
 414                         }
 415                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
 416                         for (i = 1; i < len; i++) {
 417                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
 418                                 if (col_ptr->is_view) {
 419                                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 420                                                 snprintf(temp, sizeof(temp), ", tag_media_count IS NOT NULL AS tag_media_count, tag_map.%s AS tm_id", col_ptr->name);
 421                                         else
 422                                                 snprintf(temp, sizeof(temp), ", tag_map.%s", col_ptr->name);
 423                                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 424                                 }
 425                                 memset(temp, 0, sizeof(temp));
 426                         }
 427
 428                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 429                         for (i = 1; i < len; i++) {
 430                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 431                                 if (col_ptr->is_view) {
 432                                         snprintf(temp, sizeof(temp), ", media_view.%s", col_ptr->name);
 433                                         SAFE_STRLCAT(table_query, temp, sizeof(table_query));
 434                                 }
 435                                 memset(temp, 0, sizeof(temp));
 436                         }
 437                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_TAG, tb->view_name, table_query);
 438                         ret = _media_svc_sql_query(sql, uid);
 439                         SQLITE3_SAFE_FREE(sql);
 440                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 441                 }
 442         }
 443
 444         return MS_MEDIA_ERR_NONE;
 445 }
 446
 447 int _media_svc_upgrade_table_query(sqlite3 *db_handle, const char *table_name, media_svc_table_slist_e list, uid_t uid)
 448 {
 449         int ret = MS_MEDIA_ERR_NONE;
 450         column_info_s *col_ptr = NULL;
 451         char *sql = NULL;
 452         char temp[1024] = {0, };
 453         int len, i;
 454         int cur_version = 0;
 455         sqlite3_stmt *sql_stmt = NULL;
 456
 457         len = g_slist_length(column_list[list]);
 458
 459         sql = sqlite3_mprintf("PRAGMA user_version");
 460         ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
 461
 462         if (ret != MS_MEDIA_ERR_NONE) {
 463                 media_svc_error("error when get user_version. err = [%d]", ret);
 464                 return ret;
 465         }
 466         cur_version = sqlite3_column_int(sql_stmt, 0);
 467         SQLITE3_FINALIZE(sql_stmt);
 468
 469         len = g_slist_length(column_list[list]);
 470         for (i = 1; i < len; i++) {
 471                 col_ptr = g_slist_nth_data(column_list[list], i);
 472                 if (col_ptr->version > cur_version) {
 473                         /*alter table */
 474                         if (col_ptr->has_option)
 475                                 snprintf(temp, sizeof(temp), "%s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 476                         else
 477                                 snprintf(temp, sizeof(temp), "%s %s", col_ptr->name, col_ptr->type);
 478                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_ALTER_TABLE, table_name, temp);
 479                         ret = _media_svc_sql_query(sql, uid);
 480                         SQLITE3_SAFE_FREE(sql);
 481                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 482                         /*create index */
 483                         if (col_ptr->is_index) {
 484                                 memset(temp, 0, sizeof(temp));
 485                                 snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_INDEX, col_ptr->index_name, table_name, col_ptr->name);
 486                                 ret = _media_svc_sql_query(temp, uid);
 487                                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 488                         }
 489                 }
 490                 memset(temp, 0, sizeof(temp));
 491         }
 492
 493         return MS_MEDIA_ERR_NONE;
 494 }
 495
 496 int _media_svc_init_table_query(const char *event_table_name)
 497 {
 498         int ret = MS_MEDIA_ERR_NONE;
 499         int i = 0;
 500
 501         /*variable initialize.. */
 502         table = g_hash_table_new(g_str_hash, g_str_equal);
 503         for (i = 0; i < MEDIA_SVC_DB_LIST_MAX; i++)
 504                 column_list[i] = g_slist_alloc();
 505
 506         /*table specification.. (table_name, index, unique set, trigger, view, trigger name, event table, action table, view name) */
 507         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_MEDIA, NULL, NULL, NULL, MEDIA_SVC_DB_VIEW_MEDIA);
 508         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 509         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TRIGGER_FOLDER, event_table_name, MEDIA_SVC_DB_TABLE_FOLDER, NULL);
 510         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 511         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_TRIGGER_PLAYLIST_MAP, event_table_name, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, NULL);
 512         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 513         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_TRIGGER_PLAYLIST_MAP1, MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_VIEW_PLAYLIST);
 514         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 515         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_TRIGGER_ALBUM, event_table_name, MEDIA_SVC_DB_TABLE_ALBUM, NULL);
 516         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 517         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_TRIGGER_TAG_MAP, event_table_name, MEDIA_SVC_DB_TABLE_TAG_MAP, NULL);
 518         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 519         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_TRIGGER_TAG_MAP1, MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_VIEW_TAG);
 520         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 521         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_TRIGGER_BOOKMARK, event_table_name, MEDIA_SVC_DB_TABLE_BOOKMARK, NULL);
 522         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 523         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_STORAGE, NULL, NULL, NULL, NULL);
 524         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 525         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_TRIGGER_FACE_SCAN_LIST, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, NULL);
 526         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 527         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_FACE, MEDIA_SVC_DB_TRIGGER_FACE, MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_TABLE_FACE, NULL);
 528         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 529
 530         /*insert column info.. */
 531         /*media*/
 532         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_id", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V2, NULL, false, false, true);
 533         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 534         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
 535         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 536         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_display_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, "media_file_name_idx", false, false, true);
 537         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 538         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, true);
 539         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 540         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_mime_type", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 541         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 542         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_size", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 543         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 544         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_added_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 545         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 546         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, "media_modified_time_idx", false, false, true);
 547         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 548         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "folder_id", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, "folder_uuid_idx", false, false, false);
 549         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 550         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 551         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 552         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_title", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 553         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 554         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_id", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, false);
 555         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 556         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_album", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 557         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 558         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 559         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 560         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_album_artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 561         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 562         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_genre", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 563         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 564         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_composer", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 565         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 566         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_year", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 567         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 568         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_recorded_date", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 569         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 570         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_copyright", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 571         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 572         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_track_num", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 573         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 574         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_description", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 575         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 576         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_bitrate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 577         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 578         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_bitpersample", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, true);
 579         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 580         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_samplerate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 581         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 582         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_channel", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 583         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 584         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_duration", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 585         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 586         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_longitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
 587         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 588         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_latitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
 589         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 590         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_altitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
 591         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 592         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "exposure_time", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, true);
 593         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 594         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "fnumber", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V4, NULL, false, false, true);
 595         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 596         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "iso", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V4, NULL, false, false, true);
 597         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 598         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "model", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, true);
 599         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 600         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_width", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 601         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 602         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_height", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 603         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 604         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_datetaken", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 605         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 606         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 607         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 608         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_rating", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 609         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 610         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_favourite", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 611         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 612         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_is_drm", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 613         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 614         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, true);
 615         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 616         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_timeline", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, "media_timeline_idx", false, false, true);
 617         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 618         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "sync_status", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 619         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 620         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_file_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 621         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 622         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_title_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 623         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 624         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_album_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 625         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 626         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 627         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 628         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_album_artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 629         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 630         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_genre_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 631         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 632         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_composer_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 633         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 634         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_copyright_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 635         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 636         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_description_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 637         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 638         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "age_rating_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 639         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 640         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "keyword_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 641         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 642         /* storage_uuid column is added in DB v4. When doing DB upgrade to v4, if storage_uuid is NOT NULL, alter table failed. */
 643         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, true);
 644         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 645         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", USER_V2, NULL, false, false, false);
 646         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 647         /* color column is added with dcm. (DB v5) */
 648         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_360", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V5, NULL, false, false, true);
 649         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 650
 651         /*folder*/
 652         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_id", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V2, NULL, false, false, false);
 653         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 654         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, false, false);
 655         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 656         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, false, false, false);
 657         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 658         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, false);
 659         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 660         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 661         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 662         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, false);
 663         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 664         /* storage_uuid column is added in DB v4. When doing DB upgrade to v4, if storage_uuid is NOT NULL, alter table failed. */
 665         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, true, false, false);
 666         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 667         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", USER_V4, NULL, false, false, false);
 668         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 669
 670         /*playlist_map*/
 671         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, false, true);
 672         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 673         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "playlist_id", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, false, false, false);
 674         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 675         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "media_id", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, false, true, false);
 676         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 677         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "playlist_member_order", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, false, false, true);
 678         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 679
 680         /*playlist*/
 681         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "playlist_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, true, true);
 682         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 683         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "playlist_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
 684         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 685         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 686         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 687
 688         /*album*/
 689         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "album_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, true, false);
 690         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 691         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, false, false, false);
 692         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 693         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 694         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 695         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_ALBUM], "album_art", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 696         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 697
 698         /*tag_map*/
 699         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, false, true);
 700         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 701         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "tag_id", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, true, false, false);
 702         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 703         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "media_id", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, true, false);
 704         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 705
 706         /*tag*/
 707         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "tag_id ", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, true, true);
 708         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 709         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "tag_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
 710         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 711
 712         /*bookmark*/
 713         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "bookmark_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V2, NULL, false, false, false);
 714         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 715         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "media_id", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, true, false);
 716         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 717         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "bookmark_marked_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, true, false, false);
 718         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 719         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "bookmark_thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 720         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 721         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "bookmark_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V6, NULL, false, false, false);
 722         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 723
 724         /*storage*/
 725         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_id", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V3, NULL, false, false, false);
 726         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 727         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V3, NULL, false, false, false);
 728         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 729         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_type", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, false);
 730         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 731         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "validity", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 1", USER_V3, NULL, false, false, false);
 732         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 733
 734         /*face scan list*/
 735         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE_SCAN_LIST], "media_id", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V4, NULL, false, true, false);
 736         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 737         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE_SCAN_LIST], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V6, NULL, false, false, false);
 738         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 739
 740         /*face*/
 741         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "media_face_id", MEDIA_SVC_DB_TYPE_INT, "PRIMARY KEY AUTOINCREMENT", USER_V4, NULL, false, false, false);
 742         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 743         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "media_id", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V4, NULL, true, true, false);
 744         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 745         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_x", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, true, false, false);
 746         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 747         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_y", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, true, false, false);
 748         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 749         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_w", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, true, false, false);
 750         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 751         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_h", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, true, false, false);
 752         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 753         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, false, false, false);
 754         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 755         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "media_face_tag", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, false);
 756         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 757
 758         return ret;
 759 }
 760 void __media_svc_table_free(table_info_s *tb)
 761 {
 762         SAFE_FREE(tb->trigger_name);
 763         SAFE_FREE(tb->view_name);
 764         SAFE_FREE(tb->event_table);
 765         SAFE_FREE(tb->action_table);
 766         SAFE_FREE(tb);
 767 }
 768
 769 void __media_svc_column_free(column_info_s *col)
 770 {
 771         SAFE_FREE(col->name);
 772         SAFE_FREE(col->type);
 773         SAFE_FREE(col->option);
 774         SAFE_FREE(col->index_name);
 775         SAFE_FREE(col);
 776 }
 777
 778 void _media_svc_destroy_table_query()
 779 {
 780         int i = 0;
 781         table_info_s *tb = NULL;
 782         column_info_s *col_ptr = NULL;
 783         int len = 0;
 784
 785         /* Table Free */
 786         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_MEDIA);
 787         __media_svc_table_free(tb);
 788         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_MEDIA);
 789
 790         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_FOLDER);
 791         __media_svc_table_free(tb);
 792         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_FOLDER);
 793
 794         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_PLAYLIST);
 795         __media_svc_table_free(tb);
 796         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_PLAYLIST);
 797
 798         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
 799         __media_svc_table_free(tb);
 800         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
 801
 802         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_ALBUM);
 803         __media_svc_table_free(tb);
 804         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_ALBUM);
 805
 806         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_TAG);
 807         __media_svc_table_free(tb);
 808         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_TAG);
 809
 810         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_TAG_MAP);
 811         __media_svc_table_free(tb);
 812         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_TAG_MAP);
 813
 814         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_BOOKMARK);
 815         __media_svc_table_free(tb);
 816         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_BOOKMARK);
 817
 818         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_STORAGE);
 819         __media_svc_table_free(tb);
 820         g_hash_table_remove(table, MEDIA_SVC_DB_TABLE_STORAGE);
 821
 822         g_hash_table_destroy(table);
 823
 824         /* Column Free */
 825         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 826
 827         for (i = 1; i < len; i++) {
 828                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 829                 __media_svc_column_free(col_ptr);
 830         }
 831
 832         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_FOLDER]);
 833
 834         for (i = 1; i < len; i++) {
 835                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_FOLDER], i);
 836                 __media_svc_column_free(col_ptr);
 837         }
 838
 839         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
 840
 841         for (i = 1; i < len; i++) {
 842                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
 843                 __media_svc_column_free(col_ptr);
 844         }
 845
 846         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
 847
 848         for (i = 1; i < len; i++) {
 849                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 850                 __media_svc_column_free(col_ptr);
 851         }
 852
 853         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_ALBUM]);
 854
 855         for (i = 1; i < len; i++) {
 856                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_ALBUM], i);
 857                 __media_svc_column_free(col_ptr);
 858         }
 859
 860         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
 861
 862         for (i = 1; i < len; i++) {
 863                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
 864                 __media_svc_column_free(col_ptr);
 865         }
 866
 867         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 868
 869         for (i = 1; i < len; i++) {
 870                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 871                 __media_svc_column_free(col_ptr);
 872         }
 873
 874         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_BOOKMARK]);
 875
 876         for (i = 1; i < len; i++) {
 877                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_BOOKMARK], i);
 878                 __media_svc_column_free(col_ptr);
 879         }
 880
 881         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_STORAGE]);
 882
 883         for (i = 1; i < len; i++) {
 884                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_STORAGE], i);
 885                 __media_svc_column_free(col_ptr);
 886         }
 887
 888         for (i = 0; i < MEDIA_SVC_DB_LIST_MAX; i++)
 889                 g_slist_free(column_list[i]);
 890
 891 }
 892
 893 static int __media_svc_db_upgrade(sqlite3 *db_handle, int cur_version, uid_t uid)
 894 {
 895         int ret = MS_MEDIA_ERR_NONE;
 896         char *sql = NULL;
 897
 898         media_svc_debug_fenter();
 899
 900         ret = _media_svc_init_table_query(MEDIA_SVC_DB_TABLE_MEDIA);
 901         if (ret != MS_MEDIA_ERR_NONE) {
 902                  media_svc_error("Query initialization failed");
 903                 goto ERROR;
 904         }
 905
 906         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_LIST_MEDIA, uid);
 907         if (ret != MS_MEDIA_ERR_NONE) {
 908                  media_svc_error("_media_svc_upgrade_table_query failed");
 909                 goto ERROR;
 910         }
 911
 912         /* Upgrade issue in folder table tizen 2.3(unique:path, name, storage_type) to 2.4(unique:path, name, storage_uuid) */
 913         if (cur_version < USER_V4) {
 914                 /* Create tmp table */
 915                 sql = sqlite3_mprintf("CREATE TABLE '%q' AS SELECT * FROM '%q';", MEDIA_SVC_DB_TABLE_TMP_TABLE, MEDIA_SVC_DB_TABLE_FOLDER);
 916                 if (sql == NULL) {
 917                          media_svc_error("_media_svc_upgrade_table_query failed");
 918                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 919                         goto ERROR;
 920                 }
 921
 922                 ret = _media_svc_sql_query(sql, uid);
 923                 if (ret != MS_MEDIA_ERR_NONE)
 924                         media_svc_error("Error when create backup folder table");
 925                 SQLITE3_SAFE_FREE(sql);
 926
 927                 /* Drop original table */
 928                 sql = sqlite3_mprintf("DROP TABLE '%q';", MEDIA_SVC_DB_TABLE_FOLDER);
 929                 if (sql == NULL) {
 930                          media_svc_error("_media_svc_upgrade_table_query failed");
 931                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 932                         goto ERROR;
 933                 }
 934
 935                 ret = _media_svc_sql_query(sql, uid);
 936                 if (ret != MS_MEDIA_ERR_NONE)
 937                         media_svc_error("Error when drop table");
 938                 SQLITE3_SAFE_FREE(sql);
 939
 940                 /* Create new table */
 941                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
 942                 if (ret != MS_MEDIA_ERR_NONE) {
 943                          media_svc_error("_media_svc_make_table_query failed");
 944                         goto ERROR;
 945                 }
 946
 947                 /* Insert into new table */
 948                 sql = sqlite3_mprintf("INSERT INTO '%q'(folder_uuid, path, name, modified_time, name_pinyin, storage_type) SELECT folder_uuid, path, name, modified_time, name_pinyin, storage_type FROM '%q';", MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_TMP_TABLE);
 949                 if (sql == NULL) {
 950                          media_svc_error("Query creation failed");
 951                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 952                         goto ERROR;
 953                 }
 954
 955                 ret = _media_svc_sql_query(sql, uid);
 956                 if (ret != MS_MEDIA_ERR_NONE)
 957                         media_svc_error("Error when backup folder table");
 958                 SQLITE3_SAFE_FREE(sql);
 959
 960                 /* Drop tmp table*/
 961                 sql = sqlite3_mprintf("DROP TABLE '%q';", MEDIA_SVC_DB_TABLE_TMP_TABLE);
 962                 if (sql == NULL) {
 963                          media_svc_error("Query creation failed");
 964                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
 965                         goto ERROR;
 966                 }
 967
 968                 ret = _media_svc_sql_query(sql, uid);
 969                 if (ret != MS_MEDIA_ERR_NONE)
 970                         media_svc_error("Error when drop backup folder table");
 971                 SQLITE3_SAFE_FREE(sql);
 972
 973         } else {
 974                 ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
 975                 if (ret != MS_MEDIA_ERR_NONE) {
 976                          media_svc_error("_media_svc_upgrade_table_query failed");
 977                         goto ERROR;
 978                 }
 979         }
 980
 981         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
 982         if (ret != MS_MEDIA_ERR_NONE) {
 983                  media_svc_error("_media_svc_upgrade_table_query failed");
 984                 goto ERROR;
 985         }
 986
 987         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_LIST_PLAYLIST, uid);
 988         if (ret != MS_MEDIA_ERR_NONE) {
 989                  media_svc_error("_media_svc_upgrade_table_query failed");
 990                 goto ERROR;
 991         }
 992
 993         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_LIST_ALBUM, uid);
 994         if (ret != MS_MEDIA_ERR_NONE) {
 995                  media_svc_error("_media_svc_upgrade_table_query failed");
 996                 goto ERROR;
 997         }
 998
 999         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_LIST_TAG_MAP, uid);
1000         if (ret != MS_MEDIA_ERR_NONE) {
1001                  media_svc_error("_media_svc_upgrade_table_query failed");
1002                 goto ERROR;
1003         }
1004
1005         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_LIST_TAG, uid);
1006         if (ret != MS_MEDIA_ERR_NONE) {
1007                  media_svc_error("_media_svc_upgrade_table_query failed");
1008                 goto ERROR;
1009         }
1010
1011         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_LIST_BOOKMARK, uid);
1012         if (ret != MS_MEDIA_ERR_NONE) {
1013                  media_svc_error("_media_svc_upgrade_table_query failed");
1014                 goto ERROR;
1015         }
1016
1017         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
1018         if (ret != MS_MEDIA_ERR_NONE) {
1019                  media_svc_error("_media_svc_upgrade_table_query failed");
1020                 goto ERROR;
1021         }
1022
1023         if (cur_version < USER_V4) {
1024                 /* Need to default value in storage_uuid */
1025                 sql = sqlite3_mprintf("UPDATE %q SET storage_uuid = '%q';", MEDIA_SVC_DB_TABLE_MEDIA, "media");
1026                 if (sql == NULL) {
1027                          media_svc_error("Query creation failed");
1028                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1029                         goto ERROR;
1030                 }
1031
1032                 ret = _media_svc_sql_query(sql, uid);
1033                 SQLITE3_SAFE_FREE(sql);
1034
1035                 sql = sqlite3_mprintf("UPDATE %q SET storage_uuid = '%q';", MEDIA_SVC_DB_TABLE_FOLDER, "media");
1036                 if (sql == NULL) {
1037                          media_svc_error("Query creation failed");
1038                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1039                         goto ERROR;
1040                 }
1041
1042                 ret = _media_svc_sql_query(sql, uid);
1043                 SQLITE3_SAFE_FREE(sql);
1044         }
1045
1046         /* Upgrade issue tizen 3.0 to 4.0 */
1047         if (cur_version < USER_V6) {
1048                 /******Upgrade Storage Table******/
1049                 /* remove  "storage_account" column */
1050                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME TO %q;", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1051                 if (sql == NULL) {
1052                          media_svc_error("Query creation failed");
1053                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1054                         goto ERROR;
1055                 }
1056
1057                 ret = _media_svc_sql_query(sql, uid);
1058                 SQLITE3_SAFE_FREE(sql);
1059                 if (ret != MS_MEDIA_ERR_NONE) {
1060                          media_svc_error("_media_svc_sql_query failed");
1061                         goto ERROR;
1062                 }
1063
1064                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
1065                 if (ret != MS_MEDIA_ERR_NONE) {
1066                          media_svc_error("_media_svc_make_table_query failed");
1067                         goto ERROR;
1068                 }
1069
1070                 sql = sqlite3_mprintf("INSERT INTO %q (storage_uuid, storage_name, storage_path, storage_type, scan_status, validity) SELECT storage_uuid, storage_name, storage_path, storage_type, scan_status, validity FROM %q;", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1071                 if (sql == NULL) {
1072                          media_svc_error("Query creation failed");
1073                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1074                         goto ERROR;
1075                 }
1076
1077                 ret = _media_svc_sql_query(sql, uid);
1078                 SQLITE3_SAFE_FREE(sql);
1079                 if (ret != MS_MEDIA_ERR_NONE) {
1080                          media_svc_error("_media_svc_sql_query failed");
1081                         goto ERROR;
1082                 }
1083
1084                 sql = sqlite3_mprintf("DROP TABLE %q;", MEDIA_SVC_DB_TABLE_TMP_TABLE);
1085                 if (sql == NULL) {
1086                          media_svc_error("Query creation failed");
1087                          ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1088                         goto ERROR;
1089                 }
1090
1091                 ret = _media_svc_sql_query(sql, uid);
1092                 SQLITE3_SAFE_FREE(sql);
1093                 if (ret != MS_MEDIA_ERR_NONE) {
1094                          media_svc_error("_media_svc_sql_query failed");
1095                         goto ERROR;
1096                 }
1097
1098                 /******Upgrade Folder Table******/
1099                 /* remove  "parent_folder_uuid" column */
1100                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME TO %q;", MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1101                 if (sql == NULL) {
1102                         media_svc_error("Query creation failed");
1103                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1104                         goto ERROR;
1105                 }
1106
1107                 ret = _media_svc_sql_query(sql, uid);
1108                 SQLITE3_SAFE_FREE(sql);
1109                 if (ret != MS_MEDIA_ERR_NONE) {
1110                         media_svc_error("_media_svc_sql_query failed");
1111                         goto ERROR;
1112                 }
1113
1114                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
1115                 if (ret != MS_MEDIA_ERR_NONE) {
1116                         media_svc_error("_media_svc_make_table_query failed");
1117                         goto ERROR;
1118                 }
1119
1120                 sql = sqlite3_mprintf("INSERT INTO %q (folder_uuid, path, name, modified_time, name_pinyin, storage_type, storage_uuid, folder_order, validity, scan_status) SELECT folder_uuid, path, name, modified_time, name_pinyin, storage_type, storage_uuid, folder_order, validity, scan_status FROM %q;", MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1121                 if (sql == NULL) {
1122                         media_svc_error("Query creation failed");
1123                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1124                         goto ERROR;
1125                 }
1126
1127                 ret = _media_svc_sql_query(sql, uid);
1128                 SQLITE3_SAFE_FREE(sql);
1129                 if (ret != MS_MEDIA_ERR_NONE) {
1130                         media_svc_error("_media_svc_sql_query failed");
1131                         goto ERROR;
1132                 }
1133
1134                 sql = sqlite3_mprintf("DROP TABLE %q;", MEDIA_SVC_DB_TABLE_TMP_TABLE);
1135                 if (sql == NULL) {
1136                         media_svc_error("Query creation failed");
1137                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1138                         goto ERROR;
1139                 }
1140
1141                 ret = _media_svc_sql_query(sql, uid);
1142                 SQLITE3_SAFE_FREE(sql);
1143                 if (ret != MS_MEDIA_ERR_NONE) {
1144                         media_svc_error("_media_svc_sql_query failed");
1145                         goto ERROR;
1146                 }
1147
1148                 /******Upgrade Face Table******/
1149                 sql = sqlite3_mprintf("DROP TABLE %q; DROP TABLE %q; ", MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_TABLE_FACE);
1150                 if (sql == NULL) {
1151                         media_svc_error("Query creation failed");
1152                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1153                         goto ERROR;
1154                 }
1155
1156                 ret = _media_svc_sql_query(sql, uid);
1157                 SQLITE3_SAFE_FREE(sql);
1158                 if (ret != MS_MEDIA_ERR_NONE) {
1159                         media_svc_error("_media_svc_sql_query failed");
1160                         goto ERROR;
1161                 }
1162
1163                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_LIST_FACE_SCAN_LIST, uid);
1164                 if (ret != MS_MEDIA_ERR_NONE) {
1165                         media_svc_error("_media_svc_make_table_query failed");
1166                         goto ERROR;
1167                 }
1168
1169                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FACE, MEDIA_SVC_DB_LIST_FACE, uid);
1170                 if (ret != MS_MEDIA_ERR_NONE) {
1171                         media_svc_error("_media_svc_make_table_query failed");
1172                         goto ERROR;
1173                 }
1174
1175         }
1176
1177         /* Upgrade issue tizen 4.0 to 5.0 */
1178         if (cur_version < USER_V7) {
1179                 /******Upgrade Folder Table******/
1180                 /* remove  "scan_status" column */
1181                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME TO %q;", MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1182                 if (sql == NULL) {
1183                         media_svc_error("Query creation failed");
1184                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1185                         goto ERROR;
1186                 }
1187
1188                 ret = _media_svc_sql_query(sql, uid);
1189                 SQLITE3_SAFE_FREE(sql);
1190                 if (ret != MS_MEDIA_ERR_NONE) {
1191                         media_svc_error("_media_svc_sql_query failed");
1192                         goto ERROR;
1193                 }
1194
1195                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
1196                 if (ret != MS_MEDIA_ERR_NONE) {
1197                         media_svc_error("_media_svc_make_table_query failed");
1198                         goto ERROR;
1199                 }
1200
1201                 sql = sqlite3_mprintf("INSERT INTO %q (folder_uuid, path, name, modified_time, name_pinyin, storage_type, storage_uuid, folder_order, validity) SELECT folder_uuid, path, name, modified_time, name_pinyin, storage_type, storage_uuid, folder_order, validity FROM %q;", MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1202                 if (sql == NULL) {
1203                         media_svc_error("Query creation failed");
1204                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1205                         goto ERROR;
1206                 }
1207
1208                 ret = _media_svc_sql_query(sql, uid);
1209                 SQLITE3_SAFE_FREE(sql);
1210                 if (ret != MS_MEDIA_ERR_NONE) {
1211                         media_svc_error("_media_svc_sql_query failed");
1212                         goto ERROR;
1213                 }
1214
1215                 sql = sqlite3_mprintf("DROP TABLE %q;", MEDIA_SVC_DB_TABLE_TMP_TABLE);
1216                 if (sql == NULL) {
1217                         media_svc_error("Query creation failed");
1218                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1219                         goto ERROR;
1220                 }
1221
1222                 ret = _media_svc_sql_query(sql, uid);
1223                 SQLITE3_SAFE_FREE(sql);
1224                 if (ret != MS_MEDIA_ERR_NONE) {
1225                         media_svc_error("_media_svc_sql_query failed");
1226                         goto ERROR;
1227                 }
1228
1229
1230                 /******Upgrade Storage Table******/
1231                 /* remove  "scan_status", "storage_name" column */
1232                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME TO %q;", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1233                 if (sql == NULL) {
1234                         media_svc_error("Query creation failed");
1235                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1236                         goto ERROR;
1237                 }
1238
1239                 ret = _media_svc_sql_query(sql, uid);
1240                 SQLITE3_SAFE_FREE(sql);
1241                 if (ret != MS_MEDIA_ERR_NONE) {
1242                         media_svc_error("_media_svc_sql_query failed");
1243                         goto ERROR;
1244                 }
1245
1246                 ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
1247                 if (ret != MS_MEDIA_ERR_NONE) {
1248                          media_svc_error("_media_svc_make_table_query failed");
1249                         goto ERROR;
1250                 }
1251
1252                 sql = sqlite3_mprintf("INSERT INTO %q (storage_uuid, storage_path, storage_type, validity) SELECT storage_uuid, storage_path, storage_type, validity FROM %q;", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_TMP_TABLE);
1253                 if (sql == NULL) {
1254                         media_svc_error("Query creation failed");
1255                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1256                         goto ERROR;
1257                 }
1258
1259                 ret = _media_svc_sql_query(sql, uid);
1260                 SQLITE3_SAFE_FREE(sql);
1261                 if (ret != MS_MEDIA_ERR_NONE) {
1262                         media_svc_error("_media_svc_sql_query failed");
1263                         goto ERROR;
1264                 }
1265
1266                 sql = sqlite3_mprintf("DROP TABLE %q;", MEDIA_SVC_DB_TABLE_TMP_TABLE);
1267                 if (sql == NULL) {
1268                         media_svc_error("Query creation failed");
1269                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1270                         goto ERROR;
1271                 }
1272
1273                 ret = _media_svc_sql_query(sql, uid);
1274                 SQLITE3_SAFE_FREE(sql);
1275                 if (ret != MS_MEDIA_ERR_NONE) {
1276                         media_svc_error("_media_svc_sql_query failed");
1277                         goto ERROR;
1278                 }
1279         }
1280
1281         /* Upgrade issue tizen 5.0 to 5.5 */
1282         if (cur_version < USER_V8) {
1283                 /*Drop view first*/
1284                 sql = sqlite3_mprintf("DROP VIEW IF EXISTS %q;DROP VIEW IF EXISTS %q;DROP VIEW IF EXISTS %q",
1285                         MEDIA_SVC_DB_VIEW_PLAYLIST, MEDIA_SVC_DB_VIEW_TAG, MEDIA_SVC_DB_VIEW_MEDIA);
1286                 if (sql == NULL) {
1287                         media_svc_error("Query creation failed");
1288                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1289                         goto ERROR;
1290                 }
1291
1292                 ret = _media_svc_sql_query(sql, uid);
1293                 SQLITE3_SAFE_FREE(sql);
1294                 if (ret != MS_MEDIA_ERR_NONE) {
1295                         media_svc_error("_media_svc_sql_query failed");
1296                         goto ERROR;
1297                 }
1298
1299                 /*playlist */
1300                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN play_order TO playlist_member_order;\
1301                         ALTER TABLE %q RENAME COLUMN name TO playlist_name;\
1302                         ALTER TABLE %q RENAME COLUMN media_uuid TO media_id;",
1303                         MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
1304                 if (sql == NULL) {
1305                         media_svc_error("Query creation failed");
1306                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1307                         goto ERROR;
1308                 }
1309
1310                 ret = _media_svc_sql_query(sql, uid);
1311                 SQLITE3_SAFE_FREE(sql);
1312                 if (ret != MS_MEDIA_ERR_NONE) {
1313                         media_svc_error("_media_svc_sql_query failed");
1314                         goto ERROR;
1315                 }
1316
1317                 /*tag */
1318                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN name TO tag_name;\
1319                         ALTER TABLE %q RENAME COLUMN media_uuid TO media_id;",
1320                         MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_TABLE_TAG_MAP);
1321                 if (sql == NULL) {
1322                         media_svc_error("Query creation failed");
1323                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1324                         goto ERROR;
1325                 }
1326
1327                 ret = _media_svc_sql_query(sql, uid);
1328                 SQLITE3_SAFE_FREE(sql);
1329                 if (ret != MS_MEDIA_ERR_NONE) {
1330                         media_svc_error("_media_svc_sql_query failed");
1331                         goto ERROR;
1332                 }
1333
1334                 /*face */
1335                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN face_id TO media_face_id;\
1336                         ALTER TABLE %q RENAME COLUMN orientation TO face_orientation;\
1337                         ALTER TABLE %q RENAME COLUMN face_tag TO media_face_tag;\
1338                         ALTER TABLE %q RENAME COLUMN media_uuid TO media_id;\
1339                         ALTER TABLE %q RENAME COLUMN media_uuid TO media_id;",
1340                         MEDIA_SVC_DB_TABLE_FACE, MEDIA_SVC_DB_TABLE_FACE, MEDIA_SVC_DB_TABLE_FACE,
1341                         MEDIA_SVC_DB_TABLE_FACE_SCAN_LIST, MEDIA_SVC_DB_TABLE_FACE);
1342                 if (sql == NULL) {
1343                         media_svc_error("Query creation failed");
1344                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1345                         goto ERROR;
1346                 }
1347
1348                 ret = _media_svc_sql_query(sql, uid);
1349                 SQLITE3_SAFE_FREE(sql);
1350                 if (ret != MS_MEDIA_ERR_NONE) {
1351                         media_svc_error("_media_svc_sql_query failed");
1352                         goto ERROR;
1353                 }
1354
1355                 /*bookmark */
1356                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN marked_time TO bookmark_marked_time;\
1357                         ALTER TABLE %q RENAME COLUMN name TO bookmark_name;\
1358                         ALTER TABLE %q RENAME COLUMN thumbnail_path TO bookmark_thumbnail_path;\
1359                         ALTER TABLE %q RENAME COLUMN media_uuid TO media_id;",
1360                         MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_TABLE_BOOKMARK,
1361                         MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_TABLE_BOOKMARK);
1362                 if (sql == NULL) {
1363                         media_svc_error("Query creation failed");
1364                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1365                         goto ERROR;
1366                 }
1367
1368                 ret = _media_svc_sql_query(sql, uid);
1369                 SQLITE3_SAFE_FREE(sql);
1370                 if (ret != MS_MEDIA_ERR_NONE) {
1371                         media_svc_error("_media_svc_sql_query failed");
1372                         goto ERROR;
1373                 }
1374
1375                 /*folder */
1376                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN modified_time TO folder_modified_time;\
1377                         ALTER TABLE %q RENAME COLUMN path TO folder_path;\
1378                         ALTER TABLE %q RENAME COLUMN name TO folder_name;\
1379                         ALTER TABLE %q RENAME COLUMN name_pinyin TO folder_name_pinyin;\
1380                         ALTER TABLE %q RENAME COLUMN storage_type TO folder_storage_type;\
1381                         ALTER TABLE %q RENAME COLUMN folder_uuid TO folder_id;",
1382                         MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER,
1383                         MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_TABLE_FOLDER);
1384                 if (sql == NULL) {
1385                         media_svc_error("Query creation failed");
1386                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1387                         goto ERROR;
1388                 }
1389
1390                 ret = _media_svc_sql_query(sql, uid);
1391                 SQLITE3_SAFE_FREE(sql);
1392                 if (ret != MS_MEDIA_ERR_NONE) {
1393                         media_svc_error("_media_svc_sql_query failed");
1394                         goto ERROR;
1395                 }
1396
1397                 /*storage */
1398                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN storage_uuid TO storage_id;",
1399                         MEDIA_SVC_DB_TABLE_STORAGE);
1400                 if (sql == NULL) {
1401                         media_svc_error("Query creation failed");
1402                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1403                         goto ERROR;
1404                 }
1405
1406                 ret = _media_svc_sql_query(sql, uid);
1407                 SQLITE3_SAFE_FREE(sql);
1408                 if (ret != MS_MEDIA_ERR_NONE) {
1409                         media_svc_error("_media_svc_sql_query failed");
1410                         goto ERROR;
1411                 }
1412
1413                 /*media */
1414                 sql = sqlite3_mprintf("ALTER TABLE %q RENAME COLUMN file_name_pinyin TO media_file_name_pinyin;\
1415                         ALTER TABLE %q RENAME COLUMN title_pinyin TO media_title_pinyin;\
1416                         ALTER TABLE %q RENAME COLUMN album_pinyin TO media_album_pinyin;\
1417                         ALTER TABLE %q RENAME COLUMN artist_pinyin TO media_artist_pinyin;\
1418                         ALTER TABLE %q RENAME COLUMN album_artist_pinyin TO media_album_artist_pinyin;\
1419                         ALTER TABLE %q RENAME COLUMN genre_pinyin TO media_genre_pinyin;\
1420                         ALTER TABLE %q RENAME COLUMN composer_pinyin TO media_composer_pinyin;\
1421                         ALTER TABLE %q RENAME COLUMN copyright_pinyin TO media_copyright_pinyin;\
1422                         ALTER TABLE %q RENAME COLUMN description_pinyin TO media_description_pinyin;\
1423                         ALTER TABLE %q RENAME COLUMN folder_uuid TO folder_id;\
1424                         ALTER TABLE %q RENAME COLUMN media_uuid TO media_id;\
1425                         ALTER TABLE %q RENAME COLUMN path TO media_path;\
1426                         ALTER TABLE %q RENAME COLUMN file_name TO media_display_name;\
1427                         ALTER TABLE %q RENAME COLUMN mime_type TO media_mime_type;\
1428                         ALTER TABLE %q RENAME COLUMN size TO media_size;\
1429                         ALTER TABLE %q RENAME COLUMN added_time TO media_added_time;\
1430                         ALTER TABLE %q RENAME COLUMN modified_time TO media_modified_time;\
1431                         ALTER TABLE %q RENAME COLUMN thumbnail_path TO media_thumbnail_path;\
1432                         ALTER TABLE %q RENAME COLUMN title TO media_title;\
1433                         ALTER TABLE %q RENAME COLUMN album TO media_album;\
1434                         ALTER TABLE %q RENAME COLUMN artist TO media_artist;\
1435                         ALTER TABLE %q RENAME COLUMN album_artist TO media_album_artist;\
1436                         ALTER TABLE %q RENAME COLUMN genre TO media_genre;\
1437                         ALTER TABLE %q RENAME COLUMN composer TO media_composer;\
1438                         ALTER TABLE %q RENAME COLUMN year TO media_year;\
1439                         ALTER TABLE %q RENAME COLUMN recorded_date TO media_recorded_date;\
1440                         ALTER TABLE %q RENAME COLUMN copyright TO media_copyright;\
1441                         ALTER TABLE %q RENAME COLUMN track_num TO media_track_num;\
1442                         ALTER TABLE %q RENAME COLUMN description TO media_description;\
1443                         ALTER TABLE %q RENAME COLUMN bitrate TO media_bitrate;\
1444                         ALTER TABLE %q RENAME COLUMN bitpersample TO media_bitpersample;\
1445                         ALTER TABLE %q RENAME COLUMN samplerate TO media_samplerate;\
1446                         ALTER TABLE %q RENAME COLUMN channel TO media_channel;\
1447                         ALTER TABLE %q RENAME COLUMN duration TO media_duration;\
1448                         ALTER TABLE %q RENAME COLUMN longitude TO media_longitude;\
1449                         ALTER TABLE %q RENAME COLUMN latitude TO media_latitude;\
1450                         ALTER TABLE %q RENAME COLUMN altitude TO media_altitude;\
1451                         ALTER TABLE %q RENAME COLUMN width TO media_width;\
1452                         ALTER TABLE %q RENAME COLUMN height TO media_height;\
1453                         ALTER TABLE %q RENAME COLUMN datetaken TO media_datetaken;\
1454                         ALTER TABLE %q RENAME COLUMN orientation TO media_orientation;\
1455                         ALTER TABLE %q RENAME COLUMN rating TO media_rating;\
1456                         ALTER TABLE %q RENAME COLUMN favourite TO media_favourite;\
1457                         ALTER TABLE %q RENAME COLUMN is_drm TO media_is_drm;\
1458                         ALTER TABLE %q RENAME COLUMN storage_type TO media_storage_type;\
1459                         ALTER TABLE %q RENAME COLUMN timeline TO media_timeline;\
1460                         ALTER TABLE %q RENAME COLUMN is_360 TO media_360;",
1461                         MEDIA_SVC_DB_TABLE_MEDIA,
1462                         MEDIA_SVC_DB_TABLE_MEDIA,
1463                         MEDIA_SVC_DB_TABLE_MEDIA,
1464                         MEDIA_SVC_DB_TABLE_MEDIA,
1465                         MEDIA_SVC_DB_TABLE_MEDIA,
1466                         MEDIA_SVC_DB_TABLE_MEDIA,
1467                         MEDIA_SVC_DB_TABLE_MEDIA,
1468                         MEDIA_SVC_DB_TABLE_MEDIA,
1469                         MEDIA_SVC_DB_TABLE_MEDIA,
1470                         MEDIA_SVC_DB_TABLE_MEDIA,
1471                         MEDIA_SVC_DB_TABLE_MEDIA,
1472                         MEDIA_SVC_DB_TABLE_MEDIA,
1473                         MEDIA_SVC_DB_TABLE_MEDIA,
1474                         MEDIA_SVC_DB_TABLE_MEDIA,
1475                         MEDIA_SVC_DB_TABLE_MEDIA,
1476                         MEDIA_SVC_DB_TABLE_MEDIA,
1477                         MEDIA_SVC_DB_TABLE_MEDIA,
1478                         MEDIA_SVC_DB_TABLE_MEDIA,
1479                         MEDIA_SVC_DB_TABLE_MEDIA,
1480                         MEDIA_SVC_DB_TABLE_MEDIA,
1481                         MEDIA_SVC_DB_TABLE_MEDIA,
1482                         MEDIA_SVC_DB_TABLE_MEDIA,
1483                         MEDIA_SVC_DB_TABLE_MEDIA,
1484                         MEDIA_SVC_DB_TABLE_MEDIA,
1485                         MEDIA_SVC_DB_TABLE_MEDIA,
1486                         MEDIA_SVC_DB_TABLE_MEDIA,
1487                         MEDIA_SVC_DB_TABLE_MEDIA,
1488                         MEDIA_SVC_DB_TABLE_MEDIA,
1489                         MEDIA_SVC_DB_TABLE_MEDIA,
1490                         MEDIA_SVC_DB_TABLE_MEDIA,
1491                         MEDIA_SVC_DB_TABLE_MEDIA,
1492                         MEDIA_SVC_DB_TABLE_MEDIA,
1493                         MEDIA_SVC_DB_TABLE_MEDIA,
1494                         MEDIA_SVC_DB_TABLE_MEDIA,
1495                         MEDIA_SVC_DB_TABLE_MEDIA,
1496                         MEDIA_SVC_DB_TABLE_MEDIA,
1497                         MEDIA_SVC_DB_TABLE_MEDIA,
1498                         MEDIA_SVC_DB_TABLE_MEDIA,
1499                         MEDIA_SVC_DB_TABLE_MEDIA,
1500                         MEDIA_SVC_DB_TABLE_MEDIA,
1501                         MEDIA_SVC_DB_TABLE_MEDIA,
1502                         MEDIA_SVC_DB_TABLE_MEDIA,
1503                         MEDIA_SVC_DB_TABLE_MEDIA,
1504                         MEDIA_SVC_DB_TABLE_MEDIA,
1505                         MEDIA_SVC_DB_TABLE_MEDIA,
1506                         MEDIA_SVC_DB_TABLE_MEDIA,
1507                         MEDIA_SVC_DB_TABLE_MEDIA);
1508                 if (sql == NULL) {
1509                         media_svc_error("Query creation failed");
1510                         ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1511                         goto ERROR;
1512                 }
1513
1514                 ret = _media_svc_sql_query(sql, uid);
1515                 SQLITE3_SAFE_FREE(sql);
1516                 if (ret != MS_MEDIA_ERR_NONE) {
1517                         media_svc_error("_media_svc_sql_query failed");
1518                         goto ERROR;
1519                 }
1520         }
1521
1522         /* Rebuilding view */
1523         ret = __media_svc_rebuild_view_query(db_handle, uid);
1524
1525         /* Update user version */
1526         sql = sqlite3_mprintf("PRAGMA user_version=%d;", LATEST_VERSION_NUMBER);
1527         if (sql == NULL) {
1528                 media_svc_error("Query creation failed");
1529                 ret = MS_MEDIA_ERR_OUT_OF_MEMORY;
1530                 goto ERROR;
1531         }
1532
1533         ret = _media_svc_sql_query(sql, uid);
1534         SQLITE3_SAFE_FREE(sql);
1535
1536         _media_svc_destroy_table_query();
1537
1538         media_svc_debug_fleave();
1539
1540         return ret;
1541
1542 ERROR:
1543         _media_svc_destroy_table_query();
1544
1545         return ret;
1546 }
1547
1548 int _media_svc_sql_query(const char *sql_str, uid_t uid)
1549 {
1550         return media_db_request_update_db(sql_str, uid);
1551 }
1552
1553 int _media_svc_sql_query_direct(const char *sql_str, uid_t uid)
1554 {
1555         int ret = MS_MEDIA_ERR_NONE;
1556         sqlite3 *handle = NULL;
1557
1558         ret = media_db_connect(&handle, uid, true);
1559         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "DB connection failed");
1560         ret = __media_svc_query_direct(handle, sql_str, uid);
1561         media_db_disconnect(handle);
1562
1563         return ret;
1564 }
1565
1566 int _media_svc_get_user_version(sqlite3 *db_handle, int *user_version)
1567 {
1568         int ret = MS_MEDIA_ERR_NONE;
1569         sqlite3_stmt *sql_stmt = NULL;
1570         char *sql = sqlite3_mprintf("PRAGMA user_version;");
1571
1572         ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
1573         if (ret != MS_MEDIA_ERR_NONE) {
1574                 media_svc_error("error when get user_version.");
1575                 return ret;
1576         }
1577
1578         *user_version = sqlite3_column_int(sql_stmt, 0);
1579         SQLITE3_FINALIZE(sql_stmt);
1580
1581         return MS_MEDIA_ERR_NONE;
1582 }
1583
1584 int _media_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3_stmt **stmt)
1585 {
1586         int err = -1;
1587
1588         media_svc_retvm_if(sql_str == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "invalid query");
1589
1590         if (handle == NULL) {
1591                 media_svc_error("handle is NULL");
1592                 sqlite3_free((char *)sql_str);
1593                 return MS_MEDIA_ERR_INVALID_PARAMETER;
1594         }
1595
1596         media_svc_sec_debug("Query[%s]", sql_str);
1597
1598         err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
1599         sqlite3_free((char *)sql_str);
1600
1601         if (err != SQLITE_OK) {
1602                 media_svc_error("prepare error %d[%s]", err, sqlite3_errmsg(handle));
1603                 if (err == SQLITE_CORRUPT)
1604                         return MS_MEDIA_ERR_DB_CORRUPT;
1605                 else if (err == SQLITE_PERM)
1606                         return MS_MEDIA_ERR_DB_PERMISSION;
1607
1608                 return MS_MEDIA_ERR_DB_INTERNAL;
1609         }
1610
1611         err = sqlite3_step(*stmt);
1612         if (err != SQLITE_ROW) {
1613                 media_svc_debug("No record");
1614                 SQLITE3_FINALIZE(*stmt);
1615                 return MS_MEDIA_ERR_DB_NO_RECORD;
1616         }
1617
1618         return MS_MEDIA_ERR_NONE;
1619 }
1620
1621 int _media_svc_sql_prepare_to_step_simple(sqlite3 *handle, const char *sql_str, sqlite3_stmt **stmt)
1622 {
1623         int err = -1;
1624
1625         media_svc_retvm_if(handle == NULL, MS_MEDIA_ERR_INVALID_PARAMETER, "handle is NULL");
1626
1627         media_svc_sec_debug("Query[%s]", sql_str);
1628
1629         if (!STRING_VALID(sql_str)) {
1630                 media_svc_error("invalid query");
1631                 return MS_MEDIA_ERR_INVALID_PARAMETER;
1632         }
1633
1634         err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
1635         sqlite3_free((char *)sql_str);
1636
1637         if (err != SQLITE_OK) {
1638                 media_svc_error("prepare error %d[%s]", err, sqlite3_errmsg(handle));
1639                 if (err == SQLITE_CORRUPT)
1640                         return MS_MEDIA_ERR_DB_CORRUPT;
1641                 else if (err == SQLITE_PERM)
1642                         return MS_MEDIA_ERR_DB_PERMISSION;
1643
1644                 return MS_MEDIA_ERR_DB_INTERNAL;
1645         }
1646
1647         return MS_MEDIA_ERR_NONE;
1648 }
1649
1650 int _media_svc_sql_begin_trans(uid_t uid)
1651 {
1652         int ret = MS_MEDIA_ERR_NONE;
1653
1654         media_svc_debug("Batch start(Transaction block version)");
1655
1656         ret = media_db_request_update_db_batch_start("BEGIN IMMEDIATE;", uid);
1657
1658         return ret;
1659 }
1660
1661 int _media_svc_sql_end_trans(uid_t uid)
1662 {
1663         int ret = MS_MEDIA_ERR_NONE;
1664
1665         media_svc_debug("Batch end(Transaction block version)");
1666
1667         ret = media_db_request_update_db_batch_end("COMMIT;", uid);
1668
1669         return ret;
1670 }
1671
1672 int _media_svc_sql_query_list(GList **query_list, uid_t uid)
1673 {
1674         int ret = MS_MEDIA_ERR_NONE;
1675         int idx = 0;
1676         int length = g_list_length(*query_list);
1677         char *sql = NULL;
1678         char query_bundle[MEDIA_SVC_QUERY_LEN_MAX] = {0, };
1679         int query_len = 0;
1680         int total_len = 0;
1681
1682         media_svc_debug("query list length : [%d]", length);
1683
1684         memset(query_bundle, 0, sizeof(query_bundle));
1685
1686         for (idx = 0; idx < length; idx++) {
1687                 sql = (char *)g_list_nth_data(*query_list, idx);
1688                 if (STRING_VALID(sql)) {
1689                         query_len = strlen(sql);
1690
1691                         if (query_len >= (sizeof(query_bundle) - 1)) {
1692                                 media_svc_error("NEED TO CHECK FILE : A single query size exceeds 8k [%d]", query_len);
1693                                 SQLITE3_SAFE_FREE(sql);
1694                                 continue;
1695                         }
1696
1697                         if ((total_len + query_len) >= (sizeof(query_bundle) - 1)) {
1698                                 ret = media_db_request_update_db_batch(query_bundle, uid);
1699                                 if (ret != MS_MEDIA_ERR_NONE)
1700                                         media_svc_error("media_db_request_update_db_batch failed : %d", ret);
1701
1702                                 memset(query_bundle, 0, sizeof(query_bundle));
1703                                 total_len = 0;
1704                                 /* NEED TO CHECK : If a single query size is over 8K, drop it. */
1705                                 /*                              Consider inserting the basic information without metadata */
1706                                 /* Refer : SQLITE3 spec In Tizen 3.0 */
1707                                 /* Single query limit size = 1 billion bytes(1GiB) */
1708                                 /* DB limit size = 1 billion bytes(1GiB) */
1709                                 /* column limit = 2000 */
1710                         }
1711
1712                         SAFE_STRLCAT(query_bundle, sql, sizeof(query_bundle));
1713                         total_len += query_len;
1714
1715                         SQLITE3_SAFE_FREE(sql);
1716                 }
1717         }
1718
1719         if (total_len > 0) {
1720                 ret = media_db_request_update_db_batch(query_bundle, uid);
1721                 if (ret != MS_MEDIA_ERR_NONE)
1722                         media_svc_error("media_db_request_update_db_batch failed : %d", ret);
1723
1724                 memset(query_bundle, 0, sizeof(query_bundle));
1725                 total_len = 0;
1726         }
1727
1728         _media_svc_sql_query_release(query_list);
1729
1730         return MS_MEDIA_ERR_NONE;
1731
1732 }
1733
1734 #define MAX_RETRY 9
1735 #define SLEEP_TIME 1000 * 1000
1736 static int __media_svc_query_direct(sqlite3 *handle, const char *query, uid_t uid)
1737 {
1738         int ret = MS_MEDIA_ERR_NONE;
1739         char *zErrMsg = NULL;
1740         int retry_count = 0;
1741
1742 EXEC_RETRY:
1743         ret = sqlite3_exec(handle, query, NULL, NULL, &zErrMsg);
1744         if (SQLITE_OK != ret) {
1745                 media_svc_sec_error("Error[%s],Query[%s]", zErrMsg, query);
1746                 SQLITE3_SAFE_FREE(zErrMsg);
1747                 if (ret == SQLITE_BUSY) {
1748                         ret = MS_MEDIA_ERR_DB_BUSY_FAIL;
1749                 } else if (ret == SQLITE_CONSTRAINT) {
1750                         ret = MS_MEDIA_ERR_DB_CONSTRAINT_FAIL;
1751                 } else if (ret == SQLITE_FULL) {
1752                         ret = MS_MEDIA_ERR_DB_FULL_FAIL;
1753                 } else if (ret == SQLITE_LOCKED) {
1754                         if (retry_count < MAX_RETRY) {
1755                                 media_svc_error("Locked retry[%d]", retry_count);
1756                                 retry_count++;
1757                                 usleep(SLEEP_TIME);
1758                                 goto EXEC_RETRY;
1759                         }
1760                         ret = MS_MEDIA_ERR_DB_UPDATE_FAIL;
1761                 } else {
1762                         ret = MS_MEDIA_ERR_DB_UPDATE_FAIL;
1763                 }
1764         }
1765
1766         return ret;
1767 }
1768
1769 int _media_svc_sql_query_list_direct(GList **query_list, uid_t uid)
1770 {
1771         int ret = MS_MEDIA_ERR_NONE;
1772         int idx = 0;
1773         int length = g_list_length(*query_list);
1774         char *sql = NULL;
1775         sqlite3 *handle = NULL;
1776
1777         media_svc_debug("query list length[%d]", length);
1778         if (length == 0)
1779                 goto ZERO_LEN;
1780
1781         ret = media_db_connect(&handle, uid, true);
1782         media_svc_retvm_if(ret != MS_MEDIA_ERR_NONE, ret, "DB connection failed");
1783
1784         for (idx = 0; idx < length; idx++) {
1785                 sql = (char *)g_list_nth_data(*query_list, idx);
1786                 if (STRING_VALID(sql)) {
1787                         ret = __media_svc_query_direct(handle, sql, uid);
1788                         if (ret != MS_MEDIA_ERR_NONE)
1789                                 media_svc_debug("_media_svc_query_direct failed[%s]", sql);
1790
1791                         SQLITE3_SAFE_FREE(sql);
1792                 }
1793         }
1794
1795         media_db_disconnect(handle);
1796
1797 ZERO_LEN:
1798         _media_svc_sql_query_release(query_list);
1799
1800         return MS_MEDIA_ERR_NONE;
1801 }
1802
1803 void _media_svc_sql_query_add(GList **query_list, char **query)
1804 {
1805         *query_list = g_list_append(*query_list, *query);
1806 }
1807
1808 void _media_svc_sql_query_release(GList **query_list)
1809 {
1810         if (*query_list) {
1811                 g_list_free(*query_list);
1812                 *query_list = NULL;
1813         }
1814 }
1815
1816 int _media_svc_check_db_upgrade(sqlite3 *db_handle, int user_version, uid_t uid)
1817 {
1818         if (user_version < LATEST_VERSION_NUMBER) {
1819                 media_svc_error("Current DB is out of date(%d).. So start to upgrade DB(%d)", user_version, LATEST_VERSION_NUMBER);
1820                 return __media_svc_db_upgrade(db_handle, user_version, uid);
1821         } else {
1822                 return MS_MEDIA_ERR_NONE;
1823         }
1824 }
1825
1826 int _media_svc_create_media_table_with_id(const char *table_id, uid_t uid)
1827 {
1828         int ret = MS_MEDIA_ERR_NONE;
1829
1830         ret = _media_svc_init_table_query(table_id);
1831         if (ret != MS_MEDIA_ERR_NONE) {
1832                 media_svc_error("_media_svc_init_table_query failed");
1833                 goto ERROR;
1834         }
1835
1836         ret = _media_svc_make_table_query(table_id, MEDIA_SVC_DB_LIST_MEDIA, uid);
1837         if (ret != MS_MEDIA_ERR_NONE) {
1838                 media_svc_error("_media_svc_make_table_query failed");
1839                 goto ERROR;
1840         }
1841
1842         /* Add for trigger */
1843         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
1844         if (ret != MS_MEDIA_ERR_NONE) {
1845                 media_svc_error("_media_svc_make_table_query failed");
1846                 goto ERROR;
1847         }
1848
1849         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
1850         if (ret != MS_MEDIA_ERR_NONE) {
1851                 media_svc_error("_media_svc_make_table_query failed");
1852                 goto ERROR;
1853         }
1854
1855         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_LIST_ALBUM, uid);
1856         if (ret != MS_MEDIA_ERR_NONE) {
1857                 media_svc_error("_media_svc_make_table_query failed");
1858                 goto ERROR;
1859         }
1860
1861         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_LIST_TAG_MAP, uid);
1862         if (ret != MS_MEDIA_ERR_NONE) {
1863                 media_svc_error("_media_svc_make_table_query failed");
1864                 goto ERROR;
1865         }
1866
1867         ret = _media_svc_make_table_query(MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_LIST_BOOKMARK, uid);
1868         if (ret != MS_MEDIA_ERR_NONE) {
1869                 media_svc_error("_media_svc_make_table_query failed");
1870                 goto ERROR;
1871         }
1872
1873         _media_svc_destroy_table_query();
1874
1875         return ret;
1876 ERROR:
1877
1878         _media_svc_destroy_table_query();
1879
1880         return ret;
1881 }
1882
1883 int _media_svc_update_media_view(sqlite3 *db_handle, uid_t uid)
1884 {
1885         int ret = MS_MEDIA_ERR_NONE;
1886         char *sql = NULL;
1887         sqlite3_stmt *sql_stmt = NULL;
1888         int item_cnt = 0;
1889         int idx = 0;
1890         GList *storage_list = NULL;
1891         char view_query[MEDIA_SVC_QUERY_LEN_NORMAL] = {0, };
1892         memset(view_query, 0x00, sizeof(view_query));
1893
1894         snprintf(view_query, sizeof(view_query), "DROP VIEW IF EXISTS %s; CREATE VIEW IF NOT EXISTS %s AS SELECT * from %s ", MEDIA_SVC_DB_VIEW_MEDIA, MEDIA_SVC_DB_VIEW_MEDIA, MEDIA_SVC_DB_TABLE_MEDIA);
1895
1896         /*Select list of storage*/
1897         sql = sqlite3_mprintf("SELECT storage_id FROM '%s' WHERE validity=1", MEDIA_SVC_DB_TABLE_STORAGE);
1898         ret = _media_svc_sql_prepare_to_step_simple(db_handle, sql, &sql_stmt);
1899         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1900
1901         while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
1902                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0)))
1903                         storage_list = g_list_append(storage_list, strdup((char *)sqlite3_column_text(sql_stmt, 0)));
1904         }
1905         SQLITE3_FINALIZE(sql_stmt);
1906
1907         if ((storage_list != NULL) && (g_list_length(storage_list) > 0)) {
1908                 item_cnt = g_list_length(storage_list);
1909
1910                 for (idx = 0; idx < item_cnt; idx++) {
1911                         int table_cnt = 0;
1912                         char *storage_id = NULL;
1913                         storage_id = g_list_nth_data(storage_list, idx);
1914
1915                         if (STRING_VALID(storage_id)) {
1916                                 /*Select list of storage*/
1917                                 sql = sqlite3_mprintf("SELECT COUNT(*) FROM SQLITE_MASTER WHERE type='table' and name='%q'", storage_id);
1918                                 ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
1919                                 if (ret != MS_MEDIA_ERR_NONE) {
1920                                         SAFE_FREE(storage_id);
1921                                         continue;
1922                                 }
1923
1924                                 table_cnt = sqlite3_column_int(sql_stmt, 0);
1925                                 SQLITE3_FINALIZE(sql_stmt);
1926
1927                                 if (table_cnt > 0) {
1928                                         char append_query[128] = {0, };
1929                                         memset(append_query, 0x00, sizeof(append_query));
1930                                         snprintf(append_query, sizeof(append_query), " UNION SELECT * from '%s'", storage_id);
1931                                         SAFE_STRLCAT(view_query, append_query, sizeof(view_query));
1932                                 } else {
1933                                         media_svc_error("media table not exist for storage [%s]", storage_id);
1934                                 }
1935
1936                                 SAFE_FREE(storage_id);
1937                         }
1938                 }
1939                 g_list_free(storage_list);
1940         }
1941
1942         ret = _media_svc_sql_query(view_query, uid);
1943         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1944
1945         return ret;
1946 }