1use super::CteScope;
10use crate::{RowSchema, ScalarExpr};
11use uqa_sql::plan::{
12 CommandPlan, ExpressionPlan, ProjectionPlan, QueryBlockPlan, QueryPlan, SourcePlan, UnifiedPlan,
13};
14use uqa_sql::routines::RoutineResolution;
15use uqa_sql::{ColumnType, SQLError, SQLParam};
16mod context;
17pub use context::binding_context;
18mod subqueries;
19pub use subqueries::resolve_scalar_subquery_type;
20
21pub fn analyze_prepared_command_schema<S: Clone>(
22 routines: &dyn RoutineResolution,
23 command: &CommandPlan,
24 params: &[SQLParam],
25 ctes: &CteScope<S>,
26) -> Result<Option<RowSchema>, SQLError> {
27 uqa_sql::binding::analyze_prepared_command_schema(
28 routines,
29 command,
30 params,
31 &binding_context(ctes)?,
32 )
33}
34
35pub fn analyze_recursive_control_step<S: Clone>(
36 routines: &dyn RoutineResolution,
37 cte: &uqa_sql::plan::CtePlan,
38 step: &QueryPlan,
39 base_schema: RowSchema,
40 params: &[SQLParam],
41 ctes: &CteScope<S>,
42) -> Result<(), SQLError> {
43 uqa_sql::binding::analyze_recursive_control_step(
44 routines,
45 cte,
46 step,
47 base_schema,
48 params,
49 &binding_context(ctes)?,
50 )
51}
52
53pub fn infer_prepared_parameter_types<S: Clone>(
54 routines: &dyn RoutineResolution,
55 plan: &UnifiedPlan,
56 declared: &[Option<ColumnType>],
57 ctes: &CteScope<S>,
58) -> Result<Vec<Option<ColumnType>>, SQLError> {
59 uqa_sql::binding::infer_prepared_parameter_types(
60 routines,
61 plan,
62 declared,
63 &binding_context(ctes)?,
64 )
65}
66
67pub fn bind_projection_output_schema<S: Clone>(
68 routines: &dyn RoutineResolution,
69 projections: &[ProjectionPlan],
70 expression_schema: &RowSchema,
71 star_schema: &RowSchema,
72 subqueries: &[QueryPlan],
73 params: &[SQLParam],
74 ctes: &CteScope<S>,
75) -> Result<RowSchema, SQLError> {
76 uqa_sql::binding::bind_projection_output_schema(
77 routines,
78 projections,
79 expression_schema,
80 star_schema,
81 subqueries,
82 params,
83 &binding_context(ctes)?,
84 )
85}
86
87pub fn analyze_projection_output_schema<S: Clone>(
88 routines: &dyn RoutineResolution,
89 projections: &[ProjectionPlan],
90 expression_schema: &RowSchema,
91 star_schema: &RowSchema,
92 subqueries: &[QueryPlan],
93 params: &[SQLParam],
94 ctes: &CteScope<S>,
95) -> Result<RowSchema, SQLError> {
96 uqa_sql::binding::analyze_projection_output_schema(
97 routines,
98 projections,
99 expression_schema,
100 star_schema,
101 subqueries,
102 params,
103 &binding_context(ctes)?,
104 )
105}
106
107pub fn validate_query_block_expression_types<S: Clone>(
108 routines: &dyn RoutineResolution,
109 statement: &QueryBlockPlan,
110 schema: &RowSchema,
111 params: &[SQLParam],
112 ctes: &CteScope<S>,
113) -> Result<(), SQLError> {
114 uqa_sql::binding::validate_query_block_expression_types(
115 routines,
116 statement,
117 schema,
118 params,
119 &binding_context(ctes)?,
120 )
121}
122
123pub fn validate_query_block_references<S: Clone>(
124 routines: &dyn RoutineResolution,
125 statement: &QueryBlockPlan,
126 schema: &RowSchema,
127 params: &[SQLParam],
128 ctes: &CteScope<S>,
129 outer: Option<&RowSchema>,
130) -> Result<(), SQLError> {
131 uqa_sql::binding::validate_query_block_references(
132 routines,
133 statement,
134 schema,
135 params,
136 &binding_context(ctes)?,
137 outer,
138 )
139}
140
141pub fn bind_query_plan_routines_for_storage<S: Clone>(
142 engine: &dyn RoutineResolution,
143 plan: &mut QueryPlan,
144 params: &[SQLParam],
145 ctes: &CteScope<S>,
146 outer: Option<&RowSchema>,
147) -> Result<RowSchema, SQLError> {
148 uqa_sql::binding::bind_query_plan_routines_for_storage(
149 engine,
150 plan,
151 params,
152 &binding_context(ctes)?,
153 outer,
154 )
155}
156
157pub fn assign_query_plan_input_collations<S: Clone>(
159 engine: &dyn RoutineResolution,
160 plan: &mut QueryPlan,
161 ctes: &CteScope<S>,
162) -> Result<(), SQLError> {
163 uqa_sql::binding::assign_stored_query_input_collations(engine, plan, &binding_context(ctes)?)
164}
165
166pub fn bind_expression_plan_routines_for_storage<S: Clone>(
167 engine: &dyn RoutineResolution,
168 plan: &mut ExpressionPlan,
169 params: &[SQLParam],
170 ctes: &CteScope<S>,
171 schema: &RowSchema,
172) -> Result<Option<ColumnType>, SQLError> {
173 uqa_sql::binding::bind_expression_plan_routines_for_storage(
174 engine,
175 plan,
176 params,
177 &binding_context(ctes)?,
178 schema,
179 )
180}
181
182pub fn bind_query_plan_schema<S: Clone>(
183 routines: &dyn RoutineResolution,
184 plan: &QueryPlan,
185 params: &[SQLParam],
186 ctes: &CteScope<S>,
187 outer: Option<&RowSchema>,
188) -> Result<RowSchema, SQLError> {
189 uqa_sql::binding::bind_query_plan_schema(routines, plan, params, &binding_context(ctes)?, outer)
190}
191
192pub fn bind_expression_plan_type<S: Clone>(
193 routines: &dyn RoutineResolution,
194 plan: &ExpressionPlan,
195 params: &[SQLParam],
196 ctes: &CteScope<S>,
197) -> Result<Option<ColumnType>, SQLError> {
198 uqa_sql::binding::bind_expression_plan_type(routines, plan, params, &binding_context(ctes)?)
199}
200
201pub fn analyze_expression_plan_type<S: Clone>(
202 routines: &dyn RoutineResolution,
203 plan: &ExpressionPlan,
204 params: &[SQLParam],
205 ctes: &CteScope<S>,
206) -> Result<Option<ColumnType>, SQLError> {
207 uqa_sql::binding::analyze_expression_plan_type(routines, plan, params, &binding_context(ctes)?)
208}
209
210pub fn analyze_query_plan_schema<S: Clone>(
211 routines: &dyn RoutineResolution,
212 plan: &QueryPlan,
213 params: &[SQLParam],
214 ctes: &CteScope<S>,
215 outer: Option<&RowSchema>,
216) -> Result<RowSchema, SQLError> {
217 uqa_sql::binding::analyze_query_plan_schema(
218 routines,
219 plan,
220 params,
221 &binding_context(ctes)?,
222 outer,
223 )
224}
225
226pub fn values_types_in_scope<S: Clone>(
227 routines: &dyn RoutineResolution,
228 rows: &[Vec<ScalarExpr>],
229 subqueries: &[QueryPlan],
230 schema: Option<&RowSchema>,
231 params: &[SQLParam],
232 ctes: &CteScope<S>,
233) -> Result<Vec<Option<ColumnType>>, SQLError> {
234 values_schema_in_scope(routines, rows, subqueries, schema, params, ctes)
235 .map(|schema| schema.column_types().to_vec())
236}
237
238pub fn values_schema_in_scope<S: Clone>(
239 routines: &dyn RoutineResolution,
240 rows: &[Vec<ScalarExpr>],
241 subqueries: &[QueryPlan],
242 schema: Option<&RowSchema>,
243 params: &[SQLParam],
244 ctes: &CteScope<S>,
245) -> Result<RowSchema, SQLError> {
246 uqa_sql::binding::values_schema_in_scope(
247 routines,
248 rows,
249 subqueries,
250 schema,
251 params,
252 &binding_context(ctes)?,
253 )
254}
255
256pub fn bind_source_plan_schema<S: Clone>(
257 routines: &dyn RoutineResolution,
258 source: &SourcePlan,
259 params: &[SQLParam],
260 ctes: &CteScope<S>,
261 outer: Option<&RowSchema>,
262) -> Result<RowSchema, SQLError> {
263 uqa_sql::binding::bind_source_plan_schema(
264 routines,
265 source,
266 params,
267 &binding_context(ctes)?,
268 outer,
269 )
270}
271
272pub fn analyze_source_plan_schema<S: Clone>(
273 routines: &dyn RoutineResolution,
274 source: &SourcePlan,
275 params: &[SQLParam],
276 ctes: &CteScope<S>,
277 outer: Option<&RowSchema>,
278) -> Result<RowSchema, SQLError> {
279 uqa_sql::binding::analyze_source_plan_schema(
280 routines,
281 source,
282 params,
283 &binding_context(ctes)?,
284 outer,
285 )
286}
287
288pub fn bind_source_plan_schema_for_execution<S: Clone>(
289 routines: &dyn RoutineResolution,
290 source: &mut SourcePlan,
291 params: &[SQLParam],
292 ctes: &CteScope<S>,
293 outer: Option<&RowSchema>,
294) -> Result<RowSchema, SQLError> {
295 uqa_sql::binding::bind_source_plan_schema_for_execution(
296 routines,
297 source,
298 params,
299 &binding_context(ctes)?,
300 outer,
301 )
302}
303
304pub fn bind_query_block_for_execution<'a, S: Clone>(
305 routines: &dyn RoutineResolution,
306 block: &'a QueryBlockPlan,
307 params: &[SQLParam],
308 ctes: &CteScope<S>,
309 outer: Option<&RowSchema>,
310 defer_distinct_limit: bool,
311) -> Result<(std::borrow::Cow<'a, QueryBlockPlan>, RowSchema), SQLError> {
312 uqa_sql::binding::bind_query_block_for_execution(
313 routines,
314 block,
315 params,
316 &binding_context(ctes)?,
317 outer,
318 defer_distinct_limit,
319 )
320}
321
322pub use uqa_sql::binding::{
323 extend_cte_generated_schema, overlay_outer_schema, with_query_table_pseudo_columns,
324};
325
326impl<S: Clone> uqa_sql::semantics::returning::ReturningScope for CteScope<S> {
327 fn binding_snapshot(&self) -> Result<uqa_sql::binding::snapshot::BindingSnapshot, SQLError> {
328 binding_context(self).map(uqa_sql::binding::snapshot::BindingSnapshot::from)
329 }
330}
331
332pub fn analyze_command_parameters<S: Clone>(
333 routines: &dyn RoutineResolution,
334 command: &CommandPlan,
335 params: &[SQLParam],
336 ctes: &CteScope<S>,
337) -> Result<(), SQLError> {
338 uqa_sql::binding::statements::analyze_command_parameters(routines, command, params, ctes)
339}
340
341impl<S: Clone> uqa_sql::binding::statements::StatementBindingScope for CteScope<S> {
342 fn binding_context(&self) -> Result<uqa_sql::binding::BindingContext<'_>, SQLError> {
343 binding_context(self)
344 }
345}