uqa-sql 0.4.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

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

//! `PostgreSQL` DROP target diagnostics and canonical target order.

use super::*;

struct Catalog;

impl RelationDropCatalog for Catalog {
    fn resolve_relation_kind(&self, name: &str) -> Result<RelationResolution, SQLError> {
        Ok(match name {
            "absent.item" => RelationResolution::MissingSchema("absent".into()),
            "missing" | "public.missing" => RelationResolution::MissingRelation,
            "z" | "public.z" => RelationResolution::Found("public.z".into(), "view"),
            "a" => RelationResolution::Found("public.a".into(), "view"),
            _ => RelationResolution::Found("public.t".into(), "table"),
        })
    }
    fn resolve_age_label_relation_name(&self, _: &str) -> Result<Option<String>, SQLError> {
        Ok(None)
    }
}

#[test]
fn drop_missing_targets_use_kind_specific_states_and_schema_notices() {
    for (kind, state, label) in [
        (DropKind::Table, "42P01", "table"),
        (DropKind::View, "42P01", "view"),
        (DropKind::MaterializedView, "42P01", "materialized view"),
        (DropKind::Sequence, "42P01", "sequence"),
        (DropKind::ForeignTable, "42704", "foreign table"),
    ] {
        for (name, expected, message) in [
            (
                "public.missing",
                state,
                format!("{label} \"missing\" does not exist"),
            ),
            (
                "absent.item",
                "3F000",
                "schema \"absent\" does not exist".into(),
            ),
        ] {
            let error =
                bind_relation_drop_target(&Catalog, name, kind, false, &mut |_| {}).unwrap_err();
            assert_eq!(error.sqlstate(), Some(expected));
            assert_eq!(error.to_string(), message);
            let mut notices = Vec::new();
            assert!(
                bind_relation_drop_target(&Catalog, name, kind, true, &mut |notice| notices
                    .push(notice.to_string()))
                .unwrap()
                .is_none()
            );
            assert_eq!(notices, [format!("{message}, skipping")]);
        }
    }
}

#[test]
fn drop_wrong_kind_is_an_error_even_with_if_exists() {
    for kind in [
        DropKind::View,
        DropKind::MaterializedView,
        DropKind::Sequence,
        DropKind::ForeignTable,
    ] {
        let error = bind_relation_drop_target(&Catalog, "public.t", kind, true, &mut |_| {
            panic!("wrong kind is not a notice")
        })
        .unwrap_err();
        assert_eq!(error.sqlstate(), Some("42809"));
        assert_eq!(
            error.to_string(),
            format!("\"t\" is not a {}", drop_relation_kind(kind))
        );
    }
}

#[test]
fn drop_deduplicates_canonical_targets_without_sorting_the_statement() {
    let stmt = DropStmt {
        kind: DropKind::View,
        names: vec!["z".into(), "a".into(), "public.z".into()],
        if_exists: false,
        cascade: false,
    };
    assert_eq!(
        bind_relation_drop_targets(&Catalog, &stmt, &mut |_| {}).unwrap(),
        ["public.z", "public.a"]
    );
}