Skip to main content

uqa_sql/semantics/rules/binding/actions/query/
owned.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Native rule actions move input trees and scalar namespaces without detaching their allocation owners.
8
9use super::{values::ValuesInput, RuleAction};
10use crate::{
11    ast::InternalRelationId,
12    plan::{
13        input_projection::{substitute_plan_inputs_owned, OwnedInputProjections},
14        AggregateClassifier, CommandPlan, MutableExecutablePlan, MutableExpressionPlan,
15        MutableQueryPlan, MutableSourcePlan, OwnedScalarExpr, QueryChildSlot, RelationalPlan,
16        ScalarQueryArena, UnifiedPlan,
17    },
18    semantics::rules::{action_binding::BoundRuleStatement, analysis::RuleAnalysisContext},
19    SQLError,
20};
21use uqa_core::memory::{Produced, ProductionControl};
22
23pub struct OwnedRuleQueryInput {
24    pub query: MutableQueryPlan,
25    pub inline: bool,
26    pub relation: InternalRelationId,
27    pub condition: Option<MutableExpressionPlan>,
28    pub expressions: Produced<OwnedInputProjections>,
29}
30
31impl RuleAction {
32    /// Lower an already bound statement and attach independently owned event inputs under their original request allowance.
33    pub fn bind_with_control(
34        context: RuleAnalysisContext<'_>,
35        aggregates: &dyn AggregateClassifier,
36        statement: &BoundRuleStatement,
37        input: Option<OwnedRuleQueryInput>,
38        control: &ProductionControl<'_>,
39    ) -> Result<Self, SQLError> {
40        let plan =
41            UnifiedPlan::lower_borrowed_for_rewrite(statement.statement(), aggregates, control)?
42                .mark_catalog_relations_bound(control)?;
43        let plan = match input {
44            Some(input) => input.attach(plan, context, control)?,
45            None => plan,
46        };
47        Ok(Self::Owned(plan))
48    }
49}
50
51impl OwnedRuleQueryInput {
52    pub fn attach(
53        self,
54        plan: MutableExecutablePlan,
55        context: RuleAnalysisContext<'_>,
56        control: &ProductionControl<'_>,
57    ) -> Result<MutableExecutablePlan, SQLError> {
58        control.check()?;
59        let (source, predicate) = input_parts(self.query, self.inline, self.relation, control)?;
60        let plan = match plan {
61            MutableExecutablePlan::Query(query) => MutableExecutablePlan::Query(attach_query(
62                query,
63                source,
64                predicate,
65                self.condition,
66                control,
67            )?),
68            MutableExecutablePlan::Command(command) => {
69                let command = match &*command {
70                    CommandPlan::Insert(_) => {
71                        let command =
72                            ValuesInput::prepare_action_with_control(context, command, control)?;
73                        command.map_insert_source(control, |_, query| {
74                            attach_query(
75                                query.expect("INSERT source"),
76                                source,
77                                predicate,
78                                self.condition,
79                                control,
80                            )
81                        })?
82                    }
83                    CommandPlan::Update(_) | CommandPlan::Delete(_) => {
84                        let mut command = command;
85                        if let Some(source) = source {
86                            command = command.map_source_input(control, |original| {
87                                prepend(original, Some(source), control)
88                            })?;
89                        }
90                        for condition in [predicate, self.condition].into_iter().flatten() {
91                            command = command.map_predicate_input(control, |original, arena| {
92                                add_condition(original, arena, condition, control)
93                            })?;
94                        }
95                        command
96                    }
97                    _ => {
98                        return Err(SQLError::Internal(
99                            "rule query input requires a relational action".into(),
100                        ))
101                    }
102                };
103                MutableExecutablePlan::Command(command)
104            }
105        };
106        substitute_plan_inputs_owned(plan, &self.expressions, control)
107    }
108}
109
110fn input_parts(
111    query: MutableQueryPlan,
112    inline: bool,
113    relation: InternalRelationId,
114    control: &ProductionControl<'_>,
115) -> Result<(Option<MutableSourcePlan>, Option<MutableExpressionPlan>), SQLError> {
116    Ok(if inline {
117        let mut query = query;
118        let RelationalPlan::QueryBlock(block) = &query.root else {
119            return Err(SQLError::Internal(
120                "rule target list lost its query block".into(),
121            ));
122        };
123        if !query.ctes.is_empty() {
124            return Err(SQLError::Internal(
125                "rule target list has an unexpected local CTE scope".into(),
126            ));
127        }
128        let count = block.subqueries.len();
129        let subject = query
130            .relation_privilege_subject
131            .as_ref()
132            .map(|subject| subject.clone_with_control(control))
133            .transpose()?;
134        if let Some(subject) = subject {
135            for index in 0..count {
136                query =
137                    query.map_query_child(QueryChildSlot::Subquery(index), control, |query| {
138                        if query.relation_privilege_subject.is_none() {
139                            query.set_privilege_subject(
140                                Some(subject.clone_with_control(control)?),
141                                control,
142                            )
143                        } else {
144                            Ok(query)
145                        }
146                    })?;
147            }
148        }
149        let (query, predicate) = query.take_where_expression(control)?;
150        let (_, source) = query.take_source(control)?;
151        (source, predicate)
152    } else {
153        let columns = control.finish(Vec::new(), control.empty_reservation())?;
154        (
155            Some(MutableSourcePlan::subquery(
156                query,
157                None,
158                columns,
159                Some(relation),
160                false,
161                control,
162            )?),
163            None,
164        )
165    })
166}
167
168fn attach_query(
169    query: MutableQueryPlan,
170    source: Option<MutableSourcePlan>,
171    predicate: Option<MutableExpressionPlan>,
172    condition: Option<MutableExpressionPlan>,
173    control: &ProductionControl<'_>,
174) -> Result<MutableQueryPlan, SQLError> {
175    let query = query.project_values(control)?;
176    if matches!(query.root, RelationalPlan::SetOp { .. }) {
177        if source.is_some() || predicate.is_some() || condition.is_some() {
178            return Err(SQLError::Routine {
179                sqlstate: "0A000".into(),
180                message: "conditional UNION/INTERSECT/EXCEPT statements are not implemented".into(),
181            });
182        }
183        return Ok(query);
184    }
185    let mut query = query;
186    if let Some(source) = source {
187        let (parent, original) = query.take_source(control)?;
188        query = parent.replace_source(prepend(original, Some(source), control)?, control)?;
189    }
190    for condition in [predicate, condition].into_iter().flatten() {
191        query = query.map_where_input(control, |original, arena| {
192            add_condition(original, arena, condition, control)
193        })?;
194    }
195    Ok(query)
196}
197
198fn prepend(
199    original: Option<MutableSourcePlan>,
200    input: Option<MutableSourcePlan>,
201    control: &ProductionControl<'_>,
202) -> Result<Option<MutableSourcePlan>, SQLError> {
203    Ok(match (original, input) {
204        (Some(original), Some(input)) => Some(MutableSourcePlan::cross_join(
205            input, original, true, control,
206        )?),
207        (original, None) => original,
208        (None, input) => input,
209    })
210}
211
212fn add_condition(
213    original: Option<OwnedScalarExpr>,
214    arena: &mut ScalarQueryArena,
215    condition: MutableExpressionPlan,
216    control: &ProductionControl<'_>,
217) -> Result<Option<OwnedScalarExpr>, SQLError> {
218    let condition = arena.append_expression(condition, control)?;
219    Ok(Some(match original {
220        Some(original) => {
221            OwnedScalarExpr::boolean([original, condition].into_iter(), true, control)?
222        }
223        None => condition,
224    }))
225}