maplib 0.18.14__tar.gz → 0.19.3__tar.gz

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

@@ -2451,10 +2451,11 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.18.14"
+version = "0.19.3"
 dependencies = [
  "chrono",
  "cimxml",
+ "datalog",
  "maplib",
  "mimalloc",
  "oxrdf",

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

@@ -8,11 +8,11 @@ rust-version = "1.88.0"
 [workspace.dependencies]
 pyo3 = {version = "0.25", features = ["py-clone"] }
 #Moment is there to work around a feature toggle bug
-polars = { version = "0.52.0", features = ["simd", "nightly", "new_streaming", "performant", "cse", "fmt", "parquet", "moment"] }
+polars = { version = "0.52.0", features = ["simd", "nightly", "new_streaming", "performant", "cse", "fmt", "parquet", "moment", "timezones"] }
 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.14 → maplib-0.19.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maplib
-Version: 0.18.14
+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.14 → 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.14 → maplib-0.19.3}/lib/datalog/src/inference.rs

@@ -1,8 +1,5 @@
 use crate::ast::DatalogRuleset;
-use oxrdf::NamedNode;
 use representation::dataset::NamedGraph;
-use representation::solution_mapping::EagerSolutionMappings;
-use std::collections::HashMap;
 use thiserror::*;
 use triplestore::sparql::errors::SparqlError;
 use triplestore::Triplestore;
@@ -13,6 +10,10 @@ pub enum DatalogError {
     SparqlError(SparqlError),
 }
 
