duckdb 0.8.2-dev2090.0 → 0.8.2-dev2133.0

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -162,4 +162,51 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializat
 	return std::move(result);
 }
 
+void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const {
+	Expression::FormatSerialize(serializer);
+	serializer.WriteProperty("return_type", return_type);
+	serializer.WriteProperty("children", children);
+	if (type == ExpressionType::WINDOW_AGGREGATE) {
+		D_ASSERT(aggregate);
+		FunctionSerializer::FormatSerialize(serializer, *aggregate, bind_info.get());
+	}
+	serializer.WriteProperty("partitions", partitions);
+	serializer.WriteProperty("orders", orders);
+	serializer.WriteOptionalProperty("filters", filter_expr);
+	serializer.WriteProperty("ignore_nulls", ignore_nulls);
+	serializer.WriteProperty("start", start);
+	serializer.WriteProperty("end", end);
+	serializer.WriteOptionalProperty("start_expr", start_expr);
+	serializer.WriteOptionalProperty("end_expr", end_expr);
+	serializer.WriteOptionalProperty("offset_expr", offset_expr);
+	serializer.WriteOptionalProperty("default_expr", default_expr);
+}
+
+unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression_type = deserializer.Get<ExpressionType>();
+	auto return_type = deserializer.ReadProperty<LogicalType>("return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("children");
+	unique_ptr<AggregateFunction> aggregate;
+	unique_ptr<FunctionData> bind_info;
+	if (expression_type == ExpressionType::WINDOW_AGGREGATE) {
+		auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
+		    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
+		aggregate = make_uniq<AggregateFunction>(std::move(entry.first));
+		bind_info = std::move(entry.second);
+	}
+	auto result =
+	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
+	deserializer.ReadProperty("partitions", result->partitions);
+	deserializer.ReadProperty("orders", result->orders);
+	deserializer.ReadOptionalProperty("filters", result->filter_expr);
+	deserializer.ReadProperty("ignore_nulls", result->ignore_nulls);
+	deserializer.ReadProperty("start", result->start);
+	deserializer.ReadProperty("end", result->end);
+	deserializer.ReadOptionalProperty("start_expr", result->start_expr);
+	deserializer.ReadOptionalProperty("end_expr", result->end_expr);
+	deserializer.ReadOptionalProperty("offset_expr", result->offset_expr);
+	deserializer.ReadOptionalProperty("default_expr", result->default_expr);
+	return std::move(result);
+}
+
 } // namespace duckdb

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

@@ -59,6 +59,14 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	return std::move(result);
 }
 
+void LogicalCopyToFile::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
+unique_ptr<LogicalOperator> LogicalCopyToFile::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
 idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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

@@ -8,9 +8,14 @@
 #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"
 
 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)),
@@ -199,6 +204,70 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(LogicalDeserializationState
 	return std::move(result);
 }
 
+void LogicalGet::FormatSerialize(FormatSerializer &serializer) const {
+	LogicalOperator::FormatSerialize(serializer);
+	serializer.WriteProperty("table_index", table_index);
+	serializer.WriteProperty("returned_types", returned_types);
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("column_ids", column_ids);
+	serializer.WriteProperty("projection_ids", projection_ids);
+	serializer.WriteProperty("table_filters", table_filters);
+	FunctionSerializer::FormatSerialize(serializer, function, bind_data.get());
+	if (!function.format_serialize) {
+		D_ASSERT(!function.format_deserialize);
+		// no serialize method: serialize input values and named_parameters for rebinding purposes
+		serializer.WriteProperty("parameters", parameters);
+		serializer.WriteProperty("named_parameters", named_parameters);
+		serializer.WriteProperty("input_table_types", input_table_types);
+		serializer.WriteProperty("input_table_names", input_table_names);
+	}
+	serializer.WriteProperty("projected_input", projected_input);
+}
+
+unique_ptr<LogicalOperator> LogicalGet::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = unique_ptr<LogicalGet>(new LogicalGet());
+	deserializer.ReadProperty("table_index", result->table_index);
+	deserializer.ReadProperty("returned_types", result->returned_types);
+	deserializer.ReadProperty("names", result->names);
+	deserializer.ReadProperty("column_ids", result->column_ids);
+	deserializer.ReadProperty("projection_ids", result->projection_ids);
+	deserializer.ReadProperty("table_filters", result->table_filters);
+	auto entry = FunctionSerializer::FormatDeserializeBase<TableFunction, TableFunctionCatalogEntry>(
+	    deserializer, CatalogType::TABLE_FUNCTION_ENTRY);
+	auto &function = entry.first;
+	auto has_serialize = entry.second;
+
+	unique_ptr<FunctionData> bind_data;
+	if (!has_serialize) {
+		deserializer.ReadProperty("parameters", result->parameters);
+		deserializer.ReadProperty("named_parameters", result->named_parameters);
+		deserializer.ReadProperty("input_table_types", result->input_table_types);
+		deserializer.ReadProperty("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;
+		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 (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);
+	}
+	deserializer.ReadProperty("projected_input", result->projected_input);
+	return std::move(result);
+}
+
 vector<idx_t> LogicalGet::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }

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

