uqa_planner/statement_planning/
rule_inputs.rs1use 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
76fn 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;