BlockStorage/repertory
1
0
Fork 0
Code Issues 8 Pull Requests Releases 6 Wiki Activity

fix

Browse Source
This commit is contained in:
Scott E. Graves 2024-10-09 09:47:35 -05:00
parent 6a97ad664b
commit 9adec02640
6 changed files with 76 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
repertory/librepertory/include/file_manager/file_manager.hpp
View File

@ -452,7 +452,7 @@ private:
i_provider &provider_; i_provider &provider_;
private: private:
db::db3_t db_{nullptr}; utils::db::sqlite::db3_t db_{nullptr};
std::uint64_t next_handle_{0U}; std::uint64_t next_handle_{0U};
mutable std::recursive_mutex open_file_mtx_; mutable std::recursive_mutex open_file_mtx_;
std::unordered_map<std::string, std::shared_ptr<i_closeable_open_file>> std::unordered_map<std::string, std::shared_ptr<i_closeable_open_file>>

2
repertory/librepertory/include/providers/meta_db.hpp
View File

@ -39,7 +39,7 @@ public:
auto operator=(meta_db &&) -> meta_db & = delete; auto operator=(meta_db &&) -> meta_db & = delete;
private: private:
db::db3_t db_; utils::db::sqlite::db3_t db_;
constexpr static const auto table_name = "meta"; constexpr static const auto table_name = "meta";
private: private:

68
repertory/librepertory/src/file_manager/file_manager.cpp
View File

