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

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -277,43 +277,23 @@ bool ExportAggregateFunctionBindData::Equals(const FunctionData &other_p) const
 	return aggregate->Equals(*other.aggregate);
 }
 
-static void ExportStateAggregateSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void ExportStateAggregateSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                           const AggregateFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateAggregateDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                                AggregateFunction &bound_function) {
-	throw NotImplementedException("FIXME: export state deserialize");
-}
 
-static void ExportStateAggregateFormatSerialize(FormatSerializer &serializer,
-                                                const optional_ptr<FunctionData> bind_data_p,
-                                                const AggregateFunction &function) {
-	throw SerializationException("FIXME: export state serialize");
-}
-
-static unique_ptr<FunctionData> ExportStateAggregateFormatDeserialize(FormatDeserializer &deserializer,
-                                                                      AggregateFunction &function) {
-	throw SerializationException("FIXME: export state deserialize");
+static unique_ptr<FunctionData> ExportStateAggregateDeserialize(Deserializer &deserializer,
+                                                                AggregateFunction &function) {
+	throw NotImplementedException("FIXME: export state deserialize");
 }
 
-static void ExportStateScalarSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+static void ExportStateScalarSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                        const ScalarFunction &function) {
 	throw NotImplementedException("FIXME: export state serialize");
 }
-static unique_ptr<FunctionData> ExportStateScalarDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                             ScalarFunction &bound_function) {
-	throw NotImplementedException("FIXME: export state deserialize");
-}
 
-static void ExportStateScalarFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                             const ScalarFunction &function) {
-	throw SerializationException("FIXME: export state serialize");
-}
-
-static unique_ptr<FunctionData> ExportStateScalarFormatDeserialize(FormatDeserializer &deserializer,
-                                                                   ScalarFunction &function) {
-	throw SerializationException("FIXME: export state deserialize");
+static unique_ptr<FunctionData> ExportStateScalarDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	throw NotImplementedException("FIXME: export state deserialize");
 }
 
 unique_ptr<BoundAggregateExpression>
