NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Makes Interned aggregated terms not copy

Browse Source 
Ground work for RDF* support
pull/171/head
Tpt 3 years ago
parent 42e4c15c46
commit 820ea62424
2 changed files with 107 additions and 96 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 197
      lib/src/model/dataset.rs
  2. 6
      lib/src/model/interning.rs

197
lib/src/model/dataset.rs
Unescape View File

@ -182,25 +182,25 @@ impl Dataset {
let subject = self let subject = self
.encoded_subject(subject) .encoded_subject(subject)
.unwrap_or_else(InternedSubject::impossible); .unwrap_or_else(InternedSubject::impossible);
self.interned_quads_for_subject(subject) self.interned_quads_for_subject(&subject)
.map(move |q| self.decode_spog(q)) .map(move |q| self.decode_spog(q))
} }
fn interned_quads_for_subject( fn interned_quads_for_subject(
&self, &self,
subject: InternedSubject, subject: &InternedSubject,
) -> impl Iterator< ) -> impl Iterator<
Item = ( Item = (
InternedSubject, &InternedSubject,
InternedNamedNode, &InternedNamedNode,
InternedTerm, &InternedTerm,
InternedGraphName, &InternedGraphName,
), ),
> + '_ { > + '_ {
self.spog self.spog
.range( .range(
&( &(
subject, subject.clone(),
InternedNamedNode::first(), InternedNamedNode::first(),
InternedTerm::first(), InternedTerm::first(),
InternedGraphName::first(), InternedGraphName::first(),
@ -212,7 +212,7 @@ impl Dataset {
InternedGraphName::first(), InternedGraphName::first(),
), ),
) )
.copied() .map(|(s, p, o, g)| (s, p, o, g))
} }
pub fn quads_for_predicate<'a, 'b>( pub fn quads_for_predicate<'a, 'b>(
@ -222,25 +222,25 @@ impl Dataset {
let predicate = self let predicate = self
.encoded_named_node(predicate) .encoded_named_node(predicate)
.unwrap_or_else(InternedNamedNode::impossible); .unwrap_or_else(InternedNamedNode::impossible);
self.interned_quads_for_predicate(predicate) self.interned_quads_for_predicate(&predicate)
.map(move |q| self.decode_spog(q)) .map(move |q| self.decode_spog(q))
} }
fn interned_quads_for_predicate( fn interned_quads_for_predicate(
&self, &self,
predicate: InternedNamedNode, predicate: &InternedNamedNode,
) -> impl Iterator< ) -> impl Iterator<
Item = ( Item = (
InternedSubject, &InternedSubject,
InternedNamedNode, &InternedNamedNode,
InternedTerm, &InternedTerm,
InternedGraphName, &InternedGraphName,
), ),
> + '_ { > + '_ {
self.posg self.posg
.range( .range(
&( &(
predicate, *predicate,
InternedTerm::first(), InternedTerm::first(),
InternedSubject::first(), InternedSubject::first(),
InternedGraphName::first(), InternedGraphName::first(),
@ -252,7 +252,6 @@ impl Dataset {
InternedGraphName::first(), InternedGraphName::first(),
), ),
) )
.copied()
.map(|(p, o, s, g)| (s, p, o, g)) .map(|(p, o, s, g)| (s, p, o, g))
} }
@ -264,25 +263,25 @@ impl Dataset {
.encoded_term(object) .encoded_term(object)
.unwrap_or_else(InternedTerm::impossible); .unwrap_or_else(InternedTerm::impossible);
self.interned_quads_for_object(object) self.interned_quads_for_object(&object)
.map(move |q| self.decode_spog(q)) .map(move |q| self.decode_spog(q))
} }
fn interned_quads_for_object( fn interned_quads_for_object(
&self, &self,
object: InternedTerm, object: &InternedTerm,
) -> impl Iterator< ) -> impl Iterator<
Item = ( Item = (
InternedSubject, &InternedSubject,
InternedNamedNode, &InternedNamedNode,
InternedTerm, &InternedTerm,
InternedGraphName, &InternedGraphName,
), ),
> + '_ { > + '_ {
self.ospg self.ospg
.range( .range(
&( &(
object, object.clone(),
InternedSubject::first(), InternedSubject::first(),
InternedNamedNode::first(), InternedNamedNode::first(),
InternedGraphName::first(), InternedGraphName::first(),
@ -294,25 +293,24 @@ impl Dataset {
InternedGraphName::first(), InternedGraphName::first(),
), ),
) )
.copied()
.map(|(o, s, p, g)| (s, p, o, g)) .map(|(o, s, p, g)| (s, p, o, g))
} }
fn interned_quads_for_graph_name( fn interned_quads_for_graph_name(
&self, &self,
graph_name: InternedGraphName, graph_name: &InternedGraphName,
) -> impl Iterator< ) -> impl Iterator<
Item = ( Item = (
InternedSubject, &InternedSubject,
InternedNamedNode, &InternedNamedNode,
InternedTerm, &InternedTerm,
InternedGraphName, &InternedGraphName,
), ),
> + '_ { > + '_ {
self.gspo self.gspo
.range( .range(
&( &(
graph_name, graph_name.clone(),
InternedSubject::first(), InternedSubject::first(),
InternedNamedNode::first(), InternedNamedNode::first(),
InternedTerm::first(), InternedTerm::first(),
@ -324,7 +322,6 @@ impl Dataset {
InternedTerm::first(), InternedTerm::first(),
), ),
) )
.copied()
.map(|(g, s, p, o)| (s, p, o, g)) .map(|(g, s, p, o)| (s, p, o, g))
} }
@ -363,11 +360,11 @@ impl Dataset {
), ),
) -> bool { ) -> bool {
let (s, p, o, g) = quad; let (s, p, o, g) = quad;
self.gspo.insert((g, s, p, o)); self.gspo.insert((g.clone(), s.clone(), p, o.clone()));
self.gpos.insert((g, p, o, s)); self.gpos.insert((g.clone(), p, o.clone(), s.clone()));
self.gosp.insert((g, o, s, p)); self.gosp.insert((g.clone(), o.clone(), s.clone(), p));
self.spog.insert((s, p, o, g)); self.spog.insert((s.clone(), p, o.clone(), g.clone()));
self.posg.insert((p, o, s, g)); self.posg.insert((p, o.clone(), s.clone(), g.clone()));
self.ospg.insert((o, s, p, g)) self.ospg.insert((o, s, p, g))
} }
@ -390,11 +387,11 @@ impl Dataset {
), ),
) -> bool { ) -> bool {
let (s, p, o, g) = quad; let (s, p, o, g) = quad;
self.gspo.remove(&(g, s, p, o)); self.gspo.remove(&(g.clone(), s.clone(), p, o.clone()));
self.gpos.remove(&(g, p, o, s)); self.gpos.remove(&(g.clone(), p, o.clone(), s.clone()));
self.gosp.remove(&(g, o, s, p)); self.gosp.remove(&(g.clone(), o.clone(), s.clone(), p));
self.spog.remove(&(s, p, o, g)); self.spog.remove(&(s.clone(), p, o.clone(), g.clone()));
self.posg.remove(&(p, o, s, g)); self.posg.remove(&(p, o.clone(), s.clone(), g.clone()));
self.ospg.remove(&(o, s, p, g)) self.ospg.remove(&(o, s, p, g))
} }
@ -541,10 +538,10 @@ impl Dataset {
fn decode_spog( fn decode_spog(
&self, &self,
quad: ( quad: (
InternedSubject, &InternedSubject,
InternedNamedNode, &InternedNamedNode,
InternedTerm, &InternedTerm,
InternedGraphName, &InternedGraphName,
), ),
) -> QuadRef<'_> { ) -> QuadRef<'_> {
QuadRef { QuadRef {
@ -636,7 +633,7 @@ impl Dataset {
let mut new_hashes = HashMap::new(); let mut new_hashes = HashMap::new();
for (bnode, old_hash) in &hashes { for (bnode, old_hash) in &hashes {
for (_, p, o, g) in for (_, p, o, g) in
self.interned_quads_for_subject(InternedSubject::BlankNode(*bnode)) self.interned_quads_for_subject(&InternedSubject::BlankNode(*bnode))
{ {
to_hash.push(( to_hash.push((
self.hash_named_node(p), self.hash_named_node(p),
@ -645,7 +642,7 @@ impl Dataset {
0, 0,
)); ));
} }
for (s, p, _, g) in self.interned_quads_for_object(InternedTerm::BlankNode(*bnode)) for (s, p, _, g) in self.interned_quads_for_object(&InternedTerm::BlankNode(*bnode))
{ {
to_hash.push(( to_hash.push((
self.hash_subject(s, &hashes), self.hash_subject(s, &hashes),
@ -655,7 +652,7 @@ impl Dataset {
)); ));
} }
for (s, p, o, _) in for (s, p, o, _) in
self.interned_quads_for_graph_name(InternedGraphName::BlankNode(*bnode)) self.interned_quads_for_graph_name(&InternedGraphName::BlankNode(*bnode))
{ {
to_hash.push(( to_hash.push((
self.hash_subject(s, &hashes), self.hash_subject(s, &hashes),
@ -681,25 +678,25 @@ impl Dataset {
} }
} }
fn hash_named_node(&self, node: InternedNamedNode) -> u64 { fn hash_named_node(&self, node: &InternedNamedNode) -> u64 {
self.hash_tuple(node.decode_from(&self.interner)) self.hash_tuple(node.decode_from(&self.interner))
} }
fn hash_subject( fn hash_subject(
&self, &self,
node: InternedSubject, node: &InternedSubject,
bnodes_hash: &HashMap<InternedBlankNode, u64>, bnodes_hash: &HashMap<InternedBlankNode, u64>,
) -> u64 { ) -> u64 {
if let InternedSubject::BlankNode(bnode) = node { if let InternedSubject::BlankNode(bnode) = node {
*bnodes_hash.get(&bnode).unwrap() *bnodes_hash.get(bnode).unwrap()
} else { } else {
self.hash_tuple(node.decode_from(&self.interner)) self.hash_tuple(node.decode_from(&self.interner))
} }
} }
fn hash_term(&self, term: InternedTerm, bnodes_hash: &HashMap<InternedBlankNode, u64>) -> u64 { fn hash_term(&self, term: &InternedTerm, bnodes_hash: &HashMap<InternedBlankNode, u64>) -> u64 {
if let InternedTerm::BlankNode(bnode) = term { if let InternedTerm::BlankNode(bnode) = term {
*bnodes_hash.get(&bnode).unwrap() *bnodes_hash.get(bnode).unwrap()
} else { } else {
self.hash_tuple(term.decode_from(&self.interner)) self.hash_tuple(term.decode_from(&self.interner))
} }
@ -707,11 +704,11 @@ impl Dataset {
fn hash_graph_name( fn hash_graph_name(
&self, &self,
graph_name: InternedGraphName, graph_name: &InternedGraphName,
bnodes_hash: &HashMap<InternedBlankNode, u64>, bnodes_hash: &HashMap<InternedBlankNode, u64>,
) -> u64 { ) -> u64 {
if let InternedGraphName::BlankNode(bnode) = graph_name { if let InternedGraphName::BlankNode(bnode) = graph_name {
*bnodes_hash.get(&bnode).unwrap() *bnodes_hash.get(bnode).unwrap()
} else { } else {
self.hash_tuple(graph_name.decode_from(&self.interner)) self.hash_tuple(graph_name.decode_from(&self.interner))
} }
@ -771,24 +768,24 @@ impl Dataset {
InternedTerm, InternedTerm,
InternedGraphName, InternedGraphName,
)> { )> {
let old_quads: Vec<_> = self.spog.iter().copied().collect(); let old_quads: Vec<_> = self.spog.iter().cloned().collect();
let mut quads: Vec<_> = old_quads let mut quads: Vec<_> = old_quads
.into_iter() .into_iter()
.map(|(s, p, o, g)| { .map(|(s, p, o, g)| {
( (
if let InternedSubject::BlankNode(bnode) = s { if let InternedSubject::BlankNode(bnode) = s {
InternedSubject::BlankNode(self.map_bnode(bnode, hashes)) InternedSubject::BlankNode(self.map_bnode(&bnode, hashes))
} else { } else {
s s
}, },
p, p,
if let InternedTerm::BlankNode(bnode) = o { if let InternedTerm::BlankNode(bnode) = o {
InternedTerm::BlankNode(self.map_bnode(bnode, hashes)) InternedTerm::BlankNode(self.map_bnode(&bnode, hashes))
} else { } else {
o o
}, },
if let InternedGraphName::BlankNode(bnode) = g { if let InternedGraphName::BlankNode(bnode) = g {
InternedGraphName::BlankNode(self.map_bnode(bnode, hashes)) InternedGraphName::BlankNode(self.map_bnode(&bnode, hashes))
} else { } else {
g g
}, },
@ -801,11 +798,11 @@ impl Dataset {
fn map_bnode( fn map_bnode(
&mut self, &mut self,
old_bnode: InternedBlankNode, old_bnode: &InternedBlankNode,
hashes: &HashMap<InternedBlankNode, u64>, hashes: &HashMap<InternedBlankNode, u64>,
) -> InternedBlankNode { ) -> InternedBlankNode {
InternedBlankNode::encoded_into( InternedBlankNode::encoded_into(
BlankNode::new_from_unique_id(*hashes.get(&old_bnode).unwrap()).as_ref(), BlankNode::new_from_unique_id(*hashes.get(old_bnode).unwrap()).as_ref(),
&mut self.interner, &mut self.interner,
) )
} }
@ -904,7 +901,7 @@ impl<'a> GraphView<'a> {
pub fn iter(&self) -> GraphViewIter<'a> { pub fn iter(&self) -> GraphViewIter<'a> {
let iter = self.dataset.gspo.range( let iter = self.dataset.gspo.range(
&( &(
self.graph_name, self.graph_name.clone(),
InternedSubject::first(), InternedSubject::first(),
InternedNamedNode::first(), InternedNamedNode::first(),
InternedTerm::first(), InternedTerm::first(),
@ -939,13 +936,13 @@ impl<'a> GraphView<'a> {
.gspo .gspo
.range( .range(
&( &(
self.graph_name, self.graph_name.clone(),
subject, subject.clone(),
InternedNamedNode::first(), InternedNamedNode::first(),
InternedTerm::first(), InternedTerm::first(),
) )
..&( ..&(
self.graph_name, self.graph_name.clone(),
subject.next(), subject.next(),
InternedNamedNode::first(), InternedNamedNode::first(),
InternedTerm::first(), InternedTerm::first(),
@ -979,9 +976,14 @@ impl<'a> GraphView<'a> {
self.dataset self.dataset
.gspo .gspo
.range( .range(
&(self.graph_name, subject, predicate, InternedTerm::first()) &(
self.graph_name.clone(),
subject.clone(),
predicate,
InternedTerm::first(),
)
..&( ..&(
self.graph_name, self.graph_name.clone(),
subject, subject,
predicate.next(), predicate.next(),
InternedTerm::first(), InternedTerm::first(),
@ -1021,9 +1023,14 @@ impl<'a> GraphView<'a> {
self.dataset self.dataset
.gosp .gosp
.range( .range(
&(self.graph_name, object, subject, InternedNamedNode::first()) &(
self.graph_name.clone(),
object.clone(),
subject.clone(),
InternedNamedNode::first(),
)
..&( ..&(
self.graph_name, self.graph_name.clone(),
object, object,
subject.next(), subject.next(),
InternedNamedNode::first(), InternedNamedNode::first(),
@ -1049,22 +1056,19 @@ impl<'a> GraphView<'a> {
.gpos .gpos
.range( .range(
&( &(
self.graph_name, self.graph_name.clone(),
predicate, predicate,
InternedTerm::first(), InternedTerm::first(),
InternedSubject::first(), InternedSubject::first(),
) )
..&( ..&(
self.graph_name, self.graph_name.clone(),
predicate.next(), predicate.next(),
InternedTerm::first(), InternedTerm::first(),
InternedSubject::first(), InternedSubject::first(),
), ),
) )
.map(move |q| { .map(move |(_, p, o, s)| ds.decode_spo((s, p, o)))
let (_, p, o, s) = q;
ds.decode_spo((s, p, o))
})
} }
pub fn subjects_for_predicate_object<'b>( pub fn subjects_for_predicate_object<'b>(
@ -1089,9 +1093,14 @@ impl<'a> GraphView<'a> {
self.dataset self.dataset
.gpos .gpos
.range( .range(
&(self.graph_name, predicate, object, InternedSubject::first()) &(
self.graph_name.clone(),
predicate,
object.clone(),
InternedSubject::first(),
)
..&( ..&(
self.graph_name, self.graph_name.clone(),
predicate, predicate,
object.next(), object.next(),
InternedSubject::first(), InternedSubject::first(),
@ -1125,28 +1134,27 @@ impl<'a> GraphView<'a> {
.gosp .gosp
.range( .range(
&( &(
self.graph_name, self.graph_name.clone(),
object, object.clone(),
InternedSubject::first(), InternedSubject::first(),
InternedNamedNode::first(), InternedNamedNode::first(),
) )
..&( ..&(
self.graph_name, self.graph_name.clone(),
object.next(), object.next(),
InternedSubject::first(), InternedSubject::first(),
InternedNamedNode::first(), InternedNamedNode::first(),
), ),
) )
.map(move |q| { .map(move |(_, o, s, p)| ds.decode_spo((s, p, o)))
let (_, o, s, p) = q;
ds.decode_spo((s, p, o))
})
} }
/// Checks if the graph contains the given triple /// Checks if the graph contains the given triple
pub fn contains<'b>(&self, triple: impl Into<TripleRef<'b>>) -> bool { pub fn contains<'b>(&self, triple: impl Into<TripleRef<'b>>) -> bool {
if let Some((s, p, o)) = self.encoded_triple(triple.into()) { if let Some((s, p, o)) = self.encoded_triple(triple.into()) {
self.dataset.gspo.contains(&(self.graph_name, s, p, o)) self.dataset
.gspo
.contains(&(self.graph_name.clone(), s, p, o))
} else { } else {
false false
} }
@ -1260,20 +1268,22 @@ impl<'a> GraphViewMut<'a> {
fn read(&self) -> GraphView<'_> { fn read(&self) -> GraphView<'_> {
GraphView { GraphView {
dataset: self.dataset, dataset: self.dataset,
graph_name: self.graph_name, graph_name: self.graph_name.clone(),
} }
} }
/// Adds a triple to the graph /// Adds a triple to the graph
pub fn insert<'b>(&mut self, triple: impl Into<TripleRef<'b>>) -> bool { pub fn insert<'b>(&mut self, triple: impl Into<TripleRef<'b>>) -> bool {
let (s, p, o) = self.encode_triple(triple.into()); let (s, p, o) = self.encode_triple(triple.into());
self.dataset.insert_encoded((s, p, o, self.graph_name)) self.dataset
.insert_encoded((s, p, o, self.graph_name.clone()))
} }
/// Removes a concrete triple from the graph /// Removes a concrete triple from the graph
pub fn remove<'b>(&mut self, triple: impl Into<TripleRef<'b>>) -> bool { pub fn remove<'b>(&mut self, triple: impl Into<TripleRef<'b>>) -> bool {
if let Some((s, p, o)) = self.read().encoded_triple(triple.into()) { if let Some((s, p, o)) = self.read().encoded_triple(triple.into()) {
self.dataset.remove_encoded((s, p, o, self.graph_name)) self.dataset
.remove_encoded((s, p, o, self.graph_name.clone()))
} else { } else {
false false
} }
@ -1502,7 +1512,9 @@ impl<'a> Iterator for Iter<'a> {
type Item = QuadRef<'a>; type Item = QuadRef<'a>;
fn next(&mut self) -> Option<QuadRef<'a>> { fn next(&mut self) -> Option<QuadRef<'a>> {
self.inner.next().map(|q| self.dataset.decode_spog(*q)) self.inner
.next()
.map(|(s, p, o, g)| self.dataset.decode_spog((s, p, o, g)))
} }
} }
@ -1524,9 +1536,8 @@ impl<'a> Iterator for GraphViewIter<'a> {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
fn next(&mut self) -> Option<TripleRef<'a>> { fn next(&mut self) -> Option<TripleRef<'a>> {
self.inner.next().map(|q| { self.inner
let (_, s, p, o) = q; .next()
self.dataset.decode_spo((s, p, o)) .map(|(_, s, p, o)| self.dataset.decode_spo((s, p, o)))
})
} }
} }

6
lib/src/model/interning.rs
Unescape View File

@ -165,7 +165,7 @@ impl InternedLiteral {
} }
} }
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy, Hash)] #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)]
pub enum InternedSubject { pub enum InternedSubject {
NamedNode(InternedNamedNode), NamedNode(InternedNamedNode),
BlankNode(InternedBlankNode), BlankNode(InternedBlankNode),
@ -217,7 +217,7 @@ impl InternedSubject {
} }
} }
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy, Hash)] #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)]
pub enum InternedGraphName { pub enum InternedGraphName {
DefaultGraph, DefaultGraph,
NamedNode(InternedNamedNode), NamedNode(InternedNamedNode),
@ -274,7 +274,7 @@ impl InternedGraphName {
} }
} }
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy, Hash)] #[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)]
pub enum InternedTerm { pub enum InternedTerm {
NamedNode(InternedNamedNode), NamedNode(InternedNamedNode),
BlankNode(InternedBlankNode), BlankNode(InternedBlankNode),

Write Preview
Loading…
Cancel
Save