1use 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 pub fn has_writable_column(&self) -> bool {
140 self.columns
141 .iter()
142 .any(|column| column.writable_source_column.is_some())
143 }
144
145 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
170pub 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
273pub 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
295fn 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
304fn 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
319fn 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
350fn 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 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 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}