Skip to main content

uqa_sql/semantics/view_rewrite/deferred/owned/
expression.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! A selected outer expression moves its own query occurrences into the consumer namespace exactly once.
8
9use super::{namespaces, DeferredOuterRewrite, SQLError};
10use crate::{
11    plan::{
12        MutableExecutablePlan, MutableExpressionPlan, MutableQueryPlan, OwnedScalarExpr,
13        QueryChildSlot, RelationalPlan, ScalarQueryArena,
14    },
15    production::Buffer,
16    ScalarExpr,
17};
18use uqa_core::memory::ProductionControl;
19
20pub(super) fn node(
21    rewrite: &DeferredOuterRewrite,
22    expression: OwnedScalarExpr,
23    arena: &mut ScalarQueryArena,
24    control: &ProductionControl<'_>,
25) -> Result<OwnedScalarExpr, SQLError> {
26    control.check()?;
27    if let ScalarExpr::ScalarSubquery(id)
28    | ScalarExpr::Exists { subquery: id, .. }
29    | ScalarExpr::InSubquery { subquery: id, .. } = &*expression
30    {
31        if *id < arena.queries().len() {
32            arena.map_query(*id, control, |query| self::query(rewrite, query, control))?;
33        }
34        return Ok(expression);
35    }
36    let identity = match &*expression {
37        ScalarExpr::Column(column) if !rewrite.shadowed_columns.contains(column.as_str()) => {
38            (None, column.as_str())
39        }
40        ScalarExpr::QualifiedStar(qualifier)
41            if !rewrite.shadowed_qualifiers.contains(qualifier.as_str()) =>
42        {
43            (None, qualifier.as_str())
44        }
45        ScalarExpr::QualifiedColumn { qualifier, column }
46            if !rewrite.shadowed_qualifiers.contains(qualifier.as_str()) =>
47        {
48            (Some(qualifier.as_str()), column.as_str())
49        }
50        _ => return Ok(expression),
51    };
52    let Some((_, replacement)) = rewrite
53        .replacements
54        .iter()
55        .find(|(key, _)| key.qualifier() == identity.0 && key.column() == identity.1)
56    else {
57        return Ok(expression);
58    };
59    let qualifier = replacement.qualifier.as_str();
60    let mut replacement = replacement.expression.copy_for_rewrite(control)?;
61    let bind = |expression: OwnedScalarExpr| -> Result<OwnedScalarExpr, SQLError> {
62        expression.transform_nodes(control, &mut |_, expression| {
63            bind_column(rewrite, qualifier, expression, control)
64        })
65    };
66    replacement = replacement.map_scalar(control, |expression, _| bind(expression))?;
67    for index in 0..replacement.queries().len() {
68        replacement = replacement.map_query(index, control, |query| {
69            query.transform_scalar_nodes(control, &mut |_, expression| {
70                bind_column(rewrite, qualifier, expression, control)
71            })
72        })?;
73    }
74    arena.append_expression(replacement, control)
75}
76
77fn bind_column(
78    rewrite: &DeferredOuterRewrite,
79    qualifier: &str,
80    expression: OwnedScalarExpr,
81    control: &ProductionControl<'_>,
82) -> Result<OwnedScalarExpr, SQLError> {
83    if let ScalarExpr::QualifiedColumn {
84        qualifier: name,
85        column,
86    } = &*expression
87    {
88        if name == qualifier {
89            if let Some((_, reference)) = rewrite.outer_columns.iter().find(|(identity, _)| {
90                identity.qualifier() == Some(name.as_str()) && identity.column() == column.as_str()
91            }) {
92                return Ok(ScalarExpr::InternalColumn(*reference).copy_for_rewrite(control)?);
93            }
94        }
95    }
96    Ok(expression)
97}
98
99pub(super) fn query(
100    rewrite: &DeferredOuterRewrite,
101    mut query: MutableQueryPlan,
102    control: &ProductionControl<'_>,
103) -> Result<MutableQueryPlan, SQLError> {
104    for index in 0..query.ctes.len() {
105        query = query.map_cte(index, control, |body| {
106            Ok(match body {
107                MutableExecutablePlan::Query(body) => {
108                    MutableExecutablePlan::Query(self::query(rewrite, body, control)?)
109                }
110                body => body,
111            })
112        })?;
113    }
114    match &query.root {
115        RelationalPlan::QueryBlock(_) => {
116            let (query, existing) = query.take_deferred_rewrites(control)?;
117            let mut output = Buffer::new(control);
118            let mut found = false;
119            for previous in existing {
120                if std::sync::Arc::ptr_eq(&previous.outer_columns, &rewrite.outer_columns) {
121                    found = true;
122                    output.push(namespaces::merged(&previous, rewrite, control)?, control)?;
123                } else {
124                    output.push(previous, control)?;
125                }
126            }
127            if !found {
128                output.push(rewrite.clone_with_control(control)?, control)?;
129            }
130            query.replace_deferred_rewrites(output.into_iter(), control)
131        }
132        RelationalPlan::SetOp { .. } => {
133            query = query.map_query_child(QueryChildSlot::Left, control, |query| {
134                self::query(rewrite, query, control)
135            })?;
136            query = query.map_query_child(QueryChildSlot::Right, control, |query| {
137                self::query(rewrite, query, control)
138            })?;
139            query.transform_root_scalar_arenas(control, &mut |_, expression, arena| {
140                node(rewrite, expression, arena, control)
141            })
142        }
143        RelationalPlan::Values { .. } => query
144            .transform_root_scalar_arenas(control, &mut |_, expression, arena| {
145                node(rewrite, expression, arena, control)
146            }),
147    }
148}
149
150impl DeferredOuterRewrite {
151    pub fn bind_expression_owned(
152        &self,
153        expression: MutableExpressionPlan,
154        control: &ProductionControl<'_>,
155    ) -> Result<MutableExpressionPlan, SQLError> {
156        expression.map_scalar(control, |expression, arena| {
157            expression.transform_nodes(control, &mut |_, expression| {
158                node(self, expression, arena, control)
159            })
160        })
161    }
162}