uqa_sql/semantics/view_rewrite/deferred/owned/
expression.rs1use 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}