Change memory management strategy; Implement hashjoin; other smaller features

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "bats"]
 	path = test/bats-core
 	url = https://github.com/bats-core/bats-core
+[submodule "test/test_helper/bats-assert"]
+	path = test/test_helper/bats-assert
+	url = https://github.com/bats-core/bats-assert.git
+[submodule "test/test_helper/bats-support"]
+	path = test/test_helper/bats-support
+	url = https://github.com/bats-core/bats-support.git

Makefile

@@ -22,7 +22,7 @@ $(ODIR)/%.o: $(SRC)%.c
 	$(CC) -g -c $< -o $@  $(CFLAGS)
 
 dirs:
-	mkdir -p data build/parser build/planner/operators build/binder build/io build/executor build/executor/statements build/bufferpool build/operators
+	mkdir -p data build/parser build/planner/operators build/binder build/io build/executor build/executor/statements build/operators build/util/hashmap
 
 clean:
 	rm -f ./build/squel $(OBJ)

perf/results/count.csv

@@ -1,7 +1,7 @@
 filetype;records;time
-CSV;100000;0:00.05
+CSV;100000;0:00.03
 TDB;100000;0:00.00
-CSV;1000000;0:00.46
+CSV;1000000;0:00.30
 TDB;1000000;0:00.04
-Command terminated by signal 2
-CSV;10000000;0:01.30
+CSV;10000000;0:03.36
+TDB;10000000;0:00.36

perf/results/join.csv

@@ -1,9 +1,9 @@
 filetype;records_left;records_right;time
-CSV;10000;100;0:00.06
-TDB;10000;100;0:00.04
-CSV;10000;1000;0:00.40
-TDB;10000;1000;0:00.39
-CSV;100000;100;0:00.45
-TDB;100000;100;0:00.38
-CSV;100000;1000;0:03.93
-TDB;100000;1000;0:03.80
+CSV;10000;100;0:00.05
+TDB;10000;100;0:00.05
+CSV;10000;1000;0:00.50
+TDB;10000;1000;0:00.51
+CSV;100000;100;0:00.55
+TDB;100000;100;0:00.50
+CSV;100000;1000;0:05.08
+TDB;100000;1000;0:05.01

src/executor/executeStatement.c

