Merge all storage tables

[platform/core/api/media-content.git] / src / media_db.c

diff --git a/src/media_db.c b/src/media_db.c
index dd2ea03..b69774d 100755 (executable)
--- a/src/media_db.c
+++ b/src/media_db.c
@@ -19,8 +19,7 @@
 #include <media_info_private.h>
 #include <media_util_private.h>
 
-static char * __media_db_get_group_name(media_group_e group);
-static int __media_db_make_query(filter_h filter, attribute_h attr, char *select_query, int select_query_size, char **condition_query, char **option_query);
+static int __media_db_make_query(filter_h filter, char *select_query, int select_query_size, char **condition_query, char **option_query);
 
 static char * __media_db_get_group_name(media_group_e group)
 {
@@ -182,7 +181,7 @@ static char * __media_db_get_group_name(media_group_e group)
        return NULL;
 }
 
-static int __media_db_make_query(filter_h filter, attribute_h attr, char *select_query, int select_query_size, char **condition_query, char **option_query)
+static int __media_db_make_query(filter_h filter, char *select_query, int select_query_size, char **condition_query, char **option_query)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
        filter_s *_filter = NULL;
@@ -191,20 +190,20 @@ static int __media_db_make_query(filter_h filter, attribute_h attr, char *select
                _filter = (filter_s*)filter;
 
                if (STRING_VALID(_filter->condition)) {
-                       ret = _media_filter_attribute_generate(attr, filter, condition_query);
+                       ret = _media_filter_attribute_generate(filter, condition_query);
                        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
                }
 
                if (_filter->is_full_order == false) {
                        /* Process for filter v1 */
-                       ret = _media_filter_attribute_option_generate(attr, filter, option_query);
+                       ret = _media_filter_attribute_option_generate(filter, option_query);
                        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                                SAFE_FREE(*condition_query);
                                return ret;
                        }
                } else {
                        /* Process for filter v2 */
-                       ret = _media_filter_attribute_option_generate_with_full_query(attr, filter, option_query);
+                       ret = _media_filter_attribute_option_generate_with_full_query(filter, option_query);
                        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                                SAFE_FREE(*condition_query);
                                return ret;
@@ -220,6 +219,7 @@ static int __media_db_make_query(filter_h filter, attribute_h attr, char *select
        return ret;
 }
 
+#ifdef _USE_TVPD_MODE
 int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
@@ -227,10 +227,8 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
        char select_query[MAX_QUERY_SIZE] = {0, };
        char *condition_query = NULL;
        char *option_query = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        switch (group_type) {
@@ -244,8 +242,6 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                }
                break;
        case MEDIA_GROUP_ALBUM:
-               attr = _content_get_alias_attirbute_handle();
-
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT, _filter->storage_id);
                else
@@ -253,8 +249,6 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
 
                break;
        case MEDIA_GROUP_FOLDER:
-               attr = _content_get_alias_attirbute_handle();
-
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
                else
@@ -274,8 +268,6 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                }
                break;
        case MEDIA_GROUP_BOOKMARK:
-               attr = _content_get_alias_attirbute_handle();
-
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT, _filter->storage_id);
                else
@@ -289,17 +281,13 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                }
                break;
        case MEDIA_GROUP_FACE:
-               attr = _content_get_alias_attirbute_handle();
-
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, _filter->storage_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT, DB_VIEW_MEDIA);
                break;
-#ifdef _USE_TVPD_MODE
        case MEDIA_GROUP_PVR:
        case MEDIA_GROUP_UHD:
-#endif
        default:
                {
                        media_content_error("Invalid group type [%d]", group_type);
@@ -308,10 +296,10 @@ int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *gro
                break;
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -331,12 +319,9 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        char select_query[MAX_QUERY_SIZE] = {0, };
        char *condition_query = NULL;
        char *option_query = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
-#ifdef _USE_TVPD_MODE
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content*/
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
@@ -353,13 +338,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
                else
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_COUNT, __media_db_get_group_name(group));
        }
-#else
-       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), _filter->storage_id);
-       else
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group), DB_VIEW_MEDIA);
-#endif
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
@@ -372,7 +351,7 @@ int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *g
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -393,12 +372,8 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
        char *option_query = NULL;
        char *name = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
-
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
-#ifdef _USE_TVPD_MODE
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
@@ -415,16 +390,10 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
                else
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_LIST, __media_db_get_group_name(group));
        }
-#else
-       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), _filter->storage_id);
-       else
-               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group), DB_VIEW_MEDIA);
-#endif
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -444,7 +413,7 @@ int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_
 
        return ret;
 }
-#ifdef _USE_TVPD_MODE
+
 int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, media_group_and_count_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
@@ -454,10 +423,8 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        char *option_query = NULL;
        char *name = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
        memset(group_query, 0x00, sizeof(group_query));
 
@@ -484,7 +451,7 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
                        snprintf(select_query, sizeof(select_query), SELECT_UHD_GROUP_AND_COUNT, group_name);
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        if (STRING_VALID(option_query))
@@ -492,7 +459,7 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
        else
                snprintf(group_query, sizeof(group_query), "GROUP BY %s", group_name);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, group_query);
+       ret = _content_query_prepare(select_query, condition_query, group_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -513,7 +480,179 @@ int _media_db_get_media_group_and_count(media_group_e group, filter_h filter, me
 
        return ret;
 }
+#else
+int _media_db_get_group_count(filter_h filter, group_list_e group_type, int *group_count)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       sqlite3_stmt *stmt = NULL;
+       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *condition_query = NULL;
+       char *option_query = NULL;
+       filter_s *_filter = (filter_s*)filter;
+
+       memset(select_query, 0x00, sizeof(select_query));
+
+       switch (group_type) {
+       case MEDIA_GROUP_NONE:
+       case MEDIA_GROUP_TAG_BY_MEDIA_ID:
+       case MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID:
+       case MEDIA_GROUP_FACE_BY_MEDIA_ID:
+               {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_ALBUM:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_ALBUM_COUNT);
+
+               break;
+       case MEDIA_GROUP_FOLDER:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_FOLDER_COUNT);
+
+               break;
+       case MEDIA_GROUP_PLAYLIST:
+               if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_COUNT, sizeof(select_query))) {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_TAG:
+               if (!SAFE_STRLCPY(select_query, SELECT_TAG_COUNT, sizeof(select_query))) {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_BOOKMARK:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_COUNT);
+
+               break;
+       case MEDIA_GROUP_STORAGE:
+               if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_COUNT, sizeof(select_query))) {
+                       media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       case MEDIA_GROUP_FACE:
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_COUNT);
+               break;
+       default:
+               {
+                       media_content_error("Invalid group type [%d]", group_type);
+                       return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+               }
+               break;
+       }
+
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       if (sqlite3_step(stmt) == SQLITE_ROW)
+               *group_count = (int)sqlite3_column_int(stmt, 0);
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
+
+int _media_db_get_media_group_count(media_group_e group, filter_h filter, int *group_count)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       sqlite3_stmt *stmt = NULL;
+       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *condition_query = NULL;
+       char *option_query = NULL;
+       filter_s *_filter = (filter_s*)filter;
+
+       memset(select_query, 0x00, sizeof(select_query));
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_COUNT, __media_db_get_group_name(group));
+
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
+       if (STRING_VALID(condition_query))
+               SAFE_STRLCAT(select_query, condition_query, sizeof(select_query));
+       if (STRING_VALID(option_query))
+               SAFE_STRLCAT(select_query, option_query, sizeof(select_query));
+       SAFE_STRLCAT(select_query, QUERY_KEYWORD_BRACKET, sizeof(select_query));
+
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       if (sqlite3_step(stmt) == SQLITE_ROW)
+               *group_count = (int)sqlite3_column_int(stmt, 0);
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
+
+int _media_db_get_media_group(media_group_e group, filter_h filter, media_group_cb callback, void *user_data)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       char select_query[MAX_QUERY_SIZE] = {0, };
+       char *condition_query = NULL;
+       char *option_query = NULL;
+       char *name = NULL;
+       sqlite3_stmt *stmt = NULL;
+       filter_s *_filter = (filter_s*)filter;
+       memset(select_query, 0x00, sizeof(select_query));
+
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_GROUP_LIST, __media_db_get_group_name(group));
+
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
+       SAFE_FREE(condition_query);
+       SAFE_FREE(option_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       while (sqlite3_step(stmt) == SQLITE_ROW) {
+               name = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+
+               if (callback(name, user_data) == false) {
+                       SAFE_FREE(name);
+                       break;
+               }
+
+               SAFE_FREE(name);
+       }
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
 #endif
+
 int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_data)
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
@@ -521,21 +660,24 @@ int _media_db_get_album(filter_h filter, media_album_cb callback, void *user_dat
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_alias_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, _filter->storage_id);
        else
                snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST, DB_VIEW_MEDIA);
