diff --git a/lib/src/sparql/dataset.rs b/lib/src/sparql/dataset.rs
new file mode 100644
index 00000000..abaa7936
--- /dev/null
+++ b/lib/src/sparql/dataset.rs
@@ -0,0 +1,173 @@
+use crate::sparql::EvaluationError;
+use crate::store::numeric_encoder::{
+    EncodedQuad, EncodedTerm, MemoryStrStore, StrContainer, StrHash, StrId, StrLookup,
+    WithStoreError,
+};
+use crate::store::ReadableEncodedStore;
+use std::cell::RefCell;
+use std::iter::empty;
+
+pub(crate) struct DatasetView<S: ReadableEncodedStore> {
+    store: S,
+    extra: RefCell<MemoryStrStore>,
+    default_graph_as_union: bool,
+}
+
+impl<S: ReadableEncodedStore> DatasetView<S> {
+    pub fn new(store: S, default_graph_as_union: bool) -> Self {
+        Self {
+            store,
+            extra: RefCell::new(MemoryStrStore::default()),
+            default_graph_as_union,
+        }
+    }
+}
+
+impl<S: ReadableEncodedStore> WithStoreError for DatasetView<S> {
+    type Error = EvaluationError;
+    type StrId = DatasetStrId<S::StrId>;
+}
+
+impl<S: ReadableEncodedStore> StrLookup for DatasetView<S> {
+    fn get_str(&self, id: DatasetStrId<S::StrId>) -> Result<Option<String>, EvaluationError> {
+        match id {
+            DatasetStrId::Store(id) => self.store.get_str(id).map_err(|e| e.into()),
+            DatasetStrId::Temporary(id) => Ok(self.extra.borrow().get_str(id)?),
+        }
+    }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<DatasetStrId<S::StrId>>, EvaluationError> {
+        if let Some(id) = self.extra.borrow().get_str_id(value)? {
+            Ok(Some(DatasetStrId::Temporary(id)))
+        } else {
+            Ok(self
+                .store
+                .get_str_id(value)
+                .map_err(|e| e.into())?
+                .map(DatasetStrId::Store))
+        }
+    }
+}
+
+impl<S: ReadableEncodedStore> ReadableEncodedStore for DatasetView<S> {
+    type QuadsIter =
+        Box<dyn Iterator<Item = Result<EncodedQuad<DatasetStrId<S::StrId>>, EvaluationError>>>;
+
+    fn encoded_quads_for_pattern(
+        &self,
+        subject: Option<EncodedTerm<Self::StrId>>,
+        predicate: Option<EncodedTerm<Self::StrId>>,
+        object: Option<EncodedTerm<Self::StrId>>,
+        graph_name: Option<EncodedTerm<Self::StrId>>,
+    ) -> Box<dyn Iterator<Item = Result<EncodedQuad<DatasetStrId<S::StrId>>, EvaluationError>>>
+    {
+        if let Some((subject, predicate, object, graph_name)) =
+            try_map_quad_pattern(subject, predicate, object, graph_name)
+        {
+            if graph_name == None {
+                Box::new(
+                    map_iter(
+                        self.store
+                            .encoded_quads_for_pattern(subject, predicate, object, None),
+                    )
+                    .filter(|quad| match quad {
+                        Err(_) => true,
+                        Ok(quad) => quad.graph_name != EncodedTerm::DefaultGraph,
+                    }),
+                )
+            } else if graph_name == Some(EncodedTerm::DefaultGraph) && self.default_graph_as_union {
+                Box::new(
+                    map_iter(
+                        self.store
+                            .encoded_quads_for_pattern(subject, predicate, object, None),
+                    )
+                    .map(|quad| {
+                        let quad = quad?;
+                        Ok(EncodedQuad::new(
+                            quad.subject,
+                            quad.predicate,
+                            quad.object,
+                            EncodedTerm::DefaultGraph,
+                        ))
+                    }),
+                )
+            } else {
+                Box::new(map_iter(self.store.encoded_quads_for_pattern(
+                    subject, predicate, object, graph_name,
+                )))
+            }
+        } else {
+            Box::new(empty())
+        }
+    }
+}
+
+fn map_iter<'a, I: StrId>(
+    iter: impl Iterator<Item = Result<EncodedQuad<I>, impl Into<EvaluationError>>> + 'a,
+) -> impl Iterator<Item = Result<EncodedQuad<DatasetStrId<I>>, EvaluationError>> + 'a {
+    iter.map(|t| {
+        t.map(|q| EncodedQuad {
+            subject: q.subject.map_id(DatasetStrId::Store),
+            predicate: q.predicate.map_id(DatasetStrId::Store),
+            object: q.object.map_id(DatasetStrId::Store),
+            graph_name: q.graph_name.map_id(DatasetStrId::Store),
+        })
+        .map_err(|e| e.into())
+    })
+}
+
+type QuadPattern<I> = (
+    Option<EncodedTerm<I>>,
+    Option<EncodedTerm<I>>,
+    Option<EncodedTerm<I>>,
+    Option<EncodedTerm<I>>,
+);
+
+fn try_map_quad_pattern<I: StrId>(
+    subject: Option<EncodedTerm<DatasetStrId<I>>>,
+    predicate: Option<EncodedTerm<DatasetStrId<I>>>,
+    object: Option<EncodedTerm<DatasetStrId<I>>>,
+    graph_name: Option<EncodedTerm<DatasetStrId<I>>>,
+) -> Option<QuadPattern<I>> {
+    Some((
+        transpose(subject.map(|t| t.try_map_id(unwrap_store_id)))?,
+        transpose(predicate.map(|t| t.try_map_id(unwrap_store_id)))?,
+        transpose(object.map(|t| t.try_map_id(unwrap_store_id)))?,
+        transpose(graph_name.map(|t| t.try_map_id(unwrap_store_id)))?,
+    ))
+}
+
+fn transpose<T>(o: Option<Option<T>>) -> Option<Option<T>> {
+    match o {
+        Some(Some(v)) => Some(Some(v)),
+        Some(None) => None,
+        None => Some(None),
+    }
+}
+
+fn unwrap_store_id<I: StrId>(id: DatasetStrId<I>) -> Option<I> {
+    match id {
+        DatasetStrId::Store(id) => Some(id),
+        DatasetStrId::Temporary(_) => None,
+    }
+}
+
+impl<'a, S: ReadableEncodedStore> StrContainer for &'a DatasetView<S> {
+    fn insert_str(&mut self, value: &str) -> Result<Self::StrId, EvaluationError> {
+        if let Some(id) = self.store.get_str_id(value).map_err(|e| e.into())? {
+            Ok(DatasetStrId::Store(id))
+        } else {
+            Ok(DatasetStrId::Temporary(
+                self.extra.borrow_mut().insert_str(value)?,
+            ))
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Debug, Copy, Clone, Hash)]
+pub enum DatasetStrId<I: StrId> {
+    Store(I),
+    Temporary(StrHash),
+}
+
+impl<I: StrId> StrId for DatasetStrId<I> {}
diff --git a/lib/src/sparql/eval.rs b/lib/src/sparql/eval.rs
index c2dc2f93..0499bc6c 100644
--- a/lib/src/sparql/eval.rs
+++ b/lib/src/sparql/eval.rs
@@ -28,16 +28,16 @@ use std::str;
 
 const REGEX_SIZE_LIMIT: usize = 1_000_000;
 
-type EncodedTuplesIterator = Box<dyn Iterator<Item = Result<EncodedTuple, EvaluationError>>>;
+type EncodedTuplesIterator<I> = Box<dyn Iterator<Item = Result<EncodedTuple<I>, EvaluationError>>>;
 
-pub(crate) struct SimpleEvaluator<S: ReadableEncodedStore + 'static> {
-    dataset: Rc<DatasetView<S>>,
+pub(crate) struct SimpleEvaluator<S> {
+    dataset: Rc<S>,
     base_iri: Option<Rc<Iri<String>>>,
     now: DateTime,
     service_handler: Rc<dyn ServiceHandler<Error = EvaluationError>>,
 }
 
-impl<S: ReadableEncodedStore + 'static> Clone for SimpleEvaluator<S> {
+impl<S> Clone for SimpleEvaluator<S> {
     fn clone(&self) -> Self {
         Self {
             dataset: self.dataset.clone(),
@@ -48,9 +48,12 @@ impl<S: ReadableEncodedStore + 'static> Clone for SimpleEvaluator<S> {
     }
 }
 
-impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> SimpleEvaluator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
     pub fn new(
-        dataset: Rc<DatasetView<S>>,
+        dataset: Rc<S>,
         base_iri: Option<Rc<Iri<String>>>,
         service_handler: Rc<dyn ServiceHandler<Error = EvaluationError>>,
     ) -> Self {
@@ -64,7 +67,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     pub fn evaluate_select_plan(
         &self,
-        plan: &PlanNode,
+        plan: &PlanNode<S::StrId>,
         variables: Rc<Vec<Variable>>,
     ) -> Result<QueryResult, EvaluationError> {
         let iter = self.eval_plan(plan, EncodedTuple::with_capacity(variables.len()));
@@ -73,7 +76,10 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         ))
     }
 
-    pub fn evaluate_ask_plan(&self, plan: &PlanNode) -> Result<QueryResult, EvaluationError> {
+    pub fn evaluate_ask_plan(
+        &self,
+        plan: &PlanNode<S::StrId>,
+    ) -> Result<QueryResult, EvaluationError> {
         let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len());
         match self.eval_plan(plan, from).next() {
             Some(Ok(_)) => Ok(QueryResult::Boolean(true)),
@@ -84,8 +90,8 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     pub fn evaluate_construct_plan(
         &self,
-        plan: &PlanNode,
-        construct: Rc<Vec<TripleTemplate>>,
+        plan: &PlanNode<S::StrId>,
+        construct: Rc<Vec<TripleTemplate<S::StrId>>>,
     ) -> Result<QueryResult, EvaluationError> {
         let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len());
         Ok(QueryResult::Graph(QueryTriplesIterator {
@@ -99,7 +105,10 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }))
     }
 
-    pub fn evaluate_describe_plan(&self, plan: &PlanNode) -> Result<QueryResult, EvaluationError> {
+    pub fn evaluate_describe_plan(
+        &self,
+        plan: &PlanNode<S::StrId>,
+    ) -> Result<QueryResult, EvaluationError> {
         let from = EncodedTuple::with_capacity(plan.maybe_bound_variables().len());
         Ok(QueryResult::Graph(QueryTriplesIterator {
             iter: Box::new(DescribeIterator {
@@ -110,7 +119,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }))
     }
 
-    fn eval_plan(&self, node: &PlanNode, from: EncodedTuple) -> EncodedTuplesIterator {
+    fn eval_plan(
+        &self,
+        node: &PlanNode<S::StrId>,
+        from: EncodedTuple<S::StrId>,
+    ) -> EncodedTuplesIterator<S::StrId> {
         match node {
             PlanNode::Init => Box::new(once(Ok(from))),
             PlanNode::StaticBindings { tuples } => Box::new(tuples.clone().into_iter().map(Ok)),
@@ -152,12 +165,13 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 let object = *object;
                 let graph_name = *graph_name;
                 Box::new(self.eval_plan(child, from).flat_map_ok(move |tuple| {
-                    let mut iter = eval.dataset.quads_for_pattern(
-                        get_pattern_value(&subject, &tuple),
-                        get_pattern_value(&predicate, &tuple),
-                        get_pattern_value(&object, &tuple),
-                        get_pattern_value(&graph_name, &tuple),
-                    );
+                    let mut iter: Box<dyn Iterator<Item = _>> =
+                        Box::new(eval.dataset.encoded_quads_for_pattern(
+                            get_pattern_value(&subject, &tuple),
+                            get_pattern_value(&predicate, &tuple),
+                            get_pattern_value(&object, &tuple),
+                            get_pattern_value(&graph_name, &tuple),
+                        ));
                     if subject.is_var() && subject == predicate {
                         iter = Box::new(iter.filter(|quad| match quad {
                             Err(_) => true,
@@ -196,7 +210,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                             }))
                         }
                     }
-                    let iter: EncodedTuplesIterator = Box::new(iter.map(move |quad| {
+                    let iter: EncodedTuplesIterator<_> = Box::new(iter.map(move |quad| {
                         let quad = quad?;
                         let mut new_tuple = tuple.clone();
                         put_pattern_value(&subject, quad.subject, &mut new_tuple);
@@ -227,7 +241,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                         if let Some(graph_name) = get_pattern_value(&graph_name, &tuple) {
                             graph_name
                         } else {
-                            let result: EncodedTuplesIterator =
+                            let result: EncodedTuplesIterator<_> =
                             Box::new(once(Err(EvaluationError::msg(
                                 "Unknown graph name is not allowed when evaluating property path",
                             ))));
@@ -431,8 +445,10 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 let key_mapping = key_mapping.clone();
                 let aggregates = aggregates.clone();
                 let mut errors = Vec::default();
-                let mut accumulators_for_group =
-                    HashMap::<Vec<Option<EncodedTerm>>, Vec<Box<dyn Accumulator>>>::default();
+                let mut accumulators_for_group = HashMap::<
+                    Vec<Option<EncodedTerm<S::StrId>>>,
+                    Vec<Box<dyn Accumulator<S::StrId>>>,
+                >::default();
                 self.eval_plan(child, from)
                     .filter_map(|result| match result {
                         Ok(result) => Some(result),
@@ -498,11 +514,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn evaluate_service(
         &self,
-        service_name: &PatternValue,
+        service_name: &PatternValue<S::StrId>,
         graph_pattern: Rc<GraphPattern>,
         variables: Rc<Vec<Variable>>,
-        from: &EncodedTuple,
-    ) -> Result<EncodedTuplesIterator, EvaluationError> {
+        from: &EncodedTuple<S::StrId>,
+    ) -> Result<EncodedTuplesIterator<S::StrId>, EvaluationError> {
         if let QueryResult::Solutions(iter) = self.service_handler.handle(
             self.dataset.decode_named_node(
                 get_pattern_value(service_name, from)
@@ -526,7 +542,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         &self,
         function: &PlanAggregationFunction,
         distinct: bool,
-    ) -> Box<dyn Accumulator + 'static> {
+    ) -> Box<dyn Accumulator<S::StrId> + 'static> {
         match function {
             PlanAggregationFunction::Count => {
                 if distinct {
@@ -567,14 +583,14 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn eval_path_from(
         &self,
-        path: &PlanPropertyPath,
-        start: EncodedTerm,
-        graph_name: EncodedTerm,
-    ) -> Box<dyn Iterator<Item = Result<EncodedTerm, EvaluationError>>> {
+        path: &PlanPropertyPath<S::StrId>,
+        start: EncodedTerm<S::StrId>,
+        graph_name: EncodedTerm<S::StrId>,
+    ) -> Box<dyn Iterator<Item = Result<EncodedTerm<S::StrId>, EvaluationError>>> {
         match path {
             PlanPropertyPath::PredicatePath(p) => Box::new(
                 self.dataset
-                    .quads_for_pattern(Some(start), Some(*p), None, Some(graph_name))
+                    .encoded_quads_for_pattern(Some(start), Some(*p), None, Some(graph_name))
                     .map(|t| Ok(t?.object)),
             ),
             PlanPropertyPath::InversePath(p) => self.eval_path_to(p, start, graph_name),
@@ -612,7 +628,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 let ps = ps.clone();
                 Box::new(
                     self.dataset
-                        .quads_for_pattern(Some(start), None, None, Some(graph_name))
+                        .encoded_quads_for_pattern(Some(start), None, None, Some(graph_name))
                         .filter_map(move |t| match t {
                             Ok(t) => {
                                 if ps.contains(&t.predicate) {
@@ -630,14 +646,14 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn eval_path_to(
         &self,
-        path: &PlanPropertyPath,
-        end: EncodedTerm,
-        graph_name: EncodedTerm,
-    ) -> Box<dyn Iterator<Item = Result<EncodedTerm, EvaluationError>>> {
+        path: &PlanPropertyPath<S::StrId>,
+        end: EncodedTerm<S::StrId>,
+        graph_name: EncodedTerm<S::StrId>,
+    ) -> Box<dyn Iterator<Item = Result<EncodedTerm<S::StrId>, EvaluationError>>> {
         match path {
             PlanPropertyPath::PredicatePath(p) => Box::new(
                 self.dataset
-                    .quads_for_pattern(None, Some(*p), Some(end), Some(graph_name))
+                    .encoded_quads_for_pattern(None, Some(*p), Some(end), Some(graph_name))
                     .map(|t| Ok(t?.subject)),
             ),
             PlanPropertyPath::InversePath(p) => self.eval_path_from(p, end, graph_name),
@@ -675,7 +691,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 let ps = ps.clone();
                 Box::new(
                     self.dataset
-                        .quads_for_pattern(None, None, Some(end), Some(graph_name))
+                        .encoded_quads_for_pattern(None, None, Some(end), Some(graph_name))
                         .filter_map(move |t| match t {
                             Ok(t) => {
                                 if ps.contains(&t.predicate) {
@@ -693,13 +709,17 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn eval_open_path(
         &self,
-        path: &PlanPropertyPath,
-        graph_name: EncodedTerm,
-    ) -> Box<dyn Iterator<Item = Result<(EncodedTerm, EncodedTerm), EvaluationError>>> {
+        path: &PlanPropertyPath<S::StrId>,
+        graph_name: EncodedTerm<S::StrId>,
+    ) -> Box<
+        dyn Iterator<
+            Item = Result<(EncodedTerm<S::StrId>, EncodedTerm<S::StrId>), EvaluationError>,
+        >,
+    > {
         match path {
             PlanPropertyPath::PredicatePath(p) => Box::new(
                 self.dataset
-                    .quads_for_pattern(None, Some(*p), None, Some(graph_name))
+                    .encoded_quads_for_pattern(None, Some(*p), None, Some(graph_name))
                     .map(|t| t.map(|t| (t.subject, t.object))),
             ),
             PlanPropertyPath::InversePath(p) => Box::new(
@@ -751,7 +771,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 let ps = ps.clone();
                 Box::new(
                     self.dataset
-                        .quads_for_pattern(None, None, None, Some(graph_name))
+                        .encoded_quads_for_pattern(None, None, None, Some(graph_name))
                         .filter_map(move |t| match t {
                             Ok(t) => {
                                 if ps.contains(&t.predicate) {
@@ -769,10 +789,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn get_subject_or_object_identity_pairs(
         &self,
-        graph_name: EncodedTerm,
-    ) -> impl Iterator<Item = Result<(EncodedTerm, EncodedTerm), EvaluationError>> {
+        graph_name: EncodedTerm<S::StrId>,
+    ) -> impl Iterator<Item = Result<(EncodedTerm<S::StrId>, EncodedTerm<S::StrId>), EvaluationError>>
+    {
         self.dataset
-            .quads_for_pattern(None, None, None, Some(graph_name))
+            .encoded_quads_for_pattern(None, None, None, Some(graph_name))
             .flat_map_ok(|t| once(Ok(t.subject)).chain(once(Ok(t.object))))
             .map(|e| e.map(|e| (e, e)))
     }
@@ -780,9 +801,9 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
     #[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)]
     fn eval_expression(
         &self,
-        expression: &PlanExpression,
-        tuple: &EncodedTuple,
-    ) -> Option<EncodedTerm> {
+        expression: &PlanExpression<S::StrId>,
+        tuple: &EncodedTuple<S::StrId>,
+    ) -> Option<EncodedTerm<S::StrId>> {
         match expression {
             PlanExpression::Constant(t) => Some(*t),
             PlanExpression::Variable(v) => tuple.get(*v),
@@ -1040,11 +1061,12 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 }
             }
             PlanExpression::BNode(id) => match id {
-                Some(id) => Some(
-                    (&BlankNode::new(self.to_simple_string(self.eval_expression(id, tuple)?)?)
-                        .ok()?)
-                        .into(),
-                ),
+                Some(id) => {
+                    let bnode =
+                        BlankNode::new(self.to_simple_string(self.eval_expression(id, tuple)?)?)
+                            .ok()?;
+                    Some(self.dataset.as_ref().encode_blank_node(&bnode).ok()?)
+                }
                 None => Some(EncodedTerm::InlineBlankNode {
                     id: random::<u128>(),
                 }),
@@ -1340,8 +1362,8 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
                 } else {
                     None
                 }?;
-                self.dataset
-                    .encoder()
+                let mut encoder = self.dataset.as_ref();
+                encoder
                     .encode_rio_literal(rio::Literal::Typed {
                         value: &value,
                         datatype: rio::NamedNode { iri: &datatype },
@@ -1498,7 +1520,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn to_bool(&self, term: EncodedTerm) -> Option<bool> {
+    fn to_bool(&self, term: EncodedTerm<S::StrId>) -> Option<bool> {
         match term {
             EncodedTerm::BooleanLiteral(value) => Some(value),
             EncodedTerm::StringLiteral { value_id } => {
@@ -1512,7 +1534,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn to_string_id(&self, term: EncodedTerm) -> Option<StrHash> {
+    fn to_string_id(&self, term: EncodedTerm<S::StrId>) -> Option<S::StrId> {
         match term {
             EncodedTerm::DefaultGraph => None,
             EncodedTerm::NamedNode { iri_id } => Some(iri_id),
@@ -1538,7 +1560,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn to_simple_string(&self, term: EncodedTerm) -> Option<String> {
+    fn to_simple_string(&self, term: EncodedTerm<S::StrId>) -> Option<String> {
         if let EncodedTerm::StringLiteral { value_id } = term {
             self.dataset.get_str(value_id).ok()?
         } else {
@@ -1546,7 +1568,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn to_simple_string_id(&self, term: EncodedTerm) -> Option<StrHash> {
+    fn to_simple_string_id(&self, term: EncodedTerm<S::StrId>) -> Option<S::StrId> {
         if let EncodedTerm::StringLiteral { value_id } = term {
             Some(value_id)
         } else {
@@ -1554,7 +1576,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn to_string(&self, term: EncodedTerm) -> Option<String> {
+    fn to_string(&self, term: EncodedTerm<S::StrId>) -> Option<String> {
         match term {
             EncodedTerm::StringLiteral { value_id }
             | EncodedTerm::LangStringLiteral { value_id, .. } => {
@@ -1564,7 +1586,10 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn to_string_and_language(&self, term: EncodedTerm) -> Option<(String, Option<StrHash>)> {
+    fn to_string_and_language(
+        &self,
+        term: EncodedTerm<S::StrId>,
+    ) -> Option<(String, Option<S::StrId>)> {
         match term {
             EncodedTerm::StringLiteral { value_id } => {
                 Some((self.dataset.get_str(value_id).ok()??, None))
@@ -1577,26 +1602,34 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn build_named_node(&self, iri: &str) -> Option<EncodedTerm> {
+    fn build_named_node(&self, iri: &str) -> Option<EncodedTerm<S::StrId>> {
         Some(EncodedTerm::NamedNode {
             iri_id: self.build_string_id(iri)?,
         })
     }
 
-    fn build_string_literal(&self, value: &str) -> Option<EncodedTerm> {
+    fn build_string_literal(&self, value: &str) -> Option<EncodedTerm<S::StrId>> {
         Some(EncodedTerm::StringLiteral {
             value_id: self.build_string_id(value)?,
         })
     }
 
-    fn build_lang_string_literal(&self, value: &str, language_id: StrHash) -> Option<EncodedTerm> {
+    fn build_lang_string_literal(
+        &self,
+        value: &str,
+        language_id: S::StrId,
+    ) -> Option<EncodedTerm<S::StrId>> {
         Some(EncodedTerm::LangStringLiteral {
             value_id: self.build_string_id(value)?,
             language_id,
         })
     }
 
-    fn build_plain_literal(&self, value: &str, language: Option<StrHash>) -> Option<EncodedTerm> {
+    fn build_plain_literal(
+        &self,
+        value: &str,
+        language: Option<S::StrId>,
+    ) -> Option<EncodedTerm<S::StrId>> {
         if let Some(language_id) = language {
             self.build_lang_string_literal(value, language_id)
         } else {
@@ -1604,11 +1637,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn build_string_id(&self, value: &str) -> Option<StrHash> {
-        self.dataset.encoder().insert_str(value).ok()
+    fn build_string_id(&self, value: &str) -> Option<S::StrId> {
+        self.dataset.as_ref().encode_str(value).ok()
     }
 
-    fn build_language_id(&self, value: EncodedTerm) -> Option<StrHash> {
+    fn build_language_id(&self, value: EncodedTerm<S::StrId>) -> Option<S::StrId> {
         let mut language = self.to_simple_string(value)?;
         language.make_ascii_lowercase();
         self.build_string_id(LanguageTag::parse(language).ok()?.as_str())
@@ -1616,9 +1649,9 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn to_argument_compatible_strings(
         &self,
-        arg1: EncodedTerm,
-        arg2: EncodedTerm,
-    ) -> Option<(String, String, Option<StrHash>)> {
+        arg1: EncodedTerm<S::StrId>,
+        arg2: EncodedTerm<S::StrId>,
+    ) -> Option<(String, String, Option<S::StrId>)> {
         let (value1, language1) = self.to_string_and_language(arg1)?;
         let (value2, language2) = self.to_string_and_language(arg2)?;
         if language2.is_none() || language1 == language2 {
@@ -1628,7 +1661,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn compile_pattern(&self, pattern: EncodedTerm, flags: Option<EncodedTerm>) -> Option<Regex> {
+    fn compile_pattern(
+        &self,
+        pattern: EncodedTerm<S::StrId>,
+        flags: Option<EncodedTerm<S::StrId>>,
+    ) -> Option<Regex> {
         // TODO Avoid to compile the regex each time
         let pattern = self.to_simple_string(pattern)?;
         let mut regex_builder = RegexBuilder::new(&pattern);
@@ -1659,9 +1696,9 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn parse_numeric_operands(
         &self,
-        e1: &PlanExpression,
-        e2: &PlanExpression,
-        tuple: &EncodedTuple,
+        e1: &PlanExpression<S::StrId>,
+        e2: &PlanExpression<S::StrId>,
+        tuple: &EncodedTuple<S::StrId>,
     ) -> Option<NumericBinaryOperands> {
         NumericBinaryOperands::new(
             self.eval_expression(e1, tuple)?,
@@ -1671,7 +1708,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn decode_bindings(
         &self,
-        iter: EncodedTuplesIterator,
+        iter: EncodedTuplesIterator<S::StrId>,
         variables: Rc<Vec<Variable>>,
     ) -> QuerySolutionsIterator {
         let eval = self.clone();
@@ -1695,10 +1732,10 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         &self,
         variables: Rc<Vec<Variable>>,
         iter: QuerySolutionsIterator,
-    ) -> EncodedTuplesIterator {
+    ) -> EncodedTuplesIterator<S::StrId> {
         let eval = self.clone();
         Box::new(iter.map(move |solution| {
-            let mut encoder = eval.dataset.encoder();
+            let mut encoder = eval.dataset.as_ref();
             let mut encoded_terms = EncodedTuple::with_capacity(variables.len());
             for (variable, term) in solution?.iter() {
                 put_variable_value(
@@ -1717,7 +1754,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         clippy::cast_possible_truncation,
         clippy::cast_precision_loss
     )]
-    fn equals(&self, a: EncodedTerm, b: EncodedTerm) -> Option<bool> {
+    fn equals(&self, a: EncodedTerm<S::StrId>, b: EncodedTerm<S::StrId>) -> Option<bool> {
         match a {
             EncodedTerm::DefaultGraph
             | EncodedTerm::NamedNode { .. }
@@ -1815,9 +1852,9 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
 
     fn cmp_according_to_expression(
         &self,
-        tuple_a: &EncodedTuple,
-        tuple_b: &EncodedTuple,
-        expression: &PlanExpression,
+        tuple_a: &EncodedTuple<S::StrId>,
+        tuple_b: &EncodedTuple<S::StrId>,
+        expression: &PlanExpression<S::StrId>,
     ) -> Ordering {
         self.cmp_terms(
             self.eval_expression(expression, tuple_a),
@@ -1825,7 +1862,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         )
     }
 
-    fn cmp_terms(&self, a: Option<EncodedTerm>, b: Option<EncodedTerm>) -> Ordering {
+    fn cmp_terms(
+        &self,
+        a: Option<EncodedTerm<S::StrId>>,
+        b: Option<EncodedTerm<S::StrId>>,
+    ) -> Ordering {
         match (a, b) {
             (Some(a), Some(b)) => match a {
                 EncodedTerm::InlineBlankNode { .. } | EncodedTerm::NamedBlankNode { .. } => {
@@ -1858,7 +1899,11 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
     }
 
     #[allow(clippy::cast_precision_loss)]
-    fn partial_cmp_literals(&self, a: EncodedTerm, b: EncodedTerm) -> Option<Ordering> {
+    fn partial_cmp_literals(
+        &self,
+        a: EncodedTerm<S::StrId>,
+        b: EncodedTerm<S::StrId>,
+    ) -> Option<Ordering> {
         match a {
             EncodedTerm::StringLiteral { value_id: a } => {
                 if let EncodedTerm::StringLiteral { value_id: b } = b {
@@ -1938,7 +1983,7 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         }
     }
 
-    fn compare_str_ids(&self, a: StrHash, b: StrHash) -> Option<Ordering> {
+    fn compare_str_ids(&self, a: S::StrId, b: S::StrId) -> Option<Ordering> {
         Some(
             self.dataset
                 .get_str(a)
@@ -1947,13 +1992,17 @@ impl<S: ReadableEncodedStore + 'static> SimpleEvaluator<S> {
         )
     }
 
-    fn hash<H: Digest>(&self, arg: &PlanExpression, tuple: &EncodedTuple) -> Option<EncodedTerm> {
+    fn hash<H: Digest>(
+        &self,
+        arg: &PlanExpression<S::StrId>,
+        tuple: &EncodedTuple<S::StrId>,
+    ) -> Option<EncodedTerm<S::StrId>> {
         let input = self.to_simple_string(self.eval_expression(arg, tuple)?)?;
         let hash = hex::encode(H::new().chain(input.as_str()).finalize());
         self.build_string_literal(&hash)
     }
 
-    fn datatype(&self, value: EncodedTerm) -> Option<EncodedTerm> {
+    fn datatype(&self, value: EncodedTerm<S::StrId>) -> Option<EncodedTerm<S::StrId>> {
         //TODO: optimize?
         match value {
             EncodedTerm::NamedNode { .. }
@@ -2029,7 +2078,7 @@ enum NumericBinaryOperands {
 
 impl NumericBinaryOperands {
     #[allow(clippy::cast_precision_loss)]
-    fn new(a: EncodedTerm, b: EncodedTerm) -> Option<Self> {
+    fn new<I: StrId>(a: EncodedTerm<I>, b: EncodedTerm<I>) -> Option<Self> {
         match (a, b) {
             (EncodedTerm::FloatLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
                 Some(NumericBinaryOperands::Float(v1, v2))
@@ -2147,25 +2196,32 @@ impl NumericBinaryOperands {
     }
 }
 
-fn get_pattern_value(selector: &PatternValue, tuple: &EncodedTuple) -> Option<EncodedTerm> {
+fn get_pattern_value<I: StrId>(
+    selector: &PatternValue<I>,
+    tuple: &EncodedTuple<I>,
+) -> Option<EncodedTerm<I>> {
     match selector {
         PatternValue::Constant(term) => Some(*term),
         PatternValue::Variable(v) => tuple.get(*v),
     }
 }
 
-fn put_pattern_value(selector: &PatternValue, value: EncodedTerm, tuple: &mut EncodedTuple) {
+fn put_pattern_value<I: StrId>(
+    selector: &PatternValue<I>,
+    value: EncodedTerm<I>,
+    tuple: &mut EncodedTuple<I>,
+) {
     match selector {
         PatternValue::Constant(_) => (),
         PatternValue::Variable(v) => tuple.set(*v, value),
     }
 }
 
-fn put_variable_value(
+fn put_variable_value<I: StrId>(
     selector: &Variable,
     variables: &[Variable],
-    value: EncodedTerm,
-    tuple: &mut EncodedTuple,
+    value: EncodedTerm<I>,
+    tuple: &mut EncodedTuple<I>,
 ) {
     for (i, v) in variables.iter().enumerate() {
         if selector == v {
@@ -2175,13 +2231,17 @@ fn put_variable_value(
     }
 }
 
-fn unbind_variables(binding: &mut EncodedTuple, variables: &[usize]) {
+fn unbind_variables<I: StrId>(binding: &mut EncodedTuple<I>, variables: &[usize]) {
     for var in variables {
         binding.unset(*var)
     }
 }
 
-fn combine_tuples(mut a: EncodedTuple, b: &EncodedTuple, vars: &[usize]) -> Option<EncodedTuple> {
+fn combine_tuples<I: StrId>(
+    mut a: EncodedTuple<I>,
+    b: &EncodedTuple<I>,
+    vars: &[usize],
+) -> Option<EncodedTuple<I>> {
     for var in vars {
         if let Some(b_value) = b.get(*var) {
             if let Some(a_value) = a.get(*var) {
@@ -2196,7 +2256,10 @@ fn combine_tuples(mut a: EncodedTuple, b: &EncodedTuple, vars: &[usize]) -> Opti
     Some(a)
 }
 
-pub fn are_compatible_and_not_disjointed(a: &EncodedTuple, b: &EncodedTuple) -> bool {
+pub fn are_compatible_and_not_disjointed<I: StrId>(
+    a: &EncodedTuple<I>,
+    b: &EncodedTuple<I>,
+) -> bool {
     let mut found_intersection = false;
     for (a_value, b_value) in a.iter().zip(b.iter()) {
         if let (Some(a_value), Some(b_value)) = (a_value, b_value) {
@@ -2209,16 +2272,16 @@ pub fn are_compatible_and_not_disjointed(a: &EncodedTuple, b: &EncodedTuple) ->
     found_intersection
 }
 
-struct JoinIterator {
-    left: Vec<EncodedTuple>,
-    right_iter: EncodedTuplesIterator,
-    buffered_results: Vec<Result<EncodedTuple, EvaluationError>>,
+struct JoinIterator<I: StrId> {
+    left: Vec<EncodedTuple<I>>,
+    right_iter: EncodedTuplesIterator<I>,
+    buffered_results: Vec<Result<EncodedTuple<I>, EvaluationError>>,
 }
 
-impl Iterator for JoinIterator {
-    type Item = Result<EncodedTuple, EvaluationError>;
+impl<I: StrId> Iterator for JoinIterator<I> {
+    type Item = Result<EncodedTuple<I>, EvaluationError>;
 
-    fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> {
+    fn next(&mut self) -> Option<Result<EncodedTuple<I>, EvaluationError>> {
         loop {
             if let Some(result) = self.buffered_results.pop() {
                 return Some(result);
@@ -2236,15 +2299,15 @@ impl Iterator for JoinIterator {
     }
 }
 
-struct AntiJoinIterator {
-    left_iter: EncodedTuplesIterator,
-    right: Vec<EncodedTuple>,
+struct AntiJoinIterator<I: StrId> {
+    left_iter: EncodedTuplesIterator<I>,
+    right: Vec<EncodedTuple<I>>,
 }
 
-impl Iterator for AntiJoinIterator {
-    type Item = Result<EncodedTuple, EvaluationError>;
+impl<I: StrId> Iterator for AntiJoinIterator<I> {
+    type Item = Result<EncodedTuple<I>, EvaluationError>;
 
-    fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> {
+    fn next(&mut self) -> Option<Result<EncodedTuple<I>, EvaluationError>> {
         loop {
             match self.left_iter.next()? {
                 Ok(left_tuple) => {
@@ -2263,15 +2326,18 @@ impl Iterator for AntiJoinIterator {
 
 struct LeftJoinIterator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    right_plan: Rc<PlanNode>,
-    left_iter: EncodedTuplesIterator,
-    current_right: EncodedTuplesIterator,
+    right_plan: Rc<PlanNode<S::StrId>>,
+    left_iter: EncodedTuplesIterator<S::StrId>,
+    current_right: EncodedTuplesIterator<S::StrId>,
 }
 
-impl<S: ReadableEncodedStore + 'static> Iterator for LeftJoinIterator<S> {
-    type Item = Result<EncodedTuple, EvaluationError>;
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Iterator for LeftJoinIterator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
+    type Item = Result<EncodedTuple<S::StrId>, EvaluationError>;
 
-    fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> {
+    fn next(&mut self) -> Option<Result<EncodedTuple<S::StrId>, EvaluationError>> {
         if let Some(tuple) = self.current_right.next() {
             return Some(tuple);
         }
@@ -2291,17 +2357,20 @@ impl<S: ReadableEncodedStore + 'static> Iterator for LeftJoinIterator<S> {
 
 struct BadLeftJoinIterator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    right_plan: Rc<PlanNode>,
-    left_iter: EncodedTuplesIterator,
-    current_left: Option<EncodedTuple>,
-    current_right: EncodedTuplesIterator,
+    right_plan: Rc<PlanNode<S::StrId>>,
+    left_iter: EncodedTuplesIterator<S::StrId>,
+    current_left: Option<EncodedTuple<S::StrId>>,
+    current_right: EncodedTuplesIterator<S::StrId>,
     problem_vars: Rc<Vec<usize>>,
 }
 
-impl<S: ReadableEncodedStore + 'static> Iterator for BadLeftJoinIterator<S> {
-    type Item = Result<EncodedTuple, EvaluationError>;
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Iterator for BadLeftJoinIterator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
+    type Item = Result<EncodedTuple<S::StrId>, EvaluationError>;
 
-    fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> {
+    fn next(&mut self) -> Option<Result<EncodedTuple<S::StrId>, EvaluationError>> {
         while let Some(right_tuple) = self.current_right.next() {
             match right_tuple {
                 Ok(right_tuple) => {
@@ -2343,16 +2412,19 @@ impl<S: ReadableEncodedStore + 'static> Iterator for BadLeftJoinIterator<S> {
 
 struct UnionIterator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    plans: Vec<Rc<PlanNode>>,
-    input: EncodedTuple,
-    current_iterator: EncodedTuplesIterator,
+    plans: Vec<Rc<PlanNode<S::StrId>>>,
+    input: EncodedTuple<S::StrId>,
+    current_iterator: EncodedTuplesIterator<S::StrId>,
     current_plan: usize,
 }
 
-impl<S: ReadableEncodedStore + 'static> Iterator for UnionIterator<S> {
-    type Item = Result<EncodedTuple, EvaluationError>;
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Iterator for UnionIterator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
+    type Item = Result<EncodedTuple<S::StrId>, EvaluationError>;
 
-    fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> {
+    fn next(&mut self) -> Option<Result<EncodedTuple<S::StrId>, EvaluationError>> {
         loop {
             if let Some(tuple) = self.current_iterator.next() {
                 return Some(tuple);
@@ -2370,13 +2442,13 @@ impl<S: ReadableEncodedStore + 'static> Iterator for UnionIterator<S> {
 
 struct ConstructIterator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    iter: EncodedTuplesIterator,
-    template: Rc<Vec<TripleTemplate>>,
+    iter: EncodedTuplesIterator<S::StrId>,
+    template: Rc<Vec<TripleTemplate<S::StrId>>>,
     buffered_results: Vec<Result<Triple, EvaluationError>>,
-    bnodes: Vec<BlankNode>,
+    bnodes: Vec<EncodedTerm<S::StrId>>,
 }
 
-impl<S: ReadableEncodedStore + 'static> Iterator for ConstructIterator<S> {
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Iterator for ConstructIterator<S> {
     type Item = Result<Triple, EvaluationError>;
 
     fn next(&mut self) -> Option<Result<Triple, EvaluationError>> {
@@ -2409,28 +2481,32 @@ impl<S: ReadableEncodedStore + 'static> Iterator for ConstructIterator<S> {
     }
 }
 
-fn get_triple_template_value(
-    selector: &TripleTemplateValue,
-    tuple: &EncodedTuple,
-    bnodes: &mut Vec<BlankNode>,
-) -> Option<EncodedTerm> {
+fn get_triple_template_value<I: StrId>(
+    selector: &TripleTemplateValue<I>,
+    tuple: &EncodedTuple<I>,
+    bnodes: &mut Vec<EncodedTerm<I>>,
+) -> Option<EncodedTerm<I>> {
     match selector {
         TripleTemplateValue::Constant(term) => Some(*term),
         TripleTemplateValue::Variable(v) => tuple.get(*v),
         TripleTemplateValue::BlankNode(id) => {
             if *id >= bnodes.len() {
-                bnodes.resize_with(*id, BlankNode::default)
+                bnodes.resize_with(*id, new_bnode)
             }
-            Some((&bnodes[*id]).into())
+            Some(bnodes[*id])
         }
     }
 }
 
-fn decode_triple(
-    decoder: &impl Decoder,
-    subject: EncodedTerm,
-    predicate: EncodedTerm,
-    object: EncodedTerm,
+fn new_bnode<I: StrId>() -> EncodedTerm<I> {
+    EncodedTerm::InlineBlankNode { id: random() }
+}
+
+fn decode_triple<D: Decoder>(
+    decoder: &D,
+    subject: EncodedTerm<D::StrId>,
+    predicate: EncodedTerm<D::StrId>,
+    object: EncodedTerm<D::StrId>,
 ) -> Result<Triple, EvaluationError> {
     Ok(Triple::new(
         decoder.decode_named_or_blank_node(subject)?,
@@ -2441,11 +2517,11 @@ fn decode_triple(
 
 struct DescribeIterator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    iter: EncodedTuplesIterator,
-    quads: Box<dyn Iterator<Item = Result<EncodedQuad, EvaluationError>>>,
+    iter: EncodedTuplesIterator<S::StrId>,
+    quads: Box<dyn Iterator<Item = Result<EncodedQuad<S::StrId>, EvaluationError>>>,
 }
 
-impl<S: ReadableEncodedStore + 'static> Iterator for DescribeIterator<S> {
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Iterator for DescribeIterator<S> {
     type Item = Result<Triple, EvaluationError>;
 
     fn next(&mut self) -> Option<Result<Triple, EvaluationError>> {
@@ -2467,10 +2543,12 @@ impl<S: ReadableEncodedStore + 'static> Iterator for DescribeIterator<S> {
             };
             for subject in tuple.iter() {
                 if let Some(subject) = subject {
-                    self.quads =
-                        self.eval
-                            .dataset
-                            .quads_for_pattern(Some(subject), None, None, None);
+                    self.quads = Box::new(self.eval.dataset.encoded_quads_for_pattern(
+                        Some(subject),
+                        None,
+                        None,
+                        None,
+                    ));
                 }
             }
         }
@@ -2621,19 +2699,19 @@ impl<
     }
 }
 
-trait Accumulator {
-    fn add(&mut self, element: Option<EncodedTerm>);
+trait Accumulator<I: StrId> {
+    fn add(&mut self, element: Option<EncodedTerm<I>>);
 
-    fn state(&self) -> Option<EncodedTerm>;
+    fn state(&self) -> Option<EncodedTerm<I>>;
 }
 
 #[derive(Default, Debug)]
-struct DistinctAccumulator<T: Accumulator> {
-    seen: HashSet<Option<EncodedTerm>>,
+struct DistinctAccumulator<I: StrId, T: Accumulator<I>> {
+    seen: HashSet<Option<EncodedTerm<I>>>,
     inner: T,
 }
 
-impl<T: Accumulator> DistinctAccumulator<T> {
+impl<I: StrId, T: Accumulator<I>> DistinctAccumulator<I, T> {
     fn new(inner: T) -> Self {
         Self {
             seen: HashSet::default(),
@@ -2642,14 +2720,14 @@ impl<T: Accumulator> DistinctAccumulator<T> {
     }
 }
 
-impl<T: Accumulator> Accumulator for DistinctAccumulator<T> {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<I: StrId, T: Accumulator<I>> Accumulator<I> for DistinctAccumulator<I, T> {
+    fn add(&mut self, element: Option<EncodedTerm<I>>) {
         if self.seen.insert(element) {
             self.inner.add(element)
         }
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<I>> {
         self.inner.state()
     }
 }
@@ -2659,22 +2737,22 @@ struct CountAccumulator {
     count: i64,
 }
 
-impl Accumulator for CountAccumulator {
-    fn add(&mut self, _element: Option<EncodedTerm>) {
+impl<I: StrId> Accumulator<I> for CountAccumulator {
+    fn add(&mut self, _element: Option<EncodedTerm<I>>) {
         self.count += 1;
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<I>> {
         Some(self.count.into())
     }
 }
 
 #[derive(Debug)]
-struct SumAccumulator {
-    sum: Option<EncodedTerm>,
+struct SumAccumulator<I: StrId> {
+    sum: Option<EncodedTerm<I>>,
 }
 
-impl Default for SumAccumulator {
+impl<I: StrId> Default for SumAccumulator<I> {
     fn default() -> Self {
         Self {
             sum: Some(0.into()),
@@ -2682,8 +2760,8 @@ impl Default for SumAccumulator {
     }
 }
 
-impl Accumulator for SumAccumulator {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<I: StrId> Accumulator<I> for SumAccumulator<I> {
+    fn add(&mut self, element: Option<EncodedTerm<I>>) {
         if let Some(sum) = self.sum {
             if let Some(operands) = element.and_then(|e| NumericBinaryOperands::new(sum, e)) {
                 //TODO: unify with addition?
@@ -2701,24 +2779,33 @@ impl Accumulator for SumAccumulator {
         }
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<I>> {
         self.sum
     }
 }
 
-#[derive(Debug, Default)]
-struct AvgAccumulator {
-    sum: SumAccumulator,
+#[derive(Debug)]
+struct AvgAccumulator<I: StrId> {
+    sum: SumAccumulator<I>,
     count: CountAccumulator,
 }
 
-impl Accumulator for AvgAccumulator {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<I: StrId> Default for AvgAccumulator<I> {
+    fn default() -> Self {
+        Self {
+            sum: SumAccumulator::default(),
+            count: CountAccumulator::default(),
+        }
+    }
+}
+
+impl<I: StrId> Accumulator<I> for AvgAccumulator<I> {
+    fn add(&mut self, element: Option<EncodedTerm<I>>) {
         self.sum.add(element);
         self.count.add(element);
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<I>> {
         let sum = self.sum.state()?;
         let count = self.count.state()?;
         if count == EncodedTerm::from(0) {
@@ -2742,7 +2829,7 @@ impl Accumulator for AvgAccumulator {
 #[allow(clippy::option_option)]
 struct MinAccumulator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    min: Option<Option<EncodedTerm>>,
+    min: Option<Option<EncodedTerm<S::StrId>>>,
 }
 
 impl<S: ReadableEncodedStore + 'static> MinAccumulator<S> {
@@ -2751,8 +2838,12 @@ impl<S: ReadableEncodedStore + 'static> MinAccumulator<S> {
     }
 }
 
-impl<S: ReadableEncodedStore + 'static> Accumulator for MinAccumulator<S> {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Accumulator<S::StrId>
+    for MinAccumulator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
+    fn add(&mut self, element: Option<EncodedTerm<S::StrId>>) {
         if let Some(min) = self.min {
             if self.eval.cmp_terms(element, min) == Ordering::Less {
                 self.min = Some(element)
@@ -2762,7 +2853,7 @@ impl<S: ReadableEncodedStore + 'static> Accumulator for MinAccumulator<S> {
         }
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<S::StrId>> {
         self.min.and_then(|v| v)
     }
 }
@@ -2770,7 +2861,7 @@ impl<S: ReadableEncodedStore + 'static> Accumulator for MinAccumulator<S> {
 #[allow(clippy::option_option)]
 struct MaxAccumulator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
-    max: Option<Option<EncodedTerm>>,
+    max: Option<Option<EncodedTerm<S::StrId>>>,
 }
 
 impl<S: ReadableEncodedStore + 'static> MaxAccumulator<S> {
@@ -2779,8 +2870,12 @@ impl<S: ReadableEncodedStore + 'static> MaxAccumulator<S> {
     }
 }
 
-impl<S: ReadableEncodedStore + 'static> Accumulator for MaxAccumulator<S> {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Accumulator<S::StrId>
+    for MaxAccumulator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
+    fn add(&mut self, element: Option<EncodedTerm<S::StrId>>) {
         if let Some(max) = self.max {
             if self.eval.cmp_terms(element, max) == Ordering::Greater {
                 self.max = Some(element)
@@ -2790,24 +2885,30 @@ impl<S: ReadableEncodedStore + 'static> Accumulator for MaxAccumulator<S> {
         }
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<S::StrId>> {
         self.max.and_then(|v| v)
     }
 }
 
-#[derive(Default, Debug)]
-struct SampleAccumulator {
-    value: Option<EncodedTerm>,
+#[derive(Debug)]
+struct SampleAccumulator<I: StrId> {
+    value: Option<EncodedTerm<I>>,
 }
 
-impl Accumulator for SampleAccumulator {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<I: StrId> Default for SampleAccumulator<I> {
+    fn default() -> Self {
+        Self { value: None }
+    }
+}
+
+impl<I: StrId> Accumulator<I> for SampleAccumulator<I> {
+    fn add(&mut self, element: Option<EncodedTerm<I>>) {
         if element.is_some() {
             self.value = element
         }
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<I>> {
         self.value
     }
 }
@@ -2816,7 +2917,7 @@ impl Accumulator for SampleAccumulator {
 struct GroupConcatAccumulator<S: ReadableEncodedStore + 'static> {
     eval: SimpleEvaluator<S>,
     concat: Option<String>,
-    language: Option<Option<StrHash>>,
+    language: Option<Option<S::StrId>>,
     separator: Rc<String>,
 }
 
@@ -2831,8 +2932,12 @@ impl<S: ReadableEncodedStore + 'static> GroupConcatAccumulator<S> {
     }
 }
 
-impl<S: ReadableEncodedStore + 'static> Accumulator for GroupConcatAccumulator<S> {
-    fn add(&mut self, element: Option<EncodedTerm>) {
+impl<S: ReadableEncodedStore<Error = EvaluationError> + 'static> Accumulator<S::StrId>
+    for GroupConcatAccumulator<S>
+where
+    for<'a> &'a S: StrContainer<StrId = S::StrId>,
+{
+    fn add(&mut self, element: Option<EncodedTerm<S::StrId>>) {
         if let Some(concat) = self.concat.as_mut() {
             if let Some(element) = element {
                 if let Some((value, e_language)) = self.eval.to_string_and_language(element) {
@@ -2850,7 +2955,7 @@ impl<S: ReadableEncodedStore + 'static> Accumulator for GroupConcatAccumulator<S
         }
     }
 
-    fn state(&self) -> Option<EncodedTerm> {
+    fn state(&self) -> Option<EncodedTerm<S::StrId>> {
         self.concat.as_ref().and_then(|result| {
             self.eval
                 .build_plain_literal(result, self.language.and_then(|v| v))
diff --git a/lib/src/sparql/mod.rs b/lib/src/sparql/mod.rs
index 2b75ae77..a8c66a46 100644
--- a/lib/src/sparql/mod.rs
+++ b/lib/src/sparql/mod.rs
@@ -1,6 +1,7 @@
 //! [SPARQL](https://www.w3.org/TR/sparql11-overview/) implementation.
 
 mod algebra;
+mod dataset;
 mod error;
 mod eval;
 mod json_results;
@@ -16,8 +17,7 @@ use crate::sparql::eval::SimpleEvaluator;
 pub use crate::sparql::model::QuerySolution;
 pub use crate::sparql::model::QuerySolutionsIterator;
 pub use crate::sparql::model::QueryTriplesIterator;
-use crate::sparql::plan::TripleTemplate;
-use crate::sparql::plan::{DatasetView, PlanNode};
+use crate::sparql::plan::{PlanNode, TripleTemplate};
 use crate::sparql::plan_builder::PlanBuilder;
 use crate::store::ReadableEncodedStore;
 use std::convert::TryInto;
@@ -28,10 +28,12 @@ pub use crate::sparql::model::QueryResult;
 pub use crate::sparql::model::QueryResultFormat;
 #[deprecated(note = "Use QueryResultFormat instead")]
 pub type QueryResultSyntax = QueryResultFormat;
+use crate::sparql::dataset::DatasetView;
 pub use crate::sparql::error::EvaluationError;
 pub use crate::sparql::model::Variable;
 pub use crate::sparql::parser::ParseError;
 pub use crate::sparql::parser::Query;
+use crate::store::numeric_encoder::WithStoreError;
 use std::error::Error;
 
 /// A prepared [SPARQL query](https://www.w3.org/TR/sparql11-query/)
@@ -48,22 +50,22 @@ pub(crate) struct SimplePreparedQuery<S: ReadableEncodedStore + 'static>(
 #[derive(Clone)]
 enum SimplePreparedQueryAction<S: ReadableEncodedStore + 'static> {
     Select {
-        plan: Rc<PlanNode>,
+        plan: Rc<PlanNode<<DatasetView<S> as WithStoreError>::StrId>>,
         variables: Rc<Vec<Variable>>,
-        evaluator: SimpleEvaluator<S>,
+        evaluator: SimpleEvaluator<DatasetView<S>>,
     },
     Ask {
-        plan: Rc<PlanNode>,
-        evaluator: SimpleEvaluator<S>,
+        plan: Rc<PlanNode<<DatasetView<S> as WithStoreError>::StrId>>,
+        evaluator: SimpleEvaluator<DatasetView<S>>,
     },
     Construct {
-        plan: Rc<PlanNode>,
-        construct: Rc<Vec<TripleTemplate>>,
-        evaluator: SimpleEvaluator<S>,
+        plan: Rc<PlanNode<<DatasetView<S> as WithStoreError>::StrId>>,
+        construct: Rc<Vec<TripleTemplate<<DatasetView<S> as WithStoreError>::StrId>>>,
+        evaluator: SimpleEvaluator<DatasetView<S>>,
     },
     Describe {
-        plan: Rc<PlanNode>,
-        evaluator: SimpleEvaluator<S>,
+        plan: Rc<PlanNode<<DatasetView<S> as WithStoreError>::StrId>>,
+        evaluator: SimpleEvaluator<DatasetView<S>>,
     },
 }
 
@@ -78,7 +80,7 @@ impl<S: ReadableEncodedStore + 'static> SimplePreparedQuery<S> {
             QueryVariants::Select {
                 algebra, base_iri, ..
             } => {
-                let (plan, variables) = PlanBuilder::build(dataset.encoder(), &algebra)?;
+                let (plan, variables) = PlanBuilder::build(dataset.as_ref(), &algebra)?;
                 SimplePreparedQueryAction::Select {
                     plan: Rc::new(plan),
                     variables: Rc::new(variables),
@@ -88,7 +90,7 @@ impl<S: ReadableEncodedStore + 'static> SimplePreparedQuery<S> {
             QueryVariants::Ask {
                 algebra, base_iri, ..
             } => {
-                let (plan, _) = PlanBuilder::build(dataset.encoder(), &algebra)?;
+                let (plan, _) = PlanBuilder::build(dataset.as_ref(), &algebra)?;
                 SimplePreparedQueryAction::Ask {
                     plan: Rc::new(plan),
                     evaluator: SimpleEvaluator::new(dataset, base_iri, options.service_handler),
@@ -100,11 +102,11 @@ impl<S: ReadableEncodedStore + 'static> SimplePreparedQuery<S> {
                 base_iri,
                 ..
             } => {
-                let (plan, variables) = PlanBuilder::build(dataset.encoder(), &algebra)?;
+                let (plan, variables) = PlanBuilder::build(dataset.as_ref(), &algebra)?;
                 SimplePreparedQueryAction::Construct {
                     plan: Rc::new(plan),
                     construct: Rc::new(PlanBuilder::build_graph_template(
-                        dataset.encoder(),
+                        dataset.as_ref(),
                         &construct,
                         variables,
                     )?),
@@ -114,7 +116,7 @@ impl<S: ReadableEncodedStore + 'static> SimplePreparedQuery<S> {
             QueryVariants::Describe {
                 algebra, base_iri, ..
             } => {
-                let (plan, _) = PlanBuilder::build(dataset.encoder(), &algebra)?;
+                let (plan, _) = PlanBuilder::build(dataset.as_ref(), &algebra)?;
                 SimplePreparedQueryAction::Describe {
                     plan: Rc::new(plan),
                     evaluator: SimpleEvaluator::new(dataset, base_iri, options.service_handler),
diff --git a/lib/src/sparql/plan.rs b/lib/src/sparql/plan.rs
index b08d7a66..88e47e91 100644
--- a/lib/src/sparql/plan.rs
+++ b/lib/src/sparql/plan.rs
@@ -1,96 +1,89 @@
-use crate::error::UnwrapInfallible;
 use crate::sparql::algebra::GraphPattern;
-use crate::sparql::error::EvaluationError;
 use crate::sparql::model::Variable;
-use crate::store::numeric_encoder::{
-    EncodedQuad, EncodedTerm, Encoder, MemoryStrStore, StrContainer, StrHash, StrLookup,
-    WithStoreError,
-};
-use crate::store::ReadableEncodedStore;
-use std::cell::{RefCell, RefMut};
+use crate::store::numeric_encoder::{EncodedTerm, StrId};
 use std::collections::BTreeSet;
 use std::rc::Rc;
 
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub enum PlanNode {
+pub enum PlanNode<I: StrId> {
     Init,
     StaticBindings {
-        tuples: Vec<EncodedTuple>,
+        tuples: Vec<EncodedTuple<I>>,
     },
     Service {
-        service_name: PatternValue,
+        service_name: PatternValue<I>,
         variables: Rc<Vec<Variable>>,
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
         graph_pattern: Rc<GraphPattern>,
         silent: bool,
     },
     QuadPatternJoin {
-        child: Rc<PlanNode>,
-        subject: PatternValue,
-        predicate: PatternValue,
-        object: PatternValue,
-        graph_name: PatternValue,
+        child: Rc<PlanNode<I>>,
+        subject: PatternValue<I>,
+        predicate: PatternValue<I>,
+        object: PatternValue<I>,
+        graph_name: PatternValue<I>,
     },
     PathPatternJoin {
-        child: Rc<PlanNode>,
-        subject: PatternValue,
-        path: Rc<PlanPropertyPath>,
-        object: PatternValue,
-        graph_name: PatternValue,
+        child: Rc<PlanNode<I>>,
+        subject: PatternValue<I>,
+        path: Rc<PlanPropertyPath<I>>,
+        object: PatternValue<I>,
+        graph_name: PatternValue<I>,
     },
     Join {
-        left: Rc<PlanNode>,
-        right: Rc<PlanNode>,
+        left: Rc<PlanNode<I>>,
+        right: Rc<PlanNode<I>>,
     },
     AntiJoin {
-        left: Rc<PlanNode>,
-        right: Rc<PlanNode>,
+        left: Rc<PlanNode<I>>,
+        right: Rc<PlanNode<I>>,
     },
     Filter {
-        child: Rc<PlanNode>,
-        expression: Rc<PlanExpression>,
+        child: Rc<PlanNode<I>>,
+        expression: Rc<PlanExpression<I>>,
     },
     Union {
-        children: Vec<Rc<PlanNode>>,
+        children: Vec<Rc<PlanNode<I>>>,
     },
     LeftJoin {
-        left: Rc<PlanNode>,
-        right: Rc<PlanNode>,
+        left: Rc<PlanNode<I>>,
+        right: Rc<PlanNode<I>>,
         possible_problem_vars: Rc<Vec<usize>>, //Variables that should not be part of the entry of the left join
     },
     Extend {
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
         position: usize,
-        expression: Rc<PlanExpression>,
+        expression: Rc<PlanExpression<I>>,
     },
     Sort {
-        child: Rc<PlanNode>,
-        by: Vec<Comparator>,
+        child: Rc<PlanNode<I>>,
+        by: Vec<Comparator<I>>,
     },
     HashDeduplicate {
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
     },
     Skip {
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
         count: usize,
     },
     Limit {
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
         count: usize,
     },
     Project {
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
         mapping: Rc<Vec<(usize, usize)>>, // pairs of (variable key in child, variable key in output)
     },
     Aggregate {
         // By definition the group by key are the range 0..key_mapping.len()
-        child: Rc<PlanNode>,
+        child: Rc<PlanNode<I>>,
         key_mapping: Rc<Vec<(usize, usize)>>, // aggregate key pairs of (variable key in child, variable key in output)
-        aggregates: Rc<Vec<(PlanAggregation, usize)>>,
+        aggregates: Rc<Vec<(PlanAggregation<I>, usize)>>,
     },
 }
 
-impl PlanNode {
+impl<I: StrId> PlanNode<I> {
     /// Returns variables that might be bound in the result set
     pub fn maybe_bound_variables(&self) -> BTreeSet<usize> {
         let mut set = BTreeSet::default();
@@ -201,12 +194,12 @@ impl PlanNode {
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
-pub enum PatternValue {
-    Constant(EncodedTerm),
+pub enum PatternValue<I: StrId> {
+    Constant(EncodedTerm<I>),
     Variable(usize),
 }
 
-impl PatternValue {
+impl<I: StrId> PatternValue<I> {
     pub fn is_var(&self) -> bool {
         match self {
             PatternValue::Constant(_) => false,
@@ -216,108 +209,108 @@ impl PatternValue {
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub enum PlanExpression {
-    Constant(EncodedTerm),
+pub enum PlanExpression<I: StrId> {
+    Constant(EncodedTerm<I>),
     Variable(usize),
-    Exists(Rc<PlanNode>),
-    Or(Box<PlanExpression>, Box<PlanExpression>),
-    And(Box<PlanExpression>, Box<PlanExpression>),
-    Equal(Box<PlanExpression>, Box<PlanExpression>),
-    NotEqual(Box<PlanExpression>, Box<PlanExpression>),
-    Greater(Box<PlanExpression>, Box<PlanExpression>),
-    GreaterOrEq(Box<PlanExpression>, Box<PlanExpression>),
-    Lower(Box<PlanExpression>, Box<PlanExpression>),
-    LowerOrEq(Box<PlanExpression>, Box<PlanExpression>),
-    In(Box<PlanExpression>, Vec<PlanExpression>),
-    Add(Box<PlanExpression>, Box<PlanExpression>),
-    Sub(Box<PlanExpression>, Box<PlanExpression>),
-    Mul(Box<PlanExpression>, Box<PlanExpression>),
-    Div(Box<PlanExpression>, Box<PlanExpression>),
-    UnaryPlus(Box<PlanExpression>),
-    UnaryMinus(Box<PlanExpression>),
-    UnaryNot(Box<PlanExpression>),
-    Str(Box<PlanExpression>),
-    Lang(Box<PlanExpression>),
-    LangMatches(Box<PlanExpression>, Box<PlanExpression>),
-    Datatype(Box<PlanExpression>),
+    Exists(Rc<PlanNode<I>>),
+    Or(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    And(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Equal(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    NotEqual(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Greater(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    GreaterOrEq(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Lower(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    LowerOrEq(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    In(Box<PlanExpression<I>>, Vec<PlanExpression<I>>),
+    Add(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Sub(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Mul(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Div(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    UnaryPlus(Box<PlanExpression<I>>),
+    UnaryMinus(Box<PlanExpression<I>>),
+    UnaryNot(Box<PlanExpression<I>>),
+    Str(Box<PlanExpression<I>>),
+    Lang(Box<PlanExpression<I>>),
+    LangMatches(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Datatype(Box<PlanExpression<I>>),
     Bound(usize),
-    IRI(Box<PlanExpression>),
-    BNode(Option<Box<PlanExpression>>),
+    IRI(Box<PlanExpression<I>>),
+    BNode(Option<Box<PlanExpression<I>>>),
     Rand,
-    Abs(Box<PlanExpression>),
-    Ceil(Box<PlanExpression>),
-    Floor(Box<PlanExpression>),
-    Round(Box<PlanExpression>),
-    Concat(Vec<PlanExpression>),
+    Abs(Box<PlanExpression<I>>),
+    Ceil(Box<PlanExpression<I>>),
+    Floor(Box<PlanExpression<I>>),
+    Round(Box<PlanExpression<I>>),
+    Concat(Vec<PlanExpression<I>>),
     SubStr(
-        Box<PlanExpression>,
-        Box<PlanExpression>,
-        Option<Box<PlanExpression>>,
+        Box<PlanExpression<I>>,
+        Box<PlanExpression<I>>,
+        Option<Box<PlanExpression<I>>>,
     ),
-    StrLen(Box<PlanExpression>),
+    StrLen(Box<PlanExpression<I>>),
     Replace(
-        Box<PlanExpression>,
-        Box<PlanExpression>,
-        Box<PlanExpression>,
-        Option<Box<PlanExpression>>,
+        Box<PlanExpression<I>>,
+        Box<PlanExpression<I>>,
+        Box<PlanExpression<I>>,
+        Option<Box<PlanExpression<I>>>,
     ),
-    UCase(Box<PlanExpression>),
-    LCase(Box<PlanExpression>),
-    EncodeForURI(Box<PlanExpression>),
-    Contains(Box<PlanExpression>, Box<PlanExpression>),
-    StrStarts(Box<PlanExpression>, Box<PlanExpression>),
-    StrEnds(Box<PlanExpression>, Box<PlanExpression>),
-    StrBefore(Box<PlanExpression>, Box<PlanExpression>),
-    StrAfter(Box<PlanExpression>, Box<PlanExpression>),
-    Year(Box<PlanExpression>),
-    Month(Box<PlanExpression>),
-    Day(Box<PlanExpression>),
-    Hours(Box<PlanExpression>),
-    Minutes(Box<PlanExpression>),
-    Seconds(Box<PlanExpression>),
-    Timezone(Box<PlanExpression>),
-    Tz(Box<PlanExpression>),
+    UCase(Box<PlanExpression<I>>),
+    LCase(Box<PlanExpression<I>>),
+    EncodeForURI(Box<PlanExpression<I>>),
+    Contains(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    StrStarts(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    StrEnds(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    StrBefore(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    StrAfter(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    Year(Box<PlanExpression<I>>),
+    Month(Box<PlanExpression<I>>),
+    Day(Box<PlanExpression<I>>),
+    Hours(Box<PlanExpression<I>>),
+    Minutes(Box<PlanExpression<I>>),
+    Seconds(Box<PlanExpression<I>>),
+    Timezone(Box<PlanExpression<I>>),
+    Tz(Box<PlanExpression<I>>),
     Now,
     UUID,
     StrUUID,
-    MD5(Box<PlanExpression>),
-    SHA1(Box<PlanExpression>),
-    SHA256(Box<PlanExpression>),
-    SHA384(Box<PlanExpression>),
-    SHA512(Box<PlanExpression>),
-    Coalesce(Vec<PlanExpression>),
+    MD5(Box<PlanExpression<I>>),
+    SHA1(Box<PlanExpression<I>>),
+    SHA256(Box<PlanExpression<I>>),
+    SHA384(Box<PlanExpression<I>>),
+    SHA512(Box<PlanExpression<I>>),
+    Coalesce(Vec<PlanExpression<I>>),
     If(
-        Box<PlanExpression>,
-        Box<PlanExpression>,
-        Box<PlanExpression>,
+        Box<PlanExpression<I>>,
+        Box<PlanExpression<I>>,
+        Box<PlanExpression<I>>,
     ),
-    StrLang(Box<PlanExpression>, Box<PlanExpression>),
-    StrDT(Box<PlanExpression>, Box<PlanExpression>),
-    SameTerm(Box<PlanExpression>, Box<PlanExpression>),
-    IsIRI(Box<PlanExpression>),
-    IsBlank(Box<PlanExpression>),
-    IsLiteral(Box<PlanExpression>),
-    IsNumeric(Box<PlanExpression>),
+    StrLang(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    StrDT(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    SameTerm(Box<PlanExpression<I>>, Box<PlanExpression<I>>),
+    IsIRI(Box<PlanExpression<I>>),
+    IsBlank(Box<PlanExpression<I>>),
+    IsLiteral(Box<PlanExpression<I>>),
+    IsNumeric(Box<PlanExpression<I>>),
     Regex(
-        Box<PlanExpression>,
-        Box<PlanExpression>,
-        Option<Box<PlanExpression>>,
+        Box<PlanExpression<I>>,
+        Box<PlanExpression<I>>,
+        Option<Box<PlanExpression<I>>>,
     ),
-    BooleanCast(Box<PlanExpression>),
-    DoubleCast(Box<PlanExpression>),
-    FloatCast(Box<PlanExpression>),
-    DecimalCast(Box<PlanExpression>),
-    IntegerCast(Box<PlanExpression>),
-    DateCast(Box<PlanExpression>),
-    TimeCast(Box<PlanExpression>),
-    DateTimeCast(Box<PlanExpression>),
-    DurationCast(Box<PlanExpression>),
-    YearMonthDurationCast(Box<PlanExpression>),
-    DayTimeDurationCast(Box<PlanExpression>),
-    StringCast(Box<PlanExpression>),
+    BooleanCast(Box<PlanExpression<I>>),
+    DoubleCast(Box<PlanExpression<I>>),
+    FloatCast(Box<PlanExpression<I>>),
+    DecimalCast(Box<PlanExpression<I>>),
+    IntegerCast(Box<PlanExpression<I>>),
+    DateCast(Box<PlanExpression<I>>),
+    TimeCast(Box<PlanExpression<I>>),
+    DateTimeCast(Box<PlanExpression<I>>),
+    DurationCast(Box<PlanExpression<I>>),
+    YearMonthDurationCast(Box<PlanExpression<I>>),
+    DayTimeDurationCast(Box<PlanExpression<I>>),
+    StringCast(Box<PlanExpression<I>>),
 }
 
-impl PlanExpression {
+impl<I: StrId> PlanExpression<I> {
     pub fn add_maybe_bound_variables(&self, set: &mut BTreeSet<usize>) {
         match self {
             PlanExpression::Variable(v) | PlanExpression::Bound(v) => {
@@ -434,9 +427,9 @@ impl PlanExpression {
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct PlanAggregation {
+pub struct PlanAggregation<I: StrId> {
     pub function: PlanAggregationFunction,
-    pub parameter: Option<PlanExpression>,
+    pub parameter: Option<PlanExpression<I>>,
     pub distinct: bool,
 }
 
@@ -452,43 +445,43 @@ pub enum PlanAggregationFunction {
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub enum PlanPropertyPath {
-    PredicatePath(EncodedTerm),
-    InversePath(Rc<PlanPropertyPath>),
-    SequencePath(Rc<PlanPropertyPath>, Rc<PlanPropertyPath>),
-    AlternativePath(Rc<PlanPropertyPath>, Rc<PlanPropertyPath>),
-    ZeroOrMorePath(Rc<PlanPropertyPath>),
-    OneOrMorePath(Rc<PlanPropertyPath>),
-    ZeroOrOnePath(Rc<PlanPropertyPath>),
-    NegatedPropertySet(Rc<Vec<EncodedTerm>>),
+pub enum PlanPropertyPath<I: StrId> {
+    PredicatePath(EncodedTerm<I>),
+    InversePath(Rc<PlanPropertyPath<I>>),
+    SequencePath(Rc<PlanPropertyPath<I>>, Rc<PlanPropertyPath<I>>),
+    AlternativePath(Rc<PlanPropertyPath<I>>, Rc<PlanPropertyPath<I>>),
+    ZeroOrMorePath(Rc<PlanPropertyPath<I>>),
+    OneOrMorePath(Rc<PlanPropertyPath<I>>),
+    ZeroOrOnePath(Rc<PlanPropertyPath<I>>),
+    NegatedPropertySet(Rc<Vec<EncodedTerm<I>>>),
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub enum Comparator {
-    Asc(PlanExpression),
-    Desc(PlanExpression),
+pub enum Comparator<I: StrId> {
+    Asc(PlanExpression<I>),
+    Desc(PlanExpression<I>),
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
-pub struct TripleTemplate {
-    pub subject: TripleTemplateValue,
-    pub predicate: TripleTemplateValue,
-    pub object: TripleTemplateValue,
+pub struct TripleTemplate<I: StrId> {
+    pub subject: TripleTemplateValue<I>,
+    pub predicate: TripleTemplateValue<I>,
+    pub object: TripleTemplateValue<I>,
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
-pub enum TripleTemplateValue {
-    Constant(EncodedTerm),
+pub enum TripleTemplateValue<I: StrId> {
+    Constant(EncodedTerm<I>),
     BlankNode(usize),
     Variable(usize),
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct EncodedTuple {
-    inner: Vec<Option<EncodedTerm>>,
+pub struct EncodedTuple<I: StrId> {
+    inner: Vec<Option<EncodedTerm<I>>>,
 }
 
-impl EncodedTuple {
+impl<I: StrId> EncodedTuple<I> {
     pub fn with_capacity(capacity: usize) -> Self {
         Self {
             inner: Vec::with_capacity(capacity),
@@ -503,15 +496,15 @@ impl EncodedTuple {
         self.inner.get(index).map_or(false, Option::is_some)
     }
 
-    pub fn get(&self, index: usize) -> Option<EncodedTerm> {
+    pub fn get(&self, index: usize) -> Option<EncodedTerm<I>> {
         self.inner.get(index).cloned().unwrap_or(None)
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = Option<EncodedTerm>> + 'a {
+    pub fn iter<'a>(&'a self) -> impl Iterator<Item = Option<EncodedTerm<I>>> + 'a {
         self.inner.iter().cloned()
     }
 
-    pub fn set(&mut self, index: usize, value: EncodedTerm) {
+    pub fn set(&mut self, index: usize, value: EncodedTerm<I>) {
         if self.inner.len() <= index {
             self.inner.resize(index + 1, None);
         }
@@ -524,7 +517,7 @@ impl EncodedTuple {
         }
     }
 
-    pub fn combine_with(&self, other: &EncodedTuple) -> Option<Self> {
+    pub fn combine_with(&self, other: &EncodedTuple<I>) -> Option<Self> {
         if self.inner.len() < other.inner.len() {
             let mut result = other.inner.to_owned();
             for (key, self_value) in self.inner.iter().enumerate() {
@@ -558,106 +551,3 @@ impl EncodedTuple {
         }
     }
 }
-
-pub(crate) struct DatasetView<S: ReadableEncodedStore> {
-    store: S,
-    extra: RefCell<MemoryStrStore>,
-    default_graph_as_union: bool,
-}
-
-impl<S: ReadableEncodedStore> DatasetView<S> {
-    pub fn new(store: S, default_graph_as_union: bool) -> Self {
-        Self {
-            store,
-            extra: RefCell::new(MemoryStrStore::default()),
-            default_graph_as_union,
-        }
-    }
-
-    pub fn quads_for_pattern(
-        &self,
-        subject: Option<EncodedTerm>,
-        predicate: Option<EncodedTerm>,
-        object: Option<EncodedTerm>,
-        graph_name: Option<EncodedTerm>,
-    ) -> Box<dyn Iterator<Item = Result<EncodedQuad, EvaluationError>>> {
-        if graph_name == None {
-            Box::new(
-                map_iter_err(
-                    self.store
-                        .encoded_quads_for_pattern(subject, predicate, object, None),
-                )
-                .filter(|quad| match quad {
-                    Err(_) => true,
-                    Ok(quad) => quad.graph_name != EncodedTerm::DefaultGraph,
-                }),
-            )
-        } else if graph_name == Some(EncodedTerm::DefaultGraph) && self.default_graph_as_union {
-            Box::new(
-                map_iter_err(
-                    self.store
-                        .encoded_quads_for_pattern(subject, predicate, object, None),
-                )
-                .map(|quad| {
-                    let quad = quad?;
-                    Ok(EncodedQuad::new(
-                        quad.subject,
-                        quad.predicate,
-                        quad.object,
-                        EncodedTerm::DefaultGraph,
-                    ))
-                }),
-            )
-        } else {
-            Box::new(map_iter_err(self.store.encoded_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(),
-        }
-    }
-}
-
-fn map_iter_err<'a, T>(
-    iter: impl Iterator<Item = Result<T, impl Into<EvaluationError>>> + 'a,
-) -> impl Iterator<Item = Result<T, EvaluationError>> + 'a {
-    iter.map(|e| e.map_err(|e| e.into()))
-}
-
-impl<S: ReadableEncodedStore> WithStoreError for DatasetView<S> {
-    type Error = S::Error;
-}
-impl<S: ReadableEncodedStore> StrLookup for DatasetView<S> {
-    fn get_str(&self, id: StrHash) -> Result<Option<String>, Self::Error> {
-        if let Some(value) = self.extra.borrow().get_str(id).unwrap_infallible() {
-            Ok(Some(value))
-        } else {
-            self.store.get_str(id)
-        }
-    }
-}
-
-struct DatasetViewStrContainer<'a, S: ReadableEncodedStore> {
-    store: &'a S,
-    extra: RefMut<'a, MemoryStrStore>,
-}
-
-impl<'a, S: ReadableEncodedStore> WithStoreError for DatasetViewStrContainer<'a, S> {
-    type Error = S::Error;
-}
-
-impl<'a, S: ReadableEncodedStore> StrContainer for DatasetViewStrContainer<'a, S> {
-    fn insert_str(&mut self, value: &str) -> Result<StrHash, Self::Error> {
-        let key = StrHash::new(value);
-        if self.store.get_str(key)?.is_none() {
-            Ok(self.extra.insert_str(value).unwrap_infallible())
-        } else {
-            Ok(key)
-        }
-    }
-}
diff --git a/lib/src/sparql/plan_builder.rs b/lib/src/sparql/plan_builder.rs
index 0bcfa2d6..6ade4421 100644
--- a/lib/src/sparql/plan_builder.rs
+++ b/lib/src/sparql/plan_builder.rs
@@ -1,21 +1,21 @@
-use crate::model::{BlankNode, Term};
+use crate::model::{BlankNode, Literal, NamedNode, Term};
 use crate::sparql::algebra::*;
 use crate::sparql::error::EvaluationError;
 use crate::sparql::model::*;
 use crate::sparql::plan::*;
-use crate::store::numeric_encoder::{EncodedTerm, Encoder};
+use crate::store::numeric_encoder::{EncodedTerm, WriteEncoder};
 use std::collections::{BTreeSet, HashSet};
 use std::rc::Rc;
 
-pub(crate) struct PlanBuilder<E: Encoder> {
+pub(crate) struct PlanBuilder<E: WriteEncoder> {
     encoder: E,
 }
 
-impl<E: Encoder> PlanBuilder<E> {
+impl<E: WriteEncoder<Error = EvaluationError>> PlanBuilder<E> {
     pub fn build(
         encoder: E,
         pattern: &GraphPattern,
-    ) -> Result<(PlanNode, Vec<Variable>), EvaluationError> {
+    ) -> Result<(PlanNode<E::StrId>, Vec<Variable>), EvaluationError> {
         let mut variables = Vec::default();
         let plan = PlanBuilder { encoder }.build_for_graph_pattern(
             pattern,
@@ -29,7 +29,7 @@ impl<E: Encoder> PlanBuilder<E> {
         encoder: E,
         template: &[TriplePattern],
         mut variables: Vec<Variable>,
-    ) -> Result<Vec<TripleTemplate>, EvaluationError> {
+    ) -> Result<Vec<TripleTemplate<E::StrId>>, EvaluationError> {
         PlanBuilder { encoder }.build_for_graph_template(template, &mut variables)
     }
 
@@ -37,8 +37,8 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         pattern: &GraphPattern,
         variables: &mut Vec<Variable>,
-        graph_name: PatternValue,
-    ) -> Result<PlanNode, EvaluationError> {
+        graph_name: PatternValue<E::StrId>,
+    ) -> Result<PlanNode<E::StrId>, EvaluationError> {
         Ok(match pattern {
             GraphPattern::BGP(p) => self.build_for_bgp(p, variables, graph_name)?,
             GraphPattern::Join(a, b) => PlanNode::Join {
@@ -217,8 +217,8 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         p: &[TripleOrPathPattern],
         variables: &mut Vec<Variable>,
-        graph_name: PatternValue,
-    ) -> Result<PlanNode, EvaluationError> {
+        graph_name: PatternValue<E::StrId>,
+    ) -> Result<PlanNode<E::StrId>, EvaluationError> {
         let mut plan = PlanNode::Init;
         for pattern in sort_bgp(p) {
             plan = match pattern {
@@ -244,11 +244,14 @@ impl<E: Encoder> PlanBuilder<E> {
         Ok(plan)
     }
 
-    fn build_for_path(&mut self, path: &PropertyPath) -> Result<PlanPropertyPath, EvaluationError> {
+    fn build_for_path(
+        &mut self,
+        path: &PropertyPath,
+    ) -> Result<PlanPropertyPath<E::StrId>, EvaluationError> {
         Ok(match path {
-            PropertyPath::PredicatePath(p) => PlanPropertyPath::PredicatePath(
-                self.encoder.encode_named_node(p).map_err(|e| e.into())?,
-            ),
+            PropertyPath::PredicatePath(p) => {
+                PlanPropertyPath::PredicatePath(self.build_named_node(p)?)
+            }
             PropertyPath::InversePath(p) => {
                 PlanPropertyPath::InversePath(Rc::new(self.build_for_path(p)?))
             }
@@ -271,7 +274,7 @@ impl<E: Encoder> PlanBuilder<E> {
             }
             PropertyPath::NegatedPropertySet(p) => PlanPropertyPath::NegatedPropertySet(Rc::new(
                 p.iter()
-                    .map(|p| self.encoder.encode_named_node(p).map_err(|e| e.into()))
+                    .map(|p| self.build_named_node(p))
                     .collect::<Result<Vec<_>, _>>()?,
             )),
         })
@@ -281,15 +284,11 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         expression: &Expression,
         variables: &mut Vec<Variable>,
-        graph_name: PatternValue,
-    ) -> Result<PlanExpression, EvaluationError> {
+        graph_name: PatternValue<E::StrId>,
+    ) -> Result<PlanExpression<E::StrId>, EvaluationError> {
         Ok(match expression {
-            Expression::NamedNode(node) => PlanExpression::Constant(
-                self.encoder.encode_named_node(node).map_err(|e| e.into())?,
-            ),
-            Expression::Literal(l) => {
-                PlanExpression::Constant(self.encoder.encode_literal(l).map_err(|e| e.into())?)
-            }
+            Expression::NamedNode(node) => PlanExpression::Constant(self.build_named_node(node)?),
+            Expression::Literal(l) => PlanExpression::Constant(self.build_literal(l)?),
             Expression::Variable(v) => PlanExpression::Variable(variable_key(variables, v)),
             Expression::Or(a, b) => PlanExpression::Or(
                 Box::new(self.build_for_expression(a, variables, graph_name)?),
@@ -695,11 +694,11 @@ impl<E: Encoder> PlanBuilder<E> {
     fn build_cast(
         &mut self,
         parameters: &[Expression],
-        constructor: impl Fn(Box<PlanExpression>) -> PlanExpression,
+        constructor: impl Fn(Box<PlanExpression<E::StrId>>) -> PlanExpression<E::StrId>,
         variables: &mut Vec<Variable>,
-        graph_name: PatternValue,
+        graph_name: PatternValue<E::StrId>,
         name: &'static str,
-    ) -> Result<PlanExpression, EvaluationError> {
+    ) -> Result<PlanExpression<E::StrId>, EvaluationError> {
         if parameters.len() == 1 {
             Ok(constructor(Box::new(self.build_for_expression(
                 &parameters[0],
@@ -718,8 +717,8 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         l: &[Expression],
         variables: &mut Vec<Variable>,
-        graph_name: PatternValue,
-    ) -> Result<Vec<PlanExpression>, EvaluationError> {
+        graph_name: PatternValue<E::StrId>,
+    ) -> Result<Vec<PlanExpression<E::StrId>>, EvaluationError> {
         l.iter()
             .map(|e| self.build_for_expression(e, variables, graph_name))
             .collect()
@@ -729,7 +728,7 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         term_or_variable: &TermOrVariable,
         variables: &mut Vec<Variable>,
-    ) -> Result<PatternValue, EvaluationError> {
+    ) -> Result<PatternValue<E::StrId>, EvaluationError> {
         Ok(match term_or_variable {
             TermOrVariable::Variable(variable) => {
                 PatternValue::Variable(variable_key(variables, variable))
@@ -738,9 +737,7 @@ impl<E: Encoder> PlanBuilder<E> {
                 PatternValue::Variable(variable_key(variables, &Variable::new(bnode.as_str())))
                 //TODO: very bad hack to convert bnode to variable
             }
-            TermOrVariable::Term(term) => {
-                PatternValue::Constant(self.encoder.encode_term(term).map_err(|e| e.into())?)
-            }
+            TermOrVariable::Term(term) => PatternValue::Constant(self.build_term(term)?),
         })
     }
 
@@ -748,13 +745,11 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         named_node_or_variable: &NamedNodeOrVariable,
         variables: &mut Vec<Variable>,
-    ) -> Result<PatternValue, EvaluationError> {
+    ) -> Result<PatternValue<E::StrId>, EvaluationError> {
         Ok(match named_node_or_variable {
-            NamedNodeOrVariable::NamedNode(named_node) => PatternValue::Constant(
-                self.encoder
-                    .encode_named_node(named_node)
-                    .map_err(|e| e.into())?,
-            ),
+            NamedNodeOrVariable::NamedNode(named_node) => {
+                PatternValue::Constant(self.build_named_node(named_node)?)
+            }
             NamedNodeOrVariable::Variable(variable) => {
                 PatternValue::Variable(variable_key(variables, variable))
             }
@@ -765,7 +760,7 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         bindings: &StaticBindings,
         variables: &mut Vec<Variable>,
-    ) -> Result<Vec<EncodedTuple>, EvaluationError> {
+    ) -> Result<Vec<EncodedTuple<E::StrId>>, EvaluationError> {
         let bindings_variables_keys = bindings
             .variables()
             .iter()
@@ -777,10 +772,7 @@ impl<E: Encoder> PlanBuilder<E> {
                 let mut result = EncodedTuple::with_capacity(variables.len());
                 for (key, value) in values.iter().enumerate() {
                     if let Some(term) = value {
-                        result.set(
-                            bindings_variables_keys[key],
-                            self.encoder.encode_term(term).map_err(|e| e.into())?,
-                        );
+                        result.set(bindings_variables_keys[key], self.build_term(term)?);
                     }
                 }
                 Ok(result)
@@ -792,8 +784,8 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         aggregate: &Aggregation,
         variables: &mut Vec<Variable>,
-        graph_name: PatternValue,
-    ) -> Result<PlanAggregation, EvaluationError> {
+        graph_name: PatternValue<E::StrId>,
+    ) -> Result<PlanAggregation<E::StrId>, EvaluationError> {
         Ok(match aggregate {
             Aggregation::Count(e, distinct) => PlanAggregation {
                 function: PlanAggregationFunction::Count,
@@ -842,7 +834,7 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         template: &[TriplePattern],
         variables: &mut Vec<Variable>,
-    ) -> Result<Vec<TripleTemplate>, EvaluationError> {
+    ) -> Result<Vec<TripleTemplate<E::StrId>>, EvaluationError> {
         let mut bnodes = Vec::default();
         template
             .iter()
@@ -870,7 +862,7 @@ impl<E: Encoder> PlanBuilder<E> {
         term_or_variable: &TermOrVariable,
         variables: &mut Vec<Variable>,
         bnodes: &mut Vec<BlankNode>,
-    ) -> Result<TripleTemplateValue, EvaluationError> {
+    ) -> Result<TripleTemplateValue<E::StrId>, EvaluationError> {
         Ok(match term_or_variable {
             TermOrVariable::Variable(variable) => {
                 TripleTemplateValue::Variable(variable_key(variables, variable))
@@ -878,9 +870,7 @@ impl<E: Encoder> PlanBuilder<E> {
             TermOrVariable::Term(Term::BlankNode(bnode)) => {
                 TripleTemplateValue::BlankNode(bnode_key(bnodes, bnode))
             }
-            TermOrVariable::Term(term) => {
-                TripleTemplateValue::Constant(self.encoder.encode_term(term).map_err(|e| e.into())?)
-            }
+            TermOrVariable::Term(term) => TripleTemplateValue::Constant(self.build_term(term)?),
         })
     }
 
@@ -888,23 +878,23 @@ impl<E: Encoder> PlanBuilder<E> {
         &mut self,
         named_node_or_variable: &NamedNodeOrVariable,
         variables: &mut Vec<Variable>,
-    ) -> Result<TripleTemplateValue, EvaluationError> {
+    ) -> Result<TripleTemplateValue<E::StrId>, EvaluationError> {
         Ok(match named_node_or_variable {
             NamedNodeOrVariable::Variable(variable) => {
                 TripleTemplateValue::Variable(variable_key(variables, variable))
             }
-            NamedNodeOrVariable::NamedNode(term) => TripleTemplateValue::Constant(
-                self.encoder.encode_named_node(term).map_err(|e| e.into())?,
-            ),
+            NamedNodeOrVariable::NamedNode(term) => {
+                TripleTemplateValue::Constant(self.build_named_node(term)?)
+            }
         })
     }
 
     fn convert_pattern_value_id(
         &self,
-        from_value: PatternValue,
+        from_value: PatternValue<E::StrId>,
         from: &[Variable],
         to: &mut Vec<Variable>,
-    ) -> PatternValue {
+    ) -> PatternValue<E::StrId> {
         match from_value {
             PatternValue::Constant(v) => PatternValue::Constant(v),
             PatternValue::Variable(from_id) => {
@@ -933,7 +923,11 @@ impl<E: Encoder> PlanBuilder<E> {
         }
     }
 
-    fn add_left_join_problematic_variables(&self, node: &PlanNode, set: &mut BTreeSet<usize>) {
+    fn add_left_join_problematic_variables(
+        &self,
+        node: &PlanNode<E::StrId>,
+        set: &mut BTreeSet<usize>,
+    ) {
         match node {
             PlanNode::Init
             | PlanNode::StaticBindings { .. }
@@ -995,6 +989,21 @@ impl<E: Encoder> PlanBuilder<E> {
             }
         }
     }
+
+    fn build_named_node(
+        &mut self,
+        term: &NamedNode,
+    ) -> Result<EncodedTerm<E::StrId>, EvaluationError> {
+        Ok(self.encoder.encode_named_node(term)?)
+    }
+
+    fn build_literal(&mut self, term: &Literal) -> Result<EncodedTerm<E::StrId>, EvaluationError> {
+        Ok(self.encoder.encode_literal(term)?)
+    }
+
+    fn build_term(&mut self, term: &Term) -> Result<EncodedTerm<E::StrId>, EvaluationError> {
+        Ok(self.encoder.encode_term(term)?)
+    }
 }
 
 fn variable_key(variables: &mut Vec<Variable>, variable: &Variable) -> usize {
diff --git a/lib/src/store/memory.rs b/lib/src/store/memory.rs
index b120cbc9..0e494bdc 100644
--- a/lib/src/store/memory.rs
+++ b/lib/src/store/memory.rs
@@ -4,9 +4,13 @@ use crate::error::UnwrapInfallible;
 use crate::io::{DatasetFormat, GraphFormat};
 use crate::model::*;
 use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery};
-use crate::store::numeric_encoder::*;
+use crate::store::numeric_encoder::{
+    write_term, Decoder, ReadEncoder, StrContainer, StrHash, StrLookup, WithStoreError,
+    WriteEncoder, WRITTEN_TERM_MAX_SIZE,
+};
 use crate::store::{
-    dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, WritableEncodedStore,
+    dump_dataset, dump_graph, get_encoded_quad_pattern, load_dataset, load_graph,
+    ReadableEncodedStore, WritableEncodedStore,
 };
 use std::collections::hash_map::DefaultHasher;
 use std::collections::{HashMap, HashSet};
@@ -55,6 +59,8 @@ type TrivialHashMap<K, V> = HashMap<K, V, BuildHasherDefault<TrivialHasher>>;
 type TrivialHashSet<T> = HashSet<T, BuildHasherDefault<TrivialHasher>>;
 type TripleMap<T> = TrivialHashMap<T, TrivialHashMap<T, TrivialHashSet<T>>>;
 type QuadMap<T> = TrivialHashMap<T, TripleMap<T>>;
+type EncodedTerm = crate::store::numeric_encoder::EncodedTerm<StrHash>;
+type EncodedQuad = crate::store::numeric_encoder::EncodedQuad<StrHash>;
 
 #[derive(Default)]
 struct MemoryStoreIndexes {
@@ -169,22 +175,25 @@ impl MemoryStore {
         object: Option<&Term>,
         graph_name: Option<&GraphName>,
     ) -> impl Iterator<Item = Quad> {
-        let subject = subject.map(|s| s.into());
-        let predicate = predicate.map(|p| p.into());
-        let object = object.map(|o| o.into());
-        let graph_name = graph_name.map(|g| g.into());
+        let quads = if let Some((subject, predicate, object, graph_name)) =
+            get_encoded_quad_pattern(self, subject, predicate, object, graph_name)
+                .unwrap_infallible()
+        {
+            self.encoded_quads_for_pattern_inner(subject, predicate, object, graph_name)
+        } else {
+            Vec::new()
+        };
         let this = self.clone();
-        self.encoded_quads_for_pattern_inner(subject, predicate, object, graph_name)
-            .into_iter()
-            .map(
-                move |quad| this.decode_quad(&quad).unwrap(), // Could not fail
-            )
+        quads.into_iter().map(
+            move |quad| this.decode_quad(&quad).unwrap(), // Could not fail
+        )
     }
 
     /// Checks if this store contains a given quad
     pub fn contains(&self, quad: &Quad) -> bool {
-        let quad = quad.into();
-        self.contains_encoded(&quad)
+        self.get_encoded_quad(quad)
+            .unwrap_infallible()
+            .map_or(false, |q| self.contains_encoded(&q))
     }
 
     /// Returns the number of quads in the store
@@ -238,7 +247,7 @@ impl MemoryStore {
         let mut transaction = MemoryTransaction {
             store: self,
             ops: Vec::new(),
-            strings: Vec::new(),
+            strings: TrivialHashMap::default(),
         };
         f(&mut transaction)?;
         transaction.commit();
@@ -317,16 +326,17 @@ impl MemoryStore {
     /// Adds a quad to this store.
     #[allow(clippy::needless_pass_by_value)]
     pub fn insert(&self, quad: Quad) {
-        let mut store = self;
-        let quad = store.encode_quad(&quad).unwrap_infallible();
-        store.insert_encoded(&quad).unwrap_infallible();
+        let mut indexes = self.indexes_mut();
+        let quad = indexes.encode_quad(&quad).unwrap_infallible();
+        indexes.insert_encoded(&quad).unwrap_infallible();
     }
 
     /// Removes a quad from this store.
     pub fn remove(&self, quad: &Quad) {
-        let mut store = self;
-        let quad = quad.into();
-        store.remove_encoded(&quad).unwrap_infallible();
+        let mut indexes = self.indexes_mut();
+        if let Some(quad) = indexes.get_encoded_quad(quad).unwrap_infallible() {
+            indexes.remove_encoded(&quad).unwrap_infallible();
+        }
     }
 
     /// Returns if the current dataset is [isomorphic](https://www.w3.org/TR/rdf11-concepts/#dfn-dataset-isomorphism) with another one.
@@ -689,16 +699,17 @@ impl MemoryStore {
 
 impl WithStoreError for MemoryStore {
     type Error = Infallible;
-}
-
-impl<'a> WithStoreError for &'a MemoryStore {
-    type Error = Infallible;
+    type StrId = StrHash;
 }
 
 impl StrLookup for MemoryStore {
     fn get_str(&self, id: StrHash) -> Result<Option<String>, Infallible> {
         self.indexes().get_str(id)
     }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, Infallible> {
+        self.indexes().get_str_id(value)
+    }
 }
 
 impl<'a> StrContainer for &'a MemoryStore {
@@ -737,6 +748,7 @@ impl<'a> WritableEncodedStore for &'a MemoryStore {
 
 impl WithStoreError for MemoryStoreIndexes {
     type Error = Infallible;
+    type StrId = StrHash;
 }
 
 impl StrLookup for MemoryStoreIndexes {
@@ -744,6 +756,15 @@ impl StrLookup for MemoryStoreIndexes {
         //TODO: avoid copy by adding a lifetime limit to get_str
         Ok(self.id2str.get(&id).cloned())
     }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, Infallible> {
+        let id = StrHash::new(value);
+        Ok(if self.id2str.contains_key(&id) {
+            Some(id)
+        } else {
+            None
+        })
+    }
 }
 
 impl StrContainer for MemoryStoreIndexes {
@@ -941,7 +962,7 @@ impl MemoryPreparedQuery {
 pub struct MemoryTransaction<'a> {
     store: &'a MemoryStore,
     ops: Vec<TransactionOp>,
-    strings: Vec<(StrHash, String)>,
+    strings: TrivialHashMap<StrHash, String>,
 }
 
 enum TransactionOp {
@@ -1022,8 +1043,9 @@ impl<'a> MemoryTransaction<'a> {
 
     /// Removes a quad from this store during the transaction.
     pub fn remove(&mut self, quad: &Quad) {
-        let quad = quad.into();
-        self.remove_encoded(&quad).unwrap_infallible();
+        if let Some(quad) = self.get_encoded_quad(quad).unwrap_infallible() {
+            self.remove_encoded(&quad).unwrap_infallible();
+        }
     }
 
     fn commit(self) {
@@ -1038,14 +1060,34 @@ impl<'a> MemoryTransaction<'a> {
     }
 }
 
+impl StrLookup for MemoryTransaction<'_> {
+    fn get_str(&self, id: StrHash) -> Result<Option<String>, Infallible> {
+        if let Some(str) = self.strings.get(&id) {
+            Ok(Some(str.clone()))
+        } else {
+            self.store.get_str(id)
+        }
+    }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, Infallible> {
+        let id = StrHash::new(value);
+        if self.strings.contains_key(&id) {
+            Ok(Some(id))
+        } else {
+            self.store.get_str_id(value)
+        }
+    }
+}
+
 impl WithStoreError for MemoryTransaction<'_> {
     type Error = Infallible;
+    type StrId = StrHash;
 }
 
 impl StrContainer for MemoryTransaction<'_> {
     fn insert_str(&mut self, value: &str) -> Result<StrHash, Infallible> {
         let key = StrHash::new(value);
-        self.strings.push((key, value.to_owned()));
+        self.strings.insert(key, value.to_owned());
         Ok(key)
     }
 }
diff --git a/lib/src/store/mod.rs b/lib/src/store/mod.rs
index fb9872a2..7daf5b87 100644
--- a/lib/src/store/mod.rs
+++ b/lib/src/store/mod.rs
@@ -34,21 +34,21 @@ use std::io::{BufRead, Write};
 use std::iter::Iterator;
 
 pub(crate) trait ReadableEncodedStore: StrLookup {
-    type QuadsIter: Iterator<Item = Result<EncodedQuad, Self::Error>> + 'static;
+    type QuadsIter: Iterator<Item = Result<EncodedQuad<Self::StrId>, Self::Error>> + 'static;
 
     fn encoded_quads_for_pattern(
         &self,
-        subject: Option<EncodedTerm>,
-        predicate: Option<EncodedTerm>,
-        object: Option<EncodedTerm>,
-        graph_name: Option<EncodedTerm>,
+        subject: Option<EncodedTerm<Self::StrId>>,
+        predicate: Option<EncodedTerm<Self::StrId>>,
+        object: Option<EncodedTerm<Self::StrId>>,
+        graph_name: Option<EncodedTerm<Self::StrId>>,
     ) -> Self::QuadsIter;
 }
 
 pub(crate) trait WritableEncodedStore: StrContainer {
-    fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), Self::Error>;
+    fn insert_encoded(&mut self, quad: &EncodedQuad<Self::StrId>) -> Result<(), Self::Error>;
 
-    fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), Self::Error>;
+    fn remove_encoded(&mut self, quad: &EncodedQuad<Self::StrId>) -> Result<(), Self::Error>;
 }
 
 fn load_graph<S: WritableEncodedStore>(
@@ -239,3 +239,61 @@ impl<P: Into<io::Error>> From<StoreOrParseError<Infallible, P>> for io::Error {
         }
     }
 }
+
+type QuadPattern<I> = (
+    Option<EncodedTerm<I>>,
+    Option<EncodedTerm<I>>,
+    Option<EncodedTerm<I>>,
+    Option<EncodedTerm<I>>,
+);
+
+fn get_encoded_quad_pattern<E: ReadEncoder>(
+    encoder: &E,
+    subject: Option<&NamedOrBlankNode>,
+    predicate: Option<&NamedNode>,
+    object: Option<&Term>,
+    graph_name: Option<&GraphName>,
+) -> Result<Option<QuadPattern<E::StrId>>, E::Error> {
+    Ok(Some((
+        if let Some(subject) = transpose(
+            subject
+                .map(|t| encoder.get_encoded_named_or_blank_node(t))
+                .transpose()?,
+        ) {
+            subject
+        } else {
+            return Ok(None);
+        },
+        if let Some(predicate) = transpose(
+            predicate
+                .map(|t| encoder.get_encoded_named_node(t))
+                .transpose()?,
+        ) {
+            predicate
+        } else {
+            return Ok(None);
+        },
+        if let Some(object) = transpose(object.map(|t| encoder.get_encoded_term(t)).transpose()?) {
+            object
+        } else {
+            return Ok(None);
+        },
+        if let Some(graph_name) = transpose(
+            graph_name
+                .map(|t| encoder.get_encoded_graph_name(t))
+                .transpose()?,
+        ) {
+            graph_name
+        } else {
+            return Ok(None);
+        },
+    )))
+}
+
+fn transpose<T>(o: Option<Option<T>>) -> Option<Option<T>> {
+    match o {
+        Some(Some(v)) => Some(Some(v)),
+        Some(None) => None,
+        None => Some(None),
+    }
+}
diff --git a/lib/src/store/numeric_encoder.rs b/lib/src/store/numeric_encoder.rs
index 2f488220..9013ad9b 100644
--- a/lib/src/store/numeric_encoder.rs
+++ b/lib/src/store/numeric_encoder.rs
@@ -10,13 +10,24 @@ use siphasher::sip128::{Hasher128, SipHasher24};
 use std::collections::HashMap;
 use std::convert::Infallible;
 use std::error::Error;
+use std::fmt::Debug;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::io::Read;
 use std::mem::size_of;
 use std::{fmt, io, str};
 
-#[derive(Ord, PartialOrd, Eq, PartialEq, Debug, Copy, Clone, Hash)]
+pub trait StrId: Eq + Debug + Copy + Hash {}
+
+pub trait SerializableStrId: StrId {
+    fn len() -> usize;
+
+    fn from_be_bytes(bytes: &[u8]) -> Self;
+
+    fn push_be_bytes(&self, buffer: &mut Vec<u8>);
+}
+
+#[derive(Eq, PartialEq, Debug, Copy, Clone, Hash)]
 #[repr(transparent)]
 pub struct StrHash {
     hash: u128,
@@ -44,6 +55,26 @@ impl StrHash {
     }
 }
 
+impl StrId for StrHash {}
+
+impl SerializableStrId for StrHash {
+    fn len() -> usize {
+        16
+    }
+
+    fn from_be_bytes(bytes: &[u8]) -> Self {
+        let mut hash = [0; 16];
+        hash.copy_from_slice(bytes);
+        Self {
+            hash: u128::from_be_bytes(hash),
+        }
+    }
+
+    fn push_be_bytes(&self, buffer: &mut Vec<u8>) {
+        buffer.extend_from_slice(&self.to_be_bytes())
+    }
+}
+
 const TYPE_DEFAULT_GRAPH_ID: u8 = 0;
 const TYPE_NAMED_NODE_ID: u8 = 1;
 const TYPE_INLINE_BLANK_NODE_ID: u8 = 2;
@@ -65,28 +96,14 @@ const TYPE_YEAR_MONTH_DURATION_LITERAL: u8 = 17;
 const TYPE_DAY_TIME_DURATION_LITERAL: u8 = 18;
 
 #[derive(Debug, Clone, Copy)]
-pub enum EncodedTerm {
+pub enum EncodedTerm<I: StrId> {
     DefaultGraph,
-    NamedNode {
-        iri_id: StrHash,
-    },
-    InlineBlankNode {
-        id: u128,
-    },
-    NamedBlankNode {
-        id_id: StrHash,
-    },
-    StringLiteral {
-        value_id: StrHash,
-    },
-    LangStringLiteral {
-        value_id: StrHash,
-        language_id: StrHash,
-    },
-    TypedLiteral {
-        value_id: StrHash,
-        datatype_id: StrHash,
-    },
+    NamedNode { iri_id: I },
+    InlineBlankNode { id: u128 },
+    NamedBlankNode { id_id: I },
+    StringLiteral { value_id: I },
+    LangStringLiteral { value_id: I, language_id: I },
+    TypedLiteral { value_id: I, datatype_id: I },
     BooleanLiteral(bool),
     FloatLiteral(f32),
     DoubleLiteral(f64),
@@ -100,402 +117,353 @@ pub enum EncodedTerm {
     DayTimeDurationLiteral(DayTimeDuration),
 }
 
-impl PartialEq for EncodedTerm {
+impl<I: StrId> PartialEq for EncodedTerm<I> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (EncodedTerm::DefaultGraph, EncodedTerm::DefaultGraph) => true,
-            (
-                EncodedTerm::NamedNode { iri_id: iri_id_a },
-                EncodedTerm::NamedNode { iri_id: iri_id_b },
-            ) => iri_id_a == iri_id_b,
-            (
-                EncodedTerm::InlineBlankNode { id: id_a },
-                EncodedTerm::InlineBlankNode { id: id_b },
-            ) => id_a == id_b,
-            (
-                EncodedTerm::NamedBlankNode { id_id: id_a },
-                EncodedTerm::NamedBlankNode { id_id: id_b },
-            ) => id_a == id_b,
+            (Self::DefaultGraph, Self::DefaultGraph) => true,
+            (Self::NamedNode { iri_id: iri_id_a }, Self::NamedNode { iri_id: iri_id_b }) => {
+                iri_id_a == iri_id_b
+            }
+            (Self::InlineBlankNode { id: id_a }, Self::InlineBlankNode { id: id_b }) => {
+                id_a == id_b
+            }
+            (Self::NamedBlankNode { id_id: id_a }, Self::NamedBlankNode { id_id: id_b }) => {
+                id_a == id_b
+            }
             (
-                EncodedTerm::StringLiteral {
+                Self::StringLiteral {
                     value_id: value_id_a,
                 },
-                EncodedTerm::StringLiteral {
+                Self::StringLiteral {
                     value_id: value_id_b,
                 },
             ) => value_id_a == value_id_b,
             (
-                EncodedTerm::LangStringLiteral {
+                Self::LangStringLiteral {
                     value_id: value_id_a,
                     language_id: language_id_a,
                 },
-                EncodedTerm::LangStringLiteral {
+                Self::LangStringLiteral {
                     value_id: value_id_b,
                     language_id: language_id_b,
                 },
             ) => value_id_a == value_id_b && language_id_a == language_id_b,
             (
-                EncodedTerm::TypedLiteral {
+                Self::TypedLiteral {
                     value_id: value_id_a,
                     datatype_id: datatype_id_a,
                 },
-                EncodedTerm::TypedLiteral {
+                Self::TypedLiteral {
                     value_id: value_id_b,
                     datatype_id: datatype_id_b,
                 },
             ) => value_id_a == value_id_b && datatype_id_a == datatype_id_b,
-            (EncodedTerm::BooleanLiteral(a), EncodedTerm::BooleanLiteral(b)) => a == b,
-            (EncodedTerm::FloatLiteral(a), EncodedTerm::FloatLiteral(b)) => {
+            (Self::BooleanLiteral(a), Self::BooleanLiteral(b)) => a == b,
+            (Self::FloatLiteral(a), Self::FloatLiteral(b)) => {
                 if a.is_nan() {
                     b.is_nan()
                 } else {
                     a == b
                 }
             }
-            (EncodedTerm::DoubleLiteral(a), EncodedTerm::DoubleLiteral(b)) => {
+            (Self::DoubleLiteral(a), Self::DoubleLiteral(b)) => {
                 if a.is_nan() {
                     b.is_nan()
                 } else {
                     a == b
                 }
             }
-            (EncodedTerm::IntegerLiteral(a), EncodedTerm::IntegerLiteral(b)) => a == b,
-            (EncodedTerm::DecimalLiteral(a), EncodedTerm::DecimalLiteral(b)) => a == b,
-            (EncodedTerm::DateLiteral(a), EncodedTerm::DateLiteral(b)) => a == b,
-            (EncodedTerm::TimeLiteral(a), EncodedTerm::TimeLiteral(b)) => a == b,
-            (EncodedTerm::DateTimeLiteral(a), EncodedTerm::DateTimeLiteral(b)) => a == b,
-            (EncodedTerm::DurationLiteral(a), EncodedTerm::DurationLiteral(b)) => a == b,
-            (
-                EncodedTerm::YearMonthDurationLiteral(a),
-                EncodedTerm::YearMonthDurationLiteral(b),
-            ) => a == b,
-            (EncodedTerm::DayTimeDurationLiteral(a), EncodedTerm::DayTimeDurationLiteral(b)) => {
-                a == b
-            }
+            (Self::IntegerLiteral(a), Self::IntegerLiteral(b)) => a == b,
+            (Self::DecimalLiteral(a), Self::DecimalLiteral(b)) => a == b,
+            (Self::DateLiteral(a), Self::DateLiteral(b)) => a == b,
+            (Self::TimeLiteral(a), Self::TimeLiteral(b)) => a == b,
+            (Self::DateTimeLiteral(a), Self::DateTimeLiteral(b)) => a == b,
+            (Self::DurationLiteral(a), Self::DurationLiteral(b)) => a == b,
+            (Self::YearMonthDurationLiteral(a), Self::YearMonthDurationLiteral(b)) => a == b,
+            (Self::DayTimeDurationLiteral(a), Self::DayTimeDurationLiteral(b)) => a == b,
             (_, _) => false,
         }
     }
 }
 
-impl Eq for EncodedTerm {}
+impl<I: StrId> Eq for EncodedTerm<I> {}
 
-impl Hash for EncodedTerm {
+impl<I: StrId> Hash for EncodedTerm<I> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         match self {
-            EncodedTerm::NamedNode { iri_id } => iri_id.hash(state),
-            EncodedTerm::InlineBlankNode { id } => id.hash(state),
-            EncodedTerm::NamedBlankNode { id_id } => id_id.hash(state),
-            EncodedTerm::DefaultGraph => (),
-            EncodedTerm::StringLiteral { value_id } => value_id.hash(state),
-            EncodedTerm::LangStringLiteral {
+            Self::NamedNode { iri_id } => iri_id.hash(state),
+            Self::InlineBlankNode { id } => id.hash(state),
+            Self::NamedBlankNode { id_id } => id_id.hash(state),
+            Self::DefaultGraph => (),
+            Self::StringLiteral { value_id } => value_id.hash(state),
+            Self::LangStringLiteral {
                 value_id,
                 language_id,
             } => {
                 value_id.hash(state);
                 language_id.hash(state);
             }
-            EncodedTerm::TypedLiteral {
+            Self::TypedLiteral {
                 value_id,
                 datatype_id,
             } => {
                 value_id.hash(state);
                 datatype_id.hash(state);
             }
-            EncodedTerm::BooleanLiteral(value) => value.hash(state),
-            EncodedTerm::FloatLiteral(value) => state.write(&value.to_ne_bytes()),
-            EncodedTerm::DoubleLiteral(value) => state.write(&value.to_ne_bytes()),
-            EncodedTerm::IntegerLiteral(value) => value.hash(state),
-            EncodedTerm::DecimalLiteral(value) => value.hash(state),
-            EncodedTerm::DateLiteral(value) => value.hash(state),
-            EncodedTerm::TimeLiteral(value) => value.hash(state),
-            EncodedTerm::DateTimeLiteral(value) => value.hash(state),
-            EncodedTerm::DurationLiteral(value) => value.hash(state),
-            EncodedTerm::YearMonthDurationLiteral(value) => value.hash(state),
-            EncodedTerm::DayTimeDurationLiteral(value) => value.hash(state),
+            Self::BooleanLiteral(value) => value.hash(state),
+            Self::FloatLiteral(value) => state.write(&value.to_ne_bytes()),
+            Self::DoubleLiteral(value) => state.write(&value.to_ne_bytes()),
+            Self::IntegerLiteral(value) => value.hash(state),
+            Self::DecimalLiteral(value) => value.hash(state),
+            Self::DateLiteral(value) => value.hash(state),
+            Self::TimeLiteral(value) => value.hash(state),
+            Self::DateTimeLiteral(value) => value.hash(state),
+            Self::DurationLiteral(value) => value.hash(state),
+            Self::YearMonthDurationLiteral(value) => value.hash(state),
+            Self::DayTimeDurationLiteral(value) => value.hash(state),
         }
     }
 }
 
-impl EncodedTerm {
+impl<I: StrId> EncodedTerm<I> {
     pub fn is_named_node(&self) -> bool {
         match self {
-            EncodedTerm::NamedNode { .. } => true,
+            Self::NamedNode { .. } => true,
             _ => false,
         }
     }
 
     pub fn is_blank_node(&self) -> bool {
         match self {
-            EncodedTerm::InlineBlankNode { .. } | EncodedTerm::NamedBlankNode { .. } => true,
+            Self::InlineBlankNode { .. } | Self::NamedBlankNode { .. } => true,
             _ => false,
         }
     }
 
     pub fn is_literal(&self) -> bool {
         match self {
-            EncodedTerm::StringLiteral { .. }
-            | EncodedTerm::LangStringLiteral { .. }
-            | EncodedTerm::TypedLiteral { .. }
-            | EncodedTerm::BooleanLiteral(_)
-            | EncodedTerm::FloatLiteral(_)
-            | EncodedTerm::DoubleLiteral(_)
-            | EncodedTerm::IntegerLiteral(_)
-            | EncodedTerm::DecimalLiteral(_)
-            | EncodedTerm::DateLiteral(_)
-            | EncodedTerm::TimeLiteral(_)
-            | EncodedTerm::DateTimeLiteral(_)
-            | EncodedTerm::DurationLiteral(_)
-            | EncodedTerm::YearMonthDurationLiteral(_)
-            | EncodedTerm::DayTimeDurationLiteral(_) => true,
+            Self::StringLiteral { .. }
+            | Self::LangStringLiteral { .. }
+            | Self::TypedLiteral { .. }
+            | Self::BooleanLiteral(_)
+            | Self::FloatLiteral(_)
+            | Self::DoubleLiteral(_)
+            | Self::IntegerLiteral(_)
+            | Self::DecimalLiteral(_)
+            | Self::DateLiteral(_)
+            | Self::TimeLiteral(_)
+            | Self::DateTimeLiteral(_)
+            | Self::DurationLiteral(_)
+            | Self::YearMonthDurationLiteral(_)
+            | Self::DayTimeDurationLiteral(_) => true,
             _ => false,
         }
     }
 
     fn type_id(&self) -> u8 {
         match self {
-            EncodedTerm::DefaultGraph { .. } => TYPE_DEFAULT_GRAPH_ID,
-            EncodedTerm::NamedNode { .. } => TYPE_NAMED_NODE_ID,
-            EncodedTerm::InlineBlankNode { .. } => TYPE_INLINE_BLANK_NODE_ID,
-            EncodedTerm::NamedBlankNode { .. } => TYPE_NAMED_BLANK_NODE_ID,
-            EncodedTerm::StringLiteral { .. } => TYPE_STRING_LITERAL,
-            EncodedTerm::LangStringLiteral { .. } => TYPE_LANG_STRING_LITERAL_ID,
-            EncodedTerm::TypedLiteral { .. } => TYPE_TYPED_LITERAL_ID,
-            EncodedTerm::BooleanLiteral(true) => TYPE_BOOLEAN_LITERAL_TRUE,
-            EncodedTerm::BooleanLiteral(false) => TYPE_BOOLEAN_LITERAL_FALSE,
-            EncodedTerm::FloatLiteral(_) => TYPE_FLOAT_LITERAL,
-            EncodedTerm::DoubleLiteral(_) => TYPE_DOUBLE_LITERAL,
-            EncodedTerm::IntegerLiteral(_) => TYPE_INTEGER_LITERAL,
-            EncodedTerm::DecimalLiteral(_) => TYPE_DECIMAL_LITERAL,
-            EncodedTerm::DateLiteral(_) => TYPE_DATE_LITERAL,
-            EncodedTerm::TimeLiteral(_) => TYPE_TIME_LITERAL,
-            EncodedTerm::DateTimeLiteral(_) => TYPE_DATE_TIME_LITERAL,
-            EncodedTerm::DurationLiteral(_) => TYPE_DURATION_LITERAL,
-            EncodedTerm::YearMonthDurationLiteral(_) => TYPE_YEAR_MONTH_DURATION_LITERAL,
-            EncodedTerm::DayTimeDurationLiteral(_) => TYPE_DAY_TIME_DURATION_LITERAL,
+            Self::DefaultGraph { .. } => TYPE_DEFAULT_GRAPH_ID,
+            Self::NamedNode { .. } => TYPE_NAMED_NODE_ID,
+            Self::InlineBlankNode { .. } => TYPE_INLINE_BLANK_NODE_ID,
+            Self::NamedBlankNode { .. } => TYPE_NAMED_BLANK_NODE_ID,
+            Self::StringLiteral { .. } => TYPE_STRING_LITERAL,
+            Self::LangStringLiteral { .. } => TYPE_LANG_STRING_LITERAL_ID,
+            Self::TypedLiteral { .. } => TYPE_TYPED_LITERAL_ID,
+            Self::BooleanLiteral(true) => TYPE_BOOLEAN_LITERAL_TRUE,
+            Self::BooleanLiteral(false) => TYPE_BOOLEAN_LITERAL_FALSE,
+            Self::FloatLiteral(_) => TYPE_FLOAT_LITERAL,
+            Self::DoubleLiteral(_) => TYPE_DOUBLE_LITERAL,
+            Self::IntegerLiteral(_) => TYPE_INTEGER_LITERAL,
+            Self::DecimalLiteral(_) => TYPE_DECIMAL_LITERAL,
+            Self::DateLiteral(_) => TYPE_DATE_LITERAL,
+            Self::TimeLiteral(_) => TYPE_TIME_LITERAL,
+            Self::DateTimeLiteral(_) => TYPE_DATE_TIME_LITERAL,
+            Self::DurationLiteral(_) => TYPE_DURATION_LITERAL,
+            Self::YearMonthDurationLiteral(_) => TYPE_YEAR_MONTH_DURATION_LITERAL,
+            Self::DayTimeDurationLiteral(_) => TYPE_DAY_TIME_DURATION_LITERAL,
         }
     }
+
+    pub fn map_id<J: StrId>(self, mapping: impl Fn(I) -> J) -> EncodedTerm<J> {
+        match self {
+            Self::DefaultGraph { .. } => EncodedTerm::DefaultGraph,
+            Self::NamedNode { iri_id } => EncodedTerm::NamedNode {
+                iri_id: mapping(iri_id),
+            },
+            Self::InlineBlankNode { id } => EncodedTerm::InlineBlankNode { id },
+            Self::NamedBlankNode { id_id } => EncodedTerm::NamedBlankNode {
+                id_id: mapping(id_id),
+            },
+            Self::StringLiteral { value_id } => EncodedTerm::StringLiteral {
+                value_id: mapping(value_id),
+            },
+            Self::LangStringLiteral {
+                value_id,
+                language_id,
+            } => EncodedTerm::LangStringLiteral {
+                value_id: mapping(value_id),
+                language_id: mapping(language_id),
+            },
+            Self::TypedLiteral {
+                value_id,
+                datatype_id,
+            } => EncodedTerm::TypedLiteral {
+                value_id: mapping(value_id),
+                datatype_id: mapping(datatype_id),
+            },
+            Self::BooleanLiteral(value) => EncodedTerm::BooleanLiteral(value),
+            Self::FloatLiteral(value) => EncodedTerm::FloatLiteral(value),
+            Self::DoubleLiteral(value) => EncodedTerm::DoubleLiteral(value),
+            Self::IntegerLiteral(value) => EncodedTerm::IntegerLiteral(value),
+            Self::DecimalLiteral(value) => EncodedTerm::DecimalLiteral(value),
+            Self::DateLiteral(value) => EncodedTerm::DateLiteral(value),
+            Self::TimeLiteral(value) => EncodedTerm::TimeLiteral(value),
+            Self::DateTimeLiteral(value) => EncodedTerm::DateTimeLiteral(value),
+            Self::DurationLiteral(value) => EncodedTerm::DurationLiteral(value),
+            Self::YearMonthDurationLiteral(value) => EncodedTerm::YearMonthDurationLiteral(value),
+            Self::DayTimeDurationLiteral(value) => EncodedTerm::DayTimeDurationLiteral(value),
+        }
+    }
+
+    pub fn try_map_id<J: StrId>(self, mapping: impl Fn(I) -> Option<J>) -> Option<EncodedTerm<J>> {
+        Some(match self {
+            Self::DefaultGraph { .. } => EncodedTerm::DefaultGraph,
+            Self::NamedNode { iri_id } => EncodedTerm::NamedNode {
+                iri_id: mapping(iri_id)?,
+            },
+            Self::InlineBlankNode { id } => EncodedTerm::InlineBlankNode { id },
+            Self::NamedBlankNode { id_id } => EncodedTerm::NamedBlankNode {
+                id_id: mapping(id_id)?,
+            },
+            Self::StringLiteral { value_id } => EncodedTerm::StringLiteral {
+                value_id: mapping(value_id)?,
+            },
+            Self::LangStringLiteral {
+                value_id,
+                language_id,
+            } => EncodedTerm::LangStringLiteral {
+                value_id: mapping(value_id)?,
+                language_id: mapping(language_id)?,
+            },
+            Self::TypedLiteral {
+                value_id,
+                datatype_id,
+            } => EncodedTerm::TypedLiteral {
+                value_id: mapping(value_id)?,
+                datatype_id: mapping(datatype_id)?,
+            },
+            Self::BooleanLiteral(value) => EncodedTerm::BooleanLiteral(value),
+            Self::FloatLiteral(value) => EncodedTerm::FloatLiteral(value),
+            Self::DoubleLiteral(value) => EncodedTerm::DoubleLiteral(value),
+            Self::IntegerLiteral(value) => EncodedTerm::IntegerLiteral(value),
+            Self::DecimalLiteral(value) => EncodedTerm::DecimalLiteral(value),
+            Self::DateLiteral(value) => EncodedTerm::DateLiteral(value),
+            Self::TimeLiteral(value) => EncodedTerm::TimeLiteral(value),
+            Self::DateTimeLiteral(value) => EncodedTerm::DateTimeLiteral(value),
+            Self::DurationLiteral(value) => EncodedTerm::DurationLiteral(value),
+            Self::YearMonthDurationLiteral(value) => EncodedTerm::YearMonthDurationLiteral(value),
+            Self::DayTimeDurationLiteral(value) => EncodedTerm::DayTimeDurationLiteral(value),
+        })
+    }
 }
 
-impl From<bool> for EncodedTerm {
+impl<I: StrId> From<bool> for EncodedTerm<I> {
     fn from(value: bool) -> Self {
-        EncodedTerm::BooleanLiteral(value)
+        Self::BooleanLiteral(value)
     }
 }
 
-impl From<i64> for EncodedTerm {
+impl<I: StrId> From<i64> for EncodedTerm<I> {
     fn from(value: i64) -> Self {
-        EncodedTerm::IntegerLiteral(value)
+        Self::IntegerLiteral(value)
     }
 }
 
-impl From<i32> for EncodedTerm {
+impl<I: StrId> From<i32> for EncodedTerm<I> {
     fn from(value: i32) -> Self {
-        EncodedTerm::IntegerLiteral(value.into())
+        Self::IntegerLiteral(value.into())
     }
 }
 
-impl From<u32> for EncodedTerm {
+impl<I: StrId> From<u32> for EncodedTerm<I> {
     fn from(value: u32) -> Self {
-        EncodedTerm::IntegerLiteral(value.into())
+        Self::IntegerLiteral(value.into())
     }
 }
 
-impl From<u8> for EncodedTerm {
+impl<I: StrId> From<u8> for EncodedTerm<I> {
     fn from(value: u8) -> Self {
-        EncodedTerm::IntegerLiteral(value.into())
+        Self::IntegerLiteral(value.into())
     }
 }
-impl From<f32> for EncodedTerm {
+impl<I: StrId> From<f32> for EncodedTerm<I> {
     fn from(value: f32) -> Self {
-        EncodedTerm::FloatLiteral(value)
+        Self::FloatLiteral(value)
     }
 }
 
-impl From<f64> for EncodedTerm {
+impl<I: StrId> From<f64> for EncodedTerm<I> {
     fn from(value: f64) -> Self {
-        EncodedTerm::DoubleLiteral(value)
+        Self::DoubleLiteral(value)
     }
 }
 
-impl From<Decimal> for EncodedTerm {
+impl<I: StrId> From<Decimal> for EncodedTerm<I> {
     fn from(value: Decimal) -> Self {
-        EncodedTerm::DecimalLiteral(value)
+        Self::DecimalLiteral(value)
     }
 }
 
-impl From<Date> for EncodedTerm {
+impl<I: StrId> From<Date> for EncodedTerm<I> {
     fn from(value: Date) -> Self {
-        EncodedTerm::DateLiteral(value)
+        Self::DateLiteral(value)
     }
 }
 
-impl From<Time> for EncodedTerm {
+impl<I: StrId> From<Time> for EncodedTerm<I> {
     fn from(value: Time) -> Self {
-        EncodedTerm::TimeLiteral(value)
+        Self::TimeLiteral(value)
     }
 }
 
-impl From<DateTime> for EncodedTerm {
+impl<I: StrId> From<DateTime> for EncodedTerm<I> {
     fn from(value: DateTime) -> Self {
-        EncodedTerm::DateTimeLiteral(value)
+        Self::DateTimeLiteral(value)
     }
 }
 
-impl From<Duration> for EncodedTerm {
+impl<I: StrId> From<Duration> for EncodedTerm<I> {
     fn from(value: Duration) -> Self {
-        EncodedTerm::DurationLiteral(value)
+        Self::DurationLiteral(value)
     }
 }
 
-impl From<YearMonthDuration> for EncodedTerm {
+impl<I: StrId> From<YearMonthDuration> for EncodedTerm<I> {
     fn from(value: YearMonthDuration) -> Self {
-        EncodedTerm::YearMonthDurationLiteral(value)
+        Self::YearMonthDurationLiteral(value)
     }
 }
 
-impl From<DayTimeDuration> for EncodedTerm {
+impl<I: StrId> From<DayTimeDuration> for EncodedTerm<I> {
     fn from(value: DayTimeDuration) -> Self {
-        EncodedTerm::DayTimeDurationLiteral(value)
-    }
-}
-
-impl From<&NamedNode> for EncodedTerm {
-    fn from(node: &NamedNode) -> Self {
-        rio::NamedNode::from(node).into()
-    }
-}
-
-impl<'a> From<rio::NamedNode<'a>> for EncodedTerm {
-    fn from(node: rio::NamedNode<'a>) -> Self {
-        EncodedTerm::NamedNode {
-            iri_id: StrHash::new(node.iri),
-        }
-    }
-}
-
-impl From<&BlankNode> for EncodedTerm {
-    fn from(node: &BlankNode) -> Self {
-        if let Some(id) = node.id() {
-            EncodedTerm::InlineBlankNode { id }
-        } else {
-            EncodedTerm::NamedBlankNode {
-                id_id: StrHash::new(node.as_str()),
-            }
-        }
-    }
-}
-
-impl From<&Literal> for EncodedTerm {
-    fn from(literal: &Literal) -> Self {
-        rio::Literal::from(literal).into()
-    }
-}
-
-impl<'a> From<rio::Literal<'a>> for EncodedTerm {
-    fn from(literal: rio::Literal<'a>) -> Self {
-        match literal {
-            rio::Literal::Simple { value } => EncodedTerm::StringLiteral {
-                value_id: StrHash::new(value),
-            },
-            rio::Literal::LanguageTaggedString { value, language } => {
-                EncodedTerm::LangStringLiteral {
-                    value_id: StrHash::new(value),
-                    language_id: StrHash::new(language),
-                }
-            }
-            rio::Literal::Typed { value, datatype } => {
-                match match datatype.iri {
-                    "http://www.w3.org/2001/XMLSchema#boolean" => parse_boolean_str(value),
-                    "http://www.w3.org/2001/XMLSchema#string" => Some(EncodedTerm::StringLiteral {
-                        value_id: StrHash::new(value),
-                    }),
-                    "http://www.w3.org/2001/XMLSchema#float" => parse_float_str(value),
-                    "http://www.w3.org/2001/XMLSchema#double" => parse_double_str(value),
-                    "http://www.w3.org/2001/XMLSchema#integer"
-                    | "http://www.w3.org/2001/XMLSchema#byte"
-                    | "http://www.w3.org/2001/XMLSchema#short"
-                    | "http://www.w3.org/2001/XMLSchema#int"
-                    | "http://www.w3.org/2001/XMLSchema#long"
-                    | "http://www.w3.org/2001/XMLSchema#unsignedByte"
-                    | "http://www.w3.org/2001/XMLSchema#unsignedShort"
-                    | "http://www.w3.org/2001/XMLSchema#unsignedInt"
-                    | "http://www.w3.org/2001/XMLSchema#unsignedLong"
-                    | "http://www.w3.org/2001/XMLSchema#positiveInteger"
-                    | "http://www.w3.org/2001/XMLSchema#negativeInteger"
-                    | "http://www.w3.org/2001/XMLSchema#nonPositiveInteger"
-                    | "http://www.w3.org/2001/XMLSchema#nonNegativeInteger" => {
-                        parse_integer_str(value)
-                    }
-                    "http://www.w3.org/2001/XMLSchema#decimal" => parse_decimal_str(value),
-                    "http://www.w3.org/2001/XMLSchema#date" => parse_date_str(value),
-                    "http://www.w3.org/2001/XMLSchema#time" => parse_time_str(value),
-                    "http://www.w3.org/2001/XMLSchema#dateTime"
-                    | "http://www.w3.org/2001/XMLSchema#dateTimeStamp" => {
-                        parse_date_time_str(value)
-                    }
-                    "http://www.w3.org/2001/XMLSchema#duration" => parse_duration_str(value),
-                    "http://www.w3.org/2001/XMLSchema#yearMonthDuration" => {
-                        parse_year_month_duration_str(value)
-                    }
-                    "http://www.w3.org/2001/XMLSchema#dayTimeDuration" => {
-                        parse_day_time_duration_str(value)
-                    }
-                    _ => None,
-                } {
-                    Some(v) => v,
-                    None => EncodedTerm::TypedLiteral {
-                        value_id: StrHash::new(value),
-                        datatype_id: StrHash::new(datatype.iri),
-                    },
-                }
-            }
-        }
-    }
-}
-
-impl From<&NamedOrBlankNode> for EncodedTerm {
-    fn from(node: &NamedOrBlankNode) -> Self {
-        match node {
-            NamedOrBlankNode::NamedNode(node) => node.into(),
-            NamedOrBlankNode::BlankNode(node) => node.into(),
-        }
-    }
-}
-
-impl From<&Term> for EncodedTerm {
-    fn from(node: &Term) -> Self {
-        match node {
-            Term::NamedNode(node) => node.into(),
-            Term::BlankNode(node) => node.into(),
-            Term::Literal(literal) => literal.into(),
-        }
-    }
-}
-
-impl From<&GraphName> for EncodedTerm {
-    fn from(node: &GraphName) -> Self {
-        match node {
-            GraphName::NamedNode(node) => node.into(),
-            GraphName::BlankNode(node) => node.into(),
-            GraphName::DefaultGraph => EncodedTerm::DefaultGraph,
-        }
+        Self::DayTimeDurationLiteral(value)
     }
 }
 
 #[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
-pub struct EncodedQuad {
-    pub subject: EncodedTerm,
-    pub predicate: EncodedTerm,
-    pub object: EncodedTerm,
-    pub graph_name: EncodedTerm,
+pub struct EncodedQuad<I: StrId> {
+    pub subject: EncodedTerm<I>,
+    pub predicate: EncodedTerm<I>,
+    pub object: EncodedTerm<I>,
+    pub graph_name: EncodedTerm<I>,
 }
 
-impl EncodedQuad {
-    pub const fn new(
-        subject: EncodedTerm,
-        predicate: EncodedTerm,
-        object: EncodedTerm,
-        graph_name: EncodedTerm,
+impl<I: StrId> EncodedQuad<I> {
+    pub fn new(
+        subject: EncodedTerm<I>,
+        predicate: EncodedTerm<I>,
+        object: EncodedTerm<I>,
+        graph_name: EncodedTerm<I>,
     ) -> Self {
         Self {
             subject,
@@ -506,29 +474,18 @@ impl EncodedQuad {
     }
 }
 
-impl From<&Quad> for EncodedQuad {
-    fn from(quad: &Quad) -> Self {
-        Self {
-            subject: (&quad.subject).into(),
-            predicate: (&quad.predicate).into(),
-            object: (&quad.object).into(),
-            graph_name: (&quad.graph_name).into(),
-        }
-    }
-}
-
 pub trait TermReader {
-    fn read_term(&mut self) -> Result<EncodedTerm, io::Error>;
-    fn read_spog_quad(&mut self) -> Result<EncodedQuad, io::Error>;
-    fn read_posg_quad(&mut self) -> Result<EncodedQuad, io::Error>;
-    fn read_ospg_quad(&mut self) -> Result<EncodedQuad, io::Error>;
-    fn read_gspo_quad(&mut self) -> Result<EncodedQuad, io::Error>;
-    fn read_gpos_quad(&mut self) -> Result<EncodedQuad, io::Error>;
-    fn read_gosp_quad(&mut self) -> Result<EncodedQuad, io::Error>;
+    fn read_term(&mut self) -> Result<EncodedTerm<StrHash>, io::Error>;
+    fn read_spog_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error>;
+    fn read_posg_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error>;
+    fn read_ospg_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error>;
+    fn read_gspo_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error>;
+    fn read_gpos_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error>;
+    fn read_gosp_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error>;
 }
 
 impl<R: Read> TermReader for R {
-    fn read_term(&mut self) -> Result<EncodedTerm, io::Error> {
+    fn read_term(&mut self) -> Result<EncodedTerm<StrHash>, io::Error> {
         let mut type_buffer = [0];
         self.read_exact(&mut type_buffer)?;
         match type_buffer[0] {
@@ -645,7 +602,7 @@ impl<R: Read> TermReader for R {
         }
     }
 
-    fn read_spog_quad(&mut self) -> Result<EncodedQuad, io::Error> {
+    fn read_spog_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error> {
         let subject = self.read_term()?;
         let predicate = self.read_term()?;
         let object = self.read_term()?;
@@ -658,7 +615,7 @@ impl<R: Read> TermReader for R {
         })
     }
 
-    fn read_posg_quad(&mut self) -> Result<EncodedQuad, io::Error> {
+    fn read_posg_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error> {
         let predicate = self.read_term()?;
         let object = self.read_term()?;
         let subject = self.read_term()?;
@@ -671,7 +628,7 @@ impl<R: Read> TermReader for R {
         })
     }
 
-    fn read_ospg_quad(&mut self) -> Result<EncodedQuad, io::Error> {
+    fn read_ospg_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error> {
         let object = self.read_term()?;
         let subject = self.read_term()?;
         let predicate = self.read_term()?;
@@ -684,7 +641,7 @@ impl<R: Read> TermReader for R {
         })
     }
 
-    fn read_gspo_quad(&mut self) -> Result<EncodedQuad, io::Error> {
+    fn read_gspo_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error> {
         let graph_name = self.read_term()?;
         let subject = self.read_term()?;
         let predicate = self.read_term()?;
@@ -697,7 +654,7 @@ impl<R: Read> TermReader for R {
         })
     }
 
-    fn read_gpos_quad(&mut self) -> Result<EncodedQuad, io::Error> {
+    fn read_gpos_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error> {
         let graph_name = self.read_term()?;
         let predicate = self.read_term()?;
         let object = self.read_term()?;
@@ -710,7 +667,7 @@ impl<R: Read> TermReader for R {
         })
     }
 
-    fn read_gosp_quad(&mut self) -> Result<EncodedQuad, io::Error> {
+    fn read_gosp_quad(&mut self) -> Result<EncodedQuad<StrHash>, io::Error> {
         let graph_name = self.read_term()?;
         let object = self.read_term()?;
         let subject = self.read_term()?;
@@ -726,27 +683,27 @@ impl<R: Read> TermReader for R {
 
 pub const WRITTEN_TERM_MAX_SIZE: usize = size_of::<u8>() + 2 * size_of::<StrHash>();
 
-pub fn write_term(sink: &mut Vec<u8>, term: EncodedTerm) {
+pub fn write_term<I: SerializableStrId>(sink: &mut Vec<u8>, term: EncodedTerm<I>) {
     sink.push(term.type_id());
     match term {
         EncodedTerm::DefaultGraph => {}
-        EncodedTerm::NamedNode { iri_id } => sink.extend_from_slice(&iri_id.to_be_bytes()),
+        EncodedTerm::NamedNode { iri_id } => iri_id.push_be_bytes(sink),
         EncodedTerm::InlineBlankNode { id } => sink.extend_from_slice(&id.to_be_bytes()),
-        EncodedTerm::NamedBlankNode { id_id } => sink.extend_from_slice(&id_id.to_be_bytes()),
-        EncodedTerm::StringLiteral { value_id } => sink.extend_from_slice(&value_id.to_be_bytes()),
+        EncodedTerm::NamedBlankNode { id_id } => id_id.push_be_bytes(sink),
+        EncodedTerm::StringLiteral { value_id } => value_id.push_be_bytes(sink),
         EncodedTerm::LangStringLiteral {
             value_id,
             language_id,
         } => {
-            sink.extend_from_slice(&language_id.to_be_bytes());
-            sink.extend_from_slice(&value_id.to_be_bytes());
+            value_id.push_be_bytes(sink);
+            language_id.push_be_bytes(sink);
         }
         EncodedTerm::TypedLiteral {
             value_id,
             datatype_id,
         } => {
-            sink.extend_from_slice(&datatype_id.to_be_bytes());
-            sink.extend_from_slice(&value_id.to_be_bytes());
+            value_id.push_be_bytes(sink);
+            datatype_id.push_be_bytes(sink);
         }
         EncodedTerm::BooleanLiteral(_) => {}
         EncodedTerm::FloatLiteral(value) => sink.extend_from_slice(&value.to_be_bytes()),
@@ -765,15 +722,24 @@ pub fn write_term(sink: &mut Vec<u8>, term: EncodedTerm) {
 }
 
 pub(crate) trait WithStoreError {
+    //TODO: rename
     type Error: Error + Into<EvaluationError> + 'static;
+    type StrId: StrId + 'static;
+}
+
+impl<'a, T: WithStoreError> WithStoreError for &'a T {
+    type Error = T::Error;
+    type StrId = T::StrId;
 }
 
 pub(crate) trait StrLookup: WithStoreError {
-    fn get_str(&self, id: StrHash) -> Result<Option<String>, Self::Error>;
+    fn get_str(&self, id: Self::StrId) -> Result<Option<String>, Self::Error>;
+
+    fn get_str_id(&self, value: &str) -> Result<Option<Self::StrId>, Self::Error>;
 }
 
 pub(crate) trait StrContainer: WithStoreError {
-    fn insert_str(&mut self, value: &str) -> Result<StrHash, Self::Error>;
+    fn insert_str(&mut self, value: &str) -> Result<Self::StrId, Self::Error>;
 }
 
 pub struct MemoryStrStore {
@@ -790,6 +756,7 @@ impl Default for MemoryStrStore {
 
 impl WithStoreError for MemoryStrStore {
     type Error = Infallible;
+    type StrId = StrHash;
 }
 
 impl StrLookup for MemoryStrStore {
@@ -797,6 +764,15 @@ impl StrLookup for MemoryStrStore {
         //TODO: avoid copy by adding a lifetime limit to get_str
         Ok(self.id2str.get(&id).cloned())
     }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, Infallible> {
+        let id = StrHash::new(value);
+        Ok(if self.id2str.contains_key(&id) {
+            Some(id)
+        } else {
+            None
+        })
+    }
 }
 
 impl StrContainer for MemoryStrStore {
@@ -807,28 +783,235 @@ impl StrContainer for MemoryStrStore {
     }
 }
 
-pub(crate) trait Encoder: WithStoreError {
-    fn encode_named_node(&mut self, named_node: &NamedNode) -> Result<EncodedTerm, Self::Error> {
+/// Tries to encode a term based on the existing strings (does not insert anything)
+pub(crate) trait ReadEncoder: WithStoreError {
+    fn get_encoded_named_node(
+        &self,
+        named_node: &NamedNode,
+    ) -> Result<Option<EncodedTerm<Self::StrId>>, Self::Error> {
+        Ok(Some(EncodedTerm::NamedNode {
+            iri_id: if let Some(iri_id) = self.get_encoded_str(named_node.as_str())? {
+                iri_id
+            } else {
+                return Ok(None);
+            },
+        }))
+    }
+
+    fn get_encoded_blank_node(
+        &self,
+        blank_node: &BlankNode,
+    ) -> Result<Option<EncodedTerm<Self::StrId>>, Self::Error> {
+        Ok(Some(if let Some(id) = blank_node.id() {
+            EncodedTerm::InlineBlankNode { id }
+        } else {
+            EncodedTerm::NamedBlankNode {
+                id_id: if let Some(id_id) = self.get_encoded_str(blank_node.as_str())? {
+                    id_id
+                } else {
+                    return Ok(None);
+                },
+            }
+        }))
+    }
+
+    fn get_encoded_literal(
+        &self,
+        literal: &Literal,
+    ) -> Result<Option<EncodedTerm<Self::StrId>>, Self::Error> {
+        Ok(Some(
+            match match literal.datatype().as_str() {
+                "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" => {
+                    if let Some(language) = literal.language() {
+                        Some(EncodedTerm::LangStringLiteral {
+                            value_id: if let Some(value_id) =
+                                self.get_encoded_str(literal.value())?
+                            {
+                                value_id
+                            } else {
+                                return Ok(None);
+                            },
+                            language_id: if let Some(language_id) =
+                                self.get_encoded_str(language)?
+                            {
+                                language_id
+                            } else {
+                                return Ok(None);
+                            },
+                        })
+                    } else {
+                        None
+                    }
+                }
+                "http://www.w3.org/2001/XMLSchema#boolean" => parse_boolean_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#string" => Some(EncodedTerm::StringLiteral {
+                    value_id: if let Some(value_id) = self.get_encoded_str(literal.value())? {
+                        value_id
+                    } else {
+                        return Ok(None);
+                    },
+                }),
+                "http://www.w3.org/2001/XMLSchema#float" => parse_float_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#double" => parse_double_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#integer"
+                | "http://www.w3.org/2001/XMLSchema#byte"
+                | "http://www.w3.org/2001/XMLSchema#short"
+                | "http://www.w3.org/2001/XMLSchema#int"
+                | "http://www.w3.org/2001/XMLSchema#long"
+                | "http://www.w3.org/2001/XMLSchema#unsignedByte"
+                | "http://www.w3.org/2001/XMLSchema#unsignedShort"
+                | "http://www.w3.org/2001/XMLSchema#unsignedInt"
+                | "http://www.w3.org/2001/XMLSchema#unsignedLong"
+                | "http://www.w3.org/2001/XMLSchema#positiveInteger"
+                | "http://www.w3.org/2001/XMLSchema#negativeInteger"
+                | "http://www.w3.org/2001/XMLSchema#nonPositiveInteger"
+                | "http://www.w3.org/2001/XMLSchema#nonNegativeInteger" => {
+                    parse_integer_str(literal.value())
+                }
+                "http://www.w3.org/2001/XMLSchema#decimal" => parse_decimal_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#date" => parse_date_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#time" => parse_time_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#dateTime"
+                | "http://www.w3.org/2001/XMLSchema#dateTimeStamp" => {
+                    parse_date_time_str(literal.value())
+                }
+                "http://www.w3.org/2001/XMLSchema#duration" => parse_duration_str(literal.value()),
+                "http://www.w3.org/2001/XMLSchema#yearMonthDuration" => {
+                    parse_year_month_duration_str(literal.value())
+                }
+                "http://www.w3.org/2001/XMLSchema#dayTimeDuration" => {
+                    parse_day_time_duration_str(literal.value())
+                }
+                _ => None,
+            } {
+                Some(term) => term,
+                None => EncodedTerm::TypedLiteral {
+                    value_id: if let Some(value_id) = self.get_encoded_str(literal.value())? {
+                        value_id
+                    } else {
+                        return Ok(None);
+                    },
+                    datatype_id: if let Some(datatype_id) =
+                        self.get_encoded_str(literal.datatype().as_str())?
+                    {
+                        datatype_id
+                    } else {
+                        return Ok(None);
+                    },
+                },
+            },
+        ))
+    }
+
+    fn get_encoded_named_or_blank_node(
+        &self,
+        term: &NamedOrBlankNode,
+    ) -> Result<Option<EncodedTerm<Self::StrId>>, Self::Error> {
+        match term {
+            NamedOrBlankNode::NamedNode(named_node) => self.get_encoded_named_node(named_node),
+            NamedOrBlankNode::BlankNode(blank_node) => self.get_encoded_blank_node(blank_node),
+        }
+    }
+
+    fn get_encoded_term(
+        &self,
+        term: &Term,
+    ) -> Result<Option<EncodedTerm<Self::StrId>>, Self::Error> {
+        match term {
+            Term::NamedNode(named_node) => self.get_encoded_named_node(named_node),
+            Term::BlankNode(blank_node) => self.get_encoded_blank_node(blank_node),
+            Term::Literal(literal) => self.get_encoded_literal(literal),
+        }
+    }
+
+    fn get_encoded_graph_name(
+        &self,
+        name: &GraphName,
+    ) -> Result<Option<EncodedTerm<Self::StrId>>, Self::Error> {
+        match name {
+            GraphName::NamedNode(named_node) => self.get_encoded_named_node(named_node),
+            GraphName::BlankNode(blank_node) => self.get_encoded_blank_node(blank_node),
+            GraphName::DefaultGraph => Ok(Some(EncodedTerm::DefaultGraph)),
+        }
+    }
+
+    fn get_encoded_quad(
+        &self,
+        quad: &Quad,
+    ) -> Result<Option<EncodedQuad<Self::StrId>>, Self::Error> {
+        Ok(Some(EncodedQuad {
+            subject: if let Some(subject) = self.get_encoded_named_or_blank_node(&quad.subject)? {
+                subject
+            } else {
+                return Ok(None);
+            },
+            predicate: if let Some(predicate) = self.get_encoded_named_node(&quad.predicate)? {
+                predicate
+            } else {
+                return Ok(None);
+            },
+            object: if let Some(object) = self.get_encoded_term(&quad.object)? {
+                object
+            } else {
+                return Ok(None);
+            },
+            graph_name: if let Some(graph_name) = self.get_encoded_graph_name(&quad.graph_name)? {
+                graph_name
+            } else {
+                return Ok(None);
+            },
+        }))
+    }
+
+    fn get_encoded_str(&self, value: &str) -> Result<Option<Self::StrId>, Self::Error>;
+}
+
+impl<S: StrLookup> ReadEncoder for S {
+    fn get_encoded_str(&self, value: &str) -> Result<Option<Self::StrId>, Self::Error> {
+        self.get_str_id(value)
+    }
+}
+
+/// Encodes a term and insert strings if needed
+pub(crate) trait WriteEncoder: WithStoreError {
+    fn encode_named_node(
+        &mut self,
+        named_node: &NamedNode,
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         self.encode_rio_named_node(named_node.into())
     }
 
-    fn encode_blank_node(&mut self, blank_node: &BlankNode) -> Result<EncodedTerm, Self::Error>;
+    fn encode_blank_node(
+        &mut self,
+        blank_node: &BlankNode,
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
+        if let Some(id) = blank_node.id() {
+            Ok(EncodedTerm::InlineBlankNode { id })
+        } else {
+            Ok(EncodedTerm::NamedBlankNode {
+                id_id: self.encode_str(blank_node.as_str())?,
+            })
+        }
+    }
 
-    fn encode_literal(&mut self, literal: &Literal) -> Result<EncodedTerm, Self::Error> {
+    fn encode_literal(
+        &mut self,
+        literal: &Literal,
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         self.encode_rio_literal(literal.into())
     }
 
     fn encode_named_or_blank_node(
         &mut self,
         term: &NamedOrBlankNode,
-    ) -> Result<EncodedTerm, Self::Error> {
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         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(&mut self, term: &Term) -> Result<EncodedTerm, Self::Error> {
+    fn encode_term(&mut self, term: &Term) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         match term {
             Term::NamedNode(named_node) => self.encode_named_node(named_node),
             Term::BlankNode(blank_node) => self.encode_blank_node(blank_node),
@@ -836,7 +1019,10 @@ pub(crate) trait Encoder: WithStoreError {
         }
     }
 
-    fn encode_graph_name(&mut self, name: &GraphName) -> Result<EncodedTerm, Self::Error> {
+    fn encode_graph_name(
+        &mut self,
+        name: &GraphName,
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         match name {
             GraphName::NamedNode(named_node) => self.encode_named_node(named_node),
             GraphName::BlankNode(blank_node) => self.encode_blank_node(blank_node),
@@ -844,7 +1030,7 @@ pub(crate) trait Encoder: WithStoreError {
         }
     }
 
-    fn encode_quad(&mut self, quad: &Quad) -> Result<EncodedQuad, Self::Error> {
+    fn encode_quad(&mut self, quad: &Quad) -> Result<EncodedQuad<Self::StrId>, Self::Error> {
         Ok(EncodedQuad {
             subject: self.encode_named_or_blank_node(&quad.subject)?,
             predicate: self.encode_named_node(&quad.predicate)?,
@@ -856,8 +1042,8 @@ pub(crate) trait Encoder: WithStoreError {
     fn encode_triple_in_graph(
         &mut self,
         triple: &Triple,
-        graph_name: EncodedTerm,
-    ) -> Result<EncodedQuad, Self::Error> {
+        graph_name: EncodedTerm<Self::StrId>,
+    ) -> Result<EncodedQuad<Self::StrId>, Self::Error> {
         Ok(EncodedQuad {
             subject: self.encode_named_or_blank_node(&triple.subject)?,
             predicate: self.encode_named_node(&triple.predicate)?,
@@ -869,98 +1055,17 @@ pub(crate) trait Encoder: WithStoreError {
     fn encode_rio_named_node(
         &mut self,
         named_node: rio::NamedNode<'_>,
-    ) -> Result<EncodedTerm, Self::Error>;
-
-    fn encode_rio_blank_node(
-        &mut self,
-        blank_node: rio::BlankNode<'_>,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm, Self::Error>;
-
-    fn encode_rio_literal(&mut self, literal: rio::Literal<'_>)
-        -> Result<EncodedTerm, Self::Error>;
-
-    fn encode_rio_named_or_blank_node(
-        &mut self,
-        term: rio::NamedOrBlankNode<'_>,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm, Self::Error> {
-        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, Self::Error> {
-        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, Self::Error> {
-        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 => EncodedTerm::DefaultGraph,
-            },
-        })
-    }
-
-    fn encode_rio_triple_in_graph(
-        &mut self,
-        triple: rio::Triple<'_>,
-        graph_name: EncodedTerm,
-        bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedQuad, Self::Error> {
-        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, Self::Error> {
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         Ok(EncodedTerm::NamedNode {
-            iri_id: self.insert_str(named_node.iri)?,
+            iri_id: self.encode_str(named_node.iri)?,
         })
     }
 
-    fn encode_blank_node(&mut self, blank_node: &BlankNode) -> Result<EncodedTerm, Self::Error> {
-        if let Some(id) = blank_node.id() {
-            Ok(EncodedTerm::InlineBlankNode { id })
-        } else {
-            Ok(EncodedTerm::NamedBlankNode {
-                id_id: self.insert_str(blank_node.as_str())?,
-            })
-        }
-    }
-
     fn encode_rio_blank_node(
         &mut self,
         blank_node: rio::BlankNode<'_>,
         bnodes_map: &mut HashMap<String, u128>,
-    ) -> Result<EncodedTerm, Self::Error> {
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         Ok(if let Some(id) = bnodes_map.get(blank_node.id) {
             EncodedTerm::InlineBlankNode { id: *id }
         } else {
@@ -969,26 +1074,25 @@ impl<S: StrContainer> Encoder for S {
             EncodedTerm::InlineBlankNode { id }
         })
     }
-
     fn encode_rio_literal(
         &mut self,
         literal: rio::Literal<'_>,
-    ) -> Result<EncodedTerm, Self::Error> {
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
         Ok(match literal {
             rio::Literal::Simple { value } => EncodedTerm::StringLiteral {
-                value_id: self.insert_str(value)?,
+                value_id: self.encode_str(value)?,
             },
             rio::Literal::LanguageTaggedString { value, language } => {
                 EncodedTerm::LangStringLiteral {
-                    value_id: self.insert_str(value)?,
-                    language_id: self.insert_str(language)?,
+                    value_id: self.encode_str(value)?,
+                    language_id: self.encode_str(language)?,
                 }
             }
             rio::Literal::Typed { value, datatype } => {
                 match match datatype.iri {
                     "http://www.w3.org/2001/XMLSchema#boolean" => parse_boolean_str(value),
                     "http://www.w3.org/2001/XMLSchema#string" => Some(EncodedTerm::StringLiteral {
-                        value_id: self.insert_str(value)?,
+                        value_id: self.encode_str(value)?,
                     }),
                     "http://www.w3.org/2001/XMLSchema#float" => parse_float_str(value),
                     "http://www.w3.org/2001/XMLSchema#double" => parse_double_str(value),
@@ -1025,16 +1129,79 @@ impl<S: StrContainer> Encoder for S {
                 } {
                     Some(v) => v,
                     None => EncodedTerm::TypedLiteral {
-                        value_id: self.insert_str(value)?,
-                        datatype_id: self.insert_str(datatype.iri)?,
+                        value_id: self.encode_str(value)?,
+                        datatype_id: self.encode_str(datatype.iri)?,
                     },
                 }
             }
         })
     }
+
+    fn encode_rio_named_or_blank_node(
+        &mut self,
+        term: rio::NamedOrBlankNode<'_>,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedTerm<Self::StrId>, Self::Error> {
+        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<Self::StrId>, Self::Error> {
+        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<Self::StrId>, Self::Error> {
+        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 => EncodedTerm::DefaultGraph,
+            },
+        })
+    }
+
+    fn encode_rio_triple_in_graph(
+        &mut self,
+        triple: rio::Triple<'_>,
+        graph_name: EncodedTerm<Self::StrId>,
+        bnodes_map: &mut HashMap<String, u128>,
+    ) -> Result<EncodedQuad<Self::StrId>, Self::Error> {
+        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,
+        })
+    }
+
+    fn encode_str(&mut self, value: &str) -> Result<Self::StrId, Self::Error>;
+}
+
+impl<S: StrContainer> WriteEncoder for S {
+    fn encode_str(&mut self, value: &str) -> Result<Self::StrId, Self::Error> {
+        self.insert_str(value)
+    }
 }
 
-pub fn parse_boolean_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_boolean_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     match value {
         "true" | "1" => Some(EncodedTerm::BooleanLiteral(true)),
         "false" | "0" => Some(EncodedTerm::BooleanLiteral(false)),
@@ -1042,55 +1209,58 @@ pub fn parse_boolean_str(value: &str) -> Option<EncodedTerm> {
     }
 }
 
-pub fn parse_float_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_float_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::FloatLiteral).ok()
 }
 
-pub fn parse_double_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_double_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::DoubleLiteral).ok()
 }
 
-pub fn parse_integer_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_integer_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::IntegerLiteral).ok()
 }
 
-pub fn parse_decimal_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_decimal_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::DecimalLiteral).ok()
 }
 
-pub fn parse_date_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_date_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::DateLiteral).ok()
 }
 
-pub fn parse_time_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_time_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::TimeLiteral).ok()
 }
 
-pub fn parse_date_time_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_date_time_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::DateTimeLiteral).ok()
 }
 
-pub fn parse_duration_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_duration_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::DurationLiteral).ok()
 }
 
-pub fn parse_year_month_duration_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_year_month_duration_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value
         .parse()
         .map(EncodedTerm::YearMonthDurationLiteral)
         .ok()
 }
 
-pub fn parse_day_time_duration_str(value: &str) -> Option<EncodedTerm> {
+pub fn parse_day_time_duration_str<I: StrId>(value: &str) -> Option<EncodedTerm<I>> {
     value.parse().map(EncodedTerm::DayTimeDurationLiteral).ok()
 }
 
 pub(crate) trait Decoder: StrLookup {
-    fn decode_term(&self, encoded: EncodedTerm) -> Result<Term, DecoderError<Self::Error>>;
+    fn decode_term(
+        &self,
+        encoded: EncodedTerm<Self::StrId>,
+    ) -> Result<Term, DecoderError<Self::Error>>;
 
     fn decode_named_or_blank_node(
         &self,
-        encoded: EncodedTerm,
+        encoded: EncodedTerm<Self::StrId>,
     ) -> Result<NamedOrBlankNode, DecoderError<Self::Error>> {
         match self.decode_term(encoded)? {
             Term::NamedNode(named_node) => Ok(named_node.into()),
@@ -1103,7 +1273,7 @@ pub(crate) trait Decoder: StrLookup {
 
     fn decode_named_node(
         &self,
-        encoded: EncodedTerm,
+        encoded: EncodedTerm<Self::StrId>,
     ) -> Result<NamedNode, DecoderError<Self::Error>> {
         match self.decode_term(encoded)? {
             Term::NamedNode(named_node) => Ok(named_node),
@@ -1116,7 +1286,10 @@ pub(crate) trait Decoder: StrLookup {
         }
     }
 
-    fn decode_triple(&self, encoded: &EncodedQuad) -> Result<Triple, DecoderError<Self::Error>> {
+    fn decode_triple(
+        &self,
+        encoded: &EncodedQuad<Self::StrId>,
+    ) -> Result<Triple, DecoderError<Self::Error>> {
         Ok(Triple::new(
             self.decode_named_or_blank_node(encoded.subject)?,
             self.decode_named_node(encoded.predicate)?,
@@ -1124,7 +1297,10 @@ pub(crate) trait Decoder: StrLookup {
         ))
     }
 
-    fn decode_quad(&self, encoded: &EncodedQuad) -> Result<Quad, DecoderError<Self::Error>> {
+    fn decode_quad(
+        &self,
+        encoded: &EncodedQuad<Self::StrId>,
+    ) -> Result<Quad, DecoderError<Self::Error>> {
         Ok(Quad::new(
             self.decode_named_or_blank_node(encoded.subject)?,
             self.decode_named_node(encoded.predicate)?,
@@ -1138,7 +1314,10 @@ pub(crate) trait Decoder: StrLookup {
 }
 
 impl<S: StrLookup> Decoder for S {
-    fn decode_term(&self, encoded: EncodedTerm) -> Result<Term, DecoderError<Self::Error>> {
+    fn decode_term(
+        &self,
+        encoded: EncodedTerm<Self::StrId>,
+    ) -> Result<Term, DecoderError<Self::Error>> {
         match encoded {
             EncodedTerm::DefaultGraph => Err(DecoderError::Decoder {
                 msg: "The default graph tag is not a valid term".to_owned(),
@@ -1186,7 +1365,7 @@ impl<S: StrLookup> Decoder for S {
 
 fn get_required_str<L: StrLookup>(
     lookup: &L,
-    id: StrHash,
+    id: L::StrId,
 ) -> Result<String, DecoderError<L::Error>> {
     lookup
         .get_str(id)
@@ -1263,7 +1442,7 @@ fn test_encoding() {
     ];
     for term in terms {
         let encoded = store.encode_term(&term).unwrap();
+        assert_eq!(Some(encoded), store.get_encoded_term(&term).unwrap());
         assert_eq!(term, store.decode_term(encoded).unwrap());
-        assert_eq!(encoded, EncodedTerm::from(&term));
     }
 }
diff --git a/lib/src/store/rocksdb.rs b/lib/src/store/rocksdb.rs
index e5c2fbb3..b5a62f75 100644
--- a/lib/src/store/rocksdb.rs
+++ b/lib/src/store/rocksdb.rs
@@ -1,17 +1,23 @@
 //! Store based on the [RocksDB](https://rocksdb.org/) key-value database.
 
-use crate::error::{invalid_data_error, UnwrapInfallible};
+use crate::error::invalid_data_error;
 use crate::io::{DatasetFormat, GraphFormat};
 use crate::model::*;
 use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery};
-use crate::store::numeric_encoder::*;
+use crate::store::numeric_encoder::{
+    write_term, Decoder, ReadEncoder, StrContainer, StrHash, StrLookup, TermReader, WithStoreError,
+    WriteEncoder, WRITTEN_TERM_MAX_SIZE,
+};
 use crate::store::{
-    dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, WritableEncodedStore,
+    dump_dataset, dump_graph, get_encoded_quad_pattern, load_dataset, load_graph,
+    ReadableEncodedStore, WritableEncodedStore,
 };
 use rocksdb::*;
-use std::convert::{Infallible, TryInto};
+use std::collections::HashMap;
+use std::convert::TryInto;
 use std::io;
 use std::io::{BufRead, Cursor, Write};
+use std::iter::{once, Once};
 use std::mem::{take, transmute};
 use std::path::Path;
 use std::sync::Arc;
@@ -55,6 +61,9 @@ pub struct RocksDbStore {
     db: Arc<DB>,
 }
 
+type EncodedTerm = crate::store::numeric_encoder::EncodedTerm<StrHash>;
+type EncodedQuad = crate::store::numeric_encoder::EncodedQuad<StrHash>;
+
 const ID2STR_CF: &str = "id2str";
 const SPOG_CF: &str = "spog";
 const POSG_CF: &str = "posg";
@@ -121,19 +130,23 @@ impl RocksDbStore {
         object: Option<&Term>,
         graph_name: Option<&GraphName>,
     ) -> impl Iterator<Item = Result<Quad, io::Error>> {
-        let subject = subject.map(|s| s.into());
-        let predicate = predicate.map(|p| p.into());
-        let object = object.map(|o| o.into());
-        let graph_name = graph_name.map(|g| g.into());
-        let store = self.clone();
-        self.encoded_quads_for_pattern(subject, predicate, object, graph_name)
-            .map(move |quad| Ok(store.decode_quad(&quad?)?))
+        match get_encoded_quad_pattern(self, subject, predicate, object, graph_name) {
+            Ok(Some((subject, predicate, object, graph_name))) => QuadsIter::Quads {
+                iter: self.encoded_quads_for_pattern(subject, predicate, object, graph_name),
+                store: self.clone(),
+            },
+            Ok(None) => QuadsIter::Empty,
+            Err(error) => QuadsIter::Error(once(error)),
+        }
     }
 
     /// Checks if this store contains a given quad
     pub fn contains(&self, quad: &Quad) -> Result<bool, io::Error> {
-        let quad = quad.into();
-        self.contains_encoded(&quad)
+        if let Some(quad) = self.get_encoded_quad(quad)? {
+            self.contains_encoded(&quad)
+        } else {
+            Ok(false)
+        }
     }
 
     /// Returns the number of quads in the store
@@ -162,14 +175,13 @@ impl RocksDbStore {
         f: impl FnOnce(&mut RocksDbTransaction<'a>) -> Result<(), E>,
     ) -> Result<(), E> {
         let mut transaction = RocksDbTransaction {
-            inner: BatchWriter {
-                store: self,
-                batch: WriteBatch::default(),
-                buffer: Vec::default(),
-            },
+            store: self,
+            batch: WriteBatch::default(),
+            buffer: Vec::new(),
+            new_strings: HashMap::new(),
         };
         f(&mut transaction)?;
-        Ok(transaction.inner.apply()?)
+        Ok(transaction.apply()?)
     }
 
     /// Loads a graph file (i.e. triples) into the store
@@ -225,10 +237,13 @@ impl RocksDbStore {
 
     /// Removes a quad from this store.
     pub fn remove(&self, quad: &Quad) -> Result<(), io::Error> {
-        let mut transaction = self.auto_batch_writer();
-        let quad = quad.into();
-        transaction.remove_encoded(&quad)?;
-        transaction.apply()
+        if let Some(quad) = self.get_encoded_quad(quad)? {
+            let mut transaction = self.auto_batch_writer();
+            transaction.remove_encoded(&quad)?;
+            transaction.apply()
+        } else {
+            Ok(())
+        }
     }
 
     /// Dumps a store graph into a file.
@@ -289,11 +304,9 @@ impl RocksDbStore {
 
     fn auto_batch_writer(&self) -> AutoBatchWriter<'_> {
         AutoBatchWriter {
-            inner: BatchWriter {
-                store: self,
-                batch: WriteBatch::default(),
-                buffer: Vec::default(),
-            },
+            store: self,
+            batch: WriteBatch::default(),
+            buffer: Vec::default(),
         }
     }
 
@@ -463,6 +476,7 @@ impl fmt::Display for RocksDbStore {
 
 impl WithStoreError for RocksDbStore {
     type Error = io::Error;
+    type StrId = StrHash;
 }
 
 impl StrLookup for RocksDbStore {
@@ -474,6 +488,22 @@ impl StrLookup for RocksDbStore {
             .transpose()
             .map_err(invalid_data_error)
     }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, io::Error> {
+        let id = StrHash::new(value);
+        Ok(
+            if self
+                .db
+                .get_cf(self.id2str_cf(), &id.to_be_bytes())
+                .map_err(map_err)?
+                .is_some()
+            {
+                Some(id)
+            } else {
+                None
+            },
+        )
+    }
 }
 
 impl ReadableEncodedStore for RocksDbStore {
@@ -553,9 +583,106 @@ impl RocksDbPreparedQuery {
     }
 }
 
+struct AutoBatchWriter<'a> {
+    store: &'a RocksDbStore,
+    batch: WriteBatch,
+    buffer: Vec<u8>,
+}
+
+impl AutoBatchWriter<'_> {
+    fn apply(self) -> Result<(), io::Error> {
+        self.store.db.write(self.batch).map_err(map_err)
+    }
+
+    fn apply_if_big(&mut self) -> Result<(), io::Error> {
+        if self.batch.len() > MAX_TRANSACTION_SIZE {
+            self.store
+                .db
+                .write(take(&mut self.batch))
+                .map_err(map_err)?;
+        }
+        Ok(())
+    }
+}
+
+impl WithStoreError for AutoBatchWriter<'_> {
+    type Error = io::Error;
+    type StrId = StrHash;
+}
+
+impl StrContainer for AutoBatchWriter<'_> {
+    fn insert_str(&mut self, value: &str) -> Result<StrHash, io::Error> {
+        let key = StrHash::new(value);
+        self.batch
+            .put_cf(self.store.id2str_cf(), &key.to_be_bytes(), value);
+        Ok(key)
+    }
+}
+
+impl WritableEncodedStore for AutoBatchWriter<'_> {
+    fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
+        write_spog_quad(&mut self.buffer, quad);
+        self.batch.put_cf(self.store.spog_cf(), &self.buffer, &[]);
+        self.buffer.clear();
+
+        write_posg_quad(&mut self.buffer, quad);
+        self.batch.put_cf(self.store.posg_cf(), &self.buffer, &[]);
+        self.buffer.clear();
+
+        write_ospg_quad(&mut self.buffer, quad);
+        self.batch.put_cf(self.store.ospg_cf(), &self.buffer, &[]);
+        self.buffer.clear();
+
+        write_gspo_quad(&mut self.buffer, quad);
+        self.batch.put_cf(self.store.gspo_cf(), &self.buffer, &[]);
+        self.buffer.clear();
+
+        write_gpos_quad(&mut self.buffer, quad);
+        self.batch.put_cf(self.store.gpos_cf(), &self.buffer, &[]);
+        self.buffer.clear();
+
+        write_gosp_quad(&mut self.buffer, quad);
+        self.batch.put_cf(self.store.gosp_cf(), &self.buffer, &[]);
+        self.buffer.clear();
+
+        self.apply_if_big()
+    }
+
+    fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
+        write_spog_quad(&mut self.buffer, quad);
+        self.batch.delete_cf(self.store.spog_cf(), &self.buffer);
+        self.buffer.clear();
+
+        write_posg_quad(&mut self.buffer, quad);
+        self.batch.delete_cf(self.store.posg_cf(), &self.buffer);
+        self.buffer.clear();
+
+        write_ospg_quad(&mut self.buffer, quad);
+        self.batch.delete_cf(self.store.ospg_cf(), &self.buffer);
+        self.buffer.clear();
+
+        write_gspo_quad(&mut self.buffer, quad);
+        self.batch.delete_cf(self.store.gspo_cf(), &self.buffer);
+        self.buffer.clear();
+
+        write_gpos_quad(&mut self.buffer, quad);
+        self.batch.delete_cf(self.store.gpos_cf(), &self.buffer);
+        self.buffer.clear();
+
+        write_gosp_quad(&mut self.buffer, quad);
+        self.batch.delete_cf(self.store.gosp_cf(), &self.buffer);
+        self.buffer.clear();
+
+        self.apply_if_big()
+    }
+}
+
 /// Allows inserting and deleting quads during a transaction with the `RocksDbStore`.
 pub struct RocksDbTransaction<'a> {
-    inner: BatchWriter<'a>,
+    store: &'a RocksDbStore,
+    batch: WriteBatch,
+    buffer: Vec<u8>,
+    new_strings: HashMap<StrHash, String>,
 }
 
 impl RocksDbTransaction<'_> {
@@ -576,7 +703,7 @@ impl RocksDbTransaction<'_> {
         to_graph_name: &GraphName,
         base_iri: Option<&str>,
     ) -> Result<(), io::Error> {
-        load_graph(&mut self.inner, reader, syntax, to_graph_name, base_iri)?;
+        load_graph(self, reader, syntax, to_graph_name, base_iri)?;
         Ok(())
     }
 
@@ -596,44 +723,76 @@ impl RocksDbTransaction<'_> {
         format: DatasetFormat,
         base_iri: Option<&str>,
     ) -> Result<(), io::Error> {
-        load_dataset(&mut self.inner, reader, format, base_iri)?;
+        load_dataset(self, reader, format, base_iri)?;
         Ok(())
     }
 
     /// Adds a quad to this store during the transaction.
-    pub fn insert(&mut self, quad: &Quad) {
-        let quad = self.inner.encode_quad(quad).unwrap_infallible();
-        self.inner.insert_encoded(&quad).unwrap_infallible()
+    pub fn insert(&mut self, quad: &Quad) -> Result<(), io::Error> {
+        let quad = self.encode_quad(quad)?;
+        self.insert_encoded(&quad)
     }
 
     /// Removes a quad from this store during the transaction.
-    pub fn remove(&mut self, quad: &Quad) {
-        let quad = quad.into();
-        self.inner.remove_encoded(&quad).unwrap_infallible()
+    pub fn remove(&mut self, quad: &Quad) -> Result<(), io::Error> {
+        // Works because all strings could be encoded
+        if let Some(quad) = self.get_encoded_quad(quad).unwrap() {
+            self.remove_encoded(&quad)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn apply(self) -> Result<(), io::Error> {
+        self.store.db.write(self.batch).map_err(map_err)
     }
 }
 
-struct BatchWriter<'a> {
-    store: &'a RocksDbStore,
-    batch: WriteBatch,
-    buffer: Vec<u8>,
+impl WithStoreError for RocksDbTransaction<'_> {
+    type Error = io::Error;
+    type StrId = StrHash;
 }
 
-impl WithStoreError for BatchWriter<'_> {
-    type Error = Infallible;
+impl StrLookup for RocksDbTransaction<'_> {
+    fn get_str(&self, id: StrHash) -> Result<Option<String>, io::Error> {
+        if let Some(str) = self.new_strings.get(&id) {
+            Ok(Some(str.clone()))
+        } else {
+            self.store.get_str(id)
+        }
+    }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, io::Error> {
+        let id = StrHash::new(value);
+        Ok(
+            if self.new_strings.contains_key(&id)
+                || self
+                    .store
+                    .db
+                    .get_cf(self.store.id2str_cf(), &id.to_be_bytes())
+                    .map_err(map_err)?
+                    .is_some()
+            {
+                Some(id)
+            } else {
+                None
+            },
+        )
+    }
 }
 
-impl StrContainer for BatchWriter<'_> {
-    fn insert_str(&mut self, value: &str) -> Result<StrHash, Infallible> {
+impl StrContainer for RocksDbTransaction<'_> {
+    fn insert_str(&mut self, value: &str) -> Result<StrHash, io::Error> {
         let key = StrHash::new(value);
         self.batch
             .put_cf(self.store.id2str_cf(), &key.to_be_bytes(), value);
+        self.new_strings.insert(key, value.to_owned());
         Ok(key)
     }
 }
 
-impl WritableEncodedStore for BatchWriter<'_> {
-    fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), Infallible> {
+impl WritableEncodedStore for RocksDbTransaction<'_> {
+    fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
         write_spog_quad(&mut self.buffer, quad);
         self.batch.put_cf(self.store.spog_cf(), &self.buffer, &[]);
         self.buffer.clear();
@@ -661,7 +820,7 @@ impl WritableEncodedStore for BatchWriter<'_> {
         Ok(())
     }
 
-    fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), Infallible> {
+    fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
         write_spog_quad(&mut self.buffer, quad);
         self.batch.delete_cf(self.store.spog_cf(), &self.buffer);
         self.buffer.clear();
@@ -690,55 +849,6 @@ impl WritableEncodedStore for BatchWriter<'_> {
     }
 }
 
-impl BatchWriter<'_> {
-    fn apply(self) -> Result<(), io::Error> {
-        self.store.db.write(self.batch).map_err(map_err)
-    }
-}
-
-struct AutoBatchWriter<'a> {
-    inner: BatchWriter<'a>,
-}
-
-impl WithStoreError for AutoBatchWriter<'_> {
-    type Error = io::Error;
-}
-
-impl StrContainer for AutoBatchWriter<'_> {
-    fn insert_str(&mut self, value: &str) -> Result<StrHash, io::Error> {
-        Ok(self.inner.insert_str(value).unwrap_infallible())
-    }
-}
-
-impl WritableEncodedStore for AutoBatchWriter<'_> {
-    fn insert_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
-        self.inner.insert_encoded(quad).unwrap_infallible();
-        self.apply_if_big()
-    }
-
-    fn remove_encoded(&mut self, quad: &EncodedQuad) -> Result<(), io::Error> {
-        self.inner.remove_encoded(quad).unwrap_infallible();
-        self.apply_if_big()
-    }
-}
-
-impl AutoBatchWriter<'_> {
-    fn apply(self) -> Result<(), io::Error> {
-        self.inner.apply()
-    }
-
-    fn apply_if_big(&mut self) -> Result<(), io::Error> {
-        if self.inner.batch.len() > MAX_TRANSACTION_SIZE {
-            self.inner
-                .store
-                .db
-                .write(take(&mut self.inner.batch))
-                .map_err(map_err)?;
-        }
-        Ok(())
-    }
-}
-
 #[allow(clippy::expect_used)]
 fn get_cf<'a>(db: &'a DB, name: &str) -> &'a ColumnFamily {
     db.cf_handle(name)
@@ -889,6 +999,30 @@ fn map_err(e: Error) -> io::Error {
     io::Error::new(io::ErrorKind::Other, e)
 }
 
+enum QuadsIter {
+    Quads {
+        iter: DecodingIndexIterator,
+        store: RocksDbStore,
+    },
+    Error(Once<io::Error>),
+    Empty,
+}
+
+impl Iterator for QuadsIter {
+    type Item = Result<Quad, io::Error>;
+
+    fn next(&mut self) -> Option<Result<Quad, io::Error>> {
+        match self {
+            Self::Quads { iter, store } => Some(match iter.next()? {
+                Ok(quad) => store.decode_quad(&quad).map_err(|e| e.into()),
+                Err(error) => Err(error),
+            }),
+            Self::Error(iter) => iter.next().map(Err),
+            Self::Empty => None,
+        }
+    }
+}
+
 #[test]
 fn store() -> Result<(), io::Error> {
     use crate::model::*;
diff --git a/lib/src/store/sled.rs b/lib/src/store/sled.rs
index b61e8ca2..d9d5fdcd 100644
--- a/lib/src/store/sled.rs
+++ b/lib/src/store/sled.rs
@@ -4,10 +4,13 @@ use crate::error::invalid_data_error;
 use crate::io::{DatasetFormat, GraphFormat};
 use crate::model::*;
 use crate::sparql::{EvaluationError, Query, QueryOptions, QueryResult, SimplePreparedQuery};
-use crate::store::numeric_encoder::*;
+use crate::store::numeric_encoder::{
+    write_term, Decoder, ReadEncoder, StrContainer, StrHash, StrLookup, TermReader, WithStoreError,
+    WriteEncoder, WRITTEN_TERM_MAX_SIZE,
+};
 use crate::store::{
-    dump_dataset, dump_graph, load_dataset, load_graph, ReadableEncodedStore, StoreOrParseError,
-    WritableEncodedStore,
+    dump_dataset, dump_graph, get_encoded_quad_pattern, load_dataset, load_graph,
+    ReadableEncodedStore, StoreOrParseError, WritableEncodedStore,
 };
 use sled::transaction::{
     ConflictableTransactionError, TransactionError, Transactional, TransactionalTree,
@@ -17,6 +20,7 @@ use sled::{Config, Iter, Tree};
 use std::convert::TryInto;
 use std::error::Error;
 use std::io::{BufRead, Cursor, Write};
+use std::iter::{once, Once};
 use std::path::Path;
 use std::{fmt, io, str};
 
@@ -67,6 +71,8 @@ const OSPG_PREFIX: u8 = 3;
 const GSPO_PREFIX: u8 = 4;
 const GPOS_PREFIX: u8 = 5;
 const GOSP_PREFIX: u8 = 6;
+type EncodedTerm = crate::store::numeric_encoder::EncodedTerm<StrHash>;
+type EncodedQuad = crate::store::numeric_encoder::EncodedQuad<StrHash>;
 
 //TODO: indexes for the default graph and indexes for the named graphs (no more Optional and space saving)
 
@@ -125,19 +131,23 @@ impl SledStore {
         object: Option<&Term>,
         graph_name: Option<&GraphName>,
     ) -> impl Iterator<Item = Result<Quad, io::Error>> {
-        let subject = subject.map(|s| s.into());
-        let predicate = predicate.map(|p| p.into());
-        let object = object.map(|o| o.into());
-        let graph_name = graph_name.map(|g| g.into());
-        let this = self.clone();
-        self.encoded_quads_for_pattern(subject, predicate, object, graph_name)
-            .map(move |quad| Ok(this.decode_quad(&quad?)?))
+        match get_encoded_quad_pattern(self, subject, predicate, object, graph_name) {
+            Ok(Some((subject, predicate, object, graph_name))) => QuadsIter::Quads {
+                iter: self.encoded_quads_for_pattern(subject, predicate, object, graph_name),
+                store: self.clone(),
+            },
+            Ok(None) => QuadsIter::Empty,
+            Err(error) => QuadsIter::Error(once(error)),
+        }
     }
 
     /// Checks if this store contains a given quad
     pub fn contains(&self, quad: &Quad) -> Result<bool, io::Error> {
-        let quad = quad.into();
-        self.contains_encoded(&quad)
+        if let Some(quad) = self.get_encoded_quad(quad)? {
+            self.contains_encoded(&quad)
+        } else {
+            Ok(false)
+        }
     }
 
     /// Returns the number of quads in the store
@@ -237,9 +247,12 @@ impl SledStore {
 
     /// Removes a quad from this store.
     pub fn remove(&self, quad: &Quad) -> Result<(), io::Error> {
-        let mut this = self;
-        let quad = quad.into();
-        this.remove_encoded(&quad)
+        if let Some(quad) = self.get_encoded_quad(quad)? {
+            let mut this = self;
+            this.remove_encoded(&quad)
+        } else {
+            Ok(())
+        }
     }
 
     /// Dumps a store graph into a file.
@@ -408,6 +421,7 @@ impl fmt::Display for SledStore {
 
 impl WithStoreError for SledStore {
     type Error = io::Error;
+    type StrId = StrHash;
 }
 
 impl StrLookup for SledStore {
@@ -418,6 +432,15 @@ impl StrLookup for SledStore {
             .transpose()
             .map_err(invalid_data_error)
     }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, io::Error> {
+        let id = StrHash::new(value);
+        Ok(if self.id2str.contains_key(&id.to_be_bytes())? {
+            Some(id)
+        } else {
+            None
+        })
+    }
 }
 
 impl ReadableEncodedStore for SledStore {
@@ -491,10 +514,6 @@ impl ReadableEncodedStore for SledStore {
     }
 }
 
-impl<'a> WithStoreError for &'a SledStore {
-    type Error = io::Error;
-}
-
 impl<'a> StrContainer for &'a SledStore {
     fn insert_str(&mut self, value: &str) -> Result<StrHash, io::Error> {
         let key = StrHash::new(value);
@@ -625,13 +644,36 @@ impl SledTransaction<'_> {
     /// Removes a quad from this store during the transaction.
     pub fn remove(&self, quad: &Quad) -> Result<(), SledUnabortableTransactionError> {
         let mut this = self;
-        let quad = quad.into();
-        this.remove_encoded(&quad)
+        if let Some(quad) = this.get_encoded_quad(quad)? {
+            this.remove_encoded(&quad)
+        } else {
+            Ok(())
+        }
     }
 }
 
 impl<'a> WithStoreError for &'a SledTransaction<'a> {
     type Error = SledUnabortableTransactionError;
+    type StrId = StrHash;
+}
+
+impl<'a> StrLookup for &'a SledTransaction<'a> {
+    fn get_str(&self, id: StrHash) -> Result<Option<String>, SledUnabortableTransactionError> {
+        self.id2str
+            .get(id.to_be_bytes())?
+            .map(|v| String::from_utf8(v.to_vec()))
+            .transpose()
+            .map_err(|e| SledUnabortableTransactionError::Storage(invalid_data_error(e)))
+    }
+
+    fn get_str_id(&self, value: &str) -> Result<Option<StrHash>, SledUnabortableTransactionError> {
+        let id = StrHash::new(value);
+        Ok(if self.id2str.get(&id.to_be_bytes())?.is_some() {
+            Some(id)
+        } else {
+            None
+        })
+    }
 }
 
 impl<'a> StrContainer for &'a SledTransaction<'a> {
@@ -984,6 +1026,30 @@ fn decode_quad(encoded: &[u8]) -> Result<EncodedQuad, io::Error> {
     }
 }
 
+enum QuadsIter {
+    Quads {
+        iter: DecodingQuadIterator,
+        store: SledStore,
+    },
+    Error(Once<io::Error>),
+    Empty,
+}
+
+impl Iterator for QuadsIter {
+    type Item = Result<Quad, io::Error>;
+
+    fn next(&mut self) -> Option<Result<Quad, io::Error>> {
+        match self {
+            Self::Quads { iter, store } => Some(match iter.next()? {
+                Ok(quad) => store.decode_quad(&quad).map_err(|e| e.into()),
+                Err(error) => Err(error),
+            }),
+            Self::Error(iter) => iter.next().map(Err),
+            Self::Empty => None,
+        }
+    }
+}
+
 #[test]
 fn store() -> Result<(), io::Error> {
     use crate::model::*;
diff --git a/wikibase/src/loader.rs b/wikibase/src/loader.rs
index b6d3cd44..b5a29572 100644
--- a/wikibase/src/loader.rs
+++ b/wikibase/src/loader.rs
@@ -267,7 +267,7 @@ impl WikibaseLoader {
                 .quads_for_pattern(None, None, None, Some(&graph_name))
                 .collect::<std::result::Result<Vec<_>, _>>()?;
             for q in to_remove {
-                transaction.remove(&q);
+                transaction.remove(&q)?;
             }
 
             transaction.load_graph(