types.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "api.h"
#include "cast.h"
#include "copy_constructors.h"
#include "internal_id_t.h"
#include "interval_t.h"
 
namespace kuzu {
namespace processor {
class ParquetReader;
};
namespace common {
 
class Serializer;
class Deserializer;
struct FileInfo;
 
using sel_t = uint64_t;
using hash_t = uint64_t;
using page_idx_t = uint32_t;
using frame_idx_t = page_idx_t;
using page_offset_t = uint32_t;
constexpr page_idx_t INVALID_PAGE_IDX = UINT32_MAX;
using file_idx_t = uint32_t;
constexpr file_idx_t INVALID_FILE_IDX = UINT32_MAX;
using page_group_idx_t = uint32_t;
using frame_group_idx_t = page_group_idx_t;
using property_id_t = uint32_t;
constexpr property_id_t INVALID_PROPERTY_ID = UINT32_MAX;
using column_id_t = property_id_t;
constexpr column_id_t INVALID_COLUMN_ID = INVALID_PROPERTY_ID;
constexpr column_id_t ROW_IDX_COLUMN_ID = INVALID_COLUMN_ID - 1;
using idx_t = uint32_t;
constexpr idx_t INVALID_IDX = UINT32_MAX;
using block_idx_t = uint64_t;
constexpr block_idx_t INVALID_BLOCK_IDX = UINT64_MAX;
using struct_field_idx_t = uint8_t;
using union_field_idx_t = struct_field_idx_t;
constexpr struct_field_idx_t INVALID_STRUCT_FIELD_IDX = UINT8_MAX;
using row_idx_t = uint64_t;
constexpr row_idx_t INVALID_ROW_IDX = UINT64_MAX;
constexpr uint32_t UNDEFINED_CAST_COST = UINT32_MAX;
using node_group_idx_t = uint64_t;
constexpr node_group_idx_t INVALID_NODE_GROUP_IDX = UINT64_MAX;
using partition_idx_t = uint64_t;
constexpr partition_idx_t INVALID_PARTITION_IDX = UINT64_MAX;
using length_t = uint64_t;
using list_size_t = uint32_t;
using sequence_id_t = uint64_t;
 
using transaction_t = uint64_t;
constexpr transaction_t INVALID_TRANSACTION = UINT64_MAX;
using executor_id_t = uint64_t;
using executor_info = std::unordered_map<executor_id_t, uint64_t>;
 
// System representation for a variable-sized overflow value.
struct overflow_value_t {
 // the size of the overflow buffer can be calculated as:
 // numElements * sizeof(Element) + nullMap(4 bytes alignment)
 uint64_t numElements = 0;
 uint8_t* value = nullptr;
};
 
struct list_entry_t {
 offset_t offset;
 list_size_t size;
 
 list_entry_t() : offset{INVALID_OFFSET}, size{UINT32_MAX} {}
 list_entry_t(offset_t offset, list_size_t size) : offset{offset}, size{size} {}
};
 
struct struct_entry_t {
 int64_t pos;
};
 
struct map_entry_t {
 list_entry_t entry;
};
 
struct union_entry_t {
 struct_entry_t entry;
};
 
struct int128_t;
struct ku_string_t;
 
template<typename T>
concept IntegerTypes =
 std::is_same_v<T, int8_t> || std::is_same_v<T, int16_t> || std::is_same_v<T, int32_t> ||
 std::is_same_v<T, int64_t> || std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t> ||
 std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t> || std::is_same_v<T, int128_t>;
 
template<typename T>
concept NumericTypes = IntegerTypes<T> || std::floating_point<T>;
 
template<typename T>
concept ComparableTypes = NumericTypes<T> || std::is_same_v<T, ku_string_t> ||
 std::is_same_v<T, interval_t> || std::is_same_v<T, bool>;
 
template<typename T>
concept HashablePrimitive = ((std::integral<T> && !std::is_same_v<T, bool>) ||
 std::floating_point<T> || std::is_same_v<T, int128_t>);
template<typename T>
concept IndexHashable = ((std::integral<T> && !std::is_same_v<T, bool>) || std::floating_point<T> ||
 std::is_same_v<T, int128_t> || std::is_same_v<T, ku_string_t> ||
 std::is_same_v<T, std::string_view> || std::same_as<T, std::string>);
 
template<typename T>
concept HashableNonNestedTypes = (std::integral<T> || std::floating_point<T> ||
 std::is_same_v<T, int128_t> || std::is_same_v<T, internalID_t> ||
 std::is_same_v<T, interval_t> || std::is_same_v<T, ku_string_t>);
 
template<typename T>
concept HashableNestedTypes =
 (std::is_same_v<T, list_entry_t> || std::is_same_v<T, struct_entry_t>);
 
template<typename T>
concept HashableTypes = (HashableNestedTypes<T> || HashableNonNestedTypes<T>);
 
enum class LogicalTypeID : uint8_t {
 ANY = 0,
 NODE = 10,
 REL = 11,
 RECURSIVE_REL = 12,
 // SERIAL is a special data type that is used to represent a sequence of INT64 values that are
 // incremented by 1 starting from 0.
 SERIAL = 13,
 
