Set QueryHandler's operation,db type before use

Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

diff --git a/src/common/database/abstract_db_handler.hh b/src/common/database/abstract_db_handler.hh
index dab9c3f..0c7099a 100644 (file)
--- a/src/common/database/abstract_db_handler.hh
+++ b/src/common/database/abstract_db_handler.hh
@@ -47,13 +47,13 @@ class EXPORT_API AbstractDBHandler {
   virtual ~AbstractDBHandler();
   virtual bool Execute() = 0;
   void SetLocale(const std::string& locale);
+  void SetDBType(DBType type);
+  void SetOpType(OperationType type);
 
  protected:
   bool Connect();
   sqlite3* GetConnection();
   std::string GetLocale();
-  void SetOpType(OperationType type);
-  void SetDBType(DBType type);
 
  private:
   std::string GetDBPath();

diff --git a/src/common/database/query_handler.cc b/src/common/database/query_handler.cc
index 8d4d3d9..e260c70 100644 (file)
--- a/src/common/database/query_handler.cc
+++ b/src/common/database/query_handler.cc
@@ -38,8 +38,6 @@ std::vector<std::vector<std::string>>&& QueryHandler::GetResult() {
 }
 
 bool QueryHandler::Execute() {
-  SetOpType(OPERATION_TYPE_READ);
-  SetDBType(DB_TYPE_FILE_PKGDB);
   if (!Connect()) return false;
 
   // TODO: db handle should be delivered

diff --git a/src/common/parcel/query_parcelable.cc b/src/common/parcel/query_parcelable.cc
index 65a599c..461ea77 100644 (file)
--- a/src/common/parcel/query_parcelable.cc
+++ b/src/common/parcel/query_parcelable.cc
@@ -25,29 +25,45 @@ namespace pkgmgr_common {
 namespace parcel {
 
 QueryParcelable::QueryParcelable()
-    : AbstractParcelable(0, ParcelableType::Query) {}
+    : AbstractParcelable(0, ParcelableType::Query), query_(""), db_type_(AbstractDBHandler::DBType::DB_TYPE_NONE), op_type_(AbstractDBHandler::OperationType::OPERATION_TYPE_NONE) {}
 
-QueryParcelable::QueryParcelable(uid_t uid, std::string query)
-    : AbstractParcelable(uid, ParcelableType::Query), query_(query) {}
+QueryParcelable::QueryParcelable(uid_t uid, std::string query, AbstractDBHandler::DBType db_type, AbstractDBHandler::OperationType op_type)
+    : AbstractParcelable(uid, ParcelableType::Query), query_(query), db_type_(db_type), op_type_(op_type) {}
 
 void QueryParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
   AbstractParcelable::WriteToParcel(parcel);
   WriteString(parcel, query_.c_str());
+  WriteInt(parcel, db_type_);
+  WriteInt(parcel, op_type_);
 }
 
 void QueryParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
   char *query = nullptr;
+  int op_type = 0;
+  int db_type = 0;
 
   AbstractParcelable::ReadFromParcel(parcel);
   ReadString(parcel, &query);
   query_ = query;
   free(query);
+  ReadInt(parcel, &db_type);
+  db_type_ = static_cast<AbstractDBHandler::DBType>(db_type);
+  ReadInt(parcel, &op_type);
+  op_type_ = static_cast<AbstractDBHandler::OperationType>(op_type);
 }
 
 const std::string& QueryParcelable::GetQuery() {
   return query_;
 }
 
+AbstractDBHandler::DBType QueryParcelable::GetDBType() {
+  return db_type_;
+}
+
+AbstractDBHandler::OperationType QueryParcelable::GetOpType() {
+  return op_type_;
+}
+
 std::unique_ptr<AbstractParcelable> QueryParcelable::Factory::CreateParcel() {
   return nullptr;
 }

diff --git a/src/common/parcel/query_parcelable.hh b/src/common/parcel/query_parcelable.hh
index afeca63..7b2e260 100644 (file)
--- a/src/common/parcel/query_parcelable.hh
+++ b/src/common/parcel/query_parcelable.hh
@@ -2,11 +2,14 @@
 #define QUERY_PARCELABLE_HH_
 
 #include "abstract_parcelable.hh"
+#include "abstract_db_handler.hh"
 
 #include <vector>
 
 #include "pkgmgrinfo_private.h"
 
+using namespace pkgmgr_common::database;
+
 namespace pkgmgr_common {
 namespace parcel {
 
@@ -22,14 +25,18 @@ class EXPORT_API QueryParcelable : public AbstractParcelable {
   };
 
   QueryParcelable();
-  QueryParcelable(uid_t uid, std::string query);
+  QueryParcelable(uid_t uid, std::string query, AbstractDBHandler::DBType db_type, AbstractDBHandler::OperationType op_type);
   const std::string& GetQuery();
+  AbstractDBHandler::DBType GetDBType();
+  AbstractDBHandler::OperationType GetOpType();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
   void ReadFromParcel(tizen_base::Parcel* parcel) override;
 
  private:
   std::string query_;
+  AbstractDBHandler::DBType db_type_;
+  AbstractDBHandler::OperationType op_type_;
 };
 
 }  // namespace parcel

diff --git a/src/common/request_handler/query_request_handler.cc b/src/common/request_handler/query_request_handler.cc
index b427fd1..d1fca70 100644 (file)
--- a/src/common/request_handler/query_request_handler.cc
+++ b/src/common/request_handler/query_request_handler.cc
@@ -29,6 +29,8 @@ bool QueryRequestHandler::HandleRequest(unsigned char* data, int size,
   QueryHandler db(parcel->GetUid());
   db.SetLocale(locale);
   db.SetQuery(parcel->GetQuery());
+  db.SetDBType(parcel->GetDBType());
+  db.SetOpType(parcel->GetOpType());
   if (db.Execute() == false) return false;
 
   result_ = std::make_shared<ResultParcelable>(db.GetResult());

diff --git a/src/manager/pkginfo_manager.cc b/src/manager/pkginfo_manager.cc
index 782bb3f..af51152 100644 (file)
--- a/src/manager/pkginfo_manager.cc
+++ b/src/manager/pkginfo_manager.cc
@@ -26,6 +26,7 @@
 #include "pkgmgrinfo_private.h"
 
 #include "logging.hh"
+#include "common/database/abstract_db_handler.hh"
 #include "common/parcel/appinfo_parcelable.hh"
 #include "common/parcel/filter_parcelable.hh"
 #include "common/parcel/pkginfo_parcelable.hh"
@@ -112,7 +113,9 @@ extern "C" EXPORT_API char *_appinfo_get_localed_label(
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::QUERY);
@@ -159,7 +162,9 @@ extern "C" EXPORT_API int _appinfo_get_datacontrol_info(
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::QUERY);
@@ -206,7 +211,9 @@ extern "C" EXPORT_API int _appinfo_get_datacontrol_appid(
                return PMINFO_R_ERROR;
        }
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::QUERY);
@@ -255,7 +262,9 @@ extern "C" EXPORT_API int _appinfo_get_datacontrol_trusted_info(
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::QUERY);
@@ -305,7 +314,9 @@ extern "C" EXPORT_API int _appinfo_get_datacontrol_privileges(
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::QUERY);
@@ -354,7 +365,9 @@ extern "C" EXPORT_API int _appinfo_get_appcontrol_privileges(
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,
                        pkgmgr_common::ReqType::QUERY);
@@ -418,7 +431,9 @@ extern "C" EXPORT_API int _plugininfo_get_appids(
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(_getuid(), std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(_getuid(), std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
        sqlite3_free(query);
 
        pkgmgr_client::PkgInfoClient client(parcelable, _getuid(),
@@ -502,7 +517,9 @@ extern "C" EXPORT_API int _get_pkg_updateinfo(const char *pkgid,
        }
 
        std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcelable(
-                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query)));
+                       new pkgmgr_common::parcel::QueryParcelable(uid, std::string(query),
+          pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+          pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ));
        sqlite3_free(query);
 
        pkgmgr_client::PkgInfoClient client(parcelable, uid,

diff --git a/test/unit_tests/test_parcel.cc b/test/unit_tests/test_parcel.cc
index 7bf0164..f5bbe5e 100644 (file)
--- a/test/unit_tests/test_parcel.cc
+++ b/test/unit_tests/test_parcel.cc
@@ -21,6 +21,7 @@
 #include <iostream>
 #include <tuple>
 
+#include "common/database/abstract_db_handler.hh"
 #include "common/parcel/abstract_parcelable.hh"
 #include "common/parcel/appinfo_parcelable.hh"
 #include "common/parcel/certinfo_parcelable.hh"
@@ -176,12 +177,16 @@ TEST_F(ParcelTest, QueryParcelable) {
   tizen_base::Parcel parcel;
   std::string query = "select * from package_info";
 
-  pp::QueryParcelable origin_parcelable(0, query);
+  pp::QueryParcelable origin_parcelable(0, query,
+      pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
+      pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ);
   pp::QueryParcelable new_parcelable;
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
 
   EXPECT_EQ(origin_parcelable.GetQuery(), new_parcelable.GetQuery());
+  EXPECT_EQ(origin_parcelable.GetDBType(), new_parcelable.GetDBType());
+  EXPECT_EQ(origin_parcelable.GetOpType(), new_parcelable.GetOpType());
 }
 
 TEST_F(ParcelTest, ParcelableFactory) {