-
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+#else
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST_BY_STORAGE_ID, _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_ALBUM_LIST);
+#endif
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -574,22 +716,24 @@ int _media_db_get_folder(filter_h filter, media_folder_cb callback, void *user_d
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_alias_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id, _filter->storage_id);
        else
                snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST, DB_VIEW_MEDIA);
-
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+#else
+       if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+               snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST_BY_STORAGE_ID, _filter->storage_id);
+       else
+               snprintf(select_query, sizeof(select_query), SELECT_FOLDER_LIST);
+#endif
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
-
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -629,9 +773,7 @@ int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *us
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if (!SAFE_STRLCPY(select_query, SELECT_PLAYLIST_LIST, sizeof(select_query))) {
@@ -639,10 +781,10 @@ int _media_db_get_playlist(filter_h filter, media_playlist_cb callback, void *us
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -679,18 +821,15 @@ int _media_db_get_playlist_item(int playlist_id, filter_h filter, playlist_membe
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
-       /*snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ID_FROM_PLAYLIST_VIEW, playlist_id);*/
        snprintf(select_query, sizeof(select_query), SELECT_PLAYLIST_ITEM_ALL_FROM_PLAYLIST_VIEW, playlist_id);
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -729,9 +868,7 @@ int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callba
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if (!STRING_VALID(media_id)) {
@@ -742,12 +879,12 @@ int _media_db_get_tag(const char *media_id, filter_h filter, media_tag_cb callba
        } else
                snprintf(select_query, sizeof(select_query), SELECT_TAG_LIST_BY_MEDIA_ID, media_id);
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
        SAFE_STRLCAT(select_query, QUERY_KEYWORD_SPACE, sizeof(select_query));
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -783,13 +920,10 @@ int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_alias_attirbute_handle();
-
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (STRING_VALID(media_id)) {   //get bookmark by media_id
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
@@ -801,11 +935,21 @@ int _media_db_get_bookmark(const char *media_id, filter_h filter, media_bookmark
                else
                        snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST, DB_VIEW_MEDIA);
        }
+#else
+       if (STRING_VALID(media_id)) {   //get bookmark by media_id
+               snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_MEDIA_ID, media_id);
+       } else {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_BOOKMARK_LIST);
+       }
+#endif
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -846,13 +990,10 @@ int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb call
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_alias_attirbute_handle();
-
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (STRING_VALID(media_id)) {   //get face by media_id
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, _filter->storage_id, media_id);
@@ -864,11 +1005,20 @@ int _media_db_get_face(const char *media_id, filter_h filter, media_face_cb call
                else
                        snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST, DB_VIEW_MEDIA);
        }
-
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+#else
+       if (STRING_VALID(media_id)) {   //get face by media_id
+               snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_MEDIA_ID, media_id);
+       } else {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_FACE_LIST);
+       }
+#endif
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -912,17 +1062,22 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
        char select_query[MAX_QUERY_SIZE] = {0, };
        char *condition_query = NULL;
        char *option_query = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if (group_type == MEDIA_GROUP_ALBUM) {
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, _filter->storage_id, group_id);
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, DB_VIEW_MEDIA, group_id);
+#else
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_ALBUM, group_id);
+#endif
        } else if (group_type == MEDIA_GROUP_PLAYLIST) {
                snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_PLAYLIST, group_id);
        } else if (group_type == MEDIA_GROUP_TAG) {
@@ -932,10 +1087,10 @@ int _media_db_get_group_item_count_by_id(int group_id, filter_h filter, group_li
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -957,10 +1112,8 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
        char *condition_query = NULL;
        char *option_query = NULL;
        bool is_simple = FALSE;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if (group_type == MEDIA_GROUP_NONE) {
@@ -968,44 +1121,66 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
                        If user wants to set offset and count, use SQL SELECT_MEDIA_COUNT_FROM_MEDIA.
                        If user wants to get count without setting count, SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE */
                if (_filter && ((_filter->offset < 0) && (_filter->count < 0))) {
+#ifdef _USE_TVPD_MODE
                                if (STRING_VALID(_filter->storage_id))
                                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, _filter->storage_id);
                                else
                                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE, DB_VIEW_MEDIA);
+#else
+                               if (STRING_VALID(_filter->storage_id))
+                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE_BY_STORAGE_ID, _filter->storage_id);
+                               else
+                                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA_SIMPLE);
+#endif
                                is_simple = TRUE;
                } else {
+#ifdef _USE_TVPD_MODE
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA, DB_VIEW_MEDIA);
+#else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_MEDIA);
+#endif
                }
        } else if (group_type == MEDIA_GROUP_FOLDER) {
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, _filter->storage_id, group_name);
                else
                        tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
