From 94b44024bc5740f2517230bb8f102b11aed7830d Mon Sep 17 00:00:00 2001
From: Tpt <thomaspt@hotmail.fr>
Date: Tue, 9 Oct 2018 16:43:23 +0200
Subject: [PATCH] Adds basic evaluation of arithmetic operators

---
 lib/src/sparql/eval.rs | 67 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/lib/src/sparql/eval.rs b/lib/src/sparql/eval.rs
index dd0e060b..1f0c4e1e 100644
--- a/lib/src/sparql/eval.rs
+++ b/lib/src/sparql/eval.rs
@@ -210,6 +210,38 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
             PlanExpression::LowerOrEq(a, b) => {
                 Some((self.eval_expression(a, tuple)? <= self.eval_expression(b, tuple)?).into())
             }
+            PlanExpression::Add(a, b) => Some(match self.parse_numeric_operands(a, b, tuple)? {
+                NumericBinaryOperands::Float(v1, v2) => (v1 + v2).into(),
+                NumericBinaryOperands::Double(v1, v2) => (v1 + v2).into(),
+                NumericBinaryOperands::Integer(v1, v2) => (v1 + v2).into(),
+            }),
+            PlanExpression::Sub(a, b) => Some(match self.parse_numeric_operands(a, b, tuple)? {
+                NumericBinaryOperands::Float(v1, v2) => (v1 - v2).into(),
+                NumericBinaryOperands::Double(v1, v2) => (v1 - v2).into(),
+                NumericBinaryOperands::Integer(v1, v2) => (v1 - v2).into(),
+            }),
+            PlanExpression::Mul(a, b) => Some(match self.parse_numeric_operands(a, b, tuple)? {
+                NumericBinaryOperands::Float(v1, v2) => (v1 * v2).into(),
+                NumericBinaryOperands::Double(v1, v2) => (v1 * v2).into(),
+                NumericBinaryOperands::Integer(v1, v2) => (v1 * v2).into(),
+            }),
+            PlanExpression::Div(a, b) => Some(match self.parse_numeric_operands(a, b, tuple)? {
+                NumericBinaryOperands::Float(v1, v2) => (v1 / v2).into(),
+                NumericBinaryOperands::Double(v1, v2) => (v1 / v2).into(),
+                NumericBinaryOperands::Integer(v1, v2) => (v1 / v2).into(),
+            }),
+            PlanExpression::UnaryPlus(e) => match self.eval_expression(e, tuple)? {
+                EncodedTerm::FloatLiteral(value) => Some((*value).into()),
+                EncodedTerm::DoubleLiteral(value) => Some((*value).into()),
+                EncodedTerm::IntegerLiteral(value) => Some((value).into()),
+                _ => None,
+            },
+            PlanExpression::UnaryMinus(e) => match self.eval_expression(e, tuple)? {
+                EncodedTerm::FloatLiteral(value) => Some((-*value).into()),
+                EncodedTerm::DoubleLiteral(value) => Some((-*value).into()),
+                EncodedTerm::IntegerLiteral(value) => Some((-value).into()),
+                _ => None,
+            },
             PlanExpression::UnaryNot(e) => self
                 .to_bool(self.eval_expression(e, tuple)?)
                 .map(|v| (!v).into()),
@@ -295,6 +327,35 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
         }
     }
 
+    fn parse_numeric_operands(
+        &self,
+        e1: &PlanExpression,
+        e2: &PlanExpression,
+        tuple: &[Option<EncodedTerm>],
+    ) -> Option<NumericBinaryOperands> {
+        match (
+            self.eval_expression(&e1, tuple)?,
+            self.eval_expression(&e2, tuple)?,
+        ) {
+            (EncodedTerm::FloatLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
+                Some(NumericBinaryOperands::Float(*v1, *v2))
+            }
+            (EncodedTerm::FloatLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
+                Some(NumericBinaryOperands::Double(*v1 as f64, *v2))
+            }
+            (EncodedTerm::DoubleLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
+                Some(NumericBinaryOperands::Double(*v1, *v2 as f64))
+            }
+            (EncodedTerm::DoubleLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
+                Some(NumericBinaryOperands::Double(*v1, *v2))
+            }
+            (EncodedTerm::IntegerLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
+                Some(NumericBinaryOperands::Integer(v1, v2))
+            }
+            _ => None,
+        }
+    }
+
     fn decode_bindings(
         &self,
         iter: EncodedTuplesIterator,
@@ -318,6 +379,12 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
     }
 }
 
+enum NumericBinaryOperands {
+    Float(f32, f32),
+    Double(f64, f64),
+    Integer(i128, i128),
+}
+
 fn get_pattern_value(
     selector: &PatternValue,
     tuple: &[Option<EncodedTerm>],