Skip to main content

uqa_sql/semantics/view_rewrite/
captured_projection.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind a view's output expressions to private raw input attributes without executing them.
8
9use 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
24/// The caller decides whether the selected expressions may cross the producer boundary. The replacement source retains the view predicate, namespace and owner.
25pub 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    // The stored view requires its declared source permissions even when consumers omit outputs.
76    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    /// Keep the caller's qualification above the view's own predicate, including security-barrier views, while exposing only raw attributes to its later output expressions.
213    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;