Skip to main content

uqa_engine/capabilities/
routine_resolution.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind SQL routine overload resolution to shared catalog allocations and session metadata.
8
9use 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}