Method apply_order_by

graphlite/src/exec/executor.rs:8405–8457

Apply ORDER BY clause to query result

(
        &self,
        mut result: QueryResult,
        order_clause: &crate::ast::OrderClause,
        context: &ExecutionContext,
    )

    /// Apply ORDER BY clause to query result
    fn apply_order_by(
        &self,
        mut result: QueryResult,
        order_clause: &crate::ast::OrderClause,
        context: &ExecutionContext,
    ) -> Result<QueryResult, ExecutionError> {
        use std::cmp::Ordering;

        result.rows.sort_by(|a, b| {
            for order_item in &order_clause.items {
                // Evaluate the expression for both rows using cloned context
                let mut context_a = context.clone();
                for var_name in &result.variables {
                    if let Some(value) = a.values.get(var_name) {
                        context_a.set_variable(var_name.clone(), value.clone());
                    }
                }

                let mut context_b = context.clone();
                for var_name in &result.variables {
                    if let Some(value) = b.values.get(var_name) {
                        context_b.set_variable(var_name.clone(), value.clone());
                    }
                }

                let val_a = self.evaluate_expression(&order_item.expression, &context_a);
                let val_b = self.evaluate_expression(&order_item.expression, &context_b);

                let ordering = match (val_a, val_b) {
                    (Ok(Value::String(s1)), Ok(Value::String(s2))) => s1.cmp(&s2),
                    (Ok(Value::Number(n1)), Ok(Value::Number(n2))) => {
                        n1.partial_cmp(&n2).unwrap_or(Ordering::Equal)
                    }
                    (Ok(Value::Null), Ok(Value::Null)) => Ordering::Equal,
                    (Ok(Value::Null), _) => Ordering::Less,
                    (_, Ok(Value::Null)) => Ordering::Greater,
                    _ => Ordering::Equal,
                };

                let final_ordering = match order_item.direction {
                    crate::ast::OrderDirection::Ascending => ordering,
                    crate::ast::OrderDirection::Descending => ordering.reverse(),
                };

                if final_ordering != Ordering::Equal {
                    return final_ordering;
                }
            }
            Ordering::Equal
        });

        Ok(result)
    }

    /// Apply LIMIT clause to query result
    fn apply_limit(