duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

package/src/duckdb/src/storage/table/standard_column_data.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
 
 namespace duckdb {
 
@@ -24,7 +25,7 @@ bool StandardColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filte
 			return true;
 		}
 		state.segment_checked = true;
-		auto prune_result = filter.CheckStatistics(*state.current->stats.statistics);
+		auto prune_result = filter.CheckStatistics(state.current->stats.statistics);
 		if (prune_result != FilterPropagateResult::FILTER_ALWAYS_FALSE) {
 			return true;
 		}
@@ -44,18 +45,16 @@ void StandardColumnData::InitializeScan(ColumnScanState &state) {
 	ColumnData::InitializeScan(state);
 
 	// initialize the validity segment
-	ColumnScanState child_state;
-	validity.InitializeScan(child_state);
-	state.child_states.push_back(std::move(child_state));
+	D_ASSERT(state.child_states.size() == 1);
+	validity.InitializeScan(state.child_states[0]);
 }
 
 void StandardColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
 	ColumnData::InitializeScanWithOffset(state, row_idx);
 
 	// initialize the validity segment
-	ColumnScanState child_state;
-	validity.InitializeScanWithOffset(child_state, row_idx);
-	state.child_states.push_back(std::move(child_state));
+	D_ASSERT(state.child_states.size() == 1);
+	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
 }
 
 idx_t StandardColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state,
@@ -91,8 +90,7 @@ void StandardColumnData::InitializeAppend(ColumnAppendState &state) {
 void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
                                     idx_t count) {
 	ColumnData::AppendData(stats, state, vdata, count);
-
-	validity.AppendData(*stats.validity_stats, state.child_appends[0], vdata, count);
+	validity.AppendData(stats, state.child_appends[0], vdata, count);
 }
 
 void StandardColumnData::RevertAppend(row_t start_row) {
@@ -136,9 +134,11 @@ unique_ptr<BaseStatistics> StandardColumnData::GetUpdateStatistics() {
 		return nullptr;
 	}
 	if (!stats) {
-		stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
+		stats = BaseStatistics::CreateEmpty(type).ToUnique();
+	}
+	if (validity_stats) {
+		stats->Merge(*validity_stats);
 	}
-	stats->validity_stats = std::move(validity_stats);
 	return stats;
 }
 