 BOOL = 22,
 INT64 = 23,
 INT32 = 24,
 INT16 = 25,
 INT8 = 26,
 UINT64 = 27,
 UINT32 = 28,
 UINT16 = 29,
 UINT8 = 30,
 INT128 = 31,
 DOUBLE = 32,
 FLOAT = 33,
 DATE = 34,
 TIMESTAMP = 35,
 TIMESTAMP_SEC = 36,
 TIMESTAMP_MS = 37,
 TIMESTAMP_NS = 38,
 TIMESTAMP_TZ = 39,
 INTERVAL = 40,
 DECIMAL = 41,
 INTERNAL_ID = 42,
 
 STRING = 50,
 BLOB = 51,
 
 LIST = 52,
 ARRAY = 53,
 STRUCT = 54,
 MAP = 55,
 UNION = 56,
 RDF_VARIANT = 57,
 POINTER = 58,
 
 UUID = 59,
};
 
enum class PhysicalTypeID : uint8_t {
 // Fixed size types.
 ANY = 0,
 BOOL = 1,
 INT64 = 2,
 INT32 = 3,
 INT16 = 4,
 INT8 = 5,
 UINT64 = 6,
 UINT32 = 7,
 UINT16 = 8,
 UINT8 = 9,
 INT128 = 10,
 DOUBLE = 11,
 FLOAT = 12,
 INTERVAL = 13,
 INTERNAL_ID = 14,
 
 // Variable size types.
 STRING = 20,
 LIST = 22,
 ARRAY = 23,
 STRUCT = 24,
 POINTER = 25,
};
 
class ExtraTypeInfo;
class StructField;
class StructTypeInfo;
 
class LogicalType {
 friend struct LogicalTypeUtils;
 friend struct DecimalType;
 friend struct StructType;
 friend struct ListType;
 friend struct ArrayType;
 
 KUZU_API LogicalType(const LogicalType& other);
 
public:
 KUZU_API LogicalType() : typeID{LogicalTypeID::ANY}, extraTypeInfo{nullptr} {
 physicalType = getPhysicalType(this->typeID);
 };
 explicit KUZU_API LogicalType(LogicalTypeID typeID);
 EXPLICIT_COPY_DEFAULT_MOVE(LogicalType);
 
 KUZU_API bool operator==(const LogicalType& other) const;
 KUZU_API bool operator!=(const LogicalType& other) const;
 
 KUZU_API std::string toString() const;
 static bool tryConvertFromString(const std::string& str, LogicalType& type);
 static LogicalType fromString(const std::string& str);
 
 KUZU_API LogicalTypeID getLogicalTypeID() const { return typeID; }
 bool containsAny() const;
 
 KUZU_API PhysicalTypeID getPhysicalType() const { return physicalType; }
 KUZU_API static PhysicalTypeID getPhysicalType(LogicalTypeID logicalType,
 const std::unique_ptr<ExtraTypeInfo>& extraTypeInfo = nullptr);
 
 void setExtraTypeInfo(std::unique_ptr<ExtraTypeInfo> typeInfo) {
 extraTypeInfo = std::move(typeInfo);
 }
 
 void serialize(Serializer& serializer) const;
 
 static LogicalType deserialize(Deserializer& deserializer);
 
 KUZU_API static std::vector<LogicalType> copy(const std::vector<LogicalType>& types);
 KUZU_API static std::vector<LogicalType> copy(const std::vector<LogicalType*>& types);
 
