duckdb 0.8.2-dev1862.0 → 0.8.2-dev2044.0

package/binding.gyp

@@ -241,18 +241,18 @@
                 "src/duckdb/third_party/zstd/compress/zstd_lazy.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_ldm.cpp", 
                 "src/duckdb/third_party/zstd/compress/zstd_opt.cpp", 
-                "src/duckdb/extension/icu/./icu-list-range.cpp", 
-                "src/duckdb/extension/icu/./icu-table-range.cpp", 
-                "src/duckdb/extension/icu/./icu-datesub.cpp", 
-                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
-                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
-                "src/duckdb/extension/icu/./icu-makedate.cpp", 
-                "src/duckdb/extension/icu/./icu-timezone.cpp", 
-                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
-                "src/duckdb/extension/icu/./icu-datepart.cpp", 
                 "src/duckdb/extension/icu/./icu_extension.cpp", 
                 "src/duckdb/extension/icu/./icu-datetrunc.cpp", 
+                "src/duckdb/extension/icu/./icu-datepart.cpp", 
                 "src/duckdb/extension/icu/./icu-strptime.cpp", 
+                "src/duckdb/extension/icu/./icu-table-range.cpp", 
+                "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-datefunc.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
+                "src/duckdb/extension/icu/./icu-timebucket.cpp", 
+                "src/duckdb/extension/icu/./icu-dateadd.cpp", 
+                "src/duckdb/extension/icu/./icu-timezone.cpp", 
+                "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_common.cpp", 
                 "src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp", 
                 "src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1862.0",
+  "version": "0.8.2-dev2044.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/catalog/catalog.cpp

@@ -278,7 +278,7 @@ optional_ptr<CatalogEntry> Catalog::CreateIndex(CatalogTransaction transaction,
 
 optional_ptr<CatalogEntry> Catalog::CreateIndex(ClientContext &context, CreateIndexInfo &info) {
 	auto &schema = GetSchema(context, info.schema);
-	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table->table_name);
+	auto &table = GetEntry<TableCatalogEntry>(context, schema.name, info.table);
 	return schema.CreateIndex(context, info, table);
 }
 

package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp

@@ -19,47 +19,23 @@ string IndexCatalogEntry::ToSQL() const {
 	return sql;
 }
 
-void IndexCatalogEntry::Serialize(Serializer &serializer) const {
-	// here we serialize the index metadata in the following order:
-	// schema name, table name, index name, sql, index type, index constraint type, expression list, parsed expressions,
-	// column IDs
-
-	FieldWriter writer(serializer);
-	writer.WriteString(GetSchemaName());
-	writer.WriteString(GetTableName());
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteField(index->type);
-	writer.WriteField(index->constraint_type);
-	writer.WriteSerializableList(expressions);
-	writer.WriteSerializableList(parsed_expressions);
-	writer.WriteList<idx_t>(index->column_ids);
-	writer.Finalize();
-}
-
-unique_ptr<CreateIndexInfo> IndexCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	// here we deserialize the index metadata in the following order:
-	// schema name, table schema name, table name, index name, sql, index type, index constraint type, expression list,
-	// parsed expression list, column IDs
-
-	auto create_index_info = make_uniq<CreateIndexInfo>();
-
-	FieldReader reader(source);
-
-	create_index_info->schema = reader.ReadRequired<string>();
-	create_index_info->table = make_uniq<BaseTableRef>();
-	create_index_info->table->schema_name = create_index_info->schema;
-	create_index_info->table->table_name = reader.ReadRequired<string>();
-	create_index_info->index_name = reader.ReadRequired<string>();
-	create_index_info->sql = reader.ReadRequired<string>();
-	create_index_info->index_type = IndexType(reader.ReadRequired<uint8_t>());
-	create_index_info->constraint_type = IndexConstraintType(reader.ReadRequired<uint8_t>());
-	create_index_info->expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-	create_index_info->parsed_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	create_index_info->column_ids = reader.ReadRequiredList<idx_t>();
-	reader.Finalize();
-	return create_index_info;
+unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateIndexInfo>();
+	result->schema = GetSchemaName();
+	result->table = GetTableName();
+	result->index_name = name;
+	result->sql = sql;
+	result->index_type = index->type;
+	result->constraint_type = index->constraint_type;
+	for (auto &expr : expressions) {
+		result->expressions.push_back(expr->Copy());
+	}
+	for (auto &expr : parsed_expressions) {
+		result->parsed_expressions.push_back(expr->Copy());
+	}
+	result->column_ids = index->column_ids;
+	result->temporary = temporary;
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp

@@ -22,21 +22,13 @@ TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEn
     : MacroCatalogEntry(catalog, schema, info) {
 }
 
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::GetInfoForSerialization() const {
+unique_ptr<CreateInfo> MacroCatalogEntry::GetInfo() const {
 	auto info = make_uniq<CreateMacroInfo>(type);
 	info->catalog = catalog.GetName();
 	info->schema = schema.name;
 	info->name = name;
 	info->function = function->Copy();
-	return info;
-}
-void MacroCatalogEntry::Serialize(Serializer &serializer) const {
-	auto info = GetInfoForSerialization();
-	info->Serialize(serializer);
-}
-
-unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
-	return unique_ptr_cast<CreateInfo, CreateMacroInfo>(CreateInfo::Deserialize(main_source));
+	return std::move(info);
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/schema_catalog_entry.cpp

@@ -33,20 +33,10 @@ SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction trans
 	return result;
 }
 
-void SchemaCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSchemaInfo> SchemaCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSchemaInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SchemaCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSchemaInfo>();
+	result->schema = name;
+	return std::move(result);
 }
 
 string SchemaCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp

@@ -18,34 +18,17 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry
 	this->temporary = info.temporary;
 }
 
-void SequenceCatalogEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteField<uint64_t>(usage_count);
-	writer.WriteField<int64_t>(increment);
-	writer.WriteField<int64_t>(min_value);
-	writer.WriteField<int64_t>(max_value);
-	writer.WriteField<int64_t>(counter);
-	writer.WriteField<bool>(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> SequenceCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateSequenceInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->usage_count = reader.ReadRequired<uint64_t>();
-	info->increment = reader.ReadRequired<int64_t>();
-	info->min_value = reader.ReadRequired<int64_t>();
-	info->max_value = reader.ReadRequired<int64_t>();
-	info->start_value = reader.ReadRequired<int64_t>();
-	info->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateSequenceInfo>();
+	result->schema = schema.name;
+	result->name = name;
+	result->usage_count = usage_count;
+	result->increment = increment;
+	result->min_value = min_value;
+	result->max_value = max_value;
+	result->start_value = counter;
+	result->cycle = cycle;
+	return std::move(result);
 }
 
 string SequenceCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -56,42 +56,16 @@ vector<LogicalType> TableCatalogEntry::GetTypes() {
 	return types;
 }
 
-CreateTableInfo TableCatalogEntry::GetTableInfoForSerialization() const {
-	CreateTableInfo result;
-	result.catalog = catalog.GetName();
-	result.schema = schema.name;
-	result.table = name;
-	result.columns = columns.Copy();
-	result.constraints.reserve(constraints.size());
+unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateTableInfo>();
+	result->catalog = catalog.GetName();
+	result->schema = schema.name;
+	result->table = name;
+	result->columns = columns.Copy();
+	result->constraints.reserve(constraints.size());
 	std::for_each(constraints.begin(), constraints.end(),
-	              [&result](const unique_ptr<Constraint> &c) { result.constraints.emplace_back(c->Copy()); });
-	return result;
-}
-
-void TableCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	const auto info = GetTableInfoForSerialization();
-	FieldWriter writer(serializer);
-	writer.WriteString(info.catalog);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	info.columns.Serialize(writer);
-	writer.WriteSerializableList(info.constraints);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateTableInfo>();
-
-	FieldReader reader(source);
-	info->catalog = reader.ReadRequired<string>();
-	info->schema = reader.ReadRequired<string>();
-	info->table = reader.ReadRequired<string>();
-	info->columns = ColumnList::Deserialize(reader);
-	info->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	reader.Finalize();
-
-	return info;
+	              [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
+	return std::move(result);
 }
 
 string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
@@ -162,11 +136,10 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			// single column unique: insert constraint here
 			ss << " UNIQUE";
 		}