@@ -352,8 +332,6 @@ ExportAggregateFunction::Bind(unique_ptr<BoundAggregateExpression> child_aggrega
 	export_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	export_function.serialize = ExportStateAggregateSerialize;
 	export_function.deserialize = ExportStateAggregateDeserialize;
-	export_function.format_serialize = ExportStateAggregateFormatSerialize;
-	export_function.format_deserialize = ExportStateAggregateFormatDeserialize;
 
 	return make_uniq<BoundAggregateExpression>(export_function, std::move(child_aggregate->children),
 	                                           std::move(child_aggregate->filter), std::move(export_bind_data),
@@ -366,8 +344,6 @@ ScalarFunction ExportAggregateFunction::GetFinalize() {
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.serialize = ExportStateScalarSerialize;
 	result.deserialize = ExportStateScalarDeserialize;
-	result.format_serialize = ExportStateScalarFormatSerialize;
-	result.format_deserialize = ExportStateScalarFormatDeserialize;
 	return result;
 }
 
@@ -378,8 +354,6 @@ ScalarFunction ExportAggregateFunction::GetCombine() {
 	result.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	result.serialize = ExportStateScalarSerialize;
 	result.deserialize = ExportStateScalarDeserialize;
-	result.format_serialize = ExportStateScalarFormatSerialize;
-	result.format_deserialize = ExportStateScalarFormatDeserialize;
 	return result;
 }
 

package/src/duckdb/src/function/scalar_function.cpp

@@ -13,8 +13,7 @@ ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, Logic
     : BaseScalarFunction(std::move(name), std::move(arguments), std::move(return_type), side_effects,
                          std::move(varargs), null_handling),
       function(std::move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
-      statistics(statistics), serialize(nullptr), deserialize(nullptr), format_serialize(nullptr),
-      format_deserialize(nullptr) {
+      statistics(statistics), serialize(nullptr), deserialize(nullptr) {
 }
 
 ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -49,14 +49,4 @@ string ScalarMacroFunction::ToSQL(const string &schema, const string &name) cons
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("(%s);", expression_copy->ToString());
 }
 
-void ScalarMacroFunction::SerializeInternal(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<MacroFunction> ScalarMacroFunction::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<ScalarMacroFunction>();
-	result->expression = reader.ReadRequiredSerializable<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/function/table/copy_csv.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/types/string_type.hpp"
@@ -11,6 +10,8 @@
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/common/serializer/write_stream.hpp"
+#include "duckdb/common/serializer/memory_stream.hpp"
 
 #include <limits>
 
@@ -37,10 +38,9 @@ void SubstringDetection(char &str_1, string &str_2, const string &name_str_1, co
 //===--------------------------------------------------------------------===//
 // Bind
 //===--------------------------------------------------------------------===//
-
-void WriteQuoteOrEscape(Serializer &serializer, char quote_or_escape) {
+void WriteQuoteOrEscape(WriteStream &writer, char quote_or_escape) {
 	if (quote_or_escape != '\0') {
-		serializer.Write(quote_or_escape);
+		writer.Write(quote_or_escape);
 	}
 }
 
@@ -214,7 +214,7 @@ static bool RequiresQuotes(WriteCSVData &csv_data, const char *str, idx_t len) {
 	return false;
 }
 
-static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, const char *str, idx_t len,
+static void WriteQuotedString(WriteStream &writer, WriteCSVData &csv_data, const char *str, idx_t len,
                               bool force_quote) {
 	auto &options = csv_data.options;
 	if (!force_quote) {
@@ -236,9 +236,9 @@ static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, co
 
 		if (!requires_escape) {
 			// fast path: no need to escape anything
-			WriteQuoteOrEscape(serializer, options.dialect_options.state_machine_options.quote);
-			serializer.WriteData(const_data_ptr_cast(str), len);
-			WriteQuoteOrEscape(serializer, options.dialect_options.state_machine_options.quote);
+			WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote);
+			writer.WriteData(const_data_ptr_cast(str), len);
+			WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote);
 			return;
 		}
 
@@ -252,11 +252,11 @@ static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, co
 			new_val = AddEscapes(options.dialect_options.state_machine_options.quote,
 			                     options.dialect_options.state_machine_options.escape, new_val);
 		}
-		WriteQuoteOrEscape(serializer, options.dialect_options.state_machine_options.quote);
-		serializer.WriteBufferData(new_val);
-		WriteQuoteOrEscape(serializer, options.dialect_options.state_machine_options.quote);
+		WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote);
+		writer.WriteData(const_data_ptr_cast(new_val.c_str()), new_val.size());
+		WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.quote);
 	} else {
-		serializer.WriteData(const_data_ptr_cast(str), len);
+		writer.WriteData(const_data_ptr_cast(str), len);
 	}
 }
 
@@ -265,7 +265,7 @@ static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, co
 //===--------------------------------------------------------------------===//
 struct LocalWriteCSVData : public LocalFunctionData {
 	//! The thread-local buffer to write data into
-	BufferedSerializer serializer;
+	MemoryStream stream;
 	//! A chunk with VARCHAR columns to cast intermediates into
 	DataChunk cast_chunk;
 	//! If we've written any rows yet, allows us to prevent a trailing comma when writing JSON ARRAY
@@ -333,25 +333,25 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
 	}
 
 	if (options.dialect_options.header) {
-		BufferedSerializer serializer;
+		MemoryStream stream;
 		// write the header line to the file
 		for (idx_t i = 0; i < csv_data.options.name_list.size(); i++) {
 			if (i != 0) {
-				WriteQuoteOrEscape(serializer, options.dialect_options.state_machine_options.delimiter);
+				WriteQuoteOrEscape(stream, options.dialect_options.state_machine_options.delimiter);
 			}
-			WriteQuotedString(serializer, csv_data, csv_data.options.name_list[i].c_str(),
+			WriteQuotedString(stream, csv_data, csv_data.options.name_list[i].c_str(),
 			                  csv_data.options.name_list[i].size(), false);
 		}
-		serializer.WriteBufferData(csv_data.newline);
+		stream.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
 
-		global_data->WriteData(serializer.blob.data.get(), serializer.blob.size);
+		global_data->WriteData(stream.GetData(), stream.GetPosition());
 	}
 
 	return std::move(global_data);
 }
 
 static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_data, DataChunk &cast_chunk,
-                                  BufferedSerializer &writer, DataChunk &input, bool &written_anything) {
+                                  MemoryStream &writer, DataChunk &input, bool &written_anything) {
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &options = csv_data.options;
 
@@ -385,7 +385,7 @@ static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_dat
 		if (row_idx == 0 && !written_anything) {
 			written_anything = true;
 		} else {
-			writer.WriteBufferData(csv_data.newline);
+			writer.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
 		}
 		// write values
 		for (idx_t col_idx = 0; col_idx < cast_chunk.ColumnCount(); col_idx++) {
@@ -394,7 +394,7 @@ static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_dat
 			}
 			if (FlatVector::IsNull(cast_chunk.data[col_idx], row_idx)) {
 				// write null value
-				writer.WriteBufferData(options.null_str);
+				writer.WriteData(const_data_ptr_cast(options.null_str.c_str()), options.null_str.size());
 				continue;
 			}
 
@@ -416,14 +416,14 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
 
 	// write data into the local buffer
-	WriteCSVChunkInternal(context.client, bind_data, local_data.cast_chunk, local_data.serializer, input,
+	WriteCSVChunkInternal(context.client, bind_data, local_data.cast_chunk, local_data.stream, input,
 	                      local_data.written_anything);
 
 	// check if we should flush what we have currently written
-	auto &writer = local_data.serializer;
-	if (writer.blob.size >= csv_data.flush_size) {
-		global_state.WriteRows(writer.blob.data.get(), writer.blob.size, csv_data.newline);
-		writer.Reset();
+	auto &writer = local_data.stream;
+	if (writer.GetPosition() >= csv_data.flush_size) {
+		global_state.WriteRows(writer.GetData(), writer.GetPosition(), csv_data.newline);
+		writer.Rewind();
 		local_data.written_anything = false;
 	}
 }
@@ -436,11 +436,11 @@ static void WriteCSVCombine(ExecutionContext &context, FunctionData &bind_data,
 	auto &local_data = lstate.Cast<LocalWriteCSVData>();
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &writer = local_data.serializer;
+	auto &writer = local_data.stream;
 	// flush the local writer
 	if (local_data.written_anything) {
-		global_state.WriteRows(writer.blob.data.get(), writer.blob.size, csv_data.newline);
-		writer.Reset();
+		global_state.WriteRows(writer.GetData(), writer.GetPosition(), csv_data.newline);
+		writer.Rewind();
 	}
 }
 
@@ -452,13 +452,13 @@ void WriteCSVFinalize(ClientContext &context, FunctionData &bind_data, GlobalFun
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &options = csv_data.options;
 
-	BufferedSerializer serializer;
+	MemoryStream stream;
 	if (!options.suffix.empty()) {
-		serializer.WriteBufferData(options.suffix);
+		stream.WriteData(const_data_ptr_cast(options.suffix.c_str()), options.suffix.size());
 	} else if (global_state.written_anything) {
-		serializer.WriteBufferData(csv_data.newline);
+		stream.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
 	}
-	global_state.WriteData(serializer.blob.data.get(), serializer.blob.size);
+	global_state.WriteData(stream.GetData(), stream.GetPosition());
 
 	global_state.handle->Close();
 	global_state.handle.reset();
@@ -481,7 +481,7 @@ CopyFunctionExecutionMode WriteCSVExecutionMode(bool preserve_insertion_order, b
 //===--------------------------------------------------------------------===//
 struct WriteCSVBatchData : public PreparedBatchData {
 	//! The thread-local buffer to write data into
-	BufferedSerializer serializer;
+	MemoryStream stream;
 };
 
 unique_ptr<PreparedBatchData> WriteCSVPrepareBatch(ClientContext &context, FunctionData &bind_data,
@@ -499,7 +499,7 @@ unique_ptr<PreparedBatchData> WriteCSVPrepareBatch(ClientContext &context, Funct
 	bool written_anything = false;
 	auto batch = make_uniq<WriteCSVBatchData>();
 	for (auto &chunk : collection->Chunks()) {
-		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->serializer, chunk, written_anything);
+		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->stream, chunk, written_anything);
 	}
 	return std::move(batch);
 }
@@ -512,9 +512,9 @@ void WriteCSVFlushBatch(ClientContext &context, FunctionData &bind_data, GlobalF
 	auto &csv_batch = batch.Cast<WriteCSVBatchData>();
 	auto &global_state = gstate.Cast<GlobalWriteCSVData>();
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto &writer = csv_batch.serializer;
-	global_state.WriteRows(writer.blob.data.get(), writer.blob.size, csv_data.newline);
-	writer.Reset();
+	auto &writer = csv_batch.stream;
+	global_state.WriteRows(writer.GetData(), writer.GetPosition(), csv_data.newline);
+	writer.Rewind();
 }
 
 void CSVCopyFunction::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/table/read_csv.cpp

@@ -16,8 +16,8 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/main/extension_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"
 
 #include <limits>
 
@@ -1088,182 +1088,15 @@ unique_ptr<NodeStatistics> CSVReaderCardinality(ClientContext &context, const Fu
 	}
 	return make_uniq<NodeStatistics>(bind_data.files.size() * per_file_cardinality);
 }
-void CSVStateMachineOptions::Serialize(FieldWriter &writer) const {
-	writer.WriteField<char>(delimiter);
-	writer.WriteField<char>(quote);
-	writer.WriteField<char>(escape);
-}
-
-void DialectOptions::Serialize(FieldWriter &writer) const {
-	state_machine_options.Serialize(writer);
-	writer.WriteField<bool>(header);
-	writer.WriteField<idx_t>(num_cols);
-	writer.WriteField<NewLineIdentifier>(new_line);
-	writer.WriteField<idx_t>(skip_rows);
-	vector<string> csv_formats;
-	for (auto &format : date_format) {
-		writer.WriteField(has_format.find(format.first)->second);
-		csv_formats.push_back(format.second.format_specifier);
-	}
-	writer.WriteList<string>(csv_formats);
-}
-void CSVStateMachineOptions::Deserialize(FieldReader &reader) {
-	delimiter = reader.ReadRequired<char>();
-	quote = reader.ReadRequired<char>();
-	escape = reader.ReadRequired<char>();
-}
-void DialectOptions::Deserialize(FieldReader &reader) {
-	state_machine_options.Deserialize(reader);
-	header = reader.ReadRequired<bool>();
-	num_cols = reader.ReadRequired<idx_t>();
-	new_line = reader.ReadRequired<NewLineIdentifier>();
-	skip_rows = reader.ReadRequired<idx_t>();
-
-	bool has_date = reader.ReadRequired<bool>();
-	bool has_timestamp = reader.ReadRequired<bool>();
-	auto formats = reader.ReadRequiredList<string>();
-
-	vector<LogicalTypeId> format_types {LogicalTypeId::DATE, LogicalTypeId::TIMESTAMP};
-	if (has_date) {
-		has_format[LogicalTypeId::DATE] = true;
-	}
-	if (has_timestamp) {
-		has_format[LogicalTypeId::TIMESTAMP] = true;
-	}
-	for (idx_t f_idx = 0; f_idx < formats.size(); f_idx++) {
-		auto &format = formats[f_idx];
-		auto &type = format_types[f_idx];
-		if (format.empty()) {
-			continue;
-		}
-		StrTimeFormat::ParseFormatSpecifier(format, date_format[type]);
-	}
-}
-
-void CSVReaderOptions::Serialize(FieldWriter &writer) const {
-	// common options
-	writer.WriteField<bool>(has_delimiter);
-	writer.WriteField<bool>(has_quote);
-	writer.WriteField<bool>(has_escape);
-	writer.WriteField<bool>(has_header);
-	writer.WriteField<bool>(ignore_errors);
-	writer.WriteField<idx_t>(buffer_sample_size);
-	writer.WriteString(null_str);
-	writer.WriteField<FileCompressionType>(compression);
-	writer.WriteField<bool>(allow_quoted_nulls);
-	// read options
-	writer.WriteField<bool>(skip_rows_set);
-	writer.WriteField<idx_t>(maximum_line_size);
-	writer.WriteField<bool>(normalize_names);
-	writer.WriteListNoReference<bool>(force_not_null);
-	writer.WriteField<bool>(all_varchar);
-	writer.WriteField<idx_t>(sample_chunk_size);
-	writer.WriteField<idx_t>(sample_chunks);
-	writer.WriteField<bool>(auto_detect);
-	writer.WriteString(file_path);
-	writer.WriteString(decimal_separator);
-	writer.WriteField<bool>(null_padding);
-	writer.WriteField<idx_t>(buffer_size);
-	writer.WriteSerializable(file_options);
-	// write options
-	writer.WriteListNoReference<bool>(force_quote);
-
-	// reject options
-	writer.WriteString(rejects_table_name);
-	writer.WriteField<idx_t>(rejects_limit);
-	writer.WriteList<string>(rejects_recovery_columns);
-	writer.WriteList<idx_t>(rejects_recovery_column_ids);
-
-	// Serialize Dialect Options
-	dialect_options.Serialize(writer);
-}
-
-void CSVReaderOptions::Deserialize(FieldReader &reader) {
-	// common options
-	has_delimiter = reader.ReadRequired<bool>();
-	has_quote = reader.ReadRequired<bool>();
-	has_escape = reader.ReadRequired<bool>();
-	has_header = reader.ReadRequired<bool>();
-	ignore_errors = reader.ReadRequired<bool>();
-	buffer_sample_size = reader.ReadRequired<idx_t>();
-	null_str = reader.ReadRequired<string>();
-	compression = reader.ReadRequired<FileCompressionType>();
-	allow_quoted_nulls = reader.ReadRequired<bool>();
-	// read options
-	skip_rows_set = reader.ReadRequired<bool>();
-	maximum_line_size = reader.ReadRequired<idx_t>();
-	normalize_names = reader.ReadRequired<bool>();
-	force_not_null = reader.ReadRequiredList<bool>();
-	all_varchar = reader.ReadRequired<bool>();
-	sample_chunk_size = reader.ReadRequired<idx_t>();
-	sample_chunks = reader.ReadRequired<idx_t>();
-	auto_detect = reader.ReadRequired<bool>();
-	file_path = reader.ReadRequired<string>();
-	decimal_separator = reader.ReadRequired<string>();
-	null_padding = reader.ReadRequired<bool>();
-	buffer_size = reader.ReadRequired<idx_t>();
-	file_options = reader.ReadRequiredSerializable<MultiFileReaderOptions, MultiFileReaderOptions>();
-	// write options
-	force_quote = reader.ReadRequiredList<bool>();
-
-	// rejects options
-	rejects_table_name = reader.ReadRequired<string>();
-	rejects_limit = reader.ReadRequired<idx_t>();
-	rejects_recovery_columns = reader.ReadRequiredList<string>();
-	rejects_recovery_column_ids = reader.ReadRequiredList<idx_t>();
-
-	// dialect options
-	dialect_options.Deserialize(reader);
-}
-
-static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
-	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
-	writer.WriteString(function.extra_info);
-	writer.WriteList<string>(bind_data.files);
-	writer.WriteRegularSerializableList<LogicalType>(bind_data.csv_types);
-	writer.WriteList<string>(bind_data.csv_names);
-	writer.WriteRegularSerializableList<LogicalType>(bind_data.return_types);
-	writer.WriteList<string>(bind_data.return_names);
-	writer.WriteField<idx_t>(bind_data.filename_col_idx);
-	writer.WriteField<idx_t>(bind_data.hive_partition_col_idx);
-	bind_data.options.Serialize(writer);
-	writer.WriteField<bool>(bind_data.single_threaded);
-	writer.WriteSerializable(bind_data.reader_bind);
-	writer.WriteField<uint32_t>(bind_data.column_info.size());
-	for (auto &col : bind_data.column_info) {
-		col.Serialize(writer);
-	}
-}
-
-static unique_ptr<FunctionData> CSVReaderDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                     TableFunction &function) {
-	function.extra_info = reader.ReadRequired<string>();
-	auto result_data = make_uniq<ReadCSVData>();
-	result_data->files = reader.ReadRequiredList<string>();
-	result_data->csv_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	result_data->csv_names = reader.ReadRequiredList<string>();
-	result_data->return_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	result_data->return_names = reader.ReadRequiredList<string>();
-	result_data->filename_col_idx = reader.ReadRequired<idx_t>();
-	result_data->hive_partition_col_idx = reader.ReadRequired<idx_t>();
-	result_data->options.Deserialize(reader);
-	result_data->single_threaded = reader.ReadField<bool>(true);
-	result_data->reader_bind = reader.ReadRequiredSerializable<MultiFileReaderBindData, MultiFileReaderBindData>();
-	uint32_t file_number = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < file_number; i++) {
-		result_data->column_info.emplace_back(ColumnInfo::Deserialize(reader));
-	}
-	return std::move(result_data);
-}
 
