duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
 #include <cstring>
 
 namespace duckdb {
@@ -48,9 +49,12 @@ void WriteAheadLog::Delete() {
 //===--------------------------------------------------------------------===//
 // Write Entries
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCheckpoint(block_id_t meta_block) {
-	writer->Write<WALType>(WALType::CHECKPOINT);
-	writer->Write<block_id_t>(meta_block);
+void WriteAheadLog::WriteCheckpoint(MetaBlockPointer meta_block) {
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CHECKPOINT);
+	serializer.WriteProperty(101, "meta_block", meta_block);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -60,8 +64,11 @@ void WriteAheadLog::WriteCreateTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_TABLE);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_TABLE);
+	serializer.WriteProperty(101, "table", &entry);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -71,9 +78,12 @@ void WriteAheadLog::WriteDropTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_TABLE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_TABLE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -83,8 +93,11 @@ void WriteAheadLog::WriteCreateSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_SCHEMA);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_SCHEMA);
+	serializer.WriteProperty(101, "schema", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -94,28 +107,37 @@ void WriteAheadLog::WriteCreateSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_SEQUENCE);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_SEQUENCE);
+	serializer.WriteProperty(101, "sequence", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_SEQUENCE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_SEQUENCE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteSequenceValue(const SequenceCatalogEntry &entry, SequenceValue val) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::SEQUENCE_VALUE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
-	writer->Write<uint64_t>(val.usage_count);
-	writer->Write<int64_t>(val.counter);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::SEQUENCE_VALUE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.WriteProperty(103, "usage_count", val.usage_count);
+	serializer.WriteProperty(104, "counter", val.counter);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -125,34 +147,46 @@ void WriteAheadLog::WriteCreateMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_MACRO);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_MACRO);
+	serializer.WriteProperty(101, "macro", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_MACRO);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_MACRO);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteCreateTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_TABLE_MACRO);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_TABLE_MACRO);
+	serializer.WriteProperty(101, "table", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_TABLE_MACRO);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_TABLE_MACRO);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -162,17 +196,23 @@ void WriteAheadLog::WriteCreateIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_INDEX);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_INDEX);
+	serializer.WriteProperty(101, "index", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_INDEX);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_INDEX);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -182,17 +222,23 @@ void WriteAheadLog::WriteCreateType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_TYPE);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_TYPE);
+	serializer.WriteProperty(101, "type", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_TYPE);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_TYPE);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -202,17 +248,23 @@ void WriteAheadLog::WriteCreateView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::CREATE_VIEW);
-	entry.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::CREATE_VIEW);
+	serializer.WriteProperty(101, "view", &entry);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDropView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_VIEW);
-	writer->WriteString(entry.schema.name);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_VIEW);
+	serializer.WriteProperty(101, "schema", entry.schema.name);
+	serializer.WriteProperty(102, "name", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -222,8 +274,11 @@ void WriteAheadLog::WriteDropSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::DROP_SCHEMA);
-	writer->WriteString(entry.name);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DROP_SCHEMA);
+	serializer.WriteProperty(101, "schema", entry.name);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -233,9 +288,12 @@ void WriteAheadLog::WriteSetTable(string &schema, string &table) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::USE_TABLE);
-	writer->WriteString(schema);
-	writer->WriteString(table);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::USE_TABLE);
+	serializer.WriteProperty(101, "schema", schema);
+	serializer.WriteProperty(102, "table", table);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteInsert(DataChunk &chunk) {
@@ -245,8 +303,11 @@ void WriteAheadLog::WriteInsert(DataChunk &chunk) {
 	D_ASSERT(chunk.size() > 0);
 	chunk.Verify();
 
-	writer->Write<WALType>(WALType::INSERT_TUPLE);
-	chunk.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::INSERT_TUPLE);
+	serializer.WriteProperty(101, "chunk", chunk);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteDelete(DataChunk &chunk) {
@@ -257,8 +318,11 @@ void WriteAheadLog::WriteDelete(DataChunk &chunk) {
 	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
 	chunk.Verify();
 
-	writer->Write<WALType>(WALType::DELETE_TUPLE);
-	chunk.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::DELETE_TUPLE);
+	serializer.WriteProperty(101, "chunk", chunk);
+	serializer.End();
 }
 
 void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column_indexes) {
@@ -270,23 +334,26 @@ void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column
 	D_ASSERT(chunk.data[1].GetType().id() == LogicalType::ROW_TYPE);
 	chunk.Verify();
 
-	writer->Write<WALType>(WALType::UPDATE_TUPLE);
-	writer->Write<idx_t>(column_indexes.size());
-	for (auto &col_idx : column_indexes) {
-		writer->Write<column_t>(col_idx);
-	}
-	chunk.Serialize(*writer);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::UPDATE_TUPLE);
+	serializer.WriteProperty(101, "column_indexes", column_indexes);
+	serializer.WriteProperty(102, "chunk", chunk);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
 // Write ALTER Statement
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(data_ptr_t ptr, idx_t data_size) {
+void WriteAheadLog::WriteAlter(const AlterInfo &info) {
 	if (skip_writing) {
 		return;
 	}
-	writer->Write<WALType>(WALType::ALTER_INFO);
-	writer->WriteData(ptr, data_size);
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
+	serializer.WriteProperty(100, "wal_type", WALType::ALTER_INFO);
+	serializer.WriteProperty(101, "info", &info);
+	serializer.End();
 }
 
 //===--------------------------------------------------------------------===//
@@ -296,8 +363,13 @@ void WriteAheadLog::Flush() {
 	if (skip_writing) {
 		return;
 	}
+
+	BinarySerializer serializer(*writer);
+	serializer.Begin();
 	// write an empty entry
-	writer->Write<WALType>(WALType::WAL_FLUSH);
+	serializer.WriteProperty(100, "wal_type", WALType::WAL_FLUSH);
+	serializer.End();
+
 	// flushes all changes made to the WAL to disk
 	writer->Sync();
 }

package/src/duckdb/src/transaction/cleanup_state.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/catalog/dependency_manager.hpp"
 #include "duckdb/storage/table/chunk_info.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/storage/table/row_version_manager.hpp"
 
 namespace duckdb {
 
@@ -69,7 +70,7 @@ void CleanupState::CleanupDelete(DeleteInfo &info) {
 
 	count = 0;
 	for (idx_t i = 0; i < info.count; i++) {
-		row_numbers[count++] = info.vinfo->start + info.rows[i];
+		row_numbers[count++] = info.base_row + info.rows[i];
 	}
 	Flush();
 }

package/src/duckdb/src/transaction/commit_state.cpp

@@ -1,10 +1,10 @@
 #include "duckdb/transaction/commit_state.hpp"
 
+#include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table/chunk_info.hpp"
 #include "duckdb/storage/table/column_data.hpp"
@@ -16,11 +16,14 @@
 #include "duckdb/transaction/update_info.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/storage/table/row_version_manager.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 
 namespace duckdb {
 
-CommitState::CommitState(ClientContext &context, transaction_t commit_id, optional_ptr<WriteAheadLog> log)
-    : log(log), commit_id(commit_id), current_table_info(nullptr), context(context) {
+CommitState::CommitState(transaction_t commit_id, optional_ptr<WriteAheadLog> log)
+    : log(log), commit_id(commit_id), current_table_info(nullptr) {
 }
 
 void CommitState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
@@ -44,18 +47,23 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 			auto &table_entry = entry.Cast<DuckTableEntry>();
 			D_ASSERT(table_entry.IsDuckTable());
 			// ALTER TABLE statement, read the extra data after the entry
+
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
 
-			BufferedDeserializer source(extra_data, extra_data_size);
-			string column_name = source.Read<string>();
+			MemoryStream source(extra_data, extra_data_size);
+			BinaryDeserializer deserializer(source);
+			deserializer.Begin();
+			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
+			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
+			deserializer.End();
 
 			if (!column_name.empty()) {
 				// write the alter table in the log
 				table_entry.CommitAlter(column_name);
 			}
-
-			log->WriteAlter(source.ptr, source.endptr - source.ptr);
+			auto &alter_info = parse_info->Cast<AlterInfo>();
+			log->WriteAlter(alter_info);
 		} else {
 			// CREATE TABLE statement
 			log->WriteCreateTable(parent->Cast<TableCatalogEntry>());
@@ -74,10 +82,18 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = data_ptr_cast(dataptr + sizeof(idx_t));
 			// deserialize it
-			BufferedDeserializer source(extra_data, extra_data_size);
-			string column_name = source.Read<string>();
+			MemoryStream source(extra_data, extra_data_size);
+			BinaryDeserializer deserializer(source);
+			deserializer.Begin();
+			auto column_name = deserializer.ReadProperty<string>(100, "column_name");
+			auto parse_info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(101, "alter_info");
+			deserializer.End();
+
+			(void)column_name;
+
 			// write the alter table in the log
-			log->WriteAlter(source.ptr, source.endptr - source.ptr);
+			auto &alter_info = parse_info->Cast<AlterInfo>();
+			log->WriteAlter(alter_info);
 		} else {
 			log->WriteCreateView(parent->Cast<ViewCatalogEntry>());
 		}
@@ -124,9 +140,12 @@ void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
 		case CatalogType::TYPE_ENTRY:
 			log->WriteDropType(entry.Cast<TypeCatalogEntry>());
 			break;
-		case CatalogType::INDEX_ENTRY:
+		case CatalogType::INDEX_ENTRY: {
+			auto &index_entry = entry.Cast<DuckIndexEntry>();
+			index_entry.CommitDrop();
 			log->WriteDropIndex(entry.Cast<IndexCatalogEntry>());
 			break;
+		}
 		case CatalogType::PREPARED_STATEMENT:
 		case CatalogType::SCALAR_FUNCTION_ENTRY:
 			// do nothing, indexes/prepared statements/functions aren't persisted to disk
@@ -262,7 +281,7 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 			WriteDelete(*info);
 		}
 		// mark the tuples as committed
-		info->vinfo->CommitDelete(commit_id, info->rows, info->count);
+		info->version_info->CommitDelete(info->vector_idx, commit_id, info->rows, info->count);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {
@@ -303,7 +322,7 @@ void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
 		auto info = reinterpret_cast<DeleteInfo *>(data);
 		info->table->info->cardinality += info->count;
 		// revert the commit by writing the (uncommitted) transaction_id back into the version info
-		info->vinfo->CommitDelete(transaction_id, info->rows, info->count);
+		info->version_info->CommitDelete(info->vector_idx, transaction_id, info->rows, info->count);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {

package/src/duckdb/src/transaction/duck_transaction.cpp

@@ -70,10 +70,12 @@ void DuckTransaction::PushCatalogEntry(CatalogEntry &entry, data_ptr_t extra_dat
 	}
 }
 
-void DuckTransaction::PushDelete(DataTable &table, ChunkVectorInfo *vinfo, row_t rows[], idx_t count, idx_t base_row) {
+void DuckTransaction::PushDelete(DataTable &table, RowVersionManager &info, idx_t vector_idx, row_t rows[], idx_t count,
+                                 idx_t base_row) {
 	auto delete_info = reinterpret_cast<DeleteInfo *>(
 	    undo_buffer.CreateEntry(UndoFlags::DELETE_TUPLE, sizeof(DeleteInfo) + sizeof(row_t) * count));
-	delete_info->vinfo = vinfo;
+	delete_info->version_info = &info;
+	delete_info->vector_idx = vector_idx;
 	delete_info->table = &table;
 	delete_info->count = count;
 	delete_info->base_row = base_row;
@@ -140,6 +142,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 		}
 		return string();
 	} catch (std::exception &ex) {
+		undo_buffer.RevertCommit(iterator_state, this->transaction_id);
 		return ex.what();
 	}
 }

package/src/duckdb/src/transaction/rollback_state.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
+#include "duckdb/storage/table/row_version_manager.hpp"
 
 namespace duckdb {
 
@@ -30,7 +31,7 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 	case UndoFlags::DELETE_TUPLE: {
 		auto info = reinterpret_cast<DeleteInfo *>(data);
 		// reset the deleted flag on rollback
-		info->vinfo->CommitDelete(NOT_DELETED_ID, info->rows, info->count);
+		info->version_info->CommitDelete(info->vector_idx, NOT_DELETED_ID, info->rows, info->count);
 		break;
 	}
 	case UndoFlags::UPDATE_TUPLE: {

package/src/duckdb/src/transaction/undo_buffer.cpp

@@ -11,12 +11,10 @@
 #include "duckdb/transaction/rollback_state.hpp"
 #include "duckdb/common/pair.hpp"
 
-#include <unordered_map>
-
 namespace duckdb {
 constexpr uint32_t UNDO_ENTRY_HEADER_SIZE = sizeof(UndoFlags) + sizeof(uint32_t);
 
-UndoBuffer::UndoBuffer(ClientContext &context_p) : context(context_p), allocator(BufferAllocator::Get(context_p)) {
+UndoBuffer::UndoBuffer(ClientContext &context_p) : allocator(BufferAllocator::Get(context_p)) {
 }
 
 data_ptr_t UndoBuffer::CreateEntry(UndoFlags type, idx_t len) {
@@ -138,7 +136,7 @@ void UndoBuffer::Cleanup() {
 
 void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, optional_ptr<WriteAheadLog> log,
                         transaction_t commit_id) {
-	CommitState state(context, commit_id, log);
+	CommitState state(commit_id, log);
 	if (log) {
 		// commit WITH write ahead log
 		IterateEntries(iterator_state, [&](UndoFlags type, data_ptr_t data) { state.CommitEntry<true>(type, data); });
@@ -149,7 +147,7 @@ void UndoBuffer::Commit(UndoBuffer::IteratorState &iterator_state, optional_ptr<
 }
 
 void UndoBuffer::RevertCommit(UndoBuffer::IteratorState &end_state, transaction_t transaction_id) {
-	CommitState state(context, transaction_id, nullptr);
+	CommitState state(transaction_id, nullptr);
 	UndoBuffer::IteratorState start_state;
 	IterateEntries(start_state, end_state, [&](UndoFlags type, data_ptr_t data) { state.RevertCommit(type, data); });
 }

package/src/duckdb/src/verification/deserialized_statement_verifier.cpp

@@ -1,7 +1,8 @@
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
-#include "duckdb/common/serializer/binary_serializer.hpp"
+
 #include "duckdb/common/serializer/binary_deserializer.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 namespace duckdb {
 
 DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLStatement> statement_p)
@@ -9,11 +10,15 @@ DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLState
 }
 
 unique_ptr<StatementVerifier> DeserializedStatementVerifier::Create(const SQLStatement &statement) {
+
 	auto &select_stmt = statement.Cast<SelectStatement>();
-	BufferedSerializer serializer;
-	select_stmt.Serialize(serializer);
-	BufferedDeserializer source(serializer);
-	return make_uniq<DeserializedStatementVerifier>(SelectStatement::Deserialize(source));
+
+	MemoryStream stream;
+	BinarySerializer::Serialize(select_stmt, stream);
+	stream.Rewind();
+	auto result = BinaryDeserializer::Deserialize<SelectStatement>(stream);
+
+	return make_uniq<DeserializedStatementVerifier>(std::move(result));
 }
 
 } // namespace duckdb

package/src/duckdb/src/verification/prepared_statement_verifier.cpp

@@ -23,6 +23,9 @@ void PreparedStatementVerifier::Extract() {
 	ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	    *select.node, [&](unique_ptr<ParsedExpression> &child) { ConvertConstants(child); });
 	statement->n_param = values.size();
+	for (auto &kv : values) {
+		statement->named_param_map[kv.first] = 0;
+	}
 	// create the PREPARE and EXECUTE statements
 	string name = "__duckdb_verification_prepared_statement";
 	auto prepare = make_uniq<PrepareStatement>();
@@ -31,7 +34,7 @@ void PreparedStatementVerifier::Extract() {
 
 	auto execute = make_uniq<ExecuteStatement>();
 	execute->name = name;
-	execute->values = std::move(values);
+	execute->named_values = std::move(values);
 
 	auto dealloc = make_uniq<DropStatement>();
 	dealloc->info->type = CatalogType::PREPARED_STATEMENT;
@@ -49,19 +52,21 @@ void PreparedStatementVerifier::ConvertConstants(unique_ptr<ParsedExpression> &c
 		child->alias = string();
 		// check if the value already exists
 		idx_t index = values.size();
-		for (idx_t v_idx = 0; v_idx < values.size(); v_idx++) {
-			if (values[v_idx]->Equals(*child)) {
-				// duplicate value! refer to the original value
-				index = v_idx;
-				break;
-			}
-		}
-		if (index == values.size()) {
-			values.push_back(std::move(child));
+		auto identifier = std::to_string(index + 1);
+		const auto predicate = [&](const std::pair<const string, unique_ptr<ParsedExpression>> &pair) {
+			return pair.second->Equals(*child.get());
+		};
+		auto result = std::find_if(values.begin(), values.end(), predicate);
+		if (result == values.end()) {
+			// If it doesn't exist yet, add it
+			values[identifier] = std::move(child);
+		} else {
+			identifier = result->first;
 		}
+
 		// replace it with an expression
 		auto parameter = make_uniq<ParameterExpression>();
-		parameter->parameter_nr = index + 1;
+		parameter->identifier = identifier;
 		parameter->alias = alias;
 		child = std::move(parameter);
 		return;

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/verification/copied_statement_verifier.hpp"
 #include "duckdb/verification/deserialized_statement_verifier.hpp"
-#include "duckdb/verification/deserialized_statement_verifier_v2.hpp"
 #include "duckdb/verification/external_statement_verifier.hpp"
 #include "duckdb/verification/parsed_statement_verifier.hpp"
 #include "duckdb/verification/prepared_statement_verifier.hpp"
@@ -33,8 +32,6 @@ unique_ptr<StatementVerifier> StatementVerifier::Create(VerificationType type, c
 		return CopiedStatementVerifier::Create(statement_p);
 	case VerificationType::DESERIALIZED:
 		return DeserializedStatementVerifier::Create(statement_p);
-	case VerificationType::DESERIALIZED_V2:
-		return DeserializedStatementVerifierV2::Create(statement_p);
 	case VerificationType::PARSED:
 		return ParsedStatementVerifier::Create(statement_p);
 	case VerificationType::UNOPTIMIZED: