duckdb 0.8.2-dev1862.0 → 0.8.2-dev2044.0

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

@@ -12,6 +12,23 @@ BoundParameterExpression::BoundParameterExpression(idx_t parameter_nr)
       parameter_nr(parameter_nr) {
 }
 
+BoundParameterExpression::BoundParameterExpression(bound_parameter_map_t &global_parameter_set, idx_t parameter_nr,
+                                                   LogicalType return_type,
+                                                   shared_ptr<BoundParameterData> parameter_data)
+    : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER, std::move(return_type)),
+      parameter_nr(parameter_nr) {
+	// check if we have already deserialized a parameter with this number
+	auto entry = global_parameter_set.find(parameter_nr);
+	if (entry == global_parameter_set.end()) {
+		// we have not - store the entry we deserialized from this parameter expression
+		global_parameter_set[parameter_nr] = parameter_data;
+	} else {
+		// we have! use the previously deserialized entry
+		parameter_data = entry->second;
+	}
+	this->parameter_data = std::move(parameter_data);
+}
+
 void BoundParameterExpression::Invalidate(Expression &expr) {
 	if (expr.type != ExpressionType::VALUE_PARAMETER) {
 		throw InternalException("BoundParameterExpression::Invalidate requires a parameter as input");
@@ -75,19 +92,10 @@ unique_ptr<Expression> BoundParameterExpression::Deserialize(ExpressionDeseriali
                                                              FieldReader &reader) {
 	auto &global_parameter_set = state.gstate.parameter_data;
 	auto parameter_nr = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<BoundParameterExpression>(parameter_nr);
-	result->return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto parameter_data = reader.ReadRequiredSerializable<BoundParameterData, shared_ptr<BoundParameterData>>();
-	// check if we have already deserialized a parameter with this number
-	auto entry = global_parameter_set.find(parameter_nr);
-	if (entry == global_parameter_set.end()) {
-		// we have not - store the entry we deserialized from this parameter expression
-		global_parameter_set[parameter_nr] = parameter_data;
-	} else {
-		// we have! use the previously deserialized entry
-		parameter_data = entry->second;
-	}
-	result->parameter_data = std::move(parameter_data);
+	auto result = unique_ptr<BoundParameterExpression>(new BoundParameterExpression(
+	    global_parameter_set, parameter_nr, std::move(return_type), std::move(parameter_data)));
 	return std::move(result);
 }
 

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

@@ -9,6 +9,8 @@
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -134,7 +136,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 			expressions[expr_idx]->Serialize(serializer);
 		} catch (NotImplementedException &ex) {
 			// ignore for now (FIXME)
-			return;
+			continue;
 		}
 
 		auto data = serializer.GetData();
@@ -142,6 +144,16 @@ void LogicalOperator::Verify(ClientContext &context) {
 
 		PlanDeserializationState state(context);
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
+
+		// format (de)serialization of expressions
+		try {
+			auto blob = BinarySerializer::Serialize(*expressions[expr_idx]);
+			bound_parameter_map_t parameters;
+			auto result = BinaryDeserializer::Deserialize<Expression>(context, parameters, blob.data(), blob.size());
+			result->Hash();
+		} catch (SerializationException &ex) {
+			// pass
+		}
 		// FIXME: expressions might not be equal yet because of statistics propagation
 		continue;
 		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));

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

@@ -1,6 +1,7 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/common/enum_util.hpp"
 namespace duckdb {
@@ -23,15 +24,15 @@ string LogicalComparisonJoin::ParamsToString() const {
 
 void LogicalComparisonJoin::Serialize(FieldWriter &writer) const {
 	LogicalJoin::Serialize(writer);
+	writer.WriteRegularSerializableList(mark_types);
 	writer.WriteRegularSerializableList(conditions);
-	writer.WriteRegularSerializableList(delim_types);
 }
 
 void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
                                         FieldReader &reader) {
 	LogicalJoin::Deserialize(comparison_join, state, reader);
+	comparison_join.mark_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	comparison_join.conditions = reader.ReadRequiredSerializableList<JoinCondition, JoinCondition>(state.gstate);
-	comparison_join.delim_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,
@@ -41,4 +42,17 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializ
 	return std::move(result);
 }
 
+unique_ptr<LogicalOperator> LogicalComparisonJoin::FromDelimJoin(LogicalDelimJoin &delim_join) {
+	auto new_join = make_uniq<LogicalComparisonJoin>(delim_join.join_type);
+	new_join->children = std::move(delim_join.children);
+	new_join->conditions = std::move(delim_join.conditions);
+	new_join->types = std::move(delim_join.types);
+	new_join->mark_types = std::move(delim_join.mark_types);
+	new_join->mark_index = delim_join.mark_index;
+	new_join->left_projection_map = std::move(delim_join.left_projection_map);
+	new_join->right_projection_map = std::move(delim_join.right_projection_map);
+	new_join->join_stats = std::move(delim_join.join_stats);
+	return std::move(new_join);
+}
+
 } // namespace duckdb

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

