duckdb 0.8.2-dev2133.0 → 0.8.2-dev2278.0

package/src/duckdb/src/include/duckdb/common/types/timestamp.hpp

@@ -26,7 +26,7 @@ struct timestamp_t { // NOLINT
 	int64_t value;
 
 	timestamp_t() = default;
-	explicit inline timestamp_t(int64_t value_p) : value(value_p) {
+	explicit inline constexpr timestamp_t(int64_t value_p) : value(value_p) {
 	}
 	inline timestamp_t &operator=(int64_t value_p) {
 		value = value_p;
@@ -67,21 +67,25 @@ struct timestamp_t { // NOLINT
 	timestamp_t &operator-=(const int64_t &delta);
 
 	// special values
-	static timestamp_t infinity() { // NOLINT
+	static constexpr timestamp_t infinity() { // NOLINT
 		return timestamp_t(NumericLimits<int64_t>::Maximum());
-	}                                // NOLINT
-	static timestamp_t ninfinity() { // NOLINT
+	}                                          // NOLINT
+	static constexpr timestamp_t ninfinity() { // NOLINT
 		return timestamp_t(-NumericLimits<int64_t>::Maximum());
-	}                                   // NOLINT
-	static inline timestamp_t epoch() { // NOLINT
+	}                                             // NOLINT
+	static constexpr inline timestamp_t epoch() { // NOLINT
 		return timestamp_t(0);
 	} // NOLINT
 };
 
-struct timestamp_tz_t : public timestamp_t {};  // NOLINT
-struct timestamp_ns_t : public timestamp_t {};  // NOLINT
-struct timestamp_ms_t : public timestamp_t {};  // NOLINT
-struct timestamp_sec_t : public timestamp_t {}; // NOLINT
+struct timestamp_tz_t : public timestamp_t { // NOLINT
+};
+struct timestamp_ns_t : public timestamp_t { // NOLINT
+};
+struct timestamp_ms_t : public timestamp_t { // NOLINT
+};
+struct timestamp_sec_t : public timestamp_t { // NOLINT
+};
 
 enum class TimestampCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_NON_UTC_TIMEZONE };
 

package/src/duckdb/src/include/duckdb/common/types.hpp

@@ -286,8 +286,6 @@ struct LogicalType {
 	//! Serializes a LogicalType to a stand-alone binary blob
 	DUCKDB_API void Serialize(Serializer &serializer) const;
 
-	DUCKDB_API void SerializeEnumType(Serializer &serializer) const;
-
 	//! Deserializes a blob back into an LogicalType
 	DUCKDB_API static LogicalType Deserialize(Deserializer &source);
 
@@ -373,9 +371,10 @@ public:
 	DUCKDB_API static LogicalType STRUCT(child_list_t<LogicalType> children);    // NOLINT
 	DUCKDB_API static LogicalType AGGREGATE_STATE(aggregate_state_t state_type);    // NOLINT
 	DUCKDB_API static LogicalType MAP(const LogicalType &child);				// NOLINT
-	DUCKDB_API static LogicalType MAP( child_list_t<LogicalType> children);       // NOLINT
 	DUCKDB_API static LogicalType MAP(LogicalType key, LogicalType value); // NOLINT
 	DUCKDB_API static LogicalType UNION( child_list_t<LogicalType> members);     // NOLINT
+	DUCKDB_API static LogicalType ENUM(Vector &ordered_data, idx_t size); // NOLINT
+	// DEPRECATED - provided for backwards compatibility
 	DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT
 	DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT
 	//! A list of all NUMERIC types (integral and floating point types)
@@ -400,21 +399,17 @@ struct ListType {
 	DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type);
 };
 
-struct UserType{
+struct UserType {
 	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
 };
 
-struct EnumType{
-	DUCKDB_API static const string &GetTypeName(const LogicalType &type);
+struct EnumType {
 	DUCKDB_API static int64_t GetPos(const LogicalType &type, const string_t& key);
 	DUCKDB_API static const Vector &GetValuesInsertOrder(const LogicalType &type);
 	DUCKDB_API static idx_t GetSize(const LogicalType &type);
 	DUCKDB_API static const string GetValue(const Value &val);
-	DUCKDB_API static void SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry);
-	DUCKDB_API static optional_ptr<TypeCatalogEntry> GetCatalog(const LogicalType &type);
-	DUCKDB_API static string GetSchemaName(const LogicalType &type);
 	DUCKDB_API static PhysicalType GetPhysicalType(const LogicalType &type);
-	DUCKDB_API static void Serialize(FieldWriter& writer, const ExtraTypeInfo& type_info, bool serialize_internals);
+	DUCKDB_API static string_t GetString(const LogicalType &type, idx_t pos);
 };
 
 struct StructType {

package/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp

@@ -68,6 +68,8 @@ public:
 
 	void SetDisabledFileSystems(const vector<string> &names) override;
 
+	string PathSeparator(const string &path) override;
+
 private:
 	FileSystem &FindFileSystem(const string &path);
 	FileSystem &FindFileSystemInternal(const string &path);

package/src/duckdb/src/include/duckdb/execution/operator/scan/physical_table_scan.hpp

@@ -22,10 +22,6 @@ public:
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::TABLE_SCAN;
 
 public:
-	//! Regular Table Scan
-	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
-	                  vector<column_t> column_ids, vector<string> names, unique_ptr<TableFilterSet> table_filters,
-	                  idx_t estimated_cardinality);
 	//! Table scan that immediately projects out filter columns that are unused in the remainder of the query plan
 	PhysicalTableScan(vector<LogicalType> types, TableFunction function, unique_ptr<FunctionData> bind_data,
 	                  vector<LogicalType> returned_types, vector<column_t> column_ids, vector<idx_t> projection_ids,

package/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp

@@ -50,7 +50,6 @@ protected:
 
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalAggregate &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalAnyJoin &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalAsOfJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalColumnDataGet &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalComparisonJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCreate &op);
@@ -59,7 +58,6 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCrossProduct &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelete &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimGet &op);
-	unique_ptr<PhysicalOperator> CreatePlan(LogicalDelimJoin &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDistinct &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalDummyScan &expr);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalEmptyResult &op);
@@ -93,6 +91,9 @@ protected:
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalCTERef &op);
 	unique_ptr<PhysicalOperator> CreatePlan(LogicalPivot &op);
 
+	unique_ptr<PhysicalOperator> PlanAsOfJoin(LogicalComparisonJoin &op);
+	unique_ptr<PhysicalOperator> PlanComparisonJoin(LogicalComparisonJoin &op);
+	unique_ptr<PhysicalOperator> PlanDelimJoin(LogicalComparisonJoin &op);
 	unique_ptr<PhysicalOperator> ExtractAggregateExpressions(unique_ptr<PhysicalOperator> child,
 	                                                         vector<unique_ptr<Expression>> &expressions,
 	                                                         vector<unique_ptr<Expression>> &groups);

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -113,9 +113,6 @@ public:
 
 	DUCKDB_API bool Equal(const ScalarFunction &rhs) const;
 
-private:
-	bool CompareScalarFunctionT(const scalar_function_t &other) const;
-
 public:
 	DUCKDB_API static void NopFunction(DataChunk &input, ExpressionState &state, Vector &result);
 

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -60,7 +60,7 @@ public:
 	bool IsInitialDatabase() const;
 	void SetInitialDatabase();
 
-	static string ExtractDatabaseName(const string &dbpath);
+	static string ExtractDatabaseName(const string &dbpath, FileSystem &fs);
 
 private:
 	DatabaseInstance &db;

package/src/duckdb/src/include/duckdb/optimizer/deliminator.hpp

@@ -27,9 +27,9 @@ private:
 	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates);
 	void FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate);
 	//! Remove joins with a DelimGet
