Skip to main content

uqa_execution/query/
source_projection.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Apply the durable input shape of stored table references to current table scans.
8
9use crate::{ColumnSelection, PhysicalOperator};
10use uqa_sql::SQLError;
11
12pub use uqa_sql::semantics::bound_source_column_names;
13
14pub fn bound_source_operator<'a>(
15    operator: Box<dyn PhysicalOperator + 'a>,
16    bound: Option<&[String]>,
17) -> Result<Box<dyn PhysicalOperator + 'a>, SQLError> {
18    let Some(bound) = bound else {
19        return Ok(operator);
20    };
21    if operator.schema() == bound {
22        return Ok(operator);
23    }
24    let mapping = bound
25        .iter()
26        .map(|name| {
27            let position = operator
28                .schema()
29                .iter()
30                .position(|column| column == name)
31                .ok_or_else(|| SQLError::UnknownColumn(name.clone()))?;
32            Ok((
33                name.clone(),
34                operator.row_schema().identities()[position].clone(),
35                position,
36            ))
37        })
38        .collect::<Result<Vec<_>, SQLError>>()?;
39    Ok(Box::new(ColumnSelection::with_identities(
40        operator, mapping,
41    )))
42}
43
44use uqa_sql::plan::source_projection::ColumnPrune;
45
46mod catalog_filters;
47
48fn source_column_requested(column: &str, qualifier: &str, prune: Option<&ColumnPrune>) -> bool {
49    qualifier.is_empty()
50        || prune
51            .and_then(|prune| prune.get(qualifier))
52            .is_none_or(|wanted| wanted.contains(column))
53}
54
55pub(crate) fn catalog_request(
56    source_columns: &[String],
57    aliases: &[String],
58    qualifier: &str,
59    prune: Option<&ColumnPrune>,
60    filters: Option<&uqa_sql::plan::source_projection::QualifierFilters>,
61) -> crate::catalog::projection::CatalogRequest {
62    let mut request = crate::catalog::projection::CatalogRequest::columns(
63        source_columns
64            .iter()
65            .enumerate()
66            .filter(|(index, source)| {
67                let column = aliases.get(*index).map_or(source.as_str(), String::as_str);
68                source_column_requested(column, qualifier, prune)
69            })
70            .map(|(_, source)| source.clone()),
71    );
72    if let Some(filters) = filters.and_then(|filters| filters.get(qualifier)) {
73        for filter in filters {
74            catalog_filters::add_name_bounds(
75                &mut request,
76                source_columns,
77                aliases,
78                qualifier,
79                filter,
80            );
81        }
82    }
83    request
84}
85
86pub fn qualify_source_operator_with_columns<'a>(
87    operator: Box<dyn crate::PhysicalOperator + 'a>,
88    source_columns: &[String],
89    qualifier: &str,
90    prune: Option<&ColumnPrune>,
91    aliases: &[String],
92    rebind_lock_origins: bool,
93) -> Box<dyn crate::PhysicalOperator + 'a> {
94    let mapping = source_columns
95        .iter()
96        .enumerate()
97        .filter_map(|(index, source)| {
98            let source_base = operator.row_schema().public_name(index).unwrap_or(source);
99            let column = aliases.get(index).map_or(source_base, String::as_str);
100            if !source_column_requested(column, qualifier, prune) {
101                return None;
102            }
103            let identity = if qualifier.is_empty() {
104                crate::ColumnIdentity::unqualified(column)
105            } else {
106                crate::ColumnIdentity::qualified(qualifier, column)
107            };
108            Some((column.to_string(), identity, index))
109        })
110        .collect();
111    let mut selection = crate::ColumnSelection::with_identities(operator, mapping)
112        .rebinding_score_sources(qualifier);
113    if selection.row_schema().is_empty()
114        && !qualifier.is_empty()
115        && !selection.row_schema().has_qualifier(qualifier)
116    {
117        selection = selection.with_relation_qualifier(qualifier);
118    }
119    if rebind_lock_origins {
120        Box::new(selection.rebinding_lock_origins(qualifier))
121    } else {
122        Box::new(selection.discarding_lock_origins())
123    }
124}
125
126pub use uqa_sql::semantics::join_alias_columns;
127
128pub fn alias_join_operator<'a>(
129    operator: Box<dyn crate::PhysicalOperator + 'a>,
130    alias: Option<&str>,
131    column_aliases: &[String],
132) -> Result<Box<dyn crate::PhysicalOperator + 'a>, SQLError> {
133    alias_join_operator_with_control(
134        operator,
135        alias,
136        column_aliases,
137        &uqa_core::memory::ProductionControl::uncontrolled(),
138    )
139}
140
141pub(crate) fn alias_join_operator_with_control<'a>(
142    operator: Box<dyn crate::PhysicalOperator + 'a>,
143    alias: Option<&str>,
144    column_aliases: &[String],
145    control: &uqa_core::memory::ProductionControl<'_>,
146) -> Result<Box<dyn crate::PhysicalOperator + 'a>, SQLError> {
147    crate::physical::construction::OperatorBuild::build(operator, |owner| {
148        control.check()?;
149        let Some(alias) = alias else {
150            if column_aliases.is_empty() {
151                return Ok(());
152            }
153            return Err(SQLError::Internal(
154                "JOIN column aliases exist without a relation alias".into(),
155            ));
156        };
157        owner.attach(|input| {
158            ColumnSelection::with_join_alias_with_control(input, alias, column_aliases, control)
159        })
160    })
161}
162
163#[cfg(test)]
164mod tests;