uqa_execution/relational/
filter.rs1use super::{
10 truthy, BackwardScanSupport, Batch, DefaultExpressionEvaluator, ExecResult, PhysicalOperator,
11 PhysicalScanDirection, RowSchema, SQLParam, ScalarExpr, SharedExpressionEvaluator,
12 SharedRowPredicate,
13};
14
15pub struct Filter<'a> {
18 child: Box<dyn PhysicalOperator + 'a>,
19 condition: FilterCondition<'a>,
20 schema: RowSchema,
21}
22
23enum FilterCondition<'a> {
24 Expression {
25 predicate: crate::scalar::PreparedExpressions<ScalarExpr>,
26 evaluator: SharedExpressionEvaluator<'a>,
27 },
28 Row(SharedRowPredicate<'a>),
29}
30
31impl Filter<'static> {
32 pub fn new(
33 child: Box<dyn PhysicalOperator>,
34 predicate: ScalarExpr,
35 params: Vec<SQLParam>,
36 ) -> Self {
37 Self::with_evaluator(child, predicate, DefaultExpressionEvaluator::shared(params))
38 }
39}
40
41impl<'a> Filter<'a> {
42 pub fn with_evaluator(
43 child: Box<dyn PhysicalOperator + 'a>,
44 predicate: ScalarExpr,
45 evaluator: SharedExpressionEvaluator<'a>,
46 ) -> Self {
47 let schema = child.row_schema().clone();
48 let predicate = evaluator.bind_type_introspection(predicate, &schema);
49 Self {
50 child,
51 condition: FilterCondition::Expression {
52 predicate: crate::scalar::PreparedExpressions::scalar(predicate),
53 evaluator,
54 },
55 schema,
56 }
57 }
58
59 pub fn with_row_predicate(
60 child: Box<dyn PhysicalOperator + 'a>,
61 predicate: SharedRowPredicate<'a>,
62 ) -> Self {
63 let schema = child.row_schema().clone();
64 Self {
65 child,
66 condition: FilterCondition::Row(predicate),
67 schema,
68 }
69 }
70
71 fn filter_batch(&self, batch: Batch) -> ExecResult<Option<Batch>> {
72 let mut kept = Vec::with_capacity(batch.rows.len());
73 for row in batch.rows {
74 let keep = match &self.condition {
75 FilterCondition::Expression {
76 predicate,
77 evaluator,
78 } => truthy(&evaluator.evaluate_physical_with_function_states(
79 predicate,
80 &batch.schema,
81 &row,
82 predicate.calls(),
83 )?),
84 FilterCondition::Row(predicate) => predicate.keep_physical(&batch.schema, &row)?,
85 };
86 if keep {
87 kept.push(row);
88 }
89 }
90 Ok((!kept.is_empty()).then(|| Batch::from_physical_rows(self.schema.clone(), kept)))
91 }
92}
93
94impl PhysicalOperator for Filter<'_> {
95 fn row_schema(&self) -> &RowSchema {
96 &self.schema
97 }
98
99 fn estimated_cardinality(&self) -> Option<u64> {
100 self.child.estimated_cardinality()
101 }
102
103 fn output_ordering(&self) -> &[crate::PhysicalOrder] {
104 self.child.output_ordering()
105 }
106
107 fn backward_scan_support(&self) -> BackwardScanSupport {
108 if self.child.backward_scan_support() == BackwardScanSupport::Native {
109 BackwardScanSupport::Native
110 } else {
111 BackwardScanSupport::Unsupported
112 }
113 }
114
115 fn open(&mut self) -> ExecResult<()> {
116 self.child.open()
117 }
118
119 fn next(&mut self) -> ExecResult<Option<Batch>> {
120 loop {
121 let Some(batch) = self.child.next()? else {
122 return Ok(None);
123 };
124 if let Some(batch) = self.filter_batch(batch)? {
125 return Ok(Some(batch));
126 }
127 }
128 }
129
130 fn next_direction(&mut self, direction: PhysicalScanDirection) -> ExecResult<Option<Batch>> {
131 loop {
132 let Some(batch) = self.child.next_direction(direction)? else {
133 return Ok(None);
134 };
135 if let Some(batch) = self.filter_batch(batch)? {
136 return Ok(Some(batch));
137 }
138 }
139 }
140
141 fn rewind(&mut self) -> ExecResult<()> {
142 self.child.rewind()
143 }
144
145 fn close(&mut self) -> ExecResult<()> {
146 self.child.close()
147 }
148}