Skip to main content

uqa_sql/plan/mutable/commands/
view_metadata.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! View checks and rule input descriptors retain independent vector and child constructors.
8
9use super::{CommandPlan, MutableCommandPlan, RewriteMemory, SQLError};
10use crate::{
11    plan::mutable::field_vectors::{FieldVector, OwnedFields},
12    plan::{
13        copy::Copying, OwnedScalarExpr, ScalarQueryArena, ViewCheckPlan, ViewRuleInsertPlan,
14        ViewRuleUpdatePlan,
15    },
16};
17use uqa_core::memory::{BudgetedVec, Produced, ProductionControl, ProductionVec};
18
19impl MutableCommandPlan {
20    pub fn prepend_view_check(
21        mut self,
22        view: Produced<String>,
23        control: &ProductionControl<'_>,
24        predicate: impl FnOnce(&mut ScalarQueryArena) -> Result<OwnedScalarExpr, SQLError>,
25    ) -> Result<Self, SQLError> {
26        self.assert_owner(control);
27        control.check()?;
28        let mut arena = self.take_mutation_arena()?;
29        let predicate = predicate(&mut arena)?;
30        self.restore_mutation_arena(arena)?;
31        let incoming = if let Some(mut copying) = Copying::for_rewrite(*control) {
32            let value = copying.owned_view_check(view, predicate)?;
33            OwnedFields {
34                value,
35                memory: Some(copying.into_rewrite_memory()),
36            }
37        } else {
38            OwnedFields {
39                value: ViewCheckPlan {
40                    view: view.into_uncontrolled().expect("ordinary check name"),
41                    predicate: predicate
42                        .finish(control)?
43                        .into_uncontrolled()
44                        .expect("ordinary check predicate"),
45                },
46                memory: None,
47            }
48        };
49        let values = std::mem::take(checks(&mut self.command)?);
50        let memory = self
51            .memory
52            .as_mut()
53            .and_then(|memory| body(memory).field_mut("view_checks").take());
54        let replacement = FieldVector { values, memory }.insert(0, incoming, control)?;
55        *checks(&mut self.command)? = replacement.values;
56        if let Some(memory) = &mut self.memory {
57            *body(memory).field_mut("view_checks") = replacement.memory;
58        }
59        Ok(self)
60    }
61
62    pub fn record_view_update_inputs(
63        mut self,
64        relation: &str,
65        control: &ProductionControl<'_>,
66    ) -> Result<Self, SQLError> {
67        self.assert_owner(control);
68        control.check()?;
69        let CommandPlan::Update(plan) = &mut self.command else {
70            return Err(SQLError::Internal(
71                "view update inputs require UPDATE".into(),
72            ));
73        };
74        let mut assigned = ProductionVec::new(*control);
75        for name in plan
76            .assignments
77            .iter()
78            .flat_map(|assignment| assignment.target.column_names())
79        {
80            assigned.push_produced(control.copy_text(name)?)?;
81        }
82        let relation = control.copy_text(relation)?;
83        let assigned = assigned.finish()?;
84        let incoming = if let Some(mut copying) = Copying::for_rewrite(*control) {
85            let value = copying.owned_view_update_inputs(relation, assigned)?;
86            OwnedFields {
87                value,
88                memory: Some(copying.into_rewrite_memory()),
89            }
90        } else {
91            OwnedFields {
92                value: ViewRuleUpdatePlan {
93                    relation: relation
94                        .into_uncontrolled()
95                        .expect("ordinary rule relation"),
96                    assigned_columns: assigned.into_uncontrolled().expect("ordinary rule columns"),
97                    input_columns: Vec::new(),
98                },
99                memory: None,
100            }
101        };
102        let index = plan.view_rule_update_plans.len();
103        let values = std::mem::take(&mut plan.view_rule_update_plans);
104        let memory = self
105            .memory
106            .as_mut()
107            .and_then(|memory| body(memory).field_mut("view_rule_update_plans").take());
108        let replacement = FieldVector { values, memory }.insert(index, incoming, control)?;
109        plan.view_rule_update_plans = replacement.values;
110        if let Some(memory) = &mut self.memory {
111            *body(memory).field_mut("view_rule_update_plans") = replacement.memory;
112        }
113        Ok(self)
114    }
115
116    pub fn finalize_view_update_inputs(
117        mut self,
118        control: &ProductionControl<'_>,
119    ) -> Result<Self, SQLError> {
120        self.assert_owner(control);
121        control.check()?;
122        let CommandPlan::Update(plan) = &mut self.command else {
123            return Err(SQLError::Internal(
124                "view update inputs require UPDATE".into(),
125            ));
126        };
127        for (index, input) in plan.view_rule_update_plans.iter_mut().enumerate() {
128            let mut columns = ProductionVec::new(*control);
129            for name in plan
130                .assignments
131                .iter()
132                .flat_map(|assignment| assignment.target.column_names())
133            {
134                columns.push_produced(control.copy_text(name)?)?;
135            }
136            let (columns, memory) = columns.finish()?.into_parts();
137            input.input_columns = columns;
138            if let Some(owner) = &mut self.memory {
139                *body(owner)
140                    .field_mut("view_rule_update_plans")
141                    .as_mut()
142                    .expect("view rule updates")
143                    .item_mut(index)
144                    .as_mut()
145                    .expect("view rule update")
146                    .field_mut("input_columns") = memory.map(|direct| RewriteMemory::Fields {
147                    fields: BudgetedVec::new(direct.budget()),
148                    direct,
149                });
150            }
151        }
152        Ok(self)
153    }
154    pub fn record_view_insert_inputs(
155        mut self,
156        relation: &str,
157        control: &ProductionControl<'_>,
158    ) -> Result<Self, SQLError> {
159        self.assert_owner(control);
160        control.check()?;
161        let CommandPlan::Insert(plan) = &mut self.command else {
162            return Err(SQLError::Internal(
163                "view insert inputs require INSERT".into(),
164            ));
165        };
166        let mut assigned = ProductionVec::new(*control);
167        for name in plan.columns.iter().map(|target| target.column.as_str()) {
168            assigned.push_produced(control.copy_text(name)?)?;
169        }
170        let relation = control.copy_text(relation)?;
171        let assigned = assigned.finish()?;
172        let incoming = if let Some(mut copying) = Copying::for_rewrite(*control) {
173            let value = copying.owned_view_insert_inputs(relation, assigned)?;
174            OwnedFields {
175                value,
176                memory: Some(copying.into_rewrite_memory()),
177            }
178        } else {
179            OwnedFields {
180                value: ViewRuleInsertPlan {
181                    relation: relation
182                        .into_uncontrolled()
183                        .expect("ordinary rule relation"),
184                    supplied_columns: assigned.into_uncontrolled().expect("ordinary rule columns"),
185                    input_columns: Vec::new(),
186                },
187                memory: None,
188            }
189        };
190        let index = plan.view_rule_insert_plans.len();
191        let values = std::mem::take(&mut plan.view_rule_insert_plans);
192        let memory = self
193            .memory
194            .as_mut()
195            .and_then(|memory| body(memory).field_mut("view_rule_insert_plans").take());
196        let replacement = FieldVector { values, memory }.insert(index, incoming, control)?;
197        plan.view_rule_insert_plans = replacement.values;
198        if let Some(memory) = &mut self.memory {
199            *body(memory).field_mut("view_rule_insert_plans") = replacement.memory;
200        }
201        Ok(self)
202    }
203
204    pub fn finalize_view_insert_inputs(
205        mut self,
206        control: &ProductionControl<'_>,
207    ) -> Result<Self, SQLError> {
208        self.assert_owner(control);
209        control.check()?;
210        let CommandPlan::Insert(plan) = &mut self.command else {
211            return Err(SQLError::Internal(
212                "view insert inputs require INSERT".into(),
213            ));
214        };
215        for (index, input) in plan.view_rule_insert_plans.iter_mut().enumerate() {
216            let mut columns = ProductionVec::new(*control);
217            for name in plan.columns.iter().map(|target| target.column.as_str()) {
218                columns.push_produced(control.copy_text(name)?)?;
219            }
220            let (columns, memory) = columns.finish()?.into_parts();
221            input.input_columns = columns;
222            if let Some(owner) = &mut self.memory {
223                *body(owner)
224                    .field_mut("view_rule_insert_plans")
225                    .as_mut()
226                    .expect("view rule inserts")
227                    .item_mut(index)
228                    .as_mut()
229                    .expect("view rule insert")
230                    .field_mut("input_columns") = memory.map(|direct| RewriteMemory::Fields {
231                    fields: BudgetedVec::new(direct.budget()),
232                    direct,
233                });
234            }
235        }
236        Ok(self)
237    }
238}
239
240fn body(memory: &mut RewriteMemory) -> &mut RewriteMemory {
241    memory.field_mut("value0").as_mut().expect("mutation body")
242}
243
244fn checks(command: &mut CommandPlan) -> Result<&mut Vec<ViewCheckPlan>, SQLError> {
245    match command {
246        CommandPlan::Insert(plan) => Ok(&mut plan.view_checks),
247        CommandPlan::Update(plan) => Ok(&mut plan.view_checks),
248        CommandPlan::Merge(plan) => Ok(&mut plan.view_checks),
249        _ => Err(SQLError::Internal(
250            "view checks require INSERT, UPDATE or MERGE".into(),
251        )),
252    }
253}