@@ -2,6 +2,16 @@
 
 namespace duckdb {
 
+LogicalCreate::LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info,
+                             optional_ptr<SchemaCatalogEntry> schema)
+    : LogicalOperator(type), schema(schema), info(std::move(info)) {
+}
+
+LogicalCreate::LogicalCreate(LogicalOperatorType type, ClientContext &context, unique_ptr<CreateInfo> info_p)
+    : LogicalOperator(type), info(std::move(info_p)) {
+	this->schema = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
+}
+
 void LogicalCreate::Serialize(FieldWriter &writer) const {
 	info->Serialize(writer.GetSerializer());
 }
@@ -18,4 +28,8 @@ idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
+void LogicalCreate::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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

@@ -6,6 +6,22 @@
 
 namespace duckdb {
 
+LogicalCreateIndex::LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
+                                       vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
+                                       TableFunction function_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(std::move(bind_data_p)),
+      info(std::move(info_p)), table(table_p), function(std::move(function_p)) {
+
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
+	}
+	this->expressions = std::move(expressions_p);
+
+	if (info->column_ids.empty()) {
+		throw BinderException("CREATE INDEX does not refer to any columns in the base table!");
+	}
+}
+
 void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(info);
 	writer.WriteString(table.catalog.GetName());
@@ -37,4 +53,8 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	                                     table, std::move(function));
 }
 
+void LogicalCreateIndex::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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

@@ -2,6 +2,18 @@
 
 namespace duckdb {
 
+LogicalCreateTable::LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
+}
+
+LogicalCreateTable::LogicalCreateTable(ClientContext &context, const string &catalog, const string &schema,
+                                       unique_ptr<CreateInfo> unbound_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(Catalog::GetSchema(context, catalog, schema)) {
+	D_ASSERT(unbound_info->type == CatalogType::TABLE_ENTRY);
+	auto binder = Binder::CreateBinder(context);
+	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));
+}
+
 void LogicalCreateTable::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializable(*info);
 }
@@ -16,4 +28,8 @@ idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
+void LogicalCreateTable::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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

@@ -11,6 +11,11 @@ LogicalDelete::LogicalDelete(TableCatalogEntry &table, idx_t table_index)
       return_chunk(false) {
 }
 
+LogicalDelete::LogicalDelete(ClientContext &context, const string &catalog, const string &schema, const string &table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
+}
+
 void LogicalDelete::Serialize(FieldWriter &writer) const {
 	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
@@ -20,9 +25,11 @@ void LogicalDelete::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
+	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
+	auto &table_info = info->Cast<CreateTableInfo>();
 
-	auto &table_catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, info->table);
+	auto &table_catalog_entry =
+	    Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, table_info.table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);

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

@@ -9,10 +9,8 @@ LogicalDelimJoin::LogicalDelimJoin(JoinType type)
 
 void LogicalDelimJoin::Serialize(FieldWriter &writer) const {
 	LogicalComparisonJoin::Serialize(writer);
-	if (type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		D_ASSERT(duplicate_eliminated_columns.empty());
-		// if the delim join has no delim columns anymore it is turned into a regular comparison join
-		return;
+	if (type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		throw InternalException("LogicalDelimJoin needs to have type LOGICAL_DELIM_JOIN");
 	}
 	writer.WriteSerializableList(duplicate_eliminated_columns);
 }

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

@@ -4,6 +4,14 @@
 
 namespace duckdb {
 
+LogicalDistinct::LogicalDistinct(DistinctType distinct_type)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
+}
+LogicalDistinct::LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
+      distinct_targets(std::move(targets)) {
+}
+
 string LogicalDistinct::ParamsToString() const {
 	string result = LogicalOperator::ParamsToString();
 	if (!distinct_targets.empty()) {
@@ -13,6 +21,7 @@ string LogicalDistinct::ParamsToString() const {
 
 	return result;
 }
+
 void LogicalDistinct::Serialize(FieldWriter &writer) const {
 	writer.WriteField<DistinctType>(distinct_type);
 	writer.WriteSerializableList(distinct_targets);
@@ -28,4 +37,8 @@ unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationS
 	return std::move(ret);
 }
 
+void LogicalDistinct::ResolveTypes() {
+	types = children[0]->types;
+}
+
 } // namespace duckdb

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

@@ -12,11 +12,11 @@ void LogicalExplain::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalExplain::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto explain_type = reader.ReadRequired<ExplainType>();
-	// TODO(stephwang) review if unique_ptr<LogicalOperator> plan is needed
 	auto result = unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
 	result->physical_plan = reader.ReadRequired<string>();
 	result->logical_plan_unopt = reader.ReadRequired<string>();
 	result->logical_plan_opt = reader.ReadRequired<string>();
 	return std::move(result);
 }
+
 } // namespace duckdb

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

