Refactoring code in media filter

1. Merge API to generate condition
2. Modified to create condition using internal character array instead of out parameter
3. Move condition binding code into _media_filter_attribute_generate()
4. Replace define 'QUERY_KEYWORD_SPACE' instead of 'SPACE' (And remove SPACE)

Change-Id: I25f31f825841f01e3c46b42ee633244149b9c0c6
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>

diff --git a/include/media_info_private.h b/include/media_info_private.h
index 6a06dd0..b0faebc 100755 (executable)
--- a/include/media_info_private.h
+++ b/include/media_info_private.h
@@ -536,12 +536,13 @@ typedef struct _media_content_cb_data {
 /* DB Query Keyword */
 #define QUERY_KEYWORD_AND "AND"
 #define QUERY_KEYWORD_OR "OR"
-#define QUERY_KEYWORD_ORDER_BY "ORDER BY"
+#define QUERY_KEYWORD_ORDER_BY "ORDER BY "
 #define QUERY_KEYWORD_LIMIT "limit"
 #define QUERY_KEYWORD_DESC "DESC"
 #define QUERY_KEYWORD_SPACE " "
 #define QUERY_KEYWORD_OPEN_BRACKET "("
 #define QUERY_KEYWORD_BRACKET ")"
+#define QUERY_KEYWORD_COLLATE "COLLATE "
 
 /* DB TABLE JOIN */
 /*#define FOLDER_MEDIA_JOIN                                    "("DB_TABLE_FOLDER" AS f LEFT OUTER JOIN '%s' AS m ON f.folder_uuid=m.folder_uuid AND m.validity=1) WHERE f.storage_uuid IN (SELECT storage_uuid FROM "DB_TABLE_STORAGE" WHERE validity=1) " */
@@ -645,7 +646,7 @@ typedef struct _media_content_cb_data {
 #define SELECT_MEDIA_STORAGE_ID_BY_ID          "SELECT storage_uuid FROM "DB_TABLE_MEDIA_VIEW" WHERE media_uuid='%q'"
 
 /* Delete */
-#define DELETE_MEDIA_FROM_MEDIA_BATCH  "DELETE FROM  '%s' WHERE (%s"
+#define DELETE_MEDIA_FROM_MEDIA_BATCH  "DELETE FROM  '%s' WHERE %s"
 #define DELETE_PLAYLIST_FROM_PLAYLIST          "DELETE FROM "DB_TABLE_PLAYLIST" WHERE playlist_id=%d"
 #define DELETE_TAG_FROM_TAG                            "DELETE FROM "DB_TABLE_TAG" WHERE tag_id=%d"
 #define DELETE_BOOKMARK_FROM_BOOKMARK  "DELETE FROM "DB_TABLE_BOOKMARK" WHERE bookmark_id=%d"
@@ -762,10 +763,7 @@ int _media_filter_attribute_destory(attribute_h attr);
  * @see media_filter_attribute_destory()
  *
  */
-int _media_filter_attribute_generate(attribute_h attr, char *condition, media_content_collation_e collate_type, char **generated_condition);
-
-int _media_filter_attribute_generate_with_full_query(attribute_h attr, filter_h filter, char **generated_condition);
-
+int _media_filter_attribute_generate(attribute_h attr, filter_h filter, char **generated_condition);
 
 /**
  * @internal

diff --git a/include_product/media_info_private.h b/include_product/media_info_private.h
index 8a2c6d0..4468bba 100755 (executable)
--- a/include_product/media_info_private.h
+++ b/include_product/media_info_private.h
@@ -691,12 +691,13 @@ typedef struct _media_content_scan_cb_data_v2 {
 /* DB Query Keyword */
 #define QUERY_KEYWORD_AND "AND"
 #define QUERY_KEYWORD_OR "OR"
-#define QUERY_KEYWORD_ORDER_BY "ORDER BY"
+#define QUERY_KEYWORD_ORDER_BY "ORDER BY "
 #define QUERY_KEYWORD_LIMIT "limit"
 #define QUERY_KEYWORD_DESC "DESC"
 #define QUERY_KEYWORD_SPACE " "
 #define QUERY_KEYWORD_OPEN_BRACKET "("
 #define QUERY_KEYWORD_BRACKET ")"
+#define QUERY_KEYWORD_COLLATE "COLLATE "
 
 /* DB TABLE JOIN */
 /*#define FOLDER_MEDIA_JOIN                                    "("DB_TABLE_FOLDER" AS f LEFT OUTER JOIN '%s' AS m ON f.folder_uuid=m.folder_uuid AND m.validity=1) WHERE f.storage_uuid IN (SELECT storage_uuid FROM "DB_TABLE_STORAGE" WHERE validity=1) " */
@@ -815,7 +816,7 @@ typedef struct _media_content_scan_cb_data_v2 {
 #define SELECT_MEDIA_STORAGE_ID_BY_ID          "SELECT storage_uuid FROM "DB_TABLE_MEDIA_VIEW" WHERE media_uuid='%q'"
 
 /* Delete */
-#define DELETE_MEDIA_FROM_MEDIA_BATCH  "DELETE FROM  '%s' WHERE (%s"
+#define DELETE_MEDIA_FROM_MEDIA_BATCH  "DELETE FROM  '%s' WHERE %s"
 #define DELETE_PLAYLIST_FROM_PLAYLIST          "DELETE FROM "DB_TABLE_PLAYLIST" WHERE playlist_id=%d"
 #define DELETE_TAG_FROM_TAG                            "DELETE FROM "DB_TABLE_TAG" WHERE tag_id=%d"
 #define DELETE_BOOKMARK_FROM_BOOKMARK  "DELETE FROM "DB_TABLE_BOOKMARK" WHERE bookmark_id=%d"
@@ -991,10 +992,7 @@ int _media_filter_attribute_destory(attribute_h attr);
  * @see media_filter_attribute_destory()
  *
  */
-int _media_filter_attribute_generate(attribute_h attr, char *condition, media_content_collation_e collate_type, char **generated_condition);
-
-int _media_filter_attribute_generate_with_full_query(attribute_h attr, filter_h filter, char **generated_condition);
-
+int _media_filter_attribute_generate(attribute_h attr, filter_h filter, char **generated_condition);
 
 /**
  * @internal

diff --git a/src/media_db.c b/src/media_db.c
index a88c97f..538f7a3 100755 (executable)
--- a/src/media_db.c
+++ b/src/media_db.c
@@ -208,27 +208,9 @@ static int __media_db_make_query(filter_h filter, attribute_h attr, char *select
        if (filter != NULL) {
                _filter = (filter_s*)filter;
 
-               if (_filter->is_full_condition == false) {
-                       /* Process for filter v1 */
-                       if (STRING_VALID(_filter->condition)) {
-                               /*bracket should be added to condition. If application use "OR" condition, F/W restriction condition like "validity=1" is disregared
-                               ex) select path from media where validity=1 and media_type=3 or media_type=1;*/
-                               char bracket_added_condition[MAX_QUERY_SIZE] = {0, };
-                               memset(bracket_added_condition, 0x00, sizeof(bracket_added_condition));
-
-                               SAFE_STRLCAT(bracket_added_condition, QUERY_KEYWORD_OPEN_BRACKET, sizeof(bracket_added_condition));
-                               SAFE_STRLCAT(bracket_added_condition, _filter->condition, sizeof(bracket_added_condition));
-
-                               ret = _media_filter_attribute_generate(attr, bracket_added_condition, _filter->condition_collate_type, condition_query);
-                               media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
-                       }
-
-               } else {
-                       /* Process for filter v2 */
-                       if (STRING_VALID(_filter->condition)) {
-                               ret = _media_filter_attribute_generate_with_full_query(attr, filter, condition_query);
-                               media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
-                       }
+               if (STRING_VALID(_filter->condition)) {
+                       ret = _media_filter_attribute_generate(attr, filter, condition_query);
+                       media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
                }
 
                if (_filter->is_full_order == false) {

diff --git a/src/media_filter.c b/src/media_filter.c
index b9c32c1..bcdc68d 100755 (executable)
--- a/src/media_filter.c
+++ b/src/media_filter.c
@@ -39,10 +39,6 @@ typedef struct _token_t {
        char *str;
 } token_t;
 
-
-#define MAX_LEFT_VALUE 512
-#define SPACE_LEN 1
-#define SPACE " "
 #define UNKNOWN_TYPE 1000
 #define STRING_TYPE 100
 
@@ -697,85 +693,14 @@ int _media_filter_attribute_destory(attribute_h attr)
        return ret;
 }
 
-int _media_filter_attribute_generate(attribute_h attr, char *condition, media_content_collation_e collate_type, char **generated_condition)
-{
-       unsigned int idx = 0;
-       GList *token_list = NULL;
-       int size = 0;
-       int ret = MEDIA_CONTENT_ERROR_NONE;
-       int total_str_size = 0;
-       token_t *token;
-
-       media_content_retvm_if(condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid condition");
-       media_content_retvm_if(generated_condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid generated_condition");
-       media_content_retvm_if(attr == NULL, MEDIA_CONTENT_ERROR_DB_FAILED, "DB field mapping table doesn't exist. Check db connection");
-
-       if (__tokenize(&token_list, condition) < 0) {
-               media_content_error("INVALID_PARAMETER(0x%08x):Invalid the condition", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
-               return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
-       }
-
-       for (idx = 0; idx < g_list_length(token_list); idx++) {
-               token = (token_t*)g_list_nth_data(token_list, idx);
-
-               if (token->type == UNKNOWN_TYPE) {
-                       char *replace_str = __media_filter_replace_attr(attr, token->str);
-                       if (STRING_VALID(replace_str)) {
-                               SAFE_FREE(token->str);
-                               token->str = replace_str;
-                       }
-               }
-
-               total_str_size += strlen(token->str)+1;
-               /* media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str); */
-       }
-
-       /* make the statment */
-       size = total_str_size + COLLATE_STR_SIZE + 1;
-       *generated_condition = (char*)calloc(size, sizeof(char));
-
-       for (idx = 0; idx < g_list_length(token_list); idx++) {
-               token = (token_t*)g_list_nth_data(token_list, idx);
-
-               if ((token != NULL) && STRING_VALID(token->str)) {
-                       SAFE_STRLCAT(*generated_condition, token->str, size);
-                       SAFE_STRLCAT(*generated_condition, SPACE, size);
-
-                       SAFE_FREE(token->str);
-                       SAFE_FREE(token);
-               }
-       }
-
-       if (collate_type == MEDIA_CONTENT_COLLATE_NOCASE || collate_type == MEDIA_CONTENT_COLLATE_RTRIM || collate_type == MEDIA_CONTENT_COLLATE_LOCALIZED) {
-               SAFE_STRLCAT(*generated_condition, "COLLATE ", size);
-               SAFE_STRLCAT(*generated_condition, __get_collate_str(collate_type), size);
-               SAFE_STRLCAT(*generated_condition, SPACE, size);
-       }
-
-       /* Always close in here (condition collate option issue)*/
-       SAFE_STRLCAT(*generated_condition, QUERY_KEYWORD_BRACKET, size);
-
-       /* media_content_debug("statement : %s(%d) (total:%d)", *generated_condition, strlen(*generated_condition), total_str_size); */
-       media_content_sec_debug("Condition : %s", *generated_condition);
-
-       /* if(*generated_condition != NULL)
-               res = 1; */
-
-       if (token_list != NULL)
-               g_list_free(token_list);
-
-       return ret;
-}
-
-int _media_filter_attribute_generate_with_full_query(attribute_h attr, filter_h filter, char **generated_condition)
+int _media_filter_attribute_generate(attribute_h attr, filter_h filter, char **generated_condition)
 {
        unsigned int idx = 0;
        GList *token_list = NULL;
-       int size = 0;
        int ret = MEDIA_CONTENT_ERROR_NONE;
-       int total_str_size = 0;
        token_t *token;
-       filter_s * _filter = NULL;
+       filter_s *_filter = NULL;
+       char tmp_condition[MAX_QUERY_SIZE] = {0, };
 
        media_content_retvm_if(attr == NULL, MEDIA_CONTENT_ERROR_DB_FAILED, "DB field mapping table doesn't exist. Check db connection");
        media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid filter");
@@ -784,6 +709,8 @@ int _media_filter_attribute_generate_with_full_query(attribute_h attr, filter_h
        _filter = (filter_s*)filter;
 
        media_content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid condition");
+       media_content_retvm_if(_filter->condition_collate_type < MEDIA_CONTENT_COLLATE_DEFAULT ||
+               _filter->condition_collate_type > MEDIA_CONTENT_COLLATE_LOCALIZED, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid condition collate");
 
        if (__tokenize(&token_list, _filter->condition) < 0) {
                media_content_error("INVALID_PARAMETER(0x%08x):Invalid the condition", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
@@ -800,31 +727,37 @@ int _media_filter_attribute_generate_with_full_query(attribute_h attr, filter_h
                                token->str = replace_str;
                        }
                }
-
-               total_str_size += strlen(token->str)+1;
-               /* media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str); */
        }
 
        /* make the statment */
-       /*COLLATE_STR_SIZE is to give a margin - Add : +2 */
-       size = total_str_size + COLLATE_STR_SIZE + 1;
-       *generated_condition = (char*)calloc(size, sizeof(char));
-
-       SAFE_STRLCAT(*generated_condition, QUERY_KEYWORD_OPEN_BRACKET, size);
+       memset(tmp_condition, 0, sizeof(tmp_condition));
+       SAFE_STRLCAT(tmp_condition, QUERY_KEYWORD_OPEN_BRACKET, sizeof(tmp_condition));
 
        for (idx = 0; idx < g_list_length(token_list); idx++) {
                token = (token_t*)g_list_nth_data(token_list, idx);
 
                if ((token != NULL) && STRING_VALID(token->str)) {
-                       SAFE_STRLCAT(*generated_condition, token->str, size);
-                       SAFE_STRLCAT(*generated_condition, SPACE, size);
+                       SAFE_STRLCAT(tmp_condition, token->str, sizeof(tmp_condition));
+                       SAFE_STRLCAT(tmp_condition, QUERY_KEYWORD_SPACE, sizeof(tmp_condition));
 
                        SAFE_FREE(token->str);
                        SAFE_FREE(token);
                }
        }
 
-       SAFE_STRLCAT(*generated_condition, QUERY_KEYWORD_BRACKET, size);
+       /* Process for filter v1 */
+       if (_filter->is_full_condition == false && _filter->condition_collate_type != MEDIA_CONTENT_COLLATE_DEFAULT) {
+               SAFE_STRLCAT(tmp_condition, QUERY_KEYWORD_COLLATE, sizeof(tmp_condition));
+               SAFE_STRLCAT(tmp_condition, __get_collate_str(_filter->condition_collate_type), sizeof(tmp_condition));
+               SAFE_STRLCAT(tmp_condition, QUERY_KEYWORD_SPACE, sizeof(tmp_condition));
+       }
+
+       SAFE_STRLCAT(tmp_condition, QUERY_KEYWORD_BRACKET, sizeof(tmp_condition));
+
+       if (STRING_VALID(tmp_condition))
+               *generated_condition = g_strdup(tmp_condition);
+       else
+               *generated_condition = NULL;
 
        media_content_sec_debug("Condition : %s", *generated_condition);
 
@@ -840,22 +773,20 @@ int _media_filter_attribute_option_generate(attribute_h attr, filter_h filter, c
 {
        int ret = MEDIA_CONTENT_ERROR_NONE;
        filter_s *_filter = NULL;
-       char option_query[DEFAULT_QUERY_SIZE] = {0, };
-       char condition[DEFAULT_QUERY_SIZE] = {0, };
-       int size = 0;
+       char query[DEFAULT_QUERY_SIZE] = {0, };
+       char option[DEFAULT_QUERY_SIZE] = {0, };
 
        media_content_retvm_if(attr == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid attr");
        media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "invalid filter");
 
        _filter = (filter_s*)filter;
 
-       memset(option_query, 0x00, sizeof(option_query));
+       memset(query, 0x00, sizeof(query));
 
        /* Order by*/
        if (STRING_VALID(_filter->order_keyword)) {
                if ((_filter->order_type == MEDIA_CONTENT_ORDER_ASC) || (_filter->order_type == MEDIA_CONTENT_ORDER_DESC)) {
                        unsigned int idx = 0;
-                       int total_str_size = 0;
                        GList *token_list = NULL;
                        token_t *token;
                        char *attr_str;
@@ -890,51 +821,46 @@ int _media_filter_attribute_option_generate(attribute_h attr, filter_h filter, c
                                                media_content_error("There is no matched db field for %s", token->str);
                                        }
                                }
-
-                               total_str_size += strlen(token->str) + 1;
-                               /* media_content_debug("[%d][type:%d]:%s", idx, token->type, token->str); */
                        }
 
                        /* make the statment */
-                       char *generated_condition = NULL;
-                       size = total_str_size + COLLATE_STR_SIZE + 1;
-                       generated_condition = (char*)calloc(size, sizeof(char));
+                       SAFE_STRLCAT(query, QUERY_KEYWORD_ORDER_BY, sizeof(query));
 
                        for (idx = 0; idx < g_list_length(token_list); idx++) {
                                token = (token_t*)g_list_nth_data(token_list, idx);
 
                                if ((token != NULL) && STRING_VALID(token->str)) {
-                                       /* media_content_debug("[%d] %s", idx, token->str); */
-                                       SAFE_STRLCAT(generated_condition, token->str, size);
-                                       SAFE_STRLCAT(generated_condition, SPACE, size);
+                                       SAFE_STRLCAT(query, token->str, sizeof(query));
+                                       SAFE_STRLCAT(query, QUERY_KEYWORD_SPACE, sizeof(query));
 
                                        SAFE_FREE(token->str);
                                        SAFE_FREE(token);
                                }
                        }
 
-                       snprintf(condition, sizeof(condition), "ORDER BY %s", generated_condition);
-                       SAFE_STRLCAT(option_query, condition, sizeof(option_query));
-
-                       if (token_list != NULL)
+                       if (token_list != NULL) {
                                g_list_free(token_list);
-
-                       SAFE_FREE(generated_condition);
+                               token_list = NULL;
+                       }
                } else {
-                       SAFE_STRLCAT(option_query, _filter->order_keyword, sizeof(option_query));
-                       media_content_error("option_query [%s]", option_query);
+                       SAFE_STRLCAT(query, _filter->order_keyword, sizeof(query));
                }
        }
 
        /* offset */
-       SAFE_STRLCAT(option_query, SPACE, sizeof(option_query));
-       snprintf(condition, sizeof(condition), "LIMIT %d, %d", _filter->offset, _filter->count);
-       SAFE_STRLCAT(option_query, condition, sizeof(option_query));
+       SAFE_STRLCAT(query, QUERY_KEYWORD_SPACE, sizeof(query));
 
-       if (STRING_VALID(option_query))
-               *generated_option = g_strdup(option_query);
-       else
+       memset(option, 0, sizeof(option));
+       snprintf(option, sizeof(option), "%s %d, %d", QUERY_KEYWORD_LIMIT, _filter->offset, _filter->count);
+
+       SAFE_STRLCAT(query, option, sizeof(query));
+
+       if (STRING_VALID(query)) {
+               *generated_option = g_strdup(query);
+               media_content_sec_debug("Option : %s", *generated_option);
+       } else {
                *generated_option = NULL;
+       }
 
        return ret;
 }
@@ -955,6 +881,8 @@ int _media_filter_attribute_option_generate_with_full_query(attribute_h attr, fi
 
        _filter = (filter_s*)filter;
 
+       memset(query, 0, sizeof(query));
+
        /* Order by*/
        if (STRING_VALID(_filter->order_keyword)) {
                if (__tokenize_attribute(&token_list, _filter->order_keyword) < 0) {
@@ -974,18 +902,15 @@ int _media_filter_attribute_option_generate_with_full_query(attribute_h attr, fi
                        }
                }
 
-               memset(query, 0, sizeof(query));
-
                /* make the statment */
                SAFE_STRLCAT(query, QUERY_KEYWORD_ORDER_BY, sizeof(query));
-               SAFE_STRLCAT(query, QUERY_KEYWORD_SPACE, sizeof(query));
 
                for (idx = 0; idx < g_list_length(token_list); idx++) {
                        token = (token_t*)g_list_nth_data(token_list, idx);
 
                        if ((token != NULL) && STRING_VALID(token->str)) {
                                SAFE_STRLCAT(query, token->str, sizeof(query));
-                               SAFE_STRLCAT(query, SPACE, sizeof(query));
+                               SAFE_STRLCAT(query, QUERY_KEYWORD_SPACE, sizeof(query));
 
                                SAFE_FREE(token->str);
                                SAFE_FREE(token);

diff --git a/src/media_info.c b/src/media_info.c
index 063d110..f33f679 100755 (executable)
--- a/src/media_info.c
+++ b/src/media_info.c
@@ -145,27 +145,12 @@ static void __media_info_face_completed_cb(int error, const int face_count, void
 
 static bool __media_info_delete_batch_cb(media_info_h media, void *user_data)
 {
-       int err = MEDIA_CONTENT_ERROR_NONE;
        char *thumb_path = NULL;
-       media_content_type_e media_type = 0;
        GArray *thumb_list = (GArray *)user_data;
 
-       if (media == NULL) {
-               media_content_debug("NO Item");
-               return true;
-       }
-
-       err = media_info_get_media_type(media, &media_type);
-       if (err == MEDIA_CONTENT_ERROR_NONE) {
-               media_content_debug("media_type : [%d]", media_type);
-
-               media_info_get_thumbnail_path(media, &thumb_path);
-               if (STRING_VALID(thumb_path))
-                       g_array_append_val(thumb_list, thumb_path);
-
-       } else {
-               media_content_error("media_info_get_media_type failed");
-       }
+       media_info_get_thumbnail_path(media, &thumb_path);
+       if (STRING_VALID(thumb_path))
+               g_array_append_val(thumb_list, thumb_path);
 
        return true;
 }
@@ -759,26 +744,28 @@ int media_info_delete_batch_from_db(filter_h filter)
 
        media_content_retvm_if(filter == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid filter");
 
+       _filter = (filter_s*)filter;
+
+       media_content_retvm_if(_filter->condition == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Invalid condition");
+
        thumb_list = g_array_new(FALSE, FALSE, sizeof(char*));
 
        /* Delete thumbnail of each item */
        ret = _media_db_get_group_item(NULL, filter, __media_info_delete_batch_cb, thumb_list, MEDIA_GROUP_NONE);
+       media_content_retvm_if(ret != MEDIA_CONTENT_ERROR_NONE, ret, "Failed to get thumbnail path list");
 
-       _filter = (filter_s*)filter;
        attr = _content_get_attirbute_handle();
 
-       if (_filter->condition) {
-               ret = _media_filter_attribute_generate(attr, _filter->condition, _filter->condition_collate_type, &condition_query);
-               if (ret != MEDIA_CONTENT_ERROR_NONE) {
-                       __media_info_release_thumb_list(thumb_list);
-                       return ret;
-               }
+       ret = _media_filter_attribute_generate(attr, filter, &condition_query);
+       if (ret != MEDIA_CONTENT_ERROR_NONE) {
+               __media_info_release_thumb_list(thumb_list);
+               return ret;
        }
 
        if (STRING_VALID(condition_query)) {
                if (_filter->storage_id == NULL) {
                        /*FIX ME*/
-                       query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, "media", condition_query);
+                       query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, DB_TABLE_MEDIA, condition_query);
                } else {
                        query_string = sqlite3_mprintf(DELETE_MEDIA_FROM_MEDIA_BATCH, _filter->storage_id, condition_query);
                }