Compile time optimizations

src/execution_plan/execution_plan_build/execution_plan_util.c

@@ -5,13 +5,16 @@
  */
 
 #include "execution_plan_util.h"
+#include "../ops/op_skip.h"
+#include "../ops/op_limit.h"
 
 // returns true if an operation in the op-tree rooted at `root` is eager
 bool ExecutionPlan_isEager
 (
     OpBase *root
 ) {
-	return ExecutionPlan_LocateOpMatchingTypes(root, EAGER_OPERATIONS, 6) != NULL;
+	return ExecutionPlan_LocateOpMatchingTypes(root, EAGER_OPERATIONS,
+			EAGER_OP_COUNT) != NULL;
 }
 
 OpBase *ExecutionPlan_LocateOpResolvingAlias
@@ -189,6 +192,62 @@ OpBase *ExecutionPlan_LocateReferencesExcludingOps
 	return resolving_op;
 }
 
+// scans plan from root via parent nodes until a limit operation is found
+// eager operation will terminate the scan
+// return true if a limit operation was found, in which case 'limit' is set
+// otherwise return false
+bool ExecutionPlan_ContainsLimit
+(
+	OpBase *root,    // root to start the scan from
+	uint64_t *limit  // limit value
+) {
+	ASSERT(root  != NULL);
+	ASSERT(limit != NULL);
+
+	while(root != NULL) {
+		// halt if we encounter an eager operation
+		if(ExecutionPlan_isEager(root)) return false;
+
+		// found a limit operation
+		if(root->type == OPType_LIMIT) {
+			*limit = ((const OpLimit*)root)->limit;
+			return true;
+		}
+
+		root = root->parent;
+	}
+
+	return false;
+}
+
+// scans plan from root via parent nodes until a skip operation is found
+// eager operation will terminate the scan
+// return true if a skip operation was found, in which case 'skip' is set
+// otherwise return false
+bool ExecutionPlan_ContainsSkip
+(
+	OpBase *root,   // root to start the scan from
+	uint64_t *skip  // skip value
+) {
+	ASSERT(root != NULL);
+	ASSERT(skip != NULL);
+
+	while(root != NULL) {
+		// halt if we encounter an eager operation
+		if(ExecutionPlan_isEager(root)) return false;
+
+		// found a skip operation
+		if(root->type == OPType_SKIP) {
+			*skip = ((const OpSkip*)root)->skip;
+			return true;
+		}
+
+		root = root->parent;
+	}
+
+	return false;
+}
+
 OpBase *ExecutionPlan_LocateReferences
 (
 	OpBase *root,

src/execution_plan/execution_plan_build/execution_plan_util.h

@@ -85,6 +85,26 @@ OpBase *ExecutionPlan_LocateReferencesExcludingOps
     rax *refs_to_resolve
 );
 
+// scans plan from root via parent nodes until a limit operation is found
+// eager operation will terminate the scan
+// return true if a limit operation was found, in which case 'limit' is set
+// otherwise return false
+bool ExecutionPlan_ContainsLimit
+(
+	OpBase *root,    // root to start the scan from
+	uint64_t *limit  // limit value
+);
+
+// scans plan from root via parent nodes until a skip operation is found
+// eager operation will terminate the scan
+// return true if a skip operation was found, in which case 'skip' is set
+// otherwise return false
+bool ExecutionPlan_ContainsSkip
+(
+	OpBase *root,   // root to start the scan from
+	uint64_t *skip  // skip value
+);
+
 //------------------------------------------------------------------------------
 // ExecutionPlan_Collect API:
 // For collecting all matching operations in tree.

src/execution_plan/ops/op.c

@@ -238,6 +238,20 @@ bool OpBase_IsWriter
 	return op->writer;
 }
 
+// indicates if the operation is an eager operation
+bool OpBase_IsEager
+(
+	const OpBase *op
+) {
+	ASSERT(op != NULL);
+
+	for(int i = 0; i < EAGER_OP_COUNT; i++) {
+		if(op->type == EAGER_OPERATIONS[i]) return true;
+	}
+
+	return false;
+}
+
 void OpBase_UpdateConsume
 (
 	OpBase *op,

src/execution_plan/ops/op.h

@@ -255,6 +255,12 @@ bool OpBase_IsWriter
 	OpBase *op
 );
 
