Table.h

Go to the documentation of this file.

// storage/Table.h
#pragma once
 
#include "tdb.h"
 
#include <unordered_set>
 
#include "catalog/TableDesc.h"
#include "storage/BufferManager.h"
#include "storage/FileManager.h"
#include "storage/Record.h"
 
namespace taco {
 
class File;
 
class Table {
public:
    class Iterator;
 
    static void Initialize(const TableDesc *tabdesc);
 
    static std::unique_ptr<Table> Create(
        std::shared_ptr<const TableDesc> tabdesc);
 
private:
    Table(std::shared_ptr<const TableDesc> tabdesc,
          std::unique_ptr<File> file)
        : m_tabdesc(std::move(tabdesc)),
          m_file(std::move(file)),
          m_insertion_pid(INVALID_PID) {
    }
 
public:
 
    ~Table();
 
    const TableDesc*
    GetTableDesc() const {
        return m_tabdesc.get();
    }
 
    void InsertRecord(Record& rec);
 
    void EraseRecord(RecordId rid);
 
    void UpdateRecord(RecordId rid, Record &rec);
 
    Iterator StartScan();
 
    Iterator StartScanFrom(RecordId rid);
 
private:
 
    std::shared_ptr<const TableDesc> m_tabdesc;
 
    std::unique_ptr<File> m_file;
 
    PageNumber  m_insertion_pid;
 
public:
 
    class Iterator {
    public:
        Iterator():
            m_table(nullptr) {}
 
    private:
        Iterator(Table* tbl, RecordId rid);
 
    public:
        ~Iterator() {
            try {
                if (GetTable()) {
                    EndScan();
                }
            } catch (const TDBError &e) {
                // Logs a warning about errors in the end scan call, which is
                // most likely because BufferManager::UnpinPage() throws some
                // error caused by some bug in the Iterator. There's no
                // sensible thing we could do here to mitigate the issue. If
                // the page is still pinned, the buffer manager will throw a
                // fatal error when the Database destroys it, which will
                // provide greater details for debugging than calling
                // std::terminate() here.
                LOG(kWarning, "unable to destruct the iterator due to an error "
                        "in Table::Iterator::EndScan(): \n%s", e.GetMessage());
            }
        }
 
        Iterator(Iterator&& it) = default;
 
        Iterator &operator=(Iterator &&it) = default;
 
        Iterator(const Iterator& it) = delete;
 
        Iterator &operator=(const Iterator &it) = delete;
 
        constexpr Table*
        GetTable() const {
            return m_table;
        }
 
        constexpr const Record&
        GetCurrentRecord() const {
            return m_cur_record;
        }
 
        RecordId
        GetCurrentRecordId() const {
            return m_cur_record.GetRecordId();
        }
 
        bool
        IsAtValidRecord() const {
            return m_cur_record.IsValid();
        }
 
        bool Next();
 
        void EndScan();
 
    private:
        Table*          m_table;
 
        Record          m_cur_record;
 
        ScopedBufferId  m_pinned_bufid;
 
        PageNumber      m_lastpg_pid;
 
        friend class Table;
    };
 
    friend class Iterator;
};
 
}   // namespace taco