-
+#else
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER_BY_STORAGE_ID, group_name, _filter->storage_id);
+               else
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_FOLDER, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
        } else if (group_type == MEDIA_GROUP_TAG_BY_MEDIA_ID) {
                snprintf(select_query, sizeof(select_query), SELECT_TAG_COUNT_BY_MEDIA_ID, group_name);
        } else if (group_type == MEDIA_GROUP_BOOKMARK_BY_MEDIA_ID) {
-               attr = _content_get_alias_attirbute_handle();
-
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
                else
                        tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
-
+#else
+               tmp_query = sqlite3_mprintf(SELECT_BOOKMARK_COUNT_BY_MEDIA_ID, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
        } else if (group_type == MEDIA_GROUP_STORAGE) {
+#ifdef _USE_TVPD_MODE
                tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name, group_name);
-
+#else
+               tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_STORAGE, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
        } else if (group_type == MEDIA_GROUP_FACE_BY_MEDIA_ID) {
-               attr = _content_get_alias_attirbute_handle();
-
+#ifdef _USE_TVPD_MODE
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, _filter->storage_id, group_name);
                else
                        tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, DB_VIEW_MEDIA, group_name);
-
+#else
+               tmp_query = sqlite3_mprintf(SELECT_FACE_COUNT_BY_MEDIA_ID, group_name);
+#endif
                SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
 #ifdef _USE_TVPD_MODE
        } else if (group_type == MEDIA_GROUP_PVR) {
@@ -1024,7 +1199,7 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                if (tmp_query != NULL)
                        SQLITE3_SAFE_FREE(tmp_query);
@@ -1045,7 +1220,7 @@ int _media_db_get_group_item_count(const char *group_name, filter_h filter, grou
                SAFE_FREE(option_query);
        }
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                SQLITE3_SAFE_FREE(tmp_query);
        SAFE_FREE(condition_query);
@@ -1067,12 +1242,11 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
+#ifdef _USE_TVPD_MODE
        if (group_type == MEDIA_GROUP_ALBUM) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, _filter->storage_id, group_id);
