Skip to main content

uqa_execution/query/
binding.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Adapt active engine statement inputs to SQL-owned static binding.
8
9use 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
157/// Record each call's input collation in a stored query whose routines are bound.
158pub 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}