duckdb 0.8.2-dev1968.0 → 0.8.2-dev2044.0

package/src/duckdb/src/common/types.cpp

@@ -1108,18 +1108,6 @@ LogicalType LogicalType::Deserialize(Deserializer &source) {
 	return LogicalType(id, std::move(info));
 }
 
-void LogicalType::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("id", id_);
-	serializer.WriteOptionalProperty("type_info", type_info_.get());
-}
-
-LogicalType LogicalType::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto id = deserializer.ReadProperty<LogicalTypeId>("id");
-	auto info = deserializer.ReadOptionalProperty<shared_ptr<ExtraTypeInfo>>("type_info");
-
-	return LogicalType(id, std::move(info));
-}
-
 bool LogicalType::EqualTypeInfo(const LogicalType &rhs) const {
 	if (type_info_.get() == rhs.type_info_.get()) {
 		return true;

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -305,7 +305,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 		CheckForPerfectJoinOpt(op, perfect_join_stats);
 		plan = make_uniq<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
 		                                   op.join_type, op.left_projection_map, op.right_projection_map,
-		                                   std::move(op.delim_types), op.estimated_cardinality, perfect_join_stats);
+		                                   std::move(op.mark_types), op.estimated_cardinality, perfect_join_stats);
 
 	} else {
 		static constexpr const idx_t NESTED_LOOP_JOIN_THRESHOLD = 5;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev1968"
+#define DUCKDB_VERSION "0.8.2-dev2044"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "b1d5e20f31"
+#define DUCKDB_SOURCE_ID "762396f87b"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp

@@ -33,9 +33,8 @@ public:
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
 
 public:
+	unique_ptr<CreateInfo> GetInfo() const override;
 	string ToSQL() const override;
-	void Serialize(Serializer &serializer) const;
-	static unique_ptr<CreateIndexInfo> Deserialize(Deserializer &source, ClientContext &context);
 
 	virtual string GetSchemaName() const = 0;
 	virtual string GetTableName() const = 0;

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp

@@ -24,10 +24,7 @@ public:
 	unique_ptr<MacroFunction> function;
 
 public:
-	virtual unique_ptr<CreateMacroInfo> GetInfoForSerialization() const;
-	//! Serialize the meta information
-	virtual void Serialize(Serializer &serializer) const;
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &main_source, ClientContext &context);
+	unique_ptr<CreateInfo> GetInfo() const override;
 
 	string ToSQL() const override {
 		return function->ToSQL(schema.name, name);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp

@@ -49,17 +49,14 @@ public:
 	SchemaCatalogEntry(Catalog &catalog, string name, bool is_internal);
 
 public:
+	unique_ptr<CreateInfo> GetInfo() const override;
+
 	//! Scan the specified catalog set, invoking the callback method for every entry
 	virtual void Scan(ClientContext &context, CatalogType type,
 	                  const std::function<void(CatalogEntry &)> &callback) = 0;
 	//! Scan the specified catalog set, invoking the callback method for every committed entry
 	virtual void Scan(CatalogType type, const std::function<void(CatalogEntry &)> &callback) = 0;
 
-	//! Serialize the meta information of the SchemaCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateSchemaInfo
-	static unique_ptr<CreateSchemaInfo> Deserialize(Deserializer &source);
-
 	string ToSQL() const override;
 
 	//! Creates an index with the given name in the schema

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp

@@ -57,13 +57,8 @@ public:
 	bool cycle;
 
 public:
-	//! Serialize the meta information of the SequenceCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateSequenceInfo> Deserialize(Deserializer &source);
+	unique_ptr<CreateInfo> GetInfo() const override;
 
 	string ToSQL() const override;
-
-	CatalogEntry *AlterOwnership(ClientContext &context, AlterInfo *info);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -55,6 +55,8 @@ public:
 	DUCKDB_API TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info);
 
 public:
