Skip to main content

uqa_sql/semantics/
view_rewrite.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! `PostgreSQL` 18 automatically updatable view analysis and DML rewriting.
8
9use std::collections::{BTreeMap, BTreeSet};
10
11use crate::ast::{ReturningAliases, TriggerEvent, TriggerTiming};
12use crate::plan::{
13    AssignmentPlan, ComputePlan, ConflictActionPlan, ConflictPlan, DeletePlan, InsertPlan,
14    MergePlan, MergeWhenPlan, ProjectionPlan, QueryPlan, RelationalPlan, SourcePlan, UpdatePlan,
15    ViewCheckPlan, ViewRuleInsertPlan, ViewRuleReturningPlan, ViewRuleUpdatePlan,
16};
17use crate::SQLError;
18use crate::{ColumnIdentity, RowSchema, ScalarExpr};
19
20use crate::{
21    catalog::view::{StoredViewKind, ViewRewriteDefinition as StoredView},
22    RelationIdentity,
23};
24
25use crate::binding::snapshot::BindingSnapshot as CteScope;
26pub mod context;
27use context::{stored_view_schema, ViewRewriteContext};
28
29mod captured_projection;
30mod correlation;
31pub use captured_projection::{capture_view_projection, CapturedViewProjection};
32mod deferred;
33pub use deferred::{
34    bind_outer_rewrite_scope, resolve_outer_expression_rewrites, resolve_outer_rewrites,
35    resolve_outer_source_rewrites, resolve_outer_sources, DeferredOuterRewrite,
36};
37mod layer_privileges;
38mod returning;
39mod rewrite_insert;
40mod rewrite_merge;
41mod rewrite_update_delete;
42pub mod rule_inputs;
43mod updatability;
44mod validation;
45
46use correlation::{
47    collect_expression_subquery_ids, delete_ordinary_subquery_ids, dml_analysis_scope,
48    dml_source_schema, insert_conflict_subquery_ids, insert_input_width,
49    merge_matched_subquery_ids, merge_target_only_subquery_ids, returning_subquery_ids,
50    rewrite_correlated_dml_context, schema_public_columns, update_ordinary_subquery_ids,
51    validate_delete_expressions, validate_insert_expressions, validate_merge_expressions,
52    validate_update_expressions, CorrelatedDmlContext,
53};
54use layer_privileges::LayerPrivileges;
55use returning::{
56    add_check_option, bind_unqualified_source_positions, combine_view_predicate, dml_target_width,
57    finalize_source_returning, instead_of_trigger_definition, preserve_view_rule_returning,
58    record_view_rule_relation, retarget_source_expression, rewrite_existing_view_checks,
59    rewrite_merge_returning, rewrite_returning, rewrite_target_expression,
60};
61pub use rewrite_insert::rewrite_insert_to_base;
62pub use rewrite_merge::rewrite_merge_to_base;
63pub use rewrite_update_delete::{
64    rewrite_delete_rule_inputs, rewrite_delete_to_base, rewrite_update_rule_inputs,
65    rewrite_update_to_base,
66};
67pub use rule_inputs::{rule_input_requirements, validate_grouped_rule_inputs};
68pub use updatability::NotUpdatableReason;
69use updatability::{view_not_updatable, ColumnRestriction, ColumnWrite, ViewCommand};
70use validation::{
71    duplicate_assignment, duplicate_insert_column, layer_column, validate_direct_view_rule_path,
72    validate_insert_targets, validate_mapped_columns, validate_merge_targets,
73    validate_public_delete_contract, validate_public_insert_contract,
74    validate_public_update_contract, validate_public_view_targets, validate_update_targets,
75    validate_view_expression, validate_writable_columns, writable_column, ExpressionScope,
76};
77pub use validation::{merge_view_target_path, MergeViewTargetPath};
78pub use validation::{validate_public_merge_contract, validate_public_merge_targets};
79
80#[derive(Debug, Clone, Copy, PartialEq, Eq)]
81pub enum ViewCheckOption {
82    None,
83    Local,
84    Cascaded,
85}
86
87impl ViewCheckOption {
88    fn from_options(options: &[(String, String)]) -> Self {
89        options
90            .iter()
91            .rev()
92            .find(|(name, _)| name == "check_option")
93            .map_or(Self::None, |(_, value)| match value.as_str() {
94                "local" => Self::Local,
95                "cascaded" => Self::Cascaded,
96                _ => Self::None,
97            })
98    }
99
100    const fn catalog_value(self) -> &'static str {
101        match self {
102            Self::None => "NONE",
103            Self::Local => "LOCAL",
104            Self::Cascaded => "CASCADED",
105        }
106    }
107}
108
109#[derive(Debug, Clone)]
110pub struct ViewColumn {
111    pub name: String,
112    pub collation_oid: Option<u32>,
113    pub expression: ScalarExpr,
114    pub writable_source_column: Option<String>,
115}
116
117#[derive(Debug, Clone)]
118pub struct AutomaticViewLayer {
119    pub canonical_name: String,
120    pub source_name: String,
121    pub source_qualifier: String,
122    pub source_column_map: BTreeMap<String, String>,
123    pub source_include_descendants: bool,
124    pub source_schema: RowSchema,
125    pub columns: Vec<ViewColumn>,
126    pub predicate: Option<ScalarExpr>,
127    pub subqueries: Vec<QueryPlan>,
128    pub check_option: ViewCheckOption,
129}
130
131impl AutomaticViewLayer {
132    pub fn physical_source_column<'a>(&'a self, column: &'a str) -> &'a str {
133        self.source_column_map
134            .get(column)
135            .map_or(column, String::as_str)
136    }
137
138    /// Whether a column of the view is a column of its base relation, which INSERT and UPDATE need and DELETE does not.
139    pub fn has_writable_column(&self) -> bool {
140        self.columns
141            .iter()
142            .any(|column| column.writable_source_column.is_some())
143    }
144
145    /// Why `column`, which is not a column of the base relation, cannot be written, as `view_col_is_auto_updatable` reports it.
146    fn column_restriction(&self, column: &ViewColumn) -> ColumnRestriction {
147        let name = match &column.expression {
148            ScalarExpr::Column(name) => Some(name),
149            ScalarExpr::QualifiedColumn { qualifier, column }
150                if source_qualifier_matches(
151                    qualifier,
152                    &self.source_qualifier,
153                    &self.source_name,
154                ) =>
155            {
156                Some(column)
157            }
158            _ => None,
159        };
160        if name.is_some_and(|name| {
161            crate::schema::columns::POSTGRES_SYSTEM_COLUMNS.contains(&name.as_str())
162        }) {
163            ColumnRestriction::SystemColumn
164        } else {
165            ColumnRestriction::Computed
166        }
167    }
168}
169
170/// What `view_query_is_auto_updatable` finds in a view's own query, short of its test for an updatable column, which depends on the command.
171pub enum ViewQueryShape {
172    Updatable(Box<AutomaticViewLayer>),
173    NotUpdatable(NotUpdatableReason),
174}
175
176pub use crate::catalog::view::ViewMutationCapabilities;
177
178#[derive(Debug, Clone)]
179pub struct ViewUpdatability {
180    pub automatic: ViewMutationCapabilities,
181    runtime: ViewMutationCapabilities,
182    runtime_insert_columns: Vec<bool>,
183    runtime_columns: Vec<bool>,
184    pub catalog: ViewMutationCapabilities,
185    catalog_insert_columns: Vec<bool>,
186    pub catalog_columns: Vec<bool>,
187    pub check_option: String,
188}
189
190fn display_relation(name: &str) -> String {
191    RelationIdentity::from_legacy_name(name)
192        .map_or_else(|_| name.to_string(), |relation| relation.name)
193}
194
195pub fn relation_columns(
196    services: ViewRewriteContext<'_>,
197    relation: &str,
198) -> Result<Vec<String>, SQLError> {
199    if let Some(relation) = crate::catalog::VirtualRelation::from_qualified_name(relation) {
200        return Ok(relation
201            .schema()
202            .into_iter()
203            .map(|(name, _)| name)
204            .collect());
205    }
206    if let Some(view) = services.catalog.view_definition(relation)? {
207        let schema = stored_view_schema(services, &view)?;
208        return Ok(schema
209            .columns()
210            .iter()
211            .enumerate()
212            .map(|(position, column)| {
213                schema
214                    .public_name(position)
215                    .map_or_else(|| column.clone(), str::to_string)
216            })
217            .collect());
218    }
219    let definitions = services
220        .catalog
221        .try_describe_table(relation)
222        .map_err(|error| SQLError::Internal(format!("describe view source `{relation}`: {error}")))?
223        .ok_or_else(|| SQLError::UnknownTable(relation.to_string()))?;
224    if definitions.is_empty() {
225        return services
226            .catalog
227            .try_table_columns(relation)
228            .map_err(|error| {
229                SQLError::Internal(format!("describe view source `{relation}`: {error}"))
230            });
231    }
232    Ok(definitions
233        .into_iter()
234        .map(|definition| definition.name)
235        .collect())
236}
237
238fn source_qualifier_matches(qualifier: &str, source_qualifier: &str, source_name: &str) -> bool {
239    qualifier == source_qualifier
240        || qualifier == source_name
241        || RelationIdentity::from_legacy_name(source_name)
242            .is_ok_and(|identity| qualifier == identity.name)
243}
244
245fn direct_source_column(
246    expression: &ScalarExpr,
247    source_qualifier: &str,
248    source_name: &str,
249    source_columns: &BTreeMap<String, String>,
250) -> Option<String> {
251    let column = match expression {
252        ScalarExpr::Column(column) => Some(column.clone()),
253        ScalarExpr::QualifiedColumn { qualifier, column }
254            if source_qualifier_matches(qualifier, source_qualifier, source_name) =>
255        {
256            Some(column.clone())
257        }
258        _ => None,
259    }?;
260    source_columns.get(column.as_str()).cloned()
261}
262
263pub fn automatic_view_layer(
264    services: ViewRewriteContext<'_>,
265    name: &str,
266) -> Result<Option<AutomaticViewLayer>, SQLError> {
267    Ok(match view_query_shape(services, name)? {
268        Some(ViewQueryShape::Updatable(layer)) => Some(*layer),
269        Some(ViewQueryShape::NotUpdatable(_)) | None => None,
270    })
271}
272
273/// The shape of the query of view `name`, or `None` when `name` names no regular view.
274pub fn view_query_shape(
275    services: ViewRewriteContext<'_>,
276    name: &str,
277) -> Result<Option<ViewQueryShape>, SQLError> {
278    let Some(canonical_name) = services
279        .catalog
280        .try_resolve_view_name(name)
281        .map_err(|error| SQLError::Internal(format!("resolve DML view `{name}`: {error}")))?
282    else {
283        return Ok(None);
284    };
285    let definition = services
286        .catalog
287        .view_definition(&canonical_name)?
288        .ok_or_else(|| SQLError::UnknownTable(name.to_string()))?;
289    if definition.kind != StoredViewKind::View {
290        return Ok(None);
291    }
292    view_query_shape_from_definition(services, &canonical_name, &definition).map(Some)
293}
294
295/// The catalog name of view `name`.
296fn canonical_view_name(services: ViewRewriteContext<'_>, name: &str) -> Result<String, SQLError> {
297    services
298        .catalog
299        .try_resolve_view_name(name)
300        .map_err(|error| SQLError::Internal(format!("resolve DML view `{name}`: {error}")))?
301        .ok_or_else(|| SQLError::UnknownTable(name.to_string()))
302}
303
304/// The layer of view `view` that `command` is rewritten through, or the error `rewriteTargetView` reports when the view's query does not allow the rewrite.
305fn rewritable_layer(
306    services: ViewRewriteContext<'_>,
307    view: &str,
308    command: ViewCommand,
309) -> Result<AutomaticViewLayer, SQLError> {
310    match view_query_shape(services, view)? {
311        Some(ViewQueryShape::Updatable(layer)) => Ok(*layer),
312        Some(ViewQueryShape::NotUpdatable(reason)) => {
313            Err(view_not_updatable(view, command, reason))
314        }
315        None => Err(SQLError::UnknownTable(view.to_string())),
316    }
317}
318
319/// The next layer the rewrite of `command` passes through at view `view`: the first layer, checked already, while `initial` holds it; `None` where an unconditional INSTEAD rule of a view that cannot be rewritten handles the command. As `RewriteQuery` does, conditional INSTEAD rules without an unconditional one are rejected before the view's query is examined.
320fn next_rewritten_layer(
321    services: ViewRewriteContext<'_>,
322    view: &str,
323    initial: &mut Option<AutomaticViewLayer>,
324    rewrite_suppressed: bool,
325    event: crate::ast::RuleEvent,
326    command: ViewCommand,
327) -> Result<Option<AutomaticViewLayer>, SQLError> {
328    if let Some(layer) = initial.take() {
329        return Ok(Some(layer));
330    }
331    if !rewrite_suppressed {
332        validate_direct_view_rule_path(services, view, event, command)?;
333    }
334    match view_query_shape(services, view)? {
335        Some(ViewQueryShape::Updatable(layer)) => Ok(Some(*layer)),
336        shape => {
337            if active_unconditional_instead_rule(services, view, event)? {
338                return Ok(None);
339            }
340            Err(match shape {
341                Some(ViewQueryShape::NotUpdatable(reason)) => {
342                    view_not_updatable(view, command, reason)
343                }
344                _ => SQLError::UnknownTable(view.to_string()),
345            })
346        }
347    }
348}
349
350/// The reason `view_query_is_auto_updatable` finds first in the clauses of a query block, before it looks at the block's target list and source.
351fn query_block_restriction(
352    services: ViewRewriteContext<'_>,
353    query: &QueryPlan,
354    block: &crate::plan::QueryBlockPlan,
355) -> Option<NotUpdatableReason> {
356    if block.distinct || !block.distinct_on.is_empty() {
357        Some(NotUpdatableReason::Distinct)
358    } else if !block.group_by.is_empty() || !block.grouping_sets.is_empty() || block.group_distinct
359    {
360        Some(NotUpdatableReason::GroupBy)
361    } else if block.having.is_some() {
362        Some(NotUpdatableReason::Having)
363    } else if !query.ctes.is_empty() {
364        Some(NotUpdatableReason::With)
365    } else if block.limit.is_some() || block.offset.is_some() || block.with_ties {
366        Some(NotUpdatableReason::LimitOffset)
367    } else if matches!(block.compute, ComputePlan::Aggregate)
368        || (matches!(block.compute, ComputePlan::Window)
369            && crate::semantics::aggregates::has_aggregate(
370                &|name: &str| services.routines.is_registered_aggregate(name),
371                &block.projections,
372            ))
373    {
374        Some(NotUpdatableReason::Aggregate)
375    } else if matches!(block.compute, ComputePlan::Window) {
376        Some(NotUpdatableReason::Window)
377    } else {
378        None
379    }
380}
381
382#[expect(
383    clippy::too_many_lines,
384    reason = "preserves view qualifier and row identity"
385)]
386fn view_query_shape_from_definition(
387    services: ViewRewriteContext<'_>,
388    canonical_name: &str,
389    definition: &StoredView,
390) -> Result<ViewQueryShape, SQLError> {
391    let block = match &definition.query.root {
392        RelationalPlan::QueryBlock(block) => block,
393        RelationalPlan::SetOp { .. } => {
394            return Ok(ViewQueryShape::NotUpdatable(
395                NotUpdatableReason::SetOperation,
396            ))
397        }
398        RelationalPlan::Values { .. } => {
399            return Ok(ViewQueryShape::NotUpdatable(
400                NotUpdatableReason::NotSingleRelation,
401            ))
402        }
403    };
404    if let Some(reason) = query_block_restriction(services, &definition.query, block) {
405        return Ok(ViewQueryShape::NotUpdatable(reason));
406    }
407    let analysis_scope = services.catalog.binding_scope()?;
408    let source_schema = match block.from.as_ref() {
409        Some(source) => crate::semantics::view_rewrite::context::analyze_source_plan_schema(
410            services,
411            source,
412            &[],
413            &analysis_scope,
414            None,
415        )?,
416        None => RowSchema::default(),
417    };
418    let resolver = crate::binding::scoped_types::BindingTypeResolver {
419        routines: services.routines,
420        scope: &analysis_scope,
421    };
422    for projection in &block.projections {
423        if crate::semantics::sets::validation::expression_may_return_set(
424            services.routines,
425            &resolver,
426            &projection.expr,
427            &source_schema,
428            &[],
429        )? {
430            return Ok(ViewQueryShape::NotUpdatable(
431                NotUpdatableReason::SetReturning,
432            ));
433        }
434    }
435    // The base relation must be one table or view; a materialized view is neither.
436    let Some(SourcePlan::Table {
437        name: source_name,
438        qualifier,
439        alias,
440        column_aliases,
441        include_descendants,
442        ..
443    }) = block.from.as_ref()
444    else {
445        return Ok(ViewQueryShape::NotUpdatable(
446            NotUpdatableReason::NotSingleRelation,
447        ));
448    };
449    if services.catalog.target_view_kind(source_name)? == Some(StoredViewKind::Materialized) {
450        return Ok(ViewQueryShape::NotUpdatable(
451            NotUpdatableReason::NotSingleRelation,
452        ));
453    }
454    let source_qualifier = alias.as_deref().unwrap_or(qualifier).to_string();
455    let source_columns = relation_columns(services, source_name)?;
456    let mut visible_source_columns = source_columns.clone();
457    for (column, alias) in visible_source_columns.iter_mut().zip(column_aliases) {
458        column.clone_from(alias);
459    }
460    let source_column_map = visible_source_columns
461        .iter()
462        .cloned()
463        .zip(source_columns.iter().cloned())
464        .collect::<BTreeMap<_, _>>();
465    let mut expressions = Vec::new();
466    for projection in &block.projections {
467        match &projection.expr {
468            ScalarExpr::Star => {
469                expressions.extend(
470                    visible_source_columns
471                        .iter()
472                        .cloned()
473                        .map(|column| ScalarExpr::Column(column.into())),
474                );
475            }
476            ScalarExpr::QualifiedStar(star_qualifier)
477                if source_qualifier_matches(star_qualifier, &source_qualifier, source_name) =>
478            {
479                expressions.extend(visible_source_columns.iter().cloned().map(|column| {
480                    ScalarExpr::QualifiedColumn {
481                        qualifier: source_qualifier.clone(),
482                        column: column.into(),
483                    }
484                }));
485            }
486            expression => expressions.push(expression.clone()),
487        }
488    }
489    let schema = stored_view_schema(services, definition)?;
490    let output_columns = schema
491        .columns()
492        .iter()
493        .enumerate()
494        .map(|(position, column)| schema.public_name(position).unwrap_or(column).to_string())
495        .collect::<Vec<_>>();
496    if expressions.len() != output_columns.len() {
497        return Err(SQLError::Internal(format!(
498            "view `{canonical_name}` has {} stored projections for {} output columns",
499            expressions.len(),
500            output_columns.len()
501        )));
502    }
503    let columns = output_columns
504        .into_iter()
505        .zip(expressions)
506        .enumerate()
507        .map(|(position, (name, expression))| ViewColumn {
508            collation_oid: schema.column_collation(position),
509            writable_source_column: direct_source_column(
510                &expression,
511                &source_qualifier,
512                source_name,
513                &source_column_map,
514            ),
515            name,
516            expression,
517        })
518        .collect();
519    Ok(ViewQueryShape::Updatable(Box::new(AutomaticViewLayer {
520        canonical_name: canonical_name.to_string(),
521        source_name: source_name.clone(),
522        source_qualifier,
523        source_column_map,
524        source_include_descendants: *include_descendants,
525        source_schema,
526        columns,
527        predicate: block.r#where.clone(),
528        subqueries: block.subqueries.clone(),
529        check_option: ViewCheckOption::from_options(&definition.options),
530    })))
531}
532
533mod layer_rewrite;
534use layer_rewrite::embed_layer_expression;
535
536pub fn has_instead_of_trigger(
537    services: ViewRewriteContext<'_>,
538    view: &str,
539    event: TriggerEvent,
540) -> Result<bool, SQLError> {
541    let Some(canonical) = services
542        .catalog
543        .try_resolve_view_name(view)
544        .map_err(|error| SQLError::Internal(format!("resolve DML view `{view}`: {error}")))?
545    else {
546        return Ok(false);
547    };
548    instead_of_trigger_definition(services, &canonical, event)
549}
550
551#[expect(
552    clippy::too_many_lines,
553    reason = "preserves view qualifier and row identity"
554)]
555fn view_updatability_inner(
556    services: ViewRewriteContext<'_>,
557    name: &str,
558    visited: &mut BTreeSet<String>,
559) -> Result<ViewUpdatability, SQLError> {
560    let definition = services
561        .catalog
562        .view_definition(name)?
563        .ok_or_else(|| SQLError::UnknownTable(name.to_string()))?;
564    let schema = stored_view_schema(services, &definition)?;
565    let width = schema.len();
566    let check_option = ViewCheckOption::from_options(&definition.options)
567        .catalog_value()
568        .to_string();
569    let mut automatic = ViewMutationCapabilities::default();
570    let mut automatic_insert_columns = vec![false; width];
571    let mut automatic_columns = vec![false; width];
572    let mut projected_catalog = ViewMutationCapabilities::default();
573    let mut projected_catalog_insert_columns = vec![false; width];
574    let mut projected_catalog_columns = vec![false; width];
575    if let Some(layer) = automatic_view_layer(services, name)? {
576        if visited.insert(layer.canonical_name.clone()) {
577            if services
578                .catalog
579                .view_definition(&layer.source_name)?
580                .is_some()
581            {
582                let source = view_updatability_inner(services, &layer.source_name, visited)?;
583                let source_columns = relation_columns(services, &layer.source_name)?;
584                let mapped = |source_capabilities: &[bool]| {
585                    layer
586                        .columns
587                        .iter()
588                        .map(|column| {
589                            column.writable_source_column.as_ref().is_some_and(|name| {
590                                source_columns
591                                    .iter()
592                                    .position(|candidate| candidate == name)
593                                    .is_some_and(|position| {
594                                        source_capabilities.get(position) == Some(&true)
595                                    })
596                            })
597                        })
598                        .collect::<Vec<_>>()
599                };
600                automatic_insert_columns = mapped(&source.runtime_insert_columns);
601                automatic_columns = mapped(&source.runtime_columns);
602                automatic = ViewMutationCapabilities {
603                    insertable: source.runtime.insertable
604                        && automatic_insert_columns.iter().any(|value| *value),
605                    updatable: source.runtime.updatable
606                        && automatic_columns.iter().any(|value| *value),
607                    deletable: source.runtime.deletable,
608                };
609                projected_catalog_insert_columns = mapped(&source.catalog_insert_columns);
610                projected_catalog_columns = mapped(&source.catalog_columns);
611                projected_catalog = ViewMutationCapabilities {
612                    insertable: source.catalog.insertable
613                        && projected_catalog_insert_columns.iter().any(|value| *value),
614                    updatable: source.catalog.updatable
615                        && projected_catalog_columns.iter().any(|value| *value),
616                    deletable: source.catalog.deletable,
617                };
618            } else {
619                automatic_insert_columns = layer
620                    .columns
621                    .iter()
622                    .map(|column| column.writable_source_column.is_some())
623                    .collect();
624                automatic_columns.clone_from(&automatic_insert_columns);
625                automatic = ViewMutationCapabilities {
626                    insertable: automatic_insert_columns.iter().any(|value| *value),
627                    updatable: automatic_columns.iter().any(|value| *value),
628                    deletable: true,
629                };
630                projected_catalog = automatic;
631                projected_catalog_insert_columns.clone_from(&automatic_insert_columns);
632                projected_catalog_columns.clone_from(&automatic_columns);
633            }
634            visited.remove(&layer.canonical_name);
635        }
636    }
637    let active_insert =
638        active_unconditional_instead_rule(services, name, crate::ast::RuleEvent::Insert)?;
639    let active_update =
640        active_unconditional_instead_rule(services, name, crate::ast::RuleEvent::Update)?;
641    let active_delete =
642        active_unconditional_instead_rule(services, name, crate::ast::RuleEvent::Delete)?;
643    let runtime = ViewMutationCapabilities {
644        insertable: automatic.insertable || active_insert,
645        updatable: automatic.updatable || active_update,
646        deletable: automatic.deletable || active_delete,
647    };
648    let runtime_insert_columns = automatic_insert_columns
649        .iter()
650        .map(|column| *column || active_insert)
651        .collect();
652    let runtime_columns = automatic_columns
653        .iter()
654        .map(|column| *column || active_update)
655        .collect();
656    let rule_insertable =
657        has_unconditional_instead_rule(services, name, crate::ast::RuleEvent::Insert)?;
658    let rule_updatable =
659        has_unconditional_instead_rule(services, name, crate::ast::RuleEvent::Update)?;
660    let rule_deletable =
661        has_unconditional_instead_rule(services, name, crate::ast::RuleEvent::Delete)?;
662    let catalog = ViewMutationCapabilities {
663        insertable: projected_catalog.insertable || rule_insertable,
664        updatable: projected_catalog.updatable || rule_updatable,
665        deletable: projected_catalog.deletable || rule_deletable,
666    };
667    let catalog_insert_columns = projected_catalog_insert_columns
668        .iter()
669        .map(|column| *column || rule_insertable)
670        .collect();
671    let catalog_columns = if catalog.fully_updatable() {
672        projected_catalog_columns
673            .iter()
674            .map(|column| *column || rule_updatable)
675            .collect()
676    } else {
677        vec![false; width]
678    };
679    Ok(ViewUpdatability {
680        automatic,
681        runtime,
682        runtime_insert_columns,
683        runtime_columns,
684        catalog,
685        catalog_insert_columns,
686        catalog_columns,
687        check_option,
688    })
689}
690
691pub fn view_updatability(
692    services: ViewRewriteContext<'_>,
693    name: &str,
694) -> Result<ViewUpdatability, SQLError> {
695    view_updatability_inner(services, name, &mut BTreeSet::new())
696}
697
698fn active_unconditional_instead_rule(
699    services: ViewRewriteContext<'_>,
700    relation: &str,
701    event: crate::ast::RuleEvent,
702) -> Result<bool, SQLError> {
703    Ok(services
704        .catalog
705        .rules_for(relation, event)?
706        .iter()
707        .any(|rule| rule.definition.instead && rule.definition.condition.is_none()))
708}
709
710fn has_unconditional_instead_rule(
711    services: ViewRewriteContext<'_>,
712    relation: &str,
713    event: crate::ast::RuleEvent,
714) -> Result<bool, SQLError> {
715    Ok(services
716        .catalog
717        .rule_definitions_for(relation, event)?
718        .iter()
719        .any(|rule| rule.definition.instead && rule.definition.condition.is_none()))
720}
721
722pub fn validate_view_definition_check_option(
723    services: ViewRewriteContext<'_>,
724    name: &str,
725    definition: &StoredView,
726) -> Result<(), SQLError> {
727    if ViewCheckOption::from_options(&definition.options) == ViewCheckOption::None {
728        return Ok(());
729    }
730    // `DefineView` reports why the view is not automatically updatable as the hint.
731    let reason = match view_query_shape_from_definition(services, name, definition)? {
732        ViewQueryShape::Updatable(layer) if layer.has_writable_column() => return Ok(()),
733        ViewQueryShape::Updatable(_) => NotUpdatableReason::NoUpdatableColumns,
734        ViewQueryShape::NotUpdatable(reason) => reason,
735    };
736    Err(SQLError::Diagnostic {
737        sqlstate: "0A000".into(),
738        message: "WITH CHECK OPTION is supported only on automatically updatable views".into(),
739        detail: None,
740        hint: Some(reason.detail().into()),
741    })
742}