Function _tie_segments

src/execution_plan/execution_plan.c:227–339

}

static ExecutionPlan *_tie_segments
(
	ExecutionPlan **segments,
	uint segment_count
) {
	FT_FilterNode  *ft                  =  NULL; // filters following WITH
	OpBase         *connecting_op       =  NULL; // op connecting one segment to another
	OpBase         *prev_connecting_op  =  NULL; // root of previous segment
	ExecutionPlan  *prev_segment        =  NULL;
	ExecutionPlan  *current_segment     =  NULL;
	AST            *master_ast          =  QueryCtx_GetAST();  // top-level AST of plan

	//--------------------------------------------------------------------------
	// merge segments
	//--------------------------------------------------------------------------

	for(int i = 0; i < segment_count; i++) {
		ExecutionPlan *segment = segments[i];
		AST *ast = segment->ast_segment;

		// find the first non-argument op with no children in this segment
		prev_connecting_op = connecting_op;
		// in the case of a single segment with FOREACH as its root, there is no
		// tap (of the current definition)
		// for instance: FOREACH(i in [i] | CREATE (n:N))
		// in any other case, there must be a tap

		ASSERT(_ExecutionPlan_HasLocateTaps(segment->root) == true);

		connecting_op = segment->root;
		while(connecting_op->childCount > 0) {
			connecting_op = connecting_op->children[0];
		}

		// tie the current segment's tap to the previous segment's root op
		if(prev_segment != NULL) {
			// validate the connecting operation
			// the connecting operation may already have children
			// if it's been attached to a previous scope
			ASSERT(connecting_op->type == OPType_PROJECT ||
			       connecting_op->type == OPType_AGGREGATE);

			ExecutionPlan_AddOp(connecting_op, prev_segment->root);
		}

		//----------------------------------------------------------------------
		// build pattern comprehension ops
		//----------------------------------------------------------------------

		// WITH projections
		if(prev_segment != NULL) {
			const cypher_astnode_t *opening_clause = cypher_ast_query_get_clause(ast->root, 0);
			ASSERT(cypher_astnode_type(opening_clause) == CYPHER_AST_WITH);
			uint projections = cypher_ast_with_nprojections(opening_clause);
			for (uint j = 0; j < projections; j++) {
				const cypher_astnode_t *projection = cypher_ast_with_get_projection(opening_clause, j);
				buildPatternComprehensionOps(prev_segment, connecting_op, projection);
				buildPatternPathOps(prev_segment, connecting_op, projection);