From 4a530c470341d5990b1a9d107920566e06ffaa40 Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Thu, 17 Oct 2024 18:26:24 -0500 Subject: [PATCH] refactor --- cmake/versions.cmake | 12 +- .../src/file_manager/file_manager.cpp | 19 ++- .../providers/encrypt/encrypt_provider.cpp | 46 +++---- .../librepertory/src/providers/meta_db.cpp | 10 +- support/include/utils/db/sqlite/db_common.hpp | 32 +++-- support/include/utils/db/sqlite/db_delete.hpp | 12 +- support/include/utils/db/sqlite/db_insert.hpp | 10 +- support/include/utils/db/sqlite/db_select.hpp | 24 ++-- support/include/utils/db/sqlite/db_update.hpp | 24 ++-- .../include/utils/db/sqlite/db_where_t.hpp | 4 +- support/src/utils/db/sqlite/db_delete.cpp | 57 ++++---- support/src/utils/db/sqlite/db_insert.cpp | 53 ++++---- support/src/utils/db/sqlite/db_select.cpp | 117 +++++++++------- support/src/utils/db/sqlite/db_update.cpp | 127 ++++++++++-------- 14 files changed, 292 insertions(+), 255 deletions(-) diff --git a/cmake/versions.cmake b/cmake/versions.cmake index aefb4bcb..fb10e730 100644 --- a/cmake/versions.cmake +++ b/cmake/versions.cmake @@ -1,15 +1,15 @@ set(BINUTILS_VERSION 2.41) -set(BOOST_MAJOR_VERSION 1) -set(BOOST_MINOR_VERSION 85) -set(BOOST_PATCH_VERSION 0) set(BOOST2_MAJOR_VERSION 1) set(BOOST2_MINOR_VERSION 76) set(BOOST2_PATCH_VERSION 0) +set(BOOST_MAJOR_VERSION 1) +set(BOOST_MINOR_VERSION 85) +set(BOOST_PATCH_VERSION 0) set(CPP_HTTPLIB_VERSION 0.16.3) -set(CURL_VERSION 8.9.1) set(CURL2_VERSION 8_9_1) -set(EXPAT_VERSION 2.6.2) +set(CURL_VERSION 8.9.1) set(EXPAT2_VERSION 2_6_2) +set(EXPAT_VERSION 2.6.2) set(GCC_VERSION 14.2.0) set(GTEST_VERSION 1.15.2) set(ICU_VERSION 75-1) @@ -21,7 +21,7 @@ set(OPENSSL_VERSION 3.3.1) set(PKG_CONFIG_VERSION 0.29.2) set(PUGIXML_VERSION 1.14) set(SPDLOG_VERSION 1.14.1) -set(SQLITE_VERSION 3460100) set(SQLITE2_VERSION 3.46.1) +set(SQLITE_VERSION 3460100) set(STDUUID_VERSION 1.2.3) set(ZLIB_VERSION 1.3.1) diff --git a/repertory/librepertory/src/file_manager/file_manager.cpp b/repertory/librepertory/src/file_manager/file_manager.cpp index 5c53cb4a..8717cd95 100644 --- a/repertory/librepertory/src/file_manager/file_manager.cpp +++ b/repertory/librepertory/src/file_manager/file_manager.cpp @@ -40,8 +40,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()}, @@ -105,7 +105,7 @@ file_manager::file_manager(app_config &config, i_provider &provider) : config_(config), provider_(provider) { if (not provider_.is_direct_only()) { auto db_path = - utils::path::combine(config.get_data_directory(), {"file_manager.db3"}); + utils::path::combine(config.get_data_directory(), {"file_manager.db"}); sqlite3 *db3{nullptr}; auto res = @@ -455,11 +455,10 @@ 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 &file, - std::shared_ptr 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 &file, + std::shared_ptr closeable_file) -> api_error { const auto create_and_add_handle = [&](std::shared_ptr cur_file) { handle = get_next_handle(); @@ -718,8 +717,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; } diff --git a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp index 24fb2a02..59bce566 100644 --- a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp +++ b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp @@ -69,10 +69,9 @@ const std::map 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"); @@ -98,10 +97,10 @@ auto encrypt_provider::create_api_file(const std::string &api_path, 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) @@ -188,9 +187,8 @@ 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 { @@ -255,9 +253,8 @@ 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( @@ -430,9 +427,8 @@ 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 { @@ -458,10 +454,9 @@ auto encrypt_provider::get_file_size(const std::string &api_path, 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") @@ -537,10 +532,9 @@ 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 { @@ -667,8 +661,8 @@ 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") @@ -1032,7 +1026,7 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/, } auto db_path = - utils::path::combine(config_.get_data_directory(), {"meta.db3"}); + utils::path::combine(config_.get_data_directory(), {"meta.db"}); sqlite3 *db3{nullptr}; auto res = diff --git a/repertory/librepertory/src/providers/meta_db.cpp b/repertory/librepertory/src/providers/meta_db.cpp index 86cc25ad..f2470a8f 100644 --- a/repertory/librepertory/src/providers/meta_db.cpp +++ b/repertory/librepertory/src/providers/meta_db.cpp @@ -34,7 +34,7 @@ namespace repertory { meta_db::meta_db(const app_config &cfg) { REPERTORY_USES_FUNCTION_NAME(); - auto db_path = utils::path::combine(cfg.get_data_directory(), {"meta.db3"}); + auto db_path = utils::path::combine(cfg.get_data_directory(), {"meta.db"}); sqlite3 *db3{nullptr}; auto res = @@ -108,8 +108,8 @@ auto meta_db::get_api_path_list() -> std::vector { 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} @@ -292,8 +292,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 41ca1474..9e006106 100644 --- a/support/include/utils/db/sqlite/db_common.hpp +++ b/support/include/utils/db/sqlite/db_common.hpp @@ -31,11 +31,7 @@ using db_types_t = std::variant; struct sqlite3_deleter { void operator()(sqlite3 *db3) const { if (db3 != nullptr) { -#if defined(_WIN32) - sqlite3_close(db3); -#else // !defined(_WIN32) sqlite3_close_v2(db3); -#endif // defined(_WIN32) } } }; @@ -123,21 +119,21 @@ public: template class db_row final { public: - db_row(std::shared_ptr context) { - auto column_count = sqlite3_column_count(context->stmt.get()); + db_row(std::shared_ptr ctx) { + auto column_count = sqlite3_column_count(ctx->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); + std::string name{sqlite3_column_name(ctx->stmt.get(), col)}; + auto column_type = sqlite3_column_type(ctx->stmt.get(), col); db_types_t value; switch (column_type) { case SQLITE_INTEGER: { - value = sqlite3_column_int64(context->stmt.get(), col); + value = sqlite3_column_int64(ctx->stmt.get(), col); } break; case SQLITE_TEXT: { const auto *text = reinterpret_cast( - sqlite3_column_text(context->stmt.get(), col)); + sqlite3_column_text(ctx->stmt.get(), col)); value = std::string(text == nullptr ? "" : text); } break; @@ -180,15 +176,17 @@ public: }; template struct db_result final { - db_result(std::shared_ptr context, std::int32_t res) - : context_(std::move(context)), res_(res) { + db_result(std::shared_ptr ctx, std::int32_t res) + : ctx_(std::move(ctx)), res_(res) { if (res == SQLITE_OK) { - set_res(sqlite3_step(context_->stmt.get())); + set_res(sqlite3_step(ctx_->stmt.get())); } } + ~db_result() { ctx_->clear(); } + private: - std::shared_ptr context_; + std::shared_ptr ctx_; mutable std::int32_t res_; private: @@ -212,8 +210,8 @@ public: return false; } - row = db_row{context_}; - set_res(sqlite3_step(context_->stmt.get())); + row = db_row{ctx_}; + set_res(sqlite3_step(ctx_->stmt.get())); return true; } @@ -224,7 +222,7 @@ public: return; } - set_res(sqlite3_step(context_->stmt.get())); + set_res(sqlite3_step(ctx_->stmt.get())); } }; } // namespace repertory::utils::db::sqlite diff --git a/support/include/utils/db/sqlite/db_delete.hpp b/support/include/utils/db/sqlite/db_delete.hpp index 486954aa..1cd615a8 100644 --- a/support/include/utils/db/sqlite/db_delete.hpp +++ b/support/include/utils/db/sqlite/db_delete.hpp @@ -46,26 +46,28 @@ public: using wd_t = where_data_t; std::unique_ptr where_data; + + void clear(); }; using row = db_row; public: db_delete(sqlite3 &db3, std::string table_name) - : context_(std::make_shared(&db3, table_name)) {} + : ctx_(std::make_shared(&db3, table_name)) {} - db_delete(std::shared_ptr ctx) : context_(std::move(ctx)) {} + db_delete(std::shared_ptr ctx) : ctx_(std::move(ctx)) {} private: - std::shared_ptr context_; + std::shared_ptr ctx_; public: [[nodiscard]] auto dump() const -> std::string; [[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 7453f682..187ba545 100644 --- a/support/include/utils/db/sqlite/db_insert.hpp +++ b/support/include/utils/db/sqlite/db_insert.hpp @@ -34,22 +34,24 @@ public: bool or_replace{false}; std::map values; + + void clear(); }; using row = db_row; public: db_insert(sqlite3 &db3, std::string table_name) - : context_(std::make_shared(&db3, table_name)) {} + : ctx_(std::make_shared(&db3, table_name)) {} - db_insert(std::shared_ptr ctx) : context_(std::move(ctx)) {} + db_insert(std::shared_ptr ctx) : ctx_(std::move(ctx)) {} private: - std::shared_ptr context_; + std::shared_ptr ctx_; public: [[nodiscard]] auto or_replace() -> db_insert & { - context_->or_replace = true; + ctx_->or_replace = true; return *this; } diff --git a/support/include/utils/db/sqlite/db_select.hpp b/support/include/utils/db/sqlite/db_select.hpp index a5ea2a19..ffe82622 100644 --- a/support/include/utils/db/sqlite/db_select.hpp +++ b/support/include/utils/db/sqlite/db_select.hpp @@ -44,8 +44,8 @@ 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_) @@ -63,24 +63,26 @@ public: std::optional> order_by; std::unique_ptr where_data; + + void clear(); }; using row = db_row; public: db_select(sqlite3 &db3, std::string table_name) - : context_(std::make_shared(&db3, table_name)) {} + : ctx_(std::make_shared(&db3, table_name)) {} - db_select(std::shared_ptr ctx) : context_(std::move(ctx)) {} + db_select(std::shared_ptr ctx) : ctx_(std::move(ctx)) {} private: - std::shared_ptr context_; + std::shared_ptr ctx_; 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; @@ -88,15 +90,15 @@ public: [[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 407554cf..b2ce4e54 100644 --- a/support/include/utils/db/sqlite/db_update.hpp +++ b/support/include/utils/db/sqlite/db_update.hpp @@ -43,8 +43,8 @@ public: [[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; @@ -55,34 +55,36 @@ public: std::optional> order_by; std::unique_ptr where_data; + + void clear(); }; using row = db_row; public: db_update(sqlite3 &db3, std::string table_name) - : context_(std::make_shared(&db3, table_name)) {} + : ctx_(std::make_shared(&db3, table_name)) {} - db_update(std::shared_ptr ctx) : context_(std::move(ctx)) {} + db_update(std::shared_ptr ctx) : ctx_(std::move(ctx)) {} private: - std::shared_ptr context_; + std::shared_ptr 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; - [[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/include/utils/db/sqlite/db_where_t.hpp b/support/include/utils/db/sqlite/db_where_t.hpp index 40ea6119..5178eee2 100644 --- a/support/include/utils/db/sqlite/db_where_t.hpp +++ b/support/include/utils/db/sqlite/db_where_t.hpp @@ -157,8 +157,8 @@ template struct db_where_t final { using action_t = std::variant; - [[nodiscard]] static auto dump(std::int32_t &idx, auto &&actions) - -> std::string { + [[nodiscard]] static auto dump(std::int32_t &idx, + auto &&actions) -> std::string { std::stringstream stream; for (auto &&action : actions) { diff --git a/support/src/utils/db/sqlite/db_delete.cpp b/support/src/utils/db/sqlite/db_delete.cpp index bed2c3c3..887f9a46 100644 --- a/support/src/utils/db/sqlite/db_delete.cpp +++ b/support/src/utils/db/sqlite/db_delete.cpp @@ -24,6 +24,11 @@ #if defined(PROJECT_ENABLE_SQLITE) namespace repertory::utils::db::sqlite { +void db_delete::context::clear() { + stmt.reset(); + where_data.reset(); +} + auto db_delete::context::db_delete_op_t::dump() const -> std::string { return db_delete{ctx}.dump(); } @@ -34,11 +39,11 @@ auto db_delete::context::db_delete_op_t::go() const -> db_result { auto db_delete::dump() const -> std::string { std::stringstream query; - query << "DELETE FROM \"" << context_->table_name << "\""; + query << "DELETE FROM \"" << ctx_->table_name << "\""; - if (context_->where_data) { + if (ctx_->where_data) { std::int32_t idx{}; - query << " WHERE " << context_->where_data->base.dump(idx); + query << " WHERE " << ctx_->where_data->base.dump(idx); } query << ';'; @@ -49,61 +54,65 @@ auto db_delete::dump() const -> std::string { auto db_delete::go() const -> db_result { sqlite3_stmt *stmt_ptr{nullptr}; auto query_str = dump(); - auto res = sqlite3_prepare_v2(context_->db3, query_str.c_str(), -1, &stmt_ptr, - nullptr); - context_->stmt = db3_stmt_t{ + 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 {context_, res}; + return {ctx_, res}; } - if (not context_->where_data) { - return {context_, res}; + if (not ctx_->where_data) { + return {ctx_, res}; } for (std::int32_t idx = 0; - idx < static_cast(context_->where_data->values.size()); + idx < static_cast(ctx_->where_data->values.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); + return sqlite3_bind_int64(ctx_->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); + return sqlite3_bind_text(ctx_->stmt.get(), idx + 1, data.c_str(), + -1, nullptr); }, }, - context_->where_data->values.at(static_cast(idx))); + ctx_->where_data->values.at(static_cast(idx))); if (res != SQLITE_OK) { - return {context_, res}; + return {ctx_, res}; } } - return {context_, res}; + return {ctx_, res}; } auto db_delete::group(context::w_t::group_func_t func) -> context::w_t::wn_t { - if (not context_->where_data) { - context_->where_data = std::make_unique(context::wd_t{ - context::w_t{0U, context_}, + if (not ctx_->where_data) { + ctx_->where_data = std::make_unique(context::wd_t{ + context::w_t{0U, ctx_}, + {}, + {}, }); } - return context_->where_data->base.group(std::move(func)); + return ctx_->where_data->base.group(std::move(func)); } auto db_delete::where(std::string column_name) const -> context::w_t::cn_t { - if (not context_->where_data) { - context_->where_data = std::make_unique(context::wd_t{ - context::w_t{0U, context_}, + if (not ctx_->where_data) { + ctx_->where_data = std::make_unique(context::wd_t{ + context::w_t{0U, ctx_}, + {}, + {}, }); } - return context_->where_data->base.where(column_name); + return ctx_->where_data->base.where(column_name); } } // namespace repertory::utils::db::sqlite diff --git a/support/src/utils/db/sqlite/db_insert.cpp b/support/src/utils/db/sqlite/db_insert.cpp index 9a9cc36c..00c8caa5 100644 --- a/support/src/utils/db/sqlite/db_insert.cpp +++ b/support/src/utils/db/sqlite/db_insert.cpp @@ -24,31 +24,36 @@ #if defined(PROJECT_ENABLE_SQLITE) namespace repertory::utils::db::sqlite { +void db_insert::context::clear() { + stmt.reset(); + values.clear(); +} + auto db_insert::column_value(std::string column_name, db_types_t value) -> db_insert & { - context_->values[column_name] = value; + ctx_->values[column_name] = value; return *this; } auto db_insert::dump() const -> std::string { std::stringstream query; query << "INSERT "; - if (context_->or_replace) { + if (ctx_->or_replace) { query << "OR REPLACE "; } - query << "INTO \"" << context_->table_name << "\" ("; + query << "INTO \"" << ctx_->table_name << "\" ("; for (std::int32_t idx = 0; - idx < static_cast(context_->values.size()); idx++) { + idx < static_cast(ctx_->values.size()); idx++) { if (idx > 0) { query << ", "; } - query << '"' << std::next(context_->values.begin(), idx)->first << '"'; + query << '"' << std::next(ctx_->values.begin(), idx)->first << '"'; } query << ") VALUES ("; for (std::int32_t idx = 0; - idx < static_cast(context_->values.size()); idx++) { + idx < static_cast(ctx_->values.size()); idx++) { if (idx > 0) { query << ", "; } @@ -62,36 +67,36 @@ auto db_insert::dump() const -> std::string { auto db_insert::go() const -> db_result { sqlite3_stmt *stmt_ptr{nullptr}; auto query_str = dump(); - auto res = sqlite3_prepare_v2(context_->db3, query_str.c_str(), -1, &stmt_ptr, - nullptr); - context_->stmt = db3_stmt_t{ + 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 {context_, res}; + return {ctx_, res}; } for (std::int32_t idx = 0; - idx < static_cast(context_->values.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); - }, - }, - std::next(context_->values.begin(), idx)->second); + idx < static_cast(ctx_->values.size()); idx++) { + res = std::visit(overloaded{ + [this, &idx](std::int64_t data) -> std::int32_t { + return sqlite3_bind_int64(ctx_->stmt.get(), 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); + }, + }, + std::next(ctx_->values.begin(), idx)->second); if (res != SQLITE_OK) { - return {context_, res}; + return {ctx_, res}; } } - return {context_, res}; + return {ctx_, 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 f9a72ddb..43417a4c 100644 --- a/support/src/utils/db/sqlite/db_select.cpp +++ b/support/src/utils/db/sqlite/db_select.cpp @@ -24,6 +24,17 @@ #if defined(PROJECT_ENABLE_SQLITE) namespace repertory::utils::db::sqlite { +void db_select::context::clear() { + columns.clear(); + count_columns.clear(); + group_by.clear(); + limit.reset(); + offset.reset(); + order_by.reset(); + stmt.reset(); + where_data.reset(); +} + auto db_select::context::db_select_op_t::dump() const -> std::string { return db_select{ctx}.dump(); } @@ -58,13 +69,13 @@ auto db_select::context::db_select_op_t::order_by(std::string column_name, } auto db_select::column(std::string column_name) -> db_select & { - context_->columns.push_back(column_name); + ctx_->columns.push_back(column_name); return *this; } -auto db_select::count(std::string column_name, std::string as_column_name) - -> db_select & { - context_->count_columns[column_name] = as_column_name; +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; } @@ -72,59 +83,59 @@ auto db_select::dump() const -> std::string { std::stringstream query; query << "SELECT "; bool has_column{false}; - if (context_->columns.empty()) { - if (context_->count_columns.empty()) { + if (ctx_->columns.empty()) { + if (ctx_->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++) { + has_column = not ctx_->columns.empty(); + for (std::size_t idx = 0U; idx < ctx_->columns.size(); idx++) { if (idx > 0U) { query << ", "; } - query << context_->columns.at(idx); + query << ctx_->columns.at(idx); } } for (std::int32_t idx = 0U; - idx < static_cast(context_->count_columns.size()); idx++) { + idx < static_cast(ctx_->count_columns.size()); idx++) { if (has_column || idx > 0) { query << ", "; } query << "COUNT(\""; - auto &count_column = *std::next(context_->count_columns.begin(), idx); + auto &count_column = *std::next(ctx_->count_columns.begin(), idx); query << count_column.first << "\") AS \"" << count_column.second << '"'; } - query << " FROM \"" << context_->table_name << "\""; + query << " FROM \"" << ctx_->table_name << "\""; - if (context_->where_data) { + if (ctx_->where_data) { std::int32_t idx{}; - query << " WHERE " << context_->where_data->base.dump(idx); + query << " WHERE " << ctx_->where_data->base.dump(idx); } - if (not context_->group_by.empty()) { + if (not ctx_->group_by.empty()) { query << " GROUP BY "; - for (std::size_t idx = 0U; idx < context_->group_by.size(); idx++) { + for (std::size_t idx = 0U; idx < ctx_->group_by.size(); idx++) { if (idx > 0U) { query << ", "; } - query << "\"" << context_->group_by.at(idx) << "\""; + query << "\"" << ctx_->group_by.at(idx) << "\""; } } - if (context_->order_by.has_value()) { - query << " ORDER BY \"" << context_->order_by.value().first << "\" "; - query << (context_->order_by.value().second ? "ASC" : "DESC"); + if (ctx_->order_by.has_value()) { + query << " ORDER BY \"" << ctx_->order_by.value().first << "\" "; + query << (ctx_->order_by.value().second ? "ASC" : "DESC"); } - if (context_->limit.has_value()) { - query << " LIMIT " << context_->limit.value(); + if (ctx_->limit.has_value()) { + query << " LIMIT " << ctx_->limit.value(); } - if (context_->offset.has_value()) { - query << " OFFSET " << context_->offset.value(); + if (ctx_->offset.has_value()) { + query << " OFFSET " << ctx_->offset.value(); } query << ';'; @@ -135,82 +146,86 @@ auto db_select::dump() const -> std::string { auto db_select::go() const -> db_result { sqlite3_stmt *stmt_ptr{nullptr}; auto query_str = dump(); - auto res = sqlite3_prepare_v2(context_->db3, query_str.c_str(), -1, &stmt_ptr, - nullptr); - context_->stmt = db3_stmt_t{ + 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 {context_, res}; + return {ctx_, res}; } - if (not context_->where_data) { - return {context_, res}; + if (not ctx_->where_data) { + return {ctx_, res}; } for (std::int32_t idx = 0; - idx < static_cast(context_->where_data->values.size()); + idx < static_cast(ctx_->where_data->values.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); + return sqlite3_bind_int64(ctx_->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); + return sqlite3_bind_text(ctx_->stmt.get(), idx + 1, data.c_str(), + -1, nullptr); }, }, - context_->where_data->values.at(static_cast(idx))); + ctx_->where_data->values.at(static_cast(idx))); if (res != SQLITE_OK) { - return {context_, res}; + return {ctx_, res}; } } - return {context_, res}; + return {ctx_, res}; } auto db_select::group(context::w_t::group_func_t func) -> context::w_t::wn_t { - if (not context_->where_data) { - context_->where_data = std::make_unique(context::wd_t{ - context::w_t{0U, context_}, + if (not ctx_->where_data) { + ctx_->where_data = std::make_unique(context::wd_t{ + context::w_t{0U, ctx_}, + {}, + {}, }); } - return context_->where_data->base.group(std::move(func)); + return ctx_->where_data->base.group(std::move(func)); } auto db_select::group_by(std::string column_name) -> db_select & { - context_->group_by.emplace_back(std::move(column_name)); + ctx_->group_by.emplace_back(std::move(column_name)); return *this; } auto db_select::limit(std::int32_t value) -> db_select & { - context_->limit = value; + ctx_->limit = value; return *this; } auto db_select::offset(std::int32_t value) -> db_select & { - context_->offset = value; + ctx_->offset = value; return *this; } -auto db_select::order_by(std::string column_name, bool ascending) - -> db_select & { - context_->order_by = {column_name, ascending}; +auto db_select::order_by(std::string column_name, + bool ascending) -> db_select & { + ctx_->order_by = {column_name, ascending}; return *this; } auto db_select::where(std::string column_name) const -> context::w_t::cn_t { - if (not context_->where_data) { - context_->where_data = std::make_unique(context::wd_t{ - context::w_t{0U, context_}, + if (not ctx_->where_data) { + ctx_->where_data = std::make_unique(context::wd_t{ + context::w_t{0U, ctx_}, + {}, + {}, }); } - return context_->where_data->base.where(column_name); + return ctx_->where_data->base.where(column_name); } } // namespace repertory::utils::db::sqlite diff --git a/support/src/utils/db/sqlite/db_update.cpp b/support/src/utils/db/sqlite/db_update.cpp index d4ccc369..f0d40719 100644 --- a/support/src/utils/db/sqlite/db_update.cpp +++ b/support/src/utils/db/sqlite/db_update.cpp @@ -24,6 +24,14 @@ #if defined(PROJECT_ENABLE_SQLITE) namespace repertory::utils::db::sqlite { +void db_update::context::clear() { + column_values.clear(); + limit.reset(); + order_by.reset(); + stmt.reset(); + where_data.reset(); +} + auto db_update::context::db_update_op_t::dump() const -> std::string { return db_update{ctx}.dump(); } @@ -45,38 +53,38 @@ 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 & { - context_->column_values[column_name] = value; +auto db_update::column_value(std::string column_name, + db_types_t value) -> db_update & { + ctx_->column_values[column_name] = value; return *this; } auto db_update::dump() const -> std::string { std::stringstream query; - query << "UPDATE \"" << context_->table_name << "\" SET "; + query << "UPDATE \"" << ctx_->table_name << "\" SET "; for (std::int32_t idx = 0; - idx < static_cast(context_->column_values.size()); idx++) { + idx < static_cast(ctx_->column_values.size()); idx++) { if (idx > 0) { query << ", "; } - auto column = std::next(context_->column_values.begin(), idx); + auto column = std::next(ctx_->column_values.begin(), idx); query << '"' << column->first << "\"=?" + std::to_string(idx + 1); } - if (context_->where_data) { - auto idx{static_cast(context_->column_values.size())}; - query << " WHERE " << context_->where_data->base.dump(idx); + if (ctx_->where_data) { + auto idx{static_cast(ctx_->column_values.size())}; + query << " WHERE " << ctx_->where_data->base.dump(idx); } - if (context_->order_by.has_value()) { - query << " ORDER BY \"" << context_->order_by.value().first << "\" "; - query << (context_->order_by.value().second ? "ASC" : "DESC"); + if (ctx_->order_by.has_value()) { + query << " ORDER BY \"" << ctx_->order_by.value().first << "\" "; + query << (ctx_->order_by.value().second ? "ASC" : "DESC"); } - if (context_->limit.has_value()) { - query << " LIMIT " << context_->limit.value(); + if (ctx_->limit.has_value()) { + query << " LIMIT " << ctx_->limit.value(); } query << ';'; @@ -87,100 +95,101 @@ auto db_update::dump() const -> std::string { auto db_update::go() const -> db_result { sqlite3_stmt *stmt_ptr{nullptr}; auto query_str = dump(); - auto res = sqlite3_prepare_v2(context_->db3, query_str.c_str(), -1, &stmt_ptr, - nullptr); - context_->stmt = db3_stmt_t{ + 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 {context_, res}; + return {ctx_, res}; } for (std::int32_t idx = 0; - idx < static_cast(context_->column_values.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); - }, - }, - std::next(context_->column_values.begin(), idx)->second); + idx < static_cast(ctx_->column_values.size()); idx++) { + res = std::visit(overloaded{ + [this, &idx](std::int64_t data) -> std::int32_t { + return sqlite3_bind_int64(ctx_->stmt.get(), 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); + }, + }, + std::next(ctx_->column_values.begin(), idx)->second); if (res != SQLITE_OK) { - return {context_, res}; + return {ctx_, res}; } } - if (not context_->where_data) { - return {context_, res}; + if (not ctx_->where_data) { + return {ctx_, res}; } for (std::int32_t idx = 0; - idx < static_cast(context_->where_data->values.size()); + idx < static_cast(ctx_->where_data->values.size()); idx++) { res = std::visit( overloaded{ [this, &idx](std::int64_t data) -> std::int32_t { return sqlite3_bind_int64( - context_->stmt.get(), - idx + - static_cast( - context_->column_values.size()) + + ctx_->stmt.get(), + idx + static_cast(ctx_->column_values.size()) + 1, data); }, [this, &idx](const std::string &data) -> std::int32_t { - return sqlite3_bind_text(context_->stmt.get(), - idx + - static_cast( - context_->column_values.size()) + - 1, - data.c_str(), -1, nullptr); + return sqlite3_bind_text( + ctx_->stmt.get(), + idx + static_cast(ctx_->column_values.size()) + + 1, + data.c_str(), -1, nullptr); }, }, - context_->where_data->values.at(static_cast(idx))); + ctx_->where_data->values.at(static_cast(idx))); if (res != SQLITE_OK) { - return {context_, res}; + return {ctx_, res}; } } - return {context_, res}; + return {ctx_, res}; } auto db_update::group(context::w_t::group_func_t func) -> context::w_t::wn_t { - if (not context_->where_data) { - context_->where_data = std::make_unique(context::wd_t{ - context::w_t{0U, context_}, + if (not ctx_->where_data) { + ctx_->where_data = std::make_unique(context::wd_t{ + context::w_t{0U, ctx_}, + {}, + {}, }); } - return context_->where_data->base.group(std::move(func)); + return ctx_->where_data->base.group(std::move(func)); } auto db_update::limit(std::int32_t value) -> db_update & { - context_->limit = value; + ctx_->limit = value; return *this; } -auto db_update::order_by(std::string column_name, bool ascending) - -> db_update & { - context_->order_by = {column_name, ascending}; +auto db_update::order_by(std::string column_name, + bool ascending) -> db_update & { + ctx_->order_by = {column_name, ascending}; return *this; } auto db_update::where(std::string column_name) const -> context::w_t::cn_t { - if (not context_->where_data) { - context_->where_data = std::make_unique(context::wd_t{ - context::w_t{0U, context_}, + if (not ctx_->where_data) { + ctx_->where_data = std::make_unique(context::wd_t{ + context::w_t{0U, ctx_}, + {}, + {}, }); } - return context_->where_data->base.where(column_name); + return ctx_->where_data->base.where(column_name); } } // namespace repertory::utils::db::sqlite