1use 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}