use std::{
collections::{BTreeMap, BTreeSet},
ptr::NonNull,
};
use crate::{plan::QueryPlan, ColumnIdentity, RowSchema, ScalarExpr};
mod owned;
pub use owned::substitute_outer_columns_owned;
pub fn substitute_outer_columns(
query: &mut QueryPlan,
target: &RowSchema,
inputs: &BTreeMap<ColumnIdentity, ScalarExpr>,
) -> bool {
if inputs.is_empty() {
return true;
}
let mut valid = inputs.values().all(|input| {
let mut closed = true;
input.visit(&mut |node| {
closed &= !matches!(
node,
ScalarExpr::Column(_)
| ScalarExpr::QualifiedColumn { .. }
| ScalarExpr::QualifiedStar(_)
| ScalarExpr::Star
| ScalarExpr::ScalarSubquery(_)
| ScalarExpr::Exists { .. }
| ScalarExpr::InSubquery { .. }
);
});
closed
});
if !valid {
return false;
}
let mut replacements = BTreeMap::new();
let mut selected_fields = BTreeSet::new();
let mut visit = |node: &ScalarExpr| {
if selected_fields.contains(&NonNull::from(node)) {
return;
}
if let Some(identity) =
crate::type_resolution::field_selection::relation_column(node, target)
{
if let Some(replacement) = inputs.get(&identity) {
let (base, _) = crate::type_resolution::field_selection::field_reference(node)
.expect("selected relation field");
selected_fields.insert(NonNull::from(base));
replacements.insert(NonNull::from(node), replacement.clone());
return;
}
}
let position = match node {
ScalarExpr::Column(column) => {
if target.has_qualifier(column)
&& !target.has_unqualified_column(column)
&& inputs
.keys()
.any(|key| key.qualifier() == Some(column.as_str()))
{
valid = false;
}
target.unqualified_position(column)
}
ScalarExpr::QualifiedColumn { qualifier, column } => {
target.qualified_position(qualifier, column)
}
ScalarExpr::QualifiedStar(qualifier) => {
valid &= !inputs.keys().any(|key| key.qualifier() == Some(qualifier));
None
}
_ => None,
};
if let Some(replacement) = position
.and_then(|position| target.identity(position))
.and_then(|identity| inputs.get(identity))
{
replacements.insert(NonNull::from(node), replacement.clone());
}
};
let mut references = super::ScopedReferences::new(&mut visit);
references.query(query);
if !references.is_complete() || !valid {
return false;
}
query.visit_queries_mut(&mut |query| {
if let crate::plan::RelationalPlan::QueryBlock(block) = &mut query.root {
for projection in &mut block.projections {
if projection.alias.is_some() {
continue;
}
let mut changed = false;
projection.expr.visit(&mut |node| {
changed |= replacements.contains_key(&NonNull::from(node));
});
if changed {
projection.alias = Some(crate::semantics::projection_label_at(projection));
}
}
}
crate::plan::subqueries::visit_root(&mut query.root, &mut |node| {
if let Some(replacement) = replacements.remove(&NonNull::from(&*node)) {
*node = replacement;
}
});
});
debug_assert!(
replacements.is_empty(),
"every selected reference is visited"
);
true
}