value.h

Go to the documentation of this file.

#pragma once
 
#include <utility>
 
#include "api.h"
#include "date_t.h"
#include "int128_t.h"
#include "internal_id_t.h"
#include "interval_t.h"
#include "ku_list.h"
#include "timestamp_t.h"
#include "uuid.h"
 
namespace kuzu {
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:
 KUZU_API static Value createNullValue();
 KUZU_API static Value createNullValue(const LogicalType& dataType);
 KUZU_API static Value createDefaultValue(const LogicalType& dataType);
 KUZU_API explicit Value(bool val_);
 KUZU_API explicit Value(int8_t val_);
 KUZU_API explicit Value(int16_t val_);
 KUZU_API explicit Value(int32_t val_);
 KUZU_API explicit Value(int64_t val_);
 KUZU_API explicit Value(uint8_t val_);
 KUZU_API explicit Value(uint16_t val_);
 KUZU_API explicit Value(uint32_t val_);
 KUZU_API explicit Value(uint64_t val_);
 KUZU_API explicit Value(int128_t val_);
 KUZU_API explicit Value(ku_uuid_t val_);
 KUZU_API explicit Value(double val_);
 KUZU_API explicit Value(float val_);
 KUZU_API explicit Value(date_t val_);
 KUZU_API explicit Value(timestamp_ns_t val_);
 KUZU_API explicit Value(timestamp_ms_t val_);
 KUZU_API explicit Value(timestamp_sec_t val_);
 KUZU_API explicit Value(timestamp_tz_t val_);
 KUZU_API explicit Value(timestamp_t val_);
 KUZU_API explicit Value(interval_t val_);
 KUZU_API explicit Value(internalID_t val_);
 KUZU_API explicit Value(const char* val_);
 KUZU_API explicit Value(const std::string& val_);
 KUZU_API explicit Value(uint8_t* val_);
 KUZU_API explicit Value(LogicalType type, std::string val_);
 KUZU_API explicit Value(LogicalType dataType, std::vector<std::unique_ptr<Value>> children);
 KUZU_API Value(const Value& other);
 
 KUZU_API Value(Value&& other) = default;
 KUZU_API Value& operator=(Value&& other) = default;
 KUZU_API bool operator==(const Value& rhs) const;
 
 KUZU_API void setDataType(const LogicalType& dataType_);
 KUZU_API const LogicalType& getDataType() const;
 KUZU_API void setNull(bool flag);
 KUZU_API void setNull();
 KUZU_API bool isNull() const;
 KUZU_API void copyFromRowLayout(const uint8_t* value);
 KUZU_API void copyFromColLayout(const uint8_t* value, ValueVector* vec = nullptr);
 KUZU_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()");
 }
 
 KUZU_API std::unique_ptr<Value> copy() const;
 KUZU_API std::string toString() const;
 
 KUZU_API void serialize(Serializer& serializer) const;
 
 KUZU_API static std::unique_ptr<Value> deserialize(Deserializer& deserializer);
 
 void validateType(common::LogicalTypeID targetTypeID) const;
 
 bool hasNoneNullChildren() const;
 bool allowTypeChange() const;
 
 uint64_t computeHash() const;
 
 KUZU_API 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 rdfVariantToString() const;
 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;
 } 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<>
KUZU_API inline bool Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::BOOL);
 return val.booleanVal;
}
 
template<>
KUZU_API inline int8_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT8);
 return val.int8Val;
}
 
template<>
KUZU_API inline int16_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT16);
 return val.int16Val;
}
 
template<>
KUZU_API inline int32_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT32);
 return val.int32Val;
}
 
template<>
KUZU_API inline int64_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT64);
 return val.int64Val;
}
 
template<>
KUZU_API inline uint64_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT64);
 return val.uint64Val;
}
 
template<>
KUZU_API inline uint32_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT32);
 return val.uint32Val;
}
 
template<>
KUZU_API inline uint16_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT16);
 return val.uint16Val;
}
 
template<>
KUZU_API inline uint8_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT8);
 return val.uint8Val;
}
 
template<>
KUZU_API inline int128_t Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT128);
 return val.int128Val;
}
 
template<>
KUZU_API inline float Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::FLOAT);
 return val.floatVal;
}
 
template<>
KUZU_API inline double Value::getValue() const {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::DOUBLE);
 return val.doubleVal;
}
 
template<>
KUZU_API inline date_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::DATE);
 return date_t{val.int32Val};
}
 
template<>
KUZU_API inline timestamp_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP);
 return timestamp_t{val.int64Val};
}
 
