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