RowStore.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 RowStore : Store
{
#ifndef NDEBUG
    static constexpr std::size_t ALLOCATION_SIZE = 1UL << 30; 
#else
    static constexpr std::size_t ALLOCATION_SIZE = 1UL << 37; 
#endif
 
    private:
    memory::LinearAllocator allocator_; 
    memory::Memory data_; 
    std::size_t num_rows_ = 0; 
    std::size_t capacity_; 
    uint32_t *offsets_; 
    uint32_t row_size_; 
 
    public:
    RowStore(const Table &table);
    ~RowStore();
 
    virtual std::size_t num_rows() const override { return num_rows_; }
 
    int offset(uint32_t idx) const {
        M_insist(idx <= table().num_attrs(), "index out of range");
        return offsets_[idx];
    }
    int offset(const Attribute &attr) const { return offset(attr.id); }
 
    std::size_t row_size() const { return row_size_; }
 
    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 memory(memory::Memory memory) { data_ = std::move(memory); }
 
    void dump(std::ostream &out) const override;
    using Store::dump;
 
    private:
    void compute_offsets();
 
    uintptr_t at(std::size_t idx) const { return data_.as<uintptr_t>() + row_size_/8 * idx; }
};
 
}