Struct BooleanQuery 

pub struct BooleanQuery { /* private fields */ }

The boolean query returns a set of documents that matches the Boolean combination of constituent subqueries.

The documents matched by the boolean query are those which

• match all of the sub queries associated with the Must occurrence
• match none of the sub queries associated with the MustNot occurrence.
• match at least one of the sub queries associated with the Must or Should occurrence.

You can combine other query types and their Occurances into one BooleanQuery

use tantivy::collector::Count;
use tantivy::doc;
use tantivy::query::{BooleanQuery, Occur, PhraseQuery, Query, TermQuery};
use tantivy::schema::{IndexRecordOption, Schema, TEXT};
use tantivy::Term;
use tantivy::Index;
use tantivy::IndexWriter;

fn main() -> tantivy::Result<()> {
   let mut schema_builder = Schema::builder();
   let title = schema_builder.add_text_field("title", TEXT);
   let body = schema_builder.add_text_field("body", TEXT);
   let schema = schema_builder.build();
   let index = Index::create_in_ram(schema);
   {
       let mut index_writer: IndexWriter = index.writer(15_000_000)?;
       index_writer.add_document(doc!(
           title => "The Name of the Wind",
       ))?;
       index_writer.add_document(doc!(
           title => "The Diary of Muadib",
       ))?;
       index_writer.add_document(doc!(
           title => "A Dairy Cow",
           body => "hidden",
       ))?;
       index_writer.add_document(doc!(
           title => "A Dairy Cow",
           body => "found",
       ))?;
       index_writer.add_document(doc!(
           title => "The Diary of a Young Girl",
       ))?;
       index_writer.commit()?;
   }

   let reader = index.reader()?;
   let searcher = reader.searcher();

   // Make TermQuery's for "girl" and "diary" in the title
   let girl_term_query: Box<dyn Query> = Box::new(TermQuery::new(
       Term::from_field_text(title, "girl"),
       IndexRecordOption::Basic,
   ));
   let diary_term_query: Box<dyn Query> = Box::new(TermQuery::new(
       Term::from_field_text(title, "diary"),
       IndexRecordOption::Basic,
   ));
   let cow_term_query: Box<dyn Query> = Box::new(TermQuery::new(
       Term::from_field_text(title, "cow"),
       IndexRecordOption::Basic
   ));
   // A TermQuery with "found" in the body
   let body_term_query: Box<dyn Query> = Box::new(TermQuery::new(
       Term::from_field_text(body, "found"),
       IndexRecordOption::Basic,
   ));
   // TermQuery "diary" must and "girl" must not be present
   let queries_with_occurs1 = vec![
       (Occur::Must, diary_term_query.box_clone()),
       (Occur::MustNot, girl_term_query.box_clone()),
   ];
   // Make a BooleanQuery equivalent to
   // title:+diary title:-girl
   let diary_must_and_girl_mustnot = BooleanQuery::new(queries_with_occurs1);
   let count1 = searcher.search(&diary_must_and_girl_mustnot, &Count)?;
   assert_eq!(count1, 1);

   // "title:diary OR title:cow"
   let title_diary_or_cow = BooleanQuery::new(vec![
       (Occur::Should, diary_term_query.box_clone()),
       (Occur::Should, cow_term_query.box_clone()),
   ]);
   let count2 = searcher.search(&title_diary_or_cow, &Count)?;
   assert_eq!(count2, 4);

   // Make a `PhraseQuery` from a vector of `Term`s
   let phrase_query: Box<dyn Query> = Box::new(PhraseQuery::new(vec![
       Term::from_field_text(title, "dairy"),
       Term::from_field_text(title, "cow"),
   ]));
   // You can combine subqueries of different types into 1 BooleanQuery:
   // `TermQuery` and `PhraseQuery`
   // "title:diary OR "dairy cow"
   let term_of_phrase_query = BooleanQuery::new(vec![
       (Occur::Should, diary_term_query.box_clone()),
       (Occur::Should, phrase_query.box_clone()),
   ]);
   let count3 = searcher.search(&term_of_phrase_query, &Count)?;
   assert_eq!(count3, 4);

   // You can nest one BooleanQuery inside another
   // body:found AND ("title:diary OR "dairy cow")
   let nested_query = BooleanQuery::new(vec![
       (Occur::Must, body_term_query),
       (Occur::Must, Box::new(term_of_phrase_query))
   ]);
   let count4 = searcher.search(&nested_query, &Count)?;
   assert_eq!(count4, 1);

   // You may call `with_minimum_required_clauses` to
   // specify the number of should clauses the returned documents must match.
   let minimum_required_query = BooleanQuery::with_minimum_required_clauses(vec![
        (Occur::Should, cow_term_query.box_clone()),
        (Occur::Should, girl_term_query.box_clone()),
        (Occur::Should, diary_term_query.box_clone()),
   ], 2);
   // Return documents contains "Diary Cow", "Diary Girl" or "Cow Girl"
   // Notice: "Diary" isn't "Dairy". ;-)
   let count5 = searcher.search(&minimum_required_query, &Count)?;
   assert_eq!(count5, 1);
   Ok(())
}

Implementations

impl BooleanQuery

pub fn new(subqueries: Vec<(Occur, Box<dyn Query>)>) -> BooleanQuery

Creates a new boolean query.

pub fn with_minimum_required_clauses( subqueries: Vec<(Occur, Box<dyn Query>)>, minimum_number_should_match: usize, ) -> BooleanQuery

Create a new boolean query with minimum number of required should clauses specified.

pub fn get_minimum_number_should_match(&self) -> usize

Getter for minimum_number_should_match

pub fn set_minimum_number_should_match( &mut self, minimum_number_should_match: usize, )

Setter for minimum_number_should_match

pub fn intersection(queries: Vec<Box<dyn Query>>) -> BooleanQuery

Returns the intersection of the queries.

pub fn union(queries: Vec<Box<dyn Query>>) -> BooleanQuery

Returns the union of the queries.

pub fn union_with_minimum_required_clauses( queries: Vec<Box<dyn Query>>, minimum_required_clauses: usize, ) -> BooleanQuery

Returns the union of the queries with minimum required clause.

pub fn new_multiterms_query(terms: Vec<Term>) -> BooleanQuery

Helper method to create a boolean query matching a given list of terms. The resulting query is a disjunction of the terms.

pub fn clauses(&self) -> &[(Occur, Box<dyn Query>)]

Deconstructed view of the clauses making up this query.

Trait Implementations

impl Clone for BooleanQuery

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BooleanQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Vec<(Occur, Box<dyn Query>)>> for BooleanQuery

fn from(subqueries: Vec<(Occur, Box<dyn Query>)>) -> BooleanQuery

Converts to this type from the input type.

impl Query for BooleanQuery

fn weight(&self, enable_scoring: EnableScoring<'_>) -> Result<Box<dyn Weight>>

Create the weight associated with a query.

fn query_terms<'a>(&'a self, visitor: &mut dyn FnMut(&'a Term, bool))

Extract all of the terms associated with the query and pass them to the given closure.

fn explain( &self, searcher: &Searcher, doc_address: DocAddress, ) -> Result<Explanation>

Returns an Explanation for the score of the document.

fn count(&self, searcher: &Searcher) -> Result<usize>

Returns the number of documents matching the query.