From 08e381a307b037d0dec738d3d84ef9cc16b614de Mon Sep 17 00:00:00 2001
From: "Scott E. Graves" <scott.e.graves@protonmail.com>
Date: Tue, 22 Oct 2024 15:01:04 -0500
Subject: [PATCH] refactor

---
 .../src/file_manager/file_manager.cpp         | 27 +++----
 .../providers/encrypt/encrypt_provider.cpp    | 76 ++++++++++---------
 .../librepertory/src/providers/meta_db.cpp    | 20 ++---
 support/include/utils/db/sqlite/db_common.hpp | 33 ++++----
 support/include/utils/db/sqlite/db_delete.hpp |  8 +-
 support/include/utils/db/sqlite/db_insert.hpp |  8 +-
 support/include/utils/db/sqlite/db_select.hpp | 30 +++++---
 support/include/utils/db/sqlite/db_update.hpp | 28 ++++---
 support/src/utils/db/sqlite/db_delete.cpp     | 26 +++----
 support/src/utils/db/sqlite/db_insert.cpp     | 16 ++--
 support/src/utils/db/sqlite/db_select.cpp     | 24 +++---
 support/src/utils/db/sqlite/db_update.cpp     | 27 +++----
 support/test/src/utils/db_sqlite_test.cpp     |  2 +-
 13 files changed, 168 insertions(+), 157 deletions(-)

