uqa_sql/semantics/rules/binding/actions/query/resolver/
conditions.rs1use super::{insert_expression, OwnedRuleQueryResolver};
10use crate::{
11 ast::ColumnDef,
12 binding::stored_routines::analysis::CatalogRoutineAnalysisContext,
13 catalog::{events::StoredRule, roles::RoleReference},
14 plan::{
15 input_projection::substitute_expression_inputs_owned, ExpressionPlan,
16 MutableExecutablePlan, MutableExpressionPlan,
17 },
18 plpgsql::{RewriteReference, VariableResolver},
19 SQLError, ScalarExpr,
20};
21use uqa_core::memory::{OwnedMap, ProductionControl, ProductionMap};
22
23impl OwnedRuleQueryResolver {
24 pub fn condition_with_control(
25 &mut self,
26 catalog: CatalogRoutineAnalysisContext<'_>,
27 rule: &StoredRule,
28 columns: &[ColumnDef],
29 subject: &RoleReference,
30 control: &ProductionControl<'_>,
31 ) -> Result<Option<MutableExpressionPlan>, SQLError> {
32 control.check()?;
33 if rule.definition.condition.is_none() {
34 return Ok(None);
35 }
36 let (original, binding) = rule.bound_condition_plan().ok_or_else(|| {
37 SQLError::Internal("stored rule condition has not been analyzed".into())
38 })?;
39 let (binding, mut condition) = binding.refresh_columns_with_control(
40 columns,
41 original.copy_for_rewrite(control)?,
42 control,
43 )?;
44 if crate::semantics::rules::action_binding::rule_condition_plan_references_whole_row(
45 original,
46 ) {
47 condition = catalog.bind_rule_inputs_owned(
48 condition,
49 &binding,
50 &self.table,
51 columns,
52 control,
53 )?;
54 }
55 for index in 0..condition.queries().len() {
56 condition = condition.map_query(index, control, |query| {
57 let plan =
58 MutableExecutablePlan::Query(query).mark_catalog_relations_bound(control)?;
59 let MutableExecutablePlan::Query(query) = plan else {
60 unreachable!()
61 };
62 query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
63 })?;
64 }
65 let mut selected = ProductionMap::new(*control);
66 let mut inspect = |scalar: &ScalarExpr| {
67 scalar.try_visit(&mut |node| {
68 control.check()?;
69 if let ScalarExpr::InternalColumn(column) = node {
70 if binding.column_name(*column).is_some() {
71 selected.insert_copy(*column, ())?;
72 }
73 }
74 Ok::<_, SQLError>(true)
75 })
76 };
77 inspect(condition.scalar())?;
78 for query in condition.queries() {
79 let mut result = Ok(());
80 query.visit_scalar_expressions(&mut |scalar| {
81 if result.is_ok() {
82 result = inspect(scalar);
83 }
84 });
85 result?;
86 }
87 let mut replacements = OwnedMap::new();
88 for (column, ()) in &selected {
89 let side = if Some(column.relation()) == binding.old_relation() {
90 "old"
91 } else {
92 "new"
93 };
94 let name = binding
95 .column_name(*column)
96 .expect("condition binding owns its referenced column");
97 let expression = self
98 .rewrite_with_control(
99 RewriteReference::Qualified {
100 qualifier: side,
101 column: name,
102 },
103 control,
104 )?
105 .ok_or_else(|| SQLError::UnknownColumn(format!("{side}.{name}")))?;
106 let expression = ExpressionPlan::lower_borrowed_for_rewrite(&expression, control)?;
107 let expression =
108 substitute_expression_inputs_owned(expression, &self.expressions, control)?;
109 insert_expression(
110 &mut replacements,
111 *column,
112 expression.finish(control)?,
113 control,
114 )?;
115 }
116 Ok(Some(substitute_expression_inputs_owned(
117 condition,
118 &replacements,
119 control,
120 )?))
121 }
122}