duckdb 0.7.2-dev402.0 → 0.7.2-dev586.0

package/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp

@@ -19,8 +19,7 @@
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
 
 namespace duckdb {
 
@@ -136,31 +135,39 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			auto bound_order = make_unique<BoundOrderModifier>();
 			auto &config = DBConfig::GetConfig(context);
 			D_ASSERT(!order.orders.empty());
-			if (order.orders[0].expression->type == ExpressionType::STAR) {
-				// ORDER BY ALL
-				// replace the order list with the maximum order by count
-				D_ASSERT(order.orders.size() == 1);
-				auto order_type = order.orders[0].type;
-				auto null_order = order.orders[0].null_order;
-
-				vector<OrderByNode> new_orders;
-				for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
-					new_orders.emplace_back(order_type, null_order,
-					                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
+			auto &order_binders = order_binder.GetBinders();
+			if (order.orders.size() == 1 && order.orders[0].expression->type == ExpressionType::STAR) {
+				auto star = (StarExpression *)order.orders[0].expression.get();
+				if (star->exclude_list.empty() && star->replace_list.empty() && !star->expr) {
+					// ORDER BY ALL
+					// replace the order list with the all elements in the SELECT list
+					auto order_type = order.orders[0].type;
+					auto null_order = order.orders[0].null_order;
+
+					vector<OrderByNode> new_orders;
+					for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
+						new_orders.emplace_back(order_type, null_order,
+						                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
+					}
+					order.orders = std::move(new_orders);
 				}
-				order.orders = std::move(new_orders);
 			}
 			for (auto &order_node : order.orders) {
-				auto order_expression = BindOrderExpression(order_binder, std::move(order_node.expression));
-				if (!order_expression) {
-					continue;
-				}
+				vector<unique_ptr<ParsedExpression>> order_list;
+				order_binders[0]->ExpandStarExpression(std::move(order_node.expression), order_list);
+
 				auto type =
 				    order_node.type == OrderType::ORDER_DEFAULT ? config.options.default_order_type : order_node.type;
 				auto null_order = order_node.null_order == OrderByNullType::ORDER_DEFAULT
 				                      ? config.options.default_null_order
 				                      : order_node.null_order;
-				bound_order->orders.emplace_back(type, null_order, std::move(order_expression));
+				for (auto &order_expr : order_list) {
+					auto bound_expr = BindOrderExpression(order_binder, std::move(order_expr));
+					if (!bound_expr) {
+						continue;
+					}
+					bound_order->orders.emplace_back(type, null_order, std::move(bound_expr));
+				}
 			}
 			if (!bound_order->orders.empty()) {
 				bound_modifier = std::move(bound_order);
@@ -264,69 +271,6 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 	}
 }
 
-bool Binder::FindStarExpression(ParsedExpression &expr, StarExpression **star) {
-	if (expr.GetExpressionClass() == ExpressionClass::STAR) {
-		auto current_star = (StarExpression *)&expr;
-		if (*star) {
-			// we can have multiple
-			if (!StarExpression::Equal(*star, current_star)) {
-				throw BinderException(
-				    FormatError(expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
-			}
-			return true;
-		}
-		*star = current_star;
-		return true;
-	}
-	bool has_star = false;
-	ParsedExpressionIterator::EnumerateChildren(expr, [&](ParsedExpression &child_expr) {
-		if (FindStarExpression(child_expr, star)) {
-			has_star = true;
-		}
-	});
-	return has_star;
-}
-
-void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement) {
-	D_ASSERT(expr);
-	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
-		D_ASSERT(replacement);
-		expr = replacement->Copy();
-		return;
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceStarExpression(child_expr, replacement); });
-}
-
-void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
-                                  vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	StarExpression *star = nullptr;
-	if (!FindStarExpression(*expr, &star)) {
-		// no star expression: add it as-is
-		D_ASSERT(!star);
-		new_select_list.push_back(std::move(expr));
-		return;
-	}
-	D_ASSERT(star);
-	vector<unique_ptr<ParsedExpression>> star_list;
-	// we have star expressions! expand the list of star expressions
-	bind_context.GenerateAllColumnExpressions(*star, star_list);
-
-	// now perform the replacement
-	for (idx_t i = 0; i < star_list.size(); i++) {
-		auto new_expr = expr->Copy();
-		ReplaceStarExpression(new_expr, star_list[i]);
-		new_select_list.push_back(std::move(new_expr));
-	}
-}
-
-void Binder::ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
-                                   vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	for (auto &select_element : select_list) {
-		ExpandStarExpression(std::move(select_element), new_select_list);
-	}
-}
-
 unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	D_ASSERT(statement.from_table);
 	// first bind the FROM table statement
