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