Thomas
1 year ago
committed by
Thomas Tanon
parent
c31ba0e823
commit
8e770fbb5d
File diff suppressed because it is too large
Load Diff
@ -1,896 +0,0 @@ |
||||
use crate::model::{BlankNode, Literal, NamedNode, Term, Triple}; |
||||
use crate::sparql::Variable; |
||||
use crate::storage::numeric_encoder::EncodedTerm; |
||||
use regex::Regex; |
||||
use spargebra::algebra::GraphPattern; |
||||
use spargebra::term::GroundTerm; |
||||
use std::collections::BTreeSet; |
||||
use std::fmt; |
||||
use std::rc::Rc; |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum PlanNode { |
||||
StaticBindings { |
||||
encoded_tuples: Vec<EncodedTuple>, |
||||
variables: Vec<PlanVariable>, |
||||
plain_bindings: Vec<Vec<Option<GroundTerm>>>, |
||||
}, |
||||
Service { |
||||
service_name: PatternValue, |
||||
variables: Rc<[Variable]>, |
||||
child: Rc<Self>, |
||||
graph_pattern: Rc<GraphPattern>, |
||||
silent: bool, |
||||
}, |
||||
QuadPattern { |
||||
subject: PatternValue, |
||||
predicate: PatternValue, |
||||
object: PatternValue, |
||||
graph_name: PatternValue, |
||||
}, |
||||
PathPattern { |
||||
subject: PatternValue, |
||||
path: Rc<PlanPropertyPath>, |
||||
object: PatternValue, |
||||
graph_name: PatternValue, |
||||
}, |
||||
/// Streams left and materializes right join
|
||||
HashJoin { |
||||
probe_child: Rc<Self>, |
||||
build_child: Rc<Self>, |
||||
keys: Vec<PlanVariable>, |
||||
}, |
||||
/// Right nested in left loop
|
||||
ForLoopJoin { |
||||
left: Rc<Self>, |
||||
right: Rc<Self>, |
||||
}, |
||||
/// Streams left and materializes right anti join
|
||||
AntiJoin { |
||||
left: Rc<Self>, |
||||
right: Rc<Self>, |
||||
keys: Vec<PlanVariable>, |
||||
}, |
||||
Filter { |
||||
child: Rc<Self>, |
||||
expression: Box<PlanExpression>, |
||||
}, |
||||
Union { |
||||
children: Vec<Rc<Self>>, |
||||
}, |
||||
/// hash left join
|
||||
HashLeftJoin { |
||||
left: Rc<Self>, |
||||
right: Rc<Self>, |
||||
expression: Box<PlanExpression>, |
||||
keys: Vec<PlanVariable>, |
||||
}, |
||||
/// right nested in left loop
|
||||
ForLoopLeftJoin { |
||||
left: Rc<Self>, |
||||
right: Rc<Self>, |
||||
}, |
||||
Extend { |
||||
child: Rc<Self>, |
||||
variable: PlanVariable, |
||||
expression: Box<PlanExpression>, |
||||
}, |
||||
Sort { |
||||
child: Rc<Self>, |
||||
by: Vec<Comparator>, |
||||
}, |
||||
HashDeduplicate { |
||||
child: Rc<Self>, |
||||
}, |
||||
/// Removes duplicated consecutive elements
|
||||
Reduced { |
||||
child: Rc<Self>, |
||||
}, |
||||
Skip { |
||||
child: Rc<Self>, |
||||
count: usize, |
||||
}, |
||||
Limit { |
||||
child: Rc<Self>, |
||||
count: usize, |
||||
}, |
||||
Project { |
||||
child: Rc<Self>, |
||||
mapping: Rc<[(PlanVariable, PlanVariable)]>, // pairs of (variable key in child, variable key in output)
|
||||
}, |
||||
Aggregate { |
||||
// By definition the group by key are the range 0..key_mapping.len()
|
||||
child: Rc<Self>, |
||||
key_variables: Rc<[PlanVariable]>, |
||||
aggregates: Rc<[(PlanAggregation, PlanVariable)]>, |
||||
}, |
||||
} |
||||
|
||||
impl PlanNode { |
||||
/// Returns variables that might be bound in the result set
|
||||
pub fn used_variables(&self) -> BTreeSet<usize> { |
||||
let mut set = BTreeSet::default(); |
||||
self.lookup_used_variables(&mut |v| { |
||||
set.insert(v); |
||||
}); |
||||
set |
||||
} |
||||
|
||||
pub fn lookup_used_variables(&self, callback: &mut impl FnMut(usize)) { |
||||
match self { |
||||
Self::StaticBindings { encoded_tuples, .. } => { |
||||
for tuple in encoded_tuples { |
||||
for (key, value) in tuple.iter().enumerate() { |
||||
if value.is_some() { |
||||
callback(key); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
Self::QuadPattern { |
||||
subject, |
||||
predicate, |
||||
object, |
||||
graph_name, |
||||
} => { |
||||
subject.lookup_variables(callback); |
||||
predicate.lookup_variables(callback); |
||||
object.lookup_variables(callback); |
||||
graph_name.lookup_variables(callback); |
||||
} |
||||
Self::PathPattern { |
||||
subject, |
||||
object, |
||||
graph_name, |
||||
.. |
||||
} => { |
||||
subject.lookup_variables(callback); |
||||
object.lookup_variables(callback); |
||||
graph_name.lookup_variables(callback); |
||||
} |
||||
Self::Filter { child, expression } => { |
||||
expression.lookup_used_variables(callback); |
||||
child.lookup_used_variables(callback); |
||||
} |
||||
Self::Union { children } => { |
||||
for child in children { |
||||
child.lookup_used_variables(callback); |
||||
} |
||||
} |
||||
Self::HashJoin { |
||||
probe_child: left, |
||||
build_child: right, |
||||
.. |
||||
} |
||||
| Self::ForLoopJoin { left, right, .. } |
||||
| Self::AntiJoin { left, right, .. } |
||||
| Self::ForLoopLeftJoin { left, right, .. } => { |
||||
left.lookup_used_variables(callback); |
||||
right.lookup_used_variables(callback); |
||||
} |
||||
Self::HashLeftJoin { |
||||
left, |
||||
right, |
||||
expression, |
||||
.. |
||||
} => { |
||||
left.lookup_used_variables(callback); |
||||
right.lookup_used_variables(callback); |
||||
expression.lookup_used_variables(callback); |
||||
} |
||||
Self::Extend { |
||||
child, |
||||
variable, |
||||
expression, |
||||
} => { |
||||
callback(variable.encoded); |
||||
expression.lookup_used_variables(callback); |
||||
child.lookup_used_variables(callback); |
||||
} |
||||
Self::Sort { child, .. } |
||||
| Self::HashDeduplicate { child } |
||||
| Self::Reduced { child } |
||||
| Self::Skip { child, .. } |
||||
| Self::Limit { child, .. } => child.lookup_used_variables(callback), |
||||
Self::Service { |
||||
child, |
||||
service_name, |
||||
.. |
||||
} => { |
||||
service_name.lookup_variables(callback); |
||||
child.lookup_used_variables(callback); |
||||
} |
||||
Self::Project { mapping, child } => { |
||||
let child_bound = child.used_variables(); |
||||
for (child_i, output_i) in mapping.iter() { |
||||
if child_bound.contains(&child_i.encoded) { |
||||
callback(output_i.encoded); |
||||
} |
||||
} |
||||
} |
||||
Self::Aggregate { |
||||
key_variables, |
||||
aggregates, |
||||
.. |
||||
} => { |
||||
for var in key_variables.iter() { |
||||
callback(var.encoded); |
||||
} |
||||
for (_, var) in aggregates.iter() { |
||||
callback(var.encoded); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub struct PlanTerm<T> { |
||||
pub encoded: EncodedTerm, |
||||
pub plain: T, |
||||
} |
||||
|
||||
impl<T: fmt::Display> fmt::Display for PlanTerm<T> { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
write!(f, "{}", self.plain) |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum PatternValue { |
||||
Constant(PlanTerm<PatternValueConstant>), |
||||
Variable(PlanVariable), |
||||
TriplePattern(Box<TriplePatternValue>), |
||||
} |
||||
|
||||
impl PatternValue { |
||||
pub fn lookup_variables(&self, callback: &mut impl FnMut(usize)) { |
||||
if let Self::Variable(v) = self { |
||||
callback(v.encoded) |
||||
} else if let Self::TriplePattern(p) = self { |
||||
p.subject.lookup_variables(callback); |
||||
p.predicate.lookup_variables(callback); |
||||
p.object.lookup_variables(callback); |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl fmt::Display for PatternValue { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match self { |
||||
Self::Constant(c) => write!(f, "{c}"), |
||||
Self::Variable(v) => write!(f, "{v}"), |
||||
Self::TriplePattern(p) => write!(f, "{p}"), |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum PatternValueConstant { |
||||
NamedNode(NamedNode), |
||||
Literal(Literal), |
||||
Triple(Box<Triple>), |
||||
DefaultGraph, |
||||
} |
||||
|
||||
impl fmt::Display for PatternValueConstant { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match self { |
||||
Self::NamedNode(n) => write!(f, "{n}"), |
||||
Self::Literal(l) => write!(f, "{l}"), |
||||
Self::Triple(t) => write!(f, "<< {t} >>"), |
||||
Self::DefaultGraph => f.write_str("DEFAULT"), |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub struct TriplePatternValue { |
||||
pub subject: PatternValue, |
||||
pub predicate: PatternValue, |
||||
pub object: PatternValue, |
||||
} |
||||
|
||||
impl fmt::Display for TriplePatternValue { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
write!(f, "{} {} {}", self.subject, self.predicate, self.object) |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub struct PlanVariable<P = Variable> { |
||||
pub encoded: usize, |
||||
pub plain: P, |
||||
} |
||||
|
||||
impl<P: fmt::Display> fmt::Display for PlanVariable<P> { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
write!(f, "{}", self.plain) |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum PlanExpression { |
||||
NamedNode(PlanTerm<NamedNode>), |
||||
Literal(PlanTerm<Literal>), |
||||
Variable(PlanVariable), |
||||
Exists(Rc<PlanNode>), |
||||
Or(Vec<Self>), |
||||
And(Vec<Self>), |
||||
Equal(Box<Self>, Box<Self>), |
||||
Greater(Box<Self>, Box<Self>), |
||||
GreaterOrEqual(Box<Self>, Box<Self>), |
||||
Less(Box<Self>, Box<Self>), |
||||
LessOrEqual(Box<Self>, Box<Self>), |
||||
Add(Box<Self>, Box<Self>), |
||||
Subtract(Box<Self>, Box<Self>), |
||||
Multiply(Box<Self>, Box<Self>), |
||||
Divide(Box<Self>, Box<Self>), |
||||
UnaryPlus(Box<Self>), |
||||
UnaryMinus(Box<Self>), |
||||
Not(Box<Self>), |
||||
Str(Box<Self>), |
||||
Lang(Box<Self>), |
||||
LangMatches(Box<Self>, Box<Self>), |
||||
Datatype(Box<Self>), |
||||
Bound(PlanVariable), |
||||
Iri(Box<Self>), |
||||
BNode(Option<Box<Self>>), |
||||
Rand, |
||||
Abs(Box<Self>), |
||||
Ceil(Box<Self>), |
||||
Floor(Box<Self>), |
||||
Round(Box<Self>), |
||||
Concat(Vec<Self>), |
||||
SubStr(Box<Self>, Box<Self>, Option<Box<Self>>), |
||||
StrLen(Box<Self>), |
||||
StaticReplace(Box<Self>, Regex, Box<Self>), |
||||
DynamicReplace(Box<Self>, Box<Self>, Box<Self>, Option<Box<Self>>), |
||||
UCase(Box<Self>), |
||||
LCase(Box<Self>), |
||||
EncodeForUri(Box<Self>), |
||||
Contains(Box<Self>, Box<Self>), |
||||
StrStarts(Box<Self>, Box<Self>), |
||||
StrEnds(Box<Self>, Box<Self>), |
||||
StrBefore(Box<Self>, Box<Self>), |
||||
StrAfter(Box<Self>, Box<Self>), |
||||
Year(Box<Self>), |
||||
Month(Box<Self>), |
||||
Day(Box<Self>), |
||||
Hours(Box<Self>), |
||||
Minutes(Box<Self>), |
||||
Seconds(Box<Self>), |
||||
Timezone(Box<Self>), |
||||
Tz(Box<Self>), |
||||
Now, |
||||
Uuid, |
||||
StrUuid, |
||||
Md5(Box<Self>), |
||||
Sha1(Box<Self>), |
||||
Sha256(Box<Self>), |
||||
Sha384(Box<Self>), |
||||
Sha512(Box<Self>), |
||||
Coalesce(Vec<Self>), |
||||
If(Box<Self>, Box<Self>, Box<Self>), |
||||
StrLang(Box<Self>, Box<Self>), |
||||
StrDt(Box<Self>, Box<Self>), |
||||
SameTerm(Box<Self>, Box<Self>), |
||||
IsIri(Box<Self>), |
||||
IsBlank(Box<Self>), |
||||
IsLiteral(Box<Self>), |
||||
IsNumeric(Box<Self>), |
||||
StaticRegex(Box<Self>, Regex), |
||||
DynamicRegex(Box<Self>, Box<Self>, Option<Box<Self>>), |
||||
Triple(Box<Self>, Box<Self>, Box<Self>), |
||||
Subject(Box<Self>), |
||||
Predicate(Box<Self>), |
||||
Object(Box<Self>), |
||||
IsTriple(Box<Self>), |
||||
Adjust(Box<Self>, Box<Self>), |
||||
BooleanCast(Box<Self>), |
||||
DoubleCast(Box<Self>), |
||||
FloatCast(Box<Self>), |
||||
DecimalCast(Box<Self>), |
||||
IntegerCast(Box<Self>), |
||||
DateCast(Box<Self>), |
||||
TimeCast(Box<Self>), |
||||
DateTimeCast(Box<Self>), |
||||
DurationCast(Box<Self>), |
||||
YearMonthDurationCast(Box<Self>), |
||||
DayTimeDurationCast(Box<Self>), |
||||
StringCast(Box<Self>), |
||||
CustomFunction(NamedNode, Vec<Self>), |
||||
} |
||||
|
||||
impl PlanExpression { |
||||
pub fn lookup_used_variables(&self, callback: &mut impl FnMut(usize)) { |
||||
match self { |
||||
Self::Variable(v) | Self::Bound(v) => { |
||||
callback(v.encoded); |
||||
} |
||||
Self::NamedNode(_) |
||||
| Self::Literal(_) |
||||
| Self::Rand |
||||
| Self::Now |
||||
| Self::Uuid |
||||
| Self::StrUuid |
||||
| Self::BNode(None) => (), |
||||
Self::UnaryPlus(e) |
||||
| Self::UnaryMinus(e) |
||||
| Self::Not(e) |
||||
| Self::BNode(Some(e)) |
||||
| Self::Str(e) |
||||
| Self::Lang(e) |
||||
| Self::Datatype(e) |
||||
| Self::Iri(e) |
||||
| Self::Abs(e) |
||||
| Self::Ceil(e) |
||||
| Self::Floor(e) |
||||
| Self::Round(e) |
||||
| Self::UCase(e) |
||||
| Self::LCase(e) |
||||
| Self::StrLen(e) |
||||
| Self::EncodeForUri(e) |
||||
| Self::StaticRegex(e, _) |
||||
| Self::Year(e) |
||||
| Self::Month(e) |
||||
| Self::Day(e) |
||||
| Self::Hours(e) |
||||
| Self::Minutes(e) |
||||
| Self::Seconds(e) |
||||
| Self::Timezone(e) |
||||
| Self::Tz(e) |
||||
| Self::Md5(e) |
||||
| Self::Sha1(e) |
||||
| Self::Sha256(e) |
||||
| Self::Sha384(e) |
||||
| Self::Sha512(e) |
||||
| Self::IsIri(e) |
||||
| Self::IsBlank(e) |
||||
| Self::IsLiteral(e) |
||||
| Self::IsNumeric(e) |
||||
| Self::IsTriple(e) |
||||
| Self::Subject(e) |
||||
| Self::Predicate(e) |
||||
| Self::Object(e) |
||||
| Self::BooleanCast(e) |
||||
| Self::DoubleCast(e) |
||||
| Self::FloatCast(e) |
||||
| Self::DecimalCast(e) |
||||
| Self::IntegerCast(e) |
||||
| Self::DateCast(e) |
||||
| Self::TimeCast(e) |
||||
| Self::DateTimeCast(e) |
||||
| Self::DurationCast(e) |
||||
| Self::YearMonthDurationCast(e) |
||||
| Self::DayTimeDurationCast(e) |
||||
| Self::StringCast(e) => e.lookup_used_variables(callback), |
||||
Self::Equal(a, b) |
||||
| Self::Greater(a, b) |
||||
| Self::GreaterOrEqual(a, b) |
||||
| Self::Less(a, b) |
||||
| Self::LessOrEqual(a, b) |
||||
| Self::Add(a, b) |
||||
| Self::Subtract(a, b) |
||||
| Self::Multiply(a, b) |
||||
| Self::Divide(a, b) |
||||
| Self::LangMatches(a, b) |
||||
| Self::Contains(a, b) |
||||
| Self::StaticReplace(a, _, b) |
||||
| Self::StrStarts(a, b) |
||||
| Self::StrEnds(a, b) |
||||
| Self::StrBefore(a, b) |
||||
| Self::StrAfter(a, b) |
||||
| Self::StrLang(a, b) |
||||
| Self::StrDt(a, b) |
||||
| Self::SameTerm(a, b) |
||||
| Self::SubStr(a, b, None) |
||||
| Self::DynamicRegex(a, b, None) |
||||
| Self::Adjust(a, b) => { |
||||
a.lookup_used_variables(callback); |
||||
b.lookup_used_variables(callback); |
||||
} |
||||
Self::If(a, b, c) |
||||
| Self::SubStr(a, b, Some(c)) |
||||
| Self::DynamicRegex(a, b, Some(c)) |
||||
| Self::DynamicReplace(a, b, c, None) |
||||
| Self::Triple(a, b, c) => { |
||||
a.lookup_used_variables(callback); |
||||
b.lookup_used_variables(callback); |
||||
c.lookup_used_variables(callback); |
||||
} |
||||
Self::DynamicReplace(a, b, c, Some(d)) => { |
||||
a.lookup_used_variables(callback); |
||||
b.lookup_used_variables(callback); |
||||
c.lookup_used_variables(callback); |
||||
d.lookup_used_variables(callback); |
||||
} |
||||
Self::Or(es) |
||||
| Self::And(es) |
||||
| Self::Concat(es) |
||||
| Self::Coalesce(es) |
||||
| Self::CustomFunction(_, es) => { |
||||
for e in es { |
||||
e.lookup_used_variables(callback); |
||||
} |
||||
} |
||||
Self::Exists(e) => { |
||||
e.lookup_used_variables(callback); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl fmt::Display for PlanExpression { |
||||
#[allow(clippy::many_single_char_names)] |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match self { |
||||
Self::Variable(v) => { |
||||
write!(f, "{v}") |
||||
} |
||||
Self::Bound(v) => { |
||||
write!(f, "Bound({v})") |
||||
} |
||||
Self::NamedNode(n) => write!(f, "{n}"), |
||||
Self::Literal(l) => write!(f, "{l}"), |
||||
Self::Rand => write!(f, "Rand()"), |
||||
Self::Now => write!(f, "Now()"), |
||||
Self::Uuid => write!(f, "Uuid()"), |
||||
Self::StrUuid => write!(f, "StrUuid()"), |
||||
Self::UnaryPlus(e) => write!(f, "UnaryPlus({e})"), |
||||
Self::UnaryMinus(e) => write!(f, "UnaryMinus({e})"), |
||||
Self::Not(e) => write!(f, "Not({e})"), |
||||
Self::BNode(e) => { |
||||
if let Some(e) = e { |
||||
write!(f, "BNode({e})") |
||||
} else { |
||||
write!(f, "BNode()") |
||||
} |
||||
} |
||||
Self::Str(e) => write!(f, "Str({e})"), |
||||
Self::Lang(e) => write!(f, "Lang({e})"), |
||||
Self::Datatype(e) => write!(f, "Datatype({e})"), |
||||
Self::Iri(e) => write!(f, "Iri({e})"), |
||||
Self::Abs(e) => write!(f, "Abs({e})"), |
||||
Self::Ceil(e) => write!(f, "Ceil({e})"), |
||||
Self::Floor(e) => write!(f, "Floor({e})"), |
||||
Self::Round(e) => write!(f, "Round({e})"), |
||||
Self::UCase(e) => write!(f, "UCase({e})"), |
||||
Self::LCase(e) => write!(f, "LCase({e})"), |
||||
Self::StrLen(e) => write!(f, "StrLen({e})"), |
||||
Self::EncodeForUri(e) => write!(f, "EncodeForUri({e})"), |
||||
Self::StaticRegex(e, r) => write!(f, "StaticRegex({e}, {r})"), |
||||
Self::Year(e) => write!(f, "Year({e})"), |
||||
Self::Month(e) => write!(f, "Month({e})"), |
||||
Self::Day(e) => write!(f, "Day({e})"), |
||||
Self::Hours(e) => write!(f, "Hours({e})"), |
||||
Self::Minutes(e) => write!(f, "Minutes({e})"), |
||||
Self::Seconds(e) => write!(f, "Seconds({e})"), |
||||
Self::Timezone(e) => write!(f, "Timezone({e})"), |
||||
Self::Tz(e) => write!(f, "Tz({e})"), |
||||
Self::Md5(e) => write!(f, "Md5({e})"), |
||||
Self::Sha1(e) => write!(f, "Sha1({e})"), |
||||
Self::Sha256(e) => write!(f, "Sha256({e})"), |
||||
Self::Sha384(e) => write!(f, "Sha384({e})"), |
||||
Self::Sha512(e) => write!(f, "Sha512({e})"), |
||||
Self::IsIri(e) => write!(f, "IsIri({e})"), |
||||
Self::IsBlank(e) => write!(f, "IsBlank({e})"), |
||||
Self::IsLiteral(e) => write!(f, "IsLiteral({e})"), |
||||
Self::IsNumeric(e) => write!(f, "IsNumeric({e})"), |
||||
Self::IsTriple(e) => write!(f, "IsTriple({e})"), |
||||
Self::Subject(e) => write!(f, "Subject({e})"), |
||||
Self::Predicate(e) => write!(f, "Predicate({e})"), |
||||
Self::Object(e) => write!(f, "Object({e})"), |
||||
Self::BooleanCast(e) => write!(f, "BooleanCast({e})"), |
||||
Self::DoubleCast(e) => write!(f, "DoubleCast({e})"), |
||||
Self::FloatCast(e) => write!(f, "FloatCast({e})"), |
||||
Self::DecimalCast(e) => write!(f, "DecimalCast({e})"), |
||||
Self::IntegerCast(e) => write!(f, "IntegerCast({e})"), |
||||
Self::DateCast(e) => write!(f, "DateCast({e})"), |
||||
Self::TimeCast(e) => write!(f, "TimeCast({e})"), |
||||
Self::DateTimeCast(e) => write!(f, "DateTimeCast({e})"), |
||||
Self::DurationCast(e) => write!(f, "DurationCast({e})"), |
||||
Self::YearMonthDurationCast(e) => write!(f, "YearMonthDurationCast({e})"), |
||||
Self::DayTimeDurationCast(e) => write!(f, "DayTimeDurationCast({e})"), |
||||
Self::StringCast(e) => write!(f, "StringCast({e})"), |
||||
Self::Or(es) => { |
||||
write!(f, "Or(")?; |
||||
for (i, e) in es.iter().enumerate() { |
||||
if i > 0 { |
||||
write!(f, ", ")?; |
||||
} |
||||
write!(f, "{e}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
Self::And(es) => { |
||||
write!(f, "And(")?; |
||||
for (i, e) in es.iter().enumerate() { |
||||
if i > 0 { |
||||
write!(f, ", ")?; |
||||
} |
||||
write!(f, "{e}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
Self::Equal(a, b) => write!(f, "Equal({a}, {b})"), |
||||
Self::Greater(a, b) => write!(f, "Greater({a}, {b})"), |
||||
Self::GreaterOrEqual(a, b) => write!(f, "GreaterOrEqual({a}, {b})"), |
||||
Self::Less(a, b) => write!(f, "Less({a}, {b})"), |
||||
Self::LessOrEqual(a, b) => write!(f, "LessOrEqual({a}, {b})"), |
||||
Self::Add(a, b) => write!(f, "Add({a}, {b})"), |
||||
Self::Subtract(a, b) => write!(f, "Subtract({a}, {b})"), |
||||
Self::Multiply(a, b) => write!(f, "Multiply({a}, {b})"), |
||||
Self::Divide(a, b) => write!(f, "Divide({a}, {b})"), |
||||
Self::LangMatches(a, b) => write!(f, "LangMatches({a}, {b})"), |
||||
Self::Contains(a, b) => write!(f, "Contains({a}, {b})"), |
||||
Self::StaticReplace(a, b, c) => write!(f, "StaticReplace({a}, {b}, {c})"), |
||||
Self::StrStarts(a, b) => write!(f, "StrStarts({a}, {b})"), |
||||
Self::StrEnds(a, b) => write!(f, "StrEnds({a}, {b})"), |
||||
Self::StrBefore(a, b) => write!(f, "StrBefore({a}, {b})"), |
||||
Self::StrAfter(a, b) => write!(f, "StrAfter({a}, {b})"), |
||||
Self::StrLang(a, b) => write!(f, "StrLang({a}, {b})"), |
||||
Self::StrDt(a, b) => write!(f, "StrDt({a}, {b})"), |
||||
Self::SameTerm(a, b) => write!(f, "SameTerm({a}, {b})"), |
||||
Self::SubStr(a, b, None) => write!(f, "SubStr({a}, {b})"), |
||||
Self::DynamicRegex(a, b, None) => write!(f, "DynamicRegex({a}, {b})"), |
||||
Self::Adjust(a, b) => write!(f, "Adjust({a}, {b})"), |
||||
Self::If(a, b, c) => write!(f, "If({a}, {b}, {c})"), |
||||
Self::SubStr(a, b, Some(c)) => write!(f, "SubStr({a}, {b}, {c})"), |
||||
Self::DynamicRegex(a, b, Some(c)) => write!(f, "DynamicRegex({a}, {b}, {c})"), |
||||
Self::DynamicReplace(a, b, c, None) => write!(f, "DynamicReplace({a}, {b}, {c})"), |
||||
Self::Triple(a, b, c) => write!(f, "Triple({a}, {b}, {c})"), |
||||
Self::DynamicReplace(a, b, c, Some(d)) => { |
||||
write!(f, "DynamicReplace({a}, {b}, {c}, {d})") |
||||
} |
||||
Self::Concat(es) => { |
||||
write!(f, "Concat(")?; |
||||
for (i, e) in es.iter().enumerate() { |
||||
if i > 0 { |
||||
write!(f, ", ")?; |
||||
} |
||||
write!(f, "{e}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
Self::Coalesce(es) => { |
||||
write!(f, "Coalesce(")?; |
||||
for (i, e) in es.iter().enumerate() { |
||||
if i > 0 { |
||||
write!(f, ", ")?; |
||||
} |
||||
write!(f, "{e}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
Self::CustomFunction(name, es) => { |
||||
write!(f, "{name}(")?; |
||||
for (i, e) in es.iter().enumerate() { |
||||
if i > 0 { |
||||
write!(f, ", ")?; |
||||
} |
||||
write!(f, "{e}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
Self::Exists(_) => write!(f, "Exists()"), //TODO
|
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub struct PlanAggregation { |
||||
pub function: PlanAggregationFunction, |
||||
pub parameter: Option<PlanExpression>, |
||||
pub distinct: bool, |
||||
} |
||||
|
||||
impl fmt::Display for PlanAggregation { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match &self.function { |
||||
PlanAggregationFunction::Count => { |
||||
write!(f, "Count") |
||||
} |
||||
PlanAggregationFunction::Sum => { |
||||
write!(f, "Sum") |
||||
} |
||||
PlanAggregationFunction::Min => { |
||||
write!(f, "Min") |
||||
} |
||||
PlanAggregationFunction::Max => { |
||||
write!(f, "Max") |
||||
} |
||||
PlanAggregationFunction::Avg => { |
||||
write!(f, "Avg") |
||||
} |
||||
PlanAggregationFunction::GroupConcat { .. } => { |
||||
write!(f, "GroupConcat") |
||||
} |
||||
PlanAggregationFunction::Sample => write!(f, "Sample"), |
||||
}?; |
||||
if self.distinct { |
||||
write!(f, "Distinct")?; |
||||
} |
||||
write!(f, "(")?; |
||||
if let Some(expr) = &self.parameter { |
||||
write!(f, "{expr}")?; |
||||
} |
||||
if let PlanAggregationFunction::GroupConcat { separator } = &self.function { |
||||
write!(f, "; separator={separator}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum PlanAggregationFunction { |
||||
Count, |
||||
Sum, |
||||
Min, |
||||
Max, |
||||
Avg, |
||||
Sample, |
||||
GroupConcat { separator: Rc<str> }, |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum PlanPropertyPath { |
||||
Path(PlanTerm<NamedNode>), |
||||
Reverse(Rc<Self>), |
||||
Sequence(Rc<Self>, Rc<Self>), |
||||
Alternative(Rc<Self>, Rc<Self>), |
||||
ZeroOrMore(Rc<Self>), |
||||
OneOrMore(Rc<Self>), |
||||
ZeroOrOne(Rc<Self>), |
||||
NegatedPropertySet(Rc<[PlanTerm<NamedNode>]>), |
||||
} |
||||
|
||||
impl fmt::Display for PlanPropertyPath { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match self { |
||||
Self::Path(p) => write!(f, "{p}"), |
||||
Self::Reverse(p) => write!(f, "Reverse({p})"), |
||||
Self::Sequence(a, b) => write!(f, "Sequence{a}, {b}"), |
||||
Self::Alternative(a, b) => write!(f, "Alternative{a}, {b}"), |
||||
Self::ZeroOrMore(p) => write!(f, "ZeroOrMore({p})"), |
||||
Self::OneOrMore(p) => write!(f, "OneOrMore({p})"), |
||||
Self::ZeroOrOne(p) => write!(f, "ZeroOrOne({p})"), |
||||
Self::NegatedPropertySet(ps) => { |
||||
write!(f, "NegatedPropertySet(")?; |
||||
for (i, p) in ps.iter().enumerate() { |
||||
if i > 0 { |
||||
write!(f, ", ")?; |
||||
} |
||||
write!(f, "{p}")?; |
||||
} |
||||
write!(f, ")") |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum Comparator { |
||||
Asc(PlanExpression), |
||||
Desc(PlanExpression), |
||||
} |
||||
|
||||
impl fmt::Display for Comparator { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match self { |
||||
Self::Asc(c) => write!(f, "Asc({c})"), |
||||
Self::Desc(c) => write!(f, "Desc({c})"), |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub struct TripleTemplate { |
||||
pub subject: TripleTemplateValue, |
||||
pub predicate: TripleTemplateValue, |
||||
pub object: TripleTemplateValue, |
||||
} |
||||
|
||||
impl fmt::Display for TripleTemplate { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
write!(f, "{} {} {}", self.subject, self.predicate, self.object) |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Clone)] |
||||
pub enum TripleTemplateValue { |
||||
Constant(PlanTerm<Term>), |
||||
BlankNode(PlanVariable<BlankNode>), |
||||
Variable(PlanVariable), |
||||
Triple(Box<TripleTemplate>), |
||||
} |
||||
|
||||
impl fmt::Display for TripleTemplateValue { |
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
||||
match self { |
||||
Self::Constant(c) => write!(f, "{c}"), |
||||
Self::BlankNode(bn) => write!(f, "{bn}"), |
||||
Self::Variable(v) => write!(f, "{v}"), |
||||
Self::Triple(t) => write!(f, "<< {t} >>"), |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[derive(Eq, PartialEq, Debug, Clone, Hash)] |
||||
pub struct EncodedTuple { |
||||
inner: Vec<Option<EncodedTerm>>, |
||||
} |
||||
|
||||
impl EncodedTuple { |
||||
pub fn with_capacity(capacity: usize) -> Self { |
||||
Self { |
||||
inner: Vec::with_capacity(capacity), |
||||
} |
||||
} |
||||
|
||||
pub fn capacity(&self) -> usize { |
||||
self.inner.capacity() |
||||
} |
||||
|
||||
pub fn contains(&self, index: usize) -> bool { |
||||
self.inner.get(index).map_or(false, Option::is_some) |
||||
} |
||||
|
||||
pub fn get(&self, index: usize) -> Option<&EncodedTerm> { |
||||
self.inner.get(index).unwrap_or(&None).as_ref() |
||||
} |
||||
|
||||
pub fn iter(&self) -> impl Iterator<Item = Option<EncodedTerm>> + '_ { |
||||
self.inner.iter().cloned() |
||||
} |
||||
|
||||
pub fn set(&mut self, index: usize, value: EncodedTerm) { |
||||
if self.inner.len() <= index { |
||||
self.inner.resize(index + 1, None); |
||||
} |
||||
self.inner[index] = Some(value); |
||||
} |
||||
|
||||
pub fn combine_with(&self, other: &Self) -> Option<Self> { |
||||
if self.inner.len() < other.inner.len() { |
||||
let mut result = other.inner.clone(); |
||||
for (key, self_value) in self.inner.iter().enumerate() { |
||||
if let Some(self_value) = self_value { |
||||
match &other.inner[key] { |
||||
Some(other_value) => { |
||||
if self_value != other_value { |
||||
return None; |
||||
} |
||||
} |
||||
None => result[key] = Some(self_value.clone()), |
||||
} |
||||
} |
||||
} |
||||
Some(Self { inner: result }) |
||||
} else { |
||||
let mut result = self.inner.clone(); |
||||
for (key, other_value) in other.inner.iter().enumerate() { |
||||
if let Some(other_value) = other_value { |
||||
match &self.inner[key] { |
||||
Some(self_value) => { |
||||
if self_value != other_value { |
||||
return None; |
||||
} |
||||
} |
||||
None => result[key] = Some(other_value.clone()), |
||||
} |
||||
} |
||||
} |
||||
Some(Self { inner: result }) |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl IntoIterator for EncodedTuple { |
||||
type Item = Option<EncodedTerm>; |
||||
type IntoIter = std::vec::IntoIter<Option<EncodedTerm>>; |
||||
|
||||
fn into_iter(self) -> Self::IntoIter { |
||||
self.inner.into_iter() |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in new issue