duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/storage/metadata/metadata_reader.cpp

@@ -13,7 +13,7 @@ MetadataReader::MetadataReader(MetadataManager &manager, MetaBlockPointer pointe
 }
 
 MetadataReader::MetadataReader(MetadataManager &manager, BlockPointer pointer)
-    : MetadataReader(manager, MetadataManager::FromBlockPointer(pointer)) {
+    : MetadataReader(manager, MetadataManager::FromBlockPointer(pointer, manager.GetMetadataBlockSize())) {
 }
 
 MetadataPointer MetadataReader::FromDiskPointer(MetaBlockPointer pointer) {
@@ -70,16 +70,16 @@ void MetadataReader::ReadNextBlock() {
 	if (next_offset < sizeof(block_id_t)) {
 		next_offset = sizeof(block_id_t);
 	}
-	if (next_offset > MetadataManager::METADATA_BLOCK_SIZE) {
+	if (next_offset > GetMetadataManager().GetMetadataBlockSize()) {
 		throw InternalException("next_offset cannot be bigger than block size");
 	}
 	offset = next_offset;
 	next_offset = sizeof(block_id_t);
-	capacity = MetadataManager::METADATA_BLOCK_SIZE;
+	capacity = GetMetadataManager().GetMetadataBlockSize();
 }
 
 data_ptr_t MetadataReader::BasePtr() {
-	return block.handle.Ptr() + index * MetadataManager::METADATA_BLOCK_SIZE;
+	return block.handle.Ptr() + index * GetMetadataManager().GetMetadataBlockSize();
 }
 
 data_ptr_t MetadataReader::Ptr() {

package/src/duckdb/src/storage/metadata/metadata_writer.cpp

@@ -18,7 +18,7 @@ MetadataWriter::~MetadataWriter() {
 }
 
 BlockPointer MetadataWriter::GetBlockPointer() {
-	return MetadataManager::ToBlockPointer(GetMetaBlockPointer());
+	return MetadataManager::ToBlockPointer(GetMetaBlockPointer(), GetManager().GetMetadataBlockSize());
 }
 
 MetaBlockPointer MetadataWriter::GetMetaBlockPointer() {
@@ -47,7 +47,7 @@ void MetadataWriter::NextBlock() {
 	block = std::move(new_handle);
 	current_pointer = block.pointer;
 	offset = sizeof(idx_t);
-	capacity = MetadataManager::METADATA_BLOCK_SIZE;
+	capacity = GetManager().GetMetadataBlockSize();
 	Store<idx_t>(static_cast<idx_t>(-1), BasePtr());
 	if (written_pointers) {
 		written_pointers->push_back(manager.GetDiskPointer(current_pointer));
@@ -82,7 +82,7 @@ void MetadataWriter::Flush() {
 }
 
 data_ptr_t MetadataWriter::BasePtr() {
-	return block.handle.Ptr() + current_pointer.index * MetadataManager::METADATA_BLOCK_SIZE;
+	return block.handle.Ptr() + current_pointer.index * GetManager().GetMetadataBlockSize();
 }
 
 data_ptr_t MetadataWriter::Ptr() {

package/src/duckdb/src/storage/partial_block_manager.cpp

@@ -26,7 +26,7 @@ void PartialBlock::FlushInternal(const idx_t free_space_left) {
 			memset(buffer_handle.Ptr() + uninitialized.start, 0, uninitialized.end - uninitialized.start);
 		}
 		// memset any free space at the end of the block to 0 prior to writing to disk
-		memset(buffer_handle.Ptr() + Storage::BLOCK_SIZE - free_space_left, 0, free_space_left);
+		memset(buffer_handle.Ptr() + block_manager.GetBlockSize() - free_space_left, 0, free_space_left);
 	}
 }
 
@@ -35,9 +35,16 @@ void PartialBlock::FlushInternal(const idx_t free_space_left) {
 //===--------------------------------------------------------------------===//
 
 PartialBlockManager::PartialBlockManager(BlockManager &block_manager, PartialBlockType partial_block_type,
-                                         uint32_t max_partial_block_size, uint32_t max_use_count)
-    : block_manager(block_manager), partial_block_type(partial_block_type),
-      max_partial_block_size(max_partial_block_size), max_use_count(max_use_count) {
+                                         optional_idx max_partial_block_size_p, uint32_t max_use_count)
+    : block_manager(block_manager), partial_block_type(partial_block_type), max_use_count(max_use_count) {
+
+	if (max_partial_block_size_p.IsValid()) {
+		max_partial_block_size = NumericCast<uint32_t>(max_partial_block_size_p.GetIndex());
+		return;
+	}
+
+	// Use the default maximum partial block size with a ratio of 20% free and 80% utilization.
+	max_partial_block_size = NumericCast<uint32_t>(block_manager.GetBlockSize() / 5 * 4);
 }
 PartialBlockManager::~PartialBlockManager() {
 }
@@ -70,13 +77,13 @@ bool PartialBlockManager::HasBlockAllocation(uint32_t segment_size) {
 }
 
 void PartialBlockManager::AllocateBlock(PartialBlockState &state, uint32_t segment_size) {
-	D_ASSERT(segment_size <= Storage::BLOCK_SIZE);
+	D_ASSERT(segment_size <= block_manager.GetBlockSize());
 	if (partial_block_type == PartialBlockType::FULL_CHECKPOINT) {
 		state.block_id = block_manager.GetFreeBlockId();
 	} else {
 		state.block_id = INVALID_BLOCK;
 	}
-	state.block_size = Storage::BLOCK_SIZE;
+	state.block_size = NumericCast<uint32_t>(block_manager.GetBlockSize());
 	state.offset = 0;
 	state.block_use_count = 1;
 }
@@ -108,7 +115,7 @@ void PartialBlockManager::RegisterPartialBlock(PartialBlockAllocation allocation
 		state.offset = new_size;
 		auto new_space_left = state.block_size - new_size;
 		// check if the block is STILL partially filled after adding the segment_size
-		if (new_space_left >= Storage::BLOCK_SIZE - max_partial_block_size) {
+		if (new_space_left >= block_manager.GetBlockSize() - max_partial_block_size) {
 			// the block is still partially filled: add it to the partially_filled_blocks list
 			partially_filled_blocks.insert(make_pair(new_space_left, std::move(allocation.partial_block)));
 		}
@@ -139,7 +146,7 @@ void PartialBlockManager::Merge(PartialBlockManager &other) {
 		if (!e.second) {
 			throw InternalException("Empty partially filled block found");
 		}
-		auto used_space = NumericCast<uint32_t>(Storage::BLOCK_SIZE - e.first);
+		auto used_space = NumericCast<uint32_t>(block_manager.GetBlockSize() - e.first);
 		if (HasBlockAllocation(used_space)) {
 			// we can merge this block into an existing block - merge them
 			// merge blocks
@@ -183,6 +190,10 @@ void PartialBlockManager::FlushPartialBlocks() {
 	partially_filled_blocks.clear();
 }
 
+BlockManager &PartialBlockManager::GetBlockManager() const {
+	return block_manager;
+}
+
 void PartialBlockManager::Rollback() {
 	ClearBlocks();
 	for (auto &block_id : written_blocks) {

package/src/duckdb/src/storage/serialization/serialize_create_info.cpp

@@ -39,9 +39,9 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 	auto internal = deserializer.ReadPropertyWithDefault<bool>(104, "internal");
 	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>(105, "on_conflict");
 	auto sql = deserializer.ReadPropertyWithDefault<string>(106, "sql");
-	auto comment = deserializer.ReadPropertyWithDefault<Value>(107, "comment", Value());
-	auto tags = deserializer.ReadPropertyWithDefault<unordered_map<string, string>>(108, "tags", unordered_map<string, string>());
-	auto dependencies = deserializer.ReadPropertyWithDefault<LogicalDependencyList>(109, "dependencies", LogicalDependencyList());
+	auto comment = deserializer.ReadPropertyWithExplicitDefault<Value>(107, "comment", Value());
+	auto tags = deserializer.ReadPropertyWithExplicitDefault<unordered_map<string, string>>(108, "tags", unordered_map<string, string>());
+	auto dependencies = deserializer.ReadPropertyWithExplicitDefault<LogicalDependencyList>(109, "dependencies", LogicalDependencyList());
 	deserializer.Set<CatalogType>(type);
 	unique_ptr<CreateInfo> result;
 	switch (type) {
@@ -117,13 +117,16 @@ unique_ptr<CreateInfo> CreateIndexInfo::Deserialize(Deserializer &deserializer)
 void CreateMacroInfo::Serialize(Serializer &serializer) const {
 	CreateInfo::Serialize(serializer);
 	serializer.WritePropertyWithDefault<string>(200, "name", name);
-	serializer.WritePropertyWithDefault<unique_ptr<MacroFunction>>(201, "function", function);
+	serializer.WritePropertyWithDefault<unique_ptr<MacroFunction>>(201, "function", macros[0]);
+	serializer.WritePropertyWithDefault<vector<unique_ptr<MacroFunction>>>(202, "extra_functions", GetAllButFirstFunction());
 }
 
 unique_ptr<CreateInfo> CreateMacroInfo::Deserialize(Deserializer &deserializer) {
-	auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo(deserializer.Get<CatalogType>()));
-	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
-	deserializer.ReadPropertyWithDefault<unique_ptr<MacroFunction>>(201, "function", result->function);
+	auto name = deserializer.ReadPropertyWithDefault<string>(200, "name");
+	auto function = deserializer.ReadPropertyWithDefault<unique_ptr<MacroFunction>>(201, "function");
+	auto extra_functions = deserializer.ReadPropertyWithDefault<vector<unique_ptr<MacroFunction>>>(202, "extra_functions");
+	auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo(deserializer.Get<CatalogType>(), std::move(function), std::move(extra_functions)));
+	result->name = std::move(name);
 	return std::move(result);
 }
 
@@ -206,7 +209,7 @@ unique_ptr<CreateInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(202, "types", result->types);
 	deserializer.ReadPropertyWithDefault<unique_ptr<SelectStatement>>(203, "query", result->query);
 	deserializer.ReadPropertyWithDefault<vector<string>>(204, "names", result->names);
-	deserializer.ReadPropertyWithDefault<vector<Value>>(205, "column_comments", result->column_comments, vector<Value>());
+	deserializer.ReadPropertyWithExplicitDefault<vector<Value>>(205, "column_comments", result->column_comments, vector<Value>());
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/serialization/serialize_expression.cpp

@@ -20,7 +20,7 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &deserializer) {
 	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "expression_class");
 	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
 	auto alias = deserializer.ReadPropertyWithDefault<string>(102, "alias");
-	auto query_location = deserializer.ReadPropertyWithDefault<optional_idx>(103, "query_location", optional_idx());
+	auto query_location = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(103, "query_location", optional_idx());
 	deserializer.Set<ExpressionType>(type);
 	unique_ptr<Expression> result;
 	switch (expression_class) {

package/src/duckdb/src/storage/serialization/serialize_extension_install_info.cpp

@@ -14,6 +14,7 @@ void ExtensionInstallInfo::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<string>(101, "full_path", full_path);
 	serializer.WritePropertyWithDefault<string>(102, "repository_url", repository_url);
 	serializer.WritePropertyWithDefault<string>(103, "version", version);
+	serializer.WritePropertyWithDefault<string>(104, "etag", etag);
 }
 
 unique_ptr<ExtensionInstallInfo> ExtensionInstallInfo::Deserialize(Deserializer &deserializer) {
@@ -22,6 +23,7 @@ unique_ptr<ExtensionInstallInfo> ExtensionInstallInfo::Deserialize(Deserializer
 	deserializer.ReadPropertyWithDefault<string>(101, "full_path", result->full_path);
 	deserializer.ReadPropertyWithDefault<string>(102, "repository_url", result->repository_url);
 	deserializer.ReadPropertyWithDefault<string>(103, "version", result->version);
+	deserializer.ReadPropertyWithDefault<string>(104, "etag", result->etag);
 	return result;
 }
 

package/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp

@@ -297,7 +297,7 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(Deserializer &des
 	deserializer.ReadPropertyWithDefault<vector<JoinCondition>>(204, "conditions", result->conditions);
 	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(205, "mark_types", result->mark_types);
 	deserializer.ReadPropertyWithDefault<vector<unique_ptr<Expression>>>(206, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
-	deserializer.ReadPropertyWithDefault<bool>(207, "delim_flipped", result->delim_flipped, false);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(207, "delim_flipped", result->delim_flipped, false);
 	return std::move(result);
 }
 
@@ -658,8 +658,8 @@ void LogicalSetOperation::Serialize(Serializer &serializer) const {
 unique_ptr<LogicalOperator> LogicalSetOperation::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadPropertyWithDefault<idx_t>(200, "table_index");
 	auto column_count = deserializer.ReadPropertyWithDefault<idx_t>(201, "column_count");
-	auto setop_all = deserializer.ReadPropertyWithDefault<bool>(202, "setop_all", true);
-	auto allow_out_of_order = deserializer.ReadPropertyWithDefault<bool>(203, "allow_out_of_order", true);
+	auto setop_all = deserializer.ReadPropertyWithExplicitDefault<bool>(202, "setop_all", true);
+	auto allow_out_of_order = deserializer.ReadPropertyWithExplicitDefault<bool>(203, "allow_out_of_order", true);
 	auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>(), setop_all, allow_out_of_order));
 	return std::move(result);
 }

package/src/duckdb/src/storage/serialization/serialize_nodes.cpp

@@ -199,11 +199,17 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<bool>(130, "parallel", parallel);
 	serializer.WritePropertyWithDefault<vector<bool>>(131, "was_type_manually_set", was_type_manually_set);
 	serializer.WritePropertyWithDefault<CSVOption<string>>(132, "rejects_scan_name", rejects_scan_name, {"reject_scans"});
+	serializer.WritePropertyWithDefault<vector<string>>(133, "name_list", name_list);
+	serializer.WritePropertyWithDefault<vector<LogicalType>>(134, "sql_type_list", sql_type_list);
+	serializer.WritePropertyWithDefault<case_insensitive_map_t<idx_t>>(135, "sql_types_per_column", sql_types_per_column);
+	serializer.WritePropertyWithDefault<bool>(136, "columns_set", columns_set, false);
+	serializer.WritePropertyWithDefault<CSVOption<char>>(137, "dialect_options.state_machine_options.comment", dialect_options.state_machine_options.comment, CSVOption<char>('\0'));
+	serializer.WritePropertyWithDefault<idx_t>(138, "dialect_options.rows_until_header", dialect_options.rows_until_header);
 }
 
 CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
 	CSVReaderOptions result;
-	deserializer.ReadPropertyWithDefault<bool>(100, "ignore_errors", result.ignore_errors, false);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(100, "ignore_errors", result.ignore_errors, false);
 	deserializer.ReadPropertyWithDefault<idx_t>(101, "buffer_sample_size", result.buffer_sample_size);
 	deserializer.ReadPropertyWithDefault<vector<string>>(102, "null_str", result.null_str);
 	deserializer.ReadProperty<FileCompressionType>(103, "compression", result.compression);
@@ -220,7 +226,7 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadPropertyWithDefault<idx_t>(114, "buffer_size", result.buffer_size);
 	deserializer.ReadProperty<MultiFileReaderOptions>(115, "file_options", result.file_options);
 	deserializer.ReadPropertyWithDefault<vector<bool>>(116, "force_quote", result.force_quote);
-	deserializer.ReadPropertyWithDefault<string>(117, "rejects_table_name", result.rejects_table_name, "reject_errors");
+	deserializer.ReadPropertyWithExplicitDefault<string>(117, "rejects_table_name", result.rejects_table_name, "reject_errors");
 	deserializer.ReadPropertyWithDefault<idx_t>(118, "rejects_limit", result.rejects_limit);
 	deserializer.ReadDeletedProperty<vector<string>>(119, "rejects_recovery_columns");
 	deserializer.ReadDeletedProperty<vector<idx_t>>(120, "rejects_recovery_column_ids");
@@ -235,7 +241,13 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadPropertyWithDefault<string>(129, "sniffer_user_mismatch_error", result.sniffer_user_mismatch_error);
 	deserializer.ReadPropertyWithDefault<bool>(130, "parallel", result.parallel);
 	deserializer.ReadPropertyWithDefault<vector<bool>>(131, "was_type_manually_set", result.was_type_manually_set);
-	deserializer.ReadPropertyWithDefault<CSVOption<string>>(132, "rejects_scan_name", result.rejects_scan_name, {"reject_scans"});
+	deserializer.ReadPropertyWithExplicitDefault<CSVOption<string>>(132, "rejects_scan_name", result.rejects_scan_name, {"reject_scans"});
+	deserializer.ReadPropertyWithDefault<vector<string>>(133, "name_list", result.name_list);
+	deserializer.ReadPropertyWithDefault<vector<LogicalType>>(134, "sql_type_list", result.sql_type_list);
+	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<idx_t>>(135, "sql_types_per_column", result.sql_types_per_column);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(136, "columns_set", result.columns_set, false);
+	deserializer.ReadPropertyWithExplicitDefault<CSVOption<char>>(137, "dialect_options.state_machine_options.comment", result.dialect_options.state_machine_options.comment, CSVOption<char>('\0'));
+	deserializer.ReadPropertyWithDefault<idx_t>(138, "dialect_options.rows_until_header", result.dialect_options.rows_until_header);
 	return result;
 }
 
@@ -280,8 +292,8 @@ ColumnDefinition ColumnDefinition::Deserialize(Deserializer &deserializer) {
 	auto category = deserializer.ReadProperty<TableColumnType>(103, "category");
 	ColumnDefinition result(std::move(name), std::move(type), std::move(expression), category);
 	deserializer.ReadProperty<duckdb::CompressionType>(104, "compression_type", result.compression_type);
-	deserializer.ReadPropertyWithDefault<Value>(105, "comment", result.comment, Value());
-	deserializer.ReadPropertyWithDefault<unordered_map<string, string>>(106, "tags", result.tags, unordered_map<string, string>());
+	deserializer.ReadPropertyWithExplicitDefault<Value>(105, "comment", result.comment, Value());
+	deserializer.ReadPropertyWithExplicitDefault<unordered_map<string, string>>(106, "tags", result.tags, unordered_map<string, string>());
 	return result;
 }
 
@@ -388,6 +400,7 @@ void MultiFileReaderOptions::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<bool>(103, "union_by_name", union_by_name);
 	serializer.WritePropertyWithDefault<bool>(104, "hive_types_autocast", hive_types_autocast);
 	serializer.WritePropertyWithDefault<case_insensitive_map_t<LogicalType>>(105, "hive_types_schema", hive_types_schema);
+	serializer.WritePropertyWithDefault<string>(106, "filename_column", filename_column, MultiFileReaderOptions::DEFAULT_FILENAME_COLUMN);
 }
 
 MultiFileReaderOptions MultiFileReaderOptions::Deserialize(Deserializer &deserializer) {
@@ -398,6 +411,7 @@ MultiFileReaderOptions MultiFileReaderOptions::Deserialize(Deserializer &deseria
 	deserializer.ReadPropertyWithDefault<bool>(103, "union_by_name", result.union_by_name);
 	deserializer.ReadPropertyWithDefault<bool>(104, "hive_types_autocast", result.hive_types_autocast);
 	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<LogicalType>>(105, "hive_types_schema", result.hive_types_schema);
+	deserializer.ReadPropertyWithExplicitDefault<string>(106, "filename_column", result.filename_column, MultiFileReaderOptions::DEFAULT_FILENAME_COLUMN);
 	return result;
 }
 

package/src/duckdb/src/storage/serialization/serialize_parse_info.cpp

@@ -94,6 +94,9 @@ unique_ptr<ParseInfo> AlterInfo::Deserialize(Deserializer &deserializer) {
 	case AlterType::ALTER_VIEW:
 		result = AlterViewInfo::Deserialize(deserializer);
 		break;
+	case AlterType::CHANGE_OWNERSHIP:
+		result = ChangeOwnershipInfo::Deserialize(deserializer);
+		break;
 	case AlterType::SET_COLUMN_COMMENT:
 		result = SetColumnCommentInfo::Deserialize(deserializer);
 		break;
@@ -218,7 +221,7 @@ unique_ptr<ParseInfo> AttachInfo::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadPropertyWithDefault<string>(200, "name", result->name);
 	deserializer.ReadPropertyWithDefault<string>(201, "path", result->path);
 	deserializer.ReadPropertyWithDefault<unordered_map<string, Value>>(202, "options", result->options);
-	deserializer.ReadPropertyWithDefault<OnCreateConflict>(203, "on_conflict", result->on_conflict, OnCreateConflict::ERROR_ON_CONFLICT);
+	deserializer.ReadPropertyWithExplicitDefault<OnCreateConflict>(203, "on_conflict", result->on_conflict, OnCreateConflict::ERROR_ON_CONFLICT);
 	return std::move(result);
 }
 
@@ -237,6 +240,21 @@ unique_ptr<AlterTableInfo> ChangeColumnTypeInfo::Deserialize(Deserializer &deser
 	return std::move(result);
 }
 
+void ChangeOwnershipInfo::Serialize(Serializer &serializer) const {
+	AlterInfo::Serialize(serializer);
+	serializer.WriteProperty<CatalogType>(300, "entry_catalog_type", entry_catalog_type);
+	serializer.WritePropertyWithDefault<string>(301, "owner_schema", owner_schema);
+	serializer.WritePropertyWithDefault<string>(302, "owner_name", owner_name);
+}
+
+unique_ptr<AlterInfo> ChangeOwnershipInfo::Deserialize(Deserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ChangeOwnershipInfo>(new ChangeOwnershipInfo());
+	deserializer.ReadProperty<CatalogType>(300, "entry_catalog_type", result->entry_catalog_type);
+	deserializer.ReadPropertyWithDefault<string>(301, "owner_schema", result->owner_schema);
+	deserializer.ReadPropertyWithDefault<string>(302, "owner_name", result->owner_name);
+	return std::move(result);
+}
+
 void CopyDatabaseInfo::Serialize(Serializer &serializer) const {
 	ParseInfo::Serialize(serializer);
 	serializer.WritePropertyWithDefault<string>(200, "target_database", target_database);
@@ -465,11 +483,13 @@ unique_ptr<AlterTableInfo> SetNotNullInfo::Deserialize(Deserializer &deserialize
 void TransactionInfo::Serialize(Serializer &serializer) const {
 	ParseInfo::Serialize(serializer);
 	serializer.WriteProperty<TransactionType>(200, "type", type);
+	serializer.WriteProperty<TransactionModifierType>(201, "modifier", modifier);
 }
 
 unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<TransactionInfo>(new TransactionInfo());
 	deserializer.ReadProperty<TransactionType>(200, "type", result->type);
+	deserializer.ReadProperty<TransactionModifierType>(201, "modifier", result->modifier);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp

@@ -20,7 +20,7 @@ unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &deseria
 	auto expression_class = deserializer.ReadProperty<ExpressionClass>(100, "class");
 	auto type = deserializer.ReadProperty<ExpressionType>(101, "type");
 	auto alias = deserializer.ReadPropertyWithDefault<string>(102, "alias");
-	auto query_location = deserializer.ReadPropertyWithDefault<optional_idx>(103, "query_location", optional_idx());
+	auto query_location = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(103, "query_location", optional_idx());
 	deserializer.Set<ExpressionType>(type);
 	unique_ptr<ParsedExpression> result;
 	switch (expression_class) {
@@ -292,6 +292,7 @@ void StarExpression::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(202, "replace_list", replace_list);
 	serializer.WritePropertyWithDefault<bool>(203, "columns", columns);
 	serializer.WritePropertyWithDefault<unique_ptr<ParsedExpression>>(204, "expr", expr);
+	serializer.WritePropertyWithDefault<bool>(205, "unpacked", unpacked, false);
 }
 
 unique_ptr<ParsedExpression> StarExpression::Deserialize(Deserializer &deserializer) {
@@ -301,6 +302,7 @@ unique_ptr<ParsedExpression> StarExpression::Deserialize(Deserializer &deseriali
 	deserializer.ReadPropertyWithDefault<case_insensitive_map_t<unique_ptr<ParsedExpression>>>(202, "replace_list", result->replace_list);
 	deserializer.ReadPropertyWithDefault<bool>(203, "columns", result->columns);
 	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(204, "expr", result->expr);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(205, "unpacked", result->unpacked, false);
 	return std::move(result);
 }
 
@@ -357,7 +359,7 @@ unique_ptr<ParsedExpression> WindowExpression::Deserialize(Deserializer &deseria
 	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(211, "default_expr", result->default_expr);
 	deserializer.ReadPropertyWithDefault<bool>(212, "ignore_nulls", result->ignore_nulls);
 	deserializer.ReadPropertyWithDefault<unique_ptr<ParsedExpression>>(213, "filter_expr", result->filter_expr);
-	deserializer.ReadPropertyWithDefault<WindowExcludeMode>(214, "exclude_clause", result->exclude_clause, WindowExcludeMode::NO_OTHER);
+	deserializer.ReadPropertyWithExplicitDefault<WindowExcludeMode>(214, "exclude_clause", result->exclude_clause, WindowExcludeMode::NO_OTHER);
 	deserializer.ReadPropertyWithDefault<bool>(215, "distinct", result->distinct);
 	return std::move(result);
 }

package/src/duckdb/src/storage/serialization/serialize_query_node.cpp

@@ -70,7 +70,7 @@ void RecursiveCTENode::Serialize(Serializer &serializer) const {
 unique_ptr<QueryNode> RecursiveCTENode::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<RecursiveCTENode>(new RecursiveCTENode());
 	deserializer.ReadPropertyWithDefault<string>(200, "cte_name", result->ctename);
-	deserializer.ReadPropertyWithDefault<bool>(201, "union_all", result->union_all, false);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(201, "union_all", result->union_all, false);
 	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(202, "left", result->left);
 	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(203, "right", result->right);
 	deserializer.ReadPropertyWithDefault<vector<string>>(204, "aliases", result->aliases);
@@ -117,7 +117,7 @@ unique_ptr<QueryNode> SetOperationNode::Deserialize(Deserializer &deserializer)
 	deserializer.ReadProperty<SetOperationType>(200, "setop_type", result->setop_type);
 	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(201, "left", result->left);
 	deserializer.ReadPropertyWithDefault<unique_ptr<QueryNode>>(202, "right", result->right);
-	deserializer.ReadPropertyWithDefault<bool>(203, "setop_all", result->setop_all, true);
+	deserializer.ReadPropertyWithExplicitDefault<bool>(203, "setop_all", result->setop_all, true);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/serialization/serialize_storage.cpp

@@ -88,6 +88,7 @@ void IndexStorageInfo::Serialize(Serializer &serializer) const {
 	serializer.WritePropertyWithDefault<string>(100, "name", name);
 	serializer.WritePropertyWithDefault<idx_t>(101, "root", root);
 	serializer.WritePropertyWithDefault<vector<FixedSizeAllocatorInfo>>(102, "allocator_infos", allocator_infos);
+	serializer.WritePropertyWithDefault<case_insensitive_map_t<Value>>(103, "options", options, case_insensitive_map_t<Value>());
 }
 
 IndexStorageInfo IndexStorageInfo::Deserialize(Deserializer &deserializer) {
@@ -95,6 +96,7 @@ IndexStorageInfo IndexStorageInfo::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadPropertyWithDefault<string>(100, "name", result.name);
 	deserializer.ReadPropertyWithDefault<idx_t>(101, "root", result.root);
 	deserializer.ReadPropertyWithDefault<vector<FixedSizeAllocatorInfo>>(102, "allocator_infos", result.allocator_infos);
+	deserializer.ReadPropertyWithExplicitDefault<case_insensitive_map_t<Value>>(103, "options", result.options, case_insensitive_map_t<Value>());
 	return result;
 }
 

package/src/duckdb/src/storage/serialization/serialize_tableref.cpp

@@ -20,7 +20,7 @@ unique_ptr<TableRef> TableRef::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<TableReferenceType>(100, "type");
 	auto alias = deserializer.ReadPropertyWithDefault<string>(101, "alias");
 	auto sample = deserializer.ReadPropertyWithDefault<unique_ptr<SampleOptions>>(102, "sample");
-	auto query_location = deserializer.ReadPropertyWithDefault<optional_idx>(103, "query_location", optional_idx());
+	auto query_location = deserializer.ReadPropertyWithExplicitDefault<optional_idx>(103, "query_location", optional_idx());
 	unique_ptr<TableRef> result;
 	switch (type) {
 	case TableReferenceType::BASE_TABLE:
@@ -79,13 +79,13 @@ unique_ptr<TableRef> BaseTableRef::Deserialize(Deserializer &deserializer) {
 void ColumnDataRef::Serialize(Serializer &serializer) const {
 	TableRef::Serialize(serializer);
 	serializer.WritePropertyWithDefault<vector<string>>(200, "expected_names", expected_names);
-	serializer.WritePropertyWithDefault<optionally_owned_ptr<ColumnDataCollection>>(202, "collection", collection);
+	serializer.WritePropertyWithDefault<shared_ptr<ColumnDataCollection>>(202, "collection", collection);
 }
 
 unique_ptr<TableRef> ColumnDataRef::Deserialize(Deserializer &deserializer) {
 	auto expected_names = deserializer.ReadPropertyWithDefault<vector<string>>(200, "expected_names");
-	auto collection = deserializer.ReadPropertyWithDefault<optionally_owned_ptr<ColumnDataCollection>>(202, "collection");
-	auto result = duckdb::unique_ptr<ColumnDataRef>(new ColumnDataRef(std::move(expected_names), std::move(collection)));
+	auto collection = deserializer.ReadPropertyWithDefault<shared_ptr<ColumnDataCollection>>(202, "collection");
+	auto result = duckdb::unique_ptr<ColumnDataRef>(new ColumnDataRef(std::move(collection), std::move(expected_names)));
 	return std::move(result);
 }
 
@@ -121,6 +121,8 @@ void JoinRef::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty<JoinType>(203, "join_type", type);
 	serializer.WriteProperty<JoinRefType>(204, "ref_type", ref_type);
 	serializer.WritePropertyWithDefault<vector<string>>(205, "using_columns", using_columns);
+	serializer.WritePropertyWithDefault<bool>(206, "delim_flipped", delim_flipped);
+	serializer.WritePropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(207, "duplicate_eliminated_columns", duplicate_eliminated_columns);
 }
 
 unique_ptr<TableRef> JoinRef::Deserialize(Deserializer &deserializer) {
@@ -131,6 +133,8 @@ unique_ptr<TableRef> JoinRef::Deserialize(Deserializer &deserializer) {
 	deserializer.ReadProperty<JoinType>(203, "join_type", result->type);
 	deserializer.ReadProperty<JoinRefType>(204, "ref_type", result->ref_type);
 	deserializer.ReadPropertyWithDefault<vector<string>>(205, "using_columns", result->using_columns);
+	deserializer.ReadPropertyWithDefault<bool>(206, "delim_flipped", result->delim_flipped);
+	deserializer.ReadPropertyWithDefault<vector<unique_ptr<ParsedExpression>>>(207, "duplicate_eliminated_columns", result->duplicate_eliminated_columns);
 	return std::move(result);
 }
 

package/src/duckdb/src/storage/serialization/serialize_types.cpp

@@ -18,7 +18,7 @@ void ExtraTypeInfo::Serialize(Serializer &serializer) const {
 shared_ptr<ExtraTypeInfo> ExtraTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<ExtraTypeInfoType>(100, "type");
 	auto alias = deserializer.ReadPropertyWithDefault<string>(101, "alias");
-	auto modifiers = deserializer.ReadPropertyWithDefault<vector<Value>>(102, "modifiers", vector<Value>());
+	auto modifiers = deserializer.ReadPropertyWithExplicitDefault<vector<Value>>(102, "modifiers", vector<Value>());
 	shared_ptr<ExtraTypeInfo> result;
 	switch (type) {
 	case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO:
@@ -173,9 +173,9 @@ void UserTypeInfo::Serialize(Serializer &serializer) const {
 shared_ptr<ExtraTypeInfo> UserTypeInfo::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::shared_ptr<UserTypeInfo>(new UserTypeInfo());
 	deserializer.ReadPropertyWithDefault<string>(200, "user_type_name", result->user_type_name);
-	deserializer.ReadPropertyWithDefault<string>(201, "catalog", result->catalog, string());
-	deserializer.ReadPropertyWithDefault<string>(202, "schema", result->schema, string());
-	deserializer.ReadPropertyWithDefault<vector<Value>>(203, "user_type_modifiers", result->user_type_modifiers, vector<Value>());
+	deserializer.ReadPropertyWithExplicitDefault<string>(201, "catalog", result->catalog, string());
+	deserializer.ReadPropertyWithExplicitDefault<string>(202, "schema", result->schema, string());
+	deserializer.ReadPropertyWithExplicitDefault<vector<Value>>(203, "user_type_modifiers", result->user_type_modifiers, vector<Value>());
 	return std::move(result);
 }