Xapian::Query Class Reference

Class representing a query. More...

`#include <query.h>`

## Public Types

enum

op {
OP_AND = 0 , OP_OR = 1 , OP_AND_NOT = 2 , OP_XOR = 3 ,
OP_AND_MAYBE = 4 , OP_FILTER = 5 , OP_NEAR = 6 , OP_PHRASE = 7 ,
OP_VALUE_RANGE = 8 , OP_SCALE_WEIGHT = 9 , OP_ELITE_SET = 10 , OP_VALUE_GE = 11 ,
OP_VALUE_LE = 12 , OP_SYNONYM = 13 , OP_MAX = 14 , OP_WILDCARD = 15 ,
OP_EDIT_DISTANCE = 16 , OP_INVALID = 99 , LEAF_TERM = 100 , LEAF_POSTING_SOURCE ,
LEAF_MATCH_ALL , LEAF_MATCH_NOTHING
}

| Query operators. More...
enum | { WILDCARD_LIMIT_ERROR = 0x00 , WILDCARD_LIMIT_FIRST = 0x01 , WILDCARD_LIMIT_MOST_FREQUENT = 0x02 , WILDCARD_LIMIT_MASK_ = 0x03 , WILDCARD_PATTERN_MULTI = 0x10 , WILDCARD_PATTERN_SINGLE = 0x20 , WILDCARD_PATTERN_GLOB = WILDCARD_PATTERN_MULTI|WILDCARD_PATTERN_SINGLE }

## Public Member Functions

| Query () noexcept
| Construct a query matching no documents.
| ~Query ()
| Destructor.
| Query (const Query &o)
| Copying is allowed.
Query & | operator= (const Query &o)
| Copying is allowed.
| Query (Query &&)=default
| Move constructor.
Query & | operator= (Query &&)=default
| Move assignment operator.
| Query (const std::string &term, Xapian::termcount wqf=1, Xapian::termpos pos=0)
| Construct a Query object for a term.
| Query (const char *term, Xapian::termcount wqf=1, Xapian::termpos pos=0)
| Construct a Query object for a term.
| Query (std::string_view term, Xapian::termcount wqf=1, Xapian::termpos pos=0)
| Construct a Query object for a term.
| Query (Xapian::PostingSource *source)
| Construct a Query object for a PostingSource.
| Query (double factor, const Xapian::Query &subquery)
| Scale using OP_SCALE_WEIGHT.
| Query (op op_, const Xapian::Query &subquery, double factor)
| Scale using OP_SCALE_WEIGHT.
| Query (op op_, const Xapian::Query &a, const Xapian::Query &b)
| Construct a Query object by combining two others.
template<typename S1, typename S2, typename std::enable_if< std::is_constructible< std::string_view, S1 >::value &&std::is_constructible< std::string_view, S2 >::value, bool >::type = true>
| Query (op op_, S1 a, S2 b)
| Construct a Query object by combining two terms.
| Query (op op_, Xapian::valueno slot, std::string_view range_limit)
| Construct a Query object for a single-ended value range.
| Query (op op_, Xapian::valueno slot, std::string_view range_lower, std::string_view range_upper)
| Construct a Query object for a value range.
| Query (op op_, std::string_view pattern, Xapian::termcount max_expansion=0, int flags=WILDCARD_LIMIT_ERROR, op combiner=OP_SYNONYM)
| Query constructor for OP_EDIT_DISTANCE and OP_WILDCARD queries.
| Query (op op_, std::string_view pattern, Xapian::termcount max_expansion, int flags, op combiner, unsigned edit_distance, size_t min_prefix_len=0)
| Query constructor for OP_EDIT_DISTANCE queries.

template<typename I, typename std::enable_if< std::is_convertible< typename std::iterator_traits< I >::value_type, Xapian::Query >::value||std::is_convertible< typename std::iterator_traits< I >::value_type, Xapian::Query * >::value||std::is_convertible< typename std::iterator_traits< I >::value_type, std::string_view >::value, bool >::type = true, typename iterator_category = typename std::iterator_traits<I>::iterator_category>

