duckdb 0.8.2-dev2133.0 → 0.8.2-dev2208.0

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -70,13 +70,10 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			auto &delim_join = op.Cast<LogicalDelimJoin>();
-			for (auto &expr : delim_join.duplicate_eliminated_columns) {
-				callback(&expr);
-			}
-		}
 		auto &join = op.Cast<LogicalComparisonJoin>();
+		for (auto &expr : join.duplicate_eliminated_columns) {
+			callback(&expr);
+		}
 		for (auto &cond : join.conditions) {
 			callback(&cond.left);
 			callback(&cond.right);

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

@@ -1,7 +1,6 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/common/enum_util.hpp"
 namespace duckdb {
@@ -26,6 +25,7 @@ void LogicalComparisonJoin::Serialize(FieldWriter &writer) const {
 	LogicalJoin::Serialize(writer);
 	writer.WriteRegularSerializableList(mark_types);
 	writer.WriteRegularSerializableList(conditions);
+	writer.WriteSerializableList(duplicate_eliminated_columns);
 }
 
 void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
@@ -33,6 +33,7 @@ void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join,
 	LogicalJoin::Deserialize(comparison_join, state, reader);
 	comparison_join.mark_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	comparison_join.conditions = reader.ReadRequiredSerializableList<JoinCondition, JoinCondition>(state.gstate);
+	comparison_join.duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,
@@ -42,17 +43,4 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializ
 	return std::move(result);
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::FromDelimJoin(LogicalDelimJoin &delim_join) {
-	auto new_join = make_uniq<LogicalComparisonJoin>(delim_join.join_type);
-	new_join->children = std::move(delim_join.children);
-	new_join->conditions = std::move(delim_join.conditions);
-	new_join->types = std::move(delim_join.types);
-	new_join->mark_types = std::move(delim_join.mark_types);
-	new_join->mark_index = delim_join.mark_index;
-	new_join->left_projection_map = std::move(delim_join.left_projection_map);
-	new_join->right_projection_map = std::move(delim_join.right_projection_map);
-	new_join->join_stats = std::move(delim_join.join_stats);
-	return std::move(new_join);
-}
-
 } // namespace duckdb

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

@@ -6,11 +6,9 @@
 
 namespace duckdb {
 
-LogicalCreateIndex::LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
-                                       vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
-                                       TableFunction function_p)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(std::move(bind_data_p)),
-      info(std::move(info_p)), table(table_p), function(std::move(function_p)) {
+LogicalCreateIndex::LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
+                                       TableCatalogEntry &table_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), info(std::move(info_p)), table(table_p) {
 
 	for (auto &expr : expressions_p) {
 		this->unbound_expressions.push_back(expr->Copy());
@@ -22,12 +20,21 @@ LogicalCreateIndex::LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, uni
 	}
 }
 
+LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info_p,
+                                       vector<unique_ptr<Expression>> expressions_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX),
+      info(unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info_p))), table(BindTable(context, *info)) {
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
+	}
+	this->expressions = std::move(expressions_p);
+}
+
 void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(info);
 	writer.WriteString(table.catalog.GetName());
 	writer.WriteString(table.schema.name);
 	writer.WriteString(table.name);
-	FunctionSerializer::SerializeBase<TableFunction>(writer, function, bind_data.get());
 	writer.WriteSerializableList(unbound_expressions);
 }
 
@@ -38,10 +45,6 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	auto catalog = reader.ReadRequired<string>();
 	auto schema = reader.ReadRequired<string>();
 	auto table_name = reader.ReadRequired<string>();
-	unique_ptr<FunctionData> bind_data;
-	bool has_deserialize;
-	auto function = FunctionSerializer::DeserializeBaseInternal<TableFunction, TableFunctionCatalogEntry>(
-	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	if (info->type != CatalogType::INDEX_ENTRY) {
 		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(info->type),
@@ -49,12 +52,18 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	}
 	auto index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info));
 	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
