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 has_registered_aggregate_function(&self, name: &str) -> bool {
104        Engine::has_registered_aggregate_function(self, name)
105    }
106
107    fn lookup_visible_sql_functions(
108        &self,
109        name: &str,
110    ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
111        Engine::lookup_visible_sql_functions(self, name)
112    }
113
114    fn lookup_visible_sql_functions_for_analysis(
115        &self,
116        name: &str,
117    ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError> {
118        Engine::lookup_visible_sql_functions_for_analysis(self, name)
119    }
120
121    fn resolve_static_sql_function(
122        &self,
123        name: &str,
124        binding: Option<&FunctionBinding>,
125        argument_names: &[Option<String>],
126        argument_types: &[Option<ColumnType>],
127        explicit_variadic: bool,
128    ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
129        Engine::resolve_static_sql_function(
130            self,
131            name,
132            binding,
133            argument_names,
134            argument_types,
135            explicit_variadic,
136        )
137    }
138
139    fn resolve_static_sql_function_match(
140        &self,
141        name: &str,
142        binding: Option<&FunctionBinding>,
143        argument_names: &[Option<String>],
144        argument_types: &[Option<ColumnType>],
145        explicit_variadic: bool,
146    ) -> Result<Option<StaticFunctionMatch>, SQLError> {
147        Engine::resolve_static_sql_function_match(
148            self,
149            name,
150            binding,
151            argument_names,
152            argument_types,
153            explicit_variadic,
154        )
155    }
156
157    fn resolve_table_function_overload_with_builtins(
158        &self,
159        name: &str,
160        binding: Option<&FunctionBinding>,
161        argument_names: &[Option<String>],
162        argument_types: &[Option<ColumnType>],
163        explicit_variadic: bool,
164        builtins: &[BuiltinFunctionOverload],
165    ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
166        Engine::resolve_table_function_overload_with_builtins(
167            self,
168            name,
169            binding,
170            argument_names,
171            argument_types,
172            explicit_variadic,
173            builtins,
174        )
175    }
176}
177
178impl FunctionTypeResolver for Engine {
179    fn format_type_name(&self, ty: &ColumnType) -> Result<String, SQLError> {
180        self.routine_overload_context().format_type_name(ty)
181    }
182
183    fn has_untyped_function(&self, name: &str) -> bool {
184        self.routine_overload_context().has_untyped_function(name)
185    }
186
187    fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, SQLError> {
188        self.routine_overload_context().resolve_type_name(name)
189    }
190
191    fn resolve_collation_name(&self, name: &str) -> Result<Option<u32>, SQLError> {
192        uqa_execution::catalog::projection::resolve_expression_collation_oid(
193            &self.catalog_execution(),
194            name,
195        )
196        .map(Some)
197    }
198
199    fn enum_labels(&self) -> Option<&dyn uqa_sql::expr::enums::EnumLabelCatalog> {
200        Some(self)
201    }
202
203    fn catalog_input_functions(&self) -> Option<&dyn uqa_sql::expr::CatalogInputFunctions> {
204        Some(self)
205    }
206
207    fn composite_types(&self) -> Option<&dyn uqa_sql::expr::composites::CompositeTypeCatalog> {
208        Some(self)
209    }
210
211    fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError> {
212        uqa_execution::catalog::security::type_inquiry::require_type_usage(
213            &self.catalog_execution(),
214            ty,
215        )
216    }
217
218    fn resolve_function_type(
219        &self,
220        name: &str,
221        binding: Option<&FunctionBinding>,
222        argument_names: &[Option<String>],
223        argument_types: &[Option<ColumnType>],
224        explicit_variadic: bool,
225    ) -> Result<Option<ColumnType>, SQLError> {
226        self.routine_overload_context().resolve_function_type(
227            name,
228            binding,
229            argument_names,
230            argument_types,
231            explicit_variadic,
232        )
233    }
234
235    fn resolve_function_overload(
236        &self,
237        name: &str,
238        binding: Option<&FunctionBinding>,
239        argument_names: &[Option<String>],
240        argument_types: &[Option<ColumnType>],
241        explicit_variadic: bool,
242    ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
243        self.routine_overload_context().resolve_function_overload(
244            name,
245            binding,
246            argument_names,
247            argument_types,
248            explicit_variadic,
249        )
250    }
251
252    fn is_scalar_function_binding(&self, binding: &FunctionBinding) -> Result<bool, SQLError> {
253        self.routine_overload_context()
254            .is_scalar_function_binding(binding)
255    }
256
257    fn resolve_function_overload_with_builtins(
258        &self,
259        name: &str,
260        binding: Option<&FunctionBinding>,
261        argument_names: &[Option<String>],
262        argument_types: &[Option<ColumnType>],
263        explicit_variadic: bool,
264        builtins: &[BuiltinFunctionOverload],
265    ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
266        self.routine_overload_context()
267            .resolve_function_overload_with_builtins(
268                name,
269                binding,
270                argument_names,
271                argument_types,
272                explicit_variadic,
273                builtins,
274            )
275    }
276}
277
278impl uqa_sql::expr::CatalogInputFunctions for Engine {
279    fn read_unknown_input(
280        &self,
281        text: &str,
282        target: &ColumnType,
283    ) -> Result<uqa_core::Value, SQLError> {
284        uqa_sql::expr::read_catalog_input(text, target, self)
285    }
286}
287
288impl Engine {
289    fn routine_overload_context(&self) -> RoutineOverloadContext<'_> {
290        RoutineOverloadContext { catalog: self }
291    }
292    pub(crate) fn resolve_static_sql_function(
293        &self,
294        name: &str,
295        binding: Option<&FunctionBinding>,
296        argument_names: &[Option<String>],
297        argument_types: &[Option<ColumnType>],
298        explicit_variadic: bool,
299    ) -> Result<Option<Arc<SQLUserFunction>>, SQLError> {
300        self.routine_overload_context().resolve_static_sql_function(
301            name,
302            binding,
303            argument_names,
304            argument_types,
305            explicit_variadic,
306        )
307    }
308
309    pub(crate) fn resolve_static_sql_function_match(
310        &self,
311        name: &str,
312        binding: Option<&FunctionBinding>,
313        argument_names: &[Option<String>],
314        argument_types: &[Option<ColumnType>],
315        explicit_variadic: bool,
316    ) -> Result<Option<StaticFunctionMatch>, SQLError> {
317        self.routine_overload_context()
318            .resolve_static_sql_function_match(
319                name,
320                binding,
321                argument_names,
322                argument_types,
323                explicit_variadic,
324            )
325    }
326
327    pub(crate) fn resolve_table_function_overload_with_builtins(
328        &self,
329        name: &str,
330        binding: Option<&FunctionBinding>,
331        argument_names: &[Option<String>],
332        argument_types: &[Option<ColumnType>],
333        explicit_variadic: bool,
334        builtins: &[BuiltinFunctionOverload],
335    ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
336        self.routine_overload_context()
337            .resolve_table_function_overload_with_builtins(
338                name,
339                binding,
340                argument_names,
341                argument_types,
342                explicit_variadic,
343                builtins,
344            )
345    }
346}