Laurin Weger
2 weeks ago
parent
b9ff05feee
commit
04b843e0fa
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,10 @@ |
||||
// Copyright (c) 2022-2025 Niko Bonnieure, Par le Peuple, NextGraph.org developers
|
||||
// All rights reserved.
|
||||
// Licensed under the Apache License, Version 2.0
|
||||
// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
|
||||
// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
|
||||
// at your option. All files in the project carrying such
|
||||
// notice may not be copied, modified, or distributed except
|
||||
// according to those terms.
|
||||
|
||||
pub mod orm_validation; |
||||
@ -0,0 +1,585 @@ |
||||
// Copyright (c) 2022-2025 Niko Bonnieure, Par le Peuple, NextGraph.org developers
|
||||
// All rights reserved.
|
||||
// Licensed under the Apache License, Version 2.0
|
||||
// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
|
||||
// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
|
||||
// at your option. All files in the project carrying such
|
||||
// notice may not be copied, modified, or distributed except
|
||||
// according to those terms.
|
||||
|
||||
use std::collections::HashMap; |
||||
use std::collections::HashSet; |
||||
|
||||
use ng_net::orm::BasicType; |
||||
use ng_net::orm::OrmSchemaLiteralType; |
||||
use ng_net::orm::OrmSchemaShape; |
||||
use ng_net::orm::OrmTrackedPredicate; |
||||
use ng_net::orm::OrmTrackedSubject; |
||||
use ng_net::orm::OrmTrackedSubjectChange; |
||||
use ng_net::orm::OrmTrackedSubjectValidity; |
||||
use ng_oxigraph::oxrdf::Subject; |
||||
use ng_oxigraph::oxrdf::Triple; |
||||
use ng_repo::errors::NgError; |
||||
|
||||
pub fn group_by_subject_for_shape<'a>( |
||||
shape: &'a OrmSchemaShape, |
||||
triples: &'a [Triple], |
||||
allowed_subjects: &[String], |
||||
) -> HashMap<String, Vec<&'a Triple>> { |
||||
let mut triples_by_subject: HashMap<String, Vec<&Triple>> = HashMap::new(); |
||||
let allowed_preds_set: HashSet<&str> = shape |
||||
.predicates |
||||
.iter() |
||||
.map(|OrmSchemaDataType, OrmSchemaPredicatep| p.iri.as_str()) |
||||
.collect(); |
||||
let allowed_subject_set: HashSet<&str> = allowed_subjects.iter().map(|s| s.as_str()).collect(); |
||||
for triple in triples { |
||||
// triple.subject must be in allowed_subjects (or allowed_subjects empty)
|
||||
// and triple.predicate must be in allowed_preds.
|
||||
if allowed_preds_set.contains(triple.predicate.as_str()) { |
||||
// filter subjects if list provided
|
||||
let subj = match &triple.subject { |
||||
Subject::NamedNode(n) => n.as_ref(), |
||||
_ => continue, |
||||
}; |
||||
// Subject must be in allowed subjects (or allowed_subjects is empty).
|
||||
if allowed_subject_set.is_empty() || allowed_subject_set.contains(subj.as_str()) { |
||||
triples_by_subject |
||||
.entry(subj.to_string()) |
||||
.or_insert_with(Vec::new) |
||||
.push(triple); |
||||
} |
||||
} |
||||
} |
||||
|
||||
return triples_by_subject; |
||||
} |
||||
|
||||
/// Add all triples to `subject_changes`
|
||||
/// Returns predicates to nested objects that were touched and need processing.
|
||||
/// Assumes all triples have same subject.
|
||||
use std::sync::Arc; |
||||
|
||||
pub fn add_remove_triples_mut( |
||||
shape: &Arc<OrmSchemaShape>, |
||||
subject_iri: &str, |
||||
triples_added: &[&Triple], |
||||
triples_removed: &[&Triple], |
||||
tracked_subjects: &mut HashMap<String, HashMap<String, OrmTrackedSubject>>, |
||||
subject_changes: &mut OrmTrackedSubjectChange, |
||||
) -> Result<(), NgError> { |
||||
let get_or_create_tracked_subject = |
||||
|subject_iri: &str, |
||||
shape_iri: &str, |
||||
tracked_subjects: &mut HashMap<String, HashMap<String, OrmTrackedSubject>>| { |
||||
let tracked_shapes_for_subject = tracked_subjects |
||||
.entry(subject_iri.to_string()) |
||||
.or_insert_with(HashMap::new); |
||||
|
||||
tracked_shapes_for_subject |
||||
.entry(shape_iri.to_string()) |
||||
.or_insert_with(|| OrmTrackedSubject { |
||||
tracked_predicates: HashMap::new(), |
||||
parents: HashMap::new(), |
||||
valid: ng_net::orm::OrmTrackedSubjectValidity::Pending, |
||||
subject_iri: subject_iri.to_string(), |
||||
shape, |
||||
}) |
||||
}; |
||||
|
||||
let tracked_subject = get_or_create_tracked_subject(subject_iri, &shape.iri, tracked_subjects); |
||||
|
||||
// Process added triples.
|
||||
// For each triple, check matching predicates in shape.
|
||||
// keeping track of value count (for later validations).
|
||||
// In parallel, we keep track of the values added (tracked_changes)
|
||||
for triple in triples_added { |
||||
for predicate_schema in &shape.predicates { |
||||
if predicate_schema.iri != triple.predicate.as_str() { |
||||
// Triple does not match predicate.
|
||||
continue; |
||||
} |
||||
// Predicate schema constraint matches this triple.
|
||||
|
||||
// Add tracked predicate or increase cardinality
|
||||
let tracked_predicate = tracked_subject |
||||
.tracked_predicates |
||||
.entry(predicate_schema.iri.to_string()) |
||||
.or_insert_with(|| OrmTrackedPredicate { |
||||
current_cardinality: 0, |
||||
schema: predicate_schema, |
||||
tracked_children: Vec::new(), |
||||
current_literals: None, |
||||
}); |
||||
tracked_predicate.current_cardinality += 1; |
||||
|
||||
let obj_term = oxrdf_term_to_orm_basic_type(&triple.object); |
||||
|
||||
// Keep track of the changed values too.
|
||||
let pred_changes = subject_changes |
||||
.predicates |
||||
.entry(predicate_schema.iri.clone()) |
||||
.or_insert_with(|| OrmTrackedPredicateChanges { |
||||
tracked_predicate: tracked_predicate, // reference remains inside lifetime of this call
|
||||
values_added: Vec::new(), |
||||
values_removed: Vec::new(), |
||||
}); |
||||
|
||||
pred_changes.values_added.push(obj_term.clone()); |
||||
|
||||
// If value type is literal, we need to add the current value to the tracked predicate.
|
||||
if tracked_predicate |
||||
.schema |
||||
.dataTypes |
||||
.iter() |
||||
.any(|dt| dt.valType == OrmSchemaLiteralType::literal) |
||||
{ |
||||
match &mut tracked_predicate.current_literals { |
||||
Some(lits) => lits.push(obj_term), |
||||
None => { |
||||
tracked_predicate.current_literals = Some(vec![obj_term]); |
||||
} |
||||
} |
||||
} |
||||
|
||||
// If predicate is of type shape, register (parent -> child) links so that
|
||||
// nested subjects can later be (lazily) fetched / validated.
|
||||
for shape_iri in predicate_schema |
||||
.dataTypes |
||||
.iter() |
||||
.filter(|dt| dt.valType == OrmSchemaLiteralType::shape) |
||||
.flat_map(|dt| dt.shape) |
||||
{ |
||||
if let BasicType::Str(obj_iri) = obj_term { |
||||
// Get or create object's tracked subject struct.
|
||||
let tracked_child = |
||||
get_or_create_tracked_subject(triple.predicate.as_string(), &shape_iri); |
||||
|
||||
// Add self to parent (set tracked to true, preliminary).
|
||||
tracked_child.parents.insert(obj_iri, tracked_child); |
||||
|
||||
// Add link to children
|
||||
tracked_predicate |
||||
.tracked_children |
||||
.push(unsafe { Weak::from_raw(tracked_child) }); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
// Process removed triples.
|
||||
for triple in triples_removed { |
||||
let pred_iri = triple.predicate.as_str(); |
||||
|
||||
// Only adjust if we had tracked state.
|
||||
let tracked_predicate_opt = tracked_subjects |
||||
.get_mut(subject_iri) |
||||
.and_then(|tss| tss.get_mut(&shape.iri)) |
||||
.and_then(|ts| ts.tracked_predicates.get_mut(pred_iri)); |
||||
let Some(tracked_predicate) = tracked_predicate_opt else { |
||||
continue; |
||||
}; |
||||
|
||||
// The cardinality might become -1 or 0. We will remove them from the tracked predicates during validation.
|
||||
tracked_predicate.current_cardinality = |
||||
tracked_predicate.current_cardinality.saturating_sub(1); |
||||
|
||||
let Some(pred_changes) = subject_changes.predicates.get_mut(pred_iri) else { |
||||
continue; |
||||
}; |
||||
|
||||
let val_removed = oxrdf_term_to_orm_basic_type(&triple.object); |
||||
pred_changes.values_removed.push(val_removed.clone()); |
||||
|
||||
// If value type is literal, we need to remove the current value from the tracked predicate.
|
||||
if tracked_predicate |
||||
.schema |
||||
.dataTypes |
||||
.iter() |
||||
.any(|dt| dt.valType == OrmSchemaLiteralType::literal) |
||||
{ |
||||
if let Some(current_literals) = &mut tracked_predicate.current_literals { |
||||
// Remove obj_val from current_literals in-place
|
||||
current_literals.retain(|val| *val != val_removed); |
||||
} else { |
||||
tracked_predicate.current_literals = Some(vec![val_removed]); |
||||
} |
||||
} else if tracked_predicate |
||||
.schema |
||||
.dataTypes |
||||
.iter() |
||||
.any(|dt| dt.valType == OrmSchemaLiteralType::shape) |
||||
{ |
||||
// Remove parent from child and child from tracked children.
|
||||
for shape_iri in tracked_predicate |
||||
.schema |
||||
.dataTypes |
||||
.iter() |
||||
.filter(|dt| dt.valType == OrmSchemaLiteralType::shape) |
||||
.flat_map(|dt| dt.shape) |
||||
{ |
||||
// Nested shape removal logic disabled (see note above).
|
||||
} |
||||
} |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
/// Check the validity of a subject and update affecting tracked subjects' validity.
|
||||
/// Might return nested objects that need to be validated.
|
||||
/// Assumes all triples to be of same subject.
|
||||
pub fn update_subject_validity<'a>( |
||||
s_change: &'a OrmTrackedSubjectChange<'a>, |
||||
shape: &OrmSchemaShape, |
||||
tracked_subjects: &HashMap<String, HashMap<String, OrmTrackedSubject<'a>>>, |
||||
previous_validity: OrmTrackedSubjectValidity, |
||||
) -> ( |
||||
OrmTrackedSubjectValidity, |
||||
// Vec<subject_iri, shape_iri>
|
||||
Vec<(String, String)>, |
||||
) { |
||||
let Some(tracked_shapes) = tracked_subjects.get_mut(subject_iri) else { |
||||
return (previous_validity, vec![]); |
||||
}; |
||||
let Some(tracked_subject) = tracked_shapes.get_mut(&shape.iri) else { |
||||
return (previous_validity, vec![]); |
||||
}; |
||||
|
||||
// Check 1) Check if we need to fetch this object.
|
||||
// If this subject has not been monitored but parents are now valid or need evaluation, we fetch.
|
||||
|
||||
// Check 2) If all parents are untracked, return untracked.
|
||||
if tracked_subject.parents.len() != 0 { |
||||
let no_parents_tracking = tracked_subject.parents.values().all(|parent| { |
||||
parent.valid == OrmTrackedSubjectValidity::Untracked |
||||
|| parent.valid == OrmTrackedSubjectValidity::Invalid |
||||
}); |
||||
|
||||
if no_parents_tracking { |
||||
// Remove tracked predicates and set untracked.
|
||||
tracked_subject.tracked_predicates = HashMap::new(); |
||||
tracked_subject.valid = OrmTrackedSubjectValidity::Untracked; |
||||
return (OrmTrackedSubjectValidity::Untracked, vec![]); |
||||
} else if !no_parents_tracking && previous_validity == OrmTrackedSubjectValidity::Untracked |
||||
{ |
||||
// We need to fetch the subject's current state:
|
||||
// We have new parents but were previously not recording changes.
|
||||
|
||||
// TODO
|
||||
} |
||||
} |
||||
|
||||
// Check 2) If there are no changes, there is nothing to do.
|
||||
if s_change.predicates.is_empty() { |
||||
return (previous_validity, vec![]); |
||||
} |
||||
|
||||
let mut new_validity = OrmTrackedSubjectValidity::Valid; |
||||
fn set_validity(current: &mut OrmTrackedSubjectValidity, new_val: OrmTrackedSubjectValidity) { |
||||
if new_val == OrmTrackedSubjectValidity::Invalid { |
||||
*current = OrmTrackedSubjectValidity::Invalid; |
||||
} else { |
||||
*current = new_val; |
||||
} |
||||
} |
||||
|
||||
// Check 3) If there is an infinite loop of parents pointing back to us, return invalid.
|
||||
// Create a set of visited parents to detect cycles.
|
||||
if has_cycle(tracked_subject, &mut HashSet::new()) { |
||||
// Remove tracked predicates and set invalid.
|
||||
tracked_subject.tracked_predicates = HashMap::new(); |
||||
tracked_subject.valid = OrmTrackedSubjectValidity::Invalid; |
||||
return (OrmTrackedSubjectValidity::Invalid, vec![]); |
||||
} |
||||
|
||||
// Keep track of objects that need to be validated against a shape to fetch and validate.
|
||||
let mut need_evaluation: Vec<(String, String)> = vec![]; |
||||
|
||||
// Check 4) Validate subject against each predicate in shape.
|
||||
for p_schema in shape.predicates.iter() { |
||||
let p_change = s_change.predicates.get(&p_schema.iri); |
||||
let tracked_pred = p_change.map(|pc| pc.tracked_predicate); |
||||
|
||||
let count = |
||||
tracked_pred.map_or_else(|| 0, |tp: &OrmTrackedPredicate| tp.current_cardinality); |
||||
|
||||
// Check 4.1) Cardinality
|
||||
if count < p_schema.minCardinality { |
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Invalid); |
||||
if count <= 0 { |
||||
// If cardinality is 0, we can remove the tracked predicate.
|
||||
tracked_subject.tracked_predicates.remove(&p_schema.iri); |
||||
} |
||||
break; |
||||
// Check 4.2) Cardinality too high and extra values not allowed.
|
||||
} else if count > p_schema.maxCardinality |
||||
&& p_schema.maxCardinality != -1 |
||||
&& p_schema.extra != Some(true) |
||||
{ |
||||
// If cardinality is too high and no extra allowed, invalid.
|
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Invalid); |
||||
break; |
||||
// Check 4.3) Required literals present.
|
||||
} else if p_schema |
||||
.dataTypes |
||||
.iter() |
||||
.any(|dt| dt.valType == OrmSchemaLiteralType::literal) |
||||
{ |
||||
// If we have literals, check if all required literals are present.
|
||||
// At least one datatype must match.
|
||||
let some_valid = |
||||
p_schema |
||||
.dataTypes |
||||
.iter() |
||||
.flat_map(|dt| &dt.literals) |
||||
.any(|required_literals| { |
||||
// Early stop: If no extra values allowed but the sizes
|
||||
// between required and given values mismatches.
|
||||
if !p_schema.extra.unwrap_or(false) |
||||
&& ((required_literals.len() as i32) |
||||
!= tracked_pred.map_or(0, |p| p.current_cardinality)) |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
// Check that each required literal is present.
|
||||
for required_literal in required_literals { |
||||
// Is tracked predicate present?
|
||||
if !tracked_pred |
||||
.iter() |
||||
.flat_map(|tp| &tp.current_literals) |
||||
.flatten() |
||||
.any(|literal| *literal == *required_literal) |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
// All required literals present.
|
||||
return true; |
||||
}); |
||||
if !some_valid { |
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Invalid); |
||||
} |
||||
// Check 4.4) Nested shape correct.
|
||||
} else if p_schema |
||||
.dataTypes |
||||
.iter() |
||||
.any(|dt| dt.valType == OrmSchemaLiteralType::shape) |
||||
{ |
||||
// If we have a nested shape, we need to check if the nested objects are tracked and valid.
|
||||
|
||||
// First, Count valid, invalid, unknowns, and untracked
|
||||
let counts = tracked_pred |
||||
.iter() |
||||
.flat_map(|tp| tp.tracked_children) |
||||
.map(|tc| { |
||||
tc.upgrade().map(|tc| { |
||||
if tc.valid == OrmTrackedSubjectValidity::Valid { |
||||
(1, 0, 0, 0) |
||||
} else if tc.valid == OrmTrackedSubjectValidity::Invalid { |
||||
(0, 1, 0, 0) |
||||
} else if tc.valid == OrmTrackedSubjectValidity::Pending { |
||||
(0, 0, 1, 0) |
||||
} else if tc.valid == OrmTrackedSubjectValidity::Untracked { |
||||
(0, 0, 0, 1) |
||||
} else { |
||||
(0, 0, 0, 0) |
||||
} |
||||
}) |
||||
}) |
||||
.flatten() |
||||
.fold((0, 0, 0, 0), |(v1, i1, u1, ut1), o| { |
||||
(v1 + o.0, i1 + o.1, u1 + o.2, ut1 + o.3) |
||||
}); |
||||
|
||||
if counts.1 > 0 && p_schema.extra != Some(true) { |
||||
// If we have at least one invalid nested object and no extra allowed, invalid.
|
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Invalid); |
||||
break; |
||||
} else if counts.0 < p_schema.minCardinality { |
||||
// If we have not enough valid nested objects, invalid.
|
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Invalid); |
||||
break; |
||||
} else if counts.3 > 0 { |
||||
// If we have untracked nested objects, we need to fetch them and validate.
|
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Pending); |
||||
// After that we need to reevaluate this (subject,shape) again.
|
||||
need_evaluation.push((subject_iri.to_string(), shape.iri.clone(), false)); |
||||
// Also schedule untracked children for fetching and validation.
|
||||
if let Some(tp) = tracked_pred { |
||||
for weak_child in &tp.tracked_children { |
||||
if let Some(child) = weak_child.upgrade() { |
||||
if child.valid == OrmTrackedSubjectValidity::Untracked { |
||||
need_evaluation.push(( |
||||
child.subject_iri.clone(), |
||||
child.shape.iri.clone(), |
||||
true, |
||||
)); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} else if counts.2 > 0 { |
||||
// If we have unknown nested objects, we need to wait for their evaluation.
|
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Pending); |
||||
// Schedule unknown children (NotEvaluated) for re-evaluation without fetch.
|
||||
if let Some(tp) = tracked_pred { |
||||
for weak_child in &tp.tracked_children { |
||||
if let Some(child) = weak_child.upgrade() { |
||||
if child.valid == OrmTrackedSubjectValidity::Pending { |
||||
need_evaluation.push(( |
||||
child.subject_iri.clone(), |
||||
child.shape.iri.clone(), |
||||
false, |
||||
)); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} else { |
||||
// All nested objects are valid and cardinality is correct.
|
||||
// We are valid with this predicate.
|
||||
} |
||||
// Check 4.5) Data types correct.
|
||||
} else { |
||||
// Check if the data type is correct.
|
||||
let allowed_types: Vec<&OrmSchemaLiteralType> = |
||||
p_schema.dataTypes.iter().map(|dt| &dt.valType).collect(); |
||||
// For each new value, check that data type is in allowed_types.
|
||||
for val_added in p_change.iter().map(|pc| pc.values_added).flatten() { |
||||
let matches = match val_added { |
||||
BasicType::Bool(_) => allowed_types |
||||
.iter() |
||||
.any(|t| **t == OrmSchemaLiteralType::boolean), |
||||
BasicType::Num(_) => allowed_types |
||||
.iter() |
||||
.any(|t| **t == OrmSchemaLiteralType::number), |
||||
BasicType::Str(_) => allowed_types.iter().any(|t| { |
||||
**t == OrmSchemaLiteralType::string || **t == OrmSchemaLiteralType::iri |
||||
}), |
||||
}; |
||||
if !matches { |
||||
set_validity(&mut new_validity, OrmTrackedSubjectValidity::Invalid); |
||||
break; |
||||
} |
||||
} |
||||
// Break again if validity has become invalid.
|
||||
if new_validity == OrmTrackedSubjectValidity::Invalid { |
||||
break; |
||||
} |
||||
}; |
||||
} |
||||
|
||||
if new_validity == OrmTrackedSubjectValidity::Invalid { |
||||
// If we are invalid, we can discard new unknowns again - they won't be kept in memory.
|
||||
// We need to remove ourself from child objects parents field and
|
||||
// remove them if no other is tracking.
|
||||
// Child relationship cleanup disabled (nested tracking disabled in this refactor step)
|
||||
|
||||
// Remove tracked predicates and set untracked.
|
||||
tracked_subject.tracked_predicates = HashMap::new(); |
||||
|
||||
// Empty list of children that need evaluation.
|
||||
need_evaluation.retain(|_| false); |
||||
} else if new_validity == OrmTrackedSubjectValidity::Valid |
||||
&& previous_validity != OrmTrackedSubjectValidity::Valid |
||||
{ |
||||
// If this subject became valid, we need to refetch this subject;
|
||||
// For that we prepend self to needs_fetch.
|
||||
need_evaluation.insert(0, (s_change.subject_iri, shape.iri.clone())); |
||||
} |
||||
|
||||
// If validity changed, parents need to be re-evaluated.
|
||||
if new_validity != previous_validity { |
||||
// We return the tracking parents which need re-evaluation.
|
||||
// Remember that the last elements (i.e. children or needs_fetch) are evaluated first.
|
||||
return ( |
||||
new_validity, |
||||
// Add parents and objects in `need_evaluation`.
|
||||
tracked_subject |
||||
.parents |
||||
.values() |
||||
// Inform tracking parents only.
|
||||
.filter(|(parent, is_tracked)| *is_tracked) |
||||
.map(|(parent, is_tracked)| (&parent.subject_iri, parent.shape)) |
||||
// Add `need_evaluation`.
|
||||
.chain(need_evaluation) |
||||
.collect(), |
||||
); |
||||
} |
||||
|
||||
tracked_subject.valid = new_validity; |
||||
|
||||
return (new_validity, need_evaluation); |
||||
} |
||||
|
||||
fn oxrdf_term_to_orm_basic_type(term: &ng_oxigraph::oxrdf::Term) -> BasicType { |
||||
match oxrdf_term_to_orm_term(term) { |
||||
ng_net::orm::Term::Str(s) => BasicType::Str(s), |
||||
ng_net::orm::Term::Num(n) => BasicType::Num(n), |
||||
ng_net::orm::Term::Bool(b) => BasicType::Bool(b), |
||||
ng_net::orm::Term::Ref(b) => BasicType::Str(b), // Treat IRIs as strings
|
||||
} |
||||
} |
||||
|
||||
fn has_cycle(subject: &OrmTrackedSubject, visited: &mut HashSet<String>) -> bool { |
||||
if visited.contains(&subject.subject_iri) { |
||||
return true; |
||||
} |
||||
visited.insert(subject.subject_iri.clone()); |
||||
for (_parent_iri, (parent_subject, _)) in &subject.parents { |
||||
if has_cycle(parent_subject, visited) { |
||||
return true; |
||||
} |
||||
} |
||||
visited.remove(&subject.subject_iri); |
||||
false |
||||
} |
||||
|
||||
/// Converts an oxrdf::Term to an orm::Term
|
||||
fn oxrdf_term_to_orm_term(term: &ng_oxigraph::oxrdf::Term) -> ng_net::orm::Term { |
||||
match term { |
||||
ng_oxigraph::oxrdf::Term::NamedNode(node) => { |
||||
ng_net::orm::Term::Ref(node.as_str().to_string()) |
||||
} |
||||
ng_oxigraph::oxrdf::Term::BlankNode(node) => { |
||||
ng_net::orm::Term::Ref(node.as_str().to_string()) |
||||
} |
||||
ng_oxigraph::oxrdf::Term::Literal(literal) => { |
||||
// Check the datatype to determine how to convert
|
||||
match literal.datatype().as_str() { |
||||
// Check for string first, this is the most common.
|
||||
"http://www.w3.org/2001/XMLSchema#string" => { |
||||
ng_net::orm::Term::Str(literal.value().to_string()) |
||||
} |
||||
"http://www.w3.org/2001/XMLSchema#boolean" => { |
||||
match literal.value().parse::<bool>() { |
||||
Ok(b) => ng_net::orm::Term::Bool(b), |
||||
Err(_) => ng_net::orm::Term::Str(literal.value().to_string()), |
||||
} |
||||
} |
||||
"http://www.w3.org/2001/XMLSchema#integer" |
||||
| "http://www.w3.org/2001/XMLSchema#decimal" |
||||
| "http://www.w3.org/2001/XMLSchema#double" |
||||
| "http://www.w3.org/2001/XMLSchema#float" |
||||
| "http://www.w3.org/2001/XMLSchema#int" |
||||
| "http://www.w3.org/2001/XMLSchema#long" |
||||
| "http://www.w3.org/2001/XMLSchema#short" |
||||
| "http://www.w3.org/2001/XMLSchema#byte" |
||||
| "http://www.w3.org/2001/XMLSchema#unsignedInt" |
||||
| "http://www.w3.org/2001/XMLSchema#unsignedLong" |
||||
| "http://www.w3.org/2001/XMLSchema#unsignedShort" |
||||
| "http://www.w3.org/2001/XMLSchema#unsignedByte" => { |
||||
match literal.value().parse::<f64>() { |
||||
Ok(n) => ng_net::orm::Term::Num(n), |
||||
Err(_) => ng_net::orm::Term::Str(literal.value().to_string()), |
||||
} |
||||
} |
||||
_ => ng_net::orm::Term::Str(literal.value().to_string()), |
||||
} |
||||
} |
||||
ng_oxigraph::oxrdf::Term::Triple(triple) => { |
||||
// For RDF-star triples, convert to string representation
|
||||
ng_net::orm::Term::Str(triple.to_string()) |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue