mant-query 0.11.0

Bounded semantic queries over existing ManT document snapshots
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

//! One page budget schedule shared by single-document and scoped explanations.
use super::{
    materialize::{self, Budget},
    plan::CollectionPlan,
    support::Pool,
};
use mant_protocol::{EvidenceClass, ScopedExplanationEvidence};

pub(super) struct Page {
    pub evidence: Vec<ScopedExplanationEvidence>,
    pub pools: Vec<Pool>,
}

/// Selection contains (document, candidate, global ordinal). All direct facts
/// are reserved before any body, all necessary direct bodies before optional
/// metadata/windows or weaker evidence. Collection/order is never rerun here.
pub(super) fn materialize(
    plans: &[CollectionPlan<'_>],
    selected: &[(usize, usize, u32)],
    budget: &mut Budget,
) -> Page {
    let mut pools = (0..plans.len())
        .map(|_| Pool::default())
        .collect::<Vec<_>>();
    let mut evidence = selected
        .iter()
        .map(|&(doc, index, ordinal)| {
            let plan = &plans[doc];
            let candidate = &plan.candidates[index];
            let mut deferred = Budget(0);
            let record = materialize::prepare(
                ordinal,
                candidate,
                &plan.located,
                if candidate.class() == EvidenceClass::DirectEntry {
                    budget
                } else {
                    &mut deferred
                },
            );
            ScopedExplanationEvidence {
                document_index: doc,
                evidence: record,
            }
        })
        .collect::<Vec<_>>();
    let mut body_order = (0..selected.len()).collect::<Vec<_>>();
    // Materialization order is independent of evidence ordering. Selected
    // outer source fragments cover nested groups without forcing unselected
    // ancestors into an inner-only page.
    body_order.sort_by_key(|&slot| {
        let (doc, index, _) = selected[slot];
        (
            doc,
            plans[doc]
                .supports
                .depth(plans[doc].candidates[index].located),
        )
    });
    for slot in body_order {
        let (doc, index, _) = selected[slot];
        let result = &mut evidence[slot];
        let plan = &plans[doc];
        let candidate = &plan.candidates[index];
        if candidate.class() == EvidenceClass::DirectEntry {
            plan.supports.attach(
                candidate.located,
                &mut result.evidence,
                &plan.located,
                &mut pools[doc],
                budget,
            );
            plan.supports.attach_owner(
                candidate.located,
                &mut result.evidence,
                &pools[doc],
                budget,
            );
            materialize::body(&mut result.evidence, candidate, &plan.located, budget);
            plan.supports.share_owner(
                candidate.located,
                selected
                    .iter()
                    .filter_map(|&(selected_doc, selected_index, _)| {
                        let candidate = &plans[selected_doc].candidates[selected_index];
                        (selected_doc == doc && candidate.class() == EvidenceClass::DirectEntry)
                            .then_some(candidate.located)
                            .flatten()
                    }),
                &mut result.evidence,
                &mut pools[doc],
                budget,
            );
        }
    }
    for (&(doc, index, ordinal), result) in selected.iter().zip(&mut evidence) {
        let plan = &plans[doc];
        let candidate = &plan.candidates[index];
        if candidate.class() != EvidenceClass::DirectEntry {
            result.evidence = materialize::prepare(ordinal, candidate, &plan.located, budget);
            materialize::body(&mut result.evidence, candidate, &plan.located, budget);
        }
        materialize::materialize(
            &mut result.evidence,
            candidate,
            &plan.located,
            &plan.rejected_aliases,
            budget,
        );
    }
    Page { evidence, pools }
}