maplib 0.19.3__tar.gz → 0.19.9__tar.gz

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

@@ -32,9 +32,9 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
@@ -1414,6 +1414,7 @@ dependencies = [
  "oxrdfio",
  "polars",
  "pyo3",
+ "query_processing",
  "rayon",
  "representation",
  "rstest",
@@ -2451,7 +2452,7 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.19.3"
+version = "0.19.9"
 dependencies = [
  "chrono",
  "cimxml",
@@ -3793,11 +3794,11 @@ dependencies = [
 name = "triplestore"
 version = "0.5.0"
 dependencies = [
+ "aho-corasick",
  "file_io",
  "fts",
  "itoa",
  "memmap2",
- "nohash-hasher",
  "oxrdf",
  "oxrdfio",
  "oxttl",

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

@@ -32,6 +32,7 @@ fundu = "2.0.1"
 memmap2 = "0.9.5"
 sprs = "0.11.3"
 walkdir = "2.5.0"
+aho-corasick = "1.1.4"
 
 tracing = { version = "0.1", features = [ "log" ] }
 tracing-subscriber = { version = "0.3.19", features = [ "env-filter" ] }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maplib
-Version: 0.19.3
+Version: 0.19.9
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only

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

@@ -11,8 +11,7 @@ pub enum DatalogError {
 }
 
 #[derive(Clone)]
-pub struct InferenceResult {
-}
+pub struct InferenceResult {}
 
 pub fn infer(
     _triplestore: &mut Triplestore,

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

@@ -0,0 +1,19 @@
+use crate::inference::InferenceResult;
+use pyo3::{pyclass, pymethods, PyResult};
+
+#[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.19.3 → maplib-0.19.9}/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")
     }
 
@@ -31,7 +31,7 @@ impl FtsIndex {
         unimplemented!("Contact Data Treehouse to enable full text search")
     }
 
-    pub fn commit(&mut self, _drop_writer:bool) -> Result<(), FtsError> {
+    pub fn commit(&mut self, _drop_writer: bool) -> Result<(), FtsError> {
         unimplemented!("Contact Data Treehouse to enable full text search")
     }
 

{maplib-0.19.3 → maplib-0.19.9}/lib/maplib/Cargo.toml

@@ -14,6 +14,7 @@ shacl = { path = "../shacl" }
 representation = { path = "../representation" }
 datalog = {path = "../datalog"}
 cimxml = {path = "../cimxml"}
+query_processing = {path ="../query_processing"}
 
 rayon = { workspace = true }
 oxrdf = { workspace = true }

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

@@ -3,4 +3,3 @@ extern crate chrono_tz;
 
 pub mod errors;
 pub mod model;
-mod prefixes;

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

@@ -8,13 +8,13 @@ use polars::prelude::{
 };
 use rayon::iter::ParallelIterator;
 use rayon::prelude::IntoParallelIterator;
+use representation::constants::{OTTR_BLANK_NODE, OTTR_IRI};
 use representation::rdf_to_polars::{
     polars_literal_values_to_series, rdf_named_node_to_polars_literal_value,
     rdf_term_to_polars_expr,
 };
 use representation::BaseRDFNodeType;
 use std::ops::Deref;
-use templates::constants::{OTTR_BLANK_NODE, OTTR_IRI};
 
 const BLANK_NODE_SERIES_NAME: &str = "blank_node_series";
 

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

@@ -1,12 +1,12 @@
 use super::Model;
 use crate::model::errors::MappingError;
 use crate::model::MapOptions;
+use representation::constants::{DEFAULT_PREFIX_IRI, OTTR_IRI, OTTR_TRIPLE};
 use std::collections::HashMap;
 use templates::ast::{
     Argument, ConstantTerm, ConstantTermOrList, Instance, ListExpanderType, PType, Parameter,
     Signature, StottrTerm, Template,
 };
-use templates::constants::{DEFAULT_PREFIX, OTTR_IRI, OTTR_TRIPLE};
 use tracing::warn;
 
 use crate::errors::MaplibError;
@@ -121,7 +121,7 @@ impl Model {
                             list_expand: false,
                             term: StottrTerm::ConstantTerm(ConstantTermOrList::ConstantTerm(
                                 ConstantTerm::Iri(
-                                    NamedNode::new(format!("{DEFAULT_PREFIX}{c}"))
+                                    NamedNode::new(format!("{DEFAULT_PREFIX_IRI}{c}"))
                                         .map_err(MappingError::IriParseError)?,
                                 ),
                             )),
@@ -137,7 +137,7 @@ impl Model {
 
         let template_name = format!(
             "{}default_template_{}",
-            DEFAULT_PREFIX, &self.default_template_counter
+            DEFAULT_PREFIX_IRI, &self.default_template_counter
         );
         self.default_template_counter += 1;
         let template = Template {

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

@@ -12,6 +12,7 @@ use polars::prelude::{
     NamedFrom, Series,
 };
 use rayon::iter::{IndexedParallelIterator, ParallelDrainRange, ParallelIterator};
+use representation::constants::OTTR_TRIPLE;
 use representation::dataset::NamedGraph;
 use representation::multitype::split_df_multicols;
 use representation::rdf_to_polars::rdf_named_node_to_polars_literal_value;
@@ -24,14 +25,13 @@ use std::time::Instant;
 use templates::ast::{
     ConstantTerm, ConstantTermOrList, Instance, ListExpanderType, PType, Signature, StottrTerm,
 };
-use templates::constants::OTTR_TRIPLE;
 use templates::MappingColumnType;
 use tracing::debug;
+use query_processing::expressions::non_multi_col_is_null_workaround;
 use triplestore::TriplesToAdd;
 
 const LIST_COL: &str = "list";
 const FIRST_COL: &str = "first";
-
 const REST_COL: &str = "rest";
 
 impl Model {
@@ -253,7 +253,9 @@ impl Model {
             predicate,
         } in ok_triples
         {
-            let has_multi = subject_type.is_multi() || object_type.is_multi();
+            let subject_multi = subject_type.is_multi();
+            let object_multi = object_type.is_multi();
+            let has_multi = subject_multi || object_multi;
 
             let mut types = HashMap::from([
                 (SUBJECT_COL_NAME.to_string(), subject_type),
@@ -270,23 +272,34 @@ impl Model {
             } else {
                 vec![(df, types)]
             };
-            for (df, mut types) in dfs {
-                let (subject_type, subject_state) = types
+            for (mut df, mut part_types) in dfs {
+                let (subject_type, subject_state) = part_types
                     .remove(SUBJECT_COL_NAME)
                     .unwrap()
                     .map
                     .into_iter()
                     .next()
                     .unwrap();
-                let (object_type, object_state) = types
+                let (object_type, object_state) = part_types
                     .remove(OBJECT_COL_NAME)
                     .unwrap()
                     .map
                     .into_iter()
                     .next()
                     .unwrap();
+                // Splitting by multi introduces nulls
+                if has_multi {
+                    let mut lf = df.lazy();
+                    if subject_multi {
+                        lf = lf.filter(non_multi_col_is_null_workaround(col(SUBJECT_COL_NAME), &subject_type).not())
+                    }
+                    if object_multi {
+                        lf = lf.filter(non_multi_col_is_null_workaround(col(OBJECT_COL_NAME), &object_type).not())
+                    }
+                    df = lf.collect().unwrap();
+                }
                 let predicate_state = if predicate.is_none() {
-                    let (_, s) = types
+                    let (_, s) = part_types
                         .remove(PREDICATE_COL_NAME)
                         .unwrap()
                         .map

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

@@ -25,9 +25,9 @@ use triplestore::sparql::errors::SparqlError;
 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 representation::prefixes::get_default_prefixes;
 use tracing::instrument;
 
 pub struct Model {
@@ -79,7 +79,7 @@ impl Model {
             if let Some(indexing) = indexing {
                 indexing
             } else {
-                IndexingOptions::new(false, None, None)
+                IndexingOptions::default()
             }
         } else {
             indexing.unwrap_or_default()
@@ -313,9 +313,14 @@ impl Model {
         buffer: &mut W,
         graph: &NamedGraph,
         rdf_format: RdfFormat,
+        prefixes: Option<&HashMap<String, NamedNode>>,
     ) -> Result<(), MaplibError> {
+        let mut use_prefixes = self.prefixes.clone();
+        if let Some(prefixes) = prefixes {
+            use_prefixes.extend(prefixes.clone());
+        }
         self.triplestore
-            .write_triples(buffer, rdf_format, graph)
+            .write_triples(buffer, rdf_format, graph, &use_prefixes)
             .map_err(MaplibError::TriplestoreError)?;
         Ok(())
     }

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

@@ -104,7 +104,7 @@ 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 || debug_outputs.is_some() {
+    if include_datatypes {
         Py::new(
             py,
             PySolutionMappings {

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

@@ -16,4 +16,6 @@ pub enum QueryProcessingError {
     BadNumberOfFunctionArguments(Function, usize, String),
     #[error("Maximum estimated rows `{}` in result exceeds configured maximum `{}`. You may have a cross join in your query, please double check. Alternatively, try setting the max_rows parameter to a higher value. Left columns: `{}` Right columns: `{}`", .0, .1, .2, .3)]
     MaxRowsReached(usize, usize, String, String),
+    #[error("The function `{}` is not implemented yet", .0)]
+    UnimplementedFunction(String),
 }

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

@@ -935,7 +935,7 @@ pub fn func_expression(
                     .rdf_node_types
                     .insert(outer_context.as_str().to_string(), t_new);
             } else {
-                todo!("Function {nn} is not implemented yet")
+                return Err(QueryProcessingError::UnimplementedFunction(nn.to_string()));
             }
         }
         Function::StrBefore | Function::StrAfter => {

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

@@ -159,15 +159,37 @@ pub fn binary_expression(
         .get(right_context.as_str())
         .unwrap();
     if left_type.is_none() || right_type.is_none() {
-        solution_mappings.mappings = solution_mappings.mappings.with_column(
-            lit(LiteralValue::untyped_null())
-                .cast(BaseRDFNodeType::None.default_input_polars_data_type())
-                .alias(outer_context.as_str()),
-        );
-        solution_mappings.rdf_node_types.insert(
-            outer_context.as_str().to_string(),
-            BaseRDFNodeType::None.into_default_input_rdf_node_state(),
-        );
+        if matches!(
+            expression,
+            Expression::Equal(..)
+                | Expression::Less(..)
+                | Expression::Greater(..)
+                | Expression::GreaterOrEqual(..)
+                | Expression::LessOrEqual(..)
+                | Expression::And(..)
+                | Expression::Or(..)
+        ) {
+            let bool = BaseRDFNodeType::Literal(xsd::BOOLEAN.into_owned());
+            solution_mappings.mappings = solution_mappings.mappings.with_column(
+                lit(LiteralValue::untyped_null())
+                    .cast(bool.default_input_polars_data_type())
+                    .alias(outer_context.as_str()),
+            );
+            solution_mappings.rdf_node_types.insert(
+                outer_context.as_str().to_string(),
+                bool.into_default_input_rdf_node_state(),
+            );
+        } else {
+            solution_mappings.mappings = solution_mappings.mappings.with_column(
+                lit(LiteralValue::untyped_null())
+                    .cast(BaseRDFNodeType::None.default_input_polars_data_type())
+                    .alias(outer_context.as_str()),
+            );
+            solution_mappings.rdf_node_types.insert(
+                outer_context.as_str().to_string(),
+                BaseRDFNodeType::None.into_default_input_rdf_node_state(),
+            );
+        }
         solution_mappings =
             drop_inner_contexts(solution_mappings, &vec![left_context, right_context]);
         return Ok(solution_mappings);
@@ -342,23 +364,27 @@ pub fn bound(
 pub fn expr_is_null_workaround(expr: Expr, rdf_node_type: &RDFNodeState) -> Expr {
     if !rdf_node_type.is_multi() {
         let b = rdf_node_type.get_base_type().unwrap();
-        match b {
-            BaseRDFNodeType::Literal(l) => {
-                if l.as_ref() == rdf::LANG_STRING {
-                    expr.struct_()
-                        .field_by_name(LANG_STRING_VALUE_FIELD)
-                        .is_null()
-                } else {
-                    expr.is_null()
-                }
-            }
-            _ => expr.is_null(),
-        }
+        non_multi_col_is_null_workaround(expr, b)
     } else {
         create_all_types_null_expression(expr, rdf_node_type.get_sorted_types())
     }
 }
 
+pub fn non_multi_col_is_null_workaround(expr: Expr, base_rdf_node_type: &BaseRDFNodeType) -> Expr {
+    match base_rdf_node_type {
+        BaseRDFNodeType::Literal(l) => {
+            if l.as_ref() == rdf::LANG_STRING {
+                expr.struct_()
+                    .field_by_name(LANG_STRING_VALUE_FIELD)
+                    .is_null()
+            } else {
+                expr.is_null()
+            }
+        }
+        _ => expr.is_null(),
+    }
+}
+
 pub fn if_expression(
     mut solution_mappings: SolutionMappings,
     left_context: &Context,
@@ -369,14 +395,31 @@ pub fn if_expression(
 ) -> 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())],
+        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();
+    .into_iter()
+    .map(|x| x.unwrap())
+    .collect();
     assert_eq!(exploded.len(), 2);
 
     let right_exploded = exploded.pop().unwrap();
@@ -413,9 +456,10 @@ pub fn if_expression(
         })
         .alias(outer_context.as_str()),
     );
-    solution_mappings
-        .rdf_node_types
-        .insert(outer_context.as_str().to_string(), RDFNodeState::from_map(base_type_map));
+    solution_mappings.rdf_node_types.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.19.3 → maplib-0.19.9}/lib/representation/src/base_rdf_type.rs

@@ -196,7 +196,7 @@ impl BaseRDFNodeType {
         } else if matches!(self, BaseRDFNodeType::IRI | BaseRDFNodeType::BlankNode) {
             DataType::UInt32
         } else if let BaseRDFNodeType::Literal(l) = self {
-            literal_type(l.as_ref(), &BaseCatState::String, false)
+            literal_type(l.as_ref(), &BaseCatState::CategoricalNative(false, None), false)
         } else {
             unreachable!("Should never happen")
         }
@@ -212,9 +212,11 @@ fn literal_type(
         xsd::UNSIGNED_INT => DataType::UInt32,
         xsd::UNSIGNED_LONG => DataType::UInt64,
         xsd::UNSIGNED_SHORT => DataType::UInt16,
+        xsd::UNSIGNED_BYTE => DataType::UInt8,
         xsd::INTEGER | xsd::LONG => DataType::Int64,
         xsd::INT => DataType::Int32,
         xsd::SHORT => DataType::Int16,
+        xsd::BYTE => DataType::Int8,
         xsd::DOUBLE | xsd::DECIMAL => DataType::Float64,
         xsd::FLOAT => DataType::Float32,
         xsd::BOOLEAN => DataType::Boolean,
@@ -223,8 +225,7 @@ fn literal_type(
                 DataType::Struct(polars_lang_fields(base_cat_state))
             } else {
                 match base_cat_state {
-                    BaseCatState::CategoricalNative(_, _) => DataType::UInt32,
-                    BaseCatState::String | BaseCatState::NonString => DataType::String,
+                    BaseCatState::String | BaseCatState::NonString | BaseCatState::CategoricalNative(..) => DataType::String,
                 }
             }
         }

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

@@ -20,12 +20,21 @@ impl CatEncs {
         new_ser
     }
 
-    pub fn maybe_decode_string(&self, u: &u32) -> Option<&str> {
+    pub fn maybe_decode_string(&self, u: &u32) -> Option<Cow<'_, str>> {
         self.maps.maybe_decode(u)
     }
 }
 
 impl Cats {
+    pub fn maybe_decode_of_type(&self, u:&u32, bt:&BaseRDFNodeType) -> Option<Cow<'_, str>> {
+        let ct = CatType::from_base_rdf_node_type(bt);
+        if let Some(cat_encs) = self.cat_map.get(&ct) {
+            cat_encs.maybe_decode_string(u)
+        } else {
+            None
+        }
+    }
+
     pub fn decode_iri_u32s(&self, us: &[u32], local_cats: Option<LockedCats>) -> Vec<NamedNode> {
         us.iter()
             .map(|x| self.decode_iri_u32(x, local_cats.clone()))
@@ -135,7 +144,7 @@ impl Cats {
                             break;
                         }
                     }
-                    Some(Cow::Borrowed(s.expect("Expect all cats to resolve")))
+                    Some(s.expect("Expect all cats to resolve"))
                 } else {
                     None
                 };

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

@@ -10,14 +10,14 @@ use std::collections::HashMap;
 use std::path::Path;
 
 impl CatEncs {
-    pub fn new_empty(path: Option<&Path>) -> CatEncs {
+    pub fn new_empty(path: Option<&Path>, bt: &BaseRDFNodeType) -> CatEncs {
         CatEncs {
-            maps: CatMaps::new_empty(path),
+            maps: CatMaps::new_empty(path, bt),
         }
     }
 
-    pub fn new_singular(value: &str, u: u32, path: Option<&Path>) -> CatEncs {
-        let maps = CatMaps::new_singular(value, u, path);
+    pub fn new_singular(value: &str, u: u32, path: Option<&Path>, bt: &BaseRDFNodeType) -> CatEncs {
+        let maps = CatMaps::new_singular(value, u, path, bt);
         CatEncs { maps }
     }
 
@@ -112,7 +112,7 @@ impl Cats {
         };
 
         let enc = self.get_encs(t).pop();
-        let mut new_enc = CatEncs::new_empty(path);
+        let mut new_enc = CatEncs::new_empty(path, t);
         let strch = series.str().unwrap();
         let encoded_global: Vec<_> = strch
             .iter()

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

@@ -27,7 +27,8 @@ impl Cats {
         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(path));
+                self.cat_map
+                    .insert(t.clone(), CatEncs::new_empty(path, &BaseRDFNodeType::IRI));
             }
             let enc = self.cat_map.get_mut(&t).unwrap();
             let pred = ct.predicate.as_str().to_string();

{maplib-0.19.3 → maplib-0.19.9}/lib/representation/src/cats/image.rs

@@ -2,7 +2,7 @@ use super::{reencode_solution_mappings, CatEncs, CatType};
 use super::{CatReEnc, Cats};
 use crate::cats::LockedCats;
 use crate::solution_mapping::{BaseCatState, EagerSolutionMappings};
-use crate::{BaseRDFNodeType, RDFNodeState};
+use crate::{BaseRDFNodeType, RDFNodeState, LANG_STRING_LANG_FIELD, LANG_STRING_VALUE_FIELD};
 use nohash_hasher::NoHashHasher;
 use std::collections::{HashMap, HashSet};
 use std::hash::BuildHasherDefault;
@@ -21,20 +21,40 @@ impl Cats {
                 let t = sm.rdf_node_types.get(c).unwrap();
                 for (bt, bs) in &t.map {
                     if let BaseCatState::CategoricalNative(_, local) = bs {
-                        let ser = if t.is_multi() {
-                            sm.mappings
+                        let mut sers = vec![];
+                        if bt.is_lang_string() {
+                            let ser1 = sm.mappings
                                 .column(c)
                                 .unwrap()
                                 .struct_()
                                 .unwrap()
-                                .field_by_name(&bt.field_col_name())
+                                .field_by_name(LANG_STRING_VALUE_FIELD)
+                                .unwrap();
+                            sers.push(ser1);
+                            let ser2 = sm.mappings
+                                .column(c)
+                                .unwrap()
+                                .struct_()
+                                .unwrap()
+                                .field_by_name(LANG_STRING_LANG_FIELD)
+                                .unwrap();
+                            sers.push(ser2);
+                        } else if t.is_multi() {
+                            let ser = sm.mappings
+                                .column(c)
                                 .unwrap()
+                                .struct_()
+                                .unwrap()
+                                .field_by_name(&bt.field_col_name())
+                                .unwrap();
+                            sers.push(ser);
                         } else {
-                            sm.mappings
+                            let ser = sm.mappings
                                 .column(c)
                                 .unwrap()
                                 .as_materialized_series()
-                                .clone()
+                                .clone();
+                            sers.push(ser);
                         };
                         if !s.contains_key(bt) {
                             s.insert(bt.clone(), HashSet::new());
@@ -48,16 +68,18 @@ impl Cats {
                             None
                         };
                         let ss = s.get_mut(bt).unwrap();
-                        let new_ss = ser
-                            .u32()
-                            .unwrap()
-                            .into_iter()
-                            .filter(|x| x.is_some())
-                            .map(|x| x.unwrap());
-                        if let Some(local_rev_map) = local_rev_map {
-                            ss.extend(new_ss.filter(|x| !local_rev_map.maps.contains_u32(x)));
-                        } else {
-                            ss.extend(new_ss);
+                        for ser in sers {
+                            let new_ss = ser
+                                .u32()
+                                .unwrap()
+                                .into_iter()
+                                .filter(|x| x.is_some())
+                                .map(|x| x.unwrap());
+                            if let Some(local_rev_map) = local_rev_map {
+                                ss.extend(new_ss.filter(|x| !local_rev_map.maps.contains_u32(x)));
+                            } else {
+                                ss.extend(new_ss);
+                            }
                         }
                     }
                 }