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

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

@@ -1,69 +1,15 @@
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
 
 #include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/function/copy_function.hpp"
 
 namespace duckdb {
 
-// Warning: some fields here were added while this code appears untested
-// -> copy test in test/api/test_plan_serialization.cpp was commented out as WIP
-void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
-	writer.WriteString(file_path);
-	writer.WriteField(use_tmp_file);
-	writer.WriteField(overwrite_or_ignore);
-	writer.WriteField(per_thread_output);
-	writer.WriteList<idx_t>(partition_columns);
-
-	D_ASSERT(!function.name.empty());
-	writer.WriteString(function.name);
-
-	writer.WriteField(bind_data != nullptr);
-	if (bind_data && !function.serialize) {
-		throw InvalidInputException("Can't serialize copy function %s", function.name);
-	}
-
-	function.serialize(writer, *bind_data, function);
-}
-
-unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto file_path = reader.ReadRequired<string>();
-	auto use_tmp_file = reader.ReadRequired<bool>();
-	auto overwrite_or_ignore = reader.ReadRequired<bool>();
-	auto per_thread_output = reader.ReadRequired<bool>();
-	auto partition_columns = reader.ReadRequiredList<idx_t>();
-
-	auto copy_func_name = reader.ReadRequired<string>();
-
-	auto has_bind_data = reader.ReadRequired<bool>();
-
-	auto &context = state.gstate.context;
-	auto &copy_func_catalog_entry =
-	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, copy_func_name);
-	auto &copy_func = copy_func_catalog_entry.function;
-
-	unique_ptr<FunctionData> bind_data;
-	if (has_bind_data) {
-		if (!copy_func.deserialize) {
-			throw SerializationException("Have bind info but no deserialization function for %s", copy_func.name);
-		}
-		bind_data = copy_func.deserialize(context, reader, copy_func);
-	}
-
-	auto result = make_uniq<LogicalCopyToFile>(copy_func, std::move(bind_data));
-	result->file_path = file_path;
-	result->use_tmp_file = use_tmp_file;
-	result->overwrite_or_ignore = overwrite_or_ignore;
-	result->per_thread_output = per_thread_output;
-	result->partition_columns = std::move(partition_columns);
-	return std::move(result);
-}
-
-void LogicalCopyToFile::FormatSerialize(FormatSerializer &serializer) const {
+void LogicalCopyToFile::Serialize(Serializer &serializer) const {
 	throw SerializationException("LogicalCopyToFile not implemented yet");
 }
 
-unique_ptr<LogicalOperator> LogicalCopyToFile::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(Deserializer &deserializer) {
 	throw SerializationException("LogicalCopyToFile not implemented yet");
 }
 

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

@@ -12,18 +12,6 @@ LogicalCreate::LogicalCreate(LogicalOperatorType type, ClientContext &context, u
 	this->schema = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
 }
 
-void LogicalCreate::Serialize(FieldWriter &writer) const {
-	info->Serialize(writer.GetSerializer());
-}
-
-unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto info = CreateInfo::Deserialize(reader.GetSource());
-
-	auto schema_catalog_entry = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
-	return make_uniq<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
-}
-
 idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -30,31 +30,6 @@ LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<Create
 	this->expressions = std::move(expressions_p);
 }
 
-void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(info);
-	writer.WriteString(table.catalog.GetName());
-	writer.WriteString(table.schema.name);
-	writer.WriteString(table.name);
-	writer.WriteSerializableList(unbound_expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-
-	auto info = reader.ReadOptional<CreateInfo>(nullptr);
-	auto catalog = reader.ReadRequired<string>();
-	auto schema = reader.ReadRequired<string>();
-	auto table_name = reader.ReadRequired<string>();
-	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	if (info->type != CatalogType::INDEX_ENTRY) {
-		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(info->type),
-		                        CatalogTypeToString(CatalogType::INDEX_ENTRY));
-	}
-	auto index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info));
-	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
-	return make_uniq<LogicalCreateIndex>(std::move(index_info), std::move(unbound_expressions), table);
-}
-
 void LogicalCreateIndex::ResolveTypes() {
 	types.emplace_back(LogicalType::BIGINT);
 }

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

@@ -14,16 +14,6 @@ LogicalCreateTable::LogicalCreateTable(ClientContext &context, const string &cat
 	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));
 }
 
