Skip to main content

uqa_sql/semantics/view_rewrite/deferred/
owned.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Deferred namespace resolution preserves independently owned replacement entries and mutable scalar-query arenas.
8
9use super::{DeferredOuterRewrite, RowSchema, SQLError};
10use crate::{
11    plan::{MutableQueryPlan, QueryBlockPlan, RelationalPlan},
12    production::Buffer,
13};
14use std::borrow::Cow;
15use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
16
17mod expression;
18mod namespaces;
19mod sources;
20pub use sources::resolve_outer_sources_owned;
21
22/// Resolve a standalone expression in its actual local namespace while moving its scalar-query arena with every replacement.
23pub fn resolve_outer_expression_rewrites_owned(
24    mut expression: crate::plan::MutableExpressionPlan,
25    rewrites: &[DeferredOuterRewrite],
26    local: &RowSchema,
27    control: &ProductionControl<'_>,
28) -> Result<crate::plan::MutableExpressionPlan, SQLError> {
29    control.check()?;
30    for rewrite in rewrites {
31        let rewrite =
32            namespaces::in_namespace(rewrite, Some(local), namespaces::Selection::All, control)?;
33        expression = rewrite.bind_expression_owned(expression, control)?;
34    }
35    Ok(expression)
36}
37
38pub fn bind_outer_rewrite_scope_with_control<'a>(
39    block: &QueryBlockPlan,
40    outer: &'a RowSchema,
41    control: &ProductionControl<'_>,
42) -> Result<Cow<'a, RowSchema>, SQLError> {
43    control.check()?;
44    let mut aliases = ProductionVec::new(*control);
45    for rewrite in &block.deferred_outer_rewrites {
46        for (identity, column) in rewrite.outer_columns.iter() {
47            control.check()?;
48            if !outer.has_internal_column(*column) {
49                aliases.push_copy((*column, identity))?;
50            }
51        }
52    }
53    if aliases.is_empty() {
54        return Ok(Cow::Borrowed(outer));
55    }
56    Ok(Cow::Owned(
57        RowSchema::with_named_internal_aliases_with_control(outer, &aliases, control)?,
58    ))
59}
60
61pub fn resolve_outer_rewrites_owned(
62    mut query: MutableQueryPlan,
63    local: &RowSchema,
64    control: &ProductionControl<'_>,
65) -> Result<MutableQueryPlan, SQLError> {
66    control.check()?;
67    let RelationalPlan::QueryBlock(block) = &query.root else {
68        return Err(SQLError::Internal(
69            "outer rewrites require a query block".into(),
70        ));
71    };
72    let open = local.columns_are_open(None);
73    if !super::has_resolvable_outer_rewrites(block, local) {
74        return Ok(query);
75    }
76    let (retained, rewrites) = query.take_deferred_rewrites(control)?;
77    query = retained;
78    let mut pending = Buffer::new(control);
79    for rewrite in rewrites {
80        control.check()?;
81        if open {
82            let deferred = namespaces::in_namespace(
83                &rewrite,
84                Some(local),
85                namespaces::Selection::Unqualified,
86                control,
87            )?;
88            if !deferred.replacements.is_empty() {
89                pending.push(deferred, control)?;
90            }
91        }
92        let selected = namespaces::in_namespace(
93            &rewrite,
94            Some(local),
95            if open {
96                namespaces::Selection::Qualified
97            } else {
98                namespaces::Selection::All
99            },
100            control,
101        )?;
102        query = query.transform_root_scalar_arenas(control, &mut |_, expression, arena| {
103            expression::node(&selected, expression, arena, control)
104        })?;
105    }
106    query.replace_deferred_rewrites(pending.into_iter(), control)
107}
108
109impl DeferredOuterRewrite {
110    pub(crate) fn from_inputs_owned(
111        inputs: uqa_core::memory::OwnedMap<
112            Produced<crate::ColumnIdentity>,
113            Produced<crate::plan::ExpressionPlan>,
114        >,
115        control: &ProductionControl<'_>,
116    ) -> Result<Self, SQLError> {
117        let outer_columns = control
118            .finish(super::OuterColumns::new(), control.empty_reservation())?
119            .into_shared(control)?;
120        Ok(Self {
121            outer_columns,
122            replacements: super::replacements::Replacements::from_inputs_owned(inputs, control)?,
123            shadowed_qualifiers: uqa_core::memory::OwnedSet::new(),
124            shadowed_columns: uqa_core::memory::OwnedSet::new(),
125        })
126    }
127
128    pub fn clone_with_control(
129        &self,
130        control: &ProductionControl<'_>,
131    ) -> Result<Produced<Self>, SQLError> {
132        namespaces::in_namespace(self, None, namespaces::Selection::All, control)
133    }
134}