@@ -12,6 +12,11 @@ LogicalInsert::LogicalInsert(TableCatalogEntry &table, idx_t table_index)
       action_type(OnConflictAction::THROW) {
 }
 
+LogicalInsert::LogicalInsert(ClientContext &context, const string &catalog, const string &schema, const string &table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
+}
+
 void LogicalInsert::Serialize(FieldWriter &writer) const {
 	writer.WriteField<idx_t>(insert_values.size());
 	for (auto &entry : insert_values) {
@@ -47,7 +52,7 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 
 	auto column_index_map = reader.ReadRequiredList<idx_t, physical_index_vector_t<idx_t>>();
 	auto expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
+	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto return_chunk = reader.ReadRequired<bool>();
 	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
@@ -65,7 +70,8 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 
 	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
-	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto &table_catalog_entry =
+	    catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->Cast<CreateTableInfo>().table);
 	auto result = make_uniq<LogicalInsert>(table_catalog_entry, table_index);
 	result->type = state.type;
 	result->return_chunk = return_chunk;

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

@@ -10,8 +10,9 @@ void LogicalMaterializedCTE::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalMaterializedCTE::Deserialize(LogicalDeserializationState &state,
                                                                 FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	return unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE(table_index));
+	auto result = unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
+	result->table_index = reader.ReadRequired<idx_t>();
+	return std::move(result);
 }
 
 vector<idx_t> LogicalMaterializedCTE::GetTableIndex() const {

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

@@ -4,6 +4,45 @@
 
 namespace duckdb {
 
+LogicalOrder::LogicalOrder(vector<BoundOrderByNode> orders)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
+}
+
+vector<ColumnBinding> LogicalOrder::GetColumnBindings() {
+	auto child_bindings = children[0]->GetColumnBindings();
+	if (projections.empty()) {
+		return child_bindings;
+	}
+
+	vector<ColumnBinding> result;
+	for (auto &col_idx : projections) {
+		result.push_back(child_bindings[col_idx]);
+	}
+	return result;
+}
+
+string LogicalOrder::ParamsToString() const {
+	string result = "ORDERS:\n";
+	for (idx_t i = 0; i < orders.size(); i++) {
+		if (i > 0) {
+			result += "\n";
+		}
+		result += orders[i].expression->GetName();
+	}
+	return result;
+}
+
+void LogicalOrder::ResolveTypes() {
+	const auto child_types = children[0]->types;
+	if (projections.empty()) {
+		types = child_types;
+	} else {
+		for (auto &col_idx : projections) {
+			types.push_back(child_types[col_idx]);
+		}
+	}
+}
+
 void LogicalOrder::Serialize(FieldWriter &writer) const {
 	writer.WriteRegularSerializableList(orders);
 	writer.WriteList<idx_t>(projections);

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

@@ -4,6 +4,9 @@
 
 namespace duckdb {
 
+LogicalPivot::LogicalPivot() : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT) {
+}
+
 LogicalPivot::LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info_p)
     : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT), pivot_index(pivot_idx), bound_pivot(std::move(info_p)) {
 	D_ASSERT(plan);

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

@@ -12,11 +12,11 @@ void LogicalRecursiveCTE::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_count = reader.ReadRequired<idx_t>();
-	auto union_all = reader.ReadRequired<bool>();
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	return unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE(table_index, column_count, union_all));
+	auto result = unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
+	result->table_index = reader.ReadRequired<idx_t>();
+	result->column_count = reader.ReadRequired<idx_t>();
+	result->union_all = reader.ReadRequired<bool>();
+	return std::move(result);
 }
 
 vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {

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

@@ -3,6 +3,9 @@
 
 namespace duckdb {
 
+LogicalSample::LogicalSample() : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE) {
+}
+
 LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
     : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(std::move(sample_options_p)) {
 	children.push_back(std::move(child));

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

@@ -10,6 +10,11 @@ LogicalUpdate::LogicalUpdate(TableCatalogEntry &table)
     : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
 }
 
+LogicalUpdate::LogicalUpdate(ClientContext &context, const string &catalog, const string &schema, const string &table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
+}
+
 void LogicalUpdate::Serialize(FieldWriter &writer) const {
 	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
@@ -22,10 +27,11 @@ void LogicalUpdate::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
+	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
 	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
-	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto &table_catalog_entry =
+	    catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->Cast<CreateTableInfo>().table);
 	auto result = make_uniq<LogicalUpdate>(table_catalog_entry);
 	result->table_index = reader.ReadRequired<idx_t>();
 	result->return_chunk = reader.ReadRequired<bool>();

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -2,8 +2,11 @@
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
+
 void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
 	serializer.WriteOptional(base);
 }
