include/xapian/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 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 XAPIAN_INCLUDED_DATABASE_H
#define XAPIAN_INCLUDED_DATABASE_H

#include <string>
#include <vector>

#include <xapian/base.h>
#include <xapian/document.h>
#include <xapian/types.h>
#include <xapian/positioniterator.h>
#include <xapian/postingiterator.h>
#include <xapian/termiterator.h>
#include <xapian/valueiterator.h>
#include <xapian/visibility.h>

namespace Xapian {

class XAPIAN_VISIBILITY_DEFAULT Database {
    public:
        class Internal;
        std::vector<Xapian::Internal::RefCntPtr<Internal> > internal;

        Document::Internal * get_document_lazily(Xapian::docid did) const;

        void add_database(const Database & database);

        Database();

        explicit Database(const std::string &path);

        explicit Database(Internal *internal);

        virtual ~Database();

        Database(const Database &other);

        void operator=(const Database &other);

        void reopen();

        virtual void close();

        virtual std::string get_description() const;

        PostingIterator postlist_begin(const std::string &tname) const;

        PostingIterator postlist_end(const std::string &) const {
            return PostingIterator(NULL);
        }

        TermIterator termlist_begin(Xapian::docid did) const;

        TermIterator termlist_end(Xapian::docid) const {
            return TermIterator(NULL);
        }

        bool has_positions() const;

        PositionIterator positionlist_begin(Xapian::docid did, const std::string &tname) const;

        PositionIterator positionlist_end(Xapian::docid, const std::string &) const {
            return PositionIterator(NULL);
        }

        TermIterator allterms_begin() const;

        TermIterator allterms_end() const {
            return TermIterator(NULL);
        }

        TermIterator allterms_begin(const std::string & prefix) const;

        TermIterator allterms_end(const std::string &) const {
            return TermIterator(NULL);
        }

        Xapian::doccount get_doccount() const;

        Xapian::docid get_lastdocid() const;

        Xapian::doclength get_avlength() const;

        Xapian::doccount get_termfreq(const std::string & tname) const;

        bool term_exists(const std::string & tname) const;

        Xapian::termcount get_collection_freq(const std::string & tname) const;

        Xapian::doccount get_value_freq(Xapian::valueno valno) const;

        std::string get_value_lower_bound(Xapian::valueno valno) const;

        std::string get_value_upper_bound(Xapian::valueno valno) const;

        Xapian::termcount get_doclength_lower_bound() const;

        Xapian::termcount get_doclength_upper_bound() const;

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

        ValueIterator valuestream_begin(Xapian::valueno slot) const;

        ValueIterator valuestream_end(Xapian::valueno) const {
            return ValueIterator();
        }

        Xapian::termcount get_doclength(Xapian::docid did) const;

        void keep_alive();

        Xapian::Document get_document(Xapian::docid did) const;

        std::string get_spelling_suggestion(const std::string &word,
                                            unsigned max_edit_distance = 2) const;

        Xapian::TermIterator spellings_begin() const;

        Xapian::TermIterator spellings_end() const {
            return Xapian::TermIterator(NULL);
        }

        Xapian::TermIterator synonyms_begin(const std::string &term) const;

        Xapian::TermIterator synonyms_end(const std::string &) const {
            return Xapian::TermIterator(NULL);
        }

        Xapian::TermIterator synonym_keys_begin(const std::string &prefix = std::string()) const;

        Xapian::TermIterator synonym_keys_end(const std::string & = std::string()) const {
            return Xapian::TermIterator(NULL);
        }

        std::string get_metadata(const std::string & key) const;

        Xapian::TermIterator metadata_keys_begin(const std::string &prefix = std::string()) const;

        Xapian::TermIterator metadata_keys_end(const std::string & = std::string()) const {
            return Xapian::TermIterator(NULL);
        }

        std::string get_uuid() const;
};

class XAPIAN_VISIBILITY_DEFAULT WritableDatabase : public Database {
    public:
        virtual ~WritableDatabase();

        WritableDatabase();

        WritableDatabase(const std::string &path, int action);

        explicit WritableDatabase(Database::Internal *internal);

        WritableDatabase(const WritableDatabase &other);

        void operator=(const WritableDatabase &other);

        void commit();

        void flush() { commit(); }

        void begin_transaction(bool flushed=true);

        void commit_transaction();

        void cancel_transaction();

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

        void delete_document(Xapian::docid did);

        void delete_document(const std::string & unique_term);

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

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

        void add_spelling(const std::string & word,
                          Xapian::termcount freqinc = 1) const;

        void remove_spelling(const std::string & word,
                             Xapian::termcount freqdec = 1) const;

        void add_synonym(const std::string & term,
                         const std::string & synonym) const;

        void remove_synonym(const std::string & term,
                            const std::string & synonym) const;

        void clear_synonyms(const std::string & term) const;

        void set_metadata(const std::string & key, const std::string & value);

        std::string get_description() const;
};

const int DB_CREATE_OR_OPEN = 1;
const int DB_CREATE = 2;
const int DB_CREATE_OR_OVERWRITE = 3;
const int DB_OPEN = 4;
// Can't see any sensible use for this one
// const int DB_OVERWRITE = XXX;

}

#endif /* XAPIAN_INCLUDED_DATABASE_H */

---