fix bugs with SPARQL sameValue

Author: pchampin

sparql/src/expression.rs

@@ -495,18 +495,35 @@ impl EvalResult {
     }
 
     pub fn sparql_eq(&self, other: &Self) -> Option<bool> {
-        if let (Some(s), Some(o)) = (self.as_value(), other.as_value()) {
-            s.sparql_eq(o)
-        } else {
-            let s = self.as_term();
-            let o = other.as_term();
-            if Term::eq(&s, &o) {
+        let st = self.as_term();
+        let ot = other.as_term();
+        if Term::eq(&st, &ot) {
+            Some(true)
+        } else if st.is_iri()
+            || st.is_blank_node()
+            || ot.is_iri()
+            || ot.is_blank_node()
+            || (st.is_triple() && !ot.is_triple() || !st.is_triple() && ot.is_triple())
+        {
+            Some(false)
+        } else if let Some(stt) = st.triple()
+            && let Some(ott) = ot.triple()
+        {
+            let [s1, p1, o1] = stt.map(|t| EvalResult::Term(t.clone().into()));
+            let [s2, p2, o2] = ott.map(|t| EvalResult::Term(t.clone().into()));
+            Some(s1.sparql_eq(&s2)? && p1.sparql_eq(&p2)? && o1.sparql_eq(&o2)?)
+        } else if let Some(sv) = self.as_value()
+            && let Some(ov) = other.as_value()
+        {
+            if sv.is_ill_formed() || ov.is_ill_formed() {
+                None
+            } else if sv.is_nan() && ov.is_nan() {
                 Some(true)
-            } else if s.is_literal() && o.is_literal() {
-                None // distinct unrecognized literals can not be compared
             } else {
-                Some(false)
+                sv.sparql_eq(ov)
             }
+        } else {
+            None
         }
     }
 

sparql/src/test.rs

@@ -1902,6 +1902,7 @@ fn test_expr(expr: &str, result: &str) -> TestResult {
 #[test_case("42", "42e0", Some(true))]
 #[test_case("42.0", "42e0", Some(true))]
 #[test_case("42", "43", Some(false))]
+#[test_case("\"foo\"^^xsd:integer", "42", None)]
 #[test_case("\"a\"", "\"\"", Some(false))]
 #[test_case("\"a\"@en", "\"\"@en", Some(false))]
 #[test_case("\"a\"@en", "\"a\"@fr", Some(false))]
@@ -1949,7 +1950,7 @@ fn test_expr_eq(expr1: &str, expr2: &str, exp: Option<bool>) -> TestResult {
     assert_eq!(eval_expr(&format!("{expr2} = {expr2}"))?, TRUE);
     assert_eq!(eval_expr(&format!("{expr2} != {expr2}"))?, FALSE);
     // control: every recognized value is equal to itself via comparison operators
-    if !expr1.contains("<tag:") {
+    if !expr1.contains("<tag:") && !expr1.contains("\"foo\"") {
         assert_eq!(eval_expr(&format!("{expr1} <= {expr1}"))?, TRUE);
         assert_eq!(eval_expr(&format!("{expr1} >= {expr1}"))?, TRUE);
         assert_eq!(eval_expr(&format!("{expr1} < {expr1}"))?, FALSE);

sparql/src/value.rs

@@ -113,6 +113,14 @@ impl SparqlValue {
         }
     }
 
+    pub fn is_nan(&self) -> bool {
+        match self {
+            SparqlValue::Number(Some(SparqlNumber::Float(f))) => f.is_nan(),
+            SparqlValue::Number(Some(SparqlNumber::Double(d))) => d.is_nan(),
+            _ => false,
+        }
+    }
+
     pub fn sparql_eq(&self, other: &Self) -> Option<bool> {
         use SparqlValue::*;
         match (self, other) {
@@ -121,9 +129,9 @@ impl SparqlValue {
                 d1.partial_cmp(d2).map(|o| o == Ordering::Equal)
             }
             (Number(Some(n1)), Number(Some(n2))) => Some(n1 == n2),
-            (String(s1, None), String(s2, None)) => Some(s1 == s2),
-            (String(s1, Some(t1)), String(s2, Some(t2))) => Some(t1 == t2 && s1 == s2),
-            _ => None,
+            (String(s1, opt1), String(s2, opt2)) => Some(s1 == s2 && opt1 == opt2),
+            _ if self.is_ill_formed() || other.is_ill_formed() => None,
+            _ => Some(false),
         }
     }
 

typos.toml

@@ -6,6 +6,7 @@ extend-ignore-identifiers-re = [
   # I prefer this to 'type_'
   "typ",
   "iz",
+  "ot",
 ]
 extend-ignore-re = [
   "raison d'être",