Skip to main content

uqa_planner/statement_planning/
rule_inputs.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Prune mutation inputs discarded by rewrite rules before constant evaluation.
8use crate::{CommandPlan, RelationalPlan, SourcePlan, UnifiedPlan};
9use std::collections::BTreeSet;
10use uqa_core::Value;
11use uqa_sql::plan::ScopedPlanVisitor;
12use uqa_sql::{
13    ast::RuleEvent,
14    semantics::{rules::RuleCatalog, view_rewrite::context::ViewRewriteContext},
15    SQLError, ScalarExpr,
16};
17mod owned;
18mod view_projection;
19pub use owned::{prune_captured_inputs_owned, prune_command_inputs_owned};
20
21pub fn rewrite_plan_owned(
22    context: &RuleInputPlanningContext<'_>,
23    plan: uqa_sql::plan::MutableExecutablePlan,
24    config: &crate::optimizer::OptimizerConfig<'_>,
25) -> Result<uqa_sql::plan::MutableExecutablePlan, SQLError> {
26    let plan = view_projection::rewrite_owned(context, plan, config)?;
27    let plan = prune_captured_inputs_owned(
28        context.volatility,
29        context.views.routines,
30        plan,
31        &config.production,
32    )?;
33    prune_command_inputs_owned(context, plan, &config.production)
34}
35
36pub trait RuleInputColumns {
37    fn source_column_names(
38        &self,
39        table: &str,
40        relations_bound: bool,
41    ) -> Result<Option<Vec<String>>, SQLError>;
42
43    fn source_column_names_with_control(
44        &self,
45        table: &str,
46        relations_bound: bool,
47        control: &uqa_core::memory::ProductionControl<'_>,
48    ) -> Result<Option<uqa_core::memory::Produced<Vec<String>>>, SQLError> {
49        control.check()?;
50        let Some(columns) = self.source_column_names(table, relations_bound)? else {
51            return Ok(None);
52        };
53        let mut output = uqa_core::memory::ProductionVec::new(*control);
54        for column in columns {
55            output.push_produced(control.copy_text(&column)?)?;
56        }
57        Ok(Some(output.finish()?))
58    }
59}
60pub struct RuleInputPlanningContext<'a> {
61    pub rules: &'a dyn RuleCatalog,
62    pub views: ViewRewriteContext<'a>,
63    pub columns: &'a dyn RuleInputColumns,
64    pub volatility: &'a dyn uqa_sql::semantics::volatility::VolatilityCatalog,
65}
66pub fn rewrite_plan(
67    context: &RuleInputPlanningContext<'_>,
68    plan: &mut UnifiedPlan,
69    config: &crate::optimizer::OptimizerConfig<'_>,
70) -> Result<(), SQLError> {
71    view_projection::rewrite(context, plan, config)?;
72    prune_captured_inputs(context.volatility, context.views.routines, plan)?;
73    plan.visit_scoped_mut(&mut Rules(context))
74}
75
76/// Internal producer slots have structural identities. Their unused projections can be removed before expression folding without changing the query's cardinality or visible namespace.
77fn prune_captured_inputs(
78    volatility: &dyn uqa_sql::semantics::volatility::VolatilityCatalog,
79    routines: &dyn uqa_sql::routines::RoutineResolution,
80    plan: &mut UnifiedPlan,
81) -> Result<(), SQLError> {
82    let mut required = std::collections::BTreeMap::<_, BTreeSet<usize>>::new();
83    plan.visit_scalar_expressions(&mut |expression| {
84        expression.visit(&mut |node| {
85            let column = match node {
86                ScalarExpr::InternalColumn(column) => Some(*column),
87                ScalarExpr::Func {
88                    binding: Some(binding),
89                    ..
90                } => uqa_sql::semantics::function_implicit_row_input(binding),
91                _ => None,
92            };
93            if let Some(column) = column {
94                required
95                    .entry(column.relation())
96                    .or_default()
97                    .insert(column.attribute());
98            }
99        });
100    });
101    plan.visit_scoped_mut(&mut CapturedInputs {
102        volatility,
103        routines,
104        required: &required,
105    })
106}
107
108struct Rules<'a, 'b>(&'a RuleInputPlanningContext<'b>);
109impl ScopedPlanVisitor for Rules<'_, '_> {
110    fn command(
111        &mut self,
112        command: &mut CommandPlan,
113        outer: &dyn Fn(&str) -> bool,
114    ) -> Result<bool, SQLError> {
115        if matches!(
116            command,
117            CommandPlan::Explain { .. } | CommandPlan::Prepare { .. }
118        ) {
119            return Ok(false);
120        }
121        prune_rule_inputs(self.0, command, outer)?;
122        Ok(true)
123    }
124}
125
126struct CapturedInputs<'a> {
127    volatility: &'a dyn uqa_sql::semantics::volatility::VolatilityCatalog,
128    routines: &'a dyn uqa_sql::routines::RoutineResolution,
129    required: &'a std::collections::BTreeMap<uqa_sql::ast::InternalRelationId, BTreeSet<usize>>,
130}
131impl ScopedPlanVisitor for CapturedInputs<'_> {
132    fn source(
133        &mut self,
134        source: &mut SourcePlan,
135        visible: &dyn Fn(&str) -> bool,
136    ) -> Result<bool, SQLError> {
137        if let SourcePlan::Subquery {
138            captured_output: Some(relation),
139            body,
140            ..
141        } = source
142        {
143            if let RelationalPlan::QueryBlock(block) = &body.root {
144                let width = block.projections.len();
145                crate::mutation_outputs::prune_unused_query_outputs(
146                    self.volatility,
147                    self.routines,
148                    body,
149                    self.required.get(relation).unwrap_or(&BTreeSet::new()),
150                    width,
151                    visible,
152                )?;
153            }
154        }
155        Ok(true)
156    }
157}
158
159fn prune_rule_inputs(
160    context: &RuleInputPlanningContext<'_>,
161    command: &mut CommandPlan,
162    inherited_ctes: &dyn Fn(&str) -> bool,
163) -> Result<(), SQLError> {
164    let (table, bound, event) = match command {
165        CommandPlan::Insert(plan) => (&plan.table, plan.target_relation_bound, RuleEvent::Insert),
166        CommandPlan::Update(plan) => (&plan.table, plan.target_relation_bound, RuleEvent::Update),
167        CommandPlan::Delete(plan) => (&plan.table, plan.target_relation_bound, RuleEvent::Delete),
168        _ => return Ok(()),
169    };
170    let table = context.rules.resolve_mutation_target(table, bound)?;
171    validate_rule_contracts(context, command, &table, event)?;
172    if let CommandPlan::Update(plan) = command {
173        uqa_sql::semantics::view_rewrite::validate_grouped_rule_inputs(
174            context.views,
175            &table,
176            &plan.assignments,
177        )?;
178    }
179    let Some(requirements) =
180        uqa_sql::semantics::view_rewrite::rule_input_requirements(context.views, &table, event)?
181    else {
182        return Ok(());
183    };
184    uqa_sql::semantics::rules::validate_rule_returning_contract(
185        context.rules,
186        &table,
187        event,
188        command
189            .returning()
190            .is_some_and(|returning| !returning.is_empty()),
191    )?;
192    let requires_rows = requirements.requires_rows;
193    let required = requirements.columns;
194    match command {
195        CommandPlan::Insert(plan) => {
196            let columns = if plan.columns.is_empty() {
197                context
198                    .columns
199                    .source_column_names(&table, true)?
200                    .unwrap_or_default()
201            } else {
202                plan.columns
203                    .iter()
204                    .map(|target| target.column.clone())
205                    .collect()
206            };
207            let positions = columns
208                .iter()
209                .enumerate()
210                .filter_map(|(position, column)| required.contains(column).then_some(position))
211                .collect::<BTreeSet<_>>();
212            for (position, target) in plan.columns.iter_mut().enumerate() {
213                if !positions.contains(&position) {
214                    for expression in target.expressions_mut() {
215                        *expression = ScalarExpr::Literal(Value::Null);
216                    }
217                }
218            }
219            if plan.rows.len() == 1 || !requires_rows {
220                for row in &mut plan.rows {
221                    for (position, expression) in row.iter_mut().enumerate() {
222                        if !positions.contains(&position) {
223                            *expression = ScalarExpr::Literal(Value::Null);
224                        }
225                    }
226                }
227            }
228            if !requires_rows {
229                plan.source = None;
230                plan.ctes.clear();
231                plan.subqueries.clear();
232            } else if let Some(source) = &mut plan.source {
233                crate::mutation_outputs::prune_unused_query_outputs(
234                    context.volatility,
235                    context.views.routines,
236                    source,
237                    &positions,
238                    columns.len(),
239                    &|name| plan.ctes.iter().any(|cte| cte.name == name) || inherited_ctes(name),
240                )?;
241            }
242        }
243        CommandPlan::Update(plan) => {
244            prune_update_assignments(&mut plan.assignments, &required);
245            if !requires_rows {
246                plan.source = None;
247                plan.predicate = None;
248                plan.ctes.clear();
249                plan.subqueries.clear();
250            }
251        }
252        CommandPlan::Delete(plan) if !requires_rows => {
253            plan.source = None;
254            plan.predicate = None;
255            plan.ctes.clear();
256            plan.subqueries.clear();
257        }
258        _ => {}
259    }
260    Ok(())
261}
262
263fn prune_update_assignments(
264    assignments: &mut Vec<uqa_sql::plan::AssignmentPlan>,
265    required: &BTreeSet<String>,
266) {
267    *assignments = std::mem::take(assignments)
268        .into_iter()
269        .flat_map(|assignment| {
270            if assignment
271                .target
272                .column_names()
273                .all(|column| !required.contains(column))
274            {
275                assignment
276                    .target
277                    .targets()
278                    .iter()
279                    .cloned()
280                    .map(|target| uqa_sql::plan::AssignmentPlan {
281                        target: target.into(),
282                        value: ScalarExpr::Literal(Value::Null),
283                    })
284                    .collect::<Vec<_>>()
285            } else {
286                vec![assignment]
287            }
288        })
289        .collect();
290    for assignment in assignments {
291        if assignment
292            .target
293            .column_names()
294            .all(|column| !required.contains(column))
295        {
296            for expression in assignment.expressions_mut() {
297                *expression = ScalarExpr::Literal(Value::Null);
298            }
299        }
300    }
301}
302
303fn validate_rule_contracts(
304    context: &RuleInputPlanningContext<'_>,
305    command: &CommandPlan,
306    table: &str,
307    event: RuleEvent,
308) -> Result<(), SQLError> {
309    if !command.ctes().is_empty() {
310        uqa_sql::semantics::rules::validate_rule_cte_contract(
311            context.rules,
312            table,
313            event,
314            |table, event| {
315                uqa_sql::semantics::view_rewrite::rule_inputs::original_rule_target(
316                    context.views,
317                    table,
318                    event,
319                )
320            },
321        )?;
322    }
323    if let CommandPlan::Insert(insert) = command {
324        uqa_sql::semantics::rules::validate_insert_rule_query_contract(
325            context.rules,
326            table,
327            insert,
328            |table, event| {
329                uqa_sql::semantics::view_rewrite::rule_inputs::original_rule_target(
330                    context.views,
331                    table,
332                    event,
333                )
334            },
335        )?;
336    }
337    Ok(())
338}
339
340#[cfg(test)]
341mod tests;