@@ -22,6 +22,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	deserializer.Set<ExpressionType>(type);
 	unique_ptr<Expression> result;
 	switch (expression_class) {
+	case ExpressionClass::BOUND_AGGREGATE:
+		result = BoundAggregateExpression::FormatDeserialize(deserializer);
+		break;
 	case ExpressionClass::BOUND_BETWEEN:
 		result = BoundBetweenExpression::FormatDeserialize(deserializer);
 		break;
@@ -46,6 +49,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	case ExpressionClass::BOUND_DEFAULT:
 		result = BoundDefaultExpression::FormatDeserialize(deserializer);
 		break;
+	case ExpressionClass::BOUND_FUNCTION:
+		result = BoundFunctionExpression::FormatDeserialize(deserializer);
+		break;
 	case ExpressionClass::BOUND_LAMBDA:
 		result = BoundLambdaExpression::FormatDeserialize(deserializer);
 		break;
@@ -64,6 +70,9 @@ unique_ptr<Expression> Expression::FormatDeserialize(FormatDeserializer &deseria
 	case ExpressionClass::BOUND_UNNEST:
 		result = BoundUnnestExpression::FormatDeserialize(deserializer);
 		break;
+	case ExpressionClass::BOUND_WINDOW:
+		result = BoundWindowExpression::FormatDeserialize(deserializer);
+		break;
 	default:
 		throw SerializationException("Unsupported type for deserialization of Expression!");
 	}

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

@@ -40,6 +40,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
+		result = LogicalCopyToFile::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 		result = LogicalCreate::FormatDeserialize(deserializer);
 		break;
@@ -97,6 +100,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_FILTER:
 		result = LogicalFilter::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_GET:
+		result = LogicalGet::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_INSERT:
 		result = LogicalInsert::FormatDeserialize(deserializer);
 		break;

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

@@ -22,6 +22,12 @@
 #include "duckdb/planner/expression/bound_parameter_data.hpp"
 #include "duckdb/planner/joinside.hpp"
 #include "duckdb/parser/parsed_data/vacuum_info.hpp"
+#include "duckdb/planner/table_filter.hpp"
+#include "duckdb/common/multi_file_reader_options.hpp"
+#include "duckdb/common/multi_file_reader.hpp"
+#include "duckdb/execution/operator/persistent/csv_reader_options.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
+#include "duckdb/function/table/read_csv.hpp"
 
 namespace duckdb {
 
@@ -79,6 +85,86 @@ BoundPivotInfo BoundPivotInfo::FormatDeserialize(FormatDeserializer &deserialize
 	return result;
 }
 
+void BufferedCSVReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("has_delimiter", has_delimiter);
+	serializer.WriteProperty("delimiter", delimiter);
+	serializer.WriteProperty("has_quote", has_quote);
+	serializer.WriteProperty("quote", quote);
+	serializer.WriteProperty("has_escape", has_escape);
+	serializer.WriteProperty("escape", escape);
+	serializer.WriteProperty("has_header", has_header);
+	serializer.WriteProperty("header", header);
+	serializer.WriteProperty("ignore_errors", ignore_errors);
+	serializer.WriteProperty("num_cols", num_cols);
+	serializer.WriteProperty("buffer_sample_size", buffer_sample_size);
+	serializer.WriteProperty("null_str", null_str);
+	serializer.WriteProperty("compression", compression);
+	serializer.WriteProperty("new_line", new_line);
+	serializer.WriteProperty("allow_quoted_nulls", allow_quoted_nulls);
+	serializer.WriteProperty("skip_rows", skip_rows);
+	serializer.WriteProperty("skip_rows_set", skip_rows_set);
+	serializer.WriteProperty("maximum_line_size", maximum_line_size);
+	serializer.WriteProperty("normalize_names", normalize_names);
+	serializer.WriteProperty("force_not_null", force_not_null);
+	serializer.WriteProperty("all_varchar", all_varchar);
+	serializer.WriteProperty("sample_chunk_size", sample_chunk_size);
+	serializer.WriteProperty("sample_chunks", sample_chunks);
+	serializer.WriteProperty("auto_detect", auto_detect);
+	serializer.WriteProperty("file_path", file_path);
+	serializer.WriteProperty("decimal_separator", decimal_separator);
+	serializer.WriteProperty("null_padding", null_padding);
+	serializer.WriteProperty("buffer_size", buffer_size);
+	serializer.WriteProperty("file_options", file_options);
+	serializer.WriteProperty("force_quote", force_quote);
+	serializer.WriteProperty("date_format", date_format);
+	serializer.WriteProperty("has_format", has_format);
+	serializer.WriteProperty("rejects_table_name", rejects_table_name);
+	serializer.WriteProperty("rejects_limit", rejects_limit);
+	serializer.WriteProperty("rejects_recovery_columns", rejects_recovery_columns);
+	serializer.WriteProperty("rejects_recovery_column_ids", rejects_recovery_column_ids);
+}
+
+BufferedCSVReaderOptions BufferedCSVReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	BufferedCSVReaderOptions result;
+	deserializer.ReadProperty("has_delimiter", result.has_delimiter);
+	deserializer.ReadProperty("delimiter", result.delimiter);
+	deserializer.ReadProperty("has_quote", result.has_quote);
+	deserializer.ReadProperty("quote", result.quote);
+	deserializer.ReadProperty("has_escape", result.has_escape);
+	deserializer.ReadProperty("escape", result.escape);
+	deserializer.ReadProperty("has_header", result.has_header);
+	deserializer.ReadProperty("header", result.header);
+	deserializer.ReadProperty("ignore_errors", result.ignore_errors);
+	deserializer.ReadProperty("num_cols", result.num_cols);
+	deserializer.ReadProperty("buffer_sample_size", result.buffer_sample_size);
+	deserializer.ReadProperty("null_str", result.null_str);
+	deserializer.ReadProperty("compression", result.compression);
+	deserializer.ReadProperty("new_line", result.new_line);
+	deserializer.ReadProperty("allow_quoted_nulls", result.allow_quoted_nulls);
+	deserializer.ReadProperty("skip_rows", result.skip_rows);
+	deserializer.ReadProperty("skip_rows_set", result.skip_rows_set);
+	deserializer.ReadProperty("maximum_line_size", result.maximum_line_size);
+	deserializer.ReadProperty("normalize_names", result.normalize_names);
+	deserializer.ReadProperty("force_not_null", result.force_not_null);
+	deserializer.ReadProperty("all_varchar", result.all_varchar);
+	deserializer.ReadProperty("sample_chunk_size", result.sample_chunk_size);
+	deserializer.ReadProperty("sample_chunks", result.sample_chunks);
+	deserializer.ReadProperty("auto_detect", result.auto_detect);
+	deserializer.ReadProperty("file_path", result.file_path);
+	deserializer.ReadProperty("decimal_separator", result.decimal_separator);
+	deserializer.ReadProperty("null_padding", result.null_padding);
+	deserializer.ReadProperty("buffer_size", result.buffer_size);
+	deserializer.ReadProperty("file_options", result.file_options);
+	deserializer.ReadProperty("force_quote", result.force_quote);
+	deserializer.ReadProperty("date_format", result.date_format);
+	deserializer.ReadProperty("has_format", result.has_format);
+	deserializer.ReadProperty("rejects_table_name", result.rejects_table_name);
+	deserializer.ReadProperty("rejects_limit", result.rejects_limit);
+	deserializer.ReadProperty("rejects_recovery_columns", result.rejects_recovery_columns);
+	deserializer.ReadProperty("rejects_recovery_column_ids", result.rejects_recovery_column_ids);
+	return result;
+}
+
 void CaseCheck::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("when_expr", *when_expr);
 	serializer.WriteProperty("then_expr", *then_expr);
