fixable_page_h.h

Go to the documentation of this file.

/*
 * (c) Copyright 2011-2014, Hewlett-Packard Development Company, LP
 */

#ifndef __FIXABLE_PAGE_H_H
#define __FIXABLE_PAGE_H_H

#include "buffer_pool.hpp"
#include "generic_page.h"
#include "latch.h"
#include "sm_base.h"

class fixable_page_h : public generic_page_h {
public:
    static int force_Q_fixing; // converts S mode to Q when: 0=no (default), 1=root only, 2=all <<<>>>

    // ======================================================================
    //   BEGIN: Construction/destruction/assignment
    // ======================================================================

    fixable_page_h() : generic_page_h(nullptr),
                       _bufferpool_managed(false),
                       _mode(LATCH_NL) {}

    ~fixable_page_h() {
        unfix();
    }

    fixable_page_h& operator=(fixable_page_h& p) {
        if (&p != this) {
            unfix();
            _pp = p._pp;
            _bufferpool_managed = p._bufferpool_managed;
            _mode = p._mode;
            _Q_ticket = p._Q_ticket;
            p._pp = nullptr;
            p._mode = LATCH_NL;
        }
        return *this;
    }

    // ======================================================================
    //   BEGIN: [Un]fixing pages
    // ======================================================================

    bool is_fixed() const {
        return _pp != 0;
    }

    void unfix(bool evict = false);

    bool is_bufferpool_managed() const {
        return _bufferpool_managed;
    }

    w_rc_t fix_nonroot(const fixable_page_h& parent,
                       PageID pid, latch_mode_t mode, bool conditional = false,
                       bool virgin_page = false, bool only_if_hit = false);

    w_rc_t fix_direct(PageID pid, latch_mode_t mode, bool conditional = false,
                      bool virgin_page = false, bool only_if_hit = false,
                      bool do_recovery = true);

    bf_idx pin_for_refix();

    w_rc_t refix_direct(bf_idx idx, latch_mode_t mode, bool conditional = false);

    w_rc_t fix_root(StoreID store, latch_mode_t mode,
                    bool conditional = false, bool virgin = false);

    void fix_nonbufferpool_page(generic_page* s);


    // ======================================================================
    //   BEGIN: Other page operations
    // ======================================================================

    bool is_dirty() const;

    void update_page_lsn(const lsn_t& lsn) const;

    lsn_t get_page_lsn() const;

    uint32_t get_log_volume();

    void increment_log_volume(uint32_t);

    void reset_log_volume();

    bool has_check_recovery();

    void set_img_page_lsn(const lsn_t& lsn);

    bool is_to_be_deleted();

    w_rc_t set_to_be_deleted(bool log_it);

    void unset_to_be_deleted();

    void set_check_recovery(bool);

    void set_tag(page_tag_t tag) {
        _pp->tag = tag;
    }

    latch_mode_t latch_mode() const {
        return _mode;
    }

    bool is_latched() const {
        return _mode == LATCH_SH || _mode == LATCH_EX;
    }

    bool change_possible_after_fix() const;

    bool upgrade_latch_conditional(latch_mode_t mode = LATCH_EX);


    // ======================================================================
    //   BEGIN: Interface for use only by buffer manager to perform swizzling
    // ======================================================================

    bool has_children() const;

    int max_child_slot() const;

    PageID* child_slot_address(int child_slot) const;

    static general_recordid_t find_page_id_slot(generic_page* page, PageID pid);

    PageID root() const;

    void setup_for_restore(generic_page* pp);

    bool is_pinned_for_restore();

protected:
    friend class borrowed_btree_page_h;

    bool _bufferpool_managed; 
    latch_mode_t _mode;

    q_ticket_t _Q_ticket;
};

#endif // __FIXABLE_PAGE_H_H