Tpt
5 years ago
parent
5039da163b
commit
69f94777b6
@ -1,178 +0,0 @@ |
|||||||
use crate::model::isomorphism::are_graphs_isomorphic; |
|
||||||
use crate::model::*; |
|
||||||
use std::collections::HashSet; |
|
||||||
use std::fmt; |
|
||||||
use std::iter::FromIterator; |
|
||||||
|
|
||||||
/// A simple implementation of [RDF graphs](https://www.w3.org/TR/rdf11-concepts/#dfn-graph).
|
|
||||||
///
|
|
||||||
/// It is not done to hold big graphs.
|
|
||||||
///
|
|
||||||
/// Usage example:
|
|
||||||
/// ```
|
|
||||||
/// use oxigraph::model::*;
|
|
||||||
/// use oxigraph::model::SimpleGraph;
|
|
||||||
///
|
|
||||||
/// let mut graph = SimpleGraph::default();
|
|
||||||
/// let ex = NamedNode::parse("http://example.com").unwrap();
|
|
||||||
/// let triple = Triple::new(ex.clone(), ex.clone(), ex.clone());
|
|
||||||
/// graph.insert(triple.clone());
|
|
||||||
/// let results: Vec<Triple> = graph.triples_for_subject(&ex.into()).cloned().collect();
|
|
||||||
/// assert_eq!(vec![triple], results);
|
|
||||||
/// ```
|
|
||||||
#[derive(Eq, PartialEq, Debug, Clone, Default)] |
|
||||||
pub struct SimpleGraph { |
|
||||||
triples: HashSet<Triple>, |
|
||||||
} |
|
||||||
|
|
||||||
impl SimpleGraph { |
|
||||||
/// Returns all triples contained by the graph
|
|
||||||
pub fn iter(&self) -> impl Iterator<Item = &Triple> { |
|
||||||
self.triples.iter() |
|
||||||
} |
|
||||||
|
|
||||||
pub fn triples_for_subject<'a>( |
|
||||||
&'a self, |
|
||||||
subject: &'a NamedOrBlankNode, |
|
||||||
) -> impl Iterator<Item = &Triple> + 'a { |
|
||||||
self.iter().filter(move |t| t.subject() == subject) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn objects_for_subject_predicate<'a>( |
|
||||||
&'a self, |
|
||||||
subject: &'a NamedOrBlankNode, |
|
||||||
predicate: &'a NamedNode, |
|
||||||
) -> impl Iterator<Item = &Term> + 'a { |
|
||||||
self.iter().filter_map(move |t| { |
|
||||||
if t.subject() == subject && t.predicate() == predicate { |
|
||||||
Some(t.object()) |
|
||||||
} else { |
|
||||||
None |
|
||||||
} |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn object_for_subject_predicate<'a>( |
|
||||||
&'a self, |
|
||||||
subject: &'a NamedOrBlankNode, |
|
||||||
predicate: &'a NamedNode, |
|
||||||
) -> Option<&'a Term> { |
|
||||||
self.objects_for_subject_predicate(subject, predicate) |
|
||||||
.next() |
|
||||||
} |
|
||||||
|
|
||||||
pub fn predicates_for_subject_object<'a>( |
|
||||||
&'a self, |
|
||||||
subject: &'a NamedOrBlankNode, |
|
||||||
object: &'a Term, |
|
||||||
) -> impl Iterator<Item = &NamedNode> + 'a { |
|
||||||
self.iter().filter_map(move |t| { |
|
||||||
if t.subject() == subject && t.object() == object { |
|
||||||
Some(t.predicate()) |
|
||||||
} else { |
|
||||||
None |
|
||||||
} |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn triples_for_predicate<'a>( |
|
||||||
&'a self, |
|
||||||
predicate: &'a NamedNode, |
|
||||||
) -> impl Iterator<Item = &Triple> + 'a { |
|
||||||
self.iter().filter(move |t| t.predicate() == predicate) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn subjects_for_predicate_object<'a>( |
|
||||||
&'a self, |
|
||||||
predicate: &'a NamedNode, |
|
||||||
object: &'a Term, |
|
||||||
) -> impl Iterator<Item = &NamedOrBlankNode> + 'a { |
|
||||||
self.iter().filter_map(move |t| { |
|
||||||
if t.predicate() == predicate && t.object() == object { |
|
||||||
Some(t.subject()) |
|
||||||
} else { |
|
||||||
None |
|
||||||
} |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn triples_for_object<'a>( |
|
||||||
&'a self, |
|
||||||
object: &'a Term, |
|
||||||
) -> impl Iterator<Item = &Triple> + 'a { |
|
||||||
self.iter().filter(move |t| t.object() == object) |
|
||||||
} |
|
||||||
|
|
||||||
/// Checks if the graph contains the given triple
|
|
||||||
pub fn contains(&self, triple: &Triple) -> bool { |
|
||||||
self.triples.contains(triple) |
|
||||||
} |
|
||||||
|
|
||||||
/// Adds a triple to the graph
|
|
||||||
pub fn insert(&mut self, triple: Triple) -> bool { |
|
||||||
self.triples.insert(triple) |
|
||||||
} |
|
||||||
|
|
||||||
/// Removes a concrete triple from the graph
|
|
||||||
pub fn remove(&mut self, triple: &Triple) -> bool { |
|
||||||
self.triples.remove(triple) |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns the number of triples in this graph
|
|
||||||
pub fn len(&self) -> usize { |
|
||||||
self.triples.len() |
|
||||||
} |
|
||||||
|
|
||||||
/// Checks if this graph contains a triple
|
|
||||||
pub fn is_empty(&self) -> bool { |
|
||||||
self.triples.is_empty() |
|
||||||
} |
|
||||||
|
|
||||||
/// Checks if the current graph is [isomorphic](https://www.w3.org/TR/rdf11-concepts/#dfn-graph-isomorphism) with another one
|
|
||||||
///
|
|
||||||
/// Warning: This algorithm worst case complexity is in O(n!)
|
|
||||||
pub fn is_isomorphic(&self, other: &SimpleGraph) -> bool { |
|
||||||
are_graphs_isomorphic(self, other) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl IntoIterator for SimpleGraph { |
|
||||||
type Item = Triple; |
|
||||||
type IntoIter = <HashSet<Triple> as IntoIterator>::IntoIter; |
|
||||||
|
|
||||||
fn into_iter(self) -> Self::IntoIter { |
|
||||||
self.triples.into_iter() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl<'a> IntoIterator for &'a SimpleGraph { |
|
||||||
type Item = &'a Triple; |
|
||||||
type IntoIter = <&'a HashSet<Triple> as IntoIterator>::IntoIter; |
|
||||||
|
|
||||||
fn into_iter(self) -> Self::IntoIter { |
|
||||||
self.triples.iter() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl FromIterator<Triple> for SimpleGraph { |
|
||||||
fn from_iter<I: IntoIterator<Item = Triple>>(iter: I) -> Self { |
|
||||||
Self { |
|
||||||
triples: HashSet::from_iter(iter), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl Extend<Triple> for SimpleGraph { |
|
||||||
fn extend<I: IntoIterator<Item = Triple>>(&mut self, iter: I) { |
|
||||||
self.triples.extend(iter) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl fmt::Display for SimpleGraph { |
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
|
||||||
for t in &self.triples { |
|
||||||
writeln!(f, "{}", t)?; |
|
||||||
} |
|
||||||
Ok(()) |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,289 +0,0 @@ |
|||||||
use crate::model::*; |
|
||||||
use std::collections::hash_map::{DefaultHasher, RandomState}; |
|
||||||
use std::collections::{BTreeSet, HashMap, HashSet}; |
|
||||||
use std::hash::Hash; |
|
||||||
use std::hash::Hasher; |
|
||||||
|
|
||||||
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)] |
|
||||||
struct SubjectPredicate<'a> { |
|
||||||
subject: &'a NamedOrBlankNode, |
|
||||||
predicate: &'a NamedNode, |
|
||||||
} |
|
||||||
|
|
||||||
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)] |
|
||||||
struct PredicateObject<'a> { |
|
||||||
predicate: &'a NamedNode, |
|
||||||
object: &'a Term, |
|
||||||
} |
|
||||||
|
|
||||||
fn subject_predicates_for_object<'a>( |
|
||||||
graph: &'a SimpleGraph, |
|
||||||
object: &'a Term, |
|
||||||
) -> impl Iterator<Item = SubjectPredicate<'a>> + 'a { |
|
||||||
graph.triples_for_object(object).map(|t| SubjectPredicate { |
|
||||||
subject: t.subject(), |
|
||||||
predicate: t.predicate(), |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
fn predicate_objects_for_subject<'a>( |
|
||||||
graph: &'a SimpleGraph, |
|
||||||
subject: &'a NamedOrBlankNode, |
|
||||||
) -> impl Iterator<Item = PredicateObject<'a>> + 'a { |
|
||||||
graph.triples_for_subject(subject).map(|t| PredicateObject { |
|
||||||
predicate: t.predicate(), |
|
||||||
object: t.object(), |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
fn split_hash_buckets<'a>( |
|
||||||
bnodes_by_hash: HashMap<u64, Vec<&'a BlankNode>>, |
|
||||||
graph: &'a SimpleGraph, |
|
||||||
distance: usize, |
|
||||||
) -> HashMap<u64, Vec<&'a BlankNode>> { |
|
||||||
let mut new_bnodes_by_hash = HashMap::default(); |
|
||||||
|
|
||||||
for (hash, bnodes) in bnodes_by_hash { |
|
||||||
if bnodes.len() == 1 { |
|
||||||
new_bnodes_by_hash.insert(hash, bnodes); // Nothing to improve
|
|
||||||
} else { |
|
||||||
for bnode in bnodes { |
|
||||||
let mut starts = vec![NamedOrBlankNode::from(*bnode)]; |
|
||||||
for _ in 0..distance { |
|
||||||
let mut new_starts = Vec::default(); |
|
||||||
for s in starts { |
|
||||||
for t in graph.triples_for_subject(&s) { |
|
||||||
match t.object() { |
|
||||||
Term::NamedNode(t) => new_starts.push(t.clone().into()), |
|
||||||
Term::BlankNode(t) => new_starts.push(t.clone().into()), |
|
||||||
Term::Literal(_) => (), |
|
||||||
} |
|
||||||
} |
|
||||||
for t in graph.triples_for_object(&s.into()) { |
|
||||||
new_starts.push(t.subject().clone()); |
|
||||||
} |
|
||||||
} |
|
||||||
starts = new_starts; |
|
||||||
} |
|
||||||
|
|
||||||
// We do the hashing
|
|
||||||
let mut hasher = DefaultHasher::default(); |
|
||||||
hash.hash(&mut hasher); // We start with the previous hash
|
|
||||||
|
|
||||||
// NB: we need to sort the triples to have the same hash
|
|
||||||
let mut po_set: BTreeSet<PredicateObject<'_>> = BTreeSet::default(); |
|
||||||
for start in &starts { |
|
||||||
for po in predicate_objects_for_subject(graph, start) { |
|
||||||
match &po.object { |
|
||||||
Term::BlankNode(_) => (), |
|
||||||
_ => { |
|
||||||
po_set.insert(po); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
for po in &po_set { |
|
||||||
po.hash(&mut hasher); |
|
||||||
} |
|
||||||
|
|
||||||
let mut sp_set: BTreeSet<SubjectPredicate<'_>> = BTreeSet::default(); |
|
||||||
let term_starts: Vec<_> = starts.into_iter().map(|t| t.into()).collect(); |
|
||||||
for start in &term_starts { |
|
||||||
for sp in subject_predicates_for_object(graph, start) { |
|
||||||
match &sp.subject { |
|
||||||
NamedOrBlankNode::BlankNode(_) => (), |
|
||||||
_ => { |
|
||||||
sp_set.insert(sp); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
for sp in &sp_set { |
|
||||||
sp.hash(&mut hasher); |
|
||||||
} |
|
||||||
|
|
||||||
new_bnodes_by_hash |
|
||||||
.entry(hasher.finish()) |
|
||||||
.or_insert_with(Vec::default) |
|
||||||
.push(bnode); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
new_bnodes_by_hash |
|
||||||
} |
|
||||||
|
|
||||||
fn build_and_check_containment_from_hashes<'a>( |
|
||||||
a_bnodes_by_hash: &mut Vec<(u64, Vec<&'a BlankNode>)>, |
|
||||||
b_bnodes_by_hash: &'a HashMap<u64, Vec<&'a BlankNode>>, |
|
||||||
a_to_b_mapping: &mut HashMap<&'a BlankNode, &'a BlankNode>, |
|
||||||
a: &'a SimpleGraph, |
|
||||||
b: &'a SimpleGraph, |
|
||||||
current_a_nodes: &[&'a BlankNode], |
|
||||||
current_b_nodes: &mut BTreeSet<&'a BlankNode>, |
|
||||||
) -> bool { |
|
||||||
if let Some((a_node, remaining_a_node)) = current_a_nodes.split_last() { |
|
||||||
let b_nodes = current_b_nodes.iter().cloned().collect::<Vec<_>>(); |
|
||||||
for b_node in b_nodes { |
|
||||||
current_b_nodes.remove(b_node); |
|
||||||
a_to_b_mapping.insert(a_node, b_node); |
|
||||||
if check_is_contained_focused(a_to_b_mapping, a_node, a, b) |
|
||||||
&& build_and_check_containment_from_hashes( |
|
||||||
a_bnodes_by_hash, |
|
||||||
b_bnodes_by_hash, |
|
||||||
a_to_b_mapping, |
|
||||||
a, |
|
||||||
b, |
|
||||||
remaining_a_node, |
|
||||||
current_b_nodes, |
|
||||||
) |
|
||||||
{ |
|
||||||
return true; |
|
||||||
} |
|
||||||
current_b_nodes.insert(b_node); |
|
||||||
} |
|
||||||
a_to_b_mapping.remove(a_node); |
|
||||||
false |
|
||||||
} else { |
|
||||||
let (hash, new_a_nodes) = match a_bnodes_by_hash.pop() { |
|
||||||
Some(v) => v, |
|
||||||
None => return true, |
|
||||||
}; |
|
||||||
|
|
||||||
let mut new_b_nodes = b_bnodes_by_hash |
|
||||||
.get(&hash) |
|
||||||
.map_or(BTreeSet::default(), |v| v.iter().cloned().collect()); |
|
||||||
if new_a_nodes.len() != new_b_nodes.len() { |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
if new_a_nodes.len() > 10 { |
|
||||||
eprintln!("Too big instance, aborting"); |
|
||||||
return true; //TODO: Very very very bad
|
|
||||||
} |
|
||||||
|
|
||||||
if build_and_check_containment_from_hashes( |
|
||||||
a_bnodes_by_hash, |
|
||||||
b_bnodes_by_hash, |
|
||||||
a_to_b_mapping, |
|
||||||
a, |
|
||||||
b, |
|
||||||
&new_a_nodes, |
|
||||||
&mut new_b_nodes, |
|
||||||
) { |
|
||||||
true |
|
||||||
} else { |
|
||||||
a_bnodes_by_hash.push((hash, new_a_nodes)); |
|
||||||
false |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
fn check_is_contained_focused<'a>( |
|
||||||
a_to_b_mapping: &mut HashMap<&'a BlankNode, &'a BlankNode>, |
|
||||||
a_bnode_focus: &'a BlankNode, |
|
||||||
a: &'a SimpleGraph, |
|
||||||
b: &'a SimpleGraph, |
|
||||||
) -> bool { |
|
||||||
let a_bnode_subject = a_bnode_focus.clone().into(); |
|
||||||
let a_bnode_object = a_bnode_focus.clone().into(); |
|
||||||
let ts_a = a |
|
||||||
.triples_for_subject(&a_bnode_subject) |
|
||||||
.chain(a.triples_for_object(&a_bnode_object)); |
|
||||||
for t_a in ts_a { |
|
||||||
let subject: NamedOrBlankNode = if let NamedOrBlankNode::BlankNode(s_a) = &t_a.subject() { |
|
||||||
if let Some(s_a) = a_to_b_mapping.get(s_a) { |
|
||||||
(*s_a).clone().into() |
|
||||||
} else { |
|
||||||
continue; // We skip for now
|
|
||||||
} |
|
||||||
} else { |
|
||||||
t_a.subject().clone() |
|
||||||
}; |
|
||||||
let predicate = t_a.predicate().clone(); |
|
||||||
let object: Term = if let Term::BlankNode(o_a) = &t_a.object() { |
|
||||||
if let Some(o_a) = a_to_b_mapping.get(o_a) { |
|
||||||
(*o_a).clone().into() |
|
||||||
} else { |
|
||||||
continue; // We skip for now
|
|
||||||
} |
|
||||||
} else { |
|
||||||
t_a.object().clone() |
|
||||||
}; |
|
||||||
if !b.contains(&Triple::new(subject, predicate, object)) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
true |
|
||||||
} |
|
||||||
|
|
||||||
fn graph_blank_nodes(graph: &SimpleGraph) -> Vec<&BlankNode> { |
|
||||||
let mut blank_nodes: HashSet<&BlankNode, RandomState> = HashSet::default(); |
|
||||||
for t in graph { |
|
||||||
if let NamedOrBlankNode::BlankNode(subject) = t.subject() { |
|
||||||
blank_nodes.insert(subject); |
|
||||||
} |
|
||||||
if let Term::BlankNode(object) = &t.object() { |
|
||||||
blank_nodes.insert(object); |
|
||||||
} |
|
||||||
} |
|
||||||
blank_nodes.into_iter().collect() |
|
||||||
} |
|
||||||
|
|
||||||
pub fn are_graphs_isomorphic(a: &SimpleGraph, b: &SimpleGraph) -> bool { |
|
||||||
if a.len() != b.len() { |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
// We check containment of everything buts triples with blank nodes
|
|
||||||
let mut a_bnodes_triples = SimpleGraph::default(); |
|
||||||
for t in a { |
|
||||||
if t.subject().is_blank_node() || t.object().is_blank_node() { |
|
||||||
a_bnodes_triples.insert(t.clone()); |
|
||||||
} else if !b.contains(t) { |
|
||||||
return false; // Triple in a not in b without blank nodes
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
let mut b_bnodes_triples = SimpleGraph::default(); |
|
||||||
for t in b { |
|
||||||
if t.subject().is_blank_node() || t.object().is_blank_node() { |
|
||||||
b_bnodes_triples.insert(t.clone()); |
|
||||||
} else if !a.contains(t) { |
|
||||||
return false; // Triple in a not in b without blank nodes
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
let mut a_bnodes_by_hash = HashMap::default(); |
|
||||||
a_bnodes_by_hash.insert(0, graph_blank_nodes(&a_bnodes_triples)); |
|
||||||
let mut b_bnodes_by_hash = HashMap::default(); |
|
||||||
b_bnodes_by_hash.insert(0, graph_blank_nodes(&b_bnodes_triples)); |
|
||||||
|
|
||||||
for distance in 0..5 { |
|
||||||
let max_size = a_bnodes_by_hash.values().map(Vec::len).max().unwrap_or(0); |
|
||||||
if max_size < 2 { |
|
||||||
break; // We only have small buckets
|
|
||||||
} |
|
||||||
|
|
||||||
a_bnodes_by_hash = split_hash_buckets(a_bnodes_by_hash, a, distance); |
|
||||||
b_bnodes_by_hash = split_hash_buckets(b_bnodes_by_hash, b, distance); |
|
||||||
|
|
||||||
// Hashes should have the same size
|
|
||||||
if a_bnodes_by_hash.len() != b_bnodes_by_hash.len() { |
|
||||||
return false; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
let mut sorted_a_bnodes_by_hash: Vec<_> = a_bnodes_by_hash.into_iter().collect(); |
|
||||||
sorted_a_bnodes_by_hash.sort_by(|(_, l1), (_, l2)| l1.len().cmp(&l2.len())); |
|
||||||
|
|
||||||
build_and_check_containment_from_hashes( |
|
||||||
&mut sorted_a_bnodes_by_hash, |
|
||||||
&b_bnodes_by_hash, |
|
||||||
&mut HashMap::default(), |
|
||||||
&a_bnodes_triples, |
|
||||||
&b_bnodes_triples, |
|
||||||
&[], |
|
||||||
&mut BTreeSet::default(), |
|
||||||
) |
|
||||||
} |
|
||||||
Loading…
Reference in new issue