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

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev1968.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) {

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");
+	}
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -129,7 +129,7 @@ void BinarySerializer::WriteValue(const string &value) {
 	auto len = value.length();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value.c_str(), len);
+		WriteDataInternal(value.c_str(), len);
 	}
 }
 
@@ -137,7 +137,7 @@ void BinarySerializer::WriteValue(const string_t value) {
 	auto len = value.GetSize();
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value.GetDataUnsafe(), len);
+		WriteDataInternal(value.GetDataUnsafe(), len);
 	}
 }
 
@@ -145,7 +145,7 @@ void BinarySerializer::WriteValue(const char *value) {
 	auto len = strlen(value);
 	Write<uint32_t>((uint32_t)len);
 	if (len > 0) {
-		WriteData(value, len);
+		WriteDataInternal(value, len);
 	}
 }
 
@@ -154,7 +154,7 @@ void BinarySerializer::WriteValue(bool value) {
 }
 
 void BinarySerializer::WriteDataPtr(const_data_ptr_t ptr, idx_t count) {
-	WriteData(ptr, count);
+	WriteDataInternal(ptr, count);
 }
 
 } // namespace duckdb

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

@@ -6,6 +6,8 @@
 #include "duckdb/common/types/value_map.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -1057,4 +1059,45 @@ const vector<unique_ptr<ColumnDataCollectionSegment>> &ColumnDataCollection::Get
 	return segments;
 }
 
+void ColumnDataCollection::FormatSerialize(FormatSerializer &serializer) const {
+	vector<vector<Value>> values;
+	values.resize(ColumnCount());
+	for (auto &chunk : Chunks()) {
+		for (idx_t c = 0; c < chunk.ColumnCount(); c++) {
+			for (idx_t r = 0; r < chunk.size(); r++) {
+				values[c].push_back(chunk.GetValue(c, r));
+			}
+		}
+	}
+	serializer.WriteProperty("types", types);
+	serializer.WriteProperty("values", values);
+}
+
+unique_ptr<ColumnDataCollection> ColumnDataCollection::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto types = deserializer.ReadProperty<vector<LogicalType>>("types");
+	auto values = deserializer.ReadProperty<vector<vector<Value>>>("values");
+
+	auto collection = make_uniq<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
+	if (values.empty()) {
+		return collection;
+	}
+	DataChunk chunk;
+	chunk.Initialize(Allocator::DefaultAllocator(), types);
+
+	for (idx_t r = 0; r < values[0].size(); r++) {
+		for (idx_t c = 0; c < types.size(); c++) {
+			chunk.SetValue(c, chunk.size(), values[c][r]);
+		}
+		chunk.SetCardinality(chunk.size() + 1);
+		if (chunk.size() == STANDARD_VECTOR_SIZE) {
+			collection->Append(chunk);
+			chunk.Reset();
+		}
+	}
+	if (chunk.size() > 0) {
+		collection->Append(chunk);
+	}
+	return collection;
+}
+
 } // namespace duckdb

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

@@ -977,7 +977,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	UnifiedVectorFormat vdata;
 	ToUnifiedFormat(count, vdata);
 
-	const auto all_valid = (count > 0) && !vdata.validity.AllValid();
+	const bool all_valid = (count > 0) && !vdata.validity.AllValid();
 	serializer.WriteProperty("all_valid", all_valid);
 	if (all_valid) {
 		ValidityMask flat_mask(count);