From 8541e292cddedce4aa43bc59a6913e518ae5a856 Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Wed, 9 Oct 2024 09:51:09 -0500 Subject: [PATCH] fix --- .../providers/encrypt/encrypt_provider.hpp | 2 +- .../providers/encrypt/encrypt_provider.cpp | 116 +++++++++--------- .../repertory_test/src/database_test.cpp | 34 ++--- 3 files changed, 77 insertions(+), 75 deletions(-) diff --git a/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp b/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp index c8898556..c57b362e 100644 --- a/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp +++ b/repertory/librepertory/include/providers/encrypt/encrypt_provider.hpp @@ -53,7 +53,7 @@ private: private: app_config &config_; - db::db3_t db_; + utils::db::sqlite::db3_t db_; private: i_file_manager *fm_ = nullptr; diff --git a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp index b6e981da..6d57a624 100644 --- a/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp +++ b/repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp @@ -194,12 +194,12 @@ auto encrypt_provider::get_api_path_from_source( }; try { - auto result = db::db_select{*db_, file_table} + auto result = utils::db::sqlite::db_select{*db_, file_table} .column("data") .where("source_path") .equals(source_path) .go(); - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { api_path = row->get_column("data") .get_value_as_json() @@ -208,7 +208,7 @@ auto encrypt_provider::get_api_path_from_source( return api_error::success; } - result = db::db_select{*db_, directory_table} + result = utils::db::sqlite::db_select{*db_, directory_table} .column("api_path") .where("source_path") .equals(source_path) @@ -273,12 +273,13 @@ auto encrypt_provider::get_directory_items( try { std::string current_api_path{}; if (dir_entry->is_directory_item()) { - auto result = db::db_select{*db_, directory_table} - .column("api_path") - .where("source_path") - .equals(dir_entry->get_path()) - .go(); - std::optional row; + auto result = + utils::db::sqlite::db_select{*db_, directory_table} + .column("api_path") + .where("source_path") + .equals(dir_entry->get_path()) + .go(); + std::optional row; if (result.get_row(row) && row.has_value()) { current_api_path = row->get_column("api_path").get_value(); @@ -287,7 +288,7 @@ auto encrypt_provider::get_directory_items( process_directory_entry(*dir_entry.get(), cfg, current_api_path); - result = db::db_select{*db_, directory_table} + result = utils::db::sqlite::db_select{*db_, directory_table} .column("api_path") .where("source_path") .equals(dir_entry->get_path()) @@ -302,12 +303,12 @@ auto encrypt_provider::get_directory_items( } } else { std::string api_path_data{}; - auto result = db::db_select{*db_, file_table} + auto result = utils::db::sqlite::db_select{*db_, file_table} .column("data") .where("source_path") .equals(dir_entry->get_path()) .go(); - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { api_path_data = row->get_column("data").get_value(); @@ -387,12 +388,12 @@ auto encrypt_provider::get_file(const std::string &api_path, return api_error::directory_exists; } - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { return api_error::item_not_found; } @@ -443,12 +444,12 @@ auto encrypt_provider::get_file_size( }; try { - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { return api_error::item_not_found; } @@ -468,12 +469,12 @@ auto encrypt_provider::get_file_size( auto encrypt_provider::get_filesystem_item( const std::string &api_path, bool directory, filesystem_item &fsi) const -> api_error { - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { return api_error::item_not_found; } @@ -481,7 +482,7 @@ auto encrypt_provider::get_filesystem_item( auto source_path = row->get_column("source_path").get_value(); if (directory) { - result = db::db_select{*db_, directory_table} + result = utils::db::sqlite::db_select{*db_, directory_table} .column("api_path") .where("source_path") .equals(source_path) @@ -500,7 +501,7 @@ auto encrypt_provider::get_filesystem_item( return api_error::success; } - result = db::db_select{*db_, file_table} + result = utils::db::sqlite::db_select{*db_, file_table} .column("data") .where("source_path") .equals(source_path) @@ -586,12 +587,12 @@ auto encrypt_provider::get_item_meta(const std::string &api_path, }; try { - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { return api_error::item_not_found; } @@ -635,10 +636,11 @@ auto encrypt_provider::get_total_drive_space() const -> std::uint64_t { } auto encrypt_provider::get_total_item_count() const -> std::uint64_t { - auto result = - db::db_select{*db_, source_table}.count("api_path", "count").go(); + auto result = utils::db::sqlite::db_select{*db_, source_table} + .count("api_path", "count") + .go(); - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { return static_cast( row->get_column("count").get_value()); @@ -656,12 +658,12 @@ auto encrypt_provider::get_used_drive_space() const -> std::uint64_t { auto encrypt_provider::is_directory(const std::string &api_path, bool &exists) const -> api_error { - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { exists = false; return api_error::success; @@ -677,12 +679,12 @@ auto encrypt_provider::is_directory(const std::string &api_path, auto encrypt_provider::is_file(const std::string &api_path, bool &exists) const -> api_error { - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { exists = false; return api_error::success; @@ -739,12 +741,12 @@ auto encrypt_provider::process_directory_entry( current_source_path = utils::path::combine(current_source_path, {part}); std::string current_api_path{}; - auto result = db::db_select{*db_, directory_table} + auto result = utils::db::sqlite::db_select{*db_, directory_table} .column("api_path") .where("source_path") .equals(current_source_path) .go(); - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { current_api_path = row->get_column("api_path").get_value(); } @@ -753,12 +755,12 @@ auto encrypt_provider::process_directory_entry( current_api_path = utils::path::create_api_path( current_encrypted_path + '/' + encrypted_parts.at(current_idx)); - auto ins_res = db::db_insert{*db_, directory_table} + auto ins_res = utils::db::sqlite::db_insert{*db_, directory_table} .column_value("source_path", current_source_path) .column_value("api_path", current_api_path) .go(); // TODO handle error - ins_res = db::db_insert{*db_, source_table} + ins_res = utils::db::sqlite::db_insert{*db_, source_table} .column_value("api_path", current_api_path) .column_value("source_path", current_source_path) .go(); @@ -789,18 +791,18 @@ auto encrypt_provider::process_directory_entry( utils::path::get_relative_path(dir_entry.get_path(), cfg.path); std::string api_path_data{}; - auto result = db::db_select{*db_, file_table} + auto result = utils::db::sqlite::db_select{*db_, file_table} .column("data") .where("source_path") .equals(dir_entry.get_path()) .go(); - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { api_path_data = row->get_column("data").get_value(); } std::string api_parent{}; - result = db::db_select{*db_, directory_table} + result = utils::db::sqlite::db_select{*db_, directory_table} .column("api_path") .where("source_path") .equals(utils::path::get_parent_path(dir_entry.get_path())) @@ -834,13 +836,13 @@ auto encrypt_provider::process_directory_entry( .value_or(0U)), }, }; - auto ins_res = db::db_insert{*db_, file_table} + auto ins_res = utils::db::sqlite::db_insert{*db_, file_table} .column_value("source_path", dir_entry.get_path()) .column_value("data", data.dump()) .go(); // TODO handle error - ins_res = db::db_insert{*db_, source_table} + ins_res = utils::db::sqlite::db_insert{*db_, source_table} .column_value("api_path", api_path) .column_value("source_path", dir_entry.get_path()) .go(); @@ -865,12 +867,12 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path, static_cast(__FUNCTION__), }; - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals(api_path) .go(); - std::optional row; + std::optional row; if (not(result.get_row(row) && row.has_value())) { return api_error::item_not_found; } @@ -880,7 +882,7 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path, return api_error::item_not_found; } - result = db::db_select{*db_, file_table} + result = utils::db::sqlite::db_select{*db_, file_table} .column("data") .where("source_path") .equals(source_path) @@ -919,7 +921,7 @@ auto encrypt_provider::read_file_bytes(const std::string &api_path, file_data["original_file_size"] = file_size; file_data["iv_list"] = iv_list; - auto ins_res = db::db_insert{*db_, file_table} + auto ins_res = utils::db::sqlite::db_insert{*db_, file_table} .or_replace() .column_value("source_path", source_path) .column_value("data", file_data.dump()) @@ -974,11 +976,11 @@ void encrypt_provider::remove_deleted_files() { }; std::vector removed_list{}; - std::vector row_list{}; + std::vector row_list{}; - auto result = db::db_select{*db_, source_table}.go(); + auto result = utils::db::sqlite::db_select{*db_, source_table}.go(); while (result.has_row()) { - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { row_list.push_back(row.value()); } @@ -988,7 +990,7 @@ void encrypt_provider::remove_deleted_files() { auto source_path = row.get_column("source_path").get_value(); if (not utils::path::exists(source_path)) { auto api_path = row.get_column("api_path").get_value(); - result = db::db_select{*db_, file_table} + result = utils::db::sqlite::db_select{*db_, file_table} .column("source_path") .where("source_path") .equals(source_path) @@ -1000,12 +1002,12 @@ void encrypt_provider::remove_deleted_files() { for (auto &&item : removed_list) { if (not item.directory) { - auto del_res = db::db_delete{*db_, source_table} + auto del_res = utils::db::sqlite::db_delete{*db_, source_table} .where("api_path") .equals(item.api_path) .go(); // TODO handle error - del_res = db::db_delete{*db_, file_table} + del_res = utils::db::sqlite::db_delete{*db_, file_table} .where("source_path") .equals(item.source_path) .go(); @@ -1017,12 +1019,12 @@ void encrypt_provider::remove_deleted_files() { for (auto &&item : removed_list) { if (item.directory) { - auto del_res = db::db_delete{*db_, source_table} + auto del_res = utils::db::sqlite::db_delete{*db_, source_table} .where("api_path") .equals(item.api_path) .go(); // TODO handle error - del_res = db::db_delete{*db_, directory_table} + del_res = utils::db::sqlite::db_delete{*db_, directory_table} .where("source_path") .equals(item.source_path) .go(); @@ -1060,7 +1062,7 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/, for (auto &&create : sql_create_tables) { std::string err; - if (not db::execute_sql(*db_, create.second, err)) { + if (not utils::db::sqlite::execute_sql(*db_, create.second, err)) { utils::error::raise_error(function_name, "failed to create table|" + create.first + '|' + err); db_.reset(); @@ -1068,21 +1070,21 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/, } } - db::set_journal_mode(*db_); + utils::db::sqlite::set_journal_mode(*db_); const auto cfg = config_.get_encrypt_config(); std::string source_path; - auto result = db::db_select{*db_, source_table} + auto result = utils::db::sqlite::db_select{*db_, source_table} .column("source_path") .where("api_path") .equals("/") .go(); - std::optional row; + std::optional row; if (result.get_row(row) && row.has_value()) { source_path = row->get_column("source_path").get_value(); } else { - auto ins_res = db::db_insert{*db_, source_table} + auto ins_res = utils::db::sqlite::db_insert{*db_, source_table} .column_value("api_path", "/") .column_value("source_path", cfg.path) .go(); @@ -1090,13 +1092,13 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/, source_path = cfg.path; } - result = db::db_select{*db_, directory_table} + result = utils::db::sqlite::db_select{*db_, directory_table} .column("api_path") .where("source_path") .equals(source_path) .go(); if (not result.has_row()) { - auto ins_res = db::db_insert{*db_, directory_table} + auto ins_res = utils::db::sqlite::db_insert{*db_, directory_table} .column_value("source_path", source_path) .column_value("api_path", "/") .go(); diff --git a/repertory/repertory_test/src/database_test.cpp b/repertory/repertory_test/src/database_test.cpp index 89226fb3..e55a9bad 100644 --- a/repertory/repertory_test/src/database_test.cpp +++ b/repertory/repertory_test/src/database_test.cpp @@ -32,7 +32,7 @@ namespace repertory { class database_test : public ::testing::Test { public: static console_consumer cs; - db::db3_t db3; + utils::db::sqlite::db3_t db3; void SetUp() override { event_system::instance().start(); @@ -54,7 +54,7 @@ public: }; static void common_insert(sqlite3 &db, bool dump = false) { - auto query = db::db_insert{db, "table"} + auto query = utils::db::sqlite::db_insert{db, "table"} .column_value("column1", "test0") .column_value("column2", "test1"); if (dump) { @@ -67,7 +67,7 @@ static void common_insert(sqlite3 &db, bool dump = false) { static void common_select(sqlite3 &db, std::string value1, std::string value2, bool dump = false) { - auto query = db::db_select{db, "table"}; + auto query = utils::db::sqlite::db_select{db, "table"}; if (dump) { std::cout << query.dump() << std::endl; } @@ -78,7 +78,7 @@ static void common_select(sqlite3 &db, std::string value1, std::string value2, std::size_t row_count{}; while (res.has_row()) { - std::optional row; + std::optional row; EXPECT_TRUE(res.get_row(row)); EXPECT_TRUE(row.has_value()); if (row.has_value()) { @@ -104,7 +104,7 @@ static void common_select(sqlite3 &db, std::string value1, std::string value2, static void common_delete(sqlite3 &db, bool dump = false) { { - auto query = db::db_delete{db, "table"}; + auto query = utils::db::sqlite::db_delete{db, "table"}; if (dump) { std::cout << query.dump() << std::endl; } @@ -114,7 +114,7 @@ static void common_delete(sqlite3 &db, bool dump = false) { } { - auto query = db::db_select{db, "table"}; + auto query = utils::db::sqlite::db_select{db, "table"}; auto res = query.go(); EXPECT_TRUE(res.ok()); @@ -128,14 +128,14 @@ static void common_delete(sqlite3 &db, bool dump = false) { } TEST_F(database_test, db_delete_query) { - auto query = db::db_delete{*db3.get(), "table"}; + auto query = utils::db::sqlite::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"} + auto query = utils::db::sqlite::db_delete{*db3.get(), "table"} .where("column1") .equals("test1") .and_() @@ -148,7 +148,7 @@ TEST_F(database_test, db_delete_where_query) { } TEST_F(database_test, db_insert_query) { - auto query = db::db_insert{*db3.get(), "table"} + auto query = utils::db::sqlite::db_insert{*db3.get(), "table"} .column_value("column1", "test9") .column_value("column2", "test9"); auto query_str = query.dump(); @@ -158,7 +158,7 @@ TEST_F(database_test, db_insert_query) { } TEST_F(database_test, db_insert_or_replace_query) { - auto query = db::db_insert{*db3.get(), "table"} + auto query = utils::db::sqlite::db_insert{*db3.get(), "table"} .or_replace() .column_value("column1", "test1") .column_value("column2", "test2"); @@ -170,14 +170,14 @@ TEST_F(database_test, db_insert_or_replace_query) { } TEST_F(database_test, db_select_query) { - auto query = db::db_select{*db3.get(), "table"}; + auto query = utils::db::sqlite::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"} + auto query = utils::db::sqlite::db_select{*db3.get(), "table"} .where("column1") .equals("test1") .and_() @@ -191,7 +191,7 @@ TEST_F(database_test, db_select_where_query) { TEST_F(database_test, db_select_where_with_group_query) { auto query = - db::db_select{*db3.get(), "table"} + utils::db::sqlite::db_select{*db3.get(), "table"} .group([](auto &grp) { grp.where("column1").equals("a").or_().where("column1").equals("b"); }) @@ -211,7 +211,7 @@ TEST_F(database_test, db_select_where_with_group_query) { } TEST_F(database_test, db_select_columns_query) { - auto query = db::db_select{*db3.get(), "table"} + auto query = utils::db::sqlite::db_select{*db3.get(), "table"} .column("column1") .column("column2") .where("column1") @@ -227,7 +227,7 @@ TEST_F(database_test, db_select_columns_query) { } TEST_F(database_test, db_update_query) { - auto query = db::db_update{*db3.get(), "table"} + auto query = utils::db::sqlite::db_update{*db3.get(), "table"} .column_value("column1", "moose") .where("column1") .equals("test1") @@ -253,7 +253,7 @@ TEST_F(database_test, insert_update_delete) { common_insert(*db3.get()); { - auto query = db::db_update{*db3.get(), "table"} + auto query = utils::db::sqlite::db_update{*db3.get(), "table"} .column_value("column1", "moose") .where("column1") .equals("test0"); @@ -271,7 +271,7 @@ TEST_F(database_test, insert_or_replace_and_delete) { common_insert(*db3.get()); { - auto query = db::db_insert{*db3.get(), "table"} + auto query = utils::db::sqlite::db_insert{*db3.get(), "table"} .or_replace() .column_value("column1", "test0") .column_value("column2", "moose");