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

package/src/duckdb/src/parser/parsed_data/create_sequence_info.cpp

@@ -24,35 +24,4 @@ unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateSequenceInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteString(schema);
-	writer.WriteField(usage_count);
-	writer.WriteField(increment);
-	writer.WriteField(min_value);
-	writer.WriteField(max_value);
-	writer.WriteField(start_value);
-	writer.WriteField(cycle);
-	writer.Finalize();
-}
-
-unique_ptr<CreateSequenceInfo> CreateSequenceInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateSequenceInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->schema = reader.ReadRequired<string>();
-	result->usage_count = reader.ReadRequired<uint64_t>();
-	result->increment = reader.ReadRequired<int64_t>();
-	result->min_value = reader.ReadRequired<int64_t>();
-	result->max_value = reader.ReadRequired<int64_t>();
-	result->start_value = reader.ReadRequired<int64_t>();
-	result->cycle = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_table_info.cpp

@@ -16,29 +16,6 @@ CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
     : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
 }
 
-void CreateTableInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(table);
-	columns.Serialize(writer);
-	writer.WriteSerializableList(constraints);
-	writer.WriteOptional(query);
-	writer.Finalize();
-}
-
-unique_ptr<CreateTableInfo> CreateTableInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateTableInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->table = reader.ReadRequired<string>();
-	result->columns = ColumnList::Deserialize(reader);
-	result->constraints = reader.ReadRequiredSerializableList<Constraint>();
-	result->query = reader.ReadOptional<SelectStatement>(nullptr);
-	reader.Finalize();
-
-	return result;
-}
-
 unique_ptr<CreateInfo> CreateTableInfo::Copy() const {
 	auto result = make_uniq<CreateTableInfo>(catalog, schema, table);
 	CopyProperties(*result);

package/src/duckdb/src/parser/parsed_data/create_type_info.cpp

@@ -22,26 +22,4 @@ unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
 	return std::move(result);
 }
 
