duckdb 0.8.2-dev4142.0 → 0.8.2-dev4314.0

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

@@ -3,183 +3,183 @@
 // 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/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
-void LogicalOperator::FormatSerialize(FormatSerializer &serializer) const {
+void LogicalOperator::Serialize(Serializer &serializer) const {
 	serializer.WriteProperty(100, "type", type);
 	serializer.WriteProperty(101, "children", children);
 }
 
-unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.ReadProperty<LogicalOperatorType>(100, "type");
 	auto children = deserializer.ReadProperty<vector<unique_ptr<LogicalOperator>>>(101, "children");
 	deserializer.Set<LogicalOperatorType>(type);
 	unique_ptr<LogicalOperator> result;
 	switch (type) {
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		result = LogicalAggregate::FormatDeserialize(deserializer);
+		result = LogicalAggregate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_ALTER:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
-		result = LogicalAnyJoin::FormatDeserialize(deserializer);
+		result = LogicalAnyJoin::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		result = LogicalComparisonJoin::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_ATTACH:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CHUNK_GET:
-		result = LogicalColumnDataGet::FormatDeserialize(deserializer);
+		result = LogicalColumnDataGet::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
-		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		result = LogicalComparisonJoin::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		result = LogicalCopyToFile::FormatDeserialize(deserializer);
+		result = LogicalCopyToFile::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
-		result = LogicalCreateIndex::FormatDeserialize(deserializer);
+		result = LogicalCreateIndex::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		result = LogicalCreate::FormatDeserialize(deserializer);
+		result = LogicalCreate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		result = LogicalCreate::FormatDeserialize(deserializer);
+		result = LogicalCreate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		result = LogicalCreate::FormatDeserialize(deserializer);
+		result = LogicalCreate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_TABLE:
-		result = LogicalCreateTable::FormatDeserialize(deserializer);
+		result = LogicalCreateTable::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE:
-		result = LogicalCreate::FormatDeserialize(deserializer);
+		result = LogicalCreate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		result = LogicalCreate::FormatDeserialize(deserializer);
+		result = LogicalCreate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		result = LogicalCrossProduct::FormatDeserialize(deserializer);
+		result = LogicalCrossProduct::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_CTE_REF:
-		result = LogicalCTERef::FormatDeserialize(deserializer);
+		result = LogicalCTERef::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DELETE:
-		result = LogicalDelete::FormatDeserialize(deserializer);
+		result = LogicalDelete::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DELIM_GET:
-		result = LogicalDelimGet::FormatDeserialize(deserializer);
+		result = LogicalDelimGet::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		result = LogicalComparisonJoin::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DETACH:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DISTINCT:
-		result = LogicalDistinct::FormatDeserialize(deserializer);
+		result = LogicalDistinct::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DROP:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_DUMMY_SCAN:
-		result = LogicalDummyScan::FormatDeserialize(deserializer);
+		result = LogicalDummyScan::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_EMPTY_RESULT:
-		result = LogicalEmptyResult::FormatDeserialize(deserializer);
+		result = LogicalEmptyResult::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_EXCEPT:
-		result = LogicalSetOperation::FormatDeserialize(deserializer);
+		result = LogicalSetOperation::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_EXPLAIN:
-		result = LogicalExplain::FormatDeserialize(deserializer);
+		result = LogicalExplain::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
-		result = LogicalExpressionGet::FormatDeserialize(deserializer);
+		result = LogicalExpressionGet::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
-		result = LogicalExtensionOperator::FormatDeserialize(deserializer);
+		result = LogicalExtensionOperator::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_FILTER:
-		result = LogicalFilter::FormatDeserialize(deserializer);
+		result = LogicalFilter::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_GET:
-		result = LogicalGet::FormatDeserialize(deserializer);
+		result = LogicalGet::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_INSERT:
-		result = LogicalInsert::FormatDeserialize(deserializer);
+		result = LogicalInsert::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_INTERSECT:
-		result = LogicalSetOperation::FormatDeserialize(deserializer);
+		result = LogicalSetOperation::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_LIMIT:
-		result = LogicalLimit::FormatDeserialize(deserializer);
+		result = LogicalLimit::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_LIMIT_PERCENT:
-		result = LogicalLimitPercent::FormatDeserialize(deserializer);
+		result = LogicalLimitPercent::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_LOAD:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
-		result = LogicalMaterializedCTE::FormatDeserialize(deserializer);
+		result = LogicalMaterializedCTE::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_ORDER_BY:
-		result = LogicalOrder::FormatDeserialize(deserializer);
+		result = LogicalOrder::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_PIVOT:
-		result = LogicalPivot::FormatDeserialize(deserializer);
+		result = LogicalPivot::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
-		result = LogicalPositionalJoin::FormatDeserialize(deserializer);
+		result = LogicalPositionalJoin::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		result = LogicalProjection::FormatDeserialize(deserializer);
+		result = LogicalProjection::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
-		result = LogicalRecursiveCTE::FormatDeserialize(deserializer);
+		result = LogicalRecursiveCTE::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_RESET:
-		result = LogicalReset::FormatDeserialize(deserializer);
+		result = LogicalReset::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_SAMPLE:
-		result = LogicalSample::FormatDeserialize(deserializer);
+		result = LogicalSample::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_SET:
-		result = LogicalSet::FormatDeserialize(deserializer);
+		result = LogicalSet::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_SHOW:
-		result = LogicalShow::FormatDeserialize(deserializer);
+		result = LogicalShow::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_TOP_N:
-		result = LogicalTopN::FormatDeserialize(deserializer);
+		result = LogicalTopN::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_UNION:
-		result = LogicalSetOperation::FormatDeserialize(deserializer);
+		result = LogicalSetOperation::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_UNNEST:
-		result = LogicalUnnest::FormatDeserialize(deserializer);
+		result = LogicalUnnest::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_UPDATE:
-		result = LogicalUpdate::FormatDeserialize(deserializer);
+		result = LogicalUpdate::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_VACUUM:
-		result = LogicalSimple::FormatDeserialize(deserializer);
+		result = LogicalSimple::Deserialize(deserializer);
 		break;
 	case LogicalOperatorType::LOGICAL_WINDOW:
-		result = LogicalWindow::FormatDeserialize(deserializer);
+		result = LogicalWindow::Deserialize(deserializer);
 		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of LogicalOperator!");
@@ -189,8 +189,8 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	return result;
 }
 
-void LogicalAggregate::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalAggregate::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "expressions", expressions);
 	serializer.WriteProperty(201, "group_index", group_index);
 	serializer.WriteProperty(202, "aggregate_index", aggregate_index);
@@ -200,7 +200,7 @@ void LogicalAggregate::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(206, "grouping_functions", grouping_functions);
 }
 
-unique_ptr<LogicalOperator> LogicalAggregate::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(Deserializer &deserializer) {
 	auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(200, "expressions");
 	auto group_index = deserializer.ReadProperty<idx_t>(201, "group_index");
 	auto aggregate_index = deserializer.ReadProperty<idx_t>(202, "aggregate_index");
@@ -212,8 +212,8 @@ unique_ptr<LogicalOperator> LogicalAggregate::FormatDeserialize(FormatDeserializ
 	return std::move(result);
 }
 
-void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalAnyJoin::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "join_type", join_type);
 	serializer.WriteProperty(201, "mark_index", mark_index);
 	serializer.WriteProperty(202, "left_projection_map", left_projection_map);
@@ -221,7 +221,7 @@ void LogicalAnyJoin::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(204, "condition", condition);
 }
 
-unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalAnyJoin::Deserialize(Deserializer &deserializer) {
 	auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
 	auto result = duckdb::unique_ptr<LogicalAnyJoin>(new LogicalAnyJoin(join_type));
 	deserializer.ReadProperty(201, "mark_index", result->mark_index);
@@ -231,8 +231,8 @@ unique_ptr<LogicalOperator> LogicalAnyJoin::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void LogicalCTERef::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalCTERef::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "cte_index", cte_index);
 	serializer.WriteProperty(202, "chunk_types", chunk_types);
