Complete partial implementation of filter

Author: lanlou1554

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

@@ -0,0 +1,48 @@
+use crate::common::{
+    nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprPredicateNode},
+    values::Value,
+};
+
+use super::list_pred::ListPred;
+
+#[derive(Clone, Debug)]
+pub struct InListPred(pub ArcPredicateNode);
+
+impl InListPred {
+    pub fn new(child: ArcPredicateNode, list: ListPred, negated: bool) -> Self {
+        InListPred(
+            PredicateNode {
+                typ: PredicateType::InList,
+                children: vec![child, list.into_pred_node()],
+                data: Some(Value::Bool(negated)),
+            }
+            .into(),
+        )
+    }
+
+    pub fn child(&self) -> ArcPredicateNode {
+        self.0.child(0)
+    }
+
+    pub fn list(&self) -> ListPred {
+        ListPred::from_pred_node(self.0.child(1)).unwrap()
+    }
+
+    /// `true` for `NOT IN`.
+    pub fn negated(&self) -> bool {
+        self.0.data.as_ref().unwrap().as_bool()
+    }
+}
+
+impl ReprPredicateNode for InListPred {
+    fn into_pred_node(self) -> ArcPredicateNode {
+        self.0
+    }
+
+    fn from_pred_node(pred_node: ArcPredicateNode) -> Option<Self> {
+        if !matches!(pred_node.typ, PredicateType::InList) {
+            return None;
+        }
+        Some(Self(pred_node))
+    }
+}

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

@@ -0,0 +1,66 @@
+use std::sync::Arc;
+
+use crate::common::{
+    nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprPredicateNode},
+    values::Value,
+};
+
+#[derive(Clone, Debug)]
+pub struct LikePred(pub ArcPredicateNode);
+
+impl LikePred {
+    pub fn new(
+        negated: bool,
+        case_insensitive: bool,
+        child: ArcPredicateNode,
+        pattern: ArcPredicateNode,
+    ) -> Self {
+        // TODO: support multiple values in data.
+        let negated = if negated { 1 } else { 0 };
+        let case_insensitive = if case_insensitive { 1 } else { 0 };
+        LikePred(
+            PredicateNode {
+                typ: PredicateType::Like,
+                children: vec![child.into_pred_node(), pattern.into_pred_node()],
+                data: Some(Value::Serialized(Arc::new([negated, case_insensitive]))),
+            }
+            .into(),
+        )
+    }
+
+    pub fn child(&self) -> ArcPredicateNode {
+        self.0.child(0)
+    }
+
+    pub fn pattern(&self) -> ArcPredicateNode {
+        self.0.child(1)
+    }
+
+    /// `true` for `NOT LIKE`.
+    pub fn negated(&self) -> bool {
+        match self.0.data.as_ref().unwrap() {
+            Value::Serialized(data) => data[0] != 0,
+            _ => panic!("not a serialized value"),
+        }
+    }
+
+    pub fn case_insensitive(&self) -> bool {
+        match self.0.data.as_ref().unwrap() {
+            Value::Serialized(data) => data[1] != 0,
+            _ => panic!("not a serialized value"),
+        }
+    }
+}
+
+impl ReprPredicateNode for LikePred {
+    fn into_pred_node(self) -> ArcPredicateNode {
+        self.0
+    }
+
+    fn from_pred_node(pred_node: ArcPredicateNode) -> Option<Self> {
+        if !matches!(pred_node.typ, PredicateType::Like) {
+            return None;
+        }
+        Some(Self(pred_node))
+    }
+}

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

@@ -0,0 +1,47 @@
+use crate::common::nodes::{ArcPredicateNode, PredicateNode, PredicateType, ReprPredicateNode};
+
+#[derive(Clone, Debug)]
+pub struct ListPred(pub ArcPredicateNode);
+
+impl ListPred {
+    pub fn new(preds: Vec<ArcPredicateNode>) -> Self {
+        ListPred(
+            PredicateNode {
+                typ: PredicateType::List,
+                children: preds,
+                data: None,
+            }
+            .into(),
+        )
+    }
+
+    /// Gets number of expressions in the list
+    pub fn len(&self) -> usize {
+        self.0.children.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.children.is_empty()
+    }
+
+    pub fn child(&self, idx: usize) -> ArcPredicateNode {
+        self.0.child(idx)
+    }
+
+    pub fn to_vec(&self) -> Vec<ArcPredicateNode> {
+        self.0.children.clone()
+    }
+}
+
+impl ReprPredicateNode for ListPred {
+    fn into_pred_node(self) -> ArcPredicateNode {
+        self.0
+    }
+
+    fn from_pred_node(pred_node: ArcPredicateNode) -> Option<Self> {
+        if pred_node.typ != PredicateType::List {
+            return None;
+        }
+        Some(Self(pred_node))
+    }
+}

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

@@ -4,6 +4,9 @@ pub mod cast_pred;
 pub mod constant_pred;
 pub mod data_type_pred;
 pub mod func_pred;
+pub mod in_list_pred;
+pub mod like_pred;
+pub mod list_pred;
 pub mod log_op_pred;
 pub mod sort_order_pred;
 pub mod un_op_pred;