uqa_execution/query/
source_projection.rs1use 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;