@@ -335,6 +279,34 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	return BindSelectNode(statement, std::move(from_table));
 }
 
+void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
+	// expand any expressions in the upper AND recursively
+	if (expr->type == ExpressionType::CONJUNCTION_AND) {
+		auto &conj = (ConjunctionExpression &)*expr;
+		for (auto &child : conj.children) {
+			BindWhereStarExpression(child);
+		}
+		return;
+	}
+	if (expr->type == ExpressionType::STAR) {
+		auto &star = (StarExpression &)*expr;
+		if (!star.columns) {
+			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
+		}
+	}
+	// expand the stars for this expression
+	vector<unique_ptr<ParsedExpression>> new_conditions;
+	ExpandStarExpression(std::move(expr), new_conditions);
+
+	// set up an AND conjunction between the expanded conditions
+	expr = std::move(new_conditions[0]);
+	for (idx_t i = 1; i < new_conditions.size(); i++) {
+		auto and_conj = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+		                                                   std::move(new_conditions[i]));
+		expr = std::move(and_conj);
+	}
+}
+
 unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table) {
 	D_ASSERT(from_table);
 	D_ASSERT(!statement.from_table);
@@ -381,6 +353,9 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	// first visit the WHERE clause
 	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
 	if (statement.where_clause) {
+		// bind any star expressions in the WHERE clause
+		BindWhereStarExpression(statement.where_clause);
+
 		ColumnAliasBinder alias_binder(*result, alias_map);
 		WhereBinder where_binder(*this, context, &alias_binder);
 		unique_ptr<ParsedExpression> condition = std::move(statement.where_clause);

package/src/duckdb/src/planner/binder/query_node/plan_query_node.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
+#include "duckdb/planner/bound_result_modifier.hpp"
 
 namespace duckdb {
 
@@ -20,6 +21,16 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &bound = (BoundOrderModifier &)*mod;
+			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
+				auto &distinct = (LogicalDistinct &)*root;
+				if (!distinct.distinct_targets.empty()) {
+					auto order_by = make_unique<BoundOrderModifier>();
+					for (auto &order_node : bound.orders) {
+						order_by->orders.push_back(order_node.Copy());
+					}
+					distinct.order_by = std::move(order_by);
+				}
+			}
 			auto order = make_unique<LogicalOrder>(std::move(bound.orders));
 			order->AddChild(std::move(root));
 			root = std::move(order);

package/src/duckdb/src/planner/binder/statement/bind_delete.cpp

@@ -83,7 +83,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		del->table_index = update_table_index;
 
 		unique_ptr<LogicalOperator> del_as_logicaloperator = std::move(del);
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(del_as_logicaloperator), std::move(result));
 	}
 	result.plan = std::move(del);

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -505,8 +505,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		insert->table_index = insert_table_index;
 		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
 
-		return BindReturning(std::move(stmt.returning_list), table, insert_table_index,
-		                     std::move(index_as_logicaloperator), std::move(result));
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table_ref ? stmt.table_ref->alias : string(),
+		                     insert_table_index, std::move(index_as_logicaloperator), std::move(result));
 	}
 
 	D_ASSERT(result.types.size() == result.names.size());

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -251,7 +251,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	if (!stmt.returning_list.empty()) {
 		unique_ptr<LogicalOperator> update_as_logicaloperator = std::move(update);
 
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(update_as_logicaloperator), std::move(result));
 	}
 

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -126,9 +126,18 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	unique_ptr<FunctionData> bind_data;
 	vector<LogicalType> return_types;
 	vector<string> return_names;