@@ -146,7 +146,7 @@ void StandardColumnData::FetchRow(TransactionData transaction, ColumnFetchState
                                   idx_t result_idx) {
 	// find the segment the row belongs to
 	if (state.child_states.empty()) {
-		auto child_state = make_unique<ColumnFetchState>();
+		auto child_state = make_uniq<ColumnFetchState>();
 		state.child_states.push_back(std::move(child_state));
 	}
 	validity.FetchRow(transaction, *state.child_states[0], row_id, result, result_idx);
@@ -169,7 +169,6 @@ struct StandardColumnCheckpointState : public ColumnCheckpointState {
 public:
 	unique_ptr<BaseStatistics> GetStatistics() override {
 		D_ASSERT(global_stats);
-		global_stats->validity_stats = validity_state->GetStatistics();
 		return std::move(global_stats);
 	}
 
@@ -186,7 +185,7 @@ public:
 
 unique_ptr<ColumnCheckpointState>
 StandardColumnData::CreateCheckpointState(RowGroup &row_group, PartialBlockManager &partial_block_manager) {
-	return make_unique<StandardColumnCheckpointState>(row_group, *this, partial_block_manager);
+	return make_uniq<StandardColumnCheckpointState>(row_group, *this, partial_block_manager);
 }
 
 unique_ptr<ColumnCheckpointState> StandardColumnData::Checkpoint(RowGroup &row_group,

package/src/duckdb/src/storage/table/struct_column_data.cpp

@@ -1,6 +1,9 @@
 #include "duckdb/storage/table/struct_column_data.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
+#include "duckdb/storage/table/append_state.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 namespace duckdb {
 
@@ -38,40 +41,30 @@ idx_t StructColumnData::GetMaxEntry() {
 }
 
 void StructColumnData::InitializeScan(ColumnScanState &state) {
-	D_ASSERT(state.child_states.empty());
-
+	D_ASSERT(state.child_states.size() == sub_columns.size() + 1);
 	state.row_index = 0;
 	state.current = nullptr;
 
 	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScan(validity_state);
-	state.child_states.push_back(std::move(validity_state));
+	validity.InitializeScan(state.child_states[0]);
 
 	// initialize the sub-columns
-	for (auto &sub_column : sub_columns) {
-		ColumnScanState child_state;
-		sub_column->InitializeScan(child_state);
-		state.child_states.push_back(std::move(child_state));
+	for (idx_t i = 0; i < sub_columns.size(); i++) {
+		sub_columns[i]->InitializeScan(state.child_states[i + 1]);
 	}
 }
 
 void StructColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	D_ASSERT(state.child_states.empty());
-
+	D_ASSERT(state.child_states.size() == sub_columns.size() + 1);
 	state.row_index = row_idx;
 	state.current = nullptr;
 
 	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScanWithOffset(validity_state, row_idx);
-	state.child_states.push_back(std::move(validity_state));
+	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
 
 	// initialize the sub-columns
-	for (auto &sub_column : sub_columns) {
-		ColumnScanState child_state;
-		sub_column->InitializeScanWithOffset(child_state, row_idx);
-		state.child_states.push_back(std::move(child_state));
+	for (idx_t i = 0; i < sub_columns.size(); i++) {
+		sub_columns[i]->InitializeScanWithOffset(state.child_states[i + 1], row_idx);
 	}
 }
 
@@ -127,12 +120,12 @@ void StructColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, V
 	vector.Flatten(count);
 
 	// append the null values
-	validity.Append(*stats.validity_stats, state.child_appends[0], vector, count);
+	validity.Append(stats, state.child_appends[0], vector, count);
 
-	auto &struct_stats = (StructStatistics &)stats;
 	auto &child_entries = StructVector::GetEntries(vector);
 	for (idx_t i = 0; i < child_entries.size(); i++) {
-		sub_columns[i]->Append(*struct_stats.child_stats[i], state.child_appends[i + 1], *child_entries[i], count);
+		sub_columns[i]->Append(StructStats::GetChildStats(stats, i), state.child_appends[i + 1], *child_entries[i],
+		                       count);
 	}
 }
 
@@ -190,16 +183,18 @@ void StructColumnData::UpdateColumn(TransactionData transaction, const vector<co
 
 unique_ptr<BaseStatistics> StructColumnData::GetUpdateStatistics() {
 	// check if any child column has updates
-	auto stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
-	auto &struct_stats = (StructStatistics &)*stats;
-	stats->validity_stats = validity.GetUpdateStatistics();
+	auto stats = BaseStatistics::CreateEmpty(type);
+	auto validity_stats = validity.GetUpdateStatistics();
+	if (validity_stats) {
+		stats.Merge(*validity_stats);
+	}
 	for (idx_t i = 0; i < sub_columns.size(); i++) {
 		auto child_stats = sub_columns[i]->GetUpdateStatistics();
 		if (child_stats) {
-			struct_stats.child_stats[i] = std::move(child_stats);
+			StructStats::SetChildStats(stats, i, std::move(child_stats));
 		}
 	}
-	return stats;
+	return stats.ToUnique();
 }
 
 void StructColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
@@ -208,7 +203,7 @@ void StructColumnData::FetchRow(TransactionData transaction, ColumnFetchState &s
 	auto &child_entries = StructVector::GetEntries(result);
 	// insert any child states that are required
 	for (idx_t i = state.child_states.size(); i < child_entries.size() + 1; i++) {
-		auto child_state = make_unique<ColumnFetchState>();
+		auto child_state = make_uniq<ColumnFetchState>();
 		state.child_states.push_back(std::move(child_state));
 	}
 	// fetch the validity state
@@ -230,7 +225,7 @@ struct StructColumnCheckpointState : public ColumnCheckpointState {
 	StructColumnCheckpointState(RowGroup &row_group, ColumnData &column_data,
 	                            PartialBlockManager &partial_block_manager)
 	    : ColumnCheckpointState(row_group, column_data, partial_block_manager) {
-		global_stats = make_unique<StructStatistics>(column_data.type);
+		global_stats = StructStats::CreateEmpty(column_data.type).ToUnique();
 	}
 
 	unique_ptr<ColumnCheckpointState> validity_state;
@@ -238,14 +233,11 @@ struct StructColumnCheckpointState : public ColumnCheckpointState {
 
 public:
 	unique_ptr<BaseStatistics> GetStatistics() override {
-		auto stats = make_unique<StructStatistics>(column_data.type);
-		D_ASSERT(stats->child_stats.size() == child_states.size());
-		stats->validity_stats = validity_state->GetStatistics();
+		auto stats = StructStats::CreateEmpty(column_data.type);
 		for (idx_t i = 0; i < child_states.size(); i++) {
-			stats->child_stats[i] = child_states[i]->GetStatistics();
-			D_ASSERT(stats->child_stats[i]);
+			StructStats::SetChildStats(stats, i, child_states[i]->GetStatistics());
 		}
-		return std::move(stats);
+		return stats.ToUnique();
 	}
 
 	void WriteDataPointers(RowGroupWriter &writer) override {
@@ -264,13 +256,13 @@ public:
 
 unique_ptr<ColumnCheckpointState> StructColumnData::CreateCheckpointState(RowGroup &row_group,
                                                                           PartialBlockManager &partial_block_manager) {
-	return make_unique<StructColumnCheckpointState>(row_group, *this, partial_block_manager);
+	return make_uniq<StructColumnCheckpointState>(row_group, *this, partial_block_manager);
 }
 
 unique_ptr<ColumnCheckpointState> StructColumnData::Checkpoint(RowGroup &row_group,
                                                                PartialBlockManager &partial_block_manager,
                                                                ColumnCheckpointInfo &checkpoint_info) {
-	auto checkpoint_state = make_unique<StructColumnCheckpointState>(row_group, *this, partial_block_manager);
+	auto checkpoint_state = make_uniq<StructColumnCheckpointState>(row_group, *this, partial_block_manager);
 	checkpoint_state->validity_state = validity.Checkpoint(row_group, partial_block_manager, checkpoint_info);
 	for (auto &sub_column : sub_columns) {
 		checkpoint_state->child_states.push_back(
@@ -284,6 +276,7 @@ void StructColumnData::DeserializeColumn(Deserializer &source) {
 	for (auto &sub_column : sub_columns) {
 		sub_column->DeserializeColumn(source);
 	}
+	this->count = validity.count;
 }
 
 void StructColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, TableStorageInfo &result) {

package/src/duckdb/src/storage/table/table_statistics.cpp

@@ -6,10 +6,7 @@ namespace duckdb {
 void TableStatistics::Initialize(const vector<LogicalType> &types, PersistentTableData &data) {
 	D_ASSERT(Empty());
 
-	column_stats.reserve(data.column_stats.size());
-	for (auto &stats : data.column_stats) {
-		column_stats.push_back(make_shared<ColumnStatistics>(std::move(stats)));
-	}
+	column_stats = std::move(data.table_stats.column_stats);
 	if (column_stats.size() != types.size()) { // LCOV_EXCL_START
 		throw IOException("Table statistics column count is not aligned with table column count. Corrupt file?");
 	} // LCOV_EXCL_STOP
@@ -70,7 +67,7 @@ void TableStatistics::MergeStats(TableStatistics &other) {
 	auto l = GetLock();
 	D_ASSERT(column_stats.size() == other.column_stats.size());
 	for (idx_t i = 0; i < column_stats.size(); i++) {
-		column_stats[i]->stats->Merge(*other.column_stats[i]->stats);
+		column_stats[i]->Merge(*other.column_stats[i]);
 	}
 }
 
@@ -80,7 +77,7 @@ void TableStatistics::MergeStats(idx_t i, BaseStatistics &stats) {
 }
 
 void TableStatistics::MergeStats(TableStatisticsLock &lock, idx_t i, BaseStatistics &stats) {
-	column_stats[i]->stats->Merge(stats);
+	column_stats[i]->Statistics().Merge(stats);
 }
 
 ColumnStatistics &TableStatistics::GetStats(idx_t i) {
@@ -89,11 +86,34 @@ ColumnStatistics &TableStatistics::GetStats(idx_t i) {
 
 unique_ptr<BaseStatistics> TableStatistics::CopyStats(idx_t i) {
 	lock_guard<mutex> l(stats_lock);
-	return column_stats[i]->stats->Copy();
+	auto result = column_stats[i]->Statistics().Copy();
+	if (column_stats[i]->HasDistinctStats()) {
+		result.SetDistinctCount(column_stats[i]->DistinctStats().GetCount());
+	}
+	return result.ToUnique();
+}
+
+void TableStatistics::CopyStats(TableStatistics &other) {
+	for (auto &stats : column_stats) {
+		other.column_stats.push_back(stats->Copy());
+	}
+}
+
+void TableStatistics::Serialize(Serializer &serializer) {
+	for (auto &stats : column_stats) {
+		stats->Serialize(serializer);
+	}
+}
+
+void TableStatistics::Deserialize(Deserializer &source, ColumnList &columns) {
+	for (auto &col : columns.Physical()) {
+		auto stats = ColumnStatistics::Deserialize(source, col.GetType());
+		column_stats.push_back(std::move(stats));
+	}
 }
 
 unique_ptr<TableStatisticsLock> TableStatistics::GetLock() {
-	return make_unique<TableStatisticsLock>(stats_lock);
+	return make_uniq<TableStatisticsLock>(stats_lock);
 }
 
 bool TableStatistics::Empty() {

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -1,12 +1,13 @@
 #include "duckdb/storage/table/update_segment.hpp"
 
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
+
 #include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/transaction/update_info.hpp"
+#include "duckdb/common/printer.hpp"
+
+#include <algorithm>
 
 namespace duckdb {
 
@@ -40,7 +41,17 @@ UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
     : column_data(owner), root(std::move(other.root)), stats(std::move(other.stats)), type_size(other.type_size) {
 
 	this->heap.Move(other.heap);
-
+	// update the segment links
+	if (root) {
+		for (idx_t i = 0; i < RowGroup::ROW_GROUP_VECTOR_COUNT; i++) {
+			if (!root->info[i]) {
+				continue;
+			}
+			for (auto info = root->info[i]->info.get(); info; info = info->next) {
+				info->segment = this;
+			}
+		}
+	}
 	initialize_update_function = other.initialize_update_function;
 	merge_update_function = other.merge_update_function;
 	fetch_update_function = other.fetch_update_function;
@@ -54,12 +65,6 @@ UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
 UpdateSegment::~UpdateSegment() {
 }
 
-void UpdateSegment::ClearUpdates() {
-	stats.Reset();
-	root.reset();
-	heap.Destroy();
-}
-
 //===--------------------------------------------------------------------===//
 // Update Info Helpers
 //===--------------------------------------------------------------------===//
@@ -456,15 +461,15 @@ void UpdateSegment::FetchRow(TransactionData transaction, idx_t row_id, Vector &
 // Rollback update
 //===--------------------------------------------------------------------===//
 template <class T>
-static void RollbackUpdate(UpdateInfo *base_info, UpdateInfo *rollback_info) {
-	auto base_data = (T *)base_info->tuple_data;
-	auto rollback_data = (T *)rollback_info->tuple_data;
+static void RollbackUpdate(UpdateInfo &base_info, UpdateInfo &rollback_info) {
+	auto base_data = (T *)base_info.tuple_data;
+	auto rollback_data = (T *)rollback_info.tuple_data;
 	idx_t base_offset = 0;
-	for (idx_t i = 0; i < rollback_info->N; i++) {
-		auto id = rollback_info->tuples[i];
-		while (base_info->tuples[base_offset] < id) {
+	for (idx_t i = 0; i < rollback_info.N; i++) {
+		auto id = rollback_info.tuples[i];
+		while (base_info.tuples[base_offset] < id) {
 			base_offset++;
-			D_ASSERT(base_offset < base_info->N);
+			D_ASSERT(base_offset < base_info.N);
 		}
 		base_data[base_offset] = rollback_data[i];
 	}
@@ -506,13 +511,13 @@ static UpdateSegment::rollback_update_function_t GetRollbackUpdateFunction(Physi
 	}
 }
 
-void UpdateSegment::RollbackUpdate(UpdateInfo *info) {
+void UpdateSegment::RollbackUpdate(UpdateInfo &info) {
 	// obtain an exclusive lock
 	auto lock_handle = lock.GetExclusiveLock();
 
 	// move the data from the UpdateInfo back into the base info
-	D_ASSERT(root->info[info->vector_index]);
-	rollback_update_function(root->info[info->vector_index]->info.get(), info);
+	D_ASSERT(root->info[info.vector_index]);
+	rollback_update_function(*root->info[info.vector_index]->info, info);
 
 	// clean up the update chain
 	CleanupUpdateInternal(*lock_handle, info);
@@ -521,16 +526,16 @@ void UpdateSegment::RollbackUpdate(UpdateInfo *info) {
 //===--------------------------------------------------------------------===//
 // Cleanup Update
 //===--------------------------------------------------------------------===//
-void UpdateSegment::CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo *info) {
-	D_ASSERT(info->prev);
-	auto prev = info->prev;
-	prev->next = info->next;
+void UpdateSegment::CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo &info) {
+	D_ASSERT(info.prev);
+	auto prev = info.prev;
+	prev->next = info.next;
 	if (prev->next) {
 		prev->next->prev = prev;
 	}
 }
 
-void UpdateSegment::CleanupUpdate(UpdateInfo *info) {
+void UpdateSegment::CleanupUpdate(UpdateInfo &info) {
 	// obtain an exclusive lock
 	auto lock_handle = lock.GetExclusiveLock();
 	CleanupUpdateInternal(*lock_handle, info);
@@ -905,17 +910,17 @@ static UpdateSegment::merge_update_function_t GetMergeUpdateFunction(PhysicalTyp
 //===--------------------------------------------------------------------===//
 unique_ptr<BaseStatistics> UpdateSegment::GetStatistics() {
 	lock_guard<mutex> stats_guard(stats_lock);
-	return stats.statistics->Copy();
+	return stats.statistics.ToUnique();
 }
 
 idx_t UpdateValidityStatistics(UpdateSegment *segment, SegmentStatistics &stats, Vector &update, idx_t count,
                                SelectionVector &sel) {
 	auto &mask = FlatVector::Validity(update);
-	auto &validity = (ValidityStatistics &)*stats.statistics;
-	if (!mask.AllValid() && !validity.has_null) {
+	auto &validity = stats.statistics;
+	if (!mask.AllValid() && !validity.CanHaveNull()) {
 		for (idx_t i = 0; i < count; i++) {
 			if (!mask.RowIsValid(i)) {
-				validity.has_null = true;
+				validity.SetHasNull();
 				break;
 			}
 		}
@@ -932,7 +937,7 @@ idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics
 
 	if (mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			NumericStatistics::Update<T>(stats, update_data[i]);
+			NumericStats::Update<T>(stats.statistics, update_data[i]);
 		}
 		sel.Initialize(nullptr);
 		return count;
@@ -942,7 +947,7 @@ idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics
 		for (idx_t i = 0; i < count; i++) {
 			if (mask.RowIsValid(i)) {
 				sel.set_index(not_null_count++, i);
-				NumericStatistics::Update<T>(stats, update_data[i]);
+				NumericStats::Update<T>(stats.statistics, update_data[i]);
 			}
 		}
 		return not_null_count;
@@ -955,7 +960,7 @@ idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, V
 	auto &mask = FlatVector::Validity(update);
 	if (mask.AllValid()) {
 		for (idx_t i = 0; i < count; i++) {
-			((StringStatistics &)*stats.statistics).Update(update_data[i]);
+			StringStats::Update(stats.statistics, update_data[i]);
 			if (!update_data[i].IsInlined()) {
 				update_data[i] = segment->GetStringHeap().AddBlob(update_data[i]);
 			}
@@ -968,7 +973,7 @@ idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, V
 		for (idx_t i = 0; i < count; i++) {
 			if (mask.RowIsValid(i)) {
 				sel.set_index(not_null_count++, i);
-				((StringStatistics &)*stats.statistics).Update(update_data[i]);
+				StringStats::Update(stats.statistics, update_data[i]);
 				if (!update_data[i].IsInlined()) {
 					update_data[i] = segment->GetStringHeap().AddBlob(update_data[i]);
 				}
@@ -1098,7 +1103,7 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 
 	// create the versions for this segment, if there are none yet
 	if (!root) {
-		root = make_unique<UpdateNode>();
+		root = make_uniq<UpdateNode>();
 	}
 
 	// get the vector index based on the first id
@@ -1161,9 +1166,9 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 		node->Verify();
 	} else {
 		// there is no version info yet: create the top level update info and fill it with the updates
-		auto result = make_unique<UpdateNodeData>();
+		auto result = make_uniq<UpdateNodeData>();
 
-		result->info = make_unique<UpdateInfo>();
+		result->info = make_uniq<UpdateInfo>();
 		result->tuples = unique_ptr<sel_t[]>(new sel_t[STANDARD_VECTOR_SIZE]);
 		result->tuple_data = unique_ptr<data_t[]>(new data_t[STANDARD_VECTOR_SIZE * type_size]);
 		result->info->tuples = result->tuples.get();

package/src/duckdb/src/storage/table_index_list.cpp

@@ -9,13 +9,13 @@ void TableIndexList::AddIndex(unique_ptr<Index> index) {
 	lock_guard<mutex> lock(indexes_lock);
 	indexes.push_back(std::move(index));
 }
-void TableIndexList::RemoveIndex(Index *index) {
-	D_ASSERT(index);
+
+void TableIndexList::RemoveIndex(Index &index) {
 	lock_guard<mutex> lock(indexes_lock);
 
 	for (idx_t index_idx = 0; index_idx < indexes.size(); index_idx++) {
 		auto &index_entry = indexes[index_idx];
-		if (index_entry.get() == index) {
+		if (index_entry.get() == &index) {
 			indexes.erase(indexes.begin() + index_idx);
 			break;
 		}

package/src/duckdb/src/storage/wal_replay.cpp

@@ -24,17 +24,19 @@
 namespace duckdb {
 
 bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
-	auto initial_reader = make_unique<BufferedFileReader>(FileSystem::Get(database), path.c_str());
+	Connection con(database.GetDatabase());
+	auto initial_reader = make_uniq<BufferedFileReader>(FileSystem::Get(database), path.c_str(), con.context.get());
 	if (initial_reader->Finished()) {
 		// WAL is empty
 		return false;
 	}
-	Connection con(database.GetDatabase());
+
 	con.BeginTransaction();
 
 	// first deserialize the WAL to look for a checkpoint flag
 	// if there is a checkpoint flag, we might have already flushed the contents of the WAL to disk
 	ReplayState checkpoint_state(database, *con.context, *initial_reader);
+	initial_reader->SetCatalog(checkpoint_state.catalog);
 	checkpoint_state.deserialize_only = true;
 	try {
 		while (true) {
@@ -70,7 +72,8 @@ bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
 	}
 
 	// we need to recover from the WAL: actually set up the replay state
-	BufferedFileReader reader(FileSystem::Get(database), path.c_str());
+	BufferedFileReader reader(FileSystem::Get(database), path.c_str(), con.context.get());
+	reader.SetCatalog(checkpoint_state.catalog);
 	ReplayState state(database, *con.context, reader);
 
 	// replay the WAL
@@ -192,6 +195,7 @@ void ReplayState::ReplayEntry(WALType entry_type) {
 // Replay Table
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateTable() {
+
 	auto info = TableCatalogEntry::Deserialize(source, context);
 	if (deserialize_only) {
 		return;
@@ -278,10 +282,9 @@ void ReplayState::ReplayDropSchema() {
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateType() {
 	auto info = TypeCatalogEntry::Deserialize(source);
-	if (deserialize_only) {
+	if (Catalog::TypeExists(context, info->catalog, info->schema, info->name)) {
 		return;
 	}
-
 	catalog.CreateType(context, info.get());
 }
 
@@ -408,14 +411,14 @@ void ReplayState::ReplayCreateIndex() {
 		}
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto expressions = binder->BindCreateIndexExpressions(table, info.get());
+	auto expressions = binder->BindCreateIndexExpressions(*table, *info);
 
 	// create the empty index
 	unique_ptr<Index> index;
 	switch (info->index_type) {
 	case IndexType::ART: {
-		index = make_unique<ART>(info->column_ids, TableIOManager::Get(data_table), expressions, info->constraint_type,
-		                         data_table.db, true);
+		index = make_uniq<ART>(info->column_ids, TableIOManager::Get(data_table), expressions, info->constraint_type,
+		                       data_table.db, true);
 		break;
 	}
 	default: