use crate::core::document::document::Document;
use crate::core::document::field::Store::No;
use crate::core::document::field::{FieldBase, Store};
use crate::core::document::field_type::FieldType;
use crate::core::document::fields::Fields;
use crate::core::document::long_point::LongPoint;
use crate::core::document::string_field::StringField;
use crate::core::search::doc_id_set_iterator::DocIdSetIterator;
use crate::test_framework::core::util::lucene_test_case::{
at_least, new_directory_shared, new_index_writer_config, new_index_writer_config_with_analyzer,
new_log_merge_policy, new_search_executor, new_searcher_with_reader, new_string_field,
new_text_field, random, random_multiplier,
};
use std::borrow::Borrow;
use crate::core::index::directory_reader;
use crate::core::index::index_reader::IndexReader;
use crate::core::index::index_reader_context::{IRCLeafReader, IndexReaderContext};
use crate::core::index::index_writer::IndexWriter;
use crate::core::index::index_writer_config::IndexWriterConfig;
use crate::core::index::leaf_reader::LeafReader;
use crate::core::index::leaf_reader_context::LeafReaderContext;
use crate::core::index::live_index_writer_config::LiveIndexWriterConfig;
use crate::core::index::multi_reader::MultiReader;
use crate::core::index::term::Term;
use crate::core::search::boolean_clause::{BooleanClause, Occur};
use crate::core::search::boolean_query::{BooleanQuery, Builder};
use crate::core::search::boost_query::BoostQuery;
use crate::core::search::collector::Collector;
use crate::core::search::collector_manager::CollectorManager;
use crate::core::search::constant_score_query::ConstantScoreQuery;
use crate::core::search::disjunction_max_query::DisjunctionMaxQuery;
use crate::core::search::doc_id_set_iterator::NO_MORE_DOCS;
use crate::core::search::index_searcher::{
self, IndexSearcher, IndexSearcherHook, get_max_clause_count,
};
use crate::core::search::leaf_collector::LeafCollector;
use crate::core::search::match_all_docs_query::MatchAllDocsQuery;
use crate::core::search::multi_term_query::SCORING_BOOLEAN_REWRITE;
use crate::core::search::phrase_query::PhraseQuery;
use crate::core::search::query::{Query, QueryBase, QueryRef};
use crate::core::search::query_visitor::QueryVisitor;
use crate::core::search::scorable::Scorable;
use crate::core::search::score_doc::ScoreDoc;
use crate::core::search::score_mode::ScoreMode;
use crate::core::search::scorer::Scorer;
use crate::core::search::scorer::ScorerKind;
use crate::core::search::similarities_impl::classic_similarity;
use crate::core::search::simple_collector::SimpleCollector;
use crate::core::search::term_query::TermQuery;
use crate::core::search::top_docs::TopDocsLike;
use crate::core::search::weight::Weight;
use crate::core::search::wildcard_query::WildcardQuery;
use crate::core::util::CoreHelper;
use crate::core::util::automation::operations::Operations;
use crate::core::util::error::lucene_error::{LuceneError, LuceneErrorKind, Result};
use crate::core::util::fixed_bit_set::FixedBitSet;
use crate::test_framework::core::analysis::mock_analyzer::MockAnalyzer;
use crate::test_framework::core::index::random_index_writer::RandomIndexWriter;
use crate::test_framework::core::search::fixed_bit_set_collector::FixedBitSetCollector;
use crate::test_framework::core::search::query_utils::QueryUtils;
use crate::test_framework::core::search::test_boolean_query::CountingIndexSearcher;
use crate::test_framework::core::util::test_util::TestUtil;
use rand::RngExt;
use rand::prelude::SliceRandom;
use std::collections::HashMap;
use std::fmt::{Display, Formatter};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
#[allow(dead_code)] struct TestBooleanQuery;
#[test]
fn test_equality() -> Result<()> {
let mut bq1 = Builder::new();
bq1.add(
Query::Term(TermQuery::new(Term::from_text("field", "value1"))),
Occur::Should,
)?;
bq1.add(
Query::Term(TermQuery::new(Term::from_text("field", "value2"))),
Occur::Should,
)?;
let mut nested1 = Builder::new();
nested1.add(
Query::Term(TermQuery::new(Term::from_text("field", "nestedvalue1"))),
Occur::Should,
)?;
nested1.add(
Query::Term(TermQuery::new(Term::from_text("field", "nestedvalue2"))),
Occur::Should,
)?;
bq1.add(Query::Boolean(nested1.build()), Occur::Should)?;
let mut bq2 = Builder::new();
bq2.add(
Query::Term(TermQuery::new(Term::from_text("field", "value1"))),
Occur::Should,
)?;
bq2.add(
Query::Term(TermQuery::new(Term::from_text("field", "value2"))),
Occur::Should,
)?;
let mut nested2 = Builder::new();
nested2.add(
Query::Term(TermQuery::new(Term::from_text("field", "nestedvalue1"))),
Occur::Should,
)?;
nested2.add(
Query::Term(TermQuery::new(Term::from_text("field", "nestedvalue2"))),
Occur::Should,
)?;
bq2.add(Query::Boolean(nested2.build()), Occur::Should)?;
assert_eq!(bq1.build(), bq2.build());
Ok(())
}
#[test]
fn test_equality_does_not_depend_on_order() -> Result<()> {
let mut random = random();
let queries = [
TermQuery::new(Term::from_text("foo", "bar")),
TermQuery::new(Term::from_text("foo", "baz")),
];
for _ in 0..10 {
let num_clauses = random.random_range(0..20);
let mut clauses: Vec<BooleanClause> = Vec::with_capacity(num_clauses);
for _ in 0..num_clauses {
let mut query = if random.random_bool(0.5) {
Query::Term(queries[0].clone())
} else {
Query::Term(queries[1].clone())
};
if random.random_bool(0.5) {
let boost = random.random();
query = Query::Boost(BoostQuery::new(query, boost)?);
}
let occur = match random.random_range(0..4) {
0 => Occur::Must,
1 => Occur::Filter,
2 => Occur::Should,
_ => Occur::MustNot,
};
clauses.push(BooleanClause { query, occur });
}
let min_should_match = random.random_range(0..5);
let mut bq1_builder = Builder::new();
bq1_builder.set_minimum_number_should_match(min_should_match);
for clause in &clauses {
bq1_builder.add_clause(clause.clone())?;
}
let bq1 = bq1_builder.build();
clauses.shuffle(&mut random);
let mut bq2_builder = Builder::new();
bq2_builder.set_minimum_number_should_match(min_should_match);
for clause in clauses {
bq2_builder.add_clause(clause)?;
}
let bq2 = bq2_builder.build();
QueryUtils::check_equal(&bq1, &bq2)
}
Ok(())
}
#[test]
fn test_equality_on_duplicate_should_clauses() -> Result<()> {
let mut random = random();
let min_should_match = random.random_range(0..2);
let mut bq1_builder = Builder::new();
bq1_builder.set_minimum_number_should_match(min_should_match);
bq1_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Should)?;
let bq1 = bq1_builder.build();
let mut bq2_builder = Builder::new();
bq2_builder.set_minimum_number_should_match(bq1.get_minimum_number_should_match());
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Should)?;
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Should)?;
let bq2 = bq2_builder.build();
QueryUtils::check_unequal(&bq1, &bq2);
Ok(())
}
#[test]
fn test_equality_on_duplicate_must_clauses() -> Result<()> {
let mut random = random();
let min_should_match = random.random_range(0..2);
let mut bq1_builder = Builder::new();
bq1_builder.set_minimum_number_should_match(min_should_match);
bq1_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Must)?;
let bq1 = bq1_builder.build();
let mut bq2_builder = Builder::new();
bq2_builder.set_minimum_number_should_match(bq1.get_minimum_number_should_match());
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Must)?;
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Must)?;
let bq2 = bq2_builder.build();
QueryUtils::check_unequal(&bq1, &bq2);
Ok(())
}
#[test]
fn test_equality_on_duplicate_filter_clauses() -> Result<()> {
let mut random = random();
let min_should_match = random.random_range(0..2);
let mut bq1_builder = Builder::new();
bq1_builder.set_minimum_number_should_match(min_should_match);
bq1_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Filter)?;
let bq1 = bq1_builder.build();
let mut bq2_builder = Builder::new();
bq2_builder.set_minimum_number_should_match(bq1.get_minimum_number_should_match());
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Filter)?;
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Filter)?;
let bq2 = bq2_builder.build();
QueryUtils::check_equal(&bq1, &bq2);
Ok(())
}
#[test]
fn test_equality_on_duplicate_must_not_clauses() -> Result<()> {
let mut random = random();
let min_should_match = random.random_range(0..2);
let mut bq1_builder = Builder::new();
bq1_builder.set_minimum_number_should_match(min_should_match);
bq1_builder.add(Query::MatchAllDocs(MatchAllDocsQuery::new()), Occur::Must)?;
bq1_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Filter)?;
let bq1 = bq1_builder.build();
let mut bq2_builder = Builder::new();
bq2_builder.set_minimum_number_should_match(bq1.get_minimum_number_should_match());
bq2_builder.add(Query::MatchAllDocs(MatchAllDocsQuery::new()), Occur::Must)?;
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Filter)?;
bq2_builder.add(TermQuery::new(Term::from_text("foo", "bar")), Occur::Filter)?;
let bq2 = bq2_builder.build();
QueryUtils::check_equal(&bq1, &bq2);
Ok(())
}
#[test]
fn test_hash_code_is_stable() -> Result<()> {
let mut random = random();
let t1 = Term::from_text("foo", TestUtil::random_simple_string(&mut random));
let t2 = Term::from_text("foo", TestUtil::random_simple_string(&mut random));
let mut bq_builder = Builder::new();
bq_builder.add(TermQuery::new(t1), Occur::Should)?;
bq_builder.add(TermQuery::new(t2), Occur::Should)?;
let bq = bq_builder.build();
let hash1 = CoreHelper::calculate_hash(&bq);
assert_eq!(hash1, CoreHelper::calculate_hash(&bq));
Ok(())
}
#[test]
fn test_too_many_clauses() -> Result<()> {
let mut bq = Builder::new();
let max = get_max_clause_count();
for i in 0..max {
bq.add(
TermQuery::new(Term::new("foo", format!("bar-{}", i))),
Occur::Should,
)?;
}
let res = bq.add(
TermQuery::new(Term::from_text("foo", "bar-MAX")),
Occur::Should,
);
assert!(matches!(
res.as_ref().map_err(LuceneError::kind),
Err(LuceneErrorKind::TooManyClauses(_))
));
Ok(())
}
#[test]
fn test_null_or_sub_scorer() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let w = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c d",
Store::No,
&mut field_to_type,
)?);
w.add_document(&mut random, doc)?;
let reader = w.get_reader(&mut random)?;
let s =
crate::test_framework::core::util::lucene_test_case::new_searcher_with_reader_and_similarity(
reader,
std::sync::Arc::new(classic_similarity::new()),
)?;
let mut q = Builder::new();
q.add(TermQuery::new(Term::from_text("field", "a")), Occur::Should)?;
let pq = PhraseQuery::from_terms_no_slop("field", Vec::<&str>::new().as_slice())?;
q.add(pq, Occur::Should)?;
assert_eq!(1, s.search(q.build(), 10)?.total_hits.value());
let mut q = Builder::new();
let pq = PhraseQuery::from_terms_no_slop("field", Vec::<&str>::new().as_slice())?;
q.add(TermQuery::new(Term::from_text("field", "a")), Occur::Should)?;
q.add(pq.clone(), Occur::Must)?;
assert_eq!(0, s.search(q.build(), 10)?.total_hits.value());
let dmq = DisjunctionMaxQuery::new(
vec![
TermQuery::new(Term::from_text("field", "a")).into(),
pq.into(),
],
1.0,
)?;
assert_eq!(1, s.search(dmq, 10)?.total_hits.value());
w.close(&mut random)?;
Ok(())
}
#[test]
fn test_de_morgan() -> Result<()> {
let mut random = random();
let dir1 = new_directory_shared(&mut random)?;
let iw1 = RandomIndexWriter::new(&mut random, dir1)?;
let mut field_to_type = HashMap::new();
let mut doc1 = Document::new();
doc1.add(new_text_field(
&mut random,
"field",
"foo bar",
Store::No,
&mut field_to_type,
)?);
iw1.add_document(&mut random, doc1)?;
let reader1 = iw1.get_reader(&mut random)?;
iw1.close(&mut random)?;
let dir2 = new_directory_shared(&mut random)?;
let iw2 = RandomIndexWriter::new(&mut random, dir2)?;
let mut doc2 = Document::new();
doc2.add(new_text_field(
&mut random,
"field",
"foo baz",
Store::No,
&mut field_to_type,
)?);
iw2.add_document(&mut random, doc2)?;
let reader2 = iw2.get_reader(&mut random)?;
iw2.close(&mut random)?;
let mut query = Builder::new();
query.add(TermQuery::new(Term::from_text("field", "foo")), Occur::Must)?;
let wildcard_query = WildcardQuery::with_rewrite(
Term::from_text("field", "ba*"),
Operations::DEFAULT_DETERMINIZE_WORK_LIMIT as i32,
SCORING_BOOLEAN_REWRITE,
)?;
query.add(wildcard_query, Occur::MustNot)?;
let query = query.build();
let multi_reader = Arc::new(MultiReader::new(vec![reader1, reader2])?);
let searcher = new_searcher_with_reader(multi_reader.clone())?;
assert_eq!(0, searcher.search(query.clone(), 10)?.total_hits.value());
let searcher = index_searcher::from_reader_with_executor(multi_reader, new_search_executor(2)?)?;
assert_eq!(0, searcher.search(query, 10)?.total_hits.value());
Ok(())
}
#[test]
fn test_bs2_disjunction_next_vs_advance() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let num_docs = at_least(&mut random, 300);
for _doc_upto in 0..num_docs {
let mut contents = String::from("a");
if random.random_range(0..20) <= 16 {
contents.push_str(" b");
}
if random.random_range(0..20) <= 8 {
contents.push_str(" c");
}
if random.random_range(0..20) <= 4 {
contents.push_str(" d");
}
if random.random_range(0..20) <= 2 {
contents.push_str(" e");
}
if random.random_range(0..20) <= 1 {
contents.push_str(" f");
}
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
&contents,
Store::No,
&mut field_to_type,
)?);
writer.add_document(&mut random, doc)?;
}
writer.force_merge(&mut random, 1)?;
let reader = writer.get_reader(&mut random)?;
let searcher = new_searcher_with_reader(reader)?;
writer.close(&mut random)?;
let mut terms = Vec::new();
let mut hits = Vec::new();
for _ in 0..(10 * random_multiplier()) {
terms.clear();
terms.extend_from_slice(&["a", "b", "c", "d", "e", "f"]);
let num_terms = random.random_range(1..(terms.len() + 1));
while terms.len() > num_terms {
let idx = random.random_range(0..terms.len());
terms.remove(idx);
}
let mut bq = Builder::new();
for term in &terms {
bq.add(
TermQuery::new(Term::from_text("field", *term)),
Occur::Should,
)?;
}
let q: Query = bq.build().into();
let rewritten = searcher.rewrite(q.clone())?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let ctx = &searcher.get_leaf_contexts()?[0];
let mut scorer = weight.scorer(ctx, &searcher)?.unwrap();
hits.clear();
loop {
let doc_id = scorer.next_doc()?;
if doc_id == NO_MORE_DOCS {
break;
}
hits.push(ScoreDoc::new((scorer).scoring_doc_id()?, scorer.score()?));
}
for _ in 0..10 {
let rewritten = searcher.rewrite(q.clone())?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let mut scorer = weight.scorer(ctx, &searcher)?.unwrap();
let mut upto = 0usize;
while upto <= hits.len() {
let next_upto;
let next_doc;
let left = hits.len() - upto + 1;
if left == 1 || random.random_bool(0.5) {
next_upto = upto;
next_doc = scorer.next_doc()?;
} else {
let inc = TestUtil::next_usize(&mut random, 1, left - 1);
next_upto = upto + inc - 1;
next_doc = scorer.advance(hits[next_upto].doc)?;
}
if next_upto == hits.len() {
assert_eq!(NO_MORE_DOCS, next_doc);
} else {
let hit = &hits[next_upto];
assert_eq!(hit.doc, next_doc);
let actual = scorer.score()?;
assert_eq!(
hit.score, actual,
"doc {} has wrong score: expected={} actual={}",
hit.doc, hit.score, actual
);
}
upto = next_upto + 1;
}
}
}
Ok(())
}
#[test]
fn test_min_should_match_leniency() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let mock = MockAnalyzer::new(&mut random);
let iwc = new_index_writer_config_with_analyzer(&mut random, mock)?;
let writer = IndexWriter::new(dir.clone(), iwc)?;
let mut field_to_type: HashMap<String, FieldType> = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c d",
No,
&mut field_to_type,
)?);
writer.add_document(doc)?;
let reader = directory_reader::open_from_writer(&writer)?;
let searcher = new_searcher_with_reader(reader)?;
let mut bq = Builder::new();
bq.add(TermQuery::new(Term::from_text("field", "a")), Occur::Should)?;
bq.add(TermQuery::new(Term::from_text("field", "b")), Occur::Should)?;
bq.set_minimum_number_should_match(4);
let query = bq.build();
let top_docs = searcher.search(query, 1)?;
assert_eq!(0, top_docs.total_hits.value());
Ok(())
}
fn get_matches<IRC, T, SIM>(searcher: &IndexSearcher<IRC, SIM>, query: T) -> Result<FixedBitSet>
where
SIM: crate::core::search::similarities_impl::similarities::Similarity,
IRC: IndexReaderContext + Sync + 'static,
T: Into<Query>,
crate::core::search::index_searcher::IndexSearcher<IRC, SIM>: Sync,
{
let max_doc = searcher.get_index_reader().max_doc()?;
let manager = FixedBitSetCollector::create_manager(max_doc);
searcher.search_with_collector_manager(query, &manager)
}
#[test]
fn test_filter_clause_behaves_like_must() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let w = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c d",
Store::No,
&mut field_to_type,
)?);
w.add_document(&mut random, &mut doc)?;
match doc.get_field_mut("field") {
Some(Fields::Field(field)) => field.set_string_value("b d")?,
_ => panic!("expected field"),
}
w.add_document(&mut random, &mut doc)?;
match doc.get_field_mut("field") {
Some(Fields::Field(field)) => field.set_string_value("d")?,
_ => panic!("expected field"),
}
w.add_document(&mut random, &mut doc)?;
w.commit(&mut random)?;
let reader = w.get_reader(&mut random)?;
let searcher = new_searcher_with_reader(reader)?;
let cases: [&[&str]; 5] = [&["a", "d"], &["a", "b", "d"], &["d"], &["e"], &[]];
for required_terms in cases {
let mut bq1 = Builder::new();
let mut bq2 = Builder::new();
for term in required_terms {
let q = TermQuery::new(Term::from_text("field", term));
bq1.add(q.clone(), Occur::Must)?;
bq2.add(q, Occur::Filter)?;
}
let matches1 = get_matches(&searcher, bq1.build())?;
let matches2 = get_matches(&searcher, bq2.build())?;
assert_eq!(matches1, matches2);
}
w.close(&mut random)?;
Ok(())
}
fn assert_same_scores_without_filters<IRC>(
searcher: &IndexSearcher<
IRC,
crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
>,
bq: BooleanQuery,
) -> Result<()>
where
IRC: IndexReaderContext + Sync + 'static,
crate::core::search::index_searcher::IndexSearcher<
IRC,
crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
>: Sync,
{
let mut bq2_builder = Builder::new();
let min_should_match = bq.get_minimum_number_should_match();
for c in &bq.clauses {
if *c.occur() != Occur::Filter {
bq2_builder.add_clause(c.clone())?;
}
}
bq2_builder.set_minimum_number_should_match(min_should_match);
let bq2 = bq2_builder.build();
let matched = Arc::new(AtomicBool::new(false));
let collector_manager = CollectorManagerImpl::new(searcher, matched.clone(), bq2);
searcher.search_with_collector_manager(bq, &collector_manager)?;
assert!(matched.load(Ordering::SeqCst));
Ok(())
}
#[test]
fn test_filter_clause_does_not_impact_score() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let w = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c d",
Store::No,
&mut field_to_type,
)?);
w.add_document(&mut random, &mut doc)?;
match doc.get_field_mut("field") {
Some(Fields::Field(field)) => field.set_string_value("b d")?,
_ => panic!("expected field"),
}
w.add_document(&mut random, &mut doc)?;
match doc.get_field_mut("field") {
Some(Fields::Field(field)) => field.set_string_value("a d")?,
_ => panic!("expected field"),
}
w.add_document(&mut random, &mut doc)?;
w.commit(&mut random)?;
let reader = w.get_reader(&mut random)?;
let searcher = new_searcher_with_reader(reader)?;
let mut q_builder = Builder::new();
q_builder.add(TermQuery::new(Term::from_text("field", "a")), Occur::Filter)?;
assert_same_scores_without_filters(&searcher, q_builder.clone().build())?;
q_builder.add(TermQuery::new(Term::from_text("field", "b")), Occur::Filter)?;
let mut q = q_builder.clone().build();
assert_same_scores_without_filters(&searcher, q)?;
q_builder.add(TermQuery::new(Term::from_text("field", "c")), Occur::Should)?;
q = q_builder.build();
assert_same_scores_without_filters(&searcher, q)?;
let mut q_builder = Builder::new();
q_builder.add(TermQuery::new(Term::from_text("field", "a")), Occur::Filter)?;
q_builder.add(TermQuery::new(Term::from_text("field", "e")), Occur::Should)?;
q = q_builder.build();
assert_same_scores_without_filters(&searcher, q)?;
let mut q_builder = Builder::new();
q_builder.add(TermQuery::new(Term::from_text("field", "a")), Occur::Filter)?;
q_builder.add(TermQuery::new(Term::from_text("field", "d")), Occur::Must)?;
q = q_builder.build();
assert_same_scores_without_filters(&searcher, q)?;
let mut q_builder = Builder::new();
q_builder.add(TermQuery::new(Term::from_text("field", "b")), Occur::Filter)?;
q_builder.add(TermQuery::new(Term::from_text("field", "a")), Occur::Should)?;
q_builder.add(TermQuery::new(Term::from_text("field", "d")), Occur::Should)?;
q_builder.set_minimum_number_should_match(1);
q = q_builder.build();
assert_same_scores_without_filters(&searcher, q)?;
w.close(&mut random)?;
Ok(())
}
#[test]
fn test_conjunction_propagates_approximations() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c",
Store::No,
&mut field_to_type,
)?);
writer.add_document(&mut random, doc)?;
writer.commit(&mut random)?;
let reader = writer.get_reader(&mut random)?;
let mut searcher = index_searcher::from_reader(reader)?;
searcher.set_query_cache(None);
let pq: Query = PhraseQuery::from_terms(0, "field", ["a", "b"])?.into();
let mut b = Builder::new();
b.add(pq, Occur::Must)?;
b.add(TermQuery::new(Term::from_text("field", "c")), Occur::Filter)?;
let q: Query = b.build().into();
let rewritten = searcher.rewrite(q)?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let ctx = &searcher.get_leaf_contexts()?[0];
let scorer = weight.scorer(ctx, &searcher)?.unwrap();
assert_eq!(scorer.kind(), ScorerKind::Conjunction);
assert!(scorer.has_two_phase_iterator() == crate::core::search::scorer::TwoPhaseState::Yes);
Ok(())
}
#[test]
fn test_disjunction_propagates_approximations() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c",
Store::No,
&mut field_to_type,
)?);
writer.add_document(&mut random, doc)?;
writer.commit(&mut random)?;
let reader = writer.get_reader(&mut random)?;
let mut searcher = index_searcher::from_reader(reader)?;
searcher.set_query_cache(None);
let pq: Query = PhraseQuery::from_terms(0, "field", ["a", "b"])?.into();
let mut b = Builder::new();
b.add(pq, Occur::Should)?;
b.add(TermQuery::new(Term::from_text("field", "c")), Occur::Should)?;
let q: Query = b.build().into();
let rewritten = searcher.rewrite(q)?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let ctx = &searcher.get_leaf_contexts()?[0];
let scorer = weight.scorer(ctx, &searcher)?.unwrap();
assert_eq!(scorer.kind(), ScorerKind::Disjunction);
assert!(scorer.has_two_phase_iterator() == crate::core::search::scorer::TwoPhaseState::Yes);
Ok(())
}
#[test]
fn test_boosted_scorer_propagates_approximations() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c",
Store::No,
&mut field_to_type,
)?);
writer.add_document(&mut random, doc)?;
writer.commit(&mut random)?;
let reader = writer.get_reader(&mut random)?;
let mut searcher = index_searcher::from_reader(reader)?;
searcher.set_query_cache(None);
let pq: Query = PhraseQuery::from_terms(0, "field", ["a", "b"])?.into();
let mut b = Builder::new();
b.add(pq, Occur::Should)?;
b.add(TermQuery::new(Term::from_text("field", "d")), Occur::Should)?;
let q: Query = b.build().into();
let rewritten = searcher.rewrite(q)?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let ctx = &searcher.get_leaf_contexts()?[0];
let scorer = weight.scorer(ctx, &searcher)?.unwrap();
assert_eq!(scorer.kind(), ScorerKind::Phrase);
assert!(scorer.has_two_phase_iterator() == crate::core::search::scorer::TwoPhaseState::Yes);
Ok(())
}
#[test]
fn test_exclusion_propagates_approximations() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c",
Store::No,
&mut field_to_type,
)?);
writer.add_document(&mut random, doc)?;
writer.commit(&mut random)?;
let reader = writer.get_reader(&mut random)?;
let mut searcher = index_searcher::from_reader(reader)?;
searcher.set_query_cache(None);
let pq: Query = PhraseQuery::from_terms(0, "field", ["a", "b"])?.into();
let mut b = Builder::new();
b.add(pq, Occur::Should)?;
b.add(
TermQuery::new(Term::from_text("field", "c")),
Occur::MustNot,
)?;
let q: Query = b.build().into();
let rewritten = searcher.rewrite(q)?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let ctx = &searcher.get_leaf_contexts()?[0];
let scorer = weight.scorer(ctx, &searcher)?.unwrap();
assert_eq!(scorer.kind(), ScorerKind::ReqExcl);
assert!(scorer.has_two_phase_iterator() == crate::core::search::scorer::TwoPhaseState::Yes);
Ok(())
}
#[test]
fn test_req_opt_propagates_approximations() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let mut doc = Document::new();
doc.add(new_text_field(
&mut random,
"field",
"a b c",
Store::No,
&mut field_to_type,
)?);
writer.add_document(&mut random, doc)?;
writer.commit(&mut random)?;
let reader = writer.get_reader(&mut random)?;
let mut searcher = index_searcher::from_reader(reader)?;
searcher.set_query_cache(None);
let pq: Query = PhraseQuery::from_terms(0, "field", ["a", "b"])?.into();
let mut b = Builder::new();
b.add(pq, Occur::Must)?;
b.add(TermQuery::new(Term::from_text("field", "c")), Occur::Should)?;
let q: Query = b.build().into();
let rewritten = searcher.rewrite(q)?;
let weight = rewritten.create_weight(&searcher, &ScoreMode::Complete, 1.0)?;
let ctx = &searcher.get_leaf_contexts()?[0];
let scorer = weight.scorer(ctx, &searcher)?.unwrap();
assert_eq!(scorer.kind(), ScorerKind::ReqOptSum);
assert!(scorer.has_two_phase_iterator() == crate::core::search::scorer::TwoPhaseState::Yes);
Ok(())
}
#[test]
fn test_query_matches_count() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = RandomIndexWriter::new(&mut random, dir.clone())?;
let mut field_to_type = HashMap::new();
let random_num_docs = TestUtil::next_usize(&mut random, 10, 101);
let mut num_matching_docs: i32 = 0;
for _i in 0..random_num_docs {
let mut doc = Document::new();
if random.random_bool(0.5) {
let text = format!("a b c {}", random.random::<i32>());
doc.add(new_text_field(
&mut random,
"field",
&text,
Store::No,
&mut field_to_type,
)?);
num_matching_docs += 1;
} else {
let text = random.random::<i32>().to_string();
doc.add(new_text_field(
&mut random,
"field",
&text,
Store::No,
&mut field_to_type,
)?);
}
writer.add_document(&mut random, doc)?;
}
writer.commit(&mut random)?;
let reader = writer.get_reader(&mut random)?;
let searcher = index_searcher::from_reader(reader)?;
let mut b = Builder::new();
b.add(
PhraseQuery::from_terms(0, "field", ["a", "b"])?,
Occur::Should,
)?;
b.add(TermQuery::new(Term::from_text("field", "c")), Occur::Should)?;
let built_query: Query = b.build().into();
assert_eq!(num_matching_docs, searcher.count(built_query)?);
Ok(())
}
#[test]
fn test_conjunction_matches_count() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = IndexWriter::new(dir.clone(), IndexWriterConfig::new()?)?;
let mut doc = Document::new();
doc.add(LongPoint::new("long", [3i64])?);
doc.add(StringField::from_string("string", "abc", No)?);
writer.add_document(&mut doc)?;
match doc.get_field_mut("long") {
Some(Fields::LongPoint(long_point)) => long_point.set_long_value(10)?,
_ => panic!("expected long point"),
}
match doc.get_field_mut("string") {
Some(Fields::String(string_field)) => string_field.set_string_value("xyz")?,
_ => panic!("expected string field"),
}
writer.add_document(&mut doc)?;
let reader = directory_reader::open_from_writer(&writer)?;
let searcher = index_searcher::from_reader(reader)?;
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Must,
)?
.add(LongPoint::new_exact_query("long", 3)?, Occur::Filter)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(
-1,
weight.count(&searcher.get_leaf_contexts()?[0], &searcher)?
);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "missing")),
Occur::Must,
)?
.add(LongPoint::new_exact_query("long", 3)?, Occur::Filter)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(
0,
weight.count(&searcher.get_leaf_contexts()?[0], &searcher)?
);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Must,
)?
.add(LongPoint::new_exact_query("long", 5)?, Occur::Filter)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(
0,
weight.count(&searcher.get_leaf_contexts()?[0], &searcher)?
);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Must,
)?
.add(LongPoint::new_range_query("long", 0, 10)?, Occur::Filter)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(
1,
weight.count(&searcher.get_leaf_contexts()?[0], &searcher)?
);
let mut builder = Builder::new();
builder
.add(Query::MatchAllDocs(MatchAllDocsQuery::new()), Occur::Must)?
.add(LongPoint::new_range_query("long", 1, 5)?, Occur::Filter)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(
1,
weight.count(&searcher.get_leaf_contexts()?[0], &searcher)?
);
Ok(())
}
#[test]
fn test_disjunction_matches_count() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = IndexWriter::new(dir.clone(), IndexWriterConfig::new()?)?;
let mut doc = Document::new();
doc.add(LongPoint::new("long", [3i64])?);
doc.add(LongPoint::new("long3dim", [3i64, 4i64, 5i64])?);
doc.add(StringField::from_string("string", "abc", No)?);
writer.add_document(&mut doc)?;
match doc.get_field_mut("long") {
Some(Fields::LongPoint(long_point)) => long_point.set_long_value(10)?,
_ => panic!("expected long point"),
}
match doc.get_field_mut("long3dim") {
Some(Fields::LongPoint(long_point)) => long_point.set_long_values([10i64, 11i64, 12i64])?,
_ => panic!("expected long point"),
}
match doc.get_field_mut("string") {
Some(Fields::String(string_field)) => string_field.set_string_value("xyz")?,
_ => panic!("expected string field"),
}
writer.add_document(&mut doc)?;
let reader = directory_reader::open_from_writer(&writer)?;
let searcher = index_searcher::from_reader(reader)?;
let leaf = &searcher.get_leaf_contexts()?[0];
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Should,
)?
.add(LongPoint::new_exact_query("long", 3)?, Occur::Should)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(-1, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "missing")),
Occur::Should,
)?
.add(LongPoint::new_exact_query("long", 3)?, Occur::Should)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(1, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Should,
)?
.add(LongPoint::new_exact_query("long", 5)?, Occur::Should)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(1, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Should,
)?
.add(LongPoint::new_range_query("long", 0, 10)?, Occur::Should)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(2, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(Query::MatchAllDocs(MatchAllDocsQuery::new()), Occur::Should)?
.add(LongPoint::new_range_query("long", 1, 5)?, Occur::Should)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(2, weight.count(leaf, &searcher)?);
let lower = [4i64, 5i64, 6i64];
let upper = [9i64, 10i64, 11i64];
let unknown_count_query = LongPoint::new_range_query_n("long3dim", lower, upper)?;
assert_eq!(1, searcher.get_leaf_contexts()?.len());
let w = searcher.create_weight(unknown_count_query.clone(), ScoreMode::Complete, 1.0)?;
assert_eq!(-1, w.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "xyz")),
Occur::Must,
)?
.add(unknown_count_query.clone(), Occur::MustNot)?
.add(
Query::MatchAllDocs(MatchAllDocsQuery::new()),
Occur::MustNot,
)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(0, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(
TermQuery::new(Term::from_text("string", "xyz")),
Occur::Must,
)?
.add(unknown_count_query.clone(), Occur::MustNot)?
.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::MustNot,
)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(-1, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder
.add(unknown_count_query.clone(), Occur::Should)?
.add(Query::MatchAllDocs(MatchAllDocsQuery::new()), Occur::Should)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(2, weight.count(leaf, &searcher)?);
let mut builder = Builder::new();
builder.add(unknown_count_query, Occur::Should)?.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Should,
)?;
let query = builder.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(-1, weight.count(leaf, &searcher)?);
Ok(())
}
#[test]
fn test_two_clause_term_disjunction_count_optimization() -> Result<()> {
let mut random = random();
let larger_term_count = random.random_range(11..=100);
let smaller_term_count = random.random_range(1..=(larger_term_count - 1) / 10);
let mut doc_content = Vec::with_capacity((larger_term_count + smaller_term_count) as usize);
for _ in 0..larger_term_count {
doc_content.push(&["large"][..]);
}
for _ in 0..smaller_term_count {
doc_content.push(&["small", "also small"][..]);
}
let dir = new_directory_shared(&mut random)?;
let mut iwc = new_index_writer_config(&mut random)?;
iwc.set_merge_policy(new_log_merge_policy(&mut random)?);
let writer = IndexWriter::new(dir.clone(), iwc)?;
let mut field_types = HashMap::new();
for values in doc_content {
let mut doc = Document::new();
for value in values {
doc.add(new_string_field(
&mut random,
"foo",
*value,
Store::No,
&mut field_types,
)?);
}
writer.add_document(doc)?;
}
writer.force_merge(1)?;
writer.close()?;
let reader = directory_reader::open(dir.clone())?;
let hook = CountingIndexSearcher::default();
let counting_index_searcher =
new_searcher_with_reader(reader)?.with_hook(IndexSearcherHook::Counting(hook.clone()));
{
hook.reset();
let mut builder = Builder::new();
builder.add(
TermQuery::new(Term::from_text("foo", "no match")),
Occur::Should,
)?;
builder.add(
TermQuery::new(Term::from_text("foo", "also no match")),
Occur::Should,
)?;
let query = builder.build();
assert_eq!(0, counting_index_searcher.count(query)?);
assert_eq!(3, hook.count_invocations());
}
{
hook.reset();
let mut builder = Builder::new();
builder.add(
TermQuery::new(Term::from_text("foo", "no match")),
Occur::Should,
)?;
builder.add(
TermQuery::new(Term::from_text("foo", "small")),
Occur::Should,
)?;
let query = builder.build();
assert_eq!(smaller_term_count, counting_index_searcher.count(query)?);
assert_eq!(3, hook.count_invocations());
}
{
hook.reset();
let mut builder = Builder::new();
builder.add(
TermQuery::new(Term::from_text("foo", "small")),
Occur::Should,
)?;
builder.add(
TermQuery::new(Term::from_text("foo", "no match")),
Occur::Should,
)?;
let query = builder.build();
assert_eq!(smaller_term_count, counting_index_searcher.count(query)?);
assert_eq!(3, hook.count_invocations());
}
{
hook.reset();
let mut builder = Builder::new();
builder.add(
TermQuery::new(Term::from_text("foo", "small")),
Occur::Should,
)?;
builder.add(
TermQuery::new(Term::from_text("foo", "large")),
Occur::Should,
)?;
let mut query = builder.build();
let count = counting_index_searcher.count(query.clone())?;
assert_eq!(larger_term_count + smaller_term_count, count);
assert_eq!(4, hook.count_invocations());
assert!(query.is_two_clause_pure_disjunction_with_terms());
let queries =
query.rewrite_two_clause_disjunction_with_terms_for_count(&counting_index_searcher)?;
assert_eq!(3, queries.len());
assert_eq!(
smaller_term_count,
counting_index_searcher.count(queries[0].clone())?
);
assert_eq!(
larger_term_count,
counting_index_searcher.count(queries[1].clone())?
);
}
{
hook.reset();
let mut builder = Builder::new();
builder.add(
TermQuery::new(Term::from_text("foo", "large")),
Occur::Should,
)?;
builder.add(
TermQuery::new(Term::from_text("foo", "small")),
Occur::Should,
)?;
let mut query = builder.build();
let count = counting_index_searcher.count(query.clone())?;
assert_eq!(larger_term_count + smaller_term_count, count);
assert_eq!(4, hook.count_invocations());
assert!(query.is_two_clause_pure_disjunction_with_terms());
let queries =
query.rewrite_two_clause_disjunction_with_terms_for_count(&counting_index_searcher)?;
assert_eq!(3, queries.len());
assert_eq!(
larger_term_count,
counting_index_searcher.count(queries[0].clone())?
);
assert_eq!(
smaller_term_count,
counting_index_searcher.count(queries[1].clone())?
);
}
{
hook.reset();
let mut builder = Builder::new();
builder.add(
TermQuery::new(Term::from_text("foo", "small")),
Occur::Should,
)?;
builder.add(
TermQuery::new(Term::from_text("foo", "also small")),
Occur::Should,
)?;
let query = builder.build();
let count = counting_index_searcher.count(query)?;
assert_eq!(smaller_term_count, count);
assert_eq!(3, hook.count_invocations());
}
Ok(())
}
#[test]
fn test_disjunction_two_clauses_matches_count_and_score() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let doc_content: [&[&str]; 6] = [
&["A", "B"], &["A"], &[], &["A", "B", "C"], &["B"], &["B", "C"], ];
let match_doc_score: [(i32, f32); 5] = [
(0, (2 + 1) as f32),
(3, (2 + 1) as f32),
(1, 2f32),
(4, 1f32),
(5, 1f32),
];
{
let mut iwc = new_index_writer_config(&mut random)?;
iwc.set_merge_policy(new_log_merge_policy(&mut random)?);
let w = IndexWriter::new(dir.clone(), iwc)?;
for values in doc_content {
let mut doc = Document::new();
for v in values {
doc.add(StringField::from_string("foo", *v, Store::No)?);
}
w.add_document(doc)?;
}
w.force_merge(1)?;
w.close()?;
}
let reader = directory_reader::open(dir.clone())?;
let searcher = new_searcher_with_reader(reader)?;
let q_a: Query = TermQuery::new(Term::from_text("foo", "A")).into();
let q_b: Query = TermQuery::new(Term::from_text("foo", "B")).into();
let boosted_a = BoostQuery::new(ConstantScoreQuery::new(q_a), 2.0)?;
let cs_b = ConstantScoreQuery::new(q_b);
let mut builder = Builder::new();
builder.add(boosted_a, Occur::Should)?;
builder.add(cs_b, Occur::Should)?;
let query: Query = builder.build().into();
let top_docs = searcher.search(query, 10)?;
let hits = top_docs.score_docs();
for (i, (exp_doc, exp_score)) in match_doc_score.iter().enumerate() {
let sd = &hits[i];
assert_eq!(*exp_doc, sd.doc);
assert!((sd.score - *exp_score).abs() < 0.0001);
}
Ok(())
}
#[test]
fn test_disjunction_random_clauses_matches_count() -> Result<()> {
let mut random = random();
let num_field_value: usize = random.random_range(1..=10);
let mut num_docs_per_field_value = Vec::with_capacity(num_field_value);
let mut all_docs_count: usize = 0;
for _ in 0..num_field_value {
let num_docs: usize = random.random_range(10..=50);
num_docs_per_field_value.push(num_docs);
all_docs_count += num_docs;
}
let dir = new_directory_shared(&mut random)?;
{
let mut iwc = new_index_writer_config(&mut random)?;
iwc.set_merge_policy(new_log_merge_policy(&mut random)?);
let w = IndexWriter::new(dir.clone(), iwc)?;
for (i, &num_docs) in num_docs_per_field_value.iter().enumerate() {
for _ in 0..num_docs {
let mut doc = Document::new();
doc.add(StringField::from_string("field", i.to_string(), No)?);
w.add_document(doc)?;
}
}
w.force_merge(1)?;
w.close()?;
}
let mut matched_docs_count: usize = 0;
let reader = directory_reader::open(dir.clone())?;
let searcher = new_searcher_with_reader(reader)?;
let mut builder = Builder::new();
for (i, &num_docs) in num_docs_per_field_value.iter().enumerate() {
if random.random_bool(0.5) {
matched_docs_count += num_docs;
let q = TermQuery::new(Term::new("field", i.to_string()));
builder.add(q, Occur::Should)?;
}
}
let query = builder.build();
let top_docs = searcher.search(query, all_docs_count)?;
assert_eq!(matched_docs_count, top_docs.score_docs().len());
Ok(())
}
#[test]
fn test_prohibited_matches_count() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = IndexWriter::new(dir.clone(), IndexWriterConfig::new()?)?;
let mut doc = Document::new();
doc.add(LongPoint::new("long", [3])?);
doc.add(StringField::from_string("string", "abc", No)?);
writer.add_document(&mut doc)?;
match doc.get_field_mut("long") {
Some(Fields::LongPoint(long_point)) => long_point.set_long_value(10)?,
_ => panic!("expected long point"),
}
match doc.get_field_mut("string") {
Some(Fields::String(string_field)) => string_field.set_string_value("xyz")?,
_ => panic!("expected string field"),
}
writer.add_document(&mut doc)?;
let reader = directory_reader::open_from_writer(&writer)?;
writer.close()?;
let searcher = new_searcher_with_reader(reader)?;
let leaves = searcher.get_top_reader_context().leaves()?;
{
let mut b = Builder::new();
b.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Must,
)?;
b.add(LongPoint::new_exact_query("long", 3)?, Occur::MustNot)?;
let query = b.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(-1, weight.count(&leaves[0], &searcher)?);
}
{
let mut b = Builder::new();
b.add(
TermQuery::new(Term::from_text("string", "missing")),
Occur::Must,
)?;
b.add(LongPoint::new_exact_query("long", 3)?, Occur::MustNot)?;
let query = b.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(0, weight.count(&leaves[0], &searcher)?);
}
{
let mut b = Builder::new();
b.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Must,
)?;
b.add(LongPoint::new_exact_query("long", 5)?, Occur::MustNot)?;
let query = b.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(1, weight.count(&leaves[0], &searcher)?);
}
{
let mut b = Builder::new();
b.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::Must,
)?;
b.add(LongPoint::new_range_query("long", 0, 10)?, Occur::MustNot)?;
let query = b.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(0, weight.count(&leaves[0], &searcher)?);
}
{
let mut b = Builder::new();
b.add(LongPoint::new_range_query("long", 0, 10)?, Occur::Must)?;
b.add(
TermQuery::new(Term::from_text("string", "abc")),
Occur::MustNot,
)?;
let query = b.build();
let weight = searcher.create_weight(query, ScoreMode::Complete, 1.0)?;
assert_eq!(1, weight.count(&leaves[0], &searcher)?);
}
Ok(())
}
#[test]
fn test_random_boolean_query_matches_count() -> Result<()> {
let mut random = random();
let dir = new_directory_shared(&mut random)?;
let writer = IndexWriter::new(dir.clone(), IndexWriterConfig::new()?)?;
let mut doc = Document::new();
doc.add(LongPoint::new("long", [3])?);
doc.add(StringField::from_string("string", "abc", No)?);
writer.add_document(&mut doc)?;
match doc.get_field_mut("long") {
Some(Fields::LongPoint(long_point)) => long_point.set_long_value(10)?,
_ => panic!("expected long point"),
}
match doc.get_field_mut("string") {
Some(Fields::String(string_field)) => string_field.set_string_value("xyz")?,
_ => panic!("expected string field"),
}
writer.add_document(&mut doc)?;
let reader = directory_reader::open_from_writer(&writer)?;
writer.close()?;
let searcher = new_searcher_with_reader(reader)?;
for _ in 0..1000 {
let num_clauses = TestUtil::next_int(&mut random, 2, 5);
let mut builder = Builder::new();
let mut num_should_clauses: i32 = 0;
for _ in 0..num_clauses {
let query: Query = match random.random_range(0..6) {
0 => TermQuery::new(Term::from_text("string", "abc")).into(),
1 => LongPoint::new_exact_query("long", 3)?.into(),
2 => TermQuery::new(Term::from_text("string", "missing")).into(),
3 => LongPoint::new_exact_query("long", 5)?.into(),
4 => MatchAllDocsQuery::new().into(),
_ => LongPoint::new_range_query("long", 0, 10)?.into(),
};
let occur = match random.random_range(0..4) {
0 => Occur::Must,
1 => Occur::Filter,
2 => Occur::Should,
_ => Occur::MustNot,
};
if occur == Occur::Should {
num_should_clauses += 1;
}
builder.add(query, occur)?;
}
builder.set_minimum_number_should_match(TestUtil::next_int(&mut random, 0, num_should_clauses));
let boolean_query: Query = builder.build().into();
let total_hits = searcher
.search(boolean_query.clone(), 1)?
.total_hits()
.value;
assert_eq!(total_hits, searcher.count(boolean_query)? as usize);
}
Ok(())
}
#[test]
fn test_to_string() -> Result<()> {
let mut bq = Builder::new();
bq.add(TermQuery::new(Term::from_text("field", "a")), Occur::Should)?;
bq.add(TermQuery::new(Term::from_text("field", "b")), Occur::Must)?;
bq.add(
TermQuery::new(Term::from_text("field", "c")),
Occur::MustNot,
)?;
bq.add(TermQuery::new(Term::from_text("field", "d")), Occur::Filter)?;
let q = bq.build();
assert_eq!("a +b -c #d", q.to_string("field")?);
Ok(())
}
#[test]
fn test_query_visitor() -> Result<()> {
struct Visitor<'a> {
expected: Option<&'a Term>,
a: &'a Term,
b: &'a Term,
c: &'a Term,
d: &'a Term,
}
impl QueryVisitor for Visitor<'_> {
type SubVisitor<'a>
= &'a mut Self
where
Self: 'a;
fn get_sub_visitor<'a>(
&'a mut self,
occur: Occur,
_parent: QueryRef<'_>,
) -> Self::SubVisitor<'a> {
self.expected = Some(match occur {
Occur::Should => self.a,
Occur::Must => self.b,
Occur::Filter => self.c,
Occur::MustNot => self.d,
});
self
}
fn consume_terms<T: Borrow<Term>>(&mut self, _query: QueryRef<'_>, terms: &[T]) -> Result<()> {
assert_eq!(self.expected, terms.first().map(Borrow::<Term>::borrow));
Ok(())
}
}
let a = Term::from_text("f", "a");
let b = Term::from_text("f", "b");
let c = Term::from_text("f", "c");
let d = Term::from_text("f", "d");
let mut builder = Builder::new();
builder.add(TermQuery::new(a.clone()), Occur::Should)?;
builder.add(TermQuery::new(b.clone()), Occur::Must)?;
builder.add(TermQuery::new(c.clone()), Occur::Filter)?;
builder.add(TermQuery::new(d.clone()), Occur::MustNot)?;
let query = builder.build();
query.visit(&mut Visitor {
expected: None,
a: &a,
b: &b,
c: &c,
d: &d,
})?;
Ok(())
}
#[test]
#[ignore = "Java-only: BooleanQuery clause accessors return immutable Rust slices by type"]
fn test_clause_sets_immutability() -> Result<()> {
test_not_required_in_rust_lucene!();
}
struct CollectorManagerImpl<'a, IRC>
where
IRC: 'static,
{
searcher: &'a IndexSearcher<IRC>,
matched: Arc<AtomicBool>,
bq2: BooleanQuery,
}
impl<'a, IRC> CollectorManagerImpl<'a, IRC>
where
IRC: IndexReaderContext,
{
fn new(
searcher: &'a IndexSearcher<
IRC,
crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
>,
matched: Arc<AtomicBool>,
bq2: BooleanQuery,
) -> Self
where
crate::core::search::index_searcher::IndexSearcher<
IRC,
crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
>: Sync,
{
Self {
searcher,
matched,
bq2,
}
}
}
impl<'a, IRC> CollectorManager for CollectorManagerImpl<'a, IRC>
where
IRC: IndexReaderContext,
crate::core::search::index_searcher::IndexSearcher<IRC>: Sync,
{
type C = SimpleCollectorImpl<'a, IRC>;
type T = ();
fn new_collector(&self) -> Result<Self::C> {
Ok(SimpleCollectorImpl::new(
self.matched.clone(),
self.bq2.clone(),
self.searcher,
))
}
fn reduce(&self, _collectors: Vec<Self::C>) -> Result<Self::T> {
Ok(())
}
}
struct SimpleCollectorImpl<'a, IRC>
where
IRC: 'static,
{
doc_base: i32,
matched: Arc<AtomicBool>,
bq2: BooleanQuery,
searcher: &'a IndexSearcher<IRC>,
}
impl<'a, IRC> SimpleCollectorImpl<'a, IRC>
where
IRC: IndexReaderContext,
{
fn new(
matched: Arc<AtomicBool>,
bq2: BooleanQuery,
searcher: &'a IndexSearcher<
IRC,
crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
>,
) -> Self
where
crate::core::search::index_searcher::IndexSearcher<
IRC,
crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
>: Sync,
{
Self {
doc_base: 0,
matched,
bq2,
searcher,
}
}
}
impl<IRC> Collector for SimpleCollectorImpl<'_, IRC>
where
IRC: IndexReaderContext,
crate::core::search::index_searcher::IndexSearcher<IRC>: Sync,
{
type LeafCollector<'a, IRC1>
= &'a mut Self
where
Self: 'a,
IRC1: IndexReaderContext + 'a;
fn get_leaf_collector<'a, W, IRC1, SIM>(
&'a mut self,
context: &LeafReaderContext<IRCLeafReader<IRC1>>,
_weight: Option<&W>,
_searcher: &IndexSearcher<IRC1, SIM>,
) -> Result<Self::LeafCollector<'a, IRC>>
where
SIM: crate::core::search::similarities_impl::similarities::Similarity,
IRC1: IndexReaderContext,
W: Weight<IRC1, SIM> + ?Sized,
crate::core::search::index_searcher::IndexSearcher<IRC1, SIM>: Sync,
{
SimpleCollector::do_set_next_reader(self, context)?;
Ok(self)
}
fn score_mode(&self) -> ScoreMode {
ScoreMode::Complete
}
}
impl<IRC> LeafCollector for SimpleCollectorImpl<'_, IRC>
where
IRC: IndexReaderContext,
crate::core::search::index_searcher::IndexSearcher<IRC>: Sync,
{
type CompetitiveIterator<'a>
= crate::core::search::doc_id_set_iterator::EmptyDISI
where
Self: 'a;
fn collect<SC: Scorable + ?Sized>(&mut self, doc: i32, scorer: &mut SC) -> Result<()> {
let actual_score = scorer.score()?;
let q = self.bq2.clone();
let expected_score = self
.searcher
.explain(q, self.doc_base + doc)?
.value
.to_f32()
.unwrap();
assert_eq!(expected_score, actual_score);
self.matched.store(true, Ordering::SeqCst);
Ok(())
}
}
impl<IRC> Display for SimpleCollectorImpl<'_, IRC>
where
IRC: IndexReaderContext,
{
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", std::any::type_name::<Self>())
}
}
impl<IRC> SimpleCollector for SimpleCollectorImpl<'_, IRC>
where
IRC: IndexReaderContext,
crate::core::search::index_searcher::IndexSearcher<IRC>: Sync,
{
fn do_set_next_reader<LR>(&mut self, context: &LeafReaderContext<LR>) -> Result<()>
where
LR: LeafReader,
{
self.doc_base = context.doc_base as i32;
Ok(())
}
}