uqa-planner 0.5.1

Cost model, cardinality, DPccp join enumeration, optimizer rewrites
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
124
125
126
127

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

//! Physical access domain classification with specific operator-join precedence.

use crate::AccessParadigm;
use uqa_operators::OperatorTree;

pub fn operator_tree_paradigm(tree: &OperatorTree) -> AccessParadigm {
    let mut text = false;
    let mut vector = false;
    let mut graph = false;
    let mut relational = false;
    let mut text_join = false;
    let mut vector_join = false;
    let mut graph_join = false;
    let mut hybrid_join = false;
    let mut cross_paradigm_join = false;
    tree.visit(&mut |node| match node {
        OperatorTree::Term { .. }
        | OperatorTree::BayesianScore { .. }
        | OperatorTree::BayesianMatchWithPrior { .. }
        | OperatorTree::MultiFieldSearch { .. } => text = true,
        OperatorTree::VectorSimilarity { .. }
        | OperatorTree::KNN { .. }
        | OperatorTree::CalibratedVectorMatch { .. }
        | OperatorTree::CosineProbability(_) => vector = true,
        OperatorTree::Traverse { .. }
        | OperatorTree::GraphNeighbors { .. }
        | OperatorTree::GraphEdges { .. }
        | OperatorTree::PatternMatch { .. }
        | OperatorTree::RegularPathQuery { .. }
        | OperatorTree::WeightedPathQuery { .. }
        | OperatorTree::PageRank { .. }
        | OperatorTree::HITS { .. }
        | OperatorTree::BetweennessCentrality { .. }
        | OperatorTree::TemporalTraverse { .. }
        | OperatorTree::TemporalPatternMatch { .. } => graph = true,
        OperatorTree::Filter { .. } | OperatorTree::IndexScan { .. } => relational = true,
        OperatorTree::TextSimilarityJoin { .. } => text_join = true,
        OperatorTree::VectorSimilarityJoin { .. } => vector_join = true,
        OperatorTree::GraphJoin { .. } => graph_join = true,
        OperatorTree::HybridJoin { .. } => hybrid_join = true,
        OperatorTree::CrossParadigmJoin { .. } => cross_paradigm_join = true,
        _ => {}
    });
    if cross_paradigm_join || graph && (text || vector || relational) {
        AccessParadigm::CrossParadigm
    } else if hybrid_join || text && vector || relational && (text || vector) {
        AccessParadigm::Hybrid
    } else if graph_join || graph {
        AccessParadigm::Graph
    } else if vector_join || vector {
        AccessParadigm::Vector
    } else if text_join || text {
        AccessParadigm::Text
    } else {
        AccessParadigm::Relational
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use uqa_core::Predicate;
    #[test]
    fn operator_join_paradigms_remain_specific() {
        let term = || OperatorTree::Term {
            query: "rust".into(),
            field: Some("body".into()),
            scoring: None,
            top_k: None,
        };
        let vector = || OperatorTree::KNN {
            query_vector: vec![1.0, 0.0],
            k: 3,
            field: "embedding".into(),
        };
        let filter = || OperatorTree::Filter {
            field: "category".into(),
            predicate: Predicate::IsNotNull,
            source: None,
        };
        assert_eq!(
            operator_tree_paradigm(&OperatorTree::TextSimilarityJoin {
                left: Box::new(term()),
                right: Box::new(term()),
                threshold: 0.5,
            }),
            AccessParadigm::Text
        );
        assert_eq!(
            operator_tree_paradigm(&OperatorTree::VectorSimilarityJoin {
                left: Box::new(vector()),
                right: Box::new(vector()),
                threshold: 0.5,
            }),
            AccessParadigm::Vector
        );
        assert_eq!(
            operator_tree_paradigm(&OperatorTree::GraphJoin {
                left: Box::new(OperatorTree::PageRank { graph: "g".into() }),
                right: Box::new(OperatorTree::PageRank { graph: "g".into() }),
                label: None,
                graph: "g".into(),
            }),
            AccessParadigm::Graph
        );
        assert_eq!(
            operator_tree_paradigm(&OperatorTree::HybridJoin {
                left: Box::new(OperatorTree::Intersect(vec![filter(), vector()])),
                right: Box::new(OperatorTree::Intersect(vec![filter(), vector()])),
            }),
            AccessParadigm::Hybrid
        );
        assert_eq!(
            operator_tree_paradigm(&OperatorTree::CrossParadigmJoin {
                left: Box::new(OperatorTree::PageRank { graph: "g".into() }),
                right: Box::new(filter()),
            }),
            AccessParadigm::CrossParadigm
        );
    }
}