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.column.clone()),
88    );
89    for assignment in &stmt.assignments {
90        if !collect_view_expression_columns(&assignment.value, &mut columns) {
91            return Ok(None);
92        }
93    }
94    if let Some(predicate) = stmt.predicate.as_ref() {
95        if !collect_view_expression_columns(predicate, &mut columns) {
96            return Ok(None);
97        }
98    }
99    Ok(Some(columns))
100}
101
102pub fn required_view_delete_columns(
103    analysis: RuleAnalysisContext<'_>,
104    target: &ViewMutationTarget,
105    stmt: &DeletePlan,
106) -> Result<Option<BTreeSet<String>>, SQLError> {
107    let Some(mut columns) = super::rules::analysis::relation_rule_row_columns(
108        analysis,
109        &target.canonical_name,
110        crate::ast::RuleEvent::Delete,
111    )?
112    else {
113        return Ok(None);
114    };
115    if let Some(predicate) = stmt.predicate.as_ref() {
116        if !collect_view_expression_columns(predicate, &mut columns) {
117            return Ok(None);
118        }
119    }
120    Ok(Some(columns))
121}
122
123pub fn target_columns(
124    target: &ViewMutationTarget,
125    explicit: &[String],
126    operation: &str,
127) -> Result<Vec<String>, SQLError> {
128    let columns = if explicit.is_empty() {
129        target.columns.clone()
130    } else {
131        explicit.to_vec()
132    };
133    let mut seen = BTreeSet::new();
134    for column in &columns {
135        if !seen.insert(column) {
136            return Err(SQLError::Routine {
137                sqlstate: "42701".into(),
138                message: format!("column \"{column}\" specified more than once"),
139            });
140        }
141        if !target.columns.contains(column) {
142            return Err(SQLError::UnknownColumn(format!(
143                "{}.{column}",
144                target.canonical_name
145            )));
146        }
147    }
148    if columns.is_empty() {
149        return Err(SQLError::Unsupported(format!(
150            "{operation} against a zero-column view is not supported"
151        )));
152    }
153    Ok(columns)
154}
155
156pub fn view_qualification_references_target(
157    target: &ViewMutationTarget,
158    target_qualifier: &str,
159    predicate: Option<&ScalarExpr>,
160) -> bool {
161    let Some(predicate) = predicate else {
162        return false;
163    };
164    if super::expr_contains_subquery(predicate) {
165        return true;
166    }
167    if super::expr_qualifiers(predicate).iter().any(|qualifier| {
168        qualifier.eq_ignore_ascii_case(target_qualifier)
169            || qualifier.eq_ignore_ascii_case(&target.canonical_name)
170    }) {
171        return true;
172    }
173    if !super::expr_has_unqualified_column(predicate) {
174        return false;
175    }
176    let mut columns = BTreeSet::new();
177    !predicate.collect_columns(&mut columns)
178        || columns.iter().any(|column| target.columns.contains(column))
179}
180
181pub fn coerce_view_value(
182    assignment: &dyn crate::assignment::AssignmentContext,
183    target: &ViewMutationTarget,
184    position: usize,
185    value: Value,
186) -> Result<Value, SQLError> {
187    match target.types[position].as_ref() {
188        Some(ty) => crate::assignment::conversion::convert_value_to_column_type_with_context(
189            assignment, value, ty,
190        ),
191        None => Ok(value),
192    }
193}
194
195pub fn validate_view_merge_targets(
196    target: &ViewMutationTarget,
197    plan: &MergePlan,
198) -> Result<(), SQLError> {
199    for clause in &plan.when_clauses {
200        match clause {
201            MergeWhenPlan::UpdateMatched { assignments, .. }
202            | MergeWhenPlan::UpdateNotMatchedBySource { assignments, .. } => {
203                let columns = assignments
204                    .iter()
205                    .map(|assignment| assignment.column.clone())
206                    .collect::<Vec<_>>();
207                let _ = target_columns(target, &columns, "UPDATE")?;
208            }
209            MergeWhenPlan::InsertNotMatched {
210                columns, values, ..
211            } => {
212                let implicit = columns.is_empty();
213                let columns = target_columns(target, columns, "INSERT")?;
214                if values.len() > columns.len() || (!implicit && values.len() != columns.len()) {
215                    return Err(SQLError::TypeMismatch(format!(
216                        "MERGE INSERT row width {} != column count {}",
217                        values.len(),
218                        columns.len()
219                    )));
220                }
221            }
222            _ => {}
223        }
224    }
225    Ok(())
226}
227
228pub fn validate_view_merge_contract(
229    rewrite: ViewRewriteContext<'_>,
230    target: &ViewMutationTarget,
231    plan: &MergePlan,
232    params: &[crate::SQLParam],
233    bindings: &crate::binding::context::BindingContext<'_>,
234) -> Result<(), SQLError> {
235    validate_view_merge_targets(target, plan)?;
236    let source = crate::binding::analyze_source_plan_schema(
237        rewrite.catalog,
238        &plan.source,
239        params,
240        bindings,
241        None,
242    )?;
243    super::view_rewrite::validate_public_merge_targets(rewrite, plan)?;
244    super::view_rewrite::validate_public_merge_contract(rewrite, plan, &source)?;
245    super::returning::validate_returning_alias_relations(
246        &plan.target_qualifier,
247        &plan.returning_aliases,
248        Some(&source),
249    )?;
250    let target_schema = crate::RowSchema::with_qualified_types(
251        &plan.target_qualifier,
252        target.columns.clone(),
253        target.types.clone(),
254    );
255    super::merge::validate_merge_action_scopes(
256        rewrite.catalog,
257        plan,
258        &target_schema,
259        &source,
260        params,
261        bindings,
262    )
263}
uqa_sql/semantics/view_mutation.rs

uqa_sql/semantics/
view_mutation.rs
