Method execute_union

graphlite/src/exec/executor.rs:7655–7755

Execute UNION operation

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

    /// Execute UNION operation
    fn execute_union(
        &self,
        left: QueryResult,
        right: QueryResult,
        distinct: bool,
    ) -> Result<QueryResult, ExecutionError> {
        // 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();
        let target_variables;

        if use_identity {
            // Identity-based UNION: combine rows and optionally deduplicate by entity identity
            // Don't convert to positional - preserve source_entities
            target_variables = if left.variables.is_empty() && !right.variables.is_empty() {
                right.variables.clone()
            } else {
                left.variables.clone()
            };

            // Add all left rows
            result_rows.extend(left.rows);

            // Handle UNION vs UNION ALL
            // Note: 'distinct' parameter is 'keep_all' - true for UNION ALL, false for UNION
            if distinct {
                // UNION ALL: Keep all rows, no deduplication
                result_rows.extend(right.rows);
            } else {
                // UNION: Deduplicate by identity
                for right_row in right.rows {
                    if !right_row.has_entities() {
                        // No entities, add unconditionally
                        result_rows.push(right_row);
                        continue;
                    }

                    // Check if this entity already exists in result
                    let mut found = false;
                    for result_row in &result_rows {
                        if result_row.has_entities()
                            && self.rows_equal_by_identity(&right_row, result_row)
                        {
                            found = true;
                            break;
                        }
                    }

                    if !found {
                        result_rows.push(right_row);
                    }
                }
            }
        } else {
            // Value-based UNION: convert to positional format for proper set operation semantics
            // Choose target variables from the non-empty side for alignment