1use crate::semantics::sets::placement_scope::SetPlacementScope;
8use crate::{RowSchema, SQLError};
9
10mod materialized;
11pub use materialized::materialized_view_schema;
12
13pub 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 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;