| Query (op op_, I begin, I end, Xapian::termcount window=0)
| Construct a Query object from a begin/end iterator pair.
const TermIterator | get_terms_begin () const
| Begin iterator for terms in the query object.
const TermIterator | get_terms_end () const noexcept
| End iterator for terms in the query object.
const TermIterator | get_unique_terms_begin () const
| Begin iterator for unique terms in the query object.
const TermIterator | get_unique_terms_end () const noexcept
| End iterator for unique terms in the query object.
Xapian::termcount | get_length () const noexcept
| Return the length of this query object.
bool | empty () const noexcept
| Check if this query is Xapian::Query::MatchNothing.
std::string | serialise () const
| Serialise this object into a string.
op | get_type () const noexcept
| Get the type of the top level of the query.
size_t | get_num_subqueries () const noexcept
| Get the number of subqueries of the top level query.
Xapian::termcount | get_leaf_wqf () const
| Get the wqf parameter of a leaf node.
Xapian::termpos | get_leaf_pos () const
| Get the pos parameter of a leaf node.
const Query | get_subquery (size_t n) const
| Read a top level subquery.
std::string | get_description () const
| Return a string describing this object.
const Query | operator&= (const Query &o)
| Combine with another Xapian::Query object using OP_AND.
const Query | operator|= (const Query &o)
| Combine with another Xapian::Query object using OP_OR.
const Query | operator^= (const Query &o)
| Combine with another Xapian::Query object using OP_XOR.
const Query | operator*= (double factor)
| Scale using OP_SCALE_WEIGHT.
const Query | operator/= (double factor)
| Inverse scale using OP_SCALE_WEIGHT.
| Query (Query::op op_)
| Construct with just an operator.

## Static Public Member Functions

static const Query | unserialise (std::string_view serialised, const Registry &reg=Registry())
| Unserialise a string and return a Query object.

## Static Public Attributes

static const Xapian::Query | MatchNothing
| A query matching no documents.
static const Xapian::Query | MatchAll
| A query matching all documents.

## Detailed Description

Class representing a query.

## Member Enumeration Documentation

## anonymous enum

anonymous enum

Enumerator
WILDCARD_LIMIT_ERROR | Throw an error if OP_WILDCARD exceeds its expansion limit. Xapian::WildcardError will be thrown when the query is actually run.
WILDCARD_LIMIT_FIRST | Stop expanding when OP_WILDCARD reaches its expansion limit. This makes the wildcard expand to only the first N terms (sorted by byte order).

WILDCARD_LIMIT_MOST_FREQUENT

Limit OP_WILDCARD expansion to the most frequent terms.

If OP_WILDCARD would expand to more than its expansion limit, the most frequent terms are taken. This approach works well for cases such as expanding a partial term at the end of a query string which the user hasn't finished typing yet - as well as being less expense to evaluate than the full expansion, using only the most frequent terms tends to give better results too.

WILDCARD_PATTERN_MULTI

Support * which matches 0 or more characters.

Since
  Added in Xapian 2.0.0

WILDCARD_PATTERN_SINGLE

Support ?

which matches a single character.

Since
  Added in Xapian 2.0.0.

WILDCARD_PATTERN_GLOB

Enable all supported glob-like features.

Since
  Added in Xapian 2.0.0.

## op

enum Xapian::Query::op

Query operators.

Enumerator
OP_AND | Match only documents which all subqueries match. When used in a weighted context, the weight is the sum of the weights for all the subqueries.
OP_OR | Match documents which at least one subquery matches. When used in a weighted context, the weight is the sum of the weights for matching subqueries (so additional matching subqueries will mean a higher weight).
OP_AND_NOT | Match documents which the first subquery matches but no others do. When used in a weighted context, the weight is just the weight of the first subquery.
OP_XOR | Match documents which an odd number of subqueries match. When used in a weighted context, the weight is the sum of the weights for matching subqueries (so additional matching subqueries will mean a higher weight).
OP_AND_MAYBE | Match the first subquery taking extra weight from other subqueries. When used in a weighted context, the weight is the sum of the weights for matching subqueries (so additional matching subqueries will mean a higher weight). Because only the first subquery determines which documents are matched, in a non-weighted context only the first subquery matters.
OP_FILTER | Match like OP_AND but only taking weight from the first subquery. When used in a non-weighted context, OP_FILTER and OP_AND are equivalent. In older 1.4.x, the third and subsequent subqueries were ignored in some situations. This was fixed in 1.4.15.
OP_NEAR | Match only documents where all subqueries match near each other. The subqueries must match at term positions within the specified window size, in any order. Currently subqueries must be terms or terms composed with OP_OR. When used in a weighted context, the weight is the sum of the weights for all the subqueries.
OP_PHRASE | Match only documents where all subqueries match near and in order. The subqueries must match at term positions within the specified window size, in the same term position order as subquery order. Currently subqueries must be terms or terms composed with OP_OR. When used in a weighted context, the weight is the sum of the weights for all the subqueries.
OP_VALUE_RANGE | Match only documents where a value slot is within a given range. This operator never contributes weight.
OP_SCALE_WEIGHT | Scale the weight contributed by a subquery. The weight is the weight of the subquery multiplied by the specified non-negative scale factor (so if the scale factor is zero then the subquery contributes no weight).

