Skip to main content

uqa_sql/plan/mutable/commands/
projections.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! RETURNING names retain their independently admitted payload when scalar values change.
8
9use 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    /// Rewrite RETURNING projections and append embedded queries to the same admitted arena.
55    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}