databaseinternal.h

Go to the documentation of this file.

 
/* Copyright 2004-2024 Olly Betts
 * Copyright 2007,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, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef XAPIAN_INCLUDED_DATABASEINTERNAL_H
#define XAPIAN_INCLUDED_DATABASEINTERNAL_H
 
#include "internaltypes.h"
 
#include <xapian/database.h>
#include <xapian/document.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 <string>
#include <string_view>
 
typedef Xapian::TermIterator::Internal TermList;
typedef Xapian::PositionIterator::Internal PositionList;
typedef Xapian::ValueIterator::Internal ValueList;
 
class LeafPostList;
 
namespace Xapian {
namespace Internal {
class PostList;
}
}
using Xapian::Internal::PostList;
 
namespace Xapian {
 
class Query;
struct ReplicationInfo;
 
class Database::Internal : public Xapian::Internal::intrusive_base {
    friend class Database;
 
    Internal& operator=(const Internal&) = delete;
 
    Internal(const Internal&) = delete;
 
    void dtor_called_();
 
  protected:
    enum transaction_state {
        TRANSACTION_READONLY = -2, // Not a writable database shard.
        TRANSACTION_UNIMPLEMENTED = -1, // Used by InMemory.
        TRANSACTION_NONE = 0,
        TRANSACTION_UNFLUSHED = 1,
        TRANSACTION_FLUSHED = 2
    };
 
    Internal(transaction_state transaction_support)
        : state(transaction_support) {}
 
    transaction_state state;
 
    bool is_read_only() const {
        return state == TRANSACTION_READONLY;
    }
 
    bool transaction_active() const { return state > 0; }
 
    void dtor_called() {
        // Inline the check to exclude no-op cases (read-only and unimplemented).
        if (state >= 0)
            dtor_called_();
    }
 
  public:
    virtual ~Internal() {}
 
    typedef Xapian::doccount size_type;
 
    virtual size_type size() const;
 
    virtual void keep_alive();
 
    virtual void readahead_for_query(const Query& query) const;
 
    virtual doccount get_doccount() const = 0;
 
    virtual docid get_lastdocid() const = 0;
 
    virtual totallength get_total_length() const = 0;
 
    virtual termcount get_doclength(docid did) const = 0;
 
    virtual termcount get_unique_terms(docid did) const = 0;
 
    virtual termcount get_wdfdocmax(docid did) const = 0;
 
    virtual void get_freqs(std::string_view term,
                           doccount* termfreq_ptr,
                           termcount* collfreq_ptr) const = 0;
 
    virtual doccount get_value_freq(valueno slot) const = 0;
 
    virtual std::string get_value_lower_bound(valueno slot) const = 0;
 
    virtual std::string get_value_upper_bound(valueno slot) const = 0;
 
    virtual termcount get_doclength_lower_bound() const = 0;
 
    virtual termcount get_doclength_upper_bound() const = 0;
 
    virtual termcount get_wdf_upper_bound(std::string_view term) const = 0;
 
    virtual termcount get_unique_terms_lower_bound() const;
 
    virtual termcount get_unique_terms_upper_bound() const;
 
    virtual bool term_exists(std::string_view term) const = 0;
 
    virtual bool has_positions() const = 0;
 
    virtual PostList* open_post_list(std::string_view term) const = 0;
 
    virtual LeafPostList* open_leaf_post_list(std::string_view term,
                                              bool need_read_pos) const = 0;
 
    virtual ValueList* open_value_list(valueno slot) const;
 
    virtual TermList* open_term_list(docid did) const = 0;
 
    virtual TermList* open_term_list_direct(docid did) const = 0;
 
    virtual TermList* open_allterms(std::string_view prefix) const = 0;
 
    virtual PositionList* open_position_list(docid did,
                                             std::string_view term) const = 0;
 
    virtual Document::Internal* open_document(docid did, bool lazy) const = 0;
 
    virtual TermList* open_spelling_termlist(std::string_view word) const;
 
    virtual TermList* open_spelling_wordlist() const;
 
    virtual doccount get_spelling_frequency(std::string_view word) const;
 
    virtual void add_spelling(std::string_view word,
                              termcount freqinc) const;
 
    virtual termcount remove_spelling(std::string_view word,
                                      termcount freqdec) const;
 
    virtual TermList* open_synonym_termlist(std::string_view term) const;
 
    virtual TermList* open_synonym_keylist(std::string_view prefix) const;
 
    virtual void add_synonym(std::string_view term,
                             std::string_view synonym) const;
 
    virtual void remove_synonym(std::string_view term,
                                std::string_view synonym) const;
 
    virtual void clear_synonyms(std::string_view term) const;
 
    virtual std::string get_metadata(std::string_view key) const;
 
    virtual TermList* open_metadata_keylist(std::string_view prefix) const;
 
    virtual void set_metadata(std::string_view key, std::string_view value);
 
    virtual bool reopen();
 
    virtual void close() = 0;
 
    virtual void commit();
 
    virtual void cancel();
 
    virtual void begin_transaction(bool flushed);
 
    virtual void end_transaction(bool do_commit);
 
    virtual docid add_document(const Document& document);
 
    virtual void delete_document(docid did);
 
    virtual void delete_document(std::string_view unique_term);
 
    virtual void replace_document(docid did,
                                  const Document& document);
 
    virtual docid replace_document(std::string_view unique_term,
                                   const Document& document);
 
    virtual void request_document(docid did) const;
 
    virtual void write_changesets_to_fd(int fd,
                                        std::string_view start_revision,
                                        bool need_whole_db,
                                        ReplicationInfo* info);
 
    virtual Xapian::rev get_revision() const;
 
    virtual std::string get_uuid() const;
 
    virtual void invalidate_doc_object(Document::Internal* obj) const;
 
    virtual int get_backend_info(std::string* path) const = 0;
 
    virtual void get_used_docid_range(docid& first,
                                      docid& last) const;
 
    virtual bool locked() const;
 
    virtual Internal* update_lock(int flags);
 
    virtual std::string reconstruct_text(Xapian::docid did,
                                         size_t length,
                                         std::string_view prefix,
                                         Xapian::termpos start_pos,
                                         Xapian::termpos end_pos) const;
 
    virtual std::string get_description() const = 0;
};
 
}
 
#endif // XAPIAN_INCLUDED_DATABASEINTERNAL_H