1use crate::{
10 ast::{DeferredSQLError, Expr, InternalColumnRef, InternalRelationId},
11 plan::{
12 copy::SyntaxProduction, input_projection::OwnedInputProjections, ExpressionPlan,
13 InsertPlan, MutableExpressionPlan, RelationalPlan,
14 },
15 plpgsql::{ResolvedVariable, RewriteReference, VariableResolver},
16 semantics::rules::analysis::{rule_returning_columns_with_control, RuleAnalysisContext},
17 SQLError,
18};
19use uqa_core::memory::{OwnedMap, Produced, ProductionControl};
20
21mod conditions;
22mod mutation;
23
24struct RuleColumnTemplate {
25 name: String,
26 old: Expr,
27 new: Result<Expr, DeferredSQLError>,
28}
29
30pub struct RuleInputColumns {
31 pub positions: Produced<Vec<usize>>,
32 pub width: usize,
33}
34
35pub struct OwnedRuleQueryResolver {
36 table: Produced<String>,
37 columns: Produced<Vec<RuleColumnTemplate>>,
38 pub expressions: OwnedInputProjections,
39}
40
41impl OwnedRuleQueryResolver {
42 pub(in crate::semantics::rules::binding::actions::query) fn column_count(&self) -> usize {
43 self.columns.len()
44 }
45
46 pub fn reserved_bytes(&self) -> usize {
47 self.table.reserved_bytes()
48 + self.columns.reserved_bytes()
49 + self.expressions.allocated_bytes()
50 + self
51 .expressions
52 .values()
53 .map(Produced::reserved_bytes)
54 .sum::<usize>()
55 }
56
57 pub fn input_columns_with_control(
58 &self,
59 context: RuleAnalysisContext<'_>,
60 insert: &InsertPlan,
61 action: &crate::ast::Statement,
62 condition: Option<&Expr>,
63 target_columns: &dyn crate::semantics::rules::action_binding::ActionColumns,
64 control: &ProductionControl<'_>,
65 ) -> Result<Option<RuleInputColumns>, SQLError> {
66 let Some(required) =
67 crate::semantics::rules::action_binding::rule_action_input_columns_with_control(
68 context.sources,
69 action,
70 condition,
71 target_columns,
72 control,
73 )?
74 else {
75 return Ok(None);
76 };
77 let width = if insert.columns.is_empty() {
78 insert
79 .source
80 .as_deref()
81 .and_then(|query| query.analyzed_output.as_ref())
82 .map_or_else(
83 || super::inline_width(insert).unwrap_or(self.columns.len()),
84 crate::RowSchema::len,
85 )
86 .min(self.columns.len())
87 } else {
88 insert.columns.len()
89 };
90 let mut positions = uqa_core::memory::ProductionVec::new(*control);
91 for position in 0..width {
92 control.check()?;
93 let name = if insert.columns.is_empty() {
94 &self.columns[position].name
95 } else {
96 &insert.columns[position].column
97 };
98 if required.binary_search(name).is_ok() {
99 positions.push_copy(position)?;
100 }
101 }
102 Ok(Some(RuleInputColumns {
103 positions: positions.finish()?,
104 width,
105 }))
106 }
107
108 pub fn from_insert_with_control(
109 context: RuleAnalysisContext<'_>,
110 insert: &InsertPlan,
111 relation: InternalRelationId,
112 control: &ProductionControl<'_>,
113 ) -> Result<Self, SQLError> {
114 control.check()?;
115 let definitions = rule_returning_columns_with_control(context, &insert.table, control)?;
116 let width = insert
117 .source
118 .as_deref()
119 .and_then(|source| source.analyzed_output.as_ref())
120 .map_or_else(
121 || super::inline_width(insert).unwrap_or(definitions.len()),
122 crate::RowSchema::len,
123 );
124 let output = SyntaxProduction::new(*control);
125 let mut columns = output.vector(definitions.len())?;
126 let mut pending = crate::production::Buffer::new(control);
127 for column in &*definitions {
128 output.check()?;
129 let ty = column.ty.catalog_name_with_control(control)?;
130 let old = Expr::Cast {
131 implicit: true,
132 expr: output.boxed(Expr::Literal(uqa_core::Value::Null))?,
133 ty: output.take(ty),
134 };
135 let expression = insert_column(
136 context,
137 insert,
138 &definitions,
139 column,
140 relation,
141 width,
142 control,
143 )?;
144 let expression = bind_column_collation(expression, column, control)?;
145 let reference = InternalRelationId::allocate().column(0);
146 pending.push((reference, expression), control)?;
147 columns.push(RuleColumnTemplate {
148 name: output.text(&column.name)?,
149 old,
150 new: Ok(Expr::InternalColumn(reference)),
151 })?;
152 }
153 let mut inputs = inline_inputs(insert, relation, control)?;
154 let subject = insert
155 .source
156 .as_ref()
157 .and_then(|source| source.relation_privilege_subject.as_ref());
158 let mut expressions = OwnedMap::new();
159 for (reference, expression) in pending {
160 let expression = crate::plan::input_projection::substitute_expression_inputs_owned(
161 expression, &inputs, control,
162 )?;
163 let expression = retain_authority(expression, subject, control)?;
164 insert_expression(
165 &mut expressions,
166 reference,
167 expression.finish(control)?,
168 control,
169 )?;
170 }
171 for (reference, expression) in std::mem::take(&mut inputs) {
172 insert_expression(&mut expressions, reference, expression, control)?;
173 }
174 let columns = columns.finish()?;
175 let columns = output.finish(columns)?;
176 Ok(Self {
177 table: control.copy_text(&insert.table)?,
178 columns,
179 expressions,
180 })
181 }
182}
183
184fn insert_column(
185 context: RuleAnalysisContext<'_>,
186 insert: &InsertPlan,
187 definitions: &[crate::ast::ColumnDef],
188 column: &crate::ast::ColumnDef,
189 relation: InternalRelationId,
190 width: usize,
191 control: &ProductionControl<'_>,
192) -> Result<MutableExpressionPlan, SQLError> {
193 if insert
194 .columns
195 .iter()
196 .any(|target| target.column == column.name && !target.is_whole_column())
197 {
198 return super::assignments::column_expression_with_control(
199 context, insert, column, relation, control,
200 );
201 }
202 let position = if insert.columns.is_empty() {
203 definitions
204 .iter()
205 .take(width)
206 .position(|candidate| candidate.name == column.name)
207 } else {
208 insert
209 .columns
210 .iter()
211 .position(|target| target.column == column.name)
212 }
213 .filter(|_| !super::values::overrides_identity(column, insert.overriding));
214 let value = if let Some(position) = position {
215 ExpressionPlan::lower_borrowed_for_rewrite(
216 &Expr::InternalColumn(relation.column(position)),
217 control,
218 )?
219 } else {
220 let default = super::values::default_expression_with_control(context, column, control)?;
221 ExpressionPlan::lower_borrowed_for_rewrite(
222 default
223 .as_deref()
224 .unwrap_or(&Expr::Literal(uqa_core::Value::Null)),
225 control,
226 )?
227 };
228 value.map_scalar(control, |scalar, _| {
229 Ok(crate::plan::OwnedScalarExpr::cast(
230 scalar,
231 column.ty.catalog_name_with_control(control)?,
232 true,
233 control,
234 )?)
235 })
236}
237
238pub(super) fn insert_expression(
239 output: &mut OwnedInputProjections,
240 reference: InternalColumnRef,
241 expression: Produced<ExpressionPlan>,
242 control: &ProductionControl<'_>,
243) -> Result<(), SQLError> {
244 control.check()?;
245 if let Some(budget) = control.budget() {
246 output.insert_budgeted(reference, expression, budget)?;
247 } else {
248 output.insert(reference, expression);
249 }
250 Ok(())
251}
252
253fn inline_inputs(
254 insert: &InsertPlan,
255 relation: InternalRelationId,
256 control: &ProductionControl<'_>,
257) -> Result<OwnedInputProjections, SQLError> {
258 let mut inputs = OwnedMap::new();
259 if !insert
260 .rule_values_input
261 .as_ref()
262 .is_some_and(crate::plan::RuleValuesInput::is_inline)
263 {
264 return Ok(inputs);
265 }
266 let source = insert.source.as_ref().expect("inline input query");
267 let RelationalPlan::QueryBlock(block) = &source.root else {
268 return Err(SQLError::Internal(
269 "rule target list lost its query block".into(),
270 ));
271 };
272 for (position, projection) in block.projections.iter().enumerate() {
273 let expression =
274 MutableExpressionPlan::copy_from(&projection.expr, &block.subqueries, control)?
275 .prune_subqueries(control)?;
276 let expression = retain_authority(
277 expression,
278 source.relation_privilege_subject.as_ref(),
279 control,
280 )?;
281 insert_expression(
282 &mut inputs,
283 relation.column(position),
284 expression.finish(control)?,
285 control,
286 )?;
287 }
288 Ok(inputs)
289}
290
291pub(super) fn retain_authority(
292 mut expression: MutableExpressionPlan,
293 subject: Option<&crate::catalog::roles::RoleReference>,
294 control: &ProductionControl<'_>,
295) -> Result<MutableExpressionPlan, SQLError> {
296 if let Some(subject) = subject {
297 for index in 0..expression.queries().len() {
298 if expression.queries()[index]
299 .relation_privilege_subject
300 .is_none()
301 {
302 expression = expression.map_query(index, control, |query| {
303 query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
304 })?;
305 }
306 }
307 }
308 Ok(expression)
309}
310
311pub(super) fn bind_column_collation(
312 expression: MutableExpressionPlan,
313 column: &crate::ast::ColumnDef,
314 control: &ProductionControl<'_>,
315) -> Result<MutableExpressionPlan, SQLError> {
316 if !crate::schema::composites::type_is_collatable(&column.ty) {
317 return Ok(expression);
318 }
319 let oid = column.collation_oid.unwrap_or_else(|| {
320 u32::try_from(crate::catalog::type_metadata::pg_type_collation_oid(
321 &column.ty,
322 ))
323 .expect("type collation identity")
324 });
325 let collation = crate::ir::ResultCollation::new(
326 crate::catalog::collations::derivation::Derivation::implicit(i64::from(oid)),
327 oid,
328 );
329 expression.map_scalar(control, |scalar, _| {
330 Ok(crate::plan::OwnedScalarExpr::collated(
331 scalar,
332 column.ty.clone_with_control(control)?,
333 collation,
334 control,
335 )?)
336 })
337}
338
339impl VariableResolver for OwnedRuleQueryResolver {
340 fn rewrite_with_control(
341 &mut self,
342 reference: RewriteReference<'_>,
343 control: &ProductionControl<'_>,
344 ) -> Result<Option<Produced<Expr>>, SQLError> {
345 control.check()?;
346 let output = SyntaxProduction::new(*control);
347 let selected = |column: &RuleColumnTemplate, new: bool| -> Result<Expr, SQLError> {
348 if new {
349 output.copy(
350 column
351 .new
352 .as_ref()
353 .map_err(|error| SQLError::from(error.clone()))?,
354 )
355 } else {
356 output.copy(&column.old)
357 }
358 };
359 let expression = match reference {
360 RewriteReference::Name(name) | RewriteReference::WholeRow(name) => {
361 let new = name.eq_ignore_ascii_case("new");
362 if !new && !name.eq_ignore_ascii_case("old") {
363 return Ok(None);
364 }
365 let mut items = output.vector(self.columns.len())?;
366 for column in &*self.columns {
367 items.push(selected(column, new)?)?;
368 }
369 Expr::Cast {
370 implicit: true,
371 expr: output.boxed(Expr::Row(items.finish()?))?,
372 ty: output.text(&self.table)?,
373 }
374 }
375 RewriteReference::Qualified { qualifier, column } => {
376 let new = qualifier.eq_ignore_ascii_case("new");
377 if !new && !qualifier.eq_ignore_ascii_case("old") {
378 return Ok(None);
379 }
380 let selected_column = self
381 .columns
382 .iter()
383 .find(|value| value.name == column)
384 .ok_or_else(|| SQLError::UnknownColumn(format!("{qualifier}.{column}")))?;
385 selected(selected_column, new)?
386 }
387 RewriteReference::Parameter(_) | RewriteReference::Internal(_) => return Ok(None),
388 };
389 Ok(Some(output.finish(expression)?))
390 }
391 fn resolve_name(&mut self, _: &str) -> Result<Option<ResolvedVariable>, SQLError> {
392 Ok(None)
393 }
394 fn resolve_qualified(
395 &mut self,
396 _: &str,
397 _: &str,
398 ) -> Result<Option<ResolvedVariable>, SQLError> {
399 Ok(None)
400 }
401 fn resolve_param(&mut self, _: usize) -> Result<Option<ResolvedVariable>, SQLError> {
402 Ok(None)
403 }
404 fn rewrite_name(&mut self, name: &str) -> Result<Option<Expr>, SQLError> {
405 Ok(self
406 .rewrite_with_control(
407 RewriteReference::Name(name),
408 &ProductionControl::uncontrolled(),
409 )?
410 .map(|value| value.into_uncontrolled().expect("ordinary reference")))
411 }
412 fn rewrite_qualified(
413 &mut self,
414 qualifier: &str,
415 column: &str,
416 ) -> Result<Option<Expr>, SQLError> {
417 Ok(self
418 .rewrite_with_control(
419 RewriteReference::Qualified { qualifier, column },
420 &ProductionControl::uncontrolled(),
421 )?
422 .map(|value| value.into_uncontrolled().expect("ordinary reference")))
423 }
424 fn rewrite_qualified_whole_row(&mut self, qualifier: &str) -> Result<Option<Expr>, SQLError> {
425 self.rewrite_name(qualifier)
426 }
427}