@@ -240,7 +240,7 @@ void LogicalCTERef::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(204, "materialized_cte", materialized_cte);
 }
 
-unique_ptr<LogicalOperator> LogicalCTERef::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto cte_index = deserializer.ReadProperty<idx_t>(201, "cte_index");
 	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(202, "chunk_types");
@@ -250,14 +250,14 @@ unique_ptr<LogicalOperator> LogicalCTERef::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void LogicalColumnDataGet::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalColumnDataGet::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "chunk_types", chunk_types);
 	serializer.WriteProperty(202, "collection", collection);
 }
 
-unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalColumnDataGet::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
 	auto collection = deserializer.ReadProperty<unique_ptr<ColumnDataCollection>>(202, "collection");
@@ -265,8 +265,8 @@ unique_ptr<LogicalOperator> LogicalColumnDataGet::FormatDeserialize(FormatDeseri
 	return std::move(result);
 }
 
-void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalComparisonJoin::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "join_type", join_type);
 	serializer.WriteProperty(201, "mark_index", mark_index);
 	serializer.WriteProperty(202, "left_projection_map", left_projection_map);
@@ -276,7 +276,7 @@ void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const
 	serializer.WriteProperty(206, "duplicate_eliminated_columns", duplicate_eliminated_columns);
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(Deserializer &deserializer) {
 	auto join_type = deserializer.ReadProperty<JoinType>(200, "join_type");
 	auto result = duckdb::unique_ptr<LogicalComparisonJoin>(new LogicalComparisonJoin(join_type, deserializer.Get<LogicalOperatorType>()));
 	deserializer.ReadProperty(201, "mark_index", result->mark_index);
@@ -288,38 +288,38 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeser
 	return std::move(result);
 }
 
-void LogicalCreate::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalCreate::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "info", info);
 }
 
-unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCreate::Deserialize(Deserializer &deserializer) {
 	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
 	auto result = duckdb::unique_ptr<LogicalCreate>(new LogicalCreate(deserializer.Get<LogicalOperatorType>(), deserializer.Get<ClientContext &>(), std::move(info)));
 	return std::move(result);
 }
 
-void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalCreateIndex::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "info", info);
 	serializer.WriteProperty(201, "unbound_expressions", unbound_expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalCreateIndex::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(Deserializer &deserializer) {
 	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(200, "info");
 	auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "unbound_expressions");
 	auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions)));
 	return std::move(result);
 }
 
-void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalCreateTable::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "catalog", schema.ParentCatalog().GetName());
 	serializer.WriteProperty(201, "schema", schema.name);
 	serializer.WriteProperty(202, "info", info->base);
 }
 
-unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(Deserializer &deserializer) {
 	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
 	auto schema = deserializer.ReadProperty<string>(201, "schema");
 	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>(202, "info");
@@ -327,17 +327,17 @@ unique_ptr<LogicalOperator> LogicalCreateTable::FormatDeserialize(FormatDeserial
 	return std::move(result);
 }
 
-void LogicalCrossProduct::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalCrossProduct::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 }
 
-unique_ptr<LogicalOperator> LogicalCrossProduct::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCrossProduct::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalCrossProduct>(new LogicalCrossProduct());
 	return std::move(result);
 }
 
-void LogicalDelete::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalDelete::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
 	serializer.WriteProperty(201, "schema", table.ParentSchema().name);
 	serializer.WriteProperty(202, "table", table.name);
