database.h

Go to the documentation of this file.

 
/* Copyright 1999,2000,2001 BrightStation PLC
 * Copyright 2002 Ananova Ltd
 * Copyright 2003-2026 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
 
#if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD
# error Never use <xapian/database.h> directly; include <xapian.h> instead.
#endif
 
#include <iosfwd>
#include <string>
#ifdef XAPIAN_MOVE_SEMANTICS
# include <utility>
#endif
#include <vector>
 
#include <xapian/attributes.h>
#include <xapian/deprecated.h>
#include <xapian/intrusive_ptr.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 Compactor;
class Document;
 
class XAPIAN_VISIBILITY_DEFAULT Database {
        static size_t check_(const std::string * path_ptr, int fd, int opts,
                             std::ostream *out);
 
        void compact_(const std::string * output_ptr,
                      int fd,
                      unsigned flags,
                      int block_size,
                      Xapian::Compactor * compactor) const;
 
    public:
        class Internal;
        std::vector<Xapian::Internal::intrusive_ptr<Internal> > internal;
 
        void add_database(const Database & database);
 
        size_t size() const {
            return internal.size();
        }
 
        Database();
 
        explicit Database(const std::string &path, int flags = 0);
 
        explicit Database(int fd, int flags = 0);
 
        explicit Database(Internal *internal);
 
        virtual ~Database();
 
        Database(const Database &other);
 
        void operator=(const Database &other);
 
#ifdef XAPIAN_MOVE_SEMANTICS
        Database(Database&& o);
 
        Database& operator=(Database&& o);
#endif
 
        bool reopen();
 
        virtual void close();
 
        virtual std::string get_description() const;
 
        PostingIterator postlist_begin(const std::string &tname) const;
 
        PostingIterator XAPIAN_NOTHROW(postlist_end(const std::string &) const) {
            return PostingIterator();
        }
 
        TermIterator termlist_begin(Xapian::docid did) const;
 
        TermIterator XAPIAN_NOTHROW(termlist_end(Xapian::docid) const) {
            return TermIterator();
        }
 
        bool has_positions() const;
 
        PositionIterator positionlist_begin(Xapian::docid did, const std::string &tname) const;
 
        PositionIterator XAPIAN_NOTHROW(positionlist_end(Xapian::docid, const std::string &) const) {
            return PositionIterator();
        }
 
        TermIterator allterms_begin(const std::string & prefix = std::string()) const;
 
        TermIterator XAPIAN_NOTHROW(allterms_end(const std::string & = std::string()) const) {
            return TermIterator();
        }
 
        Xapian::doccount get_doccount() const;
 
        Xapian::docid get_lastdocid() const;
 
        Xapian::doclength get_avlength() const;
 
        double get_average_length() const { return get_avlength(); }
 
        Xapian::totallength get_total_length() 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 slot) const;
 
        std::string get_value_lower_bound(Xapian::valueno slot) const;
 
        std::string get_value_upper_bound(Xapian::valueno slot) 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 XAPIAN_NOTHROW(valuestream_end(Xapian::valueno) const) {
            return ValueIterator();
        }
 
        Xapian::termcount get_doclength(Xapian::docid did) const;
 
        Xapian::termcount get_unique_terms(Xapian::docid did) const;
 
        void keep_alive();
 
        Xapian::Document get_document(Xapian::docid did) const;
 
        Xapian::Document get_document(Xapian::docid did, unsigned flags) const;
 
        std::string get_spelling_suggestion(const std::string &word,
                                            unsigned max_edit_distance = 2) const;
 
        Xapian::TermIterator spellings_begin() const;
 
        Xapian::TermIterator XAPIAN_NOTHROW(spellings_end() const) {
            return Xapian::TermIterator();
        }
 
        Xapian::TermIterator synonyms_begin(const std::string &term) const;
 
        Xapian::TermIterator XAPIAN_NOTHROW(synonyms_end(const std::string &) const) {
            return Xapian::TermIterator();
        }
 
        Xapian::TermIterator synonym_keys_begin(const std::string &prefix = std::string()) const;
 
        Xapian::TermIterator XAPIAN_NOTHROW(synonym_keys_end(const std::string & = std::string()) const) {
            return Xapian::TermIterator();
        }
 
        std::string get_metadata(const std::string & key) const;
 
        Xapian::TermIterator metadata_keys_begin(const std::string &prefix = std::string()) const;
 
        Xapian::TermIterator XAPIAN_NOTHROW(metadata_keys_end(const std::string & = std::string()) const) {
            return Xapian::TermIterator();
        }
 
        std::string get_uuid() const;
 
        bool locked() const;
 
        Xapian::rev get_revision() const;
 
        static size_t check(const std::string & path, int opts = 0,
                            std::ostream *out = NULL) {
            return check_(&path, 0, opts, out);
        }
 
        static size_t check(int fd, int opts = 0, std::ostream *out = NULL) {
            return check_(NULL, fd, opts, out);
        }
 
        void compact(const std::string & output,
                     unsigned flags = 0,
                     int block_size = 0) {
            compact_(&output, 0, flags, block_size, NULL);
        }
 
        void compact(int fd,
                     unsigned flags = 0,
                     int block_size = 0) {
            compact_(NULL, fd, flags, block_size, NULL);
        }
 
        void compact(const std::string & output,
                     unsigned flags,
                     int block_size,
                     Xapian::Compactor & compactor)
        {
            compact_(&output, 0, flags, block_size, &compactor);
        }
 
        void compact(int fd,
                     unsigned flags,
                     int block_size,
                     Xapian::Compactor & compactor)
        {
            compact_(NULL, fd, flags, block_size, &compactor);
        }
};
 
class XAPIAN_VISIBILITY_DEFAULT WritableDatabase : public Database {
    public:
        virtual ~WritableDatabase();
 
        WritableDatabase();
 
        explicit WritableDatabase(const std::string &path,
                                  int flags = 0,
                                  int block_size = 0);
 
        explicit WritableDatabase(Database::Internal *internal);
 
        WritableDatabase(const WritableDatabase &other);
 
        void operator=(const WritableDatabase &other);
 
#ifdef XAPIAN_MOVE_SEMANTICS
        WritableDatabase(WritableDatabase&& o) : Database(std::move(o)) {}
 
        WritableDatabase& operator=(WritableDatabase&& o) {
            Database::operator=(std::move(o));
            return *this;
        }
#endif
 
        void add_database(const WritableDatabase& other) {
            // This method is provided mainly so that adding a Database to a
            // WritableDatabase is a compile-time error - prior to 1.4.19, it
            // would essentially act as a "black-hole" shard which discarded
            // any changes made to it.
            Database::add_database(other);
        }
 
        void commit();
 
        XAPIAN_DEPRECATED(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 & metadata);
 
        std::string get_description() const;
};
 
}
 
#endif /* XAPIAN_INCLUDED_DATABASE_H */