uqa_sql/semantics/view_rewrite/
captured_projection.rs1use super::{automatic_view_layer, AutomaticViewLayer, DeferredOuterRewrite, ViewRewriteContext};
10use crate::{
11 ast::{InternalColumnRef, InternalRelationId},
12 plan::{ExpressionPlan, ProjectionPlan, QueryBlockPlan, QueryPlan, RelationalPlan, SourcePlan},
13 ColumnIdentity, RowSchema, SQLError, ScalarExpr,
14};
15use std::collections::BTreeMap;
16mod owned;
17pub use owned::{capture_view_projection_owned, OwnedCapturedViewProjection};
18
19pub struct CapturedViewProjection {
20 pub source: SourcePlan,
21 pub expressions: BTreeMap<InternalColumnRef, ExpressionPlan>,
22}
23
24pub fn capture_view_projection(
26 services: ViewRewriteContext<'_>,
27 relation: InternalRelationId,
28 query: &QueryPlan,
29) -> Result<Option<CapturedViewProjection>, SQLError> {
30 let RelationalPlan::QueryBlock(block) = &query.root else {
31 return Ok(None);
32 };
33 let Some(SourcePlan::Table {
34 name,
35 qualifier,
36 alias,
37 ..
38 }) = &block.from
39 else {
40 return Ok(None);
41 };
42 if !query.ctes.is_empty() || !plain_projection(block) {
43 return Ok(None);
44 }
45 let Some(layer) = automatic_view_layer(services, name)? else {
46 return Ok(None);
47 };
48 let definition = services
49 .catalog
50 .view_definition(&layer.canonical_name)?
51 .ok_or_else(|| SQLError::UnknownTable(name.clone()))?;
52 let qualifier = alias.as_deref().unwrap_or(qualifier);
53 let raw = InternalRelationId::allocate();
54 let schema = input_schema(&layer.source_schema, raw);
55 let scope = services.catalog.binding_scope()?;
56 let subject = crate::semantics::view_privileges::next_layer_privilege_subject(
57 services.authorization,
58 &layer.canonical_name,
59 )?;
60 services.authorization.ensure_query_select(query)?;
61 let names = bind_outputs(
62 services,
63 &layer,
64 qualifier,
65 &schema,
66 &scope.context(),
67 &subject,
68 raw,
69 )?;
70 let rewrite = DeferredOuterRewrite::from_inputs(names);
71 let expressions = capture_outputs(relation, block, &layer, qualifier, &rewrite);
72 let mut producer = definition.query;
73 producer.relation_privilege_subject = Some(subject);
74 producer.relations_bound = true;
75 services.authorization.ensure_query_select(&producer)?;
77 let RelationalPlan::QueryBlock(input) = &mut producer.root else {
78 unreachable!("automatic view query");
79 };
80 input.projections = (0..schema.len())
81 .map(|position| ProjectionPlan {
82 expr: ScalarExpr::Position(position),
83 alias: Some(schema.columns()[position].clone()),
84 })
85 .collect();
86 input
87 .projections
88 .extend(virtual_columns(&schema).map(|identity| ProjectionPlan {
89 expr: ScalarExpr::qualified_column(
90 identity.qualifier().expect("qualified metadata"),
91 identity.column(),
92 ),
93 alias: Some(identity.column().to_owned()),
94 }));
95 let raw_names = input
96 .projections
97 .iter()
98 .map(|projection| projection.alias.clone().expect("raw attribute"))
99 .collect::<Vec<_>>();
100 producer.analyzed_output = None;
101 producer.analyzed_source = None;
102 crate::plan::subqueries::prune_query(&mut producer);
103 let captured = CapturedViewProjection {
104 source: SourcePlan::Subquery {
105 captured_output: Some(raw),
106 lateral: false,
107 body: Box::new(producer),
108 alias: None,
109 column_aliases: Vec::new(),
110 },
111 expressions,
112 };
113 Ok(Some(captured.filter(query, raw, &raw_names, &rewrite)?))
114}
115
116fn plain_projection(block: &QueryBlockPlan) -> bool {
117 matches!(block.compute, crate::plan::ComputePlan::Project)
118 && block.deferred_outer_rewrites.is_empty()
119 && block.group_by.is_empty()
120 && block.grouping_sets.is_empty()
121 && block.having.is_none()
122 && !block.distinct
123 && block.distinct_on.is_empty()
124 && block.windows.is_empty()
125 && block.order_by.is_empty()
126 && block.limit.is_none()
127 && block.offset.is_none()
128 && block.locking.is_empty()
129}
130
131fn bind_outputs(
132 services: ViewRewriteContext<'_>,
133 layer: &AutomaticViewLayer,
134 qualifier: &str,
135 schema: &RowSchema,
136 scope: &crate::binding::BindingContext<'_>,
137 subject: &crate::catalog::roles::RoleReference,
138 raw: InternalRelationId,
139) -> Result<BTreeMap<ColumnIdentity, ExpressionPlan>, SQLError> {
140 let metadata = metadata_rewrite(schema, raw);
141 let mut names = BTreeMap::new();
142 let mut fields = Vec::new();
143 let mut arena = Vec::new();
144 for column in &layer.columns {
145 let mut expression = ExpressionPlan {
146 scalar: column.expression.clone(),
147 subqueries: layer.subqueries.clone(),
148 };
149 crate::plan::subqueries::prune_expression(&mut expression);
150 crate::binding::bind_expression_plan_routines_for_storage(
151 services.routines,
152 &mut expression,
153 &[],
154 scope,
155 schema,
156 )?;
157 metadata.bind_expression(&mut expression);
158 for query in &mut expression.subqueries {
159 query.relation_privilege_subject = Some(subject.clone());
160 }
161 fields.push(crate::plan::input_projection::append_expression(
162 &mut arena,
163 expression.clone(),
164 ));
165 names.insert(
166 ColumnIdentity::qualified(qualifier, &column.name),
167 expression.clone(),
168 );
169 names.insert(ColumnIdentity::unqualified(&column.name), expression);
170 }
171 names
172 .entry(ColumnIdentity::unqualified(qualifier))
173 .or_insert(ExpressionPlan {
174 scalar: ScalarExpr::Cast {
175 implicit: true,
176 expr: Box::new(ScalarExpr::Row(fields)),
177 ty: layer.canonical_name.clone(),
178 },
179 subqueries: arena,
180 });
181 Ok(names)
182}
183
184fn capture_outputs(
185 relation: InternalRelationId,
186 block: &QueryBlockPlan,
187 layer: &AutomaticViewLayer,
188 qualifier: &str,
189 rewrite: &DeferredOuterRewrite,
190) -> BTreeMap<InternalColumnRef, ExpressionPlan> {
191 block
192 .projections
193 .iter()
194 .enumerate()
195 .map(|(position, projection)| {
196 let mut expression = ExpressionPlan {
197 scalar: match &projection.expr {
198 ScalarExpr::Position(position) => {
199 ScalarExpr::qualified_column(qualifier, &layer.columns[*position].name)
200 }
201 expression => expression.clone(),
202 },
203 subqueries: block.subqueries.clone(),
204 };
205 rewrite.bind_expression(&mut expression);
206 (relation.column(position), expression)
207 })
208 .collect()
209}
210
211impl CapturedViewProjection {
212 fn filter(
214 mut self,
215 query: &QueryPlan,
216 raw: InternalRelationId,
217 raw_names: &[String],
218 rewrite: &DeferredOuterRewrite,
219 ) -> Result<Self, SQLError> {
220 let RelationalPlan::QueryBlock(block) = &query.root else {
221 unreachable!("captured query block");
222 };
223 let Some(predicate) = &block.r#where else {
224 return Ok(self);
225 };
226 let mut predicate = ExpressionPlan {
227 scalar: predicate.clone(),
228 subqueries: block.subqueries.clone(),
229 };
230 rewrite.bind_expression(&mut predicate);
231 crate::plan::subqueries::prune_expression(&mut predicate);
232 let filtered = InternalRelationId::allocate();
233 let replacements = (0..raw_names.len())
234 .map(|position| {
235 (
236 raw.column(position),
237 ExpressionPlan {
238 scalar: ScalarExpr::InternalColumn(filtered.column(position)),
239 subqueries: Vec::new(),
240 },
241 )
242 })
243 .collect();
244 for expression in self.expressions.values_mut() {
245 crate::plan::input_projection::substitute_expression_inputs(expression, &replacements)?;
246 }
247 let mut filter = query.clone();
248 filter.analyzed_output = None;
249 filter.analyzed_source = None;
250 let RelationalPlan::QueryBlock(block) = &mut filter.root else {
251 unreachable!("captured query block");
252 };
253 block.from = Some(self.source);
254 block.r#where = Some(predicate.scalar);
255 block.subqueries = predicate.subqueries;
256 block.privilege_columns.clear();
257 block.projections = raw_names
258 .iter()
259 .enumerate()
260 .map(|(position, name)| ProjectionPlan {
261 expr: ScalarExpr::InternalColumn(raw.column(position)),
262 alias: Some(name.clone()),
263 })
264 .collect();
265 self.source = SourcePlan::Subquery {
266 captured_output: Some(filtered),
267 lateral: false,
268 body: Box::new(filter),
269 alias: None,
270 column_aliases: Vec::new(),
271 };
272 Ok(self)
273 }
274}
275
276fn virtual_columns(schema: &RowSchema) -> impl Iterator<Item = &ColumnIdentity> {
277 schema
278 .typed_virtual_identities()
279 .map(|(identity, _)| identity)
280 .filter(|identity| identity.qualifier().is_some())
281}
282
283fn input_schema(source: &RowSchema, raw: InternalRelationId) -> RowSchema {
284 let source = crate::binding::with_query_table_pseudo_columns(source);
285 let aliases = (0..source.len())
286 .map(|position| {
287 (
288 raw.column(position),
289 source.physical_slot(position).expect("view input"),
290 source.column_types()[position].clone(),
291 )
292 })
293 .collect::<Vec<_>>();
294 RowSchema::with_physical_internal_aliases(&source, &aliases)
295}
296
297fn metadata_rewrite(schema: &RowSchema, raw: InternalRelationId) -> DeferredOuterRewrite {
298 let mut names = BTreeMap::new();
299 for (position, identity) in virtual_columns(schema).enumerate() {
300 let expression = ExpressionPlan {
301 scalar: ScalarExpr::InternalColumn(raw.column(schema.len() + position)),
302 subqueries: Vec::new(),
303 };
304 names.insert(identity.clone(), expression.clone());
305 if schema.unqualified_position(identity.column()).is_none() {
306 names
307 .entry(ColumnIdentity::unqualified(identity.column()))
308 .or_insert(expression);
309 }
310 }
311 DeferredOuterRewrite::from_inputs(names)
312}
313
314#[cfg(test)]
315mod tests;