-		if (column.DefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
-		}
 		if (column.Generated()) {
 			ss << " GENERATED ALWAYS AS(" << column.GeneratedExpression().ToString() << ")";
+		} else if (column.DefaultValue()) {
+			ss << " DEFAULT(" << column.DefaultValue()->ToString() << ")";
 		}
 	}
 	// print any extra constraints that still need to be printed

package/src/duckdb/src/catalog/catalog_entry/view_catalog_entry.cpp

@@ -25,6 +25,17 @@ ViewCatalogEntry::ViewCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
 	Initialize(info);
 }
 
+unique_ptr<CreateInfo> ViewCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateViewInfo>();
+	result->schema = schema.name;
+	result->view_name = name;
+	result->sql = sql;
+	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	result->aliases = aliases;
+	result->types = types;
+	return std::move(result);
+}
+
 unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
 	if (info.type != AlterType::ALTER_VIEW) {
@@ -43,33 +54,6 @@ unique_ptr<CatalogEntry> ViewCatalogEntry::AlterEntry(ClientContext &context, Al
 	}
 }
 
-void ViewCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	writer.WriteString(sql);
-	writer.WriteSerializable(*query);
-	writer.WriteList<string>(aliases);
-	writer.WriteRegularSerializableList<LogicalType>(types);
-	writer.Finalize();
-}
-
-unique_ptr<CreateViewInfo> ViewCatalogEntry::Deserialize(Deserializer &source, ClientContext &context) {
-	auto info = make_uniq<CreateViewInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->view_name = reader.ReadRequired<string>();
-	info->sql = reader.ReadRequired<string>();
-	info->query = reader.ReadRequiredSerializable<SelectStatement>();
-	info->aliases = reader.ReadRequiredList<string>();
-	info->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
-}
-
 string ViewCatalogEntry::ToSQL() const {
 	if (sql.empty()) {
 		//! Return empty sql with view name so pragma view_tables don't complain

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -1,6 +1,8 @@
 #include "duckdb/catalog/catalog_entry.hpp"
-
+#include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -31,6 +33,10 @@ unique_ptr<CatalogEntry> CatalogEntry::Copy(ClientContext &context) const {
 	throw InternalException("Unsupported copy type for catalog entry!");
 }
 
+unique_ptr<CreateInfo> CatalogEntry::GetInfo() const {
+	throw InternalException("Unsupported type for CatalogEntry::GetInfo!");
+}
+
 string CatalogEntry::ToSQL() const {
 	throw InternalException("Unsupported catalog type for ToSQL()");
 }
@@ -44,6 +50,24 @@ SchemaCatalogEntry &CatalogEntry::ParentSchema() {
 }
 // LCOV_EXCL_STOP
 
+void CatalogEntry::Serialize(Serializer &serializer) const {
+	const auto info = GetInfo();
+	info->Serialize(serializer);
+}
+
+unique_ptr<CreateInfo> CatalogEntry::Deserialize(Deserializer &source) {
+	return CreateInfo::Deserialize(source);
+}
+
+void CatalogEntry::FormatSerialize(FormatSerializer &serializer) const {
+	const auto info = GetInfo();
+	info->FormatSerialize(serializer);
+}
+
+unique_ptr<CreateInfo> CatalogEntry::FormatDeserialize(FormatDeserializer &deserializer) {
+	return CreateInfo::FormatDeserialize(deserializer);
+}
+
 void CatalogEntry::Verify(Catalog &catalog_p) {
 }
 

package/src/duckdb/src/common/enum_util.cpp

@@ -88,6 +88,8 @@
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_info.hpp"
 #include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+#include "duckdb/parser/parsed_data/load_info.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
 #include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/parser/parsed_data/sample_options.hpp"
 #include "duckdb/parser/parsed_data/transaction_info.hpp"
@@ -217,6 +219,29 @@ AggregateType EnumUtil::FromString<AggregateType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<AlterForeignKeyType>(AlterForeignKeyType value) {
+	switch(value) {
+	case AlterForeignKeyType::AFT_ADD:
+		return "AFT_ADD";
+	case AlterForeignKeyType::AFT_DELETE:
+		return "AFT_DELETE";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+AlterForeignKeyType EnumUtil::FromString<AlterForeignKeyType>(const char *value) {
+	if (StringUtil::Equals(value, "AFT_ADD")) {
+		return AlterForeignKeyType::AFT_ADD;
+	}
+	if (StringUtil::Equals(value, "AFT_DELETE")) {
+		return AlterForeignKeyType::AFT_DELETE;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<AlterScalarFunctionType>(AlterScalarFunctionType value) {
 	switch(value) {
@@ -2274,6 +2299,39 @@ FunctionSideEffects EnumUtil::FromString<FunctionSideEffects>(const char *value)
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<IndexConstraintType>(IndexConstraintType value) {
+	switch(value) {
+	case IndexConstraintType::NONE:
+		return "NONE";
+	case IndexConstraintType::UNIQUE:
+		return "UNIQUE";
+	case IndexConstraintType::PRIMARY:
+		return "PRIMARY";
+	case IndexConstraintType::FOREIGN:
+		return "FOREIGN";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+IndexConstraintType EnumUtil::FromString<IndexConstraintType>(const char *value) {
+	if (StringUtil::Equals(value, "NONE")) {
+		return IndexConstraintType::NONE;
+	}
+	if (StringUtil::Equals(value, "UNIQUE")) {
+		return IndexConstraintType::UNIQUE;
+	}
+	if (StringUtil::Equals(value, "PRIMARY")) {
+		return IndexConstraintType::PRIMARY;
+	}
+	if (StringUtil::Equals(value, "FOREIGN")) {
+		return IndexConstraintType::FOREIGN;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<IndexType>(IndexType value) {
 	switch(value) {
@@ -2482,6 +2540,34 @@ KeywordCategory EnumUtil::FromString<KeywordCategory>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<LoadType>(LoadType value) {
+	switch(value) {
+	case LoadType::LOAD:
+		return "LOAD";
+	case LoadType::INSTALL:
+		return "INSTALL";
+	case LoadType::FORCE_INSTALL:
+		return "FORCE_INSTALL";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+LoadType EnumUtil::FromString<LoadType>(const char *value) {
+	if (StringUtil::Equals(value, "LOAD")) {
+		return LoadType::LOAD;
+	}
+	if (StringUtil::Equals(value, "INSTALL")) {
+		return LoadType::INSTALL;
+	}
+	if (StringUtil::Equals(value, "FORCE_INSTALL")) {
+		return LoadType::FORCE_INSTALL;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value) {
 	switch(value) {
@@ -3558,6 +3644,79 @@ OutputStream EnumUtil::FromString<OutputStream>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<ParseInfoType>(ParseInfoType value) {
+	switch(value) {
+	case ParseInfoType::ALTER_INFO:
+		return "ALTER_INFO";
+	case ParseInfoType::ATTACH_INFO:
+		return "ATTACH_INFO";
+	case ParseInfoType::COPY_INFO:
+		return "COPY_INFO";
+	case ParseInfoType::CREATE_INFO:
+		return "CREATE_INFO";
+	case ParseInfoType::DETACH_INFO:
+		return "DETACH_INFO";
+	case ParseInfoType::DROP_INFO:
+		return "DROP_INFO";
+	case ParseInfoType::BOUND_EXPORT_DATA:
+		return "BOUND_EXPORT_DATA";
+	case ParseInfoType::LOAD_INFO:
+		return "LOAD_INFO";
+	case ParseInfoType::PRAGMA_INFO:
+		return "PRAGMA_INFO";
+	case ParseInfoType::SHOW_SELECT_INFO:
+		return "SHOW_SELECT_INFO";
+	case ParseInfoType::TRANSACTION_INFO:
+		return "TRANSACTION_INFO";
+	case ParseInfoType::VACUUM_INFO:
+		return "VACUUM_INFO";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+ParseInfoType EnumUtil::FromString<ParseInfoType>(const char *value) {
+	if (StringUtil::Equals(value, "ALTER_INFO")) {
+		return ParseInfoType::ALTER_INFO;
+	}
+	if (StringUtil::Equals(value, "ATTACH_INFO")) {
+		return ParseInfoType::ATTACH_INFO;
+	}
+	if (StringUtil::Equals(value, "COPY_INFO")) {
+		return ParseInfoType::COPY_INFO;
+	}
+	if (StringUtil::Equals(value, "CREATE_INFO")) {
+		return ParseInfoType::CREATE_INFO;
+	}
+	if (StringUtil::Equals(value, "DETACH_INFO")) {
+		return ParseInfoType::DETACH_INFO;
+	}
+	if (StringUtil::Equals(value, "DROP_INFO")) {
+		return ParseInfoType::DROP_INFO;
+	}
+	if (StringUtil::Equals(value, "BOUND_EXPORT_DATA")) {
+		return ParseInfoType::BOUND_EXPORT_DATA;
+	}
+	if (StringUtil::Equals(value, "LOAD_INFO")) {
+		return ParseInfoType::LOAD_INFO;
+	}
+	if (StringUtil::Equals(value, "PRAGMA_INFO")) {
+		return ParseInfoType::PRAGMA_INFO;
+	}
+	if (StringUtil::Equals(value, "SHOW_SELECT_INFO")) {
+		return ParseInfoType::SHOW_SELECT_INFO;
+	}
+	if (StringUtil::Equals(value, "TRANSACTION_INFO")) {
+		return ParseInfoType::TRANSACTION_INFO;
+	}
+	if (StringUtil::Equals(value, "VACUUM_INFO")) {
+		return ParseInfoType::VACUUM_INFO;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<ParserExtensionResultType>(ParserExtensionResultType value) {
 	switch(value) {
@@ -4718,6 +4877,29 @@ SimplifiedTokenType EnumUtil::FromString<SimplifiedTokenType>(const char *value)
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<SinkCombineResultType>(SinkCombineResultType value) {
+	switch(value) {
+	case SinkCombineResultType::FINISHED:
+		return "FINISHED";
+	case SinkCombineResultType::BLOCKED:
+		return "BLOCKED";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
+	}
+}
+
+template<>
+SinkCombineResultType EnumUtil::FromString<SinkCombineResultType>(const char *value) {
+	if (StringUtil::Equals(value, "FINISHED")) {
+		return SinkCombineResultType::FINISHED;
+	}
+	if (StringUtil::Equals(value, "BLOCKED")) {
+		return SinkCombineResultType::BLOCKED;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<SinkFinalizeType>(SinkFinalizeType value) {
 	switch(value) {
@@ -4725,6 +4907,8 @@ const char* EnumUtil::ToChars<SinkFinalizeType>(SinkFinalizeType value) {
 		return "READY";
 	case SinkFinalizeType::NO_OUTPUT_POSSIBLE:
 		return "NO_OUTPUT_POSSIBLE";
+	case SinkFinalizeType::BLOCKED:
+		return "BLOCKED";
 	default:
 		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented", value));
 	}
@@ -4738,6 +4922,9 @@ SinkFinalizeType EnumUtil::FromString<SinkFinalizeType>(const char *value) {
 	if (StringUtil::Equals(value, "NO_OUTPUT_POSSIBLE")) {
 		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
 	}
+	if (StringUtil::Equals(value, "BLOCKED")) {
+		return SinkFinalizeType::BLOCKED;
+	}
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value));
 }
 

package/src/duckdb/src/common/extra_type_info.cpp

@@ -321,7 +321,6 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 	}
 
 	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size, string enum_name) {
-
 		Vector values_insert_order(LogicalType::VARCHAR, size);
 		values_insert_order.Deserialize(size, reader.GetSource());
 		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
@@ -451,7 +450,7 @@ shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(FieldReader &reader) {
 }
 
 shared_ptr<ExtraTypeInfo> EnumTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto enum_size = deserializer.ReadProperty<uint32_t>("enum_size");
+	auto enum_size = deserializer.ReadProperty<idx_t>("enum_size");
 	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:

package/src/duckdb/src/common/serializer/binary_deserializer.cpp

@@ -5,6 +5,9 @@ namespace duckdb {
 void BinaryDeserializer::SetTag(const char *tag) {
 	current_tag = tag;
 	stack.back().read_field_count++;
+	if (stack.back().read_field_count > stack.back().expected_field_count) {
+		throw SerializationException("Attempting to read a required field, but field is missing");
+	}
 }
 
 //===--------------------------------------------------------------------===//