Method execute_intersect

graphlite/src/exec/executor.rs:7758–7900

Execute INTERSECT operation

(
        &self,
        left: QueryResult,
        right: QueryResult,
        distinct: bool,
    )

    /// Execute INTERSECT operation
    fn execute_intersect(
        &self,
        left: QueryResult,
        right: QueryResult,
        distinct: bool,
    ) -> Result<QueryResult, ExecutionError> {
        log::debug!("=== EXECUTE_INTERSECT CALLED");
        log::debug!(
            "Left: {} rows, variables: {:?}",
            left.rows.len(),
            left.variables
        );
        log::debug!(
            "Right: {} rows, variables: {:?}",
            right.rows.len(),
            right.variables
        );

        // Check if we should use identity-based or value-based comparison
        let use_identity = left.rows.iter().any(|r| r.has_entities())
            || right.rows.iter().any(|r| r.has_entities());

        log::debug!(
            "Using {} comparison",
            if use_identity {
                "identity-based"
            } else {
                "value-based"
            }
        );

        let mut result_rows = Vec::new();

        if use_identity {
            // Identity-based INTERSECT: compare by source entities
            for (left_idx, left_row) in left.rows.iter().enumerate() {
                // Skip rows without entities
                if !left_row.has_entities() {
                    log::debug!("Skipping left row {} (no entities)", left_idx);
                    continue;
                }

                for (right_idx, right_row) in right.rows.iter().enumerate() {
                    if !right_row.has_entities() {
                        log::debug!("Skipping right row {} (no entities)", right_idx);
                        continue;
                    }

                    // Compare by entity identity
                    if self.rows_equal_by_identity(left_row, right_row) {
                        log::debug!(
                            "MATCH (identity): Left row {} matches right row {}",
                            left_idx,
                            right_idx
                        );
                        result_rows.push(left_row.clone());
                        break; // Found match, no need to check other right rows
                    }