Skip to main content

uqa_engine/
hook.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Adapter from the stable SQL expression hook to engine-owned capabilities.
8
9use uqa_core::Value;
10use uqa_sql::SQLError;
11
12use super::Engine;
13
14impl uqa_sql::expr::EngineHook for Engine {
15    fn construct_range(
16        &self,
17        oid: u32,
18        bounds: uqa_sql::expr::RangeBoundsInput,
19        control: &uqa_core::memory::ProductionControl<'_>,
20    ) -> Result<uqa_core::memory::Produced<Value>, SQLError> {
21        uqa_execution::catalog::range_type::input::construct_range(
22            &self.range_input_context(&self.catalog_read_view(), self),
23            oid,
24            bounds,
25            control,
26        )
27    }
28
29    fn construct_multirange(
30        &self,
31        oid: u32,
32        members: &[Value],
33        control: &uqa_core::memory::ProductionControl<'_>,
34    ) -> Result<uqa_core::memory::Produced<Value>, SQLError> {
35        uqa_execution::catalog::range_type::input::construct_multirange(
36            &self.range_input_context(&self.catalog_read_view(), self),
37            oid,
38            members,
39            control,
40        )
41    }
42
43    fn sql_notice(&self, notice: uqa_sql::SQLNotice) {
44        self.push_sql_notice(notice);
45    }
46
47    fn read_range_input(
48        &self,
49        oid: u32,
50        text: &str,
51        control: &uqa_core::memory::ProductionControl<'_>,
52    ) -> Result<uqa_core::memory::Produced<Value>, SQLError> {
53        uqa_execution::catalog::range_type::input::read_input(
54            &self.range_input_context(&self.catalog_read_view(), self),
55            oid,
56            text,
57            control,
58        )
59    }
60
61    fn require_builtin_execute(
62        &self,
63        binding: &uqa_sql::ast::FunctionBinding,
64    ) -> Result<(), SQLError> {
65        use uqa_sql::catalog::security::builtin_routines::BuiltinRoutineExecution;
66        uqa_execution::catalog::security::builtin_routines::execution::BuiltinRoutinePermissions::capture(
67            &self.catalog_execution(),
68        ).require_execute(binding)
69    }
70
71    fn transaction_timestamp_micros(&self) -> Option<i64> {
72        Some(Engine::transaction_timestamp_micros(self))
73    }
74
75    fn statement_timestamp_micros(&self) -> Option<i64> {
76        Some(Engine::statement_timestamp_micros(self))
77    }
78
79    fn resolve_regtype_input(&self, name: &str) -> Result<Option<i64>, SQLError> {
80        uqa_execution::catalog::projection::resolve_regtype_oid(&self.catalog_execution(), name)?
81            .map(Some)
82            .ok_or_else(|| SQLError::Routine {
83                sqlstate: "42704".into(),
84                message: format!("type \"{name}\" does not exist"),
85            })
86    }
87    fn cast_domain(
88        &self,
89        value: &Value,
90        source: Option<&str>,
91        target: &uqa_sql::ast::ColumnType,
92    ) -> Result<Option<Value>, SQLError> {
93        uqa_sql::assignment::domain::cast_domain_value(self, value, source, target)
94    }
95    fn cast_domain_with_control(
96        &self,
97        value: &Value,
98        source: Option<&str>,
99        target: &uqa_sql::ColumnType,
100        control: &uqa_core::memory::ProductionControl<'_>,
101    ) -> Result<Option<uqa_core::memory::Produced<Value>>, SQLError> {
102        uqa_sql::assignment::domain::cast_domain_value_with_control(
103            self, value, source, target, control,
104        )
105    }
106    fn resolve_type_name(
107        &self,
108        name: &str,
109    ) -> std::result::Result<Option<uqa_sql::ast::ColumnType>, String> {
110        Ok(
111            uqa_execution::catalog::projection::resolve_catalog_column_type(
112                &self.catalog_execution(),
113                name,
114            ),
115        )
116    }
117
118    fn resolve_type_oid(&self, oid: u32) -> Result<Option<uqa_sql::ast::ColumnType>, String> {
119        Ok(
120            uqa_execution::catalog::projection::resolve_catalog_user_type_by_oid(
121                &self.catalog_execution(),
122                oid,
123            ),
124        )
125    }
126
127    fn type_oid_exists(&self, oid: u32) -> Result<bool, String> {
128        uqa_execution::catalog::projection::type_oid_exists(&self.catalog_execution(), oid)
129            .map_err(|error| error.to_string())
130    }
131
132    fn resolve_regclass_input(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
133        uqa_execution::catalog::projection::resolve_regclass_oid(&self.catalog_execution(), name)
134    }
135
136    fn resolve_regproc(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
137        uqa_execution::catalog::projection::resolve_regproc_input_oid(
138            &self.catalog_execution(),
139            name,
140        )
141        .map(Some)
142    }
143
144    fn resolve_regprocedure(&self, name: &str) -> std::result::Result<Option<i64>, String> {
145        uqa_execution::catalog::projection::resolve_regprocedure_oid(
146            &self.catalog_execution(),
147            name,
148        )
149    }
150
151    fn resolve_regprocedure_input(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
152        uqa_execution::catalog::projection::resolve_regprocedure_input_oid(
153            &self.catalog_execution(),
154            name,
155        )
156        .map(Some)
157    }
158
159    fn resolve_regrole(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
160        uqa_execution::catalog::projection::resolve_regrole_oid(&self.catalog_execution(), name)
161    }
162
163    fn resolve_regnamespace(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
164        uqa_execution::catalog::projection::resolve_regnamespace_oid(
165            &self.catalog_execution(),
166            name,
167        )
168    }
169
170    fn resolve_regcollation(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
171        uqa_execution::catalog::projection::resolve_regcollation_oid(
172            &self.catalog_execution(),
173            name,
174        )
175    }
176
177    fn resolve_regobject(
178        &self,
179        ty: &uqa_sql::ast::ColumnType,
180        name: &str,
181    ) -> std::result::Result<Option<i64>, SQLError> {
182        uqa_execution::catalog::projection::resolve_regobject_oid(
183            &self.catalog_execution(),
184            ty,
185            name,
186        )
187    }
188
189    fn resolve_regtype_output(
190        &self,
191        ty: &uqa_sql::ast::ColumnType,
192        oid: i64,
193    ) -> std::result::Result<Option<String>, String> {
194        uqa_execution::catalog::projection::resolve_regtype_output(
195            &self.catalog_execution(),
196            ty,
197            oid,
198        )
199    }
200
201    fn enum_labels(&self) -> Option<&dyn uqa_sql::expr::enums::EnumLabelCatalog> {
202        Some(self)
203    }
204
205    fn composite_types(&self) -> Option<&dyn uqa_sql::expr::composites::CompositeTypeCatalog> {
206        Some(self)
207    }
208
209    fn nextval(&self, name: &str) -> std::result::Result<i64, SQLError> {
210        self.nextval_sql(name)
211    }
212
213    fn currval(&self, name: &str) -> std::result::Result<i64, SQLError> {
214        self.currval_sql(name)
215    }
216
217    fn lastval(&self) -> std::result::Result<i64, SQLError> {
218        self.lastval_sql()
219    }
220
221    fn setval(
222        &self,
223        name: &str,
224        value: i64,
225        is_called: bool,
226    ) -> std::result::Result<i64, SQLError> {
227        self.setval_sql(name, value, is_called)
228    }
229
230    fn call_scalar_function(
231        &self,
232        name: &str,
233        args: &[Value],
234    ) -> Option<std::result::Result<Value, SQLError>> {
235        self.call_registered_scalar_function(name, args)
236    }
237
238    fn call_bound_builtin_function(
239        &self,
240        binding: &uqa_sql::ast::FunctionBinding,
241        args: &[(Option<String>, Value)],
242    ) -> Option<std::result::Result<Value, SQLError>> {
243        uqa_execution::query::scalar_functions::call_bound_builtin(
244            &self.scalar_function_context(),
245            binding,
246            args,
247        )
248    }
249
250    fn has_scalar_functions(&self) -> bool {
251        self.has_registered_scalar_functions()
252    }
253
254    fn current_schema(&self) -> std::result::Result<Option<String>, String> {
255        self.current_schema_name_in_execution()
256            .map_err(|error| error.to_string())
257    }
258
259    fn current_user(&self) -> std::result::Result<Option<String>, SQLError> {
260        Ok(Some(
261            self.current_role()
262                .require_name(&self.durable.roles.read())?
263                .to_owned(),
264        ))
265    }
266
267    fn session_user(&self) -> std::result::Result<Option<String>, SQLError> {
268        Ok(Some(
269            self.session_role()
270                .require_name(&self.durable.roles.read())?
271                .to_owned(),
272        ))
273    }
274
275    fn runtime_parameter(&self, name: &str) -> std::result::Result<Option<String>, SQLError> {
276        Ok(self.session_execution_view().runtime_parameter(name))
277    }
278
279    fn temporal_interval_style(
280        &self,
281    ) -> std::result::Result<Option<uqa_core::TemporalIntervalStyle>, SQLError> {
282        Ok(Some(self.session.interval_style()))
283    }
284
285    fn temporal_time_zone(
286        &self,
287    ) -> std::result::Result<Option<uqa_core::TemporalTimeZone>, SQLError> {
288        Ok(Some(self.session.time_zone()))
289    }
290
291    fn sleep(&self, duration: std::time::Duration) -> std::result::Result<(), SQLError> {
292        Ok(self.runtime.cancellation.sleep(duration)?)
293    }
294
295    fn set_runtime_parameter(
296        &self,
297        name: &str,
298        value: Option<&str>,
299        local: bool,
300    ) -> std::result::Result<String, SQLError> {
301        self.set_config(name, value, local)
302    }
303
304    fn current_schemas(
305        &self,
306        include_implicit: bool,
307    ) -> std::result::Result<Option<Vec<String>>, String> {
308        self.current_schema_names_in_execution(include_implicit)
309            .map(Some)
310            .map_err(|error| error.to_string())
311    }
312
313    fn random_value(&self) -> std::result::Result<Option<f64>, String> {
314        Ok(Some(self.next_random_value()))
315    }
316
317    fn random_u64(&self) -> std::result::Result<Option<u64>, String> {
318        Ok(Some(self.next_random_u64()))
319    }
320
321    fn set_random_seed(&self, seed: f64) -> std::result::Result<bool, String> {
322        Engine::set_random_seed(self, seed)?;
323        Ok(true)
324    }
325
326    fn call_user_function(
327        &self,
328        name: &str,
329        args: &[(Option<String>, Value)],
330    ) -> Option<std::result::Result<Value, SQLError>> {
331        crate::capabilities::routine_invocation::call_user_scalar_function(self, name, args)
332    }
333}