uqa-fdw 0.3.0

Foreign data wrappers (DuckDB, Arrow IPC)
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

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

use super::*;

fn domain(base: ColumnType) -> ColumnType {
    ColumnType::Domain {
        schema: "public".into(),
        name: "wrapped".into(),
        oid: 1,
        base: Box::new(base),
    }
}

#[test]
fn nested_domains_retain_their_array_or_scalar_base_classification() {
    assert!(column_type_is_array(&domain(domain(ColumnType::Array(
        Box::new(ColumnType::Integer)
    )))));
    assert!(!column_type_is_array(&domain(domain(ColumnType::Integer))));
    assert!(!column_type_is_array(&ColumnType::JsonB));
}

#[test]
fn rectangular_lists_become_sql_arrays_without_changing_unselected_columns() {
    let elements = vec![
        Value::List(vec![Value::Int(1), Value::Int(2)]),
        Value::List(vec![Value::Int(3), Value::Int(4)]),
    ];
    let untouched = Value::List(vec![Value::Str("payload".into())]);
    let result = normalize_array_columns(
        Row::from([
            ("matrix".into(), Value::List(elements.clone())),
            ("payload".into(), untouched.clone()),
        ]),
        &["matrix".into()],
    )
    .unwrap();
    let Value::Array(array) = &result["matrix"] else {
        panic!("expected array")
    };
    assert_eq!(array.dimensions(), &[2, 2]);
    assert_eq!(array.lower_bounds(), &[1, 1]);
    assert_eq!(array.elements(), &elements);
    assert_eq!(result["payload"], untouched);
}

#[test]
fn null_missing_values_and_existing_array_bounds_are_preserved() {
    let array = Value::Array(
        ArrayValue::with_lower_bounds(vec![Value::Int(7), Value::Int(8)], vec![-3]).unwrap(),
    );
    let row = Row::from([("bounded".into(), array), ("nullable".into(), Value::Null)]);
    assert_eq!(
        normalize_array_columns(
            row.clone(),
            &["bounded".into(), "nullable".into(), "absent".into()]
        )
        .unwrap(),
        row
    );
}

#[test]
fn ragged_dimensions_are_rejected_with_the_foreign_column_name() {
    let row = Row::from([(
        "matrix".into(),
        Value::List(vec![
            Value::List(vec![Value::Int(1)]),
            Value::List(vec![Value::Int(2), Value::Int(3)]),
        ]),
    )]);
    assert_eq!(
        normalize_array_columns(row, &["matrix".into()]).unwrap_err(),
        "foreign array column `matrix` contains non-rectangular dimensions"
    );
}

#[test]
fn scalar_values_are_rejected_for_declared_array_columns() {
    let row = Row::from([("items".into(), Value::Int(5))]);
    assert_eq!(
        normalize_array_columns(row, &["items".into()]).unwrap_err(),
        "foreign array column `items` requires an array value, got Int(5)"
    );
}