-	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(index_info), std::move(unbound_expressions),
-	                                     table, std::move(function));
+	return make_uniq<LogicalCreateIndex>(std::move(index_info), std::move(unbound_expressions), table);
 }
 
 void LogicalCreateIndex::ResolveTypes() {
 	types.emplace_back(LogicalType::BIGINT);
 }
 
+TableCatalogEntry &LogicalCreateIndex::BindTable(ClientContext &context, CreateIndexInfo &info) {
+	auto &catalog = info.catalog;
+	auto &schema = info.schema;
+	auto &table_name = info.table;
+	return Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
+}
+
 } // namespace duckdb

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

@@ -1,5 +1,7 @@
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(LogicalDeserializationState &state,
@@ -15,4 +17,26 @@ unique_ptr<LogicalExtensionOperator> LogicalExtensionOperator::Deserialize(Logic
 
 	throw SerializationException("No serialization method exists for extension: " + extension_name);
 }
+
+void LogicalExtensionOperator::FormatSerialize(FormatSerializer &serializer) const {
+	LogicalOperator::FormatSerialize(serializer);
+	serializer.WriteProperty("extension_name", GetExtensionName());
+}
+
+unique_ptr<LogicalOperator> LogicalExtensionOperator::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto &config = DBConfig::GetConfig(deserializer.Get<ClientContext &>());
+	auto extension_name = deserializer.ReadProperty<string>("extension_name");
+	for (auto &extension : config.operator_extensions) {
+		if (extension->GetName() == extension_name) {
+			return extension->FormatDeserialize(deserializer);
+		}
+	}
+	throw SerializationException("No deserialization method exists for extension: " + extension_name);
+}
+
+string LogicalExtensionOperator::GetExtensionName() const {
+	throw SerializationException("LogicalExtensionOperator::GetExtensionName not implemented which is required for "
+	                             "serializing extension operators");
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/planner.cpp

@@ -176,7 +176,6 @@ void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op
 	}
 
 	BufferedSerializer serializer;
