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