@@ -346,7 +346,7 @@ void LogicalDelete::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(205, "expressions", expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalDelete::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalDelete::Deserialize(Deserializer &deserializer) {
 	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
 	auto schema = deserializer.ReadProperty<string>(201, "schema");
 	auto table = deserializer.ReadProperty<string>(202, "table");
@@ -357,27 +357,27 @@ unique_ptr<LogicalOperator> LogicalDelete::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void LogicalDelimGet::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalDelimGet::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "chunk_types", chunk_types);
 }
 
-unique_ptr<LogicalOperator> LogicalDelimGet::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalDelimGet::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto chunk_types = deserializer.ReadProperty<vector<LogicalType>>(201, "chunk_types");
 	auto result = duckdb::unique_ptr<LogicalDelimGet>(new LogicalDelimGet(table_index, std::move(chunk_types)));
 	return std::move(result);
 }
 
-void LogicalDistinct::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalDistinct::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "distinct_type", distinct_type);
 	serializer.WriteProperty(201, "distinct_targets", distinct_targets);
 	serializer.WritePropertyWithDefault(202, "order_by", order_by, unique_ptr<BoundOrderModifier>());
 }
 
-unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(Deserializer &deserializer) {
 	auto distinct_type = deserializer.ReadProperty<DistinctType>(200, "distinct_type");
 	auto distinct_targets = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "distinct_targets");
 	auto result = duckdb::unique_ptr<LogicalDistinct>(new LogicalDistinct(std::move(distinct_targets), distinct_type));
@@ -385,39 +385,39 @@ unique_ptr<LogicalOperator> LogicalDistinct::FormatDeserialize(FormatDeserialize
 	return std::move(result);
 }
 
-void LogicalDummyScan::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalDummyScan::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 }
 
-unique_ptr<LogicalOperator> LogicalDummyScan::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalDummyScan::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto result = duckdb::unique_ptr<LogicalDummyScan>(new LogicalDummyScan(table_index));
 	return std::move(result);
 }
 
-void LogicalEmptyResult::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalEmptyResult::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "return_types", return_types);
 	serializer.WriteProperty(201, "bindings", bindings);
 }
 
-unique_ptr<LogicalOperator> LogicalEmptyResult::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalEmptyResult::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
 	deserializer.ReadProperty(200, "return_types", result->return_types);
 	deserializer.ReadProperty(201, "bindings", result->bindings);
 	return std::move(result);
 }
 
-void LogicalExplain::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalExplain::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "explain_type", explain_type);
 	serializer.WriteProperty(201, "physical_plan", physical_plan);
 	serializer.WriteProperty(202, "logical_plan_unopt", logical_plan_unopt);
 	serializer.WriteProperty(203, "logical_plan_opt", logical_plan_opt);
 }
 
-unique_ptr<LogicalOperator> LogicalExplain::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalExplain::Deserialize(Deserializer &deserializer) {
 	auto explain_type = deserializer.ReadProperty<ExplainType>(200, "explain_type");
 	auto result = duckdb::unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
 	deserializer.ReadProperty(201, "physical_plan", result->physical_plan);
@@ -426,14 +426,14 @@ unique_ptr<LogicalOperator> LogicalExplain::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void LogicalExpressionGet::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalExpressionGet::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "expr_types", expr_types);
 	serializer.WriteProperty(202, "expressions", expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalExpressionGet::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalExpressionGet::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto expr_types = deserializer.ReadProperty<vector<LogicalType>>(201, "expr_types");
 	auto expressions = deserializer.ReadProperty<vector<vector<unique_ptr<Expression>>>>(202, "expressions");
@@ -441,21 +441,21 @@ unique_ptr<LogicalOperator> LogicalExpressionGet::FormatDeserialize(FormatDeseri
 	return std::move(result);
 }
 
-void LogicalFilter::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalFilter::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "expressions", expressions);
 	serializer.WriteProperty(201, "projection_map", projection_map);
 }
 