-void LogicalCreateTable::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*info);
-}
-
-unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto info = reader.ReadRequiredSerializable<BoundCreateTableInfo>(state.gstate);
-	auto &schema = info->schema;
-	return make_uniq<LogicalCreateTable>(schema, std::move(info));
-}
-
 idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -17,13 +17,4 @@ unique_ptr<LogicalOperator> LogicalCrossProduct::Create(unique_ptr<LogicalOperat
 	return make_uniq<LogicalCrossProduct>(std::move(left), std::move(right));
 }
 
-void LogicalCrossProduct::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<LogicalOperator> LogicalCrossProduct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	auto result = unique_ptr<LogicalCrossProduct>(new LogicalCrossProduct());
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -1,27 +1,9 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalCTERef::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteField(cte_index);
-	writer.WriteRegularSerializableList(chunk_types);
-	writer.WriteList<string>(bound_columns);
-	writer.WriteField(materialized_cte);
-}
-
-unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto cte_index = reader.ReadRequired<idx_t>();
-	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto bound_columns = reader.ReadRequiredList<string>();
-	auto materialized_cte = reader.ReadField<CTEMaterialize>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT);
-	return make_uniq<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns, materialized_cte);
-}
-
 vector<idx_t> LogicalCTERef::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -16,28 +16,6 @@ LogicalDelete::LogicalDelete(ClientContext &context, const string &catalog, cons
       table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
 }
 
-void LogicalDelete::Serialize(FieldWriter &writer) const {
-	table.Serialize(writer.GetSerializer());
-	writer.WriteField(table_index);
-	writer.WriteField(return_chunk);
-	writer.WriteSerializableList(this->expressions);
-}
-
-unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
-	auto &table_info = info->Cast<CreateTableInfo>();
-
-	auto &table_catalog_entry =
-	    Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, table_info.table);
-
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);
-	result->return_chunk = reader.ReadRequired<bool>();
-	result->expressions = reader.ReadRequiredSerializableList<duckdb::Expression>(state.gstate);
-	return std::move(result);
-}
-
 idx_t LogicalDelete::EstimateCardinality(ClientContext &context) {
 	return return_chunk ? LogicalOperator::EstimateCardinality(context) : 1;
 }

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

@@ -1,21 +1,9 @@
 #include "duckdb/planner/operator/logical_delim_get.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalDelimGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(chunk_types);
-}
-
-unique_ptr<LogicalOperator> LogicalDelimGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	return make_uniq<LogicalDelimGet>(table_index, chunk_types);
-}
-
 vector<idx_t> LogicalDelimGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -19,8 +19,4 @@ unique_ptr<LogicalOperator> LogicalDependentJoin::Create(unique_ptr<LogicalOpera
 	                                       std::move(condition));
 }
 
-void LogicalDependentJoin::Serialize(FieldWriter &writer) const {
-	throw InternalException("LogicalDependentJoin should not exist in any plan");
-}
-
 } // namespace duckdb

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

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 
@@ -22,21 +21,6 @@ string LogicalDistinct::ParamsToString() const {
 	return result;
 }
 
-void LogicalDistinct::Serialize(FieldWriter &writer) const {
-	writer.WriteField<DistinctType>(distinct_type);
-	writer.WriteSerializableList(distinct_targets);
-	writer.WriteOptional(order_by);
-}
-
-unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto distinct_type = reader.ReadRequired<DistinctType>();
-	auto distinct_targets = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto order_by = reader.ReadOptional<BoundOrderModifier>(nullptr, state.gstate);
-	auto ret = make_uniq<LogicalDistinct>(std::move(distinct_targets), distinct_type);
-	ret->order_by = std::move(order_by);
-	return std::move(ret);
-}
-
 void LogicalDistinct::ResolveTypes() {
 	types = children[0]->types;
 }

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

@@ -1,19 +1,9 @@
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalDummyScan::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-}
-
-unique_ptr<LogicalOperator> LogicalDummyScan::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	return make_uniq<LogicalDummyScan>(table_index);
-}
-
 vector<idx_t> LogicalDummyScan::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
 
 namespace duckdb {
@@ -15,18 +14,4 @@ LogicalEmptyResult::LogicalEmptyResult(unique_ptr<LogicalOperator> op)
 LogicalEmptyResult::LogicalEmptyResult() : LogicalOperator(LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
 }
 
-void LogicalEmptyResult::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(return_types);
-	writer.WriteList<ColumnBinding>(bindings);
-}
-
-unique_ptr<LogicalOperator> LogicalEmptyResult::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto return_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto bindings = reader.ReadRequiredList<ColumnBinding>();
-	auto result = unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
-	result->return_types = return_types;
-	result->bindings = bindings;
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -1,33 +1,9 @@
 #include "duckdb/planner/operator/logical_expression_get.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
