--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __PKGMGR_QUERY_INDEX_H__
+#define __PKGMGR_QUERY_INDEX_H__
+
+typedef enum {
+ QUERY_INDEX_APPINFO_GET_LOCALED_LABEL = 0,
+ QUERY_INDEX_APPINFO_GET_DATACONTROL_INFO,
+ QUERY_INDEX_APPINFO_GET_DATACONTROL_APPID,
+ QUERY_INDEX_APPINFO_GET_DATACONTROL_TRUSTED_INFO,
+ QUERY_INDEX_APPINFO_GET_DATACONTROL_PRIVILEGES,
+ QUERY_INDEX_APPINFO_GET_APPCONTROL_PRIVILEGES,
+ QUERY_INDEX_PLUGININFO_GET_APPIDS,
+ QUERY_INDEX_GET_PKG_UPDATEINFO_1,
+ QUERY_INDEX_GET_PKG_UPDATEINFO_2,
+ QUERY_INDEX_PKGINFO_SET_USR_INSTALLED_STORAGE_1,
+ QUERY_INDEX_PKGINFO_SET_USR_INSTALLED_STORAGE_2,
+ QUERY_INDEX_CERTINFO_COMPARE_PKG_CERTINFO,
+ QUERY_INDEX_CERTINFO_COMPARE_APP_CERTINFO,
+ QUERY_INDEX_PKGINFO_DELETE_CERTINFO,
+
+ QUERY_INDEX_INSERT_PACKAGE_PLUGIN_EXECUTION_INFO,
+ QUERY_INDEX_DELETE_PACKAGE_PLUGIN_EXECUTION_INFO,
+ QUERY_INDEX_UPDATE_GLOBAL_APP_DISABLE,
+ QUERY_INDEX_UPDATE_APP_DISABLE_INFO,
+ QUERY_INDEX_UPDATE_PKG_DISABLE_INFO,
+ QUERY_INDEX_UPDATE_GLOBAL_APP_SPLASH_SCREEN_DISPLAY_INFO,
+ QUERY_INDEX_UPDATE_APP_SPLASH_SCREEN_DISPLAY_INFO,
+ QUERY_INDEX_UPDATE_APP_LABEL_INFO,
+ QUERY_INDEX_UPDATE_APP_ICON_INFO,
+ QUERY_INDEX_UPDATE_TEP_INFO,
+ QUERY_INDEX_REGISTER_PKG_UPDATE_INFO,
+ QUERY_INDEX_UNREGISTER_PKG_UPDATE_INFO,
+ QUERY_INDEX_UNREGISTER_ALL_PKG_UPDATE_INFO,
+ QUERY_INDEX_MAX
+} QUERY_INDEX;
+
+#endif /* __PKGMGR_QUERY_INDEX_H__ */
#include "pkgmgr_parser_debug.h"
#include "pkgmgr_parser_internal.h"
#include "manager/pkginfo_manager.h"
+#include "pkgmgr_query_index.h"
#ifndef OWNER_ROOT
#define OWNER_ROOT 0
#define XXHDPI_MIN 481
#define XXHDPI_MAX 600
+#define MAX_UID_LENGTH 64
+
/* app background category value */
#define APP_BG_CATEGORY_USER_DISABLE_FALSE_VAL 0x00000
#define APP_BG_CATEGORY_USER_DISABLE_TRUE_VAL 0x00001
{
GList *tmp;
plugin_x *plugin;
- char **queries = NULL;
int idx = 0;
- int i = 0;
+ const char ***args;
+ int i;
+ int ret = PM_PARSER_R_ERROR;
if (!mfx->plugin)
return PM_PARSER_R_OK;
- queries = calloc(g_list_length(mfx->plugin), sizeof (char *));
- if (queries == NULL) {
+ int len = g_list_length(mfx->plugin);
+
+ args = calloc(len, sizeof(char **));
+ if (args == NULL) {
_LOGE("Out of memory");
return PM_PARSER_R_ERROR;
}
+ for (i = 0; i < len; i++) {
+ args[i] = calloc(4, sizeof(char *));
+ if (args[i] == NULL) {
+ _LOGE("Out of memory");
+ goto clear;
+ }
+ }
+
for (tmp = mfx->plugin; tmp; tmp = tmp->next) {
plugin = (plugin_x *)tmp->data;
if (plugin == NULL)
continue;
- queries[idx] = sqlite3_mprintf("INSERT INTO package_plugin_info "
- "(pkgid, appid, plugin_type, plugin_name) "
- "VALUES (%Q, %Q, %Q, %Q)",
- plugin->pkgid, plugin->appid,
- plugin->plugin_type, plugin->plugin_name);
- if (queries[idx] == NULL) {
- _LOGE("Out of memory");
- for (i = 0; i < idx; ++i)
- sqlite3_free(queries[i]);
- free(queries);
- return PM_PARSER_R_ERROR;
- }
-
+ args[idx][0] = plugin->pkgid;
+ args[idx][1] = plugin->appid;
+ args[idx][2] = plugin->plugin_type;
+ args[idx][3] = plugin->plugin_name;
idx++;
}
- if (_parser_execute_write_queries((const char **)queries, idx, uid) < 0) {
+ if (_parser_execute_write_queries(QUERY_INDEX_INSERT_PACKAGE_PLUGIN_EXECUTION_INFO,
+ args, 4, idx, uid) < 0) {
_LOGE("Fail to write to db");
- for (i = 0; i < idx; ++i)
- sqlite3_free(queries[i]);
- free(queries);
+ goto clear;
return PM_PARSER_R_ERROR;
}
- for (i = 0; i < idx; ++i)
- sqlite3_free(queries[i]);
- free(queries);
+ ret = PM_PARSER_R_OK;
+clear:
+ for (i = 0; i < len; i++)
+ free(args[i]);
- return PM_PARSER_R_OK;
+ free(args);
+
+ return ret;
}
static int __delete_package_plugin_execution_info(const char *pkgid, uid_t uid)
{
- char *query = NULL;
-
- query = sqlite3_mprintf(
- "DELETE FROM package_plugin_info WHERE pkgid=%Q", pkgid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
+ const char *args[1] = { pkgid };
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_DELETE_PACKAGE_PLUGIN_EXECUTION_INFO,
+ args, 1, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_global_app_disable_for_uid_info_in_db(
const char *appid, uid_t uid, int is_disable)
{
- // TODO: construct query at here and send it to server
- char *query = NULL;
+ char uid_str[MAX_UID_LENGTH] = { 0, };
+ const char *args[4];
+ int r;
- query = sqlite3_mprintf("INSERT OR REPLACE INTO package_app_info_for_uid ("
- " app_id, uid, is_disabled, is_splash_screen_enabled) "
- "VALUES (%Q, %u, %Q,"
- " (SELECT app_splash_screen_display FROM package_app_info"
- " WHERE app_id=%Q))", appid, uid,
- (is_disable ? "true" : "false"), appid);
- if (query == NULL) {
- _LOGE("Out of memory");
+ r = snprintf(uid_str, sizeof(uid_str), "%d", uid);
+ if (r < 0 || r >= sizeof(uid_str))
return PM_PARSER_R_ERROR;
- }
+ args[0] = appid;
+ args[1] = uid_str;
+ args[2] = is_disable ? "true" : "false";
+ args[3] = appid;
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UPDATE_GLOBAL_APP_DISABLE,
+ args, 4, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_app_disable_info_in_usr_db(const char *appid,
uid_t uid, int is_disable)
{
- char *query = NULL;
-
- query = sqlite3_mprintf("UPDATE package_app_info SET app_disable=%Q "
- "WHERE app_id=%Q", (is_disable ? "true" : "false"), appid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
+ const char *args[2];
+ args[0] = is_disable ? "true" : "false";
+ args[1] = appid;
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UPDATE_APP_DISABLE_INFO,
+ args, 2, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_pkg_disable_info_in_usr_db(const char *pkgid,
uid_t uid, int is_disable)
{
- char *query = NULL;
+ const char *args[2];
+ args[0] = is_disable ? "true" : "false";
+ args[1] = pkgid;
- query = sqlite3_mprintf("UPDATE package_info SET package_disable=%Q "
- "WHERE package=%Q", (is_disable ? "true" : "false"), pkgid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
-
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UPDATE_PKG_DISABLE_INFO,
+ args, 2, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_global_app_splash_screen_display_info_in_usr_db(
const char *appid, uid_t uid, int flag)
{
- char *query = NULL;
+ const char *args[3];
+ char uid_str[MAX_UID_LENGTH] = { 0, };
+ int r;
- query = sqlite3_mprintf("INSERT OR REPLACE INTO package_app_info_for_uid("
- " app_id, uid, is_splash_screen_enabled) "
- "VALUES (%Q, %u, %Q)", appid, uid, (flag == 1 ? "true" : "false"));
- if (query == NULL) {
- _LOGE("Out of memory");
+ r = snprintf(uid_str, sizeof(uid_str), "%d", uid);
+ if (r < 0 || r >= sizeof(uid_str))
return PM_PARSER_R_ERROR;
- }
+ args[0] = appid;
+ args[1] = uid_str;
+ args[2] = (flag == 1 ? "true" : "false");
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(
+ QUERY_INDEX_UPDATE_GLOBAL_APP_SPLASH_SCREEN_DISPLAY_INFO,
+ args, 3, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_app_splash_screen_display_info_in_usr_db(
const char *appid, uid_t uid, int flag)
{
- char *query = NULL;
+ const char *args[2];
- query = sqlite3_mprintf("UPDATE package_app_info SET app_splash_screen_display=%Q "
- "WHERE app_id=%Q", (flag == 1 ? "true" : "false"), appid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
+ args[0] = (flag == 1 ? "true" : "false");
+ args[1] = appid;
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(
+ QUERY_INDEX_UPDATE_APP_SPLASH_SCREEN_DISPLAY_INFO,
+ args, 2, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_app_label_info_in_usr_db(const char *appid,
uid_t uid, const char *label)
{
- char *query = NULL;
-
- query = sqlite3_mprintf("UPDATE package_app_localized_info SET app_label=%Q "
- "WHERE app_id=%Q AND app_label IS NOT NULL", label, appid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
+ const char *args[2] = { label, appid };
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UPDATE_APP_LABEL_INFO,
+ args, 2, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_app_icon_info_in_usr_db(const char *appid,
uid_t uid, const char *icon_path)
{
- char *query = NULL;
+ const char *args[2] = { icon_path, appid };
- query = sqlite3_mprintf("UPDATE package_app_localized_info SET app_icon=%Q "
- "WHERE app_id=%Q AND app_icon IS NOT NULL", icon_path, appid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
-
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UPDATE_APP_ICON_INFO,
+ args, 2, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_update_tep_info_in_usr_db(const char *pkgid,
const char *tep_path, uid_t uid)
{
- char *query = NULL;
+ const char *args[2] = { tep_path, pkgid };
- query = sqlite3_mprintf("UPDATE package_info SET package_tep_name=%Q "
- "WHERE package=%Q", tep_path, pkgid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
-
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UPDATE_TEP_INFO,
+ args, 2, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
static int __register_pkg_update_info(updateinfo_x *info,
const char *update_type, uid_t uid)
{
- char *query = NULL;
-
- query = sqlite3_mprintf("UPDATE package_update_info "
- "SET update_version=%Q, update_type=%Q "
- "WHERE package=%Q", info->version, update_type, info->pkgid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
+ const char *args[3] = { info->version, update_type, info->pkgid };
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_REGISTER_PKG_UPDATE_INFO,
+ args, 3, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
static int __unregister_pkg_update_info(const char *pkgid, uid_t uid)
{
- char *query = NULL;
+ const char *args[1] = { pkgid };
- query = sqlite3_mprintf("UPDATE package_update_info "
- "SET update_type='none' WHERE package=%Q", pkgid);
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
-
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UNREGISTER_PKG_UPDATE_INFO,
+ args, 1, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
API int pkgmgr_parser_unregister_all_pkg_update_info_in_usr_db(uid_t uid)
{
- char *query = NULL;
-
- query = sqlite3_mprintf("UPDATE package_update_info "
- "SET update_type='none'");
- if (query == NULL) {
- _LOGE("Out of memory");
- return PM_PARSER_R_ERROR;
- }
-
- if (_parser_execute_write_query(query, uid) < 0) {
+ if (_parser_execute_write_query(QUERY_INDEX_UNREGISTER_ALL_PKG_UPDATE_INFO,
+ NULL, 0, uid) < 0) {
_LOGE("Fail to write to db");
- sqlite3_free(query);
return PM_PARSER_R_ERROR;
}
- sqlite3_free(query);
return PM_PARSER_R_OK;
}
#include "pkgmgrinfo_debug.h"
#include "pkgmgrinfo_internal.h"
+#include "pkgmgr_query_index.h"
+
+namespace {
+
+constexpr const char query_appinfo_get_localed_label[] =
+ "SELECT COALESCE((SELECT app_label FROM package_app_localized_info "
+ "WHERE app_id=%Q AND app_locale=%Q),"
+ "(SELECT app_label FROM package_app_localized_info WHERE "
+ "app_id=%Q AND app_locale='No Locale'))";
+
+constexpr const char query_appinfo_get_datacontrol_info[] =
+ "SELECT app_id, access FROM "
+ "package_app_data_control WHERE "
+ "providerid=%Q AND type=%Q";
+
+constexpr const char query_appinfo_get_datacontrol_appid[] =
+ "SELECT app_id FROM package_app_data_control "
+ "WHERE providerid=%Q";
+
+constexpr const char query_appinfo_get_datacontrol_trusted_info[] =
+ "SELECT app_id, trusted FROM package_app_data_control "
+ "WHERE providerid=%Q AND type=%Q";
+
+constexpr const char query_appinfo_get_datacontrol_privileges[] =
+ "SELECT privilege FROM package_app_data_control_privilege "
+ "WHERE providerid=%Q AND type=%Q";
+
+constexpr const char query_appinfo_get_appcontrol_privileges[] =
+ "SELECT app_control, privilege FROM package_app_app_control_privilege "
+ "WHERE app_id=%Q";
+
+constexpr const char query_plugininfo_get_appids[] =
+ "SELECT appid FROM "
+ "package_plugin_info WHERE pkgid=%Q AND "
+ "plugin_type=%Q AND plugin_name=%Q";
+
+constexpr const char query_get_pkg_updateinfo_1[] =
+ "SELECT package, update_version, update_type "
+ "FROM package_update_info";
+constexpr const char query_get_pkg_updateinfo_2[] =
+ "SELECT package, update_version, update_type "
+ "FROM package_update_info WHERE package=%Q";
+
+constexpr const char query_pkginfo_set_usr_installed_storage_1[] =
+ "UPDATE package_info SET installed_storage=%Q, external_path=%Q "
+ "WHERE package=%Q";
+constexpr const char query_pkginfo_set_usr_installed_storage_2[] =
+ "UPDATE package_app_info SET app_installed_storage=%Q, "
+ "app_external_path=%Q WHERE package=%Q";
+
+constexpr const char query_certinfo_compare_pkg_certinfo[] =
+ "SELECT package, "
+ "COALESCE(author_signer_cert, -1) FROM package_cert_info WHERE "
+ "package IN (%Q, %Q)";
+
+constexpr const char query_certinfo_compare_app_certinfo[] =
+ "SELECT app_id, package FROM "
+ "package_app_info WHERE app_id IN (%Q, %Q)";
+
+constexpr const char query_pkginfo_delete_certinfo[] =
+ "UPDATE package_cert_info SET "
+ "package_count = package_count - 1 WHERE package=%Q";
+
+// For pkgmgr_parser
+constexpr const char query_insert_package_plugin_execution_info[] =
+ "INSERT INTO package_plugin_info "
+ "(pkgid, appid, plugin_type, plugin_name) "
+ "VALUES (%Q, %Q, %Q, %Q)";
+
+constexpr const char query_delete_package_plugin_execution_info[] =
+ "DELETE FROM package_plugin_info WHERE pkgid=%Q";
+
+constexpr const char query_update_global_app_disable[] =
+ "INSERT OR REPLACE INTO package_app_info_for_uid ("
+ " app_id, uid, is_disabled, is_splash_screen_enabled) "
+ "VALUES (%Q, %Q, %Q,"
+ " (SELECT app_splash_screen_display FROM package_app_info"
+ " WHERE app_id=%Q))";
+
+constexpr const char query_update_app_disable_info[] =
+ "UPDATE package_app_info SET app_disable=%Q "
+ "WHERE app_id=%Q";
+
+constexpr const char query_update_pkg_disable_info[] =
+ "UPDATE package_info SET package_disable=%Q "
+ "WHERE package=%Q";
+
+constexpr const char query_update_global_app_splash_screen_display_info[] =
+ "INSERT OR REPLACE INTO package_app_info_for_uid("
+ " app_id, uid, is_splash_screen_enabled) "
+ "VALUES (%Q, %Q, %Q)";
+
+constexpr const char query_update_app_splash_screen_display_info[] =
+ "UPDATE package_app_info SET app_splash_screen_display=%Q "
+ "WHERE app_id=%Q";
+
+constexpr const char query_update_app_label_info[] =
+ "UPDATE package_app_localized_info SET app_label=%Q "
+ "WHERE app_id=%Q AND app_label IS NOT NULL";
+
+constexpr const char query_update_app_icon_info[] =
+ "UPDATE package_app_localized_info SET app_icon=%Q "
+ "WHERE app_id=%Q AND app_icon IS NOT NULL";
+
+constexpr const char query_update_tep_info[] =
+ "UPDATE package_info SET package_tep_name=%Q "
+ "WHERE package=%Q";
+
+constexpr const char query_register_pkg_update_info[] =
+ "UPDATE package_update_info "
+ "SET update_version=%Q, update_type=%Q "
+ "WHERE package=%Q";
+
+constexpr const char query_unregister_pkg_update_info[] =
+ "UPDATE package_update_info "
+ "SET update_type='none' WHERE package=%Q";
+
+constexpr const char query_unregister_all_pkg_update_info[] =
+ "UPDATE package_update_info "
+ "SET update_type='none'";
+
+class QueryMaker {
+ public:
+ std::vector<const char*> query_raw_ = {
+ query_appinfo_get_localed_label,
+ query_appinfo_get_datacontrol_info,
+ query_appinfo_get_datacontrol_appid,
+ query_appinfo_get_datacontrol_trusted_info,
+ query_appinfo_get_datacontrol_privileges,
+ query_appinfo_get_appcontrol_privileges,
+ query_plugininfo_get_appids,
+ query_get_pkg_updateinfo_1,
+ query_get_pkg_updateinfo_2,
+ query_pkginfo_set_usr_installed_storage_1,
+ query_pkginfo_set_usr_installed_storage_2,
+ query_certinfo_compare_pkg_certinfo,
+ query_certinfo_compare_app_certinfo,
+ query_pkginfo_delete_certinfo,
+
+ query_insert_package_plugin_execution_info,
+ query_delete_package_plugin_execution_info,
+ query_update_global_app_disable,
+ query_update_app_disable_info,
+ query_update_pkg_disable_info,
+ query_update_global_app_splash_screen_display_info,
+ query_update_app_splash_screen_display_info,
+ query_update_app_label_info,
+ query_update_app_icon_info,
+ query_update_tep_info,
+ query_register_pkg_update_info,
+ query_unregister_pkg_update_info,
+ query_unregister_all_pkg_update_info,
+ };
+
+ std::vector<unsigned int> arg_cnt_ = {
+ 3, // query_appinfo_get_localed_label
+ 2, // query_appinfo_get_datacontrol_info
+ 1, // query_appinfo_get_datacontrol_appid
+ 2, // query_appinfo_get_datacontrol_trusted_info
+ 2, // query_appinfo_get_datacontrol_privileges
+ 1, // query_appinfo_get_appcontrol_privileges
+ 3, // query_plugininfo_get_appids
+ 0, // query_get_pkg_updateinfo_1
+ 1, // query_get_pkg_updateinfo_2
+ 3, // query_pkginfo_set_usr_installed_storage_1
+ 3, // query_pkginfo_set_usr_installed_storage_2
+ 2, // query_certinfo_compare_pkg_certinfo
+ 2, // query_certinfo_compare_app_certinfo
+ 1, // query_pkginfo_delete_certinfo
+
+ 4, // query_insert_package_plugin_execution_info,
+ 1, // query_delete_package_plugin_execution_info,
+ 4, // query_update_global_app_disable,
+ 2, // query_update_app_disable_info,
+ 2, // query_update_pkg_disable_info,
+ 3, // query_update_global_app_splash_screen_display_info,
+ 2, // query_update_app_splash_screen_display_info,
+ 2, // query_update_app_label_info,
+ 2, // query_update_app_icon_info,
+ 2, // query_update_tep_info,
+ 3, // query_register_pkg_update_info,
+ 1, // query_unregister_pkg_update_info,
+ 0, // query_unregister_all_pkg_update_info,
+ };
+
+ std::string Make(int index, const std::vector<std::string>& args) {
+ if (index < 0 || index >= QUERY_INDEX_MAX)
+ return "";
+ const char* raw = query_raw_[index];
+ char* query = nullptr;
+
+ if (arg_cnt_[index] != args.size())
+ return "";
+
+ switch(arg_cnt_[index]) {
+ case 0:
+ query = sqlite3_mprintf(raw);
+ break;
+
+ case 1:
+ query = sqlite3_mprintf(raw, args[0].c_str());
+ break;
+
+ case 2:
+ query = sqlite3_mprintf(raw, args[0].c_str(), args[1].c_str());
+ break;
+
+ case 3:
+ query = sqlite3_mprintf(raw, args[0].c_str(), args[1].c_str(),
+ args[2].c_str());
+ break;
+
+ case 4:
+ query = sqlite3_mprintf(raw, args[0].c_str(), args[1].c_str(),
+ args[2].c_str(), args[3].c_str());
+ break;
+
+ case 5:
+ query = sqlite3_mprintf(raw, args[0].c_str(), args[1].c_str(),
+ args[2].c_str(), args[3].c_str(), args[4].c_str());
+ break;
+
+ case 6:
+ query = sqlite3_mprintf(raw, args[0].c_str(), args[1].c_str(),
+ args[2].c_str(), args[3].c_str(), args[4].c_str(),
+ args[5].c_str());
+ break;
+
+ case 7:
+ query = sqlite3_mprintf(raw, args[0].c_str(), args[1].c_str(),
+ args[2].c_str(), args[3].c_str(), args[4].c_str(),
+ args[5].c_str(), args[6].c_str());
+ break;
+ }
+
+ if (query == nullptr)
+ return "";
+
+ std::string ret = query;
+ sqlite3_free(query);
+
+ return ret;
+ }
+};
+
+QueryMaker __query_maker;
+
+} // namespace
namespace pkgmgr_common {
namespace database {
QueryHandler::~QueryHandler() {}
-void QueryHandler::SetQuery(std::vector<std::string> query) {
- query_ = std::move(query);
+void QueryHandler::SetQueryArgs(std::vector<std::pair<int, std::vector<std::string>>> query_args) {
+ query_args_ = std::move(query_args);
}
std::string QueryHandler::GetString() { return std::string(); }
return std::move(result_);
}
+int QueryHandler::MakeQuery() {
+ query_.clear();
+ for (auto& i : query_args_) {
+ std::string q = __query_maker.Make(i.first, i.second);
+ if (q.empty())
+ return -1;
+ query_.push_back(std::move(q));
+ }
+
+ return 0;
+}
+
int QueryHandler::Execute() {
std::shared_lock<std::shared_timed_mutex> s(lock_);
if (!Connect()) {
_LOGE("Failed to connect database");
return PMINFO_R_ERROR;
}
+
+ if (MakeQuery() != 0)
+ return PMINFO_R_ERROR;
+
if (query_.size() == 0) {
_LOGE("Empty query");
return PMINFO_R_ERROR;
public:
QueryHandler(uid_t uid, int pid);
~QueryHandler();
- void SetQuery(std::vector<std::string> query);
+ void SetQueryArgs(std::vector<std::pair<int, std::vector<std::string>>> query_args);
bool BindString(std::string value);
bool BindInt(int value);
std::string GetString();
std::vector<std::vector<std::string>> GetResult();
private:
+ int MakeQuery();
+
+ private:
uid_t uid_;
std::vector<std::string> query_;
+ std::vector<std::pair<int, std::vector<std::string>>> query_args_;
std::vector<std::vector<std::string>> result_;
};
op_type_(AbstractDBHandler::OperationType::OPERATION_TYPE_NONE) {}
-QueryParcelable::QueryParcelable(uid_t uid, std::string query,
+QueryParcelable::QueryParcelable(uid_t uid,
+ std::pair<int, std::vector<std::string>> query_args,
AbstractDBHandler::DBType db_type,
AbstractDBHandler::OperationType op_type)
: AbstractParcelable(0, ParcelableType::Query),
- queries_(std::vector<std::string>{query}),
+ query_args_(std::vector<std::pair<int, std::vector<std::string>>>{query_args}),
db_type_(db_type), op_type_(op_type) {}
-QueryParcelable::QueryParcelable(uid_t uid, std::vector<std::string> queries,
+QueryParcelable::QueryParcelable(uid_t uid,
+ std::vector<std::pair<int, std::vector<std::string>>> query_args,
AbstractDBHandler::DBType db_type,
AbstractDBHandler::OperationType op_type)
: AbstractParcelable(uid, ParcelableType::Query),
- queries_(queries), db_type_(db_type), op_type_(op_type) {}
+ query_args_(std::move(query_args)), db_type_(db_type), op_type_(op_type) {}
void QueryParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
AbstractParcelable::WriteToParcel(parcel);
- WriteInt(parcel, queries_.size());
- for (const auto& query : queries_)
- parcel->WriteString(query);
+ WriteInt(parcel, query_args_.size());
+ for (const auto& query_info : query_args_) {
+ WriteInt(parcel, query_info.first);
+ WriteInt(parcel, query_info.second.size());
+ for (const auto& args : query_info.second)
+ parcel->WriteString(args);
+ }
WriteInt(parcel, db_type_);
WriteInt(parcel, op_type_);
}
AbstractParcelable::ReadFromParcel(parcel);
ReadInt(parcel, &query_size);
for (int i = 0; i < query_size; ++i) {
- queries_.emplace_back(parcel->ReadString());
+ std::vector<std::string> args;
+ int index = -1;
+ int arg_cnt = 0;
+ ReadInt(parcel, &index);
+ ReadInt(parcel, &arg_cnt);
+
+ for (int j = 0; j < arg_cnt; ++j) {
+ args.push_back(parcel->ReadString());
+ }
+ query_args_.push_back(std::pair<int, std::vector<std::string>>(index, std::move(args)));
}
ReadInt(parcel, &db_type);
db_type_ = static_cast<AbstractDBHandler::DBType>(db_type);
op_type_ = static_cast<AbstractDBHandler::OperationType>(op_type);
}
-const std::vector<std::string>& QueryParcelable::GetQueries() {
- return queries_;
+const std::vector<std::pair<int, std::vector<std::string>>>& QueryParcelable::GetQueryArgs() {
+ return query_args_;
}
AbstractDBHandler::DBType QueryParcelable::GetDBType() {
class EXPORT_API QueryParcelable : public AbstractParcelable {
public:
QueryParcelable();
- QueryParcelable(uid_t uid, std::string query, AbstractDBHandler::DBType db_type, AbstractDBHandler::OperationType op_type);
- QueryParcelable(uid_t uid, std::vector<std::string> query, AbstractDBHandler::DBType db_type, AbstractDBHandler::OperationType op_type);
- const std::vector<std::string>& GetQueries();
+ QueryParcelable(uid_t uid, std::pair<int, std::vector<std::string>> query_args,
+ AbstractDBHandler::DBType db_type, AbstractDBHandler::OperationType op_type);
+ QueryParcelable(uid_t uid, std::vector<std::pair<int, std::vector<std::string>>> query_args,
+ AbstractDBHandler::DBType db_type, AbstractDBHandler::OperationType op_type);
+ const std::vector<std::pair<int, std::vector<std::string>>>& GetQueryArgs();
AbstractDBHandler::DBType GetDBType();
AbstractDBHandler::OperationType GetOpType();
void ReadFromParcel(tizen_base::Parcel* parcel) override;
private:
- std::vector<std::string> queries_;
+ std::vector<std::pair<int, std::vector<std::string>>> query_args_;
AbstractDBHandler::DBType db_type_;
AbstractDBHandler::OperationType op_type_;
};
pcd::QueryHandler db(parcel->GetUid(), GetPID());
db.SetLocale(locale);
- db.SetQuery(parcel->GetQueries());
+ db.SetQueryArgs(parcel->GetQueryArgs());
db.SetDBType(parcel->GetDBType());
db.SetOpType(parcel->GetOpType());
int ret = db.Execute();
#include "pkgmgr_parser.h"
#include "pkgmgrinfo_private.h"
+#include "pkgmgr_query_index.h"
#include "client/pkginfo_client.hh"
#include "common/database/abstract_db_handler.hh"
extern "C" EXPORT_API char* _appinfo_get_localed_label(
const char* appid, const char* locale, uid_t uid) {
- char* query = nullptr;
- query = sqlite3_mprintf(
- "SELECT COALESCE((SELECT app_label FROM package_app_localized_info "
- "WHERE app_id=%Q AND app_locale=%Q),"
- "(SELECT app_label FROM package_app_localized_info WHERE "
- "app_id=%Q AND app_locale='No Locale'))",
- appid, locale, appid);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return nullptr;
- }
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_APPINFO_GET_LOCALED_LABEL, { appid, locale, appid } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _appinfo_get_datacontrol_info(
const char* providerid, const char* type, uid_t uid,
char** appid, char** access) {
- char* query = nullptr;
- query = sqlite3_mprintf("SELECT app_id, access FROM "
- "package_app_data_control WHERE "
- "providerid=%Q AND type=%Q",
- providerid, type);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_APPINFO_GET_DATACONTROL_INFO, { providerid, type } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _appinfo_get_datacontrol_appid(
const char* providerid, uid_t uid, char** appid) {
- char* query = nullptr;
-
- query = sqlite3_mprintf("SELECT app_id FROM package_app_data_control "
- "WHERE providerid=%Q",
- providerid);
- if (query == nullptr) {
- LOGE("Out of memory");
- return PMINFO_R_ERROR;
- }
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_APPINFO_GET_DATACONTROL_APPID, { providerid } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _appinfo_get_datacontrol_trusted_info(
const char* providerid, const char* type, uid_t uid,
char** appid, char** trusted) {
- char* query = nullptr;
- query = sqlite3_mprintf(
- "SELECT app_id, trusted FROM package_app_data_control "
- "WHERE providerid=%Q AND type=%Q",
- providerid, type);
- if (query == nullptr) {
- LOGE("Out of memory");
- return PMINFO_R_ERROR;
- }
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_APPINFO_GET_DATACONTROL_TRUSTED_INFO, { providerid, type } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _appinfo_get_datacontrol_privileges(
const char* providerid, const char* type, uid_t uid, GList** privileges) {
- char* query = nullptr;
- query = sqlite3_mprintf(
- "SELECT privilege FROM package_app_data_control_privilege "
- "WHERE providerid=%Q AND type=%Q",
- providerid, type);
- if (query == nullptr) {
- LOGE("Out of memory");
- return PMINFO_R_ERROR;
- }
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_APPINFO_GET_DATACONTROL_PRIVILEGES, { providerid, type } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _appinfo_get_appcontrol_privileges(
const char* appid, const char* operation, uid_t uid, GList** privileges) {
- char* query = nullptr;
- query = sqlite3_mprintf(
- "SELECT app_control, privilege FROM package_app_app_control_privilege "
- "WHERE app_id=%Q", appid);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_APPINFO_GET_APPCONTROL_PRIVILEGES, { appid } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
return PMINFO_R_EINVAL;
}
- char* query = nullptr;
- query = sqlite3_mprintf(
- "SELECT appid FROM "
- "package_plugin_info WHERE pkgid=%Q AND "
- "plugin_type=%Q AND plugin_name=%Q",
- pkgid, plugin_type, plugin_name);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(_getuid(), std::string(query),
+ new pcp::QueryParcelable(_getuid(),
+ { QUERY_INDEX_PLUGININFO_GET_APPIDS, { pkgid, plugin_type, plugin_name } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, _getuid(),
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _get_pkg_updateinfo(const char* pkgid,
GSList** update_info_list, uid_t uid) {
- char* query = nullptr;
int ret;
- if (pkgid == nullptr)
- query = sqlite3_mprintf(
- "SELECT package, update_version, update_type "
- "FROM package_update_info");
- else
- query = sqlite3_mprintf(
- "SELECT package, update_version, update_type "
- "FROM package_update_info WHERE package=%Q",
- pkgid);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
+ std::pair<int, std::vector<std::string>> info;
+
+ if (pkgid == nullptr) {
+ info = std::pair<int, std::vector<std::string>>(
+ QUERY_INDEX_GET_PKG_UPDATEINFO_1, {});
+ } else {
+ info = std::pair<int, std::vector<std::string>>(
+ QUERY_INDEX_GET_PKG_UPDATEINFO_2, { pkgid });
}
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, std::string(query),
+ new pcp::QueryParcelable(uid, std::move(info),
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
- sqlite3_free(query);
pkgmgr_client::PkgInfoClient client(parcelable, uid,
pkgmgr_common::ReqType::QUERY);
extern "C" EXPORT_API int _pkginfo_set_usr_installed_storage(const char* pkgid,
INSTALL_LOCATION location, const char* external_pkg_path, uid_t uid) {
- char* query = nullptr;
const char* location_str;
- std::vector<std::string> queries;
if (location == INSTALL_INTERNAL)
location_str = "installed_internal";
location_str = "installed_external";
else
location_str = "installed_extended";
- /* pkgcakge_info table */
- query = sqlite3_mprintf(
- "UPDATE package_info SET installed_storage=%Q, external_path=%Q "
- "WHERE package=%Q",
- location_str, external_pkg_path, pkgid);
- queries.emplace_back(query);
- sqlite3_free(query);
-
- /* package_app_info table */
- query = sqlite3_mprintf(
- "UPDATE package_app_info SET app_installed_storage=%Q, "
- "app_external_path=%Q WHERE package=%Q",
- location_str, external_pkg_path, pkgid);
- queries.emplace_back(query);
- sqlite3_free(query);
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, queries,
+ new pcp::QueryParcelable(uid, { {
+ QUERY_INDEX_PKGINFO_SET_USR_INSTALLED_STORAGE_1, {
+ location_str,
+ external_pkg_path,
+ pkgid
+ }
+ }, {
+ QUERY_INDEX_PKGINFO_SET_USR_INSTALLED_STORAGE_2, {
+ location_str,
+ external_pkg_path,
+ pkgid
+ }
+ },
+ },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE));
extern "C" EXPORT_API int _certinfo_compare_pkg_certinfo(const char* l_pkgid,
const char* r_pkgid, pkgmgrinfo_cert_compare_result_type_e* result) {
- char* query = sqlite3_mprintf("SELECT package, "
- "COALESCE(author_signer_cert, -1) FROM package_cert_info WHERE "
- "package IN (%Q, %Q)",
- l_pkgid, r_pkgid);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
- std::vector<std::string> queries;
- queries.emplace_back(query);
- sqlite3_free(query);
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(0, queries,
+ new pcp::QueryParcelable(0,
+ { QUERY_INDEX_CERTINFO_COMPARE_PKG_CERTINFO, { l_pkgid, r_pkgid } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_CERTDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, 0,
extern "C" EXPORT_API int _certinfo_compare_app_certinfo(uid_t uid,
const char* l_appid, const char* r_appid,
pkgmgrinfo_cert_compare_result_type_e* result) {
- char* query = sqlite3_mprintf("SELECT app_id, package FROM "
- "package_app_info WHERE app_id IN (%Q, %Q)",
- l_appid, r_appid);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
- std::vector<std::string> queries;
- queries.emplace_back(query);
- sqlite3_free(query);
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, queries,
+ new pcp::QueryParcelable(uid,
+ { QUERY_INDEX_CERTINFO_COMPARE_APP_CERTINFO, { l_appid, r_appid } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
pkgmgr_client::PkgInfoClient client(parcelable, uid,
}
extern "C" EXPORT_API int _parser_execute_write_query(
- const char* query, uid_t uid) {
+ int query_index, const char** query_args, unsigned int arg_cnt, uid_t uid) {
+ std::vector<std::string> args;
+
+ for (unsigned int i = 0; i < arg_cnt; i++) {
+ if (query_args[i])
+ args.push_back(query_args[i]);
+ else
+ args.push_back("");
+ }
+
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, query,
+ new pcp::QueryParcelable(uid, { query_index, std::move(args) },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE));
LOG(ERROR) << "Invalid parcelable type";
return -1;
}
-
return 0;
}
extern "C" EXPORT_API int _parser_execute_write_queries(
- const char** queries, int len, uid_t uid) {
- std::vector<std::string> query_vt;
- for (int i = 0; i < len; ++i)
- query_vt.emplace_back(queries[i]);
+ int query_index, const char*** query_args, unsigned int arg_cnt,
+ unsigned int query_cnt, uid_t uid) {
+ std::vector<std::pair<int, std::vector<std::string>>> queries;
+
+ for (unsigned int i = 0; i < query_cnt; i++) {
+ std::vector<std::string> args;
+ for (unsigned int j = 0; j < arg_cnt; j++) {
+ if (query_args[i][j])
+ args.push_back(query_args[i][j]);
+ else
+ args.push_back("");
+ }
+ queries.push_back({ query_index, std::move(args) });
+ }
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(uid, query_vt,
+ new pcp::QueryParcelable(uid, std::move(queries),
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE));
}
extern "C" EXPORT_API int _pkginfo_delete_certinfo(const char* pkgid) {
- char* query = sqlite3_mprintf("UPDATE package_cert_info SET "
- "package_count = package_count - 1 WHERE package=%Q", pkgid);
- if (query == nullptr) {
- LOG(ERROR) << "Out of memory";
- return PMINFO_R_ERROR;
- }
-
- std::vector<std::string> queries;
- queries.emplace_back(query);
- sqlite3_free(query);
-
std::shared_ptr<pcp::AbstractParcelable> parcelable(
- new pcp::QueryParcelable(0, queries,
+ new pcp::QueryParcelable(0,
+ { QUERY_INDEX_PKGINFO_DELETE_CERTINFO, { pkgid } },
pcd::AbstractDBHandler::DBType::DB_TYPE_FILE_CERTDB,
pcd::AbstractDBHandler::OperationType::OPERATION_TYPE_WRITE));
int _certinfo_compare_app_certinfo(uid_t uid, const char *l_appid,
const char *r_appid, pkgmgrinfo_cert_compare_result_type_e *result);
-int _parser_execute_write_query(const char *query, uid_t uid);
+int _parser_execute_write_query(int query_index, const char** query_args,
+ unsigned int arg_cnt, uid_t uid);
-int _parser_execute_write_queries(const char **queries, int len, uid_t uid);
+int _parser_execute_write_queries(int query_index, const char*** query_args,
+ unsigned int arg_cnt, unsigned int query_cnt, uid_t uid);
int _parser_insert_manifest_info(manifest_x *mfx, uid_t uid);
TEST_F(ParcelTest, QueryParcelable) {
tizen_base::Parcel parcel;
- std::vector<std::string> query;
- query.emplace_back("select * from package_info");
+ std::vector<std::pair<int, std::vector<std::string>>> query_args = {
+ { 0, { "arg1", "arg2" } },
+ { 1, { "arg1" } }
+ };
- pp::QueryParcelable origin_parcelable(0, query,
+ pp::QueryParcelable origin_parcelable(0, query_args,
pcb::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
pcb::AbstractDBHandler::OperationType::OPERATION_TYPE_READ);
pp::QueryParcelable new_parcelable;
parcel.WriteParcelable(origin_parcelable);
parcel.ReadParcelable(&new_parcelable);
- EXPECT_EQ(origin_parcelable.GetQueries(), new_parcelable.GetQueries());
+ EXPECT_EQ(origin_parcelable.GetQueryArgs().size(), new_parcelable.GetQueryArgs().size());
+ EXPECT_EQ(origin_parcelable.GetQueryArgs()[0].first, new_parcelable.GetQueryArgs()[0].first);
+ EXPECT_EQ(origin_parcelable.GetQueryArgs()[1].first, new_parcelable.GetQueryArgs()[1].first);
+ EXPECT_EQ(origin_parcelable.GetQueryArgs()[0].second[0], new_parcelable.GetQueryArgs()[0].second[0]);
+ EXPECT_EQ(origin_parcelable.GetQueryArgs()[0].second[1], new_parcelable.GetQueryArgs()[0].second[1]);
+ EXPECT_EQ(origin_parcelable.GetQueryArgs()[1].second[0], new_parcelable.GetQueryArgs()[1].second[0]);
EXPECT_EQ(origin_parcelable.GetDBType(), new_parcelable.GetDBType());
EXPECT_EQ(origin_parcelable.GetOpType(), new_parcelable.GetOpType());
}
projects / platform / core / appfw / pkgmgr-info.git / commitdiff