+// indicates if the operation is an eager operation
+bool OpBase_IsEager
+(
+	const OpBase *op
+);
+
 // update operation consume function
 void OpBase_UpdateConsume
 (

src/execution_plan/ops/op_conditional_traverse.c

@@ -4,10 +4,11 @@
  * the Server Side Public License v1 (SSPLv1).
  */
 
-#include "op_conditional_traverse.h"
 #include "RG.h"
-#include "shared/print_functions.h"
 #include "../../query_ctx.h"
+#include "shared/print_functions.h"
+#include "op_conditional_traverse.h"
+#include "../execution_plan_build/execution_plan_util.h"
 
 // default number of records to accumulate before traversing
 #define BATCH_SIZE 16
@@ -109,11 +110,14 @@ OpBase *NewCondTraverseOp
 
 static OpResult CondTraverseInit(OpBase *opBase) {
 	OpCondTraverse *op = (OpCondTraverse *)opBase;
-	// Create 'records' with this Init function as 'record_cap'
-	// might be set during optimization time (applyLimit)
-	// If cap greater than BATCH_SIZE is specified,
-	// use BATCH_SIZE as the value.
+
+	// in case this operation is restricted by a limit
+	// set record_cap to the specified limit
+	ExecutionPlan_ContainsLimit(opBase, &op->record_cap);
+
+	// record_cap should not be greater than BATCH_SIZE
 	if(op->record_cap > BATCH_SIZE) op->record_cap = BATCH_SIZE;
+
 	op->records = rm_calloc(op->record_cap, sizeof(Record));
 
 	return OP_OK;

src/execution_plan/ops/op_conditional_traverse.h

@@ -24,8 +24,8 @@ typedef struct {
 	RG_MatrixTupleIter iter;    // Iterator over M.
 	int srcNodeIdx;             // Source node index into record.
 	int destNodeIdx;            // Destination node index into record.
-	uint record_count;          // Number of held records.
-	uint record_cap;            // Max number of records to process.
+	uint64_t record_count;      // Number of held records.
+	uint64_t record_cap;        // Max number of records to process.
 	Record *records;            // Array of records.
 	Record r;                   // Currently selected record.
 } OpCondTraverse;

src/execution_plan/ops/op_expand_into.c

@@ -5,8 +5,9 @@
  */
 
 #include "op_expand_into.h"
-#include "shared/print_functions.h"
 #include "../../query_ctx.h"
+#include "shared/print_functions.h"
+#include "../execution_plan_build/execution_plan_util.h"
 
 // default number of records to accumulate before traversing
 #define BATCH_SIZE 16
@@ -131,6 +132,10 @@ static OpResult ExpandIntoInit
 ) {
 	OpExpandInto *op = (OpExpandInto *)opBase;
 
+	// in case this operation is restricted by a limit
+	// set record_cap to the specified limit
+	ExecutionPlan_ContainsLimit(opBase, &op->record_cap);
+
 	// see if we can optimize by avoiding matrix multiplication
 	// if the algebraic expression passed in is just a single operand
 	// there's no need to compute F and perform F*X, we can simply inspect X
@@ -161,10 +166,7 @@ static OpResult ExpandIntoInit
 		}
 	}
 
-	// create 'records' within this Init function as 'record_cap'
-	// might be set during optimization time (applyLimit)
-	// If cap greater than BATCH_SIZE is specified,
-	// use BATCH_SIZE as the value.
+	// allocate record buffer, limited to a maximum of BATCH_SIZE
 	if(op->record_cap > BATCH_SIZE) op->record_cap = BATCH_SIZE;
 
 	op->records = rm_calloc(op->record_cap, sizeof(Record));

src/execution_plan/ops/op_expand_into.h

@@ -23,8 +23,8 @@ typedef struct {
 	int srcNodeIdx;             // source node index into record
 	int destNodeIdx;            // destination node index into record
 	bool single_operand;        // expression contains a single operand
-	uint record_count;          // number of held records
-	uint record_cap;            // max number of records to process
+	uint64_t record_count;      // number of held records
+	uint64_t record_cap;        // max number of records to process
 	Record *records;            // array of records
 	Record r;                   // currently selected record
 } OpExpandInto;

src/execution_plan/ops/op_sort.c

@@ -8,9 +8,10 @@
 #include "op_project.h"
 #include "op_aggregate.h"
 #include "../../util/arr.h"
+#include "../../query_ctx.h"
 #include "../../util/qsort.h"
 #include "../../util/rmalloc.h"
-#include "../../query_ctx.h"
+#include "../execution_plan_build/execution_plan_util.h"
 
 // forward declarations
 static OpResult SortInit(OpBase *opBase);
@@ -111,6 +112,11 @@ OpBase *NewSortOp
 
 static OpResult SortInit(OpBase *opBase) {
 	OpSort *op = (OpSort *)opBase;
+
+	// set skip and limit if present in the execution-plan
+	ExecutionPlan_ContainsSkip(opBase, &op->skip);
+	ExecutionPlan_ContainsLimit(opBase, &op->limit);
+
 	// if there is LIMIT value, l, set in the current clause,
 	// the operation must return the top l records with respect to
 	// the sorting criteria. In order to do so, it must collect the l records,

src/execution_plan/ops/op_sort.h

@@ -16,9 +16,9 @@ typedef struct {
 	Record *buffer;        // Holds all records.
 	heap_t *heap;          // Holds top n records.
 	bool first;            // first visit to consume func
-	uint skip;             // Total number of records to skip
+	uint64_t skip;         // Total number of records to skip
 	uint record_idx;       // index of current record to return
-	uint limit;            // Total number of records to produce
+	uint64_t limit;        // Total number of records to produce
 	uint *record_offsets;  // All Record offsets containing values to sort by
 	int *directions;       // Array of sort directions(ascending / descending)
 	AR_ExpNode **exps;     // Projected expressons.

src/execution_plan/optimizations/optimize_label_scan.c → src/execution_plan/optimizations/cost_base_label_scan.c

@@ -34,7 +34,7 @@
 // Scan(B)
 // Traverse A*R
 
-static void _optimizeLabelScan
+static void _costBaseLabelScan
 (
 	NodeByLabelScan *scan
 ) {
@@ -127,7 +127,7 @@ static void _optimizeLabelScan
 	_AlgebraicExpression_InplaceRepurpose(operand, replacement);
 }
 
-void optimizeLabelScan
+void costBaseLabelScan
 (
 	ExecutionPlan *plan
 ) {
@@ -142,7 +142,7 @@ void optimizeLabelScan
 	uint op_count = array_len(label_scan_ops);
 	for(uint i = 0; i < op_count; i++) {
 		NodeByLabelScan *label_scan = (NodeByLabelScan*)label_scan_ops[i];
-		_optimizeLabelScan(label_scan);
+		_costBaseLabelScan(label_scan);
 	}
 	array_free(label_scan_ops);
 }