duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -1,379 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/field_writer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/set.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
-#include <type_traits>
-
-namespace duckdb {
-class BufferedSerializer;
-
-struct IndexWriteOperation {
-	template <class SRC, class DST>
-	static DST Operation(SRC input) {
-		return input.index;
-	}
-};
-
-class FieldWriter {
-public:
-	DUCKDB_API explicit FieldWriter(Serializer &serializer);
-	DUCKDB_API ~FieldWriter();
-
-public:
-	template <class T>
-	void WriteField(const T &element) {
-		static_assert(std::is_trivially_destructible<T>(), "WriteField object must be trivially destructible");
-
-		AddField();
-		WriteData(const_data_ptr_cast(&element), sizeof(T));
-	}
-
-	//! Write a string with a length prefix
-	void WriteString(const string &val) {
-		WriteStringLen(const_data_ptr_cast(val.c_str()), val.size());
-	}
-	void WriteStringLen(const_data_ptr_t val, idx_t len) {
-		AddField();
-		Write<uint32_t>((uint32_t)len);
-		if (len > 0) {
-			WriteData(val, len);
-		}
-	}
-	void WriteBlob(const_data_ptr_t val, idx_t len) {
-		AddField();
-		if (len > 0) {
-			WriteData(val, len);
-		}
-	}
-
-	template <class T, class CONTAINER_TYPE = vector<T>>
-	void WriteList(const CONTAINER_TYPE &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (auto &element : elements) {
-			Write<T>(element);
-		}
-	}
-
-	template <class T, class SRC, class OP, class CONTAINER_TYPE = vector<SRC>>
-	void WriteGenericList(const CONTAINER_TYPE &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (auto &element : elements) {
-			Write<T>(OP::template Operation<SRC, T>(element));
-		}
-	}
-
-	template <class T>
-	void WriteIndexList(const vector<T> &elements) {
-		WriteGenericList<idx_t, T, IndexWriteOperation>(elements);
-	}
-
-	// vector<bool> yay
-	template <class T, class CONTAINER_TYPE = vector<T>>
-	void WriteListNoReference(const CONTAINER_TYPE &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (auto element : elements) {
-			Write<T>(element);
-		}
-	}
-
-	template <class T>
-	void WriteSerializable(const T &element) {
-		AddField();
-		element.Serialize(*buffer);
-	}
-
-	template <class T>
-	void WriteSerializableList(const vector<unique_ptr<T>> &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (idx_t i = 0; i < elements.size(); i++) {
-			elements[i]->Serialize(*buffer);
-		}
-	}
-
-	template <class T>
-	void WriteRegularSerializableList(const vector<T> &elements) {
-		AddField();
-		Write<uint32_t>(elements.size());
-		for (idx_t i = 0; i < elements.size(); i++) {
-			elements[i].Serialize(*buffer);
-		}
-	}
-
-	template <class T>
-	void WriteOptional(const unique_ptr<T> &element) {
-		AddField();
-		Write<bool>(element ? true : false);
-		if (element) {
-			element->Serialize(*buffer);
-		}
-	}
-
-	// Called after all fields have been written. Should always be called.
-	DUCKDB_API void Finalize();
-
-	Serializer &GetSerializer() {
-		return *buffer;
-	}
-
-	void AddField() {
-		field_count++;
-	}
-
-private:
-	template <class T>
-	void Write(const T &element) {
-		WriteData(const_data_ptr_cast(&element), sizeof(T));
-	}
-
-	DUCKDB_API void WriteData(const_data_ptr_t buffer, idx_t write_size);
-
-private:
-	Serializer &serializer;
-	unique_ptr<BufferedSerializer> buffer;
-	idx_t field_count;
-	bool finalized;
-};
-
-template <>
-DUCKDB_API void FieldWriter::Write(const string &val);
-
-class FieldDeserializer : public Deserializer {
-public:
-	explicit FieldDeserializer(Deserializer &root);
-
-public:
-	void ReadData(data_ptr_t buffer, idx_t read_size) override;
-
-	void SetRemainingData(idx_t remaining_data);
-	idx_t RemainingData();
-	Deserializer &GetRoot() {
-		return root;
-	}
-
-	ClientContext &GetContext() override {
-		return root.GetContext();
-	}
-
-private:
-	Deserializer &root;
-	idx_t remaining_data;
-};
-
-struct IndexReadOperation {
-	template <class SRC, class DST>
-	static DST Operation(SRC input) {
-		return DST(input);
-	}
-};
-
-class FieldReader {
-public:
-	DUCKDB_API explicit FieldReader(Deserializer &source);
-	DUCKDB_API ~FieldReader();
-
-public:
-	template <class T>
-	T ReadRequired() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		return source.Read<T>();
-	}
-
-	template <class T>
-	T ReadField(T default_value) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return source.Read<T>();
-	}
-
-	template <class T, class CONTAINER_TYPE = vector<T>>
-	bool ReadList(CONTAINER_TYPE &result) {
-		if (field_count >= max_field_count) {
-			// field is not there, return false and leave the result empty
-			return false;
-		}
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-		result.reserve(result_count);
-		for (idx_t i = 0; i < result_count; i++) {
-			result.push_back(source.Read<T>());
-		}
-		return true;
-	}
-
-	template <class T, class CONTAINER_TYPE = vector<T>>
-	CONTAINER_TYPE ReadRequiredList() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-		CONTAINER_TYPE result;
-		result.reserve(result_count);
-		for (idx_t i = 0; i < result_count; i++) {
-			result.push_back(source.Read<T>());
-		}
-		return result;
-	}
-
-	template <class T, class SRC, class OP>
-	vector<T> ReadRequiredGenericList() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-		vector<T> result;
-		result.reserve(result_count);
-		for (idx_t i = 0; i < result_count; i++) {
-			result.push_back(OP::template Operation<SRC, T>(source.Read<SRC>()));
-		}
-		return result;
-	}
-
-	template <class T>
-	vector<T> ReadRequiredIndexList() {
-		return ReadRequiredGenericList<T, idx_t, IndexReadOperation>();
-	}
-
-	template <class T, class CONTAINER_TYPE = set<T>>
-	CONTAINER_TYPE ReadRequiredSet() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-		CONTAINER_TYPE result;
-		for (idx_t i = 0; i < result_count; i++) {
-			result.insert(source.Read<T>());
-		}
-		return result;
-	}
-
-	template <class T, typename... ARGS>
-	unique_ptr<T> ReadOptional(unique_ptr<T> default_value, ARGS &&... args) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return source.template ReadOptional<T>(std::forward<ARGS>(args)...);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&... args) {
-		if (field_count >= max_field_count) {
-			// field is not there, read the default value
-			return default_value;
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source, std::forward<ARGS>(args)...);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>>
-	RETURN_TYPE ReadRequiredSerializable() {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read mandatory field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&... args) {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read mandatory field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		return T::Deserialize(source, std::forward<ARGS>(args)...);
-	}
-
-	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	vector<RETURN_TYPE> ReadRequiredSerializableList(ARGS &&... args) {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read mandatory field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		auto result_count = source.Read<uint32_t>();
-
-		vector<RETURN_TYPE> result;
-		for (idx_t i = 0; i < result_count; i++) {
-			result.push_back(T::Deserialize(source, std::forward<ARGS>(args)...));
-		}
-		return result;
-	}
-
-	void ReadBlob(data_ptr_t result, idx_t read_size) {
-		if (field_count >= max_field_count) {
-			// field is not there, throw an exception
-			throw SerializationException("Attempting to read a required field, but field is missing");
-		}
-		// field is there, read the actual value
-		AddField();
-		source.ReadData(result, read_size);
-	}
-
-	//! Called after all fields have been read. Should always be called.
-	DUCKDB_API void Finalize();
-
-	Deserializer &GetSource() {
-		return source;
-	}
-
-private:
-	void AddField() {
-		field_count++;
-	}
-
-private:
-	FieldDeserializer source;
-	idx_t field_count;
-	idx_t max_field_count;
-	idx_t total_size;
-	bool finalized;
-};
-
-} // namespace duckdb

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

