uqa-sql 0.5.2

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

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

//! Untyped destinations cannot erase assignment indirection.

use super::*;
use crate::ScalarExpr;
use uqa_core::Value;

#[test]
fn partial_assignment_requires_a_declared_container_type() {
    let index = Box::new(ScalarExpr::Literal(Value::Int(1)));
    for step in [
        AssignmentStep::Index(index.clone()),
        AssignmentStep::Slice {
            lower: None,
            upper: Some(index),
        },
    ] {
        let target = AssignmentTarget {
            column: "value".into(),
            indirection: vec![step],
        };
        let error = validate_assignment_type(&target, None).unwrap_err();
        assert_eq!(error.sqlstate(), Some("42804"));
        assert_eq!(
            error.to_string(),
            "cannot subscript type unknown because it does not support subscripting"
        );
        validate_assignment_type(
            &target,
            Some(&ColumnType::Array(Box::new(ColumnType::Integer))),
        )
        .unwrap();
    }
    validate_assignment_type(
        &AssignmentTarget::<ScalarExpr>::from("value".to_string()),
        None,
    )
    .unwrap();
}

#[test]
fn untyped_field_assignment_does_not_become_a_whole_column_write() {
    let target = AssignmentTarget::<ScalarExpr> {
        column: "value".into(),
        indirection: vec![AssignmentStep::Field("part".into())],
    };
    let error = validate_assignment_type(&target, None).unwrap_err();
    assert_eq!(error.sqlstate(), Some("42804"));
    assert_eq!(error.to_string(), "cannot assign to field \"part\" of column \"value\" because its type unknown is not a composite type");
}

struct PairCatalog;

impl crate::expr::composites::CompositeTypeCatalog for PairCatalog {
    fn composite_type(
        &self,
        type_oid: u32,
    ) -> Result<Option<std::sync::Arc<crate::expr::composites::CompositeTypeDescriptor>>, SQLError>
    {
        Ok((type_oid == 30_002).then(|| {
            std::sync::Arc::new(crate::expr::composites::CompositeTypeDescriptor {
                type_oid,
                relation_oid: 30_001,
                attributes: vec![
                    crate::expr::composites::CompositeAttribute {
                        name: "x".into(),
                        ty: ColumnType::Integer,
                        number: 1,
                    },
                    crate::expr::composites::CompositeAttribute {
                        name: "tags".into(),
                        ty: ColumnType::Array(Box::new(ColumnType::Text)),
                        number: 2,
                    },
                ],
            })
        }))
    }
}

fn pair_type() -> ColumnType {
    ColumnType::Composite(crate::ast::CompositeTypeReference {
        schema: "public".into(),
        name: "pair".into(),
        oid: 30_002,
        array_oid: 30_003,
        relation_oid: 30_001,
    })
}

#[test]
fn field_assignments_walk_composite_fields_and_subscript_groups() {
    let index = || Box::new(ScalarExpr::Literal(Value::Int(1)));
    let target = |indirection: Vec<AssignmentStep<ScalarExpr>>| AssignmentTarget {
        column: "p".into(),
        indirection,
    };
    let array_of_pairs = ColumnType::Array(Box::new(pair_type()));
    let element_field = target(vec![
        AssignmentStep::Index(index()),
        AssignmentStep::Field("tags".into()),
        AssignmentStep::Index(index()),
    ]);
    assert!(has_field_step(&element_field));
    assert_eq!(assignment_levels(&element_field.indirection).len(), 3);
    assert_eq!(
        field_assignment_types(&element_field, &array_of_pairs, Some(&PairCatalog))
            .unwrap()
            .last(),
        Some(&ColumnType::Text)
    );
    let missing = field_assignment_types(
        &target(vec![AssignmentStep::Field("missing".into())]),
        &pair_type(),
        Some(&PairCatalog),
    )
    .unwrap_err();
    assert_eq!(missing.sqlstate(), Some("42703"));
    assert_eq!(
        missing.to_string(),
        "cannot assign to field \"missing\" of column \"p\" because there is no such column in data type pair"
    );
    let scalar = field_assignment_types(
        &target(vec![
            AssignmentStep::Field("x".into()),
            AssignmentStep::Field("y".into()),
        ]),
        &pair_type(),
        Some(&PairCatalog),
    )
    .unwrap_err();
    assert_eq!(scalar.sqlstate(), Some("42804"));
    assert_eq!(
        scalar.to_string(),
        "cannot assign to field \"y\" of column \"p\" because its type integer is not a composite type"
    );
    let subscripted = field_assignment_types(
        &target(vec![
            AssignmentStep::Field("x".into()),
            AssignmentStep::Index(index()),
        ]),
        &pair_type(),
        Some(&PairCatalog),
    )
    .unwrap_err();
    assert_eq!(
        subscripted.to_string(),
        "cannot subscript type integer because it does not support subscripting"
    );
    let mismatch = validate_assignment_source(
        &target(vec![AssignmentStep::Field("x".into())]),
        &ColumnType::Integer,
        Some(&ColumnType::Boolean),
    )
    .unwrap_err();
    assert_eq!(
        mismatch.to_string(),
        "subfield \"x\" is of type integer but expression is of type boolean"
    );
}