duckdb 1.3.1-dev6.0 → 1.3.2-dev0.0

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

@@ -650,12 +650,13 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret
 	auto &context = retriever.GetContext();
 	auto entries = SimilarEntriesInSchemas(context, lookup_info, schemas);
 
+	auto &config = DBConfig::GetConfig(context);
+	auto max_schema_count = config.GetSetting<CatalogErrorMaxSchemasSetting>(context);
+
 	reference_set_t<SchemaCatalogEntry> unseen_schemas;
 	auto &db_manager = DatabaseManager::Get(context);
-	auto databases = db_manager.GetDatabases(context);
-	auto &config = DBConfig::GetConfig(context);
+	auto databases = db_manager.GetDatabases(context, max_schema_count);
 
-	auto max_schema_count = config.GetSetting<CatalogErrorMaxSchemasSetting>(context);
 	for (auto database : databases) {
 		if (unseen_schemas.size() >= max_schema_count) {
 			break;
@@ -669,7 +670,8 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret
 			unseen_schemas.insert(current_schema.get());
 		}
 	}
-	// check if the entry exists in any extension
+
+	// Check if the entry exists in any extension.
 	string extension_name;
 	auto type = lookup_info.GetCatalogType();
 	auto &entry_name = lookup_info.GetEntryName();
@@ -732,6 +734,7 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret
 	static constexpr const double UNSEEN_PENALTY = 0.2;
 	auto unseen_entries = SimilarEntriesInSchemas(context, lookup_info, unseen_schemas);
 	set<string> suggestions;
+
 	if (!unseen_entries.empty() && (unseen_entries[0].score == 1.0 || unseen_entries[0].score - UNSEEN_PENALTY >
 	                                                                      (entries.empty() ? 0.0 : entries[0].score))) {
 		// the closest matching entry requires qualification as it is not in the default search path
@@ -1201,6 +1204,9 @@ void Catalog::Initialize(optional_ptr<ClientContext> context, bool load_builtin)
 	Initialize(load_builtin);
 }
 
+void Catalog::FinalizeLoad(optional_ptr<ClientContext> context) {
+}
+
 void Catalog::OnDetach(ClientContext &context) {
 }
 

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

@@ -160,7 +160,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(CatalogTransaction transacti
 	}
 
 	// We add foreign key constraints without a client context during checkpoint loading.
-	return AddForeignKeyConstraint(nullptr, foreign_key_constraint_info);
+	return AddForeignKeyConstraint(foreign_key_constraint_info);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
@@ -219,7 +219,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, Alte
 	case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
 		auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
 		if (foreign_key_constraint_info.type == AlterForeignKeyType::AFT_ADD) {
-			return AddForeignKeyConstraint(context, foreign_key_constraint_info);
+			return AddForeignKeyConstraint(foreign_key_constraint_info);
 		} else {
 			return DropForeignKeyConstraint(context, foreign_key_constraint_info);
 		}
