Support returning boolean value in evaluator (#228)

Author: afterdusk

Team20/Code20/IntegrationTesting/TestPQLEvaluator.cpp

@@ -451,5 +451,60 @@ TEST_CLASS(TestPqlEvaluator) {
     Pql::evaluate(pq, pkb.getQueryInterface(), actual);
     Assert::IsTrue(expected == actual);
   }
+
+  TEST_METHOD(TestEvaluateParsedQuery_SelectBoolean) {
+    /* Boolean true
+       Select BOOLEAN such that Follows(1, 2)
+     */
+    ParsedQuery pq = {{},
+                      {PqlResultType::Boolean},
+                      {{TokenType::FOLLOWS,
+                        {TokenType::NUMBER, "1"},
+                        {TokenType::NUMBER, "2"}}}};
+    std::list<VALUE> expected = {"TRUE"};
+    std::list<VALUE> actual;
+    Pql::evaluate(pq, pkb.getQueryInterface(), actual);
+    Assert::IsTrue(expected == actual);
+
+    /* Boolean false
+       Select BOOLEAN such that Follows(1, 3)
+     */
+    pq = {{},
+          {PqlResultType::Boolean},
+          {{TokenType::FOLLOWS,
+            {TokenType::NUMBER, "1"},
+            {TokenType::NUMBER, "3"}}}};
+    expected = {"FALSE"};
+    actual.clear();
+    Pql::evaluate(pq, pkb.getQueryInterface(), actual);
+    Assert::IsTrue(expected == actual);
+
+    /* No values (indirect false)
+       read r; if i; Select BOOLEAN such that Parent*(i, r)
+     */
+    pq = {{{"r", TokenType::READ}, {"i", TokenType::IF}},
+          {PqlResultType::Boolean},
+          {{TokenType::PARENT, {TokenType::IF, "i"}, {TokenType::READ, "r"}}}};
+    expected = {"FALSE"};
+    actual.clear();
+    Pql::evaluate(pq, pkb.getQueryInterface(), actual);
+    Assert::IsTrue(expected == actual);
+
+    /* With values (indirect true)
+       assign a; read r; call c; Select BOOLEAN such that Follows(r, a)
+     */
+    pq = {{{"a", TokenType::ASSIGN},
+           {"r", TokenType::READ},
+           {"c", TokenType::CALL}},
+          {PqlResultType::Boolean},
+          {{TokenType::FOLLOWS,
+            {TokenType::READ, "r"},
+            {TokenType::ASSIGN, "a"}}}};
+    expected = {"TRUE"};
+    actual.clear();
+    Pql::evaluate(pq, pkb.getQueryInterface(), actual);
+    Logger::WriteMessage(actual.front().c_str());
+    Assert::IsTrue(expected == actual);
+  }
 };
 } // namespace IntegrationTesting

Team20/Code20/source/PQLEvaluator.cpp

@@ -19,6 +19,9 @@ void Pql::evaluate(ParsedQuery pq, PkbQueryInterface *queryHandler,
       // Early termination if clause evaluates to false
       if (!dispatcher->booleanDispatch()) {
         delete dispatcher;
+        if (pq.results.resultType == PqlResultType::Boolean) {
+          result.push_back(FALSE_RESULT);
+        }
         return;
       }
     } else {
@@ -36,6 +39,9 @@ void Pql::evaluate(ParsedQuery pq, PkbQueryInterface *queryHandler,
       // Early termination if clause evaluates to false
       if (!dispatcher->booleanDispatch()) {
         delete dispatcher;
+        if (pq.results.resultType == PqlResultType::Boolean) {
+          result.push_back(FALSE_RESULT);
+        }
         return;
       }
     } else {
@@ -47,6 +53,9 @@ void Pql::evaluate(ParsedQuery pq, PkbQueryInterface *queryHandler,
 
   // Early termination if table contains synonyms, but has no values
   if (!table.empty() && table.rowCount() == 0) {
+    if (pq.results.resultType == PqlResultType::Boolean) {
+      result.push_back(FALSE_RESULT);
+    }
     return;
   }
 
@@ -72,6 +81,15 @@ void Pql::evaluate(ParsedQuery pq, PkbQueryInterface *queryHandler,
     delete dispatcher;
     filtered.merge(clauseResult);
   }
+
+  if (pq.results.resultType == PqlResultType::Boolean) {
+    if (!filtered.empty() && filtered.rowCount() == 0) {
+      result.push_back(FALSE_RESULT);
+    } else {
+      result.push_back(TRUE_RESULT);
+    }
+    return;
+  }
   filtered.flatten(pq.results.results, result);
 }
 

Team20/Code20/source/PQLEvaluator.h

@@ -11,6 +11,9 @@ typedef std::string SYMBOL;
 typedef std::string VALUE;
 typedef std::unordered_map<SYMBOL, std::vector<VALUE>> TABLE;
 
+constexpr auto TRUE_RESULT = "TRUE";
+constexpr auto FALSE_RESULT = "FALSE";
+
 /** @brief Represents the table of possible query results.
  *  As clauses are evaluated, values from the PkbTables are pushed into
  *  this table.