duckdb 0.8.2-dev4126.0 → 0.8.2-dev4203.0

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

package/src/duckdb/src/parser/result_modifier.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/result_modifier.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression_util.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,38 +9,6 @@ bool ResultModifier::Equals(const ResultModifier &other) const {
 	return type == other.type;
 }
 
-void ResultModifier::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ResultModifierType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<ResultModifier> ResultModifier::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ResultModifierType>();
-
-	unique_ptr<ResultModifier> result;
-	switch (type) {
-	case ResultModifierType::LIMIT_MODIFIER:
-		result = LimitModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::ORDER_MODIFIER:
-		result = OrderModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::DISTINCT_MODIFIER:
-		result = DistinctModifier::Deserialize(reader);
-		break;
-	case ResultModifierType::LIMIT_PERCENT_MODIFIER:
-		result = LimitPercentModifier::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized ResultModifierType for Deserialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
 bool LimitModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -67,18 +34,6 @@ unique_ptr<ResultModifier> LimitModifier::Copy() const {
 	return std::move(copy);
 }
 
-void LimitModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<ResultModifier> LimitModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<LimitModifier>();
-	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
-	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(mod);
-}
-
 bool DistinctModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -98,16 +53,6 @@ unique_ptr<ResultModifier> DistinctModifier::Copy() const {
 	return std::move(copy);
 }
 
-void DistinctModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(distinct_on_targets);
-}
-
-unique_ptr<ResultModifier> DistinctModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<DistinctModifier>();
-	mod->distinct_on_targets = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return std::move(mod);
-}
-
 bool OrderModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -171,33 +116,6 @@ string OrderByNode::ToString() const {
 	return str;
 }
 
