Method project_statistics

datafusion/physical-expr/src/projection.rs:654–727

Project statistics according to this projection. For example, for a projection `SELECT a AS x, b + 1 AS y`, where `a` is at index 0 and `b` is at index 1, if the input statistics has column statistics for columns `a`, `b`, and `c`, the output statistics would have column statistics for columns `x` and `y`. # Example ```rust use arrow::datatypes::{DataType, Field, Schema}; use datafusion_common::

(
        &self,
        mut stats: Statistics,
        output_schema: &Schema,
    )

    /// }
    /// ```
    pub fn project_statistics(
        &self,
        mut stats: Statistics,
        output_schema: &Schema,
    ) -> Result<Statistics> {
        let mut column_statistics = Vec::with_capacity(self.exprs.len());

        for proj_expr in self.exprs.iter() {
            let expr = &proj_expr.expr;
            let col_stats = if let Some(col) = expr.downcast_ref::<Column>() {
                std::mem::take(&mut stats.column_statistics[col.index()])
            } else if let Some(literal) = expr.downcast_ref::<Literal>() {
                // Handle literal expressions (constants) by calculating proper statistics
                let data_type = expr.data_type(output_schema)?;

                if literal.value().is_null() {
                    let null_count = match stats.num_rows {
                        Precision::Exact(num_rows) => Precision::Exact(num_rows),
                        _ => Precision::Absent,
                    };

                    ColumnStatistics {
                        min_value: Precision::Exact(literal.value().clone()),
                        max_value: Precision::Exact(literal.value().clone()),
                        distinct_count: Precision::Exact(1),
                        null_count,
                        sum_value: Precision::Exact(literal.value().clone()),
                        byte_size: Precision::Exact(0),
                    }
                } else {
                    let value = literal.value();
                    let distinct_count = Precision::Exact(1);
                    let null_count = Precision::Exact(0);

                    let byte_size = if let Some(byte_width) = data_type.primitive_width()
                    {
                        stats.num_rows.multiply(&Precision::Exact(byte_width))
                    } else {
                        // Complex types depend on array encoding, so set to Absent
                        Precision::Absent
                    };

                    let widened_sum = Precision::Exact(value.clone()).cast_to_sum_type();
                    let sum_value = widened_sum
                        .get_value()
                        .and_then(|sum| {
                            Precision::<ScalarValue>::from(stats.num_rows)
                                .cast_to(&sum.data_type())
                                .ok()
                        })
                        .map(|row_count| widened_sum.multiply(&row_count))
                        .unwrap_or(Precision::Absent);

                    ColumnStatistics {
                        min_value: Precision::Exact(value.clone()),
                        max_value: Precision::Exact(value.clone()),
                        distinct_count,
                        null_count,