Skip to main content

uqa_execution/query/relational/
aggregation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Aggregate, DISTINCT, and ordering-key preparation.
8
9use 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            // Window output projection replaces the source schema, so an unselected sort expression must survive as an internal attribute until ordering consumes it.
68            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}