feat: refactor selection constructor to work with subqueries

src/ir/operator.rs

@@ -309,24 +309,37 @@ impl Plan {
     /// Add selection node
     ///
     /// # Errors
+    /// - children list is empty
     /// - filter expression is not boolean
-    /// - child node is not relational
-    /// - child output tuple is not valid
+    /// - children nodes are not relational
+    /// - first child output tuple is not valid
     pub fn add_select(
         &mut self,
-        child: usize,
+        children: &[usize],
         filter: usize,
         id: usize,
     ) -> Result<usize, QueryPlannerError> {
+        let first_child: usize = match children.len() {
+            0 => return Err(QueryPlannerError::InvalidInput),
+            _ => children[0],
+        };
+
         if let Node::Expression(Expression::Bool { .. }) = self.get_node(filter)? {
         } else {
             return Err(QueryPlannerError::InvalidBool);
         }
 
-        let output = self.add_row_for_output(id, child, &[])?;
+        for child in children {
+            if let Node::Relational(_) = self.get_node(*child)? {
+            } else {
+                return Err(QueryPlannerError::InvalidRelation);
+            }
+        }
+
+        let output = self.add_row_for_output(id, first_child, &[])?;
 
         let select = Relational::Selection {
-            children: vec![child],
+            children: children.into(),
             filter,
             id,
             output,

src/ir/operator/tests.rs

@@ -164,18 +164,20 @@ fn selection() {
     let gt_id = plan.nodes.add_bool(ref_row, Bool::Gt, const_row).unwrap();
 
     // Correct Selection operator
-    plan.add_select(scan_id, gt_id, logical_id).unwrap();
+    plan.add_select(&[scan_id], gt_id, logical_id).unwrap();
 
     // Non-boolean filter
     assert_eq!(
         QueryPlannerError::InvalidBool,
-        plan.add_select(scan_id, const_row, logical_id).unwrap_err()
+        plan.add_select(&[scan_id], const_row, logical_id)
+            .unwrap_err()
     );
 
     // Non-relational child
     assert_eq!(
-        QueryPlannerError::InvalidNode,
-        plan.add_select(const_row, gt_id, logical_id).unwrap_err()
+        QueryPlannerError::InvalidRelation,
+        plan.add_select(&[const_row], gt_id, logical_id)
+            .unwrap_err()
     );
 }
 

src/ir/transformation/equality_propagation/tests.rs

@@ -64,7 +64,7 @@ fn selection() {
     // a = 1 and b = 2 and c = 1 or d = 1
     let a1b2c1_d1 = plan.nodes.add_bool(a1b2c1, Bool::Or, d1).unwrap();
 
-    let select_id = plan.add_select(scan_id, a1b2c1_d1, logical_id).unwrap();
+    let select_id = plan.add_select(&[scan_id], a1b2c1_d1, logical_id).unwrap();
     plan.set_top(select_id).unwrap();
 
     let candidates = plan.nodes.gather_expr_for_eq_propagation().unwrap();

src/ir/tree/tests.rs

@@ -95,7 +95,7 @@ fn relational_post() {
     let a = plan.add_row_from_child(id, scan_t2_id, &["a"]).unwrap();
     let const1 = plan.add_const(Value::number_from_str("1").unwrap());
     let eq = plan.nodes.add_bool(a, Bool::Eq, const1).unwrap();
-    let selection_id = plan.add_select(scan_t2_id, eq, id).unwrap();
+    let selection_id = plan.add_select(&[scan_t2_id], eq, id).unwrap();
 
     let union_id = plan.add_union_all(scan_t1_id, selection_id).unwrap();
     plan.set_top(union_id).unwrap();