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