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 routine_schema_precedes_pg_catalog(
31 &self,
32 schema: uqa_core::RelationName<'_>,
33 control: &uqa_core::memory::ProductionControl<'_>,
34 ) -> Result<bool, SQLError> {
35 control.check()?;
36 let state = self.session.state.read();
37 let current_user = state.authorization.current();
38 uqa_sql::routines::resolution::search_path_precedes_pg_catalog(
39 state.search_path.iter().map(|entry| {
40 if entry == "$user" {
41 current_user.name.as_str()
42 } else {
43 entry.as_str()
44 }
45 }),
46 schema,
47 control,
48 )
49 }
50 fn has_registered_scalar_function_with_control(
51 &self,
52 name: &str,
53 control: &uqa_core::memory::ProductionControl<'_>,
54 ) -> Result<bool, SQLError> {
55 self.query_runtime_view()
56 .has_scalar_function_with_control(name, control)
57 }
58
59 fn has_registered_scalar_function(&self, name: &str) -> bool {
60 Engine::has_registered_scalar_function(self, name)
61 }
62 fn lookup_sql_routine_candidates(
63 &self,
64 name: &str,
65 ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
66 Engine::lookup_sql_routine_candidates(self, name)
67 }
68 fn lookup_sql_routine_candidates_with_control(
69 &self,
70 name: &str,
71 control: &uqa_core::memory::ProductionControl<'_>,
72 ) -> Result<Option<uqa_core::memory::Produced<Vec<Arc<SQLUserFunction>>>>, SQLError> {
73 Engine::lookup_sql_routine_candidates_with_control(self, name, control)
74 }
75 fn lookup_bound_sql_routine_candidates_by_binding(
76 &self,
77 binding: &FunctionBinding,
78 ) -> Option<Vec<Arc<SQLUserFunction>>> {
79 Engine::lookup_bound_sql_routine_candidates_by_binding(self, binding)
80 }
81 fn lookup_bound_sql_functions_by_binding(
82 &self,
83 binding: &FunctionBinding,
84 ) -> Option<Vec<Arc<SQLUserFunction>>> {
85 Engine::lookup_bound_sql_functions_by_binding(self, binding)
86 }
87 fn select_bound_routine_with_control(
88 &self,
89 binding: &FunctionBinding,
90 kind: uqa_sql::routines::resolution::RoutineCallKind,
91 control: &uqa_core::memory::ProductionControl<'_>,
92 ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
93 Engine::select_bound_routine_with_control(self, binding, kind, control)
94 }
95}
96
97impl RoutineResolution for Engine {
98 fn routine_body(
99 &self,
100 function: &SQLUserFunction,
101 ) -> Result<Arc<uqa_sql::routines::CompiledFunctionBody>, SQLError> {
102 self.session.routine_bodies.body(function, |def| {
103 uqa_execution::routines::invocation::bodies::compile_session_body(
104 self,
105 &self.routine_definition_context().compilation.analysis,
106 def,
107 )
108 })
109 }
110
111 fn routine_analysis_body(
112 &self,
113 function: &SQLUserFunction,
114 ) -> Result<Arc<uqa_sql::routines::CompiledFunctionBody>, SQLError> {
115 if matches!(function.body, uqa_sql::routines::RoutineBody::Source) {
116 self.session.routine_bodies.inspect(function, |definition| {
117 uqa_execution::routines::invocation::bodies::compile_analysis_body(
118 self,
119 &self.routine_compilation_context(),
120 definition,
121 )
122 })
123 } else {
124 self.routine_body(function)
125 }
126 }
127
128 fn lookup_bound_sql_functions(&self, name: &str) -> Option<Vec<Arc<SQLUserFunction>>> {
129 Engine::lookup_bound_sql_functions(self, name)
130 }
131
132 fn lookup_bound_sql_functions_by_binding(
133 &self,
134 binding: &FunctionBinding,
135 ) -> Option<Vec<Arc<SQLUserFunction>>> {
136 Engine::lookup_bound_sql_functions_by_binding(self, binding)
137 }
138
139 fn has_registered_scalar_function(&self, name: &str) -> bool {
140 Engine::has_registered_scalar_function(self, name)
141 }
142
143 fn has_registered_table_function(&self, name: &str) -> bool {
144 Engine::has_registered_table_function(self, name)
145 }
146
147 fn has_registered_scalar_function_with_control(
148 &self,
149 name: &str,
150 control: &uqa_core::memory::ProductionControl<'_>,
151 ) -> Result<bool, SQLError> {
152 self.query_runtime_view()
153 .has_scalar_function_with_control(name, control)
154 }
155
156 fn has_registered_table_function_with_control(
157 &self,
158 name: &str,
159 control: &uqa_core::memory::ProductionControl<'_>,
160 ) -> Result<bool, SQLError> {
161 self.query_runtime_view()
162 .has_table_function_with_control(name, control)
163 }
164
165 fn has_registered_aggregate_function_with_control(
166 &self,
167 name: &str,
168 control: &uqa_core::memory::ProductionControl<'_>,
169 ) -> Result<bool, SQLError> {
170 self.query_runtime_view()
171 .has_aggregate_function_with_control(name, control)
172 }
173
174 fn registered_table_function_columns(&self, name: &str) -> Option<Vec<String>> {
175 self.query_runtime_view()
176 .lookup_table_function(&name.to_ascii_lowercase())?
177 .function
178 .output_columns()
179 .map(<[String]>::to_vec)
180 }
181
182 fn registered_table_function_columns_with_control(
183 &self,
184 name: &str,
185 control: &uqa_core::memory::ProductionControl<'_>,
186 ) -> Result<Option<uqa_core::memory::Produced<Vec<String>>>, SQLError> {
187 let name = uqa_sql::semantics::lowercase_function_name_with_control(name, control)?;
188 let Some(registered) = self.query_runtime_view().lookup_table_function(&name) else {
189 return Ok(None);
190 };
191 registered
192 .function
193 .output_columns()
194 .map(|columns| {
195 let mut output = uqa_core::memory::ProductionVec::new(*control);
196 for column in columns {
197 output.push_produced(control.copy_text(column)?)?;
198 }
199 Ok(output.finish()?)
200 })
201 .transpose()
202 }
203
204 fn has_registered_aggregate_function(&self, name: &str) -> bool {
205 Engine::has_registered_aggregate_function(self, name)
206 }
207
208 fn lookup_visible_sql_functions(
209 &self,
210 name: &str,
211 ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
212 Engine::lookup_visible_sql_functions(self, name)
213 }
214
215 fn has_visible_sql_functions_with_control(
216 &self,
217 name: &str,
218 control: &uqa_core::memory::ProductionControl<'_>,
219 ) -> Result<bool, SQLError> {
220 self.has_visible_sql_function_candidates_with_control(name, control)
221 }
222
223 fn lookup_visible_sql_functions_for_analysis(
224 &self,
225 name: &str,
226 ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
227 Engine::lookup_visible_sql_functions_for_analysis(self, name)
228 }
229
230 fn visible_function_returns_set_with_control(
231 &self,
232 name: &str,
233 control: &uqa_core::memory::ProductionControl<'_>,
234 ) -> Result<bool, SQLError> {
235 self.visible_sql_function_returns_set_with_control(name, control)
236 }
237
238 fn visible_function_setness_with_control(
239 &self,
240 name: &str,
241 control: &uqa_core::memory::ProductionControl<'_>,
242 ) -> Result<uqa_sql::routines::VisibleFunctionSetness, SQLError> {
243 self.visible_sql_function_setness_with_control(name, control)
244 }
245
246 fn select_bound_function_with_control(
247 &self,
248 binding: &FunctionBinding,
249 control: &uqa_core::memory::ProductionControl<'_>,
250 ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
251 Engine::select_bound_function_with_control(self, binding, control)
252 }
253
254 fn resolve_static_sql_function(
255 &self,
256 name: &str,
257 binding: Option<&FunctionBinding>,
258 argument_names: &[Option<String>],
259 argument_types: &[Option<ColumnType>],
260 explicit_variadic: bool,
261 ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
262 Engine::resolve_static_sql_function(
263 self,
264 name,
265 binding,
266 argument_names,
267 argument_types,
268 explicit_variadic,
269 )
270 }
271
272 fn resolve_static_sql_function_match(
273 &self,
274 name: &str,
275 binding: Option<&FunctionBinding>,
276 argument_names: &[Option<String>],
277 argument_types: &[Option<ColumnType>],
278 explicit_variadic: bool,
279 ) -> Result<Option<StaticFunctionMatch>, SQLError> {
280 Engine::resolve_static_sql_function_match(
281 self,
282 name,
283 binding,
284 argument_names,
285 argument_types,
286 explicit_variadic,
287 )
288 }
289
290 fn resolve_static_sql_function_setness_with_control(
291 &self,
292 name: &str,
293 binding: Option<&FunctionBinding>,
294 argument_names: &[Option<String>],
295 argument_types: &[Option<ColumnType>],
296 explicit_variadic: bool,
297 control: &uqa_core::memory::ProductionControl<'_>,
298 ) -> Result<Option<bool>, SQLError> {
299 let Some(binding) = self
300 .routine_overload_context()
301 .resolve_static_sql_function_binding_with_control(
302 name,
303 binding,
304 argument_names,
305 argument_types,
306 explicit_variadic,
307 control,
308 )?
309 else {
310 return Ok(None);
311 };
312 Ok(self
313 .select_bound_function_with_control(&binding, control)?
314 .map(|function| function.def.returns_set()))
315 }
316
317 fn resolve_static_sql_function_strictness_with_control(
318 &self,
319 name: &str,
320 binding: Option<&FunctionBinding>,
321 call: uqa_sql::type_resolution::RoutineCallDescriptor<'_>,
322 control: &uqa_core::memory::ProductionControl<'_>,
323 ) -> Result<Option<bool>, SQLError> {
324 self.routine_overload_context()
325 .resolve_static_sql_routine_match_with_control(
326 name,
327 binding,
328 call.argument_names,
329 call.argument_types,
330 call.explicit_variadic,
331 uqa_sql::routines::resolution::RoutineCallKind::Function,
332 control,
333 )
334 .map(|selected| selected.map(|selected| selected.function.def.strict))
335 }
336
337 fn resolve_static_sql_function_match_with_control(
338 &self,
339 name: &str,
340 binding: Option<&FunctionBinding>,
341 call: uqa_sql::type_resolution::RoutineCallDescriptor<'_>,
342 control: &uqa_core::memory::ProductionControl<'_>,
343 ) -> Result<Option<uqa_sql::routines::resolution::OwnedStaticFunctionMatch>, SQLError> {
344 self.routine_overload_context()
345 .resolve_static_sql_routine_match_with_control(
346 name,
347 binding,
348 call.argument_names,
349 call.argument_types,
350 call.explicit_variadic,
351 uqa_sql::routines::resolution::RoutineCallKind::Function,
352 control,
353 )
354 }
355
356 fn resolve_static_sql_function_binding_with_control(
357 &self,
358 name: &str,
359 binding: Option<&FunctionBinding>,
360 argument_names: &[Option<String>],
361 argument_types: &[Option<ColumnType>],
362 explicit_variadic: bool,
363 control: &uqa_core::memory::ProductionControl<'_>,
364 ) -> Result<Option<uqa_core::memory::Produced<FunctionBinding>>, SQLError> {
365 self.routine_overload_context()
366 .resolve_static_sql_function_binding_with_control(
367 name,
368 binding,
369 argument_names,
370 argument_types,
371 explicit_variadic,
372 control,
373 )
374 }
375
376 fn resolve_table_function_overload_with_builtins_and_control(
377 &self,
378 name: &str,
379 binding: Option<&FunctionBinding>,
380 call: uqa_sql::type_resolution::RoutineCallDescriptor<'_>,
381 builtins: &[BuiltinFunctionOverload],
382 control: &uqa_core::memory::ProductionControl<'_>,
383 ) -> Result<Option<uqa_core::memory::Produced<ResolvedFunctionOverload>>, SQLError> {
384 self.routine_overload_context()
385 .resolve_table_function_overload_with_builtins_and_control(
386 name, binding, call, builtins, control,
387 )
388 }
389
390 fn resolve_table_function_overload_with_builtins(
391 &self,
392 name: &str,
393 binding: Option<&FunctionBinding>,
394 argument_names: &[Option<String>],
395 argument_types: &[Option<ColumnType>],
396 explicit_variadic: bool,
397 builtins: &[BuiltinFunctionOverload],
398 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
399 Engine::resolve_table_function_overload_with_builtins(
400 self,
401 name,
402 binding,
403 argument_names,
404 argument_types,
405 explicit_variadic,
406 builtins,
407 )
408 }
409}
410
411impl FunctionTypeResolver for Engine {
412 fn format_type_name(&self, ty: &ColumnType) -> Result<String, SQLError> {
413 self.routine_overload_context().format_type_name(ty)
414 }
415
416 fn format_type_name_with_control(
417 &self,
418 ty: &ColumnType,
419 control: &uqa_core::memory::ProductionControl<'_>,
420 ) -> Result<uqa_core::memory::Produced<String>, SQLError> {
421 self.routine_overload_context()
422 .format_type_name_with_control(ty, control)
423 }
424
425 fn has_untyped_function_with_control(
426 &self,
427 name: &str,
428 control: &uqa_core::memory::ProductionControl<'_>,
429 ) -> Result<bool, SQLError> {
430 self.query_runtime_view()
431 .has_scalar_function_with_control(name, control)
432 }
433
434 fn has_untyped_function(&self, name: &str) -> bool {
435 self.routine_overload_context().has_untyped_function(name)
436 }
437
438 fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, SQLError> {
439 self.routine_overload_context().resolve_type_name(name)
440 }
441
442 fn resolve_type_name_with_control(
443 &self,
444 name: &str,
445 control: &uqa_core::memory::ProductionControl<'_>,
446 ) -> Result<Option<uqa_core::memory::Produced<ColumnType>>, SQLError> {
447 self.routine_overload_context()
448 .resolve_type_name_with_control(name, control)
449 }
450
451 fn resolve_collation_name(&self, name: &str) -> Result<Option<u32>, SQLError> {
452 uqa_execution::catalog::projection::resolve_expression_collation_oid(
453 &self.catalog_execution(),
454 name,
455 )
456 .map(Some)
457 }
458
459 fn resolve_collation_name_with_control(
460 &self,
461 name: &str,
462 control: &uqa_core::memory::ProductionControl<'_>,
463 ) -> Result<Option<u32>, SQLError> {
464 uqa_execution::catalog::projection::resolve_expression_collation_oid_with_control(
465 &self.catalog_execution(),
466 name,
467 control,
468 )
469 .map(Some)
470 }
471
472 fn enum_labels(&self) -> Option<&dyn uqa_sql::expr::enums::EnumLabelCatalog> {
473 Some(self)
474 }
475
476 fn catalog_input_functions(&self) -> Option<&dyn uqa_sql::expr::CatalogInputFunctions> {
477 Some(self)
478 }
479
480 fn composite_types(&self) -> Option<&dyn uqa_sql::expr::composites::CompositeTypeCatalog> {
481 Some(self)
482 }
483
484 fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError> {
485 uqa_execution::catalog::security::type_inquiry::require_type_usage(
486 &self.catalog_execution(),
487 ty,
488 )
489 }
490
491 fn resolve_function_type_with_control(
492 &self,
493 name: &str,
494 binding: Option<&FunctionBinding>,
495 argument_names: &[Option<String>],
496 argument_types: &[Option<ColumnType>],
497 explicit_variadic: bool,
498 control: &uqa_core::memory::ProductionControl<'_>,
499 ) -> Result<Option<uqa_core::memory::Produced<ColumnType>>, SQLError> {
500 self.routine_overload_context()
501 .resolve_function_type_with_control(
502 name,
503 binding,
504 argument_names,
505 argument_types,
506 explicit_variadic,
507 control,
508 )
509 }
510
511 fn resolve_function_overload_with_control(
512 &self,
513 name: &str,
514 binding: Option<&FunctionBinding>,
515 argument_names: &[Option<String>],
516 argument_types: &[Option<ColumnType>],
517 explicit_variadic: bool,
518 control: &uqa_core::memory::ProductionControl<'_>,
519 ) -> Result<Option<uqa_core::memory::Produced<ResolvedFunctionOverload>>, SQLError> {
520 self.routine_overload_context()
521 .resolve_function_overload_with_control(
522 name,
523 binding,
524 argument_names,
525 argument_types,
526 explicit_variadic,
527 control,
528 )
529 }
530
531 fn resolve_function_overload_with_builtins_and_control(
532 &self,
533 name: &str,
534 binding: Option<&FunctionBinding>,
535 argument_names: &[Option<String>],
536 argument_types: &[Option<ColumnType>],
537 explicit_variadic: bool,
538 builtins: &[BuiltinFunctionOverload],
539 control: &uqa_core::memory::ProductionControl<'_>,
540 ) -> Result<Option<uqa_core::memory::Produced<ResolvedFunctionOverload>>, SQLError> {
541 self.routine_overload_context()
542 .resolve_function_overload_with_builtins_and_control(
543 name,
544 binding,
545 argument_names,
546 argument_types,
547 explicit_variadic,
548 builtins,
549 control,
550 )
551 }
552
553 fn resolve_function_type(
554 &self,
555 name: &str,
556 binding: Option<&FunctionBinding>,
557 argument_names: &[Option<String>],
558 argument_types: &[Option<ColumnType>],
559 explicit_variadic: bool,
560 ) -> Result<Option<ColumnType>, SQLError> {
561 self.routine_overload_context().resolve_function_type(
562 name,
563 binding,
564 argument_names,
565 argument_types,
566 explicit_variadic,
567 )
568 }
569
570 fn resolve_function_overload(
571 &self,
572 name: &str,
573 binding: Option<&FunctionBinding>,
574 argument_names: &[Option<String>],
575 argument_types: &[Option<ColumnType>],
576 explicit_variadic: bool,
577 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
578 self.routine_overload_context().resolve_function_overload(
579 name,
580 binding,
581 argument_names,
582 argument_types,
583 explicit_variadic,
584 )
585 }
586
587 fn is_scalar_function_binding(&self, binding: &FunctionBinding) -> Result<bool, SQLError> {
588 self.routine_overload_context()
589 .is_scalar_function_binding(binding)
590 }
591
592 fn is_scalar_function_binding_with_control(
593 &self,
594 binding: &FunctionBinding,
595 control: &uqa_core::memory::ProductionControl<'_>,
596 ) -> Result<bool, SQLError> {
597 self.routine_overload_context()
598 .is_scalar_function_binding_with_control(binding, control)
599 }
600
601 fn resolve_function_overload_with_builtins(
602 &self,
603 name: &str,
604 binding: Option<&FunctionBinding>,
605 argument_names: &[Option<String>],
606 argument_types: &[Option<ColumnType>],
607 explicit_variadic: bool,
608 builtins: &[BuiltinFunctionOverload],
609 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
610 self.routine_overload_context()
611 .resolve_function_overload_with_builtins(
612 name,
613 binding,
614 argument_names,
615 argument_types,
616 explicit_variadic,
617 builtins,
618 )
619 }
620}
621
622impl uqa_sql::expr::CatalogInputFunctions for Engine {
623 fn read_unknown_input_with_control(
624 &self,
625 text: &str,
626 target: &ColumnType,
627 control: &uqa_core::memory::ProductionControl<'_>,
628 ) -> Result<uqa_core::memory::Produced<uqa_core::Value>, SQLError> {
629 uqa_sql::expr::read_catalog_input_with_control(text, target, self, control)
630 }
631
632 fn read_unknown_input(
633 &self,
634 text: &str,
635 target: &ColumnType,
636 ) -> Result<uqa_core::Value, SQLError> {
637 uqa_sql::expr::read_catalog_input(text, target, self)
638 }
639}
640
641impl Engine {
642 fn routine_overload_context(&self) -> RoutineOverloadContext<'_> {
643 RoutineOverloadContext { catalog: self }
644 }
645 pub(crate) fn resolve_static_sql_function(
646 &self,
647 name: &str,
648 binding: Option<&FunctionBinding>,
649 argument_names: &[Option<String>],
650 argument_types: &[Option<ColumnType>],
651 explicit_variadic: bool,
652 ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
653 self.routine_overload_context().resolve_static_sql_function(
654 name,
655 binding,
656 argument_names,
657 argument_types,
658 explicit_variadic,
659 )
660 }
661
662 pub(crate) fn resolve_static_sql_function_match(
663 &self,
664 name: &str,
665 binding: Option<&FunctionBinding>,
666 argument_names: &[Option<String>],
667 argument_types: &[Option<ColumnType>],
668 explicit_variadic: bool,
669 ) -> Result<Option<StaticFunctionMatch>, SQLError> {
670 self.routine_overload_context()
671 .resolve_static_sql_function_match(
672 name,
673 binding,
674 argument_names,
675 argument_types,
676 explicit_variadic,
677 )
678 }
679
680 pub(crate) fn resolve_table_function_overload_with_builtins(
681 &self,
682 name: &str,
683 binding: Option<&FunctionBinding>,
684 argument_names: &[Option<String>],
685 argument_types: &[Option<ColumnType>],
686 explicit_variadic: bool,
687 builtins: &[BuiltinFunctionOverload],
688 ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
689 self.routine_overload_context()
690 .resolve_table_function_overload_with_builtins(
691 name,
692 binding,
693 argument_names,
694 argument_types,
695 explicit_variadic,
696 builtins,
697 )
698 }
699}