refactor(optimizer): refine the tpcds tests (#17777)

* refactor(optimizer): refine the tpcds tests

* add more logs to tpcds_test.rs

Author: BohuTANG

src/query/service/tests/it/sql/planner/optimizer/test_utils.rs

@@ -17,8 +17,6 @@ use std::sync::Arc;
 
 use databend_common_base::base::OrderedFloat;
 use databend_common_catalog::catalog::CatalogManager;
-use databend_common_catalog::BasicColumnStatistics;
-use databend_common_catalog::TableStatistics;
 use databend_common_exception::Result;
 use databend_common_expression::types::DataType;
 use databend_common_expression::types::NumberScalar;
@@ -44,181 +42,15 @@ use databend_common_sql::plans::RelOperator;
 use databend_common_sql::plans::ScalarExpr;
 use databend_common_sql::plans::ScalarItem;
 use databend_common_sql::plans::Scan;
-use databend_common_sql::plans::Statistics;
-use databend_common_sql::BaseTableColumn;
 use databend_common_sql::ColumnBinding;
-use databend_common_sql::ColumnEntry;
 use databend_common_sql::ColumnSet;
 use databend_common_sql::IndexType;
-use databend_common_sql::MetadataRef;
 use databend_common_sql::NameResolutionContext;
 use databend_common_sql::Planner;
 use databend_common_sql::Visibility;
 use databend_query::interpreters::InterpreterFactory;
 use databend_query::sessions::QueryContext;
 
-/// A builder for setting test statistics on plans
-#[derive(Clone, Debug, Default)]
-pub struct TestStatisticsBuilder {
-    // Map of table name to table statistics
-    table_stats: HashMap<String, Option<TableStatistics>>,
-    // Map of (table name, column name) to column statistics
-    column_stats: HashMap<(String, String), Option<BasicColumnStatistics>>,
-}
-
-impl TestStatisticsBuilder {
-    /// Create a new TestStatisticsBuilder
-    pub fn new() -> Self {
-        Self {
-            table_stats: HashMap::new(),
-            column_stats: HashMap::new(),
-        }
-    }
-
-    /// Set statistics for a specific table
-    pub fn set_table_statistics(
-        &mut self,
-        table_name: &str,
-        stats: Option<TableStatistics>,
-    ) -> &mut Self {
-        self.table_stats.insert(table_name.to_string(), stats);
-        self
-    }
-
-    /// Set statistics for a specific column in a table
-    pub fn set_column_statistics(
-        &mut self,
-        table_name: &str,
-        column_name: &str,
-        stats: Option<BasicColumnStatistics>,
-    ) -> &mut Self {
-        self.column_stats
-            .insert((table_name.to_string(), column_name.to_string()), stats);
-        self
-    }
-
-    /// Apply the statistics to a plan
-    pub fn apply_to_plan(&self, plan: &mut Plan) -> Result<()> {
-        if let Plan::Query {
-            s_expr, metadata, ..
-        } = plan
-        {
-            let new_s_expr = self.apply_to_sexpr(s_expr, metadata)?;
-            *s_expr = Box::new(new_s_expr);
-        }
-        Ok(())
-    }
-
-    /// Internal helper to apply statistics to an SExpr
-    fn apply_to_sexpr(&self, s_expr: &SExpr, metadata: &MetadataRef) -> Result<SExpr> {
-        let mut result = s_expr.clone();
-
-        if let RelOperator::Scan(scan) = s_expr.plan.as_ref() {
-            let table_index = scan.table_index;
-            let metadata_guard = metadata.read();
-            let table = metadata_guard.table(table_index);
-            let table_name = table.name();
-
-            // Check if we have statistics for this table
-            let should_update = self.table_stats.contains_key(table_name)
-                || self.column_stats.iter().any(|((t, _), _)| t == table_name);
-
-            if should_update {
-                let mut new_scan = scan.clone();
-
-                // Create a mutable copy of the statistics
-                let mut stats = Statistics {
-                    table_stats: None,
-                    column_stats: HashMap::new(),
-                    histograms: HashMap::new(),
-                };
-
-                // Update table statistics if specified
-                if let Some(table_stats) = self.table_stats.get(table_name) {
-                    stats.table_stats = *table_stats;
-                }
-
-                // Update column statistics if specified
-                let metadata_guard = metadata.read();
-                let columns = metadata_guard.columns_by_table_index(table_index);
-                for (idx, column) in columns.iter().enumerate() {
-                    if let ColumnEntry::BaseTableColumn(BaseTableColumn { column_name, .. }) =
-                        column
-                    {
-                        if let Some(col_stats_option) = self
-                            .column_stats
-                            .get(&(table_name.to_string(), column_name.clone()))
-                        {
-                            stats
-                                .column_stats
-                                .insert(idx as IndexType, col_stats_option.clone());
-                        }
-                    }
-                }
-
-                // Replace the statistics
-                new_scan.statistics = Arc::new(stats);
-                result = result.replace_plan(Arc::new(RelOperator::Scan(new_scan)));
-            }
-        }
-
-        // Recursively process children
-        let mut new_children = Vec::new();
-        for child in s_expr.children() {
-            new_children.push(Arc::new(self.apply_to_sexpr(child, metadata)?));
-        }
-
-        if !new_children.is_empty() {
-            result = result.replace_children(new_children);
-        }
-
-        Ok(result)
-    }
-}
-
-// Extension trait for Plan to make it easier to set statistics
-pub trait PlanStatisticsExt {
-    /// Set statistics for a specific table
-    fn set_table_statistics(
-        &mut self,
-        table_name: &str,
-        stats: Option<TableStatistics>,
-    ) -> Result<&mut Self>;
-
-    /// Set statistics for a specific column in a table
-    fn set_column_statistics(
-        &mut self,
-        table_name: &str,
-        column_name: &str,
-        stats: Option<BasicColumnStatistics>,
-    ) -> Result<&mut Self>;
-}
-
-impl PlanStatisticsExt for Plan {
-    fn set_table_statistics(
-        &mut self,
-        table_name: &str,
-        stats: Option<TableStatistics>,
-    ) -> Result<&mut Self> {
-        let mut builder = TestStatisticsBuilder::new();
-        builder.set_table_statistics(table_name, stats);
-        builder.apply_to_plan(self)?;
-        Ok(self)
-    }
-
-    fn set_column_statistics(
-        &mut self,
-        table_name: &str,
-        column_name: &str,
-        stats: Option<BasicColumnStatistics>,
-    ) -> Result<&mut Self> {
-        let mut builder = TestStatisticsBuilder::new();
-        builder.set_column_statistics(table_name, column_name, stats);
-        builder.apply_to_plan(self)?;
-        Ok(self)
-    }
-}
-
 // TPC-DS Test Utilities
 
 /// Plan SQL query to get a Plan object
@@ -271,15 +103,6 @@ pub async fn optimize_plan(ctx: &Arc<QueryContext>, plan: Plan) -> Result<Plan>
     optimize(opt_ctx, plan).await
 }
 
-/// Test case structure for optimizer tests
-pub struct TestCase {
-    pub name: &'static str,
-    pub sql: &'static str,
-    pub stats_setup: fn(&mut Plan) -> Result<()>,
-    pub raw_plan: &'static str,      // Expected raw plan string
-    pub expected_plan: &'static str, // Expected optimized plan string
-}
-
 // ===== Helper Functions =====
 
 /// Creates a column reference with the given index, name, data type, table name and table index