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 */