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