Skip to main content

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, assignment and MERGE validation.
8use super::view_rewrite::context::ViewRewriteContext;
9use crate::{
10    plan::{MergePlan, MergeWhenPlan},
11    SQLError, ScalarExpr,
12};
13use uqa_core::{
14    memory::{Produced, ProductionControl},
15    Value,
16};
17
18mod production;
19
20/// A captured mutation target retains only the definition used to read rows and its public identity.
21#[derive(Debug)]
22pub struct ViewMutationTarget {
23    pub schema: crate::RowSchema,
24    pub canonical_name: String,
25    pub query: crate::plan::QueryPlan,
26    pub security: Produced<crate::catalog::security::table_binding::CapturedTablePrivileges>,
27    pub security_invoker: bool,
28    pub columns: Vec<String>,
29}
30
31pub fn resolve_view_target(
32    context: ViewRewriteContext<'_>,
33    name: &str,
34) -> Result<ViewMutationTarget, SQLError> {
35    Ok(
36        resolve_view_target_with_control(context, name, &ProductionControl::uncontrolled())?
37            .into_uncontrolled()
38            .expect("ordinary view mutation target"),
39    )
40}
41
42pub fn resolve_view_target_with_control(
43    context: ViewRewriteContext<'_>,
44    name: &str,
45    control: &ProductionControl<'_>,
46) -> Result<Produced<ViewMutationTarget>, SQLError> {
47    production::resolve(context, name, control)
48}
49
50pub fn target_columns(
51    target: &ViewMutationTarget,
52    explicit: &[crate::ast::AssignmentTarget<ScalarExpr>],
53    operation: &str,
54) -> Result<Vec<crate::ast::AssignmentTarget<ScalarExpr>>, SQLError> {
55    let columns = if explicit.is_empty() {
56        target.columns.iter().cloned().map(Into::into).collect()
57    } else {
58        explicit.to_vec()
59    };
60    crate::assignment::targets::validate_repeated_targets(&columns, operation == "INSERT")?;
61    for column in &columns {
62        if !target.columns.contains(&column.column) {
63            return Err(SQLError::UnknownColumn(format!(
64                "{}.{}",
65                target.canonical_name, column.column
66            )));
67        }
68    }
69    if columns.is_empty() {
70        return Err(SQLError::Unsupported(format!(
71            "{operation} against a zero-column view is not supported"
72        )));
73    }
74    Ok(columns)
75}
76
77pub fn coerce_view_value(
78    assignment: &dyn crate::assignment::AssignmentContext,
79    target: &ViewMutationTarget,
80    position: usize,
81    value: Value,
82) -> Result<Value, SQLError> {
83    match target.schema.column_type(position) {
84        Some(ty) => crate::assignment::conversion::convert_value_to_column_type_with_context(
85            assignment, value, ty,
86        ),
87        None => Ok(value),
88    }
89}
90
91pub fn validate_view_merge_targets(
92    target: &ViewMutationTarget,
93    plan: &MergePlan,
94) -> Result<(), SQLError> {
95    for clause in &plan.when_clauses {
96        match clause {
97            MergeWhenPlan::UpdateMatched { assignments, .. }
98            | MergeWhenPlan::UpdateNotMatchedBySource { assignments, .. } => {
99                let columns = assignments
100                    .iter()
101                    .flat_map(|assignment| assignment.target.targets().iter().cloned())
102                    .collect::<Vec<_>>();
103                let _ = target_columns(target, &columns, "UPDATE")?;
104            }
105            MergeWhenPlan::InsertNotMatched {
106                columns, values, ..
107            } => {
108                let implicit = columns.is_empty();
109                let columns = target_columns(target, columns, "INSERT")?;
110                if values.len() > columns.len() || (!implicit && values.len() != columns.len()) {
111                    return Err(SQLError::TypeMismatch(format!(
112                        "MERGE INSERT row width {} != column count {}",
113                        values.len(),
114                        columns.len()
115                    )));
116                }
117            }
118            _ => {}
119        }
120    }
121    Ok(())
122}
123
124pub fn validate_view_merge_contract(
125    rewrite: ViewRewriteContext<'_>,
126    target: &ViewMutationTarget,
127    plan: &MergePlan,
128    params: &[crate::SQLParam],
129    bindings: &crate::binding::context::BindingContext<'_>,
130) -> Result<(), SQLError> {
131    validate_view_merge_targets(target, plan)?;
132    let source = crate::binding::analyze_source_plan_schema(
133        rewrite.routines,
134        &plan.source,
135        params,
136        bindings,
137        None,
138    )?;
139    super::view_rewrite::validate_public_merge_targets(rewrite, plan)?;
140    super::view_rewrite::validate_public_merge_contract(rewrite, plan, &source)?;
141    super::returning::validate_returning_alias_relations(
142        &plan.target_qualifier,
143        &plan.returning_aliases,
144        Some(&source),
145    )?;
146    let target_schema =
147        crate::RowSchema::with_relation_qualifier(&target.schema, &plan.target_qualifier);
148    super::merge::validate_merge_action_scopes(
149        rewrite.routines,
150        plan,
151        &target_schema,
152        &source,
153        params,
154        bindings,
155    )
156}