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