-	bool RemoveJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+	bool RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
 	                            unique_ptr<LogicalOperator> &join, bool &all_equality_conditions);
-	bool RemoveInequalityJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+	bool RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
 	                                      unique_ptr<LogicalOperator> &join,
 	                                      const vector<ReplacementBinding> &replacement_bindings);
 

package/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp

@@ -14,7 +14,6 @@ class LogicalOperator;
 
 class LogicalAggregate;
 class LogicalAnyJoin;
-class LogicalAsOfJoin;
 class LogicalColumnDataGet;
 class LogicalComparisonJoin;
 class LogicalCopyToFile;
@@ -26,7 +25,6 @@ class LogicalCrossProduct;
 class LogicalCTERef;
 class LogicalDelete;
 class LogicalDelimGet;
-class LogicalDelimJoin;
 class LogicalDistinct;
 class LogicalDummyScan;
 class LogicalEmptyResult;

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

@@ -1,6 +1,5 @@
 #include "duckdb/planner/operator/logical_aggregate.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
-#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_column_data_get.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
@@ -11,7 +10,6 @@
 #include "duckdb/planner/operator/logical_cteref.hpp"
 #include "duckdb/planner/operator/logical_delete.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include "duckdb/planner/operator/logical_empty_result.hpp"
@@ -19,6 +17,7 @@
 #include "duckdb/planner/operator/logical_explain.hpp"
 #include "duckdb/planner/operator/logical_export.hpp"
 #include "duckdb/planner/operator/logical_expression_get.hpp"
