Function ExecutionPlan_Free

src/execution_plan/execution_plan.c:549–611

free the execution plans and all of the operations

// free the execution plans and all of the operations
void ExecutionPlan_Free
(
	ExecutionPlan *plan
) {
	ASSERT(plan != NULL);
	if(plan->root == NULL) {
		_ExecutionPlan_FreeInternals(plan);
		return;
	}

	// -------------------------------------------------------------------------
	// free op tree and collect execution-plans
	// -------------------------------------------------------------------------

	// traverse the execution-plan graph (DAG -> no endless cycles), while
	// collecting the different segments, and freeing the op tree
	dict *plans = HashTableCreate(&def_dt);
	OpBase **visited = array_new(OpBase *, 1);
	OpBase **to_visit = array_new(OpBase *, 1);

	OpBase *op = plan->root;
	array_append(to_visit, op);

	while(array_len(to_visit) > 0) {
		op = array_pop(to_visit);

		// add the plan this op is affiliated with
		HashTableAdd(plans, (void *)op->plan, (void *)op->plan);

		// add all direct children of op to to_visit
		for(uint i = 0; i < op->childCount; i++) {
			if(op->children[i] != NULL) {
				array_append(to_visit, op->children[i]);
			}
		}

		// add op to `visited` array
		array_append(visited, op);
	}

	// free the collected ops
	for(int i = array_len(visited)-1; i >= 0; i--) {
		op = visited[i];
		OpBase_Free(op);
	}
	array_free(visited);
	array_free(to_visit);

	// -------------------------------------------------------------------------
	// free internals of the plans
	// -------------------------------------------------------------------------

	dictEntry *entry;
	ExecutionPlan *curr_plan;
	dictIterator *it = HashTableGetIterator(plans);
	while((entry = HashTableNext(it)) != NULL) {
		curr_plan = (ExecutionPlan *)HashTableGetVal(entry);
		_ExecutionPlan_FreeInternals(curr_plan);