uqa-sql 0.5.0

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! GROUP BY input-column precedence and output-name fallback after source binding.

use std::borrow::Cow;

use crate::plan::{ProjectionPlan, QueryBlockPlan};
use crate::routines::RoutineResolution;
use crate::{RowSchema, SQLError, SQLParam, ScalarExpr};

/// An unqualified input column wins even when its lookup is ambiguous. Output names are considered only for a whole bare name, never inside an expression. `schema` holds the query's own columns over `outer`, the scope of the queries that enclose it, whose columns do not take a name before an output column.
pub fn resolve_grouping_expression<'a>(
    routines: &dyn RoutineResolution,
    expression: &'a ScalarExpr,
    projections: &'a [ProjectionPlan],
    schema: &RowSchema,
    outer: Option<&RowSchema>,
    params: &[SQLParam],
) -> Result<Cow<'a, ScalarExpr>, SQLError> {
    let resolved = resolve_grouping_expression_reference(
        routines,
        expression,
        projections,
        schema,
        outer,
        params,
    )?;
    Ok(if std::ptr::eq(resolved, expression) {
        Cow::Borrowed(expression)
    } else {
        Cow::Owned(resolved.clone())
    })
}

/// Borrow the original grouped expression or its projection, preserving input-literal identity during prepared analysis.
pub(crate) fn resolve_grouping_expression_reference<'a>(
    routines: &dyn RoutineResolution,
    expression: &'a ScalarExpr,
    projections: &'a [ProjectionPlan],
    schema: &RowSchema,
    outer: Option<&RowSchema>,
    params: &[SQLParam],
) -> Result<&'a ScalarExpr, SQLError> {
    let mut resolved = expression;
    if let ScalarExpr::Column(name) = expression {
        if !is_input_column(schema, outer, name) {
            let mut matches = projections
                .iter()
                .filter(|projection| crate::semantics::projection_label_at(projection) == *name);
            if let Some(first) = matches.next() {
                resolved = &first.expr;
                let mut identity = None;
                for candidate in matches {
                    let first_identity = match &identity {
                        Some(identity) => identity,
                        None => identity.insert(super::expression_identity(
                            routines, resolved, schema, params,
                        )?),
                    };
                    if *first_identity
                        != super::expression_identity(routines, &candidate.expr, schema, params)?
                    {
                        return Err(SQLError::Routine {
                            sqlstate: "42702".into(),
                            message: format!("GROUP BY \"{name}\" is ambiguous"),
                        });
                    }
                }
            }
        }
    }
    if crate::semantics::aggregates::contains_aggregate(
        &|name: &str| routines.has_registered_aggregate_function(name),
        resolved,
    ) {
        return Err(SQLError::Routine {
            sqlstate: "42803".into(),
            message: "aggregate functions are not allowed in GROUP BY".into(),
        });
    }
    if resolved.contains_window() {
        return Err(SQLError::Routine {
            sqlstate: "42P20".into(),
            message: "window functions are not allowed in GROUP BY".into(),
        });
    }
    Ok(resolved)
}

/// Whether `name` is a column of the query's own sources, ambiguous or not, in `schema`, which holds those columns over `outer`: `findTargetlistEntrySQL92` looks for a GROUP BY name among the columns of the query's own level only.
fn is_input_column(schema: &RowSchema, outer: Option<&RowSchema>, name: &str) -> bool {
    if !schema.has_unqualified_column(name) {
        return false;
    }
    let Some(outer) = outer else {
        return true;
    };
    let own_width = schema
        .physical_width()
        .saturating_sub(outer.physical_width());
    schema.column_slot(name).is_none_or(|slot| slot < own_width)
}

/// Bind grouping expressions before storing a query or executing its aggregation. Returns whether an output name was replaced.
pub fn bind_grouping_names(
    routines: &dyn RoutineResolution,
    statement: &mut QueryBlockPlan,
    schema: &RowSchema,
    outer: Option<&RowSchema>,
    params: &[SQLParam],
) -> Result<bool, SQLError> {
    let mut changed = false;
    for expression in statement
        .group_by
        .iter_mut()
        .chain(statement.grouping_sets.iter_mut().flatten())
    {
        if let Cow::Owned(resolved) = resolve_grouping_expression(
            routines,
            expression,
            &statement.projections,
            schema,
            outer,
            params,
        )? {
            *expression = resolved;
            changed = true;
        }
    }
    Ok(changed)
}