uqa-sql 0.5.3

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

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

//! `PostgreSQL` 18.6 rejects comparison keys during analysis, including empty inputs.

use super::*;

const COMPARISON_KEYS: &[(&str, &str, &str)] = &[
    ("SELECT DISTINCT 'ignored'::void", "equality", "void"),
    (
        "SELECT DISTINCT 'ignored'::void WHERE false",
        "equality",
        "void",
    ),
    ("SELECT DISTINCT '{}'::json", "equality", "json"),
    (
        "SELECT DISTINCT * FROM (SELECT 'ignored'::void AS v) AS s",
        "equality",
        "void",
    ),
    ("SELECT DISTINCT ON ('ignored'::void) 1", "equality", "void"),
    ("SELECT DISTINCT ON (1) 'ignored'::void", "equality", "void"),
    (
        "SELECT DISTINCT ON (v) 'ignored'::void AS v",
        "equality",
        "void",
    ),
    ("SELECT 'ignored'::void GROUP BY 1", "equality", "void"),
    ("SELECT 'ignored'::void AS v GROUP BY v", "equality", "void"),
    (
        "SELECT 'ignored'::void GROUP BY GROUPING SETS ((1), ())",
        "equality",
        "void",
    ),
    ("SELECT 'ignored'::void ORDER BY 1", "ordering", "void"),
    ("SELECT 'ignored'::void AS v ORDER BY v", "ordering", "void"),
    (
        "SELECT 1 ORDER BY 'ignored'::void LIMIT 0",
        "ordering",
        "void",
    ),
    (
        "SELECT 'left'::void UNION ALL SELECT 'right'::void ORDER BY 1",
        "ordering",
        "void",
    ),
    ("SELECT count(DISTINCT 'ignored'::void)", "equality", "void"),
    (
        "SELECT array_agg(1 ORDER BY 'ignored'::void)",
        "ordering",
        "void",
    ),
    (
        "SELECT row_number() OVER (PARTITION BY 'ignored'::void)",
        "equality",
        "void",
    ),
    (
        "SELECT row_number() OVER (ORDER BY 'ignored'::void)",
        "ordering",
        "void",
    ),
    (
        "SELECT 1 WINDOW unused AS (PARTITION BY 'ignored'::void)",
        "equality",
        "void",
    ),
    (
        "SELECT 1 WINDOW unused AS (ORDER BY 'ignored'::void)",
        "ordering",
        "void",
    ),
    (
        "SELECT 'left'::void UNION SELECT 'right'::void",
        "equality",
        "void",
    ),
];

#[test]
fn comparison_keys_require_operators_before_execution() {
    let mut mismatches = Vec::new();
    for &(sql, operator, ty) in COMPARISON_KEYS {
        for prepared in [false, true] {
            match analyze_key(sql, prepared) {
                Err(error)
                    if error.sqlstate() == Some("42883")
                        && error.to_string()
                            == format!(
                                "could not identify an {operator} operator for type {ty}"
                            )
                        && error.hint()
                            == (operator == "ordering").then_some(
                                "Use an explicit ordering operator or modify the query.",
                            ) => {}
                result => mismatches.push(format!("prepared={prepared} {sql}: {result:?}")),
            }
        }
    }
    assert!(mismatches.is_empty(), "{}", mismatches.join("\n"));
}

#[test]
fn output_types_without_comparison_remain_valid() {
    for sql in [
        "SELECT 'ignored'::void",
        "SELECT '{}'::json",
        "SELECT DISTINCT ON (1) 1, 'ignored'::void",
        "SELECT 'ignored'::void, 1 GROUP BY 2",
        "SELECT 'ignored'::void, 1 ORDER BY 2",
        "SELECT 'ignored'::void ORDER BY 1::integer",
        "SELECT 'ignored'::void ORDER BY 1 + 0",
        "SELECT 'left'::void UNION ALL SELECT 'right'::void",
    ] {
        for prepared in [false, true] {
            analyze_key(sql, prepared)
                .unwrap_or_else(|error| panic!("prepared={prepared} {sql}: {error}"));
        }
    }
}

fn analyze_key(sql: &str, prepared: bool) -> Result<(), SQLError> {
    let scopes = Scopes::default();
    if !prepared {
        return analyze(&scopes, sql);
    }
    let scope = Scope(&scopes);
    let context = scope.binding_context()?;
    let plan = UnifiedPlan::lower(crate::compile(sql)?.remove(0));
    crate::binding::infer_prepared_parameter_types(&NoRoutines, &plan, &[], &context).map(|_| ())
}