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