uqa-sql 0.4.9

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

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

use super::*;
use uqa_core::Value;

fn call(name: &str, args: Vec<ScalarExpr>) -> ScalarExpr {
    ScalarExpr::Func {
        name: name.into(),
        binding: None,
        args,
        distinct: false,
        order_by: Vec::new(),
        filter: None,
    }
}

#[test]
fn diskann_explain_description_keeps_field_identity_without_evaluating_deferred_values() {
    let expression = call(
        "knn_match",
        vec![
            ScalarExpr::QualifiedColumn {
                qualifier: "d".into(),
                column: "embedding".into(),
            },
            call("volatile_vector", vec![]),
            ScalarExpr::Literal(Value::Int(3)),
        ],
    );
    let constants = RetrievalConstants {
        params: &[],
        evaluate: &|_, _| panic!("deferred arguments must not run"),
        stores: &|_: &str| false,
    };
    let description = describe_vector_call(&expression, &constants, &|_| false)
        .unwrap()
        .unwrap();
    assert_eq!(description.field.as_deref(), Some("embedding"));
    assert_eq!(description.qualifier.as_deref(), Some("d"));
    assert!(description.bound.is_none());
    assert!(!description.invalid_arguments);
    let invalid = call("knn_match", vec![call("volatile_field", vec![])]);
    assert!(matches!(
        describe_vector_call(&invalid, &constants, &|_| false),
        Err(SQLError::BadArity { .. })
    ));
}

#[test]
fn diskann_explain_description_reuses_the_checked_vector_contract() {
    let constants = RetrievalConstants {
        params: &[],
        evaluate: &|expression, _| match expression {
            ScalarExpr::Literal(value) => Ok(value.clone()),
            _ => Err(SQLError::Internal(
                "fixture contains a nonliteral value".into(),
            )),
        },
        stores: &|_: &str| false,
    };
    let args = vec![
        ScalarExpr::Column("embedding".into()),
        ScalarExpr::Array(vec![
            ScalarExpr::Literal(Value::Int(1)),
            ScalarExpr::Literal(Value::Int(0)),
        ]),
        ScalarExpr::Literal(Value::Int(3)),
    ];
    let expression = call("knn_match", args.clone());
    let description = describe_vector_call(&expression, &constants, &|_| true)
        .unwrap()
        .unwrap();
    assert!(
        matches!(description.bound, Some(RetrievalExpr::KNN { query_vector, k: 3, .. }) if query_vector == [1.0, 0.0])
    );
    let mut invalid = args;
    invalid[2] = ScalarExpr::Literal(Value::Int(0));
    let description = describe_vector_call(&call("knn_match", invalid), &constants, &|_| true)
        .unwrap()
        .unwrap();
    assert!(
        description.bound.is_none(),
        "a rejected SQL K must not become an executable diagnostic query"
    );
    assert!(description.invalid_arguments);
}