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

package/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp

@@ -58,8 +58,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoin(unique_
 bool SubqueryDependentFilter(Expression *expr) {
 	if (expr->expression_class == ExpressionClass::BOUND_CONJUNCTION &&
 	    expr->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
-		auto bound_conjuction = (BoundConjunctionExpression *)expr;
-		for (auto &child : bound_conjuction->children) {
+		auto &bound_conjuction = expr->Cast<BoundConjunctionExpression>();
+		for (auto &child : bound_conjuction.children) {
 			if (SubqueryDependentFilter(child.get())) {
 				return true;
 			}
@@ -114,7 +114,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
 		// now we add all the columns of the delim_scan to the projection list
-		auto proj = (LogicalProjection *)plan.get();
+		auto &proj = plan->Cast<LogicalProjection>();
 		for (idx_t i = 0; i < correlated_columns.size(); i++) {
 			auto &col = correlated_columns[i];
 			auto colref = make_uniq<BoundColumnRefExpression>(
@@ -122,13 +122,13 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			plan->expressions.push_back(std::move(colref));
 		}
 
-		base_binding.table_index = proj->table_index;
+		base_binding.table_index = proj.table_index;
 		this->delim_offset = base_binding.column_index = plan->expressions.size() - correlated_columns.size();
 		this->data_offset = 0;
 		return plan;
 	}
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: {
-		auto &aggr = (LogicalAggregate &)*plan;
+		auto &aggr = plan->Cast<LogicalAggregate>();
 		// aggregate and group by
 		// first we flatten the dependent join in the child of the projection
 		for (auto &expr : plan->expressions) {
@@ -181,8 +181,8 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			// NULL or a value
 			unique_ptr<LogicalComparisonJoin> join = make_uniq<LogicalComparisonJoin>(JoinType::INNER);
 			for (auto &aggr_exp : aggr.expressions) {
-				auto b_aggr_exp = (BoundAggregateExpression *)aggr_exp.get();
-				if (!b_aggr_exp->PropagatesNullValues() || any_join || !parent_propagate_null_values) {
+				auto &b_aggr_exp = aggr_exp->Cast<BoundAggregateExpression>();
+				if (!b_aggr_exp.PropagatesNullValues() || any_join || !parent_propagate_null_values) {
 					join = make_uniq<LogicalComparisonJoin>(JoinType::LEFT);
 					break;
 				}
@@ -204,9 +204,9 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 			// ELSE COUNT(*) END
 			for (idx_t i = 0; i < aggr.expressions.size(); i++) {
 				D_ASSERT(aggr.expressions[i]->GetExpressionClass() == ExpressionClass::BOUND_AGGREGATE);
-				auto bound = (BoundAggregateExpression *)&*aggr.expressions[i];
+				auto &bound = aggr.expressions[i]->Cast<BoundAggregateExpression>();
 				vector<LogicalType> arguments;
-				if (bound->function == CountFun::GetFunction() || bound->function == CountStarFun::GetFunction()) {
+				if (bound.function == CountFun::GetFunction() || bound.function == CountStarFun::GetFunction()) {
 					// have to replace this ColumnBinding with the CASE expression
 					replacement_map[ColumnBinding(aggr.aggregate_index, i)] = i;
 				}
@@ -264,7 +264,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = (LogicalJoin &)*plan;
+		auto &join = plan->Cast<LogicalJoin>();
 		D_ASSERT(plan->children.size() == 2);
 		// check the correlated expressions in the children of the join
 		bool left_has_correlation = has_correlated_expressions.find(plan->children[0].get())->second;
@@ -342,10 +342,10 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 				cond.right = std::move(right);
 				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 
-				auto &comparison_join = (LogicalComparisonJoin &)join;
+				auto &comparison_join = join.Cast<LogicalComparisonJoin>();
 				comparison_join.conditions.push_back(std::move(cond));
 			} else {
-				auto &any_join = (LogicalAnyJoin &)join;
+				auto &any_join = join.Cast<LogicalAnyJoin>();
 				auto comparison = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
 				                                                       std::move(left), std::move(right));
 				auto conjunction = make_uniq<BoundConjunctionExpression>(
@@ -359,7 +359,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		return plan;
 	}
 	case LogicalOperatorType::LOGICAL_LIMIT: {
-		auto &limit = (LogicalLimit &)*plan;
+		auto &limit = plan->Cast<LogicalLimit>();
 		if (limit.limit || limit.offset) {
 			throw ParserException("Non-constant limit or offset not supported in correlated subquery");
 		}
@@ -435,13 +435,13 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		throw ParserException("Limit percent operator not supported in correlated subquery");
 	}
 	case LogicalOperatorType::LOGICAL_WINDOW: {
-		auto &window = (LogicalWindow &)*plan;
+		auto &window = plan->Cast<LogicalWindow>();
 		// push into children
 		plan->children[0] = PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values);
 		// add the correlated columns to the PARTITION BY clauses in the Window
 		for (auto &expr : window.expressions) {
 			D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_WINDOW);
-			auto &w = (BoundWindowExpression &)*expr;
+			auto &w = expr->Cast<BoundWindowExpression>();
 			for (idx_t i = 0; i < correlated_columns.size(); i++) {
 				w.partitions.push_back(make_uniq<BoundColumnRefExpression>(
 				    correlated_columns[i].type,
@@ -453,7 +453,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:
 	case LogicalOperatorType::LOGICAL_UNION: {
-		auto &setop = (LogicalSetOperation &)*plan;
+		auto &setop = plan->Cast<LogicalSetOperation>();
 		// set operator, push into both children
 #ifdef DEBUG
 		plan->children[0]->ResolveOperatorTypes();
@@ -475,7 +475,7 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		return plan;
 	}
 	case LogicalOperatorType::LOGICAL_DISTINCT: {
-		auto &distinct = (LogicalDistinct &)*plan;
+		auto &distinct = plan->Cast<LogicalDistinct>();
 		// push down into child
 		distinct.children[0] = PushDownDependentJoin(std::move(distinct.children[0]));
 		// add all correlated columns to the distinct targets
@@ -493,26 +493,28 @@ unique_ptr<LogicalOperator> FlattenDependentJoins::PushDownDependentJoinInternal
 		RewriteCorrelatedExpressions rewriter(base_binding, correlated_map);
 		rewriter.VisitOperator(*plan);
 		// now we add all the correlated columns to each of the expressions of the expression scan
-		auto expr_get = (LogicalExpressionGet *)plan.get();
+		auto &expr_get = plan->Cast<LogicalExpressionGet>();
 		for (idx_t i = 0; i < correlated_columns.size(); i++) {
-			for (auto &expr_list : expr_get->expressions) {
+			for (auto &expr_list : expr_get.expressions) {
 				auto colref = make_uniq<BoundColumnRefExpression>(
 				    correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i));
 				expr_list.push_back(std::move(colref));
 			}
-			expr_get->expr_types.push_back(correlated_columns[i].type);
+			expr_get.expr_types.push_back(correlated_columns[i].type);
 		}
 
-		base_binding.table_index = expr_get->table_index;
-		this->delim_offset = base_binding.column_index = expr_get->expr_types.size() - correlated_columns.size();
+		base_binding.table_index = expr_get.table_index;
+		this->delim_offset = base_binding.column_index = expr_get.expr_types.size() - correlated_columns.size();
 		this->data_offset = 0;
 		return plan;
 	}
+	case LogicalOperatorType::LOGICAL_PIVOT:
+		throw BinderException("PIVOT is not supported in correlated subqueries yet");
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
 		plan->children[0] = PushDownDependentJoin(std::move(plan->children[0]));
 		return plan;
 	case LogicalOperatorType::LOGICAL_GET: {
-		auto &get = (LogicalGet &)*plan;
+		auto &get = plan->Cast<LogicalGet>();
 		if (get.children.size() != 1) {
 			throw InternalException("Flatten dependent joins - logical get encountered without children");
 		}

package/src/duckdb/src/planner/subquery/rewrite_correlated_expressions.cpp

@@ -70,7 +70,7 @@ void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelated
 void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelatedExpressions(Expression &child) {
 	if (child.type == ExpressionType::BOUND_COLUMN_REF) {
 		// bound column reference
-		auto &bound_colref = (BoundColumnRefExpression &)child;
+		auto &bound_colref = child.Cast<BoundColumnRefExpression>();
 		if (bound_colref.depth == 0) {
 			// not a correlated column, ignore
 			return;
@@ -87,7 +87,7 @@ void RewriteCorrelatedExpressions::RewriteCorrelatedRecursive::RewriteCorrelated
 	} else if (child.type == ExpressionType::SUBQUERY) {
 		// we encountered another subquery: rewrite recursively
 		D_ASSERT(child.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY);
-		auto &bound_subquery = (BoundSubqueryExpression &)child;
+		auto &bound_subquery = child.Cast<BoundSubqueryExpression>();
 		RewriteCorrelatedRecursive rewrite(bound_subquery, base_binding, correlated_map);
 		rewrite.RewriteCorrelatedSubquery(bound_subquery);
 	}

package/src/duckdb/src/planner/table_binding.cpp

@@ -100,7 +100,7 @@ TableBinding::TableBinding(const string &alias, vector<LogicalType> types_p, vec
 static void ReplaceAliases(ParsedExpression &expr, const ColumnList &list,
                            const unordered_map<idx_t, string> &alias_map) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
+		auto &colref = expr.Cast<ColumnRefExpression>();
 		D_ASSERT(!colref.IsQualified());
 		auto &col_names = colref.column_names;
 		D_ASSERT(col_names.size() == 1);
@@ -114,7 +114,7 @@ static void ReplaceAliases(ParsedExpression &expr, const ColumnList &list,
 
 static void BakeTableName(ParsedExpression &expr, const string &table_name) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
+		auto &colref = expr.Cast<ColumnRefExpression>();
 		D_ASSERT(!colref.IsQualified());
 		auto &col_names = colref.column_names;
 		col_names.insert(col_names.begin(), table_name);
@@ -128,18 +128,18 @@ unique_ptr<ParsedExpression> TableBinding::ExpandGeneratedColumn(const string &c
 	D_ASSERT(catalog_entry); // Should only be called on a TableBinding
 
 	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto table_entry = (TableCatalogEntry *)catalog_entry;
+	auto &table_entry = catalog_entry->Cast<TableCatalogEntry>();
 
 	// Get the index of the generated column
 	auto column_index = GetBindingIndex(column_name);
-	D_ASSERT(table_entry->GetColumn(LogicalIndex(column_index)).Generated());
+	D_ASSERT(table_entry.GetColumn(LogicalIndex(column_index)).Generated());
 	// Get a copy of the generated column
-	auto expression = table_entry->GetColumn(LogicalIndex(column_index)).GeneratedExpression().Copy();
+	auto expression = table_entry.GetColumn(LogicalIndex(column_index)).GeneratedExpression().Copy();
 	unordered_map<idx_t, string> alias_map;
 	for (auto &entry : name_map) {
 		alias_map[entry.second] = entry.first;
 	}
-	ReplaceAliases(*expression, table_entry->GetColumns(), alias_map);
+	ReplaceAliases(*expression, table_entry.GetColumns(), alias_map);
 	BakeTableName(*expression, alias);
 	return (expression);
 }
@@ -191,8 +191,8 @@ BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	if (entry && column_index != COLUMN_IDENTIFIER_ROW_ID) {
 		D_ASSERT(entry->type == CatalogType::TABLE_ENTRY);
 		// Either there is no table, or the columns category has to be standard
-		auto table_entry = (TableCatalogEntry *)entry;
-		auto &column_entry = table_entry->GetColumn(LogicalIndex(column_index));
+		auto &table_entry = entry->Cast<TableCatalogEntry>();
+		auto &column_entry = table_entry.GetColumn(LogicalIndex(column_index));
 		(void)table_entry;
 		(void)column_entry;
 		D_ASSERT(column_entry.Category() == TableColumnType::STANDARD);

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -9,7 +9,7 @@
 
 namespace duckdb {
 
-TableDataWriter::TableDataWriter(TableCatalogEntry &table_p) : table((DuckTableEntry &)table_p) {
+TableDataWriter::TableDataWriter(TableCatalogEntry &table_p) : table(table_p.Cast<DuckTableEntry>()) {
 	D_ASSERT(table_p.IsDuckTable());
 }
 

package/src/duckdb/src/storage/data_table.cpp

@@ -366,7 +366,8 @@ idx_t LocateErrorIndex(bool is_append, const ManagedSelection &matches) {
 
 	D_ASSERT(failed_index != DConstants::INVALID_INDEX);
 	D_ASSERT(index->type == IndexType::ART);
-	auto &art_index = (ART &)*index;
+	auto &art_index = index->Cast<ART>();
+	;
 	auto key_name = art_index.GenerateErrorKeyName(input, failed_index);
 	auto exception_msg = art_index.GenerateConstraintErrorMessage(verify_type, key_name);
 	throw ConstraintException(exception_msg);

package/src/duckdb/src/storage/index.cpp

@@ -48,15 +48,14 @@ void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
 	Delete(state, entries, row_identifiers);
 }
 
-bool Index::MergeIndexes(Index *other_index) {
-
+bool Index::MergeIndexes(Index &other_index) {
 	IndexLock state;
 	InitializeLock(state);
 
 	switch (this->type) {
 	case IndexType::ART: {
-		auto art = (ART *)this;
-		return art->MergeIndexes(state, other_index);
+		auto &art = Cast<ART>();
+		return art.MergeIndexes(state, other_index);
 	}
 	default:
 		throw InternalException("Unimplemented index type for merge");
@@ -69,7 +68,7 @@ void Index::ExecuteExpressions(DataChunk &input, DataChunk &result) {
 
 unique_ptr<Expression> Index::BindExpression(unique_ptr<Expression> expr) {
 	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &bound_colref = (BoundColumnRefExpression &)*expr;
+		auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 		return make_uniq<BoundReferenceExpression>(expr->return_type, column_ids[bound_colref.binding.column_index]);
 	}
 	ExpressionIterator::EnumerateChildren(

package/src/duckdb/src/storage/local_storage.cpp

@@ -120,7 +120,8 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 	row_groups->InitializeEmpty();
 	table.info->indexes.Scan([&](Index &index) {
 		D_ASSERT(index.type == IndexType::ART);
-		auto &art = (ART &)index;
+		auto &art = index.Cast<ART>();
+		;
 		if (art.constraint_type != IndexConstraintType::NONE) {
 			// unique index: create a local ART index that maintains the same unique constraint
 			vector<unique_ptr<Expression>> unbound_expressions;

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

@@ -705,7 +705,7 @@ void RowGroupCollection::VerifyNewConstraint(DataTable &parent, const BoundConst
 		return;
 	}
 	// scan the original table, check if there's any null value
-	auto &not_null_constraint = (BoundNotNullConstraint &)constraint;
+	auto &not_null_constraint = constraint.Cast<BoundNotNullConstraint>();
 	vector<LogicalType> scan_types;
 	auto physical_index = not_null_constraint.index.index;
 	D_ASSERT(physical_index < types.size());

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

@@ -56,64 +56,64 @@ void WriteAheadLog::WriteCheckpoint(block_id_t meta_block) {
 //===--------------------------------------------------------------------===//
 // CREATE TABLE
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateTable(TableCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateTable(const TableCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_TABLE);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
 //===--------------------------------------------------------------------===//
 // DROP TABLE
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropTable(TableCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // CREATE SCHEMA
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSchema(SchemaCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_SCHEMA);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // SEQUENCES
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateSequence(SequenceCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateSequence(const SequenceCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_SEQUENCE);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropSequence(SequenceCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
-void WriteAheadLog::WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValue val) {
+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->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 	writer->Write<uint64_t>(val.usage_count);
 	writer->Write<int64_t>(val.counter);
 }
@@ -121,109 +121,109 @@ void WriteAheadLog::WriteSequenceValue(SequenceCatalogEntry *entry, SequenceValu
 //===--------------------------------------------------------------------===//
 // MACROS
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateMacro(ScalarMacroCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateMacro(const ScalarMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_MACRO);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropMacro(ScalarMacroCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
-void WriteAheadLog::WriteCreateTableMacro(TableMacroCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateTableMacro(const TableMacroCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_TABLE_MACRO);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropTableMacro(TableMacroCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // Indexes
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateIndex(IndexCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateIndex(const IndexCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_INDEX);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropIndex(IndexCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // Custom Types
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateType(TypeCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateType(const TypeCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_TYPE);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropType(TypeCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // VIEWS
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteCreateView(ViewCatalogEntry *entry) {
+void WriteAheadLog::WriteCreateView(const ViewCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::CREATE_VIEW);
-	entry->Serialize(*writer);
+	entry.Serialize(*writer);
 }
 
-void WriteAheadLog::WriteDropView(ViewCatalogEntry *entry) {
+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);
+	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//
 // DROP SCHEMA
 //===--------------------------------------------------------------------===//
-void WriteAheadLog::WriteDropSchema(SchemaCatalogEntry *entry) {
+void WriteAheadLog::WriteDropSchema(const SchemaCatalogEntry &entry) {
 	if (skip_writing) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_SCHEMA);
-	writer->WriteString(entry->name);
+	writer->WriteString(entry.name);
 }
 
 //===--------------------------------------------------------------------===//