-void CreateTypeInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
-	if (query) {
-		throw InternalException("Cannot serialize CreateTypeInfo with query");
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateTypeInfo> CreateTypeInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateTypeInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return result;
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_view_info.cpp

@@ -28,29 +28,6 @@ unique_ptr<CreateInfo> CreateViewInfo::Copy() const {
 	return std::move(result);
 }
 
-unique_ptr<CreateViewInfo> CreateViewInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<CreateViewInfo>();
-	result->DeserializeBase(deserializer);
-
-	FieldReader reader(deserializer);
-	result->view_name = reader.ReadRequired<string>();
-	result->aliases = reader.ReadRequiredList<string>();
-	result->types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	result->query = reader.ReadOptional<SelectStatement>(nullptr);
-	reader.Finalize();
-
-	return result;
-}
-
-void CreateViewInfo::SerializeInternal(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(view_name);
-	writer.WriteList<string>(aliases);
-	writer.WriteRegularSerializableList(types);
-	writer.WriteOptional(query);
-	writer.Finalize();
-}
-
 unique_ptr<CreateViewInfo> CreateViewInfo::FromSelect(ClientContext &context, unique_ptr<CreateViewInfo> info) {
 	D_ASSERT(info);
 	D_ASSERT(!info->view_name.empty());

package/src/duckdb/src/parser/parsed_data/detach_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/detach_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -13,22 +12,4 @@ unique_ptr<DetachInfo> DetachInfo::Copy() const {
 	return result;
 }
 
-void DetachInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> DetachInfo::Deserialize(Deserializer &deserializer) {
-	auto result = make_uniq<DetachInfo>();
-
-	FieldReader reader(deserializer);
-	result->name = reader.ReadRequired<string>();
-	result->if_not_found = reader.ReadRequired<OnEntryNotFound>();
-	reader.Finalize();
-
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/drop_info.cpp

@@ -17,30 +17,4 @@ unique_ptr<DropInfo> DropInfo::Copy() const {
 	return result;
 }
 
-void DropInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<CatalogType>(type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField(if_not_found);
-	writer.WriteField(cascade);
-	writer.WriteField(allow_drop_internal);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> DropInfo::Deserialize(Deserializer &deserializer) {
-	FieldReader reader(deserializer);
-	auto drop_info = make_uniq<DropInfo>();
-	drop_info->type = reader.ReadRequired<CatalogType>();
-	drop_info->catalog = reader.ReadRequired<string>();
-	drop_info->schema = reader.ReadRequired<string>();
-	drop_info->name = reader.ReadRequired<string>();
-	drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
-	drop_info->cascade = reader.ReadRequired<bool>();
-	drop_info->allow_drop_internal = reader.ReadRequired<bool>();
-	reader.Finalize();
-	return std::move(drop_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/sample_options.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/parsed_data/sample_options.hpp"
-#include "duckdb/common/field_writer.hpp"
-#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"
 
 namespace duckdb {
 
@@ -10,28 +9,6 @@ string SampleMethodToString(SampleMethod method) {
 	return EnumUtil::ToString(method);
 }
 
-void SampleOptions::Serialize(Serializer &serializer) {
-	FieldWriter writer(serializer);
-	writer.WriteSerializable(sample_size);
-	writer.WriteField<bool>(is_percentage);
-	writer.WriteField<SampleMethod>(method);
-	writer.WriteField<int64_t>(seed);
-	writer.Finalize();
-}
-
-unique_ptr<SampleOptions> SampleOptions::Deserialize(Deserializer &source) {
-	auto result = make_uniq<SampleOptions>();
-
-	FieldReader reader(source);
-	result->sample_size = reader.ReadRequiredSerializable<Value, Value>();
-	result->is_percentage = reader.ReadRequired<bool>();
-	result->method = reader.ReadRequired<SampleMethod>();
-	result->seed = reader.ReadRequired<int64_t>();
-	reader.Finalize();
-
-	return result;
-}
-
 unique_ptr<SampleOptions> SampleOptions::Copy() {
 	auto result = make_uniq<SampleOptions>();
 	result->sample_size = sample_size;

package/src/duckdb/src/parser/parsed_data/transaction_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/transaction_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -9,19 +8,4 @@ TransactionInfo::TransactionInfo() : ParseInfo(TYPE) {
 TransactionInfo::TransactionInfo(TransactionType type) : ParseInfo(TYPE), type(type) {
 }
 
-void TransactionInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(type);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
-	FieldReader reader(deserializer);
-	auto transaction_type = reader.ReadRequired<TransactionType>();
-	reader.Finalize();
-
-	auto transaction_info = make_uniq<TransactionInfo>(transaction_type);
-	return std::move(transaction_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/vacuum_info.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/parsed_data/vacuum_info.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -15,23 +14,4 @@ unique_ptr<VacuumInfo> VacuumInfo::Copy() {
 	return result;
 }
 
-void VacuumInfo::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField(options.analyze);
-	writer.WriteField(options.vacuum);
-	writer.Finalize();
-}
-
-unique_ptr<ParseInfo> VacuumInfo::Deserialize(Deserializer &deserializer) {
-
-	VacuumOptions options;
-	FieldReader reader(deserializer);
-	options.analyze = reader.ReadRequired<bool>();
-	options.vacuum = reader.ReadRequired<bool>();
-	reader.Finalize();
-
-	auto vacuum_info = make_uniq<VacuumInfo>(options);
-	return std::move(vacuum_info);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/main/client_context.hpp"
 
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
-#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/parser/expression_util.hpp"
 
 namespace duckdb {
@@ -101,82 +100,6 @@ hash_t ParsedExpression::Hash() const {
 	return hash;
 }
 
-void ParsedExpression::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ExpressionClass>(GetExpressionClass());
-	writer.WriteField<ExpressionType>(type);
-	writer.WriteString(alias);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<ParsedExpression> ParsedExpression::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto expression_class = reader.ReadRequired<ExpressionClass>();
-	auto type = reader.ReadRequired<ExpressionType>();
-	auto alias = reader.ReadRequired<string>();
-	unique_ptr<ParsedExpression> result;
-	switch (expression_class) {
-	case ExpressionClass::BETWEEN:
-		result = BetweenExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CASE:
-		result = CaseExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CAST:
-		result = CastExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COLLATE:
-		result = CollateExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COLUMN_REF:
-		result = ColumnRefExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::COMPARISON:
-		result = ComparisonExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CONJUNCTION:
-		result = ConjunctionExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::CONSTANT:
-		result = ConstantExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::DEFAULT:
-		result = DefaultExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::FUNCTION:
-		result = FunctionExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::LAMBDA:
-		result = LambdaExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::OPERATOR:
-		result = OperatorExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::PARAMETER:
-		result = ParameterExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		result = PositionalReferenceExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::STAR:
-		result = StarExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::SUBQUERY:
-		result = SubqueryExpression::Deserialize(type, reader);
-		break;
-	case ExpressionClass::WINDOW:
-		result = WindowExpression::Deserialize(type, reader);
-		break;
-	default:
-		throw SerializationException("Unsupported type for expression deserialization: '%s'!",
-		                             ExpressionClassToString(expression_class));
-	}
-	result->alias = alias;
-	reader.Finalize();
-	return result;
-}
-
 bool ParsedExpression::Equals(const unique_ptr<ParsedExpression> &left, const unique_ptr<ParsedExpression> &right) {
 	if (left.get() == right.get()) {
 		return true;

package/src/duckdb/src/parser/query_node/cte_node.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/query_node/cte_node.hpp"
-#include "duckdb/common/field_writer.hpp"
-#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"
 
 namespace duckdb {
 
@@ -39,20 +38,4 @@ unique_ptr<QueryNode> CTENode::Copy() const {
 	return std::move(result);
 }
 
-void CTENode::Serialize(FieldWriter &writer) const {
-	writer.WriteString(ctename);
-	writer.WriteSerializable(*query);
-	writer.WriteSerializable(*child);
-	writer.WriteList<string>(aliases);
-}
-
-unique_ptr<QueryNode> CTENode::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<CTENode>();
-	result->ctename = reader.ReadRequired<string>();
-	result->query = reader.ReadRequiredSerializable<QueryNode>();
-	result->child = reader.ReadRequiredSerializable<QueryNode>();
-	result->aliases = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/recursive_cte_node.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
-#include "duckdb/common/field_writer.hpp"
-#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"
 
 namespace duckdb {
 
@@ -48,22 +47,4 @@ unique_ptr<QueryNode> RecursiveCTENode::Copy() const {
 	return std::move(result);
 }
 
-void RecursiveCTENode::Serialize(FieldWriter &writer) const {
-	writer.WriteString(ctename);
-	writer.WriteField<bool>(union_all);
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-	writer.WriteList<string>(aliases);
-}
-
-unique_ptr<QueryNode> RecursiveCTENode::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<RecursiveCTENode>();
-	result->ctename = reader.ReadRequired<string>();
-	result->union_all = reader.ReadRequired<bool>();
-	result->left = reader.ReadRequiredSerializable<QueryNode>();
-	result->right = reader.ReadRequiredSerializable<QueryNode>();
-	result->aliases = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression_util.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
-#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"
 
 namespace duckdb {
 
@@ -168,48 +167,4 @@ unique_ptr<QueryNode> SelectNode::Copy() const {
 	return std::move(result);
 }
 
-void SelectNode::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(select_list);
-	writer.WriteOptional(from_table);
-	writer.WriteOptional(where_clause);
-	writer.WriteSerializableList(groups.group_expressions);
-	writer.WriteField<uint32_t>(groups.grouping_sets.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &grouping_set : groups.grouping_sets) {
-		serializer.Write<idx_t>(grouping_set.size());
-		for (auto &idx : grouping_set) {
-			serializer.Write<idx_t>(idx);
-		}
-	}
-	writer.WriteField<AggregateHandling>(aggregate_handling);
-	writer.WriteOptional(having);
-	writer.WriteOptional(sample);
-	writer.WriteOptional(qualify);
-}
-
-unique_ptr<QueryNode> SelectNode::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<SelectNode>();
-	result->select_list = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result->from_table = reader.ReadOptional<TableRef>(nullptr);
-	result->where_clause = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->groups.group_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-
-	auto grouping_set_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t set_idx = 0; set_idx < grouping_set_count; set_idx++) {
-		auto set_entries = source.Read<idx_t>();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < set_entries; i++) {
-			grouping_set.insert(source.Read<idx_t>());
-		}
-		result->groups.grouping_sets.push_back(grouping_set);
-	}
-
-	result->aggregate_handling = reader.ReadRequired<AggregateHandling>();
-	result->having = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->sample = reader.ReadOptional<SampleOptions>(nullptr);
-	result->qualify = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/query_node/set_operation_node.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-#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"
 
 namespace duckdb {
 
@@ -69,18 +68,4 @@ unique_ptr<QueryNode> SetOperationNode::Copy() const {
 	return std::move(result);
 }
 
-void SetOperationNode::Serialize(FieldWriter &writer) const {
-	writer.WriteField<SetOperationType>(setop_type);
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-}
-
-unique_ptr<QueryNode> SetOperationNode::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<SetOperationNode>();
-	result->setop_type = reader.ReadRequired<SetOperationType>();
-	result->left = reader.ReadRequiredSerializable<QueryNode>();
-	result->right = reader.ReadRequiredSerializable<QueryNode>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/query_node.cpp

@@ -5,9 +5,8 @@
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
 #include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
-#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"
 
 namespace duckdb {
 
@@ -162,65 +161,6 @@ void QueryNode::CopyProperties(QueryNode &other) const {
 	}
 }
 
-void QueryNode::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteField<QueryNodeType>(type);
-	writer.WriteSerializableList(modifiers);
-	// cte_map
-
-	writer.WriteField<uint32_t>((uint32_t)cte_map.map.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &cte : cte_map.map) {
-		serializer.WriteString(cte.first);
-		serializer.WriteStringVector(cte.second->aliases);
-		cte.second->query->Serialize(serializer);
-		writer.WriteField<CTEMaterialize>(cte.second->materialized);
-	}
-	Serialize(writer);
-
-	writer.Finalize();
-}
-
-unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
-	FieldReader reader(main_source);
-
-	auto type = reader.ReadRequired<QueryNodeType>();
-	auto modifiers = reader.ReadRequiredSerializableList<ResultModifier>();
-	// cte_map
-	auto cte_count = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	case_insensitive_map_t<unique_ptr<CommonTableExpressionInfo>> new_map;
-	for (idx_t i = 0; i < cte_count; i++) {
-		auto name = source.Read<string>();
-		auto info = make_uniq<CommonTableExpressionInfo>();
-		source.ReadStringVector(info->aliases);
-		info->query = SelectStatement::Deserialize(source);
-		info->materialized = reader.ReadField<CTEMaterialize>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT);
-		new_map[name] = std::move(info);
-	}
-	unique_ptr<QueryNode> result;
-	switch (type) {
-	case QueryNodeType::SELECT_NODE:
-		result = SelectNode::Deserialize(reader);
-		break;
-	case QueryNodeType::SET_OPERATION_NODE:
-		result = SetOperationNode::Deserialize(reader);
-		break;
-	case QueryNodeType::RECURSIVE_CTE_NODE:
-		result = RecursiveCTENode::Deserialize(reader);
-		break;
-	case QueryNodeType::CTE_NODE:
-		result = CTENode::Deserialize(reader);
-		break;
-	default:
-		throw SerializationException("Could not deserialize Query Node: unknown type!");
-	}
-	result->modifiers = std::move(modifiers);
-	result->cte_map.map = std::move(new_map);
-	reader.Finalize();
-	return result;
-}
-
 void QueryNode::AddDistinct() {
 	// check if we already have a DISTINCT modifier
 	for (idx_t modifier_idx = modifiers.size(); modifier_idx > 0; modifier_idx--) {