 static LogicalType ANY() { return LogicalType(LogicalTypeID::ANY); }
 static LogicalType BOOL() { return LogicalType(LogicalTypeID::BOOL); }
 static LogicalType HASH() { return LogicalType(LogicalTypeID::UINT64); }
 static LogicalType INT64() { return LogicalType(LogicalTypeID::INT64); }
 static LogicalType INT32() { return LogicalType(LogicalTypeID::INT32); }
 static LogicalType INT16() { return LogicalType(LogicalTypeID::INT16); }
 static LogicalType INT8() { return LogicalType(LogicalTypeID::INT8); }
 static LogicalType UINT64() { return LogicalType(LogicalTypeID::UINT64); }
 static LogicalType UINT32() { return LogicalType(LogicalTypeID::UINT32); }
 static LogicalType UINT16() { return LogicalType(LogicalTypeID::UINT16); }
 static LogicalType UINT8() { return LogicalType(LogicalTypeID::UINT8); }
 static LogicalType INT128() { return LogicalType(LogicalTypeID::INT128); }
 static LogicalType DOUBLE() { return LogicalType(LogicalTypeID::DOUBLE); }
 static LogicalType FLOAT() { return LogicalType(LogicalTypeID::FLOAT); }
 static LogicalType DATE() { return LogicalType(LogicalTypeID::DATE); }
 static LogicalType TIMESTAMP_NS() { return LogicalType(LogicalTypeID::TIMESTAMP_NS); }
 static LogicalType TIMESTAMP_MS() { return LogicalType(LogicalTypeID::TIMESTAMP_MS); }
 static LogicalType TIMESTAMP_SEC() { return LogicalType(LogicalTypeID::TIMESTAMP_SEC); }
 static LogicalType TIMESTAMP_TZ() { return LogicalType(LogicalTypeID::TIMESTAMP_TZ); }
 static LogicalType TIMESTAMP() { return LogicalType(LogicalTypeID::TIMESTAMP); }
 static LogicalType INTERVAL() { return LogicalType(LogicalTypeID::INTERVAL); }
 static KUZU_API LogicalType DECIMAL(uint32_t precision, uint32_t scale);
 static LogicalType INTERNAL_ID() { return LogicalType(LogicalTypeID::INTERNAL_ID); }
 static LogicalType SERIAL() { return LogicalType(LogicalTypeID::SERIAL); }
 static LogicalType STRING() { return LogicalType(LogicalTypeID::STRING); }
 static LogicalType BLOB() { return LogicalType(LogicalTypeID::BLOB); }
 static LogicalType UUID() { return LogicalType(LogicalTypeID::UUID); }
 static LogicalType POINTER() { return LogicalType(LogicalTypeID::POINTER); }
 static KUZU_API LogicalType STRUCT(std::vector<StructField>&& fields);
 
 static KUZU_API LogicalType RECURSIVE_REL(std::unique_ptr<StructTypeInfo> typeInfo);
 
 static KUZU_API LogicalType NODE(std::unique_ptr<StructTypeInfo> typeInfo);
 
 static KUZU_API LogicalType REL(std::unique_ptr<StructTypeInfo> typeInfo);
 
 static KUZU_API LogicalType RDF_VARIANT();
 
 static KUZU_API LogicalType UNION(std::vector<StructField>&& fields);
 
 static KUZU_API LogicalType LIST(LogicalType childType);
 template<class T>
 static inline LogicalType LIST(T&& childType) {
 return LogicalType::LIST(LogicalType(std::forward<T>(childType)));
 }
 
 static KUZU_API LogicalType MAP(LogicalType keyType, LogicalType valueType);
 template<class T>
 static LogicalType MAP(T&& keyType, T&& valueType) {
 return LogicalType::MAP(LogicalType(std::forward<T>(keyType)),
 LogicalType(std::forward<T>(valueType)));
 }
 
 static KUZU_API LogicalType ARRAY(LogicalType childType, uint64_t numElements);
 template<class T>
 static LogicalType ARRAY(T&& childType, uint64_t numElements) {
 return LogicalType::ARRAY(LogicalType(std::forward<T>(childType)), numElements);
 }
 
private:
 friend struct CAPIHelper;
 friend struct JavaAPIHelper;
 friend class kuzu::processor::ParquetReader;
 explicit LogicalType(LogicalTypeID typeID, std::unique_ptr<ExtraTypeInfo> extraTypeInfo);
 
private:
 LogicalTypeID typeID;
 PhysicalTypeID physicalType;
 std::unique_ptr<ExtraTypeInfo> extraTypeInfo;
};
 
class ExtraTypeInfo {
public:
 virtual ~ExtraTypeInfo() = default;
 
 void serialize(Serializer& serializer) const { serializeInternal(serializer); }
 
 virtual bool containsAny() const = 0;
 
