uqa_sql/semantics/rules/binding/actions/query/
schedule.rs1use super::{
10 add_condition, projection_block, BTreeSet, Expr, InternalRelationId, ProjectionPlan, QueryPlan,
11 RelationalPlan, RuleQueryResolver, SQLError, ScalarExpr, SourcePlan,
12};
13use crate::{
14 ast::{BooleanTest, FunctionBinding, FunctionDispatch, FunctionOrderSyntax, RuleEvent},
15 plan::InsertPlan,
16 semantics::rules::{action_binding::bind_rule_expr_scoped, analysis::RuleAnalysisContext},
17};
18
19pub struct InsertRuleQueries {
20 pub original: Option<Box<QueryPlan>>,
21 pub relations: Vec<InsertPlan>,
23}
24
25impl InsertRuleQueries {
26 pub fn bind(
27 context: RuleAnalysisContext<'_>,
28 insert: &InsertPlan,
29 subjects: &dyn Fn(&str) -> Result<crate::catalog::roles::RoleReference, SQLError>,
30 input_subject: &crate::catalog::roles::RoleReference,
31 ) -> Result<Self, SQLError> {
32 let mut first = relation_plan(insert, insert.view_rule_insert_plans.first());
33 let mut values = super::values::ValuesInput::describe(&first)?;
34 let mut source = if let Some(values) = &values {
35 values.source(context, &mut first)?
36 } else {
37 insert.source.clone().expect("INSERT query input")
38 };
39 source
40 .relation_privilege_subject
41 .get_or_insert(input_subject.clone());
42 let mut relations = Vec::new();
43 for layer in &insert.view_rule_insert_plans {
44 let mut plan = relation_plan(insert, Some(layer));
45 plan.source = Some(source);
46 if let Some(values) = &mut values {
47 values.project_layer(context, &mut plan)?;
48 }
49 let original = original_query(context, &plan, subjects)?;
50 relations.push(plan);
51 let Some(original) = original else {
52 return Ok(Self {
53 original: None,
54 relations,
55 });
56 };
57 source = original;
58 }
59 let mut plan = relation_plan(insert, None);
60 plan.source = Some(source);
61 if let Some(values) = &mut values {
62 values.project_layer(context, &mut plan)?;
63 }
64 let original = original_query(context, &plan, subjects)?;
65 relations.push(plan);
66 let original = if let Some(values) = &values {
67 original.map(|query| values.finish(query))
68 } else {
69 original
70 };
71 Ok(Self {
72 original,
73 relations,
74 })
75 }
76}
77
78fn relation_plan(
79 insert: &InsertPlan,
80 layer: Option<&crate::plan::ViewRuleInsertPlan>,
81) -> InsertPlan {
82 let mut plan = insert.clone();
83 plan.view_rule_insert_plans.clear();
84 plan.view_rule_relations.clear();
85 let Some(layer) = layer else {
86 return plan;
87 };
88 plan.table.clone_from(&layer.relation);
89 plan.target_qualifier.clone_from(&layer.relation);
90 plan.columns = layer
91 .supplied_columns
92 .iter()
93 .zip(&insert.columns)
94 .map(|(name, target)| {
95 let mut target = target.clone();
96 target.column.clone_from(name);
97 target
98 })
99 .collect();
100 plan.returning.clear();
101 if let Some(returning) = &insert.view_rule_returning {
102 if returning.relation == layer.relation {
103 plan.target_qualifier
104 .clone_from(&returning.target_qualifier);
105 plan.returning.clone_from(&returning.returning);
106 plan.returning_aliases.clone_from(&returning.aliases);
107 plan.subqueries.clone_from(&returning.subqueries);
108 }
109 }
110 plan
111}
112
113fn original_query(
114 context: RuleAnalysisContext<'_>,
115 insert: &InsertPlan,
116 subjects: &dyn Fn(&str) -> Result<crate::catalog::roles::RoleReference, SQLError>,
117) -> Result<Option<Box<QueryPlan>>, SQLError> {
118 let rules = context.rules.rules_for(&insert.table, RuleEvent::Insert)?;
119 if rules
120 .iter()
121 .any(|rule| rule.definition.instead && rule.definition.condition.is_none())
122 {
123 return Ok(None);
124 }
125 let conditions = rules
126 .iter()
127 .filter(|rule| rule.definition.instead)
128 .filter_map(|rule| rule.definition.condition.as_ref())
129 .collect::<Vec<_>>();
130 if conditions.is_empty() {
131 return Ok(insert.source.clone());
132 }
133 let subject = subjects(&insert.table)?;
134 let relation = InternalRelationId::allocate();
135 let mut resolver = RuleQueryResolver::from_insert(context, insert, relation)?;
136 let source = insert.source.as_deref().expect("INSERT query input");
137 let mut block = original_block(insert, source, relation, resolver.columns.len())?;
138 for condition in conditions {
139 let expression = bind_rule_expr_scoped(condition, &mut resolver, &BTreeSet::new())?;
140 let binding =
141 FunctionBinding::dispatched(FunctionDispatch::BooleanTest(BooleanTest::IsNotTrue));
142 add_condition(
143 &mut block.r#where,
144 &mut block.subqueries,
145 Some(Expr::Func {
146 order_syntax: FunctionOrderSyntax::Ordinary,
147 name: binding.name.clone(),
148 binding: Some(binding),
149 args: vec![expression],
150 distinct: false,
151 order_by: Vec::new(),
152 filter: None,
153 }),
154 Some(&subject),
155 );
156 }
157 if let Some(predicate) = block.r#where.take() {
158 let mut expression = crate::plan::ExpressionPlan {
159 scalar: predicate,
160 subqueries: std::mem::take(&mut block.subqueries),
161 };
162 crate::plan::input_projection::substitute_expression_inputs(
163 &mut expression,
164 &resolver.expressions,
165 )?;
166 block.r#where = Some(expression.scalar);
167 block.subqueries = expression.subqueries;
168 }
169 Ok(Some(Box::new(QueryPlan {
170 analyzed_output: source.analyzed_output.clone(),
171 analyzed_source: None,
172 analyzed_grouping: None,
173 relation_privilege_subject: source.relation_privilege_subject.clone(),
174 relations_bound: insert.relations_bound,
175 ctes: Vec::new(),
176 root: RelationalPlan::QueryBlock(Box::new(block)),
177 })))
178}
179
180fn original_block(
181 insert: &InsertPlan,
182 source: &QueryPlan,
183 relation: InternalRelationId,
184 default_width: usize,
185) -> Result<crate::plan::QueryBlockPlan, SQLError> {
186 let width = source.analyzed_output.as_ref().map_or_else(
187 || match &source.root {
188 RelationalPlan::QueryBlock(block) => block.projections.len(),
189 RelationalPlan::Values { rows, .. } => rows.first().map_or(0, Vec::len),
190 RelationalPlan::SetOp { .. } => {
191 if insert.columns.is_empty() {
192 default_width
193 } else {
194 insert.columns.len()
195 }
196 }
197 },
198 crate::RowSchema::len,
199 );
200 let inline = insert
201 .rule_values_input
202 .as_ref()
203 .is_some_and(crate::plan::RuleValuesInput::is_inline);
204 let mut block = if inline {
205 let RelationalPlan::QueryBlock(block) = &source.root else {
206 return Err(SQLError::Internal(
207 "rule target list lost its query block".into(),
208 ));
209 };
210 (**block).clone()
211 } else {
212 projection_block(
213 (0..width)
214 .map(|position| ProjectionPlan {
215 expr: ScalarExpr::InternalColumn(relation.column(position)),
216 alias: None,
217 })
218 .collect(),
219 )
220 };
221 if !inline {
222 block.from = Some(SourcePlan::Subquery {
223 captured_output: Some(relation),
224 lateral: false,
225 body: Box::new(source.clone()),
226 alias: None,
227 column_aliases: Vec::new(),
228 });
229 }
230 Ok(block)
231}