@@ -1101,8 +1101,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetColumnComment(ClientContext &context
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
-unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(optional_ptr<ClientContext> context,
-                                                                 AlterForeignKeyInfo &info) {
+unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(AlterForeignKeyInfo &info) {
 	D_ASSERT(info.type == AlterForeignKeyType::AFT_ADD);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
@@ -1123,12 +1122,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(optional_ptr<Cl
 	    make_uniq<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, std::move(fk_info)));
 
 	unique_ptr<BoundCreateTableInfo> bound_create_info;
-	if (context) {
-		auto binder = Binder::CreateBinder(*context);
-		bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	} else {
-		bound_create_info = Binder::BindCreateTableCheckpoint(std::move(create_info), schema);
-	}
+	bound_create_info = Binder::BindCreateTableCheckpoint(std::move(create_info), schema);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 

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

@@ -6,8 +6,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
-
-#include <sstream>
+#include "duckdb/original/std/sstream.hpp"
 
 namespace duckdb {
 

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

@@ -108,7 +108,7 @@ unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
 string SequenceCatalogEntry::ToSQL() const {
 	auto seq_data = GetData();
 
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	ss << "CREATE SEQUENCE ";
 	ss << name;
 	ss << " INCREMENT BY " << seq_data.increment;

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

@@ -79,7 +79,7 @@ unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
 }
 
 string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 
 	ss << "(";
 
@@ -185,7 +185,7 @@ string TableCatalogEntry::ColumnNamesToSQL(const ColumnList &columns) {
 		return "";
 	}
 
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	ss << "(";
 
 	for (auto &column : columns.Logical()) {

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

@@ -40,7 +40,7 @@ unique_ptr<CreateInfo> TypeCatalogEntry::GetInfo() const {
 }
 
 string TypeCatalogEntry::ToSQL() const {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	ss << "CREATE TYPE ";
 	ss << KeywordHelper::WriteOptionallyQuoted(name);
 	ss << " AS ";

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

@@ -149,10 +149,16 @@ string CatalogSearchPath::GetSetName(CatalogSetPathType set_type) {
 }
 
 void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type) {
-	if (set_type != CatalogSetPathType::SET_SCHEMAS && new_paths.size() != 1) {
+	if (set_type == CatalogSetPathType::SET_SCHEMA && new_paths.size() != 1) {
 		throw CatalogException("%s can set only 1 schema. This has %d", GetSetName(set_type), new_paths.size());
 	}
 	for (auto &path : new_paths) {
+		if (set_type == CatalogSetPathType::SET_DIRECTLY) {
+			if (path.catalog.empty() || path.schema.empty()) {
+				throw InternalException("SET_WITHOUT_VERIFICATION requires a fully qualified set path");
+			}
+			continue;
+		}
 		auto schema_entry = Catalog::GetSchema(context, path.catalog, path.schema, OnEntryNotFound::RETURN_NULL);
 		if (schema_entry) {
 			// we are setting a schema - update the catalog and schema

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

@@ -674,7 +674,7 @@ void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_loc
 }
 
 void CatalogSet::Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback) {
-	// lock the catalog set
+	// Lock the catalog set.
 	unique_lock<mutex> lock(catalog_lock);
 	CreateDefaultEntries(transaction, lock);
 
@@ -687,10 +687,30 @@ void CatalogSet::Scan(CatalogTransaction transaction, const std::function<void(C
 	}
 }
 
+void CatalogSet::ScanWithReturn(CatalogTransaction transaction, const std::function<bool(CatalogEntry &)> &callback) {
+	// Lock the catalog set.
+	unique_lock<mutex> lock(catalog_lock);
+	CreateDefaultEntries(transaction, lock);
+
+	for (auto &kv : map.Entries()) {
+		auto &entry = *kv.second;
+		auto &entry_for_transaction = GetEntryForTransaction(transaction, entry);
+		if (!entry_for_transaction.deleted) {
+			if (!callback(entry_for_transaction)) {
+				return;
+			}
+		}
+	}
+}
+
 void CatalogSet::Scan(ClientContext &context, const std::function<void(CatalogEntry &)> &callback) {
 	Scan(catalog.GetCatalogTransaction(context), callback);
 }
 
+void CatalogSet::ScanWithReturn(ClientContext &context, const std::function<bool(CatalogEntry &)> &callback) {
+	ScanWithReturn(catalog.GetCatalogTransaction(context), callback);
+}
+
 void CatalogSet::ScanWithPrefix(CatalogTransaction transaction, const std::function<void(CatalogEntry &)> &callback,
                                 const string &prefix) {
 	// lock the catalog set

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -1067,7 +1067,7 @@ AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *k
 			return ADBC_STATUS_INVALID_ARGUMENT;
 		}
 	}
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	ss << "Statement Set Option " << key << " is not yet accepted by DuckDB";
 	SetError(error, ss.str());
 	return ADBC_STATUS_INVALID_ARGUMENT;

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -215,13 +215,25 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 	case LogicalTypeId::DECIMAL:
 		switch (type.InternalType()) {
 		case PhysicalType::INT16:
-			InitializeAppenderForType<ArrowScalarData<int32_t, int16_t>>(append_data);
+			if (append_data.options.arrow_output_version > 14) {
+				InitializeAppenderForType<ArrowScalarData<int32_t, int16_t>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowScalarData<hugeint_t, int16_t>>(append_data);
+			}
 			break;
 		case PhysicalType::INT32:
-			InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
+			if (append_data.options.arrow_output_version > 14) {
+				InitializeAppenderForType<ArrowScalarData<int32_t>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowScalarData<hugeint_t, int32_t>>(append_data);
+			}
 			break;
 		case PhysicalType::INT64:
-			InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
+			if (append_data.options.arrow_output_version > 14) {
+				InitializeAppenderForType<ArrowScalarData<int64_t>>(append_data);
+			} else {
+				InitializeAppenderForType<ArrowScalarData<hugeint_t, int64_t>>(append_data);
+			}
 			break;
 		case PhysicalType::INT128:
 			InitializeAppenderForType<ArrowScalarData<hugeint_t>>(append_data);
@@ -231,7 +243,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		}
 		break;
 	case LogicalTypeId::VARCHAR:
-		if (append_data.options.produce_arrow_string_view) {
+		if (append_data.options.produce_arrow_string_view && append_data.options.arrow_output_version >= 14) {
 			InitializeAppenderForType<ArrowVarcharToStringViewData>(append_data);
 		} else {
 			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
@@ -278,7 +290,7 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic
 		InitializeAppenderForType<ArrowFixedSizeListData>(append_data);
 		break;
 	case LogicalTypeId::LIST: {
-		if (append_data.options.arrow_use_list_view) {
+		if (append_data.options.arrow_use_list_view && append_data.options.arrow_output_version >= 14) {
 			if (append_data.options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 				InitializeAppenderForType<ArrowListViewData<>>(append_data);
 			} else {

package/src/duckdb/src/common/arrow/arrow_converter.cpp

@@ -173,7 +173,8 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		if (options.arrow_lossless_conversion) {
 			SetArrowExtension(root_holder, child, type, context);
 		} else {
-			if (options.produce_arrow_string_view) {
+			if (options.produce_arrow_string_view && options.arrow_output_version >= 14) {
+				// List views are only introduced in arrow format v1.4
 				child.format = "vu";
 			} else {
 				if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
@@ -186,7 +187,8 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	}
 	case LogicalTypeId::VARCHAR:
-		if (options.produce_arrow_string_view) {
+		if (options.produce_arrow_string_view && options.arrow_output_version >= 14) {
+			// List views are only introduced in arrow format v1.4
 			child.format = "vu";
 		} else {
 			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
@@ -233,19 +235,24 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	case LogicalTypeId::DECIMAL: {
 		uint8_t width, scale, bit_width;
-		switch (type.InternalType()) {
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-			bit_width = 32;
-			break;
-		case PhysicalType::INT64:
-			bit_width = 64;
-			break;
-		case PhysicalType::INT128:
+		if (options.arrow_output_version <= 14) {
+			// Before version 1.4 all decimals were int128
 			bit_width = 128;
-			break;
-		default:
-			throw NotImplementedException("Unsupported internal type For DUCKDB Decimal -> Arrow ");
+		} else {
+			switch (type.InternalType()) {
+			case PhysicalType::INT16:
+			case PhysicalType::INT32:
+				bit_width = 32;
+				break;
+			case PhysicalType::INT64:
+				bit_width = 64;
+				break;
+			case PhysicalType::INT128:
+				bit_width = 128;
+				break;
+			default:
+				throw NotImplementedException("Unsupported internal type For DUCKDB Decimal -> Arrow ");
+			}
 		}
 
 		type.GetDecimalProperties(width, scale);
@@ -279,7 +286,8 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co
 		break;
 	}
 	case LogicalTypeId::LIST: {
-		if (options.arrow_use_list_view) {
+		if (options.arrow_use_list_view && options.arrow_output_version >= 14) {
+			// List views are only introduced in arrow format v1.4
 			if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
 				child.format = "+vL";
 			} else {

package/src/duckdb/src/common/box_renderer.cpp

@@ -3,10 +3,9 @@
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/original/std/sstream.hpp"
 #include "utf8proc_wrapper.hpp"
 
-#include <sstream>
-
 namespace duckdb {
 
 const idx_t BoxRenderer::SPLIT_COLUMN = idx_t(-1);

package/src/duckdb/src/common/enum_util.cpp

@@ -1719,19 +1719,20 @@ const StringUtil::EnumStringLiteral *GetFileBufferTypeValues() {
 	static constexpr StringUtil::EnumStringLiteral values[] {
 		{ static_cast<uint32_t>(FileBufferType::BLOCK), "BLOCK" },
 		{ static_cast<uint32_t>(FileBufferType::MANAGED_BUFFER), "MANAGED_BUFFER" },
-		{ static_cast<uint32_t>(FileBufferType::TINY_BUFFER), "TINY_BUFFER" }
+		{ static_cast<uint32_t>(FileBufferType::TINY_BUFFER), "TINY_BUFFER" },
+		{ static_cast<uint32_t>(FileBufferType::EXTERNAL_FILE), "EXTERNAL_FILE" }
 	};
 	return values;
 }
 
 template<>
 const char* EnumUtil::ToChars<FileBufferType>(FileBufferType value) {
-	return StringUtil::EnumToString(GetFileBufferTypeValues(), 3, "FileBufferType", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetFileBufferTypeValues(), 4, "FileBufferType", static_cast<uint32_t>(value));
 }
 
 template<>
 FileBufferType EnumUtil::FromString<FileBufferType>(const char *value) {
-	return static_cast<FileBufferType>(StringUtil::StringToEnum(GetFileBufferTypeValues(), 3, "FileBufferType", value));
+	return static_cast<FileBufferType>(StringUtil::StringToEnum(GetFileBufferTypeValues(), 4, "FileBufferType", value));
 }
 
 const StringUtil::EnumStringLiteral *GetFileCompressionTypeValues() {

package/src/duckdb/src/common/local_file_system.cpp

@@ -696,7 +696,7 @@ bool LocalFileSystem::ListFilesExtended(const string &directory,
 	}
 
 	// RAII wrapper around DIR to automatically free on exceptions in callback
-	std::unique_ptr<DIR, std::function<void(DIR *)>> dir_unique_ptr(dir, [](DIR *d) { closedir(d); });
+	duckdb::unique_ptr<DIR, std::function<void(DIR *)>> dir_unique_ptr(dir, [](DIR *d) { closedir(d); });
 
 	struct dirent *ent;
 	// loop over all files in the directory
@@ -838,13 +838,13 @@ static string AdditionalLockInfo(const std::wstring path) {
 
 	status = RmStartSession(&session, 0, session_key);
 	if (status != ERROR_SUCCESS) {
-		return "";
+		return string();
 	}
 
 	PCWSTR path_ptr = path.c_str();
 	status = RmRegisterResources(session, 1, &path_ptr, 0, NULL, 0, NULL);
 	if (status != ERROR_SUCCESS) {
-		return "";
+		return string();
 	}
 	UINT process_info_size_needed, process_info_size;
 
@@ -852,7 +852,7 @@ static string AdditionalLockInfo(const std::wstring path) {
 	process_info_size = 0;
 	status = RmGetList(session, &process_info_size_needed, &process_info_size, NULL, &reason);
 	if (status != ERROR_MORE_DATA || process_info_size_needed == 0) {
-		return "";
+		return string();
 	}
 
 	// allocate
@@ -866,8 +866,7 @@ static string AdditionalLockInfo(const std::wstring path) {
 		return "";
 	}
 
-	string conflict_string = "File is already open in ";
-
+	string conflict_string;
 	for (UINT process_idx = 0; process_idx < process_info_size; process_idx++) {
 		string process_name = WindowsUtil::UnicodeToUTF8(process_info[process_idx].strAppName);
 		auto pid = process_info[process_idx].Process.dwProcessId;
@@ -886,7 +885,10 @@ static string AdditionalLockInfo(const std::wstring path) {
 	}
 
 	RmEndSession(session);
-	return conflict_string;
+	if (conflict_string.empty()) {
+		return string();
+	}
+	return "File is already open in " + conflict_string;
 }
 
 bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) {
@@ -950,12 +952,11 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path_p, FileOpenF
 		}
 		auto error = LocalFileSystem::GetLastErrorAsString();
 
-		auto better_error = AdditionalLockInfo(unicode_path);
-		if (!better_error.empty()) {
-			throw IOException(better_error);
-		} else {
-			throw IOException("Cannot open file \"%s\": %s", path.c_str(), error);
+		auto extended_error = AdditionalLockInfo(unicode_path);
+		if (!extended_error.empty()) {
+			extended_error = "\n" + extended_error;
 		}
+		throw IOException("Cannot open file \"%s\": %s%s", path.c_str(), error, extended_error);
 	}
 	auto handle = make_uniq<WindowsFileHandle>(*this, path.c_str(), hFile, flags);
 	if (flags.OpenForAppending()) {

package/src/duckdb/src/common/multi_file/multi_file_column_mapper.cpp

@@ -18,11 +18,10 @@ MultiFileColumnMapper::MultiFileColumnMapper(ClientContext &context, MultiFileRe
                                              const vector<MultiFileColumnDefinition> &global_columns,
                                              const vector<ColumnIndex> &global_column_ids,
                                              optional_ptr<TableFilterSet> filters, MultiFileList &multi_file_list,
-                                             const MultiFileReaderBindData &bind_data,
                                              const virtual_column_map_t &virtual_columns)
     : context(context), multi_file_reader(multi_file_reader), multi_file_list(multi_file_list),
       reader_data(reader_data), global_columns(global_columns), global_column_ids(global_column_ids),
-      global_filters(filters), bind_data(bind_data), virtual_columns(virtual_columns) {
+      global_filters(filters), virtual_columns(virtual_columns) {
 }
 
 struct MultiFileIndexMapping {
@@ -297,6 +296,19 @@ ColumnMapResult MapColumnList(ClientContext &context, const MultiFileColumnDefin
 			result.column_map = Value::STRUCT(std::move(child_list));
 		}
 	}
+	if (is_selected && child_map.default_value) {
+		// we have default values at a previous level wrap it in a "list"
+		child_list_t<LogicalType> default_type_list;
+		default_type_list.emplace_back("list", child_map.default_value->return_type);
+		vector<unique_ptr<Expression>> default_expressions;
+		child_map.default_value->alias = "list";
+		default_expressions.push_back(std::move(child_map.default_value));
+		auto default_type = LogicalType::STRUCT(std::move(default_type_list));
+		auto struct_pack_fun = StructPackFun::GetFunction();
+		auto bind_data = make_uniq<VariableReturnBindData>(default_type);
+		result.default_value = make_uniq<BoundFunctionExpression>(std::move(default_type), std::move(struct_pack_fun),
+		                                                          std::move(default_expressions), std::move(bind_data));
+	}
 	result.column_index = make_uniq<ColumnIndex>(local_id.GetId(), std::move(child_indexes));
 	result.mapping = std::move(mapping);
 	return result;
@@ -347,7 +359,7 @@ ColumnMapResult MapColumnMap(ClientContext &context, const MultiFileColumnDefini
 
 	auto nested_mapper = mapper.Create(local_key_value.children);
 	child_list_t<Value> column_mapping;
-	unique_ptr<Expression> default_expression;
+	vector<unique_ptr<Expression>> default_expressions;
 	unordered_map<idx_t, const_reference<ColumnIndex>> selected_children;
 	if (global_index.HasChildren()) {
 		//! FIXME: is this expected for maps??
@@ -378,6 +390,10 @@ ColumnMapResult MapColumnMap(ClientContext &context, const MultiFileColumnDefini
 			// found a column mapping for the component - emplace it
 			column_mapping.emplace_back(name, std::move(map_result.column_map));
 		}
+		if (map_result.default_value) {
+			map_result.default_value->alias = name;
+			default_expressions.push_back(std::move(map_result.default_value));
+		}
 	}
 
 	ColumnMapResult result;
@@ -393,6 +409,18 @@ ColumnMapResult MapColumnMap(ClientContext &context, const MultiFileColumnDefini
 			result.column_map = Value::STRUCT(std::move(child_list));
 		}
 	}
+	if (!default_expressions.empty()) {
+		// we have default values at a previous level wrap it in a "list"
+		child_list_t<LogicalType> default_type_list;
+		for (auto &expr : default_expressions) {
+			default_type_list.emplace_back(expr->GetAlias(), expr->return_type);
+		}
+		auto default_type = LogicalType::STRUCT(std::move(default_type_list));
+		auto struct_pack_fun = StructPackFun::GetFunction();
+		auto bind_data = make_uniq<VariableReturnBindData>(default_type);
+		result.default_value = make_uniq<BoundFunctionExpression>(std::move(default_type), std::move(struct_pack_fun),
+		                                                          std::move(default_expressions), std::move(bind_data));
+	}
 	vector<ColumnIndex> map_indexes;
 	map_indexes.emplace_back(0, std::move(child_indexes));
 
@@ -563,11 +591,6 @@ unique_ptr<Expression> ConstructMapExpression(ClientContext &context, idx_t loca
 		}
 		return expr;
 	}
-	// struct column - generate a remap_struct - but only if we have any columns to remap
-	if (mapping.column_map.IsNull()) {
-		// no columns to map - emit the default value directly
-		return std::move(mapping.default_value);
-	}
 	// generate the remap_struct function call
 	vector<unique_ptr<Expression>> children;
 	children.push_back(std::move(expr));
@@ -719,10 +742,10 @@ ResultColumnMapping MultiFileColumnMapper::CreateColumnMappingByMapper(const Col
 	return result;
 }
 
-ResultColumnMapping MultiFileColumnMapper::CreateColumnMapping() {
+ResultColumnMapping MultiFileColumnMapper::CreateColumnMapping(MultiFileColumnMappingMode mapping_mode) {
 	auto &reader = *reader_data.reader;
 	auto &local_columns = reader.GetColumns();
-	switch (bind_data.mapping) {
+	switch (mapping_mode) {
 	case MultiFileColumnMappingMode::BY_NAME: {
 		// we have expected types: create a map of name -> (local) column id
 		NameMapper name_map(*this, local_columns);
@@ -1083,9 +1106,9 @@ unique_ptr<TableFilterSet> MultiFileColumnMapper::CreateFilters(map<idx_t, refer
 	return result;
 }
 
-ReaderInitializeType MultiFileColumnMapper::CreateMapping() {
+ReaderInitializeType MultiFileColumnMapper::CreateMapping(MultiFileColumnMappingMode mapping_mode) {
 	// copy global columns and inject any different defaults
-	auto result = CreateColumnMapping();
+	auto result = CreateColumnMapping(mapping_mode);
 	//! Evaluate the filters against the column(s) that are constant for this file (not present in the local schema)
 	//! If any of these fail, the file can be skipped entirely
 	map<idx_t, reference<TableFilter>> remaining_filters;

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

@@ -371,13 +371,23 @@ MultiFileReader::InitializeGlobalState(ClientContext &context, const MultiFileOp
 	return nullptr;
 }
 
+ReaderInitializeType
+MultiFileReader::CreateMapping(ClientContext &context, MultiFileReaderData &reader_data,
+                               const vector<MultiFileColumnDefinition> &global_columns,
+                               const vector<ColumnIndex> &global_column_ids, optional_ptr<TableFilterSet> filters,
+                               MultiFileList &multi_file_list, const MultiFileReaderBindData &bind_data,
+                               const virtual_column_map_t &virtual_columns, MultiFileColumnMappingMode mapping_mode) {
+	MultiFileColumnMapper column_mapper(context, *this, reader_data, global_columns, global_column_ids, filters,
+	                                    multi_file_list, virtual_columns);
+	return column_mapper.CreateMapping(mapping_mode);
+}
+
 ReaderInitializeType MultiFileReader::CreateMapping(
     ClientContext &context, MultiFileReaderData &reader_data, const vector<MultiFileColumnDefinition> &global_columns,
     const vector<ColumnIndex> &global_column_ids, optional_ptr<TableFilterSet> filters, MultiFileList &multi_file_list,
     const MultiFileReaderBindData &bind_data, const virtual_column_map_t &virtual_columns) {
-	MultiFileColumnMapper column_mapper(context, *this, reader_data, global_columns, global_column_ids, filters,
-	                                    multi_file_list, bind_data, virtual_columns);
-	return column_mapper.CreateMapping();
+	return CreateMapping(context, reader_data, global_columns, global_column_ids, filters, multi_file_list, bind_data,
+	                     virtual_columns, bind_data.mapping);
 }
 
 string GetExtendedMultiFileError(const MultiFileBindData &bind_data, const Expression &expr, BaseFileReader &reader,

package/src/duckdb/src/common/string_util.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/exception/parser_exception.hpp"
 #include "duckdb/common/random_engine.hpp"
+#include "duckdb/original/std/sstream.hpp"
 #include "jaro_winkler.hpp"
 #include "utf8proc_wrapper.hpp"
 
@@ -14,7 +15,6 @@
 #include <cctype>
 #include <iomanip>
 #include <memory>
-#include <sstream>
 #include <stdarg.h>
 #include <string.h>
 #include <stack>
@@ -27,7 +27,7 @@ namespace duckdb {
 
 string StringUtil::GenerateRandomName(idx_t length) {
 	RandomEngine engine;
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	for (idx_t i = 0; i < length; i++) {
 		ss << "0123456789abcdef"[engine.NextRandomInteger(0, 15)];
 	}
@@ -105,7 +105,7 @@ string StringUtil::Repeat(const string &str, idx_t n) {
 namespace string_util_internal {
 
 inline void SkipSpaces(const string &str, idx_t &index) {
-	while (index < str.size() && std::isspace(str[index])) {
+	while (index < str.size() && StringUtil::CharacterIsSpace(str[index])) {
 		index++;
 	}
 }
@@ -136,7 +136,9 @@ inline string TakePossiblyQuotedItem(const string &str, idx_t &index, char delim
 		ConsumeLetter(str, index, quote);
 	} else {
 		TakeWhile(
-		    str, index, [delimiter, quote](char c) { return c != delimiter && c != quote && !std::isspace(c); }, entry);
+		    str, index,
+		    [delimiter, quote](char c) { return c != delimiter && c != quote && !StringUtil::CharacterIsSpace(c); },
+		    entry);
 	}
 
 	return entry;
@@ -342,7 +344,7 @@ idx_t StringUtil::CIFind(vector<string> &vector, const string &search_string) {
 }
 
 vector<string> StringUtil::Split(const string &str, char delimiter) {
-	std::stringstream ss(str);
+	duckdb::stringstream ss(str);
 	vector<string> lines;
 	string temp;
 	while (getline(ss, temp, delimiter)) {

package/src/duckdb/src/common/tree_renderer/graphviz_tree_renderer.cpp

@@ -16,25 +16,25 @@
 namespace duckdb {
 
 string GRAPHVIZTreeRenderer::ToString(const LogicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string GRAPHVIZTreeRenderer::ToString(const PhysicalOperator &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string GRAPHVIZTreeRenderer::ToString(const ProfilingNode &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }
 
 string GRAPHVIZTreeRenderer::ToString(const Pipeline &op) {
-	std::stringstream ss;
+	duckdb::stringstream ss;
 	Render(op, ss);
 	return ss.str();
 }