Peter Heringer
1 year ago
parent
edc1c0d91d
commit
8ca20cbfe1
@ -0,0 +1,768 @@ |
|||||||
|
#![allow(clippy::same_name_method)] |
||||||
|
use crate::model::vocab::rdf; |
||||||
|
use crate::model::{NamedNodeRef, Term}; |
||||||
|
use crate::storage::DecodingQuadIterator; |
||||||
|
use crate::storage::binary_encoder::QuadEncoding; |
||||||
|
pub use crate::storage::error::{CorruptionError, LoaderError, SerializerError, StorageError}; |
||||||
|
use crate::storage::numeric_encoder::Decoder; |
||||||
|
#[cfg(not(target_family = "wasm"))] |
||||||
|
use crate::storage::numeric_encoder::{EncodedQuad, EncodedTerm}; |
||||||
|
use crate::storage::vg_vocab::{faldo, vg}; |
||||||
|
use super::numeric_encoder::{StrLookup, StrHash}; |
||||||
|
use super::{Storage, ChainedDecodingQuadIterator}; |
||||||
|
use gfa::gfa::Orientation; |
||||||
|
use handlegraph::handle::{Direction, Handle}; |
||||||
|
use handlegraph::pathhandlegraph::{ |
||||||
|
path::PathStep, GraphPathsRef, IntoPathIds, PathBase, |
||||||
|
}; |
||||||
|
use handlegraph::pathhandlegraph::{GraphPathNames, PathId}; |
||||||
|
use handlegraph::{ |
||||||
|
handlegraph::IntoHandles, handlegraph::IntoNeighbors, |
||||||
|
handlegraph::IntoSequences, |
||||||
|
}; |
||||||
|
use oxrdf::{Literal, NamedNode}; |
||||||
|
use std::str; |
||||||
|
|
||||||
|
pub struct StorageGenerator { |
||||||
|
storage: Storage, |
||||||
|
} |
||||||
|
|
||||||
|
impl StorageGenerator { |
||||||
|
pub fn new(storage: Storage) -> Self { |
||||||
|
Self { |
||||||
|
storage |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
pub fn quads_for_pattern( |
||||||
|
&self, |
||||||
|
subject: Option<&EncodedTerm>, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
object: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
) -> ChainedDecodingQuadIterator { |
||||||
|
println!("Receiving quads_for_pattern"); |
||||||
|
// let sub = subject.map(|s| self.decode_term(s).ok()).flatten();
|
||||||
|
// let pre = predicate.map(|s| self.decode_term(s).ok()).flatten();
|
||||||
|
// let obj = object.map(|s| self.decode_term(s).ok()).flatten();
|
||||||
|
if subject.is_some_and(|s| s.is_blank_node()) || object.is_some_and(|o| o.is_blank_node()) { |
||||||
|
println!("Containing blank nodes"); |
||||||
|
return ChainedDecodingQuadIterator { |
||||||
|
first: DecodingQuadIterator { |
||||||
|
terms: Vec::new(), |
||||||
|
encoding: QuadEncoding::Spog, |
||||||
|
}, |
||||||
|
second: None, |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
if self.is_vocab(predicate, rdf::TYPE) && object.is_some() { |
||||||
|
//TODO
|
||||||
|
println!("Containing type predicate"); |
||||||
|
return ChainedDecodingQuadIterator { |
||||||
|
first: DecodingQuadIterator { |
||||||
|
terms: Vec::new(), |
||||||
|
encoding: QuadEncoding::Spog, |
||||||
|
}, |
||||||
|
second: None, |
||||||
|
}; |
||||||
|
} else if self.is_node_related(predicate) { |
||||||
|
println!("Containing node-related predicate"); |
||||||
|
let terms = self.nodes(subject, predicate, object, graph_name); |
||||||
|
return ChainedDecodingQuadIterator { |
||||||
|
first: DecodingQuadIterator { |
||||||
|
terms, |
||||||
|
encoding: QuadEncoding::Spog, |
||||||
|
}, |
||||||
|
second: None, |
||||||
|
}; |
||||||
|
} else if self.is_step_associated(predicate) { |
||||||
|
println!("Containing node-related predicate"); |
||||||
|
let terms = self.steps(subject, predicate, object, graph_name); |
||||||
|
return ChainedDecodingQuadIterator { |
||||||
|
first: DecodingQuadIterator { |
||||||
|
terms, |
||||||
|
encoding: QuadEncoding::Spog, |
||||||
|
}, |
||||||
|
second: None, |
||||||
|
}; |
||||||
|
} |
||||||
|
return ChainedDecodingQuadIterator { |
||||||
|
first: DecodingQuadIterator { |
||||||
|
terms: Vec::new(), |
||||||
|
encoding: QuadEncoding::Spog, |
||||||
|
}, |
||||||
|
second: None, |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
fn nodes( |
||||||
|
&self, |
||||||
|
subject: Option<&EncodedTerm>, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
object: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
match subject { |
||||||
|
Some(sub) => { |
||||||
|
println!("Real subject: {}", sub.get_named_node_value().unwrap()); |
||||||
|
let is_node_iri = self.is_node_iri_in_graph(sub); |
||||||
|
if self.is_vocab(predicate, rdf::TYPE) |
||||||
|
&& self.is_vocab(object, vg::NODE) |
||||||
|
&& is_node_iri |
||||||
|
{ |
||||||
|
println!("First"); |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
sub.to_owned(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::NODE.into(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} else if predicate.is_none() && self.is_vocab(object, vg::NODE) && is_node_iri { |
||||||
|
println!("Second"); |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
sub.to_owned(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::NODE.into(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} else if predicate.is_none() && is_node_iri { |
||||||
|
println!("Third"); |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
sub.to_owned(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::NODE.into(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
|
||||||
|
if is_node_iri { |
||||||
|
println!("Fourth"); |
||||||
|
let mut triples = self.handle_to_triples(sub, predicate, object, graph_name); |
||||||
|
let mut edge_triples = |
||||||
|
self.handle_to_edge_triples(sub, predicate, object, graph_name); |
||||||
|
println!("Normal: {:?}", triples); |
||||||
|
println!("Edge: {:?}", edge_triples); |
||||||
|
results.append(&mut triples); |
||||||
|
results.append(&mut edge_triples); |
||||||
|
} |
||||||
|
} |
||||||
|
None => { |
||||||
|
println!("None subject"); |
||||||
|
for handle in self.storage.graph.handles() { |
||||||
|
println!("{:?}", handle); |
||||||
|
let term = self |
||||||
|
.handle_to_namednode(handle) |
||||||
|
.expect("Can turn handle to namednode"); |
||||||
|
let mut recursion_results = |
||||||
|
self.nodes(Some(&term), predicate, object, graph_name); |
||||||
|
println!("{:?}", recursion_results); |
||||||
|
println!("---------------------------"); |
||||||
|
results.append(&mut recursion_results); |
||||||
|
} |
||||||
|
// println!("{:?}", results);
|
||||||
|
} |
||||||
|
} |
||||||
|
println!("Nodes successfully done!"); |
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn steps( |
||||||
|
&self, |
||||||
|
subject: Option<&EncodedTerm>, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
object: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
if subject.is_none() { |
||||||
|
for path_id in self.storage.graph.path_ids() { |
||||||
|
if let Some(path_ref) = self.storage.graph.get_path_ref(path_id) { |
||||||
|
let path_name = self.get_path_name(path_id); |
||||||
|
let mut rank = Some(1); |
||||||
|
let mut position = Some(1); |
||||||
|
let step_handle = path_ref.step_at(path_ref.first_step()); |
||||||
|
if step_handle.is_none() { |
||||||
|
continue; |
||||||
|
} |
||||||
|
let step_handle = step_handle.unwrap(); |
||||||
|
let node_handle = step_handle.handle(); |
||||||
|
let mut triples = self.step_handle_to_triples( |
||||||
|
&path_name.unwrap(), |
||||||
|
subject, |
||||||
|
predicate, |
||||||
|
object, |
||||||
|
graph_name, |
||||||
|
node_handle, |
||||||
|
rank, |
||||||
|
position, |
||||||
|
); |
||||||
|
results.append(&mut triples); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn step_handle_to_triples( |
||||||
|
&self, |
||||||
|
path_name: &str, |
||||||
|
subject: Option<&EncodedTerm>, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
object: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
node_handle: Handle, |
||||||
|
rank: Option<usize>, |
||||||
|
position: Option<usize>, |
||||||
|
) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
let step_iri = self.step_to_namednode(path_name, rank).unwrap(); |
||||||
|
let node_len = self.storage.graph.node_len(node_handle); |
||||||
|
let path_iri = self.path_to_namednode(path_name).unwrap(); |
||||||
|
let rank = rank.unwrap() as i64; |
||||||
|
let position = position.unwrap() as i64; |
||||||
|
|
||||||
|
if subject.is_none() || step_iri == subject.unwrap().to_owned() { |
||||||
|
if self.is_vocab(predicate, rdf::TYPE) || predicate.is_none() { |
||||||
|
if object.is_none() || self.is_vocab(object, vg::STEP) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::STEP.into(), |
||||||
|
graph_name.to_owned() |
||||||
|
)); |
||||||
|
} |
||||||
|
if object.is_none() || self.is_vocab(object, faldo::REGION) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
faldo::REGION.into(), |
||||||
|
graph_name.to_owned() |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
let node_iri = self.handle_to_namednode(node_handle).unwrap(); |
||||||
|
if (self.is_vocab(predicate, vg::NODE_PRED) || predicate.is_none() && !node_handle.is_reverse()) && (object.is_none() || node_iri == object.unwrap().to_owned()) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
vg::NODE_PRED.into(), |
||||||
|
node_iri.clone(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
|
||||||
|
if (self.is_vocab(predicate, vg::REVERSE_OF_NODE) || predicate.is_none() && node_handle.is_reverse()) && (object.is_none() || node_iri == object.unwrap().to_owned()) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
vg::REVERSE_OF_NODE.into(), |
||||||
|
node_iri, |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
if self.is_vocab(predicate, vg::RANK) || predicate.is_none() { |
||||||
|
let rank_literal = EncodedTerm::IntegerLiteral(rank.into()); |
||||||
|
if object.is_none() || object.unwrap().to_owned() == rank_literal { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
vg::RANK.into(), |
||||||
|
rank_literal, |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if self.is_vocab(predicate, vg::POSITION) || predicate.is_none() { |
||||||
|
let position_literal = EncodedTerm::IntegerLiteral(position.into()); |
||||||
|
if object.is_none() || object.unwrap().to_owned() == position_literal { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
vg::RANK.into(), |
||||||
|
position_literal, |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if self.is_vocab(predicate, vg::PATH_PRED) || predicate.is_none() { |
||||||
|
if object.is_none() || path_iri == object.unwrap().to_owned() { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
vg::PATH_PRED.into(), |
||||||
|
path_iri.clone(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if predicate.is_none() || self.is_vocab(predicate, faldo::BEGIN) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri.clone(), |
||||||
|
faldo::BEGIN.into(), |
||||||
|
self.get_faldo_border_namednode(position as usize, path_name).unwrap(), // FIX
|
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
if predicate.is_none() || self.is_vocab(predicate, faldo::END) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
step_iri, |
||||||
|
faldo::END.into(), |
||||||
|
self.get_faldo_border_namednode(position as usize + node_len, path_name).unwrap(), // FIX
|
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
|
||||||
|
if subject.is_none() { |
||||||
|
let begin_pos = position as usize; |
||||||
|
let begin = self.get_faldo_border_namednode(begin_pos, path_name); |
||||||
|
let mut begins = self.faldo_for_step(begin_pos, path_iri.clone(), begin, predicate, object, graph_name); |
||||||
|
results.append(&mut begins); |
||||||
|
let end_pos = position as usize + node_len; |
||||||
|
let end = self.get_faldo_border_namednode(end_pos, path_name); |
||||||
|
let mut ends = self.faldo_for_step(end_pos, path_iri, end, predicate, object, graph_name); |
||||||
|
results.append(&mut ends); |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
// TODO reverse parsing
|
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn get_faldo_border_namednode(&self, position: usize, path_name: &str) -> Option<EncodedTerm> { |
||||||
|
let text = format!("{}/path/{}/position/{}", self.storage.base, path_name, position); |
||||||
|
let named_node = NamedNode::new(text).unwrap(); |
||||||
|
Some(named_node.as_ref().into()) |
||||||
|
} |
||||||
|
|
||||||
|
fn faldo_for_step(&self, position: usize, path_iri: EncodedTerm, subject: Option<EncodedTerm>, predicate: Option<&EncodedTerm>, object: Option<&EncodedTerm>, graph_name: &EncodedTerm) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
let ep = EncodedTerm::IntegerLiteral((position as i64).into()); |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, faldo::POSITION_PRED)) && (object.is_none() || object.unwrap().to_owned() == ep) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
subject.clone().unwrap(), |
||||||
|
faldo::POSITION_PRED.into(), |
||||||
|
ep, |
||||||
|
graph_name.to_owned() |
||||||
|
)); |
||||||
|
} |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, rdf::TYPE)) && (object.is_none() || self.is_vocab(object, faldo::EXACT_POSITION)) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
subject.clone().unwrap(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
faldo::EXACT_POSITION.into(), |
||||||
|
graph_name.to_owned() |
||||||
|
)); |
||||||
|
} |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, rdf::TYPE)) && (object.is_none() || self.is_vocab(object, faldo::POSITION)) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
subject.clone().unwrap(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
faldo::POSITION.into(), |
||||||
|
graph_name.to_owned() |
||||||
|
)); |
||||||
|
} |
||||||
|
if predicate.is_none() || self.is_vocab(predicate, faldo::REFERENCE) && (object.is_none() || object.unwrap().to_owned() == path_iri){ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
subject.unwrap(), |
||||||
|
faldo::REFERENCE.into(), |
||||||
|
path_iri, |
||||||
|
graph_name.to_owned() |
||||||
|
)); |
||||||
|
} |
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn handle_to_triples( |
||||||
|
&self, |
||||||
|
subject: &EncodedTerm, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
object: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
if self.is_vocab(predicate, rdf::VALUE) || predicate.is_none() { |
||||||
|
let handle = Handle::new( |
||||||
|
self.get_node_id(subject).expect("Subject is node"), |
||||||
|
Orientation::Forward, |
||||||
|
); |
||||||
|
let seq_bytes = self.storage.graph.sequence_vec(handle); |
||||||
|
let seq = str::from_utf8(&seq_bytes).expect("Node contains sequence"); |
||||||
|
let seq_value = Literal::new_simple_literal(seq); |
||||||
|
println!("Decoding 338"); |
||||||
|
if object.is_none() |
||||||
|
|| self.decode_term(object.unwrap()).unwrap() == Term::Literal(seq_value.clone()) |
||||||
|
{ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
subject.to_owned(), |
||||||
|
rdf::VALUE.into(), |
||||||
|
seq_value.as_ref().into(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
println!("Done decoding 338"); |
||||||
|
} else if (self.is_vocab(predicate, rdf::TYPE) || predicate.is_none()) |
||||||
|
&& (object.is_none() || self.is_vocab(object, vg::NODE)) |
||||||
|
{ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
subject.to_owned(), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::NODE.into(), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn handle_to_edge_triples( |
||||||
|
&self, |
||||||
|
subject: &EncodedTerm, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
object: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
print!("Subject: {:?}, ", subject); |
||||||
|
if predicate.is_none() || self.is_node_related(predicate) { |
||||||
|
let handle = Handle::new( |
||||||
|
self.get_node_id(subject).expect("Subject has node id"), |
||||||
|
Orientation::Forward, |
||||||
|
); |
||||||
|
println!("Handle: {:?}", handle); |
||||||
|
let neighbors = self.storage.graph.neighbors(handle, Direction::Right); |
||||||
|
for neighbor in neighbors { |
||||||
|
if object.is_none() |
||||||
|
|| self |
||||||
|
.get_node_id(object.unwrap()) |
||||||
|
.expect("Object has node id") |
||||||
|
== neighbor.unpack_number() |
||||||
|
{ |
||||||
|
let mut edge_triples = |
||||||
|
self.generate_edge_triples(handle, neighbor, predicate, graph_name); |
||||||
|
results.append(&mut edge_triples); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn generate_edge_triples( |
||||||
|
&self, |
||||||
|
subject: Handle, |
||||||
|
object: Handle, |
||||||
|
predicate: Option<&EncodedTerm>, |
||||||
|
graph_name: &EncodedTerm, |
||||||
|
) -> Vec<EncodedQuad> { |
||||||
|
let mut results = Vec::new(); |
||||||
|
let node_is_reverse = subject.is_reverse(); |
||||||
|
let other_is_reverse = object.is_reverse(); |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, vg::LINKS_FORWARD_TO_FORWARD)) |
||||||
|
&& !node_is_reverse |
||||||
|
&& !other_is_reverse |
||||||
|
{ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
self.handle_to_namednode(subject).expect("Subject is fine"), |
||||||
|
vg::LINKS_FORWARD_TO_FORWARD.into(), |
||||||
|
self.handle_to_namednode(object).expect("Object is fine"), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, vg::LINKS_FORWARD_TO_REVERSE)) |
||||||
|
&& !node_is_reverse |
||||||
|
&& other_is_reverse |
||||||
|
{ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
self.handle_to_namednode(subject).expect("Subject is fine"), |
||||||
|
vg::LINKS_FORWARD_TO_REVERSE.into(), |
||||||
|
self.handle_to_namednode(object).expect("Object is fine"), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, vg::LINKS_REVERSE_TO_FORWARD)) |
||||||
|
&& node_is_reverse |
||||||
|
&& !other_is_reverse |
||||||
|
{ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
self.handle_to_namednode(subject).expect("Subject is fine"), |
||||||
|
vg::LINKS_REVERSE_TO_FORWARD.into(), |
||||||
|
self.handle_to_namednode(object).expect("Object is fine"), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
if (predicate.is_none() || self.is_vocab(predicate, vg::LINKS_REVERSE_TO_REVERSE)) |
||||||
|
&& node_is_reverse |
||||||
|
&& other_is_reverse |
||||||
|
{ |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
self.handle_to_namednode(subject).expect("Subject is fine"), |
||||||
|
vg::LINKS_REVERSE_TO_REVERSE.into(), |
||||||
|
self.handle_to_namednode(object).expect("Object is fine"), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
if predicate.is_none() || self.is_vocab(predicate, vg::LINKS) { |
||||||
|
results.push(EncodedQuad::new( |
||||||
|
self.handle_to_namednode(subject).expect("Subject is fine"), |
||||||
|
vg::LINKS.into(), |
||||||
|
self.handle_to_namednode(object).expect("Object is fine"), |
||||||
|
graph_name.to_owned(), |
||||||
|
)); |
||||||
|
} |
||||||
|
results |
||||||
|
} |
||||||
|
|
||||||
|
fn handle_to_namednode(&self, handle: Handle) -> Option<EncodedTerm> { |
||||||
|
let id = handle.unpack_number(); |
||||||
|
let text = format!("{}/node/{}", self.storage.base, id); |
||||||
|
let named_node = NamedNode::new(text).unwrap(); |
||||||
|
Some(named_node.as_ref().into()) |
||||||
|
} |
||||||
|
|
||||||
|
fn step_to_namednode(&self, path_name: &str, rank: Option<usize>) -> Option<EncodedTerm> { |
||||||
|
let text = format!( |
||||||
|
"{}/path/{}/step/{}", |
||||||
|
self.storage.base, |
||||||
|
path_name, |
||||||
|
rank? |
||||||
|
); |
||||||
|
let named_node = NamedNode::new(text).ok()?; |
||||||
|
Some(named_node.as_ref().into()) |
||||||
|
} |
||||||
|
|
||||||
|
fn path_to_namednode(&self, path_name: &str) -> Option<EncodedTerm> { |
||||||
|
let text = format!("{}/path/{}", self.storage.base, path_name); |
||||||
|
let named_node = NamedNode::new(text).ok()?; |
||||||
|
Some(named_node.as_ref().into()) |
||||||
|
} |
||||||
|
|
||||||
|
fn get_path_name(&self, path_id: PathId) -> Option<String> { |
||||||
|
if let Some(path_name_iter) = self.storage.graph.get_path_name(path_id) { |
||||||
|
let path_name: Vec<u8> = path_name_iter.collect(); |
||||||
|
let path_name = std::str::from_utf8(&path_name).ok()?; |
||||||
|
Some(path_name.to_owned()) |
||||||
|
} else { |
||||||
|
None |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
fn is_node_related(&self, predicate: Option<&EncodedTerm>) -> bool { |
||||||
|
let predicates = [ |
||||||
|
vg::LINKS, |
||||||
|
vg::LINKS_FORWARD_TO_FORWARD, |
||||||
|
vg::LINKS_FORWARD_TO_REVERSE, |
||||||
|
vg::LINKS_REVERSE_TO_FORWARD, |
||||||
|
vg::LINKS_REVERSE_TO_REVERSE, |
||||||
|
]; |
||||||
|
if predicate.is_none() { |
||||||
|
return false; |
||||||
|
} |
||||||
|
predicates |
||||||
|
.into_iter() |
||||||
|
.map(|x| self.is_vocab(predicate, x)) |
||||||
|
.reduce(|acc, x| acc || x) |
||||||
|
.unwrap() |
||||||
|
} |
||||||
|
|
||||||
|
fn is_step_associated(&self, predicate: Option<&EncodedTerm>) -> bool { |
||||||
|
let predicates = [ |
||||||
|
vg::RANK, |
||||||
|
vg::POSITION, |
||||||
|
vg::PATH_PRED, |
||||||
|
vg::NODE_PRED, |
||||||
|
vg::REVERSE_OF_NODE, |
||||||
|
faldo::BEGIN, |
||||||
|
faldo::END, |
||||||
|
faldo::REFERENCE, |
||||||
|
faldo::POSITION_PRED, |
||||||
|
]; |
||||||
|
if predicate.is_none() { |
||||||
|
return false; |
||||||
|
} |
||||||
|
predicates |
||||||
|
.into_iter() |
||||||
|
.map(|x| self.is_vocab(predicate, x)) |
||||||
|
.reduce(|acc, x| acc || x) |
||||||
|
.unwrap() |
||||||
|
} |
||||||
|
|
||||||
|
fn is_vocab(&self, term: Option<&EncodedTerm>, vocab: NamedNodeRef) -> bool { |
||||||
|
if term.is_none() { |
||||||
|
return false; |
||||||
|
} |
||||||
|
let term = term.unwrap(); |
||||||
|
if !term.is_named_node() { |
||||||
|
return false; |
||||||
|
} |
||||||
|
let named_node = term.get_named_node_value().expect("Is named node"); |
||||||
|
named_node == vocab.as_str() |
||||||
|
} |
||||||
|
|
||||||
|
fn is_node_iri_in_graph(&self, term: &EncodedTerm) -> bool { |
||||||
|
match self.get_node_id(term) { |
||||||
|
Some(id) => self.storage.graph.has_node(id), |
||||||
|
None => false, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
fn get_node_id(&self, term: &EncodedTerm) -> Option<u64> { |
||||||
|
match term.is_named_node() { |
||||||
|
true => { |
||||||
|
let text = term |
||||||
|
.get_named_node_value() |
||||||
|
.expect("Encoded NamedNode has to have value") |
||||||
|
.to_owned(); |
||||||
|
|
||||||
|
// Remove trailing '>'
|
||||||
|
println!("Text: {}", text); |
||||||
|
// text.pop();
|
||||||
|
|
||||||
|
let mut parts_iter = text.rsplit("/"); |
||||||
|
let last = parts_iter.next(); |
||||||
|
let pre_last = parts_iter.next(); |
||||||
|
match last.is_some() |
||||||
|
&& pre_last.is_some() |
||||||
|
&& pre_last.expect("Option is some") == "node" |
||||||
|
{ |
||||||
|
true => last.expect("Option is some").parse::<u64>().ok(), |
||||||
|
false => None, |
||||||
|
} |
||||||
|
} |
||||||
|
false => None, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#[cfg(not(target_family = "wasm"))] |
||||||
|
pub fn get_str(&self, _key: &StrHash) -> Result<Option<String>, StorageError> { |
||||||
|
Ok(None) |
||||||
|
} |
||||||
|
|
||||||
|
#[cfg(not(target_family = "wasm"))] |
||||||
|
pub fn contains_str(&self, _key: &StrHash) -> Result<bool, StorageError> { |
||||||
|
Ok(true) |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
impl StrLookup for StorageGenerator { |
||||||
|
fn get_str(&self, key: &StrHash) -> Result<Option<String>, StorageError> { |
||||||
|
self.get_str(key) |
||||||
|
} |
||||||
|
|
||||||
|
fn contains_str(&self, key: &StrHash) -> Result<bool, StorageError> { |
||||||
|
self.contains_str(key) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
#[cfg(test)] |
||||||
|
mod tests { |
||||||
|
use std::{path::Path, str::FromStr}; |
||||||
|
|
||||||
|
|
||||||
|
use crate::storage::small_string::SmallString; |
||||||
|
|
||||||
|
// Note this useful idiom: importing names from outer (for mod tests) scope.
|
||||||
|
use super::*; |
||||||
|
const BASE: &'static str = "https://example.org"; |
||||||
|
|
||||||
|
fn get_generator(gfa: &str) -> StorageGenerator { |
||||||
|
let storage = Storage::from_str(gfa).unwrap(); |
||||||
|
StorageGenerator::new(storage) |
||||||
|
} |
||||||
|
|
||||||
|
fn get_odgi_test_file_generator(file_name: &str) -> StorageGenerator { |
||||||
|
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join(file_name); |
||||||
|
println!("{}", path.to_str().unwrap()); |
||||||
|
let storage = Storage::open(&path).unwrap(); |
||||||
|
StorageGenerator::new(storage) |
||||||
|
} |
||||||
|
|
||||||
|
fn print_quad(quad: &EncodedQuad) { |
||||||
|
let sub = match &quad.subject { |
||||||
|
EncodedTerm::NamedNode { iri_id: _, value } => value.to_owned(), |
||||||
|
_ => "NOT NAMED".to_owned() |
||||||
|
}; |
||||||
|
let pre = match &quad.predicate { |
||||||
|
EncodedTerm::NamedNode { iri_id: _, value } => value.to_owned(), |
||||||
|
_ => "NOT NAMED".to_owned() |
||||||
|
}; |
||||||
|
let obj = match &quad.object { |
||||||
|
EncodedTerm::NamedNode { iri_id: _, value } => value.to_owned(), |
||||||
|
EncodedTerm::SmallStringLiteral(value) => format!("\"{}\"", value).to_string(), |
||||||
|
_ => "NOT NAMED".to_owned() |
||||||
|
}; |
||||||
|
println!("{}\t{}\t{} .", sub, pre, obj); |
||||||
|
} |
||||||
|
|
||||||
|
fn get_node(id: i64) -> EncodedTerm { |
||||||
|
let text = format!("{}/node/{}", BASE, id); |
||||||
|
let named_node = NamedNode::new(text).unwrap(); |
||||||
|
named_node.as_ref().into() |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn test_single_node() { |
||||||
|
let gen = get_odgi_test_file_generator("t_red.gfa"); |
||||||
|
let node_triple = gen.nodes(None, None, None, &EncodedTerm::DefaultGraph); |
||||||
|
let node_id_quad = EncodedQuad::new( |
||||||
|
get_node(1), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::NODE.into(), |
||||||
|
EncodedTerm::DefaultGraph, |
||||||
|
); |
||||||
|
let sequence_quad = EncodedQuad::new( |
||||||
|
get_node(1), |
||||||
|
rdf::VALUE.into(), |
||||||
|
EncodedTerm::SmallStringLiteral(SmallString::from_str("CAAATAAG").unwrap()), |
||||||
|
EncodedTerm::DefaultGraph, |
||||||
|
); |
||||||
|
assert_eq!(node_triple.len(), 2); |
||||||
|
assert!(node_triple.contains(&node_id_quad)); |
||||||
|
assert!(node_triple.contains(&sequence_quad)); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
// FIX: Currently triple gets generated twice
|
||||||
|
fn test_single_node_non_generic() { |
||||||
|
let gen = get_odgi_test_file_generator("t_red.gfa"); |
||||||
|
let node_1 = get_node(1); |
||||||
|
let node_triple = gen.nodes(Some(&node_1), Some(&rdf::TYPE.into()), Some(&vg::NODE.into()), &EncodedTerm::DefaultGraph); |
||||||
|
let node_id_quad = EncodedQuad::new( |
||||||
|
get_node(1), |
||||||
|
rdf::TYPE.into(), |
||||||
|
vg::NODE.into(), |
||||||
|
EncodedTerm::DefaultGraph, |
||||||
|
); |
||||||
|
for tripe in &node_triple { |
||||||
|
print_quad(tripe); |
||||||
|
} |
||||||
|
assert_eq!(node_triple.len(), 1); |
||||||
|
assert!(node_triple.contains(&node_id_quad)); |
||||||
|
} |
||||||
|
|
||||||
|
#[test] |
||||||
|
fn test_double_node() { |
||||||
|
// Reminder: fails with "old" version of rs-handlegraph (use git-master)
|
||||||
|
let gen = get_odgi_test_file_generator("t_double.gfa"); |
||||||
|
let node_triple = gen.nodes(None, None, None, &EncodedTerm::DefaultGraph); |
||||||
|
let links_quad = EncodedQuad::new( |
||||||
|
get_node(1), |
||||||
|
vg::LINKS.into(), |
||||||
|
get_node(2), |
||||||
|
EncodedTerm::DefaultGraph, |
||||||
|
); |
||||||
|
let links_f2f_quad = EncodedQuad::new( |
||||||
|
get_node(1), |
||||||
|
vg::LINKS_FORWARD_TO_FORWARD.into(), |
||||||
|
get_node(2), |
||||||
|
EncodedTerm::DefaultGraph, |
||||||
|
); |
||||||
|
for tripe in &node_triple { |
||||||
|
print_quad(tripe); |
||||||
|
} |
||||||
|
assert_eq!(node_triple.len(), 6); |
||||||
|
assert!(node_triple.contains(&links_quad)); |
||||||
|
assert!(node_triple.contains(&links_f2f_quad)); |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue