feat: support index cover & fix is_null can't use index

Author: KKould

src/execution/dql/index_scan.rs

@@ -4,15 +4,31 @@ use crate::planner::operator::table_scan::TableScanOperator;
 use crate::storage::{Iter, StatisticsMetaCache, TableCache, Transaction, ViewCache};
 use crate::throw;
 use crate::types::index::IndexMetaRef;
+use crate::types::serialize::TupleValueSerializableImpl;
 
 pub(crate) struct IndexScan {
     op: TableScanOperator,
     index_by: IndexMetaRef,
     ranges: Vec<Range>,
+    covered_deserializers: Option<Vec<TupleValueSerializableImpl>>,
 }
 
-impl From<(TableScanOperator, IndexMetaRef, Range)> for IndexScan {
-    fn from((op, index_by, range): (TableScanOperator, IndexMetaRef, Range)) -> Self {
+impl
+    From<(
+        TableScanOperator,
+        IndexMetaRef,
+        Range,
+        Option<Vec<TupleValueSerializableImpl>>,
+    )> for IndexScan
+{
+    fn from(
+        (op, index_by, range, covered_deserializers): (
+            TableScanOperator,
+            IndexMetaRef,
+            Range,
+            Option<Vec<TupleValueSerializableImpl>>,
+        ),
+    ) -> Self {
         let ranges = match range {
             Range::SortedRanges(ranges) => ranges,
             range => vec![range],
@@ -22,6 +38,7 @@ impl From<(TableScanOperator, IndexMetaRef, Range)> for IndexScan {
             op,
             index_by,
             ranges,
+            covered_deserializers,
         }
     }
 }
@@ -51,6 +68,7 @@ impl<'a, T: Transaction + 'a> ReadExecutor<'a, T> for IndexScan {
                     self.index_by,
                     self.ranges,
                     with_pk,
+                    self.covered_deserializers,
                 )
             );
 

src/execution/mod.rs

@@ -124,9 +124,11 @@ pub fn build_read<'a, T: Transaction + 'a>(
             if let Some(PhysicalOption::IndexScan(IndexInfo {
                 meta,
                 range: Some(range),
+                covered_deserializers,
             })) = plan.physical_option
             {
-                IndexScan::from((op, meta, range)).execute(cache, transaction)
+                IndexScan::from((op, meta, range, covered_deserializers))
+                    .execute(cache, transaction)
             } else {
                 SeqScan::from(op).execute(cache, transaction)
             }

src/optimizer/core/memo.rs

@@ -212,6 +212,7 @@ mod tests {
                         max: Bound::Unbounded,
                     }
                 ])),
+                covered_deserializers: None,
             }))
         );
 

src/optimizer/rule/implementation/dql/table_scan.rs

@@ -79,7 +79,9 @@ impl<T: Transaction> ImplementationRule<T> for IndexScanImplementation {
                     {
                         let mut row_count = statistics_meta.collect_count(range)?;
 
-                        if !matches!(index_info.meta.ty, IndexType::PrimaryKey { .. }) {
+                        if index_info.covered_deserializers.is_none()
+                            && !matches!(index_info.meta.ty, IndexType::PrimaryKey { .. })
+                        {
                             // need to return table query(non-covering index)
                             row_count *= 2;
                         }

src/optimizer/rule/normalization/pushdown_predicates.rs

@@ -215,12 +215,17 @@ impl NormalizationRule for PushPredicateIntoScan {
     fn apply(&self, node_id: HepNodeId, graph: &mut HepGraph) -> Result<(), DatabaseError> {
         if let Operator::Filter(op) = graph.operator(node_id).clone() {
             if let Some(child_id) = graph.eldest_child_at(node_id) {
-                if let Operator::TableScan(child_op) = graph.operator_mut(child_id) {
-                    //FIXME: now only support `unique` and `primary key`
-                    for IndexInfo { meta, range } in &mut child_op.index_infos {
+                if let Operator::TableScan(scan_op) = graph.operator_mut(child_id) {
+                    for IndexInfo {
+                        meta,
+                        range,
+                        covered_deserializers,
+                    } in &mut scan_op.index_infos
+                    {
                         if range.is_some() {
                             continue;
                         }
+                        // range detach
                         *range = match meta.ty {
                             IndexType::PrimaryKey { is_multiple: false }
                             | IndexType::Unique
@@ -232,6 +237,17 @@ impl NormalizationRule for PushPredicateIntoScan {
                                 Self::composite_range(&op, meta)?
                             }
                         };
+                        // try index covered
+                        let mut deserializers = Vec::with_capacity(scan_op.columns.len());
+                        for column_id in &meta.column_ids {
+                            for column in scan_op.columns.values() {
+                                if column.id().map(|id| &id == column_id).unwrap_or(false) {
+                                    deserializers.push(column.datatype().serializable());
+                                }
+                            }
+                        }
+                        *covered_deserializers =
+                            (!deserializers.is_empty()).then_some(deserializers);
                     }
                 }
             }

src/planner/operator/table_scan.rs

@@ -48,6 +48,7 @@ impl TableScanOperator {
             .map(|meta| IndexInfo {
                 meta: meta.clone(),
                 range: None,
+                covered_deserializers: None,
             })
             .collect_vec();
 

src/storage/memory.rs

@@ -349,6 +349,7 @@ mod native_tests {
                 max: Bound::Included(DataValue::Int32(2)),
             }],
             true,
+            None,
         )?;
 
         let mut result = Vec::new();