DataRecord.h

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <iostream>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "../Fort/fort.hpp"
#include "Column.h"
 
namespace ColumnStore {
class DataValue {
    std::any value;
 
   public:
    DataValue(std::any value) : value(value) {}
 
    template <typename T>
    const T as() const {
        return std::any_cast<T>(value);
    }
 
    void operator=(std::any value) { this->value = value; }
 
    std::any get() { return value; }
 
    operator int() { return as<int>(); }
    operator float() { return as<float>(); }
    operator std::string() { return as<std::string>(); }
};
 
struct DataRecord {
    std::vector<DataValue> values;
    DataRecord() {}
    DataRecord(std::vector<DataValue>& values) : values(std::move(values)) {}
 
    DataValue& operator[](int index) { return values[index]; }
};
 
class DataRecordMetadata {
    std::vector<Column> columns;
    std::unordered_map<std::string, int> columnMap;
 
   public:
    DataRecordMetadata(std::vector<Column> columns) : columns(columns) {
        for (int i = 0; i < int(columns.size()); i++) {
            columnMap[columns[i].name] = i;
            columns[i].index = i;
        }
    }
    std::vector<Column>& getColumns() { return columns; }
 
    Column& operator[](int i) {
        assert(i < int(columns.size()));
        return columns[i];
    }
 
    Column& getColumn(std::string name) { return (*this)[name]; }
 
    Column& getColumn(int i) { return (*this)[i]; }
 
    Column& operator[](std::string name) {
        assert(columnMap.find(name) != columnMap.end());
        return columns[columnMap[name]];
    }
 
    void print(DataRecord& record) {
        fort::char_table table;
        table << fort::header;
 
        for (int i = 0; i < int(columns.size()); i++) table << columns[i].name;
 
        table << fort::endr;
 
        for (int i = 0; i < int(columns.size()); i++) {
            auto type = columns[i].type;
            if (type == DataType::INT)
                table << record[i].as<int>();
            else if (type == DataType::FLOAT)
                table << record[i].as<float>();
            else if (type == DataType::STRING)
                table << record[i].as<std::string>();
            else
                throw std::runtime_error("Unknown DataType");
        }
        table << fort::endr;
 
        std::cout << table.to_string() << std::endl;
    }
 
    void print() {
        for (int i = 0; i < int(columns.size()); i++) {
            auto type = columns[i].type;
            std::cout << columns[i].name << " - ";
            if (type == DataType::INT)
                std::cout << "INT";
            else if (type == DataType::FLOAT)
                std::cout << "FLOAT";
            else if (type == DataType::STRING)
                std::cout << "STRING";
            else
                throw std::runtime_error("Unknown DataType");
 
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
};
 
typedef std::shared_ptr<DataRecordMetadata> Metadata;
};  // namespace ColumnStore