Method execute_except

graphlite/src/exec/executor.rs:7936–8016

Execute EXCEPT operation

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

    /// Execute EXCEPT operation
    fn execute_except(
        &self,
        left: QueryResult,
        right: QueryResult,
        distinct: bool,
    ) -> Result<QueryResult, ExecutionError> {
        use std::collections::HashSet;

        // 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());

        let mut result_rows = Vec::new();

        if use_identity {
            // Identity-based EXCEPT: remove rows from left that match by entity identity in right
            // Don't convert to positional - preserve source_entities
            for left_row in left.rows {
                if !left_row.has_entities() {
                    // No entities, keep it (can't match by identity)
                    result_rows.push(left_row);
                    continue;
                }

                // Check if this left row's entity exists in right
                let mut found_in_right = false;
                for right_row in &right.rows {
                    if right_row.has_entities() && self.rows_equal_by_identity(&left_row, right_row)
                    {
                        found_in_right = true;
                        break;
                    }
                }

                // Only keep if NOT found in right
                if !found_in_right {
                    result_rows.push(left_row);
                }
            }

            // Note: For identity-based EXCEPT, 'distinct' is handled by identity uniqueness
        } else {
            // Value-based EXCEPT: convert to positional format for proper set operation semantics
            let left_positional = self.convert_to_positional_rows(left.rows, &left.variables);
            let right_positional = self.convert_to_positional_rows_aligned(
                right.rows,
                &right.variables,
                &left.variables,
            );

            let right_set: HashSet<Row> = right_positional.into_iter().collect();

            for row in left_positional {
                if !right_set.contains(&row) {
                    result_rows.push(row);
                }
            }