Method execute_with_query_with_context

graphlite/src/exec/executor.rs:1179–1283

Execute a WITH query as a pipeline of segments

(
        &self,
        with_query: &WithQuery,
        outer_context: &ExecutionContext,
    )

    /// Execute a WITH query as a pipeline of segments
    fn execute_with_query_with_context(
        &self,
        with_query: &WithQuery,
        outer_context: &ExecutionContext,
    ) -> Result<QueryResult, ExecutionError> {
        log::debug!(
            "Starting WITH query execution with {} segments",
            with_query.segments.len()
        );
        let mut current_context = outer_context.clone();

        let mut final_results = Vec::new();

        // Execute each query segment in sequence, piping results forward
        for (i, segment) in with_query.segments.iter().enumerate() {
            // Execute MATCH clause for this segment
            let mut segment_results =
                self.execute_match_with_context(&segment.match_clause, &current_context)?;

            // Apply WHERE clause if present (this is the WHERE clause that comes BEFORE WITH)
            if let Some(where_clause) = &segment.where_clause {
                segment_results = self.apply_where_filter_to_rows(
                    segment_results,
                    where_clause,
                    &current_context,
                )?;
            }

            // Apply WITH clause to transform and filter results (if present)
            let mut with_results = if let Some(with_clause) = &segment.with_clause {
                log::debug!(
                    "Executing WITH clause on {} input rows",
                    segment_results.len()
                );
                self.execute_with_clause(with_clause, segment_results, &current_context)?
            } else {
                log::debug!(
                    "No WITH clause, passing through {} rows",
                    segment_results.len()
                );
                segment_results
            };

            // Apply UNWIND clause if present (expands lists into rows)
            if let Some(unwind_clause) = &segment.unwind_clause {
                log::debug!("Executing UNWIND clause after WITH");
                with_results =
                    self.execute_unwind_on_rows(unwind_clause, with_results, &current_context)?;
            }

            // Apply post-UNWIND WHERE clause if present
            if let Some(where_clause) = &segment.post_unwind_where {
                log::debug!("Applying WHERE clause after UNWIND");
                with_results = self.apply_where_filter_to_rows_vec(
                    with_results,
                    where_clause,
                    &current_context,
                )?;