Refine some codes.

Author: RinChanNOWWW

src/query/storages/fuse/fuse/src/pruning/pruning_executor.rs

@@ -25,10 +25,10 @@ use common_catalog::table_context::TableContext;
 use common_datavalues::DataSchemaRef;
 use common_exception::ErrorCode;
 use common_exception::Result;
-use common_storages_pruner::limiter_pruner;
-use common_storages_pruner::limiter_pruner::LimiterPruner;
-use common_storages_pruner::range_pruner;
-use common_storages_pruner::range_pruner::RangePruner;
+use common_storages_pruner::LimiterPruner;
+use common_storages_pruner::LimiterPrunerCreator;
+use common_storages_pruner::RangePruner;
+use common_storages_pruner::RangePrunerCreator;
 use common_storages_table_meta::meta::BlockMeta;
 use common_storages_table_meta::meta::Location;
 use common_storages_table_meta::meta::SegmentInfo;
@@ -79,11 +79,11 @@ impl BlockPruner {
             .and_then(|p| p.limit);
 
         // prepare the limiter. in case that limit is none, an unlimited limiter will be returned
-        let limiter = limiter_pruner::new_limiter(limit);
+        let limiter = LimiterPrunerCreator::create(limit);
 
         // prepare the range filter.
         // if filter_expression is none, an dummy pruner will be returned, which prunes nothing
-        let range_pruner = range_pruner::new_range_pruner(ctx, filter_expressions, &schema)?;
+        let range_pruner = RangePrunerCreator::try_create(ctx, filter_expressions, &schema)?;
 
         // prepare the filter.
         // None will be returned, if filter is not applicable (e.g. unsuitable filter expression, index not available, etc.)

src/query/storages/parquet/src/parquet_reader/meta.rs

@@ -80,8 +80,7 @@ impl ParquetReader {
         }
 
         for (rg_idx, _) in rgs.iter().enumerate() {
-            let mut cols_stats = HashMap::new();
-            cols_stats.reserve(stats.capacity());
+            let mut cols_stats = HashMap::with_capacity(stats.capacity());
             for index in indices {
                 let col_stats = stats_of_row_groups[index].get(rg_idx);
                 cols_stats.insert(*index as u32, col_stats);

src/query/storages/parquet/src/table_function/read.rs

@@ -27,7 +27,7 @@ use common_exception::Result;
 use common_pipeline_core::Pipeline;
 use common_sql::evaluator::EvalNode;
 use common_sql::evaluator::Evaluator;
-use common_storages_pruner::range_pruner;
+use common_storages_pruner::RangePrunerCreator;
 
 use super::ParquetTable;
 use super::TableContext;
@@ -145,7 +145,7 @@ impl ParquetTable {
 
             // build row group pruner.
             let filter_expr = push_downs.as_ref().map(|extra| extra.filters.as_slice());
-            let row_group_pruner = range_pruner::new_range_pruner(&ctx_ref, filter_expr, &schema)?;
+            let row_group_pruner = RangePrunerCreator::try_create(&ctx_ref, filter_expr, &schema)?;
 
             for location in &locations {
                 let file_meta = ParquetReader::read_meta(location)?;

src/query/storages/pruner/src/lib.rs

@@ -14,5 +14,10 @@
 
 #![deny(unused_crate_dependencies)]
 
-pub mod limiter_pruner;
-pub mod range_pruner;
+mod limiter_pruner;
+mod range_pruner;
+
+pub use limiter_pruner::LimiterPruner;
+pub use limiter_pruner::LimiterPrunerCreator;
+pub use range_pruner::RangePruner;
+pub use range_pruner::RangePrunerCreator;

src/query/storages/pruner/src/limiter_pruner.rs

@@ -59,9 +59,14 @@ impl Limiter for U64Limiter {
 }
 
 pub type LimiterPruner = Arc<dyn Limiter + Send + Sync>;
-pub fn new_limiter(limit: Option<usize>) -> LimiterPruner {
-    match limit {
-        Some(size) => Arc::new(U64Limiter::new(size as u64)),
-        _ => Arc::new(Unlimited),
+
+pub struct LimiterPrunerCreator;
+
+impl LimiterPrunerCreator {
+    pub fn create(limit: Option<usize>) -> LimiterPruner {
+        match limit {
+            Some(size) => Arc::new(U64Limiter::new(size as u64)),
+            _ => Arc::new(Unlimited),
+        }
     }
 }

src/query/storages/pruner/src/range_pruner.rs

@@ -55,28 +55,32 @@ impl RangePruner for RangeFilter {
     }
 }
 
-/// Create a new [`RangePruner`] from expression and schema.
-///
-/// Note: the schema should be the schema of the table, not the schema of the input.
-pub fn new_range_pruner<'a>(
-    ctx: &Arc<dyn TableContext>,
-    filter_expr: Option<&'a [Expression]>,
-    schema: &'a DataSchemaRef,
-) -> Result<Arc<dyn RangePruner + Send + Sync>> {
-    Ok(match filter_expr {
-        Some(exprs) if !exprs.is_empty() => {
-            let range_filter = RangeFilter::try_create(ctx.clone(), exprs, schema.clone())?;
-            match range_filter.try_eval_const() {
-                Ok(v) => {
-                    if v {
-                        Arc::new(KeepTrue)
-                    } else {
-                        Arc::new(KeepFalse)
+pub struct RangePrunerCreator;
+
+impl RangePrunerCreator {
+    /// Create a new [`RangePruner`] from expression and schema.
+    ///
+    /// Note: the schema should be the schema of the table, not the schema of the input.
+    pub fn try_create<'a>(
+        ctx: &Arc<dyn TableContext>,
+        filter_expr: Option<&'a [Expression]>,
+        schema: &'a DataSchemaRef,
+    ) -> Result<Arc<dyn RangePruner + Send + Sync>> {
+        Ok(match filter_expr {
+            Some(exprs) if !exprs.is_empty() => {
+                let range_filter = RangeFilter::try_create(ctx.clone(), exprs, schema.clone())?;
+                match range_filter.try_eval_const() {
+                    Ok(v) => {
+                        if v {
+                            Arc::new(KeepTrue)
+                        } else {
+                            Arc::new(KeepFalse)
+                        }
                     }
+                    Err(_) => Arc::new(range_filter),
                 }
-                Err(_) => Arc::new(range_filter),
             }
-        }
-        _ => Arc::new(KeepTrue),
-    })
+            _ => Arc::new(KeepTrue),
+        })
+    }
 }