@@ -121,6 +207,18 @@ ColumnDefinition ColumnDefinition::FormatDeserialize(FormatDeserializer &deseria
 	return result;
 }
 
+void ColumnInfo::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("types", types);
+}
+
+ColumnInfo ColumnInfo::FormatDeserialize(FormatDeserializer &deserializer) {
+	ColumnInfo result;
+	deserializer.ReadProperty("names", result.names);
+	deserializer.ReadProperty("types", result.types);
+	return result;
+}
+
 void ColumnList::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("columns", columns);
 }
@@ -155,6 +253,18 @@ CommonTableExpressionMap CommonTableExpressionMap::FormatDeserialize(FormatDeser
 	return result;
 }
 
+void HivePartitioningIndex::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("value", value);
+	serializer.WriteProperty("index", index);
+}
+
+HivePartitioningIndex HivePartitioningIndex::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto value = deserializer.ReadProperty<string>("value");
+	auto index = deserializer.ReadProperty<idx_t>("index");
+	HivePartitioningIndex result(std::move(value), index);
+	return result;
+}
+
 void JoinCondition::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("left", *left);
 	serializer.WriteProperty("right", *right);
@@ -181,6 +291,38 @@ LogicalType LogicalType::FormatDeserialize(FormatDeserializer &deserializer) {
 	return result;
 }
 
