database.h

Go to the documentation of this file.

/* Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002 Ananova Ltd
 * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2011,2013,2014,2015,2016 Olly Betts
 * Copyright 2006,2008 Lemur Consulting Ltd
 *
 * 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 OM_HGUARD_DATABASE_H
#define OM_HGUARD_DATABASE_H

#include <string>

#include "internaltypes.h"

#include "xapian/intrusive_ptr.h"
#include <xapian/types.h>
#include <xapian/database.h>
#include <xapian/document.h>
#include <xapian/positioniterator.h>
#include <xapian/termiterator.h>
#include <xapian/valueiterator.h>

using std::string;
using std::vector;

class LeafPostList;
class RemoteDatabase;

typedef Xapian::TermIterator::Internal TermList;
typedef Xapian::PositionIterator::Internal PositionList;
typedef Xapian::ValueIterator::Internal ValueList;

namespace Xapian {

class Query;
struct ReplicationInfo;

class Database::Internal : public Xapian::Internal::intrusive_base {
    private:
        Internal(const Internal &);

        void operator=(const Internal &);

    protected:
        enum {
            TRANSACTION_UNIMPLEMENTED = -1, // Used by InMemory.
            TRANSACTION_NONE = 0,
            TRANSACTION_UNFLUSHED = 1,
            TRANSACTION_FLUSHED = 2
        } transaction_state;

        bool transaction_active() const { return int(transaction_state) > 0; }

        Internal() : transaction_state(TRANSACTION_NONE) { }

        void dtor_called();

    public:
        virtual ~Internal();

        virtual void keep_alive();

        virtual void readahead_for_query(const Xapian::Query & query);

        // Database statistics:
        // ====================

        virtual Xapian::doccount get_doccount() const = 0;

        virtual Xapian::docid get_lastdocid() const = 0;

        virtual Xapian::totallength get_total_length() const = 0;

        virtual Xapian::termcount get_doclength(Xapian::docid did) const = 0;

        virtual Xapian::termcount get_unique_terms(Xapian::docid did) const = 0;

        virtual void get_freqs(const string & term,
                               Xapian::doccount * termfreq_ptr,
                               Xapian::termcount * collfreq_ptr) const = 0;

        virtual Xapian::doccount get_value_freq(Xapian::valueno slot) const = 0;

        virtual std::string get_value_lower_bound(Xapian::valueno slot) const = 0;

        virtual std::string get_value_upper_bound(Xapian::valueno slot) const = 0;

        virtual Xapian::termcount get_doclength_lower_bound() const;

        virtual Xapian::termcount get_doclength_upper_bound() const;

        virtual Xapian::termcount get_wdf_upper_bound(const std::string & term) const;

        virtual bool term_exists(const string & tname) const = 0;

        virtual bool has_positions() const = 0;

        // Data item access methods:
        // =========================

        virtual LeafPostList * open_post_list(const string & tname) const = 0;

        virtual ValueList * open_value_list(Xapian::valueno slot) const;

        virtual TermList * open_term_list(Xapian::docid did) const = 0;

        virtual TermList * open_allterms(const string & prefix) const = 0;

        virtual PositionList * open_position_list(Xapian::docid did,
                                        const string & tname) const = 0;

        virtual Xapian::Document::Internal *
        open_document(Xapian::docid did, bool lazy) const = 0;

        virtual TermList * open_spelling_termlist(const string & word) const;

        virtual TermList * open_spelling_wordlist() const;

        virtual Xapian::doccount get_spelling_frequency(const string & word) const;

        virtual void add_spelling(const string & word,
                                  Xapian::termcount freqinc) const;

        virtual void remove_spelling(const string & word,
                                     Xapian::termcount freqdec) const;

        virtual TermList * open_synonym_termlist(const string & term) const;

        virtual TermList * open_synonym_keylist(const string & prefix) const;

        virtual void add_synonym(const string & term, const string & synonym) const;

        virtual void remove_synonym(const string & term, const string & synonym) const;

        virtual void clear_synonyms(const string & term) const;

        virtual string get_metadata(const string & key) const;

        virtual TermList * open_metadata_keylist(const std::string &prefix) const;

        virtual void set_metadata(const string & key, const string & value);

        virtual bool reopen();

        virtual void close() = 0;

        // Modifying the database:
        // =======================

        virtual void commit();

        virtual void cancel();

        void begin_transaction(bool flushed);

        void commit_transaction();

        void cancel_transaction();

        virtual Xapian::docid add_document(const Xapian::Document & document);

        virtual void delete_document(Xapian::docid did);

        virtual void delete_document(const string & unique_term);

        virtual void replace_document(Xapian::docid did,
                                      const Xapian::Document & document);

        virtual Xapian::docid replace_document(const string & unique_term,
                                               const Xapian::Document & document);

        virtual void request_document(Xapian::docid /*did*/) const;

        virtual Xapian::Document::Internal * collect_document(Xapian::docid did) const;

        virtual void write_changesets_to_fd(int fd,
                                            const std::string & start_revision,
                                            bool need_whole_db,
                                            Xapian::ReplicationInfo * info);

        virtual string get_revision_info() const;

        virtual string get_uuid() const;

        virtual void invalidate_doc_object(Xapian::Document::Internal * obj) const;

        virtual int get_backend_info(string * path) const = 0;

        virtual void get_used_docid_range(Xapian::docid & first,
                                          Xapian::docid & last) const;

        virtual bool locked() const;
};

}

#endif /* OM_HGUARD_DATABASE_H */