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