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