1use crate::{Arc, Engine};
10use uqa_sql::{
11 ast::{ColumnType, FunctionBinding},
12 routines::{
13 resolution::{RoutineOverloadCatalog, RoutineOverloadContext, RoutineTypeSnapshot},
14 RoutineResolution, SQLUserFunction, StaticFunctionMatch,
15 },
16 type_resolution::{BuiltinFunctionOverload, FunctionTypeResolver, ResolvedFunctionOverload},
17 SQLError,
18};
19
20impl RoutineOverloadCatalog for Engine {
21 fn routine_type_snapshot(&self) -> RoutineTypeSnapshot {
22 self.query_catalog_snapshot.as_ref().map_or_else(
23 || self.durable.domains.snapshot(),
24 |snapshot| Arc::clone(&snapshot.domains),
25 )
26 }
27 fn routine_search_path(&self) -> Vec<String> {
28 crate::session::effective_search_path(&self.session.state.read())
29 }
30 fn has_registered_scalar_function(&self, name: &str) -> bool {
31 Engine::has_registered_scalar_function(self, name)
32 }
33 fn lookup_sql_routine_candidates(
34 &self,
35 name: &str,
36 ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
37 Engine::lookup_sql_routine_candidates(self, name)
38 }
39 fn lookup_bound_sql_routine_candidates_by_binding(
40 &self,
41 binding: &FunctionBinding,
42 ) -> Option<Vec<Arc<SQLUserFunction>>> {
43 Engine::lookup_bound_sql_routine_candidates_by_binding(self, binding)
44 }
45 fn lookup_bound_sql_functions_by_binding(
46 &self,
47 binding: &FunctionBinding,
48 ) -> Option<Vec<Arc<SQLUserFunction>>> {
49 Engine::lookup_bound_sql_functions_by_binding(self, binding)
50 }
51}
52
53impl RoutineResolution for Engine {
54 fn routine_body(
55 &self,
56 function: &SQLUserFunction,
57 ) -> Result<Arc<uqa_sql::routines::CompiledFunctionBody>, SQLError> {
58 self.session.routine_bodies.body(function, |def| {
59 uqa_execution::routines::invocation::bodies::compile_session_body(
60 self,
61 &self.routine_definition_context().compilation.analysis,
62 def,
63 )
64 })
65 }
66
67 fn routine_analysis_body(
68 &self,
69 function: &SQLUserFunction,
70 ) -> Result<Arc<uqa_sql::routines::CompiledFunctionBody>, SQLError> {
71 if matches!(function.body, uqa_sql::routines::RoutineBody::Source) {
72 self.session.routine_bodies.inspect(function, |definition| {
73 uqa_execution::routines::invocation::bodies::compile_analysis_body(
74 self,
75 &self.routine_compilation_context(),
76 definition,
77 )
78 })
79 } else {
80 self.routine_body(function)
81 }
82 }
83
84 fn lookup_bound_sql_functions(&self, name: &str) -> Option<Vec<Arc<SQLUserFunction>>> {
85 Engine::lookup_bound_sql_functions(self, name)
86 }
87
88 fn lookup_bound_sql_functions_by_binding(
89 &self,
90 binding: &FunctionBinding,
91 ) -> Option<Vec<Arc<SQLUserFunction>>> {
92 Engine::lookup_bound_sql_functions_by_binding(self, binding)
93 }
94
95 fn has_registered_scalar_function(&self, name: &str) -> bool {
96 Engine::has_registered_scalar_function(self, name)
97 }
98
99 fn has_registered_table_function(&self, name: &str) -> bool {
100 Engine::has_registered_table_function(self, name)
101 }
102
103 fn registered_table_function_columns(&self, name: &str) -> Option<Vec<String>> {
104 self.query_runtime_view()
105 .lookup_table_function(&name.to_ascii_lowercase())?
106 .function
107 .output_columns()
108 .map(<[String]>::to_vec)
109 }
110
111 fn has_registered_aggregate_function(&self, name: &str) -> bool {
112 Engine::has_registered_aggregate_function(self, name)
113 }
114
115 fn lookup_visible_sql_functions(
116 &self,
117 name: &str,
118 ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
119 Engine::lookup_visible_sql_functions(self, name)
120 }
121
122 fn lookup_visible_sql_functions_for_analysis(
123 &self,
124 name: &str,
125 ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
126 Engine::lookup_visible_sql_functions_for_analysis(self, name)
127 }
128
129 fn resolve_static_sql_function(
130 &self,
131 name: &str,
132 binding: Option<&FunctionBinding>,
133 argument_names: &[Option<String>],
134 argument_types: &[Option<ColumnType>],
135 explicit_variadic: bool,
136 ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
137 Engine::resolve_static_sql_function(
138 self,
139 name,
140 binding,
141 argument_names,
142 argument_types,
143 explicit_variadic,
144 )
145 }
146
147 fn resolve_static_sql_function_match(
148 &self,
149 name: &str,
150 binding: Option<&FunctionBinding>,
151 argument_names: &[Option<String>],
152 argument_types: &[Option<ColumnType>],
153 explicit_variadic: bool,
154 ) -> Result<Option<StaticFunctionMatch>, SQLError> {
155 Engine::resolve_static_sql_function_match(
156 self,
157 name,
158 binding,
159 argument_names,
160 argument_types,
161 explicit_variadic,
162 )
163 }
164
165 fn resolve_table_function_overload_with_builtins(
166 &self,
167 name: &str,
168 binding: Option<&FunctionBinding>,
169 argument_names: &[Option<String>],
170 argument_types: &[Option<ColumnType>],
171 explicit_variadic: bool,
172 builtins: &[BuiltinFunctionOverload],
173 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
174 Engine::resolve_table_function_overload_with_builtins(
175 self,
176 name,
177 binding,
178 argument_names,
179 argument_types,
180 explicit_variadic,
181 builtins,
182 )
183 }
184}
185
186impl FunctionTypeResolver for Engine {
187 fn format_type_name(&self, ty: &ColumnType) -> Result<String, SQLError> {
188 self.routine_overload_context().format_type_name(ty)
189 }
190
191 fn has_untyped_function(&self, name: &str) -> bool {
192 self.routine_overload_context().has_untyped_function(name)
193 }
194
195 fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, SQLError> {
196 self.routine_overload_context().resolve_type_name(name)
197 }
198
199 fn resolve_collation_name(&self, name: &str) -> Result<Option<u32>, SQLError> {
200 uqa_execution::catalog::projection::resolve_expression_collation_oid(
201 &self.catalog_execution(),
202 name,
203 )
204 .map(Some)
205 }
206
207 fn enum_labels(&self) -> Option<&dyn uqa_sql::expr::enums::EnumLabelCatalog> {
208 Some(self)
209 }
210
211 fn catalog_input_functions(&self) -> Option<&dyn uqa_sql::expr::CatalogInputFunctions> {
212 Some(self)
213 }
214
215 fn composite_types(&self) -> Option<&dyn uqa_sql::expr::composites::CompositeTypeCatalog> {
216 Some(self)
217 }
218
219 fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError> {
220 uqa_execution::catalog::security::type_inquiry::require_type_usage(
221 &self.catalog_execution(),
222 ty,
223 )
224 }
225
226 fn resolve_function_type(
227 &self,
228 name: &str,
229 binding: Option<&FunctionBinding>,
230 argument_names: &[Option<String>],
231 argument_types: &[Option<ColumnType>],
232 explicit_variadic: bool,
233 ) -> Result<Option<ColumnType>, SQLError> {
234 self.routine_overload_context().resolve_function_type(
235 name,
236 binding,
237 argument_names,
238 argument_types,
239 explicit_variadic,
240 )
241 }
242
243 fn resolve_function_overload(
244 &self,
245 name: &str,
246 binding: Option<&FunctionBinding>,
247 argument_names: &[Option<String>],
248 argument_types: &[Option<ColumnType>],
249 explicit_variadic: bool,
250 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
251 self.routine_overload_context().resolve_function_overload(
252 name,
253 binding,
254 argument_names,
255 argument_types,
256 explicit_variadic,
257 )
258 }
259
260 fn is_scalar_function_binding(&self, binding: &FunctionBinding) -> Result<bool, SQLError> {
261 self.routine_overload_context()
262 .is_scalar_function_binding(binding)
263 }
264
265 fn resolve_function_overload_with_builtins(
266 &self,
267 name: &str,
268 binding: Option<&FunctionBinding>,
269 argument_names: &[Option<String>],
270 argument_types: &[Option<ColumnType>],
271 explicit_variadic: bool,
272 builtins: &[BuiltinFunctionOverload],
273 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
274 self.routine_overload_context()
275 .resolve_function_overload_with_builtins(
276 name,
277 binding,
278 argument_names,
279 argument_types,
280 explicit_variadic,
281 builtins,
282 )
283 }
284}
285
286impl uqa_sql::expr::CatalogInputFunctions for Engine {
287 fn read_unknown_input(
288 &self,
289 text: &str,
290 target: &ColumnType,
291 ) -> Result<uqa_core::Value, SQLError> {
292 uqa_sql::expr::read_catalog_input(text, target, self)
293 }
294}
295
296impl Engine {
297 fn routine_overload_context(&self) -> RoutineOverloadContext<'_> {
298 RoutineOverloadContext { catalog: self }
299 }
300 pub(crate) fn resolve_static_sql_function(
301 &self,
302 name: &str,
303 binding: Option<&FunctionBinding>,
304 argument_names: &[Option<String>],
305 argument_types: &[Option<ColumnType>],
306 explicit_variadic: bool,
307 ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
308 self.routine_overload_context().resolve_static_sql_function(
309 name,
310 binding,
311 argument_names,
312 argument_types,
313 explicit_variadic,
314 )
315 }
316
317 pub(crate) fn resolve_static_sql_function_match(
318 &self,
319 name: &str,
320 binding: Option<&FunctionBinding>,
321 argument_names: &[Option<String>],
322 argument_types: &[Option<ColumnType>],
323 explicit_variadic: bool,
324 ) -> Result<Option<StaticFunctionMatch>, SQLError> {
325 self.routine_overload_context()
326 .resolve_static_sql_function_match(
327 name,
328 binding,
329 argument_names,
330 argument_types,
331 explicit_variadic,
332 )
333 }
334
335 pub(crate) fn resolve_table_function_overload_with_builtins(
336 &self,
337 name: &str,
338 binding: Option<&FunctionBinding>,
339 argument_names: &[Option<String>],
340 argument_types: &[Option<ColumnType>],
341 explicit_variadic: bool,
342 builtins: &[BuiltinFunctionOverload],
343 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
344 self.routine_overload_context()
345 .resolve_table_function_overload_with_builtins(
346 name,
347 binding,
348 argument_names,
349 argument_types,
350 explicit_variadic,
351 builtins,
352 )
353 }
354}