From 4c95b709c05778f7916ae139fda009f64bcc1d75 Mon Sep 17 00:00:00 2001 From: davidemazzocchi Date: Mon, 6 Oct 2025 07:26:14 +0200 Subject: [PATCH] refactor: group sqlite-related errors under one enum --- 01.workspace/heave/src/fun/sqlite_init_db.rs | 4 ++-- .../heave/src/fun/sqlite_load_attributes.rs | 4 ++-- .../heave/src/fun/sqlite_load_by_class.rs | 8 ++++---- 01.workspace/heave/src/fun/sqlite_load_by_id.rs | 6 +++--- .../heave/src/fun/sqlite_persist_catalog.rs | 12 ++++++------ 01.workspace/heave/src/lib.rs | 1 + 01.workspace/heave/src/str/failed_to.rs | 16 +++++++++------- 01.workspace/heave/src/str/mod.rs | 1 + 01.workspace/heave/src/str/sqlite_failed_to.rs | 10 ++++++++++ 9 files changed, 38 insertions(+), 24 deletions(-) create mode 100644 01.workspace/heave/src/str/sqlite_failed_to.rs diff --git a/01.workspace/heave/src/fun/sqlite_init_db.rs b/01.workspace/heave/src/fun/sqlite_init_db.rs index 7e4360d..7a4ebe6 100644 --- a/01.workspace/heave/src/fun/sqlite_init_db.rs +++ b/01.workspace/heave/src/fun/sqlite_init_db.rs @@ -22,10 +22,10 @@ pub fn run(path: &path::Path) -> result::Result<(), FailedTo> { CREATE INDEX IF NOT EXISTS entity_class ON entity (class); CREATE INDEX IF NOT EXISTS attribute_id ON attribute (id); "#; - let connection = Connection::open(path).map_err(|_| FailedTo::OpenSQLiteConnection)?; + let connection = Connection::open(path).map_err(|_| sqlite::FailedTo::OpenConnection)?; connection .execute_batch(init_statement) - .map_err(|_| FailedTo::ExecuteSQLiteBatch)?; + .map_err(|_| sqlite::FailedTo::ExecuteBatch)?; Ok(()) } diff --git a/01.workspace/heave/src/fun/sqlite_load_attributes.rs b/01.workspace/heave/src/fun/sqlite_load_attributes.rs index f1cfbce..4b7cee0 100644 --- a/01.workspace/heave/src/fun/sqlite_load_attributes.rs +++ b/01.workspace/heave/src/fun/sqlite_load_attributes.rs @@ -9,10 +9,10 @@ const SELECT_ATTRIBUTE_BY_FK: &str = r#" pub fn run(transaction: &Transaction, entity: &mut Entity) -> Result<(), FailedTo> { let mut select_attributes_statement = transaction .prepare(SELECT_ATTRIBUTE_BY_FK) - .map_err(|_| FailedTo::PrepareSQLiteStatement)?; + .map_err(|_| sqlite::FailedTo::PrepareStatement)?; let attributes = select_attributes_statement .query_map([&entity.id], sqlite::map::row_to_attribute) - .map_err(|_| FailedTo::ExecuteSQLiteQuery)?; + .map_err(|_| sqlite::FailedTo::ExecuteQuery)?; for attribute in attributes { let attribute = attribute.map_err(|_| FailedTo::MapAttribute)?; entity.attributes.insert(attribute.id.clone(), attribute); diff --git a/01.workspace/heave/src/fun/sqlite_load_by_class.rs b/01.workspace/heave/src/fun/sqlite_load_by_class.rs index 16ec63d..81fc509 100644 --- a/01.workspace/heave/src/fun/sqlite_load_by_class.rs +++ b/01.workspace/heave/src/fun/sqlite_load_by_class.rs @@ -8,17 +8,17 @@ const SELECT_ENTITY_BY_CLASS: &str = r#" pub fn run(path: &path::Path, entity_class: &str) -> Result, FailedTo> { let mut entities = Vec::::new(); - let mut connection = Connection::open(path).map_err(|_| FailedTo::OpenSQLiteConnection)?; + let mut connection = Connection::open(path).map_err(|_| sqlite::FailedTo::OpenConnection)?; let mut transaction = connection .transaction() - .map_err(|_| FailedTo::BeginSQLiteTransaction)?; + .map_err(|_| sqlite::FailedTo::BeginTransaction)?; transaction.set_drop_behavior(DropBehavior::Commit); let mut statement = transaction .prepare(SELECT_ENTITY_BY_CLASS) - .map_err(|_| FailedTo::PrepareSQLiteStatement)?; + .map_err(|_| sqlite::FailedTo::PrepareStatement)?; let result = statement .query_map([entity_class], sqlite::map::row_to_entity) - .map_err(|_| FailedTo::ExecuteSQLiteQuery)?; + .map_err(|_| sqlite::FailedTo::ExecuteQuery)?; for entity in result { let mut entity = entity.map_err(|_| FailedTo::MapEntity)?; sqlite::load::attributes(&transaction, &mut entity)?; diff --git a/01.workspace/heave/src/fun/sqlite_load_by_id.rs b/01.workspace/heave/src/fun/sqlite_load_by_id.rs index 15145b7..9ff0501 100644 --- a/01.workspace/heave/src/fun/sqlite_load_by_id.rs +++ b/01.workspace/heave/src/fun/sqlite_load_by_id.rs @@ -7,15 +7,15 @@ const SELECT_ENTITY_BY_ID: &str = r#" "#; pub fn run(path: &path::Path, entity_id: &str) -> Result, FailedTo> { - let mut connection = Connection::open(path).map_err(|_| FailedTo::OpenSQLiteConnection)?; + let mut connection = Connection::open(path).map_err(|_| sqlite::FailedTo::OpenConnection)?; let mut transaction = connection .transaction() - .map_err(|_| FailedTo::BeginSQLiteTransaction)?; + .map_err(|_| sqlite::FailedTo::BeginTransaction)?; transaction.set_drop_behavior(DropBehavior::Commit); let mut entity = transaction .query_one(SELECT_ENTITY_BY_ID, [entity_id], sqlite::map::row_to_entity) .optional() - .map_err(|_| FailedTo::ExecuteSQLiteQuery)?; + .map_err(|_| sqlite::FailedTo::ExecuteQuery)?; if let Some(ref mut entity) = entity { sqlite::load::attributes(&transaction, entity)?; entity.state = EntityState::Loaded; diff --git a/01.workspace/heave/src/fun/sqlite_persist_catalog.rs b/01.workspace/heave/src/fun/sqlite_persist_catalog.rs index 2ff1a16..176f50a 100644 --- a/01.workspace/heave/src/fun/sqlite_persist_catalog.rs +++ b/01.workspace/heave/src/fun/sqlite_persist_catalog.rs @@ -37,7 +37,7 @@ fn write_attribute( INSERT_ATTRIBUTE_STATEMENT_TEMPLATE.replace("{column}", column); transaction .execute(&insert_attribute_statement, attribute_values) - .map_err(|_| FailedTo::ExecuteSQLiteStatement)?; + .map_err(|_| sqlite::FailedTo::ExecuteStatement)?; Ok(()) } @@ -46,10 +46,10 @@ fn write_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result< let entity_values = (&entity.id, &entity.class, entity.ref_date); transaction .execute(DELETE_ENTITY_STATEMENT, entity_id) - .map_err(|_| FailedTo::ExecuteSQLiteStatement)?; + .map_err(|_| sqlite::FailedTo::ExecuteStatement)?; transaction .execute(INSERT_ENTITY_STATEMENT, entity_values) - .map_err(|_| FailedTo::ExecuteSQLiteStatement)?; + .map_err(|_| sqlite::FailedTo::ExecuteStatement)?; for attribute in entity.attributes.values() { write_attribute(attribute, entity, transaction)?; } @@ -57,10 +57,10 @@ fn write_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result< } pub fn run(path: &path::Path, catalog: &Catalog) -> result::Result<(), FailedTo> { - let mut connection = Connection::open(path).map_err(|_| FailedTo::OpenSQLiteConnection)?; + let mut connection = Connection::open(path).map_err(|_| sqlite::FailedTo::OpenConnection)?; let transaction = connection .transaction() - .map_err(|_| FailedTo::BeginSQLiteTransaction)?; + .map_err(|_| sqlite::FailedTo::BeginTransaction)?; for entity in catalog .items .values() @@ -70,6 +70,6 @@ pub fn run(path: &path::Path, catalog: &Catalog) -> result::Result<(), FailedTo> } transaction .commit() - .map_err(|_| FailedTo::CommitSQLiteTransaction)?; + .map_err(|_| sqlite::FailedTo::CommitTransaction)?; Ok(()) } diff --git a/01.workspace/heave/src/lib.rs b/01.workspace/heave/src/lib.rs index 47219cc..1bfe918 100644 --- a/01.workspace/heave/src/lib.rs +++ b/01.workspace/heave/src/lib.rs @@ -16,6 +16,7 @@ pub use crate::str::value::E as Value; pub use crate::trt::eav::T as EAV; mod sqlite { + pub use crate::str::sqlite_failed_to::E as FailedTo; pub mod init { pub use crate::fun::sqlite_init_db::run as db; } diff --git a/01.workspace/heave/src/str/failed_to.rs b/01.workspace/heave/src/str/failed_to.rs index 6de511a..373b1b5 100644 --- a/01.workspace/heave/src/str/failed_to.rs +++ b/01.workspace/heave/src/str/failed_to.rs @@ -1,15 +1,17 @@ +use crate::*; + #[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Clone, Copy, Hash)] pub enum E { - BeginSQLiteTransaction, - CommitSQLiteTransaction, - ExecuteSQLiteBatch, - ExecuteSQLiteQuery, - ExecuteSQLiteStatement, InitDatabase, LoadFromDB, MapAttribute, MapEntity, - OpenSQLiteConnection, PersistCatalog, - PrepareSQLiteStatement, + SQLite(sqlite::FailedTo), +} + +impl From for E { + fn from(value: sqlite::FailedTo) -> Self { + Self::SQLite(value) + } } diff --git a/01.workspace/heave/src/str/mod.rs b/01.workspace/heave/src/str/mod.rs index b46553f..bfe57fe 100644 --- a/01.workspace/heave/src/str/mod.rs +++ b/01.workspace/heave/src/str/mod.rs @@ -3,4 +3,5 @@ pub mod catalog; pub mod entity; pub mod entity_state; pub mod failed_to; +pub mod sqlite_failed_to; pub mod value; diff --git a/01.workspace/heave/src/str/sqlite_failed_to.rs b/01.workspace/heave/src/str/sqlite_failed_to.rs new file mode 100644 index 0000000..e760b44 --- /dev/null +++ b/01.workspace/heave/src/str/sqlite_failed_to.rs @@ -0,0 +1,10 @@ +#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Clone, Copy, Hash)] +pub enum E { + BeginTransaction, + CommitTransaction, + ExecuteBatch, + ExecuteQuery, + ExecuteStatement, + OpenConnection, + PrepareStatement, +}