Skip to main content

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

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Independent query inputs for the original INSERT and each view/rule relation.
8
9use super::{
10    add_condition, projection_block, BTreeSet, Expr, InternalRelationId, ProjectionPlan, QueryPlan,
11    RelationalPlan, RuleQueryResolver, SQLError, ScalarExpr, SourcePlan,
12};
13use crate::{
14    ast::{BooleanTest, FunctionBinding, FunctionDispatch, FunctionOrderSyntax, RuleEvent},
15    plan::InsertPlan,
16    semantics::rules::{action_binding::bind_rule_expr_scoped, analysis::RuleAnalysisContext},
17};
18
19pub struct InsertRuleQueries {
20    pub original: Option<Box<QueryPlan>>,
21    /// Outermost view first; INSERT executes these actions in reverse order after its original query.
22    pub relations: Vec<InsertPlan>,
23}
24
25impl InsertRuleQueries {
26    pub fn bind(
27        context: RuleAnalysisContext<'_>,
28        insert: &InsertPlan,
29        subjects: &dyn Fn(&str) -> Result<crate::catalog::roles::RoleReference, SQLError>,
30        input_subject: &crate::catalog::roles::RoleReference,
31    ) -> Result<Self, SQLError> {
32        let mut first = relation_plan(insert, insert.view_rule_insert_plans.first());
33        let mut values = super::values::ValuesInput::describe(&first)?;
34        let mut source = if let Some(values) = &values {
35            values.source(context, &mut first)?
36        } else {
37            insert.source.clone().expect("INSERT query input")
38        };
39        source
40            .relation_privilege_subject
41            .get_or_insert(input_subject.clone());
42        let mut relations = Vec::new();
43        for layer in &insert.view_rule_insert_plans {
44            let mut plan = relation_plan(insert, Some(layer));
45            plan.source = Some(source);
46            if let Some(values) = &mut values {
47                values.project_layer(context, &mut plan)?;
48            }
49            let original = original_query(context, &plan, subjects)?;
50            relations.push(plan);
51            let Some(original) = original else {
52                return Ok(Self {
53                    original: None,
54                    relations,
55                });
56            };
57            source = original;
58        }
59        let mut plan = relation_plan(insert, None);
60        plan.source = Some(source);
61        if let Some(values) = &mut values {
62            values.project_layer(context, &mut plan)?;
63        }
64        let original = original_query(context, &plan, subjects)?;
65        relations.push(plan);
66        let original = if let Some(values) = &values {
67            original.map(|query| values.finish(query))
68        } else {
69            original
70        };
71        Ok(Self {
72            original,
73            relations,
74        })
75    }
76}
77
78fn relation_plan(
79    insert: &InsertPlan,
80    layer: Option<&crate::plan::ViewRuleInsertPlan>,
81) -> InsertPlan {
82    let mut plan = insert.clone();
83    plan.view_rule_insert_plans.clear();
84    plan.view_rule_relations.clear();
85    let Some(layer) = layer else {
86        return plan;
87    };
88    plan.table.clone_from(&layer.relation);
89    plan.target_qualifier.clone_from(&layer.relation);
90    plan.columns = layer
91        .supplied_columns
92        .iter()
93        .zip(&insert.columns)
94        .map(|(name, target)| {
95            let mut target = target.clone();
96            target.column.clone_from(name);
97            target
98        })
99        .collect();
100    plan.returning.clear();
101    if let Some(returning) = &insert.view_rule_returning {
102        if returning.relation == layer.relation {
103            plan.target_qualifier
104                .clone_from(&returning.target_qualifier);
105            plan.returning.clone_from(&returning.returning);
106            plan.returning_aliases.clone_from(&returning.aliases);
107            plan.subqueries.clone_from(&returning.subqueries);
108        }
109    }
110    plan
111}
112
113fn original_query(
114    context: RuleAnalysisContext<'_>,
115    insert: &InsertPlan,
116    subjects: &dyn Fn(&str) -> Result<crate::catalog::roles::RoleReference, SQLError>,
117) -> Result<Option<Box<QueryPlan>>, SQLError> {
118    let rules = context.rules.rules_for(&insert.table, RuleEvent::Insert)?;
119    if rules
120        .iter()
121        .any(|rule| rule.definition.instead && rule.definition.condition.is_none())
122    {
123        return Ok(None);
124    }
125    let conditions = rules
126        .iter()
127        .filter(|rule| rule.definition.instead)
128        .filter_map(|rule| rule.definition.condition.as_ref())
129        .collect::<Vec<_>>();
130    if conditions.is_empty() {
131        return Ok(insert.source.clone());
132    }
133    let subject = subjects(&insert.table)?;
134    let relation = InternalRelationId::allocate();
135    let mut resolver = RuleQueryResolver::from_insert(context, insert, relation)?;
136    let source = insert.source.as_deref().expect("INSERT query input");
137    let mut block = original_block(insert, source, relation, resolver.columns.len())?;
138    for condition in conditions {
139        let expression = bind_rule_expr_scoped(condition, &mut resolver, &BTreeSet::new())?;
140        let binding =
141            FunctionBinding::dispatched(FunctionDispatch::BooleanTest(BooleanTest::IsNotTrue));
142        add_condition(
143            &mut block.r#where,
144            &mut block.subqueries,
145            Some(Expr::Func {
146                order_syntax: FunctionOrderSyntax::Ordinary,
147                name: binding.name.clone(),
148                binding: Some(binding),
149                args: vec![expression],
150                distinct: false,
151                order_by: Vec::new(),
152                filter: None,
153            }),
154            Some(&subject),
155        );
156    }
157    if let Some(predicate) = block.r#where.take() {
158        let mut expression = crate::plan::ExpressionPlan {
159            scalar: predicate,
160            subqueries: std::mem::take(&mut block.subqueries),
161        };
162        crate::plan::input_projection::substitute_expression_inputs(
163            &mut expression,
164            &resolver.expressions,
165        )?;
166        block.r#where = Some(expression.scalar);
167        block.subqueries = expression.subqueries;
168    }
169    Ok(Some(Box::new(QueryPlan {
170        analyzed_output: source.analyzed_output.clone(),
171        analyzed_source: None,
172        analyzed_grouping: None,
173        relation_privilege_subject: source.relation_privilege_subject.clone(),
174        relations_bound: insert.relations_bound,
175        ctes: Vec::new(),
176        root: RelationalPlan::QueryBlock(Box::new(block)),
177    })))
178}
179
180fn original_block(
181    insert: &InsertPlan,
182    source: &QueryPlan,
183    relation: InternalRelationId,
184    default_width: usize,
185) -> Result<crate::plan::QueryBlockPlan, SQLError> {
186    let width = source.analyzed_output.as_ref().map_or_else(
187        || match &source.root {
188            RelationalPlan::QueryBlock(block) => block.projections.len(),
189            RelationalPlan::Values { rows, .. } => rows.first().map_or(0, Vec::len),
190            RelationalPlan::SetOp { .. } => {
191                if insert.columns.is_empty() {
192                    default_width
193                } else {
194                    insert.columns.len()
195                }
196            }
197        },
198        crate::RowSchema::len,
199    );
200    let inline = insert
201        .rule_values_input
202        .as_ref()
203        .is_some_and(crate::plan::RuleValuesInput::is_inline);
204    let mut block = if inline {
205        let RelationalPlan::QueryBlock(block) = &source.root else {
206            return Err(SQLError::Internal(
207                "rule target list lost its query block".into(),
208            ));
209        };
210        (**block).clone()
211    } else {
212        projection_block(
213            (0..width)
214                .map(|position| ProjectionPlan {
215                    expr: ScalarExpr::InternalColumn(relation.column(position)),
216                    alias: None,
217                })
218                .collect(),
219        )
220    };
221    if !inline {
222        block.from = Some(SourcePlan::Subquery {
223            captured_output: Some(relation),
224            lateral: false,
225            body: Box::new(source.clone()),
226            alias: None,
227            column_aliases: Vec::new(),
228        });
229    }
230    Ok(block)
231}