duckdb 0.8.2-dev2090.0 → 0.8.2-dev2208.0

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/src/storage/storage_info.cpp

@@ -2,7 +2,7 @@
 
 namespace duckdb {
 
-const uint64_t VERSION_NUMBER = 53;
+const uint64_t VERSION_NUMBER = 54;
 
 struct StorageVersionInfo {
 	const char *version_name;

package/src/duckdb/src/storage/wal_replay.cpp

@@ -36,7 +36,6 @@ bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
 	// first deserialize the WAL to look for a checkpoint flag
 	// if there is a checkpoint flag, we might have already flushed the contents of the WAL to disk
 	ReplayState checkpoint_state(database, *con.context, *initial_reader);
-	initial_reader->SetCatalog(checkpoint_state.catalog);
 	checkpoint_state.deserialize_only = true;
 	try {
 		while (true) {
@@ -73,7 +72,6 @@ bool WriteAheadLog::Replay(AttachedDatabase &database, string &path) {
 
 	// we need to recover from the WAL: actually set up the replay state
 	BufferedFileReader reader(FileSystem::Get(database), path.c_str(), con.context.get());
-	reader.SetCatalog(checkpoint_state.catalog);
 	ReplayState state(database, *con.context, reader);
 
 	// replay the WAL
@@ -284,7 +282,7 @@ void ReplayState::ReplayDropSchema() {
 void ReplayState::ReplayCreateType() {
 	auto info = TypeCatalogEntry::Deserialize(source);
 	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateType(context, *info);
+	catalog.CreateType(context, info->Cast<CreateTypeInfo>());
 }
 
 void ReplayState::ReplayDropType() {

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_planner_operator.cpp

@@ -2,8 +2,6 @@
 
 #include "src/planner/operator/logical_any_join.cpp"
 
-#include "src/planner/operator/logical_asof_join.cpp"
-
 #include "src/planner/operator/logical_column_data_get.cpp"
 
 #include "src/planner/operator/logical_comparison_join.cpp"
@@ -24,8 +22,6 @@
 
 #include "src/planner/operator/logical_delim_get.cpp"
 
-#include "src/planner/operator/logical_delim_join.cpp"
-
 #include "src/planner/operator/logical_dependent_join.cpp"
 
 #include "src/planner/operator/logical_distinct.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"

package/src/statement.cpp

@@ -548,7 +548,6 @@ static Napi::Value TypeToObject(Napi::Env &env, const duckdb::LogicalType &type)
 		obj.Set("value", TypeToObject(env, value_type));
 	} break;
 	case duckdb::LogicalTypeId::ENUM: {
-		auto name = duckdb::EnumType::GetTypeName(type);
 		auto &values_vec = duckdb::EnumType::GetValuesInsertOrder(type);
 		auto enum_size = duckdb::EnumType::GetSize(type);
 		auto arr = Napi::Array::New(env, enum_size);
@@ -556,7 +555,6 @@ static Napi::Value TypeToObject(Napi::Env &env, const duckdb::LogicalType &type)
 			auto child_name = values_vec.GetValue(i).GetValue<duckdb::string>();
 			arr.Set(i, child_name);
 		}
-		obj.Set("name", name);
 		obj.Set("values", arr);
 	} break;
 	case duckdb::LogicalTypeId::UNION: {

package/test/columns.test.ts

@@ -48,8 +48,7 @@ describe('Column Types', function() {
               name: 'small_enum',
               type: {
                 id: 'ENUM',
-                sql_type: 'small_enum',
-                name: 'small_enum',
+                sql_type: "ENUM('DUCK_DUCK_ENUM', 'GOOSE')",
                 values: [
                   "DUCK_DUCK_ENUM",
                   "GOOSE"

package/src/duckdb/src/include/duckdb/planner/operator/logical_asof_join.hpp

@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_asof_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! LogicalAsOfJoin represents a temporal-style join with one less-than inequality.
-//! This inequality matches the greatest value on the right that satisfies the condition.
-class LogicalAsOfJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_ASOF_JOIN;
-
-public:
-	explicit LogicalAsOfJoin(JoinType type);
-
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-};
-
-} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_join.hpp

@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/operator/logical_delim_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/planner/operator/logical_comparison_join.hpp"
-
-namespace duckdb {
-
-//! LogicalDelimJoin represents a special "duplicate eliminated" join. This join type is only used for subquery
-//! flattening, and involves performing duplicate elimination on the LEFT side which is then pushed into the RIGHT side.
-class LogicalDelimJoin : public LogicalComparisonJoin {
-public:
-	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELIM_JOIN;
-
-public:
-	explicit LogicalDelimJoin(JoinType type);
-
-	//! The set of columns that will be duplicate eliminated from the LHS and pushed into the RHS
-	vector<unique_ptr<Expression>> duplicate_eliminated_columns;
-
-public:
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-};
-
-} // namespace duckdb

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

@@ -1,14 +0,0 @@
-#include "duckdb/planner/operator/logical_asof_join.hpp"
-
-namespace duckdb {
-
-LogicalAsOfJoin::LogicalAsOfJoin(JoinType type) : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-}
-
-unique_ptr<LogicalOperator> LogicalAsOfJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto result = make_uniq<LogicalAsOfJoin>(JoinType::INVALID);
-	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	return std::move(result);
-}
-
-} // namespace duckdb

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

@@ -1,25 +0,0 @@
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
-
-namespace duckdb {
-
-LogicalDelimJoin::LogicalDelimJoin(JoinType type)
-    : LogicalComparisonJoin(type, LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-}
-
-void LogicalDelimJoin::Serialize(FieldWriter &writer) const {
-	LogicalComparisonJoin::Serialize(writer);
-	if (type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		throw InternalException("LogicalDelimJoin needs to have type LOGICAL_DELIM_JOIN");
-	}
-	writer.WriteSerializableList(duplicate_eliminated_columns);
-}
-
-unique_ptr<LogicalOperator> LogicalDelimJoin::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto result = make_uniq<LogicalDelimJoin>(JoinType::INVALID);
-	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	result->duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return std::move(result);
-}
-
-} // namespace duckdb