cleanup

Author: octaviansima

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

@@ -289,7 +289,7 @@ case class EncryptedSortMergeJoinExec(
       case Inner => 
         (leftSchema ++ rightSchema).map(_.toAttribute)
       case LeftOuter =>
-        leftSchema++ rightSchema.map(_.withNullability(true))
+        leftSchema ++ rightSchema.map(_.withNullability(true))
       case LeftSemi | LeftAnti => 
         leftSchema.map(_.toAttribute)
       case _ =>

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

@@ -100,10 +100,9 @@ object OpaqueOperators extends Strategy {
         rightProjSchema.map(_.toAttribute),
         sorted)
 
-
       val tagsDropped = joinType match {
-        case LeftOuter | Inner => EncryptedProjectExec(dropTags(left.output, right.output), joined)
-        case LeftSemi | LeftAnti => EncryptedProjectExec(left.output, joined)
+        case Inner | LeftOuter => EncryptedProjectExec(dropTags(left.output, right.output), joined)
+        case LeftExistence(_) => EncryptedProjectExec(left.output, joined)
       }
 
       val filtered = condition match {

src/test/scala/edu/berkeley/cs/rise/opaque/OpaqueOperatorTests.scala

@@ -452,6 +452,36 @@ trait OpaqueOperatorTests extends OpaqueTestsBase { self =>
     df.collect
   }
 
+  testAgainstSpark("join on floats") { securityLevel =>
+    val p_data = for (i <- 0 to 16) yield (i, i.toFloat, i * 10)
+    val f_data = (0 until 256).map(x => {
+      if (x % 3 == 0)
+        (x, null.asInstanceOf[Float], x * 10)
+      else
+        (x, (x % 16).asInstanceOf[Float], x * 10)
+    }).toSeq
+
+    val p = makeDF(p_data, securityLevel, "id", "pk", "x")
+    val f = makeDF(f_data, securityLevel, "id", "fk", "x")
+    val df = p.join(f, $"pk" === $"fk")
+    df.collect.toSet
+  }
+
+  testAgainstSpark("join on doubles") { securityLevel =>
+    val p_data = for (i <- 0 to 16) yield (i, i.toDouble, i * 10)
+    val f_data = (0 until 256).map(x => {
+      if (x % 3 == 0)
+        (x, null.asInstanceOf[Double], x * 10)
+      else
+        (x, (x % 16).asInstanceOf[Double], x * 10)
+    }).toSeq
+
+    val p = makeDF(p_data, securityLevel, "id", "pk", "x")
+    val f = makeDF(f_data, securityLevel, "id", "fk", "x")
+    val df = p.join(f, $"pk" === $"fk")
+    df.collect.toSet
+  }
+
   def abc(i: Int): String = (i % 3) match {
     case 0 => "A"
     case 1 => "B"