introduce IdPred and make AttributeRefPred store table id and attr index

Author: xx01cyx

optd-cost-model/src/common/nodes.rs

@@ -51,6 +51,7 @@ pub enum PredicateType {
     Constant(ConstantType),
     AttributeRef,
     ExternAttributeRef,
+    Id,
     UnOp(UnOpType),
     BinOp(BinOpType),
     LogOp(LogOpType),
@@ -79,16 +80,6 @@ pub struct PredicateNode {
     /// Child predicate nodes, always materialized
     pub children: Vec<ArcPredicateNode>,
     /// Data associated with the predicate, if any
-    /// TODO: If it is PredicateType::AttributeRef, then
-    /// the data is attribute index. But we need more information
-    /// to represent this attribute in case it is a derived attribute.
-    /// 1. We can use Vec<Value>, but the disadvantage is that the optimizer
-    /// may need to do some memory copy. (However, if we want to provide a
-    /// general API, the memory copy is unavoidable. It applies for both 1
-    /// and 2 designs). And Vec<Value> lacks readability.
-    /// 2. Also we can use enum, but if Rust uses something like `union` to
-    /// implement enum, then if some members are large, it will waste memory space,
-    /// also causing unnecessary memory copy. But enum provides better readability.
     pub data: Option<Value>,
 }
 

optd-cost-model/src/common/predicates/attr_ref_pred.rs

@@ -1,33 +1,38 @@
-use crate::common::{
-    nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprPredicateNode},
-    values::Value,
-};
+use crate::common::nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprPredicateNode};
 
+use super::id_pred::IdPred;
+
+/// [`AttributeRefPred`] represents a reference to a column in a relation.
+///
+/// An [`AttributeRefPred`] has two children:
+/// 1. The table id, represented by an [`IdPred`].
+/// 2. The index of the column, represented by an [`IdPred`].
 #[derive(Clone, Debug)]
 pub struct AttributeRefPred(pub ArcPredicateNode);
 
 impl AttributeRefPred {
-    /// Creates a new `ColumnRef` expression.
-    pub fn new(attribute_idx: usize) -> AttributeRefPred {
-        // this conversion is always safe since usize is at most u64
-        let u64_attribute_idx = attribute_idx as u64;
+    pub fn new(table_id: usize, attribute_idx: usize) -> AttributeRefPred {
         AttributeRefPred(
             PredicateNode {
                 typ: PredicateType::AttributeRef,
-                children: vec![],
-                data: Some(Value::UInt64(u64_attribute_idx)),
+                children: vec![
+                    IdPred::new(table_id).into_pred_node(),
+                    IdPred::new(attribute_idx).into_pred_node(),
+                ],
+                data: None,
             }
             .into(),
         )
     }
 
-    fn get_data_usize(&self) -> usize {
-        self.0.data.as_ref().unwrap().as_u64() as usize
+    /// Gets the table id.
+    pub fn table_id(&self) -> usize {
+        self.0.child(0).data.as_ref().unwrap().as_u64() as usize
     }
 
-    /// Gets the column index.
-    pub fn index(&self) -> usize {
-        self.get_data_usize()
+    /// Gets the attribute index.
+    pub fn attr_index(&self) -> usize {
+        self.0.child(1).data.as_ref().unwrap().as_u64() as usize
     }
 }
 

optd-cost-model/src/common/predicates/cast_pred.rs

@@ -4,6 +4,11 @@ use crate::common::nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprP
 
 use super::data_type_pred::DataTypePred;
 
+/// [`CastPred`] casts a column from one data type to another.
+///
+/// A [`CastPred`] has two children:
+/// 1. The original data to cast
+/// 2. The target data type to cast to
 #[derive(Clone, Debug)]
 pub struct CastPred(pub ArcPredicateNode);
 

optd-cost-model/src/common/predicates/id_pred.rs

@@ -0,0 +1,40 @@
+use crate::common::{
+    nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprPredicateNode},
+    values::Value,
+};
+
+/// [`IdPred`] holds an id or an index, e.g. table id.
+///
+/// The data is of uint64 type, because an id or an index can always be
+/// represented by uint64.
+#[derive(Clone, Debug)]
+pub struct IdPred(pub ArcPredicateNode);
+
+impl IdPred {
+    pub fn new(id: usize) -> IdPred {
+        // This conversion is always safe since usize is at most u64.
+        let u64_id = id as u64;
+        IdPred(
+            PredicateNode {
+                typ: PredicateType::Id,
+                children: vec![],
+                data: Some(Value::UInt64(u64_id)),
+            }
+            .into(),
+        )
+    }
+}
+
+impl ReprPredicateNode for IdPred {
+    fn into_pred_node(self) -> ArcPredicateNode {
+        self.0
+    }
+
+    fn from_pred_node(pred_node: ArcPredicateNode) -> Option<Self> {
+        if let PredicateType::Id = pred_node.typ {
+            Some(Self(pred_node))
+        } else {
+            None
+        }
+    }
+}

optd-cost-model/src/common/predicates/mod.rs

@@ -4,6 +4,7 @@ pub mod cast_pred;
 pub mod constant_pred;
 pub mod data_type_pred;
 pub mod func_pred;
+pub mod id_pred;
 pub mod in_list_pred;
 pub mod like_pred;
 pub mod list_pred;

optd-cost-model/src/cost/filter.rs

@@ -189,7 +189,7 @@ impl<S: CostModelStorageLayer> CostModelImpl<S> {
             let attr_ref_expr = attr_ref_exprs
                 .first()
                 .expect("we just checked that attr_ref_exprs.len() == 1");
-            let attr_ref_idx = attr_ref_expr.index();
+            let attr_ref_idx = attr_ref_expr.attr_index();
 
             // TODO: Consider attribute is a derived attribute
             if values.len() == 1 {
@@ -415,7 +415,9 @@ impl<S: CostModelStorageLayer> CostModelImpl<S> {
             return Ok(UNIMPLEMENTED_SEL);
         }
 
-        let attr_ref_idx = AttributeRefPred::from_pred_node(child).unwrap().index();
+        let attr_ref_idx = AttributeRefPred::from_pred_node(child)
+            .unwrap()
+            .attr_index();
 
         // TODO: Consider attribute is a derived attribute
         let pattern = ConstantPred::from_pred_node(pattern)
@@ -486,7 +488,9 @@ impl<S: CostModelStorageLayer> CostModelImpl<S> {
         }
 
         // Convert child and const expressions to concrete types.
-        let attr_ref_idx = AttributeRefPred::from_pred_node(child).unwrap().index();
+        let attr_ref_idx = AttributeRefPred::from_pred_node(child)
+            .unwrap()
+            .attr_index();
         let list_exprs = list_exprs
             .into_iter()
             .map(|expr| {
@@ -581,7 +585,7 @@ impl<S: CostModelStorageLayer> CostModelImpl<S> {
                     PredicateType::AttributeRef => {
                         let attr_ref_expr = AttributeRefPred::from_pred_node(cast_expr_child)
                             .expect("we already checked that the type is AttributeRef");
-                        let attr_ref_idx = attr_ref_expr.index();
+                        let attr_ref_idx = attr_ref_expr.attr_index();
                         cast_node = attr_ref_expr.into_pred_node();
                         // The "invert" cast is to invert the cast so that we're casting the
                         // non_cast_node to the attribute's original type.