duckdb 0.8.2-dev77.0 → 0.9.0

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

@@ -6,35 +6,39 @@
 
 namespace duckdb {
 
-void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
-	writer.WriteOptional(info);
-	writer.WriteString(table.catalog.GetName());
-	writer.WriteString(table.schema.name);
-	writer.WriteString(table.name);
-	FunctionSerializer::SerializeBase<TableFunction>(writer, function, bind_data.get());
-	writer.WriteSerializableList(unbound_expressions);
+LogicalCreateIndex::LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
+                                       TableCatalogEntry &table_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), info(std::move(info_p)), table(table_p) {
+
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
+	}
+	this->expressions = std::move(expressions_p);
+
+	if (info->column_ids.empty()) {
+		throw BinderException("CREATE INDEX does not refer to any columns in the base table!");
+	}
 }
 
-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>();
-	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);
-	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));
+LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info_p,
+                                       vector<unique_ptr<Expression>> expressions_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX),
+      info(unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info_p))), table(BindTable(context, *info)) {
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
 	}
-	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(bind_data), std::move(index_info), std::move(unbound_expressions),
-	                                     table, std::move(function));
+	this->expressions = std::move(expressions_p);
+}
+
+void LogicalCreateIndex::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
+TableCatalogEntry &LogicalCreateIndex::BindTable(ClientContext &context, CreateIndexInfo &info) {
+	auto &catalog = info.catalog;
+	auto &schema = info.schema;
+	auto &table_name = info.table;
+	return Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
 }
 
 } // namespace duckdb

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

@@ -2,18 +2,24 @@
 
 namespace duckdb {
 
-void LogicalCreateTable::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*info);
+LogicalCreateTable::LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(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));
+LogicalCreateTable::LogicalCreateTable(ClientContext &context, unique_ptr<CreateInfo> unbound_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE),
+      schema(Catalog::GetSchema(context, unbound_info->catalog, unbound_info->schema)) {
+	D_ASSERT(unbound_info->type == CatalogType::TABLE_ENTRY);
+	auto binder = Binder::CreateBinder(context);
+	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));
 }
 
 idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
+void LogicalCreateTable::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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,25 +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);
-}
-
-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>();
-	return make_uniq<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns);
-}
-
 vector<idx_t> LogicalCTERef::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -11,24 +11,10 @@ LogicalDelete::LogicalDelete(TableCatalogEntry &table, idx_t table_index)
       return_chunk(false) {
 }
 
-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(), context);
-
-	auto &table_catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, 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);
+LogicalDelete::LogicalDelete(ClientContext &context, const unique_ptr<CreateInfo> &table_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
+                                                 dynamic_cast<CreateTableInfo &>(*table_info).table)) {
 }
 
 idx_t LogicalDelete::EstimateCardinality(ClientContext &context) {

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

@@ -0,0 +1,22 @@
+#include "duckdb/planner/operator/logical_dependent_join.hpp"
+
+namespace duckdb {
+
+LogicalDependentJoin::LogicalDependentJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
+                                           vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+                                           unique_ptr<Expression> condition)
+    : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_DEPENDENT_JOIN), join_condition(std::move(condition)),
+      correlated_columns(std::move(correlated_columns)) {
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
+}
+
+unique_ptr<LogicalOperator> LogicalDependentJoin::Create(unique_ptr<LogicalOperator> left,
+                                                         unique_ptr<LogicalOperator> right,
+                                                         vector<CorrelatedColumnInfo> correlated_columns, JoinType type,
+                                                         unique_ptr<Expression> condition) {
+	return make_uniq<LogicalDependentJoin>(std::move(left), std::move(right), std::move(correlated_columns), type,
+	                                       std::move(condition));
+}
+
+} // namespace duckdb

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

@@ -1,9 +1,16 @@
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 
 namespace duckdb {
 
+LogicalDistinct::LogicalDistinct(DistinctType distinct_type)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
+}
+LogicalDistinct::LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
+      distinct_targets(std::move(targets)) {
+}
+
 string LogicalDistinct::ParamsToString() const {
 	string result = LogicalOperator::ParamsToString();
 	if (!distinct_targets.empty()) {
@@ -13,19 +20,9 @@ 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;
 }
 
 } // namespace duckdb

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,18 +1,44 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
+#include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/main/config.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>();
+void LogicalExtensionOperator::ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings) {
+	// general case
+	// first visit the children of this operator
+	for (auto &child : children) {
+		res.VisitOperator(*child);
+	}
+	// now visit the expressions of this operator to resolve any bound column references
+	for (auto &expression : expressions) {
+		res.VisitExpression(&expression);
+	}
+	// finally update the current set of bindings to the current set of column bindings
+	bindings = GetColumnBindings();
+}
+
+void LogicalExtensionOperator::Serialize(Serializer &serializer) const {
+	LogicalOperator::Serialize(serializer);
+	serializer.WriteProperty(200, "extension_name", GetExtensionName());
+}
+
+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->Deserialize(state, reader);
+			return extension->Deserialize(deserializer);
 		}
 	}