@@ -11,10 +14,9 @@ void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
 unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer &source,
                                                                    PlanDeserializationState &state) {
 	auto info = source.ReadOptional<CreateInfo>();
-	auto schema_name = info->schema;
-	auto catalog = info->catalog;
 	auto binder = Binder::CreateBinder(state.context);
 	auto bound_info = binder->BindCreateTableInfo(std::move(info));
 	return bound_info;
 }
+
 } // namespace duckdb

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

@@ -11,6 +11,8 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -164,6 +166,15 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 		return;
 	}
 
+	// format (de)serialization of this operator
+	try {
+		auto blob = BinarySerializer::Serialize(*op);
+		bound_parameter_map_t parameters;
+		auto result = BinaryDeserializer::Deserialize<LogicalOperator>(context, parameters, blob.data(), blob.size());
+	} catch (SerializationException &ex) {
+		// pass
+	}
+
 	BufferedSerializer serializer;
 	serializer.is_query_plan = true;
 	try {

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

@@ -254,10 +254,10 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 
 void CheckpointReader::ReadSchema(ClientContext &context, MetaBlockReader &reader) {
 	// read the schema and create it in the catalog
-	auto info = SchemaCatalogEntry::Deserialize(reader);
+	auto info = CatalogEntry::Deserialize(reader);
 	// we set create conflict to ignore to ignore the failure of recreating the main schema
 	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateSchema(context, *info);
+	catalog.CreateSchema(context, info->Cast<CreateSchemaInfo>());
 
 	// first read all the counts
 	FieldReader field_reader(reader);
@@ -309,8 +309,8 @@ void CheckpointWriter::WriteView(ViewCatalogEntry &view) {
 }
 
 void CheckpointReader::ReadView(ClientContext &context, MetaBlockReader &reader) {
-	auto info = ViewCatalogEntry::Deserialize(reader, context);
-	catalog.CreateView(context, *info);
+	auto info = CatalogEntry::Deserialize(reader);
+	catalog.CreateView(context, info->Cast<CreateViewInfo>());
 }
 
 //===--------------------------------------------------------------------===//
@@ -322,7 +322,7 @@ void CheckpointWriter::WriteSequence(SequenceCatalogEntry &seq) {
 
 void CheckpointReader::ReadSequence(ClientContext &context, MetaBlockReader &reader) {
 	auto info = SequenceCatalogEntry::Deserialize(reader);
-	catalog.CreateSequence(context, *info);
+	catalog.CreateSequence(context, info->Cast<CreateSequenceInfo>());
 }
 
 //===--------------------------------------------------------------------===//
@@ -341,13 +341,14 @@ void CheckpointWriter::WriteIndex(IndexCatalogEntry &index_catalog) {
 
 void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader) {
 	// deserialize the index metadata
-	auto info = IndexCatalogEntry::Deserialize(reader, context);
+	auto info = IndexCatalogEntry::Deserialize(reader);
+	auto &index_info = info->Cast<CreateIndexInfo>();
 
 	// create the index in the catalog
 	auto &schema_catalog = catalog.GetSchema(context, info->schema);
-	auto &table_catalog = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, info->table->table_name)
-	                          .Cast<DuckTableEntry>();
-	auto &index_catalog = schema_catalog.CreateIndex(context, *info, table_catalog)->Cast<DuckIndexEntry>();
+	auto &table_catalog =
+	    catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, index_info.table).Cast<DuckTableEntry>();
+	auto &index_catalog = schema_catalog.CreateIndex(context, index_info, table_catalog)->Cast<DuckIndexEntry>();
 	index_catalog.info = table_catalog.GetStorage().info;
 
 	// we deserialize the index lazily, i.e., we do not need to load any node information
@@ -358,7 +359,7 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	// obtain the expressions of the ART from the index metadata
 	vector<unique_ptr<Expression>> unbound_expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
-	for (auto &p_exp : info->parsed_expressions) {
+	for (auto &p_exp : index_info.parsed_expressions) {
 		parsed_expressions.push_back(p_exp->Copy());
 	}
 
@@ -372,8 +373,7 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 		column_names.push_back(col.Name());
 	}
 	vector<column_t> column_ids;
-	binder->bind_context.AddBaseTable(0, info->table->table_name, column_names, column_types, column_ids,
-	                                  &table_catalog);
+	binder->bind_context.AddBaseTable(0, index_info.table, column_names, column_types, column_ids, &table_catalog);
 	IndexBinder idx_binder(*binder, context);
 	unbound_expressions.reserve(parsed_expressions.size());
 	for (auto &expr : parsed_expressions) {
@@ -382,20 +382,20 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 
 	if (parsed_expressions.empty()) {
 		// this is a PK/FK index: we create the necessary bound column ref expressions
-		unbound_expressions.reserve(info->column_ids.size());
-		for (idx_t key_nr = 0; key_nr < info->column_ids.size(); key_nr++) {
-			auto &col = table_catalog.GetColumn(LogicalIndex(info->column_ids[key_nr]));
+		unbound_expressions.reserve(index_info.column_ids.size());
+		for (idx_t key_nr = 0; key_nr < index_info.column_ids.size(); key_nr++) {
+			auto &col = table_catalog.GetColumn(LogicalIndex(index_info.column_ids[key_nr]));
 			unbound_expressions.push_back(
 			    make_uniq<BoundColumnRefExpression>(col.GetName(), col.GetType(), ColumnBinding(0, key_nr)));
 		}
 	}
 
 	// create the index and add it to the storage
-	switch (info->index_type) {
+	switch (index_info.index_type) {
 	case IndexType::ART: {
 		auto &storage = table_catalog.GetStorage();
-		auto art = make_uniq<ART>(info->column_ids, TableIOManager::Get(storage), std::move(unbound_expressions),
-		                          info->constraint_type, storage.db, root_block_id, root_offset);
+		auto art = make_uniq<ART>(index_info.column_ids, TableIOManager::Get(storage), std::move(unbound_expressions),
+		                          index_info.constraint_type, storage.db, root_block_id, root_offset);
 		index_catalog.index = art.get();
 		storage.info->indexes.AddIndex(std::move(art));
 		break;
@@ -428,8 +428,8 @@ void CheckpointWriter::WriteMacro(ScalarMacroCatalogEntry &macro) {
 }
 
 void CheckpointReader::ReadMacro(ClientContext &context, MetaBlockReader &reader) {
-	auto info = MacroCatalogEntry::Deserialize(reader, context);
-	catalog.CreateFunction(context, *info);
+	auto info = MacroCatalogEntry::Deserialize(reader);
+	catalog.CreateFunction(context, info->Cast<CreateMacroInfo>());
 }
 
 void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro) {
@@ -437,8 +437,8 @@ void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro) {
 }
 
 void CheckpointReader::ReadTableMacro(ClientContext &context, MetaBlockReader &reader) {
-	auto info = MacroCatalogEntry::Deserialize(reader, context);
-	catalog.CreateFunction(context, *info);
+	auto info = MacroCatalogEntry::Deserialize(reader);
+	catalog.CreateFunction(context, info->Cast<CreateMacroInfo>());
 }
 
 //===--------------------------------------------------------------------===//
@@ -455,7 +455,7 @@ void CheckpointWriter::WriteTable(TableCatalogEntry &table) {
 
 void CheckpointReader::ReadTable(ClientContext &context, MetaBlockReader &reader) {
 	// deserialize the table meta data
-	auto info = TableCatalogEntry::Deserialize(reader, context);
+	auto info = TableCatalogEntry::Deserialize(reader);
 	// bind the info
 	auto binder = Binder::CreateBinder(context);
 	auto &schema = catalog.GetSchema(context, info->schema);