duckdb 0.7.2-dev457.0 → 0.7.2-dev614.0

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -128,6 +128,8 @@ void SingleFileCheckpointReader::LoadFromStorage() {
 	con.BeginTransaction();
 	// create the MetaBlockReader to read from the storage
 	MetaBlockReader reader(block_manager, meta_block);
+	reader.SetCatalog(&catalog.GetAttached().GetCatalog());
+	reader.SetContext(con.context.get());
 	LoadCheckpoint(*con.context, reader);
 	con.Commit();
 }
@@ -395,13 +397,16 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 //===--------------------------------------------------------------------===//
 // Custom Types
 //===--------------------------------------------------------------------===//
-void CheckpointWriter::WriteType(TypeCatalogEntry &table) {
-	table.Serialize(GetMetaBlockWriter());
+void CheckpointWriter::WriteType(TypeCatalogEntry &type) {
+	type.Serialize(GetMetaBlockWriter());
 }
 
 void CheckpointReader::ReadType(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TypeCatalogEntry::Deserialize(reader);
-	catalog.CreateType(context, info.get());
+	auto catalog_entry = (TypeCatalogEntry *)catalog.CreateType(context, info.get());
+	if (info->type.id() == LogicalTypeId::ENUM) {
+		EnumType::SetCatalog(info->type, catalog_entry);
+	}
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/meta_block_reader.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/storage/meta_block_reader.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
+#include "duckdb/main/connection_manager.hpp"
+#include "duckdb/main/database.hpp"
 
 #include <cstring>
 
@@ -34,6 +36,16 @@ void MetaBlockReader::ReadData(data_ptr_t buffer, idx_t read_size) {
 	offset += read_size;
 }
 
+ClientContext &MetaBlockReader::GetContext() {
+	if (!context) {
+		throw InternalException("Meta Block Reader is missing context");
+	}
+	return *context;
+}
+Catalog *MetaBlockReader::GetCatalog() {
+	return catalog;
+}
+
 void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	auto &buffer_manager = block_manager.buffer_manager;
 
@@ -52,4 +64,14 @@ void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	offset = sizeof(block_id_t);
 }
 
+void MetaBlockReader::SetCatalog(Catalog *catalog_p) {
+	D_ASSERT(!catalog);
+	catalog = catalog_p;
+}
+
+void MetaBlockReader::SetContext(ClientContext *context_p) {
+	D_ASSERT(!context);
+	context = context_p;
+}
+
 } // namespace duckdb

package/src/duckdb/src/storage/statistics/list_stats.cpp

@@ -34,12 +34,16 @@ void ListStats::Copy(BaseStatistics &stats, const BaseStatistics &other) {
 }
 
 const BaseStatistics &ListStats::GetChildStats(const BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::LIST_STATS);
+	if (stats.GetStatsType() != StatisticsType::LIST_STATS) {
+		throw InternalException("ListStats::GetChildStats called on stats that is not a list");
+	}
 	D_ASSERT(stats.child_stats);
 	return stats.child_stats[0];
 }
 BaseStatistics &ListStats::GetChildStats(BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::LIST_STATS);
+	if (stats.GetStatsType() != StatisticsType::LIST_STATS) {
+		throw InternalException("ListStats::GetChildStats called on stats that is not a list");
+	}
 	D_ASSERT(stats.child_stats);
 	return stats.child_stats[0];
 }

package/src/duckdb/src/storage/statistics/struct_stats.cpp

@@ -34,7 +34,9 @@ BaseStatistics StructStats::CreateEmpty(LogicalType type) {
 }
 
 const BaseStatistics *StructStats::GetChildStats(const BaseStatistics &stats) {
-	D_ASSERT(stats.GetStatsType() == StatisticsType::STRUCT_STATS);
+	if (stats.GetStatsType() != StatisticsType::STRUCT_STATS) {
+		throw InternalException("Calling StructStats::GetChildStats on stats that is not a struct");
+	}
 	return stats.child_stats.get();
 }
 

package/src/duckdb/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 46;
+const uint64_t VERSION_NUMBER = 47;
 
 struct StorageVersionInfo {
 	const char *version_name;

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

@@ -38,7 +38,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;
@@ -52,12 +62,6 @@ UpdateSegment::UpdateSegment(UpdateSegment &other, ColumnData &owner)
 UpdateSegment::~UpdateSegment() {
 }
 
-void UpdateSegment::ClearUpdates() {
-	stats.statistics.Copy(BaseStatistics::CreateEmpty(stats.statistics.GetType()));
-	root.reset();
-	heap.Destroy();
-}
-
 //===--------------------------------------------------------------------===//
 // Update Info Helpers
 //===--------------------------------------------------------------------===//

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_unique<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->catalog = &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.catalog = &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());
 }
 

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

@@ -281,12 +281,12 @@ void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column
 //===--------------------------------------------------------------------===//
 // Write ALTER Statement
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteAlter(AlterInfo &info) {
+void WriteAheadLog::WriteAlter(data_ptr_t ptr, idx_t data_size) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::ALTER_INFO);
-	info.Serialize(*writer);
+	writer->WriteData(ptr, data_size);
 }
 
 //===--------------------------------------------------------------------===//

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

@@ -46,12 +46,16 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 			// ALTER TABLE statement, read the extra data after the entry
 			auto extra_data_size = Load<idx_t>(dataptr);
 			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
-			// deserialize it
+
 			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
-			// write the alter table in the log
-			table_entry->CommitAlter(*info);
-			log->WriteAlter(*info);
+			string column_name = source.Read<string>();
+
+			if (!column_name.empty()) {
+				// write the alter table in the log
+				table_entry->CommitAlter(column_name);
+			}
+
+			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
 			// CREATE TABLE statement
 			log->WriteCreateTable((TableCatalogEntry *)parent);
@@ -71,9 +75,9 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 			auto extra_data = (data_ptr_t)(dataptr + sizeof(idx_t));
 			// deserialize it
 			BufferedDeserializer source(extra_data, extra_data_size);
-			auto info = AlterInfo::Deserialize(source);
+			string column_name = source.Read<string>();
 			// write the alter table in the log
-			log->WriteAlter(*info);
+			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
 			log->WriteCreateView((ViewCatalogEntry *)parent);
 		}