refactor

support/include/utils/db/sqlite/db_common.hpp

@@ -28,17 +28,13 @@
 namespace repertory::utils::db::sqlite {
 using db_types_t = std::variant<std::int64_t, std::string>;
 
-struct sqlite3_deleter {
-  void operator()(sqlite3 *db3) const {
-    if (db3 != nullptr) {
-      sqlite3_close_v2(db3);
-    }
-  }
+struct sqlite3_deleter final {
+  void operator()(sqlite3 *db3) const;
 };
 
 using db3_t = std::unique_ptr<sqlite3, sqlite3_deleter>;
 
-struct sqlite3_statement_deleter {
+struct sqlite3_statement_deleter final {
   void operator()(sqlite3_stmt *stmt) const {
     if (stmt != nullptr) {
       sqlite3_finalize(stmt);
@@ -104,16 +100,7 @@ public:
   }
 
 #if defined(PROJECT_ENABLE_JSON)
-  [[nodiscard]] auto get_value_as_json() const -> nlohmann::json {
-    return std::visit(
-        overloaded{
-            [this](std::int64_t value) -> auto {
-              return nlohmann::json({{name_, value}});
-            },
-            [](auto &&value) -> auto { return nlohmann::json::parse(value); },
-        },
-        value_);
-  }
+  [[nodiscard]] auto get_value_as_json() const -> nlohmann::json;
 #endif // defined(PROJECT_ENABLE_JSON)
 };
 
@@ -211,7 +198,8 @@ public:
   [[nodiscard]] auto get_error() const -> std::int32_t { return res_; }
 
   [[nodiscard]] auto get_error_str() const -> std::string {
-    return sqlite3_errstr(res_);
+    auto &&err_msg = sqlite3_errstr(res_);
+    return err_msg == nullptr ? std::to_string(res_) : err_msg;
   }
 
   [[nodiscard]] auto get_row(std::optional<db_row<ctx_t>> &row) const -> bool {

support/include/utils/error.hpp

@@ -72,8 +72,7 @@ extern std::atomic<const i_exception_handler *> exception_handler;
 }
 #endif // defined(PROJECT_ENABLE_TESTING)
 
-[[nodiscard]] auto create_error_message(std::string_view function_name,
-                                        std::vector<std::string_view> items)
+[[nodiscard]] auto create_error_message(std::vector<std::string_view> items)
     -> std::string;
 
 void handle_error(std::string_view function_name, std::string_view msg);

support/src/utils/db/sqlite/db_common.cpp

@@ -19,13 +19,63 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
 */
-#include "utils/db/sqlite/db_common.hpp"
-
 #if defined(PROJECT_ENABLE_SQLITE)
 
+#include "utils/db/sqlite/db_common.hpp"
+
+#include "utils/common.hpp"
+#include "utils/error.hpp"
+
 namespace repertory::utils::db::sqlite {
-auto execute_sql(sqlite3 &db3, const std::string &sql,
-                 std::string &err) -> bool {
+void sqlite3_deleter::operator()(sqlite3 *db3) const {
+  REPERTORY_USES_FUNCTION_NAME();
+
+  if (db3 == nullptr) {
+    return;
+  }
+
+  utils::error::handle_error(function_name, "closing database handle");
+  sqlite3_db_cacheflush(db3);
+
+  std::string err_msg;
+  execute_sql(*db3, "PRAGMA wal_checkpoint(full);", err_msg);
+
+  if (not utils::retry_action(
+          [&db3]() -> bool {
+            auto res = sqlite3_close_v2(db3);
+            if (res == SQLITE_OK) {
+              return true;
+            }
+
+            auto &&err_str = sqlite3_errstr(res);
+            utils::error::handle_error(
+                function_name,
+                utils::error::create_error_message({
+                    "failed to close database",
+                    (err_str == nullptr ? std::to_string(res) : err_str),
+                }));
+            return false;
+          },
+          60U)) {
+    utils::error::handle_error(function_name, "failed to close database");
+  }
+}
+
+#if defined(PROJECT_ENABLE_JSON)
+auto db_column::get_value_as_json() const -> nlohmann::json {
+  return std::visit(
+      overloaded{
+          [this](std::int64_t value) -> auto {
+            return nlohmann::json({{name_, value}});
+          },
+          [](auto &&value) -> auto { return nlohmann::json::parse(value); },
+      },
+      value_);
+}
+#endif // defined(PROJECT_ENABLE_JSON)
+
+auto execute_sql(sqlite3 &db3, const std::string &sql, std::string &err)
+    -> bool {
   char *err_msg{nullptr};
   auto res = sqlite3_exec(&db3, sql.c_str(), nullptr, nullptr, &err_msg);
   if (err_msg != nullptr) {

support/src/utils/db/sqlite/db_delete.cpp

@@ -24,7 +24,10 @@
 #if defined(PROJECT_ENABLE_SQLITE)
 
 namespace repertory::utils::db::sqlite {
-void db_delete::context::clear() { where_data.reset(); }
+void db_delete::context::clear() {
+  // stmt.reset();
+  where_data.reset();
+}
 
 auto db_delete::context::db_delete_op_t::dump() const -> std::string {
   return db_delete{ctx}.dump();

support/src/utils/db/sqlite/db_insert.cpp

@@ -24,10 +24,13 @@
 #if defined(PROJECT_ENABLE_SQLITE)
 
 namespace repertory::utils::db::sqlite {
-void db_insert::context::clear() { values.clear(); }
+void db_insert::context::clear() {
+  // stmt.reset();
+  values.clear();
+}
 
-auto db_insert::column_value(std::string column_name,
-                             db_types_t value) -> db_insert & {
+auto db_insert::column_value(std::string column_name, db_types_t value)
+    -> db_insert & {
   ctx_->values[column_name] = value;
   return *this;
 }

support/src/utils/db/sqlite/db_select.cpp

@@ -31,6 +31,7 @@ void db_select::context::clear() {
   limit.reset();
   offset.reset();
   order_by.reset();
+  // stmt.reset();
   where_data.reset();
 }
 
@@ -72,8 +73,8 @@ auto db_select::column(std::string column_name) -> db_select & {
   return *this;
 }
 
-auto db_select::count(std::string column_name,
-                      std::string as_column_name) -> db_select & {
+auto db_select::count(std::string column_name, std::string as_column_name)
+    -> db_select & {
   ctx_->count_columns[column_name] = as_column_name;
   return *this;
 }
@@ -209,8 +210,8 @@ auto db_select::offset(std::int32_t value) -> db_select & {
   return *this;
 }
 
-auto db_select::order_by(std::string column_name,
-                         bool ascending) -> db_select & {
+auto db_select::order_by(std::string column_name, bool ascending)
+    -> db_select & {
   ctx_->order_by = {column_name, ascending};
   return *this;
 }

support/src/utils/db/sqlite/db_update.cpp

@@ -28,6 +28,7 @@ void db_update::context::clear() {
   column_values.clear();
   limit.reset();
   order_by.reset();
+  // stmt.reset();
   where_data.reset();
 }
 
@@ -52,8 +53,8 @@ auto db_update::context::db_update_op_t::order_by(std::string column_name,
   return *this;
 }
 
-auto db_update::column_value(std::string column_name,
-                             db_types_t value) -> db_update & {
+auto db_update::column_value(std::string column_name, db_types_t value)
+    -> db_update & {
   ctx_->column_values[column_name] = value;
   return *this;
 }
@@ -173,8 +174,8 @@ auto db_update::limit(std::int32_t value) -> db_update & {
   return *this;
 }
 
-auto db_update::order_by(std::string column_name,
-                         bool ascending) -> db_update & {
+auto db_update::order_by(std::string column_name, bool ascending)
+    -> db_update & {
   ctx_->order_by = {column_name, ascending};
   return *this;
 }

support/src/utils/error.cpp

@@ -25,10 +25,8 @@ namespace repertory::utils::error {
 std::atomic<const i_exception_handler *> exception_handler{
     &default_exception_handler};
 
-auto create_error_message(std::string_view function_name,
-                          std::vector<std::string_view> items) -> std::string {
+auto create_error_message(std::vector<std::string_view> items) -> std::string {
   std::stringstream stream{};
-  stream << function_name;
   for (auto &&item : items) {
     stream << '|' << item;
   }

support/src/utils/file_file.cpp

@@ -486,7 +486,7 @@ auto file::write(const unsigned char *data, std::size_t to_write,
         break;
       }
 
-      bytes_written += res;
+      bytes_written += written;
     }
 
     flush();