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;
16
17pub struct CapturedViewProjection {
18    pub source: SourcePlan,
19    pub expressions: BTreeMap<InternalColumnRef, ExpressionPlan>,
20}
21
22/// The caller decides whether the selected expressions may cross the producer boundary. The replacement source retains the view predicate, namespace and owner.
23pub 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    // The stored view requires its declared source permissions even when consumers omit outputs.
75    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    /// 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.
212    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;