Skip to main content

uqa_execution/relational/
evaluator.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Expression-evaluation and row-predicate seams.
8
9use 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    /// Borrow the same retained enum catalog used while evaluating expressions.
23    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    /// Evaluate a prepared physical expression with its execution-owned function state.
37    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    /// Bound SQL parameters used by static type resolution. Implementations
48    /// that do not evaluate parameters may keep the empty default.
49    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    /// Bind overloads and common-type coercions while this evaluator's declared-type context is still available.
62    fn bind_type_introspection(&self, expression: ScalarExpr, schema: &RowSchema) -> ScalarExpr {
63        crate::bind_type_introspection(expression, schema, self.parameters())
64    }
65
66    /// Preserve independent scalar constructor owners while binding executable type introspection.
67    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    /// Decide wildcard visibility from the bound logical attribute rather
90    /// than its possibly colliding SQL label.
91    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}