@ -119,13 +119,13 @@ file_manager::file_manager(app_config &config, i_provider &provider)
for (auto &&create_item : sql_create_tables) { for (auto &&create_item : sql_create_tables) {
std::string err; std::string err;
if (not db::execute_sql(*db_, create_item.second, err)) { if (not utils::db::sqlite::execute_sql(*db_, create_item.second, err)) {
db_.reset(); db_.reset();
throw startup_exception(err); throw startup_exception(err);
} }
} }
db::set_journal_mode(*db_); utils::db::sqlite::set_journal_mode(*db_);
E_SUBSCRIBE_EXACT(file_upload_completed, E_SUBSCRIBE_EXACT(file_upload_completed,
[this](const file_upload_completed &completed) { [this](const file_upload_completed &completed) {
@ -354,10 +354,10 @@ auto file_manager::get_stored_downloads() const -> std::vector<json> {
std::vector<json> ret; std::vector<json> ret;
if (not provider_.is_direct_only()) { if (not provider_.is_direct_only()) {
auto result = db::db_select{*db_.get(), resume_table}.go(); auto result = utils::db::sqlite::db_select{*db_.get(), resume_table}.go();
while (result.has_row()) { while (result.has_row()) {
try { try {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (not result.get_row(row)) { if (not result.get_row(row)) {
continue; continue;
} }
@ -390,12 +390,12 @@ auto file_manager::handle_file_rename(const std::string &from_api_path,
source_path = upload_lookup_.at(from_api_path)->get_source_path(); source_path = upload_lookup_.at(from_api_path)->get_source_path();
} }
} else { } else {
auto result = db::db_select{*db_.get(), upload_table} auto result = utils::db::sqlite::db_select{*db_.get(), upload_table}
.column("source_path") .column("source_path")
.where("api_path") .where("api_path")
.equals(from_api_path) .equals(from_api_path)
.go(); .go();
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
should_upload = result.get_row(row) && row.has_value(); should_upload = result.get_row(row) && row.has_value();
if (should_upload && source_path.empty()) { if (should_upload && source_path.empty()) {
source_path = row->get_column("source_path").get_value<std::string>(); source_path = row->get_column("source_path").get_value<std::string>();
@ -438,7 +438,7 @@ auto file_manager::is_processing(const std::string &api_path) const -> bool {
} }
upload_lock.unlock(); upload_lock.unlock();
db::db_select query{*db_.get(), upload_table}; utils::db::sqlite::db_select query{*db_.get(), upload_table};
if (query.where("api_path").equals(api_path).go().has_row()) { if (query.where("api_path").equals(api_path).go().has_row()) {
return true; return true;
}; };
@ -521,7 +521,7 @@ void file_manager::queue_upload(const std::string &api_path,
remove_upload(api_path, true); remove_upload(api_path, true);
auto result = auto result =
db::db_insert{*db_.get(), upload_table} utils::db::sqlite::db_insert{*db_.get(), upload_table}
.or_replace() .or_replace()
.column_value("api_path", api_path) .column_value("api_path", api_path)
.column_value("date_time", .column_value("date_time",
@ -559,7 +559,7 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
remove_upload(api_path); remove_upload(api_path);
auto result = db::db_delete{*db_.get(), resume_table} auto result = utils::db::sqlite::db_delete{*db_.get(), resume_table}
.where("api_path") .where("api_path")
.equals(api_path) .equals(api_path)
.go(); .go();
@ -585,7 +585,7 @@ auto file_manager::remove_file(const std::string &api_path) -> api_error {
void file_manager::remove_resume(const std::string &api_path, void file_manager::remove_resume(const std::string &api_path,
const std::string &source_path) { const std::string &source_path) {
auto result = db::db_delete{*db_.get(), resume_table} auto result = utils::db::sqlite::db_delete{*db_.get(), resume_table}
.where("api_path") .where("api_path")
.equals(api_path) .equals(api_path)
.go(); .go();
@ -613,7 +613,7 @@ void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
lock = std::make_unique<mutex_lock>(upload_mtx_); lock = std::make_unique<mutex_lock>(upload_mtx_);
} }
auto result = db::db_delete{*db_.get(), upload_table} auto result = utils::db::sqlite::db_delete{*db_.get(), upload_table}
.where("api_path") .where("api_path")
.equals(api_path) .equals(api_path)
.go(); .go();
@ -623,7 +623,7 @@ void file_manager::remove_upload(const std::string &api_path, bool no_lock) {
"failed to remove from upload table"); "failed to remove from upload table");
} }
result = db::db_delete{*db_.get(), upload_active_table} result = utils::db::sqlite::db_delete{*db_.get(), upload_active_table}
.where("api_path") .where("api_path")
.equals(api_path) .equals(api_path)
.go(); .go();
@ -820,10 +820,11 @@ void file_manager::start() {
std::vector<active_item> active_items{}; std::vector<active_item> active_items{};
auto result = db::db_select{*db_.get(), upload_active_table}.go(); auto result =
utils::db::sqlite::db_select{*db_.get(), upload_active_table}.go();
while (result.has_row()) { while (result.has_row()) {
try { try {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
active_items.emplace_back(active_item{ active_items.emplace_back(active_item{
row->get_column("api_path").get_value<std::string>(), row->get_column("api_path").get_value<std::string>(),
@ -840,14 +841,14 @@ void file_manager::start() {
} }
active_items.clear(); active_items.clear();
result = db::db_select{*db_.get(), resume_table}.go(); result = utils::db::sqlite::db_select{*db_.get(), resume_table}.go();
if (not result.ok()) { if (not result.ok()) {
return; return;
} }
while (result.has_row()) { while (result.has_row()) {
try { try {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (not(result.get_row(row) && row.has_value())) { if (not(result.get_row(row) && row.has_value())) {
return; return;
} }
@ -957,7 +958,7 @@ void file_manager::store_resume(const i_open_file &file) {
return; return;
} }
auto result = db::db_insert{*db_.get(), resume_table} auto result = utils::db::sqlite::db_insert{*db_.get(), resume_table}
.or_replace() .or_replace()
.column_value("api_path", file.get_api_path()) .column_value("api_path", file.get_api_path())
.column_value("data", create_resume_entry(file).dump()) .column_value("data", create_resume_entry(file).dump())
@ -992,7 +993,7 @@ void file_manager::swap_renamed_items(std::string from_api_path,
return; return;
} }
auto result = db::db_update{*db_.get(), resume_table} auto result = utils::db::sqlite::db_update{*db_.get(), resume_table}
.column_value("api_path", to_api_path) .column_value("api_path", to_api_path)
.where("api_path") .where("api_path")
.equals(from_api_path) .equals(from_api_path)
@ -1014,10 +1015,11 @@ void file_manager::upload_completed(const file_upload_completed &evt) {
if (not utils::string::to_bool(evt.get_cancelled().get<std::string>())) { if (not utils::string::to_bool(evt.get_cancelled().get<std::string>())) {
auto err = api_error_from_string(evt.get_result().get<std::string>()); auto err = api_error_from_string(evt.get_result().get<std::string>());
if (err == api_error::success) { if (err == api_error::success) {
auto result = db::db_delete{*db_.get(), upload_active_table} auto result =
.where("api_path") utils::db::sqlite::db_delete{*db_.get(), upload_active_table}
.equals(evt.get_api_path().get<std::string>()) .where("api_path")
.go(); .equals(evt.get_api_path().get<std::string>())
.go();
if (not result.ok()) { if (not result.ok()) {
utils::error::raise_api_path_error( utils::error::raise_api_path_error(
function_name, evt.get_api_path().get<std::string>(), function_name, evt.get_api_path().get<std::string>(),
@ -1062,12 +1064,12 @@ void file_manager::upload_handler() {
} }
if (upload_lookup_.size() < config_.get_max_upload_count()) { if (upload_lookup_.size() < config_.get_max_upload_count()) {
auto result = db::db_select{*db_.get(), upload_table} auto result = utils::db::sqlite::db_select{*db_.get(), upload_table}
.order_by("api_path", true) .order_by("api_path", true)
.limit(1) .limit(1)
.go(); .go();
try { try {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
auto api_path = row->get_column("api_path").get_value<std::string>(); auto api_path = row->get_column("api_path").get_value<std::string>();
auto source_path = auto source_path =
@ -1088,15 +1090,17 @@ void file_manager::upload_handler() {
upload_lookup_[fsi.api_path] = upload_lookup_[fsi.api_path] =
std::make_unique<upload>(fsi, provider_); std::make_unique<upload>(fsi, provider_);
auto del_res = db::db_delete{*db_.get(), upload_table} auto del_res =
.where("api_path") utils::db::sqlite::db_delete{*db_.get(), upload_table}
.equals(api_path) .where("api_path")
.go(); .equals(api_path)
.go();
if (del_res.ok()) { if (del_res.ok()) {
auto ins_res = db::db_insert{*db_.get(), upload_active_table} auto ins_res =
.column_value("api_path", api_path) utils::db::sqlite::db_insert{*db_.get(), upload_active_table}
.column_value("source_path", source_path) .column_value("api_path", api_path)
.go(); .column_value("source_path", source_path)
.go();
if (not ins_res.ok()) { if (not ins_res.ok()) {
utils::error::raise_api_path_error( utils::error::raise_api_path_error(
function_name, api_path, source_path, function_name, api_path, source_path,

40
repertory/librepertory/src/providers/meta_db.cpp
View File

@ -60,28 +60,28 @@ meta_db::meta_db(const app_config &cfg) {
"source_path TEXT" "source_path TEXT"
");"; ");";
std::string err; std::string err;
if (not db::execute_sql(*db_, create, err)) { if (not utils::db::sqlite::execute_sql(*db_, create, err)) {
utils::error::raise_error(function_name, utils::error::raise_error(function_name,
"failed to create db|" + db_path + '|' + err); "failed to create db|" + db_path + '|' + err);
db_.reset(); db_.reset();
return; return;
} }
db::set_journal_mode(*db_); utils::db::sqlite::set_journal_mode(*db_);
} }
meta_db::~meta_db() { db_.reset(); } meta_db::~meta_db() { db_.reset(); }
auto meta_db::get_api_path(const std::string &source_path, auto meta_db::get_api_path(const std::string &source_path,
std::string &api_path) -> api_error { std::string &api_path) -> api_error {
auto result = db::db_select{*db_, table_name} auto result = utils::db::sqlite::db_select{*db_, table_name}
.column("api_path") .column("api_path")
.where("source_path") .where("source_path")
.equals(source_path) .equals(source_path)
.limit(1) .limit(1)
.go(); .go();
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
api_path = row->get_column("api_path").get_value<std::string>(); api_path = row->get_column("api_path").get_value<std::string>();
return api_error::success; return api_error::success;
@ -93,9 +93,10 @@ auto meta_db::get_api_path(const std::string &source_path,
auto meta_db::get_api_path_list() -> std::vector<std::string> { auto meta_db::get_api_path_list() -> std::vector<std::string> {
std::vector<std::string> ret{}; std::vector<std::string> ret{};
auto result = db::db_select{*db_, table_name}.column("api_path").go(); auto result =
utils::db::sqlite::db_select{*db_, table_name}.column("api_path").go();
while (result.has_row()) { while (result.has_row()) {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
ret.push_back(row->get_column("api_path").get_value<std::string>()); ret.push_back(row->get_column("api_path").get_value<std::string>());
} }
@ -110,7 +111,7 @@ auto meta_db::get_item_meta(const std::string &api_path,
static_cast<const char *>(__FUNCTION__), static_cast<const char *>(__FUNCTION__),
}; };
auto result = db::db_select{*db_, table_name} auto result = utils::db::sqlite::db_select{*db_, table_name}
.column("*") .column("*")
.where("api_path") .where("api_path")
.equals(api_path) .equals(api_path)
@ -121,7 +122,7 @@ auto meta_db::get_item_meta(const std::string &api_path,
} }
try { try {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
meta = json::parse(row->get_column("data").get_value<std::string>()) meta = json::parse(row->get_column("data").get_value<std::string>())
.get<api_meta_map>(); .get<api_meta_map>();
@ -150,7 +151,7 @@ auto meta_db::get_item_meta(const std::string &api_path, const std::string &key,
static_cast<const char *>(__FUNCTION__), static_cast<const char *>(__FUNCTION__),
}; };
auto result = db::db_select{*db_, table_name} auto result = utils::db::sqlite::db_select{*db_, table_name}
.column("*") .column("*")
.where("api_path") .where("api_path")
.equals(api_path) .equals(api_path)
@ -161,7 +162,7 @@ auto meta_db::get_item_meta(const std::string &api_path, const std::string &key,
} }
try { try {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
value = value =
key == META_SOURCE key == META_SOURCE
@ -195,13 +196,13 @@ auto meta_db::get_pinned_files() const -> std::vector<std::string> {
std::vector<std::string> ret{}; std::vector<std::string> ret{};
try { try {
auto result = db::db_select{*db_, table_name} auto result = utils::db::sqlite::db_select{*db_, table_name}
.column("api_path") .column("api_path")
.where("pinned") .where("pinned")
.equals(1) .equals(1)
.go(); .go();
while (result.has_row()) { while (result.has_row()) {
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
ret.emplace_back(row->get_column("api_path").get_value<std::string>()); ret.emplace_back(row->get_column("api_path").get_value<std::string>());
} }
@ -221,10 +222,11 @@ auto meta_db::get_total_item_count() const -> std::uint64_t {
std::uint64_t ret{}; std::uint64_t ret{};
try { try {
auto result = auto result = utils::db::sqlite::db_select{*db_, table_name}
db::db_select{*db_, table_name}.count("api_path", "count").go(); .count("api_path", "count")
.go();
std::optional<db::db_select::row> row; std::optional<utils::db::sqlite::db_select::row> row;
if (result.get_row(row) && row.has_value()) { if (result.get_row(row) && row.has_value()) {
ret = static_cast<std::uint64_t>( ret = static_cast<std::uint64_t>(
row->get_column("count").get_value<std::int64_t>()); row->get_column("count").get_value<std::int64_t>());
@ -242,8 +244,10 @@ void meta_db::remove_api_path(const std::string &api_path) {
static_cast<const char *>(__FUNCTION__), static_cast<const char *>(__FUNCTION__),
}; };
auto result = auto result = utils::db::sqlite::db_delete{*db_, table_name}
db::db_delete{*db_, table_name}.where("api_path").equals(api_path).go(); .where("api_path")
.equals(api_path)
.go();
if (not result.ok()) { if (not result.ok()) {
utils::error::raise_api_path_error( utils::error::raise_api_path_error(
function_name, api_path, result.get_error(), "failed to remove meta"); function_name, api_path, result.get_error(), "failed to remove meta");
@ -307,7 +311,7 @@ auto meta_db::update_item_meta(const std::string &api_path,
meta.erase(META_PINNED); meta.erase(META_PINNED);
meta.erase(META_SOURCE); meta.erase(META_SOURCE);
auto result = db::db_insert{*db_, table_name} auto result = utils::db::sqlite::db_insert{*db_, table_name}
.or_replace() .or_replace()
.column_value("api_path", api_path) .column_value("api_path", api_path)
.column_value("data", nlohmann::json(meta).dump()) .column_value("data", nlohmann::json(meta).dump())

16
support/include/utils/db/sqlite/db_where_limit_t.hpp
View File

@ -111,7 +111,7 @@ struct db_comp_next_limit_t final {
using wn_t = db_where_next_limit_t<db_comp_next_limit_t, ctx_t, op_t, w_t>; using wn_t = db_where_next_limit_t<db_comp_next_limit_t, ctx_t, op_t, w_t>;
[[nodiscard]] auto create(std::string operation, db::db_types_t value) { [[nodiscard]] auto create(std::string operation, db_types_t value) {
owner->actions.emplace_back(db_comp_data_t{ owner->actions.emplace_back(db_comp_data_t{
column_name, column_name,
operation, operation,
@ -125,19 +125,19 @@ struct db_comp_next_limit_t final {
}; };
} }
auto equals(db::db_types_t value) -> wn_t { return create("=", value); }; auto equals(db_types_t value) -> wn_t { return create("=", value); };
auto gt(db::db_types_t value) -> wn_t { return create(">", value); } auto gt(db_types_t value) -> wn_t { return create(">", value); }
auto gte(db::db_types_t value) -> wn_t { return create(">=", value); } auto gte(db_types_t value) -> wn_t { return create(">=", value); }
auto like(db::db_types_t value) -> wn_t { return create("LIKE", value); } auto like(db_types_t value) -> wn_t { return create("LIKE", value); }
auto lt(db::db_types_t value) -> wn_t { return create("<", value); } auto lt(db_types_t value) -> wn_t { return create("<", value); }
auto lte(db::db_types_t value) -> wn_t { return create("<=", value); } auto lte(db_types_t value) -> wn_t { return create("<=", value); }
auto not_equals(db::db_types_t value) -> wn_t { return create("!=", value); }; auto not_equals(db_types_t value) -> wn_t { return create("!=", value); };
}; };
template <typename ctx_t, typename op_t> struct db_where_with_limit_t final { template <typename ctx_t, typename op_t> struct db_where_with_limit_t final {

16
support/include/utils/db/sqlite/db_where_t.hpp
View File

@ -95,7 +95,7 @@ struct db_comp_next_t final {
using wn_t = db_where_next_t<db_comp_next_t, ctx_t, op_t, w_t>; using wn_t = db_where_next_t<db_comp_next_t, ctx_t, op_t, w_t>;
[[nodiscard]] auto create(std::string operation, db::db_types_t value) { [[nodiscard]] auto create(std::string operation, db_types_t value) {
owner->actions.emplace_back(db_comp_data_t{ owner->actions.emplace_back(db_comp_data_t{
column_name, column_name,
operation, operation,
@ -109,19 +109,19 @@ struct db_comp_next_t final {
}; };
} }
auto equals(db::db_types_t value) -> wn_t { return create("=", value); }; auto equals(db_types_t value) -> wn_t { return create("=", value); };
auto gt(db::db_types_t value) -> wn_t { return create(">", value); } auto gt(db_types_t value) -> wn_t { return create(">", value); }
auto gte(db::db_types_t value) -> wn_t { return create(">=", value); } auto gte(db_types_t value) -> wn_t { return create(">=", value); }
auto like(db::db_types_t value) -> wn_t { return create("LIKE", value); } auto like(db_types_t value) -> wn_t { return create("LIKE", value); }
auto lt(db::db_types_t value) -> wn_t { return create("<", value); } auto lt(db_types_t value) -> wn_t { return create("<", value); }
auto lte(db::db_types_t value) -> wn_t { return create("<=", value); } auto lte(db_types_t value) -> wn_t { return create("<=", value); }
auto not_equals(db::db_types_t value) -> wn_t { return create("!=", value); }; auto not_equals(db_types_t value) -> wn_t { return create("!=", value); };
}; };
template <typename ctx_t, typename op_t> struct db_where_t final { template <typename ctx_t, typename op_t> struct db_where_t final {