uqa_execution/relational/
evaluator.rs1use super::{
10 eval_scalar, Arc, ExecResult, RowSchema, SQLParam, ScalarEvalContext, ScalarExpr, Value,
11};
12use crate::RowSchemaExecution;
13use uqa_sql::ast::ColumnType;
14use uqa_sql::expr::RowLookup;
15use uqa_sql::SQLError;
16
17use crate::PhysicalRow;
18
19pub trait ExpressionEvaluator: Send + Sync {
20 fn evaluate(&self, expression: &ScalarExpr, row: &dyn RowLookup) -> ExecResult<Value>;
21
22 fn enum_labels(&self) -> Option<&dyn uqa_sql::expr::enums::EnumLabelCatalog> {
24 None
25 }
26
27 fn evaluate_physical(
28 &self,
29 expression: &ScalarExpr,
30 schema: &RowSchema,
31 row: &PhysicalRow,
32 ) -> ExecResult<Value> {
33 self.evaluate(expression, &schema.view(row))
34 }
35
36 fn evaluate_physical_with_function_states(
38 &self,
39 expression: &ScalarExpr,
40 schema: &RowSchema,
41 row: &PhysicalRow,
42 _states: &crate::scalar::FunctionCallStates,
43 ) -> ExecResult<Value> {
44 self.evaluate_physical(expression, schema, row)
45 }
46
47 fn parameters(&self) -> &[SQLParam] {
50 &[]
51 }
52
53 fn expression_type(
54 &self,
55 expression: &ScalarExpr,
56 schema: &RowSchema,
57 ) -> Result<Option<ColumnType>, SQLError> {
58 crate::scalar_type(expression, schema, self.parameters())
59 }
60
61 fn bind_type_introspection(&self, expression: ScalarExpr, schema: &RowSchema) -> ScalarExpr {
63 crate::bind_type_introspection(expression, schema, self.parameters())
64 }
65
66 fn bind_type_introspection_owned(
68 &self,
69 expression: uqa_sql::plan::OwnedScalarExpr,
70 schema: &RowSchema,
71 control: &uqa_core::memory::ProductionControl<'_>,
72 ) -> Result<uqa_sql::plan::OwnedScalarExpr, SQLError> {
73 uqa_sql::bind_type_introspection_owned(expression, schema, self.parameters(), None, control)
74 }
75
76 fn expression_type_with_control(
77 &self,
78 expression: &ScalarExpr,
79 schema: &RowSchema,
80 control: &uqa_core::memory::ProductionControl<'_>,
81 ) -> Result<Option<uqa_core::memory::Produced<ColumnType>>, SQLError> {
82 uqa_sql::scalar_type_with_control(expression, schema, self.parameters(), control)
83 }
84
85 fn star_column_visible(&self, _column: &str) -> bool {
86 true
87 }
88
89 fn star_position_visible(&self, schema: &RowSchema, position: usize) -> bool {
92 schema.wildcard_position_visible(position)
93 && schema
94 .columns()
95 .get(position)
96 .is_none_or(|column| self.star_column_visible(column))
97 }
98
99 fn project_star(&self, row: &dyn RowLookup) -> ExecResult<Vec<(String, Value)>> {
100 let mut output = Vec::new();
101 row.visit_columns(&mut |column, value| {
102 if self.star_column_visible(column) {
103 output.push((column.to_string(), value.clone()));
104 }
105 });
106 Ok(output)
107 }
108}
109
110pub type SharedExpressionEvaluator<'a> = Arc<dyn ExpressionEvaluator + 'a>;
111
112pub trait RowPredicate: Send + Sync {
113 fn keep_physical(&self, schema: &RowSchema, row: &PhysicalRow) -> ExecResult<bool>;
114}
115
116pub type SharedRowPredicate<'a> = Arc<dyn RowPredicate + 'a>;
117
118pub(crate) struct DefaultExpressionEvaluator {
119 params: Vec<SQLParam>,
120}
121
122impl DefaultExpressionEvaluator {
123 pub(crate) fn shared(params: Vec<SQLParam>) -> SharedExpressionEvaluator<'static> {
124 Arc::new(Self { params })
125 }
126}
127
128impl ExpressionEvaluator for DefaultExpressionEvaluator {
129 fn evaluate(&self, expression: &ScalarExpr, row: &dyn RowLookup) -> ExecResult<Value> {
130 let context = ScalarEvalContext::from_row_lookup(row, &self.params);
131 Ok(eval_scalar(expression, &context)?)
132 }
133
134 fn evaluate_physical(
135 &self,
136 expression: &ScalarExpr,
137 schema: &RowSchema,
138 row: &PhysicalRow,
139 ) -> ExecResult<Value> {
140 let view = schema.view(row);
141 let context =
142 ScalarEvalContext::from_row_lookup(&view, &self.params).with_row_schema(schema);
143 Ok(eval_scalar(expression, &context)?)
144 }
145
146 fn parameters(&self) -> &[SQLParam] {
147 &self.params
148 }
149
150 fn evaluate_physical_with_function_states(
151 &self,
152 expression: &ScalarExpr,
153 schema: &RowSchema,
154 row: &PhysicalRow,
155 states: &crate::scalar::FunctionCallStates,
156 ) -> ExecResult<Value> {
157 let view = schema.view(row);
158 let context = ScalarEvalContext::from_row_lookup(&view, &self.params)
159 .with_row_schema(schema)
160 .with_function_states(states);
161 Ok(eval_scalar(expression, &context)?)
162 }
163}