queryparser.h

Go to the documentation of this file.

 
/* Copyright (C) 2005-2026 Olly Betts
 * Copyright (C) 2010 Adam Sjøgren
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef XAPIAN_INCLUDED_QUERYPARSER_H
#define XAPIAN_INCLUDED_QUERYPARSER_H
 
#if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD
# error Never use <xapian/queryparser.h> directly; include <xapian.h> instead.
#endif
 
#include <xapian/attributes.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/query.h>
#include <xapian/termiterator.h>
#include <xapian/visibility.h>
 
#include <string>
#include <string_view>
#include <unordered_set>
 
namespace Xapian {
 
class Database;
class Stem;
 
class XAPIAN_VISIBILITY_DEFAULT Stopper
    : public Xapian::Internal::opt_intrusive_base {
    void operator=(const Stopper &) = delete;
 
    Stopper(const Stopper &) = delete;
 
  public:
    Stopper() { }
 
    virtual bool operator()(const std::string & term) const = 0;
 
    virtual ~Stopper() { }
 
    virtual std::string get_description() const;
 
    Stopper * release() {
        opt_intrusive_base::release();
        return this;
    }
 
    const Stopper * release() const {
        opt_intrusive_base::release();
        return this;
    }
};
 
class XAPIAN_VISIBILITY_DEFAULT SimpleStopper : public Stopper {
    std::unordered_set<std::string> stop_words;
 
  public:
    SimpleStopper() { }
 
    template<class Iterator>
    SimpleStopper(Iterator begin, Iterator end) : stop_words(begin, end) { }
 
    void add(const std::string & word) { stop_words.insert(word); }
 
    virtual bool operator()(const std::string & term) const {
        return stop_words.find(term) != stop_words.end();
    }
 
    virtual std::string get_description() const;
};
 
enum {
    RP_SUFFIX = 1,
    RP_REPEATED = 2,
    RP_DATE_PREFER_MDY = 4
};
 
class XAPIAN_VISIBILITY_DEFAULT RangeProcessor
    : public Xapian::Internal::opt_intrusive_base {
    void operator=(const RangeProcessor &);
 
    RangeProcessor(const RangeProcessor &);
 
  protected:
    Xapian::valueno slot;
 
    std::string str;
 
    unsigned flags;
 
  public:
    RangeProcessor() : slot(Xapian::BAD_VALUENO), flags(0) { }
 
    explicit RangeProcessor(Xapian::valueno slot_,
                            std::string_view str_ = {},
                            unsigned flags_ = 0)
        : slot(slot_), str(str_), flags(flags_) { }
 
    virtual ~RangeProcessor();
 
    Xapian::Query check_range(const std::string& b, const std::string& e);
 
    virtual Xapian::Query
        operator()(const std::string &begin, const std::string &end);
 
    RangeProcessor * release() {
        opt_intrusive_base::release();
        return this;
    }
 
    const RangeProcessor * release() const {
        opt_intrusive_base::release();
        return this;
    }
};
 
class XAPIAN_VISIBILITY_DEFAULT DateRangeProcessor : public RangeProcessor {
    int epoch_year;
 
  public:
    explicit DateRangeProcessor(Xapian::valueno slot_,
                                unsigned flags_ = 0,
                                int epoch_year_ = 1970)
        : RangeProcessor(slot_, {}, flags_),
          epoch_year(epoch_year_) { }
 
    DateRangeProcessor(Xapian::valueno slot_, std::string_view str_,
                       unsigned flags_ = 0, int epoch_year_ = 1970)
        : RangeProcessor(slot_, str_, flags_),
          epoch_year(epoch_year_) { }
 
    Xapian::Query operator()(const std::string& begin, const std::string& end);
};
 
class XAPIAN_VISIBILITY_DEFAULT NumberRangeProcessor : public RangeProcessor {
  public:
    NumberRangeProcessor(Xapian::valueno slot_,
                         std::string_view str_ = {},
                         unsigned flags_ = 0)
        : RangeProcessor(slot_, str_, flags_) { }
 
    Xapian::Query operator()(const std::string& begin, const std::string& end);
};
 
class XAPIAN_VISIBILITY_DEFAULT UnitRangeProcessor : public RangeProcessor {
  public:
    UnitRangeProcessor(Xapian::valueno slot_,
                       std::string_view str_ = {})
        : RangeProcessor(slot_, str_) { }
 
    Xapian::Query operator()(const std::string& begin, const std::string& end);
};
 
class XAPIAN_VISIBILITY_DEFAULT FieldProcessor
    : public Xapian::Internal::opt_intrusive_base {
    void operator=(const FieldProcessor &);
 
    FieldProcessor(const FieldProcessor &);
 
  public:
    FieldProcessor() { }
 
    virtual ~FieldProcessor();
 
    virtual Xapian::Query operator()(const std::string &str) = 0;
 
    FieldProcessor * release() {
        opt_intrusive_base::release();
        return this;
    }
 
    const FieldProcessor * release() const {
        opt_intrusive_base::release();
        return this;
    }
};
 
class XAPIAN_VISIBILITY_DEFAULT QueryParser {
  public:
    class Internal;
    Xapian::Internal::intrusive_ptr_nonnull<Internal> internal;
 
    typedef enum {
        FLAG_BOOLEAN = 1,
        FLAG_PHRASE = 2,
        FLAG_LOVEHATE = 4,
        FLAG_BOOLEAN_ANY_CASE = 8,
        FLAG_WILDCARD = 16,
        FLAG_PURE_NOT = 32,
        FLAG_PARTIAL = 64,
 
        FLAG_SPELLING_CORRECTION = 128,
 
        FLAG_SYNONYM = 256,
 
        FLAG_AUTO_SYNONYMS = 512,
 
        FLAG_AUTO_MULTIWORD_SYNONYMS = 1024,
 
        FLAG_NGRAMS = 2048,
 
        FLAG_CJK_NGRAM = FLAG_NGRAMS,
 
        FLAG_WORD_BREAKS = 4096,
 
        FLAG_WILDCARD_MULTI = 8192,
 
        FLAG_WILDCARD_SINGLE = 16384,
 
        FLAG_WILDCARD_GLOB = FLAG_WILDCARD_MULTI | FLAG_WILDCARD_SINGLE,
 
        FLAG_FUZZY = 32768,
 
        FLAG_ACCUMULATE = 65536,
 
        FLAG_NO_POSITIONS = 0x20000,
 
        FLAG_NO_PROPER_NOUN_HEURISTIC = 0x40000,
 
        FLAG_DEFAULT = FLAG_PHRASE|FLAG_BOOLEAN|FLAG_LOVEHATE
    } feature_flag;
 
    typedef enum {
        STEM_NONE, STEM_SOME, STEM_ALL, STEM_ALL_Z, STEM_SOME_FULL_POS
    } stem_strategy;
 
    typedef enum { STOP_NONE, STOP_ALL, STOP_STEMMED } stop_strategy;
 
    QueryParser(const QueryParser & o);
 
    QueryParser & operator=(const QueryParser & o);
 
    QueryParser(QueryParser && o);
 
    QueryParser & operator=(QueryParser && o);
 
    QueryParser();
 
    ~QueryParser();
 
    void set_stemmer(const Xapian::Stem & stemmer);
 
    void set_stemming_strategy(stem_strategy strategy);
 
    void set_stopper(const Stopper *stop = NULL);
 
    void set_stopper_strategy(stop_strategy strategy);
 
    void set_default_op(Query::op default_op);
 
    Query::op get_default_op() const;
 
    void set_database(const Database &db);
 
    void set_max_expansion(Xapian::termcount max_expansion,
                           int max_type = Xapian::Query::WILDCARD_LIMIT_ERROR,
                           unsigned flags = FLAG_WILDCARD |
                                            FLAG_PARTIAL |
                                            FLAG_FUZZY);
 
    void set_min_wildcard_prefix(unsigned min_prefix_len,
                                 unsigned flags = FLAG_WILDCARD|FLAG_PARTIAL);
 
    Query parse_query(std::string_view query_string,
                      unsigned flags = FLAG_DEFAULT,
                      std::string_view default_prefix = {});
 
    void add_prefix(std::string_view field, std::string_view prefix);
 
    void add_prefix(std::string_view field, Xapian::FieldProcessor* proc);
 
    void add_boolean_prefix(std::string_view field, std::string_view prefix,
                            const std::string* grouping = NULL);
 
    void add_boolean_prefix(std::string_view field, std::string_view prefix,
                            bool exclusive) {
        if (exclusive) {
            add_boolean_prefix(field, prefix);
        } else {
            std::string empty_grouping;
            add_boolean_prefix(field, prefix, &empty_grouping);
        }
    }
 
    void add_boolean_prefix(std::string_view field,
                            Xapian::FieldProcessor* proc,
                            const std::string* grouping = NULL);
 
    void add_boolean_prefix(std::string_view field,
                            Xapian::FieldProcessor* proc,
                            bool exclusive) {
        if (exclusive) {
            add_boolean_prefix(field, proc);
        } else {
            std::string empty_grouping;
            add_boolean_prefix(field, proc, &empty_grouping);
        }
    }
 
    TermIterator stoplist_begin() const;
 
    TermIterator stoplist_end() const noexcept {
        return TermIterator();
    }
 
    TermIterator unstem_begin(std::string_view term) const;
 
    TermIterator unstem_end(std::string_view) const noexcept {
        return TermIterator();
    }
 
    void add_rangeprocessor(Xapian::RangeProcessor * range_proc,
                            const std::string* grouping = NULL);
 
    std::string get_corrected_query_string() const;
 
    std::string get_description() const;
};
 
XAPIAN_VISIBILITY_DEFAULT
size_t sortable_serialise_(double value, char* buf) noexcept;
 
inline std::string sortable_serialise(double value) {
    char buf[9];
    return std::string(buf, sortable_serialise_(value, buf));
}
 
XAPIAN_VISIBILITY_DEFAULT
double sortable_unserialise(std::string_view serialised) noexcept;
 
}
 
#endif // XAPIAN_INCLUDED_QUERYPARSER_H