uqa-execution 0.3.0

Volcano physical operators with row-batch pipelines
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

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

//! Complete Boolean text scores and their calibration units from the same execution.

use super::{
    scored_term_count, DriverResult, OperatorTree, PhysicalRetrievalDriver, PostingList, SQLError,
};

impl PhysicalRetrievalDriver<'_> {
    pub(super) fn execute_counted_text_query(
        &self,
        source: &OperatorTree,
    ) -> DriverResult<(PostingList, usize)> {
        match source {
            OperatorTree::Phrase {
                query,
                field,
                scoring,
            } => self.execute_phrase_counted(query, field.as_deref(), *scoring),
            OperatorTree::Intersect(children) | OperatorTree::Union(children) => {
                let mut result: Option<PostingList> = None;
                let mut units = 0_usize;
                for child in children {
                    self.context.runtime.check_cancelled()?;
                    let (rows, count) = self.execute_counted_text_query(child)?;
                    units = units.checked_add(count).ok_or_else(|| {
                        SQLError::Internal("text query calibration count overflow".into())
                    })?;
                    result = Some(match result {
                        None => rows,
                        Some(previous) if matches!(source, OperatorTree::Intersect(_)) => {
                            previous.merge_intersection_owned(&rows)
                        }
                        Some(previous) => previous.merge_union(&rows),
                    });
                }
                Ok((result.unwrap_or_default(), units))
            }
            // Complements have no scoring contribution. Other carriers keep their existing calibration contract.
            _ => self
                .execute_posting_node(source)
                .map(|rows| (rows, scored_term_count(source))),
        }
    }
}