-unique_ptr<LogicalOperator> LogicalFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalFilter::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalFilter>(new LogicalFilter());
 	deserializer.ReadProperty(200, "expressions", result->expressions);
 	deserializer.ReadProperty(201, "projection_map", result->projection_map);
 	return std::move(result);
 }
 
-void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalInsert::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
 	serializer.WriteProperty(201, "schema", table.ParentSchema().name);
 	serializer.WriteProperty(202, "table", table.name);
@@ -475,9 +475,10 @@ void LogicalInsert::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(216, "excluded_table_index", excluded_table_index);
 	serializer.WriteProperty(217, "columns_to_fetch", columns_to_fetch);
 	serializer.WriteProperty(218, "source_columns", source_columns);
+	serializer.WriteProperty(219, "expressions", expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalInsert::Deserialize(Deserializer &deserializer) {
 	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
 	auto schema = deserializer.ReadProperty<string>(201, "schema");
 	auto table = deserializer.ReadProperty<string>(202, "table");
@@ -498,18 +499,19 @@ unique_ptr<LogicalOperator> LogicalInsert::FormatDeserialize(FormatDeserializer
 	deserializer.ReadProperty(216, "excluded_table_index", result->excluded_table_index);
 	deserializer.ReadProperty(217, "columns_to_fetch", result->columns_to_fetch);
 	deserializer.ReadProperty(218, "source_columns", result->source_columns);
+	deserializer.ReadProperty(219, "expressions", result->expressions);
 	return std::move(result);
 }
 
-void LogicalLimit::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalLimit::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "limit_val", limit_val);
 	serializer.WriteProperty(201, "offset_val", offset_val);
 	serializer.WritePropertyWithDefault(202, "limit", limit, unique_ptr<Expression>());
 	serializer.WritePropertyWithDefault(203, "offset", offset, unique_ptr<Expression>());
 }
 
-unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalLimit::Deserialize(Deserializer &deserializer) {
 	auto limit_val = deserializer.ReadProperty<int64_t>(200, "limit_val");
 	auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
 	auto limit = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "limit", unique_ptr<Expression>());
@@ -518,15 +520,15 @@ unique_ptr<LogicalOperator> LogicalLimit::FormatDeserialize(FormatDeserializer &
 	return std::move(result);
 }
 
-void LogicalLimitPercent::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalLimitPercent::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "limit_percent", limit_percent);
 	serializer.WriteProperty(201, "offset_val", offset_val);
 	serializer.WritePropertyWithDefault(202, "limit", limit, unique_ptr<Expression>());
 	serializer.WritePropertyWithDefault(203, "offset", offset, unique_ptr<Expression>());
 }
 
-unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalLimitPercent::Deserialize(Deserializer &deserializer) {
 	auto limit_percent = deserializer.ReadProperty<double>(200, "limit_percent");
 	auto offset_val = deserializer.ReadProperty<int64_t>(201, "offset_val");
 	auto limit = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(202, "limit", unique_ptr<Expression>());
@@ -535,14 +537,14 @@ unique_ptr<LogicalOperator> LogicalLimitPercent::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void LogicalMaterializedCTE::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalMaterializedCTE::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "column_count", column_count);
 	serializer.WriteProperty(202, "ctename", ctename);
 }
 
-unique_ptr<LogicalOperator> LogicalMaterializedCTE::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalMaterializedCTE::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
 	deserializer.ReadProperty(200, "table_index", result->table_index);
 	deserializer.ReadProperty(201, "column_count", result->column_count);
@@ -550,63 +552,63 @@ unique_ptr<LogicalOperator> LogicalMaterializedCTE::FormatDeserialize(FormatDese
 	return std::move(result);
 }
 
-void LogicalOrder::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalOrder::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "orders", orders);
 	serializer.WriteProperty(201, "projections", projections);
 }
 
