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 require_builtin_execute(
16        &self,
17        binding: &uqa_sql::ast::FunctionBinding,
18    ) -> Result<(), SQLError> {
19        use uqa_sql::catalog::security::builtin_routines::BuiltinRoutineExecution;
20        uqa_execution::catalog::security::builtin_routines::execution::BuiltinRoutinePermissions::capture(
21            &self.catalog_execution(),
22        ).require_execute(binding)
23    }
24
25    fn transaction_timestamp_micros(&self) -> Option<i64> {
26        Some(Engine::transaction_timestamp_micros(self))
27    }
28
29    fn statement_timestamp_micros(&self) -> Option<i64> {
30        Some(Engine::statement_timestamp_micros(self))
31    }
32
33    fn resolve_regtype_input(&self, name: &str) -> Result<Option<i64>, SQLError> {
34        uqa_execution::catalog::projection::resolve_regtype_oid(&self.catalog_execution(), name)?
35            .map(Some)
36            .ok_or_else(|| SQLError::Routine {
37                sqlstate: "42704".into(),
38                message: format!("type \"{name}\" does not exist"),
39            })
40    }
41    fn cast_domain(
42        &self,
43        value: &Value,
44        source: Option<&str>,
45        target: &uqa_sql::ast::ColumnType,
46    ) -> Result<Option<Value>, SQLError> {
47        uqa_sql::assignment::domain::cast_domain_value(self, value, source, target)
48    }
49    fn resolve_type_name(
50        &self,
51        name: &str,
52    ) -> std::result::Result<Option<uqa_sql::ast::ColumnType>, String> {
53        Ok(
54            uqa_execution::catalog::projection::resolve_catalog_column_type(
55                &self.catalog_execution(),
56                name,
57            ),
58        )
59    }
60
61    fn resolve_type_oid(&self, oid: u32) -> Result<Option<uqa_sql::ast::ColumnType>, String> {
62        Ok(
63            uqa_execution::catalog::projection::resolve_catalog_user_type_by_oid(
64                &self.catalog_execution(),
65                oid,
66            ),
67        )
68    }
69
70    fn resolve_regclass_input(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
71        uqa_execution::catalog::projection::resolve_regclass_oid(&self.catalog_execution(), name)
72    }
73
74    fn resolve_regproc(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
75        uqa_execution::catalog::projection::resolve_regproc_input_oid(
76            &self.catalog_execution(),
77            name,
78        )
79        .map(Some)
80    }
81
82    fn resolve_regprocedure(&self, name: &str) -> std::result::Result<Option<i64>, String> {
83        uqa_execution::catalog::projection::resolve_regprocedure_oid(
84            &self.catalog_execution(),
85            name,
86        )
87    }
88
89    fn resolve_regprocedure_input(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
90        uqa_execution::catalog::projection::resolve_regprocedure_input_oid(
91            &self.catalog_execution(),
92            name,
93        )
94        .map(Some)
95    }
96
97    fn resolve_regrole(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
98        uqa_execution::catalog::projection::resolve_regrole_oid(&self.catalog_execution(), name)
99    }
100
101    fn resolve_regnamespace(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
102        uqa_execution::catalog::projection::resolve_regnamespace_oid(
103            &self.catalog_execution(),
104            name,
105        )
106    }
107
108    fn resolve_regcollation(&self, name: &str) -> std::result::Result<Option<i64>, SQLError> {
109        uqa_execution::catalog::projection::resolve_regcollation_oid(
110            &self.catalog_execution(),
111            name,
112        )
113    }
114
115    fn resolve_regobject(
116        &self,
117        ty: &uqa_sql::ast::ColumnType,
118        name: &str,
119    ) -> std::result::Result<Option<i64>, SQLError> {
120        uqa_execution::catalog::projection::resolve_regobject_oid(
121            &self.catalog_execution(),
122            ty,
123            name,
124        )
125    }
126
127    fn resolve_regtype_output(
128        &self,
129        ty: &uqa_sql::ast::ColumnType,
130        oid: i64,
131    ) -> std::result::Result<Option<String>, String> {
132        uqa_execution::catalog::projection::resolve_regtype_output(
133            &self.catalog_execution(),
134            ty,
135            oid,
136        )
137    }
138
139    fn enum_labels(&self) -> Option<&dyn uqa_sql::expr::enums::EnumLabelCatalog> {
140        Some(self)
141    }
142
143    fn composite_types(&self) -> Option<&dyn uqa_sql::expr::composites::CompositeTypeCatalog> {
144        Some(self)
145    }
146
147    fn nextval(&self, name: &str) -> std::result::Result<i64, SQLError> {
148        self.nextval_sql(name)
149    }
150
151    fn currval(&self, name: &str) -> std::result::Result<i64, SQLError> {
152        self.currval_sql(name)
153    }
154
155    fn lastval(&self) -> std::result::Result<i64, SQLError> {
156        self.lastval_sql()
157    }
158
159    fn setval(
160        &self,
161        name: &str,
162        value: i64,
163        is_called: bool,
164    ) -> std::result::Result<i64, SQLError> {
165        self.setval_sql(name, value, is_called)
166    }
167
168    fn call_scalar_function(
169        &self,
170        name: &str,
171        args: &[Value],
172    ) -> Option<std::result::Result<Value, SQLError>> {
173        self.call_registered_scalar_function(name, args)
174    }
175
176    fn call_bound_builtin_function(
177        &self,
178        binding: &uqa_sql::ast::FunctionBinding,
179        args: &[(Option<String>, Value)],
180    ) -> Option<std::result::Result<Value, SQLError>> {
181        uqa_execution::query::scalar_functions::call_bound_builtin(
182            &self.scalar_function_context(),
183            binding,
184            args,
185        )
186    }
187
188    fn has_scalar_functions(&self) -> bool {
189        self.has_registered_scalar_functions()
190    }
191
192    fn current_schema(&self) -> std::result::Result<Option<String>, String> {
193        self.current_schema_name_in_execution()
194            .map_err(|error| error.to_string())
195    }
196
197    fn current_user(&self) -> std::result::Result<Option<String>, SQLError> {
198        Ok(Some(
199            self.current_role()
200                .require_name(&self.durable.roles.read())?
201                .to_owned(),
202        ))
203    }
204
205    fn session_user(&self) -> std::result::Result<Option<String>, SQLError> {
206        Ok(Some(
207            self.session_role()
208                .require_name(&self.durable.roles.read())?
209                .to_owned(),
210        ))
211    }
212
213    fn runtime_parameter(&self, name: &str) -> std::result::Result<Option<String>, SQLError> {
214        Ok(self.session_execution_view().runtime_parameter(name))
215    }
216
217    fn temporal_interval_style(
218        &self,
219    ) -> std::result::Result<Option<uqa_core::TemporalIntervalStyle>, SQLError> {
220        Ok(Some(self.session.interval_style()))
221    }
222
223    fn temporal_time_zone(
224        &self,
225    ) -> std::result::Result<Option<uqa_core::TemporalTimeZone>, SQLError> {
226        Ok(Some(self.session.time_zone()))
227    }
228
229    fn sleep(&self, duration: std::time::Duration) -> std::result::Result<(), SQLError> {
230        Ok(self.runtime.cancellation.sleep(duration)?)
231    }
232
233    fn set_runtime_parameter(
234        &self,
235        name: &str,
236        value: Option<&str>,
237        local: bool,
238    ) -> std::result::Result<String, SQLError> {
239        self.set_config(name, value, local)
240    }
241
242    fn current_schemas(
243        &self,
244        include_implicit: bool,
245    ) -> std::result::Result<Option<Vec<String>>, String> {
246        self.current_schema_names_in_execution(include_implicit)
247            .map(Some)
248            .map_err(|error| error.to_string())
249    }
250
251    fn random_value(&self) -> std::result::Result<Option<f64>, String> {
252        Ok(Some(self.next_random_value()))
253    }
254
255    fn random_u64(&self) -> std::result::Result<Option<u64>, String> {
256        Ok(Some(self.next_random_u64()))
257    }
258
259    fn set_random_seed(&self, seed: f64) -> std::result::Result<bool, String> {
260        Engine::set_random_seed(self, seed)?;
261        Ok(true)
262    }
263
264    fn call_user_function(
265        &self,
266        name: &str,
267        args: &[(Option<String>, Value)],
268    ) -> Option<std::result::Result<Value, SQLError>> {
269        crate::capabilities::routine_invocation::call_user_scalar_function(self, name, args)
270    }
271}