lucisearch 0.8.1

Embeddable, in-process search engine — the SQLite/DuckDB of search
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

//! ConstantScoreQuery: wrap a query with a fixed score.
//!
//! Runs the inner query in filter context and returns a constant score
//! for all matching documents.
//!
//! See [[query-dsl#Compound Queries]] and [[architecture-query-execution#Step 6]].

use crate::core::{DocId, Result, ScoreMode, Scorer, TwoPhaseIterator};

use crate::query::{BoundQuery, Query, ScorerSupplier};
use crate::search::searcher::Searcher;
use crate::segment::reader::SegmentReader;

pub struct ConstantScoreQuery {
    pub(crate) inner: Box<dyn Query>,
    pub boost: f32,
}

impl Query for ConstantScoreQuery {
    fn bind(&self, searcher: &Searcher, _score_mode: ScoreMode) -> Result<Box<dyn BoundQuery>> {
        // Inner query runs in filter context
        let inner_weight = self.inner.bind(searcher, ScoreMode::CompleteNoScores)?;
        Ok(Box::new(BoundConstantScoreQuery {
            inner: inner_weight,
            boost: self.boost,
        }))
    }
}

struct BoundConstantScoreQuery {
    inner: Box<dyn BoundQuery>,
    boost: f32,
}

impl BoundQuery for BoundConstantScoreQuery {
    fn scorer_supplier(&self, reader: &SegmentReader) -> Result<Option<Box<dyn ScorerSupplier>>> {
        match self.inner.scorer_supplier(reader)? {
            Some(supplier) => Ok(Some(Box::new(ConstantScoreScorerSupplier {
                inner: supplier,
                boost: self.boost,
            }))),
            None => Ok(None),
        }
    }
}

struct ConstantScoreScorerSupplier {
    inner: Box<dyn ScorerSupplier>,
    boost: f32,
}

unsafe impl Send for ConstantScoreScorerSupplier {}

impl ScorerSupplier for ConstantScoreScorerSupplier {
    fn cost(&self) -> u64 {
        self.inner.cost()
    }

    fn scorer(self: Box<Self>) -> Result<Box<dyn Scorer>> {
        let inner = self.inner.scorer()?;
        Ok(Box::new(ConstantScoreScorer {
            inner,
            boost: self.boost,
        }))
    }
}

struct ConstantScoreScorer {
    inner: Box<dyn Scorer>,
    boost: f32,
}

impl Scorer for ConstantScoreScorer {
    fn doc_id(&self) -> DocId {
        self.inner.doc_id()
    }
    fn next(&mut self) -> DocId {
        self.inner.next()
    }
    fn advance(&mut self, target: DocId) -> DocId {
        self.inner.advance(target)
    }
    fn score(&mut self) -> f32 {
        self.boost
    }
    fn two_phase(&mut self) -> Option<&mut dyn TwoPhaseIterator> {
        self.inner.two_phase()
    }
}