uqa_sql/semantics/
view_mutation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! View mutation target identity, declared columns, and rewrite-rule input analysis.
8use super::{
9    rules::analysis::RuleAnalysisContext,
10    view_rewrite::context::{stored_view_schema, ViewRewriteContext},
11};
12use crate::{
13    catalog::stored_view::StoredView,
14    plan::{DeletePlan, MergePlan, MergeWhenPlan, UpdatePlan},
15    ColumnType, SQLError, ScalarExpr,
16};
17use std::collections::BTreeSet;
18use uqa_core::Value;
19
20pub struct ViewMutationTarget {
21    pub canonical_name: String,
22    pub definition: StoredView,
23    pub columns: Vec<String>,
24    pub types: Vec<Option<ColumnType>>,
25}
26
27pub fn resolve_view_target(
28    context: ViewRewriteContext<'_>,
29    name: &str,
30) -> Result<ViewMutationTarget, SQLError> {
31    let canonical_name = context
32        .catalog
33        .try_resolve_view_name(name)
34        .map_err(|error| SQLError::Internal(format!("resolve DML view `{name}`: {error}")))?
35        .ok_or_else(|| SQLError::UnknownTable(name.to_string()))?;
36    let definition = context
37        .authorization
38        .view_definition(&canonical_name)?
39        .ok_or_else(|| SQLError::UnknownTable(name.to_string()))?;
40    if definition.kind != crate::catalog::view::StoredViewKind::View {
41        return Err(SQLError::Routine {
42            sqlstate: "42809".into(),
43            message: format!("relation \"{canonical_name}\" is not a view"),
44        });
45    }
46    let schema = stored_view_schema(context, &definition.rewrite_definition())?;
47    let columns = schema
48        .columns()
49        .iter()
50        .enumerate()
51        .map(|(position, column)| schema.public_name(position).unwrap_or(column).to_string())
52        .collect::<Vec<_>>();
53    let types = (0..columns.len())
54        .map(|position| schema.column_type(position).cloned())
55        .collect();
56    Ok(ViewMutationTarget {
57        canonical_name,
58        definition,
59        columns,
60        types,
61    })
62}
63
64fn collect_view_expression_columns(
65    expression: &ScalarExpr,
66    columns: &mut BTreeSet<String>,
67) -> bool {
68    expression.collect_columns(columns)
69}
70
71pub fn required_view_update_columns(
72    analysis: RuleAnalysisContext<'_>,
73    target: &ViewMutationTarget,
74    stmt: &UpdatePlan,
75) -> Result<Option<BTreeSet<String>>, SQLError> {
76    let Some(mut columns) = super::rules::analysis::relation_rule_row_columns(
77        analysis,
78        &target.canonical_name,
79        crate::ast::RuleEvent::Update,
80    )?
81    else {
82        return Ok(None);
83    };
84    columns.extend(
85        stmt.assignments
86            .iter()
87            .map(|assignment| assignment.target.column.clone()),
88    );
89    for expression in stmt
90        .assignments
91        .iter()
92        .flat_map(crate::plan::AssignmentPlan::expressions)
93    {
94        if !collect_view_expression_columns(expression, &mut columns) {
95            return Ok(None);
96        }
97    }
98    if let Some(predicate) = stmt.predicate.as_ref() {
99        if !collect_view_expression_columns(predicate, &mut columns) {
100            return Ok(None);
101        }
102    }
103    Ok(Some(columns))
104}
105
106pub fn required_view_delete_columns(
107    analysis: RuleAnalysisContext<'_>,
108    target: &ViewMutationTarget,
109    stmt: &DeletePlan,
110) -> Result<Option<BTreeSet<String>>, SQLError> {
111    let Some(mut columns) = super::rules::analysis::relation_rule_row_columns(
112        analysis,
113        &target.canonical_name,
114        crate::ast::RuleEvent::Delete,
115    )?
116    else {
117        return Ok(None);
118    };
119    if let Some(predicate) = stmt.predicate.as_ref() {
120        if !collect_view_expression_columns(predicate, &mut columns) {
121            return Ok(None);
122        }
123    }
124    Ok(Some(columns))
125}
126
127pub fn target_columns(
128    target: &ViewMutationTarget,
129    explicit: &[crate::ast::AssignmentTarget<ScalarExpr>],
130    operation: &str,
131) -> Result<Vec<crate::ast::AssignmentTarget<ScalarExpr>>, SQLError> {
132    let columns = if explicit.is_empty() {
133        target.columns.iter().cloned().map(Into::into).collect()
134    } else {
135        explicit.to_vec()
136    };
137    crate::assignment::targets::validate_repeated_targets(&columns, operation == "INSERT")?;
138    for column in &columns {
139        if !target.columns.contains(&column.column) {
140            return Err(SQLError::UnknownColumn(format!(
141                "{}.{}",
142                target.canonical_name, column.column
143            )));
144        }
145    }
146    if columns.is_empty() {
147        return Err(SQLError::Unsupported(format!(
148            "{operation} against a zero-column view is not supported"
149        )));
150    }
151    Ok(columns)
152}
153
154pub fn view_qualification_references_target(
155    target: &ViewMutationTarget,
156    target_qualifier: &str,
157    predicate: Option<&ScalarExpr>,
158) -> bool {
159    let Some(predicate) = predicate else {
160        return false;
161    };
162    if super::expr_contains_subquery(predicate) {
163        return true;
164    }
165    if super::expr_qualifiers(predicate).iter().any(|qualifier| {
166        qualifier.eq_ignore_ascii_case(target_qualifier)
167            || qualifier.eq_ignore_ascii_case(&target.canonical_name)
168    }) {
169        return true;
170    }
171    if !super::expr_has_unqualified_column(predicate) {
172        return false;
173    }
174    let mut columns = BTreeSet::new();
175    !predicate.collect_columns(&mut columns)
176        || columns.iter().any(|column| target.columns.contains(column))
177}
178
179pub fn coerce_view_value(
180    assignment: &dyn crate::assignment::AssignmentContext,
181    target: &ViewMutationTarget,
182    position: usize,
183    value: Value,
184) -> Result<Value, SQLError> {
185    match target.types[position].as_ref() {
186        Some(ty) => crate::assignment::conversion::convert_value_to_column_type_with_context(
187            assignment, value, ty,
188        ),
189        None => Ok(value),
190    }
191}
192
193pub fn validate_view_merge_targets(
194    target: &ViewMutationTarget,
195    plan: &MergePlan,
196) -> Result<(), SQLError> {
197    for clause in &plan.when_clauses {
198        match clause {
199            MergeWhenPlan::UpdateMatched { assignments, .. }
200            | MergeWhenPlan::UpdateNotMatchedBySource { assignments, .. } => {
201                let columns = assignments
202                    .iter()
203                    .map(|assignment| assignment.target.clone())
204                    .collect::<Vec<_>>();
205                let _ = target_columns(target, &columns, "UPDATE")?;
206            }
207            MergeWhenPlan::InsertNotMatched {
208                columns, values, ..
209            } => {
210                let implicit = columns.is_empty();
211                let columns = target_columns(target, columns, "INSERT")?;
212                if values.len() > columns.len() || (!implicit && values.len() != columns.len()) {
213                    return Err(SQLError::TypeMismatch(format!(
214                        "MERGE INSERT row width {} != column count {}",
215                        values.len(),
216                        columns.len()
217                    )));
218                }
219            }
220            _ => {}
221        }
222    }
223    Ok(())
224}
225
226pub fn validate_view_merge_contract(
227    rewrite: ViewRewriteContext<'_>,
228    target: &ViewMutationTarget,
229    plan: &MergePlan,
230    params: &[crate::SQLParam],
231    bindings: &crate::binding::context::BindingContext<'_>,
232) -> Result<(), SQLError> {
233    validate_view_merge_targets(target, plan)?;
234    let source = crate::binding::analyze_source_plan_schema(
235        rewrite.catalog,
236        &plan.source,
237        params,
238        bindings,
239        None,
240    )?;
241    super::view_rewrite::validate_public_merge_targets(rewrite, plan)?;
242    super::view_rewrite::validate_public_merge_contract(rewrite, plan, &source)?;
243    super::returning::validate_returning_alias_relations(
244        &plan.target_qualifier,
245        &plan.returning_aliases,
246        Some(&source),
247    )?;
248    let target_schema = crate::RowSchema::with_qualified_types(
249        &plan.target_qualifier,
250        target.columns.clone(),
251        target.types.clone(),
252    );
253    super::merge::validate_merge_action_scopes(
254        rewrite.catalog,
255        plan,
256        &target_schema,
257        &source,
258        params,
259        bindings,
260    )
261}
uqa_sql/semantics/view_mutation.rs

uqa_sql/semantics/
view_mutation.rs
