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 <sys/stat.h>
  24 #include <db-util.h>
  25 #include <media-util.h>
  26 #include <errno.h>
  27 #include <grp.h>
  28 #include <pwd.h>
  29 #include "media-svc-env.h"
  30 #include "media-svc-debug.h"
  31 #include "media-svc-util.h"
  32 #include "media-svc-db-utils.h"
  33 #include "media-util-err.h"
  34 #include "media-util-db.h"
  35 #include "media-svc-media.h"
  36
  37 static int __media_svc_db_upgrade(sqlite3 *db_handle, int cur_version, uid_t uid);
  38 static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid);
  39
  40
  41 static GHashTable *table;
  42 static GSList *column_list[MEDIA_SVC_DB_LIST_MAX];
  43
  44 char *_media_svc_get_path(uid_t uid)
  45 {
  46         char *result_psswd = NULL;
  47         struct group *grpinfo = NULL;
  48         if (uid == getuid()) {
  49                 result_psswd = strdup(MEDIA_ROOT_PATH_INTERNAL);
  50                 grpinfo = getgrnam("users");
  51                 if (grpinfo == NULL) {
  52                         media_svc_error("getgrnam(users) returns NULL !");
  53                         return NULL;
  54                 }
  55         } else {
  56                 struct passwd *userinfo = getpwuid(uid);
  57                 if (userinfo == NULL) {
  58                         media_svc_error("getpwuid(%d) returns NULL !", uid);
  59                         return NULL;
  60                 }
  61                 grpinfo = getgrnam("users");
  62                 if (grpinfo == NULL) {
  63                         media_svc_error("getgrnam(users) returns NULL !");
  64                         return NULL;
  65                 }
  66                 /* Compare git_t type and not group name */
  67                 if (grpinfo->gr_gid != userinfo->pw_gid) {
  68                         media_svc_error("UID [%d] does not belong to 'users' group!", uid);
  69                         return NULL;
  70                 }
  71                 asprintf(&result_psswd, "%s/%s", userinfo->pw_dir, MEDIA_CONTENT_PATH);
  72         }
  73
  74         return result_psswd;
  75 }
  76
  77 int __media_svc_add_table_info(const char *name, const char *triggerName, const char *eventTable, const char *actionTable, const char *viewName)
  78 {
  79         table_info *tbl = NULL;
  80
  81         media_svc_retvm_if(!STRING_VALID(name), MS_MEDIA_ERR_INVALID_PARAMETER, "name is NULL");
  82
  83         if (STRING_VALID(triggerName)) {
  84                 media_svc_retvm_if(!STRING_VALID(eventTable), MS_MEDIA_ERR_INVALID_PARAMETER, "eventTable is NULL");
  85                 media_svc_retvm_if(!STRING_VALID(actionTable), MS_MEDIA_ERR_INVALID_PARAMETER, "actionTable is NULL");
  86         }
  87
  88         tbl = malloc(sizeof(table_info));
  89         if (tbl == NULL) {
  90                 media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
  91                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
  92         }
  93
  94         memset(tbl, 0x00, sizeof(table_info));
  95
  96         if (STRING_VALID(triggerName)) {
  97                 tbl->triggerName = malloc(MEDIA_SVC_PATHNAME_SIZE);
  98                 if(tbl->triggerName == NULL) {
  99                         media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
 100                         SAFE_FREE(tbl);
 101                         return MS_MEDIA_ERR_OUT_OF_MEMORY;
 102                 }
 103
 104                 memset(tbl->triggerName, 0x00, MEDIA_SVC_PATHNAME_SIZE);
 105                 snprintf(tbl->triggerName, MEDIA_SVC_PATHNAME_SIZE, "%s_%s", triggerName, eventTable);
 106
 107                 tbl->eventTable = strndup(eventTable, strlen(eventTable));
 108                 tbl->actionTable = strndup(actionTable, strlen(actionTable));
 109         }
 110
 111         if (STRING_VALID(viewName)) {
 112                 tbl->viewName = strndup(viewName, strlen(viewName));
 113         }
 114
 115         g_hash_table_insert(table, (gpointer)name, (gpointer)tbl);
 116
 117         return MS_MEDIA_ERR_NONE;
 118 }
 119
 120 int __media_svc_add_column_info(GSList **slist, const char *name, const char *type, const char *option, int version, const char *indexName, bool isUnique, bool isTrigger, bool isView)
 121 {
 122         column_info *col = NULL;
 123         col = malloc(sizeof(column_info));
 124         if (col == NULL) {
 125                 media_svc_error("MS_MEDIA_ERR_OUT_OF_MEMORY");
 126                 return MS_MEDIA_ERR_OUT_OF_MEMORY;
 127         }
 128         memset(col, 0, sizeof(column_info));
 129
 130         col->name = strndup(name, strlen(name));
 131         col->type = strndup(type, strlen(type));
 132         if (option != NULL) {
 133                 col->hasOption = true;
 134                 col->option = strndup(option, strlen(option));
 135         } else {
 136                 col->hasOption = false;
 137         }
 138         col->version = version;
 139         if (indexName != NULL) {
 140                 col->isIndex = true;
 141                 col->indexName = strndup(indexName, strlen(indexName));
 142         } else {
 143                 col->isIndex = false;
 144         }
 145         col->isUnique = isUnique;
 146         col->isTrigger = isTrigger;
 147         col->isView = isView;
 148         *slist = g_slist_append(*slist, col);
 149
 150         return MS_MEDIA_ERR_NONE;
 151 }
 152
 153 static int __media_svc_rebuild_view_query(sqlite3 *db_handle, uid_t uid)
 154 {
 155         int ret = MS_MEDIA_ERR_NONE;
 156         column_info *col_ptr = NULL;
 157         char *sql = NULL;
 158         char table_query[4096] = {0, };
 159         char temp[1024] = {0, };
 160         bool sflag = false;
 161         int i, len;
 162         /*media */
 163         _media_svc_update_media_view(db_handle, uid);
 164
 165         /*drop playlist_view, tag_view */
 166         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_DROP_VIEW, MEDIA_SVC_DB_VIEW_PLAYLIST);
 167         ret = _media_svc_sql_query(db_handle, sql, uid);
 168         sqlite3_free(sql);
 169         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 170
 171         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_DROP_VIEW, MEDIA_SVC_DB_VIEW_TAG);
 172         ret = _media_svc_sql_query(db_handle, sql, uid);
 173         sqlite3_free(sql);
 174         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 175
 176         /*create playlist_view */
 177         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
 178         for (i = 1; i < len; i++) {
 179                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 180                 if (col_ptr->isView) {
 181                         if (sflag == true) {
 182                                 if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_THUMBNAIL, strlen(MEDIA_SVC_DB_COLUMN_THUMBNAIL)) == 0)
 183                                         snprintf(temp, sizeof(temp), ", playlist.%s AS p_thumbnail_path", col_ptr->name);
 184                                 else
 185                                         snprintf(temp, sizeof(temp), ", playlist.%s", col_ptr->name);
 186                                 strncat(table_query, temp, strlen(temp));
 187                         } else {
 188                                 snprintf(temp, sizeof(temp), "playlist.%s", col_ptr->name);
 189                                 strncpy(table_query, temp, strlen(temp));
 190                                 sflag = true;
 191                         }
 192                 }
 193                 memset(temp, 0, sizeof(temp));
 194         }
 195         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
 196         for (i = 1; i < len; i++) {
 197                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
 198                 if (col_ptr->isView) {
 199                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 200                                 snprintf(temp, sizeof(temp), ", media_count IS NOT NULL AS media_count, playlist_map.%s AS pm_id", col_ptr->name);
 201                         else
 202                                 snprintf(temp, sizeof(temp), ", playlist_map.%s", col_ptr->name);
 203                         strncat(table_query, temp, strlen(temp));
 204                 }
 205                 memset(temp, 0, sizeof(temp));
 206         }
 207
 208         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 209         for (i = 1; i < len; i++) {
 210                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 211                 if (col_ptr->isView) {
 212                         snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 213                         strncat(table_query, temp, strlen(temp));
 214                 }
 215                 memset(temp, 0, sizeof(temp));
 216         }
 217         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_PLAYLIST, MEDIA_SVC_DB_VIEW_PLAYLIST, table_query);
 218         ret = _media_svc_sql_query(db_handle, sql, uid);
 219         sqlite3_free(sql);
 220         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 221
 222         /*create tag_view */
 223         sflag = false;
 224         memset(table_query, 0, sizeof(table_query));
 225
 226         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 227         for (i = 1; i < len; i++) {
 228                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 229                 if (col_ptr->isView) {
 230                         if (sflag == true) {
 231                                 snprintf(temp, sizeof(temp), ", tag.%s", col_ptr->name);
 232                                 strncat(table_query, temp, strlen(temp));
 233                         } else {
 234                                 snprintf(temp, sizeof(temp), "tag.%s", col_ptr->name);
 235                                 strncpy(table_query, temp, strlen(temp));
 236                                 sflag = true;
 237                         }
 238                 }
 239                 memset(temp, 0, sizeof(temp));
 240         }
 241         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
 242         for (i = 1; i < len; i++) {
 243                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
 244                 if (col_ptr->isView) {
 245                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 246                                 snprintf(temp, sizeof(temp), ", media_count IS NOT NULL AS media_count, tag_map.%s AS tm_id", col_ptr->name);
 247                         else
 248                                 snprintf(temp, sizeof(temp), ", tag_map.%s", col_ptr->name);
 249                         strncat(table_query, temp, strlen(temp));
 250                 }
 251                 memset(temp, 0, sizeof(temp));
 252         }
 253
 254         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 255         for (i = 1; i < len; i++) {
 256                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 257                 if (col_ptr->isView) {
 258                         snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 259                         strncat(table_query, temp, strlen(temp));
 260                 }
 261                 memset(temp, 0, sizeof(temp));
 262         }
 263         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_TAG, MEDIA_SVC_DB_VIEW_TAG, table_query);
 264         ret = _media_svc_sql_query(db_handle, sql, uid);
 265         sqlite3_free(sql);
 266         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 267
 268         return MS_MEDIA_ERR_NONE;
 269 }
 270
 271 int _media_svc_make_table_query(sqlite3 *db_handle, const char *table_name, media_svc_table_slist_e list, uid_t uid)
 272 {
 273         int ret = MS_MEDIA_ERR_NONE;
 274         table_info *tb = NULL;
 275         column_info *col_ptr = NULL;
 276         char *sql = NULL;
 277         char table_query[4096] = {0, };
 278         char index_query[4096] = {0, };
 279         char trigger_query[4096] = {0, };
 280         char table_query_sub[1024] = {0, };
 281         char temp[1024] = {0 ,};
 282         int sflag = false;
 283         int index_len = 0;
 284         int trigger_len = 0;
 285         int table_sub_len = 0;
 286         int len = 0;
 287         int i = 0;
 288
 289         tb = g_hash_table_lookup(table, table_name);
 290         if(tb == NULL) {
 291                 media_svc_debug("lookup fail.. table name [%s] ", table_name);
 292                 tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_MEDIA);
 293         }
 294
 295         len = g_slist_length(column_list[list]);
 296
 297         if (len == 0) {
 298                 media_svc_error("Invalid column");
 299                 return MS_MEDIA_ERR_INTERNAL;
 300         }
 301
 302         for (i = 1; i < len; i++) {
 303                 col_ptr = g_slist_nth_data(column_list[list], i);
 304                 /*create table */
 305                 if (col_ptr->hasOption) {
 306                         if(sflag == true) {
 307                                 snprintf(temp, sizeof(temp), ", %s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 308                                 strncat(table_query, temp, strlen(temp));
 309                         } else {
 310                                 snprintf(temp, sizeof(temp), "%s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 311                                 strncpy(table_query, temp, strlen(temp));
 312                                 sflag = true;
 313                         }
 314                 } else {
 315                         if (sflag == true) {
 316                                 snprintf(temp, sizeof(temp), ", %s %s", col_ptr->name, col_ptr->type);
 317                                 strncat(table_query, temp, strlen(temp));
 318                         } else {
 319                                 snprintf(temp, sizeof(temp), "%s %s", col_ptr->name, col_ptr->type);
 320                                 strncpy(table_query, temp, strlen(temp));
 321                                 sflag = true;
 322                         }
 323                 }
 324                 memset(temp, 0, sizeof(temp));
 325
 326                 /*unique */
 327                 if (col_ptr->isUnique) {
 328                         if (table_sub_len > 0) {
 329                                 snprintf(temp, sizeof(temp), ", %s", col_ptr->name);
 330                                 strncat(table_query_sub, temp, strlen(temp));
 331                                 table_sub_len = strlen(table_query_sub);
 332                         } else {
 333                                 snprintf(temp, sizeof(temp), "%s", col_ptr->name);
 334                                 strncpy(table_query_sub, temp, strlen(temp));
 335                                 table_sub_len = strlen(table_query_sub);
 336                         }
 337                 }
 338                 memset(temp, 0, sizeof(temp));
 339
 340                 /*create index */
 341                 if (col_ptr->isIndex) {
 342                         if (index_len > 0) {
 343                                 snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_INDEX, col_ptr->indexName, table_name, col_ptr->name);
 344                                 strncat(index_query, temp, strlen(temp));
 345                                 index_len = strlen(index_query);
 346                         } else {
 347                                 snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_INDEX, col_ptr->indexName, table_name, col_ptr->name);
 348                                 strncpy(index_query, temp, strlen(temp));
 349                                 index_len = strlen(index_query);
 350                         }
 351                 }
 352                 memset(temp, 0, sizeof(temp));
 353
 354                 /*create trigger */
 355                 if (col_ptr->isTrigger) {
 356                         if (STRING_VALID(tb->triggerName)) {
 357                                 if (strncmp(table_name, MEDIA_SVC_DB_TABLE_ALBUM, strlen(MEDIA_SVC_DB_TABLE_ALBUM)) == 0) {
 358                                         snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER_WITH_COUNT, tb->triggerName, tb->eventTable, tb->actionTable, tb->eventTable, col_ptr->name, col_ptr->name, col_ptr->name, col_ptr->name);
 359                                         strncpy(trigger_query, temp, strlen(temp));
 360                                         trigger_len = strlen(trigger_query);
 361                                 } else {
 362                                         snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_TRIGGER, tb->triggerName, tb->eventTable, tb->actionTable, col_ptr->name, col_ptr->name);
 363                                         strncpy(trigger_query, temp, strlen(temp));
 364                                         trigger_len = strlen(trigger_query);
 365                                 }
 366                         } else {
 367                                 media_svc_error("invalid trigger name");
 368                         }
 369                 }
 370                 memset(temp, 0, sizeof(temp));
 371         }
 372
 373         /*send queries */
 374         if (table_sub_len > 0) {
 375                 sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_TABLE_WITH_UNIQUE, table_name, table_query, table_query_sub);
 376                 ret = _media_svc_sql_query(db_handle, sql, uid);
 377                 sqlite3_free(sql);
 378                 memset(table_query, 0, sizeof(table_query));
 379                 memset(table_query_sub, 0, sizeof(table_query_sub));
 380                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 381         } else {
 382                 sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_TABLE, table_name, table_query);
 383                 ret = _media_svc_sql_query(db_handle, sql, uid);
 384                 sqlite3_free(sql);
 385                 memset(table_query, 0, sizeof(table_query));
 386                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 387         }
 388
 389         if (index_len > 0) {
 390                 ret = _media_svc_sql_query(db_handle, index_query, uid);
 391                 memset(index_query, 0, sizeof(index_query));
 392                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 393         }
 394
 395         if (trigger_len > 0) {
 396                 ret = _media_svc_sql_query(db_handle, trigger_query, uid);
 397                 memset(trigger_query, 0, sizeof(trigger_query));
 398                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 399         }
 400
 401         /*create view */
 402         sflag = false;
 403         if (tb != NULL && tb->viewName != NULL) {
 404                 if (strncmp(table_name, MEDIA_SVC_DB_TABLE_MEDIA, strlen(MEDIA_SVC_DB_TABLE_MEDIA)) == 0) {
 405                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_MEDIA, tb->viewName, table_name);
 406                         ret = _media_svc_sql_query(db_handle, sql, uid);
 407                         sqlite3_free(sql);
 408                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 409
 410                 } else if (strncmp(table_name, MEDIA_SVC_DB_TABLE_PLAYLIST, strlen(MEDIA_SVC_DB_TABLE_PLAYLIST)) == 0) {
 411                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
 412                         for (i = 1; i < len; i++) {
 413                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 414                                 if (col_ptr->isView) {
 415                                         if (sflag == true) {
 416                                                 if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_THUMBNAIL, strlen(MEDIA_SVC_DB_COLUMN_THUMBNAIL)) == 0)
 417                                                         snprintf(temp, sizeof(temp), ", playlist.%s AS p_thumbnail_path", col_ptr->name);
 418                                                 else
 419                                                         snprintf(temp, sizeof(temp), ", playlist.%s", col_ptr->name);
 420                                                 strncat(table_query, temp, strlen(temp));
 421                                         } else {
 422                                                 snprintf(temp, sizeof(temp), "playlist.%s", col_ptr->name);
 423                                                 strncpy(table_query, temp, strlen(temp));
 424                                                 sflag = true;
 425                                         }
 426                                 }
 427                                 memset(temp, 0, sizeof(temp));
 428                         }
 429                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
 430                         for (i = 1; i < len; i++) {
 431                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
 432                                 if (col_ptr->isView) {
 433                                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 434                                                 snprintf(temp, sizeof(temp), ", media_count IS NOT NULL AS media_count, playlist_map.%s AS pm_id", col_ptr->name);
 435                                         else
 436                                                 snprintf(temp, sizeof(temp), ", playlist_map.%s", col_ptr->name);
 437                                         strncat(table_query, temp, strlen(temp));
 438                                 }
 439                                 memset(temp, 0, sizeof(temp));
 440                         }
 441
 442                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 443                         for (i = 1; i < len; i++) {
 444                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 445                                 if (col_ptr->isView) {
 446                                         snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 447                                         strncat(table_query, temp, strlen(temp));
 448                                 }
 449                                 memset(temp, 0, sizeof(temp));
 450                         }
 451                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_PLAYLIST, tb->viewName, table_query);
 452                         ret = _media_svc_sql_query(db_handle, sql, uid);
 453                         sqlite3_free(sql);
 454                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 455
 456                 } else {
 457                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 458                         for (i = 1; i < len; i++) {
 459                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 460                                 if (col_ptr->isView) {
 461                                         if(sflag == true) {
 462                                                 snprintf(temp, sizeof(temp), ", tag.%s", col_ptr->name);
 463                                                 strncat(table_query, temp, strlen(temp));
 464                                         } else {
 465                                                 snprintf(temp, sizeof(temp), "tag.%s", col_ptr->name);
 466                                                 strncpy(table_query, temp, strlen(temp));
 467                                                 sflag = true;
 468                                         }
 469                                 }
 470                                 memset(temp, 0, sizeof(temp));
 471                         }
 472                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
 473                         for (i = 1; i < len; i++) {
 474                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
 475                                 if (col_ptr->isView) {
 476                                         if (strncmp(col_ptr->name, MEDIA_SVC_DB_COLUMN_MAP_ID, strlen(MEDIA_SVC_DB_COLUMN_MAP_ID)) == 0)
 477                                                 snprintf(temp, sizeof(temp), ", media_count IS NOT NULL AS media_count, tag_map.%s AS tm_id", col_ptr->name);
 478                                         else
 479                                                 snprintf(temp, sizeof(temp), ", tag_map.%s", col_ptr->name);
 480                                         strncat(table_query, temp, strlen(temp));
 481                                 }
 482                                 memset(temp, 0, sizeof(temp));
 483                         }
 484
 485                         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 486                         for (i = 1; i < len; i++) {
 487                                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 488                                 if (col_ptr->isView) {
 489                                         snprintf(temp, sizeof(temp), ", media.%s", col_ptr->name);
 490                                         strncat(table_query, temp, strlen(temp));
 491                                 }
 492                                 memset(temp, 0, sizeof(temp));
 493                         }
 494                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_VIEW_TAG, tb->viewName, table_query);
 495                         ret = _media_svc_sql_query(db_handle, sql, uid);
 496                         sqlite3_free(sql);
 497                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 498
 499                 }
 500         }
 501
 502         return MS_MEDIA_ERR_NONE;
 503 }
 504
 505 int _media_svc_upgrade_table_query(sqlite3 *db_handle, const char *table_name, media_svc_table_slist_e list, uid_t uid)
 506 {
 507         int ret = MS_MEDIA_ERR_NONE;
 508         column_info *col_ptr = NULL;
 509         char *sql = NULL;
 510         char temp[1024] = {0, };
 511         int len, i;
 512         int cur_version = 0;
 513         sqlite3_stmt *sql_stmt = NULL;
 514
 515         len = g_slist_length(column_list[list]);
 516
 517         sql = sqlite3_mprintf("PRAGMA user_version");
 518         ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
 519
 520         if (ret != MS_MEDIA_ERR_NONE) {
 521                 media_svc_error("error when get user_version. err = [%d]", ret);
 522                 return ret;
 523         }
 524         cur_version = sqlite3_column_int(sql_stmt, 0);
 525         SQLITE3_FINALIZE(sql_stmt);
 526
 527         len = g_slist_length(column_list[list]);
 528         for (i = 1; i < len; i++) {
 529                 col_ptr = g_slist_nth_data(column_list[list], i);
 530                 if (col_ptr->version > cur_version) {
 531                         /*alter table */
 532                         if (col_ptr->hasOption)
 533                                 snprintf(temp, sizeof(temp), "%s %s %s", col_ptr->name, col_ptr->type, col_ptr->option);
 534                         else
 535                                 snprintf(temp, sizeof(temp), "%s %s", col_ptr->name, col_ptr->type);
 536                         sql = sqlite3_mprintf(MEDIA_SVC_DB_QUERY_ALTER_TABLE, table_name, temp);
 537                         ret = _media_svc_sql_query(db_handle, sql, uid);
 538                         sqlite3_free(sql);
 539                         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 540                         /*create index */
 541                         if (col_ptr->isIndex) {
 542                                 memset(temp, 0, sizeof(temp));
 543                                 snprintf(temp, sizeof(temp), MEDIA_SVC_DB_QUERY_INDEX, col_ptr->indexName, table_name, col_ptr->name);
 544                                 ret = _media_svc_sql_query(db_handle, temp, uid);
 545                                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 546                         }
 547                 }
 548                 memset(temp, 0, sizeof(temp));
 549         }
 550
 551         return MS_MEDIA_ERR_NONE;
 552 }
 553
 554 int _media_svc_init_table_query(const char *event_table_name)
 555 {
 556         int ret = MS_MEDIA_ERR_NONE;
 557         int i = 0;
 558
 559         /*variable initialize.. */
 560         table = g_hash_table_new(g_str_hash, g_str_equal);
 561         for (i = 0; i < MEDIA_SVC_DB_LIST_MAX; i++) {
 562                 column_list[i] = g_slist_alloc();
 563         }
 564
 565         /*table specification..                  (table_name, index, unique set, trigger, view, trigger name, event table, action table, view name) */
 566         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_MEDIA, NULL, NULL, NULL, MEDIA_SVC_DB_VIEW_MEDIA);
 567         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);
 568         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);
 569         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);
 570         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);
 571         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);
 572         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);
 573         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);
 574         ret = __media_svc_add_table_info(MEDIA_SVC_DB_TABLE_STORAGE, NULL, NULL, NULL, NULL);
 575         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);
 576         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);
 577         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 578
 579         /*insert column info.. */
 580         /*media*/
 581         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V2, NULL, false, false, true);
 582         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, true, false, true);
 583         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "file_name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, "media_file_name_idx", true, false, true);
 584         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "media_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, "media_media_type_idx", false, false, true);
 585         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "mime_type", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 586         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "size", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 587         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "added_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 588         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, "media_modified_time_idx", false, false, true);
 589         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, "folder_uuid_idx", false, false, false);
 590         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 591         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "title", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_title_idx", false, false, true);
 592         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);
 593         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_album_idx", false, false, true);
 594         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_artist_idx", false, false, true);
 595         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_artist", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 596         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "genre", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_genre_idx", false, false, true);
 597         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "composer", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_composer_idx", false, false, true);
 598         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "year", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 599         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "recorded_date", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 600         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "copyright", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 601         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "track_num", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 602         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "description", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 603         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "bitrate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 604         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "bitpersample", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, true);
 605         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "samplerate", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 606         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "channel", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 607         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "duration", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 608         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "longitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
 609         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "latitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
 610         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "altitude", MEDIA_SVC_DB_TYPE_DOUBLE, "DEFAULT 0", USER_V2, NULL, false, false, true);
 611         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);
 612         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);
 613         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);
 614         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);
 615         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "width", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 616         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "height", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 617         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "datetaken", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 618         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT -1", USER_V2, NULL, false, false, true);
 619         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "burst_id", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 620         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "played_count", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 621         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "last_played_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 622         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "last_played_position", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 623         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "rating", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 624         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "favourite", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 625         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "author", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_author_idx", false, false, true);
 626         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "provider", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_provider_idx", false, false, true);
 627         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "content_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_content_name_idx", false, false, true);
 628         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "category", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_category_idx", false, false, true);
 629         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "location_tag", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, "media_location_tag_idx", false, false, true);
 630         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "age_rating", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 631         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "keyword", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 632         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "is_drm", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, true);
 633         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, true);
 634         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "timeline", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, "media_timeline_idx", false, false, true);
 635         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "weather", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, true);
 636         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);
 637         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "file_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 638         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "title_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 639         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 640         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 641         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "album_artist_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 642         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "genre_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 643         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "composer_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 644         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "copyright_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 645         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "description_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 646         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "author_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 647         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "provider_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 648         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "content_name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 649         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "category_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 650         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_MEDIA], "location_tag_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 651         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);
 652         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);
 653         /* storage_uuid column is added in DB v4. When doing DB upgrade to v4, if storage_uuid is NOT NULL, alter table failed. */
 654         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);
 655         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);
 656         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 657
 658         /*folder*/
 659         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", USER_V2, NULL, false, false, false);
 660         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "path", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, false, false);
 661         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, false, false);
 662         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "modified_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, false, false, false);
 663         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 664         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "storage_type", MEDIA_SVC_DB_TYPE_INT, NULL, USER_V2, NULL, false, false, false);
 665         /* storage_uuid column is added in DB v4. When doing DB upgrade to v4, if storage_uuid is NOT NULL, alter table failed. */
 666         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);
 667         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "folder_order", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V4, NULL, false, false, false);
 668         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FOLDER], "parent_folder_uuid", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V4, NULL, false, false, false);
 669         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);
 670         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 671
 672         /*playlist_map*/
 673         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);
 674         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);
 675         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, false, true, false);
 676         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], "play_order", MEDIA_SVC_DB_TYPE_INT, "NOT NULL", USER_V2, NULL, false, false, true);
 677         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 678
 679         /*playlist*/
 680         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);
 681         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
 682         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_PLAYLIST], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 683         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);
 684         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 685
 686         /*album*/
 687         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);
 688         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);
 689         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);
 690         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);
 691         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 692
 693         /*tag_map*/
 694         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);
 695         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);
 696         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG_MAP], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, true, false);
 697         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 698
 699         /*tag*/
 700         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);
 701         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "name", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL UNIQUE", USER_V2, NULL, false, false, true);
 702         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_TAG], "name_pinyin", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 703         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 704
 705         /*bookmark*/
 706         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);
 707         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V2, NULL, true, true, false);
 708         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "marked_time", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V2, NULL, true, false, false);
 709         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_BOOKMARK], "thumbnail_path", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V2, NULL, false, false, false);
 710         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 711
 712         /*storage*/
 713         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", USER_V3, NULL, true, false, false);
 714         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_name", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V3, NULL, true, false, false);
 715         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);
 716         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "storage_account", MEDIA_SVC_DB_TYPE_TEXT, NULL, USER_V3, NULL, false, false, false);
 717         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);
 718         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_STORAGE], "scan_status", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", USER_V3, NULL, false, false, false);
 719         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);
 720         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 721
 722         /*face scan list*/
 723         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE_SCAN_LIST], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, true, true, false);
 724         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE_SCAN_LIST], "storage_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, false, false, false);
 725         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 726
 727         /*face*/
 728         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_uuid", MEDIA_SVC_DB_TYPE_TEXT, "PRIMARY KEY", 0, NULL, true, false, false);
 729         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "media_uuid", MEDIA_SVC_DB_TYPE_TEXT, "NOT NULL", 0, NULL, false, true, false);
 730         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_x", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
 731         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_y", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
 732         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_w", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
 733         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "face_rect_h", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
 734         ret = __media_svc_add_column_info(&column_list[MEDIA_SVC_DB_LIST_FACE], "orientation", MEDIA_SVC_DB_TYPE_INT, "DEFAULT 0", 0, NULL, false, false, false);
 735         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 736
 737         return ret;
 738 }
 739 void __media_svc_table_free(table_info *tb) {
 740         SAFE_FREE(tb->triggerName);
 741         SAFE_FREE(tb->viewName);
 742         SAFE_FREE(tb->eventTable);
 743         SAFE_FREE(tb->actionTable);
 744         SAFE_FREE(tb);
 745 }
 746
 747 void __media_svc_column_free(column_info *col) {
 748         SAFE_FREE(col->name);
 749         SAFE_FREE(col->type);
 750         SAFE_FREE(col->option);
 751         SAFE_FREE(col->indexName);
 752         SAFE_FREE(col);
 753 }
 754
 755 void _media_svc_destroy_table_query()
 756 {
 757         int i = 0;
 758         table_info *tb = NULL;
 759         column_info *col_ptr = NULL;
 760         int len = 0;
 761
 762         /* Table Free */
 763         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_MEDIA);
 764         __media_svc_table_free(tb);
 765         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_MEDIA);
 766
 767         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_FOLDER);
 768         __media_svc_table_free(tb);
 769         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_FOLDER);
 770
 771         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_PLAYLIST);
 772         __media_svc_table_free(tb);
 773         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_PLAYLIST);
 774
 775         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
 776         __media_svc_table_free(tb);
 777         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP);
 778
 779         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_ALBUM);
 780         __media_svc_table_free(tb);
 781         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_ALBUM);
 782
 783         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_TAG);
 784         __media_svc_table_free(tb);
 785         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_TAG);
 786
 787         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_TAG_MAP);
 788         __media_svc_table_free(tb);
 789         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_TAG_MAP);
 790
 791         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_BOOKMARK);
 792         __media_svc_table_free(tb);
 793         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_BOOKMARK);
 794
 795         tb = g_hash_table_lookup(table, MEDIA_SVC_DB_TABLE_STORAGE);
 796         __media_svc_table_free(tb);
 797         g_hash_table_remove (table, MEDIA_SVC_DB_TABLE_STORAGE);
 798
 799         g_hash_table_destroy(table);
 800
 801         /* Column Free */
 802         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_MEDIA]);
 803
 804         for(i=1; i<len; i++) {
 805                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_MEDIA], i);
 806                 __media_svc_column_free(col_ptr);
 807         }
 808
 809         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_FOLDER]);
 810
 811         for(i=1; i<len; i++) {
 812                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_FOLDER], i);
 813                 __media_svc_column_free(col_ptr);
 814         }
 815
 816         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP]);
 817
 818         for(i=1; i<len; i++) {
 819                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST_MAP], i);
 820                 __media_svc_column_free(col_ptr);
 821         }
 822
 823         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_PLAYLIST]);
 824
 825         for(i=1; i<len; i++) {
 826                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_PLAYLIST], i);
 827                 __media_svc_column_free(col_ptr);
 828         }
 829
 830         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_ALBUM]);
 831
 832         for(i=1; i<len; i++) {
 833                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_ALBUM], i);
 834                 __media_svc_column_free(col_ptr);
 835         }
 836
 837         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG_MAP]);
 838
 839         for(i=1; i<len; i++) {
 840                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG_MAP], i);
 841                 __media_svc_column_free(col_ptr);
 842         }
 843
 844         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_TAG]);
 845
 846         for(i=1; i<len; i++) {
 847                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_TAG], i);
 848                 __media_svc_column_free(col_ptr);
 849         }
 850
 851         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_BOOKMARK]);
 852
 853         for(i=1; i<len; i++) {
 854                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_BOOKMARK], i);
 855                 __media_svc_column_free(col_ptr);
 856         }
 857
 858         len = g_slist_length(column_list[MEDIA_SVC_DB_LIST_STORAGE]);
 859
 860         for(i=1; i<len; i++) {
 861                 col_ptr = g_slist_nth_data(column_list[MEDIA_SVC_DB_LIST_STORAGE], i);
 862                 __media_svc_column_free(col_ptr);
 863         }
 864
 865         for(i=0; i<MEDIA_SVC_DB_LIST_MAX; i++) {
 866                 g_slist_free(column_list[i]);
 867         }
 868 }
 869
 870 static int __media_svc_db_upgrade(sqlite3 *db_handle, int cur_version, uid_t uid)
 871 {
 872         int ret = MS_MEDIA_ERR_NONE;
 873         char *sql = NULL;
 874
 875         ret = _media_svc_init_table_query(MEDIA_SVC_DB_TABLE_MEDIA);
 876         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 877
 878         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_MEDIA, MEDIA_SVC_DB_LIST_MEDIA, uid);
 879         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 880
 881         /* Upgrade issue in folder table */
 882         if(cur_version < USER_V4) {
 883                 /* Create tmp table */
 884                 sql = sqlite3_mprintf("CREATE TABLE '%q' AS SELECT * FROM '%q';", MEDIA_SVC_DB_TABLE_TMP_TABLE, MEDIA_SVC_DB_TABLE_FOLDER);
 885                 media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 886
 887                 ret = _media_svc_sql_query(db_handle, sql, uid);
 888                 if (ret != MS_MEDIA_ERR_NONE) {
 889                         media_svc_error("Error when create backup folder table");
 890                 }
 891                 sqlite3_free(sql);
 892
 893                 /* Drop original table */
 894                 sql = sqlite3_mprintf("DROP TABLE '%q';", MEDIA_SVC_DB_TABLE_FOLDER);
 895                 media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 896
 897                 ret = _media_svc_sql_query(db_handle, sql, uid);
 898                 if (ret != MS_MEDIA_ERR_NONE) {
 899                         media_svc_error("Error when drop table");
 900                 }
 901                 sqlite3_free(sql);
 902
 903                 /* Create new table */
 904                 ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
 905                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 906
 907                 /* Insert into new table */
 908                 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);
 909                 media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 910
 911                 ret = _media_svc_sql_query(db_handle, sql, uid);
 912                 if (ret != MS_MEDIA_ERR_NONE) {
 913                         media_svc_error("Error when backup folder table");
 914                 }
 915                 sqlite3_free(sql);
 916
 917                 /* Drop tmp table*/
 918                 sql = sqlite3_mprintf("DROP TABLE '%q';", MEDIA_SVC_DB_TABLE_TMP_TABLE);
 919                 media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 920
 921                 ret = _media_svc_sql_query(db_handle, sql, uid);
 922                 if (ret != MS_MEDIA_ERR_NONE) {
 923                         media_svc_error("Error when drop backup folder table");
 924                 }
 925                 sqlite3_free(sql);
 926
 927         } else {
 928                 ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER , MEDIA_SVC_DB_LIST_FOLDER, uid);
 929                 media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 930         }
 931
 932         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
 933         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 934
 935         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST, MEDIA_SVC_DB_LIST_PLAYLIST, uid);
 936         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 937
 938         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_LIST_ALBUM, uid);
 939         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 940
 941         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_LIST_TAG_MAP, uid);
 942         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 943
 944         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_TAG, MEDIA_SVC_DB_LIST_TAG, uid);
 945         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 946
 947         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_LIST_BOOKMARK, uid);
 948         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 949
 950         ret = _media_svc_upgrade_table_query(db_handle, MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_LIST_STORAGE, uid);
 951         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
 952
 953         if(cur_version < USER_V4) {
 954                 /* Need to default value in storage_uuid */
 955                 sql = sqlite3_mprintf("UPDATE %q SET storage_uuid  = '%q';",MEDIA_SVC_DB_TABLE_MEDIA, "media");
 956                 media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 957
 958                 ret = _media_svc_sql_query(db_handle, sql, uid);
 959                 sqlite3_free(sql);
 960
 961                 sql = sqlite3_mprintf("UPDATE %q SET storage_uuid  = '%q';",MEDIA_SVC_DB_TABLE_FOLDER, "media");
 962                 media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 963
 964                 ret = _media_svc_sql_query(db_handle, sql, uid);
 965                 sqlite3_free(sql);
 966         }
 967
 968         ret = __media_svc_rebuild_view_query(db_handle, uid);
 969
 970         sql = sqlite3_mprintf("PRAGMA user_version=%d;", LATEST_VERSION_NUMBER);
 971         media_svc_retv_if(sql == NULL, MS_MEDIA_ERR_OUT_OF_MEMORY);
 972
 973         ret = _media_svc_sql_query(db_handle, sql, uid);
 974         sqlite3_free(sql);
 975
 976         _media_svc_destroy_table_query();
 977
 978         return ret;
 979 }
 980
 981 int _media_svc_sql_query(sqlite3 *db_handle, const char *sql_str, uid_t uid)
 982 {
 983         int ret = MS_MEDIA_ERR_NONE;
 984
 985         media_svc_sec_debug("[SQL query] : %s", sql_str);
 986
 987         ret = media_db_request_update_db(sql_str, uid);
 988
 989         return ret;
 990 }
 991
 992 int _media_svc_sql_prepare_to_step(sqlite3 *handle, const char *sql_str, sqlite3_stmt **stmt)
 993 {
 994         int err = -1;
 995
 996         media_svc_sec_debug("[SQL query] : %s", sql_str);
 997
 998         if (!STRING_VALID(sql_str)) {
 999                 media_svc_error("invalid query");
1000                 return MS_MEDIA_ERR_INVALID_PARAMETER;
1001         }
1002
1003         err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
1004         sqlite3_free((char *)sql_str);
1005
1006         if (err != SQLITE_OK) {
1007                 media_svc_error("prepare error %d[%s]", err, sqlite3_errmsg(handle));
1008                 if (err == SQLITE_CORRUPT) {
1009                         return MS_MEDIA_ERR_DB_CORRUPT;
1010                 } else if (err == SQLITE_PERM) {
1011                         return MS_MEDIA_ERR_DB_PERMISSION;
1012                 }
1013
1014                 return MS_MEDIA_ERR_DB_INTERNAL;
1015         }
1016
1017         err = sqlite3_step(*stmt);
1018         if (err != SQLITE_ROW) {
1019                 media_svc_error("[No-Error] Item not found. end of row [%s]", sqlite3_errmsg(handle));
1020                 SQLITE3_FINALIZE(*stmt);
1021                 return MS_MEDIA_ERR_DB_NO_RECORD;
1022         }
1023
1024         return MS_MEDIA_ERR_NONE;
1025 }
1026
1027 int _media_svc_sql_prepare_to_step_simple(sqlite3 *handle, const char *sql_str, sqlite3_stmt **stmt)
1028 {
1029         int err = -1;
1030
1031         media_svc_sec_debug("[SQL query] : %s", sql_str);
1032
1033         if (!STRING_VALID(sql_str)) {
1034                 media_svc_error("invalid query");
1035                 return MS_MEDIA_ERR_INVALID_PARAMETER;
1036         }
1037
1038         err = sqlite3_prepare_v2(handle, sql_str, -1, stmt, NULL);
1039         sqlite3_free((char *)sql_str);
1040
1041         if (err != SQLITE_OK) {
1042                 media_svc_error("prepare error %d[%s]", err, sqlite3_errmsg(handle));
1043                 if (err == SQLITE_CORRUPT) {
1044                         return MS_MEDIA_ERR_DB_CORRUPT;
1045                 } else if (err == SQLITE_PERM) {
1046                         return MS_MEDIA_ERR_DB_PERMISSION;
1047                 }
1048
1049                 return MS_MEDIA_ERR_DB_INTERNAL;
1050         }
1051
1052         return MS_MEDIA_ERR_NONE;
1053 }
1054
1055 int _media_svc_sql_begin_trans(sqlite3 *handle, uid_t uid)
1056 {
1057         int ret = MS_MEDIA_ERR_NONE;
1058
1059         media_svc_error("========_media_svc_sql_begin_trans");
1060
1061         ret = media_db_request_update_db_batch_start("BEGIN IMMEDIATE;", uid);
1062
1063         return ret;
1064 }
1065
1066 int _media_svc_sql_end_trans(sqlite3 *handle, uid_t uid)
1067 {
1068         int ret = MS_MEDIA_ERR_NONE;
1069
1070         media_svc_error("========_media_svc_sql_end_trans");
1071
1072         ret = media_db_request_update_db_batch_end("COMMIT;", uid);
1073
1074         return ret;
1075 }
1076
1077 int _media_svc_sql_rollback_trans(sqlite3 *handle, uid_t uid)
1078 {
1079         media_svc_error("========_media_svc_sql_rollback_trans");
1080
1081         return _media_svc_sql_query(handle, "ROLLBACK;", uid);
1082 }
1083
1084 int _media_svc_sql_query_list(sqlite3 *handle, GList **query_list, uid_t uid)
1085 {
1086         int ret = MS_MEDIA_ERR_NONE;
1087         int idx = 0;
1088         int length = g_list_length(*query_list);
1089         char *sql = NULL;
1090
1091         media_svc_debug("query list length : [%d]", length);
1092
1093         for (idx = 0; idx < length; idx++) {
1094                 sql = (char *)g_list_nth_data(*query_list, idx);
1095                 if (sql != NULL) {
1096                         /*ret = _media_svc_sql_query(handle, sql); */
1097                         ret = media_db_request_update_db_batch(sql, uid);
1098                         if (ret != MS_MEDIA_ERR_NONE) {
1099                                 media_svc_error("media_db_request_update_db_batch failed : %d", ret);
1100                         }
1101                         sqlite3_free(sql);
1102                         sql = NULL;
1103                 }
1104         }
1105
1106         _media_svc_sql_query_release(query_list);
1107
1108         return MS_MEDIA_ERR_NONE;
1109
1110 }
1111
1112 void _media_svc_sql_query_add(GList **query_list, char **query)
1113 {
1114         *query_list = g_list_append(*query_list, *query);
1115 }
1116
1117 void _media_svc_sql_query_release(GList **query_list)
1118 {
1119         if (*query_list) {
1120                 media_svc_debug("_svc_sql_query_release");
1121                 g_list_free(*query_list);
1122                 *query_list = NULL;
1123         }
1124 }
1125
1126 int _media_svc_check_db_upgrade(sqlite3 *db_handle, bool *need_full_scan, uid_t uid)
1127 {
1128         int ret = MS_MEDIA_ERR_NONE;
1129         sqlite3_stmt *sql_stmt = NULL;
1130         int cur_version;
1131         char *sql = sqlite3_mprintf("PRAGMA user_version");
1132
1133         ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
1134
1135         if (ret != MS_MEDIA_ERR_NONE) {
1136                 media_svc_error("error when get user_version. err = [%d]", ret);
1137                 return ret;
1138         }
1139
1140         cur_version = sqlite3_column_int(sql_stmt, 0);
1141
1142         SQLITE3_FINALIZE(sql_stmt);
1143
1144         if (cur_version < LATEST_VERSION_NUMBER) {
1145                 if(cur_version < USER_V4) {
1146                         *need_full_scan = true;
1147                 }
1148                 media_svc_error("Current DB is out of date(%d).. So start to upgrade DB(%d)", cur_version, LATEST_VERSION_NUMBER);
1149                 return __media_svc_db_upgrade(db_handle, cur_version, uid);
1150         } else {
1151                 return MS_MEDIA_ERR_NONE;
1152         }
1153 }
1154
1155 int _media_db_check_corrupt(sqlite3 *db_handle)
1156 {
1157         int ret = MS_MEDIA_ERR_NONE;
1158         char *sql = sqlite3_mprintf("PRAGMA quick_check(1)");
1159         sqlite3_stmt *sql_stmt = NULL;
1160         char *result = NULL;
1161
1162         ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
1163         if (ret != MS_MEDIA_ERR_NONE) {
1164                 media_svc_error("error when check db. err = [%d]", ret);
1165                 return ret;
1166         }
1167
1168         result = (char *)sqlite3_column_text(sql_stmt, 0);
1169         SQLITE3_FINALIZE(sql_stmt);
1170
1171         if (result != NULL) {
1172                 media_svc_debug("result %s", result);
1173                 if (strcasecmp(result, "OK"))
1174                         ret = MS_MEDIA_ERR_DB_CORRUPT;
1175         } else {
1176                 media_svc_error("result is NULL");
1177                 ret = MS_MEDIA_ERR_DB_INTERNAL;
1178         }
1179
1180         return ret;
1181 }
1182
1183
1184 int _media_svc_create_media_table_with_id(sqlite3 *db_handle, const char *table_id, uid_t uid)
1185 {
1186         int ret = MS_MEDIA_ERR_NONE;
1187
1188         ret = _media_svc_init_table_query(table_id);
1189         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1190
1191         ret = _media_svc_make_table_query(db_handle, table_id, MEDIA_SVC_DB_LIST_MEDIA, uid);
1192         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1193
1194         /* Add for trigger */
1195         ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_FOLDER, MEDIA_SVC_DB_LIST_FOLDER, uid);
1196         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1197
1198         ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_PLAYLIST_MAP, MEDIA_SVC_DB_LIST_PLAYLIST_MAP, uid);
1199         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1200
1201         ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_ALBUM, MEDIA_SVC_DB_LIST_ALBUM, uid);
1202         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1203
1204         ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_TAG_MAP, MEDIA_SVC_DB_LIST_TAG_MAP, uid);
1205         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1206
1207         ret = _media_svc_make_table_query(db_handle, MEDIA_SVC_DB_TABLE_BOOKMARK, MEDIA_SVC_DB_LIST_BOOKMARK, uid);
1208         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1209
1210         _media_svc_destroy_table_query();
1211
1212         return ret;
1213 }
1214
1215 int _media_svc_drop_media_table(sqlite3 *handle, const char *storage_id, uid_t uid)
1216 {
1217         int ret = MS_MEDIA_ERR_NONE;
1218
1219         char *sql = sqlite3_mprintf("DROP TABLE IF EXISTS '%q'", storage_id);
1220
1221         ret = _media_svc_sql_query(handle, sql, uid);
1222         sqlite3_free(sql);
1223
1224         return ret;
1225 }
1226
1227 int _media_svc_update_media_view(sqlite3 *db_handle, uid_t uid)
1228 {
1229         int ret = MS_MEDIA_ERR_NONE;
1230         char *sql = NULL;
1231         sqlite3_stmt *sql_stmt = NULL;
1232         int item_cnt = 0;
1233         int idx = 0;
1234         GList *storage_list = NULL;
1235         char view_query[4096] = {0, };
1236         memset(view_query, 0x00, sizeof(view_query));
1237
1238         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);
1239
1240         /*Select list of storage*/
1241         sql = sqlite3_mprintf("SELECT storage_uuid FROM '%s' WHERE validity=1 AND storage_uuid != '%s'", MEDIA_SVC_DB_TABLE_STORAGE, MEDIA_SVC_DB_TABLE_MEDIA);
1242         ret = _media_svc_sql_prepare_to_step_simple(db_handle, sql, &sql_stmt);
1243         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1244
1245         while (sqlite3_step(sql_stmt) == SQLITE_ROW) {
1246                 if (STRING_VALID((const char *)sqlite3_column_text(sql_stmt, 0))) {
1247                         storage_list = g_list_append(storage_list, strdup((char *)sqlite3_column_text(sql_stmt, 0)));
1248                 }
1249         }
1250         SQLITE3_FINALIZE(sql_stmt);
1251
1252         if ((storage_list != NULL) && (g_list_length(storage_list) > 0)) {
1253                 item_cnt = g_list_length(storage_list);
1254
1255                 for (idx = 0; idx < item_cnt; idx++) {
1256                         int table_cnt = 0;
1257                         char *storage_id = NULL;
1258                         storage_id = g_list_nth_data(storage_list, idx);
1259
1260                         if (STRING_VALID(storage_id)) {
1261                                 /*Select list of storage*/
1262                                 sql = sqlite3_mprintf("SELECT COUNT(*) FROM SQLITE_MASTER WHERE type='table' and name='%q'", storage_id);
1263                                 ret = _media_svc_sql_prepare_to_step(db_handle, sql, &sql_stmt);
1264                                 if (ret != MS_MEDIA_ERR_NONE) {
1265                                         SAFE_FREE(storage_id);
1266                                         continue;
1267                                 }
1268
1269                                 table_cnt = sqlite3_column_int(sql_stmt, 0);
1270                                 SQLITE3_FINALIZE(sql_stmt);
1271
1272                                 if (table_cnt > 0) {
1273                                         char append_query[128] = {0, };
1274                                         memset(append_query, 0x00, sizeof(append_query));
1275                                         snprintf(append_query, sizeof(append_query), " UNION SELECT * from '%s'", storage_id);
1276                                         strncat(view_query, append_query, strlen(append_query));
1277                                 } else {
1278                                         media_svc_error("media table not exist for storage [%s]", storage_id);
1279                                 }
1280
1281                                 SAFE_FREE(storage_id);
1282                         }
1283                 }
1284                 g_list_free(storage_list);
1285         }
1286
1287         ret = _media_svc_sql_query(db_handle, view_query, uid);
1288         media_svc_retv_if(ret != MS_MEDIA_ERR_NONE, ret);
1289
1290         return ret;
1291 }