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
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

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

use super::*;
use crate::assignment::vectors::index_vectors_for_type;
use uqa_core::{ArrayValue, DecimalValue};

#[test]
fn converted_vectors_match_assignment_and_keep_all_buffer_capacities_charged() {
    let values = vec![
        Value::Int(-7),
        Value::Float(0.5),
        Value::Decimal(DecimalValue::parse("1.25").unwrap()),
    ];
    let tensor = vec![Value::List(values.clone()), Value::List(values.clone())];
    for (value, ty) in [
        (Value::List(values.clone()), ColumnType::Vector(3)),
        (
            Value::Array(ArrayValue::with_lower_bounds(values, vec![-2]).unwrap()),
            ColumnType::Vector(3),
        ),
        (Value::List(tensor.clone()), ColumnType::Tensor(3)),
        (
            Value::Array(ArrayValue::with_lower_bounds(tensor, vec![-1, 4]).unwrap()),
            ColumnType::Tensor(3),
        ),
        (Value::List(Vec::new()), ColumnType::Tensor(3)),
        (Value::Null, ColumnType::Vector(3)),
    ] {
        let memory = MemoryBudget::new(4096);
        let converted =
            index_vectors_for_type_budgeted(&value, &ty, &memory, &mut || Ok(())).unwrap();
        assert_eq!(*converted, index_vectors_for_type(&value, &ty).unwrap());
        let bytes = converted.capacity() * size_of::<Vec<f32>>()
            + converted
                .iter()
                .map(|vector| vector.capacity() * size_of::<f32>())
                .sum::<usize>();
        assert_eq!(converted.reserved_bytes(), bytes);
        assert_eq!(memory.used(), bytes);
        drop(converted);
        assert_eq!(memory.used(), 0);
    }
}

#[test]
fn invalid_shapes_and_numeric_elements_preserve_assignment_diagnostics() {
    for (value, ty) in [
        (Value::Int(1), ColumnType::Vector(2)),
        (Value::List(vec![Value::Int(1)]), ColumnType::Vector(2)),
        (
            Value::List(vec![Value::Float(f64::NAN)]),
            ColumnType::Vector(1),
        ),
        (
            Value::List(vec![Value::Float(f64::MAX)]),
            ColumnType::Vector(1),
        ),
        (
            Value::List(vec![Value::Str("1".into())]),
            ColumnType::Vector(1),
        ),
        (Value::List(vec![Value::Int(1)]), ColumnType::Tensor(1)),
        (
            Value::List(vec![
                Value::List(vec![Value::Int(1)]),
                Value::List(vec![Value::Str("invalid".into())]),
            ]),
            ColumnType::Tensor(2),
        ),
        (
            Value::Array(ArrayValue::try_new(vec![Value::List(vec![Value::Int(1)])]).unwrap()),
            ColumnType::Vector(1),
        ),
        (Value::List(Vec::new()), ColumnType::Text),
    ] {
        let memory = MemoryBudget::new(4096);
        let expected = index_vectors_for_type(&value, &ty).unwrap_err();
        let actual =
            index_vectors_for_type_budgeted(&value, &ty, &memory, &mut || Ok(())).unwrap_err();
        assert_eq!(actual.sqlstate(), expected.sqlstate());
        assert_eq!(actual.to_string(), expected.to_string());
        assert_eq!(memory.used(), 0);
    }
}

#[test]
fn quota_rejection_precedes_float_buffer_allocation_and_leaves_inputs_unchanged() {
    let value = Value::List(vec![Value::Int(1); 1024]);
    let original = value.clone();
    let memory = MemoryBudget::new(size_of::<Vec<f32>>());
    let error =
        index_vectors_for_type_budgeted(&value, &ColumnType::Vector(1024), &memory, &mut || Ok(()))
            .unwrap_err();
    assert_eq!(error.sqlstate(), Some("53200"));
    assert_eq!(value, original);
    assert_eq!(memory.peak(), size_of::<Vec<f32>>());
    assert_eq!(memory.used(), 0);
}

#[test]
fn cancellation_during_each_tensor_conversion_step_releases_partial_buffers() {
    let value = Value::List(vec![Value::List(vec![Value::Int(1); 32]); 2]);
    for cancel_at in 1..=70 {
        let memory = MemoryBudget::new(4096);
        let mut polls = 0;
        let error =
            index_vectors_for_type_budgeted(&value, &ColumnType::Tensor(32), &memory, &mut || {
                polls += 1;
                if polls == cancel_at {
                    Err(QueryCancelled)
                } else {
                    Ok(())
                }
            })
            .unwrap_err();
        assert_eq!(error.sqlstate(), Some("57014"));
        assert_eq!(memory.used(), 0);
    }
}