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 bind_expression_plan_routines_for_storage<S: Clone>(
158 engine: &dyn RoutineResolution,
159 plan: &mut ExpressionPlan,
160 params: &[SQLParam],
161 ctes: &CteScope<S>,
162 schema: &RowSchema,
163) -> Result<Option<ColumnType>, SQLError> {
164 uqa_sql::binding::bind_expression_plan_routines_for_storage(
165 engine,
166 plan,
167 params,
168 &binding_context(ctes)?,
169 schema,
170 )
171}
172
173pub fn bind_query_plan_schema<S: Clone>(
174 routines: &dyn RoutineResolution,
175 plan: &QueryPlan,
176 params: &[SQLParam],
177 ctes: &CteScope<S>,
178 outer: Option<&RowSchema>,
179) -> Result<RowSchema, SQLError> {
180 uqa_sql::binding::bind_query_plan_schema(routines, plan, params, &binding_context(ctes)?, outer)
181}
182
183pub fn bind_expression_plan_type<S: Clone>(
184 routines: &dyn RoutineResolution,
185 plan: &ExpressionPlan,
186 params: &[SQLParam],
187 ctes: &CteScope<S>,
188) -> Result<Option<ColumnType>, SQLError> {
189 uqa_sql::binding::bind_expression_plan_type(routines, plan, params, &binding_context(ctes)?)
190}
191
192pub fn analyze_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::analyze_expression_plan_type(routines, plan, params, &binding_context(ctes)?)
199}
200
201pub fn analyze_query_plan_schema<S: Clone>(
202 routines: &dyn RoutineResolution,
203 plan: &QueryPlan,
204 params: &[SQLParam],
205 ctes: &CteScope<S>,
206 outer: Option<&RowSchema>,
207) -> Result<RowSchema, SQLError> {
208 uqa_sql::binding::analyze_query_plan_schema(
209 routines,
210 plan,
211 params,
212 &binding_context(ctes)?,
213 outer,
214 )
215}
216
217pub fn values_types_in_scope<S: Clone>(
218 routines: &dyn RoutineResolution,
219 rows: &[Vec<ScalarExpr>],
220 subqueries: &[QueryPlan],
221 schema: Option<&RowSchema>,
222 params: &[SQLParam],
223 ctes: &CteScope<S>,
224) -> Result<Vec<Option<ColumnType>>, SQLError> {
225 values_schema_in_scope(routines, rows, subqueries, schema, params, ctes)
226 .map(|schema| schema.column_types().to_vec())
227}
228
229pub fn values_schema_in_scope<S: Clone>(
230 routines: &dyn RoutineResolution,
231 rows: &[Vec<ScalarExpr>],
232 subqueries: &[QueryPlan],
233 schema: Option<&RowSchema>,
234 params: &[SQLParam],
235 ctes: &CteScope<S>,
236) -> Result<RowSchema, SQLError> {
237 uqa_sql::binding::values_schema_in_scope(
238 routines,
239 rows,
240 subqueries,
241 schema,
242 params,
243 &binding_context(ctes)?,
244 )
245}
246
247pub fn bind_source_plan_schema<S: Clone>(
248 routines: &dyn RoutineResolution,
249 source: &SourcePlan,
250 params: &[SQLParam],
251 ctes: &CteScope<S>,
252 outer: Option<&RowSchema>,
253) -> Result<RowSchema, SQLError> {
254 uqa_sql::binding::bind_source_plan_schema(
255 routines,
256 source,
257 params,
258 &binding_context(ctes)?,
259 outer,
260 )
261}
262
263pub fn analyze_source_plan_schema<S: Clone>(
264 routines: &dyn RoutineResolution,
265 source: &SourcePlan,
266 params: &[SQLParam],
267 ctes: &CteScope<S>,
268 outer: Option<&RowSchema>,
269) -> Result<RowSchema, SQLError> {
270 uqa_sql::binding::analyze_source_plan_schema(
271 routines,
272 source,
273 params,
274 &binding_context(ctes)?,
275 outer,
276 )
277}
278
279pub fn bind_source_plan_schema_for_execution<S: Clone>(
280 routines: &dyn RoutineResolution,
281 source: &mut SourcePlan,
282 params: &[SQLParam],
283 ctes: &CteScope<S>,
284 outer: Option<&RowSchema>,
285) -> Result<RowSchema, SQLError> {
286 uqa_sql::binding::bind_source_plan_schema_for_execution(
287 routines,
288 source,
289 params,
290 &binding_context(ctes)?,
291 outer,
292 )
293}
294
295pub use uqa_sql::binding::{
296 extend_cte_generated_schema, overlay_outer_schema, with_query_table_pseudo_columns,
297};
298
299impl<S: Clone> uqa_sql::semantics::returning::ReturningScope for CteScope<S> {
300 fn binding_snapshot(&self) -> Result<uqa_sql::binding::snapshot::BindingSnapshot, SQLError> {
301 binding_context(self).map(uqa_sql::binding::snapshot::BindingSnapshot::from)
302 }
303}
304
305pub fn analyze_command_parameters<S: Clone>(
306 routines: &dyn RoutineResolution,
307 command: &CommandPlan,
308 params: &[SQLParam],
309 ctes: &CteScope<S>,
310) -> Result<(), SQLError> {
311 uqa_sql::binding::statements::analyze_command_parameters(routines, command, params, ctes)
312}
313
314impl<S: Clone> uqa_sql::binding::statements::StatementBindingScope for CteScope<S> {
315 fn binding_context(&self) -> Result<uqa_sql::binding::BindingContext<'_>, SQLError> {
316 binding_context(self)
317 }
318}