Skip to main content

uqa_sql/binding/
scoped_types.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Catalog-backed function and scalar-subquery typing within an owned analysis scope.
8
9use super::snapshot::BindingSnapshot;
10use crate::{
11    ast::FunctionBinding, routines::RoutineResolution, BuiltinFunctionOverload, ColumnType,
12    FunctionTypeResolver, ResolvedFunctionOverload, SQLError, SQLParam,
13};
14
15mod scope;
16pub use scope::BindingTypeScope;
17
18pub struct BindingTypeResolver<'a, Scope = BindingSnapshot> {
19    pub routines: &'a dyn RoutineResolution,
20    pub scope: &'a Scope,
21}
22
23impl<Scope: BindingTypeScope> FunctionTypeResolver for BindingTypeResolver<'_, Scope> {
24    fn resolve_collation_name_with_control(
25        &self,
26        name: &str,
27        control: &uqa_core::memory::ProductionControl<'_>,
28    ) -> Result<Option<u32>, SQLError> {
29        self.routines
30            .resolve_collation_name_with_control(name, control)
31    }
32
33    fn is_scalar_function_binding_with_control(
34        &self,
35        binding: &crate::ast::FunctionBinding,
36        control: &uqa_core::memory::ProductionControl<'_>,
37    ) -> Result<bool, SQLError> {
38        self.routines
39            .is_scalar_function_binding_with_control(binding, control)
40    }
41
42    fn format_type_name_with_control(
43        &self,
44        ty: &crate::ColumnType,
45        control: &uqa_core::memory::ProductionControl<'_>,
46    ) -> Result<uqa_core::memory::Produced<String>, SQLError> {
47        self.routines.format_type_name_with_control(ty, control)
48    }
49
50    fn resolve_type_name_with_control(
51        &self,
52        name: &str,
53        control: &uqa_core::memory::ProductionControl<'_>,
54    ) -> Result<Option<uqa_core::memory::Produced<crate::ColumnType>>, SQLError> {
55        self.routines.resolve_type_name_with_control(name, control)
56    }
57
58    fn resolve_function_type_with_control(
59        &self,
60        name: &str,
61        binding: Option<&crate::ast::FunctionBinding>,
62        argument_names: &[Option<String>],
63        argument_types: &[Option<crate::ColumnType>],
64        explicit_variadic: bool,
65        control: &uqa_core::memory::ProductionControl<'_>,
66    ) -> Result<Option<uqa_core::memory::Produced<crate::ColumnType>>, SQLError> {
67        self.routines.resolve_function_type_with_control(
68            name,
69            binding,
70            argument_names,
71            argument_types,
72            explicit_variadic,
73            control,
74        )
75    }
76
77    fn resolve_function_overload_with_control(
78        &self,
79        name: &str,
80        binding: Option<&crate::ast::FunctionBinding>,
81        argument_names: &[Option<String>],
82        argument_types: &[Option<crate::ColumnType>],
83        explicit_variadic: bool,
84        control: &uqa_core::memory::ProductionControl<'_>,
85    ) -> Result<Option<uqa_core::memory::Produced<ResolvedFunctionOverload>>, SQLError> {
86        self.routines.resolve_function_overload_with_control(
87            name,
88            binding,
89            argument_names,
90            argument_types,
91            explicit_variadic,
92            control,
93        )
94    }
95
96    fn resolve_function_overload_with_builtins_and_control(
97        &self,
98        name: &str,
99        binding: Option<&crate::ast::FunctionBinding>,
100        argument_names: &[Option<String>],
101        argument_types: &[Option<crate::ColumnType>],
102        explicit_variadic: bool,
103        builtins: &[crate::BuiltinFunctionOverload],
104        control: &uqa_core::memory::ProductionControl<'_>,
105    ) -> Result<Option<uqa_core::memory::Produced<ResolvedFunctionOverload>>, SQLError> {
106        self.routines
107            .resolve_function_overload_with_builtins_and_control(
108                name,
109                binding,
110                argument_names,
111                argument_types,
112                explicit_variadic,
113                builtins,
114                control,
115            )
116    }
117
118    fn format_type_name(&self, ty: &ColumnType) -> Result<String, SQLError> {
119        self.routines.format_type_name(ty)
120    }
121
122    fn has_untyped_function(&self, name: &str) -> bool {
123        self.routines.has_untyped_function(name)
124    }
125
126    fn has_untyped_function_with_control(
127        &self,
128        name: &str,
129        control: &uqa_core::memory::ProductionControl<'_>,
130    ) -> Result<bool, SQLError> {
131        self.routines
132            .has_untyped_function_with_control(name, control)
133    }
134
135    fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, SQLError> {
136        self.routines.resolve_type_name(name)
137    }
138
139    fn resolve_collation_name(&self, name: &str) -> Result<Option<u32>, SQLError> {
140        self.routines.resolve_collation_name(name)
141    }
142
143    fn enum_labels(&self) -> Option<&dyn crate::expr::enums::EnumLabelCatalog> {
144        self.routines.enum_labels()
145    }
146
147    fn composite_types(&self) -> Option<&dyn crate::expr::composites::CompositeTypeCatalog> {
148        self.routines.composite_types()
149    }
150
151    fn resolve_function_type(
152        &self,
153        name: &str,
154        binding: Option<&FunctionBinding>,
155        argument_names: &[Option<String>],
156        argument_types: &[Option<ColumnType>],
157        explicit_variadic: bool,
158    ) -> Result<Option<ColumnType>, SQLError> {
159        self.routines.resolve_function_type(
160            name,
161            binding,
162            argument_names,
163            argument_types,
164            explicit_variadic,
165        )
166    }
167
168    fn resolve_function_overload(
169        &self,
170        name: &str,
171        binding: Option<&FunctionBinding>,
172        argument_names: &[Option<String>],
173        argument_types: &[Option<ColumnType>],
174        explicit_variadic: bool,
175    ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
176        self.routines.resolve_function_overload(
177            name,
178            binding,
179            argument_names,
180            argument_types,
181            explicit_variadic,
182        )
183    }
184
185    fn is_scalar_function_binding(&self, binding: &FunctionBinding) -> Result<bool, SQLError> {
186        self.routines.is_scalar_function_binding(binding)
187    }
188
189    fn resolve_function_overload_with_builtins(
190        &self,
191        name: &str,
192        binding: Option<&FunctionBinding>,
193        argument_names: &[Option<String>],
194        argument_types: &[Option<ColumnType>],
195        explicit_variadic: bool,
196        builtins: &[BuiltinFunctionOverload],
197    ) -> Result<Option<ResolvedFunctionOverload>, SQLError> {
198        self.routines.resolve_function_overload_with_builtins(
199            name,
200            binding,
201            argument_names,
202            argument_types,
203            explicit_variadic,
204            builtins,
205        )
206    }
207
208    fn resolve_scalar_subquery_type(
209        &self,
210        subquery: crate::SubqueryId,
211        outer_schema: &crate::RowSchema,
212        params: &[SQLParam],
213    ) -> Result<Option<ColumnType>, SQLError> {
214        let control = uqa_core::memory::ProductionControl::uncontrolled();
215        Ok(self
216            .resolve_scalar_subquery_type_with_control(subquery, outer_schema, params, &control)?
217            .map(|ty| {
218                ty.into_uncontrolled()
219                    .unwrap_or_else(|_| panic!("ordinary scoped type"))
220            }))
221    }
222
223    fn resolve_scalar_subquery_type_with_control(
224        &self,
225        subquery: crate::SubqueryId,
226        outer_schema: &crate::RowSchema,
227        params: &[SQLParam],
228        control: &uqa_core::memory::ProductionControl<'_>,
229    ) -> Result<Option<uqa_core::memory::Produced<ColumnType>>, SQLError> {
230        control.check()?;
231        let plan = self
232            .scope
233            .scalar_subqueries()
234            .get(subquery)
235            .ok_or_else(|| {
236                SQLError::Internal(format!(
237                    "physical scalar subquery slot {subquery} is out of bounds"
238                ))
239            })?;
240        let output = crate::binding::bind_query_plan_schema_with_control(
241            self.routines,
242            plan,
243            params,
244            self.scope.type_context(control)?,
245            Some(outer_schema),
246            control,
247        )?;
248        output
249            .column_type(0)
250            .map(|ty| ty.clone_with_control(control).map_err(Into::into))
251            .transpose()
252    }
253}