+#include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"

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

@@ -15,7 +15,6 @@
 #include "duckdb/planner/operator/logical_join.hpp"
 
 namespace duckdb {
-class LogicalDelimJoin;
 
 //! LogicalComparisonJoin represents a join that involves comparisons between the LHS and RHS
 class LogicalComparisonJoin : public LogicalJoin {
@@ -30,6 +29,8 @@ public:
 	vector<JoinCondition> conditions;
 	//! Used for duplicate-eliminated MARK joins
 	vector<LogicalType> mark_types;
+	//! 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:
 	string ParamsToString() const override;
@@ -41,9 +42,6 @@ public:
 	void FormatSerialize(FormatSerializer &serializer) const override;
 	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
 
-	//! Turn a delim join into a regular comparison join (after all required delim scans have been pruned)
-	static unique_ptr<LogicalOperator> FromDelimJoin(LogicalDelimJoin &join);
-
 public:
 	static unique_ptr<LogicalOperator> CreateJoin(ClientContext &context, JoinType type, JoinRefType ref_type,
 	                                              unique_ptr<LogicalOperator> left_child,

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

@@ -19,19 +19,14 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_INDEX;
 
 public:
-	LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
-	                   vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
-	                   TableFunction function_p);
+	LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
+	                   TableCatalogEntry &table_p);
 
-	//! The bind data of the function
-	unique_ptr<FunctionData> bind_data;
 	// Info for index creation
 	unique_ptr<CreateIndexInfo> info;
 
 	//! The table to create the index for
 	TableCatalogEntry &table;
-	//! The function that is called
-	TableFunction function;
 
 	//! Unbound expressions to be used in the optimizer
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -40,7 +35,15 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	void ResolveTypes() override;
+
+private:
+	LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info, vector<unique_ptr<Expression>> expressions);
+
+	TableCatalogEntry &BindTable(ClientContext &context, CreateIndexInfo &info);
 };
 } // namespace duckdb

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

@@ -26,6 +26,11 @@ public:
 
 	static unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<LogicalOperator> FormatDeserialize(FormatDeserializer &deserializer);
+
 	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;
+
+	virtual string GetExtensionName() const;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator_extension.hpp

@@ -36,6 +36,7 @@ public:
 	virtual std::string GetName() = 0;
 	virtual unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state,
 	                                                         FieldReader &reader) = 0;
+	virtual unique_ptr<LogicalExtensionOperator> FormatDeserialize(FormatDeserializer &deserializer) = 0;
 
 	virtual ~OperatorExtension() {
 	}

package/src/duckdb/src/include/duckdb/storage/meta_block_reader.hpp

@@ -37,13 +37,10 @@ public:
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
 
 	ClientContext &GetContext() override;
-	optional_ptr<Catalog> GetCatalog() override;
-	void SetCatalog(Catalog &catalog_p);
 	void SetContext(ClientContext &context_p);
 
 private:
 	void ReadNewBlock(block_id_t id);
 	optional_ptr<ClientContext> context;
-	optional_ptr<Catalog> catalog;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb.h

@@ -360,6 +360,21 @@ The instantiated connection should be closed using 'duckdb_disconnect'
 */
 DUCKDB_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
 