-	if (table_function.bind) {
+	if (table_function.bind || table_function.bind_replace) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
 		                                  table_function.function_info.get());
+		if (table_function.bind_replace) {
+			auto new_plan = table_function.bind_replace(context, bind_input);
+			if (new_plan != nullptr) {
+				return CreatePlan(*Bind(*new_plan));
+			} else if (!table_function.bind) {
+				throw BinderException("Failed to bind \"%s\": nullptr returned from bind_replace without bind function",
+				                      table_function.name);
+			}
+		}
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
 		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
 			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
@@ -153,6 +162,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			return_names[i] = "C" + to_string(i);
 		}
 	}
+
 	auto get = make_unique<LogicalGet>(bind_index, table_function, std::move(bind_data), return_types, return_names);
 	get->parameters = parameters;
 	get->named_parameters = named_parameters;

package/src/duckdb/src/planner/binder.cpp

@@ -438,8 +438,8 @@ void VerifyNotExcluded(ParsedExpression &expr) {
 }
 
 BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
-                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
-                                     BoundStatement result) {
+                                     const string &alias, idx_t update_table_index,
+                                     unique_ptr<LogicalOperator> child_operator, BoundStatement result) {
 
 	vector<LogicalType> types;
 	vector<std::string> names;
@@ -457,31 +457,20 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		column_count++;
 	}
 
-	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table, false);
+	binder->bind_context.AddBaseTable(update_table_index, alias.empty() ? table->name : alias, names, types,
+	                                  bound_columns, table, false);
 	ReturningBinder returning_binder(*binder, context);
 
 	vector<unique_ptr<Expression>> projection_expressions;
 	LogicalType result_type;
-	for (auto &returning_expr : returning_list) {
-		auto expr_type = returning_expr->GetExpressionType();
-		if (expr_type == ExpressionType::STAR) {
-			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
-
-			for (auto &star_column : generated_star_list) {
-				auto star_expr = returning_binder.Bind(star_column, &result_type);
-				result.types.push_back(result_type);
-				result.names.push_back(star_expr->GetName());
-				projection_expressions.push_back(std::move(star_expr));
-			}
-		} else {
-			// TODO: accept 'excluded' in the RETURNING clause
-			VerifyNotExcluded(*returning_expr);
-			auto expr = returning_binder.Bind(returning_expr, &result_type);
-			result.names.push_back(expr->GetName());
-			result.types.push_back(result_type);
-			projection_expressions.push_back(std::move(expr));
-		}
+	vector<unique_ptr<ParsedExpression>> new_returning_list;
+	binder->ExpandStarExpressions(returning_list, new_returning_list);
+	for (auto &returning_expr : new_returning_list) {
+		VerifyNotExcluded(*returning_expr);
+		auto expr = returning_binder.Bind(returning_expr, &result_type);
+		result.names.push_back(expr->GetName());
+		result.types.push_back(result_type);
+		projection_expressions.push_back(std::move(expr));
 	}
 
 	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(projection_expressions));

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -80,6 +80,32 @@ BoundOrderByNode BoundOrderByNode::Deserialize(Deserializer &source, PlanDeseria
 	return BoundOrderByNode(type, null_order, std::move(expression));
 }
 