-unique_ptr<LogicalOperator> LogicalOrder::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalOrder::Deserialize(Deserializer &deserializer) {
 	auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
 	auto result = duckdb::unique_ptr<LogicalOrder>(new LogicalOrder(std::move(orders)));
 	deserializer.ReadProperty(201, "projections", result->projections);
 	return std::move(result);
 }
 
-void LogicalPivot::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalPivot::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "pivot_index", pivot_index);
 	serializer.WriteProperty(201, "bound_pivot", bound_pivot);
 }
 
-unique_ptr<LogicalOperator> LogicalPivot::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalPivot::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalPivot>(new LogicalPivot());
 	deserializer.ReadProperty(200, "pivot_index", result->pivot_index);
 	deserializer.ReadProperty(201, "bound_pivot", result->bound_pivot);
 	return std::move(result);
 }
 
-void LogicalPositionalJoin::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalPositionalJoin::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 }
 
-unique_ptr<LogicalOperator> LogicalPositionalJoin::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalPositionalJoin::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalPositionalJoin>(new LogicalPositionalJoin());
 	return std::move(result);
 }
 
-void LogicalProjection::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalProjection::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "expressions", expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalProjection::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalProjection::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "expressions");
 	auto result = duckdb::unique_ptr<LogicalProjection>(new LogicalProjection(table_index, std::move(expressions)));
 	return std::move(result);
 }
 
-void LogicalRecursiveCTE::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalRecursiveCTE::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "union_all", union_all);
 	serializer.WriteProperty(201, "ctename", ctename);
 	serializer.WriteProperty(202, "table_index", table_index);
 	serializer.WriteProperty(203, "column_count", column_count);
 }
 
-unique_ptr<LogicalOperator> LogicalRecursiveCTE::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
 	deserializer.ReadProperty(200, "union_all", result->union_all);
 	deserializer.ReadProperty(201, "ctename", result->ctename);
@@ -615,38 +617,38 @@ unique_ptr<LogicalOperator> LogicalRecursiveCTE::FormatDeserialize(FormatDeseria
 	return std::move(result);
 }
 
-void LogicalReset::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalReset::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "name", name);
 	serializer.WriteProperty(201, "scope", scope);
 }
 
-unique_ptr<LogicalOperator> LogicalReset::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalReset::Deserialize(Deserializer &deserializer) {
 	auto name = deserializer.ReadProperty<string>(200, "name");
 	auto scope = deserializer.ReadProperty<SetScope>(201, "scope");
 	auto result = duckdb::unique_ptr<LogicalReset>(new LogicalReset(std::move(name), scope));
 	return std::move(result);
 }
 
-void LogicalSample::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalSample::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "sample_options", sample_options);
 }
 
-unique_ptr<LogicalOperator> LogicalSample::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalSample::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalSample>(new LogicalSample());
 	deserializer.ReadProperty(200, "sample_options", result->sample_options);
 	return std::move(result);
 }
 
-void LogicalSet::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalSet::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "name", name);
 	serializer.WriteProperty(201, "value", value);
 	serializer.WriteProperty(202, "scope", scope);
 }
 
-unique_ptr<LogicalOperator> LogicalSet::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalSet::Deserialize(Deserializer &deserializer) {
 	auto name = deserializer.ReadProperty<string>(200, "name");
 	auto value = deserializer.ReadProperty<Value>(201, "value");
 	auto scope = deserializer.ReadProperty<SetScope>(202, "scope");
@@ -654,51 +656,51 @@ unique_ptr<LogicalOperator> LogicalSet::FormatDeserialize(FormatDeserializer &de
 	return std::move(result);
 }
 
-void LogicalSetOperation::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalSetOperation::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "column_count", column_count);
 }
 
