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

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -45,7 +45,7 @@ const vector<string> ExtensionHelper::PathComponents() {
 
 string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs) {
 #ifdef WASM_LOADABLE_EXTENSIONS
-	static_assert(0, "ExtensionDirectory functionality is not supported in duckdb-wasm");
+	throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm");
 #endif
 	string extension_directory;
 	if (!config.options.extension_directory.empty()) { // create the extension directory if not present
@@ -159,9 +159,11 @@ void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, id
 
 string ExtensionHelper::ExtensionUrlTemplate(optional_ptr<const ClientConfig> client_config, const string &repository) {
 	string default_endpoint = "http://extensions.duckdb.org";
-	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
+	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension";
 #ifdef WASM_LOADABLE_EXTENSIONS
-	versioned_path = "/duckdb-wasm" + versioned_path;
+	versioned_path = "/duckdb-wasm" + versioned_path + ".wasm";
+#else
+	versioned_path = versioned_path + ".gz";
 #endif
 	string custom_endpoint = client_config ? client_config->custom_extension_repo : string();
 	string endpoint;

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -70,14 +70,15 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 
 	// shorthand case
 	if (!ExtensionHelper::IsFullPath(extension)) {
+		string extension_name = ApplyExtensionAlias(extension);
 #ifdef WASM_LOADABLE_EXTENSIONS
 		string url_template = ExtensionUrlTemplate(client_config, "");
 		string url = ExtensionFinalizeUrlTemplate(url_template, extension_name);
 
 		char *str = (char *)EM_ASM_PTR(
 		    {
-			    var jsString = ((typeof runtime == = 'object') && runtime &&
-			                    (typeof runtime.whereToLoad == = 'function') && runtime.whereToLoad)
+			    var jsString = ((typeof runtime == 'object') && runtime && (typeof runtime.whereToLoad == 'function') &&
+			                    runtime.whereToLoad)
 			                       ? runtime.whereToLoad(UTF8ToString($0))
 			                       : (UTF8ToString($1));
 			    var lengthBytes = lengthBytesUTF8(jsString) + 1;
@@ -105,7 +106,6 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 		for (auto &path_ele : path_components) {
 			local_path = fs.JoinPath(local_path, path_ele);
 		}
-		string extension_name = ApplyExtensionAlias(extension);
 		filename = fs.JoinPath(local_path, extension_name + ".duckdb_extension");
 #endif
 	}

package/src/duckdb/src/parser/column_definition.cpp

@@ -1,5 +1,4 @@
 #include "duckdb/parser/column_definition.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/parsed_data/alter_table_info.hpp"
@@ -26,30 +25,6 @@ ColumnDefinition ColumnDefinition::Copy() const {
 	return copy;
 }
 
-void ColumnDefinition::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteString(name);
-	writer.WriteSerializable(type);
-	writer.WriteOptional(expression);
-	writer.WriteField<TableColumnType>(category);
-	writer.WriteField<duckdb::CompressionType>(compression_type);
-	writer.Finalize();
-}
-
-ColumnDefinition ColumnDefinition::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto column_name = reader.ReadRequired<string>();
-	auto column_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto expression = reader.ReadOptional<ParsedExpression>(nullptr);
-	auto category = reader.ReadField<TableColumnType>(TableColumnType::STANDARD);
-	auto compression_type = reader.ReadField<duckdb::CompressionType>(duckdb::CompressionType::COMPRESSION_AUTO);
-	reader.Finalize();
-
-	ColumnDefinition result(column_name, column_type, std::move(expression), category);
-	result.compression_type = compression_type;
-	return result;
-}
-
 const unique_ptr<ParsedExpression> &ColumnDefinition::DefaultValue() const {
 	if (Generated()) {
 		throw InternalException("Calling DefaultValue() on a generated column");

package/src/duckdb/src/parser/column_list.cpp

@@ -158,19 +158,6 @@ ColumnList ColumnList::Copy() const {
 	return result;
 }
 
-void ColumnList::Serialize(FieldWriter &writer) const {
-	writer.WriteRegularSerializableList(columns);
-}
-
-ColumnList ColumnList::Deserialize(FieldReader &reader) {
-	ColumnList result;
-	auto columns = reader.ReadRequiredSerializableList<ColumnDefinition, ColumnDefinition>();
-	for (auto &col : columns) {
-		result.AddColumn(std::move(col));
-	}
-	return result;
-}
-
 ColumnList::ColumnListIterator ColumnList::Logical() const {
 	return ColumnListIterator(*this, false);
 }

package/src/duckdb/src/parser/constraint.cpp

@@ -1,9 +1,7 @@
 #include "duckdb/parser/constraint.hpp"
 
 #include "duckdb/common/printer.hpp"
-#include "duckdb/common/serializer.hpp"
 #include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
@@ -13,37 +11,6 @@ Constraint::Constraint(ConstraintType type) : type(type) {
 Constraint::~Constraint() {
 }
 
-void Constraint::Serialize(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<ConstraintType>(type);
-	Serialize(writer);
-	writer.Finalize();
-}
-
-unique_ptr<Constraint> Constraint::Deserialize(Deserializer &source) {
-	FieldReader reader(source);
-	auto type = reader.ReadRequired<ConstraintType>();
-	unique_ptr<Constraint> result;
-	switch (type) {
-	case ConstraintType::NOT_NULL:
-		result = NotNullConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::CHECK:
-		result = CheckConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::UNIQUE:
-		result = UniqueConstraint::Deserialize(reader);
-		break;
-	case ConstraintType::FOREIGN_KEY:
-		result = ForeignKeyConstraint::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Unrecognized constraint type for serialization");
-	}
-	reader.Finalize();
-	return result;
-}
-
 void Constraint::Print() const {
 	Printer::Print(ToString());
 }

package/src/duckdb/src/parser/constraints/check_constraint.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/constraints/check_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 CheckConstraint::CheckConstraint(unique_ptr<ParsedExpression> expression)
@@ -16,13 +14,4 @@ unique_ptr<Constraint> CheckConstraint::Copy() const {
 	return make_uniq<CheckConstraint>(expression->Copy());
 }
 
-void CheckConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*expression);
-}
-
-unique_ptr<Constraint> CheckConstraint::Deserialize(FieldReader &source) {
-	auto expression = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<CheckConstraint>(std::move(expression));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/foreign_key_constraint.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
@@ -50,30 +49,4 @@ unique_ptr<Constraint> ForeignKeyConstraint::Copy() const {
 	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, info);
 }
 
-void ForeignKeyConstraint::Serialize(FieldWriter &writer) const {
-	D_ASSERT(pk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(pk_columns);
-	D_ASSERT(fk_columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(fk_columns);
-	writer.WriteField<ForeignKeyType>(info.type);
-	writer.WriteString(info.schema);
-	writer.WriteString(info.table);
-	writer.WriteIndexList<PhysicalIndex>(info.pk_keys);
-	writer.WriteIndexList<PhysicalIndex>(info.fk_keys);
-}
-
-unique_ptr<Constraint> ForeignKeyConstraint::Deserialize(FieldReader &source) {
-	ForeignKeyInfo read_info;
-	auto pk_columns = source.ReadRequiredList<string>();
-	auto fk_columns = source.ReadRequiredList<string>();
-	read_info.type = source.ReadRequired<ForeignKeyType>();
-	read_info.schema = source.ReadRequired<string>();
-	read_info.table = source.ReadRequired<string>();
-	read_info.pk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
-	read_info.fk_keys = source.ReadRequiredIndexList<PhysicalIndex>();
-
-	// column list parsed constraint
-	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(read_info));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/not_null_constraint.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/parser/constraints/not_null_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
-
 namespace duckdb {
 
 NotNullConstraint::NotNullConstraint(LogicalIndex index) : Constraint(ConstraintType::NOT_NULL), index(index) {
@@ -18,13 +16,4 @@ unique_ptr<Constraint> NotNullConstraint::Copy() const {
 	return make_uniq<NotNullConstraint>(index);
 }
 
-void NotNullConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<idx_t>(index.index);
-}
-
-unique_ptr<Constraint> NotNullConstraint::Deserialize(FieldReader &source) {
-	auto index = source.ReadRequired<idx_t>();
-	return make_uniq_base<Constraint, NotNullConstraint>(LogicalIndex(index));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/constraints/unique_constraint.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/parser/constraints/unique_constraint.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 
@@ -38,27 +37,4 @@ unique_ptr<Constraint> UniqueConstraint::Copy() const {
 	}
 }
 
-void UniqueConstraint::Serialize(FieldWriter &writer) const {
-	writer.WriteField<bool>(is_primary_key);
-	writer.WriteField<uint64_t>(index.index);
-	D_ASSERT(columns.size() <= NumericLimits<uint32_t>::Maximum());
-	writer.WriteList<string>(columns);
-}
-
-unique_ptr<Constraint> UniqueConstraint::Deserialize(FieldReader &source) {
-	auto is_primary_key = source.ReadRequired<bool>();
-	auto index = source.ReadRequired<uint64_t>();
-	auto columns = source.ReadRequiredList<string>();
-
-	if (index != DConstants::INVALID_INDEX) {
-		// single column parsed constraint
-		auto result = make_uniq<UniqueConstraint>(LogicalIndex(index), is_primary_key);
-		result->columns = std::move(columns);
-		return std::move(result);
-	} else {
-		// column list parsed constraint
-		return make_uniq<UniqueConstraint>(std::move(columns), is_primary_key);
-	}
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/between_expression.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/parser/expression/between_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -37,17 +36,4 @@ unique_ptr<ParsedExpression> BetweenExpression::Copy() const {
 	return std::move(copy);
 }
 
-void BetweenExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*input);
-	writer.WriteSerializable(*lower);
-	writer.WriteSerializable(*upper);
-}
-
-unique_ptr<ParsedExpression> BetweenExpression::Deserialize(ExpressionType type, FieldReader &source) {
-	auto input = source.ReadRequiredSerializable<ParsedExpression>();
-	auto lower = source.ReadRequiredSerializable<ParsedExpression>();
-	auto upper = source.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<BetweenExpression>(std::move(input), std::move(lower), std::move(upper));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/case_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/case_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -46,30 +45,4 @@ unique_ptr<ParsedExpression> CaseExpression::Copy() const {
 	return std::move(copy);
 }
 
-void CaseExpression::Serialize(FieldWriter &writer) const {
-	auto &serializer = writer.GetSerializer();
-	// we write a list of multiple expressions here
-	// in order to write this as a single field we directly use the field writers' internal serializer
-	writer.WriteField<uint32_t>(case_checks.size());
-	for (auto &check : case_checks) {
-		check.when_expr->Serialize(serializer);
-		check.then_expr->Serialize(serializer);
-	}
-	writer.WriteSerializable<ParsedExpression>(*else_expr);
-}
-
-unique_ptr<ParsedExpression> CaseExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto result = make_uniq<CaseExpression>();
-	auto &source = reader.GetSource();
-	auto count = reader.ReadRequired<uint32_t>();
-	for (idx_t i = 0; i < count; i++) {
-		CaseCheck new_check;
-		new_check.when_expr = ParsedExpression::Deserialize(source);
-		new_check.then_expr = ParsedExpression::Deserialize(source);
-		result->case_checks.push_back(std::move(new_check));
-	}
-	result->else_expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/cast_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/cast_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -41,17 +40,4 @@ unique_ptr<ParsedExpression> CastExpression::Copy() const {
 	return std::move(copy);
 }
 
-void CastExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child);
-	writer.WriteSerializable(cast_type);
-	writer.WriteField<bool>(try_cast);
-}
-
-unique_ptr<ParsedExpression> CastExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto cast_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	auto try_cast = reader.ReadRequired<bool>();
-	return make_uniq_base<ParsedExpression, CastExpression>(cast_type, std::move(child), try_cast);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/collate_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/collate_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -37,15 +36,4 @@ unique_ptr<ParsedExpression> CollateExpression::Copy() const {
 	return std::move(copy);
 }
 
-void CollateExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child);
-	writer.WriteString(collation);
-}
-
-unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto collation = reader.ReadRequired<string>();
-	return make_uniq_base<ParsedExpression, CollateExpression>(collation, std::move(child));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/columnref_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/qualified_name.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 {
 
@@ -93,14 +92,4 @@ unique_ptr<ParsedExpression> ColumnRefExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ColumnRefExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteList<string>(column_names);
-}
-
-unique_ptr<ParsedExpression> ColumnRefExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto column_names = reader.ReadRequiredList<string>();
-	auto expression = make_uniq<ColumnRefExpression>(std::move(column_names));
-	return std::move(expression);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/comparison_expression.cpp

@@ -1,11 +1,10 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression/cast_expression.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 {
 
@@ -37,15 +36,4 @@ unique_ptr<ParsedExpression> ComparisonExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ComparisonExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*left);
-	writer.WriteSerializable(*right);
-}
-
-unique_ptr<ParsedExpression> ComparisonExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto left_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto right_child = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<ComparisonExpression>(type, std::move(left_child), std::move(right_child));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/conjunction_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/expression_util.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -58,14 +57,4 @@ unique_ptr<ParsedExpression> ConjunctionExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ConjunctionExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<ParsedExpression> ConjunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto result = make_uniq<ConjunctionExpression>(type);
-	result->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return std::move(result);
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/constant_expression.cpp

@@ -1,12 +1,11 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/value_operations/value_operations.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -35,13 +34,4 @@ unique_ptr<ParsedExpression> ConstantExpression::Copy() const {
 	return std::move(copy);
 }
 
-void ConstantExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(value);
-}
-
-unique_ptr<ParsedExpression> ConstantExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	Value value = reader.ReadRequiredSerializable<Value, Value>();
-	return make_uniq<ConstantExpression>(std::move(value));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/default_expression.cpp

@@ -2,8 +2,8 @@
 
 #include "duckdb/common/exception.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 {
 
@@ -20,11 +20,4 @@ unique_ptr<ParsedExpression> DefaultExpression::Copy() const {
 	return std::move(copy);
 }
 
-void DefaultExpression::Serialize(FieldWriter &writer) const {
-}
-
-unique_ptr<ParsedExpression> DefaultExpression::Deserialize(ExpressionType type, FieldReader &source) {
-	return make_uniq<DefaultExpression>();
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/function_expression.cpp

@@ -3,11 +3,10 @@
 #include <utility>
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.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 {
 
@@ -92,35 +91,6 @@ unique_ptr<ParsedExpression> FunctionExpression::Copy() const {
 	return std::move(copy);
 }
 
-void FunctionExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteString(function_name);
-	writer.WriteString(schema);
-	writer.WriteSerializableList(children);
-	writer.WriteOptional(filter);
-	writer.WriteSerializable((ResultModifier &)*order_bys);
-	writer.WriteField<bool>(distinct);
-	writer.WriteField<bool>(is_operator);
-	writer.WriteField<bool>(export_state);
-	writer.WriteString(catalog);
-}
-
-unique_ptr<ParsedExpression> FunctionExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto function_name = reader.ReadRequired<string>();
-	auto schema = reader.ReadRequired<string>();
-	auto children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	auto filter = reader.ReadOptional<ParsedExpression>(nullptr);
-	auto order_bys = unique_ptr_cast<ResultModifier, OrderModifier>(reader.ReadRequiredSerializable<ResultModifier>());
-	auto distinct = reader.ReadRequired<bool>();
-	auto is_operator = reader.ReadRequired<bool>();
-	auto export_state = reader.ReadField<bool>(false);
-	auto catalog = reader.ReadField<string>(INVALID_CATALOG);
-
-	unique_ptr<FunctionExpression> function;
-	function = make_uniq<FunctionExpression>(catalog, schema, function_name, std::move(children), std::move(filter),
-	                                         std::move(order_bys), distinct, is_operator, export_state);
-	return std::move(function);
-}
-
 void FunctionExpression::Verify() const {
 	D_ASSERT(!function_name.empty());
 }

package/src/duckdb/src/parser/expression/lambda_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/lambda_expression.hpp"
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/common/string_util.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -36,15 +35,4 @@ unique_ptr<ParsedExpression> LambdaExpression::Copy() const {
 	return std::move(copy);
 }
 
-void LambdaExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*lhs);
-	writer.WriteSerializable(*expr);
-}
-
-unique_ptr<ParsedExpression> LambdaExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto lhs = reader.ReadRequiredSerializable<ParsedExpression>();
-	auto expr = reader.ReadRequiredSerializable<ParsedExpression>();
-	return make_uniq<LambdaExpression>(std::move(lhs), std::move(expr));
-}
-
 } // namespace duckdb

package/src/duckdb/src/parser/expression/operator_expression.cpp

@@ -1,10 +1,9 @@
 #include "duckdb/parser/expression/operator_expression.hpp"
 
 #include "duckdb/common/exception.hpp"
-#include "duckdb/common/field_writer.hpp"
 
-#include "duckdb/common/serializer/format_serializer.hpp"
-#include "duckdb/common/serializer/format_deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 
 namespace duckdb {
 
@@ -48,14 +47,4 @@ unique_ptr<ParsedExpression> OperatorExpression::Copy() const {
 	return std::move(copy);
 }
 
-void OperatorExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializableList(children);
-}
-
-unique_ptr<ParsedExpression> OperatorExpression::Deserialize(ExpressionType type, FieldReader &reader) {
-	auto expression = make_uniq<OperatorExpression>(type);
-	expression->children = reader.ReadRequiredSerializableList<ParsedExpression>();
-	return std::move(expression);
-}
-
 } // namespace duckdb