maplib 0.17.11__tar.gz → 0.17.12__tar.gz

{maplib-0.17.11 → maplib-0.17.12}/Cargo.lock

@@ -2470,12 +2470,11 @@ dependencies = [
 
 [[package]]
 name = "py_maplib"
-version = "0.17.11"
+version = "0.17.12"
 dependencies = [
  "chrono",
  "cimxml",
  "jemallocator",
- "log",
  "maplib",
  "mimalloc",
  "oxrdf",
@@ -2489,7 +2488,6 @@ dependencies = [
  "templates",
  "thiserror",
  "tracing",
- "tracing-log",
  "tracing-subscriber",
  "triplestore",
  "uuid",

{maplib-0.17.11 → maplib-0.17.12}/PKG-INFO

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

{maplib-0.17.11 → maplib-0.17.12}/lib/query_processing/src/expressions/functions.rs

@@ -1472,76 +1472,62 @@ pub fn func_expression(
                 let bs = t.get_base_state().unwrap();
                 let decoded =
                     maybe_decode_expr(col(first_context.as_str()), bt, bs, global_cats.clone());
-                match func {
-                    Function::StrStarts => {
-                        solution_mappings.mappings = solution_mappings.mappings.with_column(
-                            decoded
-                                .str()
-                                .starts_with(second_decoded)
-                                .alias(outer_context.as_str()),
-                        );
-                    }
-                    Function::StrEnds => {
-                        solution_mappings.mappings = solution_mappings.mappings.with_column(
-                            decoded
-                                .str()
-                                .ends_with(second_decoded)
-                                .alias(outer_context.as_str()),
-                        );
-                    }
-                    Function::Contains => {
-                        solution_mappings.mappings = solution_mappings.mappings.with_column(
-                            decoded
-                                .str()
-                                .contains_literal(second_decoded)
-                                .alias(outer_context.as_str()),
-                        );
-                    }
-                    _ => panic!("Should never happen"),
-                }
+                let expr = str_starts_ends_contains(decoded, second_decoded, func)
+                    .alias(outer_context.as_str());
+                solution_mappings.mappings = solution_mappings.mappings.with_column(expr);
             } else if t.is_lang_string() {
-                match func {
-                    Function::StrStarts => {
-                        solution_mappings.mappings = solution_mappings.mappings.with_column(
-                            col(first_context.as_str())
-                                .struct_()
-                                .field_by_name(LANG_STRING_VALUE_FIELD)
-                                .cast(DataType::String)
-                                .str()
-                                .starts_with(second_decoded)
-                                .alias(outer_context.as_str()),
-                        );
-                    }
-                    Function::StrEnds => {
-                        solution_mappings.mappings = solution_mappings.mappings.with_column(
-                            col(first_context.as_str())
-                                .struct_()
-                                .field_by_name(LANG_STRING_VALUE_FIELD)
-                                .cast(DataType::String)
-                                .str()
-                                .ends_with(second_decoded)
-                                .alias(outer_context.as_str()),
+                let expr = str_starts_ends_contains(
+                    col(first_context.as_str())
+                        .struct_()
+                        .field_by_name(LANG_STRING_VALUE_FIELD),
+                    second_decoded,
+                    func,
+                )
+                .alias(outer_context.as_str());
+                solution_mappings.mappings = solution_mappings.mappings.with_column(expr);
+            } else if t.is_multi() {
+                let mut exprs = vec![];
+                for (bt, bs) in &t.map {
+                    if bt.is_lit_type(xsd::STRING) {
+                        exprs.push(
+                            str_starts_ends_contains(
+                                col(first_context.as_str())
+                                    .struct_()
+                                    .field_by_name(&bt.field_col_name()),
+                                second_decoded.clone(),
+                                func,
+                            )
+                            .alias(outer_context.as_str()),
                         );
-                    }
-                    Function::Contains => {
-                        solution_mappings.mappings = solution_mappings.mappings.with_column(
+                    } else if bt.is_lang_string() {
+                        exprs.push(str_starts_ends_contains(
                             col(first_context.as_str())
                                 .struct_()
-                                .field_by_name(LANG_STRING_VALUE_FIELD)
-                                .cast(DataType::String)
-                                .str()
-                                .contains_literal(second_decoded)
-                                .alias(outer_context.as_str()),
-                        );
+                                .field_by_name(LANG_STRING_VALUE_FIELD),
+                            second_decoded.clone(),
+                            func,
+                        ))
                     }
-                    _ => panic!("Should never happen"),
                 }
-            } else if t.is_none() {
-                solution_mappings.mappings = solution_mappings
-                    .mappings
-                    .with_column(col(first_context.as_str()).alias(outer_context.as_str()));
+                if exprs.is_empty() {
+                    solution_mappings.mappings = solution_mappings.mappings.with_column(
+                        lit(LiteralValue::untyped_null())
+                            .cast(DataType::Boolean)
+                            .alias(outer_context.as_str()),
+                    );
+                } else if exprs.len() == 1 {
+                    solution_mappings.mappings =
+                        solution_mappings.mappings.with_column(exprs.pop().unwrap());
+                } else {
+                    solution_mappings.mappings =
+                        solution_mappings.mappings.with_column(coalesce(&exprs));
+                }
             } else {
-                todo!()
+                solution_mappings.mappings = solution_mappings.mappings.with_column(
+                    lit(LiteralValue::untyped_null())
+                        .cast(DataType::Boolean)
+                        .alias(outer_context.as_str()),
+                );
             }
             solution_mappings.rdf_node_types.insert(
                 outer_context.as_str().to_string(),
@@ -1800,6 +1786,7 @@ pub fn str_function(c: &str, t: &RDFNodeState, global_cats: LockedCats) -> Expr
                             s,
                             global_cats.clone(),
                         )
+                        .cast(DataType::String)
                     }
                 }
                 BaseRDFNodeType::None => lit(LiteralValue::untyped_null()).cast(DataType::String),
@@ -1974,3 +1961,12 @@ pub fn add_regex_feature_flags(pattern: &str, flags: Option<&str>) -> String {
         pattern.to_string()
     }
 }
+
+pub fn str_starts_ends_contains(expr_decoded: Expr, second_decoded: Expr, f: &Function) -> Expr {
+    match f {
+        Function::StrStarts => expr_decoded.str().starts_with(second_decoded),
+        Function::StrEnds => expr_decoded.str().ends_with(second_decoded),
+        Function::Contains => expr_decoded.str().contains_literal(second_decoded),
+        _ => unreachable!("Should never happen"),
+    }
+}

{maplib-0.17.11 → maplib-0.17.12}/lib/report_mapping/src/lib.rs

@@ -1,7 +1,7 @@
 use maplib::mapping::Model;
 use shacl::errors::ShaclError;
 use shacl::ValidationReport;
-use triplestore::{Triplestore};
+use triplestore::Triplestore;
 
 pub fn report_to_model(
     _report: &ValidationReport,

{maplib-0.17.11 → maplib-0.17.12}/py_maplib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "py_maplib"
-version = "0.17.11"
+version = "0.17.12"
 edition = "2021"
 readme = "README.md"
 
@@ -27,12 +27,10 @@ polars = { workspace = true, features = [
     "dtype-datetime", "dtype-decimal", "dtype-duration",
     "dtype-i8", "dtype-i16", "dtype-struct",
     "dtype-time", "dtype-u8", "dtype-u16"], default-features = false }
-log.workspace = true
 uuid.workspace = true
 chrono.workspace = true
 
 tracing.workspace = true
-tracing-log.workspace = true
 tracing-subscriber.workspace = true
 
 [lib]

{maplib-0.17.11 → maplib-0.17.12}/py_maplib/src/lib.rs

@@ -5,7 +5,6 @@ use crate::error::*;
 use polars::frame::DataFrame;
 use pydf_io::to_rust::polars_df_to_rust_df;
 
-
 use tracing::{info, instrument, warn};
 use tracing_subscriber::EnvFilter;
 use tracing_subscriber::{filter, prelude::*};