rusty-donkey/heave
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: rewrite mapping closures for sqlite errors

Browse Source
This commit is contained in:
davidemazzocchi
2026-02-27 10:10:43 +01:00
parent feecaea417
commit dd259fcbe7
6 changed files with 22 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
01.workspace/heave/src/fun/sqlite_init_db.rs
View File

@@ -26,9 +26,9 @@ pub fn run(path: &path::Path) -> result::Result<(), FailedTo> {
CREATE INDEX IF NOT EXISTS attribute_entity_id ON attribute (entity_id);
"#;
let connection = Connection::open(path)
.map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
.map_err(sqlite::FailedTo::OpenConnection)?;
connection
.execute_batch(init_statement)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteBatch(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteBatch)?;
Ok(())
}

4
01.workspace/heave/src/fun/sqlite_load_attributes.rs
View File

@@ -17,10 +17,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(|sqlite_error| sqlite::FailedTo::PrepareStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::PrepareStatement)?;
let attributes = select_attributes_statement
.query_map([&entity.id], sqlite::map::row_to_attribute)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteQuery)?;
for attribute in attributes {
let attribute = attribute.map_err(|_| FailedTo::MapAttribute)?;
entity.attributes.insert(attribute.id.clone(), attribute);

8
01.workspace/heave/src/fun/sqlite_load_by_class.rs
View File

@@ -9,17 +9,17 @@ const SELECT_ENTITY_BY_CLASS: &str = r#"
pub fn run(path: &path::Path, entity_class: &str) -> Result<Vec<Entity>, FailedTo> {
let mut entities = Vec::<Entity>::new();
let mut connection = Connection::open(path)
.map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
.map_err(sqlite::FailedTo::OpenConnection)?;
let mut transaction = connection
.transaction()
.map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
.map_err(sqlite::FailedTo::BeginTransaction)?;
transaction.set_drop_behavior(DropBehavior::Commit);
let mut statement = transaction
.prepare(SELECT_ENTITY_BY_CLASS)
.map_err(|sqlite_error| sqlite::FailedTo::PrepareStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::PrepareStatement)?;
let result = statement
.query_map([entity_class], sqlite::map::row_to_entity)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteQuery)?;
for entity in result {
let mut entity = entity.map_err(|_| FailedTo::MapEntity)?;
sqlite::load::attributes(&transaction, &mut entity)?;

8
01.workspace/heave/src/fun/sqlite_load_by_filter.rs
View File

@@ -4,20 +4,20 @@ use rusqlite::*;
pub fn run(path: &path::Path, filter: &Filter) -> Result<Vec<Entity>, FailedTo> {
let mut entities = Vec::<Entity>::new();
let mut connection = Connection::open(path)
.map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
.map_err(sqlite::FailedTo::OpenConnection)?;
let mut transaction = connection
.transaction()
.map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
.map_err(sqlite::FailedTo::BeginTransaction)?;
transaction.set_drop_behavior(DropBehavior::Commit);
let select_entity_by_filter = sqlite::build::statement(filter)?;
let params = sqlite::build::params(filter)?;
let params: Vec<&dyn ToSql> = params.iter().map(|p| p.as_ref() as &dyn ToSql).collect();
let mut statement = transaction
.prepare(&select_entity_by_filter)
.map_err(|sqlite_error| sqlite::FailedTo::PrepareStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::PrepareStatement)?;
let result = statement
.query_map(&params[..], sqlite::map::row_to_entity)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteQuery)?;
for entity in result {
let mut entity = entity.map_err(|_| FailedTo::MapEntity)?;
sqlite::load::attributes(&transaction, &mut entity)?;

6
01.workspace/heave/src/fun/sqlite_load_by_id.rs
View File

@@ -8,15 +8,15 @@ const SELECT_ENTITY_BY_ID: &str = r#"
pub fn run(path: &path::Path, entity_id: &str) -> Result<Option<Entity>, FailedTo> {
let mut connection = Connection::open(path)
.map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
.map_err(sqlite::FailedTo::OpenConnection)?;
let mut transaction = connection
.transaction()
.map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
.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(|sqlite_error| sqlite::FailedTo::ExecuteQuery(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteQuery)?;
if let Some(ref mut entity) = entity {
sqlite::load::attributes(&transaction, entity)?;
entity.state = EntityState::Loaded;

14
01.workspace/heave/src/fun/sqlite_persist_catalog.rs
View File

@@ -38,7 +38,7 @@ fn write_attribute(
INSERT_ATTRIBUTE_STATEMENT_TEMPLATE.replace("{column}", column);
transaction
.execute(&insert_attribute_statement, attribute_values)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteStatement)?;
Ok(())
}
@@ -46,7 +46,7 @@ fn delete_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result
let entity_id = [&entity.id];
transaction
.execute(DELETE_ENTITY_STATEMENT, entity_id)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteStatement)?;
Ok(())
}
@@ -55,10 +55,10 @@ fn write_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result<
let entity_values = (&entity.id, &entity.class, &entity.subclass, entity.ref_date);
transaction
.execute(DELETE_ENTITY_STATEMENT, entity_id)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteStatement)?;
transaction
.execute(INSERT_ENTITY_STATEMENT, entity_values)
.map_err(|sqlite_error| sqlite::FailedTo::ExecuteStatement(sqlite_error))?;
.map_err(sqlite::FailedTo::ExecuteStatement)?;
for attribute in entity.attributes.values() {
write_attribute(attribute, entity, transaction)?;
}
@@ -67,10 +67,10 @@ fn write_entity(entity: &Entity, transaction: &rusqlite::Transaction) -> Result<
pub fn run(path: &path::Path, items: &HashMap<String, Entity>) -> result::Result<(), FailedTo> {
let mut connection = Connection::open(path)
.map_err(|sqlite_error| sqlite::FailedTo::OpenConnection(sqlite_error))?;
.map_err(sqlite::FailedTo::OpenConnection)?;
let transaction = connection
.transaction()
.map_err(|sqlite_error| sqlite::FailedTo::BeginTransaction(sqlite_error))?;
.map_err(sqlite::FailedTo::BeginTransaction)?;
for entity in items.values().filter(|item| {
item.state == EntityState::New
|| item.state == EntityState::Updated
@@ -84,6 +84,6 @@ pub fn run(path: &path::Path, items: &HashMap<String, Entity>) -> result::Result
}
transaction
.commit()
.map_err(|sqlite_error| sqlite::FailedTo::CommitTransaction(sqlite_error))?;
.map_err(sqlite::FailedTo::CommitTransaction)?;
Ok(())
}