queryparser.h

Go to the documentation of this file.

 
/* Copyright (C) 2005-2023 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */
 
#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/deprecated.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/query.h>
#include <xapian/termiterator.h>
#include <xapian/visibility.h>
 
#include <set>
#include <string>
 
namespace Xapian {
 
class Database;
class Stem;
 
class XAPIAN_VISIBILITY_DEFAULT Stopper
    : public Xapian::Internal::opt_intrusive_base {
    void operator=(const Stopper &);
 
    Stopper(const Stopper &);
 
  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::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_,
                            const std::string& str_ = std::string(),
                            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_, std::string(), flags_),
          epoch_year(epoch_year_) { }
 
    DateRangeProcessor(Xapian::valueno slot_, const std::string &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_,
                         const std::string &str_ = std::string(),
                         unsigned flags_ = 0)
        : RangeProcessor(slot_, str_, flags_) { }
 
    Xapian::Query operator()(const std::string& begin, const std::string& end);
};
 
class XAPIAN_VISIBILITY_DEFAULT ValueRangeProcessor
    : public Xapian::Internal::opt_intrusive_base {
    void operator=(const ValueRangeProcessor &);
 
    ValueRangeProcessor(const ValueRangeProcessor &);
 
  public:
    ValueRangeProcessor() { }
 
    virtual ~ValueRangeProcessor();
 
    virtual Xapian::valueno operator()(std::string &begin, std::string &end) = 0;
 
    ValueRangeProcessor * release() {
        opt_intrusive_base::release();
        return this;
    }
 
    const ValueRangeProcessor * release() const {
        opt_intrusive_base::release();
        return this;
    }
};
 
class XAPIAN_DEPRECATED_CLASS_EX XAPIAN_VISIBILITY_DEFAULT StringValueRangeProcessor : public ValueRangeProcessor {
  protected:
    Xapian::valueno valno;
 
    bool prefix;
 
    std::string str;
 
  public:
    explicit StringValueRangeProcessor(Xapian::valueno slot_)
        : valno(slot_), str() { }
 
    StringValueRangeProcessor(Xapian::valueno slot_, const std::string &str_,
                              bool prefix_ = true)
        : valno(slot_), prefix(prefix_), str(str_) { }
 
    Xapian::valueno operator()(std::string &begin, std::string &end);
};
 
class XAPIAN_DEPRECATED_CLASS_EX XAPIAN_VISIBILITY_DEFAULT DateValueRangeProcessor : public StringValueRangeProcessor {
    bool prefer_mdy;
    int epoch_year;
 
  public:
    DateValueRangeProcessor(Xapian::valueno slot_, bool prefer_mdy_ = false,
                            int epoch_year_ = 1970)
        : StringValueRangeProcessor(slot_),
          prefer_mdy(prefer_mdy_), epoch_year(epoch_year_) { }
 
    DateValueRangeProcessor(Xapian::valueno slot_, const std::string &str_,
                            bool prefix_ = true,
                            bool prefer_mdy_ = false, int epoch_year_ = 1970)
        : StringValueRangeProcessor(slot_, str_, prefix_),
          prefer_mdy(prefer_mdy_), epoch_year(epoch_year_) { }
 
#ifndef SWIG
    DateValueRangeProcessor(Xapian::valueno slot_, const char * str_,
                            bool prefix_ = true,
                            bool prefer_mdy_ = false, int epoch_year_ = 1970)
        : StringValueRangeProcessor(slot_, str_, prefix_),
          prefer_mdy(prefer_mdy_), epoch_year(epoch_year_) { }
#endif
 
    Xapian::valueno operator()(std::string &begin, std::string &end);
};
 
class XAPIAN_DEPRECATED_CLASS_EX XAPIAN_VISIBILITY_DEFAULT NumberValueRangeProcessor : public StringValueRangeProcessor {
  public:
    explicit NumberValueRangeProcessor(Xapian::valueno slot_)
        : StringValueRangeProcessor(slot_) { }
 
    NumberValueRangeProcessor(Xapian::valueno slot_, const std::string &str_,
                              bool prefix_ = true)
        : StringValueRangeProcessor(slot_, str_, prefix_) { }
 
    Xapian::valueno operator()(std::string &begin, 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<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_ACCUMULATE = 65536,
 
        FLAG_NO_POSITIONS = 0x20000,
 
        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;
 
    QueryParser(const QueryParser & o);
 
    QueryParser & operator=(const QueryParser & o);
 
#ifdef XAPIAN_MOVE_SEMANTICS
    QueryParser(QueryParser && o);
 
    QueryParser & operator=(QueryParser && o);
#endif
 
    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_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);
 
    XAPIAN_DEPRECATED(void set_max_wildcard_expansion(Xapian::termcount));
 
    Query parse_query(const std::string &query_string,
                      unsigned flags = FLAG_DEFAULT,
                      const std::string &default_prefix = std::string());
 
    void add_prefix(const std::string& field, const std::string& prefix);
 
    void add_prefix(const std::string& field, Xapian::FieldProcessor * proc);
 
    void add_boolean_prefix(const std::string &field, const std::string &prefix,
                            const std::string* grouping = NULL);
 
    void add_boolean_prefix(const std::string &field, const std::string &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(const std::string &field, Xapian::FieldProcessor *proc,
                            const std::string* grouping = NULL);
 
    void add_boolean_prefix(const std::string &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 XAPIAN_NOTHROW(stoplist_end() const) {
        return TermIterator();
    }
 
    TermIterator unstem_begin(const std::string &term) const;
 
    TermIterator XAPIAN_NOTHROW(unstem_end(const std::string &) const) {
        return TermIterator();
    }
 
    void add_rangeprocessor(Xapian::RangeProcessor * range_proc,
                            const std::string* grouping = NULL);
 
    XAPIAN_DEPRECATED(void add_valuerangeprocessor(Xapian::ValueRangeProcessor * vrproc)) {
#ifdef __GNUC__
// Avoid deprecation warnings if compiling without optimisation.
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        class ShimRangeProcessor : public RangeProcessor {
            Xapian::Internal::opt_intrusive_ptr<Xapian::ValueRangeProcessor> vrp;
 
          public:
            ShimRangeProcessor(Xapian::ValueRangeProcessor * vrp_)
                : RangeProcessor(Xapian::BAD_VALUENO), vrp(vrp_) { }
 
            Xapian::Query
            operator()(const std::string &begin, const std::string &end)
            {
                std::string b = begin, e = end;
                slot = (*vrp)(b, e);
                if (slot == Xapian::BAD_VALUENO)
                    return Xapian::Query(Xapian::Query::OP_INVALID);
                return RangeProcessor::operator()(b, e);
            }
        };
 
        add_rangeprocessor((new ShimRangeProcessor(vrproc))->release());
#ifdef __GNUC__
# pragma GCC diagnostic pop
#endif
    }
 
    std::string get_corrected_query_string() const;
 
    std::string get_description() const;
};
 
inline void
QueryParser::set_max_wildcard_expansion(Xapian::termcount max_expansion)
{
    set_max_expansion(max_expansion,
                      Xapian::Query::WILDCARD_LIMIT_ERROR,
                      FLAG_WILDCARD);
}
 
XAPIAN_VISIBILITY_DEFAULT
size_t XAPIAN_NOTHROW(sortable_serialise_(double value, char * buf));
 
inline std::string sortable_serialise(double value) {
    char buf[9];
    return std::string(buf, sortable_serialise_(value, buf));
}
 
XAPIAN_VISIBILITY_DEFAULT
double XAPIAN_NOTHROW(sortable_unserialise(const std::string & serialised));
 
}
 
#endif // XAPIAN_INCLUDED_QUERYPARSER_H