@@ -1092,11 +1266,31 @@ int _media_db_get_group_item_by_id(int group_id, filter_h filter, media_info_cb
                media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
-
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+#else
+       if (group_type == MEDIA_GROUP_ALBUM) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_ALBUM, group_id);
+       } else if (group_type == MEDIA_GROUP_PLAYLIST) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_PLAYLIST, group_id);
+       } else if (group_type == MEDIA_GROUP_TAG) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG_BY_STORAGE_ID, group_id, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_TAG, group_id);
+       } else {
+               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+       }
+#endif
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1131,12 +1325,10 @@ int _media_db_get_group_item(const char *group_name, filter_h filter, media_info
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (group_type == MEDIA_GROUP_NONE) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM, _filter->storage_id);
@@ -1153,11 +1345,25 @@ int _media_db_get_group_item(const char *group_name, filter_h filter, media_info
                media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
-
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+#else
+       if (group_type == MEDIA_GROUP_NONE) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM_BY_STORAGE_ID, _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_ITEM);
+       } else if (group_type == MEDIA_GROUP_FOLDER) {
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_FOLDER, group_name);
+       } else if (group_type == MEDIA_GROUP_STORAGE) {
+               snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_STORAGE, group_name);
+       } else {
+               media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
+               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+       }
+#endif
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1196,12 +1402,9 @@ int _media_db_get_group_item_by_union_select(const char *group_name, filter_h fi
        char *condition_query2 = NULL;
        char *option_query2 = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter1 = (filter_s*)filter1;
        filter_s *_filter2 = (filter_s*)filter2;
 
-       attr = _content_get_attirbute_handle();
-
        memset(select_query1, 0x00, sizeof(select_query1));
 
        if ((_filter1 != NULL) && STRING_VALID(_filter1->storage_id))
@@ -1209,7 +1412,7 @@ int _media_db_get_group_item_by_union_select(const char *group_name, filter_h fi
        else
                snprintf(select_query1, sizeof(select_query1), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
 
-       ret = __media_db_make_query(filter1, attr, select_query1, sizeof(select_query1), &condition_query1, &option_query1);
+       ret = __media_db_make_query(filter1, select_query1, sizeof(select_query1), &condition_query1, &option_query1);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                SAFE_FREE(condition_query1);
                SAFE_FREE(option_query1);
@@ -1224,7 +1427,7 @@ int _media_db_get_group_item_by_union_select(const char *group_name, filter_h fi
        else
                snprintf(select_query2, sizeof(select_query2), SELECT_MEDIA_FROM_FOLDER, DB_VIEW_MEDIA, group_name);
 
-       ret = __media_db_make_query(filter2, attr, select_query2, sizeof(select_query2), &condition_query2, &option_query2);
+       ret = __media_db_make_query(filter2, select_query2, sizeof(select_query2), &condition_query2, &option_query2);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                SAFE_FREE(condition_query1);
                SAFE_FREE(option_query1);
@@ -1273,10 +1476,8 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        char *tmp_query = NULL;
        char *condition_query = NULL;
        char *option_query = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 #ifdef _USE_TVPD_MODE
        if (group < MEDIA_PVR_GROUP_DURATION) { /*media content */
@@ -1325,20 +1526,20 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
 #else
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id)) {
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
                        SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
                } else {
-                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, DB_VIEW_MEDIA, __media_db_get_group_name(group), group_name);
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_COUNT_FROM_GROUP, __media_db_get_group_name(group), group_name);
                        SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
                }
        } else {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, _filter->storage_id, __media_db_get_group_name(group));
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
                else
-                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_COUNT_FROM_GROUP_NULL, __media_db_get_group_name(group));
        }
 #endif
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                if (tmp_query != NULL)
                        SQLITE3_SAFE_FREE(tmp_query);
@@ -1355,7 +1556,7 @@ int _media_db_get_media_group_item_count(const char *group_name, filter_h filter
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                SQLITE3_SAFE_FREE(tmp_query);
        SAFE_FREE(condition_query);
@@ -1378,12 +1579,10 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
-
+#ifdef _USE_TVPD_MODE
        if (group_name != NULL) {
                if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
                        tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, _filter->storage_id, __media_db_get_group_name(group), group_name);
@@ -1397,15 +1596,29 @@ int _media_db_get_media_group_item(const char *group_name, filter_h filter, medi
                else
                        snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, DB_VIEW_MEDIA, __media_db_get_group_name(group));
        }
+#else
+       if (group_name != NULL) {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP_BY_STORAGE_ID, __media_db_get_group_name(group), group_name, _filter->storage_id);
+               else
+                       tmp_query = sqlite3_mprintf(SELECT_MEDIA_FROM_GROUP, __media_db_get_group_name(group), group_name);
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+               SAFE_STRLCAT(select_query, tmp_query, sizeof(select_query));
+       } else {
+               if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL_BY_STORAGE_ID, __media_db_get_group_name(group), _filter->storage_id);
+               else
+                       snprintf(select_query, sizeof(select_query), SELECT_MEDIA_FROM_GROUP_NULL, __media_db_get_group_name(group));
+       }
+#endif
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                if (tmp_query != NULL)
                        SQLITE3_SAFE_FREE(tmp_query);
                return ret;
        }
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                SQLITE3_SAFE_FREE(tmp_query);
        SAFE_FREE(condition_query);
