Struct ColumnStats 

pub struct ColumnStats {
    pub min_value: i64,
    pub max_value: i64,
    pub min_value_u64: u64,
    pub max_value_u64: u64,
    pub null_count: u64,
    pub value_count: u64,
    pub sum: f64,
    pub sum_i128: i128,
    pub distinct_count: u32,
}

Statistics for a single column within a row group.

Fields

min_value: i64

Minimum value (as raw i64 bits for i64/f64/bool types).

For f64 columns this uses the total-order mapping from f64_to_ordered_i64 so that min/max comparisons are correct even for negative values.

max_value: i64

Maximum value (as raw i64 bits for i64/f64/bool types).

min_value_u64: u64

Minimum u64 value — used only for u64 columns.

max_value_u64: u64

Maximum u64 value — used only for u64 columns.

null_count: u64

Number of null values.

value_count: u64

Number of non-null values.

sum: f64

Sum of all values (for numeric types, 0 for others).

For float columns this is the canonical sum. For integer columns, use sum_i128 for full precision.

sum_i128: i128

Precise integer sum (i128) for i64/u64 columns.

Avoids the 2^53 precision loss of the f64 sum field. Set to zero for float and non-numeric columns.

distinct_count: u32

Number of distinct values (for string/tag columns, 0 for others).

Implementations

impl ColumnStats

pub fn empty() -> Self

Create empty statistics.

pub fn says_nothing(&self) -> bool

true when these statistics say nothing about the data.

A block with no observed value — every row null, or a block whose statistics were deliberately suppressed because it is encrypted — leaves min/max at their sentinels. A zone map must read that as “unknown”, never as an empty range: min = i64::MAX and max = i64::MIN make every comparison false, so a predicate on an encrypted column pruned every row group and the query returned no rows at all, with the correct key configured.

The distinction from a genuinely all-null block is null_count: an all-null block is impossible to match, and pruning it is correct.

pub fn update_i64(&mut self, value: i64)

Update statistics with a new i64 value.

pub fn update_u64(&mut self, value: u64)

Update statistics with a new u64 value.

Tracks full-precision u64 min/max in dedicated fields. Clamping to i64::MAX instead breaks predicate pushdown above 2^63.

pub fn update_decimal(&mut self, mantissa: i128)

Update statistics with a new decimal mantissa.

The mantissa is an i128 and min_value/max_value are i64, so the zone map records a saturated range. That is deliberate and safe in the only direction that matters: a saturated bound is wider than the true one, so a row group is never pruned that might have matched — the predicate simply stops being selective above 19 digits. sum_i128 stays exact, because a sum is an answer rather than a hint.

pub fn update_f64(&mut self, value: f64)

Update statistics with a new f64 value.

Uses f64_to_ordered_i64 for correct ordering of negative values. NaN values are excluded from min/max tracking (they would sort above +∞, corrupting predicate pushdown) but are still counted in value_count. Only finite values contribute to sum, so computing an average as sum / value_count is only correct when the data contains no NaN or Infinity values.

pub fn update_bool(&mut self, value: bool)

Update statistics with a new boolean value.

pub fn record_null(&mut self)

Record a null value.

pub fn to_bytes(&self) -> Vec<u8>

Serialize stats to bytes (fixed 60-byte layout).

pub fn from_bytes(data: &[u8]) -> Result<Self>

Deserialize stats from bytes.

Errors

Returns an error if data is shorter than 60 bytes.

Trait Implementations

impl Clone for ColumnStats

fn clone(&self) -> ColumnStats

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ColumnStats

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ColumnStats

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ColumnStats

fn eq(&self, other: &ColumnStats) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ColumnStats

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ColumnStats