uqa_sql/plan/mutable/commands/
projections.rs1use super::{item, CommandPlan, MutableCommandPlan, RewriteMemory, SQLError};
10use uqa_core::memory::{BudgetedVec, Produced, ProductionControl};
11
12impl MutableCommandPlan {
13 pub fn replace_returning_alias(
14 mut self,
15 index: usize,
16 alias: Option<Produced<String>>,
17 control: &ProductionControl<'_>,
18 ) -> Result<Self, SQLError> {
19 self.assert_owner(control);
20 control.check()?;
21 let projections = match &mut self.command {
22 CommandPlan::Insert(plan) => &mut plan.returning,
23 CommandPlan::Update(plan) => &mut plan.returning,
24 CommandPlan::Delete(plan) => &mut plan.returning,
25 CommandPlan::Merge(plan) => &mut plan.returning,
26 _ => {
27 return Err(SQLError::Internal(
28 "RETURNING alias requires a mutation".into(),
29 ));
30 }
31 };
32 let (alias, reservation) = match alias {
33 Some(alias) => {
34 let (alias, memory) = alias.into_parts();
35 (Some(alias), memory)
36 }
37 None => (None, control.empty_reservation()),
38 };
39 let (alias, reservation) = control.finish(alias, reservation)?.into_parts();
40 let memory = reservation.map(|direct| RewriteMemory::Fields {
41 fields: BudgetedVec::new(direct.budget()),
42 direct,
43 });
44 projections[index].alias = alias;
45 if let Some(owner) = &mut self.memory {
46 let body = owner.field_mut("value0").as_mut().expect("mutation body");
47 *item(body, "returning", index).field_mut("alias") = memory;
48 }
49 Ok(self)
50 }
51}
52
53impl MutableCommandPlan {
54 pub fn map_returning_inputs<I: ExactSizeIterator<Item = crate::plan::OwnedProjection>>(
56 mut self,
57 control: &ProductionControl<'_>,
58 map: impl FnOnce(
59 &CommandPlan,
60 crate::plan::OwnedProjectionIter,
61 &mut crate::plan::ScalarQueryArena,
62 ) -> Result<I, SQLError>,
63 ) -> Result<Self, SQLError> {
64 use super::super::projections::{OwnedProjectionIter, ProjectionVector};
65 self.assert_owner(control);
66 control.check()?;
67 let projections = std::mem::take(returning(&mut self.command)?).into_iter();
68 let memory = self.memory.as_mut().and_then(|memory| {
69 memory
70 .field_mut("value0")
71 .as_mut()
72 .expect("mutation body")
73 .field_mut("returning")
74 .take()
75 });
76 let inputs = OwnedProjectionIter {
77 projections,
78 memory,
79 index: 0,
80 };
81 let mut arena = self.take_mutation_arena()?;
82 let replacement = ProjectionVector::new(map(&self.command, inputs, &mut arena)?, control)?;
83 *returning(&mut self.command)? = replacement.projections;
84 if let Some(memory) = &mut self.memory {
85 *memory
86 .field_mut("value0")
87 .as_mut()
88 .expect("mutation body")
89 .field_mut("returning") = replacement.memory;
90 }
91 self.restore_mutation_arena(arena)?;
92 control.check()?;
93 Ok(self)
94 }
95}
96
97fn returning(command: &mut CommandPlan) -> Result<&mut Vec<crate::plan::ProjectionPlan>, SQLError> {
98 match command {
99 CommandPlan::Insert(plan) => Ok(&mut plan.returning),
100 CommandPlan::Update(plan) => Ok(&mut plan.returning),
101 CommandPlan::Delete(plan) => Ok(&mut plan.returning),
102 CommandPlan::Merge(plan) => Ok(&mut plan.returning),
103 _ => Err(SQLError::Internal("RETURNING requires a mutation".into())),
104 }
105}