OP_ELITE_SET

Pick the best N subqueries and combine with OP_OR.

If you want to implement a feature which finds documents similar to a piece of text, an obvious approach is to build an "OR" query from all the terms in the text, and run this query against a database containing the documents. However such a query can contain a lots of terms and be quite slow to perform, yet many of these terms don't contribute usefully to the results.

The OP_ELITE_SET operator can be used instead of OP_OR in this situation. OP_ELITE_SET selects the most important ''N'' terms and then acts as an OP_OR query with just these, ignoring any other terms. This will usually return results just as good as the full OP_OR query, but much faster.

In general, the OP_ELITE_SET operator can be used when you have a large OR query, but it doesn't matter if the search completely ignores some of the less important terms in the query.

The subqueries don't have to be terms. If they aren't then OP_ELITE_SET could potentially pick a subset which doesn't actually match any documents even if the full OR would match some (because OP_ELITE_SET currently selects those subqueries which can return the highest weights). This is probably rare in practice though.

You can specify a parameter to the query constructor which controls the number of subqueries which OP_ELITE_SET will pick. If not specified, this defaults to 10 (Xapian used to default to `ceil(sqrt(number_of_subqueries))` if there are more than 100 subqueries, but this rather arbitrary special case was dropped in 1.3.0). For example, this will pick the best 7 terms:

    Xapian::Query query(Xapian::Query::OP_ELITE_SET, subqs.begin(), subqs.end(), 7);

If the number of subqueries is less than this threshold, OP_ELITE_SET behaves identically to OP_OR.

When used with a sharded database, OP_ELITE_SET currently picks the subqueries to use separately for each shard based on the maximum weight they can return in that shard. This means it probably won't select exactly the same terms, and so the results of the search may not be exactly the same as for a single database with equivalent contents.

OP_VALUE_GE | Match only documents where a value slot is >= a given value. Similar to OP_VALUE_RANGE, but open-ended. This operator never contributes weight.
OP_VALUE_LE | Match only documents where a value slot is <= a given value. Similar to OP_VALUE_RANGE, but open-ended. This operator never contributes weight.
OP_SYNONYM | Match like OP_OR but weighting as if a single term. The weight is calculated combining the statistics for the subqueries to approximate the weight of a single term occurring with those statistics.

OP_MAX

Pick the maximum weight of any subquery.