 virtual bool operator==(const ExtraTypeInfo& other) const = 0;
 
 virtual std::unique_ptr<ExtraTypeInfo> copy() const = 0;
 
 template<class TARGET>
 const TARGET* constPtrCast() const {
 return common::ku_dynamic_cast<const ExtraTypeInfo*, const TARGET*>(this);
 }
 
protected:
 virtual void serializeInternal(Serializer& serializer) const = 0;
};
 
class DecimalTypeInfo final : public ExtraTypeInfo {
public:
 explicit DecimalTypeInfo(uint32_t precision = 18, uint32_t scale = 3)
 : precision(precision), scale(scale) {}
 
 uint32_t getPrecision() const { return precision; }
 uint32_t getScale() const { return scale; }
 
 bool containsAny() const override { return false; }
 
 bool operator==(const ExtraTypeInfo& other) const override;
 
 std::unique_ptr<ExtraTypeInfo> copy() const override;
 
 static std::unique_ptr<ExtraTypeInfo> deserialize(Deserializer& deserializer);
 
protected:
 void serializeInternal(Serializer& serializer) const override;
 
 uint32_t precision, scale;
};
 
class ListTypeInfo : public ExtraTypeInfo {
public:
 ListTypeInfo() = default;
 explicit ListTypeInfo(LogicalType childType) : childType{std::move(childType)} {}
 
 const LogicalType& getChildType() const { return childType; }
 
 bool containsAny() const override;
 
 bool operator==(const ExtraTypeInfo& other) const override;
 
 std::unique_ptr<ExtraTypeInfo> copy() const override;
 
 static std::unique_ptr<ExtraTypeInfo> deserialize(Deserializer& deserializer);
 
protected:
 void serializeInternal(Serializer& serializer) const override;
 
protected:
 LogicalType childType;
};
 
class ArrayTypeInfo final : public ListTypeInfo {
public:
 ArrayTypeInfo() = default;
 explicit ArrayTypeInfo(LogicalType childType, uint64_t numElements)
 : ListTypeInfo{std::move(childType)}, numElements{numElements} {}
 
 uint64_t getNumElements() const { return numElements; }
 
 bool operator==(const ExtraTypeInfo& other) const override;
 
 static std::unique_ptr<ExtraTypeInfo> deserialize(Deserializer& deserializer);
 
 std::unique_ptr<ExtraTypeInfo> copy() const override;
 
private:
 void serializeInternal(Serializer& serializer) const override;
 
private:
 uint64_t numElements;
};
 
class KUZU_API StructField {
public:
 StructField() : type{LogicalType()} {}
 StructField(std::string name, LogicalType type)
 : name{std::move(name)}, type{std::move(type)} {};
 
 std::string getName() const { return name; }
 
 const LogicalType& getType() const { return type; }
 
 bool containsAny() const;
 
 bool operator==(const StructField& other) const;
 bool operator!=(const StructField& other) const { return !(*this == other); }
 
 void serialize(Serializer& serializer) const;
 
 static StructField deserialize(Deserializer& deserializer);
 
 StructField copy() const;
 
private:
 std::string name;
 LogicalType type;
};
 
class StructTypeInfo final : public ExtraTypeInfo {
public:
 StructTypeInfo() = default;
 explicit StructTypeInfo(std::vector<StructField>&& fields);
 StructTypeInfo(const std::vector<std::string>& fieldNames,
 const std::vector<LogicalType>& fieldTypes);
 
 bool hasField(const std::string& fieldName) const;
 struct_field_idx_t getStructFieldIdx(std::string fieldName) const;
 const StructField& getStructField(struct_field_idx_t idx) const;
 const StructField& getStructField(const std::string& fieldName) const;
 const std::vector<StructField>& getStructFields() const;
 
 const LogicalType& getChildType(struct_field_idx_t idx) const;
 std::vector<const LogicalType*> getChildrenTypes() const;
 // can't be a vector of refs since that can't be for-each looped through
 std::vector<std::string> getChildrenNames() const;
 
 bool containsAny() const override;
 
 bool operator==(const ExtraTypeInfo& other) const override;
 
