Merge move join (#191)

* Support for multiple branched CaseWhen

* Interval (#116)

* add date_add, interval sql still running into issues

* Add Interval SQL support

* uncomment out the other tests

* resolve comments

* change interval equality

Co-authored-by: Eric Feng <[email protected]>

* Remove partition ID argument from enclaves

* Fix comments

* updates

* Modifications to integrate crumb, log-mac, and all-outputs_mac, wip

* Store log mac after each output buffer, add all-outputs-mac to each encryptedblocks wip

* Add all_outputs_mac to all EncryptedBlocks once all log_macs have been generated

* Almost builds

* cpp builds

* Use ubyte for all_outputs_mac

* use Mac for all_outputs_mac

* Hopefully this works for flatbuffers all_outputs_mac mutation, cpp builds

* Scala builds now too, running into error with union

* Stuff builds, error with all outputs mac serialization. this commit uses all_outputs_mac as Mac table

* Fixed bug, basic encryption / show works

* All single partition tests pass, multiple partiton passes until tpch-9

* All tests pass except tpch-9 and skew join

* comment tpch back in

* Check same number of ecalls per partition - exception for scanCollectLastPrimary(?)

* First attempt at constructing executed DAG

* Fix typos

* Rework graph

* Add log macs to graph nodes

* Construct expected DAG and refactor JobNode.
Refactor construction of executed DAG.

* Implement 'paths to sink' for a DAG

* add crumb for last ecall

* Fix NULL handling for aggregation (#130)

* Modify COUNT and SUM to correctly handle NULL values

* Change average to support NULL values

* Fix

* Changing operator matching from logical to physical (#129)

* WIP

* Fix

* Unapply change

* Aggregation rewrite (#132)

* updated build/sbt file (#135)

* Travis update (#137)

* update breeze (#138)

* TPC-H test suite added (#136)

* added tpch sql files

* functions updated to save temp view

* main function skeleton done

* load and clear done

* fix clear

* performQuery done

* import cleanup, use OPAQUE_HOME

* TPC-H 9 refactored to use SQL rather than DF operations

* removed : Unit, unused imports

* added TestUtils.scala

* moved all common initialization to TestUtils

* update name

* begin rewriting TPCH.scala to store persistent tables

* invalid table name error

* TPCH conversion to class started

* compiles

* added second case, cleared up names

* added TPC-H 6 to check that persistent state has no issues

* added functions for the last two tables

* addressed most logic changes

* DataFrame only loaded once

* apply method in companion object

* full test suite added

* added testFunc parameter to testAgainstSpark

* ignore #18

* Separate IN PR (#124)

* finishing the in expression. adding more tests and null support. need confirmation on null behavior and also I wonder why integer field is sufficient for string

* adding additional test

* adding additional test

* saving concat implementation and it's passing basic functionality tests

* adding type aware comparison and better error message for IN operator

* adding null checking for the concat operator and adding one additional test

* cleaning up IN&Concat PR

* deleting concat and preping the in branch for in pr

* fixing null bahavior 

now it's only null when there's no match and there's null input

* Build failed

Co-authored-by: Ubuntu <[email protected]>
Co-authored-by: Wenting Zheng <[email protected]>
Co-authored-by: Wenting Zheng <[email protected]>

* Merge new aggregate

* Uncomment log_mac_lst clear

* Clean up comments

* Separate Concat PR  (#125)

Implementation of the CONCAT expression.

Co-authored-by: Ubuntu <[email protected]>
Co-authored-by: Wenting Zheng <[email protected]>

* Clean up comments in other files

* Update pathsEqual to be less conservative

* Remove print statements from unit tests

* Removed calls to toSet in TPC-H tests (#140)

* removed calls to toSet

* added calls to toSet back where queries are unordered

* Documentation update (#148)

* Cluster Remote Attestation Fix (#146)

The existing code only had RA working when run locally. This PR adds a sleep for 5 seconds to make sure that all executors are spun up successfully before attestation begins.

Closes #147

* upgrade to 3.0.1 (#144)

* Update two TPC-H queries (#149)

Tests for TPC-H 12 and 19 pass.

* TPC-H 20 Fix (#142)

* string to stringtype error

* tpch 20 passes

* cleanup

* implemented changes

* decimal.tofloat

Co-authored-by: Wenting Zheng <[email protected]>

* Add expected operator DAG generation from executedPlan string

* Rebase

* Join update (#145)

* Merge join update

* Integrate new join

* Add expected operator for sortexec

* Merge comp-integrity with join update

* Remove some print statements

* Migrate from Travis CI to Github Actions (#156)

* Upgrade to OE 0.12 (#153)

* Update README.md

* Support for scalar subquery (#157)

This PR implements the scalar subquery expression, which is triggered whenever a subquery returns a scalar value. There were two main problems that needed to be solved.

First, support for matching the scalar subquery expression is necessary. Spark implements this by wrapping a SparkPlan within the expression and calls executeCollect. Then it constructs a literal with that value. However, this is problematic for us because that value should not be decrypted by the driver and serialized into an expression, since it's an intermediate value.

Therefore, the second issue to be addressed here is supporting an encrypted literal. This is implemented in this PR by serializing an encrypted ciphertext into a base64 encoded string, and wrapping a Decrypt expression on top of it. This expression is then evaluated in the enclave and returns a literal. Note that, in order to test our implementation, we also implement a Decrypt expression in Scala. However, this should never be evaluated on the driver side and serialized into a plaintext literal. This is because Decrypt is designated as a Nondeterministic expression, and therefore will always evaluate on the workers.

* Add TPC-H Benchmarks (#139)

* logic decoupling in TPCH.scala for easier benchmarking

* added TPCHBenchmark.scala

* Benchmark.scala rewrite

* done adding all support TPC-H query benchmarks

* changed commandline arguments that benchmark takes

* TPCHBenchmark takes in parameters

* fixed issue with spark conf

* size error handling, --help flag

* add Utils.force, break cluster mode

* comment out logistic regression benchmark

* ensureCached right before temp view created/replaced

* upgrade to 3.0.1

* upgrade to 3.0.1

* 10 scale factor

* persistData

* almost done refactor

* more cleanup

* compiles

* 9 passes

* cleanup

* collect instead of force, sf_none

* remove sf_none

* defaultParallelism

* no removing trailing/leading whitespace

* add sf_med

* hdfs works in local case

* cleanup, added new CLI argument

* added newly supported tpch queries

* function for running all supported tests

* Construct expected DAG from dataframe physical plan

* Refactor collect and add integrity checking helper function to OpaqueOperatorTest

* Float expressions (#160)

This PR adds float normalization expressions [implemented in Spark](https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/NormalizeFloatingNumbers.scala#L170). TPC-H query 2 also passes.

* Broadcast Nested Loop Join - Left Anti and Left Semi  (#159)

This PR is the first of two parts towards making TPC-H 16 work: the other will be implementing `is_distinct` for aggregate operations.

`BroadcastNestedLoopJoin` is Spark's "catch all" for non-equi joins. It works by first picking a side to broadcast, then iterating through every possible row combination and checking the non-equi condition against the pair.

* Move join condition handling for equi-joins into enclave code (#164)

* Add in TPC-H 21

* Add condition processing in enclave code

* Code clean up

* Enable query 18

* WIP

* Local tests pass

* Apply suggestions from code review

Co-authored-by: octaviansima <[email protected]>

* WIP

* Address comments

* q21.sql

Co-authored-by: octaviansima <[email protected]>

* Remove addExpectedOperator from JobVerificationEngine, add comments

* Implement expected DAG construction by doing graph manipulation on dataframe field instead of string parsing

* Fix merge errors in the test cases

Co-authored-by: Andrew Law <[email protected]>
Co-authored-by: Eric Feng <[email protected]>
Co-authored-by: Eric Feng <[email protected]>
Co-authored-by: Chester Leung <[email protected]>
Co-authored-by: Wenting Zheng <[email protected]>
Co-authored-by: octaviansima <[email protected]>
Co-authored-by: Chenyu Shi <[email protected]>
Co-authored-by: Ubuntu <[email protected]>
Co-authored-by: Wenting Zheng <[email protected]>

Author: 9 people

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "*.tcc": "cpp"
+    }
+}

src/enclave/Enclave/ExpressionEvaluation.h

@@ -1790,6 +1790,7 @@ class FlatbuffersJoinExprEvaluator {
     join_type = join_expr->join_type();
 
     join_type = join_expr->join_type();
+    condition_eval = nullptr;
     if (join_expr->condition() != NULL) {
       condition_eval = std::unique_ptr<FlatbuffersExpressionEvaluator>(
           new FlatbuffersExpressionEvaluator(join_expr->condition()));
@@ -1798,9 +1799,6 @@ class FlatbuffersJoinExprEvaluator {
 
     if (join_expr->left_keys() != NULL && join_expr->right_keys() != NULL) {
       is_equi_join = true;
-      if (join_expr->condition() != NULL) {
-        throw std::runtime_error("Equi join cannot have condition");
-      }
       if (join_expr->left_keys()->size() != join_expr->right_keys()->size()) {
         throw std::runtime_error("Mismatched join key lengths");
       }
@@ -1836,14 +1834,12 @@ class FlatbuffersJoinExprEvaluator {
     return is_primary(row1) ? row1 : row2;
   }
 
-  /** Return true if the two rows satisfy the join condition. */
-  bool eval_condition(const tuix::Row *row1, const tuix::Row *row2) {
+  /** Return true if the two rows are from the same join group
+   *  Since the function calls `is_primary`, the rows must have been tagged in Scala */
+  bool is_same_group(const tuix::Row *row1, const tuix::Row *row2) {
     builder.Clear();
     bool row1_equals_row2;
 
-    /** Check equality for equi joins. If it is a non-equi join, 
-     * the key evaluators will be empty, so the code never enters the for loop.
-    */
     auto &row1_evaluators = is_primary(row1) ? left_key_evaluators : right_key_evaluators;
     auto &row2_evaluators = is_primary(row2) ? left_key_evaluators : right_key_evaluators;
     for (uint32_t i = 0; i < row1_evaluators.size(); i++) {
@@ -1856,9 +1852,8 @@ class FlatbuffersJoinExprEvaluator {
       auto row2_field = flatbuffers::GetTemporaryPointer<tuix::Field>(builder, row2_eval_offset);
 
       flatbuffers::Offset<tuix::Field> comparison = eval_binary_comparison<tuix::EqualTo, std::equal_to>(
-        builder,
-        row1_field,
-        row2_field);
+        builder, row1_field, row2_field);
+        
       row1_equals_row2 =
         static_cast<const tuix::BooleanField *>(
           flatbuffers::GetTemporaryPointer<tuix::Field>(
@@ -1889,6 +1884,28 @@ class FlatbuffersJoinExprEvaluator {
     return true;
   }
 
+  /** Evaluate condition on the two input rows */
+  bool eval_condition(const tuix::Row *row1, const tuix::Row *row2) {
+    if (condition_eval != nullptr) {
+      std::vector<flatbuffers::Offset<tuix::Field>> concat_fields;
+      for (auto field : *row1->field_values()) {
+        concat_fields.push_back(flatbuffers_copy<tuix::Field>(field, builder));
+      }
+      for (auto field : *row2->field_values()) {
+        concat_fields.push_back(flatbuffers_copy<tuix::Field>(field, builder));
+      }
+      flatbuffers::Offset<tuix::Row> concat = tuix::CreateRowDirect(builder, &concat_fields);
+      const tuix::Row *concat_ptr = flatbuffers::GetTemporaryPointer<tuix::Row>(builder, concat);
+      const tuix::Field *condition_result = condition_eval->eval(concat_ptr);
+      return static_cast<const tuix::BooleanField *>(condition_result->value())->value();
+    }
+
+    // The `condition_eval` can only be empty when it's an equi-join.
+    // Since `condition_eval` is an extra predicate used to filter out *matched* rows in an equi-join, an empty
+    // condition means the matched row should not be filtered out; hence the default return value of true 
+    return true;
+  }
+
   tuix::JoinType get_join_type() {
     return join_type;
   }

src/enclave/Enclave/NonObliviousSortMergeJoin.cpp

@@ -5,6 +5,53 @@
 #include "FlatbuffersWriters.h"
 #include "common.h"
 
+/** 
+ * C++ implementation of a non-oblivious sort merge join.
+ * Rows MUST be tagged primary or secondary for this to work.
+ */
+
+void test_rows_same_group(FlatbuffersJoinExprEvaluator &join_expr_eval,
+                          const tuix::Row *primary,
+                          const tuix::Row *current) {
+  if (!join_expr_eval.is_same_group(primary, current)) {
+    throw std::runtime_error(
+                             std::string("Invariant violation: rows of primary_group "
+                                         "are not of the same group: ")
+                             + to_string(primary)
+                             + std::string(" vs ")
+                             + to_string(current));
+  }
+}
+
+void write_output_rows(RowWriter &group, RowWriter &w) {
+  auto group_buffer = group.output_buffer(std::string(""));
+  RowReader group_reader(group_buffer.view());
+          
+  while (group_reader.has_next()) {
+    const tuix::Row *row = group_reader.next();
+    w.append(row);
+  }  
+}
+
+/** 
+ * Sort merge equi join algorithm
+ * Input: the rows are unioned from both the primary (or left) table and the non-primary (or right) table
+ * 
+ * Outer loop: iterate over all input rows
+ * 
+ * If it's a row from the left table
+ * - Add it to the current group
+ * - Otherwise start a new group
+ *   - If it's a left semi/anti join, output the primary_matched_rows/primary_unmatched_rows
+ * 
+ * If it's a row from the right table
+ * - Inner join: iterate over current left group, output the joined row only if the condition is satisfied
+ * - Left semi/anti join: iterate over `primary_unmatched_rows`, add a matched row to `primary_matched_rows` 
+ *   and remove from `primary_unmatched_rows`
+ * 
+ * After loop: output the last group left semi/anti join
+ */
+
 void non_oblivious_sort_merge_join(
   uint8_t *join_expr, size_t join_expr_length,
   uint8_t *input_rows, size_t input_rows_length,
@@ -17,86 +64,85 @@ void non_oblivious_sort_merge_join(
 
   RowWriter primary_group;
   FlatbuffersTemporaryRow last_primary_of_group;
+  RowWriter primary_matched_rows, primary_unmatched_rows; // This is only used for left semi/anti join
 
-  bool pk_fk_match = false;
-
+  EnclaveContext::getInstance().set_append_mac(false);
   while (r.has_next()) {
     const tuix::Row *current = r.next();
+
     if (join_expr_eval.is_primary(current)) {
-      EnclaveContext::getInstance().set_append_mac(false);
-      // If current row is from primary table
       if (last_primary_of_group.get()
-          && join_expr_eval.eval_condition(last_primary_of_group.get(), current)) {
+          && join_expr_eval.is_same_group(last_primary_of_group.get(), current)) {
+        
         // Add this primary row to the current group
+        // If this is a left semi/anti join, also add the rows to primary_unmatched_rows
         primary_group.append(current);
+        if (join_type == tuix::JoinType_LeftSemi || join_type == tuix::JoinType_LeftAnti) {
+          primary_unmatched_rows.append(current);
+        }
         last_primary_of_group.set(current);
+        
       } else {
         // If a new primary group is encountered
-        if (join_type == tuix::JoinType_LeftAnti && !pk_fk_match) {
-          auto primary_group_buffer = primary_group.output_buffer(std::string(""));
-          RowReader primary_group_reader(primary_group_buffer.view());
-          
-          while (primary_group_reader.has_next()) {
-            const tuix::Row *primary = primary_group_reader.next();
-            w.append(primary);
-          }
+        if (join_type == tuix::JoinType_LeftSemi) {
+          write_output_rows(primary_matched_rows, w);
+        } else if (join_type == tuix::JoinType_LeftAnti) {
+          write_output_rows(primary_unmatched_rows, w);
         }
 
         primary_group.clear();
+        primary_unmatched_rows.clear();
+        primary_matched_rows.clear();
+        
         primary_group.append(current);
+        primary_unmatched_rows.append(current);
         last_primary_of_group.set(current);
-        
-        pk_fk_match = false;
       }
     } else {
-      // Current row isn't from primary table
-      // Output the joined rows resulting from this foreign row
       if (last_primary_of_group.get()
-          && join_expr_eval.eval_condition(last_primary_of_group.get(), current)) {
-        EnclaveContext::getInstance().set_append_mac(false);
-        auto primary_group_buffer = primary_group.output_buffer(std::string(""));
-        RowReader primary_group_reader(primary_group_buffer.view());
-        while (primary_group_reader.has_next()) {
-          // For each foreign key row, join all primary key rows in same group with it
-          const tuix::Row *primary = primary_group_reader.next();
+          && join_expr_eval.is_same_group(last_primary_of_group.get(), current)) {
+        if (join_type == tuix::JoinType_Inner) {       
+          auto primary_group_buffer = primary_group.output_buffer(std::string(""));
+          RowReader primary_group_reader(primary_group_buffer.view());
+          while (primary_group_reader.has_next()) {
+            const tuix::Row *primary = primary_group_reader.next();
+            test_rows_same_group(join_expr_eval, primary, current);
 
-          if (!join_expr_eval.eval_condition(primary, current)) {
-            throw std::runtime_error(
-              std::string("Invariant violation: rows of primary_group "
-                          "are not of the same group: ")
-              + to_string(primary)
-              + std::string(" vs ")
-              + to_string(current));
+            if (join_expr_eval.eval_condition(primary, current)) {
+              w.append(primary, current);
+            }
           }
+        } else if (join_type == tuix::JoinType_LeftSemi || join_type == tuix::JoinType_LeftAnti) {
+          auto primary_unmatched_rows_buffer = primary_unmatched_rows.output_buffer(std::string(""));
+          RowReader primary_unmatched_rows_reader(primary_unmatched_rows_buffer.view());
+          RowWriter new_primary_unmatched_rows;
 
-          if (join_type == tuix::JoinType_Inner) {
-            w.append(primary, current);
-          } else if (join_type == tuix::JoinType_LeftSemi) {
-            // Only output the pk group ONCE
-            if (!pk_fk_match) {
-              w.append(primary);
+          while (primary_unmatched_rows_reader.has_next()) {
+            const tuix::Row *primary = primary_unmatched_rows_reader.next();
+            test_rows_same_group(join_expr_eval, primary, current);
+            if (join_expr_eval.eval_condition(primary, current)) {
+              primary_matched_rows.append(primary);
+            } else {
+              new_primary_unmatched_rows.append(primary);
             }
           }
+           
+          // Reset primary_unmatched_rows
+          primary_unmatched_rows.clear();
+          auto new_primary_unmatched_rows_buffer = new_primary_unmatched_rows.output_buffer(std::string(""));
+          RowReader new_primary_unmatched_rows_reader(new_primary_unmatched_rows_buffer.view());
+          while (new_primary_unmatched_rows_reader.has_next()) {
+            primary_unmatched_rows.append(new_primary_unmatched_rows_reader.next());
+          }
         }
-
-        pk_fk_match = true;
-      } else {
-        // If pk_fk_match were true, and the code got to here, then that means the group match has not been "cleared" yet
-        // It will be processed when the code advances to the next pk group
-        pk_fk_match &= true;
       }
     }
   }
 
-  if (join_type == tuix::JoinType_LeftAnti && !pk_fk_match) {
-    EnclaveContext::getInstance().set_append_mac(false);
-    auto primary_group_buffer = primary_group.output_buffer(std::string(""));
-    RowReader primary_group_reader(primary_group_buffer.view());
-          
-    while (primary_group_reader.has_next()) {
-      const tuix::Row *primary = primary_group_reader.next();
-      w.append(primary);
-    }
+  if (join_type == tuix::JoinType_LeftSemi) {
+    write_output_rows(primary_matched_rows, w);
+  } else if (join_type == tuix::JoinType_LeftAnti) {
+    write_output_rows(primary_unmatched_rows, w);
   }
 
   EnclaveContext::getInstance().set_append_mac(true);

src/main/scala/edu/berkeley/cs/rise/opaque/JobVerificationEngine.scala

@@ -544,7 +544,8 @@ object JobVerificationEngine {
     if (!arePathsEqual) {
       // println(executedPathsToSink.toString)
       // println(expectedPathsToSink.toString)
-      println("===========DAGS NOT EQUAL===========")
+      // println("===========DAGS NOT EQUAL===========")
+      return false
     }
     return true 
   }

src/main/scala/edu/berkeley/cs/rise/opaque/Utils.scala

@@ -1279,7 +1279,7 @@ object Utils extends Logging {
   def serializeJoinExpression(
     joinType: JoinType, leftKeys: Option[Seq[Expression]], rightKeys: Option[Seq[Expression]],
     leftSchema: Seq[Attribute], rightSchema: Seq[Attribute],
-    condition: Option[Expression] = None): Array[Byte] = {
+    condition: Option[Expression]): Array[Byte] = {
     val builder = new FlatBufferBuilder
     builder.finish(
       tuix.JoinExpr.createJoinExpr(
@@ -1318,7 +1318,7 @@ object Utils extends Logging {
         condition match {
           case Some(condition) =>
             flatbuffersSerializeExpression(builder, condition, leftSchema ++ rightSchema)
-          case _ => 0
+          case None => 0
         }))
     builder.sizedByteArray()
   }

src/main/scala/edu/berkeley/cs/rise/opaque/benchmark/TPCHBenchmark.scala

@@ -24,7 +24,7 @@ import org.apache.spark.sql.SQLContext
 object TPCHBenchmark {
 
   // Add query numbers here once they are supported
-  val supportedQueries = Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 17, 19, 20, 22)
+  val supportedQueries = Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 17, 18, 19, 20, 21, 22)
 
   def query(queryNumber: Int, tpch: TPCH, sqlContext: SQLContext, numPartitions: Int) = {
     val sqlStr = tpch.getQuery(queryNumber)

src/main/scala/edu/berkeley/cs/rise/opaque/execution/operators.scala

@@ -292,6 +292,7 @@ case class EncryptedSortMergeJoinExec(
     rightKeys: Seq[Expression],
     leftSchema: Seq[Attribute],
     rightSchema: Seq[Attribute],
+    condition: Option[Expression],
     child: SparkPlan)
     extends UnaryExecNode with OpaqueOperatorExec {
 
@@ -304,7 +305,7 @@ case class EncryptedSortMergeJoinExec(
 
   override def executeBlocked(): RDD[Block] = {
     val joinExprSer = Utils.serializeJoinExpression(
-      joinType, Some(leftKeys), Some(rightKeys), leftSchema, rightSchema)
+      joinType, Some(leftKeys), Some(rightKeys), leftSchema, rightSchema, condition)
 
     timeOperator(
       child.asInstanceOf[OpaqueOperatorExec].executeBlocked(),

src/main/scala/edu/berkeley/cs/rise/opaque/strategies.scala

@@ -98,19 +98,35 @@ object OpaqueOperators extends Strategy {
         rightKeysProj,
         leftProjSchema.map(_.toAttribute),
         rightProjSchema.map(_.toAttribute),
+        condition, 
         sorted)
 
       val tagsDropped = joinType match {
         case Inner => EncryptedProjectExec(dropTags(left.output, right.output), joined)
         case LeftSemi | LeftAnti => EncryptedProjectExec(left.output, joined)
       }
 
-      val filtered = condition match {
-        case Some(condition) => EncryptedFilterExec(condition, tagsDropped)
-        case None => tagsDropped
-      }
+      tagsDropped :: Nil
+
+    // Used to match non-equi joins
+    case Join(left, right, joinType, condition, hint) if isEncrypted(left) && isEncrypted(right) =>
+      // How to pick broadcast side: if left join, broadcast right. If right join, broadcast left.
+      // This is the simplest and most performant method, but may be worth revisting if one side is
+      // significantly smaller than the other. Otherwise, pick the smallest side to broadcast.
+      // NOTE: the current implementation of BNLJ only works under the assumption that
+      // left join <==> broadcast right AND right join <==> broadcast left.
+      val desiredBuildSide = if (joinType.isInstanceOf[InnerLike] || joinType == FullOuter)
+          getSmallerSide(left, right) else
+          getBroadcastSideBNLJ(joinType)
+
+      val joined = EncryptedBroadcastNestedLoopJoinExec(
+        planLater(left),
+        planLater(right),
+        desiredBuildSide,
+        joinType,
+        condition)
 
-      filtered :: Nil
+      joined :: Nil
 
     // Used to match non-equi joins
     case Join(left, right, joinType, condition, hint) if isEncrypted(left) && isEncrypted(right) =>