Bind repeated steps for accessing DB

- Bind check query and prepare DB into a function
- Make open / prepare DB as try / return
- Leave comment for TODO

Change-Id: I16b1e150bae44829255baa49f76d349f311a352c
Signed-off-by: Yunjin Lee <yunjin-.lee@samsung.com>

diff --git a/capi/src/privilege_db_manager.c b/capi/src/privilege_db_manager.c
index 901bdb3..cb3eebf 100755 (executable)
--- a/capi/src/privilege_db_manager.c
+++ b/capi/src/privilege_db_manager.c
@@ -99,7 +99,22 @@ privilege_profile_type_e get_priv_profile()
                return returnValue; \
        }
 
-char* __get_policy_table(privilege_manager_policy_type_e policy_type)
+#define TRY_INIT_DB(type, db) { \
+       int ret = __initialize_db(type, db); \
+       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE) { \
+               return ret; \
+       } \
+}
+
+#define TRY_PREPARE_STMT(db, sql, stmt) { \
+       int ret = __prepare_stmt(db, sql, stmt); \
+       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE) { \
+               __finalize_db(db, *stmt, sql); \
+               return ret; \
+       } \
+}
+
+static const char* __get_policy_table(privilege_manager_policy_type_e policy_type)
 {
        switch (policy_type) {
        case (PRVMGR_POLICY_TYPE_PREVENT):
@@ -110,7 +125,7 @@ char* __get_policy_table(privilege_manager_policy_type_e policy_type)
        }
 }
 
-int __initialize_db(privilege_db_type_e type, sqlite3 ** db)
+static int __initialize_db(privilege_db_type_e type, sqlite3 ** db)
 {
        char *db_path = NULL;
        int db_mode = SQLITE_OPEN_READONLY;
@@ -145,31 +160,53 @@ int __initialize_db(privilege_db_type_e type, sqlite3 ** db)
                sqlite3_close(*db);
                return PRIVILEGE_DB_MANAGER_ERR_CONNECTION_FAIL;
        }
+       if (*db == NULL) {
+               _LOGE("[DB_FAIL] Can't open database %s : db handle is NULL", db_path);
+               return PRIVILEGE_DB_MANAGER_ERR_CONNECTION_FAIL;
+       }
+
        return PRIVILEGE_DB_MANAGER_ERR_NONE;
 }
 
-void __finalize_db(sqlite3 *db, sqlite3_stmt *stmt, char* sql)
+static void __finalize_db(sqlite3 *db, sqlite3_stmt *stmt, char* sql)
 {
        if (stmt != NULL)
                sqlite3_finalize(stmt);
 
        if (db != NULL)
-               sqlite3_close(db);
+               sqlite3_close_v2(db);
 
        if (sql != NULL)
                sqlite3_free(sql);
 }
 