Matches the same documents as OP_OR, but the weight contributed is the maximum weight from any matching subquery (for OP_OR, it's the sum of the weights from the matching subqueries).

Since
  Added in Xapian 1.3.2.

OP_WILDCARD

Wildcard expansion.

Since
  Added in Xapian 1.3.3.

OP_EDIT_DISTANCE

Edit distance expansion.

Expand to terms within a specified edit distance of a target.

This works in a fairly similar way to OP_WILDCARD - the difference is that instead of expanding to terms matching a wildcard pattern, it expands to terms within a specified number of edits (insertion, deletion or substitution of a character, or transposition of two adjacent characters) of a specified target.

Since
  Added in Xapian 2.0.0.

OP_INVALID | Construct an invalid query. This can be useful as a placeholder - for example RangeProcessor uses it as a return value to indicate that a range hasn't been recognised.
LEAF_TERM | Value returned by get_type() for a term.
LEAF_POSTING_SOURCE | Value returned by get_type() for a PostingSource.
LEAF_MATCH_ALL | Value returned by get_type() for MatchAll or equivalent. This is returned for any `Xapian::Query(std::string_view())` object.
LEAF_MATCH_NOTHING | Value returned by get_type() for MatchNothing or equivalent. This is returned for any `Xapian::Query()` object.

## Constructor & Destructor Documentation

## Query() [1/15]

Xapian::Query::Query | ( |  | ) |

inline noexcept

Construct a query matching no documents.

MatchNothing is a static instance of this.

When combined with other Query objects using the various supported operators, `Query()` works like `false` in boolean logic, so `Query() & q` is `Query()`, while `Query() | q` is `q`.

Referenced by get_description(), get_subquery(), operator&=(), operator*=(), operator/=(), operator=(), operator=(), operator^=(), operator|=(), Query(), Query(), Query(), Query(), and unserialise().

## Query() [2/15]

Xapian::Query::Query | ( | const Query & | o | ) |

inline

Copying is allowed.

The internals are reference counted, so copying is cheap.

References Query().

## Query() [3/15]

Xapian::Query::Query | ( | const std::string & | term,
|  | Xapian::termcount | wqf = 1,
|  | Xapian::termpos | pos = 0 )

inline

Construct a Query object for a term.

Parameters

  term | The term. An empty string constructs a query matching all documents (MatchAll is a static instance of this).
  wqf | The within-query frequency. (default: 1)
  pos | The query position. Currently this is mainly used to determine the order of terms obtained via get_terms_begin(). (default: 0)

References Query().

## Query() [4/15]

Xapian::Query::Query | ( | const char * | term,
|  | Xapian::termcount | wqf = 1,
|  | Xapian::termpos | pos = 0 )

inline

Construct a Query object for a term.

Parameters

  term | The term. An empty string constructs a query matching all documents (MatchAll is a static instance of this).
  wqf | The within-query frequency. (default: 1)
  pos | The query position. Currently this is mainly used to determine the order of terms obtained via get_terms_begin(). (default: 0)

References Query().

## Query() [5/15]

Xapian::Query::Query | ( | std::string_view | term,
|  | Xapian::termcount | wqf = 1,
|  | Xapian::termpos | pos = 0 )

Construct a Query object for a term.

Parameters

  term | The term. An empty string constructs a query matching all documents (MatchAll is a static instance of this).
  wqf | The within-query frequency. (default: 1)
  pos | The query position. Currently this is mainly used to determine the order of terms obtained via get_terms_begin(). (default: 0)

## Query() [6/15]

Xapian::Query::Query | ( | double | factor,
|  | const Xapian::Query & | subquery )

Scale using OP_SCALE_WEIGHT.

Parameters

  factor | Non-negative real number to multiply weights by.
  subquery | Query object to scale weights from.

## Query() [7/15]

Xapian::Query::Query | ( | op | op_,
|  | const Xapian::Query & | subquery,
|  | double | factor )

Scale using OP_SCALE_WEIGHT.

In this form, the op_ parameter is totally redundant - use Query(factor, subquery) in preference.

Parameters

  op_ | Must be OP_SCALE_WEIGHT.
  factor | Non-negative real number to multiply weights by.
  subquery | Query object to scale weights from.

## Query() [8/15]

Xapian::Query::Query | ( | op | op_,
|  | const Xapian::Query & | a,
|  | const Xapian::Query & | b )

inline

Construct a Query object by combining two others.

Parameters

  op_ | The operator to combine the queries with.
  a | First subquery.
  b | Second subquery.

References OP_NEAR, and OP_PHRASE.

## Query() [9/15]

template<typename S1, typename S2, typename std::enable_if< std::is_constructible< std::string_view, S1 >::value &&std::is_constructible< std::string_view, S2 >::value, bool >::type = true>

Xapian::Query::Query | ( | op | op_,
|  | S1 | a,
|  | S2 | b )

inline

Construct a Query object by combining two terms.

Parameters

  op_ | The operator to combine the terms with.
  a | First term.
  b | Second term.

## Query() [10/15]

Xapian::Query::Query | ( | op | op_,
|  | Xapian::valueno | slot,
|  | std::string_view | range_limit )

Construct a Query object for a single-ended value range.

Parameters

  op_ | Must be OP_VALUE_LE or OP_VALUE_GE currently.
  slot | The value slot to work over.
  range_limit | The limit of the range.

## Query() [11/15]

Xapian::Query::Query | ( | op | op_,
|  | Xapian::valueno | slot,
|  | std::string_view | range_lower,
|  | std::string_view | range_upper )

Construct a Query object for a value range.

Parameters

  op_ | Must be OP_VALUE_RANGE currently.
  slot | The value slot to work over.
  range_lower | Lower end of the range.
  range_upper | Upper end of the range.

## Query() [12/15]

Xapian::Query::Query | ( | op | op_,
|  | std::string_view | pattern,
|  | Xapian::termcount | max_expansion = 0,
|  | int | flags = WILDCARD_LIMIT_ERROR,
|  | op | combiner = OP_SYNONYM )

Query constructor for OP_EDIT_DISTANCE and OP_WILDCARD queries.

Parameters

  op_ | Must be OP_EDIT_DISTANCE or OP_WILDCARD
  pattern | The wildcard pattern (for OP_WILDCARD) or target string (for OP_EDIT_DISTANCE). See flags which affects how this pattern is interpreted.
  max_expansion | The maximum number of terms to expand to (default: 0, which means no limit)
  flags | Flags controlling aspects of the wildcarding - this consists of a bitwise OR of:

- At most one of WILDCARD_LIMIT_ERROR (the default), WILDCARD_LIMIT_FIRST or WILDCARD_LIMIT_MOST_FREQUENT specifying how to enforce max_expansion.

  When searching multiple databases, the expansion limit is currently applied independently for each database, so the total number of terms may be higher than the limit. This is arguably a bug, and may change in future versions.

- For OP_WILDCARD: Zero or more of WILDCARD_PATTERN_MULTI and WILDCARD_PATTERN_SINGLE, which specify whether '*' (matching zero or more characters) and '?' (matching exactly one character) are supported. If neither is specified, then a Xapian-1.4-compatible mode is used where the pattern matches terms which start with the pattern interpreted as a literal string.

Parameters

  combiner | The Query::op to combine the terms with - one of OP_SYNONYM (the default), OP_OR or OP_MAX.

For OP_WILDCARD: A leading wildcard won't match terms starting with an ASCII capital letter, as this is assumed to be part of a term prefix.

References OP_SYNONYM, and WILDCARD_LIMIT_ERROR.

## Query() [13/15]

Xapian::Query::Query | ( | op | op_,
|  | std::string_view | pattern,
|  | Xapian::termcount | max_expansion,
|  | int | flags,
|  | op | combiner,
|  | unsigned | edit_distance,
|  | size_t | min_prefix_len = 0 )

Query constructor for OP_EDIT_DISTANCE queries.

This form supports some additional parameters.

Parameters

  op_ | Must be OP_EDIT_DISTANCE.
  pattern | The target string.
  max_expansion | The maximum number of terms to expand to (default: 0, which means no limit)

  flags

  Flags controlling aspects of the wildcarding:

                  * At most one of @a WILDCARD_LIMIT_ERROR (the default),
                    @a WILDCARD_LIMIT_FIRST or
                    @a WILDCARD_LIMIT_MOST_FREQUENT specifying how to
                    enforce max_expansion.

                    When searching multiple databases, the expansion
                    limit is currently applied independently for each
                    database, so the total number of terms may be higher
                    than the limit.  This is arguably a bug, and may
                    change in future versions.

  combiner | The Query::op to combine the terms with - one of OP_SYNONYM (the default), OP_OR or OP_MAX.
  edit_distance | The maximum number of edits allowed between a term and target (an edit is insertion, deletion or substitution of a character, or transposition of two adjacent characters). Default: 2
  min_prefix_len | The length in bytes of any initial substring of target that is required to match exactly. Default: 0

Since
  Added in Xapian 2.0.0.

## Query() [14/15]

template<typename I, typename std::enable_if< std::is_convertible< typename std::iterator_traits< I >::value_type, Xapian::Query >::value||std::is_convertible< typename std::iterator_traits< I >::value_type, Xapian::Query * >::value||std::is_convertible< typename std::iterator_traits< I >::value_type, std::string_view >::value, bool >::type = true, typename iterator_category = typename std::iterator_traits<I>::iterator_category>

Xapian::Query::Query | ( | op | op_,
|  | I | begin,
|  | I | end,
|  | Xapian::termcount | window = 0 )

inline

Construct a Query object from a begin/end iterator pair.

Dereferencing the iterator should return a Xapian::Query, a non-NULL Xapian::Query*, a std::string_view or a type which converts to one of these (e.g. std::string or const char*).

If begin == end then there are no subqueries and the resulting Query won't match anything.

Parameters

  op_ | The operator to combine the queries with.
  begin | Begin iterator.
  end | End iterator.
  window | Window size for OP_NEAR and OP_PHRASE, or 0 to use the number of subqueries as the window size (default: 0).

References OP_NEAR, and OP_PHRASE.

## Query() [15/15]

Xapian::Query::Query | ( | Query::op | op_ | ) |

inline explicit

Construct with just an operator.

Parameters

  op_ | The operator to use - currently only OP_INVALID is useful.

References OP_INVALID.

## Member Function Documentation

## get_leaf_pos()

Xapian::termpos Xapian::Query::get_leaf_pos | ( |  | ) | const

Get the pos parameter of a leaf node.

Since
  Added in Xapian 2.0.0.

References get_leaf_pos().

Referenced by get_leaf_pos().

## get_leaf_wqf()

Xapian::termcount Xapian::Query::get_leaf_wqf | ( |  | ) | const

Get the wqf parameter of a leaf node.

Since
  Added in Xapian 2.0.0.

References get_leaf_wqf().

Referenced by get_leaf_wqf().

## get_subquery()

const Query Xapian::Query::get_subquery | ( | size_t | n | ) | const

Read a top level subquery.

Parameters

  n | Return the n-th subquery (starting from 0) - only valid when 0 <= n < get_num_subqueries().

References get_subquery(), and Query().

Referenced by get_subquery().

## get_terms_begin()

const TermIterator Xapian::Query::get_terms_begin | ( |  | ) | const

Begin iterator for terms in the query object.

The iterator returns terms in ascending query position order, and will return the same term in each unique position it occurs in. If you want the terms in sorted order and without duplicates, see get_unique_terms_begin().

## get_unique_terms_begin()

const TermIterator Xapian::Query::get_unique_terms_begin | ( |  | ) | const

Begin iterator for unique terms in the query object.

Terms are sorted and terms with the same name removed from the list.

If you want the terms in ascending query position order, see get_terms_begin().

## operator&=()

const Query Xapian::Query::operator&= | ( | const Query & | o | ) |

inline

Combine with another Xapian::Query object using OP_AND.

Since
  Since Xapian 1.4.10, when called on a Query object which is OP_AND and has a reference count of 1, then o is appended as a new subquery (provided o is a different Query object and `!o.empty()`).

References get_type(), OP_AND, and Query().

## operator*=()

const Query Xapian::Query::operator*= | ( | double | factor | ) |

inline

Scale using OP_SCALE_WEIGHT.

Parameters

  factor | Non-negative real number to multiply weights by.

References Query().

## operator/=()

const Query Xapian::Query::operator/= | ( | double | factor | ) |

inline

Inverse scale using OP_SCALE_WEIGHT.

Parameters

  factor | Positive real number to divide weights by.

References Query().

## operator=()

Query & Xapian::Query::operator= | ( | const Query & | o | ) |

inline

Copying is allowed.

The internals are reference counted, so assignment is cheap.

References Query().

## operator^=()

const Query Xapian::Query::operator^= | ( | const Query & | o | ) |

inline

Combine with another Xapian::Query object using OP_XOR.

Since
  Since Xapian 1.4.10, when called on a Query object which is OP_XOR and has a reference count of 1, then o is appended as a new subquery (provided o is a different Query object and `!o.empty()`).

References empty(), get_type(), OP_XOR, and Query().

## operator|=()

const Query Xapian::Query::operator|= | ( | const Query & | o | ) |

inline

Combine with another Xapian::Query object using OP_OR.

Since
  Since Xapian 1.4.10, when called on a Query object which is OP_OR and has a reference count of 1, then o is appended as a new subquery (provided o is a different Query object and `!o.empty()`).

References empty(), get_type(), OP_OR, and Query().

## unserialise()

const Query Xapian::Query::unserialise | ( | std::string_view | serialised,
|  | const Registry & | reg = Registry() )

static

Unserialise a string and return a Query object.

Parameters

  serialised | the string to unserialise.
  reg | Xapian::Registry object to use to unserialise user-subclasses of Xapian::PostingSource (default: standard registry).

References Query().

## Member Data Documentation

## MatchAll

const Xapian::Query Xapian::Query::MatchAll

static

A query matching all documents.

This is a static instance of `Xapian::Query(std::string_view())`. If you are constructing Query objects which use MatchAll in different threads then the reference counting of the static object can get messed up by concurrent access so you should instead use `Xapian::Query(std::string_view())` directly.

## MatchNothing

const Xapian::Query Xapian::Query::MatchNothing

static

A query matching no documents.

This is a static instance of a default-constructed Xapian::Query object. It is safe to use concurrently from different threads, unlike MatchAll (this is because MatchNothing has a NULL internal object so there's no reference counting happening).

When combined with other Query objects using the various supported operators, MatchNothing works like `false` in boolean logic, so `MatchNothing & q` is `MatchNothing`, while `MatchNothing | q` is `q`.

The documentation for this class was generated from the following file:

- xapian/query.h