 static std::unique_ptr<ExtraTypeInfo> deserialize(Deserializer& deserializer);
 std::unique_ptr<ExtraTypeInfo> copy() const override;
 
private:
 void serializeInternal(Serializer& serializer) const override;
 
private:
 std::vector<StructField> fields;
 std::unordered_map<std::string, struct_field_idx_t> fieldNameToIdxMap;
};
 
using logical_type_vec_t = std::vector<LogicalType>;
 
struct KUZU_API DecimalType {
 static uint32_t getPrecision(const LogicalType& type);
 static uint32_t getScale(const LogicalType& type);
 static std::string insertDecimalPoint(const std::string& value, uint32_t posFromEnd);
};
 
struct KUZU_API ListType {
 static const LogicalType& getChildType(const LogicalType& type);
};
 
struct KUZU_API ArrayType {
 static const LogicalType& getChildType(const LogicalType& type);
 static uint64_t getNumElements(const LogicalType& type);
};
 
struct KUZU_API StructType {
 static std::vector<const LogicalType*> getFieldTypes(const LogicalType& type);
 // since the field types isn't stored as a vector of LogicalTypes, we can't return vector<>&
 
 static const LogicalType& getFieldType(const LogicalType& type, struct_field_idx_t idx);
 
 static const LogicalType& getFieldType(const LogicalType& type, const std::string& key);
 
 static std::vector<std::string> getFieldNames(const LogicalType& type);
 
 static uint64_t getNumFields(const LogicalType& type);
 
 static const std::vector<StructField>& getFields(const LogicalType& type);
 
 static bool hasField(const LogicalType& type, const std::string& key);
 
 static const StructField& getField(const LogicalType& type, struct_field_idx_t idx);
 
 static const StructField& getField(const LogicalType& type, const std::string& key);
 
 static struct_field_idx_t getFieldIdx(const LogicalType& type, const std::string& key);
};
 
struct KUZU_API MapType {
 static const LogicalType& getKeyType(const LogicalType& type);
 
 static const LogicalType& getValueType(const LogicalType& type);
};
 
struct KUZU_API UnionType {
 static constexpr union_field_idx_t TAG_FIELD_IDX = 0;
 
 static constexpr auto TAG_FIELD_TYPE = LogicalTypeID::INT8;
 
 static constexpr char TAG_FIELD_NAME[] = "tag";
 
 static union_field_idx_t getInternalFieldIdx(union_field_idx_t idx);
 
 static std::string getFieldName(const LogicalType& type, union_field_idx_t idx);
 
 static const LogicalType& getFieldType(const LogicalType& type, union_field_idx_t idx);
 
 static uint64_t getNumFields(const LogicalType& type);
};
 
struct PhysicalTypeUtils {
 static std::string toString(PhysicalTypeID physicalType);
 static uint32_t getFixedTypeSize(PhysicalTypeID physicalType);
};
 
struct KUZU_API LogicalTypeUtils {
 static std::string toString(LogicalTypeID dataTypeID);
 static std::string toString(const std::vector<LogicalType>& dataTypes);
 static std::string toString(const std::vector<LogicalTypeID>& dataTypeIDs);
 static uint32_t getRowLayoutSize(const LogicalType& logicalType);
 static bool isDate(const LogicalType& dataType);
 static bool isDate(const LogicalTypeID& dataType);
 static bool isTimestamp(const LogicalType& dataType);
 static bool isTimestamp(const LogicalTypeID& dataType);
 static bool isUnsigned(const LogicalType& dataType);
 static bool isUnsigned(const LogicalTypeID& dataType);
 static bool isIntegral(const LogicalType& dataType);
 static bool isIntegral(const LogicalTypeID& dataType);
 static bool isNumerical(const LogicalType& dataType);
 static bool isNumerical(const LogicalTypeID& dataType);
 static bool isNested(const LogicalType& dataType);
 static bool isNested(LogicalTypeID logicalTypeID);
 static std::vector<LogicalTypeID> getAllValidComparableLogicalTypes();
 static std::vector<LogicalTypeID> getNumericalLogicalTypeIDs();
 static std::vector<LogicalTypeID> getIntegerTypeIDs();
 static std::vector<LogicalTypeID> getAllValidLogicTypeIDs();
 static std::vector<LogicalType> getAllValidLogicTypes();
 static bool tryGetMaxLogicalType(const LogicalType& left, const LogicalType& right,
 LogicalType& result);
 static bool tryGetMaxLogicalType(const std::vector<LogicalType>& types, LogicalType& result);
 
private:
 static bool tryGetMaxLogicalTypeID(const LogicalTypeID& left, const LogicalTypeID& right,
 LogicalTypeID& result);
};
 
enum class FileVersionType : uint8_t { ORIGINAL = 0, WAL_VERSION = 1 };
 
} // namespace common
} // namespace kuzu