use crate::core::index::index_reader::IndexReader;
use crate::core::index::index_reader_context::{IRCLeafReader, IndexReaderContext};
use crate::core::index::leaf_reader_context::LeafReaderContext;
use crate::core::search::abstract_multi_term_query_constant_score_wrapper::BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD;
use crate::core::search::boolean_clause::Occur;
use crate::core::search::boolean_clause::Occur::{Filter, Must};
use crate::core::search::boolean_query::BooleanQuery;
use crate::core::search::boolean_scorer_supplier::BooleanScorerSupplier;
use crate::core::search::doc_id_set_iterator::DocIdSetIterator;
use crate::core::search::explanation::Explanation;
use crate::core::search::index_searcher::IndexSearcher;
use crate::core::search::matches_utils::from_sub_matches;
use crate::core::search::query::QueryRef;
use crate::core::search::query::{QueryBase, QueryWeight};
use crate::core::search::scorable::Scorable;
use crate::core::search::score_mode::ScoreMode;
use crate::core::search::segment_cacheable::SegmentCacheable;
use crate::core::search::similarities_impl::similarities::Similarity;
use crate::core::search::weight::Weight;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use std::collections::HashMap;
pub struct BooleanWeight<
IRC: IndexReaderContext + 'static,
SIM = crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
> where
SIM: Similarity,
{
pub(crate) weighted_clauses: Box<[WeightedBooleanClause<IRC, SIM>]>,
pub(crate) query: BooleanQuery,
pub(crate) score_mode: ScoreMode,
}
impl<IRC, SIM> BooleanWeight<IRC, SIM>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static,
{
fn req_count(
&self,
context: &LeafReaderContext<IRCLeafReader<IRC>>,
searcher: &IndexSearcher<IRC, SIM>,
) -> Result<i32>
where
IndexSearcher<IRC, SIM>: Sync,
{
let num_docs = context.reader().num_docs()?;
let mut req_count = num_docs;
for weighted_clause in &self.weighted_clauses {
if !self.query.clauses()[weighted_clause.clause_index].is_required() {
continue;
}
let count = weighted_clause.weight.count(context, searcher)?;
if count == -1 || count == 0 {
return Ok(count);
} else if count == num_docs {
} else if req_count == num_docs {
req_count = count;
} else {
return Ok(-1);
}
}
Ok(req_count)
}
fn opt_count(
&self,
context: &LeafReaderContext<IRCLeafReader<IRC>>,
occur: Occur,
searcher: &IndexSearcher<IRC, SIM>,
) -> Result<i32>
where
IndexSearcher<IRC, SIM>: Sync,
{
let num_docs = context.reader().num_docs()?;
let mut opt_count = 0i32;
let mut unknown_count = false;
for weighted_clause in &self.weighted_clauses {
if *self.query.clauses()[weighted_clause.clause_index].occur() != occur {
continue;
}
let count = weighted_clause.weight.count(context, searcher)?;
if count == -1 {
unknown_count = true;
continue;
} else if count == num_docs {
return Ok(count);
} else if count == 0 {
} else if opt_count == 0 {
opt_count = count;
} else {
unknown_count = true;
}
}
Ok(if unknown_count { -1 } else { opt_count })
}
}
impl<IRC, SIM> SegmentCacheable<IRC> for BooleanWeight<IRC, SIM>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static,
{
fn is_cacheable(&self, ctx: &LeafReaderContext<IRCLeafReader<IRC>>) -> Result<bool> {
if self.query.clauses().len() > BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD {
return Ok(false);
}
for wc in &self.weighted_clauses {
if !wc.weight.is_cacheable(ctx)? {
return Ok(false);
}
}
Ok(true)
}
}
impl<IRC, SIM> Weight<IRC, SIM> for BooleanWeight<IRC, SIM>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static,
{
fn matches<'a>(
&'a self,
context: &'a LeafReaderContext<IRCLeafReader<IRC>>,
doc: i32,
searcher: &'a IndexSearcher<IRC, SIM>,
) -> Result<Option<crate::core::search::query::QueryWeightMatches<'a, IRC, SIM>>>
where
IndexSearcher<IRC, SIM>: Sync,
{
let mut matches = Vec::new();
let mut should_match_count = 0;
for weighted_clause in &self.weighted_clauses {
let clause = &self.query.clauses()[weighted_clause.clause_index];
let clause_matches = weighted_clause.weight.matches(context, doc, searcher)?;
if clause.is_prohibited() {
if clause_matches.is_some() {
return Ok(None);
}
} else if clause.is_required() {
let Some(clause_matches) = clause_matches else {
return Ok(None);
};
matches.push(clause_matches);
} else if let Some(clause_matches) = clause_matches {
matches.push(clause_matches);
should_match_count += 1;
}
}
if should_match_count < self.query.get_minimum_number_should_match() {
return Ok(None);
}
Ok(from_sub_matches(matches))
}
fn explain(
&self,
context: &LeafReaderContext<IRCLeafReader<IRC>>,
doc: i32,
searcher: &IndexSearcher<IRC, SIM>,
) -> Result<Explanation>
where
IndexSearcher<IRC, SIM>: Sync,
{
let min_should_match = self.query.get_minimum_number_should_match();
let mut subs: Vec<Explanation> = Vec::with_capacity(self.weighted_clauses.len());
let mut fail = false;
let mut match_count = 0;
let mut should_match_count = 0;
for wc in &self.weighted_clauses {
let clause = &self.query.clauses()[wc.clause_index];
let weight = &wc.weight;
let e = weight.explain(context, doc, searcher)?;
if e.is_match() {
if clause.is_scoring() {
subs.push(e);
} else if clause.is_required() {
subs.push(Explanation::match_(
0.0,
"match on required clause, product of:",
vec![
Explanation::match_(0.0, format!("{} clause", Occur::Filter), vec![]),
e,
],
));
} else if clause.is_prohibited() {
subs.push(Explanation::no_match(
format!(
"match on prohibited clause ({})",
clause.query.to_string("")?
),
vec![e],
));
fail = true;
}
if !clause.is_prohibited() {
match_count += 1;
}
if clause.occur() == &Occur::Should {
should_match_count += 1;
}
} else if clause.is_required() {
subs.push(Explanation::no_match(
format!(
"no match on required clause ({})",
clause.query.to_string("")?
),
vec![e],
));
fail = true;
}
}
if fail {
Ok(Explanation::no_match(
"Failure to meet condition(s) of required/prohibited clause(s)",
subs,
))
} else if match_count == 0 {
Ok(Explanation::no_match("No matching clauses", subs))
} else if should_match_count < min_should_match {
Ok(Explanation::no_match(
format!(
"Failure to match minimum number of optional clauses: {}",
min_should_match
),
subs,
))
} else {
let mut scorer = self
.scorer(context, searcher)?
.ok_or_else(|| LuceneError::illegal_state("no scorer available for explanation"))?;
let advanced = scorer.advance(doc)?;
debug_assert!(advanced == doc);
Ok(Explanation::match_(scorer.score()?, "sum of:", subs))
}
}
fn get_query(&self) -> QueryRef<'_> {
(&self.query).into()
}
type ScorerSupplier = BooleanScorerSupplier<IRC, SIM>;
fn scorer_supplier(
&self,
context: &LeafReaderContext<IRCLeafReader<IRC>>,
searcher: &IndexSearcher<IRC, SIM>,
) -> Result<Option<Self::ScorerSupplier>>
where
IndexSearcher<IRC, SIM>: Sync,
{
let mut min_should_match = self.query.get_minimum_number_should_match();
let mut must = Vec::new();
let mut should = Vec::new();
let mut filter = Vec::new();
let mut must_not = Vec::new();
for wc in &self.weighted_clauses {
let sub_supplier = wc.weight.scorer_supplier(context, searcher)?;
match sub_supplier {
None => {
if self.query.clauses()[wc.clause_index].is_required() {
return Ok(None);
}
},
Some(sub_scorer) => match self.query.clauses()[wc.clause_index].occur() {
Occur::Must => must.push(sub_scorer),
Occur::Should => should.push(sub_scorer),
Occur::Filter => filter.push(sub_scorer),
Occur::MustNot => must_not.push(sub_scorer),
},
}
}
if (should.len() as i32) == min_should_match {
if must.is_empty() {
must = std::mem::take(&mut should);
} else {
must.append(&mut should);
}
min_should_match = 0;
}
if (filter.is_empty() && must.is_empty() && should.is_empty())
|| (should.len() as i32) < min_should_match
{
return Ok(None);
}
if !self.score_mode.needs_scores() && min_should_match == 0 && (must.len() + filter.len()) > 0 {
should.clear();
}
let max_doc = context.reader().max_doc()?;
let mut scores = HashMap::with_capacity(4);
scores.insert(Occur::Must, must);
scores.insert(Occur::Should, should);
scores.insert(Occur::Filter, filter);
scores.insert(Occur::MustNot, must_not);
let v = BooleanScorerSupplier::new(scores, self.score_mode, min_should_match, max_doc)?;
Ok(Some(v))
}
fn count(
&self,
context: &LeafReaderContext<IRCLeafReader<IRC>>,
searcher: &IndexSearcher<IRC, SIM>,
) -> Result<i32>
where
IndexSearcher<IRC, SIM>: Sync,
{
let num_docs = context.reader().num_docs()?;
if self.query.is_pure_disjunction() {
return self.opt_count(context, Occur::Should, searcher);
}
let positive_count = if (!self.query.get_clauses_idx(Filter).is_empty()
|| !self.query.get_clauses_idx(Must).is_empty())
&& self.query.get_minimum_number_should_match() == 0
{
self.req_count(context, searcher)?
} else {
-1
};
if positive_count == 0 {
return Ok(0);
}
let prohibited_count = self.opt_count(context, Occur::MustNot, searcher)?;
if prohibited_count == -1 {
Ok(-1)
} else if prohibited_count == 0 {
Ok(positive_count)
} else if prohibited_count == num_docs {
Ok(0)
} else if positive_count == num_docs {
Ok(num_docs - prohibited_count)
} else {
Ok(-1)
}
}
#[cfg(test)]
fn as_any(&mut self) -> &mut dyn std::any::Any {
self
}
}
pub(crate) struct WeightedBooleanClause<
IRC: IndexReaderContext + 'static,
SIM = crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
> where
SIM: Similarity,
{
pub(crate) clause_index: usize,
pub(crate) weight: QueryWeight<IRC, SIM>,
}
impl<IRC, SIM> WeightedBooleanClause<IRC, SIM>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static,
{
pub(crate) fn new(clause_index: usize, weight: QueryWeight<IRC, SIM>) -> Self {
Self {
clause_index,
weight,
}
}
}