Skip to main content

uqa_sql/plan/mutable/
deferred.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Deferred substitutions move with their exact item owners while source and scalar arenas retain their original namespaces.
8
9use super::{
10    Copying, MutableQueryPlan, RelationalPlan, RewriteMemory, ScalarArenaTransform,
11    ScalarQueryArena,
12};
13use crate::{semantics::view_rewrite::DeferredOuterRewrite, SQLError};
14use uqa_core::memory::{Budgeted, Produced, ProductionControl};
15
16pub struct OwnedDeferredRewriteIter {
17    values: std::vec::IntoIter<DeferredOuterRewrite>,
18    memory: Option<RewriteMemory>,
19    index: usize,
20}
21impl Iterator for OwnedDeferredRewriteIter {
22    type Item = Produced<DeferredOuterRewrite>;
23    fn next(&mut self) -> Option<Self::Item> {
24        let value = self.values.next()?;
25        let owner = self
26            .memory
27            .as_mut()
28            .and_then(|memory| memory.item_mut(self.index).take())
29            .and_then(RewriteMemory::into_reservation);
30        self.index += 1;
31        Some(match owner {
32            Some(memory) => Produced::from(Budgeted::new(value, memory)),
33            None => ProductionControl::uncontrolled()
34                .finish(value, None)
35                .expect("ordinary deferred substitution"),
36        })
37    }
38    fn size_hint(&self) -> (usize, Option<usize>) {
39        self.values.size_hint()
40    }
41}
42impl ExactSizeIterator for OwnedDeferredRewriteIter {}
43
44impl MutableQueryPlan {
45    pub fn take_deferred_rewrites(
46        mut self,
47        control: &ProductionControl<'_>,
48    ) -> Result<(Self, OwnedDeferredRewriteIter), SQLError> {
49        self.assert_owner(control);
50        control.check()?;
51        let RelationalPlan::QueryBlock(block) = &mut self.query.root else {
52            return Err(SQLError::Internal(
53                "deferred substitutions require a query block".into(),
54            ));
55        };
56        let values = std::mem::take(&mut block.deferred_outer_rewrites);
57        let memory = self.memory.as_mut().and_then(|memory| {
58            block_memory(memory)
59                .field_mut("deferred_outer_rewrites")
60                .take()
61        });
62        Ok((
63            self,
64            OwnedDeferredRewriteIter {
65                values: values.into_iter(),
66                memory,
67                index: 0,
68            },
69        ))
70    }
71
72    pub fn replace_deferred_rewrites(
73        mut self,
74        rewrites: impl ExactSizeIterator<Item = Produced<DeferredOuterRewrite>>,
75        control: &ProductionControl<'_>,
76    ) -> Result<Self, SQLError> {
77        self.assert_owner(control);
78        control.check()?;
79        let (values, owner) = if let Some(mut copying) = Copying::for_rewrite(*control) {
80            let values = copying.map(rewrites, |copying, rewrite| {
81                copying.take_deferred_rewrite(rewrite)
82            })?;
83            (values, Some(copying.into_rewrite_memory()))
84        } else {
85            let mut values = Vec::with_capacity(rewrites.len());
86            for rewrite in rewrites {
87                control.check()?;
88                values.push(
89                    rewrite
90                        .into_uncontrolled()
91                        .expect("ordinary deferred substitution"),
92                );
93            }
94            (values, None)
95        };
96        let RelationalPlan::QueryBlock(block) = &mut self.query.root else {
97            return Err(SQLError::Internal(
98                "deferred substitutions require a query block".into(),
99            ));
100        };
101        block.deferred_outer_rewrites = values;
102        if let Some(memory) = &mut self.memory {
103            *block_memory(memory).field_mut("deferred_outer_rewrites") = owner;
104        }
105        Ok(self)
106    }
107
108    /// Edit block-owned roots while lending their scalar-query namespace. FROM expressions and nested query bodies retain their separate rewrite boundary.
109    pub fn transform_root_scalar_arenas(
110        mut self,
111        control: &ProductionControl<'_>,
112        transform: &mut ScalarArenaTransform<'_>,
113    ) -> Result<Self, SQLError> {
114        self.assert_owner(control);
115        control.check()?;
116        let mut arena = self.take_arena();
117        super::nodes::query_scalars(
118            &mut self.query,
119            self.memory.as_mut(),
120            false,
121            control,
122            &mut |expression, memory, control| {
123                super::OwnedScalarExpr::transform_nodes_in_place(
124                    expression,
125                    memory,
126                    control,
127                    &mut |identity, expression| transform(identity, expression, &mut arena),
128                )
129            },
130        )?;
131        self.restore_arena(arena);
132        Ok(self)
133    }
134
135    pub fn map_source_with_arena(
136        mut self,
137        control: &ProductionControl<'_>,
138        map: impl FnOnce(
139            super::MutableSourcePlan,
140            &mut ScalarQueryArena,
141        ) -> Result<super::MutableSourcePlan, SQLError>,
142    ) -> Result<Self, SQLError> {
143        self.assert_owner(control);
144        control.check()?;
145        let mut arena = self.take_arena();
146        self = self.map_source(control, |source| map(source, &mut arena))?;
147        self.restore_arena(arena);
148        Ok(self)
149    }
150
151    pub(super) fn take_arena(&mut self) -> ScalarQueryArena {
152        let queries = std::mem::take(arena_queries(&mut self.query.root));
153        let memory = self
154            .memory
155            .as_mut()
156            .and_then(|memory| arena_memory(memory).take());
157        ScalarQueryArena { queries, memory }
158    }
159    pub(super) fn restore_arena(&mut self, arena: ScalarQueryArena) {
160        *arena_queries(&mut self.query.root) = arena.queries;
161        if let Some(memory) = &mut self.memory {
162            *arena_memory(memory) = arena.memory;
163        }
164    }
165}
166
167fn block_memory(memory: &mut RewriteMemory) -> &mut RewriteMemory {
168    memory
169        .field_mut("root")
170        .as_mut()
171        .expect("query root")
172        .field_mut("block")
173        .as_mut()
174        .expect("query block")
175}
176fn arena_queries(root: &mut RelationalPlan) -> &mut Vec<crate::plan::QueryPlan> {
177    match root {
178        RelationalPlan::QueryBlock(block) => &mut block.subqueries,
179        RelationalPlan::SetOp { subqueries, .. } | RelationalPlan::Values { subqueries, .. } => {
180            subqueries
181        }
182    }
183}
184fn arena_memory(memory: &mut RewriteMemory) -> &mut Option<RewriteMemory> {
185    let root = memory.field_mut("root").as_mut().expect("query root");
186    let is_block = match root {
187        RewriteMemory::Fields { fields, .. } => fields.iter().any(|field| field.name == "block"),
188        RewriteMemory::Scalar(_) | RewriteMemory::Scalars { .. } => unreachable!(),
189    };
190    let root = if is_block {
191        root.field_mut("block").as_mut().expect("query block")
192    } else {
193        root
194    };
195    root.field_mut("subqueries")
196}