duckdb 0.8.2-dev1968.0 → 0.8.2-dev2068.0

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

package/src/duckdb/src/storage/serialization/serialize_constraint.cpp

@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/parser/constraints/list.hpp"
+
+namespace duckdb {
+
+void Constraint::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+}
+
+unique_ptr<Constraint> Constraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<ConstraintType>("type");
+	unique_ptr<Constraint> result;
+	switch (type) {
+	case ConstraintType::CHECK:
+		result = CheckConstraint::FormatDeserialize(deserializer);
+		break;
+	case ConstraintType::FOREIGN_KEY:
+		result = ForeignKeyConstraint::FormatDeserialize(deserializer);
+		break;
+	case ConstraintType::NOT_NULL:
+		result = NotNullConstraint::FormatDeserialize(deserializer);
+		break;
+	case ConstraintType::UNIQUE:
+		result = UniqueConstraint::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of Constraint!");
+	}
+	return result;
+}
+
+void CheckConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("expression", *expression);
+}
+
+unique_ptr<Constraint> CheckConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
+	auto result = duckdb::unique_ptr<CheckConstraint>(new CheckConstraint(std::move(expression)));
+	return std::move(result);
+}
+
+void ForeignKeyConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("pk_columns", pk_columns);
+	serializer.WriteProperty("fk_columns", fk_columns);
+	serializer.WriteProperty("type", info.type);
+	serializer.WriteProperty("schema", info.schema);
+	serializer.WriteProperty("table", info.table);
+	serializer.WriteProperty("pk_keys", info.pk_keys);
+	serializer.WriteProperty("fk_keys", info.fk_keys);
+}
+
+unique_ptr<Constraint> ForeignKeyConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ForeignKeyConstraint>(new ForeignKeyConstraint());
+	deserializer.ReadProperty("pk_columns", result->pk_columns);
+	deserializer.ReadProperty("fk_columns", result->fk_columns);
+	deserializer.ReadProperty("type", result->info.type);
+	deserializer.ReadProperty("schema", result->info.schema);
+	deserializer.ReadProperty("table", result->info.table);
+	deserializer.ReadProperty("pk_keys", result->info.pk_keys);
+	deserializer.ReadProperty("fk_keys", result->info.fk_keys);
+	return std::move(result);
+}
+
+void NotNullConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("index", index);
+}
+
+unique_ptr<Constraint> NotNullConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto index = deserializer.ReadProperty<LogicalIndex>("index");
+	auto result = duckdb::unique_ptr<NotNullConstraint>(new NotNullConstraint(index));
+	return std::move(result);
+}
+
+void UniqueConstraint::FormatSerialize(FormatSerializer &serializer) const {
+	Constraint::FormatSerialize(serializer);
+	serializer.WriteProperty("is_primary_key", is_primary_key);
+	serializer.WriteProperty("index", index);
+	serializer.WriteProperty("columns", columns);
+}
+
+unique_ptr<Constraint> UniqueConstraint::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<UniqueConstraint>(new UniqueConstraint());
+	deserializer.ReadProperty("is_primary_key", result->is_primary_key);
+	deserializer.ReadProperty("index", result->index);
+	deserializer.ReadProperty("columns", result->columns);
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/src/storage/serialization/serialize_create_info.cpp

