database.h

Go to the documentation of this file.

 
/* Copyright 2003-2026 Olly Betts
 * Copyright 2007,2008,2009 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, see
 * <https://www.gnu.org/licenses/>.
 */
 
#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>
#include <string_view>
#include <utility>
#include <vector>
 
#include <xapian/attributes.h>
#include <xapian/constants.h>
#include <xapian/intrusive_ptr.h>
#include <xapian/positioniterator.h>
#include <xapian/postingiterator.h>
#include <xapian/termiterator.h>
#include <xapian/types.h>
#include <xapian/valueiterator.h>
#include <xapian/visibility.h>
 
namespace Xapian {
 
class Compactor;
class Document;
class WritableDatabase;
 
class XAPIAN_VISIBILITY_DEFAULT Database {
    static size_t check_(const std::string_view* path_ptr,
                         int fd,
                         int opts,
                         std::ostream* out);
 
    void compact_(const std::string_view* output_ptr,
                  int fd,
                  unsigned flags,
                  int block_size,
                  Xapian::Compactor* compactor) const;
 
  protected:
    void add_database_(const Database& other, bool read_only);
 
  public:
    class Internal;
    Xapian::Internal::intrusive_ptr_nonnull<Internal> internal;
 
    void add_database(const Database& other) {
        add_database_(other, true);
    }
 
    size_t size() const;
 
    Database();
 
    explicit Database(std::string_view path, int flags = 0);
 
    explicit Database(int fd, int flags = 0);
 
    XAPIAN_VISIBILITY_INTERNAL
    explicit Database(Internal* internal) XAPIAN_NONNULL();
 
    virtual ~Database();
 
    Database(const Database& o);
 
    Database& operator=(const Database& o);
 
    Database(Database&& o);
 
    Database& operator=(Database&& o);
 
    bool reopen();
 
    void close();
 
    virtual std::string get_description() const;
 
    PostingIterator postlist_begin(std::string_view term) const;
 
    PostingIterator postlist_end(std::string_view) const noexcept {
        return PostingIterator();
    }
 
    TermIterator termlist_begin(Xapian::docid did) const;
 
    TermIterator termlist_end(Xapian::docid) const noexcept {
        return TermIterator();
    }
 
    bool has_positions() const;
 
    PositionIterator positionlist_begin(Xapian::docid did,
                                        std::string_view term) const;
 
    PositionIterator positionlist_end(Xapian::docid,
                                      std::string_view) const noexcept {
        return PositionIterator();
    }
 
    TermIterator allterms_begin(std::string_view prefix = {}) const;
 
    TermIterator allterms_end(std::string_view = {}) const noexcept
    {
        return TermIterator();
    }
 
    Xapian::doccount get_doccount() const;
 
    Xapian::docid get_lastdocid() const;
 
    double get_average_length() const;
 
    double get_avlength() const { return get_average_length(); }
 
    Xapian::totallength get_total_length() const;
 
    Xapian::doccount get_termfreq(std::string_view term) const;
 
    bool term_exists(std::string_view term) const;
 
    Xapian::termcount get_collection_freq(std::string_view term) 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(std::string_view term) const;
 
    Xapian::termcount get_unique_terms_lower_bound() const;
 
    Xapian::termcount get_unique_terms_upper_bound() const;
 
    ValueIterator valuestream_begin(Xapian::valueno slot) const;
 
    ValueIterator valuestream_end(Xapian::valueno) const noexcept {
        return ValueIterator();
    }
 
    Xapian::termcount get_doclength(Xapian::docid did) const;
 
    Xapian::termcount get_unique_terms(Xapian::docid did) const;
 
    Xapian::termcount get_wdfdocmax(Xapian::docid did) const;
 
    void keep_alive();
 
    Xapian::Document get_document(Xapian::docid did,
                                  unsigned flags = 0) const;
 
    std::string get_spelling_suggestion(std::string_view word,
                                        unsigned max_edit_distance = 2) const;
 
    Xapian::TermIterator spellings_begin() const;
 
    Xapian::TermIterator spellings_end() const noexcept {
        return Xapian::TermIterator();
    }
 
    Xapian::TermIterator synonyms_begin(std::string_view term) const;
 
    Xapian::TermIterator synonyms_end(std::string_view) const noexcept {
        return Xapian::TermIterator();
    }
 
    Xapian::TermIterator synonym_keys_begin(std::string_view prefix = {}) const;
 
    Xapian::TermIterator
    synonym_keys_end(std::string_view = {}) const noexcept {
        return Xapian::TermIterator();
    }
 
    std::string get_metadata(std::string_view key) const;
 
    Xapian::TermIterator
        metadata_keys_begin(std::string_view prefix = {}) const;
 
    Xapian::TermIterator
    metadata_keys_end(std::string_view = {}) const noexcept {
        return Xapian::TermIterator();
    }
 
    std::string get_uuid() const;
 
    bool locked() const;
 
    Xapian::WritableDatabase lock(int flags = 0);
 
    Xapian::Database unlock();
 
    Xapian::rev get_revision() const;
 
    static size_t check(std::string_view 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(std::string_view 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(std::string_view 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);
    }
 
    std::string reconstruct_text(Xapian::docid did,
                                 size_t length = 0,
                                 std::string_view prefix = {},
                                 Xapian::termpos start_pos = 0,
                                 Xapian::termpos end_pos = 0) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT WritableDatabase : public Database {
    void end_transaction_(bool do_commit);
 
  public:
    WritableDatabase() : Database() {}
 
    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 2.0.0, it
        // would essentially act as a "black-hole" shard which discarded
        // any changes made to it.
        add_database_(other, false);
    }
 
    explicit WritableDatabase(std::string_view path,
                              int flags = 0,
                              int block_size = 0);
 
    XAPIAN_VISIBILITY_INTERNAL
    explicit WritableDatabase(Database::Internal* internal_)
        : Database(internal_) {}
 
    WritableDatabase(const WritableDatabase& o) : Database(o) {}
 
    WritableDatabase& operator=(const WritableDatabase& o) {
        Database::operator=(o);
        return *this;
    }
 
    WritableDatabase(WritableDatabase&& o) : Database(std::move(o)) {}
 
    WritableDatabase& operator=(WritableDatabase&& o) {
        Database::operator=(std::move(o));
        return *this;
    }
 
    void commit();
 
    void begin_transaction(bool flushed = true);
 
    void commit_transaction() { end_transaction_(true); }
 
    void cancel_transaction() { end_transaction_(false); }
 
    Xapian::docid add_document(const Xapian::Document& doc);
 
    void delete_document(Xapian::docid did);
 
    void delete_document(std::string_view unique_term);
 
    void replace_document(Xapian::docid did, const Xapian::Document& document);
 
    Xapian::docid replace_document(std::string_view unique_term,
                                   const Xapian::Document& document);
 
    void add_spelling(std::string_view word,
                      Xapian::termcount freqinc = 1) const;
 
    termcount remove_spelling(std::string_view word,
                              termcount freqdec = 1) const;
 
    void add_synonym(std::string_view term,
                     std::string_view synonym) const;
 
    void remove_synonym(std::string_view term,
                        std::string_view synonym) const;
 
    void clear_synonyms(std::string_view term) const;
 
    void set_metadata(std::string_view key, std::string_view metadata);
 
    std::string get_description() const;
};
 
}
 
#endif // XAPIAN_INCLUDED_DATABASE_H