uqa-sql 0.5.4

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

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

use super::evaluate;
use uqa_core::{
    memory::{MemoryBudget, ProductionControl},
    CancellationToken, Value,
};

#[test]
fn escape_results_retain_their_entire_buffer_and_release_temporary_inputs() {
    for (similar, arguments) in [
        (
            false,
            vec![Value::Str("a!_b\\c".into()), Value::Str("!".into())],
        ),
        (
            false,
            vec![
                Value::Bytes(vec![0xff, b'!', b'_', b'\\']),
                Value::Bytes(vec![b'!']),
            ],
        ),
        (true, vec![Value::Str("a%_b".into())]),
    ] {
        let memory = MemoryBudget::new(4096);
        let original = CancellationToken::new();
        let invoking = CancellationToken::new();
        let control = ProductionControl::new(&memory, &original, &invoking);
        let result = evaluate(similar, &arguments, &control).unwrap();
        let capacity = match &*result {
            Value::Str(text) => text.capacity(),
            Value::Bytes(bytes) => bytes.capacity(),
            value => panic!("unexpected escape result {value:?}"),
        };
        assert!(capacity > 0);
        assert_eq!(memory.used(), capacity);
        invoking.cancel();
        assert_eq!(memory.used(), capacity);
        drop(result);
        assert_eq!(memory.used(), 0);
    }
}

#[test]
fn escape_failure_nulls_and_both_cancellation_owners_release_admitted_buffers() {
    for (similar, arguments, state) in [
        (
            false,
            vec![Value::Bytes(vec![b'\\'; 1024]), Value::Bytes(Vec::new())],
            "53200",
        ),
        (
            false,
            vec![Value::Str("\\".repeat(128)), Value::Str(String::new())],
            "53200",
        ),
        (true, vec![Value::Str("%".repeat(128))], "53200"),
        (
            false,
            vec![Value::Str("a".into()), Value::Str("!!".into())],
            "22025",
        ),
        (
            false,
            vec![Value::Bytes(vec![0xff]), Value::Bytes(vec![0xff, 0xfe])],
            "22025",
        ),
    ] {
        let memory = MemoryBudget::new(256);
        let token = CancellationToken::new();
        let control = ProductionControl::new(&memory, &token, &token);
        assert_eq!(
            evaluate(similar, &arguments, &control)
                .err()
                .unwrap()
                .sqlstate(),
            Some(state)
        );
        assert_eq!(memory.used(), 0);
    }
    for original_owner in [false, true] {
        let memory = MemoryBudget::new(0);
        let original = CancellationToken::new();
        let invoking = CancellationToken::new();
        let control = ProductionControl::new(&memory, &original, &invoking);
        let arguments = [Value::Null, Value::Str("invalid escape".into())];
        let result = evaluate(false, &arguments, &control).unwrap();
        assert_eq!(*result, Value::Null);
        assert_eq!(memory.used(), 0);
        drop(result);
        if original_owner {
            original.cancel();
        } else {
            invoking.cancel();
        }
        assert_eq!(
            evaluate(false, &arguments, &control)
                .err()
                .unwrap()
                .sqlstate(),
            Some("57014")
        );
        assert_eq!(memory.used(), 0);
    }
}