PaxStore.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/catalog/Schema.hpp>
#include <mutable/storage/Store.hpp>
#include <mutable/util/memory.hpp>
 
 
namespace m {
 
struct PaxStore : Store
{
#ifndef NDEBUG
    static constexpr std::size_t ALLOCATION_SIZE = 1UL << 30; 
#else
    static constexpr std::size_t ALLOCATION_SIZE = 1UL << 37; 
#endif
 
    static constexpr uint32_t BLOCK_SIZE = 1UL << 12; 
 
    private:
    memory::LinearAllocator allocator_; 
    memory::Memory data_; 
    std::size_t num_rows_ = 0; 
    std::size_t capacity_; 
    uint32_t *offsets_; 
    uint32_t block_size_; 
    std::size_t num_rows_per_block_; 
 
    public:
    PaxStore(const Table &table, uint32_t block_size_in_bytes = BLOCK_SIZE);
    ~PaxStore();
 
    virtual std::size_t num_rows() const override { return num_rows_; }
    std::size_t num_rows_per_block() const { return num_rows_per_block_; }
    uint32_t block_size() const { return block_size_; }
 
    uint32_t offset(uint32_t idx) const {
        M_insist(idx <= table().num_attrs(), "index out of range");
        return offsets_[idx];
    }
    uint32_t offset(const Attribute &attr) const { return offset(attr.id); }
 
    void append() override {
        if (num_rows_ == capacity_)
            throw std::logic_error("row store exceeds capacity");
        ++num_rows_;
    }
 
    void drop() override {
        M_insist(num_rows_);
        --num_rows_;
    }
 
    const memory::Memory & memory() const override { return data_; }
 
    void dump(std::ostream &out) const override;
    using Store::dump;
 
    private:
    void compute_block_offsets();
};
 
}