@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_deserializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
-
-namespace duckdb {
-class ClientContext;
-
-class BufferedDeserializer : public Deserializer {
-public:
-	BufferedDeserializer(data_ptr_t ptr, idx_t data_size);
-	explicit BufferedDeserializer(BufferedSerializer &serializer);
-
-	data_ptr_t ptr;
-	data_ptr_t endptr;
-
-public:
-	void ReadData(data_ptr_t buffer, uint64_t read_size) override;
-};
-
-class BufferedContextDeserializer : public BufferedDeserializer {
-public:
-	BufferedContextDeserializer(ClientContext &context_p, data_ptr_t ptr, idx_t data_size)
-	    : BufferedDeserializer(ptr, data_size), context(context_p) {
-	}
-
-public:
-	ClientContext &context;
-
-	ClientContext &GetContext() override;
-};
-
-} // namespace duckdb

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

@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer/buffered_serializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/unique_ptr.hpp"
-
-namespace duckdb {
-
-#define SERIALIZER_DEFAULT_SIZE 1024
-
-struct BinaryData {
-	unsafe_unique_array<data_t> data;
-	idx_t size;
-};
-
-class BufferedSerializer : public Serializer {
-public:
-	//! Serializes to a buffer allocated by the serializer, will expand when
-	//! writing past the initial threshold
-	DUCKDB_API explicit BufferedSerializer(idx_t maximum_size = SERIALIZER_DEFAULT_SIZE);
-	//! Serializes to a provided (owned) data pointer
-	BufferedSerializer(unsafe_unique_array<data_t> data, idx_t size);
-	BufferedSerializer(data_ptr_t data, idx_t size);
-
-	idx_t maximum_size;
-	data_ptr_t data;
-
-	BinaryData blob;
-
-public:
-	void WriteData(const_data_ptr_t buffer, uint64_t write_size) override;
-
-	//! Retrieves the data after the writing has been completed
-	BinaryData GetData() {
-		return std::move(blob);
-	}
-
-	void Reset() {
-		blob.size = 0;
-	}
-};
-
-} // namespace duckdb

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

