[Unit Test] SQLite mini-ORM unit tests and cleanup #14

repertory/librepertory/include/database/db_column.hpp

@@ -0,0 +1,314 @@
+/*
+  Copyright <2018-2024> <scott.e.graves@protonmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef INCLUDE_DATABASE_DB_COMMON_HPP_
+#define INCLUDE_DATABASE_DB_COMMON_HPP_
+
+#include "utils/error_utils.hpp"
+
+namespace repertory::db {
+using db_types_t = std::variant<std::int64_t, std::string>;
+
+struct sqlite3_deleter {
+  void operator()(sqlite3 *db3) {
+    if (db3 != nullptr) {
+      sqlite3_close_v2(db3);
+    }
+  }
+};
+
+using db3_t = std::unique_ptr<sqlite3, sqlite3_deleter>;
+
+struct sqlite3_statement_deleter {
+  void operator()(sqlite3_stmt *stmt) {
+    if (stmt != nullptr) {
+      sqlite3_finalize(stmt);
+    }
+  }
+};
+
+using db3_stmt_t = std::unique_ptr<sqlite3_stmt, sqlite3_statement_deleter>;
+
+struct comp_data_t final {
+  std::string column_name;
+  std::string op_type;
+  db_types_t value;
+};
+
+class db_column final {
+public:
+  db_column() noexcept = default;
+  db_column(const db_column &) = default;
+  db_column(db_column &&column) noexcept = default;
+  ~db_column() = default;
+
+  auto operator=(const db_column &) -> db_column & = default;
+  auto operator=(db_column &&) -> db_column & = default;
+
+  db_column(std::int32_t index, std::string name, db_types_t value) noexcept
+      : index_(index), name_(std::move(name)), value_(std::move(value)) {}
+
+private:
+  std::int32_t index_{};
+  std::string name_;
+  db_types_t value_;
+
+public:
+  [[nodiscard]] auto get_index() const -> std::int32_t { return index_; }
+
+  [[nodiscard]] auto get_name() const -> std::string { return name_; }
+
+  template <typename data_type>
+  [[nodiscard]] auto get_value() const -> data_type {
+    return std::visit(
+        overloaded{
+            [](const data_type &value) -> data_type { return value; },
+            [](auto &&) -> data_type {
+              throw std::runtime_error("data type not supported");
+            },
+        },
+        value_);
+  }
+
+  [[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_);
+  }
+};
+
+template <typename context_t> class db_row final {
+public:
+  db_row(std::shared_ptr<context_t> context) {
+    auto column_count = sqlite3_column_count(context->stmt.get());
+    for (std::int32_t col = 0; col < column_count; col++) {
+      std::string name{sqlite3_column_name(context->stmt.get(), col)};
+      auto column_type = sqlite3_column_type(context->stmt.get(), col);
+
+      db_types_t value;
+      switch (column_type) {
+      case SQLITE_INTEGER: {
+        value = sqlite3_column_int64(context->stmt.get(), col);
+      } break;
+
+      case SQLITE_TEXT: {
+        const auto *text = reinterpret_cast<const char *>(
+            sqlite3_column_text(context->stmt.get(), col));
+        value = std::string(text == nullptr ? "" : text);
+      } break;
+
+      default:
+        throw std::runtime_error("column type not implemented|" + name + '|' +
+                                 std::to_string(column_type));
+      }
+
+      columns_[name] = db_column{col, name, value};
+    }
+  }
+
+private:
+  std::map<std::string, db_column> columns_;
+
+public:
+  [[nodiscard]] auto get_columns() const -> std::vector<db_column> {
+    std::vector<db_column> ret;
+    for (const auto &item : columns_) {
+      ret.push_back(item.second);
+    }
+    return ret;
+  }
+
+  [[nodiscard]] auto get_column(std::int32_t index) const -> db_column {
+    auto iter = std::find_if(columns_.begin(), columns_.end(),
+                             [&index](auto &&col) -> bool {
+                               return col.second.get_index() == index;
+                             });
+    if (iter == columns_.end()) {
+      throw std::out_of_range("");
+    }
+
+    return iter->second;
+  }
+
+  [[nodiscard]] auto get_column(std::string name) const -> db_column {
+    return columns_.at(name);
+  }
+};
+
+template <typename context_t> struct db_result final {
+  db_result(std::shared_ptr<context_t> context, std::int32_t res)
+      : context_(std::move(context)), res_(res) {
+    constexpr const auto *function_name =
+        static_cast<const char *>(__FUNCTION__);
+
+    if (res == SQLITE_OK) {
+      set_res(sqlite3_step(context_->stmt.get()), function_name);
+    }
+  }
+
+private:
+  std::shared_ptr<context_t> context_;
+  mutable std::int32_t res_;
+
+private:
+  void set_res(std::int32_t res, std::string_view function) const {
+    if (res != SQLITE_OK && res != SQLITE_DONE && res != SQLITE_ROW) {
+      utils::error::raise_error(function, "failed to step|" +
+                                              std::to_string(res) + '|' +
+                                              sqlite3_errstr(res));
+    }
+    res_ = res;
+  }
+
+public:
+  [[nodiscard]] auto ok() const -> bool {
+    return res_ == SQLITE_DONE || res_ == SQLITE_ROW;
+  }
+
+  [[nodiscard]] auto get_error() const -> std::int32_t { return res_; }
+
+  [[nodiscard]] auto get_error_str() const -> std::string {
+    return sqlite3_errstr(res_);
+  }
+
+  [[nodiscard]] auto
+  get_row(std::optional<db_row<context_t>> &row) const -> bool {
+    constexpr const auto *function_name =
+        static_cast<const char *>(__FUNCTION__);
+
+    row.reset();
+    if (has_row()) {
+      row = db_row{context_};
+      set_res(sqlite3_step(context_->stmt.get()), function_name);
+      return true;
+    }
+    return false;
+  }
+
+  [[nodiscard]] auto has_row() const -> bool { return res_ == SQLITE_ROW; }
+
+  void next_row() const {
+    constexpr const auto *function_name =
+        static_cast<const char *>(__FUNCTION__);
+
+    if (has_row()) {
+      set_res(sqlite3_step(context_->stmt.get()), function_name);
+    }
+  }
+};
+
+inline void set_journal_mode(sqlite3 &db3) {
+  sqlite3_exec(&db3, "PRAGMA journal_mode = WAL;PRAGMA synchronous = NORMAL;",
+               nullptr, nullptr, nullptr);
+}
+
+[[nodiscard]] inline 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) {
+    err = err_msg;
+    sqlite3_free(err_msg);
+    err_msg = nullptr;
+  }
+  if (res != SQLITE_OK) {
+    err = "failed to execute sql|" + sql + "|" + std::to_string(res) + '|' +
+          (err.empty() ? sqlite3_errstr(res) : err);
+    return false;
+  }
+
+  return true;
+}
+
+template <typename context_t, typename next_t> struct db_where_t final {
+  db_where_t(std::shared_ptr<context_t> ctx, std::string column_name)
+      : context_(std::move(ctx)), column_name_(std::move(column_name)) {}
+
+private:
+  std::shared_ptr<context_t> context_;
+  std::string column_name_;
+
+public:
+  [[nodiscard]] auto equals(db_types_t value) const -> next_t {
+    context_->ands.emplace_back(comp_data_t{column_name_, "=", value});
+    return next_t{context_};
+  }
+};
+
+template <typename context_t, typename operation_t>
+struct db_where_next_t final {
+  db_where_next_t(std::shared_ptr<context_t> ctx) : context_(std::move(ctx)) {}
+
+private:
+  std::shared_ptr<context_t> context_;
+
+public:
+  [[nodiscard]] auto
+  and_where(std::string column_name) const -> db_where_t<db_where_next_t> {
+    return db_where_t<db_where_next_t>{context_, column_name};
+  }
+
+  [[nodiscard]] auto dump() const -> std::string {
+    return operation_t{context_}.dump();
+  }
+
+  [[nodiscard]] auto go() const -> db_result<context_t> {
+    return operation_t{context_}.go();
+  }
+};
+
+template <typename operation_t> struct db_where_with_limit_next_t final {
+  db_where_next(std::shared_ptr<context_t> ctx) : context_(std::move(ctx)) {}
+
+private:
+  std::shared_ptr<context_t> context_;
+
+public:
+  [[nodiscard]] auto and_where(std::string column_name) const
+      -> db_where_t<db_where_with_limit_next_t> {
+    return db_where_t<db_where_with_limit_next_t>{context_, column_name};
+  }
+
+  [[nodiscard]] auto dump() const -> std::string {
+    return operation_t{context_}.dump();
+  }
+
+  [[nodiscard]] auto go() const -> db_result<context_t> {
+    return operation_t{context_}.go();
+  }
+
+  [[nodiscard]] auto limit(std::int32_t value) const -> operation_t {
+    return operation_t{context_}.limit(value);
+  }
+
+  [[nodiscard]] auto order_by(std::string column_name,
+                              bool ascending) const -> operation_t {
+    return operation_t{context_}.order_by(column_name, ascending);
+  }
+};
+} // namespace repertory::db
+
+#endif // INCLUDE_DATABASE_DB_COMMON_HPP_

repertory/librepertory/include/database/db_common.hpp

@@ -47,6 +47,11 @@ struct sqlite3_statement_deleter {
 
 using db3_stmt_t = std::unique_ptr<sqlite3_stmt, sqlite3_statement_deleter>;
 
+[[nodiscard]] auto execute_sql(sqlite3 &db3, const std::string &sql,
+                               std::string &err) -> bool;
+
+void set_journal_mode(sqlite3 &db3);
+
 struct comp_data_t final {
   std::string column_name;
   std::string op_type;
@@ -220,28 +225,75 @@ public:
   }
 };
 
-inline void set_journal_mode(sqlite3 &db3) {
-  sqlite3_exec(&db3, "PRAGMA journal_mode = WAL;PRAGMA synchronous = NORMAL;",
-               nullptr, nullptr, nullptr);
-}
+template <typename context_t, typename next_t> struct db_where_t final {
+  db_where_t(std::shared_ptr<context_t> ctx, std::string column_name)
+      : context_(std::move(ctx)), column_name_(std::move(column_name)) {}
 
-[[nodiscard]] inline 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) {
-    err = err_msg;
-    sqlite3_free(err_msg);
-    err_msg = nullptr;
+private:
+  std::shared_ptr<context_t> context_;
+  std::string column_name_;
+
+public:
+  [[nodiscard]] auto equals(db_types_t value) const -> next_t {
+    context_->ands.emplace_back(comp_data_t{column_name_, "=", value});
+    return next_t{context_};
   }
-  if (res != SQLITE_OK) {
-    err = "failed to execute sql|" + sql + "|" + std::to_string(res) + '|' +
-          (err.empty() ? sqlite3_errstr(res) : err);
-    return false;
+};
+
+template <typename context_t, typename operation_t>
+struct db_where_next_t final {
+  db_where_next_t(std::shared_ptr<context_t> ctx) : context_(std::move(ctx)) {}
+
+private:
+  std::shared_ptr<context_t> context_;
+
+public:
+  [[nodiscard]] auto and_where(std::string column_name) const
+      -> db_where_t<context_t, db_where_next_t> {
+    return db_where_t<context_t, db_where_next_t>{context_, column_name};
   }
 
-  return true;
-}
+  [[nodiscard]] auto dump() const -> std::string {
+    return operation_t{context_}.dump();
+  }
+
+  [[nodiscard]] auto go() const -> db_result<context_t> {
+    return operation_t{context_}.go();
+  }
+};
+
+template <typename context_t, typename operation_t>
+struct db_where_with_limit_next_t final {
+  db_where_with_limit_next_t(std::shared_ptr<context_t> ctx)
+      : context_(std::move(ctx)) {}
+
+private:
+  std::shared_ptr<context_t> context_;
+
+public:
+  [[nodiscard]] auto and_where(std::string column_name) const
+      -> db_where_t<context_t, db_where_with_limit_next_t> {
+    return db_where_t<context_t, db_where_with_limit_next_t>{context_,
+                                                             column_name};
+  }
+
+  [[nodiscard]] auto dump() const -> std::string {
+    return operation_t{context_}.dump();
+  }
+
+  [[nodiscard]] auto go() const -> db_result<context_t> {
+    return operation_t{context_}.go();
+  }
+
+  [[nodiscard]] auto limit(std::int32_t value) const -> operation_t {
+    return operation_t{context_}.limit(value);
+  }
+
+  [[nodiscard]] auto order_by(std::string column_name,
+                              bool ascending) const -> operation_t {
+    return operation_t{context_}.order_by(column_name, ascending);
+  }
+};
 } // namespace repertory::db
 
 #endif // INCLUDE_DATABASE_DB_COMMON_HPP_

repertory/librepertory/include/database/db_delete.hpp

@@ -0,0 +1,63 @@
+/*
+  Copyright <2018-2024> <scott.e.graves@protonmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#ifndef INCLUDE_DATABASE_DB_DELETE_HPP_
+#define INCLUDE_DATABASE_DB_DELETE_HPP_
+
+#include "database/db_common.hpp"
+#include "utils/error_utils.hpp"
+
+namespace repertory::db {
+class db_delete final {
+public:
+  struct context final {
+    context(sqlite3 &db3_, std::string table_name_)
+        : db3(db3_), table_name(std::move(table_name_)) {}
+
+    sqlite3 &db3;
+    std::string table_name;
+
+    std::vector<comp_data_t> ands{};
+    db3_stmt_t stmt{nullptr};
+  };
+
+  using row = db_row<context>;
+
+public:
+  db_delete(sqlite3 &db3, std::string table_name)
+      : context_(std::make_shared<context>(db3, table_name)) {}
+
+  db_delete(std::shared_ptr<context> ctx) : context_(std::move(ctx)) {}
+
+private:
+  std::shared_ptr<context> context_;
+
+public:
+  [[nodiscard]] auto dump() const -> std::string;
+
+  [[nodiscard]] auto go() const -> db_result<context>;
+
+  [[nodiscard]] auto where(std::string column_name) const
+      -> db_where_t<context, db_where_next_t<context, db_delete>>;
+};
+} // namespace repertory::db
+
+#endif // INCLUDE_DATABASE_DB_DELETE_HPP_

repertory/librepertory/include/database/db_select.hpp

@@ -23,6 +23,7 @@
 #define INCLUDE_DATABASE_DB_SELECT_HPP_
 
 #include "database/db_common.hpp"
+#include "db_common.hpp"
 #include "utils/error_utils.hpp"
 
 namespace repertory::db {
@@ -38,7 +39,6 @@ public:
     std::vector<comp_data_t> ands{};
     std::vector<std::string> columns{};
     std::map<std::string, std::string> count_columns{};
-    bool delete_query{false};
     std::optional<std::int32_t> limit;
     std::optional<std::pair<std::string, bool>> order_by;
     db3_stmt_t stmt{nullptr};
@@ -52,62 +52,14 @@ public:
 
   db_select(std::shared_ptr<context> ctx) : context_(std::move(ctx)) {}
 
-public:
-  struct db_where final {
-    db_where(std::shared_ptr<context> ctx, std::string column_name)
-        : context_(std::move(ctx)), column_name_(std::move(column_name)) {}
-
-  public:
-    struct db_where_next final {
-      db_where_next(std::shared_ptr<context> ctx) : context_(std::move(ctx)) {}
-
-    private:
-      std::shared_ptr<context> context_;
-
-    public:
-      [[nodiscard]] auto and_where(std::string column_name) const -> db_where {
-        return db_where{context_, column_name};
-      }
-
-      [[nodiscard]] auto dump() const -> std::string {
-        return db_select{context_}.dump();
-      }
-
-      [[nodiscard]] auto go() const -> db_result<context> {
-        return db_select{context_}.go();
-      }
-
-      [[nodiscard]] auto limit(std::int32_t value) const -> db_select {
-        return db_select{context_}.limit(value);
-      }
-
-      [[nodiscard]] auto order_by(std::string column_name, bool ascending) const
-          -> db_select {
-        return db_select{context_}.order_by(column_name, ascending);
-      }
-    };
-
-  private:
-    std::shared_ptr<context> context_;
-    std::string column_name_;
-
-  public:
-    [[nodiscard]] auto equals(db_types_t value) const -> db_where_next {
-      context_->ands.emplace_back(comp_data_t{column_name_, "=", value});
-      return db_where_next{context_};
-    }
-  };
-
 private:
   std::shared_ptr<context> context_;
 
 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 delete_query() -> db_select &;
+  [[nodiscard]] auto count(std::string column_name,
+                           std::string as_column_name) -> db_select &;
 
   [[nodiscard]] auto dump() const -> std::string;
 
@@ -115,10 +67,11 @@ public:
 
   [[nodiscard]] auto limit(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 -> db_where;
+  [[nodiscard]] auto where(std::string column_name) const
+      -> db_where_t<context, db_where_with_limit_next_t<context, db_select>>;
 };
 } // namespace repertory::db
 

repertory/librepertory/include/database/db_update.hpp

@@ -36,48 +36,13 @@ public:
 
     std::vector<comp_data_t> ands{};
     std::map<std::string, db_types_t> values{};
+    std::optional<std::int32_t> limit;
+    std::optional<std::pair<std::string, bool>> order_by;
     db3_stmt_t stmt{nullptr};
   };
 
   using row = db_row<context>;
 
-public:
-  struct db_where final {
-    db_where(std::shared_ptr<context> ctx, std::string column_name)
-        : context_(std::move(ctx)), column_name_(std::move(column_name)) {}
-
-  public:
-    struct db_where_next final {
-      db_where_next(std::shared_ptr<context> ctx) : context_(std::move(ctx)) {}
-
-    private:
-      std::shared_ptr<context> context_;
-
-    public:
-      [[nodiscard]] auto and_where(std::string column_name) const -> db_where {
-        return db_where{context_, column_name};
-      }
-
-      [[nodiscard]] auto dump() const -> std::string {
-        return db_update{context_}.dump();
-      }
-
-      [[nodiscard]] auto go() const -> db_result<context> {
-        return db_update{context_}.go();
-      }
-    };
-
-  private:
-    std::shared_ptr<context> context_;
-    std::string column_name_;
-
-  public:
-    [[nodiscard]] auto equals(db_types_t value) const -> db_where_next {
-      context_->ands.emplace_back(comp_data_t{column_name_, "=", value});
-      return db_where_next{context_};
-    }
-  };
-
 public:
   db_update(sqlite3 &db3, std::string table_name)
       : context_(std::make_shared<context>(db3, table_name)) {}
@@ -95,7 +60,13 @@ public:
 
   [[nodiscard]] auto go() const -> db_result<context>;
 
-  [[nodiscard]] auto where(std::string column_name) const -> db_where;
+  [[nodiscard]] auto limit(std::int32_t value) -> db_update &;
+
+  [[nodiscard]] auto order_by(std::string column_name,
+                              bool ascending) -> db_update &;
+
+  [[nodiscard]] auto where(std::string column_name) const
+      -> db_where_t<context, db_where_with_limit_next_t<context, db_update>>;
 };
 } // namespace repertory::db
 

repertory/librepertory/src/database/db_common.cpp

@@ -0,0 +1,48 @@
+/*
+  Copyright <2018-2024> <scott.e.graves@protonmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "database/db_common.hpp"
+
+namespace repertory::db {
+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) {
+    err = err_msg;
+    sqlite3_free(err_msg);
+    err_msg = nullptr;
+  }
+
+  if (res == SQLITE_OK) {
+    return true;
+  }
+
+  err = "failed to execute sql|" + sql + "|" + std::to_string(res) + '|' +
+        (err.empty() ? sqlite3_errstr(res) : err);
+  return false;
+}
+
+void set_journal_mode(sqlite3 &db3) {
+  sqlite3_exec(&db3, "PRAGMA journal_mode = WAL;PRAGMA synchronous = NORMAL;",
+               nullptr, nullptr, nullptr);
+}
+} // namespace repertory::db

repertory/librepertory/src/database/db_delete.cpp

@@ -0,0 +1,95 @@
+/*
+  Copyright <2018-2024> <scott.e.graves@protonmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+#include "database/db_delete.hpp"
+
+namespace repertory::db {
+auto db_delete::dump() const -> std::string {
+  std::stringstream query;
+  query << "DELETE FROM \"" << context_->table_name << "\"";
+
+  if (not context_->ands.empty()) {
+    query << " WHERE (";
+    for (std::int32_t idx = 0;
+         idx < static_cast<std::int32_t>(context_->ands.size()); idx++) {
+      if (idx > 0) {
+        query << " AND ";
+      }
+
+      auto &item = context_->ands.at(static_cast<std::size_t>(idx));
+      query << '"' << item.column_name << '"' << item.op_type << "?"
+            << (idx + 1);
+    }
+    query << ")";
+  }
+
+  query << ';';
+
+  return query.str();
+}
+
+auto db_delete::go() const -> db_result<context> {
+  static constexpr const std::string_view function_name{
+      static_cast<const char *>(__FUNCTION__),
+  };
+
+  sqlite3_stmt *stmt_ptr{nullptr};
+  auto query_str = dump();
+  auto res = sqlite3_prepare_v2(&context_->db3, query_str.c_str(), -1,
+                                &stmt_ptr, nullptr);
+  if (res != SQLITE_OK) {
+    utils::error::raise_error(function_name,
+                              "failed to prepare|" + std::to_string(res) + '|' +
+                                  sqlite3_errstr(res) + '|' + query_str);
+    return {context_, res};
+  }
+  context_->stmt.reset(stmt_ptr);
+
+  for (std::int32_t idx = 0;
+       idx < static_cast<std::int32_t>(context_->ands.size()); idx++) {
+    res = std::visit(
+        overloaded{
+            [this, &idx](std::int64_t data) -> std::int32_t {
+              return sqlite3_bind_int64(context_->stmt.get(), idx + 1, data);
+            },
+            [this, &idx](const std::string &data) -> std::int32_t {
+              return sqlite3_bind_text(context_->stmt.get(), idx + 1,
+                                       data.c_str(), -1, nullptr);
+            },
+        },
+        context_->ands.at(static_cast<std::size_t>(idx)).value);
+    if (res != SQLITE_OK) {
+      utils::error::raise_error(function_name,
+                                "failed to bind|" + std::to_string(res) + '|' +
+                                    sqlite3_errstr(res) + '|' + query_str);
+      return {context_, res};
+    }
+  }
+
+  return {context_, res};
+}
+
+auto db_delete::where(std::string column_name) const
+    -> db_where_t<context, db_where_next_t<context, db_delete>> {
+  return db_where_t<context, db_where_next_t<context, db_delete>>{context_,
+                                                                  column_name};
+}
+} // namespace repertory::db

repertory/librepertory/src/database/db_select.cpp

@@ -22,12 +22,7 @@
 #include "database/db_select.hpp"
 
 namespace repertory::db {
-
 auto db_select::column(std::string column_name) -> db_select & {
-  if (context_->delete_query) {
-    throw std::runtime_error("columns may not be specified for delete");
-  }
-
   context_->columns.push_back(column_name);
   return *this;
 }
@@ -38,46 +33,34 @@ auto db_select::count(std::string column_name,
   return *this;
 }
 
-auto db_select::delete_query() -> db_select & {
-  if (not context_->columns.empty()) {
-    throw std::runtime_error("columns must be empty for delete");
-  }
-
-  context_->delete_query = true;
-  return *this;
-}
-
 auto db_select::dump() const -> std::string {
   std::stringstream query;
-  query << (context_->delete_query ? "DELETE " : "SELECT ");
-  if (not context_->delete_query) {
-    bool has_column{false};
-    if (context_->columns.empty()) {
-      if (context_->count_columns.empty()) {
-        query << "*";
-        has_column = true;
-      }
-    } else {
-      has_column = not context_->columns.empty();
-      for (std::size_t idx = 0U; idx < context_->columns.size(); idx++) {
-        if (idx > 0U) {
-          query << ", ";
-        }
-        query << context_->columns.at(idx);
-      }
+  query << "SELECT ";
+  bool has_column{false};
+  if (context_->columns.empty()) {
+    if (context_->count_columns.empty()) {
+      query << "*";
+      has_column = true;
     }
-
-    for (std::int32_t idx = 0U;
-         idx < static_cast<std::int32_t>(context_->count_columns.size());
-         idx++) {
-      if (has_column || idx > 0) {
+  } else {
+    has_column = not context_->columns.empty();
+    for (std::size_t idx = 0U; idx < context_->columns.size(); idx++) {
+      if (idx > 0U) {
         query << ", ";
       }
-      query << "COUNT(\"";
-      auto &count_column = *std::next(context_->count_columns.begin(), idx);
-      query << count_column.first << "\") AS \"" << count_column.second << '"';
+      query << context_->columns.at(idx);
     }
   }
+
+  for (std::int32_t idx = 0U;
+       idx < static_cast<std::int32_t>(context_->count_columns.size()); idx++) {
+    if (has_column || idx > 0) {
+      query << ", ";
+    }
+    query << "COUNT(\"";
+    auto &count_column = *std::next(context_->count_columns.begin(), idx);
+    query << count_column.first << "\") AS \"" << count_column.second << '"';
+  }
   query << " FROM \"" << context_->table_name << "\"";
 
   if (not context_->ands.empty()) {
@@ -95,15 +78,13 @@ auto db_select::dump() const -> std::string {
     query << ")";
   }
 
-  if (not context_->delete_query) {
-    if (context_->order_by.has_value()) {
-      query << " ORDER BY \"" << context_->order_by.value().first << "\" ";
-      query << (context_->order_by.value().second ? "ASC" : "DESC");
-    }
+  if (context_->order_by.has_value()) {
+    query << " ORDER BY \"" << context_->order_by.value().first << "\" ";
+    query << (context_->order_by.value().second ? "ASC" : "DESC");
+  }
 
-    if (context_->limit.has_value()) {
-      query << " LIMIT " << context_->limit.value();
-    }
+  if (context_->limit.has_value()) {
+    query << " LIMIT " << context_->limit.value();
   }
 
   query << ';';
@@ -153,25 +134,19 @@ auto db_select::go() const -> db_result<context> {
 }
 
 auto db_select::limit(std::int32_t value) -> db_select & {
-  if (context_->delete_query) {
-    throw std::runtime_error("limit may not be specified for delete");
-  }
-
   context_->limit = value;
   return *this;
 }
 
 auto db_select::order_by(std::string column_name,
                          bool ascending) -> db_select & {
-  if (context_->delete_query) {
-    throw std::runtime_error("order_by may not be specified for delete");
-  }
-
   context_->order_by = {column_name, ascending};
   return *this;
 }
 
-auto db_select::where(std::string column_name) const -> db_where {
-  return db_where{context_, column_name};
+auto db_select::where(std::string column_name) const
+    -> db_where_t<context, db_where_with_limit_next_t<context, db_select>> {
+  return db_where_t<context, db_where_with_limit_next_t<context, db_select>>{
+      context_, column_name};
 }
 } // namespace repertory::db

repertory/librepertory/src/database/db_update.cpp

@@ -39,7 +39,7 @@ auto db_update::dump() const -> std::string {
     }
 
     auto column = std::next(context_->values.begin(), idx);
-    query << column->first << " = ?";
+    query << '"' << column->first << "\"=?" + std::to_string(idx + 1);
   }
 
   if (not context_->ands.empty()) {
@@ -52,11 +52,20 @@ auto db_update::dump() const -> std::string {
 
       auto &item = context_->ands.at(static_cast<std::size_t>(idx));
       query << '"' << item.column_name << '"' << item.op_type << "?"
-            << (idx + 1);
+            << (idx + static_cast<std::int32_t>(context_->values.size()) + 1);
     }
     query << ")";
   }
 
+  if (context_->order_by.has_value()) {
+    query << " ORDER BY \"" << context_->order_by.value().first << "\" ";
+    query << (context_->order_by.value().second ? "ASC" : "DESC");
+  }
+
+  if (context_->limit.has_value()) {
+    query << " LIMIT " << context_->limit.value();
+  }
+
   query << ';';
 
   return query.str();
@@ -105,11 +114,16 @@ auto db_update::go() const -> db_result<context> {
     res = std::visit(
         overloaded{
             [this, &idx](std::int64_t data) -> std::int32_t {
-              return sqlite3_bind_int64(context_->stmt.get(), idx + 1, data);
+              return sqlite3_bind_int64(
+                  context_->stmt.get(),
+                  idx + static_cast<std::int32_t>(context_->values.size()) + 1,
+                  data);
             },
             [this, &idx](const std::string &data) -> std::int32_t {
-              return sqlite3_bind_text(context_->stmt.get(), idx + 1,
-                                       data.c_str(), -1, nullptr);
+              return sqlite3_bind_text(
+                  context_->stmt.get(),
+                  idx + static_cast<std::int32_t>(context_->values.size()) + 1,
+                  data.c_str(), -1, nullptr);
             },
         },
         context_->ands.at(static_cast<std::size_t>(idx)).value);
@@ -124,7 +138,20 @@ auto db_update::go() const -> db_result<context> {
   return {context_, res};
 }
 
-auto db_update::where(std::string column_name) const -> db_where {
-  return db_where{context_, column_name};
+auto db_update::limit(std::int32_t value) -> db_update & {
+  context_->limit = value;
+  return *this;
+}
+
+auto db_update::order_by(std::string column_name,
+                         bool ascending) -> db_update & {
+  context_->order_by = {column_name, ascending};
+  return *this;
+}
+
+auto db_update::where(std::string column_name) const
+    -> db_where_t<context, db_where_with_limit_next_t<context, db_update>> {
+  return db_where_t<context, db_where_with_limit_next_t<context, db_update>>{
+      context_, column_name};
 }
 } // namespace repertory::db

repertory/librepertory/src/file_manager/file_manager.cpp

@@ -23,6 +23,7 @@
 
 #include "app_config.hpp"
 #include "database/db_common.hpp"
+#include "database/db_delete.hpp"
 #include "database/db_insert.hpp"
 #include "database/db_select.hpp"
 #include "database/db_update.hpp"
@@ -565,8 +566,7 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
 
   remove_upload(api_path);
 
-  auto result = db::db_select{*db_.get(), resume_table}
-                    .delete_query()
+  auto result = db::db_delete{*db_.get(), resume_table}
                     .where("api_path")
                     .equals(api_path)
                     .go();
@@ -587,8 +587,7 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
 
 void file_manager::remove_resume(const std::string &api_path,
                                  const std::string &source_path) {
-  auto result = db::db_select{*db_.get(), resume_table}
-                    .delete_query()
+  auto result = db::db_delete{*db_.get(), resume_table}
                     .where("api_path")
                     .equals(api_path)
                     .go();
@@ -612,14 +611,12 @@ void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
     lock = std::make_unique<mutex_lock>(upload_mtx_);
   }
 
-  auto result = db::db_select{*db_.get(), upload_table}
-                    .delete_query()
+  auto result = db::db_delete{*db_.get(), upload_table}
                     .where("api_path")
                     .equals(api_path)
                     .go();
 
-  result = db::db_select{*db_.get(), upload_active_table}
-               .delete_query()
+  result = db::db_delete{*db_.get(), upload_active_table}
                .where("api_path")
                .equals(api_path)
                .go();
@@ -996,8 +993,7 @@ void file_manager::upload_completed(const file_upload_completed &evt) {
   if (not utils::string::to_bool(evt.get_cancelled().get<std::string>())) {
     auto err = api_error_from_string(evt.get_result().get<std::string>());
     if (err == api_error::success) {
-      auto result = db::db_select{*db_.get(), upload_active_table}
-                        .delete_query()
+      auto result = db::db_delete{*db_.get(), upload_active_table}
                         .where("api_path")
                         .equals(evt.get_api_path().get<std::string>())
                         .go();
@@ -1071,8 +1067,7 @@ void file_manager::upload_handler() {
 
             upload_lookup_[fsi.api_path] =
                 std::make_unique<upload>(fsi, provider_);
-            auto del_res = db::db_select{*db_.get(), upload_table}
-                               .delete_query()
+            auto del_res = db::db_delete{*db_.get(), upload_table}
                                .where("api_path")
                                .equals(api_path)
                                .go();

repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp

@@ -22,6 +22,7 @@
 #include "providers/encrypt/encrypt_provider.hpp"
 
 #include "database/db_common.hpp"
+#include "database/db_delete.hpp"
 #include "database/db_insert.hpp"
 #include "database/db_select.hpp"
 #include "events/event_system.hpp"
@@ -999,14 +1000,12 @@ void encrypt_provider::remove_deleted_files() {
 
   for (auto &&item : removed_list) {
     if (not item.directory) {
-      auto del_res = db::db_select{*db_, source_table}
-                         .delete_query()
+      auto del_res = db::db_delete{*db_, source_table}
                          .where("api_path")
                          .equals(item.api_path)
                          .go();
       // TODO handle error
-      del_res = db::db_select{*db_, file_table}
-                    .delete_query()
+      del_res = db::db_delete{*db_, file_table}
                     .where("source_path")
                     .equals(item.source_path)
                     .go();
@@ -1018,14 +1017,12 @@ void encrypt_provider::remove_deleted_files() {
 
   for (auto &&item : removed_list) {
     if (item.directory) {
-      auto del_res = db::db_select{*db_, source_table}
-                         .delete_query()
+      auto del_res = db::db_delete{*db_, source_table}
                          .where("api_path")
                          .equals(item.api_path)
                          .go();
       // TODO handle error
-      del_res = db::db_select{*db_, directory_table}
-                    .delete_query()
+      del_res = db::db_delete{*db_, directory_table}
                     .where("source_path")
                     .equals(item.source_path)
                     .go();

repertory/librepertory/src/providers/meta_db.cpp

@@ -23,6 +23,7 @@
 
 #include "app_config.hpp"
 #include "database/db_common.hpp"
+#include "database/db_delete.hpp"
 #include "database/db_insert.hpp"
 #include "database/db_select.hpp"
 #include "utils/error_utils.hpp"
@@ -241,11 +242,8 @@ void meta_db::remove_api_path(const std::string &api_path) {
       static_cast<const char *>(__FUNCTION__),
   };
 
-  auto result = db::db_select{*db_, table_name}
-                    .delete_query()
-                    .where("api_path")
-                    .equals(api_path)
-                    .go();
+  auto result =
+      db::db_delete{*db_, table_name}.where("api_path").equals(api_path).go();
   if (not result.ok()) {
     utils::error::raise_api_path_error(
         function_name, api_path, result.get_error(), "failed to remove meta");

repertory/repertory_test/src/database_test.cpp

@@ -22,103 +22,144 @@
 #include "test_common.hpp"
 
 #include "database/db_common.hpp"
+#include "database/db_delete.hpp"
 #include "database/db_insert.hpp"
 #include "database/db_select.hpp"
+#include "database/db_update.hpp"
 #include "utils/path.hpp"
 
 namespace repertory {
-TEST(database, db_insert) {
-  console_consumer consumer1;
-  event_system::instance().start();
-  {
-    db::db3_t db3;
-    {
-      sqlite3 *db3_ptr{nullptr};
-      auto res = sqlite3_open_v2(
-          utils::path::combine(test::get_test_input_dir(), {"test.db3"})
-              .c_str(),
-          &db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
-      ASSERT_EQ(SQLITE_OK, res);
-      ASSERT_TRUE(db3_ptr != nullptr);
+class database_test : public ::testing::Test {
+public:
+  static console_consumer cs;
+  db::db3_t db3;
 
-      db3.reset(db3_ptr);
-    }
+  void SetUp() override {
+    event_system::instance().start();
 
-    auto query = db::db_insert{*db3.get(), "table"}
-                     .column_value("column1", "test9")
-                     .column_value("column2", "test9");
-    auto query_str = query.dump();
-    std::cout << query_str << std::endl;
-    EXPECT_STREQ(
-        R"(INSERT INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
-        query_str.c_str());
+    sqlite3 *db3_ptr{nullptr};
+    auto res = sqlite3_open_v2(
+        utils::path::combine(test::get_test_input_dir(), {"test.db3"}).c_str(),
+        &db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
+    ASSERT_EQ(SQLITE_OK, res);
+    ASSERT_TRUE(db3_ptr != nullptr);
 
-    query = db::db_insert{*db3.get(), "table"}
-                .or_replace()
-                .column_value("column1", "test1")
-                .column_value("column2", "test2");
-    query_str = query.dump();
-    std::cout << query_str << std::endl;
-    EXPECT_STREQ(
-        R"(INSERT OR REPLACE INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
-        query_str.c_str());
-
-    auto res = query.go();
-    EXPECT_TRUE(res.ok());
-    EXPECT_FALSE(res.has_row());
+    db3.reset(db3_ptr);
   }
 
-  event_system::instance().stop();
-}
-
-TEST(database, db_select) {
-  console_consumer consumer1;
-  event_system::instance().start();
-  {
-    db::db3_t db3;
-    {
-      sqlite3 *db3_ptr{nullptr};
-      auto res = sqlite3_open_v2(
-          utils::path::combine(test::get_test_input_dir(), {"test.db3"})
-              .c_str(),
-          &db3_ptr, SQLITE_OPEN_READWRITE, nullptr);
-      ASSERT_EQ(SQLITE_OK, res);
-      ASSERT_TRUE(db3_ptr != nullptr);
-
-      db3.reset(db3_ptr);
-    }
-
-    auto query = db::db_select{*db3.get(), "table"}
-                     .where("column1")
-                     .equals("test1")
-                     .and_where("column2")
-                     .equals("test2");
-    auto query_str = query.dump();
-    std::cout << query_str << std::endl;
-    EXPECT_STREQ(
-        R"(SELECT * FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
-        query_str.c_str());
-    auto res = query.go();
-
-    EXPECT_TRUE(res.ok());
-    EXPECT_TRUE(res.has_row());
-    std::size_t row_count{};
-    while (res.has_row()) {
-      std::optional<db::db_select::row> row;
-      EXPECT_TRUE(res.get_row(row));
-      EXPECT_TRUE(row.has_value());
-      if (row.has_value()) {
-        for (const auto &column : row.value().get_columns()) {
-          std::cout << column.get_index() << ':';
-          std::cout << column.get_name() << ':';
-          std::cout << column.get_value<std::string>() << std::endl;
-        }
-      }
-      ++row_count;
-    }
-    EXPECT_EQ(std::size_t(1U), row_count);
+  void TearDown() override {
+    db3.reset();
+    event_system::instance().stop();
   }
+};
 
-  event_system::instance().stop();
+TEST_F(database_test, db_delete_query) {
+  auto query = db::db_delete{*db3.get(), "table"};
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(R"(DELETE FROM "table";)", query_str.c_str());
 }
+
+TEST_F(database_test, db_delete_where_query) {
+  auto query = db::db_delete{*db3.get(), "table"}
+                   .where("column1")
+                   .equals("test1")
+                   .and_where("column2")
+                   .equals("test2");
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(R"(DELETE FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
+               query_str.c_str());
+}
+
+TEST_F(database_test, db_insert_query) {
+  auto query = db::db_insert{*db3.get(), "table"}
+                   .column_value("column1", "test9")
+                   .column_value("column2", "test9");
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(R"(INSERT INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
+               query_str.c_str());
+}
+
+TEST_F(database_test, db_insert_or_replace_query) {
+  auto query = db::db_insert{*db3.get(), "table"}
+                   .or_replace()
+                   .column_value("column1", "test1")
+                   .column_value("column2", "test2");
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(
+      R"(INSERT OR REPLACE INTO "table" ("column1", "column2") VALUES (?1, ?2);)",
+      query_str.c_str());
+}
+
+TEST_F(database_test, db_select_query) {
+  auto query = db::db_select{*db3.get(), "table"};
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(R"(SELECT * FROM "table";)", query_str.c_str());
+}
+
+TEST_F(database_test, db_select_where_query) {
+  auto query = db::db_select{*db3.get(), "table"}
+                   .where("column1")
+                   .equals("test1")
+                   .and_where("column2")
+                   .equals("test2");
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(
+      R"(SELECT * FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
+      query_str.c_str());
+}
+
+TEST_F(database_test, db_select_columns_query) {
+  auto query = db::db_select{*db3.get(), "table"}
+                   .column("column1")
+                   .column("column2")
+                   .where("column1")
+                   .equals("test1")
+                   .and_where("column2")
+                   .equals("test2");
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(
+      R"(SELECT column1, column2 FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
+      query_str.c_str());
+}
+
+TEST_F(database_test, db_update_query) {
+  auto query = db::db_update{*db3.get(), "table"}
+                   .column_value("column1", "moose")
+                   .where("column1")
+                   .equals("test1")
+                   .and_where("column2")
+                   .equals("test2");
+  auto query_str = query.dump();
+  std::cout << query_str << std::endl;
+  EXPECT_STREQ(
+      R"(UPDATE "table" SET "column1"=?1 WHERE ("column1"=?2 AND "column2"=?3);)",
+      query_str.c_str());
+}
+
+// auto res = query.go();
+//
+// EXPECT_TRUE(res.ok());
+// EXPECT_TRUE(res.has_row());
+// std::size_t row_count{};
+// while (res.has_row()) {
+//   std::optional<db::db_select::row> row;
+//   EXPECT_TRUE(res.get_row(row));
+//   EXPECT_TRUE(row.has_value());
+//   if (row.has_value()) {
+//     for (const auto &column : row.value().get_columns()) {
+//       std::cout << column.get_index() << ':';
+//       std::cout << column.get_name() << ':';
+//       std::cout << column.get_value<std::string>() << std::endl;
+//     }
+//   }
+//   ++row_count;
+// }
+// EXPECT_EQ(std::size_t(1U), row_count);
 } // namespace repertory