Debug + better sqlite store

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "accumulators"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 license-file = "LICENSE"
 description = "Complete package of multiple Accumulators with Stores and hashing functions (Hashers)"

benches/incremental_benchmark.rs

@@ -10,7 +10,7 @@ use tokio::runtime::Runtime;
 async fn prepare_incremental(count: usize) -> IncrementalMerkleTree<StarkPoseidonHasher> {
     let hasher = StarkPoseidonHasher::new(Some(false));
 
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let store = Arc::new(store);
 

benches/mmr_benchmark.rs

@@ -9,7 +9,7 @@ use tokio::runtime::Runtime;
 async fn prepare_mmr(count: usize) -> MMR {
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let store = Arc::new(store);
 

src/hasher/core.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
-use std::str::FromStr;
+use std::{fmt::Debug, str::FromStr};
 
 // Default Hasher Options
 pub const DEFAULT_BLOCK_SIZE_BITS: usize = 256;
 
-pub trait Hasher: Send + Sync {
+pub trait Hasher: Send + Sync + Debug {
     fn hash(&self, data: Vec<String>) -> Result<String>;
     fn is_element_size_valid(&self, element: &str) -> bool;
     fn hash_single(&self, data: &str) -> String;

src/hasher/hashers/keccak.rs

@@ -7,6 +7,7 @@ use crate::hasher::HashingFunction;
 
 use super::super::Hasher;
 
+#[derive(Debug)]
 pub struct KeccakHasher {
     block_size_bits: usize,
 }

src/mmr/core.rs

@@ -16,6 +16,7 @@ use crate::mmr::{
     },
 };
 
+#[derive(Debug)]
 pub struct MMR {
     pub store: Arc<dyn Store>,
     pub hasher: Arc<dyn Hasher>,
@@ -28,7 +29,7 @@ pub struct MMR {
     pub sub_mmrs: SizesToMMRs,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct MmrMetadata {
     pub mmr_id: String,
     pub store: Arc<dyn Store>,

src/store/core.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
 use async_trait::async_trait;
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt::Debug};
 
 #[async_trait]
-pub trait Store: Send + Sync {
+pub trait Store: Send + Sync + Debug {
     async fn get(&self, key: &str) -> Result<Option<String>>;
     async fn get_many(&self, keys: Vec<&str>) -> Result<HashMap<String, String>>;
     async fn set(&self, key: &str, value: &str) -> Result<()>;

src/store/counter.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use super::Store;
 use anyhow::Result;
 
+#[derive(Debug)]
 pub struct InStoreCounter {
     pub store: Arc<dyn Store>,
     pub key: String,

src/store/stores/memory.rs

@@ -6,6 +6,7 @@ use parking_lot::RwLock;
 
 use crate::store::Store;
 
+#[derive(Debug)]
 pub struct InMemoryStore {
     pub store: RwLock<HashMap<String, String>>,
 }

src/store/stores/sqlite.rs

@@ -1,19 +1,28 @@
 use anyhow::Result;
 
 use async_trait::async_trait;
-use sqlx::{Pool, Row, Sqlite, SqlitePool};
+use sqlx::{sqlite::SqliteConnectOptions, Pool, Row, Sqlite, SqlitePool};
 use std::collections::HashMap;
 use tokio::sync::Mutex;
 
 use super::super::Store;
 
+#[derive(Debug)]
 pub struct SQLiteStore {
     db: Mutex<Pool<Sqlite>>,
 }
 
 impl SQLiteStore {
-    pub async fn new(path: &str) -> Result<Self> {
-        let pool = SqlitePool::connect(path).await?;
+    pub async fn new(path: &str, create_file_if_not_exists: Option<bool>) -> Result<Self> {
+        let pool = if let Some(create_file_if_not_exists) = create_file_if_not_exists {
+            let options = SqliteConnectOptions::new()
+                .filename(path)
+                .create_if_missing(create_file_if_not_exists);
+            SqlitePool::connect_with(options).await?
+        } else {
+            SqlitePool::connect(path).await?
+        };
+
         let store = SQLiteStore {
             db: Mutex::new(pool),
         };

src/store/table.rs

@@ -40,14 +40,14 @@ pub type GetFullKeysAndStoresFn =
     fn(&InStoreTable, Vec<SubKey>) -> Vec<(Arc<dyn Store>, Vec<String>)>;
 
 #[cfg(feature = "stacked_mmr")]
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct SubMMR {
     pub size: usize,
     pub key: String,
     pub store: Arc<dyn Store>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct InStoreTable {
     /// Always use this store for setters
     ///

tests/merkle_tree/incremental.rs

@@ -8,7 +8,7 @@ use accumulators::{
 
 #[tokio::test]
 async fn initialize() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = StarkPoseidonHasher::new(Some(false));
 
     let store = Arc::new(store);
@@ -23,7 +23,7 @@ async fn initialize() {
 
 #[tokio::test]
 async fn get_path() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = StarkPoseidonHasher::new(Some(false));
 
     let store = Arc::new(store);
@@ -51,7 +51,7 @@ async fn get_path() {
 
 #[tokio::test]
 async fn verify_proof() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = StarkPoseidonHasher::new(Some(false));
 
     let store = Arc::new(store);
@@ -67,7 +67,7 @@ async fn verify_proof() {
 
 #[tokio::test]
 async fn update() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = StarkPoseidonHasher::new(Some(false));
 
     let store = Arc::new(store);
@@ -95,7 +95,7 @@ async fn update() {
 
 #[tokio::test]
 async fn invalid_update() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = StarkPoseidonHasher::new(Some(false));
 
     let store = Arc::new(store);
@@ -111,7 +111,7 @@ async fn invalid_update() {
 
 #[tokio::test]
 async fn generate_and_verify_multi_proof() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = StarkPoseidonHasher::new(Some(false));
 
     let store = Arc::new(store);

tests/mmr/core.rs

@@ -193,7 +193,7 @@ async fn should_append_to_mmr() {
 
 #[tokio::test]
 async fn should_append_duplicate_to_mmr() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);
@@ -208,7 +208,7 @@ async fn should_append_duplicate_to_mmr() {
 #[tokio::test]
 async fn test_new() {
     // Arrange
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);

tests/mmr/stacked.rs

@@ -6,7 +6,7 @@ use accumulators::{
 
 #[tokio::test]
 async fn should_stack_two_mmrs() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);
@@ -66,7 +66,7 @@ async fn should_stack_two_mmrs() {
 
 #[tokio::test]
 async fn should_stack_4_mmrs() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let hasher = Arc::new(StarkPoseidonHasher::new(Some(false)));
 
     let store = Arc::new(store);

tests/store/sqlite.rs

@@ -6,7 +6,7 @@ use std::{collections::HashMap, sync::Arc};
 
 #[tokio::test]
 async fn set_and_get_value() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let key_value = (
         "6b9b77f2-a893-48bf-a52a-d5be5d0aaba3:RootHash",
@@ -24,7 +24,7 @@ async fn set_and_get_value() {
 
 #[tokio::test]
 async fn set_and_get_many_values() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let mut entries = HashMap::new();
     entries.insert("key1".to_string(), "value1".to_string());
@@ -39,7 +39,7 @@ async fn set_and_get_many_values() {
 
 #[tokio::test]
 async fn get_many_values_in_correct_order() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let mut entries = HashMap::new();
     entries.insert("a".to_string(), "value1".to_string());
@@ -61,7 +61,7 @@ async fn get_many_values_in_correct_order() {
 
 #[tokio::test]
 async fn should_delete_a_value() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     store.set("key", "value").await.unwrap();
     store.delete("key").await.unwrap();
@@ -72,7 +72,7 @@ async fn should_delete_a_value() {
 
 #[tokio::test]
 async fn test_in_store_counter() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
     let store = Arc::new(store);
 
     // Create an in-store counter
@@ -86,7 +86,7 @@ async fn test_in_store_counter() {
 
 #[tokio::test]
 async fn test_get_none_in_store_table() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let store = Arc::new(store);
 
@@ -99,7 +99,7 @@ async fn test_get_none_in_store_table() {
 
 #[tokio::test]
 async fn test_get_many_none_in_store_table() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let store = Arc::new(store);
 
@@ -126,7 +126,7 @@ async fn test_get_many_none_in_store_table() {
 
 #[tokio::test]
 async fn test_get_some_in_store_table() {
-    let store = SQLiteStore::new(":memory:").await.unwrap();
+    let store = SQLiteStore::new(":memory:", None).await.unwrap();
 
     let store = Arc::new(store);