@@ -0,0 +1,188 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/parser/parsed_data/create_info.hpp"
+#include "duckdb/parser/parsed_data/create_index_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/parser/parsed_data/create_schema_info.hpp"
+#include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+
+namespace duckdb {
+
+void CreateInfo::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("type", type);
+	serializer.WriteProperty("catalog", catalog);
+	serializer.WriteProperty("schema", schema);
+	serializer.WriteProperty("temporary", temporary);
+	serializer.WriteProperty("internal", internal);
+	serializer.WriteProperty("on_conflict", on_conflict);
+	serializer.WriteProperty("sql", sql);
+}
+
+unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto type = deserializer.ReadProperty<CatalogType>("type");
+	auto catalog = deserializer.ReadProperty<string>("catalog");
+	auto schema = deserializer.ReadProperty<string>("schema");
+	auto temporary = deserializer.ReadProperty<bool>("temporary");
+	auto internal = deserializer.ReadProperty<bool>("internal");
+	auto on_conflict = deserializer.ReadProperty<OnCreateConflict>("on_conflict");
+	auto sql = deserializer.ReadProperty<string>("sql");
+	unique_ptr<CreateInfo> result;
+	switch (type) {
+	case CatalogType::INDEX_ENTRY:
+		result = CreateIndexInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::MACRO_ENTRY:
+		result = CreateMacroInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::SCHEMA_ENTRY:
+		result = CreateSchemaInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::SEQUENCE_ENTRY:
+		result = CreateSequenceInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::TABLE_ENTRY:
+		result = CreateTableInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::TABLE_MACRO_ENTRY:
+		result = CreateMacroInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::TYPE_ENTRY:
+		result = CreateTypeInfo::FormatDeserialize(deserializer);
+		break;
+	case CatalogType::VIEW_ENTRY:
+		result = CreateViewInfo::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of CreateInfo!");
+	}
+	result->catalog = std::move(catalog);
+	result->schema = std::move(schema);
+	result->temporary = temporary;
+	result->internal = internal;
+	result->on_conflict = on_conflict;
+	result->sql = std::move(sql);
+	return result;
+}
+
+void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", index_name);
+	serializer.WriteProperty("index_type", index_type);
+	serializer.WriteProperty("constraint_type", constraint_type);
+	serializer.WriteProperty("parsed_expressions", parsed_expressions);
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("column_ids", column_ids);
+}
+
+unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
+	deserializer.ReadProperty("name", result->index_name);
+	deserializer.ReadProperty("index_type", result->index_type);
+	deserializer.ReadProperty("constraint_type", result->constraint_type);
+	deserializer.ReadProperty("parsed_expressions", result->parsed_expressions);
+	deserializer.ReadProperty("names", result->names);
+	deserializer.ReadProperty("column_ids", result->column_ids);
+	return std::move(result);
+}
+
+void CreateMacroInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", name);
+	serializer.WriteProperty("function", *function);
+}
+
+unique_ptr<CreateInfo> CreateMacroInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateMacroInfo>(new CreateMacroInfo());
+	deserializer.ReadProperty("name", result->name);
+	deserializer.ReadProperty("function", result->function);
+	return std::move(result);
+}
+
+void CreateSchemaInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+}
+
+unique_ptr<CreateInfo> CreateSchemaInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateSchemaInfo>(new CreateSchemaInfo());
+	return std::move(result);
+}
+
+void CreateSequenceInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", name);
+	serializer.WriteProperty("usage_count", usage_count);
+	serializer.WriteProperty("increment", increment);
+	serializer.WriteProperty("min_value", min_value);
+	serializer.WriteProperty("max_value", max_value);
+	serializer.WriteProperty("start_value", start_value);
+	serializer.WriteProperty("cycle", cycle);
+}
+
+unique_ptr<CreateInfo> CreateSequenceInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateSequenceInfo>(new CreateSequenceInfo());
+	deserializer.ReadProperty("name", result->name);
+	deserializer.ReadProperty("usage_count", result->usage_count);
+	deserializer.ReadProperty("increment", result->increment);
+	deserializer.ReadProperty("min_value", result->min_value);
+	deserializer.ReadProperty("max_value", result->max_value);
+	deserializer.ReadProperty("start_value", result->start_value);
+	deserializer.ReadProperty("cycle", result->cycle);
+	return std::move(result);
+}
+
+void CreateTableInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("table", table);
+	serializer.WriteProperty("columns", columns);
+	serializer.WriteProperty("constraints", constraints);
+	serializer.WriteOptionalProperty("query", query);
+}
+
+unique_ptr<CreateInfo> CreateTableInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateTableInfo>(new CreateTableInfo());
+	deserializer.ReadProperty("table", result->table);
+	deserializer.ReadProperty("columns", result->columns);
+	deserializer.ReadProperty("constraints", result->constraints);
+	deserializer.ReadOptionalProperty("query", result->query);
+	return std::move(result);
+}
+
+void CreateTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("name", name);
+	serializer.WriteProperty("type", type);
+}
+
+unique_ptr<CreateInfo> CreateTypeInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateTypeInfo>(new CreateTypeInfo());
+	deserializer.ReadProperty("name", result->name);
+	deserializer.ReadProperty("type", result->type);
+	return std::move(result);
+}
+
+void CreateViewInfo::FormatSerialize(FormatSerializer &serializer) const {
+	CreateInfo::FormatSerialize(serializer);
+	serializer.WriteProperty("view_name", view_name);
+	serializer.WriteProperty("aliases", aliases);
+	serializer.WriteProperty("types", types);
+	serializer.WriteOptionalProperty("query", query);
+}
+
+unique_ptr<CreateInfo> CreateViewInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<CreateViewInfo>(new CreateViewInfo());
+	deserializer.ReadProperty("view_name", result->view_name);
+	deserializer.ReadProperty("aliases", result->aliases);
+	deserializer.ReadProperty("types", result->types);
+	deserializer.ReadOptionalProperty("query", result->query);
+	return std::move(result);
+}
+
+} // namespace duckdb