-void LogicalExpressionGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(expr_types);
-
-	writer.WriteField<idx_t>(expressions.size());
-	for (auto &entry : expressions) {
-		writer.WriteSerializableList(entry);
-	}
-}
-
-unique_ptr<LogicalOperator> LogicalExpressionGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto expr_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-
-	auto expressions_size = reader.ReadRequired<idx_t>();
-	vector<vector<unique_ptr<Expression>>> expressions;
-	for (idx_t i = 0; i < expressions_size; i++) {
-		expressions.push_back(reader.ReadRequiredSerializableList<Expression>(state.gstate));
-	}
-
-	return make_uniq<LogicalExpressionGet>(table_index, expr_types, std::move(expressions));
-}
-
 vector<idx_t> LogicalExpressionGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -1,23 +1,10 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/main/config.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 {
-unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(LogicalDeserializationState &state,
-                                                                           FieldReader &reader) {
-	auto &config = DBConfig::GetConfig(state.gstate.context);
-
-	auto extension_name = reader.ReadRequired<std::string>();
-	for (auto &extension : config.operator_extensions) {
-		if (extension->GetName() == extension_name) {
-			return extension->Deserialize(state, reader);
-		}
-	}
-
-	throw SerializationException("No serialization method exists for extension: " + extension_name);
-}
 
 void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings) {
 	// general case
@@ -33,17 +20,17 @@ void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res,
 	bindings = GetColumnBindings();
 }
 
-void LogicalExtensionOperator::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalExtensionOperator::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "extension_name", GetExtensionName());
 }
 
-unique_ptr<LogicalOperator> LogicalExtensionOperator::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalExtensionOperator::Deserialize(Deserializer &deserializer) {
 	auto &config = DBConfig::GetConfig(deserializer.Get<ClientContext &>());
 	auto extension_name = deserializer.ReadProperty<string>(200, "extension_name");
 	for (auto &extension : config.operator_extensions) {
 		if (extension->GetName() == extension_name) {
-			return extension->FormatDeserialize(deserializer);
+			return extension->Deserialize(deserializer);
 		}
 	}
 	throw SerializationException("No deserialization method exists for extension: " + extension_name);

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

@@ -1,4 +1,3 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 
@@ -43,18 +42,4 @@ bool LogicalFilter::SplitPredicates(vector<unique_ptr<Expression>> &expressions)
 	return found_conjunction;
 }
 
-void LogicalFilter::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList<Expression>(expressions);
-	writer.WriteList<idx_t>(projection_map);
-}
-
-unique_ptr<LogicalOperator> LogicalFilter::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	auto projection_map = reader.ReadRequiredList<idx_t>();
-	auto result = make_uniq<LogicalFilter>();
-	result->expressions = std::move(expressions);
-	result->projection_map = std::move(projection_map);
-	return std::move(result);
-}
-
 } // namespace duckdb

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

