UDF Diff.

benchmark/benchmark_util/benchmark_main.cpp

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 //
-// Modified from the Apache Arrow project for the Terrier project.
+// Modified from the Apache Arrow project for the Noisepage project.
 
 #include "benchmark/benchmark.h"
 #include "benchmark_util/benchmark_config.h"

sample_tpl/agg.tpl

@@ -6,6 +6,10 @@ struct State {
     count: int32
 }
 
+struct OutputStruct {
+    out0: Integer
+}
+
 struct Agg {
     key: Integer
     count: CountStarAggregate
@@ -35,51 +39,43 @@ fun updateAgg(agg: *Agg, vpi: *VectorProjectionIterator) -> nil {
     @aggAdvance(&agg.count, &input)
 }
 
-fun pipeline_1(execCtx: *ExecutionContext, state: *State) -> nil {
+fun pipeline_1(execCtx: *ExecutionContext, state: *State, lam : lambda [(Integer)->nil] ) -> nil {
     var ht = &state.table
     var tvi: TableVectorIterator
     var table_oid = @testCatalogLookup(execCtx, "test_1", "")
     var col_oids: [2]uint32
-    col_oids[0] = @testCatalogLookup(execCtx, "test_1", "colA")
-    col_oids[1] = @testCatalogLookup(execCtx, "test_1", "colB")
+    col_oids[0] = @testCatalogLookup(execCtx, "test_1", "cola")
+    col_oids[1] = @testCatalogLookup(execCtx, "test_1", "colb")
     for (@tableIterInit(&tvi, execCtx, table_oid, col_oids); @tableIterAdvance(&tvi); ) {
         var vec = @tableIterGetVPI(&tvi)
         for (; @vpiHasNext(vec); @vpiAdvance(vec)) {
-            var hash_val = @hash(@vpiGetInt(vec, 1))
-            var agg = @ptrCast(*Agg, @aggHTLookup(ht, hash_val, keyCheck, vec))
-            if (agg == nil) {
-                agg = @ptrCast(*Agg, @aggHTInsert(ht, hash_val))
-                constructAgg(agg, vec)
-            } else {
-                updateAgg(agg, vec)
-            }
+           var output_row: OutputStruct
+           output_row.out0 = @vpiGetIntNull(vec, 0)
+           lam(output_row.out0)
         }
     }
     @tableIterClose(&tvi)
 }
 
-fun pipeline_2(state: *State) -> nil {
-    var aht_iter: AHTIterator
-    var iter = &aht_iter
-    for (@aggHTIterInit(iter, &state.table); @aggHTIterHasNext(iter); @aggHTIterNext(iter)) {
-        var agg = @ptrCast(*Agg, @aggHTIterGetRow(iter))
-        state.count = state.count + 1
-    }
-    @aggHTIterClose(iter)
-}
-
-fun execQuery(execCtx: *ExecutionContext, qs: *State) -> nil {
-    pipeline_1(execCtx, qs)
-    pipeline_2(qs)
+fun execQuery(execCtx: *ExecutionContext, qs: *State, lam : lambda [(Integer)->nil] ) -> nil {
+    pipeline_1(execCtx, qs, lam)
 }
 
 fun main(execCtx: *ExecutionContext) -> int32 {
+    var count : Integer
+    count = @intToSql(0)
+    var lam = lambda [count] (x : Integer) -> nil {
+                        count = count + 1
+                    }
     var state: State
 
     setUpState(execCtx, &state)
-    execQuery(execCtx, &state)
+    execQuery(execCtx, &state, lam)
     tearDownState(&state)
 
     var ret = state.count
-    return ret
+    if(count > 0) {
+        return 1
+    }
+    return 0
 }

sample_tpl/call.tpl

@@ -1,8 +1,43 @@
 // Expected output: 70
 
-fun f(x: int) -> int { return x * 7 }
+fun f(z : Date ) -> Date { return z  }
 
-fun main() -> int {
-    var x = 10
-    return f(x)
+fun main(exec : *ExecutionContext) -> int32 {
+    var y = 11
+    var lam = lambda [y] (z: Integer ) -> nil {
+                    y = y + z
+                }
+    lam(10)
+
+
+    var d = @dateToSql(1999, 2, 11)
+    //f(lam, d)
+    var k : Date
+    //var h = &k
+    //*h = d
+    //k = f(d)
+    lam(d)
+    if(@datePart(y, @intToSql(21)) == @intToSql(1999)){
+        // good
+        return 1
+    }
+    return 0
 }
+
+fun pipeline1(QueryState *q) {
+    TableIterator tvi;
+    for(@tableIteratorAdvance(&tvi)){
+        @hashTableInsert(q.join_ht, @getTupleValue(&tvi, 3)))
+    }
+}
+
+fun pipeline2(QueryState *q) {
+    TableIterator tvi;
+    for(@tableIteratorAdvance(&tvi)){
+        var o_custkey = @getTupleValue(&tvi, 1)
+        if(@hashTableKeyExists(q.join_ht, o_custkey)){
+            var out = @outputBufferAlloc(q.output_buff)
+            out.col1 = o_custkey + 1
+        }
+    }
+}

sample_tpl/cte_scan_temp_table_insert.tpl

@@ -0,0 +1,58 @@
+// Expected output: 11 (number of output rows)
+// SQL: INSERT INTO temp_table SELECT colA FROM test_1 WHERE colA BETWEEN 495 AND 505; SELECT * FROM temp_table;
+
+fun main(execCtx: *ExecutionContext) -> int32 {
+  var TEMP_OID_MASK: uint64 = 2147483648                       // 2^31
+
+  // Init inserter
+  var col_types: [1]uint32
+  col_types[0] = 4 // colA
+  var temp_col_oids: [1]uint32
+  temp_col_oids[0] = TEMP_OID_MASK | 1 // colA
+  var cte_scan_iterator: CteScanIterator
+  @cteScanInit(&cte_scan_iterator, execCtx, TEMP_OID_MASK, temp_col_oids, col_types)
+
+  var col_oids: [1]uint32
+  col_oids[0] = @testCatalogLookup(execCtx, "test_1", "colA")
+
+  // Iterate through rows with colA between 495 and 505
+  // Init index iterator
+  var index : IndexIterator
+  var index_oid : int32
+  var test_oid : int32
+  test_oid = @testCatalogLookup(execCtx, "test_1", "")
+  index_oid = @testCatalogIndexLookup(execCtx, "index_1")
+  @indexIteratorInit(&index, execCtx, 1, test_oid, index_oid, col_oids)
+  // Set iteration bounds
+  var lo_index_pr = @indexIteratorGetLoPR(&index)
+  var hi_index_pr = @indexIteratorGetHiPR(&index)
+  @prSetInt(lo_index_pr, 0, @intToSql(495)) // Set colA in lo
+  @prSetInt(hi_index_pr, 0, @intToSql(505)) // Set colA in hi
+  for (@indexIteratorScanAscending(&index, 0, 0); @indexIteratorAdvance(&index);) {
+    // Materialize the current match.
+    var table_pr = @indexIteratorGetTablePR(&index)
+    var colA = @prGetInt(table_pr, 0)
+    var slot = @indexIteratorGetSlot(&index)
+
+    // Insert into temp table
+    var insert_temp_table_pr = @cteScanGetInsertTempTablePR(&cte_scan_iterator)
+    @prSetInt(insert_temp_table_pr, 0, colA)
+    var insert_temp_table_slot = @cteScanTableInsert(&cte_scan_iterator)
+  }
+  @indexIteratorFree(&index)
+
+  var ret = 0
+  var tvi: TableVectorIterator
+  @tableIterInit(&tvi, execCtx, TEMP_OID_MASK, temp_col_oids)
+  for (@tableIterAdvance(&tvi)) {
+    var vpi = @tableIterGetVPI(&tvi)
+    for (; @vpiHasNext(vpi); @vpiAdvance(vpi)) {
+      var cola = @vpiGetInt(vpi, 0)
+        ret = ret + 1
+    }
+    @vpiReset(vpi)
+  }
+  @tableIterClose(&tvi)
+  @cteScanFree(&cte_scan_iterator)
+  return ret
+}

sample_tpl/ind_cte_scan_temp_table_insert.tpl

@@ -0,0 +1,65 @@
+// Expected output: 20 (number of output rows)
+// Perform the following
+//      INSERT INTO temp_table SELECT colA FROM test_1 WHERE colA BETWEEN 1 AND 20;
+//      Call temp_table Accumulate()
+
+fun main(exec_ctx: *ExecutionContext) -> int32 {
+  // Initialize CTE Scan Iterator
+  var TEMP_OID_MASK: uint64 = 2147483648                       // 2^31
+  var col_types: [1]uint32
+  col_types[0] = 4
+
+  var temp_col_oids: [1]uint32
+  temp_col_oids[0] = TEMP_OID_MASK | 1 // colA
+
+  var cte_scan: IndCteScanIterator
+  @indCteScanInit(&cte_scan, exec_ctx, TEMP_OID_MASK, temp_col_oids, col_types, false)
+
+  var col_oids: [1]uint32
+  col_oids[0] = @testCatalogLookup(exec_ctx, "test_1", "colA")
+
+  // Iterate from 1 -> 20
+  var index_iter : IndexIterator
+  var index_oid : int32
+  var test_oid : int32
+  test_oid = @testCatalogLookup(exec_ctx, "test_1", "")
+  index_oid = @testCatalogIndexLookup(exec_ctx, "index_1")
+  @indexIteratorInit(&index_iter, exec_ctx, 1, test_oid, index_oid, col_oids)
+  var lo_pr = @indexIteratorGetLoPR(&index_iter)
+  var hi_pr = @indexIteratorGetHiPR(&index_iter)
+  @prSetInt(lo_pr, 0, @intToSql(1))
+  @prSetInt(hi_pr, 0, @intToSql(20))
+
+  // Insert values 1, 2, ... 20 into temp table
+  for (@indexIteratorScanAscending(&index_iter, 0, 0); @indexIteratorAdvance(&index_iter); ) {
+    // Get entry
+    var cur_pr = @indexIteratorGetTablePR(&index_iter)
+    var cur_val = @prGetInt(cur_pr, 0)
+    var slot = @indexIteratorGetSlot(&index_iter)
+
+    // Insert entry
+    var insert_pr = @indCteScanGetInsertTempTablePR(&cte_scan)
+    @prSetInt(insert_pr, 0, cur_val)
+    var insert_temp_table_slot = @indCteScanTableInsert(&cte_scan)
+  }
+  var acc_bool = @indCteScanAccumulate(&cte_scan)
+  // Test accumulate on empty WriteTable
+  acc_bool = @indCteScanAccumulate(&cte_scan)
+  @indexIteratorFree(&index_iter)
+  var cte = @indCteScanGetReadCte(&cte_scan)
+
+  var ret = 0
+  var tvi: TableVectorIterator
+  @tableIterInit(&tvi, exec_ctx, TEMP_OID_MASK, temp_col_oids)
+  for (@tableIterAdvance(&tvi)) {
+    var vpi = @tableIterGetVPI(&tvi)
+    for (; @vpiHasNext(vpi); @vpiAdvance(vpi)) {
+      var cola = @vpiGetInt(vpi, 0)
+        ret = ret + 1
+    }
+    @vpiReset(vpi)
+  }
+  @tableIterClose(&tvi)
+  @indCteScanFree(&cte_scan)
+  return ret
+}