@@ -16,6 +16,9 @@ void executeStatement(Node* node) {
         case STMTINSERT:
             executeInsert(node);
             break;
+        case STMTEXPLAIN:
+            executeExplain(node);
+            break;
         default:
             printf("Don't know how execute statement of type %d\n", node->type);
             exit(1);

src/executor/executor.c

@@ -1,7 +1,7 @@
 #include "../include/executor/executor.h"
+#include "../include/executor/tuple.h"
 
 
-Bufferpool* buffpool;
 
 void assignGetTupleFunction(Operator *op) {
 
@@ -25,19 +25,19 @@ void assignGetTupleFunction(Operator *op) {
         case (OP_JOIN):
             op->getTuple = &joinGetTuple;
             break;
+        case (OP_HASHJOIN):
+            op->getTuple = &hashjoinGetTuple;
+            break;
         case (OP_AGGREGATE):
             op->getTuple = &aggregateGetTuple;
             break;
         default:
-            printf("Don't know how to handle op-type %d\n", op->type);
+            printf("EXECUTOR-error: Don't know how to handle op-type %d\n", op->type);
             exit(1);
     }
 }
 
 
-
-
-
 void doAssignGetTupleFunction(Operator* p_op) {
 
     if (p_op == NULL) {
@@ -50,23 +50,19 @@ void doAssignGetTupleFunction(Operator* p_op) {
         doAssignGetTupleFunction(p_op->child);
     }
 
-    if (p_op->type == OP_JOIN) {
+    if (p_op->type == OP_JOIN || p_op->type == OP_HASHJOIN) {
         doAssignGetTupleFunction(p_op->info.join.left);
         doAssignGetTupleFunction(p_op->info.join.right);
     }
 }
 
 
-void execute(Operator* op, bool printColNames, void (*tupleHandler)(int pooloffset)) {
+void execute(Operator* op, bool printColNames, void (*tupleHandler)(Tuple* tpl)) {
 
     if (op == NULL) {
         return;
     }
 
-    buffpool            = calloc(1, sizeof(Bufferpool));
-    buffpool->pool      = calloc(BUFFERPOOLSIZE, 1);
-    buffpool->capacity  = BUFFERPOOLSIZE;
-    buffpool->used      = 0;
 
     doAssignGetTupleFunction(op);
 
@@ -86,14 +82,15 @@ void execute(Operator* op, bool printColNames, void (*tupleHandler)(int pooloffs
     }
 
     // Get tuples one by one
-    int offset;
+    Tuple* tpl = initTupleOfSize(TUPLESIZE);
     for (;;) {
-        offset = op->getTuple(op);
-        if (offset == -1) break;
+        op->getTuple(op, tpl);
+        if (isTupleEmpty(tpl)) break;
+
+        tupleHandler(tpl);
 
-        tupleHandler(offset);
     };
+    freeTuple(tpl);
+
 
-    free(buffpool->pool);
-    free(buffpool);
 }

src/executor/statements/explain.c

@@ -0,0 +1,69 @@
+#include "../../include/executor/executor.h"
+
+void printOp(Operator* op) {
+
+    switch (op->type) {
+        case OP_SCANTDB:
+            printf("OP_SCANTDB");
+            break;
+        case OP_SCAN:
+            printf("OP_SCAN");
+            break;
+        case OP_PROJECT:
+            printf("OP_PROJECT");
+            break;
+        case OP_FILTER:
+            printf("OP_FILTER");
+            break;
+        case OP_JOIN:
+            printf("OP_JOIN");
+            break;
+        case OP_AGGREGATE:
+            printf("OP_AGGREGATE");
+            break;
+        case OP_HASHJOIN:
+            printf("OP_HASHJOIN");
+            break;
+        default:
+            printf("EXPLAIN-error: Unknown operation type");
+            break;
+    }
+
+}
+
+void explainOp(Operator* op) {
+
+    if (!op) return;
+
+    printOp(op);
+    printf("\n");
+
+    if (op->type == OP_FILTER) {
+        explainOp(op->info.filter.next);
+    }
+
+    if (op->type == OP_JOIN || op->type == OP_HASHJOIN) {
+        explainOp(op->info.join.filter);
+        explainOp(op->info.join.left);
+        explainOp(op->info.join.right);
+    }
+
+    if (op->child) {
+        explainOp(op->child);
+    }
+}
+
+
+void executeExplain(Node* node) {
+
+    /* Plan the query */
+    Operator* queryplan = planQuery(node->next);
+
+    /* Print the query plan */
+    printf("******* EXPLAIN **********\n");
+    explainOp(queryplan);
+    printf("**************************\n");
+
+    freeQueryplan(queryplan);
+}
+

src/executor/statements/insert.c

@@ -5,14 +5,14 @@ size_t tupleSize = 0;
 FILE* f = NULL;
 
 
-void handleTupleInsert(int offset) {
+void handleTupleInsert(Tuple* tpl) {
 
     if (f == NULL) {
         printf("No file to insert to\n");
         exit(1);
     }
 
-    size_t bytesWritten = fwrite(getTuple(offset), tupleSize, 1, f);
+    size_t bytesWritten = fwrite(tpl->data, tupleSize, 1, f);
     assert(bytesWritten > 0);
 }
 

src/executor/tuple.c

@@ -0,0 +1,36 @@
+#include "../include/executor/tuple.h"
+
+
+Tuple* initTuple() {
+    Tuple* tpl = malloc(sizeof(Tuple));
+    tpl->size = 0;
+    return tpl;
+}
+
+
+Tuple* initTupleOfSize(size_t p_size) {
+    Tuple* tpl = malloc(sizeof(Tuple));
+    tpl->data = calloc(1, p_size);
+    tpl->size = p_size;
+    return tpl;
+}
+
+
+void* getTupleCol(Tuple* tpl, size_t colOffset) {
+    return tpl->data + colOffset;
+}
+
+void freeTuple(Tuple* tpl) {
+    if (tpl->data) {
+        free(tpl->data);
+    }
+    free(tpl);
+}
+
+size_t isTupleEmpty(Tuple* tpl) {
+    return tpl->size == 0 ? 1 : 0;
+}
+
+void markTupleAsEmpty(Tuple* tpl) {
+    tpl->size = 0;
+}