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

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.8.2-dev2133.0",
+  "version": "0.8.2-dev2208.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/json_functions.cpp

@@ -209,7 +209,8 @@ unique_ptr<TableRef> JSONFunctions::ReadJSONReplacement(ClientContext &context,
 	table_function->function = make_uniq<FunctionExpression>("read_json_auto", std::move(children));
 
 	if (!FileSystem::HasGlob(table_name)) {
-		table_function->alias = FileSystem::ExtractBaseName(table_name);
+		auto &fs = FileSystem::GetFileSystem(context);
+		table_function->alias = fs.ExtractBaseName(table_name);
 	}
 
 	return std::move(table_function);

package/src/duckdb/extension/parquet/parquet_extension.cpp

@@ -961,7 +961,8 @@ unique_ptr<TableRef> ParquetScanReplacement(ClientContext &context, const string
 	table_function->function = make_uniq<FunctionExpression>("parquet_scan", std::move(children));
 
 	if (!FileSystem::HasGlob(table_name)) {
-		table_function->alias = FileSystem::ExtractBaseName(table_name);
+		auto &fs = FileSystem::GetFileSystem(context);
+		table_function->alias = fs.ExtractBaseName(table_name);
 	}
 
 	return std::move(table_function);

package/src/duckdb/src/catalog/catalog.cpp

@@ -655,17 +655,13 @@ LogicalType Catalog::GetType(ClientContext &context, const string &schema, const
 	if (!type_entry) {
 		return LogicalType::INVALID;
 	}
-	auto result_type = type_entry->user_type;
-	EnumType::SetCatalog(result_type, type_entry.get());
-	return result_type;
+	return type_entry->user_type;
 }
 
 LogicalType Catalog::GetType(ClientContext &context, const string &catalog_name, const string &schema,
                              const string &name) {
 	auto &type_entry = Catalog::GetEntry<TypeCatalogEntry>(context, catalog_name, schema, name);
-	auto result_type = type_entry.user_type;
-	EnumType::SetCatalog(result_type, &type_entry);
-	return result_type;
+	return type_entry.user_type;
 }
 
 vector<reference<SchemaCatalogEntry>> Catalog::GetSchemas(ClientContext &context) {

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -527,10 +527,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	if (info.target_type.id() == LogicalTypeId::USER) {
-		info.target_type =
-		    Catalog::GetType(context, catalog.GetName(), schema.name, UserType::GetTypeName(info.target_type));
-	}
+	Binder::BindLogicalType(context, info.target_type, &catalog, schema.name);
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -172,10 +172,6 @@ const ColumnList &TableCatalogEntry::GetColumns() const {
 	return columns;
 }
 
-ColumnList &TableCatalogEntry::GetColumnsMutable() {
-	return columns;
-}
-
 const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) {
 	return columns.GetColumn(idx);
 }

package/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include <algorithm>
 #include <sstream>
@@ -18,31 +17,13 @@ TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
 	this->internal = info.internal;
 }
 
-void TypeCatalogEntry::Serialize(Serializer &serializer) const {
-	D_ASSERT(!internal);
-	FieldWriter writer(serializer);
-	writer.WriteString(schema.name);
-	writer.WriteString(name);
-	if (user_type.id() == LogicalTypeId::ENUM) {
-		// We have to serialize Enum Values
-		writer.AddField();
-		user_type.SerializeEnumType(writer.GetSerializer());
-	} else {
-		writer.WriteSerializable(user_type);
-	}
-	writer.Finalize();
-}
-
-unique_ptr<CreateTypeInfo> TypeCatalogEntry::Deserialize(Deserializer &source) {
-	auto info = make_uniq<CreateTypeInfo>();
-
-	FieldReader reader(source);
-	info->schema = reader.ReadRequired<string>();
-	info->name = reader.ReadRequired<string>();
-	info->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
-	reader.Finalize();
-
-	return info;
+unique_ptr<CreateInfo> TypeCatalogEntry::GetInfo() const {
+	auto result = make_uniq<CreateTypeInfo>();
+	result->catalog = catalog.GetName();
+	result->schema = schema.name;
+	result->name = name;
+	result->type = user_type;
+	return std::move(result);
 }
 
 string TypeCatalogEntry::ToSQL() const {

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -543,67 +543,6 @@ void CatalogSet::UpdateTimestamp(CatalogEntry &entry, transaction_t timestamp) {
 	mapping[entry.name]->timestamp = timestamp;
 }
 
-void CatalogSet::AdjustUserDependency(CatalogEntry &entry, ColumnDefinition &column, bool remove) {
-	auto user_type_catalog_p = EnumType::GetCatalog(column.Type());
-	if (!user_type_catalog_p) {
-		return;
-	}
-	auto &user_type_catalog = user_type_catalog_p->Cast<CatalogEntry>();
-	auto &dependency_manager = catalog.GetDependencyManager();
-	if (remove) {
-		dependency_manager.dependents_map[user_type_catalog].erase(*entry.parent);
-		dependency_manager.dependencies_map[*entry.parent].erase(user_type_catalog);
-	} else {
-		dependency_manager.dependents_map[user_type_catalog].insert(entry);
-		dependency_manager.dependencies_map[entry].insert(user_type_catalog);
-	}
-}
-
-void CatalogSet::AdjustDependency(CatalogEntry &entry, TableCatalogEntry &table, ColumnDefinition &column,
-                                  bool remove) {
-	bool found = false;
-	if (column.Type().id() == LogicalTypeId::ENUM) {
-		for (auto &old_column : table.GetColumns().Logical()) {
-			if (old_column.Name() == column.Name() && old_column.Type().id() != LogicalTypeId::ENUM) {
-				AdjustUserDependency(entry, column, remove);
-				found = true;
-			}
-		}
-		if (!found) {
-			AdjustUserDependency(entry, column, remove);
-		}
-	} else if (!(column.Type().GetAlias().empty())) {
-		auto alias = column.Type().GetAlias();
-		for (auto &old_column : table.GetColumns().Logical()) {
-			auto old_alias = old_column.Type().GetAlias();
-			if (old_column.Name() == column.Name() && old_alias != alias) {
-				AdjustUserDependency(entry, column, remove);
-				found = true;
-			}
-		}
-		if (!found) {
-			AdjustUserDependency(entry, column, remove);
-		}
-	}
-}
-
-void CatalogSet::AdjustTableDependencies(CatalogEntry &entry) {
-	if (entry.type == CatalogType::TABLE_ENTRY && entry.parent->type == CatalogType::TABLE_ENTRY) {
-		// If it's a table entry we have to check for possibly removing or adding user type dependencies
-		auto &old_table = entry.parent->Cast<TableCatalogEntry>();
-		auto &new_table = entry.Cast<TableCatalogEntry>();
-
-		for (idx_t i = 0; i < new_table.GetColumns().LogicalColumnCount(); i++) {
-			auto &new_column = new_table.GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
-			AdjustDependency(entry, old_table, new_column, false);
-		}
-		for (idx_t i = 0; i < old_table.GetColumns().LogicalColumnCount(); i++) {
-			auto &old_column = old_table.GetColumnsMutable().GetColumnMutable(LogicalIndex(i));
-			AdjustDependency(entry, new_table, old_column, true);
-		}
-	}
-}
-
 void CatalogSet::Undo(CatalogEntry &entry) {
 	lock_guard<mutex> write_lock(catalog.GetWriteLock());
 	lock_guard<mutex> lock(catalog_lock);
@@ -614,8 +553,6 @@ void CatalogSet::Undo(CatalogEntry &entry) {
 	// i.e. we have to place (entry) as (entry->parent) again
 	auto &to_be_removed_node = *entry.parent;
 
-	AdjustTableDependencies(entry);
-
 	if (!to_be_removed_node.deleted) {
 		// delete the entry from the dependency manager as well
 		auto &dependency_manager = catalog.GetDependencyManager();

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -106,52 +106,16 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 	}
 	// add the new object to the dependents_map of each object that it depends on
 	auto &old_dependencies = dependencies_map[old_obj];
-	catalog_entry_vector_t to_delete;
 	for (auto &dep : old_dependencies) {
 		auto &dependency = dep.get();
-		if (dependency.type == CatalogType::TYPE_ENTRY) {
-			auto &user_type = dependency.Cast<TypeCatalogEntry>();
-			auto &table = new_obj.Cast<TableCatalogEntry>();
-			bool deleted_dependency = true;
-			for (auto &column : table.GetColumns().Logical()) {
-				if (column.Type() == user_type.user_type) {
-					deleted_dependency = false;
-					break;
-				}
-			}
-			if (deleted_dependency) {
-				to_delete.push_back(dependency);
-				continue;
-			}
-		}
 		dependents_map[dependency].insert(new_obj);
 	}
-	for (auto &dep : to_delete) {
-		auto &dependency = dep.get();
-		old_dependencies.erase(dependency);
-		dependents_map[dependency].erase(old_obj);
-	}
 
 	// We might have to add a type dependency
-	catalog_entry_vector_t to_add;
-	if (new_obj.type == CatalogType::TABLE_ENTRY) {
-		auto &table = new_obj.Cast<TableCatalogEntry>();
-		for (auto &column : table.GetColumns().Logical()) {
-			auto user_type_catalog = EnumType::GetCatalog(column.Type());
-			if (user_type_catalog) {
-				to_add.push_back(*user_type_catalog);
-			}
-		}
-	}
 	// add the new object to the dependency manager
 	dependents_map[new_obj] = dependency_set_t();
 	dependencies_map[new_obj] = old_dependencies;
 
-	for (auto &dependency : to_add) {
-		dependencies_map[new_obj].insert(dependency);
-		dependents_map[dependency].insert(new_obj);
-	}
-
 	for (auto &dependency : owned_objects_to_add) {
 		dependents_map[new_obj].insert(Dependency(dependency, DependencyType::DEPENDENCY_OWNS));
 		dependents_map[dependency].insert(Dependency(new_obj, DependencyType::DEPENDENCY_OWNED_BY));

package/src/duckdb/src/common/extra_type_info.cpp

@@ -299,8 +299,8 @@ PhysicalType EnumTypeInfo::DictType(idx_t size) {
 
 template <class T>
 struct EnumTypeInfoTemplated : public EnumTypeInfo {
-	explicit EnumTypeInfoTemplated(const string &enum_name_p, Vector &values_insert_order_p, idx_t size_p)
-	    : EnumTypeInfo(enum_name_p, values_insert_order_p, size_p) {
+	explicit EnumTypeInfoTemplated(Vector &values_insert_order_p, idx_t size_p)
+	    : EnumTypeInfo(values_insert_order_p, size_p) {
 		D_ASSERT(values_insert_order_p.GetType().InternalType() == PhysicalType::VARCHAR);
 
 		UnifiedVectorFormat vdata;
@@ -320,17 +320,16 @@ struct EnumTypeInfoTemplated : public EnumTypeInfo {
 		}
 	}
 
-	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size, string enum_name) {
+	static shared_ptr<EnumTypeInfoTemplated> Deserialize(FieldReader &reader, uint32_t size) {
 		Vector values_insert_order(LogicalType::VARCHAR, size);
 		values_insert_order.Deserialize(size, reader.GetSource());
-		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
+		return make_shared<EnumTypeInfoTemplated>(values_insert_order, size);
 	}
 
 	static shared_ptr<EnumTypeInfoTemplated> FormatDeserialize(FormatDeserializer &source, uint32_t size) {
-		auto enum_name = source.ReadProperty<string>("enum_name");
 		Vector values_insert_order(LogicalType::VARCHAR, size);
 		values_insert_order.FormatDeserialize(source, size);
-		return make_shared<EnumTypeInfoTemplated>(std::move(enum_name), values_insert_order, size);
+		return make_shared<EnumTypeInfoTemplated>(values_insert_order, size);
 	}
 
 	const string_map_t<T> &GetValues() const {
@@ -344,23 +343,15 @@ private:
 	string_map_t<T> values;
 };
 
-EnumTypeInfo::EnumTypeInfo(string enum_name_p, Vector &values_insert_order_p, idx_t dict_size_p)
+EnumTypeInfo::EnumTypeInfo(Vector &values_insert_order_p, idx_t dict_size_p)
     : ExtraTypeInfo(ExtraTypeInfoType::ENUM_TYPE_INFO), values_insert_order(values_insert_order_p),
-      dict_type(EnumDictType::VECTOR_DICT), enum_name(std::move(enum_name_p)), dict_size(dict_size_p) {
+      dict_type(EnumDictType::VECTOR_DICT), dict_size(dict_size_p) {
 }
 
 const EnumDictType &EnumTypeInfo::GetEnumDictType() const {
 	return dict_type;
 }
 
-const string &EnumTypeInfo::GetEnumName() const {
-	return enum_name;
-}
-
-const string EnumTypeInfo::GetSchemaName() const {
-	return catalog_entry ? catalog_entry->schema.name : "";
-}
-
 const Vector &EnumTypeInfo::GetValuesInsertOrder() const {
 	return values_insert_order;
 }
@@ -369,19 +360,19 @@ const idx_t &EnumTypeInfo::GetDictSize() const {
 	return dict_size;
 }
 
-LogicalType EnumTypeInfo::CreateType(const string &enum_name, Vector &ordered_data, idx_t size) {
+LogicalType EnumTypeInfo::CreateType(Vector &ordered_data, idx_t size) {
 	// Generate EnumTypeInfo
 	shared_ptr<ExtraTypeInfo> info;
 	auto enum_internal_type = EnumTypeInfo::DictType(size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
-		info = make_shared<EnumTypeInfoTemplated<uint8_t>>(enum_name, ordered_data, size);
+		info = make_shared<EnumTypeInfoTemplated<uint8_t>>(ordered_data, size);
 		break;
 	case PhysicalType::UINT16:
-		info = make_shared<EnumTypeInfoTemplated<uint16_t>>(enum_name, ordered_data, size);
+		info = make_shared<EnumTypeInfoTemplated<uint16_t>>(ordered_data, size);
 		break;
 	case PhysicalType::UINT32:
-		info = make_shared<EnumTypeInfoTemplated<uint32_t>>(enum_name, ordered_data, size);
+		info = make_shared<EnumTypeInfoTemplated<uint32_t>>(ordered_data, size);
 		break;
 	default:
 		throw InternalException("Invalid Physical Type for ENUMs");
@@ -413,37 +404,22 @@ int64_t EnumType::GetPos(const LogicalType &type, const string_t &key) {
 	}
 }
 
+string_t EnumType::GetString(const LogicalType &type, idx_t pos) {
+	D_ASSERT(pos < EnumType::GetSize(type));
+	return FlatVector::GetData<string_t>(EnumType::GetValuesInsertOrder(type))[pos];
+}
+
 shared_ptr<ExtraTypeInfo> EnumTypeInfo::Deserialize(FieldReader &reader) {
-	auto schema_name = reader.ReadRequired<string>();
-	auto enum_name = reader.ReadRequired<string>();
-	auto deserialize_internals = reader.ReadRequired<bool>();
-	if (!deserialize_internals) {
-		// this means the enum should already be in the catalog.
-		auto &client_context = reader.GetSource().GetContext();
-		// See if the serializer has a catalog
-		auto catalog = reader.GetSource().GetCatalog();
-		shared_ptr<ExtraTypeInfo> extra_info;
-		if (catalog) {
-			auto enum_type = catalog->GetType(client_context, schema_name, enum_name, OnEntryNotFound::RETURN_NULL);
-			if (enum_type != LogicalType::INVALID) {
-				extra_info = enum_type.GetAuxInfoShrPtr();
-			}
-		}
-		if (!extra_info) {
-			throw InternalException("Could not find ENUM in the Catalog to deserialize");
-		}
-		return extra_info;
-	}
 	// deserialize the enum data
 	auto enum_size = reader.ReadRequired<uint32_t>();
 	auto enum_internal_type = EnumTypeInfo::DictType(enum_size);
 	switch (enum_internal_type) {
 	case PhysicalType::UINT8:
-		return EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size, enum_name);
+		return EnumTypeInfoTemplated<uint8_t>::Deserialize(reader, enum_size);
 	case PhysicalType::UINT16:
-		return EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size, enum_name);
+		return EnumTypeInfoTemplated<uint16_t>::Deserialize(reader, enum_size);
 	case PhysicalType::UINT32:
-		return EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size, enum_name);
+		return EnumTypeInfoTemplated<uint32_t>::Deserialize(reader, enum_size);
 	default:
 		throw InternalException("Invalid Physical Type for ENUMs");
 	}
@@ -491,14 +467,16 @@ void EnumTypeInfo::Serialize(FieldWriter &writer) const {
 	if (dict_type != EnumDictType::VECTOR_DICT) {
 		throw InternalException("Cannot serialize non-vector dictionary ENUM types");
 	}
-	bool serialize_internals = GetSchemaName().empty() || writer.GetSerializer().is_query_plan;
-	EnumType::Serialize(writer, *this, serialize_internals);
+	auto dict_size = GetDictSize();
+	// Store Dictionary Size
+	writer.WriteField<uint32_t>(dict_size);
+	// Store Vector Order By Insertion
+	((Vector &)GetValuesInsertOrder()).Serialize(dict_size, writer.GetSerializer()); // NOLINT - FIXME
 }
 
 void EnumTypeInfo::FormatSerialize(FormatSerializer &serializer) const {
 	ExtraTypeInfo::FormatSerialize(serializer);
 	serializer.WriteProperty("dict_size", dict_size);
-	serializer.WriteProperty("enum_name", enum_name);
 	((Vector &)values_insert_order).FormatSerialize(serializer, dict_size); // NOLINT - FIXME
 }
 

package/src/duckdb/src/common/field_writer.cpp

@@ -8,7 +8,6 @@ namespace duckdb {
 FieldWriter::FieldWriter(Serializer &serializer_p)
     : serializer(serializer_p), buffer(make_uniq<BufferedSerializer>()), field_count(0), finalized(false) {
 	buffer->SetVersion(serializer.GetVersion());
-	buffer->is_query_plan = serializer.is_query_plan;
 }
 
 FieldWriter::~FieldWriter() {

package/src/duckdb/src/common/file_system.cpp

@@ -71,11 +71,11 @@ string FileSystem::GetEnvVariable(const string &name) {
 }
 
 bool FileSystem::IsPathAbsolute(const string &path) {
-	auto path_separator = FileSystem::PathSeparator();
+	auto path_separator = PathSeparator(path);
 	return PathMatched(path, path_separator);
 }
 
-string FileSystem::PathSeparator() {
+string FileSystem::PathSeparator(const string &path) {
 	return "/";
 }
 
@@ -167,7 +167,7 @@ string FileSystem::NormalizeAbsolutePath(const string &path) {
 	return result;
 }
 
-string FileSystem::PathSeparator() {
+string FileSystem::PathSeparator(const string &path) {
 	return "\\";
 }
 
@@ -210,11 +210,11 @@ string FileSystem::GetWorkingDirectory() {
 
 string FileSystem::JoinPath(const string &a, const string &b) {
 	// FIXME: sanitize paths
-	return a + PathSeparator() + b;
+	return a + PathSeparator(a) + b;
 }
 
 string FileSystem::ConvertSeparators(const string &path) {
-	auto separator_str = PathSeparator();
+	auto separator_str = PathSeparator(path);
 	char separator = separator_str[0];
 	if (separator == '/') {
 		// on unix-based systems we only accept / as a separator
@@ -229,7 +229,7 @@ string FileSystem::ExtractName(const string &path) {
 		return string();
 	}
 	auto normalized_path = ConvertSeparators(path);
-	auto sep = PathSeparator();
+	auto sep = PathSeparator(path);
 	auto splits = StringUtil::Split(normalized_path, sep);
 	D_ASSERT(!splits.empty());
 	return splits.back();

package/src/duckdb/src/common/filename_pattern.cpp

@@ -24,7 +24,7 @@ void FilenamePattern::SetFilenamePattern(const string &pattern) {
 	_pos = std::min(_pos, (idx_t)_base.length());
 }
 
-string FilenamePattern::CreateFilename(const FileSystem &fs, const string &path, const string &extension,
+string FilenamePattern::CreateFilename(FileSystem &fs, const string &path, const string &extension,
                                        idx_t offset) const {
 	string result(_base);
 	string replacement;

package/src/duckdb/src/common/gzip_file_system.cpp

@@ -145,6 +145,13 @@ void MiniZStreamWrapper::Initialize(CompressedFile &file, bool write) {
 bool MiniZStreamWrapper::Read(StreamData &sd) {
 	// Handling for the concatenated files
 	if (sd.refresh) {
+		auto available = (uint32_t)(sd.in_buff_end - sd.in_buff_start);
+		if (available <= GZIP_FOOTER_SIZE) {
+			// Only footer is available so we just close and return finished
+			Close();
+			return true;
+		}
+
 		sd.refresh = false;
 		auto body_ptr = sd.in_buff_start + GZIP_FOOTER_SIZE;
 		uint8_t gzip_hdr[GZIP_HEADER_MINSIZE];
@@ -200,18 +207,6 @@ bool MiniZStreamWrapper::Read(StreamData &sd) {
 
 	// if stream ended, deallocate inflator
 	if (ret == duckdb_miniz::MZ_STREAM_END) {
-		// Last read from file done and remaining bytes only for footer or less
-		if ((sd.in_buff_end < sd.in_buff.get() + sd.in_buf_size) && mz_stream_ptr->avail_in <= GZIP_FOOTER_SIZE) {
-			Close();
-			return true;
-		}
-		if (mz_stream_ptr->avail_in > GZIP_FOOTER_SIZE) {
-			// Definitely not concatenated gzip
-			if (*(sd.in_buff_start + GZIP_FOOTER_SIZE) != 0x1F) {
-				Close();
-				return true;
-			}
-		}
 		// Concatenated GZIP potentially coming up - refresh input buffer
 		sd.refresh = true;
 	}

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -440,10 +440,11 @@ void UnionByName::CombineUnionTypes(const vector<string> &col_names, const vecto
 	}
 }
 
-bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(const vector<string> &files) {
+bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(const vector<string> &files, ClientContext &context) {
 	std::unordered_set<string> partitions;
+	auto &fs = FileSystem::GetFileSystem(context);
 
-	auto splits_first_file = StringUtil::Split(files.front(), FileSystem::PathSeparator());
+	auto splits_first_file = StringUtil::Split(files.front(), fs.PathSeparator(files.front()));
 	if (splits_first_file.size() < 2) {
 		return false;
 	}
@@ -457,7 +458,7 @@ bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(const vector<str
 		return false;
 	}
 	for (auto &file : files) {
-		auto splits = StringUtil::Split(file, FileSystem::PathSeparator());
+		auto splits = StringUtil::Split(file, fs.PathSeparator(file));
 		if (splits.size() != splits_first_file.size()) {
 			return false;
 		}
@@ -474,8 +475,10 @@ bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(const vector<str
 	return true;
 }
 void MultiFileReaderOptions::AutoDetectHiveTypesInternal(const string &file, ClientContext &context) {
+	auto &fs = FileSystem::GetFileSystem(context);
+
 	std::map<string, string> partitions;
-	auto splits = StringUtil::Split(file, FileSystem::PathSeparator());
+	auto splits = StringUtil::Split(file, fs.PathSeparator(file));
 	if (splits.size() < 2) {
 		return;
 	}
@@ -518,7 +521,7 @@ void MultiFileReaderOptions::AutoDetectHivePartitioning(const vector<string> &fi
 		auto_detect_hive_partitioning = false;
 	}
 	if (auto_detect_hive_partitioning) {
-		hive_partitioning = AutoDetectHivePartitioningInternal(files);
+		hive_partitioning = AutoDetectHivePartitioningInternal(files, context);
 	}
 	if (hive_partitioning && hive_types_autocast) {
 		AutoDetectHiveTypesInternal(files.front(), context);

package/src/duckdb/src/common/serializer/buffered_file_reader.cpp

@@ -63,13 +63,4 @@ ClientContext &BufferedFileReader::GetContext() {
 	return *context;
 }
 
-optional_ptr<Catalog> BufferedFileReader::GetCatalog() {
-	return catalog;
-}
-
-void BufferedFileReader::SetCatalog(Catalog &catalog_p) {
-	D_ASSERT(!catalog);
-	this->catalog = &catalog_p;
-}
-
 } // namespace duckdb

package/src/duckdb/src/common/types.cpp

@@ -395,7 +395,15 @@ string LogicalType::ToString() const {
 		return StringUtil::Format("DECIMAL(%d,%d)", width, scale);
 	}
 	case LogicalTypeId::ENUM: {
-		return KeywordHelper::WriteOptionallyQuoted(EnumType::GetTypeName(*this));
+		string ret = "ENUM(";
+		for (idx_t i = 0; i < EnumType::GetSize(*this); i++) {
+			if (i > 0) {
+				ret += ", ";
+			}
+			ret += "'" + KeywordHelper::WriteOptionallyQuoted(EnumType::GetString(*this, i).GetString(), '\'') + "'";
+		}
+		ret += ")";
+		return ret;
 	}
 	case LogicalTypeId::USER: {
 		return KeywordHelper::WriteOptionallyQuoted(UserType::GetTypeName(*this));
@@ -995,34 +1003,12 @@ LogicalType LogicalType::USER(const string &user_type_name) {
 //===--------------------------------------------------------------------===//
 // Enum Type
 //===--------------------------------------------------------------------===//
-void EnumType::Serialize(FieldWriter &writer, const ExtraTypeInfo &type_info, bool serialize_internals) {
-	D_ASSERT(type_info.type == ExtraTypeInfoType::ENUM_TYPE_INFO);
-	auto &enum_info = type_info.Cast<EnumTypeInfo>();
-	// Store Schema Name
-	writer.WriteString(enum_info.GetSchemaName());
-	// Store Enum Name
-	writer.WriteString(enum_info.GetEnumName());
-	// Store If we are serializing the internals
-	writer.WriteField<bool>(serialize_internals);
-	if (serialize_internals) {
-		// We must serialize the internals
-		auto dict_size = enum_info.GetDictSize();
-		// Store Dictionary Size
-		writer.WriteField<uint32_t>(dict_size);
-		// Store Vector Order By Insertion
-		((Vector &)enum_info.GetValuesInsertOrder()).Serialize(dict_size, writer.GetSerializer()); // NOLINT - FIXME
-	}
-}
-
-const string &EnumType::GetTypeName(const LogicalType &type) {
-	D_ASSERT(type.id() == LogicalTypeId::ENUM);
-	auto info = type.AuxInfo();
-	D_ASSERT(info);
-	return info->Cast<EnumTypeInfo>().GetEnumName();
+LogicalType LogicalType::ENUM(Vector &ordered_data, idx_t size) {
+	return EnumTypeInfo::CreateType(ordered_data, size);
 }
 
 LogicalType LogicalType::ENUM(const string &enum_name, Vector &ordered_data, idx_t size) {
-	return EnumTypeInfo::CreateType(enum_name, ordered_data, size);
+	return LogicalType::ENUM(ordered_data, size);
 }
 
 const string EnumType::GetValue(const Value &val) {
@@ -1045,27 +1031,6 @@ idx_t EnumType::GetSize(const LogicalType &type) {
 	return info->Cast<EnumTypeInfo>().GetDictSize();
 }
 
-void EnumType::SetCatalog(LogicalType &type, optional_ptr<TypeCatalogEntry> catalog_entry) {
-	auto info = type.AuxInfo();
-	if (!info) {
-		return;
-	}
-	((ExtraTypeInfo &)*info).catalog_entry = catalog_entry;
-}
-
-optional_ptr<TypeCatalogEntry> EnumType::GetCatalog(const LogicalType &type) {
-	auto info = type.AuxInfo();
-	if (!info) {
-		return nullptr;
-	}
-	return info->catalog_entry;
-}
-
-string EnumType::GetSchemaName(const LogicalType &type) {
-	auto catalog_entry = EnumType::GetCatalog(type);
-	return catalog_entry ? catalog_entry->schema.name : "";
-}
-
 PhysicalType EnumType::GetPhysicalType(const LogicalType &type) {
 	D_ASSERT(type.id() == LogicalTypeId::ENUM);
 	auto aux_info = type.AuxInfo();
@@ -1090,15 +1055,6 @@ void LogicalType::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void LogicalType::SerializeEnumType(Serializer &serializer) const {
-	FieldWriter writer(serializer);
-	writer.WriteField<LogicalTypeId>(id_);
-	writer.WriteField<ExtraTypeInfoType>(type_info_->type);
-	EnumType::Serialize(writer, *type_info_, true);
-	writer.WriteString(type_info_->alias);
-	writer.Finalize();
-}
-
 LogicalType LogicalType::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto id = reader.ReadRequired<LogicalTypeId>();

package/src/duckdb/src/common/virtual_file_system.cpp

@@ -108,6 +108,10 @@ void VirtualFileSystem::RemoveFile(const string &filename) {
 	FindFileSystem(filename).RemoveFile(filename);
 }
 
+string VirtualFileSystem::PathSeparator(const string &path) {
+	return FindFileSystem(path).PathSeparator(path);
+}
+
 vector<string> VirtualFileSystem::Glob(const string &path, FileOpener *opener) {
 	return FindFileSystem(path).Glob(path, opener);
 }