uqa-engine 0.1.12

Engine: schema-aware table store, catalog restore, transactions
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

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

use super::*;

#[test]
fn combine_filters_handles_empty_and_single_inputs_without_panicking() {
    assert!(combine_filters(Vec::<ScalarExpr>::new()).is_none());
    let combined = combine_filters([ScalarExpr::Literal(Value::Bool(true))]);
    assert!(matches!(
        combined,
        Some(ScalarExpr::Literal(Value::Bool(true)))
    ));
}

#[test]
fn engine_backed_projection_functions_reject_a_missing_engine_context() {
    let row = ResultRow::new();
    for function in [
        "deep_learn",
        "graph_create",
        "graph_drop",
        "create_graph",
        "drop_graph",
    ] {
        let mut evaluate = |_: &ScalarExpr| Ok(Value::Null);
        let error = engine_func_intercept(None, function, &[], &row, &mut evaluate)
            .expect_err("engine-backed functions must not report success without an engine");
        assert!(
            matches!(
                &error,
                SQLError::Unsupported(message)
                    if message == &format!("{function} requires an engine-backed projection")
            ),
            "unexpected {function} error: {error:?}"
        );
    }
}

#[test]
fn score_projection_uses_explicit_provenance_even_for_zero() {
    use uqa_execution::{OwnedPhysicalRow, PhysicalRow, RowSchema};

    let args = [ScalarExpr::Literal(Value::Str("query".into()))];
    let mut evaluate = |expr: &ScalarExpr| match expr {
        ScalarExpr::Literal(value) => Ok(value.clone()),
        _ => Ok(Value::Null),
    };
    let score_column = uqa_sql::ast::InternalRelationId::allocate().column(0);
    let schema = RowSchema::with_qualified_types(
        "hit",
        vec!["body".into(), super::super::SCORE_COLUMN.into()],
        vec![None, None],
    );
    let schema = RowSchema::with_physical_internal_aliases(&schema, &[(score_column, 1, None)]);
    let schema = RowSchema::with_score_source(&schema, Some("hit"), score_column);
    let scored_row = OwnedPhysicalRow::new(
        schema,
        PhysicalRow::from_values(vec![Value::Str("rust".into()), Value::Float(0.0)]),
    );
    assert_eq!(
        engine_func_intercept(None, "score_bm25", &args, &scored_row, &mut evaluate).unwrap(),
        Some(Value::Float(0.0))
    );

    let unscored_schema = RowSchema::with_qualified_types(
        "plain",
        vec!["body".into(), super::super::SCORE_COLUMN.into()],
        vec![None, None],
    );
    let unscored_row = OwnedPhysicalRow::new(
        unscored_schema,
        PhysicalRow::from_values(vec![Value::Str("rust".into()), Value::Float(0.0)]),
    );
    let error =
        engine_func_intercept(None, "score_bm25", &args, &unscored_row, &mut evaluate).unwrap_err();
    assert!(error.to_string().contains("score-bearing"), "{error}");
}

#[test]
fn qualified_score_projection_uses_structured_provenance_identity() {
    use uqa_execution::{OwnedPhysicalRow, PhysicalRow, RowSchema};

    let score_column = uqa_sql::ast::InternalRelationId::allocate().column(0);
    let schema = RowSchema::with_qualified_types(
        "hit",
        vec!["body".into(), super::super::SCORE_COLUMN.into()],
        vec![None, None],
    );
    let schema = RowSchema::with_physical_internal_aliases(&schema, &[(score_column, 1, None)]);
    let schema = RowSchema::with_score_source(&schema, Some("hit"), score_column);
    let row = OwnedPhysicalRow::new(
        schema,
        PhysicalRow::from_values(vec![Value::Str("rust".into()), Value::Float(0.25)]),
    );
    let args = [
        ScalarExpr::qualified_column("hit", "body"),
        ScalarExpr::Literal(Value::Str("rust".into())),
    ];
    let mut evaluate = |expr: &ScalarExpr| match expr {
        ScalarExpr::Literal(value) => Ok(value.clone()),
        _ => Ok(Value::Null),
    };
    assert_eq!(
        engine_func_intercept(None, "score_bm25", &args, &row, &mut evaluate).unwrap(),
        Some(Value::Float(0.25))
    );
}