use crate::core::index::index_reader::Identity;
use crate::core::index::index_reader_context::IndexReaderContext;
use crate::core::index::terms::{Terms, TermsPosting};
use crate::core::index::terms_enum::TermsEnum;
use crate::core::search::automaton_query::AutomatonQuery;
use crate::core::search::fuzzy_query::FuzzyQuery;
use crate::core::search::index_searcher::IndexSearcher;
use crate::core::search::multi_term_query_constant_score_blended_wrapper::MultiTermQueryConstantScoreBlendedWrapper;
use crate::core::search::multi_term_query_constant_score_wrapper::MultiTermQueryConstantScoreWrapper;
use crate::core::search::prefix_query::PrefixQuery;
use crate::core::search::query::{IntoQuery, Query, QueryBase, QueryWeight};
use crate::core::search::query_visitor::QueryVisitor;
use crate::core::search::regexp_query::RegexpQuery;
use crate::core::search::score_mode::ScoreMode;
use crate::core::search::similarities_impl::similarities::Similarity;
use crate::core::search::term_in_set_query::TermInSetQuery;
use crate::core::search::term_range_query::TermRangeQuery;
use crate::core::search::wildcard_query::WildcardQuery;
use crate::core::util::HasIdentity;
use crate::core::util::accountable::Accountable;
use crate::core::util::error::lucene_error::Result;
use crate::impl_from_for_enum;
#[cfg(test)]
use crate::test_framework::core::search::multi_term::BoostCheckingQuery;
#[cfg(test)]
use crate::test_framework::core::search::multi_term::DumbPrefixQuery;
#[cfg(test)]
use crate::test_framework::core::search::multi_term::DumbRegexpQuery;
use std::fmt::Debug;
use std::sync::Arc;
pub trait MultiTermQuery: QueryBase + Clone {
fn get_field(&self) -> &str;
type TermsEnum<T>: TermsEnum<PostingsEnum = TermsPosting<T>>
where
T: Terms;
fn get_terms_enum<T>(&self, terms: T) -> Result<Self::TermsEnum<T>>
where
T: Terms + Clone;
fn get_terms_count(&self) -> i64 {
-1
}
fn to_query(&self) -> Query;
}
pub trait RewriteMethod {
fn rewrite<IRC, Q, SIM>(
&self,
index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync;
fn get_terms_enum<M, T>(&self, query: &M, terms: T) -> Result<<M as MultiTermQuery>::TermsEnum<T>>
where
M: MultiTermQuery,
T: Terms + Clone,
{
query.get_terms_enum(terms)
}
}
#[derive(Default, Clone, Debug, PartialEq, Eq, Hash)]
pub struct ConstantScoreBlendedRewrite;
impl RewriteMethod for ConstantScoreBlendedRewrite {
fn rewrite<IRC, Q, SIM>(
&self,
_index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
{
Ok(MultiTermQueryConstantScoreBlendedWrapper::new(query.clone()).into())
}
}
#[derive(Default, Clone, Debug, PartialEq, Eq, Hash)]
pub struct ConstantScoreRewrite;
impl RewriteMethod for ConstantScoreRewrite {
fn rewrite<IRC, Q, SIM>(
&self,
_index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
{
Ok(MultiTermQueryConstantScoreWrapper::new(query.clone()).into())
}
}
pub const DOC_VALUES_REWRITE: DocValuesRewriteMethod = DocValuesRewriteMethod;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum RewriteMethodEnum {
Blended(ConstantScoreBlendedRewrite),
ConstantScoreBoolean(ConstantScoreBooleanRewrite),
DocValues(DocValuesRewriteMethod),
ScoringBoolean(ScoringBooleanRewrite),
Standard(ConstantScoreRewrite),
TopTermsBlendedFreqScoring(TopTermsBlendedFreqScoringRewrite),
TopTermsBoostOnlyBoolean(TopTermsBoostOnlyBooleanQueryRewrite),
TopTermsScoringBoolean(TopTermsScoringBooleanQueryRewrite),
}
impl RewriteMethod for RewriteMethodEnum {
fn rewrite<IRC, Q, SIM>(
&self,
index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
{
match self {
RewriteMethodEnum::Blended(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::ConstantScoreBoolean(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::DocValues(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::ScoringBoolean(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::Standard(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::TopTermsBlendedFreqScoring(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::TopTermsBoostOnlyBoolean(r) => r.rewrite(index_searcher, query),
RewriteMethodEnum::TopTermsScoringBoolean(r) => r.rewrite(index_searcher, query),
}
}
}
pub const SCORING_BOOLEAN_REWRITE: ScoringBooleanRewrite = ScoringBooleanRewrite;
pub const CONSTANT_SCORE_BOOLEAN_REWRITE: ConstantScoreBooleanRewrite = ConstantScoreBooleanRewrite;
impl_from_for_enum!(
RewriteMethodEnum,
ConstantScoreBlendedRewrite => Blended,
ConstantScoreBooleanRewrite => ConstantScoreBoolean,
DocValuesRewriteMethod => DocValues,
ScoringBooleanRewrite => ScoringBoolean,
ConstantScoreRewrite => Standard,
TopTermsBlendedFreqScoringRewrite => TopTermsBlendedFreqScoring,
TopTermsBoostOnlyBooleanQueryRewrite => TopTermsBoostOnlyBoolean,
TopTermsScoringBooleanQueryRewrite => TopTermsScoringBoolean,
);
macro_rules! dispatch_multi_term_query {
($self:expr, |$inner:ident| $body:expr) => {{
match $self {
MultiTermQuerySet::Prefix($inner) => $body,
MultiTermQuerySet::TermRange($inner) => $body,
MultiTermQuerySet::Automaton($inner) => $body,
MultiTermQuerySet::Fuzzy($inner) => $body,
MultiTermQuerySet::TermInSet($inner) => $body,
MultiTermQuerySet::Wildcard($inner) => $body,
MultiTermQuerySet::Regexp($inner) => $body,
#[cfg(test)]
MultiTermQuerySet::BoostChecking($inner) => $body,
#[cfg(test)]
MultiTermQuerySet::DumbPrefix($inner) => $body,
#[cfg(test)]
MultiTermQuerySet::DumbRegexp($inner) => $body,
}
}};
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TopTermsScoringBooleanQueryRewrite {
size: usize,
}
impl TopTermsScoringBooleanQueryRewrite {
pub fn new(size: usize) -> Self {
Self { size }
}
}
impl TermCollectingRewrite for TopTermsScoringBooleanQueryRewrite {
type B = boolean_query::Builder;
fn get_top_level_builder(&self) -> Result<Self::B> {
Ok(boolean_query::Builder::new())
}
fn build(&self, builder: Self::B) -> Result<Query> {
Ok(builder.build().into())
}
fn add_clause_with_states(
&self,
top_level: &mut Self::B,
term: Term,
_doc_count: i32,
boost: f32,
states: Option<TermStates>,
) -> Result<()> {
let tq = TermQuery::with_term_state(term, states.map(Arc::new));
top_level.add(BoostQuery::new(tq, boost)?, Occur::Should)?;
Ok(())
}
}
impl RewriteMethod for TopTermsScoringBooleanQueryRewrite {
fn rewrite<IRC, Q, SIM>(
&self,
index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
{
self.default_rewrite(index_searcher, query)
}
}
impl TopTermsRewrite for TopTermsScoringBooleanQueryRewrite {
fn get_size(&self) -> usize {
self.size
}
fn get_max_size(&self) -> usize {
index_searcher::get_max_clause_count()
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TopTermsBlendedFreqScoringRewrite {
size: usize,
}
impl TopTermsBlendedFreqScoringRewrite {
pub fn new(size: usize) -> Self {
Self { size }
}
}
impl TermCollectingRewrite for TopTermsBlendedFreqScoringRewrite {
type B = blended_term_query::Builder;
fn get_top_level_builder(&self) -> Result<Self::B> {
let mut builder = blended_term_query::Builder::new();
builder.set_rewrite_method(BooleanRewrite);
Ok(builder)
}
fn build(&self, builder: Self::B) -> Result<Query> {
Ok(builder.build()?.into())
}
fn add_clause_with_states(
&self,
top_level: &mut Self::B,
term: Term,
_doc_count: i32,
boost: f32,
states: Option<TermStates>,
) -> Result<()> {
top_level.add_with_term_states(term, boost, states.map(Arc::new))?;
Ok(())
}
}
impl RewriteMethod for TopTermsBlendedFreqScoringRewrite {
fn rewrite<IRC, Q, SIM>(
&self,
index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
{
self.default_rewrite(index_searcher, query)
}
}
impl TopTermsRewrite for TopTermsBlendedFreqScoringRewrite {
fn get_size(&self) -> usize {
self.size
}
fn get_max_size(&self) -> usize {
index_searcher::get_max_clause_count()
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TopTermsBoostOnlyBooleanQueryRewrite {
size: usize,
}
impl TopTermsBoostOnlyBooleanQueryRewrite {
pub fn new(size: usize) -> Self {
Self { size }
}
}
impl TermCollectingRewrite for TopTermsBoostOnlyBooleanQueryRewrite {
type B = boolean_query::Builder;
fn get_top_level_builder(&self) -> Result<Self::B> {
Ok(boolean_query::Builder::new())
}
fn build(&self, builder: Self::B) -> Result<Query> {
Ok(builder.build().into())
}
fn add_clause_with_states(
&self,
top_level: &mut Self::B,
term: Term,
_doc_count: i32,
boost: f32,
states: Option<TermStates>,
) -> Result<()> {
let tq = TermQuery::with_term_state(term, states.map(Arc::new));
let q = ConstantScoreQuery::new(tq);
top_level.add(BoostQuery::new(q, boost)?, Occur::Should)?;
Ok(())
}
}
impl RewriteMethod for TopTermsBoostOnlyBooleanQueryRewrite {
fn rewrite<IRC, Q, SIM>(
&self,
index_searcher: &IndexSearcher<IRC, SIM>,
query: &Q,
) -> Result<Query>
where
SIM: Similarity,
Q: MultiTermQuery + Into<MultiTermQuerySet>,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
{
self.default_rewrite(index_searcher, query)
}
}
impl TopTermsRewrite for TopTermsBoostOnlyBooleanQueryRewrite {
fn get_size(&self) -> usize {
self.size
}
fn get_max_size(&self) -> usize {
index_searcher::get_max_clause_count()
}
}
use crate::core::index::term::Term;
use crate::core::index::term_states::TermStates;
use crate::core::search::blended_term_query::BooleanRewrite;
use crate::core::search::boolean_clause::Occur;
use crate::core::search::boost_query::BoostQuery;
use crate::core::search::constant_score_query::ConstantScoreQuery;
use crate::core::search::doc_values_rewrite_method::DocValuesRewriteMethod;
use crate::core::search::scoring_rewrite::{ConstantScoreBooleanRewrite, ScoringBooleanRewrite};
use crate::core::search::term_collecting_rewrite::TermCollectingRewrite;
use crate::core::search::term_query::TermQuery;
use crate::core::search::top_terms_rewrite::TopTermsRewrite;
use crate::core::search::{blended_term_query, boolean_query, index_searcher};
pub(crate) use dispatch_multi_term_query;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum MultiTermQuerySet {
Automaton(AutomatonQuery),
Fuzzy(FuzzyQuery),
Prefix(PrefixQuery),
Regexp(RegexpQuery),
TermInSet(TermInSetQuery),
TermRange(TermRangeQuery),
Wildcard(WildcardQuery),
#[cfg(test)]
BoostChecking(BoostCheckingQuery),
#[cfg(test)]
DumbPrefix(DumbPrefixQuery),
#[cfg(test)]
DumbRegexp(DumbRegexpQuery),
}
impl QueryBase for MultiTermQuerySet {
type Weight<IRC, SIM>
= QueryWeight<IRC, SIM>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static;
fn to_string(&self, field: &str) -> Result<String> {
dispatch_multi_term_query!(self, |q| q.to_string(field))
}
fn create_weight<IRC, SIM>(
self,
searcher: &IndexSearcher<IRC, SIM>,
score_mode: &ScoreMode,
boost: f32,
) -> Result<Self::Weight<IRC, SIM>>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
Self: Sized,
{
dispatch_multi_term_query!(self, |q| q.create_weight(searcher, score_mode, boost))
}
fn rewrite<IRC, SIM>(&self, searcher: &IndexSearcher<IRC, SIM>) -> Result<Option<Query>>
where
SIM: Similarity,
IRC: IndexReaderContext + 'static,
IndexSearcher<IRC, SIM>: Sync,
Self: Sized,
{
dispatch_multi_term_query!(self, |q| q.rewrite(searcher))
}
fn visit<QV>(&self, visitor: &mut QV) -> Result<()>
where
QV: QueryVisitor,
{
dispatch_multi_term_query!(self, |q| q.visit(visitor))
}
}
impl Accountable for MultiTermQuerySet {
fn ram_bytes_used(&self) -> Result<i64> {
dispatch_multi_term_query!(self, |q| q.ram_bytes_used())
}
}
impl HasIdentity for MultiTermQuerySet {
fn identity(&self) -> &Identity {
dispatch_multi_term_query!(self, |q| q.identity())
}
}
impl_from_for_enum!(
MultiTermQuerySet,
AutomatonQuery => Automaton,
FuzzyQuery => Fuzzy,
PrefixQuery => Prefix,
RegexpQuery => Regexp,
TermInSetQuery => TermInSet,
TermRangeQuery => TermRange,
WildcardQuery => Wildcard,
);
#[cfg(test)]
impl_from_for_enum!(
MultiTermQuerySet,
BoostCheckingQuery => BoostChecking,
DumbPrefixQuery => DumbPrefix,
DumbRegexpQuery => DumbRegexp,
);
macro_rules! impl_into_query_for_multi_term_query {
($($ty:ty),* $(,)?) => {
$(
impl IntoQuery for $ty {
fn into_query(self) -> Query {
MultiTermQuerySet::from(self).into()
}
}
)*
};
}
impl_into_query_for_multi_term_query!(
AutomatonQuery,
FuzzyQuery,
PrefixQuery,
RegexpQuery,
TermInSetQuery,
TermRangeQuery,
WildcardQuery,
);
#[cfg(test)]
impl_into_query_for_multi_term_query!(BoostCheckingQuery, DumbPrefixQuery, DumbRegexpQuery,);