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

Optimizer: Adds builder functions for expressions

Browse Source
rules
Tpt 2 years ago
parent d2d98e09e8
commit 701328f444
2 changed files with 156 additions and 98 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. 97
      lib/sparopt/src/algebra.rs
  2. 157
      lib/sparopt/src/optimizer.rs

97
lib/sparopt/src/algebra.rs
Unescape View File

@ -62,6 +62,103 @@ pub enum Expression {
} }
impl Expression { impl Expression {
pub(crate) fn or(left: Self, right: Self) -> Self {
match (
left.effective_boolean_value(),
right.effective_boolean_value(),
) {
(Some(true), _) | (_, Some(true)) => true.into(),
(Some(false), Some(false)) => false.into(),
_ => Self::Or(Box::new(left), Box::new(right)),
}
}
pub(crate) fn and(left: Self, right: Self) -> Self {
match (
left.effective_boolean_value(),
right.effective_boolean_value(),
) {
(Some(false), _) | (_, Some(false)) => false.into(),
(Some(true), Some(true)) => true.into(),
_ => Self::And(Box::new(left), Box::new(right)),
}
}
pub(crate) fn equal(left: Self, right: Self) -> Self {
Self::Equal(Box::new(left), Box::new(right))
}
pub(crate) fn same_term(left: Self, right: Self) -> Self {
Self::SameTerm(Box::new(left), Box::new(right))
}
pub(crate) fn greater(left: Self, right: Self) -> Self {
Self::Greater(Box::new(left), Box::new(right))
}
pub(crate) fn greater_or_equal(left: Self, right: Self) -> Self {
Self::GreaterOrEqual(Box::new(left), Box::new(right))
}
pub(crate) fn less(left: Self, right: Self) -> Self {
Self::Less(Box::new(left), Box::new(right))
}
pub(crate) fn less_or_equal(left: Self, right: Self) -> Self {
Self::LessOrEqual(Box::new(left), Box::new(right))
}
pub(crate) fn add(left: Self, right: Self) -> Self {
Self::Add(Box::new(left), Box::new(right))
}
pub(crate) fn subtract(left: Self, right: Self) -> Self {
Self::Subtract(Box::new(left), Box::new(right))
}
pub(crate) fn multiply(left: Self, right: Self) -> Self {
Self::Multiply(Box::new(left), Box::new(right))
}
pub(crate) fn divide(left: Self, right: Self) -> Self {
Self::Divide(Box::new(left), Box::new(right))
}
pub(crate) fn unary_plus(inner: Self) -> Self {
Self::UnaryPlus(Box::new(inner))
}
pub(crate) fn unary_minus(inner: Self) -> Self {
Self::UnaryMinus(Box::new(inner))
}
pub(crate) fn not(inner: Self) -> Self {
Self::Not(Box::new(inner))
}
pub(crate) fn exists(inner: GraphPattern) -> Self {
if inner.is_empty() {
return false.into();
}
Self::Exists(Box::new(inner))
}
pub(crate) fn if_cond(cond: Self, then: Self, els: Self) -> Self {
match cond.effective_boolean_value() {
Some(true) => then,
Some(false) => els,
None => Self::If(Box::new(cond), Box::new(then), Box::new(els)),
}
}
pub(crate) fn coalesce(args: Vec<Self>) -> Self {
Self::Coalesce(args)
}
pub(crate) fn call(name: Function, args: Vec<Self>) -> Self {
Self::FunctionCall(name, args)
}
pub(crate) fn effective_boolean_value(&self) -> Option<bool> { pub(crate) fn effective_boolean_value(&self) -> Option<bool> {
match self { match self {
Self::NamedNode(_) => Some(true), Self::NamedNode(_) => Some(true),

157
lib/sparopt/src/optimizer.rs
Unescape View File

@ -121,111 +121,72 @@ impl Optimizer {
Expression::NamedNode(node) => node.into(), Expression::NamedNode(node) => node.into(),
Expression::Literal(literal) => literal.into(), Expression::Literal(literal) => literal.into(),
Expression::Variable(variable) => variable.into(), Expression::Variable(variable) => variable.into(),
Expression::Or(left, right) => { Expression::Or(left, right) => Expression::or(
let left = Self::normalize_expression(*left); Self::normalize_expression(*left),
let right = Self::normalize_expression(*right); Self::normalize_expression(*right),
match ( ),
left.effective_boolean_value(), Expression::And(left, right) => Expression::and(
right.effective_boolean_value(), Self::normalize_expression(*left),
) { Self::normalize_expression(*right),
(Some(true), _) | (_, Some(true)) => true.into(), ),
(Some(false), Some(false)) => false.into(), Expression::Equal(left, right) => Expression::equal(
_ => Expression::Or(Box::new(left), Box::new(right)), Self::normalize_expression(*left),
} Self::normalize_expression(*right),
} ),
Expression::And(left, right) => { Expression::SameTerm(left, right) => Expression::same_term(
let left = Self::normalize_expression(*left); Self::normalize_expression(*left),
let right = Self::normalize_expression(*right); Self::normalize_expression(*right),
match ( ),
left.effective_boolean_value(), Expression::Greater(left, right) => Expression::greater(
right.effective_boolean_value(), Self::normalize_expression(*left),
) { Self::normalize_expression(*right),
(Some(false), _) | (_, Some(false)) => false.into(), ),
(Some(true), Some(true)) => true.into(), Expression::GreaterOrEqual(left, right) => Expression::greater_or_equal(
_ => Expression::And(Box::new(left), Box::new(right)), Self::normalize_expression(*left),
} Self::normalize_expression(*right),
} ),
Expression::Equal(left, right) => { Expression::Less(left, right) => Expression::less(
let left = Self::normalize_expression(*left); Self::normalize_expression(*left),
let right = Self::normalize_expression(*right); Self::normalize_expression(*right),
Expression::Equal(Box::new(left), Box::new(right)) ),
} Expression::LessOrEqual(left, right) => Expression::less_or_equal(
Expression::SameTerm(left, right) => { Self::normalize_expression(*left),
let left = Self::normalize_expression(*left); Self::normalize_expression(*right),
let right = Self::normalize_expression(*right); ),
Expression::SameTerm(Box::new(left), Box::new(right)) Expression::Add(left, right) => Expression::add(
} Self::normalize_expression(*left),
Expression::Greater(left, right) => { Self::normalize_expression(*right),
let left = Self::normalize_expression(*left); ),
let right = Self::normalize_expression(*right); Expression::Subtract(left, right) => Expression::subtract(
Expression::Greater(Box::new(left), Box::new(right)) Self::normalize_expression(*left),
} Self::normalize_expression(*right),
Expression::GreaterOrEqual(left, right) => { ),
let left = Self::normalize_expression(*left); Expression::Multiply(left, right) => Expression::multiply(
let right = Self::normalize_expression(*right); Self::normalize_expression(*left),
Expression::GreaterOrEqual(Box::new(left), Box::new(right)) Self::normalize_expression(*right),
} ),
Expression::Less(left, right) => { Expression::Divide(left, right) => Expression::divide(
let left = Self::normalize_expression(*left); Self::normalize_expression(*left),
let right = Self::normalize_expression(*right); Self::normalize_expression(*right),
Expression::Less(Box::new(left), Box::new(right)) ),
}
Expression::LessOrEqual(left, right) => {
let left = Self::normalize_expression(*left);
let right = Self::normalize_expression(*right);
Expression::LessOrEqual(Box::new(left), Box::new(right))
}
Expression::Add(left, right) => {
let left = Self::normalize_expression(*left);
let right = Self::normalize_expression(*right);
Expression::Add(Box::new(left), Box::new(right))
}
Expression::Subtract(left, right) => {
let left = Self::normalize_expression(*left);
let right = Self::normalize_expression(*right);
Expression::Subtract(Box::new(left), Box::new(right))
}
Expression::Multiply(left, right) => {
let left = Self::normalize_expression(*left);
let right = Self::normalize_expression(*right);
Expression::Multiply(Box::new(left), Box::new(right))
}
Expression::Divide(left, right) => {
let left = Self::normalize_expression(*left);
let right = Self::normalize_expression(*right);
Expression::Divide(Box::new(left), Box::new(right))
}
Expression::UnaryPlus(inner) => { Expression::UnaryPlus(inner) => {
let inner = Self::normalize_expression(*inner); Expression::unary_plus(Self::normalize_expression(*inner))
Expression::UnaryPlus(Box::new(inner))
} }
Expression::UnaryMinus(inner) => { Expression::UnaryMinus(inner) => {
let inner = Self::normalize_expression(*inner); Expression::unary_minus(Self::normalize_expression(*inner))
Expression::UnaryMinus(Box::new(inner))
}
Expression::Not(inner) => {
let inner = Self::normalize_expression(*inner);
Expression::Not(Box::new(inner))
}
Expression::Exists(inner) => {
let inner = Self::normalize_pattern(*inner);
Expression::Exists(Box::new(inner))
} }
Expression::Not(inner) => Expression::not(Self::normalize_expression(*inner)),
Expression::Exists(inner) => Expression::exists(Self::normalize_pattern(*inner)),
Expression::Bound(variable) => Expression::Bound(variable), Expression::Bound(variable) => Expression::Bound(variable),
Expression::If(cond, then, els) => { Expression::If(cond, then, els) => Expression::if_cond(
let cond = Self::normalize_expression(*cond); Self::normalize_expression(*cond),
let then = Self::normalize_expression(*then); Self::normalize_expression(*then),
let els = Self::normalize_expression(*els); Self::normalize_expression(*els),
match cond.effective_boolean_value() { ),
Some(true) => then,
Some(false) => els,
None => Expression::If(Box::new(cond), Box::new(then), Box::new(els)),
}
}
Expression::Coalesce(inners) => { Expression::Coalesce(inners) => {
Expression::Coalesce(inners.into_iter().map(Self::normalize_expression).collect()) Expression::coalesce(inners.into_iter().map(Self::normalize_expression).collect())
} }
Expression::FunctionCall(name, args) => Expression::FunctionCall( Expression::FunctionCall(name, args) => Expression::call(
name, name,
args.into_iter().map(Self::normalize_expression).collect(), args.into_iter().map(Self::normalize_expression).collect(),
), ),

Write Preview
Loading…
Cancel
Save