chore: add test for composite index trailing columns cover

Author: KKould

src/optimizer/rule/normalization/pushdown_predicates.rs

@@ -13,9 +13,9 @@ use crate::types::index::{IndexInfo, IndexMetaRef, IndexType};
 use crate::types::value::DataValue;
 use crate::types::LogicalType;
 use itertools::Itertools;
-use std::mem;
 use std::ops::Bound;
 use std::sync::LazyLock;
+use std::{mem, slice};
 
 static PUSH_PREDICATE_THROUGH_JOIN: LazyLock<Pattern> = LazyLock::new(|| Pattern {
     predicate: |op| matches!(op, Operator::Filter(_)),
@@ -238,16 +238,27 @@ impl NormalizationRule for PushPredicateIntoScan {
                             }
                         };
                         // try index covered
-                        let mut deserializers = Vec::with_capacity(scan_op.columns.len());
-                        for column_id in &meta.column_ids {
+                        let mut deserializers = Vec::with_capacity(meta.column_ids.len());
+                        let mut cover_count = 0;
+                        let index_column_types = match &meta.value_ty {
+                            LogicalType::Tuple(tys) => tys,
+                            ty => slice::from_ref(ty),
+                        };
+                        for (i, column_id) in meta.column_ids.iter().enumerate() {
                             for column in scan_op.columns.values() {
-                                if column.id().map(|id| &id == column_id).unwrap_or(false) {
-                                    deserializers.push(column.datatype().serializable());
-                                }
+                                deserializers.push(
+                                    if column.id().map(|id| &id == column_id).unwrap_or(false) {
+                                        cover_count += 1;
+                                        column.datatype().serializable()
+                                    } else {
+                                        index_column_types[i].skip_serializable()
+                                    },
+                                );
                             }
                         }
-                        *covered_deserializers =
-                            (!deserializers.is_empty()).then_some(deserializers);
+                        if cover_count == scan_op.columns.len() {
+                            *covered_deserializers = Some(deserializers)
+                        }
                     }
                 }
             }

src/storage/table_codec.rs

@@ -19,9 +19,9 @@ pub(crate) const BOUND_MAX_TAG: u8 = u8::MAX;
 pub(crate) const NULL_TAG: u8 = 0u8;
 pub(crate) const NOTNULL_TAG: u8 = 1u8;
 
-static ROOT_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"R".to_vec());
-static VIEW_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"V".to_vec());
-static HASH_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"H".to_vec());
+static ROOT_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"Root".to_vec());
+static VIEW_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"View".to_vec());
+static HASH_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| b"Hash".to_vec());
 static EMPTY_REFERENCE_TABLES: LazyLock<ReferenceTables> = LazyLock::new(ReferenceTables::new);
 
 pub type Bytes = Vec<u8>;

tests/slt/where_by_index.slt

@@ -202,6 +202,15 @@ select * from t1 where c2 > 0 and c2 < 10;
 query I rowsort
 select c1 from t1 where c1 < 10;
 ----
+1
+7
+
+# unique covered with primary key projection
+query II rowsort
+select c1, id from t1 where c1 < 10;
+----
+1 0
+7 6
 
 statement ok
 drop index t1.u_c1_index;
@@ -210,15 +219,49 @@ drop index t1.u_c1_index;
 query II rowsort
 select c2 from t1 where c2 < 10 and c2 > 0;
 ----
+8
+9
 
 statement ok
 drop index t1.c2_index;
 
 # composite covered
 query II rowsort
-select c1 c2 from t1 where c1 < 10 and c1 > 0 and c2 >0 and c2 < 10;
+select c1, c2 from t1 where c1 < 10 and c1 > 0 and c2 >0 and c2 < 10;
 ----
+1 9
+7 8
+
+# composite covered projection reorder
+query II rowsort
+select c2, c1 from t1 where c1 < 10 and c1 > 0 and c2 > 0 and c2 < 10;
+----
+8 7
+9 1
+
+
+statement ok
+drop table t1;
 
+statement ok
+create table t_cover(id int primary key, c1 int, c2 int, c3 int);
+
+statement ok
+insert into t_cover values
+    (1, 1, 10, 11),
+    (2, 2, 20, 21),
+    (3, 2, 22, 23),
+    (4, 3, 30, 31);
+
+statement ok
+create index idx_cover on t_cover (c1, c2, c3);
+
+# composite index trailing columns cover (index columns > output columns)
+query II rowsort
+select c2, c3 from t_cover where c1 = 2;
+----
+20 21
+22 23
 
 statement ok
-drop table t1;
+drop table t_cover;