@@ -2,14 +2,13 @@
 
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/function_serialization.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/storage/data_table.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 {
 
@@ -122,103 +121,17 @@ idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
-void LogicalGet::Serialize(FieldWriter &writer) const {
-	writer.WriteField(table_index);
-	writer.WriteRegularSerializableList(returned_types);
-	writer.WriteList<string>(names);
-	writer.WriteList<column_t>(column_ids);
-	writer.WriteList<column_t>(projection_ids);
-	writer.WriteSerializable(table_filters);
-
-	FunctionSerializer::SerializeBase<TableFunction>(writer, function, bind_data.get());
-	if (!function.serialize) {
-		D_ASSERT(!function.deserialize);
-		// no serialize method: serialize input values and named_parameters for rebinding purposes
-		writer.WriteRegularSerializableList(parameters);
-		writer.WriteField<idx_t>(named_parameters.size());
-		for (auto &pair : named_parameters) {
-			writer.WriteString(pair.first);
-			writer.WriteSerializable(pair.second);
-		}
-		writer.WriteRegularSerializableList(input_table_types);
-		writer.WriteList<string>(input_table_names);
-	}
-	writer.WriteList<column_t>(projected_input);
-}
-
-unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto returned_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto returned_names = reader.ReadRequiredList<string>();
-	auto column_ids = reader.ReadRequiredList<column_t>();
-	auto projection_ids = reader.ReadRequiredList<column_t>();
-	auto table_filters = reader.ReadRequiredSerializable<TableFilterSet>();
-
-	unique_ptr<FunctionData> bind_data;
-	bool has_deserialize;
-	auto function = FunctionSerializer::DeserializeBaseInternal<TableFunction, TableFunctionCatalogEntry>(
-	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
-
-	vector<Value> parameters;
-	named_parameter_map_t named_parameters;
-	vector<LogicalType> input_table_types;
-	vector<string> input_table_names;
-	if (!has_deserialize) {
-		D_ASSERT(!bind_data);
-		parameters = reader.ReadRequiredSerializableList<Value, Value>();
-
-		auto named_parameters_size = reader.ReadRequired<idx_t>();
-		for (idx_t i = 0; i < named_parameters_size; i++) {
-			auto first = reader.ReadRequired<string>();
-			auto second = reader.ReadRequiredSerializable<Value, Value>();
-			auto pair = make_pair(first, second);
-			named_parameters.insert(pair);
-		}
-
-		input_table_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-		input_table_names = reader.ReadRequiredList<string>();
-		TableFunctionBindInput input(parameters, named_parameters, input_table_types, input_table_names,
-		                             function.function_info.get());
-
-		vector<LogicalType> bind_return_types;
-		vector<string> bind_names;
-		bind_data = function.bind(state.gstate.context, input, bind_return_types, bind_names);
-		if (returned_types != bind_return_types) {
-			throw SerializationException(
-			    "Table function deserialization failure - bind returned different return types than were serialized");
-		}
-		// names can actually be different because of aliases - only the sizes cannot be different
-		if (returned_names.size() != bind_names.size()) {
-			throw SerializationException(
-			    "Table function deserialization failure - bind returned different returned names than were serialized");
-		}
-	}
-	vector<column_t> projected_input;
-	reader.ReadList<column_t>(projected_input);
-
-	auto result = make_uniq<LogicalGet>(table_index, function, std::move(bind_data), returned_types, returned_names);
-	result->column_ids = std::move(column_ids);
-	result->projection_ids = std::move(projection_ids);
-	result->table_filters = std::move(*table_filters);
-	result->parameters = std::move(parameters);
-	result->named_parameters = std::move(named_parameters);
-	result->input_table_types = input_table_types;
-	result->input_table_names = input_table_names;
-	result->projected_input = std::move(projected_input);
-	return std::move(result);
-}
-
-void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
-	LogicalOperator::FormatSerialize(serializer);
+void LogicalGet::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
 	serializer.WriteProperty(200, "table_index", table_index);
 	serializer.WriteProperty(201, "returned_types", returned_types);
 	serializer.WriteProperty(202, "names", names);
 	serializer.WriteProperty(203, "column_ids", column_ids);
 	serializer.WriteProperty(204, "projection_ids", projection_ids);
 	serializer.WriteProperty(205, "table_filters", table_filters);
-	FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
-	if (!function.format_serialize) {
-		D_ASSERT(!function.format_deserialize);
+	FunctionSerializer::Serialize(serializer, function, bind_data.get());
+	if (!function.serialize) {
+		D_ASSERT(!function.serialize);
 		// no serialize method: serialize input values and named_parameters for rebinding purposes
 		serializer.WriteProperty(206, "parameters", parameters);
 		serializer.WriteProperty(207, "named_parameters", named_parameters);
@@ -228,7 +141,7 @@ void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty(210, "projected_input", projected_input);
 }
 
-unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
+unique_ptr<LogicalOperator> LogicalGet::Deserialize(Deserializer &deserializer) {
 	auto result = unique_ptr<LogicalGet>(new LogicalGet());
 	deserializer.ReadProperty(200, "table_index", result->table_index);
 	deserializer.ReadProperty(201, "returned_types", result->returned_types);
@@ -236,9 +149,10 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 	deserializer.ReadProperty(203, "column_ids", result->column_ids);
 	deserializer.ReadProperty(204, "projection_ids", result->projection_ids);
 	deserializer.ReadProperty(205, "table_filters", result->table_filters);
-	auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
+	auto entry = FunctionSerializer::DeserializeBase<TableFunction, TableFunctionCatalogEntry>(
 	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
-	auto &function = entry.first;
+	result->function = entry.first;
+	auto &function = result->function;
 	auto has_serialize = entry.second;
 
 	unique_ptr<FunctionData> bind_data;
@@ -268,6 +182,7 @@ unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &de
 	} else {
 		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
 	}
+	result->bind_data = std::move(bind_data);
 	deserializer.ReadProperty(210, "projected_input", result->projected_input);
 	return std::move(result);
 }