-static void CSVReaderFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                     const TableFunction &function) {
+static void CSVReaderSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                               const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
 	serializer.WriteProperty(100, "extra_info", function.extra_info);
 	serializer.WriteProperty(101, "csv_data", &bind_data);
 }
 
-static unique_ptr<FunctionData> CSVReaderFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
+static unique_ptr<FunctionData> CSVReaderDeserialize(Deserializer &deserializer, TableFunction &function) {
 	unique_ptr<ReadCSVData> result;
 	deserializer.ReadProperty(100, "extra_info", function.extra_info);
 	deserializer.ReadProperty(101, "csv_data", result);
@@ -1277,8 +1110,6 @@ TableFunction ReadCSVTableFunction::GetFunction() {
 	read_csv.pushdown_complex_filter = CSVComplexFilterPushdown;
 	read_csv.serialize = CSVReaderSerialize;
 	read_csv.deserialize = CSVReaderDeserialize;
-	read_csv.format_serialize = CSVReaderFormatSerialize;
-	read_csv.format_deserialize = CSVReaderFormatDeserialize;
 	read_csv.get_batch_index = CSVReaderGetBatchIndex;
 	read_csv.cardinality = CSVReaderCardinality;
 	read_csv.projection_pushdown = true;

package/src/duckdb/src/function/table/table_scan.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/function/table/table_scan.hpp"
 
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/optimizer/matcher/expression_matcher.hpp"
@@ -15,8 +14,8 @@
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/storage/table/scan_state.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 {
 
@@ -417,40 +416,8 @@ string TableScanToString(const FunctionData *bind_data_p) {
 	return result;
 }
 
-static void TableScanSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {
-	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-
-	writer.WriteString(bind_data.table.schema.name);
-	writer.WriteString(bind_data.table.name);
-	writer.WriteField<bool>(bind_data.is_index_scan);
-	writer.WriteField<bool>(bind_data.is_create_index);
-	writer.WriteList<row_t>(bind_data.result_ids);
-	writer.WriteString(bind_data.table.schema.catalog.GetName());
-}
-
-static unique_ptr<FunctionData> TableScanDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                     TableFunction &function) {
-	auto schema_name = reader.ReadRequired<string>();
-	auto table_name = reader.ReadRequired<string>();
-	auto is_index_scan = reader.ReadRequired<bool>();
-	auto is_create_index = reader.ReadRequired<bool>();
-	auto result_ids = reader.ReadRequiredList<row_t>();
-	auto catalog_name = reader.ReadField<string>(INVALID_CATALOG);
-
-	auto &catalog_entry = Catalog::GetEntry<TableCatalogEntry>(state.context, catalog_name, schema_name, table_name);
-	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
-		throw SerializationException("Cant find table for %s.%s", schema_name, table_name);
-	}
-
-	auto result = make_uniq<TableScanBindData>(catalog_entry.Cast<DuckTableEntry>());
-	result->is_index_scan = is_index_scan;
-	result->is_create_index = is_create_index;
-	result->result_ids = std::move(result_ids);
-	return std::move(result);
-}
-
-static void TableScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
-                                     const TableFunction &function) {
+static void TableScanSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
+                               const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
 	serializer.WriteProperty(100, "catalog", bind_data.table.schema.catalog.GetName());
 	serializer.WriteProperty(101, "schema", bind_data.table.schema.name);
@@ -460,7 +427,7 @@ static void TableScanFormatSerialize(FormatSerializer &serializer, const optiona
 	serializer.WriteProperty(105, "result_ids", bind_data.result_ids);
 }
 
-static unique_ptr<FunctionData> TableScanFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
+static unique_ptr<FunctionData> TableScanDeserialize(Deserializer &deserializer, TableFunction &function) {
 	auto catalog = deserializer.ReadProperty<string>(100, "catalog");
 	auto schema = deserializer.ReadProperty<string>(101, "schema");
 	auto table = deserializer.ReadProperty<string>(102, "table");
@@ -491,8 +458,6 @@ TableFunction TableScanFunction::GetIndexScanFunction() {
 	scan_function.filter_pushdown = false;
 	scan_function.serialize = TableScanSerialize;
 	scan_function.deserialize = TableScanDeserialize;
-	scan_function.format_serialize = TableScanFormatSerialize;
-	scan_function.format_deserialize = TableScanFormatDeserialize;
 	return scan_function;
 }
 
@@ -513,8 +478,6 @@ TableFunction TableScanFunction::GetFunction() {
 	scan_function.filter_prune = true;
 	scan_function.serialize = TableScanSerialize;
 	scan_function.deserialize = TableScanDeserialize;
-	scan_function.format_serialize = TableScanFormatSerialize;
-	scan_function.format_deserialize = TableScanFormatDeserialize;
 	return scan_function;
 }
 

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev4142"
+#define DUCKDB_VERSION "0.8.2-dev4314"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "d5c4422f72"
+#define DUCKDB_SOURCE_ID "84a109bbee"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_function.cpp

@@ -18,8 +18,8 @@ TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_f
       init_global(init_global), init_local(init_local), function(function), in_out_function(nullptr),
       in_out_function_final(nullptr), statistics(nullptr), dependency(nullptr), cardinality(nullptr),
       pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr), get_batch_index(nullptr),
-      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), format_serialize(nullptr),
-      format_deserialize(nullptr), projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
+      get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr), projection_pushdown(false),
+      filter_pushdown(false), filter_prune(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
@@ -32,8 +32,7 @@ TableFunction::TableFunction()
       init_local(nullptr), function(nullptr), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
       cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
       get_batch_index(nullptr), get_batch_info(nullptr), serialize(nullptr), deserialize(nullptr),
-      format_serialize(nullptr), format_deserialize(nullptr), projection_pushdown(false), filter_pushdown(false),
-      filter_prune(false) {
+      projection_pushdown(false), filter_pushdown(false), filter_prune(false) {
 }
 
 bool TableFunction::Equal(const TableFunction &rhs) const {

package/src/duckdb/src/function/table_macro_function.cpp

@@ -31,14 +31,4 @@ string TableMacroFunction::ToSQL(const string &schema, const string &name) const
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("TABLE (%s);", query_node->ToString());
 }
 
-void TableMacroFunction::SerializeInternal(FieldWriter &writer) const {
-	writer.WriteSerializable(*query_node);
-}
-
-unique_ptr<MacroFunction> TableMacroFunction::Deserialize(FieldReader &reader) {
-	auto result = make_uniq<TableMacroFunction>();
-	result->query_node = reader.ReadRequiredSerializable<QueryNode>();
-	return std::move(result);
-}
-
 } // namespace duckdb