value.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <utility>
 
#include "api.h"
#include "date_t.h"
#include "int128_t.h"
#include "interval_t.h"
#include "ku_list.h"
#include "timestamp_t.h"
#include "uint128_t.h"
#include "uuid.h"
 
namespace lbug {
namespace common {
 
class NodeVal;
class RelVal;
struct FileInfo;
class NestedVal;
class RecursiveRelVal;
class ArrowRowBatch;
class ValueVector;
class Serializer;
class Deserializer;
 
class Value {
    friend class NodeVal;
    friend class RelVal;
    friend class NestedVal;
    friend class RecursiveRelVal;
    friend class ArrowRowBatch;
    friend class ValueVector;
 
public:
    LBUG_API static Value createNullValue();
    LBUG_API static Value createNullValue(const LogicalType& dataType);
    LBUG_API static Value createDefaultValue(const LogicalType& dataType);
    LBUG_API explicit Value(bool val_);
    LBUG_API explicit Value(int8_t val_);
    LBUG_API explicit Value(int16_t val_);
    LBUG_API explicit Value(int32_t val_);
    LBUG_API explicit Value(int64_t val_);
    LBUG_API explicit Value(uint8_t val_);
    LBUG_API explicit Value(uint16_t val_);
    LBUG_API explicit Value(uint32_t val_);
    LBUG_API explicit Value(uint64_t val_);
    LBUG_API explicit Value(int128_t val_);
    LBUG_API explicit Value(ku_uuid_t val_);
    LBUG_API explicit Value(double val_);
    LBUG_API explicit Value(float val_);
    LBUG_API explicit Value(date_t val_);
    LBUG_API explicit Value(timestamp_ns_t val_);
    LBUG_API explicit Value(timestamp_ms_t val_);
    LBUG_API explicit Value(timestamp_sec_t val_);
    LBUG_API explicit Value(timestamp_tz_t val_);
    LBUG_API explicit Value(timestamp_t val_);
    LBUG_API explicit Value(interval_t val_);
    LBUG_API explicit Value(internalID_t val_);
    LBUG_API explicit Value(uint128_t val_);
    LBUG_API explicit Value(const char* val_);
    LBUG_API explicit Value(const std::string& val_);
    LBUG_API explicit Value(uint8_t* val_);
    LBUG_API explicit Value(LogicalType type, std::string val_);
    LBUG_API explicit Value(LogicalType dataType, std::vector<std::unique_ptr<Value>> children);
    LBUG_API Value(const Value& other);

    LBUG_API Value(Value&& other) = default;
    LBUG_API Value& operator=(Value&& other) = default;
    LBUG_API bool operator==(const Value& rhs) const;

    LBUG_API void setDataType(const LogicalType& dataType_);
    LBUG_API const LogicalType& getDataType() const;
    LBUG_API void setNull(bool flag);
    LBUG_API void setNull();
    LBUG_API bool isNull() const;
    LBUG_API void copyFromRowLayout(const uint8_t* value);
    LBUG_API void copyFromColLayout(const uint8_t* value, ValueVector* vec = nullptr);
    LBUG_API void copyValueFrom(const Value& other);
    template<class T>
    T getValue() const {
        throw std::runtime_error("Unimplemented template for Value::getValue()");
    }

    template<class T>
    T& getValueReference() {
        throw std::runtime_error("Unimplemented template for Value::getValueReference()");
    }

    template<class T>
    static Value createValue(T /*value*/) {
        throw std::runtime_error("Unimplemented template for Value::createValue()");
    }

    LBUG_API std::unique_ptr<Value> copy() const;
    LBUG_API std::string toString() const;
 
    LBUG_API void serialize(Serializer& serializer) const;
 
    LBUG_API static std::unique_ptr<Value> deserialize(Deserializer& deserializer);
 
    LBUG_API void validateType(common::LogicalTypeID targetTypeID) const;
 
    bool hasNoneNullChildren() const;
    bool allowTypeChange() const;
 
    uint64_t computeHash() const;
 
    uint32_t getChildrenSize() const { return childrenSize; }
 
private:
    Value();
    explicit Value(const LogicalType& dataType);
 
    void resizeChildrenVector(uint64_t size, const LogicalType& childType);
    void copyFromRowLayoutList(const ku_list_t& list, const LogicalType& childType);
    void copyFromColLayoutList(const list_entry_t& list, ValueVector* vec);
    void copyFromRowLayoutStruct(const uint8_t* kuStruct);
    void copyFromColLayoutStruct(const struct_entry_t& structEntry, ValueVector* vec);
    void copyFromUnion(const uint8_t* kuUnion);
 
    std::string mapToString() const;
    std::string listToString() const;
    std::string structToString() const;
    std::string nodeToString() const;
    std::string relToString() const;
    std::string decimalToString() const;
 
public:
    union Val {
        constexpr Val() : booleanVal{false} {}
        bool booleanVal;
        int128_t int128Val;
        int64_t int64Val;
        int32_t int32Val;
        int16_t int16Val;
        int8_t int8Val;
        uint64_t uint64Val;
        uint32_t uint32Val;
        uint16_t uint16Val;
        uint8_t uint8Val;
        double doubleVal;
        float floatVal;
        // TODO(Ziyi): Should we remove the val suffix from all values in Val? Looks redundant.
        uint8_t* pointer;
        interval_t intervalVal;
        internalID_t internalIDVal;
        uint128_t uint128Val;
    } val;
    std::string strVal;
 
private:
    LogicalType dataType;
    bool isNull_;
 