+	DUCKDB_API unique_ptr<CreateInfo> GetInfo() const override;
+
 	DUCKDB_API bool HasGeneratedColumns() const;
 
 	//! Returns whether or not a column with the given name exists
@@ -83,11 +85,6 @@ public:
 	//! Get statistics of a column (physical or virtual) within the table
 	virtual unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id) = 0;
 
-	//! Serialize the meta information of the TableCatalogEntry a serializer
-	void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateTableInfo> Deserialize(Deserializer &source, ClientContext &context);
-
 	//! Returns the column index of the specified column name.
 	//! If the column does not exist:
 	//! If if_column_exists is true, returns DConstants::INVALID_INDEX
@@ -113,12 +110,6 @@ public:
 	                                   ClientContext &context);
 
 protected:
-	// This is used to serialize the entry by #Serialize(Serializer& ). It is virtual to allow
-	// Custom catalog implementations to override the default implementation. We can not make
-	// The Serialize method itself virtual as the logic is tightly coupled to the static
-	// Deserialize method.
-	virtual CreateTableInfo GetTableInfoForSerialization() const;
-
 	//! A list of columns that are part of this table
 	ColumnList columns;
 	//! A list of constraints that are part of this table

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp

@@ -38,12 +38,9 @@ public:
 	vector<LogicalType> types;
 
 public:
-	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
+	unique_ptr<CreateInfo> GetInfo() const override;
 
-	//! Serialize the meta information of the ViewCatalogEntry a serializer
-	virtual void Serialize(Serializer &serializer) const;
-	//! Deserializes to a CreateTableInfo
-	static unique_ptr<CreateViewInfo> Deserialize(Deserializer &source, ClientContext &context);
+	unique_ptr<CatalogEntry> AlterEntry(ClientContext &context, AlterInfo &info) override;
 
 	unique_ptr<CatalogEntry> Copy(ClientContext &context) const override;
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -21,6 +21,10 @@ class Catalog;
 class CatalogSet;
 class ClientContext;
 class SchemaCatalogEntry;
+class FormatSerializer;
+class FormatDeserializer;
+
+struct CreateInfo;
 
 //! Abstract base class of an entry in the catalog
 class CatalogEntry {
@@ -56,6 +60,8 @@ public:
 
 	virtual unique_ptr<CatalogEntry> Copy(ClientContext &context) const;
 
+	virtual unique_ptr<CreateInfo> GetInfo() const;
+
 	//! Sets the CatalogEntry as the new root entry (i.e. the newest entry)
 	// this is called on a rollback to an AlterEntry
 	virtual void SetAsRoot();
@@ -68,6 +74,14 @@ public:
 
 	virtual void Verify(Catalog &catalog);
 
+	//! Serialize the meta information of the CatalogEntry a serializer
+	void Serialize(Serializer &serializer) const;
+	//! Deserializes to a CreateInfo
+	static unique_ptr<CreateInfo> Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<CreateInfo> FormatDeserialize(FormatDeserializer &deserializer);
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

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

@@ -17,6 +17,8 @@
 namespace duckdb {
 class Serializer;
 class Deserializer;
+class FormatSerializer;
+class FormatDeserializer;
 
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE

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

@@ -40,6 +40,8 @@ enum class AggregateOrderDependent : uint8_t;
 
 enum class AggregateType : uint8_t;
 
+enum class AlterForeignKeyType : uint8_t;
+
 enum class AlterScalarFunctionType : uint8_t;
 
 enum class AlterTableFunctionType : uint8_t;
@@ -128,6 +130,8 @@ enum class FunctionNullHandling : uint8_t;
 
 enum class FunctionSideEffects : uint8_t;
 
+enum class IndexConstraintType : uint8_t;
+
 enum class IndexType : uint8_t;
 
 enum class InsertColumnOrder : uint8_t;
@@ -140,6 +144,8 @@ enum class JoinType : uint8_t;
 
 enum class KeywordCategory : uint8_t;
 
+enum class LoadType : uint8_t;
+
 enum class LogicalOperatorType : uint8_t;
 
 enum class LogicalTypeId : uint8_t;
@@ -174,6 +180,8 @@ enum class OrderType : uint8_t;
 
 enum class OutputStream : uint8_t;
 
+enum class ParseInfoType : uint8_t;
+
 enum class ParserExtensionResultType : uint8_t;
 
 enum class ParserMode : uint8_t;
@@ -285,6 +293,9 @@ const char* EnumUtil::ToChars<AggregateOrderDependent>(AggregateOrderDependent v
 template<>
 const char* EnumUtil::ToChars<AggregateType>(AggregateType value);
 
+template<>
+const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value);
+
 template<>
 const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value);
 
@@ -417,6 +428,9 @@ const char* EnumUtil::ToChars<FunctionNullHandling>(FunctionNullHandling value);
 template<>
 const char* EnumUtil::ToChars<FunctionSideEffects>(FunctionSideEffects value);
 
+template<>
+const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value);
+
 template<>
 const char* EnumUtil::ToChars<IndexType>(IndexType value);
 
