uqa_sql/semantics/rules/binding/actions/query/
owned.rs1use 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 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}