x

Author: forsaken628

src/query/functions/src/scalars/comparison.rs

@@ -348,16 +348,13 @@ impl<Op: StatComparisonOp> HistogramComparison<'_, Op> {
                     Scalar::Timestamp(v) => *v,
                     _ => return Err(unexpected_histogram_constant("Int", self.constant)),
                 };
-                Ok(
-                    self.typed_selectivity(histogram, &constant, |bucket, constant| {
-                        HistogramBucketComparison::<_, Op> {
-                            bucket,
-                            constant,
-                            _op: PhantomData,
-                        }
-                        .number_selectivity()
-                    }),
-                )
+                Ok(TypedHistogramScan::<_, Op> {
+                    histogram,
+                    constant: &constant,
+                    selected: 0.0,
+                    _op: PhantomData,
+                }
+                .selectivity(HistogramBucketComparison::number_selectivity))
             }
             Histogram::UInt(histogram) => {
                 let constant = match self.constant {
@@ -367,72 +364,68 @@ impl<Op: StatComparisonOp> HistogramComparison<'_, Op> {
                     Scalar::Number(NumberScalar::UInt64(n)) => *n,
                     _ => return Err(unexpected_histogram_constant("UInt", self.constant)),
                 };
-                Ok(
-                    self.typed_selectivity(histogram, &constant, |bucket, constant| {
-                        HistogramBucketComparison::<_, Op> {
-                            bucket,
-                            constant,
-                            _op: PhantomData,
-                        }
-                        .number_selectivity()
-                    }),
-                )
+                Ok(TypedHistogramScan::<_, Op> {
+                    histogram,
+                    constant: &constant,
+                    selected: 0.0,
+                    _op: PhantomData,
+                }
+                .selectivity(HistogramBucketComparison::number_selectivity))
             }
             Histogram::Float(histogram) => {
                 let constant = scalar_number_value(self.constant)
                     .ok_or_else(|| unexpected_histogram_constant("Float", self.constant))?;
-                Ok(
-                    self.typed_selectivity(histogram, &constant, |bucket, constant| {
-                        HistogramBucketComparison::<_, Op> {
-                            bucket,
-                            constant,
-                            _op: PhantomData,
-                        }
-                        .number_selectivity()
-                    }),
-                )
+                Ok(TypedHistogramScan::<_, Op> {
+                    histogram,
+                    constant: &constant,
+                    selected: 0.0,
+                    _op: PhantomData,
+                }
+                .selectivity(HistogramBucketComparison::number_selectivity))
             }
             Histogram::Bytes(histogram) => {
                 let constant = scalar_bytes_value(self.constant)
                     .ok_or_else(|| unexpected_histogram_constant("Bytes", self.constant))?;
-                Ok(
-                    self.typed_selectivity(histogram, &constant, |bucket, constant| {
-                        HistogramBucketComparison::<_, Op> {
-                            bucket,
-                            constant,
-                            _op: PhantomData,
-                        }
-                        .bytes_selectivity()
-                    }),
-                )
+                Ok(TypedHistogramScan::<_, Op> {
+                    histogram,
+                    constant: &constant,
+                    selected: 0.0,
+                    _op: PhantomData,
+                }
+                .selectivity(HistogramBucketComparison::bytes_selectivity))
             }
         }
     }
+}
 
-    fn typed_selectivity<T: Ord>(
-        &self,
-        histogram: &TypedHistogram<T>,
-        constant: &T,
-        estimate_partial_bucket: impl Fn(&TypedHistogramBucket<T>, &T) -> f64,
+struct TypedHistogramScan<'a, T, Op> {
+    histogram: &'a TypedHistogram<T>,
+    constant: &'a T,
+    selected: f64,
+    _op: PhantomData<fn(Op)>,
+}
+
+impl<'a, T: Ord, Op: StatComparisonOp> TypedHistogramScan<'a, T, Op> {
+    fn selectivity(
+        mut self,
+        estimate_partial_bucket: impl Fn(&HistogramBucketComparison<'a, T, Op>) -> f64,
     ) -> f64 {
-        let mut selected = 0.0;
-        for bucket in &histogram.buckets {
-            let bucket_comparison = HistogramBucketComparison::<_, Op> {
+        for bucket in &self.histogram.buckets {
+            let bucket = HistogramBucketComparison::<_, Op> {
                 bucket,
-                constant,
+                constant: self.constant,
                 _op: PhantomData,
             };
-            match bucket_comparison.overlap() {
+            match bucket.overlap() {
                 HistogramBucketOverlap::None => {}
-                HistogramBucketOverlap::Complete => selected += bucket.num_values(),
+                HistogramBucketOverlap::Complete => self.selected += bucket.bucket.num_values(),
                 HistogramBucketOverlap::Partial => {
-                    let selectivity = estimate_partial_bucket(bucket, constant);
-                    selected += bucket.num_values() * selectivity;
+                    self.selected += bucket.bucket.num_values() * estimate_partial_bucket(&bucket);
                 }
             }
         }
 
-        selected / histogram.num_values()
+        self.selected / self.histogram.num_values()
     }
 }
 
@@ -523,7 +516,7 @@ impl<T: StatNumberValue, Op: StatComparisonOp> HistogramBucketComparison<'_, T,
 }
 
 enum IntegerRangeComparison<'s, 'a> {
-    Empty,
+    MissingMinMax,
     Bounded {
         stat: &'s ArgStat<'a>,
         min: F64,
@@ -536,7 +529,7 @@ enum IntegerRangeComparison<'s, 'a> {
 impl<'s, 'a> IntegerRangeComparison<'s, 'a> {
     fn from_input(input: &ConstantComparison<'s, 'a>) -> Option<Self> {
         let Some((min, max)) = input.stat.value_minmax() else {
-            return Some(Self::Empty);
+            return Some(Self::MissingMinMax);
         };
 
         Some(Self::Bounded {
@@ -1983,22 +1976,21 @@ mod tests {
         });
         let constant = Scalar::Number(NumberScalar::Int64(10));
 
-        let gte_selectivity = HistogramComparison::<GteOp> {
+        let gte_input = HistogramComparison::<GteOp> {
             histogram: &histogram,
             constant: &constant,
             cardinality: 1.0,
             _op: PhantomData,
-        }
-        .selectivity()
-        .unwrap();
-        let lt_selectivity = HistogramComparison::<LtOp> {
+        };
+        let lt_input = HistogramComparison::<LtOp> {
             histogram: &histogram,
             constant: &constant,
             cardinality: 1.0,
             _op: PhantomData,
-        }
-        .selectivity()
-        .unwrap();
+        };
+
+        let gte_selectivity = gte_input.selectivity().unwrap();
+        let lt_selectivity = lt_input.selectivity().unwrap();
 
         assert!((gte_selectivity - 0.1).abs() < 1e-9);
         assert!((lt_selectivity - 0.9).abs() < 1e-9);