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 subqueries that is not a MustNot 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;

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 = index.writer(3_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,
   ));
   // 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),
   ];
   // 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);

   // TermQuery for "cow" in the title
   let cow_term_query: Box<dyn Query> = Box::new(TermQuery::new(
       Term::from_field_text(title, "cow"),
       IndexRecordOption::Basic,
   ));
   // "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),
   ]);
   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);
   Ok(())
}

Implementations

impl BooleanQuery

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

Creates a new boolean query.

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 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.

const 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.