+void MultiFileReaderBindData::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("filename_idx", filename_idx);
+	serializer.WriteProperty("hive_partitioning_indexes", hive_partitioning_indexes);
+}
+
+MultiFileReaderBindData MultiFileReaderBindData::FormatDeserialize(FormatDeserializer &deserializer) {
+	MultiFileReaderBindData result;
+	deserializer.ReadProperty("filename_idx", result.filename_idx);
+	deserializer.ReadProperty("hive_partitioning_indexes", result.hive_partitioning_indexes);
+	return result;
+}
+
+void MultiFileReaderOptions::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("filename", filename);
+	serializer.WriteProperty("hive_partitioning", hive_partitioning);
+	serializer.WriteProperty("auto_detect_hive_partitioning", auto_detect_hive_partitioning);
+	serializer.WriteProperty("union_by_name", union_by_name);
+	serializer.WriteProperty("hive_types_autocast", hive_types_autocast);
+	serializer.WriteProperty("hive_types_schema", hive_types_schema);
+}
+
+MultiFileReaderOptions MultiFileReaderOptions::FormatDeserialize(FormatDeserializer &deserializer) {
+	MultiFileReaderOptions result;
+	deserializer.ReadProperty("filename", result.filename);
+	deserializer.ReadProperty("hive_partitioning", result.hive_partitioning);
+	deserializer.ReadProperty("auto_detect_hive_partitioning", result.auto_detect_hive_partitioning);
+	deserializer.ReadProperty("union_by_name", result.union_by_name);
+	deserializer.ReadProperty("hive_types_autocast", result.hive_types_autocast);
+	deserializer.ReadProperty("hive_types_schema", result.hive_types_schema);
+	return result;
+}
+
 void OrderByNode::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("type", type);
 	serializer.WriteProperty("null_order", null_order);
@@ -211,6 +353,34 @@ PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &deserializer) {
 	return result;
 }
 
+void ReadCSVData::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("files", files);
+	serializer.WriteProperty("csv_types", csv_types);
+	serializer.WriteProperty("csv_names", csv_names);
+	serializer.WriteProperty("return_types", return_types);
+	serializer.WriteProperty("return_names", return_names);
+	serializer.WriteProperty("filename_col_idx", filename_col_idx);
+	serializer.WriteProperty("options", options);
+	serializer.WriteProperty("single_threaded", single_threaded);
+	serializer.WriteProperty("reader_bind", reader_bind);
+	serializer.WriteProperty("column_info", column_info);
+}
+
+unique_ptr<ReadCSVData> ReadCSVData::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ReadCSVData>(new ReadCSVData());
+	deserializer.ReadProperty("files", result->files);
+	deserializer.ReadProperty("csv_types", result->csv_types);
+	deserializer.ReadProperty("csv_names", result->csv_names);
+	deserializer.ReadProperty("return_types", result->return_types);
+	deserializer.ReadProperty("return_names", result->return_names);
+	deserializer.ReadProperty("filename_col_idx", result->filename_col_idx);
+	deserializer.ReadProperty("options", result->options);
+	deserializer.ReadProperty("single_threaded", result->single_threaded);
+	deserializer.ReadProperty("reader_bind", result->reader_bind);
+	deserializer.ReadProperty("column_info", result->column_info);
+	return result;
+}
+
 void SampleOptions::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("sample_size", sample_size);
 	serializer.WriteProperty("is_percentage", is_percentage);
@@ -227,6 +397,26 @@ unique_ptr<SampleOptions> SampleOptions::FormatDeserialize(FormatDeserializer &d
 	return result;
 }
 
