Skip to main content

uqa_sql/catalog/
view.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use crate::semantics::sets::placement_scope::SetPlacementScope;
8use crate::{RowSchema, SQLError};
9
10mod materialized;
11pub use materialized::materialized_view_schema;
12
13/// Scanning an unpopulated materialized view fails even if the query would read no rows.
14pub fn require_materialized_view_population(name: &str, populated: bool) -> Result<(), SQLError> {
15    if populated {
16        return Ok(());
17    }
18    let (_, relation) =
19        uqa_core::RelationIdentity::parse_reference(name).map_err(SQLError::Unsupported)?;
20    Err(SQLError::Diagnostic {
21        sqlstate: "55000".into(),
22        message: format!("materialized view \"{relation}\" has not been populated"),
23        detail: None,
24        hint: Some("Use the REFRESH MATERIALIZED VIEW command.".into()),
25    })
26}
27
28pub fn create_view_output_columns(
29    schema: &RowSchema,
30    declared: &[String],
31) -> Result<Vec<String>, SQLError> {
32    if declared.len() > schema.len() {
33        return Err(SQLError::Routine {
34            sqlstate: "42601".into(),
35            message: "CREATE VIEW specifies more column names than columns".into(),
36        });
37    }
38    let columns = schema
39        .columns()
40        .iter()
41        .enumerate()
42        .map(|(position, column)| {
43            declared
44                .get(position)
45                .cloned()
46                .unwrap_or_else(|| schema.public_name(position).unwrap_or(column).to_string())
47        })
48        .collect::<Vec<_>>();
49    let mut seen = std::collections::BTreeSet::new();
50    for column in &columns {
51        if !seen.insert(column) {
52            return Err(SQLError::Routine {
53                sqlstate: "42701".into(),
54                message: format!("column \"{column}\" specified more than once"),
55            });
56        }
57    }
58    Ok(columns)
59}
60
61pub fn named_view_schema(
62    query_schema: &RowSchema,
63    output_columns: &[String],
64) -> Result<RowSchema, SQLError> {
65    if query_schema.len() != output_columns.len() {
66        return Err(SQLError::Internal(format!(
67            "stored view row type has {} columns but its query has {}",
68            output_columns.len(),
69            query_schema.len()
70        )));
71    }
72    Ok(RowSchema::with_types(
73        output_columns.to_vec(),
74        query_schema.column_types().to_vec(),
75    )
76    .with_column_collations(
77        (0..query_schema.len()).map(|index| query_schema.column_collation(index)),
78    )
79    .with_record_fields_from(query_schema))
80}
81
82pub fn validate_view_column_types(
83    query_schema: &RowSchema,
84    output_columns: &[String],
85) -> Result<(), SQLError> {
86    for (position, column) in output_columns.iter().enumerate() {
87        if let Some(ty) = query_schema.column_type(position) {
88            crate::schema::columns::validate_postgres_relation_column_type(column, ty)?;
89        }
90    }
91    Ok(())
92}
93
94#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
95pub enum StoredViewKind {
96    #[default]
97    View,
98    Materialized,
99}
100
101#[derive(Debug, Clone, Copy, Default)]
102pub struct ViewMutationCapabilities {
103    pub insertable: bool,
104    pub updatable: bool,
105    pub deletable: bool,
106}
107impl ViewMutationCapabilities {
108    pub const fn fully_updatable(self) -> bool {
109        self.updatable && self.deletable
110    }
111}
112
113#[derive(Clone)]
114pub struct ViewRewriteDefinition {
115    pub query: crate::plan::QueryPlan,
116    pub output_columns: Option<Vec<String>>,
117    pub options: Vec<(String, String)>,
118    pub kind: StoredViewKind,
119    pub materialized_column_types: Vec<Option<crate::ColumnType>>,
120    pub materialized_column_collations: Option<Vec<u32>>,
121}
122
123impl ViewRewriteDefinition {
124    pub fn row_schema(
125        &self,
126        routines: &dyn crate::routines::RoutineResolution,
127        catalog: super::analysis::CatalogReadView,
128        resolution: super::resolution::RelationNameResolution,
129    ) -> Result<crate::RowSchema, crate::SQLError> {
130        use crate::catalog::view::{create_view_output_columns, named_view_schema};
131        if self.kind == StoredViewKind::Materialized {
132            return materialized_view_schema(
133                self.output_columns.as_deref().unwrap_or_default(),
134                &self.materialized_column_types,
135                self.materialized_column_collations.as_deref(),
136            );
137        }
138        // The stored query is analyzed as it was created; its set-returning calls are not placed again.
139        let query_schema = {
140            let _stored = SetPlacementScope::stored_definition();
141            crate::binding::analyze_query_plan_schema_with_catalog(
142                routines,
143                &self.query,
144                &[],
145                catalog,
146                resolution,
147            )
148        }?;
149        let output_columns = match &self.output_columns {
150            Some(columns) => columns.clone(),
151            None => create_view_output_columns(&query_schema, &[])?,
152        };
153        named_view_schema(&query_schema, &output_columns)
154    }
155}
156
157#[cfg(test)]
158mod tests;