Skip to main content

uqa_sql/semantics/view_rewrite/captured_projection/
owned.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Captured view outputs retain admitted expressions, source boxes and lexical substitutions.
8
9use super::{plain_projection, virtual_columns, DeferredOuterRewrite, ViewRewriteContext};
10use crate::{
11    ast::InternalRelationId,
12    binding::production::ControlledBindingContext,
13    catalog::roles::RoleReference,
14    plan::{
15        input_projection::OwnedInputProjections, MutableExpressionPlan, MutableQueryPlan,
16        MutableSourcePlan, OwnedProjection, OwnedScalarExpr, QueryBlockPlan, QueryPlan,
17        RelationalPlan, ScalarQueryArena, SourcePlan,
18    },
19    production::Buffer,
20    semantics::view_rewrite::production::{automatic_view_layer_owned, OwnedAutomaticViewLayer},
21    ColumnIdentity, RowSchema, SQLError, ScalarExpr,
22};
23use uqa_core::memory::{OwnedMap, Produced, ProductionControl, ProductionVec};
24
25type Names = OwnedMap<Produced<ColumnIdentity>, Produced<crate::plan::ExpressionPlan>>;
26
27pub struct OwnedCapturedViewProjection {
28    pub source: MutableSourcePlan,
29    pub expressions: OwnedInputProjections,
30}
31
32pub fn capture_view_projection_owned(
33    services: ViewRewriteContext<'_>,
34    relation: InternalRelationId,
35    query: &QueryPlan,
36    control: &ProductionControl<'_>,
37) -> Result<Option<OwnedCapturedViewProjection>, SQLError> {
38    control.check()?;
39    let RelationalPlan::QueryBlock(block) = &query.root else {
40        return Ok(None);
41    };
42    let Some(SourcePlan::Table {
43        name,
44        qualifier,
45        alias,
46        ..
47    }) = &block.from
48    else {
49        return Ok(None);
50    };
51    if !query.ctes.is_empty() || !plain_projection(block) {
52        return Ok(None);
53    }
54    let Some(layer) = automatic_view_layer_owned(services, name, control)? else {
55        return Ok(None);
56    };
57    let mut definition = None;
58    services.catalog.with_view_definition_with_control(
59        &layer.canonical_name,
60        control,
61        &mut |view| {
62            let view = view.ok_or_else(|| SQLError::UnknownTable(name.clone()))?;
63            definition = Some(view.query.copy_for_rewrite(control)?);
64            Ok(())
65        },
66    )?;
67    let definition = definition
68        .ok_or_else(|| SQLError::Internal("view catalog did not supply its definition".into()))?;
69    let qualifier = alias.as_deref().unwrap_or(qualifier);
70    let raw = InternalRelationId::allocate();
71    let schema = input_schema(&layer.source_schema, raw, control)?;
72    let scope = services.catalog.binding_scope_with_control(control)?;
73    let subject = crate::semantics::view_privileges::next_layer_privilege_subject_with_control(
74        services.authorization,
75        &layer.canonical_name,
76        control,
77    )?;
78    services
79        .authorization
80        .ensure_query_select_with_control(query, control)?;
81    let names = bind_outputs(
82        services,
83        &layer,
84        qualifier,
85        &schema,
86        scope.context_with_control(control)?,
87        &subject,
88        raw,
89        control,
90    )?;
91    let rewrite = DeferredOuterRewrite::from_inputs_owned(names, control)?;
92    let expressions = capture_outputs(relation, block, &layer, qualifier, &rewrite, control)?;
93    let mut producer = definition
94        .set_privilege_subject(Some(subject), control)?
95        .set_relations_bound(true, control)?;
96    services
97        .authorization
98        .ensure_query_select_with_control(&producer, control)?;
99    let mut projections = Buffer::new(control);
100    let mut raw_names = ProductionVec::new(*control);
101    for (position, name) in schema.columns().iter().enumerate() {
102        projections.push(
103            OwnedProjection {
104                expression: ScalarExpr::Position(position).copy_for_rewrite(control)?,
105                alias: Some(control.copy_text(name)?),
106            },
107            control,
108        )?;
109        raw_names.push_produced(control.copy_text(name)?)?;
110    }
111    for identity in virtual_columns(&schema) {
112        projections.push(
113            OwnedProjection {
114                expression: OwnedScalarExpr::column(
115                    control.copy_text(identity.column())?,
116                    Some(control.copy_text(identity.qualifier().expect("qualified metadata"))?),
117                    control,
118                )?,
119                alias: Some(control.copy_text(identity.column())?),
120            },
121            control,
122        )?;
123        raw_names.push_produced(control.copy_text(identity.column())?)?;
124    }
125    producer = producer
126        .replace_projections(projections.into_iter(), control)?
127        .set_analyzed_output(None, control)?
128        .discard_source_analysis(control)?
129        .prune_subqueries(control)?;
130    let captured = OwnedCapturedViewProjection {
131        source: source(producer, raw, control)?,
132        expressions,
133    };
134    Ok(Some(
135        captured.filter(query, raw, &raw_names, &rewrite, control)?,
136    ))
137}
138
139fn input_schema(
140    source: &RowSchema,
141    raw: InternalRelationId,
142    control: &ProductionControl<'_>,
143) -> Result<RowSchema, SQLError> {
144    let source = crate::binding::with_query_table_pseudo_columns_with_control(source, control)?;
145    RowSchema::with_physical_internal_aliases_with_control(
146        &source,
147        (0..source.len()).map(|position| {
148            (
149                raw.column(position),
150                source.physical_slot(position).expect("view input"),
151                source.column_type(position),
152            )
153        }),
154        control,
155    )
156}
157
158#[expect(
159    clippy::too_many_arguments,
160    reason = "one captured view binding retains its namespace, authority and original request"
161)]
162fn bind_outputs(
163    services: ViewRewriteContext<'_>,
164    layer: &OwnedAutomaticViewLayer,
165    qualifier: &str,
166    schema: &RowSchema,
167    scope: ControlledBindingContext<'_>,
168    subject: &RoleReference,
169    raw: InternalRelationId,
170    control: &ProductionControl<'_>,
171) -> Result<Names, SQLError> {
172    let metadata = metadata_rewrite(schema, raw, control)?;
173    let mut names = Names::new();
174    let mut fields = Buffer::new(control);
175    let mut arena = ScalarQueryArena::copy_from(&[], control)?;
176    for column in layer.columns.iter() {
177        let expression = MutableExpressionPlan::copy_from(
178            &column.expression,
179            layer.subqueries.queries(),
180            control,
181        )?
182        .prune_subqueries(control)?;
183        let expression = crate::binding::bind_expression_plan_routines_for_storage_owned(
184            services.routines,
185            expression,
186            &[],
187            scope.copy_with_control(control)?,
188            schema,
189            control,
190        )?;
191        let mut expression = metadata.bind_expression_owned(expression, control)?;
192        for index in 0..expression.queries().len() {
193            expression = expression.map_query(index, control, |query| {
194                query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
195            })?;
196        }
197        let expression = expression.finish(control)?;
198        fields.push(
199            arena.append_expression(expression.copy_for_rewrite(control)?, control)?,
200            control,
201        )?;
202        insert(
203            &mut names,
204            ColumnIdentity::from_parts_with_control(Some(qualifier), &column.name, control)?,
205            expression.copy_for_rewrite(control)?.finish(control)?,
206            control,
207        )?;
208        insert(
209            &mut names,
210            ColumnIdentity::from_parts_with_control(None, &column.name, control)?,
211            expression,
212            control,
213        )?;
214    }
215    let key = ColumnIdentity::from_parts_with_control(None, qualifier, control)?;
216    if names.get_by(|identity| identity.cmp(&key)).is_none() {
217        let row = OwnedScalarExpr::row(fields.into_iter(), control)?;
218        let scalar = OwnedScalarExpr::cast(
219            row,
220            control.copy_text(&layer.canonical_name)?,
221            true,
222            control,
223        )?;
224        let expression =
225            MutableExpressionPlan::from_parts(scalar, arena, control)?.finish(control)?;
226        insert(&mut names, key, expression, control)?;
227    }
228    Ok(names)
229}
230
231fn capture_outputs(
232    relation: InternalRelationId,
233    block: &QueryBlockPlan,
234    layer: &OwnedAutomaticViewLayer,
235    qualifier: &str,
236    rewrite: &DeferredOuterRewrite,
237    control: &ProductionControl<'_>,
238) -> Result<OwnedInputProjections, SQLError> {
239    let mut expressions = OwnedInputProjections::new();
240    for (position, projection) in block.projections.iter().enumerate() {
241        let scalar = match &projection.expr {
242            ScalarExpr::Position(position) => OwnedScalarExpr::column(
243                control.copy_text(&layer.columns[*position].name)?,
244                Some(control.copy_text(qualifier)?),
245                control,
246            )?,
247            expression => expression.copy_for_rewrite(control)?,
248        };
249        let expression = MutableExpressionPlan::from_parts(
250            scalar,
251            ScalarQueryArena::copy_from(&block.subqueries, control)?,
252            control,
253        )?;
254        let expression = rewrite
255            .bind_expression_owned(expression, control)?
256            .finish(control)?;
257        insert(
258            &mut expressions,
259            relation.column(position),
260            expression,
261            control,
262        )?;
263    }
264    Ok(expressions)
265}
266
267fn metadata_rewrite(
268    schema: &RowSchema,
269    raw: InternalRelationId,
270    control: &ProductionControl<'_>,
271) -> Result<DeferredOuterRewrite, SQLError> {
272    let mut names = Names::new();
273    for (position, identity) in virtual_columns(schema).enumerate() {
274        let expression = MutableExpressionPlan::copy_from(
275            &ScalarExpr::InternalColumn(raw.column(schema.len() + position)),
276            &[],
277            control,
278        )?
279        .finish(control)?;
280        insert(
281            &mut names,
282            ColumnIdentity::from_parts_with_control(
283                identity.qualifier(),
284                identity.column(),
285                control,
286            )?,
287            expression.copy_for_rewrite(control)?.finish(control)?,
288            control,
289        )?;
290        if schema.unqualified_position(identity.column()).is_none() {
291            let key = ColumnIdentity::from_parts_with_control(None, identity.column(), control)?;
292            if names.get_by(|identity| identity.cmp(&key)).is_none() {
293                insert(&mut names, key, expression, control)?;
294            }
295        }
296    }
297    DeferredOuterRewrite::from_inputs_owned(names, control)
298}
299
300fn source(
301    query: MutableQueryPlan,
302    relation: InternalRelationId,
303    control: &ProductionControl<'_>,
304) -> Result<MutableSourcePlan, SQLError> {
305    MutableSourcePlan::subquery(
306        query,
307        None,
308        control.finish(Vec::new(), control.empty_reservation())?,
309        Some(relation),
310        false,
311        control,
312    )
313}
314
315fn insert<K: Ord, V>(
316    map: &mut OwnedMap<K, V>,
317    key: K,
318    value: V,
319    control: &ProductionControl<'_>,
320) -> Result<(), SQLError> {
321    control.check()?;
322    if let Some(budget) = control.budget() {
323        map.insert_budgeted(key, value, budget)?;
324    } else {
325        map.insert(key, value);
326    }
327    Ok(())
328}
329
330impl OwnedCapturedViewProjection {
331    fn filter(
332        mut self,
333        query: &QueryPlan,
334        raw: InternalRelationId,
335        raw_names: &[String],
336        rewrite: &DeferredOuterRewrite,
337        control: &ProductionControl<'_>,
338    ) -> Result<Self, SQLError> {
339        let RelationalPlan::QueryBlock(block) = &query.root else {
340            unreachable!("captured query block")
341        };
342        let Some(predicate) = &block.r#where else {
343            return Ok(self);
344        };
345        let predicate = MutableExpressionPlan::copy_from(predicate, &block.subqueries, control)?;
346        let predicate = rewrite
347            .bind_expression_owned(predicate, control)?
348            .prune_subqueries(control)?;
349        let filtered = InternalRelationId::allocate();
350        let mut replacements = OwnedInputProjections::new();
351        for position in 0..raw_names.len() {
352            let expression = MutableExpressionPlan::copy_from(
353                &ScalarExpr::InternalColumn(filtered.column(position)),
354                &[],
355                control,
356            )?
357            .finish(control)?;
358            insert(&mut replacements, raw.column(position), expression, control)?;
359        }
360        let mut expressions = OwnedInputProjections::new();
361        for (column, expression) in self.expressions {
362            let expression = crate::plan::input_projection::substitute_expression_inputs_owned(
363                expression.copy_for_rewrite(control)?,
364                &replacements,
365                control,
366            )?
367            .finish(control)?;
368            insert(&mut expressions, column, expression, control)?;
369        }
370        self.expressions = expressions;
371        let mut projections = Buffer::new(control);
372        for (position, name) in raw_names.iter().enumerate() {
373            projections.push(
374                OwnedProjection {
375                    expression: ScalarExpr::InternalColumn(raw.column(position))
376                        .copy_for_rewrite(control)?,
377                    alias: Some(control.copy_text(name)?),
378                },
379                control,
380            )?;
381        }
382        let filter = query
383            .copy_for_rewrite(control)?
384            .set_analyzed_output(None, control)?
385            .discard_source_analysis(control)?
386            .replace_source(Some(self.source), control)?
387            .replace_where_expression(predicate, control)?
388            .clear_privilege_columns(control)?
389            .replace_projections(projections.into_iter(), control)?;
390        self.source = source(filter, filtered, control)?;
391        Ok(self)
392    }
393}