maplib 0.18.18__tar.gz → 0.19.3__tar.gz

{maplib-0.18.18 → maplib-0.19.3}/Cargo.lock

@@ -2451,7 +2451,7 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.18.18"
+version = "0.19.3"
 dependencies = [
  "chrono",
  "cimxml",

{maplib-0.18.18 → maplib-0.19.3}/Cargo.toml

@@ -12,7 +12,7 @@ polars = { version = "0.52.0", features = ["simd", "nightly", "new_streaming", "
 polars-core = { version = "0.52.0" }
 rayon = "1.10.0"
 regex = "1.11.1"
-oxrdf = { version="0.2.4" }
+oxrdf = { version = "0.2.4" }
 oxrdfio = { version = "0.1.7" }
 oxttl = { version="0.1.7" }
 oxiri = "0.2.11"

{maplib-0.18.18 → maplib-0.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maplib
-Version: 0.18.18
+Version: 0.19.3
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -81,7 +81,7 @@ template = Template(
         Parameter(variable=ings_var, rdf_type=RDFType.Nested(RDFType.IRI()))
     ],
     instances= [
-        Triple(p_var, a(), pi.suf("Pizza")),
+        Triple(p_var, a, pi.suf("Pizza")),
         Triple(p_var, pi.suf("fromCountry"), c_var),
         Triple(
             p_var, 

{maplib-0.18.18 → maplib-0.19.3}/README.md

@@ -55,7 +55,7 @@ template = Template(
         Parameter(variable=ings_var, rdf_type=RDFType.Nested(RDFType.IRI()))
     ],
     instances= [
-        Triple(p_var, a(), pi.suf("Pizza")),
+        Triple(p_var, a, pi.suf("Pizza")),
         Triple(p_var, pi.suf("fromCountry"), c_var),
         Triple(
             p_var, 

{maplib-0.18.18 → maplib-0.19.3}/lib/maplib/src/model/expansion.rs

@@ -302,6 +302,7 @@ impl Model {
                     subject_type: subject_type,
                     object_type: object_type,
                     predicate: predicate.clone(),
+                    graph: graph.clone(),
                     subject_cat_state: subject_state,
                     object_cat_state: object_state,
                     predicate_cat_state: predicate_state,
@@ -310,7 +311,7 @@ impl Model {
         }
 
         self.triplestore
-            .add_triples_vec(all_triples_to_add, false, graph)
+            .add_triples_vec(all_triples_to_add, false)
             .map_err(MappingError::TriplestoreError)?;
 
         self.blank_node_counter = new_blank_node_counter;

{maplib-0.18.18 → maplib-0.19.3}/lib/maplib/src/model.rs

@@ -184,7 +184,16 @@ impl Model {
             self.truncate_graph(&graph)
         }
         self.triplestore
-            .read_triples_from_path(p, rdf_format, base_iri, transient, parallel, checked, graph)
+            .read_triples_from_path(
+                p,
+                rdf_format,
+                base_iri,
+                transient,
+                parallel,
+                checked,
+                graph,
+                &self.prefixes,
+            )
             .map_err(MaplibError::TriplestoreError)
     }
 
@@ -217,7 +226,16 @@ impl Model {
             self.truncate_graph(&graph)
         }
         self.triplestore
-            .read_triples_from_string(s, rdf_format, base_iri, transient, parallel, checked, graph)
+            .read_triples_from_string(
+                s,
+                rdf_format,
+                base_iri,
+                transient,
+                parallel,
+                checked,
+                graph,
+                &self.prefixes,
+            )
             .map_err(MaplibError::TriplestoreError)
     }
 
@@ -369,6 +387,7 @@ impl Model {
         only_shapes: Option<Vec<NamedNode>>,
         deactivate_shapes: Vec<NamedNode>,
         dry_run: bool,
+        serial: bool,
     ) -> Result<ValidationReport, MaplibError> {
         let res = validate(
             &mut self.triplestore,
@@ -384,6 +403,7 @@ impl Model {
             deactivate_shapes,
             dry_run,
             Some(self.prefixes.clone()),
+            serial,
         );
         res.map_err(|x| x.into())
     }
@@ -465,4 +485,20 @@ impl Model {
         );
         Ok(res.map_err(|x| MaplibError::DatalogError(x))?)
     }
+
+    pub fn detach_graph(
+        &mut self,
+        graph: &NamedGraph,
+        preserve_name: bool,
+    ) -> Result<Model, MaplibError> {
+        let triplestore = self.triplestore.detach_graph(graph, preserve_name)?;
+        Ok(Model {
+            template_dataset: self.template_dataset.clone(),
+            triplestore,
+            blank_node_counter: self.blank_node_counter,
+            default_template_counter: self.default_template_counter,
+            indexing: self.indexing.clone(),
+            prefixes: self.prefixes.clone(),
+        })
+    }
 }

{maplib-0.18.18 → maplib-0.19.3}/lib/query_processing/src/cats.rs

@@ -25,52 +25,55 @@ pub fn create_compatible_cats(
     let mut string_cast = HashSet::new();
 
     for t in base_types {
-        let need_native_cat_cast = check_need_native_cat_cast(&t, &states);
-        if need_native_cat_cast {
-            let locals = find_all_locals(&t, &states);
-            let mut cats = Cats::new_empty(Some(global_cats.read().unwrap().deref()));
-            let renc_local = cats.merge(locals);
-            let renc_local: HashMap<_, _> = renc_local
-                .into_iter()
-                .map(|(uu, map)| {
-                    let mut blank_renc = None;
-                    let mut iri_renc = vec![];
-                    let mut literal_renc_map = HashMap::new();
-                    for (p, renc) in map {
-                        match p {
-                            CatType::IRI => {
-                                iri_renc.push(renc);
-                            }
-                            CatType::Blank => {
-                                blank_renc = Some(renc);
-                            }
-                            CatType::Literal(l) => {
-                                literal_renc_map.insert(l, renc);
-                            }
-                        }
-                    }
-                    let iri_renc = if iri_renc.is_empty() {
-                        None
-                    } else {
-                        let mut renc_map =
-                            HashMap::with_capacity_and_hasher(2, BuildHasherDefault::default());
-                        for renc in iri_renc {
-                            renc_map.extend(renc.cat_map.iter().map(|(x, y)| (*x, *y)))
-                        }
-                        Some(CatReEnc {
-                            cat_map: Arc::new(renc_map),
-                        })
-                    };
-                    (uu, (blank_renc, iri_renc, literal_renc_map))
-                })
-                .collect();
-            let state = BaseCatState::CategoricalNative(false, Some(LockedCats::new(cats)));
-            native_cat_map.insert(t.clone(), (renc_local, state));
-        }
         let need_string_cast = check_need_string_cast(&t, &states);
         if need_string_cast {
             string_cast.insert(t.clone());
         }
+        if !need_string_cast {
+            let need_native_cat_cast = check_need_native_cat_cast(&t, &states);
+            if need_native_cat_cast {
+                let locals = find_all_locals(&t, &states);
+                let mut cats = Cats::new_empty(Some(global_cats.read().unwrap().deref()));
+                // We do not store local cats to disk
+                let renc_local = cats.merge(locals, None);
+                let renc_local: HashMap<_, _> = renc_local
+                    .into_iter()
+                    .map(|(uu, map)| {
+                        let mut blank_renc = None;
+                        let mut iri_renc = vec![];
+                        let mut literal_renc_map = HashMap::new();
+                        for (p, renc) in map {
+                            match p {
+                                CatType::IRI => {
+                                    iri_renc.push(renc);
+                                }
+                                CatType::Blank => {
+                                    blank_renc = Some(renc);
+                                }
+                                CatType::Literal(l) => {
+                                    literal_renc_map.insert(l, renc);
+                                }
+                            }
+                        }
+                        let iri_renc = if iri_renc.is_empty() {
+                            None
+                        } else {
+                            let mut renc_map =
+                                HashMap::with_capacity_and_hasher(2, BuildHasherDefault::default());
+                            for renc in iri_renc {
+                                renc_map.extend(renc.cat_map.iter().map(|(x, y)| (*x, *y)))
+                            }
+                            Some(CatReEnc {
+                                cat_map: Arc::new(renc_map),
+                            })
+                        };
+                        (uu, (blank_renc, iri_renc, literal_renc_map))
+                    })
+                    .collect();
+                let state = BaseCatState::CategoricalNative(false, Some(LockedCats::new(cats)));
+                native_cat_map.insert(t.clone(), (renc_local, state));
+            }
+        }
     }
 
     let mut exploded: Vec<_> = expressions

{maplib-0.18.18 → maplib-0.19.3}/lib/query_processing/src/expressions.rs

@@ -32,7 +32,8 @@ pub fn named_node_local_enc(nn: &NamedNode, global_cats: &Cats) -> (Expr, Option
     if let Some(enc) = global_cats.encode_iri_slice(&[nn.as_str()]).pop().unwrap() {
         (lit(enc).cast(DataType::UInt32), None)
     } else {
-        let (enc, local) = Cats::new_singular_iri(nn.as_str(), global_cats.get_iri_counter());
+        // We do not store these local cats to disk
+        let (enc, local) = Cats::new_singular_iri(nn.as_str(), global_cats.get_iri_counter(), None);
         (lit(enc).cast(DataType::UInt32), Some(local))
     }
 }
@@ -46,12 +47,14 @@ pub fn blank_node_local_enc(bl: &BlankNode, global_cats: &Cats) -> (Expr, Option
     if let Some(enc) = global_cats.encode_blanks(&[bl.as_str()]).pop().unwrap() {
         (lit(enc).cast(DataType::UInt32), None)
     } else {
-        let (enc, local) = Cats::new_singular_blank(bl.as_str(), global_cats.get_iri_counter());
+        // Local cats not stored to disk, hence None path
+        let (enc, local) =
+            Cats::new_singular_blank(bl.as_str(), global_cats.get_iri_counter(), None);
         (lit(enc).cast(DataType::UInt32), Some(local))
     }
 }
 
-pub fn maybe_literal_enc(l: &Literal, global_cats: &Cats) -> (Expr, BaseRDFNodeType, BaseCatState) {
+pub fn literal_enc(l: &Literal, global_cats: &Cats) -> (Expr, BaseRDFNodeType, BaseCatState) {
     let bt = BaseRDFNodeType::Literal(l.datatype().into_owned());
     if literal_is_cat(l.datatype()) {
         if let Some(enc) = global_cats
@@ -67,7 +70,8 @@ pub fn maybe_literal_enc(l: &Literal, global_cats: &Cats) -> (Expr, BaseRDFNodeT
         } else {
             let dt = l.datatype().into_owned();
             let offset = global_cats.get_literal_counter(&dt);
-            let (enc, local) = Cats::new_singular_literal(l.value(), dt, offset);
+            // Local cats are not stored to disk, hence None
+            let (enc, local) = Cats::new_singular_literal(l.value(), dt, offset, None);
             (
                 lit(enc).cast(DataType::UInt32),
                 bt,
@@ -106,7 +110,7 @@ pub fn literal(
     context: &Context,
     global_cats: &Cats,
 ) -> Result<SolutionMappings, QueryProcessingError> {
-    let (e, bt, bs) = maybe_literal_enc(lit, global_cats);
+    let (e, bt, bs) = literal_enc(lit, global_cats);
     solution_mappings.mappings = solution_mappings
         .mappings
         .with_column(e.alias(context.as_str()));
@@ -361,23 +365,57 @@ pub fn if_expression(
     middle_context: &Context,
     right_context: &Context,
     outer_context: &Context,
+    global_cats: LockedCats,
 ) -> Result<SolutionMappings, QueryProcessingError> {
+    //
+    let mut exploded: Vec<_> = create_compatible_cats(
+        vec![Some(col(middle_context.as_str())), Some(col(right_context.as_str()))],
+        vec![Some(solution_mappings.rdf_node_types.get(middle_context.as_str()).unwrap().clone()),
+             Some(solution_mappings.rdf_node_types.get(right_context.as_str()).unwrap().clone())],
+        global_cats,
+    )
+        .into_iter()
+        .map(|x| x.unwrap())
+        .collect();
+    assert_eq!(exploded.len(), 2);
+
+    let right_exploded = exploded.pop().unwrap();
+    let mid_exploded = exploded.pop().unwrap();
+
+    let mut mid_exprs = vec![];
+    let mut right_exprs = vec![];
+
+    let mut base_type_map = HashMap::new();
+    for (t, (exprs, base_state)) in right_exploded {
+        base_type_map.insert(t, base_state);
+        right_exprs.extend(exprs);
+    }
+    for (_, (exprs, _)) in mid_exploded {
+        mid_exprs.extend(exprs);
+    }
+    let mid_expr = if mid_exprs.len() > 1 {
+        as_struct(mid_exprs)
+    } else {
+        mid_exprs.pop().unwrap()
+    };
+
+    let right_expr = if right_exprs.len() > 1 {
+        as_struct(right_exprs)
+    } else {
+        right_exprs.pop().unwrap()
+    };
+
     solution_mappings.mappings = solution_mappings.mappings.with_column(
         (Expr::Ternary {
             predicate: Arc::new(col(left_context.as_str())),
-            truthy: Arc::new(col(middle_context.as_str())),
-            falsy: Arc::new(col(right_context.as_str())),
+            truthy: Arc::new(mid_expr),
+            falsy: Arc::new(right_expr),
         })
         .alias(outer_context.as_str()),
     );
-    //Todo: generalize..
-    let existing_type = solution_mappings
-        .rdf_node_types
-        .get(middle_context.as_str())
-        .unwrap();
     solution_mappings
         .rdf_node_types
-        .insert(outer_context.as_str().to_string(), existing_type.clone());
+        .insert(outer_context.as_str().to_string(), RDFNodeState::from_map(base_type_map));
     solution_mappings = drop_inner_contexts(
         solution_mappings,
         &vec![left_context, middle_context, right_context],

{maplib-0.18.18 → maplib-0.19.3}/lib/representation/src/cats/decode.rs

@@ -8,30 +8,20 @@ use polars::frame::column::ScalarColumn;
 use polars::frame::DataFrame;
 use polars::prelude::{col, Column, Expr, IntoColumn, IntoLazy, NamedFrom, SeriesSealed};
 use polars::series::Series;
-use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use std::borrow::Cow;
 
 impl CatEncs {
-    pub fn decode(&self, ser: &Series) -> Series {
+    pub fn decode_series(&self, ser: &Series) -> Series {
         let original_name = ser.name().clone();
         let uch: Vec<_> = ser.u32().unwrap().iter().collect();
-        let decoded_vec_iter = uch
-            .into_par_iter()
-            .map(|x| x.map(|x| self.rev_map.get(&x).unwrap()));
-
-        let decoded_vec: Vec<_> = decoded_vec_iter.map(|x| x.map(|x| x.as_str())).collect();
+        let decoded_vec = self.maps.decode_batch(uch.as_ref());
         let new_ser = Series::new(original_name, decoded_vec);
-        //
-        // let mut new_ser = if let CatType::Prefix(pre) = cat_type {
-        //     Series::from_iter(decoded_ser.map(|x| x.map(|x| format!("{}{}", pre.as_str(), x))))
-        // } else {
-        //     Series::from_iter(decoded_ser.map(|x| x.map(|x| x.as_str())))
-        // };
         new_ser
     }
 
     pub fn maybe_decode_string(&self, u: &u32) -> Option<&str> {
-        self.rev_map.get(u).map(|x| x.as_str())
+        self.maps.maybe_decode(u)
     }
 }
 
@@ -68,7 +58,7 @@ impl Cats {
     pub fn decode_of_type(&self, ser: &Series, bt: &BaseRDFNodeType) -> Series {
         let ct = CatType::from_base_rdf_node_type(bt);
         if let Some(enc) = self.cat_map.get(&ct) {
-            enc.decode(ser)
+            enc.decode_series(ser)
         } else {
             unreachable!("Should never be called when type does not exist")
         }
@@ -120,6 +110,9 @@ impl Cats {
         local_cats: Option<LockedCats>,
     ) -> Series {
         let local = local_cats.as_ref().map(|x| x.read().unwrap());
+        if ser.dtype() != &DataType::UInt32 {
+            panic!("Series should have datatype UInt32 {:?}", ser);
+        }
         let u32s = ser.u32().unwrap();
         let us: Vec<_> = u32s.iter().collect();
 

{maplib-0.18.18 → maplib-0.19.3}/lib/representation/src/cats/encode.rs

@@ -1,4 +1,5 @@
 use super::{CatEncs, CatType, Cats, EncodedTriples};
+use crate::cats::maps::CatMaps;
 use crate::cats::LockedCats;
 use crate::solution_mapping::{BaseCatState, EagerSolutionMappings};
 use crate::{BaseRDFNodeType, RDFNodeState, OBJECT_COL_NAME, SUBJECT_COL_NAME};
@@ -6,34 +7,22 @@ use oxrdf::NamedNode;
 use polars::frame::DataFrame;
 use polars::prelude::{col, lit, IntoLazy, Series};
 use std::collections::HashMap;
-use std::hash::BuildHasherDefault;
-use std::sync::Arc;
+use std::path::Path;
 
 impl CatEncs {
-    pub fn new_empty() -> CatEncs {
-        let rev_map = HashMap::with_capacity_and_hasher(2, BuildHasherDefault::default());
+    pub fn new_empty(path: Option<&Path>) -> CatEncs {
         CatEncs {
-            map: Default::default(),
-            rev_map,
+            maps: CatMaps::new_empty(path),
         }
     }
 
-    pub fn contains_key(&self, s: &str) -> bool {
-        let s = s.to_string();
-        self.map.contains_key(&s)
-    }
-
-    pub fn new_singular(value: &str, u: u32) -> CatEncs {
-        let mut sing = Self::new_empty();
-        let s = Arc::new(value.to_string());
-        sing.map.insert(s.clone(), u);
-        sing.rev_map.insert(u, s);
-        sing
+    pub fn new_singular(value: &str, u: u32, path: Option<&Path>) -> CatEncs {
+        let maps = CatMaps::new_singular(value, u, path);
+        CatEncs { maps }
     }
 
     pub fn maybe_encode_str(&self, s: &str) -> Option<&u32> {
-        let s = Arc::new(s.to_string());
-        self.map.get(&s)
+        self.maps.maybe_encode_str(s)
     }
 
     pub fn encode_new_str(&mut self, s: &str, u: u32) {
@@ -41,23 +30,20 @@ impl CatEncs {
     }
 
     pub fn encode_new_string(&mut self, s: String, u: u32) {
-        let s = Arc::new(s.clone());
-        self.map.insert(s.clone(), u);
-        self.rev_map.insert(u, s);
-    }
-
-    pub fn encode_new_arc_string(&mut self, s: Arc<String>, u: u32) {
-        self.map.insert(s.clone(), u);
-        self.rev_map.insert(u, s);
+        self.maps.encode_new_string(s, u);
     }
 
-    pub fn height(&self) -> u32 {
-        self.map.len() as u32
+    pub fn counter(&self) -> u32 {
+        self.maps.counter()
     }
 }
 
 impl Cats {
-    pub fn encode_solution_mappings(&self, sm: EagerSolutionMappings) -> EagerSolutionMappings {
+    pub fn encode_solution_mappings(
+        &self,
+        sm: EagerSolutionMappings,
+        path: Option<&Path>,
+    ) -> EagerSolutionMappings {
         let EagerSolutionMappings {
             mappings,
             mut rdf_node_types,
@@ -87,7 +73,7 @@ impl Cats {
         let encoded: Vec<_> = to_encode
             .into_iter()
             .map(|(c, t, ser)| {
-                let (enc, local) = self.encode_series(&ser, &t);
+                let (enc, local) = self.encode_series(&ser, &t, path);
                 (c, t, enc, local)
             })
             .collect();
@@ -109,7 +95,12 @@ impl Cats {
         EagerSolutionMappings::new(mappings.collect().unwrap(), rdf_node_types)
     }
 
-    pub fn encode_series(&self, series: &Series, t: &BaseRDFNodeType) -> (Series, Option<Cats>) {
+    pub fn encode_series(
+        &self,
+        series: &Series,
+        t: &BaseRDFNodeType,
+        path: Option<&Path>,
+    ) -> (Series, Option<Cats>) {
         let original_name = series.name().clone();
         let mut use_height = match t {
             BaseRDFNodeType::IRI => self.iri_counter,
@@ -121,7 +112,7 @@ impl Cats {
         };
 
         let enc = self.get_encs(t).pop();
-        let mut new_enc = CatEncs::new_empty();
+        let mut new_enc = CatEncs::new_empty(path);
         let strch = series.str().unwrap();
         let encoded_global: Vec<_> = strch
             .iter()
@@ -158,7 +149,7 @@ impl Cats {
             };
             encoded_global_local.push(encoded);
         }
-        let local = if !new_enc.map.is_empty() {
+        let local = if !new_enc.maps.is_empty() {
             let cat_type = CatType::from_base_rdf_node_type(t);
             let mut map = HashMap::new();
             map.insert(cat_type, new_enc);
@@ -212,7 +203,7 @@ impl Cats {
         u32s
     }
 
-    pub fn encode_iri_or_local_cat(&self, iri: &str) -> (u32, RDFNodeState) {
+    pub fn encode_iri_or_local_cat(&self, iri: &str, path: Option<&Path>) -> (u32, RDFNodeState) {
         let mut v = self.encode_iri_slice(&[iri]);
         if let Some(u) = v.pop().unwrap() {
             (
@@ -223,7 +214,7 @@ impl Cats {
                 ),
             )
         } else {
-            let (u, l) = Cats::new_singular_iri(iri, self.iri_counter);
+            let (u, l) = Cats::new_singular_iri(iri, self.iri_counter, path);
             (
                 u,
                 RDFNodeState::from_bases(
@@ -234,7 +225,11 @@ impl Cats {
         }
     }
 
-    pub fn encode_blank_or_local_cat(&self, blank: &str) -> (u32, RDFNodeState) {
+    pub fn encode_blank_or_local_cat(
+        &self,
+        blank: &str,
+        path: Option<&Path>,
+    ) -> (u32, RDFNodeState) {
         let mut v = self.encode_blanks(&[blank]);
         if let Some(u) = v.pop().unwrap() {
             (
@@ -245,7 +240,7 @@ impl Cats {
                 ),
             )
         } else {
-            let (u, l) = Cats::new_singular_blank(blank, self.blank_counter);
+            let (u, l) = Cats::new_singular_blank(blank, self.blank_counter, path);
             (
                 u,
                 RDFNodeState::from_bases(
@@ -264,6 +259,7 @@ pub fn encode_triples(
     subject_cat_state: BaseCatState,
     object_cat_state: BaseCatState,
     global_cats: &Cats,
+    path: Option<&Path>,
 ) -> (Vec<LockedCats>, EncodedTriples) {
     let mut map = HashMap::new();
     map.insert(
@@ -274,7 +270,7 @@ pub fn encode_triples(
         OBJECT_COL_NAME.to_string(),
         RDFNodeState::from_bases(object_type.clone(), object_cat_state),
     );
-    let mut sm = global_cats.encode_solution_mappings(EagerSolutionMappings::new(df, map));
+    let mut sm = global_cats.encode_solution_mappings(EagerSolutionMappings::new(df, map), path);
 
     let mut subject_state = sm.rdf_node_types.remove(SUBJECT_COL_NAME).unwrap();
     let mut object_state = sm.rdf_node_types.remove(OBJECT_COL_NAME).unwrap();

{maplib-0.18.18 → maplib-0.19.3}/lib/representation/src/cats/globalize.rs

@@ -1,34 +1,38 @@
 use super::{encode_triples, re_encode, CatEncs, CatTriples, CatType, Cats};
+use crate::dataset::NamedGraph;
 use crate::solution_mapping::BaseCatState;
 use crate::BaseRDFNodeType;
 use oxrdf::NamedNode;
 use polars::frame::DataFrame;
-use std::sync::Arc;
+use std::path::Path;
 use tracing::instrument;
 
 impl Cats {
-    pub fn globalize(&mut self, mut cat_triples: Vec<CatTriples>) -> Vec<CatTriples> {
+    pub fn globalize(
+        &mut self,
+        mut cat_triples: Vec<CatTriples>,
+        path: Option<&Path>,
+    ) -> Vec<CatTriples> {
         let local_cats: Vec<_> = cat_triples
             .iter_mut()
             .map(|x| x.local_cats.drain(..))
             .flatten()
             .collect();
-        let re_enc_map = self.merge(local_cats);
+        let re_enc_map = self.merge(local_cats, path);
         let global_cat_triples = re_encode(cat_triples, re_enc_map);
         global_cat_triples
     }
 
-    pub fn encode_predicates(&mut self, cat_triples: &Vec<CatTriples>) {
+    pub fn encode_predicates(&mut self, cat_triples: &Vec<CatTriples>, path: Option<&Path>) {
         for ct in cat_triples {
             let t = CatType::IRI;
             if !self.cat_map.contains_key(&t) {
-                self.cat_map.insert(t.clone(), CatEncs::new_empty());
+                self.cat_map.insert(t.clone(), CatEncs::new_empty(path));
             }
             let enc = self.cat_map.get_mut(&t).unwrap();
             let pred = ct.predicate.as_str().to_string();
-            if !enc.map.contains_key(&pred) {
-                let arc_pred = Arc::new(pred);
-                enc.encode_new_arc_string(arc_pred.clone(), self.iri_counter);
+            if !enc.maps.contains_str(&pred) {
+                enc.encode_new_string(pred, self.iri_counter);
                 self.iri_counter += 1;
             }
         }
@@ -41,9 +45,11 @@ pub fn cat_encode_triples(
     subject_type: BaseRDFNodeType,
     object_type: BaseRDFNodeType,
     predicate: NamedNode,
+    graph: NamedGraph,
     subject_cat_state: BaseCatState,
     object_cat_state: BaseCatState,
     global_cats: &Cats,
+    path: Option<&Path>,
 ) -> CatTriples {
     let (local_cats, encoded_triples) = encode_triples(
         df,
@@ -52,11 +58,13 @@ pub fn cat_encode_triples(
         subject_cat_state,
         object_cat_state,
         global_cats,
+        path,
     );
 
     CatTriples {
         encoded_triples,
         predicate,
+        graph,
         subject_type,
         object_type,
         local_cats,