diff --git a/repertory/librepertory/src/file_manager/file_manager.cpp b/repertory/librepertory/src/file_manager/file_manager.cpp
index d6942e30..e3c0befa 100644
--- a/repertory/librepertory/src/file_manager/file_manager.cpp
+++ b/repertory/librepertory/src/file_manager/file_manager.cpp
@@ -43,8 +43,8 @@
 #include "utils/time.hpp"
 
 namespace {
-[[nodiscard]] auto
-create_resume_entry(const repertory::i_open_file &file) -> json {
+[[nodiscard]] auto create_resume_entry(const repertory::i_open_file &file)
+    -> json {
   return {
       {"chunk_size", file.get_chunk_size()},
       {"path", file.get_api_path()},
@@ -338,7 +338,7 @@ auto file_manager::get_stored_downloads() const -> std::vector<json> {
   auto result = utils::db::sqlite::db_select{*db_, resume_table}.go();
   while (result.has_row()) {
     try {
-      std::optional<utils::db::sqlite::db_select::row> row;
+      std::optional<utils::db::sqlite::db_result::row> row;
       if (not result.get_row(row)) {
         continue;
       }
@@ -375,7 +375,7 @@ auto file_manager::handle_file_rename(const std::string &from_api_path,
                       .where("api_path")
                       .equals(from_api_path)
                       .go();
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     should_upload = result.get_row(row) && row.has_value();
     if (should_upload && source_path.empty()) {
       source_path = row->get_column("source_path").get_value<std::string>();
@@ -438,10 +438,11 @@ auto file_manager::open(const std::string &api_path, bool directory,
   return open(api_path, directory, ofd, handle, file, nullptr);
 }
 
-auto file_manager::open(
-    const std::string &api_path, bool directory, const open_file_data &ofd,
-    std::uint64_t &handle, std::shared_ptr<i_open_file> &file,
-    std::shared_ptr<i_closeable_open_file> closeable_file) -> api_error {
+auto file_manager::open(const std::string &api_path, bool directory,
+                        const open_file_data &ofd, std::uint64_t &handle,
+                        std::shared_ptr<i_open_file> &file,
+                        std::shared_ptr<i_closeable_open_file> closeable_file)
+    -> api_error {
   const auto create_and_add_handle =
       [&](std::shared_ptr<i_closeable_open_file> cur_file) {
         handle = get_next_handle();
@@ -700,8 +701,8 @@ auto file_manager::rename_directory(const std::string &from_api_path,
 }
 
 auto file_manager::rename_file(const std::string &from_api_path,
-                               const std::string &to_api_path,
-                               bool overwrite) -> api_error {
+                               const std::string &to_api_path, bool overwrite)
+    -> api_error {
   if (not provider_.is_rename_supported()) {
     return api_error::not_implemented;
   }
@@ -800,7 +801,7 @@ void file_manager::start() {
   auto result = utils::db::sqlite::db_select{*db_, upload_active_table}.go();
   while (result.has_row()) {
     try {
-      std::optional<utils::db::sqlite::db_select::row> row;
+      std::optional<utils::db::sqlite::db_result::row> row;
       if (result.get_row(row) && row.has_value()) {
         active_items.emplace_back(active_item{
             row->get_column("api_path").get_value<std::string>(),
@@ -824,7 +825,7 @@ void file_manager::start() {
 
   while (result.has_row()) {
     try {
-      std::optional<utils::db::sqlite::db_select::row> row;
+      std::optional<utils::db::sqlite::db_result::row> row;
       if (not(result.get_row(row) && row.has_value())) {
         return;
       }
@@ -1039,7 +1040,7 @@ void file_manager::upload_handler() {
                         .limit(1)
                         .go();
       try {
-        std::optional<utils::db::sqlite::db_select::row> row;
+        std::optional<utils::db::sqlite::db_result::row> row;
         if (result.get_row(row) && row.has_value()) {
           auto api_path = row->get_column("api_path").get_value<std::string>();
           auto source_path =
diff --git a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
index e50f0c05..776175f1 100644
--- a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
+++ b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp
@@ -69,9 +69,10 @@ const std::map<std::string, std::string> sql_create_tables = {
 namespace repertory {
 encrypt_provider::encrypt_provider(app_config &config) : config_(config) {}
 
-auto encrypt_provider::create_api_file(
-    const std::string &api_path, bool directory,
-    const std::string &source_path) -> api_file {
+auto encrypt_provider::create_api_file(const std::string &api_path,
+                                       bool directory,
+                                       const std::string &source_path)
+    -> api_file {
   auto times = utils::file::get_times(source_path);
   if (not times.has_value()) {
     throw std::runtime_error("failed to get file times");
@@ -97,10 +98,10 @@ auto encrypt_provider::create_api_file(
 void encrypt_provider::create_item_meta(api_meta_map &meta, bool directory,
                                         const api_file &file) {
 #if defined(_WIN32)
-  struct _stat64 buf {};
+  struct _stat64 buf{};
   _stat64(file.source_path.c_str(), &buf);
 #else  // !defined(_WIN32)
-  struct stat buf {};
+  struct stat buf{};
   stat(file.source_path.c_str(), &buf);
 #endif // defined(_WIN32)
 
@@ -187,8 +188,9 @@ auto encrypt_provider::do_fs_operation(
   return callback(cfg, source_path);
 }
 
-auto encrypt_provider::get_api_path_from_source(
-    const std::string &source_path, std::string &api_path) const -> api_error {
+auto encrypt_provider::get_api_path_from_source(const std::string &source_path,
+                                                std::string &api_path) const
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -197,7 +199,7 @@ auto encrypt_provider::get_api_path_from_source(
                       .where("source_path")
                       .equals(source_path)
                       .go();
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       api_path = row->get_column("data")
                      .get_value_as_json()
@@ -253,8 +255,9 @@ auto encrypt_provider::get_directory_item_count(
   return count;
 }
 
-auto encrypt_provider::get_directory_items(
-    const std::string &api_path, directory_item_list &list) const -> api_error {
+auto encrypt_provider::get_directory_items(const std::string &api_path,
+                                           directory_item_list &list) const
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   return do_fs_operation(
@@ -273,7 +276,7 @@ auto encrypt_provider::get_directory_items(
                         .where("source_path")
                         .equals(dir_entry->get_path())
                         .go();
-                std::optional<utils::db::sqlite::db_select::row> row;
+                std::optional<utils::db::sqlite::db_result::row> row;
                 if (result.get_row(row) && row.has_value()) {
                   current_api_path =
                       row->get_column("api_path").get_value<std::string>();
@@ -302,7 +305,7 @@ auto encrypt_provider::get_directory_items(
                                   .where("source_path")
                                   .equals(dir_entry->get_path())
                                   .go();
-                std::optional<utils::db::sqlite::db_select::row> row;
+                std::optional<utils::db::sqlite::db_result::row> row;
                 if (result.get_row(row) && row.has_value()) {
                   api_path_data =
                       row->get_column("data").get_value<std::string>();
@@ -385,7 +388,7 @@ auto encrypt_provider::get_file(const std::string &api_path,
                       .where("api_path")
                       .equals(api_path)
                       .go();
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (not(result.get_row(row) && row.has_value())) {
       return api_error::item_not_found;
     }
@@ -427,8 +430,9 @@ auto encrypt_provider::get_file_list(api_file_list &list) const -> api_error {
   return api_error::error;
 }
 
-auto encrypt_provider::get_file_size(
-    const std::string &api_path, std::uint64_t &file_size) const -> api_error {
+auto encrypt_provider::get_file_size(const std::string &api_path,
+                                     std::uint64_t &file_size) const
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -437,7 +441,7 @@ auto encrypt_provider::get_file_size(
                       .where("api_path")
                       .equals(api_path)
                       .go();
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (not(result.get_row(row) && row.has_value())) {
       return api_error::item_not_found;
     }
@@ -454,15 +458,16 @@ auto encrypt_provider::get_file_size(
   return api_error::error;
 }
 
-auto encrypt_provider::get_filesystem_item(
-    const std::string &api_path, bool directory,
-    filesystem_item &fsi) const -> api_error {
+auto encrypt_provider::get_filesystem_item(const std::string &api_path,
+                                           bool directory,
+                                           filesystem_item &fsi) const
+    -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, source_table}
                     .column("source_path")
                     .where("api_path")
                     .equals(api_path)
                     .go();
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (not(result.get_row(row) && row.has_value())) {
     return api_error::item_not_found;
   }
@@ -532,9 +537,10 @@ auto encrypt_provider::get_filesystem_item_from_source_path(
   return get_filesystem_item(api_path, false, fsi);
 }
 
-auto encrypt_provider::get_filesystem_item_and_file(
-    const std::string &api_path, api_file &file,
-    filesystem_item &fsi) const -> api_error {
+auto encrypt_provider::get_filesystem_item_and_file(const std::string &api_path,
+                                                    api_file &file,
+                                                    filesystem_item &fsi) const
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   try {
@@ -576,7 +582,7 @@ auto encrypt_provider::get_item_meta(const std::string &api_path,
                       .where("api_path")
                       .equals(api_path)
                       .go();
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (not(result.get_row(row) && row.has_value())) {
       return api_error::item_not_found;
     }
@@ -624,7 +630,7 @@ auto encrypt_provider::get_total_item_count() const -> std::uint64_t {
                     .count("api_path", "count")
                     .go();
 
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (result.get_row(row) && row.has_value()) {
     return static_cast<std::uint64_t>(
         row->get_column("count").get_value<std::int64_t>());
@@ -647,7 +653,7 @@ auto encrypt_provider::is_directory(const std::string &api_path,
                     .where("api_path")
                     .equals(api_path)
                     .go();
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (not(result.get_row(row) && row.has_value())) {
     exists = false;
     return api_error::success;
@@ -661,14 +667,14 @@ auto encrypt_provider::is_directory(const std::string &api_path,
   return api_error::success;
 }
 
-auto encrypt_provider::is_file(const std::string &api_path,
-                               bool &exists) const -> api_error {
+auto encrypt_provider::is_file(const std::string &api_path, bool &exists) const
+    -> api_error {
   auto result = utils::db::sqlite::db_select{*db_, source_table}
                     .column("source_path")
                     .where("api_path")
                     .equals(api_path)
                     .go();
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (not(result.get_row(row) && row.has_value())) {
     exists = false;
     return api_error::success;
@@ -730,7 +736,7 @@ auto encrypt_provider::process_directory_entry(
                         .where("source_path")
                         .equals(current_source_path)
                         .go();
-      std::optional<utils::db::sqlite::db_select::row> row;
+      std::optional<utils::db::sqlite::db_result::row> row;
       if (result.get_row(row) && row.has_value()) {
         current_api_path = row->get_column("api_path").get_value<std::string>();
       }
@@ -780,7 +786,7 @@ auto encrypt_provider::process_directory_entry(
                       .where("source_path")
                       .equals(dir_entry.get_path())
                       .go();
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       api_path_data = row->get_column("data").get_value<std::string>();
     }
@@ -854,7 +860,7 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path,
                     .where("api_path")
                     .equals(api_path)
                     .go();
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (not(result.get_row(row) && row.has_value())) {
     return api_error::item_not_found;
   }
@@ -958,11 +964,11 @@ void encrypt_provider::remove_deleted_files() {
   };
 
   std::vector<removed_item> removed_list{};
-  std::vector<utils::db::sqlite::db_select::row> row_list{};
+  std::vector<utils::db::sqlite::db_result::row> row_list{};
 
   auto result = utils::db::sqlite::db_select{*db_, source_table}.go();
   while (result.has_row()) {
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       row_list.push_back(row.value());
     }
@@ -1037,7 +1043,7 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
                     .where("api_path")
                     .equals("/")
                     .go();
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (result.get_row(row) && row.has_value()) {
     source_path = row->get_column("source_path").get_value<std::string>();
   } else {
diff --git a/repertory/librepertory/src/providers/meta_db.cpp b/repertory/librepertory/src/providers/meta_db.cpp
index 6da89931..dee7ad2c 100644
--- a/repertory/librepertory/src/providers/meta_db.cpp
+++ b/repertory/librepertory/src/providers/meta_db.cpp
@@ -66,7 +66,7 @@ auto meta_db::get_api_path(const std::string &source_path,
                     .limit(1)
                     .go();
 
-  std::optional<utils::db::sqlite::db_select::row> row;
+  std::optional<utils::db::sqlite::db_result::row> row;
   if (result.get_row(row) && row.has_value()) {
     api_path = row->get_column("api_path").get_value<std::string>();
     return api_error::success;
@@ -81,7 +81,7 @@ auto meta_db::get_api_path_list() -> std::vector<std::string> {
   auto result =
       utils::db::sqlite::db_select{*db_, table_name}.column("api_path").go();
   while (result.has_row()) {
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       ret.push_back(row->get_column("api_path").get_value<std::string>());
     }
@@ -90,8 +90,8 @@ auto meta_db::get_api_path_list() -> std::vector<std::string> {
   return ret;
 }
 
-auto meta_db::get_item_meta(const std::string &api_path,
-                            api_meta_map &meta) -> api_error {
+auto meta_db::get_item_meta(const std::string &api_path, api_meta_map &meta)
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto result = utils::db::sqlite::db_select{*db_, table_name}
@@ -106,7 +106,7 @@ auto meta_db::get_item_meta(const std::string &api_path,
   }
 
   try {
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       meta = json::parse(row->get_column("data").get_value<std::string>())
                  .get<api_meta_map>();
@@ -145,7 +145,7 @@ auto meta_db::get_item_meta(const std::string &api_path, const std::string &key,
   }
 
   try {
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       value =
           key == META_SOURCE
@@ -183,7 +183,7 @@ auto meta_db::get_pinned_files() const -> std::vector<std::string> {
                       .equals(1)
                       .go();
     while (result.has_row()) {
-      std::optional<utils::db::sqlite::db_select::row> row;
+      std::optional<utils::db::sqlite::db_result::row> row;
       if (result.get_row(row) && row.has_value()) {
         ret.emplace_back(row->get_column("api_path").get_value<std::string>());
       }
@@ -205,7 +205,7 @@ auto meta_db::get_total_item_count() const -> std::uint64_t {
                       .count("api_path", "count")
                       .go();
 
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     if (result.get_row(row) && row.has_value()) {
       ret = static_cast<std::uint64_t>(
           row->get_column("count").get_value<std::int64_t>());
@@ -274,8 +274,8 @@ auto meta_db::set_item_meta(const std::string &api_path,
   return update_item_meta(api_path, existing_meta);
 }
 
-auto meta_db::update_item_meta(const std::string &api_path,
-                               api_meta_map meta) -> api_error {
+auto meta_db::update_item_meta(const std::string &api_path, api_meta_map meta)
+    -> api_error {
   REPERTORY_USES_FUNCTION_NAME();
 
   auto directory = utils::string::to_bool(meta[META_DIRECTORY]);
diff --git a/support/include/utils/db/sqlite/db_common.hpp b/support/include/utils/db/sqlite/db_common.hpp
index 8e445f4c..9910453b 100644
--- a/support/include/utils/db/sqlite/db_common.hpp
+++ b/support/include/utils/db/sqlite/db_common.hpp
@@ -66,8 +66,6 @@ struct db_context_t {
 
   sqlite3 *db3{};
   std::string table_name;
-
-  db3_stmt_t stmt;
 };
 
 class db_column final {
@@ -178,9 +176,20 @@ public:
   }
 };
 
-template <typename ctx_t> struct db_result final {
-  db_result(std::shared_ptr<ctx_t> ctx, std::int32_t res)
-      : ctx_(std::move(ctx)), res_(res) {
+struct db_result final {
+  struct context final {
+    db3_stmt_t stmt;
+  };
+
+  using row = db_row<context>;
+
+  db_result(sqlite3_stmt *stmt, std::int32_t res)
+      : ctx_(std::make_shared<context>()), res_(res) {
+    ctx_->stmt = db3_stmt_t{
+        stmt,
+        sqlite3_statement_deleter(),
+    };
+
     if (res == SQLITE_OK) {
       set_res(sqlite3_step(ctx_->stmt.get()));
     }
@@ -193,14 +202,8 @@ template <typename ctx_t> struct db_result final {
   auto operator=(const db_result &) -> db_result & = default;
   auto operator=(db_result &&) -> db_result & = default;
 
-  ~db_result() {
-    if (ctx_) {
-      ctx_->clear();
-    }
-  }
-
 private:
-  std::shared_ptr<ctx_t> ctx_;
+  std::shared_ptr<context> ctx_;
   mutable std::int32_t res_{};
 
 private:
@@ -218,14 +221,14 @@ public:
     return err_msg == nullptr ? std::to_string(res_) : err_msg;
   }
 
-  [[nodiscard]] auto get_row(std::optional<db_row<ctx_t>> &row) const -> bool {
-    row.reset();
+  [[nodiscard]] auto get_row(std::optional<row> &opt_row) const -> bool {
+    opt_row.reset();
 
     if (not has_row()) {
       return false;
     }
 
-    row = db_row{ctx_};
+    opt_row = db_row<context>{ctx_};
     set_res(sqlite3_step(ctx_->stmt.get()));
     return true;
   }
diff --git a/support/include/utils/db/sqlite/db_delete.hpp b/support/include/utils/db/sqlite/db_delete.hpp
index 1cd615a8..a5b50b27 100644
--- a/support/include/utils/db/sqlite/db_delete.hpp
+++ b/support/include/utils/db/sqlite/db_delete.hpp
@@ -36,7 +36,7 @@ public:
 
       [[nodiscard]] auto dump() const -> std::string;
 
-      [[nodiscard]] auto go() const -> db_result<context>;
+      [[nodiscard]] auto go() const -> db_result;
     };
 
     context(sqlite3 *db3_, std::string table_name_)
@@ -64,10 +64,10 @@ private:
 public:
   [[nodiscard]] auto dump() const -> std::string;
 
-  [[nodiscard]] auto go() const -> db_result<context>;
+  [[nodiscard]] auto go() const -> db_result;
 
-  [[nodiscard]] auto
-  group(context::w_t::group_func_t func) -> context::w_t::wn_t;
+  [[nodiscard]] auto group(context::w_t::group_func_t func)
+      -> context::w_t::wn_t;
 
   [[nodiscard]] auto where(std::string column_name) const -> context::w_t::cn_t;
 };
diff --git a/support/include/utils/db/sqlite/db_insert.hpp b/support/include/utils/db/sqlite/db_insert.hpp
index 187ba545..c150e5e1 100644
--- a/support/include/utils/db/sqlite/db_insert.hpp
+++ b/support/include/utils/db/sqlite/db_insert.hpp
@@ -55,12 +55,14 @@ public:
     return *this;
   }
 
-  [[nodiscard]] auto column_value(std::string column_name,
-                                  db_types_t value) -> db_insert &;
+  [[nodiscard]] auto column_value(std::string column_name, db_types_t value)
+
+
+      -> db_insert &;
 
   [[nodiscard]] auto dump() const -> std::string;
 
-  [[nodiscard]] auto go() const -> db_result<context>;
+  [[nodiscard]] auto go() const -> db_result;
 };
 } // namespace repertory::utils::db::sqlite
 
diff --git a/support/include/utils/db/sqlite/db_select.hpp b/support/include/utils/db/sqlite/db_select.hpp
index ffe82622..3778c4a3 100644
--- a/support/include/utils/db/sqlite/db_select.hpp
+++ b/support/include/utils/db/sqlite/db_select.hpp
@@ -36,7 +36,7 @@ public:
 
       [[nodiscard]] auto dump() const -> std::string;
 
-      [[nodiscard]] auto go() const -> db_result<context>;
+      [[nodiscard]] auto go() const -> db_result;
 
       [[nodiscard]] auto group_by(std::string column_name) -> db_select_op_t;
 
@@ -44,8 +44,10 @@ public:
 
       [[nodiscard]] auto offset(std::int32_t value) -> db_select_op_t;
 
-      [[nodiscard]] auto order_by(std::string column_name,
-                                  bool ascending) -> db_select_op_t;
+      [[nodiscard]] auto order_by(std::string column_name, bool ascending)
+
+
+          -> db_select_op_t;
     };
 
     context(sqlite3 *db3_, std::string table_name_)
@@ -67,8 +69,6 @@ public:
     void clear();
   };
 
-  using row = db_row<context>;
-
 public:
   db_select(sqlite3 &db3, std::string table_name)
       : ctx_(std::make_shared<context>(&db3, table_name)) {}
@@ -81,24 +81,30 @@ private:
 public:
   [[nodiscard]] auto column(std::string column_name) -> db_select &;
 
-  [[nodiscard]] auto count(std::string column_name,
-                           std::string as_column_name) -> db_select &;
+  [[nodiscard]] auto count(std::string column_name, std::string as_column_name)
+
+
+      -> db_select &;
 
   [[nodiscard]] auto dump() const -> std::string;
 
-  [[nodiscard]] auto go() const -> db_result<context>;
+  [[nodiscard]] auto go() const -> db_result;
 
   [[nodiscard]] auto group_by(std::string column_name) -> db_select &;
 
-  [[nodiscard]] auto
-  group(context::w_t::group_func_t func) -> context::w_t::wn_t;
+  [[nodiscard]] auto group(context::w_t::group_func_t func)
+
+
+      -> context::w_t::wn_t;
 
   [[nodiscard]] auto limit(std::int32_t value) -> db_select &;
 
   [[nodiscard]] auto offset(std::int32_t value) -> db_select &;
 
-  [[nodiscard]] auto order_by(std::string column_name,
-                              bool ascending) -> db_select &;
+  [[nodiscard]] auto order_by(std::string column_name, bool ascending)
+
+
+      -> db_select &;
 
   [[nodiscard]] auto where(std::string column_name) const -> context::w_t::cn_t;
 };
diff --git a/support/include/utils/db/sqlite/db_update.hpp b/support/include/utils/db/sqlite/db_update.hpp
index b2ce4e54..222dd237 100644
--- a/support/include/utils/db/sqlite/db_update.hpp
+++ b/support/include/utils/db/sqlite/db_update.hpp
@@ -39,12 +39,14 @@ public:
 
       [[nodiscard]] auto dump() const -> std::string;
 
-      [[nodiscard]] auto go() const -> db_result<context>;
+      [[nodiscard]] auto go() const -> db_result;
 
       [[nodiscard]] auto limit(std::int32_t value) -> db_update_op_t;
 
-      [[nodiscard]] auto order_by(std::string column_name,
-                                  bool ascending) -> db_update_op_t;
+      [[nodiscard]] auto order_by(std::string column_name, bool ascending)
+
+
+          -> db_update_op_t;
     };
 
     using w_t = db_where_t<context, db_update_op_t>;
@@ -71,20 +73,26 @@ private:
   std::shared_ptr<context> ctx_;
 
 public:
-  [[nodiscard]] auto column_value(std::string column_name,
-                                  db_types_t value) -> db_update &;
+  [[nodiscard]] auto column_value(std::string column_name, db_types_t value)
+
+
+      -> db_update &;
 
   [[nodiscard]] auto dump() const -> std::string;
 
-  [[nodiscard]] auto go() const -> db_result<context>;
+  [[nodiscard]] auto go() const -> db_result;
 
-  [[nodiscard]] auto
-  group(context::w_t::group_func_t func) -> context::w_t::wn_t;
+  [[nodiscard]] auto group(context::w_t::group_func_t func)
+
+
+      -> context::w_t::wn_t;
 
   [[nodiscard]] auto limit(std::int32_t value) -> db_update &;
 
-  [[nodiscard]] auto order_by(std::string column_name,
-                              bool ascending) -> db_update &;
+  [[nodiscard]] auto order_by(std::string column_name, bool ascending)
+
+
+      -> db_update &;
 
   [[nodiscard]] auto where(std::string column_name) const -> context::w_t::cn_t;
 };
diff --git a/support/src/utils/db/sqlite/db_delete.cpp b/support/src/utils/db/sqlite/db_delete.cpp
index b10d27cd..6d230076 100644
--- a/support/src/utils/db/sqlite/db_delete.cpp
+++ b/support/src/utils/db/sqlite/db_delete.cpp
@@ -30,7 +30,7 @@ auto db_delete::context::db_delete_op_t::dump() const -> std::string {
   return db_delete{ctx}.dump();
 }
 
-auto db_delete::context::db_delete_op_t::go() const -> db_result<context> {
+auto db_delete::context::db_delete_op_t::go() const -> db_result {
   return db_delete{ctx}.go();
 }
 
@@ -48,22 +48,18 @@ auto db_delete::dump() const -> std::string {
   return query.str();
 }
 
-auto db_delete::go() const -> db_result<context> {
+auto db_delete::go() const -> db_result {
   sqlite3_stmt *stmt_ptr{nullptr};
   auto query_str = dump();
   auto res =
       sqlite3_prepare_v2(ctx_->db3, query_str.c_str(), -1, &stmt_ptr, nullptr);
-  ctx_->stmt = db3_stmt_t{
-      stmt_ptr,
-      sqlite3_statement_deleter(),
-  };
 
   if (res != SQLITE_OK) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   if (not ctx_->where_data) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   for (std::int32_t idx = 0;
@@ -71,21 +67,21 @@ auto db_delete::go() const -> db_result<context> {
        idx++) {
     res = std::visit(
         overloaded{
-            [this, &idx](std::int64_t data) -> std::int32_t {
-              return sqlite3_bind_int64(ctx_->stmt.get(), idx + 1, data);
+            [&stmt_ptr, &idx](std::int64_t data) -> std::int32_t {
+              return sqlite3_bind_int64(stmt_ptr, idx + 1, data);
             },
-            [this, &idx](const std::string &data) -> std::int32_t {
-              return sqlite3_bind_text(ctx_->stmt.get(), idx + 1, data.c_str(),
-                                       -1, nullptr);
+            [&stmt_ptr, &idx](const std::string &data) -> std::int32_t {
+              return sqlite3_bind_text(stmt_ptr, idx + 1, data.c_str(), -1,
+                                       nullptr);
             },
         },
         ctx_->where_data->values.at(static_cast<std::size_t>(idx)));
     if (res != SQLITE_OK) {
-      return {ctx_, res};
+      return {stmt_ptr, res};
     }
   }
 
-  return {ctx_, res};
+  return {stmt_ptr, res};
 }
 
 auto db_delete::group(context::w_t::group_func_t func) -> context::w_t::wn_t {
diff --git a/support/src/utils/db/sqlite/db_insert.cpp b/support/src/utils/db/sqlite/db_insert.cpp
index 1c9778b3..0b497b20 100644
--- a/support/src/utils/db/sqlite/db_insert.cpp
+++ b/support/src/utils/db/sqlite/db_insert.cpp
@@ -26,8 +26,8 @@
 namespace repertory::utils::db::sqlite {
 void db_insert::context::clear() { 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;
 }
@@ -61,18 +61,14 @@ auto db_insert::dump() const -> std::string {
   return query.str();
 }
 
-auto db_insert::go() const -> db_result<context> {
+auto db_insert::go() const -> db_result {
   sqlite3_stmt *stmt_ptr{nullptr};
   auto query_str = dump();
   auto res =
       sqlite3_prepare_v2(ctx_->db3, query_str.c_str(), -1, &stmt_ptr, nullptr);
-  ctx_->stmt = db3_stmt_t{
-      stmt_ptr,
-      sqlite3_statement_deleter(),
-  };
 
   if (res != SQLITE_OK) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   for (std::int32_t idx = 0;
@@ -89,11 +85,11 @@ auto db_insert::go() const -> db_result<context> {
                      },
                      std::next(ctx_->values.begin(), idx)->second);
     if (res != SQLITE_OK) {
-      return {ctx_, res};
+      return {stmt_ptr, res};
     }
   }
 
-  return {ctx_, res};
+  return {stmt_ptr, res};
 }
 } // namespace repertory::utils::db::sqlite
 
diff --git a/support/src/utils/db/sqlite/db_select.cpp b/support/src/utils/db/sqlite/db_select.cpp
index 1ffa4da8..b4c5dd39 100644
--- a/support/src/utils/db/sqlite/db_select.cpp
+++ b/support/src/utils/db/sqlite/db_select.cpp
@@ -38,7 +38,7 @@ auto db_select::context::db_select_op_t::dump() const -> std::string {
   return db_select{ctx}.dump();
 }
 
-auto db_select::context::db_select_op_t::go() const -> db_result<context> {
+auto db_select::context::db_select_op_t::go() const -> db_result {
   return db_select{ctx}.go();
 }
 
@@ -72,8 +72,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;
 }
@@ -142,22 +142,18 @@ auto db_select::dump() const -> std::string {
   return query.str();
 }
 
-auto db_select::go() const -> db_result<context> {
+auto db_select::go() const -> db_result {
   sqlite3_stmt *stmt_ptr{nullptr};
   auto query_str = dump();
   auto res =
       sqlite3_prepare_v2(ctx_->db3, query_str.c_str(), -1, &stmt_ptr, nullptr);
-  ctx_->stmt = db3_stmt_t{
-      stmt_ptr,
-      sqlite3_statement_deleter(),
-  };
 
   if (res != SQLITE_OK) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   if (not ctx_->where_data) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   for (std::int32_t idx = 0;
@@ -175,11 +171,11 @@ auto db_select::go() const -> db_result<context> {
         },
         ctx_->where_data->values.at(static_cast<std::size_t>(idx)));
     if (res != SQLITE_OK) {
-      return {ctx_, res};
+      return {stmt_ptr, res};
     }
   }
 
-  return {ctx_, res};
+  return {stmt_ptr, res};
 }
 
 auto db_select::group(context::w_t::group_func_t func) -> context::w_t::wn_t {
@@ -209,8 +205,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;
 }
diff --git a/support/src/utils/db/sqlite/db_update.cpp b/support/src/utils/db/sqlite/db_update.cpp
index 31efe5ba..a68a8715 100644
--- a/support/src/utils/db/sqlite/db_update.cpp
+++ b/support/src/utils/db/sqlite/db_update.cpp
@@ -35,7 +35,7 @@ auto db_update::context::db_update_op_t::dump() const -> std::string {
   return db_update{ctx}.dump();
 }
 
-auto db_update::context::db_update_op_t::go() const -> db_result<context> {
+auto db_update::context::db_update_op_t::go() const -> db_result {
   return db_update{ctx}.go();
 }
 
@@ -52,8 +52,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;
 }
@@ -91,18 +91,15 @@ auto db_update::dump() const -> std::string {
   return query.str();
 }
 
-auto db_update::go() const -> db_result<context> {
+auto db_update::go() const -> db_result {
   sqlite3_stmt *stmt_ptr{nullptr};
+
   auto query_str = dump();
   auto res =
       sqlite3_prepare_v2(ctx_->db3, query_str.c_str(), -1, &stmt_ptr, nullptr);
-  ctx_->stmt = db3_stmt_t{
-      stmt_ptr,
-      sqlite3_statement_deleter(),
-  };
 
   if (res != SQLITE_OK) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   for (std::int32_t idx = 0;
@@ -119,12 +116,12 @@ auto db_update::go() const -> db_result<context> {
                      },
                      std::next(ctx_->column_values.begin(), idx)->second);
     if (res != SQLITE_OK) {
-      return {ctx_, res};
+      return {stmt_ptr, res};
     }
   }
 
   if (not ctx_->where_data) {
-    return {ctx_, res};
+    return {stmt_ptr, res};
   }
 
   for (std::int32_t idx = 0;
@@ -149,11 +146,11 @@ auto db_update::go() const -> db_result<context> {
         },
         ctx_->where_data->values.at(static_cast<std::size_t>(idx)));
     if (res != SQLITE_OK) {
-      return {ctx_, res};
+      return {stmt_ptr, res};
     }
   }
 
-  return {ctx_, res};
+  return {stmt_ptr, res};
 }
 
 auto db_update::group(context::w_t::group_func_t func) -> context::w_t::wn_t {
@@ -173,8 +170,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;
 }
diff --git a/support/test/src/utils/db_sqlite_test.cpp b/support/test/src/utils/db_sqlite_test.cpp
index 9575ca28..d5f964ad 100644
--- a/support/test/src/utils/db_sqlite_test.cpp
+++ b/support/test/src/utils/db_sqlite_test.cpp
@@ -89,7 +89,7 @@ static void common_select(sqlite3 &db3, std::string value1, std::string value2,
 
   std::size_t row_count{};
   while (res.has_row()) {
-    std::optional<utils::db::sqlite::db_select::row> row;
+    std::optional<utils::db::sqlite::db_result::row> row;
     EXPECT_TRUE(res.get_row(row));
     EXPECT_TRUE(row.has_value());
     if (row.has_value()) {