uqa-operators 0.1.9

Operator trait and primitives: term, vector, filter, score, boolean, hybrid
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

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

//! Boolean operators: union, intersect, complement.

use std::sync::Arc;

use uqa_core::{IndexStats, Payload, PostingEntry, PostingList};

use crate::base::{missing_backend, ExecutionContext, Operator, OperatorResult};

pub struct UnionOperator {
    pub operands: Vec<Arc<dyn Operator>>,
}

impl UnionOperator {
    pub fn new(operands: Vec<Arc<dyn Operator>>) -> Self {
        Self { operands }
    }
}

impl Operator for UnionOperator {
    fn execute(&self, ctx: &ExecutionContext) -> OperatorResult {
        let mut result = PostingList::new();
        for operand in &self.operands {
            result = result.merge_union(&operand.execute(ctx)?);
        }
        Ok(result)
    }

    fn cost_estimate(&self, stats: &IndexStats) -> f64 {
        self.operands.iter().map(|op| op.cost_estimate(stats)).sum()
    }
}

pub struct IntersectOperator {
    pub operands: Vec<Arc<dyn Operator>>,
}

impl IntersectOperator {
    pub fn new(operands: Vec<Arc<dyn Operator>>) -> Self {
        Self { operands }
    }
}

impl Operator for IntersectOperator {
    fn execute(&self, ctx: &ExecutionContext) -> OperatorResult {
        let mut iter = self.operands.iter();
        let Some(first) = iter.next() else {
            return Ok(PostingList::new());
        };
        let mut acc = first.execute(ctx)?;
        for op in iter {
            if acc.is_empty() {
                return Ok(acc);
            }
            acc = acc.merge_intersection_owned(&op.execute(ctx)?);
        }
        Ok(acc)
    }

    fn cost_estimate(&self, stats: &IndexStats) -> f64 {
        self.operands
            .iter()
            .map(|op| op.cost_estimate(stats))
            .fold(f64::INFINITY, f64::min)
            .max(0.0)
    }
}

/// Complement with respect to the universal set drawn from
/// `ctx.document_store.doc_ids()`.
pub struct ComplementOperator {
    pub operand: Arc<dyn Operator>,
}

impl ComplementOperator {
    pub fn new(operand: Arc<dyn Operator>) -> Self {
        Self { operand }
    }
}

impl Operator for ComplementOperator {
    fn execute(&self, ctx: &ExecutionContext) -> OperatorResult {
        let result = self.operand.execute(ctx)?;
        let Some(doc_store) = ctx.document_store.as_ref() else {
            return Err(missing_backend("document-store", "boolean complement"));
        };
        let universal_entries: Vec<PostingEntry> = doc_store
            .doc_ids()?
            .into_iter()
            .map(|id| PostingEntry::new(id, Payload::default()))
            .collect();
        let universal = PostingList::from_sorted_unchecked(universal_entries);
        Ok(universal.exclude(&result))
    }

    fn cost_estimate(&self, stats: &IndexStats) -> f64 {
        stats.total_docs as f64
    }
}