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