Refactor amd_api_database

amd_api_database has been  refactored to tizen_base::Database.

Change-Id: I06645732b9492e470dabf189f33f39e634019474
Signed-off-by: Changgyu Choi <changyu.choi@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 576a89643a83d9fb143c2042afedd5a07be45b72..866803bccbe8f796834f90dfd797a5972fd24a3f 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -81,6 +81,7 @@ PKG_CHECK_MODULES(SECURITY_MANAGER_DEPS REQUIRED security-manager)
 PKG_CHECK_MODULES(SENSOR_DEPS REQUIRED sensor)
 PKG_CHECK_MODULES(SQLITE3_DEPS REQUIRED sqlite3)
 PKG_CHECK_MODULES(TANCHOR_DEPS REQUIRED tanchor)
+PKG_CHECK_MODULES(TIZEN_DATABASE_DEPS REQUIRED tizen-database)
 PKG_CHECK_MODULES(TIZEN_EXTENSION_CLIENT_DEPS REQUIRED tizen-extension-client)
 PKG_CHECK_MODULES(TIZEN_LAUNCH_CLIENT_DEPS REQUIRED tizen-launch-client)
 PKG_CHECK_MODULES(TIZEN_SHARED_QUEUE_DEPS REQUIRED tizen-shared-queue)

diff --git a/packaging/amd.spec b/packaging/amd.spec
index f30ebe00825efd9aebb92609d77a57f8be04a0ff..dfdf46a9fa02739e962e027482e3ecac4e16528c 100644 (file)
--- a/packaging/amd.spec
+++ b/packaging/amd.spec
@@ -46,6 +46,7 @@ BuildRequires:  pkgconfig(security-manager)
 BuildRequires:  pkgconfig(sensor)
 BuildRequires:  pkgconfig(sqlite3)
 BuildRequires:  pkgconfig(tanchor)
+BuildRequires:  pkgconfig(tizen-database)
 BuildRequires:  pkgconfig(tizen-extension-client)
 BuildRequires:  pkgconfig(tizen-launch-client)
 BuildRequires:  pkgconfig(tizen-shared-queue)

diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index a50311f7964c0a0680a4ac1210ae7aef6604c857..9443db1d18d489e64adb78711d38b9c2487745be 100644 (file)
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -82,6 +82,7 @@ APPLY_PKG_CONFIG(${TARGET_LIB_AMD} PUBLIC
   PKGMGR_DEPS
   PKGMGR_INFO_DEPS
   SQLITE3_DEPS
+  TIZEN_DATABASE_DEPS
   TIZEN_SHARED_QUEUE_DEPS
   TTRACE_DEPS
   UUID_DEPS

diff --git a/src/lib/api/amd_api_database.cc b/src/lib/api/amd_api_database.cc
index 6cbbb71ff0962707c03d0d3ff45e8d354af58964..548b431d056932b43786e64b10d527e42f5bb2e1 100644 (file)
--- a/src/lib/api/amd_api_database.cc
+++ b/src/lib/api/amd_api_database.cc
@@ -31,6 +31,7 @@
 #include <utility>
 #include <vector>
 
+#include <database.hpp>
 #include <shared-queue.hpp>
 
 #include "lib/amd_api.h"
@@ -43,56 +44,24 @@ constexpr const char PATH_AMD_DB[] = "/run/aul/dbspace/.amd.db";
 
 class Cursor {
  public:
-  Cursor(sqlite3* db, const std::string& query,
-      const std::vector<std::string>& bind_text) {
-    sqlite3_stmt* stmt;
-    int ret = sqlite3_prepare_v2(db, query.c_str(), query.length(), &stmt,
-        nullptr);
-    auto stmt_auto = std::unique_ptr<sqlite3_stmt, decltype(sqlite3_finalize)*>(
-        stmt, sqlite3_finalize);
-    if (ret != SQLITE_OK) {
-      _E("sqlite3_prepare_v2() is failed. error(%s:%d)",
-          sqlite3_errmsg(db), ret);
-      THROW(-ret);
+  Cursor(tizen_base::Database db, const std::string& query,
+      const std::vector<std::string>& bind_text)
+      : db_(std::move(db)), sql_(tizen_base::Database::Sql(query)) {
+    for (auto& text : bind_text) {
+      sql_.Bind(text);
     }
-
-    int index = 1;
-    for (auto const& text : bind_text) {
-      ret = sqlite3_bind_text(stmt, index++, text.c_str(), -1,
-          SQLITE_TRANSIENT);
-      if (ret != SQLITE_OK) {
-        _E("sqlite3_bind_text() is failed. index(%d), error(%s:%d)",
-            index - 1, sqlite3_errmsg(db), ret);
-        THROW(-ret);
-      }
-    }
-
-    stmt_ = stmt_auto.release();
   }
 
-  ~Cursor() {
-    if (stmt_ != nullptr)
-      sqlite3_finalize(stmt_);
-  }
+  ~Cursor() = default;
 
   Cursor(const Cursor&) = delete;
   Cursor& operator=(const Cursor&) = delete;
 
   void Next() {
-    int ret = sqlite3_step(stmt_);
-    if (ret == SQLITE_ROW)
-      return;
-
-    if (ret == SQLITE_DONE)
-      _D("SQLITE_DONE");
-    else if (ret == SQLITE_BUSY)
-      _E("SQLITE_BUSY");
-    else if (ret == SQLITE_ERROR)
-      _E("SQLITE_ERROR");
-    else if (ret == SQLITE_MISUSE)
-      _E("SQLITE_MISUSE");
-
-    done_ = true;
+    ++iter_;
+    if (!(iter_ != result_.end())) {
+      done_ = true;
+    }
   }
 
   bool IsDone() const {
@@ -100,26 +69,24 @@ class Cursor {
   }
 
   bool Execute() {
-    int ret = sqlite3_step(stmt_);
-    if (ret != SQLITE_DONE) {
-      if (ret != SQLITE_ROW) {
-        _E("sqlite3_step() is failed. error(%d)", ret);
-        done_ = true;
-      }
+    result_ = db_.Exec(sql_);
+    iter_ = result_.begin();
 
-      return false;
-    }
+    if (!(iter_ != result_.end()))
+      done_ = true;
 
-    done_ = true;
-    return true;
+    return static_cast<bool>(result_);
   }
 
   const char* GetColumn(int index) {
-    return reinterpret_cast<const char*>(sqlite3_column_text(stmt_, index));
+    return reinterpret_cast<const char*>(sqlite3_column_text(result_.GetRaw(), index));
   }
 
  private:
-  sqlite3_stmt* stmt_ = nullptr;
+  tizen_base::Database db_;
+  tizen_base::Database::Sql sql_;
+  tizen_base::Database::Result result_;
+  tizen_base::Database::Result::Iterator iter_ = tizen_base::Database::Result::Iterator(nullptr);
   bool done_ = false;
 };
 
@@ -174,10 +141,10 @@ class DBManager {
       amd_database_query_cb cb, void* user_data, bool sync) {
     if (sync) {
       try {
-        amd::Database db(PATH_AMD_DB);
-        db.Open(SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE);
-        auto cursor = std::make_unique<Cursor>(db.GetHandle(),
-            std::move(query), std::move(bind_text));
+        tizen_base::Database db(PATH_AMD_DB,
+            SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE);
+        auto cursor = std::make_unique<Cursor>(std::move(db), std::move(query),
+            std::move(bind_text));
         return cb(cursor.get(), user_data);
       } catch (const amd::Exception& e) {
         _E("Exception(%d) occurs", e.GetErrorCode());
@@ -201,43 +168,38 @@ class DBManager {
     if (!disposed_)
       return;
 
-    db_.reset(new amd::Database(PATH_AMD_DB));
-    thread_ = std::thread([&]{
-          SetComm("DBWriter+");
-          do {
-            auto job = queue_.WaitAndPop();
-            if (job.IsDone())
-              break;
-
-            try {
-              db_->Open(SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE);
-            } catch (const amd::Exception& e) {
-              _E("Open() is failed. error(%d)", e.GetErrorCode());
-              continue;
-            }
-
-            db_->BeginTransaction();
-
-            std::unique_ptr<Cursor> cursor;
-            try {
-              cursor = std::make_unique<Cursor>(db_->GetHandle(),
-                  job.GetQuery(), job.GetBindText());
-            } catch (const amd::Exception& e) {
-              _E("Failed to create Cursor. error(%s)", e.what());
-              db_->EndTransaction();
-              db_->Close();
-              queue_.Push(std::move(job));
-              continue;
-            }
-
+    thread_ = std::thread([&] {
+      SetComm("DBWriter+");
+      int retry = 0;
+      do {
+        auto job = queue_.WaitAndPop();
+        if (job.IsDone())
+          break;
+
+        try {
+          tizen_base::Database db(PATH_AMD_DB,
+              SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE);
+
+          std::unique_ptr<Cursor> cursor;
+          {
+            auto guard = db.CreateTransactionGuard();
+            cursor = std::make_unique<Cursor>(std::move(db), job.GetQuery(),
+                                              job.GetBindText());
             int ret = job.Invoke(cursor.get());
-            if (ret != 0)
-              db_->Rollback();
-
-            db_->EndTransaction();
-            db_->Close();
-          } while (true);
-        });
+            if (ret == 0)
+              guard.Commit();
+          }
+          retry = 0;
+        } catch (const std::exception& e) {
+          _E("Failed to execute a job: %s", e.what());
+          retry++;
+          if (retry < 5) {
+            _W("retry(%d)", retry);
+            queue_.Push(std::move(job));
+          }
+        }
+      } while (true);
+    });
 
     disposed_ = false;
   }
@@ -251,7 +213,8 @@ class DBManager {
       timer_ = 0;
     }
 
-    db_->Close();
+    queue_.Push(Job(true));
+    thread_.join();
     disposed_ = true;
   }
 
@@ -289,7 +252,6 @@ class DBManager {
 
  private:
   bool disposed_ = true;
-  std::unique_ptr<amd::Database> db_;
   std::thread thread_;
   tizen_base::SharedQueue<Job> queue_;
   guint timer_ = 0;
@@ -344,7 +306,7 @@ extern "C" EXPORT_API int amd_database_cursor_column(
 
   auto* h = static_cast<Cursor*>(cursor);
   *value = h->GetColumn(index);
-  return 0;
+  return *value == nullptr ? -1 : 0;
 }
 
 extern "C" EXPORT_API int amd_database_execute(const char* query,

diff --git a/src/lib/app_com/app_com_dao_implementation.cc b/src/lib/app_com/app_com_dao_implementation.cc
index 74f89b3e2c2769046ceb653f7cf439a6902c572e..8dafcea1c14a47572e3da08a763923b155cb5109 100644 (file)
--- a/src/lib/app_com/app_com_dao_implementation.cc
+++ b/src/lib/app_com/app_com_dao_implementation.cc
@@ -144,7 +144,7 @@ AppComDaoImpl::GetAllEndpoints() {
                   std::move(client_filter), client_pid, client_uid, nullptr));
           }
 
-          amd_database_cursor_execute(cursor);
+          amd_database_cursor_next(cursor);
           amd_database_cursor_is_done(cursor, &done);
         }