duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

package/src/duckdb/src/include/duckdb/common/serializer/enum_serializer.hpp

@@ -0,0 +1,113 @@
+#pragma once
+#include <stdint.h>
+
+namespace duckdb {
+
+struct EnumSerializer {
+	// String -> Enum
+	template <class T>
+	static T StringToEnum(const char *value) = delete;
+
+	// Enum -> String
+	template <class T>
+	static const char *EnumToString(T value) = delete;
+};
+
+enum class OrderType : uint8_t;
+enum class OrderByNullType : uint8_t;
+enum class ResultModifierType : uint8_t;
+enum class ExtraTypeInfoType : uint8_t;
+enum class TableReferenceType : uint8_t;
+enum class JoinRefType : uint8_t;
+enum class JoinType : uint8_t;
+enum class AggregateHandling : uint8_t;
+enum class QueryNodeType : uint8_t;
+enum class SetOperationType : uint8_t;
+enum class WindowBoundary : uint8_t;
+enum class SubqueryType : uint8_t;
+enum class ExpressionType : uint8_t;
+enum class ExpressionClass : uint8_t;
+enum class SampleMethod : uint8_t;
+enum class LogicalTypeId : uint8_t;
+
+template <>
+OrderType EnumSerializer::StringToEnum<OrderType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<OrderType>(OrderType value);
+
+template <>
+OrderByNullType EnumSerializer::StringToEnum<OrderByNullType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<OrderByNullType>(OrderByNullType value);
+
+template <>
+ResultModifierType EnumSerializer::StringToEnum<ResultModifierType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ResultModifierType>(ResultModifierType value);
+
+template <>
+ExtraTypeInfoType EnumSerializer::StringToEnum<ExtraTypeInfoType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ExtraTypeInfoType>(ExtraTypeInfoType value);
+
+template <>
+TableReferenceType EnumSerializer::StringToEnum<TableReferenceType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<TableReferenceType>(TableReferenceType value);
+
+template <>
+JoinRefType EnumSerializer::StringToEnum<JoinRefType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<JoinRefType>(JoinRefType value);
+
+template <>
+JoinType EnumSerializer::StringToEnum<JoinType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<JoinType>(JoinType value);
+
+template <>
+AggregateHandling EnumSerializer::StringToEnum<AggregateHandling>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<AggregateHandling>(AggregateHandling value);
+
+template <>
+QueryNodeType EnumSerializer::StringToEnum<QueryNodeType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<QueryNodeType>(QueryNodeType value);
+
+template <>
+SetOperationType EnumSerializer::StringToEnum<SetOperationType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<SetOperationType>(SetOperationType value);
+
+template <>
+WindowBoundary EnumSerializer::StringToEnum<WindowBoundary>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<WindowBoundary>(WindowBoundary value);
+
+template <>
+SubqueryType EnumSerializer::StringToEnum<SubqueryType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<SubqueryType>(SubqueryType value);
+
+template <>
+ExpressionType EnumSerializer::StringToEnum<ExpressionType>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ExpressionType>(ExpressionType value);
+
+template <>
+ExpressionClass EnumSerializer::StringToEnum<ExpressionClass>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<ExpressionClass>(ExpressionClass value);
+
+template <>
+SampleMethod EnumSerializer::StringToEnum<SampleMethod>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<SampleMethod>(SampleMethod value);
+
+template <>
+LogicalTypeId EnumSerializer::StringToEnum<LogicalTypeId>(const char *value);
+template <>
+const char *EnumSerializer::EnumToString<LogicalTypeId>(LogicalTypeId value);
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp

@@ -0,0 +1,336 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/format_serializer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/serializer/serialization_traits.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+
+namespace duckdb {
+
+class FormatDeserializer {
+protected:
+	bool deserialize_enum_from_string = false;
+
+public:
+	// We fake return-type overloading using templates and enable_if
+	/*
+	template<typename T>
+	T ReadProperty(const char* tag) {
+	    SetTag(tag);
+	    return std::move<T>(Read<T>());
+	}
+	 */
+
+	// Read into an existing value
+	template <typename T>
+	inline void ReadProperty(const char *tag, T &ret) {
+		SetTag(tag);
+		ret = Read<T>();
+	}
+
+	// Read and return a value
+	template <typename T>
+	inline T ReadProperty(const char *tag) {
+		SetTag(tag);
+		return Read<T>();
+	}
+
+	// Read optional property and return a value, or forward a default value
+	template <typename T>
+	inline T ReadOptionalPropertyOrDefault(const char *tag, T &&default_value) {
+		SetTag(tag);
+		auto present = OnOptionalBegin();
+		if (present) {
+			return Read<T>();
+		} else {
+			return std::forward<T>(default_value);
+		}
+	}
+
+	// Read optional property into an existing value, or use a default value
+	template <typename T>
+	inline void ReadOptionalPropertyOrDefault(const char *tag, T &ret, T &&default_value) {
+		SetTag(tag);
+		auto present = OnOptionalBegin();
+		if (present) {
+			ret = Read<T>();
+		} else {
+			ret = std::forward<T>(default_value);
+		}
+	}
+
+	// Read optional property and return a value, or default construct it
+	template <typename T>
+	inline typename std::enable_if<std::is_default_constructible<T>::value, T>::type
+	ReadOptionalProperty(const char *tag) {
+		SetTag(tag);
+		auto present = OnOptionalBegin();
+		if (present) {
+			return Read<T>();
+		} else {
+			return T();
+		}
+	}
+
+	// Read optional property into an existing value, or default construct it
+	template <typename T>
+	inline typename std::enable_if<std::is_default_constructible<T>::value, void>::type
+	ReadOptionalProperty(const char *tag, T &ret) {
+		SetTag(tag);
+		auto present = OnOptionalBegin();
+		if (present) {
+			ret = Read<T>();
+		} else {
+			ret = T();
+		}
+	}
+
+private:
+	// Deserialize anything implementing a FormatDeserialize method
+	template <typename T = void>
+	inline typename std::enable_if<has_deserialize<T>::value, T>::type Read() {
+		return T::FormatDeserialize(*this);
+	}
+
+	// Structural Types
+	// Deserialize a unique_ptr
+	template <class T = void>
+	inline typename std::enable_if<is_unique_ptr<T>::value, T>::type Read() {
+		using ELEMENT_TYPE = typename is_unique_ptr<T>::ELEMENT_TYPE;
+		return std::move(ELEMENT_TYPE::FormatDeserialize(*this));
+	}
+
+	// Deserialize shared_ptr
+	template <typename T = void>
+	inline typename std::enable_if<is_shared_ptr<T>::value, T>::type Read() {
+		using ELEMENT_TYPE = typename is_shared_ptr<T>::ELEMENT_TYPE;
+		return std::move(ELEMENT_TYPE::FormatDeserialize(*this));
+	}
+
+	// Deserialize a vector
+	template <typename T = void>
+	inline typename std::enable_if<is_vector<T>::value, T>::type Read() {
+		using ELEMENT_TYPE = typename is_vector<T>::ELEMENT_TYPE;
+		T vec;
+		auto size = ReadUnsignedInt32();
+		for (idx_t i = 0; i < size; i++) {
+			vec.push_back(Read<ELEMENT_TYPE>());
+		}
+
+		return vec;
+	}
+
+	// Deserialize a map
+	template <typename T = void>
+	inline typename std::enable_if<is_unordered_map<T>::value, T>::type Read() {
+		using KEY_TYPE = typename is_unordered_map<T>::KEY_TYPE;
+		using VALUE_TYPE = typename is_unordered_map<T>::VALUE_TYPE;
+		auto size = ReadUnsignedInt32();
+		T map;
+		for (idx_t i = 0; i < size; i++) {
+			map[Read<KEY_TYPE>()] = Read<VALUE_TYPE>();
+		}
+
+		return map;
+	}
+
+	// Deserialize an unordered set
+	template <typename T = void>
+	inline typename std::enable_if<is_unordered_set<T>::value, T>::type Read() {
+		using ELEMENT_TYPE = typename is_unordered_set<T>::ELEMENT_TYPE;
+		auto size = ReadUnsignedInt32();
+		T set;
+		for (idx_t i = 0; i < size; i++) {
+			set.insert(Read<ELEMENT_TYPE>());
+		}
+
+		return set;
+	}
+
+	// Deserialize a set
+	template <typename T = void>
+	inline typename std::enable_if<is_set<T>::value, T>::type Read() {
+		using ELEMENT_TYPE = typename is_set<T>::ELEMENT_TYPE;
+		auto size = ReadUnsignedInt32();
+		T set;
+		for (idx_t i = 0; i < size; i++) {
+			set.insert(Read<ELEMENT_TYPE>());
+		}
+
+		return set;
+	}
+
+	// Deserialize a pair
+	template <typename T = void>
+	inline typename std::enable_if<is_pair<T>::value, T>::type Read() {
+		using FIRST_TYPE = typename is_pair<T>::FIRST_TYPE;
+		using SECOND_TYPE = typename is_pair<T>::SECOND_TYPE;
+
+		OnPairBegin();
+		OnPairKeyBegin();
+		FIRST_TYPE first = Read<FIRST_TYPE>();
+		OnPairKeyEnd();
+		OnPairValueBegin();
+		SECOND_TYPE second = Read<SECOND_TYPE>();
+		OnPairValueEnd();
+		OnPairEnd();
+		return std::make_pair(first, second);
+	}
+
+	// Primitive types
+	// Deserialize a bool
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, bool>::value, T>::type Read() {
+		return ReadBool();
+	}
+
+	// Deserialize a int8_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, int8_t>::value, T>::type Read() {
+		return ReadSignedInt8();
+	}
+
+	// Deserialize a uint8_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, uint8_t>::value, T>::type Read() {
+		return ReadUnsignedInt8();
+	}
+
+	// Deserialize a int16_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, int16_t>::value, T>::type Read() {
+		return ReadSignedInt16();
+	}
+
+	// Deserialize a uint16_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, uint16_t>::value, T>::type Read() {
+		return ReadUnsignedInt16();
+	}
+
+	// Deserialize a int32_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, int32_t>::value, T>::type Read() {
+		return ReadSignedInt32();
+	}
+
+	// Deserialize a uint32_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, uint32_t>::value, T>::type Read() {
+		return ReadUnsignedInt32();
+	}
+
+	// Deserialize a int64_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, int64_t>::value, T>::type Read() {
+		return ReadSignedInt64();
+	}
+
+	// Deserialize a uint64_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, uint64_t>::value, T>::type Read() {
+		return ReadUnsignedInt64();
+	}
+
+	// Deserialize a float
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, float>::value, T>::type Read() {
+		return ReadFloat();
+	}
+
+	// Deserialize a double
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, double>::value, T>::type Read() {
+		return ReadDouble();
+	}
+
+	// Deserialize a string
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, string>::value, T>::type Read() {
+		return ReadString();
+	}
+
+	// Deserialize a Enum
+	template <typename T = void>
+	inline typename std::enable_if<std::is_enum<T>::value, T>::type Read() {
+		auto str = ReadString();
+		return EnumSerializer::StringToEnum<T>(str.c_str());
+	}
+
+	// Deserialize a interval_t
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, interval_t>::value, T>::type Read() {
+		return ReadInterval();
+	}
+
+protected:
+	virtual void SetTag(const char *tag) {
+		(void)tag;
+	}
+
+	virtual idx_t OnListBegin() = 0;
+	virtual void OnListEnd() {
+	}
+	virtual idx_t OnMapBegin() = 0;
+	virtual void OnMapEnd() {
+	}
+	virtual void OnMapEntryBegin() {
+	}
+	virtual void OnMapEntryEnd() {
+	}
+	virtual void OnMapKeyBegin() {
+	}
+	virtual void OnMapKeyEnd() {
+	}
+	virtual void OnMapValueBegin() {
+	}
+	virtual void OnMapValueEnd() {
+	}
+	virtual bool OnOptionalBegin() = 0;
+	virtual void OnOptionalEnd() {
+	}
+	virtual void OnObjectBegin() {
+	}
+	virtual void OnObjectEnd() {
+	}
+	virtual void OnPairBegin() {
+	}
+	virtual void OnPairKeyBegin() {
+	}
+	virtual void OnPairKeyEnd() {
+	}
+	virtual void OnPairValueBegin() {
+	}
+	virtual void OnPairValueEnd() {
+	}
+	virtual void OnPairEnd() {
+	}
+
+	virtual bool ReadBool() = 0;
+	virtual int8_t ReadSignedInt8() = 0;
+	virtual uint8_t ReadUnsignedInt8() = 0;
+	virtual int16_t ReadSignedInt16() = 0;
+	virtual uint16_t ReadUnsignedInt16() = 0;
+	virtual int32_t ReadSignedInt32() = 0;
+	virtual uint32_t ReadUnsignedInt32() = 0;
+	virtual int64_t ReadSignedInt64() = 0;
+	virtual uint64_t ReadUnsignedInt64() = 0;
+	virtual float ReadFloat() = 0;
+	virtual double ReadDouble() = 0;
+	virtual string ReadString() = 0;
+	virtual interval_t ReadInterval() = 0;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -0,0 +1,268 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/format_serializer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/enum_serializer.hpp"
+#include "duckdb/common/serializer/serialization_traits.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/unordered_set.hpp"
+
+namespace duckdb {
+
+class FormatSerializer {
+protected:
+	bool serialize_enum_as_string = false;
+
+public:
+	// Serialize a value
+	template <class T>
+	typename std::enable_if<!std::is_enum<T>::value, void>::type WriteProperty(const char *tag, T &value) {
+		SetTag(tag);
+		WriteValue(value);
+	}
+
+	// Serialize a range
+	template <class T>
+	typename std::enable_if<std::is_pointer<T>::value, void>::type WriteProperty(const char *tag, const T start,
+	                                                                             idx_t count) {
+		SetTag(tag);
+		WriteValue(start, count);
+	}
+
+	// Serialize an enum
+	template <class T>
+	typename std::enable_if<std::is_enum<T>::value, void>::type WriteProperty(const char *tag, T value) {
+		SetTag(tag);
+		if (serialize_enum_as_string) {
+			// Use the enum serializer to lookup tostring function
+			auto str = EnumSerializer::EnumToString(value);
+			WriteValue(str);
+		} else {
+			// Use the underlying type
+			WriteValue(static_cast<typename std::underlying_type<T>::type>(value));
+		}
+	}
+
+	// Optional pointer
+	template <class T>
+	void WriteOptionalProperty(const char *tag, T *ptr) {
+		SetTag(tag);
+		if (ptr == nullptr) {
+			OnOptionalBegin(false);
+			OnOptionalEnd(false);
+		} else {
+			OnOptionalBegin(true);
+			WriteValue(*ptr);
+			OnOptionalEnd(true);
+		}
+	}
+
+	// Optional unique_ptr
+	template <class T>
+	void WriteOptionalProperty(const char *tag, const unique_ptr<T> &ptr) {
+		SetTag(tag);
+		if (ptr == nullptr) {
+			OnOptionalBegin(false);
+			OnOptionalEnd(false);
+		} else {
+			OnOptionalBegin(true);
+			WriteValue(*ptr);
+			OnOptionalEnd(true);
+		}
+	}
+
+protected:
+	// Unique Pointer Ref
+	template <typename T>
+	void WriteValue(const unique_ptr<T> &ptr) {
+		WriteValue(ptr.get());
+	}
+
+	// Pointer
+	template <typename T>
+	typename std::enable_if<std::is_pointer<T>::value, void>::type WriteValue(const T ptr) {
+		if (ptr == nullptr) {
+			WriteNull();
+		} else {
+			WriteValue(*ptr);
+		}
+	}
+
+	// data_ptr_t
+	void WriteValue(data_ptr_t ptr, idx_t count) {
+		OnListBegin(count);
+		auto end = ptr + count;
+		while (ptr != end) {
+			WriteValue(*ptr);
+			ptr++;
+		}
+		OnListEnd(count);
+	}
+
+	void WriteValue(const_data_ptr_t ptr, idx_t count) {
+		OnListBegin(count);
+		auto end = ptr + count;
+		while (ptr != end) {
+			WriteValue(*ptr);
+			ptr++;
+		}
+		OnListEnd(count);
+	}
+
+	// Pair
+	template <class K, class V>
+	void WriteValue(const std::pair<K, V> &pair) {
+		OnPairBegin();
+		OnPairKeyBegin();
+		WriteValue(pair.first);
+		OnPairKeyEnd();
+		OnPairValueBegin();
+		WriteValue(pair.second);
+		OnPairValueEnd();
+		OnPairEnd();
+	}
+
+	// Vector
+	template <class T>
+	void WriteValue(const vector<T> &vec) {
+		auto count = vec.size();
+		OnListBegin(count);
+		for (auto &item : vec) {
+			WriteValue(item);
+		}
+		OnListEnd(count);
+	}
+
+	// UnorderedSet
+	// Serialized the same way as a list/vector
+	template <class T, class HASH, class CMP>
+	void WriteValue(const unordered_set<T, HASH, CMP> &set) {
+		auto count = set.size();
+		OnListBegin(count);
+		for (auto &item : set) {
+			WriteValue(item);
+		}
+		OnListEnd(count);
+	}
+
+	// Set
+	// Serialized the same way as a list/vector
+	template <class T, class HASH, class CMP>
+	void WriteValue(const set<T, HASH, CMP> &set) {
+		auto count = set.size();
+		OnListBegin(count);
+		for (auto &item : set) {
+			WriteValue(item);
+		}
+		OnListEnd(count);
+	}
+
+	// Map
+	template <class K, class V, class HASH, class CMP>
+	void WriteValue(const std::unordered_map<K, V, HASH, CMP> &map) {
+		auto count = map.size();
+		OnMapBegin(count);
+		for (auto &item : map) {
+			OnMapEntryBegin();
+			OnMapKeyBegin();
+			WriteValue(item.first);
+			OnMapKeyEnd();
+			OnMapValueBegin();
+			WriteValue(item.second);
+			OnMapValueEnd();
+			OnMapEntryEnd();
+		}
+		OnMapEnd(count);
+	}
+
+	// class or struct implementing `FormatSerialize(FormatSerializer& FormatSerializer)`;
+	template <typename T>
+	typename std::enable_if<has_serialize_v<T>(), void>::type WriteValue(T &value) {
+		// Else, we defer to the .FormatSerialize method
+		OnObjectBegin();
+		value.FormatSerialize(*this);
+		OnObjectEnd();
+	}
+
+	// Handle setting a "tag" (optional)
+	virtual void SetTag(const char *tag) {
+		(void)tag;
+	}
+
+	// Hooks for subclasses to override to implement custom behavior
+	virtual void OnListBegin(idx_t count) {
+		(void)count;
+	}
+	virtual void OnListEnd(idx_t count) {
+		(void)count;
+	}
+	virtual void OnMapBegin(idx_t count) {
+		(void)count;
+	}
+	virtual void OnMapEnd(idx_t count) {
+		(void)count;
+	}
+	virtual void OnMapEntryBegin() {
+	}
+	virtual void OnMapEntryEnd() {
+	}
+	virtual void OnMapKeyBegin() {
+	}
+	virtual void OnMapKeyEnd() {
+	}
+	virtual void OnMapValueBegin() {
+	}
+	virtual void OnMapValueEnd() {
+	}
+	virtual void OnOptionalBegin(bool present) {
+	}
+	virtual void OnOptionalEnd(bool present) {
+	}
+	virtual void OnObjectBegin() {
+	}
+	virtual void OnObjectEnd() {
+	}
+	virtual void OnPairBegin() {
+	}
+	virtual void OnPairKeyBegin() {
+	}
+	virtual void OnPairKeyEnd() {
+	}
+	virtual void OnPairValueBegin() {
+	}
+	virtual void OnPairValueEnd() {
+	}
+	virtual void OnPairEnd() {
+	}
+
+	// Handle primitive types, a serializer needs to implement these.
+	virtual void WriteNull() = 0;
+	virtual void WriteValue(uint8_t value) = 0;
+	virtual void WriteValue(int8_t value) = 0;
+	virtual void WriteValue(uint16_t value) = 0;
+	virtual void WriteValue(int16_t value) = 0;
+	virtual void WriteValue(uint32_t value) = 0;
+	virtual void WriteValue(int32_t value) = 0;
+	virtual void WriteValue(uint64_t value) = 0;
+	virtual void WriteValue(int64_t value) = 0;
+	virtual void WriteValue(hugeint_t value) = 0;
+	virtual void WriteValue(float value) = 0;
+	virtual void WriteValue(double value) = 0;
+	virtual void WriteValue(interval_t value) = 0;
+	virtual void WriteValue(const string &value) = 0;
+	virtual void WriteValue(const string_t value) = 0;
+	virtual void WriteValue(const char *value) = 0;
+	virtual void WriteValue(bool value) = 0;
+};
+
+} // namespace duckdb