@@ -1442,9 +1655,7 @@ int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if (!SAFE_STRLCPY(select_query, SELECT_STORAGE_LIST, sizeof(select_query))) {
@@ -1452,10 +1663,10 @@ int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user
                return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1485,6 +1696,31 @@ int _media_db_get_storage(filter_h filter, media_storage_cb callback, void *user
 
        return ret;
 }
+
+int _media_db_get_storage_id_by_media_id(const char *media_id, char **storage_id)
+{
+       int ret = MEDIA_CONTENT_ERROR_NONE;
+       sqlite3_stmt *stmt = NULL;
+       char *select_query = NULL;
+
+       select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
+
+       ret = _content_get_result(select_query, &stmt);
+       SQLITE3_SAFE_FREE(select_query);
+       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
+
+       if (sqlite3_step(stmt) == SQLITE_ROW) {
+               *storage_id = g_strdup((const char *)sqlite3_column_text(stmt, 0));
+       } else {
+               media_content_error("Invalid media_id[%s]", media_id);
+               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
+       }
+
+       SQLITE3_FINALIZE(stmt);
+
+       return ret;
+}
+
 #ifdef _USE_TVPD_MODE
 int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_group_e group, media_pvr_cb callback, void *user_data)
 {
@@ -1494,10 +1730,8 @@ int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if (group_name != NULL) {
@@ -1514,14 +1748,14 @@ int _media_db_get_pvr_group_item(const char *group_name, filter_h filter, media_
                        snprintf(select_query, sizeof(select_query), SELECT_PVR_FROM_GROUP_NULL, __media_db_get_group_name(group));
        }
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        if (ret != MEDIA_CONTENT_ERROR_NONE) {
                if (tmp_query != NULL)
                        sqlite3_free(tmp_query);
                return ret;
        }
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        if (tmp_query != NULL)
                sqlite3_free(tmp_query);
        SAFE_FREE(condition_query);
@@ -1725,10 +1959,8 @@ int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
@@ -1736,10 +1968,10 @@ int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
        else
                SAFE_STRLCAT(select_query, SELECT_PVR_LIST, sizeof(select_query));
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
@@ -1767,38 +1999,7 @@ int _media_db_get_pvr(filter_h filter, media_pvr_cb callback, void *user_data)
 
        return ret;
 }
-#endif
 
-int _media_db_get_storage_id_by_media_id(const char *media_id, char *storage_id)
-{
-       int ret = MEDIA_CONTENT_ERROR_NONE;
-       sqlite3_stmt *stmt = NULL;
-       char *select_query = NULL;
-
-       select_query = sqlite3_mprintf(SELECT_MEDIA_STORAGE_ID_BY_ID, media_id);
-
-       ret = _content_query_prepare(&stmt, select_query, NULL, NULL);
-       SQLITE3_SAFE_FREE(select_query);
-       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
-
-       if (sqlite3_step(stmt) == SQLITE_ROW) {
-               if (STRING_VALID((const char *)sqlite3_column_text(stmt, 0))) {
-                       if (!SAFE_STRLCPY(storage_id, (const char *)sqlite3_column_text(stmt, 0), MEDIA_CONTENT_UUID_SIZE+1)) {
-                               media_content_error("Storage id copy fail");
-                               ret = MEDIA_CONTENT_ERROR_INVALID_OPERATION;
-                       }
-               }
-       } else {
-               media_content_error("There's no media!!");
-               ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
-
-       SQLITE3_FINALIZE(stmt);
-
-       return ret;
-}
-
-#ifdef _USE_TVPD_MODE
 typedef enum {
        MEDIA_UHD_MEDIA_ID = 0,
        MEDIA_UHD_STORAGE_ID,
@@ -1857,10 +2058,8 @@ int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
        char *condition_query = NULL;
        char *option_query = NULL;
        sqlite3_stmt *stmt = NULL;
-       attribute_h attr = NULL;
        filter_s *_filter = (filter_s*)filter;
 
-       attr = _content_get_attirbute_handle();
        memset(select_query, 0x00, sizeof(select_query));
 
        if ((_filter != NULL) && STRING_VALID(_filter->storage_id))
@@ -1868,10 +2067,10 @@ int _media_db_get_uhd(filter_h filter, media_uhd_cb callback, void *user_data)
        else
                SAFE_STRLCAT(select_query, SELECT_UHD_LIST, sizeof(select_query));
 
-       ret = __media_db_make_query(filter, attr, select_query, sizeof(select_query), &condition_query, &option_query);
+       ret = __media_db_make_query(filter, select_query, sizeof(select_query), &condition_query, &option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 
-       ret = _content_query_prepare(&stmt, select_query, condition_query, option_query);
+       ret = _content_query_prepare(select_query, condition_query, option_query, &stmt);
        SAFE_FREE(condition_query);
        SAFE_FREE(option_query);
        media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);