Refactor pkgmgr-info

[platform/core/appfw/pkgmgr-info.git] / src / server / database / query_handler.cc

diff --git a/src/server/database/query_handler.cc b/src/server/database/query_handler.cc
index b34a2dc..1d481e3 100644 (file)
--- a/src/server/database/query_handler.cc
+++ b/src/server/database/query_handler.cc
@@ -188,17 +188,6 @@ class QueryMaker {
 
 QueryMaker __query_maker;
 
-void __free_argument(gpointer data) {
-  query_args* args = reinterpret_cast<query_args*>(data);
-  g_list_free(args->argument);
-  free(args);
-}
-
-void __free_query_list(GList* queries, GList* args_list) {
-  g_list_free(queries);
-  g_list_free_full(args_list, __free_argument);
-}
-
 }  // namespace
 
 namespace pkgmgr_server {
@@ -222,50 +211,37 @@ std::vector<pkgmgr_common::parcel::StrArgs> QueryHandler::GetResult() {
   return std::move(result_);
 }
 
-int QueryHandler::ExecuteReadQuery(GList* queries, GList* args_list) {
+int QueryHandler::ExecuteReadQuery(const std::vector<std::string>& queries,
+    const std::vector<std::vector<std::optional<std::string>>>& args_list) {
   std::shared_lock<std::shared_mutex> s(lock_);
   if (!Connect()) {
     LOG(ERROR) << "Failed to connect database";
     return PMINFO_R_ERROR;
   }
 
-  std::vector<std::pair<sqlite3*, uid_t>> conn_list = GetConnection();
+  const auto& conn_list = GetConnection();
   int ret = PMINFO_R_ERROR;
-  for (auto& conn : conn_list) {
-    for (GList* it = args_list; it; it = it->next) {
-      GList* list = nullptr;
-      int row = 0;
-      int col = 0;
-
-      query_args* params = reinterpret_cast<query_args*>(it->data);
-      ret = get_query_result(conn.first, (const char *)queries->data,
-          params->argument, &list, &row, &col);
+  for (const auto& conn : conn_list) {
+    int i = 0;
+    for (auto& q : queries) {
+      std::vector<std::vector<std::optional<std::string>>> result;
+      ret = internal::GetQueryResult(conn.first, q, args_list[i++], result);
       if (ret == PMINFO_R_ERROR) {
         LOG(ERROR) << "Failed to execute query";
         return ret;
       }
 
-      GList* tmp = list;
-      for (int i = 0; i < row; ++i) {
-        pkgmgr_common::parcel::StrArgs vt;
-        for (int j = 0; j < col; ++j) {
-          if (!tmp->data)
-            vt.emplace_back(std::nullopt);
-          else
-            vt.emplace_back(reinterpret_cast<char *>(tmp->data));
-          tmp = tmp->next;
-        }
-        result_.emplace_back(std::move(vt));
+      for (auto& r : result) {
+        result_.push_back(std::move(r));
       }
-
-      g_list_free_full(list, free);
     }
   }
 
   return ret;
 }
 
-int QueryHandler::ExecuteWriteQuery(GList* queries, GList* args_list,
+int QueryHandler::ExecuteWriteQuery(const std::vector<std::string>& queries,
+    const std::vector<std::vector<std::optional<std::string>>>& args_list,
     const std::vector<std::pair<CacheChangeFlag, std::string>>& changes) {
   std::unique_lock<std::shared_mutex> u(lock_);
   if (!Connect()) {
@@ -273,11 +249,11 @@ int QueryHandler::ExecuteWriteQuery(GList* queries, GList* args_list,
     return PMINFO_R_ERROR;
   }
 
-  std::vector<std::pair<sqlite3*, uid_t>> conn_list = GetConnection();
+  const auto& conn_list = GetConnection();
   int ret = PMINFO_R_ERROR;
   bool is_writer = DBHandleProvider::IsWriter(GetPID());
-  for (auto& conn : conn_list) {
-    ret = execute_write_queries(conn.first, queries, args_list);
+  for (const auto& conn : conn_list) {
+    ret = internal::ExecuteWriteQueries(conn.first, queries, args_list);
     if (ret != PMINFO_R_OK) {
       LOG(ERROR) << "Failed to execute";
       break;
@@ -329,33 +305,19 @@ int QueryHandler::ExecuteWriteQuery(GList* queries, GList* args_list,
 }
 
 int QueryHandler::Execute() {
-  GList* queries = nullptr;
-  GList* args_list = nullptr;
+  std::vector<std::string> queries;
+  std::vector<std::vector<std::optional<std::string>>> args_list;
   std::vector<std::pair<CacheChangeFlag, std::string>> changes;
   for (auto& [queryIndex, args] : query_args_) {
     const auto& query_info = __query_maker.GetQueryInfo(queryIndex);
     const char* query = std::get<0>(query_info);
     if (query == nullptr) {
       LOG(ERROR) << "Failed to get query";
-      __free_query_list(queries, args_list);
       return PMINFO_R_ERROR;
     }
 
-    queries = g_list_append(queries, (gpointer)query);
-    query_args* arg = reinterpret_cast<query_args*>(
-        calloc(1, sizeof(query_args)));
-    if (arg == nullptr) {
-      LOG(ERROR) << "Out of memory";
-      __free_query_list(queries, args_list);
-      return PMINFO_R_ERROR;
-    }
-    arg->len = args.size();
-    for (auto& argument : args) {
-      arg->argument = g_list_append(arg->argument,
-          gpointer(argument ? (*argument).c_str() : nullptr));
-    }
-
-    args_list = g_list_append(args_list, arg);
+    queries.push_back(query);
+    args_list.push_back(args);
 
     if (GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_READ)
       continue;
@@ -368,7 +330,6 @@ int QueryHandler::Execute() {
     unsigned int idx = std::get<2>(query_info);
     if (args.size() <= idx) {
       LOG(ERROR) << "Invalid query argument";
-      __free_query_list(queries, args_list);
       return PMINFO_R_ERROR;
     }
 
@@ -380,11 +341,9 @@ int QueryHandler::Execute() {
 
   if (GetOpType() == pkgmgr_common::DBOperationType::OPERATION_TYPE_READ) {
     int ret = ExecuteReadQuery(queries, args_list);
-    __free_query_list(queries, args_list);
     return ret;
   } else {
     int ret = ExecuteWriteQuery(queries, args_list, changes);
-    __free_query_list(queries, args_list);
     return ret;
   }
 }