+/*!
+Interrupt running query
+
+* connection: The connection to interruot
+*/
+DUCKDB_API void duckdb_interrupt(duckdb_connection connection);
+
+/*!
+Get progress of the running query
+
+* connection: The working connection
+* returns: -1 if no progress or a percentage of the progress
+*/
+DUCKDB_API double duckdb_query_progress(duckdb_connection connection);
+
 /*!
 Closes the specified connection and de-allocates all memory allocated for that connection.
 

package/src/duckdb/src/main/attached_database.cpp

@@ -87,11 +87,11 @@ bool AttachedDatabase::IsReadOnly() const {
 	return type == AttachedDatabaseType::READ_ONLY_DATABASE;
 }
 
-string AttachedDatabase::ExtractDatabaseName(const string &dbpath) {
+string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &fs) {
 	if (dbpath.empty() || dbpath == ":memory:") {
 		return "memory";
 	}
-	return FileSystem::ExtractBaseName(dbpath);
+	return fs.ExtractBaseName(dbpath);
 }
 
 void AttachedDatabase::Initialize() {

package/src/duckdb/src/main/capi/duckdb-c.cpp

@@ -54,6 +54,22 @@ duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) {
 	return DuckDBSuccess;
 }
 
+void duckdb_interrupt(duckdb_connection connection) {
+	if (!connection) {
+		return;
+	}
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+	conn->Interrupt();
+}
+
+double duckdb_query_progress(duckdb_connection connection) {
+	if (!connection) {
+		return -1;
+	}
+	Connection *conn = reinterpret_cast<Connection *>(connection);
+	return conn->context->GetProgress();
+}
+
 void duckdb_disconnect(duckdb_connection *connection) {
 	if (connection && *connection) {
 		Connection *conn = reinterpret_cast<Connection *>(*connection);

package/src/duckdb/src/main/database.cpp

@@ -158,7 +158,7 @@ duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(At
 
 void DatabaseInstance::CreateMainDatabase() {
 	AttachInfo info;
-	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
+	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path, GetFileSystem());
 	info.path = config.options.database_path;
 
 	auto attached_database = CreateAttachedDatabase(info, config.options.database_type, config.options.access_mode);

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-string GetDBAbsolutePath(const string &database_p) {
+string GetDBAbsolutePath(const string &database_p, FileSystem &fs) {
 	auto database = FileSystem::ExpandPath(database_p, nullptr);
 	if (database.empty()) {
 		return ":memory:";
@@ -16,15 +16,17 @@ string GetDBAbsolutePath(const string &database_p) {
 		// this database path is handled by a replacement open and is not a file path
 		return database;
 	}
-	if (FileSystem::IsPathAbsolute(database)) {
-		return FileSystem::NormalizeAbsolutePath(database);
+	if (fs.IsPathAbsolute(database)) {
+		return fs.NormalizeAbsolutePath(database);
 	}
-	return FileSystem::NormalizeAbsolutePath(FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database));
+	return fs.NormalizeAbsolutePath(fs.JoinPath(FileSystem::GetWorkingDirectory(), database));
 }
 
 shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {
 	shared_ptr<DuckDB> db_instance;
-	auto abs_database_path = GetDBAbsolutePath(database);
+
+	auto local_fs = FileSystem::CreateLocal();
+	auto abs_database_path = GetDBAbsolutePath(database, *local_fs);
 	if (db_instances.find(abs_database_path) != db_instances.end()) {
 		db_instance = db_instances[abs_database_path].lock();
 		if (db_instance) {
@@ -48,7 +50,13 @@ shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DB
 
 shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &database, DBConfig &config,
                                                            bool cache_instance) {
-	auto abs_database_path = GetDBAbsolutePath(database);
+	string abs_database_path;
+	if (config.file_system) {
+		abs_database_path = GetDBAbsolutePath(database, *config.file_system);
+	} else {
+		auto tmp_fs = FileSystem::CreateLocal();
+		abs_database_path = GetDBAbsolutePath(database, *tmp_fs);
+	}
 	if (db_instances.find(abs_database_path) != db_instances.end()) {
 		throw duckdb::Exception(ExceptionType::CONNECTION,
 		                        "Instance with path: " + abs_database_path + " already exists.");

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

@@ -56,7 +56,7 @@ string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs) {
 		// expand ~ in extension directory
 		extension_directory = fs.ExpandPath(extension_directory);
 		if (!fs.DirectoryExists(extension_directory)) {
-			auto sep = fs.PathSeparator();
+			auto sep = fs.PathSeparator(extension_directory);
 			auto splits = StringUtil::Split(extension_directory, sep);
 			D_ASSERT(!splits.empty());
 			string extension_directory_prefix;

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -1,7 +1,6 @@
 #include "duckdb/optimizer/column_lifetime_optimizer.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 
 namespace duckdb {
@@ -38,7 +37,7 @@ void ColumnLifetimeAnalyzer::StandardVisitOperator(LogicalOperator &op) {
 	LogicalOperatorVisitor::VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		// visit the duplicate eliminated columns on the LHS, if any
-		auto &delim_join = op.Cast<LogicalDelimJoin>();
+		auto &delim_join = op.Cast<LogicalComparisonJoin>();
 		for (auto &expr : delim_join.duplicate_eliminated_columns) {
 			VisitExpression(&expr);
 		}

package/src/duckdb/src/optimizer/compressed_materialization.cpp

@@ -9,7 +9,6 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 
 namespace duckdb {

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -7,21 +7,21 @@
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
+#include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 
 namespace duckdb {
 
 struct DelimCandidate {
 public:
-	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalDelimJoin &delim_join)
+	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalComparisonJoin &delim_join)
 	    : op(op), delim_join(delim_join), delim_get_count(0) {
 	}
 
 public:
 	unique_ptr<LogicalOperator> &op;
-	LogicalDelimJoin &delim_join;
+	LogicalComparisonJoin &delim_join;
 	vector<reference<unique_ptr<LogicalOperator>>> joins;
 	idx_t delim_get_count;
 };
@@ -55,6 +55,7 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 
 		// Change type if there are no more duplicate-eliminated columns
 		if (candidate.joins.size() == candidate.delim_get_count && all_removed) {
+			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
 			delim_join.duplicate_eliminated_columns.clear();
 			if (all_equality_conditions) {
 				for (auto &cond : delim_join.conditions) {
@@ -63,7 +64,6 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 					}
 				}
 			}
-			candidate.op = LogicalComparisonJoin::FromDelimJoin(delim_join);
 		}
 	}
 
@@ -80,7 +80,7 @@ void Deliminator::FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCa
 		return;
 	}
 
-	candidates.emplace_back(op, op->Cast<LogicalDelimJoin>());
+	candidates.emplace_back(op, op->Cast<LogicalComparisonJoin>());
 	auto &candidate = candidates.back();
 
 	// DelimGets are in the RHS
@@ -125,7 +125,7 @@ static bool ChildJoinTypeCanBeDeliminated(JoinType &join_type) {
 	}
 }
 
-bool Deliminator::RemoveJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+bool Deliminator::RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
                                          unique_ptr<LogicalOperator> &join, bool &all_equality_conditions) {
 	auto &comparison_join = join->Cast<LogicalComparisonJoin>();
 	if (!ChildJoinTypeCanBeDeliminated(comparison_join.join_type)) {
@@ -218,7 +218,7 @@ bool FindAndReplaceBindings(vector<ColumnBinding> &traced_bindings, const vector
 	return true;
 }
 
-bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalDelimJoin &delim_join, const idx_t delim_get_count,
+bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
                                                    unique_ptr<LogicalOperator> &join,
                                                    const vector<ReplacementBinding> &replacement_bindings) {
 	auto &comparison_join = join->Cast<LogicalComparisonJoin>();

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -2,7 +2,7 @@
 
 #include "duckdb/common/pair.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
+#include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_unnest.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_window.hpp"
@@ -17,11 +17,9 @@ void UnnestRewriterPlanUpdater::VisitOperator(LogicalOperator &op) {
 }
 
 void UnnestRewriterPlanUpdater::VisitExpression(unique_ptr<Expression> *expression) {
-
 	auto &expr = *expression;
 
 	if (expr->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
-
 		auto &bound_column_ref = expr->Cast<BoundColumnRefExpression>();
 		for (idx_t i = 0; i < replace_bindings.size(); i++) {
 			if (bound_column_ref.binding == replace_bindings[i].old_binding) {
@@ -76,7 +74,7 @@ void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
 	}
 
 	// found a delim join
-	auto &delim_join = op->children[0]->Cast<LogicalDelimJoin>();
+	auto &delim_join = op->children[0]->Cast<LogicalComparisonJoin>();
 	// only support INNER delim joins
 	if (delim_join.join_type != JoinType::INNER) {
 		return;
@@ -295,7 +293,7 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 void UnnestRewriter::GetDelimColumns(LogicalOperator &op) {
 
 	D_ASSERT(op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &delim_join = op.Cast<LogicalDelimJoin>();
+	auto &delim_join = op.Cast<LogicalComparisonJoin>();
 	for (idx_t i = 0; i < delim_join.duplicate_eliminated_columns.size(); i++) {
 		auto &expr = *delim_join.duplicate_eliminated_columns[i];
 		D_ASSERT(expr.type == ExpressionType::BOUND_COLUMN_REF);

package/src/duckdb/src/parser/transform/helpers/transform_typename.cpp

@@ -4,6 +4,7 @@
 
 #include "duckdb/parser/transformer.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/common/types/vector.hpp"
 
 namespace duckdb {
 
@@ -21,7 +22,21 @@ LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_n
 	if (base_type == LogicalTypeId::LIST) {
 		throw ParserException("LIST is not valid as a stand-alone type");
 	} else if (base_type == LogicalTypeId::ENUM) {
-		throw ParserException("ENUM is not valid as a stand-alone type");
+		if (!type_name.typmods || type_name.typmods->length == 0) {
+			throw ParserException("Enum needs a set of entries");
+		}
+		Vector enum_vector(LogicalType::VARCHAR, type_name.typmods->length);
+		auto string_data = FlatVector::GetData<string_t>(enum_vector);
+		idx_t pos = 0;
+		for (auto node = type_name.typmods->head; node; node = node->next) {
+			auto constant_value = PGPointerCast<duckdb_libpgquery::PGAConst>(node->data.ptr_value);
+			if (constant_value->type != duckdb_libpgquery::T_PGAConst ||
+			    constant_value->val.type != duckdb_libpgquery::T_PGString) {
+				throw ParserException("Enum type requires a set of strings as type modifiers");
+			}
+			string_data[pos++] = StringVector::AddString(enum_vector, constant_value->val.val.str);
+		}
+		return LogicalType::ENUM(enum_vector, type_name.typmods->length);
 	} else if (base_type == LogicalTypeId::STRUCT) {
 		if (!type_name.typmods || type_name.typmods->length == 0) {
 			throw ParserException("Struct needs a name and entries");

package/src/duckdb/src/parser/transform/statement/transform_create_type.cpp

@@ -56,7 +56,7 @@ unique_ptr<CreateStatement> Transformer::TransformCreateType(duckdb_libpgquery::
 			D_ASSERT(stmt.query == nullptr);
 			idx_t size = 0;
 			auto ordered_array = PGListToVector(stmt.vals, size);
-			info->type = LogicalType::ENUM(info->name, ordered_array, size);
+			info->type = LogicalType::ENUM(ordered_array, size);
 		}
 	} break;
 

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -138,10 +138,10 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 	}
 }
 
-static unique_ptr<LogicalDelimJoin>
+static unique_ptr<LogicalComparisonJoin>
 CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_columns, JoinType join_type,
                               unique_ptr<LogicalOperator> original_plan, bool perform_delim) {
-	auto delim_join = make_uniq<LogicalDelimJoin>(join_type);
+	auto delim_join = make_uniq<LogicalComparisonJoin>(join_type, LogicalOperatorType::LOGICAL_DELIM_JOIN);
 	if (!perform_delim) {
 		// if we are not performing a delim join, we push a row_number() OVER() window operator on the LHS
 		// and perform all duplicate elimination on that row number instead
@@ -165,7 +165,7 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 	return delim_join;
 }
 
-static void CreateDelimJoinConditions(LogicalDelimJoin &delim_join,
+static void CreateDelimJoinConditions(LogicalComparisonJoin &delim_join,
                                       const vector<CorrelatedColumnInfo> &correlated_columns,
                                       vector<ColumnBinding> bindings, idx_t base_offset, bool perform_delim) {
 	auto col_count = perform_delim ? correlated_columns.size() : 1;