fix test

Author: zhyass

src/query/storages/fuse/src/io/write/stream/column_ndv_estimator.rs

@@ -94,15 +94,17 @@ where
     for<'a> T::ScalarRef<'a>: Hash,
 {
     fn update_column(&mut self, column: &Column) {
-        let (column, validity) = if let Column::Nullable(box inner) = column {
-            let validity = if inner.validity.null_count() == 0 {
-                None
-            } else {
-                Some(&inner.validity)
-            };
-            (&inner.column, validity)
-        } else {
-            (column, None)
+        let (column, validity) = match column {
+            Column::Nullable(box inner) => {
+                let validity = if inner.validity.null_count() == 0 {
+                    None
+                } else {
+                    Some(&inner.validity)
+                };
+                (&inner.column, validity)
+            }
+            Column::Null { .. } => return,
+            column => (column, None),
         };
 
         let column = T::try_downcast_column(column).unwrap();

src/query/storages/fuse/src/io/write/stream/column_statistics_builder.rs

@@ -212,15 +212,23 @@ where
 {
     fn update_column(&mut self, column: &Column) {
         self.in_memory_size += column.memory_size();
-        let (column, validity) = if let Column::Nullable(box inner) = column {
-            let validity = if inner.validity.null_count() == 0 {
-                None
-            } else {
-                Some(&inner.validity)
-            };
-            (&inner.column, validity)
-        } else {
-            (column, None)
+        if column.len() == 0 {
+            return;
+        }
+        let (column, validity) = match column {
+            Column::Nullable(box inner) => {
+                let validity = if inner.validity.null_count() == 0 {
+                    None
+                } else {
+                    Some(&inner.validity)
+                };
+                (&inner.column, validity)
+            }
+            Column::Null { len } => {
+                self.null_count += *len;
+                return;
+            }
+            col => (col, None),
         };
         self.null_count += validity.map_or(0, |v| v.null_count());
 

src/query/storages/fuse/src/io/write/stream/column_statistics_state.rs

@@ -92,9 +92,22 @@ impl ColumnStatisticsState {
         for (id, stats) in self.col_stats {
             let mut col_stats = stats.finalize()?;
             if let Some(count) = column_distinct_count.get(&id) {
-                col_stats.distinct_of_values = Some(*count as u64);
+                // value calculated by xor hash function include NULL, need to subtract one.
+                let distinct_of_values = if col_stats.null_count > 0 {
+                    *count as u64 - 1
+                } else {
+                    *count as u64
+                };
+                col_stats.distinct_of_values = Some(distinct_of_values);
             } else if let Some(estimator) = self.distinct_columns.get(&id) {
                 col_stats.distinct_of_values = Some(estimator.finalize());
+            } else {
+                assert_eq!(col_stats.min, col_stats.max);
+                if col_stats.min.is_null() {
+                    col_stats.distinct_of_values = Some(0);
+                } else {
+                    col_stats.distinct_of_values = Some(1);
+                }
             }
             statistics.insert(id, col_stats);
         }

src/query/storages/fuse/src/statistics/column_statistic.rs

@@ -83,37 +83,39 @@ pub fn gen_columns_statistics(
                 let mut min = Scalar::Null;
                 let mut max = Scalar::Null;
 
-                let (mins, _) = eval_aggr("min", vec![], &[col.clone().into()], rows, vec![])?;
-                let (maxs, _) = eval_aggr("max", vec![], &[col.clone().into()], rows, vec![])?;
+                if col.len() > 0 {
+                    let (mins, _) = eval_aggr("min", vec![], &[col.clone().into()], rows, vec![])?;
+                    let (maxs, _) = eval_aggr("max", vec![], &[col.clone().into()], rows, vec![])?;
 
-                if mins.len() > 0 {
-                    min = if let Some(v) = mins.index(0) {
-                        if let Some(v) = v.to_owned().trim_min() {
-                            v
+                    if mins.len() > 0 {
+                        min = if let Some(v) = mins.index(0) {
+                            if let Some(v) = v.to_owned().trim_min() {
+                                v
+                            } else {
+                                continue;
+                            }
                         } else {
                             continue;
                         }
-                    } else {
-                        continue;
                     }
-                }
 
-                if maxs.len() > 0 {
-                    max = if let Some(v) = maxs.index(0) {
-                        if let Some(v) = v.to_owned().trim_max() {
-                            v
+                    if maxs.len() > 0 {
+                        max = if let Some(v) = maxs.index(0) {
+                            if let Some(v) = v.to_owned().trim_max() {
+                                v
+                            } else {
+                                continue;
+                            }
                         } else {
                             continue;
                         }
-                    } else {
-                        continue;
                     }
                 }
 
                 let (is_all_null, bitmap) = col.validity();
                 let unset_bits = match (is_all_null, bitmap) {
-                    (true, _) => rows,
-                    (false, Some(bitmap)) => bitmap.null_count(),
+                    (_, Some(bitmap)) => bitmap.null_count(),
+                    (true, None) => rows,
                     (false, None) => 0,
                 };