-	serializer.is_query_plan = true;
 	try {
 		op->Serialize(serializer);
 	} catch (NotImplementedException &ex) {

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -131,7 +131,6 @@ void SingleFileCheckpointReader::LoadFromStorage() {
 	con.BeginTransaction();
 	// create the MetaBlockReader to read from the storage
 	MetaBlockReader reader(block_manager, meta_block);
-	reader.SetCatalog(catalog.GetAttached().GetCatalog());
 	reader.SetContext(*con.context);
 	LoadCheckpoint(*con.context, reader);
 	con.Commit();
@@ -414,10 +413,7 @@ void CheckpointWriter::WriteType(TypeCatalogEntry &type) {
 
 void CheckpointReader::ReadType(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TypeCatalogEntry::Deserialize(reader);
-	auto &catalog_entry = catalog.CreateType(context, *info)->Cast<TypeCatalogEntry>();
-	if (info->type.id() == LogicalTypeId::ENUM) {
-		EnumType::SetCatalog(info->type, &catalog_entry);
-	}
+	catalog.CreateType(context, info->Cast<CreateTypeInfo>());
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/storage/meta_block_reader.cpp

@@ -43,10 +43,6 @@ ClientContext &MetaBlockReader::GetContext() {
 	return *context;
 }
 
-optional_ptr<Catalog> MetaBlockReader::GetCatalog() {
-	return catalog;
-}
-
 void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	auto &buffer_manager = block_manager.buffer_manager;
 
@@ -65,11 +61,6 @@ void MetaBlockReader::ReadNewBlock(block_id_t id) {
 	offset = sizeof(block_id_t);
 }
 
-void MetaBlockReader::SetCatalog(Catalog &catalog_p) {
-	D_ASSERT(!catalog);
-	catalog = &catalog_p;
-}
-
 void MetaBlockReader::SetContext(ClientContext &context_p) {
 	D_ASSERT(!context);
 	context = &context_p;

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

@@ -75,6 +75,7 @@ unique_ptr<CreateInfo> CreateInfo::FormatDeserialize(FormatDeserializer &deseria
 void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
 	CreateInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("name", index_name);
+	serializer.WriteProperty("table", table);
 	serializer.WriteProperty("index_type", index_type);
 	serializer.WriteProperty("constraint_type", constraint_type);
 	serializer.WriteProperty("parsed_expressions", parsed_expressions);
@@ -85,6 +86,7 @@ void CreateIndexInfo::FormatSerialize(FormatSerializer &serializer) const {
 unique_ptr<CreateInfo> CreateIndexInfo::FormatDeserialize(FormatDeserializer &deserializer) {
 	auto result = duckdb::unique_ptr<CreateIndexInfo>(new CreateIndexInfo());
 	deserializer.ReadProperty("name", result->index_name);
+	deserializer.ReadProperty("table", result->table);
 	deserializer.ReadProperty("index_type", result->index_type);
 	deserializer.ReadProperty("constraint_type", result->constraint_type);
 	deserializer.ReadProperty("parsed_expressions", result->parsed_expressions);

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

@@ -31,6 +31,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 		result = LogicalAnyJoin::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_ATTACH:
 		result = LogicalSimple::FormatDeserialize(deserializer);
 		break;
@@ -43,6 +46,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
 		result = LogicalCopyToFile::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_CREATE_INDEX:
+		result = LogicalCreateIndex::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
 		result = LogicalCreate::FormatDeserialize(deserializer);
 		break;
@@ -73,6 +79,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_DELIM_GET:
 		result = LogicalDelimGet::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+		result = LogicalComparisonJoin::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_DETACH:
 		result = LogicalSimple::FormatDeserialize(deserializer);
 		break;
@@ -97,6 +106,9 @@ unique_ptr<LogicalOperator> LogicalOperator::FormatDeserialize(FormatDeserialize
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
 		result = LogicalExpressionGet::FormatDeserialize(deserializer);
 		break;
+	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
+		result = LogicalExtensionOperator::FormatDeserialize(deserializer);
+		break;
 	case LogicalOperatorType::LOGICAL_FILTER:
 		result = LogicalFilter::FormatDeserialize(deserializer);
 		break;
@@ -261,6 +273,7 @@ void LogicalComparisonJoin::FormatSerialize(FormatSerializer &serializer) const
 	serializer.WriteProperty("right_projection_map", right_projection_map);
 	serializer.WriteProperty("conditions", conditions);
 	serializer.WriteProperty("mark_types", mark_types);
+	serializer.WriteProperty("duplicate_eliminated_columns", duplicate_eliminated_columns);
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeserializer &deserializer) {
@@ -271,6 +284,7 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::FormatDeserialize(FormatDeser
 	deserializer.ReadProperty("right_projection_map", result->right_projection_map);
 	deserializer.ReadProperty("conditions", result->conditions);
 	deserializer.ReadProperty("mark_types", result->mark_types);
+	deserializer.ReadProperty("duplicate_eliminated_columns", result->duplicate_eliminated_columns);
 	return std::move(result);
 }
 
@@ -285,6 +299,19 @@ unique_ptr<LogicalOperator> LogicalCreate::FormatDeserialize(FormatDeserializer
 	return std::move(result);
 }
 
+void LogicalCreateIndex::FormatSerialize(FormatSerializer &serializer) const {
+	LogicalOperator::FormatSerialize(serializer);
+	serializer.WriteProperty("info", *info);
+	serializer.WriteProperty("unbound_expressions", unbound_expressions);
+}
+
+unique_ptr<LogicalOperator> LogicalCreateIndex::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto info = deserializer.ReadProperty<unique_ptr<CreateInfo>>("info");
+	auto unbound_expressions = deserializer.ReadProperty<vector<unique_ptr<Expression>>>("unbound_expressions");
+	auto result = duckdb::unique_ptr<LogicalCreateIndex>(new LogicalCreateIndex(deserializer.Get<ClientContext &>(), std::move(info), std::move(unbound_expressions)));
+	return std::move(result);
+}
+
 void LogicalCreateTable::FormatSerialize(FormatSerializer &serializer) const {
 	LogicalOperator::FormatSerialize(serializer);
 	serializer.WriteProperty("catalog", schema.ParentCatalog().GetName());

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_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/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