Use papaya concurrent hash map

So we can use atomic operations on the hash maps used in storage,
and thus avoid the need of using an `RwLock`.

Author: aleics

Cargo.toml

@@ -11,6 +11,7 @@ axum = { version = "0.8.1" }
 heed = "0.21.0"
 indexmap = { version = "2.7.1", features = ["serde"] }
 ordered-float = { version = "4.6", features = ["serde"] }
+papaya = "0.1.8"
 pest = "2.7.15"
 pest_derive = "2.7.15"
 roaring = { version = "0.10.10", features = ["serde"] }

examples/simple.rs

@@ -9,8 +9,7 @@ use delta_search::query::{
 use delta_search::Engine;
 use time::{Date, Month};
 
-#[tokio::main]
-async fn main() -> Result<(), Error> {
+fn main() -> Result<(), Error> {
     println!("Welcome to the simple Player search!");
 
     let michael_jordan = michael_jordan();
@@ -38,27 +37,25 @@ async fn main() -> Result<(), Error> {
 
     let engine = Engine::with_entities(vec![entity]);
 
-    let filter_options = engine.options(name, OptionsQueryExecution::new()).await;
+    let filter_options = engine.options(name, OptionsQueryExecution::new());
 
     println!("Filter possibilities:\n{:?}\n", filter_options);
 
     let query = QueryExecution::new()
         .with_filter(CompositeFilter::parse("sport = \"Basketball\"")?)
         .with_sort(Sort::new("score").with_direction(SortDirection::DESC));
-    let players = engine.query(name, query).await;
+    let players = engine.query(name, query);
 
     println!("Basketball players sorted by score:\n{:?}\n", players);
 
-    let players = engine
-        .query(
-            name,
-            QueryExecution::new()
-                .with_filter(CompositeFilter::parse(
-                    "birth_date >= \"1980-01-01\" && birth_date <= \"1989-12-31\"",
-                )?)
-                .with_sort(Sort::new("name").with_direction(SortDirection::ASC)),
-        )
-        .await;
+    let players = engine.query(
+        name,
+        QueryExecution::new()
+            .with_filter(CompositeFilter::parse(
+                "birth_date >= \"1980-01-01\" && birth_date <= \"1989-12-31\"",
+            )?)
+            .with_sort(Sort::new("name").with_direction(SortDirection::ASC)),
+    );
 
     println!("Players born in the 80s:\n{:?}\n", players);
 
@@ -71,7 +68,6 @@ async fn main() -> Result<(), Error> {
 
     engine
         .store_deltas(name, &delta_scope, &switch_sports)
-        .await
         .unwrap();
 
     let query = QueryExecution::new()
@@ -83,7 +79,7 @@ async fn main() -> Result<(), Error> {
             1,
         )?));
 
-    let players = engine.query(name, query).await?;
+    let players = engine.query(name, query)?;
 
     println!(
         "Basketball players sorted by score after switching sports in 2023:\n{:?}\n",
@@ -97,9 +93,7 @@ async fn main() -> Result<(), Error> {
 
     let delta_scope = DeltaScope::context(0, Date::from_calendar_date(2023, Month::January, 1)?);
 
-    engine
-        .store_deltas(name, &delta_scope, &lower_scores)
-        .await?;
+    engine.store_deltas(name, &delta_scope, &lower_scores)?;
 
     let query = QueryExecution::new()
         .with_sort(Sort::new("score").with_direction(SortDirection::DESC))
@@ -108,21 +102,19 @@ async fn main() -> Result<(), Error> {
             Date::from_calendar_date(2024, Month::January, 1)?,
         ));
 
-    let players = engine.query(name, query).await?;
+    let players = engine.query(name, query)?;
 
     println!(
         "Players sorted by score after decreasing their score by 1:\n{:?}\n",
         players
     );
 
-    engine.remove(name, &david_id).await?;
+    engine.remove(name, &david_id)?;
 
-    let players = engine
-        .query(
-            name,
-            QueryExecution::new().with_filter(CompositeFilter::parse("sport = \"Basketball\"")?),
-        )
-        .await?;
+    let players = engine.query(
+        name,
+        QueryExecution::new().with_filter(CompositeFilter::parse("sport = \"Basketball\"")?),
+    )?;
 
     println!(
         "Players playing basketball after deletion:\n{:?}\n",

src/fixtures.rs

@@ -78,17 +78,16 @@ impl TestRunners {
         }
     }
 
-    pub(crate) async fn start_runner(&self, items: Vec<DataItem>) -> TestPlayerRunner {
-        let mut runner = self
+    pub(crate) fn start_runner(&self, items: Vec<DataItem>) -> TestPlayerRunner {
+        let runner = self
             .runners
             .lock()
             .unwrap()
             .pop()
             .expect("No storages left - make sure you didn't exceed the test count");
 
-        if let Some(entry) = runner.engine.entities.get_mut(&runner.name) {
-            let mut entity = entry.write().await;
-            carry_players(items, &mut entity);
+        if let Some(entity) = runner.engine.entities.pin().get(&runner.name) {
+            carry_players(items, entity);
         }
 
         runner
@@ -122,13 +121,13 @@ pub fn create_player_from_index(index: u64) -> DataItem {
 }
 
 pub fn create_players_storage(name: &str, data: Vec<DataItem>) -> EntityStorage {
-    let mut storage = StorageBuilder::new(name).build().unwrap();
-    carry_players(data, &mut storage);
+    let storage = StorageBuilder::new(name).build().unwrap();
+    carry_players(data, &storage);
 
     storage
 }
 
-fn carry_players(items: Vec<DataItem>, storage: &mut EntityStorage) {
+fn carry_players(items: Vec<DataItem>, storage: &EntityStorage) {
     storage.carry(&items).unwrap();
 
     storage