Index.h

Go to the documentation of this file.

#ifndef INDEX_INDEX_H
#define INDEX_INDEX_H
 
#include "tdb.h"
 
#include "index/BulkLoadIterator.h"
#include "index/IndexKey.h"
#include "index/idxtyps.h"
#include "catalog/IndexDesc.h"
#include "storage/Record.h"
 
namespace taco {
 
class Index {
public:
    class Iterator;
 
    static void Initialize(const IndexDesc *idxdesc);
 
    static std::unique_ptr<Index> Create(
        std::shared_ptr<const IndexDesc> idxdesc);
 
    virtual ~Index();
 
    const IndexDesc*
    GetIndexDesc() const {
        return m_idxdesc.get();
    }
 
    const Schema*
    GetKeySchema() const {
        return m_idxdesc->GetKeySchema();
    }
 
    virtual void BulkLoad(BulkLoadIterator &iter);
 
    virtual bool InsertKey(const IndexKey *key, RecordId rid) = 0;
 
    bool InsertRecord(const Record& rec, const Schema *tabschema = nullptr);
 
    virtual bool DeleteKey(const IndexKey *key, RecordId &rid) = 0;
 
    bool DeleteRecord(Record& rec, const Schema *tabschema = nullptr);
 
    virtual std::unique_ptr<Iterator> StartScan(const IndexKey *lower,
                                                bool lower_isstrict,
                                                const IndexKey *upper,
                                                bool upper_isstrict) = 0;
 
protected:
    Index(std::shared_ptr<const IndexDesc> idxdesc);
 
private:
    void PrepareKey(std::vector<Datum> &data,
                    const char *recbuf,
                    const Schema *tabschema);
 
    std::shared_ptr<const IndexDesc> m_idxdesc;
 
    unique_malloced_ptr m_key;
public:
    class Iterator {
    public:
        Iterator() = default;
        Iterator(const Iterator&) = delete;
        Iterator& operator=(const Iterator&) = delete;
 
        Iterator(Iterator&& it) = default;
 
        Iterator &operator=(Iterator &&it) = default;
 
        virtual ~Iterator() = default;
 
        constexpr const Index*
        GetIndex() const {
            return m_index;
        }
 
        virtual bool Next() = 0;
 
        virtual bool IsAtValidItem() = 0;
 
        virtual const Record &GetCurrentItem() = 0;
 
        virtual RecordId GetCurrentRecordId() = 0;
 
        virtual void EndScan() = 0;
 
    protected:
        Iterator(Index *index):
            m_index(index) {}
 
        template<class T>
        constexpr T*
        GetIndexAs() const {
            return (T*) m_index;
        }
 
    private:
        Index *m_index;
    };
};
 
}   // namespace taco
 
#endif      // INDEX_INDEX_H