refactor: improve code formatting and readability in SQL and function calls

src/db.rs

@@ -93,7 +93,13 @@ pub fn update_item(conn: &Connection, item: Item) -> Result<()> {
     debug!("DB: Updating item: {:?}", item);
     conn.execute(
         "UPDATE items SET size=?2, compression=?3, digest_type=?4, digest_value=?5 WHERE id=?1",
-        params![item.id, item.size, item.compression, item.digest_type, item.digest_value],
+        params![
+            item.id,
+            item.size,
+            item.compression,
+            item.digest_type,
+            item.digest_value
+        ],
     )?;
     Ok(())
 }
@@ -444,3 +450,16 @@ pub fn get_item_meta_name(conn: &Connection, item: &Item, name: String) -> Resul
         None => Ok(None),
     }
 }
+
+pub fn get_item_meta_value(conn: &Connection, item: &Item, name: String) -> Result<Option<String>> {
+    debug!("DB: Getting item meta value: {:?} {:?}", item, name);
+    let mut statement = conn
+        .prepare_cached("SELECT value FROM metas WHERE id=?1 AND name=?2")
+        .context("Problem preparing SQL statement")?;
+    let mut rows = statement.query(params![item.id, name])?;
+
+    match rows.next()? {
+        Some(row) => Ok(Some(row.get(0)?)),
+        None => Ok(None),
+    }
+}

src/main.rs

@@ -299,7 +299,9 @@ fn main() -> Result<(), Error> {
         KeepModes::Delete => {
             crate::modes::delete::mode_delete(&mut cmd, &args, ids, tags, &mut conn, data_path)?
         }
-        KeepModes::Status => crate::modes::status::mode_status(&mut cmd, &args, data_path, db_path)?,
+        KeepModes::Status => {
+            crate::modes::status::mode_status(&mut cmd, &args, data_path, db_path)?
+        }
         _ => todo!(),
     }
 

src/modes/common.rs

@@ -1,28 +1,28 @@
-use humansize::{BINARY, FormatSizeOptions};
-use clap::Command;
-use log::debug;
-use prettytable::format::TableFormat;
-use clap::error::ErrorKind;
-use regex::Regex;
-use std::collections::HashMap;
-use std::env;
-use rusqlite::Connection;
-use std::str::FromStr;
+use crate::Args;
+use crate::compression_engine::CompressionType;
 use crate::db::Item;
 use crate::db::Meta;
 use crate::db::store_meta;
-use crate::compression_engine::CompressionType;
 use crate::digest_engine::DigestType;
-use crate::Args;
+use clap::Command;
+use clap::error::ErrorKind;
+use humansize::{BINARY, FormatSizeOptions};
+use log::debug;
+use prettytable::format::TableFormat;
+use regex::Regex;
+use rusqlite::Connection;
+use std::collections::HashMap;
+use std::env;
+use std::str::FromStr;
 
 pub fn get_meta_from_env() -> HashMap<String, String> {
-    debug!("MAIN: Getting meta from KEEP_META_*");
+    debug!("COMMON: Getting meta from KEEP_META_*");
     let re = Regex::new(r"^KEEP_META_(.+)$").unwrap();
     let mut meta_env: HashMap<String, String> = HashMap::new();
     for (key, value) in env::vars() {
         if let Some(meta_name_caps) = re.captures(key.as_str()) {
             let name = String::from(meta_name_caps.get(1).unwrap().as_str());
-            debug!("MAIN: Found meta: {}={}", name.clone(), value.clone());
+            debug!("COMMON: Found meta: {}={}", name.clone(), value.clone());
             meta_env.insert(name, value.clone());
         }
     }
@@ -101,7 +101,6 @@ pub fn get_format_box_chars_no_border_line_separator() -> TableFormat {
         .build()
 }
 
-
 pub fn get_digest_type_meta(digest_type: DigestType) -> String {
     format!("digest_{}", digest_type.to_string().to_lowercase())
 }
@@ -136,7 +135,7 @@ pub fn cmd_args_digest_type(cmd: &mut Command, args: &Args) -> DigestType {
             ErrorKind::InvalidValue,
             format!("Unknown digest type: {}", digest_name),
         )
-            .exit();
+        .exit();
     }
 
     digest_type_opt.unwrap()
@@ -155,7 +154,7 @@ pub fn cmd_args_compression_type(cmd: &mut Command, args: &Args) -> CompressionT
             ErrorKind::InvalidValue,
             format!("Unknown compression type: {}", compression_name),
         )
-            .exit();
+        .exit();
     }
 
     compression_type_opt.unwrap()

src/modes/save.rs

@@ -1,5 +1,5 @@
+use anyhow::{Context, Result, anyhow};
 use gethostname::gethostname;
-use anyhow::{anyhow, Context, Result};
 use is_terminal::IsTerminal;
 use std::collections::HashMap;
 use std::io::{self, Read, Write};
@@ -13,7 +13,9 @@ use std::path::PathBuf;
 use crate::compression_engine::get_compression_engine;
 use crate::db::{self};
 use crate::digest_engine::get_digest_engine;
-use crate::modes::common::{get_meta_from_env, store_item_digest_value, cmd_args_compression_type, cmd_args_digest_type};
+use crate::modes::common::{
+    cmd_args_compression_type, cmd_args_digest_type, get_meta_from_env, store_item_digest_value,
+};
 use chrono::Utc;
 
 pub fn mode_save(
@@ -143,15 +145,11 @@ pub fn mode_save(
     stdout.flush()?;
     item_out.flush()?;
 
-    // Finalize the digest and log the result
     let digest = digest_engine.finalize()?;
     debug!("DIGEST: {}", digest);
-    item.digest_value = Some(digest.clone());
 
-    db::update_item(conn, item.clone())?;
-
-    // Save digest to meta using the common function
     store_item_digest_value(conn, item.clone(), digest_type, digest)?;
+    db::update_item(conn, item.clone())?;
 
     Ok(())
 }

src/modes/update.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use crate::compression_engine::{CompressionType, get_compression_engine};
 use crate::db;
 use crate::digest_engine;
-use crate::modes::common::store_item_digest_value;
+use crate::modes::common::{cmd_args_digest_type, get_digest_type_meta, store_item_digest_value};
 use clap::Command;
 use clap::error::ErrorKind;
 use log::{debug, info};
@@ -67,13 +67,11 @@ pub fn mode_update(
         }
     }
 
-    if item.digest_value.is_none() {
-        let digest_type = digest_engine::DigestType::from_str(&item.digest_type.clone())?;
-
-        if digest_type != digest_engine::DigestType::None {
-            info!("Updating unknown digest value");
-        }
+    let digest_type = cmd_args_digest_type(cmd, args);
+    let digest_meta = get_digest_type_meta(digest_type.clone());
+    let digest_value = db::get_item_meta_value(&conn, &item, digest_meta)?;
 
+    if digest_value.is_none() || digest_value.unwrap().is_empty() {
         let item_file_metadata = item_path.metadata();
 
         if item_file_metadata.is_ok() {
@@ -97,10 +95,6 @@ pub fn mode_update(
             let digest_value = digest_engine.finalize()?;
             debug!("DIGEST: {}", digest_value);
 
-            // Update item with new digest value
-            item.digest_value = Some(digest_value.clone());
-            db::update_item(conn, item.clone())?;
-
             // Save digest to meta using the common function
             store_item_digest_value(conn, item.clone(), digest_type, digest_value)?;
         } else {