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

Fix some issues

Browse Source
pull/825/head
Peter Heringer 1 year ago
parent 7af075b1d6
commit a7794bbbbe
4 changed files with 91 additions and 41 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. 66
      lib/src/sparql/eval.rs
  2. 3
      lib/src/storage/binary_encoder.rs
  3. 13
      lib/src/storage/numeric_encoder.rs
  4. 50
      lib/src/storage/storage_generator.rs

66
lib/src/sparql/eval.rs
Unescape View File

@ -1932,8 +1932,8 @@ impl SimpleEvaluator {
EncodedTerm::DecimalLiteral(value) => Some(Double::from(value).into()), EncodedTerm::DecimalLiteral(value) => Some(Double::from(value).into()),
EncodedTerm::BooleanLiteral(value) => Some(Double::from(value).into()), EncodedTerm::BooleanLiteral(value) => Some(Double::from(value).into()),
EncodedTerm::SmallStringLiteral(value) => parse_double_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_double_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_double_str(&dataset.get_str(&value_id).ok()??) parse_double_str(&value)
} }
_ => None, _ => None,
}) })
@ -1948,8 +1948,8 @@ impl SimpleEvaluator {
EncodedTerm::DecimalLiteral(value) => Some(Float::from(value).into()), EncodedTerm::DecimalLiteral(value) => Some(Float::from(value).into()),
EncodedTerm::BooleanLiteral(value) => Some(Float::from(value).into()), EncodedTerm::BooleanLiteral(value) => Some(Float::from(value).into()),
EncodedTerm::SmallStringLiteral(value) => parse_float_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_float_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_float_str(&dataset.get_str(&value_id).ok()??) parse_float_str(&value)
} }
_ => None, _ => None,
}) })
@ -1968,8 +1968,8 @@ impl SimpleEvaluator {
} }
EncodedTerm::BooleanLiteral(value) => Some(Integer::from(value).into()), EncodedTerm::BooleanLiteral(value) => Some(Integer::from(value).into()),
EncodedTerm::SmallStringLiteral(value) => parse_integer_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_integer_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_integer_str(&dataset.get_str(&value_id).ok()??) parse_integer_str(&value)
} }
_ => None, _ => None,
}) })
@ -1988,8 +1988,8 @@ impl SimpleEvaluator {
EncodedTerm::DecimalLiteral(value) => Some(value.into()), EncodedTerm::DecimalLiteral(value) => Some(value.into()),
EncodedTerm::BooleanLiteral(value) => Some(Decimal::from(value).into()), EncodedTerm::BooleanLiteral(value) => Some(Decimal::from(value).into()),
EncodedTerm::SmallStringLiteral(value) => parse_decimal_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_decimal_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_decimal_str(&dataset.get_str(&value_id).ok()??) parse_decimal_str(&value)
} }
_ => None, _ => None,
}) })
@ -2001,8 +2001,8 @@ impl SimpleEvaluator {
EncodedTerm::DateLiteral(value) => Some(value.into()), EncodedTerm::DateLiteral(value) => Some(value.into()),
EncodedTerm::DateTimeLiteral(value) => Some(Date::try_from(value).ok()?.into()), EncodedTerm::DateTimeLiteral(value) => Some(Date::try_from(value).ok()?.into()),
EncodedTerm::SmallStringLiteral(value) => parse_date_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_date_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_date_str(&dataset.get_str(&value_id).ok()??) parse_date_str(&value)
} }
_ => None, _ => None,
}) })
@ -2014,8 +2014,8 @@ impl SimpleEvaluator {
EncodedTerm::TimeLiteral(value) => Some(value.into()), EncodedTerm::TimeLiteral(value) => Some(value.into()),
EncodedTerm::DateTimeLiteral(value) => Some(Time::try_from(value).ok()?.into()), EncodedTerm::DateTimeLiteral(value) => Some(Time::try_from(value).ok()?.into()),
EncodedTerm::SmallStringLiteral(value) => parse_time_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_time_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_time_str(&dataset.get_str(&value_id).ok()??) parse_time_str(&value)
} }
_ => None, _ => None,
}) })
@ -2027,8 +2027,8 @@ impl SimpleEvaluator {
EncodedTerm::DateTimeLiteral(value) => Some(value.into()), EncodedTerm::DateTimeLiteral(value) => Some(value.into()),
EncodedTerm::DateLiteral(value) => Some(DateTime::try_from(value).ok()?.into()), EncodedTerm::DateLiteral(value) => Some(DateTime::try_from(value).ok()?.into()),
EncodedTerm::SmallStringLiteral(value) => parse_date_time_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_date_time_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_date_time_str(&dataset.get_str(&value_id).ok()??) parse_date_time_str(&value)
} }
_ => None, _ => None,
}) })
@ -2045,8 +2045,8 @@ impl SimpleEvaluator {
Some(Duration::from(value).into()) Some(Duration::from(value).into())
} }
EncodedTerm::SmallStringLiteral(value) => parse_duration_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_duration_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_duration_str(&dataset.get_str(&value_id).ok()??) parse_duration_str(&value)
} }
_ => None, _ => None,
}) })
@ -2060,8 +2060,8 @@ impl SimpleEvaluator {
} }
EncodedTerm::YearMonthDurationLiteral(value) => Some(value.into()), EncodedTerm::YearMonthDurationLiteral(value) => Some(value.into()),
EncodedTerm::SmallStringLiteral(value) => parse_year_month_duration_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_year_month_duration_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_year_month_duration_str(&dataset.get_str(&value_id).ok()??) parse_year_month_duration_str(&value)
} }
_ => None, _ => None,
}) })
@ -2075,8 +2075,8 @@ impl SimpleEvaluator {
} }
EncodedTerm::DayTimeDurationLiteral(value) => Some(value.into()), EncodedTerm::DayTimeDurationLiteral(value) => Some(value.into()),
EncodedTerm::SmallStringLiteral(value) => parse_day_time_duration_str(&value), EncodedTerm::SmallStringLiteral(value) => parse_day_time_duration_str(&value),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
parse_day_time_duration_str(&dataset.get_str(&value_id).ok()??) parse_day_time_duration_str(&value)
} }
_ => None, _ => None,
}) })
@ -2150,7 +2150,7 @@ fn to_string_id(dataset: &DatasetView, term: &EncodedTerm) -> Option<SmallString
| EncodedTerm::SmallSmallLangStringLiteral { value, .. } | EncodedTerm::SmallSmallLangStringLiteral { value, .. }
| EncodedTerm::SmallBigLangStringLiteral { value, .. } | EncodedTerm::SmallBigLangStringLiteral { value, .. }
| EncodedTerm::SmallTypedLiteral { value, .. } => Some((*value).into()), | EncodedTerm::SmallTypedLiteral { value, .. } => Some((*value).into()),
EncodedTerm::BigStringLiteral { value_id } EncodedTerm::BigStringLiteral { value_id, .. }
| EncodedTerm::BigSmallLangStringLiteral { value_id, .. } | EncodedTerm::BigSmallLangStringLiteral { value_id, .. }
| EncodedTerm::BigBigLangStringLiteral { value_id, .. } | EncodedTerm::BigBigLangStringLiteral { value_id, .. }
| EncodedTerm::BigTypedLiteral { value_id, .. } => Some((*value_id).into()), | EncodedTerm::BigTypedLiteral { value_id, .. } => Some((*value_id).into()),
@ -2183,7 +2183,7 @@ fn to_string_id(dataset: &DatasetView, term: &EncodedTerm) -> Option<SmallString
fn to_simple_string(dataset: &DatasetView, term: &EncodedTerm) -> Option<String> { fn to_simple_string(dataset: &DatasetView, term: &EncodedTerm) -> Option<String> {
match term { match term {
EncodedTerm::SmallStringLiteral(value) => Some((*value).into()), EncodedTerm::SmallStringLiteral(value) => Some((*value).into()),
EncodedTerm::BigStringLiteral { value_id } => dataset.get_str(value_id).ok()?, EncodedTerm::BigStringLiteral { value_id, value } => Some(value.to_owned()),
_ => None, _ => None,
} }
} }
@ -2191,7 +2191,7 @@ fn to_simple_string(dataset: &DatasetView, term: &EncodedTerm) -> Option<String>
fn to_simple_string_id(term: &EncodedTerm) -> Option<SmallStringOrId> { fn to_simple_string_id(term: &EncodedTerm) -> Option<SmallStringOrId> {
match term { match term {
EncodedTerm::SmallStringLiteral(value) => Some((*value).into()), EncodedTerm::SmallStringLiteral(value) => Some((*value).into()),
EncodedTerm::BigStringLiteral { value_id } => Some((*value_id).into()), EncodedTerm::BigStringLiteral { value_id, .. } => Some((*value_id).into()),
_ => None, _ => None,
} }
} }
@ -2201,8 +2201,8 @@ fn to_string(dataset: &DatasetView, term: &EncodedTerm) -> Option<String> {
EncodedTerm::SmallStringLiteral(value) EncodedTerm::SmallStringLiteral(value)
| EncodedTerm::SmallSmallLangStringLiteral { value, .. } | EncodedTerm::SmallSmallLangStringLiteral { value, .. }
| EncodedTerm::SmallBigLangStringLiteral { value, .. } => Some((*value).into()), | EncodedTerm::SmallBigLangStringLiteral { value, .. } => Some((*value).into()),
EncodedTerm::BigStringLiteral { value_id } EncodedTerm::BigStringLiteral { value_id, value } => Some(value.to_owned()),
| EncodedTerm::BigSmallLangStringLiteral { value_id, .. } EncodedTerm::BigSmallLangStringLiteral { value_id, .. }
| EncodedTerm::BigBigLangStringLiteral { value_id, .. } => { | EncodedTerm::BigBigLangStringLiteral { value_id, .. } => {
dataset.get_str(value_id).ok()? dataset.get_str(value_id).ok()?
} }
@ -2216,8 +2216,8 @@ fn to_string_and_language(
) -> Option<(String, Option<SmallStringOrId>)> { ) -> Option<(String, Option<SmallStringOrId>)> {
match term { match term {
EncodedTerm::SmallStringLiteral(value) => Some(((*value).into(), None)), EncodedTerm::SmallStringLiteral(value) => Some(((*value).into(), None)),
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
Some((dataset.get_str(value_id).ok()??, None)) Some((value.to_owned(), None))
} }
EncodedTerm::SmallSmallLangStringLiteral { value, language } => { EncodedTerm::SmallSmallLangStringLiteral { value, language } => {
Some(((*value).into(), Some((*language).into()))) Some(((*value).into(), Some((*language).into())))
@ -2254,7 +2254,7 @@ fn build_string_literal(dataset: &DatasetView, value: &str) -> EncodedTerm {
fn build_string_literal_from_id(id: SmallStringOrId) -> EncodedTerm { fn build_string_literal_from_id(id: SmallStringOrId) -> EncodedTerm {
match id { match id {
SmallStringOrId::Small(value) => EncodedTerm::SmallStringLiteral(value), SmallStringOrId::Small(value) => EncodedTerm::SmallStringLiteral(value),
SmallStringOrId::Big(value_id) => EncodedTerm::BigStringLiteral { value_id }, SmallStringOrId::Big(value_id) => EncodedTerm::BigStringLiteral { value_id, value: "Why are we here?".to_owned() },
} }
} }
@ -2412,8 +2412,8 @@ fn equals(a: &EncodedTerm, b: &EncodedTerm) -> Option<bool> {
EncodedTerm::SmallTypedLiteral { .. } | EncodedTerm::BigTypedLiteral { .. } => None, EncodedTerm::SmallTypedLiteral { .. } | EncodedTerm::BigTypedLiteral { .. } => None,
_ => Some(false), _ => Some(false),
}, },
EncodedTerm::BigStringLiteral { value_id: a } => match b { EncodedTerm::BigStringLiteral { value_id: a, .. } => match b {
EncodedTerm::BigStringLiteral { value_id: b } => Some(a == b), EncodedTerm::BigStringLiteral { value_id: b, .. } => Some(a == b),
EncodedTerm::SmallTypedLiteral { .. } | EncodedTerm::BigTypedLiteral { .. } => None, EncodedTerm::SmallTypedLiteral { .. } | EncodedTerm::BigTypedLiteral { .. } => None,
_ => Some(false), _ => Some(false),
}, },
@ -2671,12 +2671,12 @@ fn partial_cmp_literals(
match a { match a {
EncodedTerm::SmallStringLiteral(a) => match b { EncodedTerm::SmallStringLiteral(a) => match b {
EncodedTerm::SmallStringLiteral(b) => a.partial_cmp(b), EncodedTerm::SmallStringLiteral(b) => a.partial_cmp(b),
EncodedTerm::BigStringLiteral { value_id: b } => compare_str_str_id(dataset, a, b), EncodedTerm::BigStringLiteral { value_id: b, .. } => compare_str_str_id(dataset, a, b),
_ => None, _ => None,
}, },
EncodedTerm::BigStringLiteral { value_id: a } => match b { EncodedTerm::BigStringLiteral { value_id: a, .. } => match b {
EncodedTerm::SmallStringLiteral(b) => compare_str_id_str(dataset, a, b), EncodedTerm::SmallStringLiteral(b) => compare_str_id_str(dataset, a, b),
EncodedTerm::BigStringLiteral { value_id: b } => compare_str_ids(dataset, a, b), EncodedTerm::BigStringLiteral { value_id: b, .. } => compare_str_ids(dataset, a, b),
_ => None, _ => None,
}, },
EncodedTerm::SmallSmallLangStringLiteral { EncodedTerm::SmallSmallLangStringLiteral {

3
lib/src/storage/binary_encoder.rs
Unescape View File

@ -311,6 +311,7 @@ impl<R: Read> TermReader for R {
self.read_exact(&mut buffer)?; self.read_exact(&mut buffer)?;
Ok(EncodedTerm::BigStringLiteral { Ok(EncodedTerm::BigStringLiteral {
value_id: StrHash::from_be_bytes(buffer), value_id: StrHash::from_be_bytes(buffer),
value: std::str::from_utf8(&buffer).expect("Should be fine to convert").to_owned(),
}) })
} }
TYPE_BOOLEAN_LITERAL_TRUE => Ok(true.into()), TYPE_BOOLEAN_LITERAL_TRUE => Ok(true.into()),
@ -519,7 +520,7 @@ pub fn write_term(sink: &mut Vec<u8>, term: &EncodedTerm) {
sink.push(TYPE_SMALL_STRING_LITERAL); sink.push(TYPE_SMALL_STRING_LITERAL);
sink.extend_from_slice(&value.to_be_bytes()) sink.extend_from_slice(&value.to_be_bytes())
} }
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, .. } => {
sink.push(TYPE_BIG_STRING_LITERAL); sink.push(TYPE_BIG_STRING_LITERAL);
sink.extend_from_slice(&value_id.to_be_bytes()); sink.extend_from_slice(&value_id.to_be_bytes());
} }

13
lib/src/storage/numeric_encoder.rs
Unescape View File

@ -56,6 +56,7 @@ pub enum EncodedTerm {
SmallStringLiteral(SmallString), SmallStringLiteral(SmallString),
BigStringLiteral { BigStringLiteral {
value_id: StrHash, value_id: StrHash,
value: String,
}, },
SmallSmallLangStringLiteral { SmallSmallLangStringLiteral {
value: SmallString, value: SmallString,
@ -125,9 +126,11 @@ impl PartialEq for EncodedTerm {
( (
Self::BigStringLiteral { Self::BigStringLiteral {
value_id: value_id_a, value_id: value_id_a,
value: value_a,
}, },
Self::BigStringLiteral { Self::BigStringLiteral {
value_id: value_id_b, value_id: value_id_b,
value: value_b,
}, },
) => value_id_a == value_id_b, ) => value_id_a == value_id_b,
( (
@ -227,7 +230,7 @@ impl Hash for EncodedTerm {
Self::BigBlankNode { id_id } => id_id.hash(state), Self::BigBlankNode { id_id } => id_id.hash(state),
Self::DefaultGraph => (), Self::DefaultGraph => (),
Self::SmallStringLiteral(value) => value.hash(state), Self::SmallStringLiteral(value) => value.hash(state),
Self::BigStringLiteral { value_id } => value_id.hash(state), Self::BigStringLiteral { value_id, value } => value_id.hash(state),
Self::SmallSmallLangStringLiteral { value, language } => { Self::SmallSmallLangStringLiteral { value, language } => {
value.hash(state); value.hash(state);
language.hash(state); language.hash(state);
@ -552,6 +555,7 @@ impl From<LiteralRef<'_>> for EncodedTerm {
} else { } else {
Self::BigStringLiteral { Self::BigStringLiteral {
value_id: StrHash::new(value), value_id: StrHash::new(value),
value: value.to_owned(),
} }
}) })
} }
@ -741,7 +745,7 @@ pub fn insert_term<F: FnMut(&StrHash, &str) -> Result<(), StorageError>>(
_ => unreachable!("Invalid term encoding {:?} for {}", encoded, term), _ => unreachable!("Invalid term encoding {:?} for {}", encoded, term),
}, },
TermRef::Literal(literal) => match encoded { TermRef::Literal(literal) => match encoded {
EncodedTerm::BigStringLiteral { value_id } EncodedTerm::BigStringLiteral { value_id, .. }
| EncodedTerm::BigSmallLangStringLiteral { value_id, .. } => { | EncodedTerm::BigSmallLangStringLiteral { value_id, .. } => {
insert_str(value_id, literal.value()) insert_str(value_id, literal.value())
} }
@ -962,6 +966,7 @@ pub trait Decoder: StrLookup {
impl<S: StrLookup> Decoder for S { impl<S: StrLookup> Decoder for S {
fn decode_term(&self, encoded: &EncodedTerm) -> Result<Term, StorageError> { fn decode_term(&self, encoded: &EncodedTerm) -> Result<Term, StorageError> {
println!("DECODING: {:?}", encoded);
match encoded { match encoded {
EncodedTerm::DefaultGraph => { EncodedTerm::DefaultGraph => {
Err(CorruptionError::msg("The default graph tag is not a valid term").into()) Err(CorruptionError::msg("The default graph tag is not a valid term").into())
@ -975,8 +980,8 @@ impl<S: StrLookup> Decoder for S {
EncodedTerm::SmallStringLiteral(value) => { EncodedTerm::SmallStringLiteral(value) => {
Ok(Literal::new_simple_literal(*value).into()) Ok(Literal::new_simple_literal(*value).into())
} }
EncodedTerm::BigStringLiteral { value_id } => { EncodedTerm::BigStringLiteral { value_id, value } => {
Ok(Literal::new_simple_literal(get_required_str(self, value_id)?).into()) Ok(Literal::new_simple_literal(value).into())
} }
EncodedTerm::SmallSmallLangStringLiteral { value, language } => { EncodedTerm::SmallSmallLangStringLiteral { value, language } => {
Ok(Literal::new_language_tagged_literal_unchecked(*value, *language).into()) Ok(Literal::new_language_tagged_literal_unchecked(*value, *language).into())

50
lib/src/storage/storage_generator.rs
Unescape View File

@ -31,6 +31,24 @@ impl StorageGenerator {
Self { storage } Self { storage }
} }
fn print_quad(&self, 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(),
EncodedTerm::IntegerLiteral(value) => value.to_string(),
_ => "NOT NAMED".to_owned(),
};
println!("\t- {}\t{}\t{} .", sub, pre, obj);
}
pub fn quads_for_pattern( pub fn quads_for_pattern(
&self, &self,
subject: Option<&EncodedTerm>, subject: Option<&EncodedTerm>,
@ -54,6 +72,9 @@ impl StorageGenerator {
if self.is_vocab(predicate, rdf::TYPE) && object.is_some() { if self.is_vocab(predicate, rdf::TYPE) && object.is_some() {
println!("OF: rdf::type"); println!("OF: rdf::type");
let terms = self.type_triples(subject, predicate, object, graph_name); let terms = self.type_triples(subject, predicate, object, graph_name);
for triple in &terms {
self.print_quad(triple);
}
return ChainedDecodingQuadIterator { return ChainedDecodingQuadIterator {
first: DecodingQuadIterator { first: DecodingQuadIterator {
terms, terms,
@ -64,6 +85,9 @@ impl StorageGenerator {
} else if self.is_node_related(predicate) { } else if self.is_node_related(predicate) {
println!("OF: nodes"); println!("OF: nodes");
let terms = self.nodes(subject, predicate, object, graph_name); let terms = self.nodes(subject, predicate, object, graph_name);
for triple in &terms {
self.print_quad(triple);
}
return ChainedDecodingQuadIterator { return ChainedDecodingQuadIterator {
first: DecodingQuadIterator { first: DecodingQuadIterator {
terms, terms,
@ -74,6 +98,9 @@ impl StorageGenerator {
} else if self.is_step_associated(predicate) { } else if self.is_step_associated(predicate) {
println!("OF: steps"); println!("OF: steps");
let terms = self.steps(subject, predicate, object, graph_name); let terms = self.steps(subject, predicate, object, graph_name);
for triple in &terms {
self.print_quad(triple);
}
return ChainedDecodingQuadIterator { return ChainedDecodingQuadIterator {
first: DecodingQuadIterator { first: DecodingQuadIterator {
terms, terms,
@ -84,6 +111,9 @@ impl StorageGenerator {
} else if self.is_vocab(predicate, rdfs::LABEL) { } else if self.is_vocab(predicate, rdfs::LABEL) {
println!("OF: rdfs::label"); println!("OF: rdfs::label");
let terms = self.paths(subject, predicate, object, graph_name); let terms = self.paths(subject, predicate, object, graph_name);
for triple in &terms {
self.print_quad(triple);
}
return ChainedDecodingQuadIterator { return ChainedDecodingQuadIterator {
first: DecodingQuadIterator { first: DecodingQuadIterator {
terms, terms,
@ -99,6 +129,9 @@ impl StorageGenerator {
let terms_steps = self.steps(subject, predicate, object, graph_name); let terms_steps = self.steps(subject, predicate, object, graph_name);
terms.extend(terms_paths); terms.extend(terms_paths);
terms.extend(terms_steps); terms.extend(terms_steps);
for triple in &terms {
self.print_quad(triple);
}
return ChainedDecodingQuadIterator { return ChainedDecodingQuadIterator {
first: DecodingQuadIterator { first: DecodingQuadIterator {
terms, terms,
@ -128,6 +161,9 @@ impl StorageGenerator {
Vec::new() Vec::new()
} }
}; };
for triple in &terms {
self.print_quad(triple);
}
return ChainedDecodingQuadIterator { return ChainedDecodingQuadIterator {
first: DecodingQuadIterator { first: DecodingQuadIterator {
terms, terms,
@ -338,20 +374,26 @@ impl StorageGenerator {
println!("SF: some subject"); println!("SF: some subject");
match step_type { match step_type {
StepType::Rank(path_name, target_rank) => { StepType::Rank(path_name, target_rank) => {
println!("RANK: {}, {}", path_name, target_rank);
if let Some(id) = self.storage.graph.get_path_id(path_name.as_bytes()) { if let Some(id) = self.storage.graph.get_path_id(path_name.as_bytes()) {
let path_ref = self.storage.graph.get_path_ref(id).unwrap(); let path_ref = self.storage.graph.get_path_ref(id).unwrap();
let step_handle = path_ref.step_at(path_ref.first_step()); let step_handle = path_ref.step_at(path_ref.first_step());
let step_handle = step_handle.unwrap(); let mut step_handle = step_handle.unwrap();
let mut node_handle = step_handle.handle(); let mut node_handle = step_handle.handle();
let mut rank = 1; let mut rank = 1;
let mut position = 1; let mut position = 1;
while path_ref.next_step(step_handle.0).is_some() && rank < target_rank { let steps = self.storage.graph.path_steps(id).expect("Path has steps");
let step_handle = path_ref.next_step(step_handle.0).unwrap(); for _ in steps.skip(1) {
if rank >= target_rank {
break;
}
step_handle = path_ref.next_step(step_handle.0).unwrap();
position += self.storage.graph.node_len(node_handle); position += self.storage.graph.node_len(node_handle);
node_handle = step_handle.handle(); node_handle = step_handle.handle();
rank += 1; rank += 1;
} }
println!("Now handling: {}, {}, {}", rank, position, node_handle.0);
let mut triples = self.step_handle_to_triples( let mut triples = self.step_handle_to_triples(
&path_name, &path_name,
subject, subject,
@ -366,6 +408,7 @@ impl StorageGenerator {
} }
} }
StepType::Position(path_name, position) => { StepType::Position(path_name, position) => {
println!("POSITION: {}, {}", path_name, position);
if let Some(id) = self.storage.graph.get_path_id(path_name.as_bytes()) { if let Some(id) = self.storage.graph.get_path_id(path_name.as_bytes()) {
if let Some(step) = self.storage.graph.path_step_at_base(id, position) { if let Some(step) = self.storage.graph.path_step_at_base(id, position) {
let node_handle = let node_handle =
@ -646,6 +689,7 @@ impl StorageGenerator {
let seq_bytes = self.storage.graph.sequence_vec(handle); let seq_bytes = self.storage.graph.sequence_vec(handle);
let seq = str::from_utf8(&seq_bytes).expect("Node contains sequence"); let seq = str::from_utf8(&seq_bytes).expect("Node contains sequence");
let seq_value = Literal::new_simple_literal(seq); let seq_value = Literal::new_simple_literal(seq);
println!("Decoding1");
if object.is_none() if object.is_none()
|| self.decode_term(object.unwrap()).unwrap() == Term::Literal(seq_value.clone()) || self.decode_term(object.unwrap()).unwrap() == Term::Literal(seq_value.clone())
{ {

Write Preview
Loading…
Cancel
Save