duckdb 0.7.2-dev1457.0 → 0.7.2-dev1533.0

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

@@ -5,7 +5,6 @@
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/common/serializer/buffered_deserializer.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/table/chunk_info.hpp"
 #include "duckdb/storage/table/column_data.hpp"
@@ -16,6 +15,7 @@
 #include "duckdb/transaction/delete_info.hpp"
 #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"
 
 namespace duckdb {
 
@@ -31,18 +31,18 @@ void CommitState::SwitchTable(DataTableInfo *table_info, UndoFlags new_op) {
 	}
 }
 
-void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
-	if (entry->temporary || entry->parent->temporary) {
+void CommitState::WriteCatalogEntry(CatalogEntry &entry, data_ptr_t dataptr) {
+	if (entry.temporary || entry.parent->temporary) {
 		return;
 	}
 	D_ASSERT(log);
 	// look at the type of the parent entry
-	auto parent = entry->parent;
+	auto parent = entry.parent;
 	switch (parent->type) {
 	case CatalogType::TABLE_ENTRY:
-		if (entry->type == CatalogType::TABLE_ENTRY) {
-			auto table_entry = (DuckTableEntry *)entry;
-			D_ASSERT(table_entry->IsDuckTable());
+		if (entry.type == CatalogType::TABLE_ENTRY) {
+			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_t)(dataptr + sizeof(idx_t));
@@ -52,24 +52,24 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 
 			if (!column_name.empty()) {
 				// write the alter table in the log
-				table_entry->CommitAlter(column_name);
+				table_entry.CommitAlter(column_name);
 			}
 
 			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
 			// CREATE TABLE statement
-			log->WriteCreateTable((TableCatalogEntry *)parent);
+			log->WriteCreateTable(parent->Cast<TableCatalogEntry>());
 		}
 		break;
 	case CatalogType::SCHEMA_ENTRY:
-		if (entry->type == CatalogType::SCHEMA_ENTRY) {
+		if (entry.type == CatalogType::SCHEMA_ENTRY) {
 			// ALTER TABLE statement, skip it
 			return;
 		}
-		log->WriteCreateSchema((SchemaCatalogEntry *)parent);
+		log->WriteCreateSchema(parent->Cast<SchemaCatalogEntry>());
 		break;
 	case CatalogType::VIEW_ENTRY:
-		if (entry->type == CatalogType::VIEW_ENTRY) {
+		if (entry.type == CatalogType::VIEW_ENTRY) {
 			// 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));
@@ -79,53 +79,53 @@ void CommitState::WriteCatalogEntry(CatalogEntry *entry, data_ptr_t dataptr) {
 			// write the alter table in the log
 			log->WriteAlter(source.ptr, source.endptr - source.ptr);
 		} else {
-			log->WriteCreateView((ViewCatalogEntry *)parent);
+			log->WriteCreateView(parent->Cast<ViewCatalogEntry>());
 		}
 		break;
 	case CatalogType::SEQUENCE_ENTRY:
-		log->WriteCreateSequence((SequenceCatalogEntry *)parent);
+		log->WriteCreateSequence(parent->Cast<SequenceCatalogEntry>());
 		break;
 	case CatalogType::MACRO_ENTRY:
-		log->WriteCreateMacro((ScalarMacroCatalogEntry *)parent);
+		log->WriteCreateMacro(parent->Cast<ScalarMacroCatalogEntry>());
 		break;
 	case CatalogType::TABLE_MACRO_ENTRY:
-		log->WriteCreateTableMacro((TableMacroCatalogEntry *)parent);
+		log->WriteCreateTableMacro(parent->Cast<TableMacroCatalogEntry>());
 		break;
 	case CatalogType::INDEX_ENTRY:
-		log->WriteCreateIndex((IndexCatalogEntry *)parent);
+		log->WriteCreateIndex(parent->Cast<IndexCatalogEntry>());
 		break;
 	case CatalogType::TYPE_ENTRY:
-		log->WriteCreateType((TypeCatalogEntry *)parent);
+		log->WriteCreateType(parent->Cast<TypeCatalogEntry>());
 		break;
 	case CatalogType::DELETED_ENTRY:
-		switch (entry->type) {
+		switch (entry.type) {
 		case CatalogType::TABLE_ENTRY: {
-			auto table_entry = (DuckTableEntry *)entry;
-			D_ASSERT(table_entry->IsDuckTable());
-			table_entry->CommitDrop();
+			auto &table_entry = entry.Cast<DuckTableEntry>();
+			D_ASSERT(table_entry.IsDuckTable());
+			table_entry.CommitDrop();
 			log->WriteDropTable(table_entry);
 			break;
 		}
 		case CatalogType::SCHEMA_ENTRY:
-			log->WriteDropSchema((SchemaCatalogEntry *)entry);
+			log->WriteDropSchema(entry.Cast<SchemaCatalogEntry>());
 			break;
 		case CatalogType::VIEW_ENTRY:
-			log->WriteDropView((ViewCatalogEntry *)entry);
+			log->WriteDropView(entry.Cast<ViewCatalogEntry>());
 			break;
 		case CatalogType::SEQUENCE_ENTRY:
-			log->WriteDropSequence((SequenceCatalogEntry *)entry);
+			log->WriteDropSequence(entry.Cast<SequenceCatalogEntry>());
 			break;
 		case CatalogType::MACRO_ENTRY:
-			log->WriteDropMacro((ScalarMacroCatalogEntry *)entry);
+			log->WriteDropMacro(entry.Cast<ScalarMacroCatalogEntry>());
 			break;
 		case CatalogType::TABLE_MACRO_ENTRY:
-			log->WriteDropTableMacro((TableMacroCatalogEntry *)entry);
+			log->WriteDropTableMacro(entry.Cast<TableMacroCatalogEntry>());
 			break;
 		case CatalogType::TYPE_ENTRY:
-			log->WriteDropType((TypeCatalogEntry *)entry);
+			log->WriteDropType(entry.Cast<TypeCatalogEntry>());
 			break;
 		case CatalogType::INDEX_ENTRY:
-			log->WriteDropIndex((IndexCatalogEntry *)entry);
+			log->WriteDropIndex(entry.Cast<IndexCatalogEntry>());
 			break;
 		case CatalogType::PREPARED_STATEMENT:
 		case CatalogType::SCALAR_FUNCTION_ENTRY:
@@ -234,15 +234,15 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		D_ASSERT(catalog->IsDuckCatalog());
 
 		// Grab a write lock on the catalog
-		auto &duck_catalog = (DuckCatalog &)*catalog;
+		auto &duck_catalog = catalog->Cast<DuckCatalog>();
 		lock_guard<mutex> write_lock(duck_catalog.GetWriteLock());
-		catalog_entry->set->UpdateTimestamp(catalog_entry->parent, commit_id);
+		catalog_entry->set->UpdateTimestamp(*catalog_entry->parent, commit_id);
 		if (catalog_entry->name != catalog_entry->parent->name) {
-			catalog_entry->set->UpdateTimestamp(catalog_entry, commit_id);
+			catalog_entry->set->UpdateTimestamp(*catalog_entry, commit_id);
 		}
 		if (HAS_LOG) {
 			// push the catalog update to the WAL
-			WriteCatalogEntry(catalog_entry, data + sizeof(CatalogEntry *));
+			WriteCatalogEntry(*catalog_entry, data + sizeof(CatalogEntry *));
 		}
 		break;
 	}
@@ -287,9 +287,9 @@ void CommitState::RevertCommit(UndoFlags type, data_ptr_t data) {
 		// set the commit timestamp of the catalog entry to the given id
 		auto catalog_entry = Load<CatalogEntry *>(data);
 		D_ASSERT(catalog_entry->parent);
-		catalog_entry->set->UpdateTimestamp(catalog_entry->parent, transaction_id);
+		catalog_entry->set->UpdateTimestamp(*catalog_entry->parent, transaction_id);
 		if (catalog_entry->name != catalog_entry->parent->name) {
-			catalog_entry->set->UpdateTimestamp(catalog_entry, transaction_id);
+			catalog_entry->set->UpdateTimestamp(*catalog_entry, transaction_id);
 		}
 		break;
 	}

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

@@ -130,7 +130,7 @@ string DuckTransaction::Commit(AttachedDatabase &db, transaction_t commit_id, bo
 		if (log) {
 			// commit any sequences that were used to the WAL
 			for (auto &entry : sequence_usage) {
-				log->WriteSequenceValue(entry.first, entry.second);
+				log->WriteSequenceValue(*entry.first, entry.second);
 			}
 		}
 		if (storage_commit_state) {

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

@@ -18,7 +18,7 @@ void RollbackState::RollbackEntry(UndoFlags type, data_ptr_t data) {
 		// undo this catalog entry
 		auto catalog_entry = Load<CatalogEntry *>(data);
 		D_ASSERT(catalog_entry->set);
-		catalog_entry->set->Undo(catalog_entry);
+		catalog_entry->set->Undo(*catalog_entry);
 		break;
 	}
 	case UndoFlags::INSERT_TUPLE: {

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

@@ -8,7 +8,7 @@ DeserializedStatementVerifier::DeserializedStatementVerifier(unique_ptr<SQLState
 }
 
 unique_ptr<StatementVerifier> DeserializedStatementVerifier::Create(const SQLStatement &statement) {
-	auto &select_stmt = (SelectStatement &)statement;
+	auto &select_stmt = statement.Cast<SelectStatement>();
 	BufferedSerializer serializer;
 	select_stmt.Serialize(serializer);
 	BufferedDeserializer source(serializer);