include/xapian/query.h

Go to the documentation of this file.

/* Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002 Ananova Ltd
 * Copyright 2003,2004,2005,2006,2007,2008,2009,2012 Olly Betts
 * Copyright 2006,2007,2008,2009 Lemur Consulting Ltd
 * Copyright 2008 Richard Boulton
 *
 * 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_QUERY_H
#define XAPIAN_INCLUDED_QUERY_H

#include <string>
#include <vector>

#include <xapian/base.h>
#include <xapian/types.h>
#include <xapian/termiterator.h>
#include <xapian/visibility.h>

// FIXME: sort this out so we avoid exposing Xapian::Query::Internal
// - we need to at present so that the Xapian::Query's template ctors
// compile.
class LocalSubMatch;
class MultiMatch;
class QueryOptimiser;
struct SortPosName;

namespace Xapian {

class PostingSource;
class Registry;

class XAPIAN_VISIBILITY_DEFAULT Query {
    public:
        class Internal;
        Xapian::Internal::RefCntPtr<Internal> internal;

        typedef enum {
            OP_AND,

            OP_OR,

            OP_AND_NOT,

            OP_XOR,

            OP_AND_MAYBE,

            OP_FILTER,

            OP_NEAR,

            OP_PHRASE,

            OP_VALUE_RANGE,

            OP_SCALE_WEIGHT,

            OP_ELITE_SET,

            OP_VALUE_GE,

            OP_VALUE_LE,

            OP_SYNONYM
        } op;

        Query(const Query & copyme);

        Query & operator=(const Query & copyme);

        Query();

        ~Query();

        Query(const std::string & tname_, Xapian::termcount wqf_ = 1,
              Xapian::termpos pos_ = 0);

        Query(Query::op op_, const Query & left, const Query & right);

        Query(Query::op op_,
              const std::string & left, const std::string & right);

        template <class Iterator>
        Query(Query::op op_, Iterator qbegin, Iterator qend,
              Xapian::termcount parameter = 0);

        Query(Query::op op_, Xapian::Query q, double parameter);

        Query(Query::op op_, Xapian::valueno slot,
              const std::string &begin, const std::string &end);

        Query(Query::op op_, Xapian::valueno slot, const std::string &value);

        explicit Query(Xapian::PostingSource * external_source);

        static const Xapian::Query MatchAll;

        static const Xapian::Query MatchNothing;

        Xapian::termcount get_length() const;

        TermIterator get_terms_begin() const;

        TermIterator get_terms_end() const {
            return TermIterator();
        }

        bool empty() const;

        std::string serialise() const;

        static Query unserialise(const std::string &s);

        static Query unserialise(const std::string & s,
                                 const Registry & registry);

        std::string get_description() const;

    private:
        void add_subquery(const Query & subq);
        void add_subquery(const Query * subq);
        void add_subquery(const std::string & tname);
        void start_construction(Query::op op_, Xapian::termcount parameter);
        void end_construction();
        void abort_construction();
};

template <class Iterator>
Query::Query(Query::op op_, Iterator qbegin, Iterator qend, termcount parameter)
    : internal(0)
{
    try {
        start_construction(op_, parameter);

        /* Add all the elements */
        while (qbegin != qend) {
            add_subquery(*qbegin);
            ++qbegin;
        }

        end_construction();
    } catch (...) {
        abort_construction();
        throw;
    }
}

#ifndef SWIG // SWIG has no interest in the internal class, so hide it completely.

class XAPIAN_VISIBILITY_DEFAULT Query::Internal : public Xapian::Internal::RefCntBase {
    friend class ::LocalSubMatch;
    friend class ::MultiMatch;
    friend class ::QueryOptimiser;
    friend struct ::SortPosName;
    friend class Query;
    public:
        static const int OP_LEAF = -1;
        static const int OP_EXTERNAL_SOURCE = -2;

        typedef std::vector<Internal *> subquery_list;

        typedef int op_t;

    private:
        Xapian::Query::Internal::op_t op;

        subquery_list subqs;

        Xapian::termcount parameter;

        std::string tname;

        std::string str_parameter;

        Xapian::termpos term_pos;

        Xapian::PostingSource * external_source;

        bool external_source_owned;

        void initialise_from_copy(const Query::Internal & copyme);

        void accumulate_terms(
            std::vector<std::pair<std::string, Xapian::termpos> > &terms) const;

        Internal * simplify_query();

        void validate_query() const;

        bool simplify_matchnothing();

        static std::string get_op_name(Xapian::Query::Internal::op_t op);

        void collapse_subqs();

        Xapian::Query::Internal * flatten_subqs();

        std::string serialise(Xapian::termpos & curpos) const;

    public:
        Internal(const Query::Internal & copyme);

        void operator=(const Query::Internal & copyme);

        explicit Internal(const std::string & tname_, Xapian::termcount wqf_ = 1,
                          Xapian::termpos term_pos_ = 0);

        Internal(op_t op_, Xapian::termcount parameter);

        Internal(op_t op_, Xapian::valueno slot,
                 const std::string &begin, const std::string &end);

        Internal(op_t op_, Xapian::valueno slot, const std::string &value);

        explicit Internal(Xapian::PostingSource * external_source_, bool owned);

        ~Internal();

        static Xapian::Query::Internal * unserialise(const std::string &s,
                                                     const Registry & registry);

        void add_subquery(const Query::Internal * subq);

        void add_subquery_nocopy(Query::Internal * subq);

        void set_dbl_parameter(double dbl_parameter_);

        double get_dbl_parameter() const;

        Query::Internal * end_construction();

        std::string serialise() const {
            Xapian::termpos curpos = 1;
            return serialise(curpos);
        }

        std::string get_description() const;

        Xapian::termcount get_parameter() const { return parameter; }

        Xapian::termcount get_wqf() const { return parameter; }

        Xapian::termcount get_length() const;

        TermIterator get_terms() const;
};

#endif // SWIG

}

#endif /* XAPIAN_INCLUDED_QUERY_H */

---