Batch work

Cargo.toml

@@ -3,7 +3,7 @@ members = ["crate/findex", "crate/memories"]
 resolver = "2"
 
 [workspace.package]
-version = "8.0.1"
+version = "8.1.0"
 authors = [
     "Bruno Grieder <[email protected]>",
     "Célia Corsin <[email protected]>",
@@ -30,3 +30,4 @@ cosmian_crypto_core = { version = "10.2", default-features = false, features = [
 criterion = { version = "0.6" }
 smol-macros = { version = "0.1" }
 tokio = { version = "1.46" }
+futures = "0.3.31"

crate/findex/Cargo.toml

@@ -15,14 +15,15 @@ name = "cosmian_findex"
 path = "src/lib.rs"
 
 [features]
+batch = ["cosmian_sse_memories/batch"]
 test-utils = ["agnostic-lite", "criterion"]
 
 [dependencies]
 aes = "0.8"
 cosmian_crypto_core.workspace = true
-cosmian_sse_memories = { path = "../memories", version = "8.0" }
+cosmian_sse_memories = { path = "../memories", version = "8.1.0" }
 xts-mode = "0.5"
-
+futures.workspace = true
 # Optional dependencies for testing and benchmarking.
 agnostic-lite = { workspace = true, optional = true, features = [
     "tokio",
@@ -33,7 +34,7 @@ criterion = { workspace = true, optional = true }
 
 [dev-dependencies]
 agnostic-lite = { workspace = true, features = ["tokio"] }
-cosmian_sse_memories = { path = "../memories", version = "8.0", features = [
+cosmian_sse_memories = { path = "../memories", version = "8.1.0", features = [
     "redis-mem",
     "sqlite-mem",
     "postgres-mem",

crate/findex/README.md

@@ -2,6 +2,8 @@
 
 This crate provides the core functionality of Findex, defining the abstract data types, cryptographic operations, and encoding algorithms.
 
+Supports batching operations into a singe call to the memory interface, which reduces connection overhead and avoids file descriptor limits on some Linux systems.
+
 ## Setup
 
 Add `cosmian_findex` as dependency to your project :

crate/findex/src/adt.rs

@@ -51,6 +51,39 @@ pub trait VectorADT: Send {
     fn read(&self) -> impl Send + Future<Output = Result<Vec<Self::Value>, Self::Error>>;
 }
 
+/// This trait provides methods that let an index operate on multiple keywords or entries simultaneously.
+#[cfg(feature = "batch")]
+pub trait IndexBatcher<Keyword, Value> {
+    type Error: std::error::Error;
+
+    /// Search the index for the values bound to the given keywords.
+    fn batch_search(
+        &self,
+        keywords: Vec<&Keyword>,
+    ) -> impl Future<Output = Result<Vec<HashSet<Value>>, Self::Error>>;
+
+    /// Binds each value to their associated keyword in this index.
+    fn batch_insert<Values, Entries>(
+        &self,
+        entries: Entries,
+    ) -> impl Send + Future<Output = Result<(), Self::Error>>
+    where
+        Values: Send + IntoIterator<Item = Value>,
+        Entries: Send + IntoIterator<Item = (Keyword, Values)>,
+        Entries::IntoIter: ExactSizeIterator,
+        <Entries as IntoIterator>::IntoIter: Send;
+
+    /// Removes the given values from the index.
+    fn batch_delete<Values, Entries>(
+        &self,
+        entries: Entries,
+    ) -> impl Send + Future<Output = Result<(), Self::Error>>
+    where
+        Values: Send + IntoIterator<Item = Value>,
+        Entries: Send + IntoIterator<Item = (Keyword, Values)>,
+        Entries::IntoIter: ExactSizeIterator + Send;
+}
+
 #[cfg(test)]
 pub mod tests {
 

crate/findex/src/error.rs

@@ -1,5 +1,8 @@
 use std::fmt::{Debug, Display};
 
+#[cfg(feature = "batch")]
+pub use batch_findex_error::*;
+
 #[derive(Debug)]
 pub enum Error<Address> {
     Parsing(String),
@@ -16,3 +19,59 @@ impl<Address: Debug> Display for Error<Address> {
 }
 
 impl<Address: Debug> std::error::Error for Error<Address> {}
+
+#[cfg(feature = "batch")]
+pub mod batch_findex_error {
+    use cosmian_sse_memories::{MemoryADT, MemoryBatcherError};
+
+    use super::*;
+
+    #[derive(Debug)]
+    pub enum BatchFindexError<M: MemoryADT>
+    where
+        <M as MemoryADT>::Word: Debug,
+    {
+        BatchingLayer(MemoryBatcherError<M>),
+        Findex(Error<M::Address>),
+        Other(String),
+    }
+
+    impl<M: MemoryADT + Debug> Display for BatchFindexError<M>
+    where
+        <M as MemoryADT>::Address: Debug,
+        <M as MemoryADT>::Word: Debug,
+    {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Self::BatchingLayer(e) => write!(f, "Batching layer error: {e}"),
+                Self::Findex(error) => write!(f, "Findex error: {error:?}"),
+                Self::Other(msg) => write!(f, "{msg}"),
+            }
+        }
+    }
+
+    impl<M: MemoryADT + Debug> From<Error<M::Address>> for BatchFindexError<M>
+    where
+        <M as MemoryADT>::Word: Debug,
+    {
+        fn from(e: Error<M::Address>) -> Self {
+            Self::Findex(e)
+        }
+    }
+
+    impl<M: MemoryADT + Debug> From<MemoryBatcherError<M>> for BatchFindexError<M>
+    where
+        <M as MemoryADT>::Word: Debug,
+    {
+        fn from(e: MemoryBatcherError<M>) -> Self {
+            Self::BatchingLayer(e)
+        }
+    }
+
+    impl<M: MemoryADT + Debug> std::error::Error for BatchFindexError<M>
+    where
+        <M as MemoryADT>::Address: Debug,
+        <M as MemoryADT>::Word: Debug,
+    {
+    }
+}

crate/findex/src/findex.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::type_complexity)]
-
 use std::{
     collections::HashSet,
     fmt::Debug,