1use 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}