pallet 0.7.0

Document store built with sled and tantivy
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

/// Datastore `id`, scored according to search performance
pub struct ScoredId {
    pub id: u64,
    pub score: f32,
}

/// Like `tantivy`'s `TopDocs` collector, but without any limit
///
/// Returns `ScoredId`, a container for the datastore `id` and search score.
pub struct ScoredIds {
    pub size_hint: Option<usize>,
    pub id_field: tantivy::schema::Field,
}

// Used by the `ScoredIds` collector.
#[doc(hidden)]
pub struct ScoredIdsSegmentCollector {
    id_field_reader: Option<tantivy::fastfield::FastFieldReader<u64>>,
    buffer: Vec<ScoredId>,
}

impl tantivy::collector::Collector for ScoredIds {
    type Fruit = Vec<ScoredId>;
    type Child = ScoredIdsSegmentCollector;

    fn for_segment(
        &self,
        _segment_local_id: tantivy::SegmentLocalId,
        segment: &tantivy::SegmentReader,
    ) -> tantivy::Result<Self::Child> {
        Ok(ScoredIdsSegmentCollector {
            buffer: self.size_hint.map(Vec::with_capacity).unwrap_or_else(Vec::new),
            id_field_reader: segment.fast_fields().u64(self.id_field.clone()).ok(),
        })
    }

    fn requires_scoring(&self) -> bool {
        true
    }

    fn merge_fruits(&self, segment_fruits: Vec<Self::Fruit>) -> tantivy::Result<Self::Fruit> {
        let mut out = segment_fruits.into_iter().flatten().collect::<Vec<_>>();
        out.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or_else(|| a.id.cmp(&b.id)));
        Ok(out)
    }
}

impl tantivy::collector::SegmentCollector for ScoredIdsSegmentCollector {
    type Fruit = Vec<ScoredId>;

    fn collect(&mut self, doc: tantivy::DocId, score: tantivy::Score) {
        if let Some(ref id_field_reader) = self.id_field_reader {
            self.buffer.push(ScoredId { score, id: id_field_reader.get(doc) });
        }
    }

    fn harvest(self) -> Self::Fruit {
        self.buffer
    }
}