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