template<>
KUZU_API inline timestamp_ns_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_NS);
 return timestamp_ns_t{val.int64Val};
}
 
template<>
KUZU_API inline timestamp_ms_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_MS);
 return timestamp_ms_t{val.int64Val};
}
 
template<>
KUZU_API inline timestamp_sec_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_SEC);
 return timestamp_sec_t{val.int64Val};
}
 
template<>
KUZU_API inline timestamp_tz_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_TZ);
 return timestamp_tz_t{val.int64Val};
}
 
template<>
KUZU_API inline interval_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERVAL);
 return val.intervalVal;
}
 
template<>
KUZU_API inline internalID_t Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERNAL_ID);
 return val.internalIDVal;
}
 
template<>
KUZU_API inline std::string Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::STRING ||
 dataType.getLogicalTypeID() == LogicalTypeID::BLOB ||
 dataType.getLogicalTypeID() == LogicalTypeID::UUID);
 return strVal;
}
 
template<>
KUZU_API inline uint8_t* Value::getValue() const {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::POINTER);
 return val.pointer;
}
 
template<>
KUZU_API inline bool& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::BOOL);
 return val.booleanVal;
}
 
template<>
KUZU_API inline int8_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT8);
 return val.int8Val;
}
 
template<>
KUZU_API inline int16_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT16);
 return val.int16Val;
}
 
template<>
KUZU_API inline int32_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT32);
 return val.int32Val;
}
 
template<>
KUZU_API inline int64_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT64);
 return val.int64Val;
}
 
template<>
KUZU_API inline uint8_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT8);
 return val.uint8Val;
}
 
template<>
KUZU_API inline uint16_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT16);
 return val.uint16Val;
}
 
template<>
KUZU_API inline uint32_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT32);
 return val.uint32Val;
}
 
template<>
KUZU_API inline uint64_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::UINT64);
 return val.uint64Val;
}
 
template<>
KUZU_API inline int128_t& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::INT128);
 return val.int128Val;
}
 
template<>
KUZU_API inline float& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::FLOAT);
 return val.floatVal;
}
 
template<>
KUZU_API inline double& Value::getValueReference() {
 KU_ASSERT(dataType.getPhysicalType() == PhysicalTypeID::DOUBLE);
 return val.doubleVal;
}
 
template<>
KUZU_API inline date_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::DATE);
 return *reinterpret_cast<date_t*>(&val.int32Val);
}
 
template<>
KUZU_API inline timestamp_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP);
 return *reinterpret_cast<timestamp_t*>(&val.int64Val);
}
 
template<>
KUZU_API inline timestamp_ms_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_MS);
 return *reinterpret_cast<timestamp_ms_t*>(&val.int64Val);
}
 
template<>
KUZU_API inline timestamp_ns_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_NS);
 return *reinterpret_cast<timestamp_ns_t*>(&val.int64Val);
}
 
template<>
KUZU_API inline timestamp_sec_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_SEC);
 return *reinterpret_cast<timestamp_sec_t*>(&val.int64Val);
}
 
template<>
KUZU_API inline timestamp_tz_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::TIMESTAMP_TZ);
 return *reinterpret_cast<timestamp_tz_t*>(&val.int64Val);
}
 
template<>
KUZU_API inline interval_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERVAL);
 return val.intervalVal;
}
 
template<>
KUZU_API inline nodeID_t& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::INTERNAL_ID);
 return val.internalIDVal;
}
 
template<>
KUZU_API inline std::string& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::STRING);
 return strVal;
}
 
template<>
KUZU_API inline uint8_t*& Value::getValueReference() {
 KU_ASSERT(dataType.getLogicalTypeID() == LogicalTypeID::POINTER);
 return val.pointer;
}
 
template<>
KUZU_API inline Value Value::createValue(bool val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(int8_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(int16_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(int32_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(int64_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(uint8_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(uint16_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(uint32_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(uint64_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(int128_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(double val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(date_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(timestamp_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(interval_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(nodeID_t val) {
 return Value(val);
}
 
template<>
KUZU_API inline Value Value::createValue(std::string val) {
 return Value(LogicalType::STRING(), std::move(val));
}
 
template<>
KUZU_API inline Value Value::createValue(const char* value) {
 return Value(LogicalType::STRING(), std::string(value));
}
 
template<>
KUZU_API inline Value Value::createValue(uint8_t* val) {
 return Value(val);
}
 
} // namespace common
} // namespace kuzu