refactor

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;
   }

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;
 };

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
 

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;
 };

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;
 };

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 {

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
 

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;
 }

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;
 }

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()) {