+	throw SerializationException("No deserialization method exists for extension: " + extension_name);
+}
 
-	throw SerializationException("No serialization method exists for extension: " + extension_name);
+string LogicalExtensionOperator::GetExtensionName() const {
+	throw SerializationException("LogicalExtensionOperator::GetExtensionName not implemented which is required for "
+	                             "serializing extension operators");
 }
+
 } // namespace duckdb

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,19 +2,24 @@
 
 #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/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
+LogicalGet::LogicalGet() : LogicalOperator(LogicalOperatorType::LOGICAL_GET) {
+}
+
 LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr<FunctionData> bind_data,
                        vector<LogicalType> returned_types, vector<string> returned_names)
     : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(std::move(function)),
-      bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)) {
+      bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)),
+      extra_info() {
 }
 
 optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
@@ -22,7 +27,7 @@ optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
 }
 
 string LogicalGet::ParamsToString() const {
-	string result;
+	string result = "";
 	for (auto &kv : table_filters.filters) {
 		auto &column_index = kv.first;
 		auto &filter = kv.second;
@@ -31,10 +36,14 @@ string LogicalGet::ParamsToString() const {
 		}
 		result += "\n";
 	}
+	if (!extra_info.file_filters.empty()) {
+		result += "\n[INFOSEPARATOR]\n";
+		result += "File Filters: " + extra_info.file_filters;
+	}
 	if (!function.to_string) {
-		return string();
+		return result;
 	}
-	return function.to_string(bind_data.get());
+	return result + "\n" + function.to_string(bind_data.get());
 }
 
 vector<ColumnBinding> LogicalGet::GetColumnBindings() {
@@ -99,6 +108,10 @@ void LogicalGet::ResolveTypes() {
 }
 
 idx_t LogicalGet::EstimateCardinality(ClientContext &context) {
+	// join order optimizer does better cardinality estimation.
+	if (has_estimated_cardinality) {
+		return estimated_cardinality;
+	}
 	if (function.cardinality) {
 		auto node_stats = function.cardinality(context, bind_data.get());
 		if (node_stats && node_stats->has_estimated_cardinality) {
@@ -108,89 +121,69 @@ 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());
+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::Serialize(serializer, function, bind_data.get());
 	if (!function.serialize) {
-		D_ASSERT(!function.deserialize);
+		D_ASSERT(!function.serialize);
 		// 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);
+		serializer.WriteProperty(206, "parameters", parameters);
+		serializer.WriteProperty(207, "named_parameters", named_parameters);
+		serializer.WriteProperty(208, "input_table_types", input_table_types);
+		serializer.WriteProperty(209, "input_table_names", input_table_names);
 	}
-	writer.WriteList<column_t>(projected_input);
+	serializer.WriteProperty(210, "projected_input", 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<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);
+	deserializer.ReadProperty(202, "names", result->names);
+	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::DeserializeBase<TableFunction, TableFunctionCatalogEntry>(
+	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
+	result->function = entry.first;
+	auto &function = result->function;
+	auto has_serialize = entry.second;
 
 	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());
+	if (!has_serialize) {
+		deserializer.ReadProperty(206, "parameters", result->parameters);
+		deserializer.ReadProperty(207, "named_parameters", result->named_parameters);
+		deserializer.ReadProperty(208, "input_table_types", result->input_table_types);
+		deserializer.ReadProperty(209, "input_table_names", result->input_table_names);
+		TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
+		                             result->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) {
+		if (!function.bind) {
+			throw InternalException("Table function \"%s\" has neither bind nor (de)serialize", function.name);
+		}
+		bind_data = function.bind(deserializer.Get<ClientContext &>(), input, bind_return_types, bind_names);
+		if (result->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()) {
+		if (result->names.size() != bind_names.size()) {
 			throw SerializationException(
 			    "Table function deserialization failure - bind returned different returned names than were serialized");
 		}
+	} else {
+		bind_data = FunctionSerializer::FunctionDeserialize(deserializer, function);
 	}
-	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);
+	result->bind_data = std::move(bind_data);
+	deserializer.ReadProperty(210, "projected_input", result->projected_input);
 	return std::move(result);
 }