-void OrderByNode::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<OrderType>(type);
-	writer.WriteField<OrderByNullType>(null_order);
-	writer.WriteSerializable(*expression);
-	writer.Finalize();
-}
-
-OrderByNode OrderByNode::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<OrderType>();
-	auto null_order = reader.ReadRequired<OrderByNullType>();
-	auto expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	reader.Finalize();
-	return OrderByNode(type, null_order, std::move(expression));
-}
-
-void OrderModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(orders);
-}
-
-unique_ptr<ResultModifier> OrderModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<OrderModifier>();
-	mod->orders = reader.ReadRequiredSerializableList<OrderByNode, OrderByNode>();
-	return std::move(mod);
-}
-
 bool LimitPercentModifier::Equals(const ResultModifier &other_p) const {
 	if (!ResultModifier::Equals(other_p)) {
 		return false;
@@ -223,16 +141,4 @@ unique_ptr<ResultModifier> LimitPercentModifier::Copy() const {
 	return std::move(copy);
 }
 
-void LimitPercentModifier::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(limit);
-	writer.WriteOptional(offset);
-}
-
-unique_ptr<ResultModifier> LimitPercentModifier::Deserialize(FieldReader &reader) {
-	auto mod = make_uniq<LimitPercentModifier>();
-	mod->limit = reader.ReadOptional<ParsedExpression>(nullptr);
-	mod->offset = reader.ReadOptional<ParsedExpression>(nullptr);
-	return std::move(mod);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/statement/select_statement.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/statement/select_statement.hpp"
 
-#include "duckdb/common/serializer.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 {
 
@@ -13,16 +12,6 @@ unique_ptr<SQLStatement> SelectStatement::Copy() const {
 	return unique_ptr<SelectStatement>(new SelectStatement(*this));
 }
 
-void SelectStatement::Serialize(Serializer &serializer) const {
-	node->Serialize(serializer);
-}
-
-unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
-	auto result = make_uniq<SelectStatement>();
-	result->node = QueryNode::Deserialize(source);
-	return result;
-}
-
 bool SelectStatement::Equals(const SQLStatement &other_p) const {
 	if (type != other_p.type) {
 		return false;

package/src/duckdb/src/parser/tableref/basetableref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/basetableref.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 {
 
@@ -24,24 +23,6 @@ bool BaseTableRef::Equals(const TableRef &other_p) const {
 	       column_name_alias == other.column_name_alias;
 }
 
-void BaseTableRef::Serialize(FieldWriter &writer) const {
-	writer.WriteString(schema_name);
-	writer.WriteString(table_name);
-	writer.WriteList<string>(column_name_alias);
-	writer.WriteString(catalog_name);
-}
-
-unique_ptr<TableRef> BaseTableRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<BaseTableRef>();
-
-	result->schema_name = reader.ReadRequired<string>();
-	result->table_name = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	result->catalog_name = reader.ReadField<string>(INVALID_CATALOG);
-
-	return std::move(result);
-}
-
 unique_ptr<TableRef> BaseTableRef::Copy() {
 	auto copy = make_uniq<BaseTableRef>();
 

package/src/duckdb/src/parser/tableref/emptytableref.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/tableref/emptytableref.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 string EmptyTableRef::ToString() const {
@@ -16,11 +14,4 @@ unique_ptr<TableRef> EmptyTableRef::Copy() {
 	return make_uniq<EmptyTableRef>();
 }
 
-void EmptyTableRef::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<TableRef> EmptyTableRef::Deserialize(FieldReader &reader) {
-	return make_uniq<EmptyTableRef>();
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/expressionlistref.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/tableref/expressionlistref.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 {
 
@@ -65,29 +64,4 @@ unique_ptr<TableRef> ExpressionListRef::Copy() {
 	return std::move(result);
 }
 
-void ExpressionListRef::Serialize(FieldWriter &writer) const {
-	writer.WriteList<string>(expected_names);
-	writer.WriteRegularSerializableList<LogicalType>(expected_types);
-	auto &serializer = writer.GetSerializer();
-	writer.WriteField<uint32_t>(values.size());
-	for (idx_t i = 0; i < values.size(); i++) {
-		serializer.WriteList(values[i]);
-	}
-}
-
-unique_ptr<TableRef> ExpressionListRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<ExpressionListRef>();
-	// value list
-	result->expected_names = reader.ReadRequiredList<string>();
-	result->expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	idx_t value_list_size = reader.ReadRequired<uint32_t>();
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < value_list_size; i++) {
-		vector<unique_ptr<ParsedExpression>> value_list;
-		source.ReadList<ParsedExpression>(value_list);
-		result->values.push_back(std::move(value_list));
-	}
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/joinref.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 {
 
@@ -82,24 +81,4 @@ unique_ptr<TableRef> JoinRef::Copy() {
 	return std::move(copy);
 }
 
-void JoinRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-	writer.WriteOptional(condition);
-	writer.WriteField<JoinType>(type);
-	writer.WriteField<JoinRefType>(ref_type);
-	writer.WriteList<string>(using_columns);
-}
-
-unique_ptr<TableRef> JoinRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<JoinRef>(JoinRefType::REGULAR);
-	result->left = reader.ReadRequiredSerializable<TableRef>();
-	result->right = reader.ReadRequiredSerializable<TableRef>();
-	result->condition = reader.ReadOptional<ParsedExpression>(nullptr);
-	result->type = reader.ReadRequired<JoinType>();
-	result->ref_type = reader.ReadRequired<JoinRefType>();
-	result->using_columns = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/tableref/pivotref.hpp"
 
 #include "duckdb/common/limits.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -119,26 +118,6 @@ PivotColumn PivotColumn::Copy() const {
 	return result;
 }
 
-void PivotColumn::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteSerializableList(pivot_expressions);
-	writer.WriteList<string>(unpivot_names);
-	writer.WriteRegularSerializableList(entries);
-	writer.WriteString(pivot_enum);
-	writer.Finalize();
-}
-
-PivotColumn PivotColumn::Deserialize(Deserializer &source) {
-	PivotColumn result;
-	FieldReader reader(source);
-	result.pivot_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result.unpivot_names = reader.ReadRequiredList<string>();
-	result.entries = reader.ReadRequiredSerializableList<PivotColumnEntry, PivotColumnEntry>();
-	result.pivot_enum = reader.ReadRequired<string>();
-	reader.Finalize();
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//
@@ -150,24 +129,6 @@ PivotColumnEntry PivotColumnEntry::Copy() const {
 	return result;
 }
 
-void PivotColumnEntry::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteRegularSerializableList(values);
-	writer.WriteOptional(star_expr);
-	writer.WriteString(alias);
-	writer.Finalize();
-}
-
-PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &source) {
-	PivotColumnEntry result;
-	FieldReader reader(source);
-	result.values = reader.ReadRequiredSerializableList<Value, Value>();
-	result.star_expr = reader.ReadOptional<ParsedExpression>(nullptr);
-	result.alias = reader.ReadRequired<string>();
-	reader.Finalize();
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotRef
 //===--------------------------------------------------------------------===//
@@ -288,26 +249,4 @@ unique_ptr<TableRef> PivotRef::Copy() {
 	return std::move(copy);
 }
 
-void PivotRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*source);
-	writer.WriteSerializableList(aggregates);
-	writer.WriteList<string>(unpivot_names);
-	writer.WriteRegularSerializableList(pivots);
-	writer.WriteList<string>(groups);
-	writer.WriteList<string>(column_name_alias);
-	writer.WriteField<bool>(include_nulls);
-}
-
-unique_ptr<TableRef> PivotRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<PivotRef>();
-	result->source = reader.ReadRequiredSerializable<TableRef>();
-	result->aggregates = reader.ReadRequiredSerializableList<ParsedExpression>();
-	result->unpivot_names = reader.ReadRequiredList<string>();
-	result->pivots = reader.ReadRequiredSerializableList<PivotColumn, PivotColumn>();
-	result->groups = reader.ReadRequiredList<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	result->include_nulls = reader.ReadRequired<bool>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/subqueryref.cpp

@@ -1,9 +1,8 @@
 #include "duckdb/parser/tableref/subqueryref.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 {
 
@@ -35,16 +34,4 @@ unique_ptr<TableRef> SubqueryRef::Copy() {
 	return std::move(copy);
 }
 
-void SubqueryRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*subquery);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> SubqueryRef::Deserialize(FieldReader &reader) {
-	auto subquery = reader.ReadRequiredSerializable<SelectStatement>();
-	auto result = make_uniq<SubqueryRef>(std::move(subquery));
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/table_function.cpp

@@ -1,8 +1,7 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/common/vector.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 {
 
@@ -21,20 +20,6 @@ bool TableFunctionRef::Equals(const TableRef &other_p) const {
 	return function->Equals(*other.function);
 }
 
-void TableFunctionRef::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*function);
-	writer.WriteString(alias);
-	writer.WriteList<string>(column_name_alias);
-}
-
-unique_ptr<TableRef> TableFunctionRef::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<TableFunctionRef>();
-	result->function = reader.ReadRequiredSerializable<ParsedExpression>();
-	result->alias = reader.ReadRequired<string>();
-	result->column_name_alias = reader.ReadRequiredList<string>();
-	return std::move(result);
-}
-
 unique_ptr<TableRef> TableFunctionRef::Copy() {
 	auto copy = make_uniq<TableFunctionRef>();
 

package/src/duckdb/src/parser/tableref.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/tableref.hpp"
 
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/tableref/list.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/common/to_string.hpp"
 
 namespace duckdb {
@@ -44,55 +43,6 @@ bool TableRef::Equals(const TableRef &other) const {
 	return type == other.type && alias == other.alias && SampleOptions::Equals(sample.get(), other.sample.get());
 }
 
-void TableRef::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<TableReferenceType>(type);
-	writer.WriteString(alias);
-	writer.WriteOptional(sample);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<TableRef> TableRef::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-
-	auto type = reader.ReadRequired<TableReferenceType>();
-	auto alias = reader.ReadRequired<string>();
-	auto sample = reader.ReadOptional<SampleOptions>(nullptr);
-	unique_ptr<TableRef> result;
-	switch (type) {
-	case TableReferenceType::BASE_TABLE:
-		result = BaseTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::JOIN:
-		result = JoinRef::Deserialize(reader);
-		break;
-	case TableReferenceType::SUBQUERY:
-		result = SubqueryRef::Deserialize(reader);
-		break;
-	case TableReferenceType::TABLE_FUNCTION:
-		result = TableFunctionRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EMPTY:
-		result = EmptyTableRef::Deserialize(reader);
-		break;
-	case TableReferenceType::EXPRESSION_LIST:
-		result = ExpressionListRef::Deserialize(reader);
-		break;
-	case TableReferenceType::PIVOT:
-		result = PivotRef::Deserialize(reader);
-		break;
-	case TableReferenceType::CTE:
-	case TableReferenceType::INVALID:
-		throw InternalException("Unsupported type for TableRef::Deserialize");
-	}
-	reader.Finalize();
-
-	result->alias = alias;
-	result->sample = std::move(sample);
-	return result;
-}
-
 void TableRef::CopyProperties(TableRef &target) const {
 	D_ASSERT(type == target.type);
 	target.alias = alias;

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

@@ -32,11 +32,8 @@ public:
 	unique_ptr<QueryNode> Copy() const override {
 		throw InternalException("Cannot copy bound subquery node");
 	}
-	void Serialize(FieldWriter &writer) const override {
-		throw InternalException("Cannot serialize bound subquery node");
-	}
 
-	void FormatSerialize(FormatSerializer &serializer) const override {
+	void Serialize(Serializer &serializer) const override {
 		throw InternalException("Cannot serialize bound subquery node");
 	}
 };