@@ -1,151 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/serializer.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/vector.hpp"
-#include <type_traits>
-
-namespace duckdb {
-
-//! The Serialize class is a base class that can be used to serializing objects into a binary buffer
-class Serializer {
-private:
-	uint64_t version = 0L;
-
-public:
-	virtual ~Serializer() {
-	}
-
-	//! Sets the version of the serialization that writers are expected to use
-	//! The version is mostly the most recent one, unless modifying old data or streaming to
-	//! an older version
-	void SetVersion(uint64_t v) {
-		D_ASSERT(this->version == 0); // version can only be set once
-		this->version = v;
-	}
-
-	//! Returns the version of serialization that writers are expected to use
-	uint64_t GetVersion() {
-		return version;
-	}
-
-	virtual void WriteData(const_data_ptr_t buffer, idx_t write_size) = 0;
-
-	template <class T>
-	void Write(T element) {
-		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
-
-		WriteData(const_data_ptr_cast(&element), sizeof(T));
-	}
-
-	//! Write data from a string buffer directly (without length prefix)
-	void WriteBufferData(const string &str) {
-		WriteData(const_data_ptr_cast(str.c_str()), str.size());
-	}
-	//! Write a string with a length prefix
-	void WriteString(const string &val) {
-		WriteStringLen(const_data_ptr_cast(val.c_str()), val.size());
-	}
-	void WriteStringLen(const_data_ptr_t val, idx_t len) {
-		Write<uint32_t>((uint32_t)len);
-		if (len > 0) {
-			WriteData(val, len);
-		}
-	}
-
-	template <class T>
-	void WriteList(const vector<unique_ptr<T>> &list) {
-		Write<uint32_t>((uint32_t)list.size());
-		for (auto &child : list) {
-			child->Serialize(*this);
-		}
-	}
-
-	void WriteStringVector(const vector<string> &list) {
-		Write<uint32_t>((uint32_t)list.size());
-		for (auto &child : list) {
-			WriteString(child);
-		}
-	}
-
-	template <class T>
-	void WriteOptional(const unique_ptr<T> &element) {
-		Write<bool>(element ? true : false);
-		if (element) {
-			element->Serialize(*this);
-		}
-	}
-};
-
-//! The Deserializer class assists in deserializing a binary blob back into an
-//! object
-class Deserializer {
-private:
-	uint64_t version = 0L;
-
-public:
-	virtual ~Deserializer() {
-	}
-
-	//! Sets the version of the serialization that readers are expected to use
-	//! The version is mostly the most recent one, unless reading old data or streaming from
-	//! an older version
-	void SetVersion(uint64_t v) {
-		D_ASSERT(this->version == 0); // version can only be set once
-		this->version = v;
-	}
-
-	//! Returns the version of serialization that readers are expected to use
-	uint64_t GetVersion() {
-		return version;
-	}
-
-	//! Reads [read_size] bytes into the buffer
-	virtual void ReadData(data_ptr_t buffer, idx_t read_size) = 0;
-
-	//! Gets the context for the deserializer
-	virtual ClientContext &GetContext() {
-		throw InternalException("This deserializer does not have a client-context");
-	};
-
-	template <class T>
-	T Read() {
-		T value;
-		ReadData(data_ptr_cast(&value), sizeof(T));
-		return value;
-	}
-
-	template <class T, typename... ARGS>
-	void ReadList(vector<unique_ptr<T>> &list, ARGS &&... args) {
-		auto select_count = Read<uint32_t>();
-		for (uint32_t i = 0; i < select_count; i++) {
-			auto child = T::Deserialize(*this, std::forward<ARGS>(args)...);
-			list.push_back(std::move(child));
-		}
-	}
-
-	template <class T, class RETURN_TYPE = T, typename... ARGS>
-	unique_ptr<RETURN_TYPE> ReadOptional(ARGS &&... args) {
-		auto has_entry = Read<bool>();
-		if (has_entry) {
-			return T::Deserialize(*this, std::forward<ARGS>(args)...);
-		}
-		return nullptr;
-	}
-
-	void ReadStringVector(vector<string> &list);
-};
-
-template <>
-DUCKDB_API string Deserializer::Read();
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/plan_serialization.hpp

@@ -1,44 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/plan_serialization.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/common/enums/logical_operator_type.hpp"
-#include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/planner/bound_parameter_map.hpp"
-
-namespace duckdb {
-class ClientContext;
-class LogicalOperator;
-struct BoundParameterData;
-
-struct PlanDeserializationState {
-	PlanDeserializationState(ClientContext &context);
-	~PlanDeserializationState();
-
-	ClientContext &context;
-	bound_parameter_map_t parameter_data;
-};
-
-struct LogicalDeserializationState {
-	LogicalDeserializationState(PlanDeserializationState &gstate, LogicalOperatorType type,
-	                            vector<unique_ptr<LogicalOperator>> &children);
-
-	PlanDeserializationState &gstate;
-	LogicalOperatorType type;
-	vector<unique_ptr<LogicalOperator>> &children;
-};
-
-struct ExpressionDeserializationState {
-	ExpressionDeserializationState(PlanDeserializationState &gstate, ExpressionType type);
-
-	PlanDeserializationState &gstate;
-	ExpressionType type;
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/verification/deserialized_statement_verifier_v2.hpp

@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/verification/deserialized_statement_verifier_v2.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/verification/statement_verifier.hpp"
-
-namespace duckdb {
-
-//------------------------------------------------------------------------------
-// This is a temporary statement verifier that uses the new de/serialization
-// infrastructure to verify the correctness of the de/serialization process.
-// This verifier will be removed once the new de/serialization infrastructure
-// (FormatDe/Serializer) replaces the old one.
-class DeserializedStatementVerifierV2 : public StatementVerifier {
-public:
-	explicit DeserializedStatementVerifierV2(unique_ptr<SQLStatement> statement_p);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
-};
-
-class DeserializedStatementVerifierNoDefaultV2 : public StatementVerifier {
-public:
-	explicit DeserializedStatementVerifierNoDefaultV2(unique_ptr<SQLStatement> statement_p);
-	static unique_ptr<StatementVerifier> Create(const SQLStatement &statement);
-};
-
-} // namespace duckdb