Merge pull request #7747 from Xuanwo/move-planner-out

refactor: Planner Code Cleanup

Author: Xuanwo

src/query/planner/src/metadata.rs

@@ -163,12 +163,32 @@ impl Metadata {
         table_index
     }
 
-    pub fn find_smallest_column_within(&self, indices: &[usize]) -> usize {
-        let entries = indices
+    /// find_smallest_column in given indices.
+    pub fn find_smallest_column(&self, indices: &[usize]) -> usize {
+        let mut smallest_index = indices.iter().min().expect("indices must be valid");
+        let mut smallest_size = usize::MAX;
+        for idx in indices.iter() {
+            let entry = self.column(*idx);
+            if let Ok(bytes) = entry.data_type.data_type_id().numeric_byte_size() {
+                if smallest_size > bytes {
+                    smallest_size = bytes;
+                    smallest_index = &entry.column_index;
+                }
+            }
+        }
+        *smallest_index
+    }
+
+    /// find_smallest_column_by_table_index by given table_index
+    pub fn find_smallest_column_by_table_index(&self, table_index: IndexType) -> usize {
+        let indices: Vec<usize> = self
+            .columns
             .iter()
-            .map(|i| self.column(*i).clone())
-            .collect::<Vec<_>>();
-        find_smallest_column(entries.as_slice())
+            .filter(|v| v.table_index == Some(table_index))
+            .map(|v| v.column_index)
+            .collect();
+
+        self.find_smallest_column(&indices)
     }
 }
 
@@ -295,24 +315,3 @@ impl ColumnEntry {
         self.path_indices.is_some()
     }
 }
-
-/// TODO(xuanwo): migrate this as a function of metadata.
-pub fn find_smallest_column(entries: &[ColumnEntry]) -> usize {
-    debug_assert!(!entries.is_empty());
-    let mut column_indexes = entries
-        .iter()
-        .map(|entry| entry.column_index)
-        .collect::<Vec<IndexType>>();
-    column_indexes.sort();
-    let mut smallest_index = column_indexes[0];
-    let mut smallest_size = usize::MAX;
-    for (idx, column_entry) in entries.iter().enumerate() {
-        if let Ok(bytes) = column_entry.data_type.data_type_id().numeric_byte_size() {
-            if smallest_size > bytes {
-                smallest_size = bytes;
-                smallest_index = entries[idx].column_index;
-            }
-        }
-    }
-    smallest_index
-}

src/query/service/src/sql/planner/metadata.rs

@@ -14,9 +14,6 @@
 
 use common_ast::ast::Expr;
 use common_ast::ast::Literal;
-use common_datavalues::prelude::*;
-use common_planner::ColumnEntry;
-use common_planner::IndexType;
 
 pub fn optimize_remove_count_args(name: &str, distinct: bool, args: &[&Expr]) -> bool {
     name.eq_ignore_ascii_case("count")
@@ -25,23 +22,3 @@ pub fn optimize_remove_count_args(name: &str, distinct: bool, args: &[&Expr]) ->
             .iter()
             .all(|expr| matches!(expr, Expr::Literal{lit,..} if *lit!=Literal::Null))
 }
-
-pub fn find_smallest_column(entries: &[ColumnEntry]) -> usize {
-    debug_assert!(!entries.is_empty());
-    let mut column_indexes = entries
-        .iter()
-        .map(|entry| entry.index())
-        .collect::<Vec<IndexType>>();
-    column_indexes.sort();
-    let mut smallest_index = column_indexes[0];
-    let mut smallest_size = usize::MAX;
-    for (idx, column_entry) in entries.iter().enumerate() {
-        if let Ok(bytes) = column_entry.data_type().data_type_id().numeric_byte_size() {
-            if smallest_size > bytes {
-                smallest_size = bytes;
-                smallest_index = entries[idx].index();
-            }
-        }
-    }
-    smallest_index
-}

src/query/service/src/sql/planner/mod.rs

@@ -39,7 +39,6 @@ pub use binder::Visibility;
 use common_catalog::catalog::CatalogManager;
 use common_planner::Metadata;
 use common_planner::MetadataRef;
-pub use metadata::find_smallest_column;
 pub use semantic::normalize_identifier;
 pub use semantic::IdentifierNormalizer;
 pub use semantic::NameResolutionContext;

src/query/service/src/sql/planner/optimizer/heuristic/prune_columns.rs

@@ -17,7 +17,6 @@ use common_exception::Result;
 use common_planner::MetadataRef;
 use itertools::Itertools;
 
-use crate::sql::find_smallest_column;
 use crate::sql::optimizer::ColumnSet;
 use crate::sql::optimizer::RelExpr;
 use crate::sql::optimizer::SExpr;
@@ -90,7 +89,7 @@ impl ColumnPruner {
                         let smallest_index = self
                             .metadata
                             .read()
-                            .find_smallest_column_within(prewhere_columns.as_slice());
+                            .find_smallest_column(prewhere_columns.as_slice());
                         used.insert(smallest_index);
                     }
                     pw.output_columns = used.clone();
@@ -100,8 +99,10 @@ impl ColumnPruner {
                 }
 
                 if used.is_empty() {
-                    let columns = self.metadata.read().columns_by_table_index(p.table_index);
-                    let smallest_index = find_smallest_column(&columns);
+                    let smallest_index = self
+                        .metadata
+                        .read()
+                        .find_smallest_column_by_table_index(p.table_index);
                     used.insert(smallest_index);
                 }