From e007d7fc975e18ca7c29b8b53ec1c27f4ffdc581 Mon Sep 17 00:00:00 2001
From: Abdul Zreika <azre6702@uni.sydney.edu.au>
Date: Thu, 3 Dec 2020 14:45:11 +1100
Subject: [PATCH] Moved out eqcheck functionality.

---
 src/ast2ram/ClauseTranslator.cpp | 25 ++++++++++++-------------
 src/ast2ram/ClauseTranslator.h   |  3 +++
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/ast2ram/ClauseTranslator.cpp b/src/ast2ram/ClauseTranslator.cpp
index b7af152c6d5..d218975e315 100644
--- a/src/ast2ram/ClauseTranslator.cpp
+++ b/src/ast2ram/ClauseTranslator.cpp
@@ -121,10 +121,9 @@ Own<ram::Operation> ClauseTranslator::addVariableBindingConstraints(Own<ram::Ope
         const auto& first = *references.begin();
         for (const auto& reference : references) {
             if (first != reference && !valueIndex->isGenerator(reference.identifier)) {
-                // FIXME: equiv' for float types (`FEQ`)
-                op = mk<ram::Filter>(mk<ram::Constraint>(BinaryConstraintOp::EQ, makeRamTupleElement(first),
-                                             makeRamTupleElement(reference)),
-                        std::move(op));
+                // TODO: float type equivalence check
+                op = addEqualityCheck(
+                        std::move(op), makeRamTupleElement(first), makeRamTupleElement(reference), false);
             }
         }
     }
@@ -224,7 +223,7 @@ Own<ram::Operation> ClauseTranslator::instantiateAggregator(
     auto addAggEqCondition = [&](Own<ram::Condition> aggr, Own<ram::Expression> value, size_t pos) {
         if (isUndefValue(value.get())) return aggr;
 
-        // FIXME: equiv' for float types (`FEQ`)
+        // TODO: float type equivalence check
         return addConjunctiveTerm(
                 std::move(aggr), mk<ram::Constraint>(BinaryConstraintOp::EQ,
                                          mk<ram::TupleElement>(curLevel, pos), std::move(value)));
@@ -368,15 +367,15 @@ Own<ram::Expression> ClauseTranslator::translateConstant(
     return mk<ram::SignedConstant>(rawConstant);
 }
 
-Own<ram::Operation> ClauseTranslator::addConstantConstraints(
-        size_t const curLevel, const std::vector<ast::Argument*>& arguments, Own<ram::Operation> op) const {
-    // Helper function to add a constraint check
-    auto addEqualityCheck = [&](Own<ram::Operation> op, Own<ram::Expression> lhs, Own<ram::Expression> rhs,
-                                    bool isFloat) {
-        auto eqOp = isFloat ? BinaryConstraintOp::FEQ : BinaryConstraintOp::EQ;
-        return mk<ram::Filter>(mk<ram::Constraint>(eqOp, std::move(lhs), std::move(rhs)), std::move(op));
-    };
+Own<ram::Operation> ClauseTranslator::addEqualityCheck(
+        Own<ram::Operation> op, Own<ram::Expression> lhs, Own<ram::Expression> rhs, bool isFloat) const {
+    auto eqOp = isFloat ? BinaryConstraintOp::FEQ : BinaryConstraintOp::EQ;
+    auto eqConstraint = mk<ram::Constraint>(eqOp, std::move(lhs), std::move(rhs));
+    return mk<ram::Filter>(std::move(eqConstraint), std::move(op));
+}
 
+Own<ram::Operation> ClauseTranslator::addConstantConstraints(
+        size_t curLevel, const std::vector<ast::Argument*>& arguments, Own<ram::Operation> op) const {
     for (size_t i = 0; i < arguments.size(); i++) {
         const auto* argument = arguments.at(i);
         if (const auto* numericConstant = dynamic_cast<const ast::NumericConstant*>(argument)) {
diff --git a/src/ast2ram/ClauseTranslator.h b/src/ast2ram/ClauseTranslator.h
index 7a9ebcd7152..82d386b25e7 100644
--- a/src/ast2ram/ClauseTranslator.h
+++ b/src/ast2ram/ClauseTranslator.h
@@ -88,6 +88,9 @@ class ClauseTranslator {
     void indexNodeArguments(int nodeLevel, const std::vector<ast::Argument*>& nodeArgs);
     void indexAggregatorBody(const ast::Aggregator& agg);
 
+    Own<ram::Operation> addEqualityCheck(
+            Own<ram::Operation> op, Own<ram::Expression> lhs, Own<ram::Expression> rhs, bool isFloat) const;
+
     Own<ram::Statement> createRamFactQuery(const ast::Clause& clause) const;
     Own<ram::Statement> createRamRuleQuery(
             const ast::Clause& clause, const ast::Clause& originalClause, int version);