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