+#[derive(Clone)]
+pub struct InferenceResult {
+}
+
 pub fn infer(
     _triplestore: &mut Triplestore,
     _graph: Option<&NamedGraph>,
@@ -21,6 +22,7 @@ pub fn infer(
     _max_results: Option<usize>,
     _include_transient: bool,
     _max_rows: Option<usize>,
-) -> Result<Option<HashMap<NamedNode, EagerSolutionMappings>>, DatalogError> {
+    _debug_no_results: bool,
+) -> Result<InferenceResult, DatalogError> {
     unimplemented!("Contact data treehouse to try")
 }

{maplib-0.18.14 → maplib-0.19.3}/lib/datalog/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod ast;
 pub mod inference;
 pub mod parser;
+pub mod python;

{maplib-0.18.14 → maplib-0.19.3}/lib/datalog/src/parser.rs

@@ -1,9 +1,12 @@
+use std::collections::HashMap;
+use oxrdf::NamedNode;
 use crate::ast::DatalogRuleset;
 use thiserror::*;
 
 pub fn parse_datalog_ruleset(
     _datalog_ruleset: &str,
     _base_iri: Option<&str>,
+    _prefixes: Option<&HashMap<String, NamedNode>>,
 ) -> Result<DatalogRuleset, DatalogSyntaxError> {
     unimplemented!("Contact Data Treehouse to try")
 }

maplib-0.19.3/lib/datalog/src/python.rs

@@ -0,0 +1,19 @@
+use pyo3::{pyclass, pymethods, PyResult};
+use crate::inference::InferenceResult;
+
+#[derive(Clone)]
+#[pyclass(name = "InferenceResult")]
+pub struct PyInferenceResult {
+   pub inner: InferenceResult,
+}
+
+#[pymethods]
+impl PyInferenceResult {
+   fn __repr__(&self) -> PyResult<String> {
+      Ok("Contact Data Treehouse to try".to_string())
+   }
+
+   fn __str__(&self) -> PyResult<String> {
+      Ok("Contact Data Treehouse to try".to_string())
+   }
+}

{maplib-0.18.14 → maplib-0.19.3}/lib/fts/src/lib.rs

@@ -14,7 +14,7 @@ pub enum FtsError {}
 pub struct FtsIndex {}
 
 impl FtsIndex {
-    pub fn new(_path: &Path, uuid:&str) -> Result<FtsIndex, FtsError> {
+    pub fn new(_path: &Path, _uuid:&str) -> Result<FtsIndex, FtsError> {
         unimplemented!("Contact Data Treehouse to enable full text search")
     }
 

{maplib-0.18.14 → maplib-0.19.3}/lib/maplib/src/errors.rs

@@ -1,4 +1,4 @@
-use crate::mapping::errors::MappingError;
+use crate::model::errors::MappingError;
 use cimxml::export::CIMXMLError;
 use datalog::inference::DatalogError;
 use oxiri::IriParseError;

{maplib-0.18.14 → maplib-0.19.3}/lib/maplib/src/lib.rs

@@ -2,4 +2,5 @@ extern crate chrono;
 extern crate chrono_tz;
 
 pub mod errors;
-pub mod mapping;
+pub mod model;
+mod prefixes;

{maplib-0.18.14/lib/maplib/src/mapping → maplib-0.19.3/lib/maplib/src/model}/constant_terms.rs

@@ -1,5 +1,5 @@
-use crate::mapping::errors::MappingError;
-use crate::mapping::{MappingColumnType, RDFNodeState};
+use crate::model::errors::MappingError;
+use crate::model::{MappingColumnType, RDFNodeState};
 use templates::ast::{ConstantTerm, ConstantTermOrList, PType};
 
 use oxrdf::{NamedNode, Term};

{maplib-0.18.14/lib/maplib/src/mapping → maplib-0.19.3/lib/maplib/src/model}/default.rs

@@ -1,6 +1,6 @@
 use super::Model;
-use crate::mapping::errors::MappingError;
-use crate::mapping::MapOptions;
+use crate::model::errors::MappingError;
+use crate::model::MapOptions;
 use std::collections::HashMap;
 use templates::ast::{
     Argument, ConstantTerm, ConstantTermOrList, Instance, ListExpanderType, PType, Parameter,
@@ -10,7 +10,7 @@ use templates::constants::{DEFAULT_PREFIX, OTTR_IRI, OTTR_TRIPLE};
 use tracing::warn;
 
 use crate::errors::MaplibError;
-use crate::mapping::expansion::validation::infer_type_from_column;
+use crate::model::expansion::validation::infer_type_from_column;
 use oxrdf::{NamedNode, Variable};
 use polars::prelude::{col, DataFrame, DataType, IntoLazy};
 use templates::MappingColumnType;

{maplib-0.18.14/lib/maplib/src/mapping → maplib-0.19.3/lib/maplib/src/model}/errors.rs

@@ -133,7 +133,7 @@ impl Display for MappingError {
                 write!(f, "Template error: {x}")
             }
             MappingError::TriplestoreError(x) => {
-                write!(f, "Error storing mapping results in triplestore: {x}")
+                write!(f, "Error storing model results in triplestore: {x}")
             }
             MappingError::IriParseError(x) => {
                 write!(f, "IRI parse error: {x}")

{maplib-0.18.14/lib/maplib/src/mapping → maplib-0.19.3/lib/maplib/src/model}/expansion/validation.rs

@@ -1,4 +1,4 @@
-use crate::mapping::errors::MappingError;
+use crate::model::errors::MappingError;
 use oxiri::Iri;
 use oxrdf::vocab::{rdfs, xsd};
 use oxrdf::NamedNode;

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

@@ -2,9 +2,9 @@ pub mod validation;
 
 use super::{MapOptions, Model, OTTRTripleInstance, StaticColumn};
 use crate::errors::MaplibError;
-use crate::mapping::constant_terms::{constant_blank_node_to_series, constant_to_expr};
-use crate::mapping::errors::MappingError;
-use crate::mapping::expansion::validation::validate;
+use crate::model::constant_terms::{constant_blank_node_to_series, constant_to_expr};
+use crate::model::errors::MappingError;
+use crate::model::expansion::validation::validate;
 use oxrdf::vocab::rdf;
 use oxrdf::{NamedNode, Variable};
 use polars::prelude::{
@@ -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.14/lib/maplib/src/mapping.rs → maplib-0.19.3/lib/maplib/src/model.rs

@@ -4,9 +4,9 @@ pub mod errors;
 pub mod expansion;
 
 use crate::errors::MaplibError;
-use crate::mapping::errors::MappingError;
+use crate::model::errors::MappingError;
 use cimxml::export::{cim_xml_write, FullModelDetails};
-use datalog::inference::infer;
+use datalog::inference::{infer, InferenceResult};
 use datalog::parser::parse_datalog_ruleset;
 use oxrdf::NamedNode;
 use oxrdfio::RdfFormat;
@@ -22,9 +22,10 @@ use templates::dataset::TemplateDataset;
 use templates::document::document_from_str;
 use templates::MappingColumnType;
 use triplestore::sparql::errors::SparqlError;
-use triplestore::sparql::{QueryResult, QuerySettings};
+use triplestore::sparql::{QueryResult, QuerySettings, UpdateResult};
 use triplestore::{IndexingOptions, NewTriples, Triplestore};
 
+use crate::prefixes::get_default_prefixes;
 use datalog::ast::DatalogRuleset;
 use representation::dataset::NamedGraph;
 use tracing::instrument;
@@ -35,6 +36,7 @@ pub struct Model {
     pub blank_node_counter: usize,
     pub default_template_counter: usize,
     pub indexing: IndexingOptions,
+    pub prefixes: HashMap<String, NamedNode>,
 }
 
 #[derive(Clone, Default)]
@@ -70,6 +72,7 @@ impl Model {
         template_dataset: Option<&TemplateDataset>,
         storage_folder: Option<String>,
         indexing: Option<IndexingOptions>,
+        prefixes: Option<HashMap<String, NamedNode>>,
     ) -> Result<Model, MaplibError> {
         let use_disk = storage_folder.is_some();
         let indexing = if use_disk {
@@ -86,6 +89,10 @@ impl Model {
         } else {
             TemplateDataset::new_empty()?
         };
+        let mut use_prefixes = get_default_prefixes();
+        if let Some(prefixes) = prefixes {
+            use_prefixes.extend(prefixes)
+        };
         Ok(Model {
             template_dataset,
             triplestore: Triplestore::new(storage_folder, Some(indexing.clone()))
@@ -93,6 +100,7 @@ impl Model {
             blank_node_counter: 0,
             default_template_counter: 0,
             indexing,
+            prefixes: use_prefixes,
         })
     }
 
@@ -101,34 +109,35 @@ impl Model {
         recursive: bool,
         storage_folder: Option<String>,
     ) -> Result<Model, MaplibError> {
-        let dataset =
-            TemplateDataset::from_folder(path, recursive).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        let dataset = TemplateDataset::from_folder(path, recursive, Some(&get_default_prefixes()))
+            .map_err(MaplibError::TemplateError)?;
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn from_file<P: AsRef<Path>>(
         path: P,
         storage_folder: Option<String>,
     ) -> Result<Model, MaplibError> {
-        let dataset = TemplateDataset::from_file(path).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        let dataset = TemplateDataset::from_file(path, Some(&get_default_prefixes()))
+            .map_err(MaplibError::TemplateError)?;
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn from_str(s: &str, storage_folder: Option<String>) -> Result<Model, MaplibError> {
-        let doc = document_from_str(s)?;
+        let doc = document_from_str(s, Some(&get_default_prefixes()))?;
         let dataset =
             TemplateDataset::from_documents(vec![doc]).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn from_strs(ss: Vec<&str>, storage_folder: Option<String>) -> Result<Model, MaplibError> {
         let mut docs = vec![];
         for s in ss {
-            let doc = document_from_str(s)?;
+            let doc = document_from_str(s, Some(&get_default_prefixes()))?;
             docs.push(doc);
         }
         let dataset = TemplateDataset::from_documents(docs).map_err(MaplibError::TemplateError)?;
-        Model::new(Some(&dataset), storage_folder, None)
+        Model::new(Some(&dataset), storage_folder, None, None)
     }
 
     pub fn add_template(&mut self, template: Template) -> Result<(), MaplibError> {
@@ -140,7 +149,7 @@ impl Model {
 
     #[instrument(skip_all)]
     pub fn add_templates_from_string(&mut self, s: &str) -> Result<Option<NamedNode>, MaplibError> {
-        let doc = document_from_str(s).map_err(MaplibError::TemplateError)?;
+        let doc = document_from_str(s, Some(&self.prefixes)).map_err(MaplibError::TemplateError)?;
         let mut dataset =
             TemplateDataset::from_documents(vec![doc]).map_err(MaplibError::TemplateError)?;
         let return_template_iri = if !dataset.templates.is_empty() {
@@ -175,10 +184,32 @@ 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)
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn read_template(&mut self, p: &Path) -> Result<(), MaplibError> {
+        let mut dataset = TemplateDataset::from_file(p, Some(&self.prefixes))
+            .map_err(MaplibError::TemplateError)?;
+        self.template_dataset
+            .prefix_map
+            .extend(dataset.prefix_map.drain());
+        for t in dataset.templates {
+            self.add_template(t)?
+        }
+        Ok(())
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn reads(
         &mut self,
@@ -195,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)
     }
 
@@ -208,6 +248,7 @@ impl Model {
         streaming: bool,
         include_transient: bool,
         max_rows: Option<usize>,
+        debug_no_results: bool,
     ) -> Result<QueryResult, MaplibError> {
         let query_settings = QuerySettings {
             include_transient,
@@ -215,7 +256,15 @@ impl Model {
             strict_project: false,
         };
         self.triplestore
-            .query(query, parameters, streaming, &query_settings, graph)
+            .query(
+                query,
+                parameters,
+                streaming,
+                &query_settings,
+                graph,
+                Some(&self.prefixes),
+                debug_no_results,
+            )
             .map_err(|x| x.into())
     }
 
@@ -227,14 +276,23 @@ impl Model {
         streaming: bool,
         include_transient: bool,
         max_rows: Option<usize>,
-    ) -> Result<(), MaplibError> {
+        debug_no_results: bool,
+    ) -> Result<UpdateResult, MaplibError> {
         let query_settings = QuerySettings {
             include_transient,
             max_rows,
             strict_project: false,
         };
         self.triplestore
-            .update(update, parameters, streaming, &query_settings, graph)
+            .update(
+                update,
+                parameters,
+                streaming,
+                &query_settings,
+                graph,
+                Some(&self.prefixes),
+                debug_no_results,
+            )
             .map_err(|x| x.into())
     }
 
@@ -329,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,
@@ -343,6 +402,8 @@ impl Model {
             only_shapes,
             deactivate_shapes,
             dry_run,
+            Some(self.prefixes.clone()),
+            serial,
         );
         res.map_err(|x| x.into())
     }
@@ -396,13 +457,14 @@ impl Model {
         graph: Option<&NamedGraph>,
         include_transient: bool,
         max_rows: Option<usize>,
-    ) -> Result<Option<HashMap<NamedNode, EagerSolutionMappings>>, MaplibError> {
+        debug_no_results: bool,
+    ) -> Result<InferenceResult, MaplibError> {
         if rulesets.is_empty() {
             return Err(MaplibError::MissingDatalogRuleset);
         }
         let mut ruleset: Option<DatalogRuleset> = None;
         for r in rulesets {
-            let new_ruleset = parse_datalog_ruleset(&r, None)
+            let new_ruleset = parse_datalog_ruleset(&r, None, Some(&self.prefixes))
                 .map_err(|x| MaplibError::DatalogSyntaxError(x.to_string()))?;
             if let Some(orig_ruleset) = &mut ruleset {
                 orig_ruleset.extend(new_ruleset);
@@ -419,7 +481,24 @@ impl Model {
             max_results,
             include_transient,
             max_rows,
+            debug_no_results,
         );
         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.19.3/lib/maplib/src/prefixes.rs

@@ -0,0 +1,22 @@
+use oxrdf::NamedNode;
+use std::collections::HashMap;
+use templates::constants::{
+    OTTR_PREFIX, OTTR_PREFIX_IRI, OWL_PREFIX, OWL_PREFIX_IRI, RDFS_PREFIX, RDFS_PREFIX_IRI,
+    RDF_PREFIX, RDF_PREFIX_IRI, SHACL_PREFIX, SHACL_PREFIX_IRI, XSD_PREFIX, XSD_PREFIX_IRI,
+};
+
+pub fn get_default_prefixes() -> HashMap<String, NamedNode> {
+    let predefined = [
+        (RDFS_PREFIX, RDFS_PREFIX_IRI),
+        (RDF_PREFIX, RDF_PREFIX_IRI),
+        (XSD_PREFIX, XSD_PREFIX_IRI),
+        (OTTR_PREFIX, OTTR_PREFIX_IRI),
+        (OWL_PREFIX, OWL_PREFIX_IRI),
+        (SHACL_PREFIX, SHACL_PREFIX_IRI),
+    ];
+    HashMap::from_iter(
+        predefined
+            .into_iter()
+            .map(|(x, y)| (x.to_string(), NamedNode::new_unchecked(y))),
+    )
+}

{maplib-0.18.14 → maplib-0.19.3}/lib/pydf_io/src/to_python.rs

@@ -12,6 +12,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyList;
 use pyo3::IntoPyObjectExt;
 use representation::cats::LockedCats;
+use representation::debug::DebugOutputs;
 use representation::formatting::{format_columns, format_native_columns};
 use representation::multitype::compress_actual_multitypes;
 use representation::python::PySolutionMappings;
@@ -84,6 +85,7 @@ pub fn to_py_df(
 pub fn df_to_py_df(
     mut df: DataFrame,
     rdf_node_states: HashMap<String, RDFNodeState>,
+    debug_outputs: Option<DebugOutputs>,
     pushdown_paths: Option<Vec<Context>>,
     include_datatypes: bool,
     py: Python,
@@ -102,11 +104,12 @@ pub fn df_to_py_df(
     let pyarrow = PyModule::import(py, "pyarrow")?;
     let polars = PyModule::import(py, "polars")?;
     let py_df = to_py_df(&chunk, names.as_slice(), py, &pyarrow, &polars)?;
-    if include_datatypes {
+    if include_datatypes || debug_outputs.is_some() {
         Py::new(
             py,
             PySolutionMappings {
                 mappings: py_df.into_any(),
+                debug: debug_outputs,
                 rdf_node_states,
                 pushdown_paths,
             },

{maplib-0.18.14 → 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