Skip to main content

uqa_sql/catalog/view/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! View metadata borrows the retained declaration and admits only the result descriptor selected by analysis.
8
9use super::{StoredViewKind, ViewRewriteDefinition};
10use crate::{plan::QueryPlan, ColumnType, RowSchema, SQLError};
11use uqa_core::memory::{Produced, ProductionControl, ProductionMap, ProductionVec};
12
13#[derive(Clone, Copy)]
14pub struct ViewRewriteDefinitionRef<'a> {
15    pub query: &'a QueryPlan,
16    pub output_columns: Option<&'a [String]>,
17    pub options: &'a [(String, String)],
18    pub kind: StoredViewKind,
19    pub materialized_column_types: &'a [Option<ColumnType>],
20    pub materialized_column_collations: Option<&'a [u32]>,
21}
22
23impl<'a> From<&'a ViewRewriteDefinition> for ViewRewriteDefinitionRef<'a> {
24    fn from(definition: &'a ViewRewriteDefinition) -> Self {
25        Self {
26            query: &definition.query,
27            output_columns: definition.output_columns.as_deref(),
28            options: &definition.options,
29            kind: definition.kind,
30            materialized_column_types: &definition.materialized_column_types,
31            materialized_column_collations: definition.materialized_column_collations.as_deref(),
32        }
33    }
34}
35
36impl crate::catalog::stored_view::StoredViewDefinition {
37    pub fn rewrite_definition_ref(&self) -> ViewRewriteDefinitionRef<'_> {
38        ViewRewriteDefinitionRef {
39            query: &self.query,
40            output_columns: self.output_columns.as_deref(),
41            options: &self.options,
42            kind: self.kind,
43            materialized_column_types: &self.materialized_column_types,
44            materialized_column_collations: self.materialized_column_collations.as_deref(),
45        }
46    }
47}
48
49impl ViewRewriteDefinitionRef<'_> {
50    pub fn row_schema_with_control(
51        self,
52        routines: &dyn crate::routines::RoutineResolution,
53        scope: crate::binding::production::ControlledBindingContext<'_>,
54        control: &ProductionControl<'_>,
55    ) -> Result<RowSchema, SQLError> {
56        control.check()?;
57        if self.kind == StoredViewKind::Materialized {
58            return materialized_view_schema_with_control(
59                self.output_columns.unwrap_or_default(),
60                self.materialized_column_types,
61                self.materialized_column_collations,
62                control,
63            );
64        }
65        let query_schema = {
66            let _stored =
67                crate::semantics::sets::placement_scope::SetPlacementScope::stored_definition();
68            crate::binding::analyze_query_plan_schema_with_control(
69                routines,
70                self.query,
71                &[],
72                scope,
73                None,
74                control,
75            )?
76        };
77        if let Some(columns) = self.output_columns {
78            named_view_schema_with_control(&query_schema, columns, control)
79        } else {
80            let names = create_view_output_columns_with_control(&query_schema, &[], control)?;
81            named_view_schema_with_control(&query_schema, &names, control)
82        }
83    }
84}
85
86pub fn create_view_output_columns_with_control(
87    schema: &RowSchema,
88    declared: &[String],
89    control: &ProductionControl<'_>,
90) -> Result<Produced<Vec<String>>, SQLError> {
91    control.check()?;
92    if declared.len() > schema.len() {
93        return Err(SQLError::Routine {
94            sqlstate: "42601".into(),
95            message: "CREATE VIEW specifies more column names than columns".into(),
96        });
97    }
98    let mut seen = ProductionMap::new(*control);
99    let mut columns = ProductionVec::new(*control);
100    for (position, column) in schema.columns().iter().enumerate() {
101        control.check()?;
102        let column = declared
103            .get(position)
104            .map(String::as_str)
105            .unwrap_or_else(|| schema.public_name(position).unwrap_or(column));
106        if seen.insert_copy(column, ())?.is_some() {
107            return Err(SQLError::Routine {
108                sqlstate: "42701".into(),
109                message: format!("column \"{column}\" specified more than once"),
110            });
111        }
112        columns.push_produced(control.copy_text(column)?)?;
113    }
114    Ok(columns.finish()?)
115}
116
117pub fn named_view_schema_with_control(
118    query_schema: &RowSchema,
119    output_columns: &[String],
120    control: &ProductionControl<'_>,
121) -> Result<RowSchema, SQLError> {
122    control.check()?;
123    if query_schema.len() != output_columns.len() {
124        return Err(SQLError::Internal(format!(
125            "stored view row type has {} columns but its query has {}",
126            output_columns.len(),
127            query_schema.len()
128        )));
129    }
130    RowSchema::with_output_metadata_with_control(
131        None,
132        output_columns.iter().enumerate().map(|(position, name)| {
133            (
134                name.as_str(),
135                query_schema.column_type(position),
136                query_schema.column_collation(position),
137                query_schema.record_metadata(position).cloned(),
138            )
139        }),
140        false,
141        control,
142    )
143}
144
145pub fn materialized_view_schema_with_control(
146    columns: &[String],
147    types: &[Option<ColumnType>],
148    collations: Option<&[u32]>,
149    control: &ProductionControl<'_>,
150) -> Result<RowSchema, SQLError> {
151    control.check()?;
152    let collations = super::materialized::validate_metadata(columns, types, collations, control)?;
153    RowSchema::with_column_metadata_with_control(
154        None,
155        columns
156            .iter()
157            .zip(types)
158            .zip(collations)
159            .map(|((name, ty), oid)| (name.as_str(), ty.as_ref(), Some(*oid))),
160        control,
161    )
162}