    // Note: ALWAYS use childrenSize over children.size(). We do NOT resize children when
    // iterating with nested value. So children.size() reflects the capacity() rather the actual
    // size.
    std::vector<std::unique_ptr<Value>> children;
    uint32_t childrenSize;
};

template<>
inline bool Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::BOOL);
    return val.booleanVal;
}

template<>
inline int8_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT8);
    return val.int8Val;
}

template<>
inline int16_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT16);
    return val.int16Val;
}

template<>
inline int32_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT32);
    return val.int32Val;
}

template<>
inline int64_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT64);
    return val.int64Val;
}

template<>
inline uint64_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT64);
    return val.uint64Val;
}

template<>
inline uint32_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT32);
    return val.uint32Val;
}

template<>
inline uint16_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT16);
    return val.uint16Val;
}

template<>
inline uint8_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT8);
    return val.uint8Val;
}

template<>
inline int128_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT128);
    return val.int128Val;
}

template<>
inline float Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::FLOAT);
    return val.floatVal;
}

template<>
inline double Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::DOUBLE);
    return val.doubleVal;
}

template<>
inline date_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::DATE);
    return date_t{val.int32Val};
}

template<>
inline timestamp_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP);
    return timestamp_t{val.int64Val};
}

template<>
inline timestamp_ns_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_NS);
    return timestamp_ns_t{val.int64Val};
}

template<>
inline timestamp_ms_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_MS);
    return timestamp_ms_t{val.int64Val};
}

template<>
inline timestamp_sec_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_SEC);
    return timestamp_sec_t{val.int64Val};
}

template<>
inline timestamp_tz_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_TZ);
    return timestamp_tz_t{val.int64Val};
}

template<>
inline interval_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERVAL);
    return val.intervalVal;
}

template<>
inline internalID_t Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERNAL_ID);
    return val.internalIDVal;
}

template<>
inline uint128_t Value::getValue() const {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT128);
    return val.uint128Val;
}

template<>
inline std::string Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::STRING ||
              dataType.getLogicalTypeID() == LogicalTypeID::BLOB ||
              dataType.getLogicalTypeID() == LogicalTypeID::UUID);
    return strVal;
}

template<>
inline uint8_t* Value::getValue() const {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::POINTER);
    return val.pointer;
}

template<>
inline bool& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::BOOL);
    return val.booleanVal;
}

template<>
inline int8_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT8);
    return val.int8Val;
}

template<>
inline int16_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT16);
    return val.int16Val;
}

template<>
inline int32_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT32);
    return val.int32Val;
}

template<>
inline int64_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT64);
    return val.int64Val;
}

template<>
inline uint8_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT8);
    return val.uint8Val;
}

template<>
inline uint16_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT16);
    return val.uint16Val;
}

template<>
inline uint32_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT32);
    return val.uint32Val;
}

template<>
inline uint64_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT64);
    return val.uint64Val;
}

template<>
inline int128_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT128);
    return val.int128Val;
}

template<>
inline float& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::FLOAT);
    return val.floatVal;
}

template<>
inline double& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::DOUBLE);
    return val.doubleVal;
}

template<>
inline date_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::DATE);
    return *reinterpret_cast<date_t*>(&val.int32Val);
}

template<>
inline timestamp_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP);
    return *reinterpret_cast<timestamp_t*>(&val.int64Val);
}

template<>
inline timestamp_ms_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_MS);
    return *reinterpret_cast<timestamp_ms_t*>(&val.int64Val);
}

template<>
inline timestamp_ns_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_NS);
    return *reinterpret_cast<timestamp_ns_t*>(&val.int64Val);
}

template<>
inline timestamp_sec_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_SEC);
    return *reinterpret_cast<timestamp_sec_t*>(&val.int64Val);
}

template<>
inline timestamp_tz_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_TZ);
    return *reinterpret_cast<timestamp_tz_t*>(&val.int64Val);
}

template<>
inline interval_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERVAL);
    return val.intervalVal;
}

template<>
inline uint128_t& Value::getValueReference() {
    KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT128);
    return val.uint128Val;
}

template<>
inline nodeID_t& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERNAL_ID);
    return val.internalIDVal;
}

template<>
inline std::string& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::STRING);
    return strVal;
}

template<>
inline uint8_t*& Value::getValueReference() {
    KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::POINTER);
    return val.pointer;
}

template<>
inline Value Value::createValue(bool val) {
    return Value(val);
}
 
template<>
inline Value Value::createValue(int8_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(int16_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(int32_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(int64_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(uint8_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(uint16_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(uint32_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(uint64_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(int128_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(double val) {
    return Value(val);
}

template<>
inline Value Value::createValue(date_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(timestamp_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(interval_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(uint128_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(nodeID_t val) {
    return Value(val);
}

template<>
inline Value Value::createValue(std::string val) {
    return Value(LogicalType::STRING(), std::move(val));
}

template<>
inline Value Value::createValue(const char* value) {
    return Value(LogicalType::STRING(), std::string(value));
}

template<>
inline Value Value::createValue(uint8_t* val) {
    return Value(val);
}

template<>
inline Value Value::createValue(ku_uuid_t val) {
    return Value(val);
}
 
} // namespace common
} // namespace lbug