+unique_ptr<BoundOrderModifier> BoundOrderModifier::Copy() const {
+	auto result = make_unique<BoundOrderModifier>();
+	for (auto &order : orders) {
+		result->orders.push_back(order.Copy());
+	}
+	return result;
+}
+
+bool BoundOrderModifier::Equals(const BoundOrderModifier *left, const BoundOrderModifier *right) {
+	if (left == right) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	if (left->orders.size() != right->orders.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < left->orders.size(); i++) {
+		if (!left->orders[i].Equals(right->orders[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
 }
 

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -19,8 +19,8 @@ BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, v
 }
 
 string BoundAggregateExpression::ToString() const {
-	return FunctionExpression::ToString<BoundAggregateExpression, Expression>(*this, string(), function.name, false,
-	                                                                          IsDistinct(), filter.get());
+	return FunctionExpression::ToString<BoundAggregateExpression, Expression, BoundOrderModifier>(
+	    *this, string(), function.name, false, IsDistinct(), filter.get(), order_bys.get());
 }
 
 hash_t BoundAggregateExpression::Hash() const {
@@ -55,6 +55,9 @@ bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
 	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
 		return false;
 	}
+	if (!BoundOrderModifier::Equals(order_bys.get(), other->order_bys.get())) {
+		return false;
+	}
 	return true;
 }
 
@@ -74,12 +77,16 @@ unique_ptr<Expression> BoundAggregateExpression::Copy() {
 	auto copy = make_unique<BoundAggregateExpression>(function, std::move(new_children), std::move(new_filter),
 	                                                  std::move(new_bind_info), aggr_type);
 	copy->CopyProperties(*this);
+	copy->order_bys = order_bys ? order_bys->Copy() : nullptr;
 	return std::move(copy);
 }
 
 void BoundAggregateExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteField(IsDistinct());
 	writer.WriteOptional(filter);
+	if (order_bys) {
+		throw NotImplementedException("Serialization of ORDER BY aggregate not yet supported");
+	}
 	FunctionSerializer::Serialize<AggregateFunction>(writer, function, return_type, children, bind_info.get());
 }
 

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -29,6 +29,11 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		if (aggr_expr.filter) {
 			callback(aggr_expr.filter);
 		}
+		if (aggr_expr.order_bys) {
+			for (auto &order : aggr_expr.order_bys->orders) {
+				callback(order.expression);
+			}
+		}
 		break;
 	}
 	case ExpressionClass::BOUND_BETWEEN: {

package/src/duckdb/src/planner/logical_operator.cpp

@@ -128,6 +128,8 @@ void LogicalOperator::Verify(ClientContext &context) {
 			continue;
 		}
 		BufferedSerializer serializer;
+		// We are serializing a query plan
+		serializer.is_query_plan = true;
 		try {
 			expressions[expr_idx]->Serialize(serializer);
 		} catch (NotImplementedException &ex) {
@@ -136,7 +138,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 		}
 
 		auto data = serializer.GetData();
-		auto deserializer = BufferedDeserializer(data.data.get(), data.size);
+		auto deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
 
 		PlanDeserializationState state(context);
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
@@ -371,7 +373,7 @@ unique_ptr<LogicalOperator> LogicalOperator::Copy(ClientContext &context) const
 		                              std::string(ex.what()));
 	}
 	auto data = logical_op_serializer.GetData();
-	auto logical_op_deserializer = BufferedDeserializer(data.data.get(), data.size);
+	auto logical_op_deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
 	PlanDeserializationState state(context);
 	auto op_copy = LogicalOperator::Deserialize(logical_op_deserializer, state);
 	return op_copy;

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -48,6 +48,11 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		for (auto &target : distinct.distinct_targets) {
 			callback(&target);
 		}
+		if (distinct.order_by) {
+			for (auto &order : distinct.order_by->orders) {
+				callback(&order.expression);
+			}
+		}
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_INSERT: {

package/src/duckdb/src/planner/operator/logical_distinct.cpp

@@ -15,6 +15,9 @@ string LogicalDistinct::ParamsToString() const {
 }
 void LogicalDistinct::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializableList(distinct_targets);
+	if (order_by) {
+		throw NotImplementedException("Serializing ORDER BY not yet supported");
+	}
 }
 
 unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {

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

@@ -184,6 +184,7 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 	}
 
 	BufferedSerializer serializer;
+	serializer.is_query_plan = true;
 	try {
 		op->Serialize(serializer);
 	} catch (NotImplementedException &ex) {
@@ -191,7 +192,7 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 		return;
 	}
 	auto data = serializer.GetData();
-	auto deserializer = BufferedDeserializer(data.data.get(), data.size);
+	auto deserializer = BufferedContextDeserializer(context, data.data.get(), data.size);
 
 	PlanDeserializationState state(context);
 	auto new_plan = LogicalOperator::Deserialize(deserializer, state);

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/storage_info.cpp

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

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);
 		}