-unique_ptr<LogicalOperator> LogicalSetOperation::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalSetOperation::Deserialize(Deserializer &deserializer) {
 	auto table_index = deserializer.ReadProperty<idx_t>(200, "table_index");
 	auto column_count = deserializer.ReadProperty<idx_t>(201, "column_count");
 	auto result = duckdb::unique_ptr<LogicalSetOperation>(new LogicalSetOperation(table_index, column_count, deserializer.Get<LogicalOperatorType>()));
 	return std::move(result);
 }
 
-void LogicalShow::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalShow::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "types_select", types_select);
 	serializer.WriteProperty(201, "aliases", aliases);
 }
 
-unique_ptr<LogicalOperator> LogicalShow::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalShow::Deserialize(Deserializer &deserializer) {
 	auto result = duckdb::unique_ptr<LogicalShow>(new LogicalShow());
 	deserializer.ReadProperty(200, "types_select", result->types_select);
 	deserializer.ReadProperty(201, "aliases", result->aliases);
 	return std::move(result);
 }
 
-void LogicalSimple::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalSimple::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "info", info);
 }
 
-unique_ptr<LogicalOperator> LogicalSimple::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalSimple::Deserialize(Deserializer &deserializer) {
 	auto info = deserializer.ReadProperty<unique_ptr<ParseInfo>>(200, "info");
 	auto result = duckdb::unique_ptr<LogicalSimple>(new LogicalSimple(deserializer.Get<LogicalOperatorType>(), std::move(info)));
 	return std::move(result);
 }
 
-void LogicalTopN::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalTopN::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "orders", orders);
 	serializer.WriteProperty(201, "limit", limit);
 	serializer.WriteProperty(202, "offset", offset);
 }
 
-unique_ptr<LogicalOperator> LogicalTopN::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalTopN::Deserialize(Deserializer &deserializer) {
 	auto orders = deserializer.ReadProperty<vector<BoundOrderByNode>>(200, "orders");
 	auto limit = deserializer.ReadProperty<idx_t>(201, "limit");
 	auto offset = deserializer.ReadProperty<idx_t>(202, "offset");
@@ -706,21 +708,21 @@ unique_ptr<LogicalOperator> LogicalTopN::FormatDeserialize(FormatDeserializer &d
 	return std::move(result);
 }
 
-void LogicalUnnest::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalUnnest::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "unnest_index", unnest_index);
 	serializer.WriteProperty(201, "expressions", expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalUnnest::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalUnnest::Deserialize(Deserializer &deserializer) {
 	auto unnest_index = deserializer.ReadProperty<idx_t>(200, "unnest_index");
 	auto result = duckdb::unique_ptr<LogicalUnnest>(new LogicalUnnest(unnest_index));
 	deserializer.ReadProperty(201, "expressions", result->expressions);
 	return std::move(result);
 }
 
-void LogicalUpdate::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalUpdate::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "catalog", table.ParentCatalog().GetName());
 	serializer.WriteProperty(201, "schema", table.ParentSchema().name);
 	serializer.WriteProperty(202, "table", table.name);
@@ -732,7 +734,7 @@ void LogicalUpdate::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(208, "update_is_del_and_insert", update_is_del_and_insert);
 }
 
-unique_ptr<LogicalOperator> LogicalUpdate::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(Deserializer &deserializer) {
 	auto catalog = deserializer.ReadProperty<string>(200, "catalog");
 	auto schema = deserializer.ReadProperty<string>(201, "schema");
 	auto table = deserializer.ReadProperty<string>(202, "table");
@@ -746,13 +748,13 @@ unique_ptr<LogicalOperator> LogicalUpdate::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
-void LogicalWindow::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalWindow::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "window_index", window_index);
 	serializer.WriteProperty(201, "expressions", expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalWindow::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalWindow::Deserialize(Deserializer &deserializer) {
 	auto window_index = deserializer.ReadProperty<idx_t>(200, "window_index");
 	auto result = duckdb::unique_ptr<LogicalWindow>(new LogicalWindow(window_index));
 	deserializer.ReadProperty(201, "expressions", result->expressions);