uqa_execution/query/relational/
aggregation.rs1use crate::{FunctionTypeResolver, ProjectionTarget, RowSchema, ScalarExpr};
10use uqa_sql::ast::InternalColumnRef;
11use uqa_sql::plan::{ProjectionPlan, QueryBlockPlan};
12use uqa_sql::{SQLError, SQLParam};
13
14use super::ordering::{
15 distinct_output_target_position, identity_order_columns, one_based_output_position,
16 output_target_position, prior_distinct_key_index, resolve_order_expression,
17};
18use crate::query::projection::projection_target_expression;
19use crate::query::{OutputColumnMapping, PhysicalProjection};
20use uqa_sql::semantics::{
21 projection_columns,
22 sets::{validation::expression_may_return_set, SetFunctionCatalog},
23};
24
25#[cfg(test)]
26mod tests;
27
28type PreparedOrderSetProjections = (Option<QueryBlockPlan>, Vec<(usize, InternalColumnRef)>);
29
30pub fn prepare_order_set_projections(
31 engine: &dyn SetFunctionCatalog,
32 type_resolver: &dyn FunctionTypeResolver,
33 statement: &QueryBlockPlan,
34 output_columns: &[OutputColumnMapping],
35 projections: &mut Vec<PhysicalProjection>,
36 schema: &RowSchema,
37 params: &[SQLParam],
38) -> Result<PreparedOrderSetProjections, SQLError> {
39 let mut prepared: Option<QueryBlockPlan> = None;
40 let relation = uqa_sql::ast::InternalRelationId::allocate();
41 let mut resjunk = Vec::new();
42 for (index, order) in statement.order_by.iter().enumerate() {
43 if let Some(target) = output_target_position(statement, &order.expr, output_columns)? {
44 if !target.direct {
45 prepared.get_or_insert_with(|| statement.clone()).order_by[index].expr =
46 one_based_output_position(target.position)?;
47 }
48 continue;
49 }
50 let expression = resolve_order_expression(&order.expr, output_columns)?;
51 if statement.with_ties {
52 let column = relation.column(resjunk.len());
53 projections.push((ProjectionTarget::Internal(column), expression));
54 resjunk.push((index, column));
55 prepared.get_or_insert_with(|| statement.clone()).order_by[index].expr =
56 ScalarExpr::InternalColumn(column);
57 continue;
58 }
59 if let Some((target, _)) = projections.iter().find(|(_, projected)| {
60 uqa_sql::semantics::aggregates::exprs_match(projected, &expression)
61 }) {
62 prepared.get_or_insert_with(|| statement.clone()).order_by[index].expr =
63 projection_target_expression(target);
64 } else if matches!(statement.compute, uqa_sql::plan::ComputePlan::Window)
65 || expression_may_return_set(engine, type_resolver, &expression, schema, params)?
66 {
67 let column = relation.column(resjunk.len());
69 projections.push((ProjectionTarget::Internal(column), expression));
70 resjunk.push((index, column));
71 prepared.get_or_insert_with(|| statement.clone()).order_by[index].expr =
72 ScalarExpr::InternalColumn(column);
73 }
74 }
75 Ok((prepared, resjunk))
76}
77
78pub fn append_distinct_set_projections(
79 statement: &QueryBlockPlan,
80 output_columns: &[OutputColumnMapping],
81 projections: &mut Vec<PhysicalProjection>,
82) -> Result<Vec<(usize, InternalColumnRef)>, SQLError> {
83 let mut columns = Vec::new();
84 let relation = uqa_sql::ast::InternalRelationId::allocate();
85 for (index, expression) in statement.distinct_on.iter().enumerate() {
86 if prior_distinct_key_index(statement, index, expression, output_columns)?.is_some() {
87 continue;
88 }
89 if distinct_output_target_position(statement, expression, output_columns)?.is_some() {
90 continue;
91 }
92 let expression = resolve_order_expression(expression, output_columns)?;
93 let column = relation.column(columns.len());
94 projections.push((ProjectionTarget::Internal(column), expression));
95 columns.push((index, column));
96 }
97 Ok(columns)
98}
99
100pub struct AggregateKeyStatement {
101 pub statement: QueryBlockPlan,
102 pub targets: Vec<(usize, InternalColumnRef)>,
103 pub distinct_on: Vec<(usize, InternalColumnRef)>,
104 pub order_by: Vec<(usize, InternalColumnRef)>,
105}
106
107pub fn prepare_aggregate_key_statement(
108 statement: &QueryBlockPlan,
109) -> Result<Option<AggregateKeyStatement>, SQLError> {
110 let output = identity_order_columns(&projection_columns(&statement.projections));
111 let mut prepared: Option<QueryBlockPlan> = None;
112 let relation = uqa_sql::ast::InternalRelationId::allocate();
113 let mut targets = Vec::new();
114 let mut distinct_on = Vec::new();
115 let mut order_by = Vec::new();
116 for (index, expression) in statement.distinct_on.iter().enumerate() {
117 if prior_distinct_key_index(statement, index, expression, &output)?.is_some() {
118 continue;
119 }
120 if distinct_output_target_position(statement, expression, &output)?.is_some() {
121 continue;
122 }
123 let expression = resolve_order_expression(expression, &output)?;
124 let prepared = prepared.get_or_insert_with(|| statement.clone());
125 let position = prepared.projections.len();
126 let column = relation.column(targets.len());
127 prepared.projections.push(ProjectionPlan {
128 expr: expression,
129 alias: None,
130 });
131 targets.push((position, column));
132 distinct_on.push((index, column));
133 }
134 for (index, order) in statement.order_by.iter().enumerate() {
135 if let Some(target) = output_target_position(statement, &order.expr, &output)? {
136 if !target.direct {
137 prepared.get_or_insert_with(|| statement.clone()).order_by[index].expr =
138 one_based_output_position(target.position)?;
139 }
140 continue;
141 }
142 let expression = resolve_order_expression(&order.expr, &output)?;
143 let current = prepared.as_ref().unwrap_or(statement);
144 let existing = current
145 .projections
146 .iter()
147 .enumerate()
148 .find(|(_, projection)| {
149 uqa_sql::semantics::aggregates::exprs_match(&projection.expr, &expression)
150 })
151 .map(|(position, _)| position);
152 let prepared = prepared.get_or_insert_with(|| statement.clone());
153 let key = if let Some(position) = existing {
154 if let Some((_, column)) = targets
155 .iter()
156 .find(|(target_position, _)| *target_position == position)
157 {
158 order_by.push((index, *column));
159 ScalarExpr::InternalColumn(*column)
160 } else {
161 ScalarExpr::Position(position)
162 }
163 } else {
164 let position = prepared.projections.len();
165 let column = relation.column(targets.len());
166 prepared.projections.push(ProjectionPlan {
167 expr: expression,
168 alias: None,
169 });
170 targets.push((position, column));
171 order_by.push((index, column));
172 ScalarExpr::InternalColumn(column)
173 };
174 prepared.order_by[index].expr = key;
175 }
176 Ok(prepared.map(|statement| AggregateKeyStatement {
177 statement,
178 targets,
179 distinct_on,
180 order_by,
181 }))
182}