Make StrContainer.insert_str mutable

Allows to avoid some not useful RwLock

lib/src/sparql/eval.rs

@@ -1230,6 +1230,7 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
                     None
                 }?;
                 self.dataset
+                    .encoder()
                     .encode_rio_literal(rio::Literal::Typed {
                         value: &value,
                         datatype: rio::NamedNode { iri: &datatype },
@@ -1474,7 +1475,7 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
 
     fn build_string_id(&self, value: &str) -> Option<u128> {
         let value_id = get_str_id(value);
-        self.dataset.insert_str(value_id, value).ok()?;
+        self.dataset.encoder().insert_str(value_id, value).ok()?;
         Some(value_id)
     }
 
@@ -2211,7 +2212,7 @@ fn get_triple_template_value(
 }
 
 fn decode_triple(
-    decoder: impl Decoder,
+    decoder: &impl Decoder,
     subject: EncodedTerm,
     predicate: EncodedTerm,
     object: EncodedTerm,

lib/src/sparql/mod.rs

@@ -64,7 +64,7 @@ impl<S: StoreConnection> SimplePreparedQuery<S> {
                 dataset: _,
                 base_iri,
             } => {
-                let (plan, variables) = PlanBuilder::build(&dataset, &algebra)?;
+                let (plan, variables) = PlanBuilder::build(dataset.encoder(), &algebra)?;
                 SimplePreparedQueryOptions::Select {
                     plan,
                     variables,
@@ -76,7 +76,7 @@ impl<S: StoreConnection> SimplePreparedQuery<S> {
                 dataset: _,
                 base_iri,
             } => {
-                let (plan, _) = PlanBuilder::build(&dataset, &algebra)?;
+                let (plan, _) = PlanBuilder::build(dataset.encoder(), &algebra)?;
                 SimplePreparedQueryOptions::Ask {
                     plan,
                     evaluator: SimpleEvaluator::new(dataset, base_iri),
@@ -88,10 +88,14 @@ impl<S: StoreConnection> SimplePreparedQuery<S> {
                 dataset: _,
                 base_iri,
             } => {
-                let (plan, variables) = PlanBuilder::build(&dataset, &algebra)?;
+                let (plan, variables) = PlanBuilder::build(dataset.encoder(), &algebra)?;
                 SimplePreparedQueryOptions::Construct {
                     plan,
-                    construct: PlanBuilder::build_graph_template(&dataset, &construct, variables)?,
+                    construct: PlanBuilder::build_graph_template(
+                        dataset.encoder(),
+                        &construct,
+                        variables,
+                    )?,
                     evaluator: SimpleEvaluator::new(dataset, base_iri),
                 }
             }
@@ -100,7 +104,7 @@ impl<S: StoreConnection> SimplePreparedQuery<S> {
                 dataset: _,
                 base_iri,
             } => {
-                let (plan, _) = PlanBuilder::build(&dataset, &algebra)?;
+                let (plan, _) = PlanBuilder::build(dataset.encoder(), &algebra)?;
                 SimplePreparedQueryOptions::Describe {
                     plan,
                     evaluator: SimpleEvaluator::new(dataset, base_iri),

lib/src/sparql/plan.rs

@@ -1,9 +1,10 @@
 use crate::sparql::eval::StringOrStoreString;
 use crate::store::numeric_encoder::{
-    EncodedQuad, EncodedTerm, MemoryStrStore, StrContainer, StrLookup,
+    EncodedQuad, EncodedTerm, Encoder, MemoryStrStore, StrContainer, StrLookup,
 };
 use crate::store::StoreConnection;
 use crate::Result;
+use std::cell::{RefCell, RefMut};
 use std::collections::BTreeSet;
 
 pub type EncodedTuple = Vec<Option<EncodedTerm>>;
@@ -460,14 +461,14 @@ pub enum TripleTemplateValue {
 
 pub struct DatasetView<S: StoreConnection> {
     store: S,
-    extra: MemoryStrStore,
+    extra: RefCell<MemoryStrStore>,
 }
 
 impl<S: StoreConnection> DatasetView<S> {
     pub fn new(store: S) -> Self {
         Self {
             store,
-            extra: MemoryStrStore::default(),
+            extra: RefCell::new(MemoryStrStore::default()),
         }
     }
 
@@ -481,13 +482,20 @@ impl<S: StoreConnection> DatasetView<S> {
         self.store
             .quads_for_pattern(subject, predicate, object, graph_name)
     }
+
+    pub fn encoder<'a>(&'a self) -> impl Encoder + StrContainer + 'a {
+        DatasetViewStrContainer {
+            store: &self.store,
+            extra: self.extra.borrow_mut(),
+        }
+    }
 }
 
 impl<S: StoreConnection> StrLookup for DatasetView<S> {
     type StrType = StringOrStoreString<S::StrType>;
 
     fn get_str(&self, id: u128) -> Result<Option<StringOrStoreString<S::StrType>>> {
-        Ok(if let Some(value) = self.extra.get_str(id)? {
+        Ok(if let Some(value) = self.extra.borrow().get_str(id)? {
             Some(StringOrStoreString::String(value))
         } else if let Some(value) = self.store.get_str(id)? {
             Some(StringOrStoreString::Store(value))
@@ -497,8 +505,13 @@ impl<S: StoreConnection> StrLookup for DatasetView<S> {
     }
 }
 
-impl<S: StoreConnection> StrContainer for DatasetView<S> {
-    fn insert_str(&self, key: u128, value: &str) -> Result<()> {
+struct DatasetViewStrContainer<'a, S: StoreConnection> {
+    store: &'a S,
+    extra: RefMut<'a, MemoryStrStore>,
+}
+
+impl<'a, S: StoreConnection> StrContainer for DatasetViewStrContainer<'a, S> {
+    fn insert_str(&mut self, key: u128, value: &str) -> Result<()> {
         if self.store.get_str(key)?.is_none() {
             self.extra.insert_str(key, value)
         } else {

lib/src/sparql/plan_builder.rs

@@ -33,7 +33,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn build_for_graph_pattern(
-        &self,
+        &mut self,
         pattern: &GraphPattern,
         variables: &mut Vec<Variable>,
         graph_name: PatternValue,
@@ -197,7 +197,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn build_for_bgp(
-        &self,
+        &mut self,
         p: &[TripleOrPathPattern],
         variables: &mut Vec<Variable>,
         graph_name: PatternValue,
@@ -227,7 +227,7 @@ impl<E: Encoder> PlanBuilder<E> {
         Ok(plan)
     }
 
-    fn build_for_path(&self, path: &PropertyPath) -> Result<PlanPropertyPath> {
+    fn build_for_path(&mut self, path: &PropertyPath) -> Result<PlanPropertyPath> {
         Ok(match path {
             PropertyPath::PredicatePath(p) => {
                 PlanPropertyPath::PredicatePath(self.encoder.encode_named_node(p)?)
@@ -261,7 +261,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn build_for_expression(
-        &self,
+        &mut self,
         expression: &Expression,
         variables: &mut Vec<Variable>,
         graph_name: PatternValue,
@@ -650,7 +650,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn build_cast(
-        &self,
+        &mut self,
         parameters: &[Expression],
         constructor: impl Fn(Box<PlanExpression>) -> PlanExpression,
         variables: &mut Vec<Variable>,
@@ -672,7 +672,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn expression_list(
-        &self,
+        &mut self,
         l: &[Expression],
         variables: &mut Vec<Variable>,
         graph_name: PatternValue,
@@ -683,7 +683,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn pattern_value_from_term_or_variable(
-        &self,
+        &mut self,
         term_or_variable: &TermOrVariable,
         variables: &mut Vec<Variable>,
     ) -> Result<PatternValue> {
@@ -696,7 +696,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn pattern_value_from_named_node_or_variable(
-        &self,
+        &mut self,
         named_node_or_variable: &NamedNodeOrVariable,
         variables: &mut Vec<Variable>,
     ) -> Result<PatternValue> {
@@ -711,7 +711,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn encode_bindings(
-        &self,
+        &mut self,
         bindings: &StaticBindings,
         variables: &mut Vec<Variable>,
     ) -> Result<Vec<EncodedTuple>> {
@@ -736,7 +736,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn build_for_aggregate(
-        &self,
+        &mut self,
         aggregate: &Aggregation,
         variables: &mut Vec<Variable>,
         graph_name: PatternValue,
@@ -786,7 +786,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn build_for_graph_template(
-        &self,
+        &mut self,
         template: &[TriplePattern],
         variables: &mut Vec<Variable>,
     ) -> Result<Vec<TripleTemplate>> {
@@ -816,7 +816,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn template_value_from_term_or_variable(
-        &self,
+        &mut self,
         term_or_variable: &TermOrVariable,
         variables: &mut Vec<Variable>,
         bnodes: &mut Vec<Variable>,
@@ -836,7 +836,7 @@ impl<E: Encoder> PlanBuilder<E> {
     }
 
     fn template_value_from_named_node_or_variable(
-        &self,
+        &mut self,
         named_node_or_variable: &NamedNodeOrVariable,
         variables: &mut Vec<Variable>,
         bnodes: &mut Vec<Variable>,

lib/src/store/memory.rs

@@ -1,9 +1,10 @@
 use crate::store::numeric_encoder::*;
 use crate::store::*;
 use crate::{Repository, Result};
+use failure::{Backtrace, Fail};
 use std::collections::{BTreeMap, BTreeSet};
 use std::iter::{empty, once};
-use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 /// Memory based implementation of the `Repository` trait.
 /// They are cheap to build using the `MemoryRepository::default()` method.
@@ -45,8 +46,7 @@ type QuadMap<T> = BTreeMap<T, TripleMap<T>>;
 
 #[derive(Default)]
 pub struct MemoryStore {
-    str_store: MemoryStrStore,
-    quad_indexes: RwLock<MemoryStoreIndexes>,
+    indexes: RwLock<MemoryStoreIndexes>,
 }
 
 #[derive(Default)]
@@ -57,6 +57,7 @@ struct MemoryStoreIndexes {
     gspo: QuadMap<EncodedTerm>,
     gpos: QuadMap<EncodedTerm>,
     gosp: QuadMap<EncodedTerm>,
+    str_store: MemoryStrStore,
 }
 
 impl<'a> Repository for &'a MemoryRepository {
@@ -75,24 +76,24 @@ impl<'a> Store for &'a MemoryStore {
     }
 }
 
-impl StrLookup for MemoryStore {
+impl<'a> StrLookup for &'a MemoryStore {
     type StrType = String;
 
     fn get_str(&self, id: u128) -> Result<Option<String>> {
-        self.str_store.get_str(id)
+        self.indexes()?.str_store.get_str(id)
     }
 }
 
-impl StrContainer for MemoryStore {
-    fn insert_str(&self, key: u128, value: &str) -> Result<()> {
-        self.str_store.insert_str(key, value)
+impl<'a> StrContainer for &'a MemoryStore {
+    fn insert_str(&mut self, key: u128, value: &str) -> Result<()> {
+        self.indexes_mut()?.str_store.insert_str(key, value)
     }
 }
 
 impl<'a> StoreConnection for &'a MemoryStore {
     fn contains(&self, quad: &EncodedQuad) -> Result<bool> {
         Ok(self
-            .quad_indexes()?
+            .indexes()?
             .spog
             .get(&quad.subject)
             .map_or(false, |pog| {
@@ -104,7 +105,7 @@ impl<'a> StoreConnection for &'a MemoryStore {
     }
 
     fn insert(&mut self, quad: &EncodedQuad) -> Result<()> {
-        let mut quad_indexes = self.quad_indexes_mut()?;
+        let mut quad_indexes = self.indexes_mut()?;
         insert_into_quad_map(
             &mut quad_indexes.gosp,
             quad.graph_name,
@@ -151,7 +152,7 @@ impl<'a> StoreConnection for &'a MemoryStore {
     }
 
     fn remove(&mut self, quad: &EncodedQuad) -> Result<()> {
-        let mut quad_indexes = self.quad_indexes_mut()?;
+        let mut quad_indexes = self.indexes_mut()?;
         remove_from_quad_map(
             &mut quad_indexes.gosp,
             &quad.graph_name,
@@ -275,16 +276,16 @@ impl<'a> StoreConnection for &'a MemoryStore {
 }
 
 impl MemoryStore {
-    fn quad_indexes(&self) -> Result<RwLockReadGuard<'_, MemoryStoreIndexes>> {
-        Ok(self.quad_indexes.read().map_err(MutexPoisonError::from)?)
+    fn indexes(&self) -> Result<RwLockReadGuard<'_, MemoryStoreIndexes>> {
+        Ok(self.indexes.read().map_err(MutexPoisonError::from)?)
     }
 
-    fn quad_indexes_mut(&self) -> Result<RwLockWriteGuard<'_, MemoryStoreIndexes>> {
-        Ok(self.quad_indexes.write().map_err(MutexPoisonError::from)?)
+    fn indexes_mut(&self) -> Result<RwLockWriteGuard<'_, MemoryStoreIndexes>> {
+        Ok(self.indexes.write().map_err(MutexPoisonError::from)?)
     }
 
     fn quads<'a>(&'a self) -> Result<impl Iterator<Item = Result<EncodedQuad>> + 'a> {
-        Ok(quad_map_flatten(&self.quad_indexes()?.gspo)
+        Ok(quad_map_flatten(&self.indexes()?.gspo)
             .map(|(g, s, p, o)| Ok(EncodedQuad::new(s, p, o, g)))
             .collect::<Vec<_>>()
             .into_iter())
@@ -295,7 +296,7 @@ impl MemoryStore {
         subject: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(
-            option_triple_map_flatten(self.quad_indexes()?.spog.get(&subject))
+            option_triple_map_flatten(self.indexes()?.spog.get(&subject))
                 .map(|(p, o, g)| Ok(EncodedQuad::new(subject, p, o, g)))
                 .collect::<Vec<_>>()
                 .into_iter(),
@@ -308,7 +309,7 @@ impl MemoryStore {
         predicate: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_pair_map_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .spog
                 .get(&subject)
                 .and_then(|pog| pog.get(&predicate)),
@@ -325,7 +326,7 @@ impl MemoryStore {
         object: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_set_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .spog
                 .get(&subject)
                 .and_then(|pog| pog.get(&predicate))
@@ -342,7 +343,7 @@ impl MemoryStore {
         object: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_pair_map_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .ospg
                 .get(&object)
                 .and_then(|spg| spg.get(&subject)),
@@ -357,7 +358,7 @@ impl MemoryStore {
         predicate: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(
-            option_triple_map_flatten(self.quad_indexes()?.posg.get(&predicate))
+            option_triple_map_flatten(self.indexes()?.posg.get(&predicate))
                 .map(|(o, s, g)| Ok(EncodedQuad::new(s, predicate, o, g)))
                 .collect::<Vec<_>>()
                 .into_iter(),
@@ -370,7 +371,7 @@ impl MemoryStore {
         object: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_pair_map_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .posg
                 .get(&predicate)
                 .and_then(|osg| osg.get(&object)),
@@ -384,12 +385,10 @@ impl MemoryStore {
         &self,
         object: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
-        Ok(
-            option_triple_map_flatten(self.quad_indexes()?.ospg.get(&object))
-                .map(|(s, p, g)| Ok(EncodedQuad::new(s, p, object, g)))
-                .collect::<Vec<_>>()
-                .into_iter(),
-        )
+        Ok(option_triple_map_flatten(self.indexes()?.ospg.get(&object))
+            .map(|(s, p, g)| Ok(EncodedQuad::new(s, p, object, g)))
+            .collect::<Vec<_>>()
+            .into_iter())
     }
 
     fn quads_for_graph(
@@ -397,7 +396,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(
-            option_triple_map_flatten(self.quad_indexes()?.gspo.get(&graph_name))
+            option_triple_map_flatten(self.indexes()?.gspo.get(&graph_name))
                 .map(|(s, p, o)| Ok(EncodedQuad::new(s, p, o, graph_name)))
                 .collect::<Vec<_>>()
                 .into_iter(),
@@ -410,7 +409,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_pair_map_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .gspo
                 .get(&graph_name)
                 .and_then(|spo| spo.get(&subject)),
@@ -427,7 +426,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_set_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .gspo
                 .get(&graph_name)
                 .and_then(|spo| spo.get(&subject))
@@ -445,7 +444,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_set_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .gosp
                 .get(&graph_name)
                 .and_then(|osp| osp.get(&object))
@@ -462,7 +461,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_pair_map_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .gpos
                 .get(&graph_name)
                 .and_then(|pos| pos.get(&predicate)),
@@ -479,7 +478,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_set_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .gpos
                 .get(&graph_name)
                 .and_then(|pos| pos.get(&predicate))
@@ -496,7 +495,7 @@ impl MemoryStore {
         graph_name: EncodedTerm,
     ) -> Result<impl Iterator<Item = Result<EncodedQuad>>> {
         Ok(option_pair_map_flatten(
-            self.quad_indexes()?
+            self.indexes()?
                 .gosp
                 .get(&graph_name)
                 .and_then(|osp| osp.get(&object)),
@@ -592,3 +591,17 @@ fn quad_map_flatten<'a, T: Copy>(gspo: &'a QuadMap<T>) -> impl Iterator<Item = (
         })
     })
 }
+
+#[derive(Debug, Fail)]
+#[fail(display = "Mutex Mutex was poisoned")]
+pub struct MutexPoisonError {
+    backtrace: Backtrace,
+}
+
+impl<T> From<PoisonError<T>> for MutexPoisonError {
+    fn from(_: PoisonError<T>) -> Self {
+        Self {
+            backtrace: Backtrace::new(),
+        }
+    }
+}

lib/src/store/mod.rs

@@ -123,11 +123,13 @@ impl<S: StoreConnection> RepositoryConnection for StoreRepositoryConnection<S> {
     }
 
     fn insert(&mut self, quad: &Quad) -> Result<()> {
-        self.inner.insert(&self.inner.encode_quad(quad)?)
+        let quad = self.inner.encode_quad(quad)?;
+        self.inner.insert(&quad)
     }
 
     fn remove(&mut self, quad: &Quad) -> Result<()> {
-        self.inner.remove(&self.inner.encode_quad(quad)?)
+        let quad = self.inner.encode_quad(quad)?;
+        self.inner.remove(&quad)
     }
 }
 
@@ -147,11 +149,10 @@ impl<S: StoreConnection> StoreRepositoryConnection<S> {
             EncodedTerm::DefaultGraph
         };
         parser.parse_all(&mut move |t| {
-            self.inner.insert(&self.inner.encode_rio_triple_in_graph(
-                t,
-                graph_name,
-                &mut bnode_map,
-            )?)
+            let quad = self
+                .inner
+                .encode_rio_triple_in_graph(t, graph_name, &mut bnode_map)?;
+            self.inner.insert(&quad)
         })?;
         Ok(())
     }
@@ -162,8 +163,8 @@ impl<S: StoreConnection> StoreRepositoryConnection<S> {
     {
         let mut bnode_map = HashMap::default();
         parser.parse_all(&mut move |q| {
-            self.inner
-                .insert(&self.inner.encode_rio_quad(q, &mut bnode_map)?)
+            let quad = self.inner.encode_rio_quad(q, &mut bnode_map)?;
+            self.inner.insert(&quad)
         })?;
         Ok(())
     }

lib/src/store/numeric_encoder.rs

@@ -6,8 +6,6 @@ use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use chrono::format::{parse, Parsed, StrftimeItems};
 use chrono::prelude::*;
 use failure::format_err;
-use failure::Backtrace;
-use failure::Fail;
 use md5::digest::Digest;
 use md5::Md5;
 use ordered_float::OrderedFloat;
@@ -20,8 +18,6 @@ use std::io::Write;
 use std::mem::size_of;
 use std::ops::Deref;
 use std::str;
-use std::sync::PoisonError;
-use std::sync::RwLock;
 
 const EMPTY_STRING_ID: u128 = 167830467844043968176572005485231480276;
 const RDF_LANG_STRING_ID: u128 = 32982328051974780078994098831023510434;
@@ -703,10 +699,10 @@ pub trait StrLookup {
 }
 
 pub trait StrContainer {
-    fn insert_str(&self, key: u128, value: &str) -> Result<()>;
+    fn insert_str(&mut self, key: u128, value: &str) -> Result<()>;
 
     /// Should be called when the bytes store is created
-    fn set_first_strings(&self) -> Result<()> {
+    fn set_first_strings(&mut self) -> Result<()> {
         self.insert_str(EMPTY_STRING_ID, "")?;
         self.insert_str(RDF_LANG_STRING_ID, rdf::LANG_STRING.as_str())?;
         self.insert_str(XSD_STRING_ID, xsd::STRING.as_str())?;
@@ -722,28 +718,14 @@ pub trait StrContainer {
     }
 }
 
-impl<'a, S: StrLookup + 'a> StrLookup for &'a S {
-    type StrType = S::StrType;
-
-    fn get_str(&self, id: u128) -> Result<Option<S::StrType>> {
-        (*self).get_str(id)
-    }
-}
-
-impl<'a, S: StrContainer + 'a> StrContainer for &'a S {
-    fn insert_str(&self, key: u128, value: &str) -> Result<()> {
-        (*self).insert_str(key, value)
-    }
-}
-
 pub struct MemoryStrStore {
-    id2str: RwLock<HashMap<u128, String>>,
+    id2str: HashMap<u128, String>,
 }
 
 impl Default for MemoryStrStore {
     fn default() -> Self {
-        let new = Self {
-            id2str: RwLock::default(),
+        let mut new = Self {
+            id2str: HashMap::default(),
         };
         new.set_first_strings().unwrap();
         new
@@ -755,82 +737,19 @@ impl StrLookup for MemoryStrStore {
 
     fn get_str(&self, id: u128) -> Result<Option<String>> {
         //TODO: avoid copy by adding a lifetime limit to get_str
-        Ok(self
-            .id2str
-            .read()
-            .map_err(MutexPoisonError::from)?
-            .get(&id)
-            .cloned())
+        Ok(self.id2str.get(&id).cloned())
     }
 }
 
 impl StrContainer for MemoryStrStore {
-    fn insert_str(&self, key: u128, value: &str) -> Result<()> {
-        let mut id2str = self.id2str.write().map_err(MutexPoisonError::from)?;
-        if !id2str.contains_key(&key) {
-            id2str.insert(key, value.to_owned());
-        }
+    fn insert_str(&mut self, key: u128, value: &str) -> Result<()> {
+        self.id2str.entry(key).or_insert_with(|| value.to_owned());
         Ok(())
     }
 }
 
 pub trait Encoder {
-    fn encode_named_node(&self, named_node: &NamedNode) -> Result<EncodedTerm>;
-
-    fn encode_blank_node(&self, blank_node: &BlankNode) -> Result<EncodedTerm>;
-
-    fn encode_literal(&self, literal: &Literal) -> Result<EncodedTerm>;
-
-    fn encode_named_or_blank_node(&self, term: &NamedOrBlankNode) -> Result<EncodedTerm>;
-
-    fn encode_term(&self, term: &Term) -> Result<EncodedTerm>;
-
-    fn encode_quad(&self, quad: &Quad) -> Result<EncodedQuad>;
-
-    fn encode_triple_in_graph(
-        &self,
-        triple: &Triple,
-        graph_name: EncodedTerm,
-    ) -> Result<EncodedQuad>;
-
-    fn encode_rio_named_node(&self, named_node: rio::NamedNode) -> Result<EncodedTerm>;
-
-    fn encode_rio_blank_node(
-        &self,
-        blank_node: rio::BlankNode,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm>;
-
-    fn encode_rio_literal(&self, literal: rio::Literal) -> Result<EncodedTerm>;
-
-    fn encode_rio_named_or_blank_node(
-        &self,
-        term: rio::NamedOrBlankNode,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm>;
-
-    fn encode_rio_term(
-        &self,
-        term: rio::Term,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm>;
-
-    fn encode_rio_quad(
-        &self,
-        quad: rio::Quad,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedQuad>;
-
-    fn encode_rio_triple_in_graph(
-        &self,
-        triple: rio::Triple,
-        graph_name: EncodedTerm,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedQuad>;
-}
-
-impl<S: StrContainer> Encoder for S {
-    fn encode_named_node(&self, named_node: &NamedNode) -> Result<EncodedTerm> {
+    fn encode_named_node(&mut self, named_node: &NamedNode) -> Result<EncodedTerm> {
         self.encode_rio_named_node(named_node.into())
     }
 
@@ -838,18 +757,18 @@ impl<S: StrContainer> Encoder for S {
         Ok(blank_node.into())
     }
 
-    fn encode_literal(&self, literal: &Literal) -> Result<EncodedTerm> {
+    fn encode_literal(&mut self, literal: &Literal) -> Result<EncodedTerm> {
         self.encode_rio_literal(literal.into())
     }
 
-    fn encode_named_or_blank_node(&self, term: &NamedOrBlankNode) -> Result<EncodedTerm> {
+    fn encode_named_or_blank_node(&mut self, term: &NamedOrBlankNode) -> Result<EncodedTerm> {
         match term {
             NamedOrBlankNode::NamedNode(named_node) => self.encode_named_node(named_node),
             NamedOrBlankNode::BlankNode(blank_node) => self.encode_blank_node(blank_node),
         }
     }
 
-    fn encode_term(&self, term: &Term) -> Result<EncodedTerm> {
+    fn encode_term(&mut self, term: &Term) -> Result<EncodedTerm> {
         match term {
             Term::NamedNode(named_node) => self.encode_named_node(named_node),
             Term::BlankNode(blank_node) => self.encode_blank_node(blank_node),
@@ -857,7 +776,7 @@ impl<S: StrContainer> Encoder for S {
         }
     }
 
-    fn encode_quad(&self, quad: &Quad) -> Result<EncodedQuad> {
+    fn encode_quad(&mut self, quad: &Quad) -> Result<EncodedQuad> {
         Ok(EncodedQuad {
             subject: self.encode_named_or_blank_node(quad.subject())?,
             predicate: self.encode_named_node(quad.predicate())?,
@@ -870,7 +789,7 @@ impl<S: StrContainer> Encoder for S {
     }
 
     fn encode_triple_in_graph(
-        &self,
+        &mut self,
         triple: &Triple,
         graph_name: EncodedTerm,
     ) -> Result<EncodedQuad> {
@@ -882,14 +801,81 @@ impl<S: StrContainer> Encoder for S {
         })
     }
 
-    fn encode_rio_named_node(&self, named_node: rio::NamedNode) -> Result<EncodedTerm> {
+    fn encode_rio_named_node(&mut self, named_node: rio::NamedNode) -> Result<EncodedTerm>;
+
+    fn encode_rio_blank_node(
+        &mut self,
+        blank_node: rio::BlankNode,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedTerm>;
+
+    fn encode_rio_literal(&mut self, literal: rio::Literal) -> Result<EncodedTerm>;
+
+    fn encode_rio_named_or_blank_node(
+        &mut self,
+        term: rio::NamedOrBlankNode,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedTerm> {
+        match term {
+            rio::NamedOrBlankNode::NamedNode(named_node) => self.encode_rio_named_node(named_node),
+            rio::NamedOrBlankNode::BlankNode(blank_node) => {
+                self.encode_rio_blank_node(blank_node, bnodes_map)
+            }
+        }
+    }
+
+    fn encode_rio_term(
+        &mut self,
+        term: rio::Term,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedTerm> {
+        match term {
+            rio::Term::NamedNode(named_node) => self.encode_rio_named_node(named_node),
+            rio::Term::BlankNode(blank_node) => self.encode_rio_blank_node(blank_node, bnodes_map),
+            rio::Term::Literal(literal) => self.encode_rio_literal(literal),
+        }
+    }
+
+    fn encode_rio_quad(
+        &mut self,
+        quad: rio::Quad,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedQuad> {
+        Ok(EncodedQuad {
+            subject: self.encode_rio_named_or_blank_node(quad.subject, bnodes_map)?,
+            predicate: self.encode_rio_named_node(quad.predicate)?,
+            object: self.encode_rio_term(quad.object, bnodes_map)?,
+            graph_name: match quad.graph_name {
+                Some(graph_name) => self.encode_rio_named_or_blank_node(graph_name, bnodes_map)?,
+                None => ENCODED_DEFAULT_GRAPH,
+            },
+        })
+    }
+
+    fn encode_rio_triple_in_graph(
+        &mut self,
+        triple: rio::Triple,
+        graph_name: EncodedTerm,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedQuad> {
+        Ok(EncodedQuad {
+            subject: self.encode_rio_named_or_blank_node(triple.subject, bnodes_map)?,
+            predicate: self.encode_rio_named_node(triple.predicate)?,
+            object: self.encode_rio_term(triple.object, bnodes_map)?,
+            graph_name,
+        })
+    }
+}
+
+impl<S: StrContainer> Encoder for S {
+    fn encode_rio_named_node(&mut self, named_node: rio::NamedNode) -> Result<EncodedTerm> {
         let iri_id = get_str_id(named_node.iri);
         self.insert_str(iri_id, named_node.iri)?;
         Ok(EncodedTerm::NamedNode { iri_id })
     }
 
     fn encode_rio_blank_node(
-        &self,
+        &mut self,
         blank_node: rio::BlankNode,
         bnodes_map: &mut HashMap<String, u128>,
     ) -> Result<EncodedTerm> {
@@ -902,7 +888,7 @@ impl<S: StrContainer> Encoder for S {
         })
     }
 
-    fn encode_rio_literal(&self, literal: rio::Literal) -> Result<EncodedTerm> {
+    fn encode_rio_literal(&mut self, literal: rio::Literal) -> Result<EncodedTerm> {
         Ok(match literal {
             rio::Literal::Simple { value } => {
                 let value_id = get_str_id(value);
@@ -978,61 +964,6 @@ impl<S: StrContainer> Encoder for S {
             }
         })
     }
-
-    fn encode_rio_named_or_blank_node(
-        &self,
-        term: rio::NamedOrBlankNode,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm> {
-        match term {
-            rio::NamedOrBlankNode::NamedNode(named_node) => self.encode_rio_named_node(named_node),
-            rio::NamedOrBlankNode::BlankNode(blank_node) => {
-                self.encode_rio_blank_node(blank_node, bnodes_map)
-            }
-        }
-    }
-
-    fn encode_rio_term(
-        &self,
-        term: rio::Term,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm> {
-        match term {
-            rio::Term::NamedNode(named_node) => self.encode_rio_named_node(named_node),
-            rio::Term::BlankNode(blank_node) => self.encode_rio_blank_node(blank_node, bnodes_map),
-            rio::Term::Literal(literal) => self.encode_rio_literal(literal),
-        }
-    }
-
-    fn encode_rio_quad(
-        &self,
-        quad: rio::Quad,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedQuad> {
-        Ok(EncodedQuad {
-            subject: self.encode_rio_named_or_blank_node(quad.subject, bnodes_map)?,
-            predicate: self.encode_rio_named_node(quad.predicate)?,
-            object: self.encode_rio_term(quad.object, bnodes_map)?,
-            graph_name: match quad.graph_name {
-                Some(graph_name) => self.encode_rio_named_or_blank_node(graph_name, bnodes_map)?,
-                None => ENCODED_DEFAULT_GRAPH,
-            },
-        })
-    }
-
-    fn encode_rio_triple_in_graph(
-        &self,
-        triple: rio::Triple,
-        graph_name: EncodedTerm,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedQuad> {
-        Ok(EncodedQuad {
-            subject: self.encode_rio_named_or_blank_node(triple.subject, bnodes_map)?,
-            predicate: self.encode_rio_named_node(triple.predicate)?,
-            object: self.encode_rio_term(triple.object, bnodes_map)?,
-            graph_name,
-        })
-    }
 }
 
 pub fn parse_boolean_str(value: &str) -> Option<EncodedTerm> {
@@ -1190,7 +1121,7 @@ impl<S: StrLookup> Decoder for S {
     }
 }
 
-fn get_required_str<S: StrLookup>(lookup: S, id: u128) -> Result<S::StrType> {
+fn get_required_str<S: StrLookup>(lookup: &S, id: u128) -> Result<S::StrType> {
     lookup.get_str(id)?.ok_or_else(|| {
         format_err!(
             "Not able to find the string with id {} in the string store",
@@ -1199,23 +1130,9 @@ fn get_required_str<S: StrLookup>(lookup: S, id: u128) -> Result<S::StrType> {
     })
 }
 
-#[derive(Debug, Fail)]
-#[fail(display = "Mutex Mutex was poisoned")]
-pub struct MutexPoisonError {
-    backtrace: Backtrace,
-}
-
-impl<T> From<PoisonError<T>> for MutexPoisonError {
-    fn from(_: PoisonError<T>) -> Self {
-        Self {
-            backtrace: Backtrace::new(),
-        }
-    }
-}
-
 #[test]
 fn test_encoding() {
-    let store = MemoryStrStore::default();
+    let mut store = MemoryStrStore::default();
     let terms: Vec<Term> = vec![
         NamedNode::new_from_string("http://foo.com").into(),
         NamedNode::new_from_string("http://bar.com").into(),

lib/src/store/rocksdb.rs

@@ -146,7 +146,7 @@ impl StrLookup for RocksDbStoreConnection<'_> {
 }
 
 impl StrContainer for RocksDbStoreConnection<'_> {
-    fn insert_str(&self, key: u128, value: &str) -> Result<()> {
+    fn insert_str(&mut self, key: u128, value: &str) -> Result<()> {
         self.store
             .db
             .put_cf(self.id2str_cf, &key.to_le_bytes(), value)?;