-int __make_privilege_list_str(GList *privilege_list, char** privilege_list_str)
+static int __prepare_stmt(sqlite3 *db, char* sql, sqlite3_stmt **stmt)
+{
+       TryReturn(sql != NULL, , PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "query is NULL");
+
+       int ret = sqlite3_prepare_v2(db, sql, strlen(sql), stmt, NULL);
+       if (ret != SQLITE_OK) {
+               _LOGE("sqlite3_prepare_v2() failed. ret %d[%s]", ret, sqlite3_errmsg(db));
+               return PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY;
+       }
+
+       return PRIVILEGE_DB_MANAGER_ERR_NONE;
+}
+
+static int __make_privilege_list_str(GList *privilege_list, char** privilege_list_str)
 {
-       GList *l;
        char* temp_privilege_list_str = NULL;
-       for (l = privilege_list; l != NULL; l = l->next) {
+       for (GList* l = privilege_list; l != NULL; l = l->next) {
                char *privilege_name = (char *)l->data;
-               if (temp_privilege_list_str == NULL)
+               if (temp_privilege_list_str == NULL) {
                        temp_privilege_list_str = sqlite3_mprintf("'%q'", privilege_name);
-               else
-                       temp_privilege_list_str = sqlite3_mprintf("%s, '%q'", temp_privilege_list_str, privilege_name);
+               } else {
+                       char* temp = sqlite3_mprintf("%s, '%q'", temp_privilege_list_str, privilege_name);
+                       sqlite3_free(temp_privilege_list_str);
+                       temp_privilege_list_str = temp;
+               }
+               if (temp_privilege_list_str == NULL)
+                       return -1;
        }
        *privilege_list_str = temp_privilege_list_str;
        return 0;
@@ -202,23 +239,23 @@ int privilege_db_manager_check_black_list(uid_t uid, privilege_manager_package_t
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
+
        int ret = 0;
        int count = 0;
 
-       ret = __initialize_db(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE) {
-               _LOGE("db initialize failed. ret = %d", ret);
-               return ret;
-       }
-
        char *privilege_list_str = NULL;
        ret = __make_privilege_list_str(privilege_list, &privilege_list_str);
+       if (ret == -1) {
+               _LOGE("__make_privilege_list_str() failed.");
+               return PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY;
+       }
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
+
        char *sql = sqlite3_mprintf("select distinct privilege_name from prevent_list where privilege_name in(%s)and (uid=%d or uid=%d) and package_type=%d", privilege_list_str, uid, GLOBAL_USER, package_type);
        sqlite3_free(privilege_list_str);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        do {
                ret = sqlite3_step(stmt);
@@ -238,18 +275,13 @@ int privilege_db_manager_get_privilege_list(privilege_manager_package_type_e pac
        sqlite3_stmt *stmt = NULL;
        int ret;
 
-       ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
-
-       GList *temp_privilege_list = NULL;
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privilege_name, privilege_level_id from privilege_info where package_type_id=%d", package_type);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
+       GList *temp_privilege_list = NULL;
        do {
                ret = sqlite3_step(stmt);
                if (ret == SQLITE_ROW) {
@@ -282,22 +314,18 @@ int privilege_db_manager_get_mapped_privilege_list(const char *api_version, priv
        sqlite3_stmt *stmt = NULL;
        int ret;
 
-       ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
-
        GList *temp_privilege_list = NULL;
 
        char *privilege_list_str = NULL;
        ret = __make_privilege_list_str(privilege_list, &privilege_list_str);
        TryReturn(ret == 0 && privilege_list_str != NULL, sqlite3_close(db), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] making privilege_list_str for where in query is failed.");
 
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
+
        char *sql =  sqlite3_mprintf("select distinct mapped_privilege_name from privilege_mapping where package_type_id=%d and privilege_name in(%s) and from_api_version<=%Q and to_api_version>%Q", package_type, privilege_list_str, api_version, api_version, package_type);
        sqlite3_free(privilege_list_str);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        do {
                ret = sqlite3_step(stmt);
@@ -318,15 +346,14 @@ int privilege_db_manager_get_privacy_display(const char *privacy_name, char **pr
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
+
        char *sql = sqlite3_mprintf("select privacy_display from privacy_info where privacy_name=%Q", privacy_name);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
 
-       ret = sqlite3_step(stmt);
+       TRY_PREPARE_STMT(db, sql, &stmt);
+
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                *privacy_display = strdup((char*)sqlite3_column_text(stmt, 0));
                TryReturn(*privacy_display != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] privilege_name's strdup is failed.");
@@ -343,18 +370,14 @@ int privilege_db_manager_get_privilege_display(privilege_manager_package_type_e
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret;
-       ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privilege_display from privilege_info where package_type_id=%d and privilege_name=%Q", package_type, privilege_name);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
-       ret = sqlite3_step(stmt);
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                *privilege_display = strdup((char *)sqlite3_column_text(stmt, 0));
                TryReturn(*privilege_display != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] privilege_name's strdup is failed.");
@@ -371,18 +394,14 @@ int privilege_db_manager_get_privilege_description(privilege_manager_package_typ
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret;
-       ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privilege_description from privilege_info where package_type_id=%d and privilege_name=%Q", package_type, privilege_name);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
-       ret = sqlite3_step(stmt);
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                *privilege_description = strdup((char *)sqlite3_column_text(stmt, 0));
                TryReturn(*privilege_description != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY, "[PRIVILEGE_DB_MANAGER_ERR_OUT_OF_MEMORY] privilege_name's strdup is failed.");
@@ -400,19 +419,16 @@ int privilege_db_manager_get_privilege_group_id(privilege_manager_package_type_e
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret;
-       ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privilege_group_id from privilege_info where package_type_id=%d and privilege_name=%Q",
                                                                package_type, privilege_name);
 
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
-       ret = sqlite3_step(stmt);
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                *privilege_group_id = (int)sqlite3_column_int(stmt, 0);
 
@@ -430,8 +446,8 @@ int privilege_db_manager_is(char type, const char* privilege)
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
        int res = 0;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] DB INITIALIZE FAIL");
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = NULL;
        switch (type) {
@@ -449,11 +465,10 @@ int privilege_db_manager_is(char type, const char* privilege)
                __finalize_db(db, stmt, sql);
                return PRIVILEGE_DB_MANAGER_ERR_INVALID_TYPE;
        }
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database : %s", sqlite3_errmsg(db));
 
-       ret = sqlite3_step(stmt);
+       TRY_PREPARE_STMT(db, sql, &stmt);
+
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                switch (type) {
                case 'v':
@@ -478,22 +493,21 @@ int privilege_db_manager_is(char type, const char* privilege)
                return res;
 }
 
+// TODO: change it to get package's privacy option only.
 int privilege_db_manager_is_privacy_white_list(const char* pkgid, const char* privilege)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] DB INITIALIZE FAIL");
 
        int privacy_id = 0;
-       ret = privilege_db_manager_get_privacy_id_by_privilege(privilege, &privacy_id);
+       int ret = privilege_db_manager_get_privacy_id_by_privilege(privilege, &privacy_id);
        TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] privilege_db_manager_get_privacy_id_by_privilege failed");
 
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
+
        char *sql = sqlite3_mprintf("select privacy_option from privacy_whitelist where pkg_id=%Q", pkgid);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database : %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        int res = 0;
        do {
@@ -514,23 +528,22 @@ int privilege_db_manager_is_privacy_white_list(const char* pkgid, const char* pr
        return res;
 }
 
+// TODO: make it to get package's privacy option and settable info only.
 int privilege_db_manager_is_user_settable(const char* pkgid, const char* privacy_name)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int res = 1;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] DB INITIALIZE FAIL");
 
+       int res = 1;
        int privacy_id = 0;
-       ret = privilege_db_manager_get_privacy_id(privacy_name, &privacy_id);
+       int ret = privilege_db_manager_get_privacy_id(privacy_name, &privacy_id);
        TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] privilege_db_manager_get_privacy_id failed");
 
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
+
        char *sql = sqlite3_mprintf("select privacy_option, settable from privacy_whitelist where pkg_id=%Q", pkgid);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database : %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        res = 1;
        do {
@@ -562,16 +575,13 @@ int privilege_db_manager_is_disabled_privilege(uid_t uid, const char* privilege)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
-       TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE, , ret, "[PRIVILEGE_DB_MANAGER] DB INITIALIZE FAIL. ret = %d", ret);
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
 
        char *sql = sqlite3_mprintf("select * from disable_list where privilege_name=%Q and (uid=%d or uid=%d)", privilege, uid, GLOBAL_USER);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
 
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database : %s", sqlite3_errmsg(db));
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
-       ret = sqlite3_step(stmt);
+       int ret = sqlite3_step(stmt);
 
        if (ret == SQLITE_ROW)
                ret = 1;
@@ -586,14 +596,13 @@ int privilege_db_manager_get_privacy_list(GList **privacy_list)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select DISTINCT privacy_name from privilege_info where is_privacy=1 and package_type='core' order by privacy_name");
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_privacy_list = NULL;
        do {
@@ -616,14 +625,13 @@ int privilege_db_manager_get_privilege_list_by_privacy(const char* privacy, GLis
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select distinct privilege_name from privilege_info where is_privacy=1 and privacy_name=%Q", privacy);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_privilege_list = NULL;
        do {
@@ -646,14 +654,14 @@ int privilege_db_manager_get_privacy_by_privilege(const char* privilege, char**
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privacy_name from privilege_info where privilege_name=%Q and package_type='core'", privilege);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
+
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                *privacy_name = strdup((char*)sqlite3_column_text(stmt, 0));
@@ -671,14 +679,12 @@ int privilege_db_manager_get_same_privacy_grouped_privileges(const char* privile
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select distinct privilege_name from privilege_info where privacy_name=(select distinct privacy_name from privilege_info where privilege_name=%Q and is_privacy=1)", privilege);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_privilege_list = NULL;
        do {
@@ -705,15 +711,14 @@ int privilege_db_manager_get_privacy_id_by_privilege(const char* privilege, int
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privacy_id from privacy_info where privacy_name=(select privacy_name from privilege_info where privilege_name=%Q and package_type='core')", privilege);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
-       ret = sqlite3_step(stmt);
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
+
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                int tmp = (int)sqlite3_column_int(stmt, 0);
                *privacy_id = tmp;
@@ -731,15 +736,16 @@ int privilege_db_manager_get_privacy_id(const char* privacy, int *privacy_id)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_INFO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_INFO, &db);
 
        char *sql = sqlite3_mprintf("select privacy_id from privacy_info where privacy_name=%Q", privacy);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
-       ret = sqlite3_step(stmt);
+
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
+
+       int ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
                int tmp = (int)sqlite3_column_int(stmt, 0);
                *privacy_id = tmp;
@@ -758,17 +764,18 @@ int privilege_db_manager_get_black_list(privilege_manager_policy_type_e policy_t
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RO, &db);
+
        char* sql = NULL;
        if (policy_type == PRVMGR_POLICY_TYPE_DISABLE)
                sql = sqlite3_mprintf("select privilege_name from %Q where (uid=%d or uid=%d)", __get_policy_table(policy_type), uid, GLOBAL_USER);
        else if (policy_type == PRVMGR_POLICY_TYPE_PREVENT)
                sql = sqlite3_mprintf("select privilege_name from %Q where uid=%d and package_type=%d", __get_policy_table(policy_type), uid, package_type);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList *temp_privilege_list = NULL;
        do {
@@ -792,9 +799,9 @@ int privilege_db_manager_set_black_list(int uid, privilege_manager_package_type_
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_POLICY_RW, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret = PRIVILEGE_DB_MANAGER_ERR_NONE;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RW, &db);
 
        TryReturn(sqlite3_exec(db, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, NULL) == SQLITE_OK, __finalize_db(db, NULL, NULL), PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL, "[DB_FAIL] sqlite3_exec for BEGIN IMMEDIATE TRANSACTION failed");
        GList *l = NULL;
@@ -825,13 +832,12 @@ int privilege_db_manager_unset_black_list(int uid, privilege_manager_package_typ
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_POLICY_RW, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_POLICY_RW, &db);
 
        TryReturn(sqlite3_exec(db, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, NULL) == SQLITE_OK, __finalize_db(db, NULL, NULL), PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL, "[DB_FAIL] sqlite3_exec for BEGIN IMMEDIATE TRANSACTION failed");
-       GList *l = NULL;
-       for (l = privilege_list; l != NULL; l = l->next) {
+
+       for (GList *l = privilege_list; l != NULL; l = l->next) {
                char *privilege_name = (char *)l->data;
                char* sql = sqlite3_mprintf("delete from prevent_list where uid=%d and package_type=%d and privilege_name=%Q", uid, package_type, privilege_name);
                TryReturn(sql != NULL, sqlite3_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, NULL); __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
@@ -854,21 +860,21 @@ int privilege_db_manager_unset_black_list(int uid, privilege_manager_package_typ
        return PRIVILEGE_DB_MANAGER_ERR_NONE;
 }
 
+//TODO: Do insert only. DO NOT determine whether to insert or not in here.
 int privilege_db_manager_set_package_critical_privilege_info(const uid_t uid, const char* pkgid, privilege_manager_package_type_e package_type, const char* api_version, GList* critical_privilege_list)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
 
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
        GList* mapped_privilege_list = NULL;
        ret = privilege_db_manager_get_mapped_privilege_list(api_version, package_type, critical_privilege_list, &mapped_privilege_list);
        TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE && mapped_privilege_list != NULL, __finalize_db(db, stmt, NULL), PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL, "[DB_FAIL] privilege_db_manager_get_mapped_privilege_list failed");
 
        TryReturn(sqlite3_exec(db, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, NULL) == SQLITE_OK, __finalize_db(db, NULL, NULL), PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL, "[DB_FAIL] sqlite3_exec for BEGIN IMMEDIATE TRANSACTION failed");
-       GList *l = NULL;
-       for (l = mapped_privilege_list; l != NULL; l = l->next) {
+
+       for (GList *l = mapped_privilege_list; l != NULL; l = l->next) {
                char *privilege_name = (char *)l->data;
                if (strstr(privilege_name, "/internal/") == NULL) {
                        char* sql = NULL;
@@ -903,13 +909,15 @@ int privilege_db_manager_set_package_critical_privilege_info(const uid_t uid, co
        return PRIVILEGE_DB_MANAGER_ERR_NONE;
 }
 
+//TODO: Do insert only. DO NOT determine whether to insert or not in here.
 int privilege_db_manager_set_package_privacy_privilege_info(const uid_t uid, const char* pkgid, privilege_manager_package_type_e package_type, const char* api_version, GList* privilege_list)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
+
        GList* mapped_privilege_list = NULL;
        ret = privilege_db_manager_get_mapped_privilege_list(api_version, package_type, privilege_list, &mapped_privilege_list);
        TryReturn(ret == PRIVILEGE_DB_MANAGER_ERR_NONE && mapped_privilege_list != NULL, __finalize_db(db, stmt, NULL), PRIVILEGE_DB_MANAGER_ERR_DB_UPDATE_FAIL, "[DB_FAIL] privilege_db_manager_get_mapped_privilege_list failed");
@@ -955,15 +963,14 @@ int privilege_db_manager_unset_package_privilege_info(const uid_t uid, const cha
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RW, &db);
+
+       char* sql = sql = sqlite3_mprintf("delete from privacy_package where pkg_id = %Q and uid = %d", pkgid, uid);
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
-       char* sql = NULL;
-       sql = sqlite3_mprintf("delete from privacy_package where pkg_id = %Q and uid = %d", pkgid, uid);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
        ret = sqlite3_step(stmt);
 
        if (ret != SQLITE_DONE)
@@ -979,9 +986,9 @@ int privilege_db_manager_is_privacy_requestable(const uid_t uid, const char* pkg
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
 
        char* sql = NULL;
        if (g_privilege_profile_type == PRIVILEGE_PROFILE_TYPE_WEARABLE || pkg_type == PRVMGR_PACKAGE_TYPE_CORE) {
@@ -989,9 +996,8 @@ int privilege_db_manager_is_privacy_requestable(const uid_t uid, const char* pkg
        } else {
                sql = sqlite3_mprintf("select (case when api_version < 4 or (api_version < 5 and privacy_name=%Q) then 0 else 1 end) from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q and privilege_name=%Q", STORAGE_PRIVACY, uid, GLOBAL_USER, pkgid, privilege);
        }
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
@@ -1019,14 +1025,13 @@ int privilege_db_manager_is_critical_privilege(const uid_t uid, const char* pkgi
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
 
        char* sql = sqlite3_mprintf("select is_critical from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q and privilege_name=%Q", uid, GLOBAL_USER, pkgid, privilege);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        ret = sqlite3_step(stmt);
        if (ret == SQLITE_ROW) {
@@ -1053,14 +1058,12 @@ int privilege_db_manager_get_all_privacy_package_list(const uid_t uid, GList** p
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
 
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
        char *sql = sqlite3_mprintf("select distinct pkg_id from privacy_package where (uid=%d or uid=%d)", uid, GLOBAL_USER);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_package_list = NULL;
        do {
@@ -1084,14 +1087,13 @@ int privilege_db_manager_get_privacy_list_by_pkgid(const uid_t uid, const char*
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
 
        char *sql = sqlite3_mprintf("select distinct privacy_name from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q", uid, GLOBAL_USER, pkgid);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_privacy_list = NULL;
        do {
@@ -1110,18 +1112,17 @@ int privilege_db_manager_get_privacy_list_by_pkgid(const uid_t uid, const char*
 
        return PRIVILEGE_DB_MANAGER_ERR_NONE;
 }
+
 int privilege_db_manager_get_package_list_by_privacy(const uid_t uid, const char* privacy, GList** package_list)
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
 
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
        char *sql = sqlite3_mprintf("select distinct pkg_id from privacy_package where (uid=%d or uid=%d) and privacy_name=%Q", uid, GLOBAL_USER, privacy);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_package_list = NULL;
        do {
@@ -1145,14 +1146,13 @@ int privilege_db_manager_get_privilege_list_by_pkgid_and_privacy(const uid_t uid
 {
        sqlite3 *db = NULL;
        sqlite3_stmt *stmt = NULL;
-       int ret = __initialize_db(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
-       if (ret != PRIVILEGE_DB_MANAGER_ERR_NONE)
-               return ret;
+       int ret;
+
+       TRY_INIT_DB(PRIVILEGE_DB_TYPE_PRIVACY_RO, &db);
 
        char *sql = sqlite3_mprintf("select distinct privilege_name from privacy_package where (uid=%d or uid=%d) and pkg_id=%Q and privacy_name=%Q", uid, GLOBAL_USER, pkgid, privacy);
-       TryReturn(sql != NULL, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] sqlite3_mprintf failed");
-       ret = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);
-       TryReturn(ret == SQLITE_OK, __finalize_db(db, stmt, sql), PRIVILEGE_DB_MANAGER_ERR_INVALID_QUERY, "[DB_FAIL] fail to prepare database: %s", sqlite3_errmsg(db));
+
+       TRY_PREPARE_STMT(db, sql, &stmt);
 
        GList* temp_privilege_list = NULL;
        do {