x

Author: forsaken628

src/query/sql/src/planner/plans/union_all.rs

@@ -311,277 +311,3 @@ impl Operator for UnionAll {
         Ok(children_required)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-
-    use databend_common_expression::stat_distribution::NdvEstimate;
-    use databend_common_expression::stat_distribution::StatCount;
-    use databend_common_expression::types::ArgType;
-    use databend_common_expression::types::DataType;
-    use databend_common_expression::types::Int32Type;
-    use databend_common_expression::types::Int64Type;
-    use databend_common_statistics::Datum;
-    use databend_common_statistics::HistogramBuilder;
-
-    use super::*;
-    use crate::ColumnBindingBuilder;
-    use crate::Visibility;
-    use crate::plans::BoundColumnRef;
-    use crate::plans::CastExpr;
-    use crate::plans::Join;
-    use crate::plans::JoinEquiCondition;
-    use crate::plans::JoinType;
-
-    fn stat_info(cardinality: u64, column: Option<(Symbol, ColumnStat)>) -> Arc<StatInfo> {
-        Arc::new(StatInfo {
-            cardinality: cardinality as f64,
-            statistics: Statistics {
-                precise_cardinality: Some(cardinality),
-                column_stats: column.into_iter().collect::<HashMap<_, _>>(),
-                top_n: Default::default(),
-                count_min_sketch: Default::default(),
-            },
-        })
-    }
-
-    fn column_stat(min: i64, max: i64, ndv: f64, null_count: u64) -> ColumnStat {
-        ColumnStat {
-            min: Datum::Int(min),
-            max: Datum::Int(max),
-            ndv: NdvEstimate::exact(ndv),
-            null_count: StatCount::exact(null_count),
-            histogram: None,
-        }
-    }
-
-    fn typed_column(index: Symbol, data_type: DataType) -> ScalarExpr {
-        ScalarExpr::BoundColumnRef(BoundColumnRef {
-            span: None,
-            column: ColumnBindingBuilder::new(
-                format!("c{}", index.as_usize()),
-                index,
-                Box::new(data_type),
-                Visibility::Visible,
-            )
-            .build(),
-        })
-    }
-
-    #[test]
-    fn test_union_stats_merge_and_remap_output_column() -> Result<()> {
-        let left = Symbol::new(1);
-        let right = Symbol::new(2);
-        let output = Symbol::new(10);
-        let union = UnionAll {
-            left_outputs: vec![(left, None)],
-            right_outputs: vec![(right, None)],
-            cte_scan_names: vec![],
-            logical_recursive_cte_id: None,
-            output_indexes: vec![output],
-        };
-        let stats = union.derive_union_stats(
-            stat_info(10, Some((left, column_stat(1, 3, 3.0, 1)))),
-            stat_info(20, Some((right, column_stat(4, 8, 5.0, 2)))),
-        )?;
-
-        assert_eq!(stats.cardinality, 30.0);
-        assert_eq!(stats.statistics.precise_cardinality, Some(30));
-        assert!(!stats.statistics.column_stats.contains_key(&left));
-        assert!(!stats.statistics.column_stats.contains_key(&right));
-        let output_stat = &stats.statistics.column_stats[&output];
-        assert_eq!(output_stat, &ColumnStat {
-            min: Datum::Int(1),
-            max: Datum::Int(8),
-            ndv: NdvEstimate::new(5.0, 8.0),
-            null_count: StatCount::exact(3),
-            histogram: None,
-        });
-        Ok(())
-    }
-
-    #[test]
-    fn test_union_stats_apply_lossless_coercion_cast() -> Result<()> {
-        let left = Symbol::new(1);
-        let right = Symbol::new(2);
-        let output = Symbol::new(10);
-        let union = UnionAll {
-            left_outputs: vec![(
-                left,
-                Some(ScalarExpr::CastExpr(CastExpr {
-                    span: None,
-                    is_try: false,
-                    argument: Box::new(typed_column(left, Int32Type::data_type().wrap_nullable())),
-                    target_type: Box::new(Int64Type::data_type().wrap_nullable()),
-                })),
-            )],
-            right_outputs: vec![(right, None)],
-            cte_scan_names: vec![],
-            logical_recursive_cte_id: None,
-            output_indexes: vec![output],
-        };
-
-        let stats = union.derive_union_stats(
-            stat_info(10, Some((left, column_stat(1, 3, 3.0, 1)))),
-            stat_info(20, Some((right, column_stat(4, 8, 5.0, 2)))),
-        )?;
-
-        let output_stat = &stats.statistics.column_stats[&output];
-        assert_eq!(output_stat, &ColumnStat {
-            min: Datum::Int(1),
-            max: Datum::Int(8),
-            ndv: NdvEstimate::new(5.0, 8.0),
-            null_count: StatCount::exact(3),
-            histogram: None,
-        });
-        Ok(())
-    }
-
-    #[test]
-    fn test_union_stats_do_not_keep_partial_stats_from_nonempty_branch() -> Result<()> {
-        let left = Symbol::new(1);
-        let right = Symbol::new(2);
-        let output = Symbol::new(10);
-        let union = UnionAll {
-            left_outputs: vec![(left, None)],
-            right_outputs: vec![(right, None)],
-            cte_scan_names: vec![],
-            logical_recursive_cte_id: None,
-            output_indexes: vec![output],
-        };
-
-        let stats = union.derive_union_stats(
-            stat_info(10, Some((left, column_stat(1, 3, 3.0, 0)))),
-            stat_info(20, None),
-        )?;
-        assert!(!stats.statistics.column_stats.contains_key(&output));
-
-        let stats = union.derive_union_stats(
-            stat_info(10, Some((left, column_stat(1, 3, 3.0, 0)))),
-            stat_info(0, None),
-        )?;
-        assert_eq!(
-            stats.statistics.column_stats[&output].ndv,
-            NdvEstimate::exact(3.0)
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_union_ndv_fallback_preserves_known_side() -> Result<()> {
-        let left = Symbol::new(1);
-        let right = Symbol::new(2);
-        let output = Symbol::new(10);
-        let mut left_stat = column_stat(1, 3, 3.0, 0);
-        left_stat.ndv = NdvEstimate::upper_bound(3.0);
-
-        let union = UnionAll {
-            left_outputs: vec![(left, None)],
-            right_outputs: vec![(right, None)],
-            cte_scan_names: vec![],
-            logical_recursive_cte_id: None,
-            output_indexes: vec![output],
-        };
-        let stats = union.derive_union_stats(
-            stat_info(10, Some((left, left_stat))),
-            stat_info(20, Some((right, column_stat(2, 8, 5.0, 0)))),
-        )?;
-
-        assert_eq!(
-            stats.statistics.column_stats[&output].ndv,
-            NdvEstimate::new(5.0, 8.0)
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_union_output_stats_are_consumed_by_join_estimation() -> Result<()> {
-        let left = Symbol::new(1);
-        let right = Symbol::new(2);
-        let output = Symbol::new(10);
-        let join_key = Symbol::new(20);
-        let union = UnionAll {
-            left_outputs: vec![(left, None)],
-            right_outputs: vec![(right, None)],
-            cte_scan_names: vec![],
-            logical_recursive_cte_id: None,
-            output_indexes: vec![output],
-        };
-        let union_stats = union.derive_union_stats(
-            stat_info(10, Some((left, column_stat(1, 3, 3.0, 0)))),
-            stat_info(20, Some((right, column_stat(2, 8, 5.0, 0)))),
-        )?;
-        assert_eq!(
-            union_stats.statistics.column_stats[&output].ndv,
-            NdvEstimate::new(5.0, 8.0)
-        );
-        let join = Join {
-            equi_conditions: vec![JoinEquiCondition::new(
-                typed_column(output, Int64Type::data_type()),
-                typed_column(join_key, Int64Type::data_type()),
-                false,
-            )],
-            join_type: JoinType::Inner,
-            ..Default::default()
-        };
-
-        let stats = join.derive_join_stats(
-            union_stats,
-            stat_info(100, Some((join_key, column_stat(1, 10, 10.0, 0)))),
-        )?;
-
-        // 30 * 100 / max(union estimated NDV 5, right NDV 10), rather than 30 * 100.
-        assert_eq!(stats.cardinality, 300.0);
-        Ok(())
-    }
-
-    #[test]
-    fn test_union_ndv_uses_histogram_intersection() -> Result<()> {
-        let left = Symbol::new(1);
-        let right = Symbol::new(2);
-        let output = Symbol::new(10);
-        let mut left_histogram =
-            HistogramBuilder::from_ndv(10, 100, Some((Datum::Int(0), Datum::Int(9))), 2)
-                .expect("left histogram should be valid");
-        let mut right_histogram =
-            HistogramBuilder::from_ndv(10, 100, Some((Datum::Int(5), Datum::Int(14))), 2)
-                .expect("right histogram should be valid");
-        left_histogram.scale_counts(0.25);
-        right_histogram.scale_counts(0.5);
-        let left_ndv = left_histogram.ndv();
-        let right_ndv = right_histogram.ndv();
-        let intersection_ndv = left_histogram
-            .estimate_join_numeric_compatible(&right_histogram)?
-            .expect("integer histograms should be compatible")
-            .ndv
-            .expected
-            .expect("histogram intersection should have an expected NDV");
-        let mut left_stat = column_stat(0, 9, 10.0, 0);
-        left_stat.ndv = left_ndv;
-        left_stat.histogram = Some(left_histogram);
-        let mut right_stat = column_stat(5, 14, 10.0, 0);
-        right_stat.ndv = right_ndv;
-        right_stat.histogram = Some(right_histogram);
-
-        let union = UnionAll {
-            left_outputs: vec![(left, None)],
-            right_outputs: vec![(right, None)],
-            cte_scan_names: vec![],
-            logical_recursive_cte_id: None,
-            output_indexes: vec![output],
-        };
-        let stats = union.derive_union_stats(
-            stat_info(25, Some((left, left_stat))),
-            stat_info(50, Some((right, right_stat))),
-        )?;
-
-        let expected = stats.statistics.column_stats[&output].ndv.expected.unwrap();
-        let expected_from_intersection =
-            left_ndv.expected.unwrap() + right_ndv.expected.unwrap() - intersection_ndv;
-        assert!((expected - expected_from_intersection).abs() < 1e-9);
-        assert!(expected > left_ndv.expected.unwrap().max(right_ndv.expected.unwrap()));
-        assert!(expected < left_ndv.expected.unwrap() + right_ndv.expected.unwrap());
-        Ok(())
-    }
-}

src/query/sql/tests/it/optimizer/mod.rs

@@ -21,3 +21,4 @@ mod outer_join_to_anti;
 mod push_down_filter_project_set;
 mod selectivity;
 mod selectivity_smoke;
+mod union_all;