x

Author: forsaken628

src/common/statistics/src/datum.rs

@@ -34,14 +34,6 @@ impl Datum {
         matches!(self, Datum::Bytes(_))
     }
 
-    pub fn cast_float(self) -> Self {
-        match self {
-            Datum::Int(v) => Datum::Float(F64::from(v as f64)),
-            Datum::UInt(v) => Datum::Float(F64::from(v as f64)),
-            _ => self,
-        }
-    }
-
     pub fn as_double(&self) -> Result<f64, ErrorCode> {
         match self {
             Datum::Bool(v) => Ok(*v as u8 as f64),

src/common/statistics/src/histogram.rs

@@ -14,6 +14,9 @@
 
 use std::fmt;
 
+use databend_common_exception::ErrorCode;
+use databend_common_exception::Result as ExceptionResult;
+
 use crate::Datum;
 use crate::F64;
 use crate::JoinEstimation;
@@ -22,6 +25,25 @@ use crate::TypedHistogramBucket;
 
 pub const DEFAULT_HISTOGRAM_BUCKETS: usize = 100;
 
+/// A column histogram used by optimizer statistics.
+///
+/// Histograms currently have two sources with different reliability:
+/// - `accuracy == true`: buckets come from `ANALYZE TABLE`. For each supported
+///   non-null column, ANALYZE runs a query equivalent to sorting rows by the
+///   column, assigning `NTILE(DEFAULT_HISTOGRAM_BUCKETS)`, then grouping by tile
+///   and collecting `MIN(col)`, `MAX(col)`, `COUNT()`, and
+///   `COUNT(DISTINCT col)`. Each bucket is therefore the closed value envelope
+///   observed in one row-order tile. The bucket list is not a value-domain
+///   partition: adjacent buckets may share boundaries or overlap when duplicate
+///   values cross tile boundaries.
+/// - `accuracy == false`: buckets are synthesized from column NDV plus
+///   min/max bounds by [`crate::HistogramBuilder::from_ndv`]. These buckets
+///   assume a uniform distribution over the recorded bounds, and numeric
+///   histograms keep `avg_spacing` so consumers can detect distorted ranges.
+///
+/// Consumers should preserve this distinction when updating or interpreting
+/// bucket counts. The type variants preserve the bucket value type for
+/// serialization, function selectivity, and type-specific join estimation.
 #[derive(Debug, Clone)]
 pub enum Histogram {
     Int(TypedHistogram<i64>),
@@ -160,13 +182,16 @@ impl Histogram {
         }
     }
 
-    pub fn estimate_join(&self, other: &Histogram) -> JoinEstimation {
+    /// Estimate a join only when both histograms use the same typed bucket representation.
+    pub fn estimate_join(&self, other: &Histogram) -> ExceptionResult<JoinEstimation> {
         match (self, other) {
-            (Self::Int(left), Self::Int(right)) => left.estimate_join(right),
-            (Self::UInt(left), Self::UInt(right)) => left.estimate_join(right),
-            (Self::Float(left), Self::Float(right)) => left.estimate_join(right),
-            (Self::Bytes(left), Self::Bytes(right)) => left.estimate_join(right),
-            _ => JoinEstimation::zero(),
+            (Self::Int(left), Self::Int(right)) => Ok(left.estimate_join(right)),
+            (Self::UInt(left), Self::UInt(right)) => Ok(left.estimate_join(right)),
+            (Self::Float(left), Self::Float(right)) => Ok(left.estimate_join(right)),
+            (Self::Bytes(left), Self::Bytes(right)) => Ok(left.estimate_join(right)),
+            _ => Err(ErrorCode::Internal(
+                "cannot estimate join for histograms with different bucket types",
+            )),
         }
     }
 
@@ -290,15 +315,7 @@ impl HistogramBucket {
             (Datum::Bytes(lower_bound), Datum::Bytes(upper_bound)) => Ok(Self::Bytes(
                 TypedHistogramBucket::new(lower_bound, upper_bound, num_values, num_distinct),
             )),
-            (lower_bound, upper_bound) if lower_bound.is_numeric() && upper_bound.is_numeric() => {
-                Ok(Self::Float(TypedHistogramBucket::new(
-                    F64::from(lower_bound.as_double().unwrap_or(0.0)),
-                    F64::from(upper_bound.as_double().unwrap_or(0.0)),
-                    num_values,
-                    num_distinct,
-                )))
-            }
-            _ => Err("histogram bucket bounds must have comparable types"),
+            _ => Err("histogram bucket bounds must have the same supported type"),
         }
     }
 

src/common/statistics/src/histogram_builder.rs

@@ -66,28 +66,44 @@ impl HistogramBuilder {
 pub type UniformSampleSet = HistogramBounds;
 
 impl HistogramBounds {
+    pub fn has_same_supported_type(&self, other: &HistogramBounds) -> bool {
+        let Some(kind) = histogram_bound_kind(self.lower_bound()) else {
+            return false;
+        };
+
+        histogram_bound_kind(self.upper_bound()) == Some(kind)
+            && histogram_bound_kind(other.lower_bound()) == Some(kind)
+            && histogram_bound_kind(other.upper_bound()) == Some(kind)
+    }
+
     pub fn has_intersection(&self, other: &HistogramBounds) -> Result<bool> {
         match (
             self.lower_bound(),
             self.upper_bound(),
             other.lower_bound(),
             other.upper_bound(),
         ) {
-            (left_min, left_max, right_min, right_max)
-                if left_min.is_numeric()
-                    && left_max.is_numeric()
-                    && right_min.is_numeric()
-                    && right_max.is_numeric() =>
-            {
-                Ok(TypedHistogramBounds::new(
-                    F64::from(left_min.as_double()?),
-                    F64::from(left_max.as_double()?),
-                )
-                .has_intersection(&TypedHistogramBounds::new(
-                    F64::from(right_min.as_double()?),
-                    F64::from(right_max.as_double()?),
-                )))
-            }
+            (
+                Datum::Int(left_min),
+                Datum::Int(left_max),
+                Datum::Int(right_min),
+                Datum::Int(right_max),
+            ) => Ok(TypedHistogramBounds::new(*left_min, *left_max)
+                .has_intersection(&TypedHistogramBounds::new(*right_min, *right_max))),
+            (
+                Datum::UInt(left_min),
+                Datum::UInt(left_max),
+                Datum::UInt(right_min),
+                Datum::UInt(right_max),
+            ) => Ok(TypedHistogramBounds::new(*left_min, *left_max)
+                .has_intersection(&TypedHistogramBounds::new(*right_min, *right_max))),
+            (
+                Datum::Float(left_min),
+                Datum::Float(left_max),
+                Datum::Float(right_min),
+                Datum::Float(right_max),
+            ) => Ok(TypedHistogramBounds::new(*left_min, *left_max)
+                .has_intersection(&TypedHistogramBounds::new(*right_min, *right_max))),
             (
                 Datum::Bytes(left_min),
                 Datum::Bytes(left_max),
@@ -109,20 +125,34 @@ impl HistogramBounds {
             other.lower_bound(),
             other.upper_bound(),
         ) {
-            (left_min, left_max, right_min, right_max)
-                if left_min.is_numeric()
-                    && left_max.is_numeric()
-                    && right_min.is_numeric()
-                    && right_max.is_numeric() =>
-            {
-                let (min, max) = TypedHistogramBounds::new(
-                    F64::from(left_min.as_double()?),
-                    F64::from(left_max.as_double()?),
-                )
-                .intersection(&TypedHistogramBounds::new(
-                    F64::from(right_min.as_double()?),
-                    F64::from(right_max.as_double()?),
-                ));
+            (
+                Datum::Int(left_min),
+                Datum::Int(left_max),
+                Datum::Int(right_min),
+                Datum::Int(right_max),
+            ) => {
+                let (min, max) = TypedHistogramBounds::new(*left_min, *left_max)
+                    .intersection(&TypedHistogramBounds::new(*right_min, *right_max));
+                Ok((min.map(Datum::Int), max.map(Datum::Int)))
+            }
+            (
+                Datum::UInt(left_min),
+                Datum::UInt(left_max),
+                Datum::UInt(right_min),
+                Datum::UInt(right_max),
+            ) => {
+                let (min, max) = TypedHistogramBounds::new(*left_min, *left_max)
+                    .intersection(&TypedHistogramBounds::new(*right_min, *right_max));
+                Ok((min.map(Datum::UInt), max.map(Datum::UInt)))
+            }
+            (
+                Datum::Float(left_min),
+                Datum::Float(left_max),
+                Datum::Float(right_min),
+                Datum::Float(right_max),
+            ) => {
+                let (min, max) = TypedHistogramBounds::new(*left_min, *left_max)
+                    .intersection(&TypedHistogramBounds::new(*right_min, *right_max));
                 Ok((min.map(Datum::Float), max.map(Datum::Float)))
             }
             (
@@ -142,9 +172,28 @@ impl HistogramBounds {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum HistogramBoundKind {
+    Int,
+    UInt,
+    Float,
+    Bytes,
+}
+
+fn histogram_bound_kind(datum: &Datum) -> Option<HistogramBoundKind> {
+    match datum {
+        Datum::Int(_) => Some(HistogramBoundKind::Int),
+        Datum::UInt(_) => Some(HistogramBoundKind::UInt),
+        Datum::Float(_) => Some(HistogramBoundKind::Float),
+        Datum::Bytes(_) => Some(HistogramBoundKind::Bytes),
+        Datum::Bool(_) => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::HistogramBucket;
     use crate::TypedHistogram;
     use crate::TypedHistogramBucket;
 
@@ -165,13 +214,32 @@ mod tests {
         let left = UniformSampleSet::new(Datum::UInt(0), Datum::UInt(10));
         let right = UniformSampleSet::new(Datum::UInt(5), Datum::UInt(15));
 
+        assert!(left.has_same_supported_type(&right));
         assert!(left.has_intersection(&right).unwrap());
         assert_eq!(
             left.intersection(&right).unwrap(),
-            (
-                Some(Datum::Float(F64::from(5.0))),
-                Some(Datum::Float(F64::from(10.0)))
-            )
+            (Some(Datum::UInt(5)), Some(Datum::UInt(10)))
+        );
+    }
+
+    #[test]
+    fn test_uniform_sample_set_rejects_mixed_numeric_intersection() {
+        let left = UniformSampleSet::new(Datum::UInt(0), Datum::UInt(10));
+        let right = UniformSampleSet::new(Datum::Int(5), Datum::Int(15));
+
+        assert!(!left.has_same_supported_type(&right));
+        assert!(!left.has_intersection(&right).unwrap());
+        assert_eq!(left.intersection(&right).unwrap(), (None, None));
+    }
+
+    #[test]
+    fn test_histogram_bucket_rejects_mixed_numeric_bounds() {
+        let err = HistogramBucket::try_from_bounds(Datum::UInt(0), Datum::Int(10), 10.0, 10.0)
+            .unwrap_err();
+
+        assert_eq!(
+            err,
+            "histogram bucket bounds must have the same supported type"
         );
     }
 
@@ -199,9 +267,30 @@ mod tests {
             avg_spacing: None,
         });
 
-        let estimation = left.estimate_join(&right);
+        let estimation = left.estimate_join(&right).unwrap();
 
         assert_eq!(estimation.cardinality.expected, 5.0);
         assert_eq!(estimation.ndv.expected, 5.0);
     }
+
+    #[test]
+    fn test_estimate_histogram_join_rejects_mixed_numeric_types() {
+        let left = Histogram::UInt(TypedHistogram {
+            accuracy: true,
+            buckets: vec![TypedHistogramBucket::new(0, 10, 10.0, 10.0)],
+            avg_spacing: None,
+        });
+        let right = Histogram::Int(TypedHistogram {
+            accuracy: true,
+            buckets: vec![TypedHistogramBucket::new(5, 15, 10.0, 10.0)],
+            avg_spacing: None,
+        });
+
+        let err = left.estimate_join(&right).unwrap_err();
+
+        assert_eq!(
+            err.message(),
+            "cannot estimate join for histograms with different bucket types"
+        );
+    }
 }