@@ -435,6 +449,9 @@ const char* EnumUtil::ToChars<JoinType>(JoinType value);
 template<>
 const char* EnumUtil::ToChars<KeywordCategory>(KeywordCategory value);
 
+template<>
+const char* EnumUtil::ToChars<LoadType>(LoadType value);
+
 template<>
 const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value);
 
@@ -486,6 +503,9 @@ const char* EnumUtil::ToChars<OrderType>(OrderType value);
 template<>
 const char* EnumUtil::ToChars<OutputStream>(OutputStream value);
 
+template<>
+const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value);
+
 template<>
 const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value);
 
@@ -646,6 +666,9 @@ AggregateOrderDependent EnumUtil::FromString<AggregateOrderDependent>(const char
 template<>
 AggregateType EnumUtil::FromString<AggregateType>(const char *value);
 
+template<>
+AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value);
+
 template<>
 AlterScalarFunctionType EnumUtil::FromString<AlterScalarFunctionType>(const char *value);
 
@@ -778,6 +801,9 @@ FunctionNullHandling EnumUtil::FromString<FunctionNullHandling>(const char *valu
 template<>
 FunctionSideEffects EnumUtil::FromString<FunctionSideEffects>(const char *value);
 
+template<>
+IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value);
+
 template<>
 IndexType EnumUtil::FromString<IndexType>(const char *value);
 
@@ -796,6 +822,9 @@ JoinType EnumUtil::FromString<JoinType>(const char *value);
 template<>
 KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value);
 
+template<>
+LoadType EnumUtil::FromString<LoadType>(const char *value);
+
 template<>
 LogicalOperatorType EnumUtil::FromString<LogicalOperatorType>(const char *value);
 
@@ -847,6 +876,9 @@ OrderType EnumUtil::FromString<OrderType>(const char *value);
 template<>
 OutputStream EnumUtil::FromString<OutputStream>(const char *value);
 
+template<>
+ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value);
+
 template<>
 ParserExtensionResultType EnumUtil::FromString<ParserExtensionResultType>(const char *value);
 

package/src/duckdb/src/include/duckdb/common/enums/index_type.hpp