+void StrpTimeFormat::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("format_specifier", format_specifier);
+}
+
+StrpTimeFormat StrpTimeFormat::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto format_specifier = deserializer.ReadProperty<string>("format_specifier");
+	StrpTimeFormat result(format_specifier);
+	return result;
+}
+
+void TableFilterSet::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("filters", filters);
+}
+
+TableFilterSet TableFilterSet::FormatDeserialize(FormatDeserializer &deserializer) {
+	TableFilterSet result;
+	deserializer.ReadProperty("filters", result.filters);
+	return result;
+}
+
 void VacuumOptions::FormatSerialize(FormatSerializer &serializer) const {
 	serializer.WriteProperty("vacuum", vacuum);
 	serializer.WriteProperty("analyze", analyze);

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

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+// This file is automatically generated by scripts/generate_serialization.py
+// Do not edit this file manually, your changes will be overwritten
+//===----------------------------------------------------------------------===//
+
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/planner/table_filter.hpp"
+#include "duckdb/planner/filter/null_filter.hpp"
+#include "duckdb/planner/filter/constant_filter.hpp"
+#include "duckdb/planner/filter/conjunction_filter.hpp"
+
+namespace duckdb {
+
+void TableFilter::FormatSerialize(FormatSerializer &serializer) const {
+	serializer.WriteProperty("filter_type", filter_type);
+}
+
+unique_ptr<TableFilter> TableFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto filter_type = deserializer.ReadProperty<TableFilterType>("filter_type");
+	unique_ptr<TableFilter> result;
+	switch (filter_type) {
+	case TableFilterType::CONJUNCTION_AND:
+		result = ConjunctionAndFilter::FormatDeserialize(deserializer);
+		break;
+	case TableFilterType::CONJUNCTION_OR:
+		result = ConjunctionOrFilter::FormatDeserialize(deserializer);
+		break;
+	case TableFilterType::CONSTANT_COMPARISON:
+		result = ConstantFilter::FormatDeserialize(deserializer);
+		break;
+	case TableFilterType::IS_NOT_NULL:
+		result = IsNotNullFilter::FormatDeserialize(deserializer);
+		break;
+	case TableFilterType::IS_NULL:
+		result = IsNullFilter::FormatDeserialize(deserializer);
+		break;
+	default:
+		throw SerializationException("Unsupported type for deserialization of TableFilter!");
+	}
+	return result;
+}
+
+void ConjunctionAndFilter::FormatSerialize(FormatSerializer &serializer) const {
+	TableFilter::FormatSerialize(serializer);
+	serializer.WriteProperty("child_filters", child_filters);
+}
+
+unique_ptr<TableFilter> ConjunctionAndFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ConjunctionAndFilter>(new ConjunctionAndFilter());
+	deserializer.ReadProperty("child_filters", result->child_filters);
+	return std::move(result);
+}
+
+void ConjunctionOrFilter::FormatSerialize(FormatSerializer &serializer) const {
+	TableFilter::FormatSerialize(serializer);
+	serializer.WriteProperty("child_filters", child_filters);
+}
+
+unique_ptr<TableFilter> ConjunctionOrFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<ConjunctionOrFilter>(new ConjunctionOrFilter());
+	deserializer.ReadProperty("child_filters", result->child_filters);
+	return std::move(result);
+}
+
+void ConstantFilter::FormatSerialize(FormatSerializer &serializer) const {
+	TableFilter::FormatSerialize(serializer);
+	serializer.WriteProperty("comparison_type", comparison_type);
+	serializer.WriteProperty("constant", constant);
+}
+
+unique_ptr<TableFilter> ConstantFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto comparison_type = deserializer.ReadProperty<ExpressionType>("comparison_type");
+	auto constant = deserializer.ReadProperty<Value>("constant");
+	auto result = duckdb::unique_ptr<ConstantFilter>(new ConstantFilter(comparison_type, constant));
+	return std::move(result);
+}
+
+void IsNotNullFilter::FormatSerialize(FormatSerializer &serializer) const {
+	TableFilter::FormatSerialize(serializer);
+}
+
+unique_ptr<TableFilter> IsNotNullFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<IsNotNullFilter>(new IsNotNullFilter());
+	return std::move(result);
+}
+
+void IsNullFilter::FormatSerialize(FormatSerializer &serializer) const {
+	TableFilter::FormatSerialize(serializer);
+}
+
+unique_ptr<TableFilter> IsNullFilter::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto result = duckdb::unique_ptr<IsNullFilter>(new IsNullFilter());
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/ub_src_common_serializer.cpp

@@ -10,3 +10,5 @@
 
 #include "src/common/serializer/buffered_serializer.cpp"
 
+#include "src/common/serializer/format_serializer.cpp"
+

package/src/duckdb/ub_src_storage_serialization.cpp

@@ -20,6 +20,8 @@
 
 #include "src/storage/serialization/serialize_statement.cpp"
 
+#include "src/storage/serialization/serialize_table_filter.cpp"
+
 #include "src/storage/serialization/serialize_tableref.cpp"
 
 #include "src/storage/serialization/serialize_types.cpp"