@@ -23,7 +23,7 @@ enum class IndexType : uint8_t {
 //===--------------------------------------------------------------------===//
 // Index Constraint Types
 //===--------------------------------------------------------------------===//
-enum IndexConstraintType : uint8_t {
+enum class IndexConstraintType : uint8_t {
 	NONE = 0,    // index is an index don't built to any constraint
 	UNIQUE = 1,  // index is an index built to enforce a UNIQUE constraint
 	PRIMARY = 2, // index is an index built to enforce a PRIMARY KEY constraint

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

@@ -10,6 +10,8 @@
 
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -59,6 +61,16 @@ public:
 		return internal_vector.end();
 	}
 
+	void FormatSerialize(FormatSerializer &serializer) const {
+		serializer.WriteProperty("internal_vector", internal_vector);
+	}
+
+	static IndexVector<T, INDEX_TYPE> FormatDeserialize(FormatDeserializer &deserializer) {
+		IndexVector<T, INDEX_TYPE> result;
+		deserializer.ReadProperty("internal_vector", result.internal_vector);
+		return result;
+	}
+
 private:
 	vector<T> internal_vector;
 };

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

@@ -1,17 +1,41 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/binary_deserializer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
+
 #include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
+class ClientContext;
 
 class BinaryDeserializer : public FormatDeserializer {
 public:
+	template <class T>
+	unique_ptr<T> Deserialize() {
+		OnObjectBegin();
+		auto result = T::FormatDeserialize(*this);
+		OnObjectEnd();
+		return result;
+	}
+
 	template <class T>
 	static unique_ptr<T> Deserialize(data_ptr_t ptr, idx_t length) {
 		BinaryDeserializer deserializer(ptr, length);
-		deserializer.OnObjectBegin();
-		auto result = T::FormatDeserialize(deserializer);
-		deserializer.OnObjectEnd();
-		return result;
+		return deserializer.template Deserialize<T>();
+	}
+
+	template <class T>
+	static unique_ptr<T> Deserialize(ClientContext &context, bound_parameter_map_t &parameters, data_ptr_t ptr,
+	                                 idx_t length) {
+		BinaryDeserializer deserializer(ptr, length);
+		deserializer.Set<ClientContext &>(context);
+		deserializer.Set<bound_parameter_map_t &>(parameters);
+		return deserializer.template Deserialize<T>();
 	}
 
 private:

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

@@ -1,3 +1,11 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/binary_serializer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
 #include "duckdb/common/serializer/format_serializer.hpp"
@@ -5,7 +13,6 @@
 namespace duckdb {
 
 struct BinarySerializer : public FormatSerializer {
-
 private:
 	struct State {
 		// how many fields are present in the object
@@ -24,14 +31,14 @@ private:
 	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));
+		WriteDataInternal(const_data_ptr_cast(&element), sizeof(T));
 	}
-	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
+	void WriteDataInternal(const_data_ptr_t buffer, idx_t write_size) {
 		data.insert(data.end(), buffer, buffer + write_size);
 		stack.back().size += write_size;
 	}
-	void WriteData(const char *ptr, idx_t write_size) {
-		WriteData(const_data_ptr_cast(ptr), write_size);
+	void WriteDataInternal(const char *ptr, idx_t write_size) {
+		WriteDataInternal(const_data_ptr_cast(ptr), write_size);
 	}
 
 	explicit BinarySerializer() {

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

@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/serializer/deserialization_data.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/stack.hpp"
+#include "duckdb/planner/bound_parameter_map.hpp"
+
+namespace duckdb {
+class ClientContext;
+class Catalog;
+enum class ExpressionType : uint8_t;
+
+struct DeserializationData {
+	stack<reference<ClientContext>> contexts;
+	stack<idx_t> enums;
+	stack<reference<bound_parameter_map_t>> parameter_data;
+
+	template <class T>
+	void Set(T entry) = delete;
+
+	template <class T>
+	T Get() = delete;
+
+	template <class T>
+	void Unset() = delete;
+
+	template <class T>
+	inline void AssertNotEmpty(const stack<T> &e) {
+		if (e.empty()) {
+			throw InternalException("DeserializationData - unexpected empty stack");
+		}
+	}
+};
+
+template <>
+inline void DeserializationData::Set(ExpressionType type) {
+	enums.push(idx_t(type));
+}
+
+template <>
+inline ExpressionType DeserializationData::Get() {
+	AssertNotEmpty(enums);
+	return ExpressionType(enums.top());
+}
+
+template <>
+inline void DeserializationData::Unset<ExpressionType>() {
+	AssertNotEmpty(enums);
+	enums.pop();
+}
+
+template <>
+inline void DeserializationData::Set(LogicalOperatorType type) {
+	enums.push(idx_t(type));
+}
+
+template <>
+inline LogicalOperatorType DeserializationData::Get() {
+	AssertNotEmpty(enums);
+	return LogicalOperatorType(enums.top());
+}
+
+template <>
+inline void DeserializationData::Unset<LogicalOperatorType>() {
+	AssertNotEmpty(enums);
+	enums.pop();
+}
+
+template <>
+inline void DeserializationData::Set(ClientContext &context) {
+	contexts.push(context);
+}
+
+template <>
+inline ClientContext &DeserializationData::Get() {
+	AssertNotEmpty(contexts);
+	return contexts.top();
+}
+
+template <>
+inline void DeserializationData::Unset<ClientContext>() {
+	AssertNotEmpty(contexts);
+	contexts.pop();
+}
+
+template <>
+inline void DeserializationData::Set(bound_parameter_map_t &context) {
+	parameter_data.push(context);
+}
+
+template <>
+inline bound_parameter_map_t &DeserializationData::Get() {
+	AssertNotEmpty(parameter_data);
+	return parameter_data.top();
+}
+
+template <>
+inline void DeserializationData::Unset<bound_parameter_map_t>() {
+	AssertNotEmpty(parameter_data);
+	parameter_data.pop();
+}
+
+} // namespace duckdb

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

@@ -12,6 +12,7 @@
 #include "duckdb/common/serializer.hpp"
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/serializer/serialization_traits.hpp"
+#include "duckdb/common/serializer/deserialization_data.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/unordered_map.hpp"
@@ -24,6 +25,7 @@ class FormatDeserializer {
 
 protected:
 	bool deserialize_enum_from_string = false;
+	DeserializationData data;
 
 public:
 	// Read into an existing value
@@ -107,6 +109,24 @@ public:
 		ReadDataPtr(ret, count);
 	}
 
+	//! Set a serialization property
+	template <class T>
+	void Set(T entry) {
+		return data.Set<T>(entry);
+	}
+
+	//! Retrieve the last set serialization property of this type
+	template <class T>
+	T Get() {
+		return data.Get<T>();
+	}
+
+	//! Unset a serialization property
+	template <class T>
+	void Unset() {
+		return data.Unset<T>();
+	}
+
 private:
 	// Deserialize anything implementing a FormatDeserialize method
 	template <typename T = void>
@@ -152,6 +172,19 @@ private:
 		return vec;
 	}
 
+	template <typename T = void>
+	inline typename std::enable_if<is_unsafe_vector<T>::value, T>::type Read() {
+		using ELEMENT_TYPE = typename is_unsafe_vector<T>::ELEMENT_TYPE;
+		T vec;
+		auto size = OnListBegin();
+		for (idx_t i = 0; i < size; i++) {
+			vec.push_back(Read<ELEMENT_TYPE>());
+		}
+		OnListEnd();
+
+		return vec;
+	}
+
 	// Deserialize a map
 	template <typename T = void>
 	inline typename std::enable_if<is_unordered_map<T>::value, T>::type Read() {
@@ -308,12 +341,24 @@ private:
 		return ReadInterval();
 	}
 
-	// Deserialize a interval_t
+	// Deserialize a hugeint_t
 	template <typename T = void>
 	inline typename std::enable_if<std::is_same<T, hugeint_t>::value, T>::type Read() {
 		return ReadHugeInt();
 	}
 
+	// Deserialize a LogicalIndex
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, LogicalIndex>::value, T>::type Read() {
+		return LogicalIndex(ReadUnsignedInt64());
+	}
+
+	// Deserialize a PhysicalIndex
+	template <typename T = void>
+	inline typename std::enable_if<std::is_same<T, PhysicalIndex>::value, T>::type Read() {
+		return PhysicalIndex(ReadUnsignedInt64());
+	}
+
 protected:
 	virtual void SetTag(const char *tag) {
 		(void)tag;