duckdb 1.4.0 → 1.4.1-dev2.0

package/src/duckdb/extension/parquet/writer/array_column_writer.cpp

@@ -9,6 +9,22 @@ void ArrayColumnWriter::Analyze(ColumnWriterState &state_p, ColumnWriterState *p
 	child_writer->Analyze(*state.child_state, &state_p, array_child, array_size * count);
 }
 
+void ArrayColumnWriter::WriteArrayState(ListColumnWriterState &state, idx_t array_size, uint16_t first_repeat_level,
+                                        idx_t define_value, const bool is_empty) {
+	state.definition_levels.push_back(define_value);
+	state.repetition_levels.push_back(first_repeat_level);
+	state.is_empty.push_back(is_empty);
+
+	if (is_empty) {
+		return;
+	}
+	for (idx_t k = 1; k < array_size; k++) {
+		state.repetition_levels.push_back(MaxRepeat() + 1);
+		state.definition_levels.push_back(define_value);
+		state.is_empty.push_back(false);
+	}
+}
+
 void ArrayColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *parent, Vector &vector, idx_t count,
                                 bool vector_can_span_multiple_pages) {
 	auto &state = state_p.Cast<ListColumnWriterState>();
@@ -25,42 +41,20 @@ void ArrayColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *p
 	for (idx_t i = start; i < vcount; i++) {
 		idx_t parent_index = state.parent_index + i;
 		if (parent && !parent->is_empty.empty() && parent->is_empty[parent_index]) {
-			state.definition_levels.push_back(parent->definition_levels[parent_index]);
-			state.repetition_levels.push_back(parent->repetition_levels[parent_index]);
-			state.is_empty.push_back(true);
+			WriteArrayState(state, array_size, parent->repetition_levels[parent_index],
+			                parent->definition_levels[parent_index], true);
 			continue;
 		}
 		auto first_repeat_level =
 		    parent && !parent->repetition_levels.empty() ? parent->repetition_levels[parent_index] : MaxRepeat();
 		if (parent && parent->definition_levels[parent_index] != PARQUET_DEFINE_VALID) {
-			state.definition_levels.push_back(parent->definition_levels[parent_index]);
-			state.repetition_levels.push_back(first_repeat_level);
-			state.is_empty.push_back(false);
-			for (idx_t k = 1; k < array_size; k++) {
-				state.repetition_levels.push_back(MaxRepeat() + 1);
-				state.definition_levels.push_back(parent->definition_levels[parent_index]);
-				state.is_empty.push_back(false);
-			}
+			WriteArrayState(state, array_size, first_repeat_level, parent->definition_levels[parent_index]);
 		} else if (validity.RowIsValid(vector_index)) {
 			// push the repetition levels
-			state.definition_levels.push_back(PARQUET_DEFINE_VALID);
-			state.is_empty.push_back(false);
-
-			state.repetition_levels.push_back(first_repeat_level);
-			for (idx_t k = 1; k < array_size; k++) {
-				state.repetition_levels.push_back(MaxRepeat() + 1);
-				state.definition_levels.push_back(PARQUET_DEFINE_VALID);
-				state.is_empty.push_back(false);
-			}
+			WriteArrayState(state, array_size, first_repeat_level, PARQUET_DEFINE_VALID);
 		} else {
-			state.definition_levels.push_back(MaxDefine() - 1);
-			state.repetition_levels.push_back(first_repeat_level);
-			state.is_empty.push_back(false);
-			for (idx_t k = 1; k < array_size; k++) {
-				state.repetition_levels.push_back(MaxRepeat() + 1);
-				state.definition_levels.push_back(MaxDefine() - 1);
-				state.is_empty.push_back(false);
-			}
+			//! Produce a null
+			WriteArrayState(state, array_size, first_repeat_level, MaxDefine() - 1);
 		}
 		vector_index++;
 	}

package/src/duckdb/extension/parquet/writer/primitive_column_writer.cpp

@@ -304,12 +304,24 @@ void PrimitiveColumnWriter::SetParquetStatistics(PrimitiveColumnWriterState &sta
 	}
 
 	if (state.stats_state->HasGeoStats()) {
-		column_chunk.meta_data.__isset.geospatial_statistics = true;
-		state.stats_state->WriteGeoStats(column_chunk.meta_data.geospatial_statistics);
 
-		// Add the geospatial statistics to the extra GeoParquet metadata
-		writer.GetGeoParquetData().AddGeoParquetStats(column_schema.name, column_schema.type,
-		                                              *state.stats_state->GetGeoStats());
+		auto gpq_version = writer.GetGeoParquetVersion();
+
+		const auto has_real_stats = gpq_version == GeoParquetVersion::NONE || gpq_version == GeoParquetVersion::BOTH ||
+		                            gpq_version == GeoParquetVersion::V2;
+		const auto has_json_stats = gpq_version == GeoParquetVersion::V1 || gpq_version == GeoParquetVersion::BOTH ||
+		                            gpq_version == GeoParquetVersion::V2;
+
+		if (has_real_stats) {
+			// Write the parquet native geospatial statistics
+			column_chunk.meta_data.__isset.geospatial_statistics = true;
+			state.stats_state->WriteGeoStats(column_chunk.meta_data.geospatial_statistics);
+		}
+		if (has_json_stats) {
+			// Add the geospatial statistics to the extra GeoParquet metadata
+			writer.GetGeoParquetData().AddGeoParquetStats(column_schema.name, column_schema.type,
+			                                              *state.stats_state->GetGeoStats());
+		}
 	}
 
 	for (const auto &write_info : state.write_info) {

package/src/duckdb/extension/parquet/writer/struct_column_writer.cpp

@@ -62,8 +62,9 @@ void StructColumnWriter::Prepare(ColumnWriterState &state_p, ColumnWriterState *
 	auto &validity = FlatVector::Validity(vector);
 	if (parent) {
 		// propagate empty entries from the parent
-		while (state.is_empty.size() < parent->is_empty.size()) {
-			state.is_empty.push_back(parent->is_empty[state.is_empty.size()]);
+		if (state.is_empty.size() < parent->is_empty.size()) {
+			state.is_empty.insert(state.is_empty.end(), parent->is_empty.begin() + state.is_empty.size(),
+			                      parent->is_empty.end());
 		}
 	}
 	HandleRepeatLevels(state_p, parent, count, MaxRepeat());

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

@@ -24,8 +24,8 @@ string CatalogSearchEntry::ToString() const {
 
 string CatalogSearchEntry::WriteOptionallyQuoted(const string &input) {
 	for (idx_t i = 0; i < input.size(); i++) {
-		if (input[i] == '.' || input[i] == ',') {
-			return "\"" + input + "\"";
+		if (input[i] == '.' || input[i] == ',' || input[i] == '"') {
+			return "\"" + StringUtil::Replace(input, "\"", "\"\"") + "\"";
 		}
 	}
 	return input;

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

@@ -401,8 +401,6 @@ bool CatalogSet::DropEntryInternal(CatalogTransaction transaction, const string
 		throw CatalogException("Cannot drop entry \"%s\" because it is an internal system entry", entry->name);
 	}
 
-	entry->OnDrop();
-
 	// create a new tombstone entry and replace the currently stored one
 	// set the timestamp to the timestamp of the current transaction
 	// and point it at the tombstone node
@@ -454,6 +452,7 @@ void CatalogSet::VerifyExistenceOfDependency(transaction_t commit_id, CatalogEnt
 void CatalogSet::CommitDrop(transaction_t commit_id, transaction_t start_time, CatalogEntry &entry) {
 	auto &duck_catalog = GetCatalog();
 
+	entry.OnDrop();
 	// Make sure that we don't see any uncommitted changes
 	auto transaction_id = MAX_TRANSACTION_ID;
 	// This will allow us to see all committed changes made before this COMMIT happened

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

@@ -117,6 +117,7 @@
 #include "duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/function/window/window_merge_sort_tree.hpp"
+#include "duckdb/logging/log_storage.hpp"
 #include "duckdb/logging/logging.hpp"
 #include "duckdb/main/appender.hpp"
 #include "duckdb/main/capi/capi_internal.hpp"
@@ -2439,6 +2440,25 @@ LogMode EnumUtil::FromString<LogMode>(const char *value) {
 	return static_cast<LogMode>(StringUtil::StringToEnum(GetLogModeValues(), 3, "LogMode", value));
 }
 
+const StringUtil::EnumStringLiteral *GetLoggingTargetTableValues() {
+	static constexpr StringUtil::EnumStringLiteral values[] {
+		{ static_cast<uint32_t>(LoggingTargetTable::ALL_LOGS), "ALL_LOGS" },
+		{ static_cast<uint32_t>(LoggingTargetTable::LOG_ENTRIES), "LOG_ENTRIES" },
+		{ static_cast<uint32_t>(LoggingTargetTable::LOG_CONTEXTS), "LOG_CONTEXTS" }
+	};
+	return values;
+}
+
+template<>
+const char* EnumUtil::ToChars<LoggingTargetTable>(LoggingTargetTable value) {
+	return StringUtil::EnumToString(GetLoggingTargetTableValues(), 3, "LoggingTargetTable", static_cast<uint32_t>(value));
+}
+
+template<>
+LoggingTargetTable EnumUtil::FromString<LoggingTargetTable>(const char *value) {
+	return static_cast<LoggingTargetTable>(StringUtil::StringToEnum(GetLoggingTargetTableValues(), 3, "LoggingTargetTable", value));
+}
+
 const StringUtil::EnumStringLiteral *GetLogicalOperatorTypeValues() {
 	static constexpr StringUtil::EnumStringLiteral values[] {
 		{ static_cast<uint32_t>(LogicalOperatorType::LOGICAL_INVALID), "LOGICAL_INVALID" },

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

@@ -628,39 +628,9 @@ bool FileSystem::CanHandleFile(const string &fpath) {
 	throw NotImplementedException("%s: CanHandleFile is not implemented!", GetName());
 }
 
-static string LookupExtensionForPattern(const string &pattern) {
-	for (const auto &entry : EXTENSION_FILE_PREFIXES) {
-		if (StringUtil::StartsWith(pattern, entry.name)) {
-			return entry.extension;
-		}
-	}
-	return "";
-}
-
 vector<OpenFileInfo> FileSystem::GlobFiles(const string &pattern, ClientContext &context, const FileGlobInput &input) {
 	auto result = Glob(pattern);
 	if (result.empty()) {
-		string required_extension = LookupExtensionForPattern(pattern);
-		if (!required_extension.empty() && !context.db->ExtensionIsLoaded(required_extension)) {
-			auto &dbconfig = DBConfig::GetConfig(context);
-			if (!ExtensionHelper::CanAutoloadExtension(required_extension) ||
-			    !dbconfig.options.autoload_known_extensions) {
-				auto error_message =
-				    "File " + pattern + " requires the extension " + required_extension + " to be loaded";
-				error_message =
-				    ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, required_extension);
-				throw MissingExtensionException(error_message);
-			}
-			// an extension is required to read this file, but it is not loaded - try to load it
-			ExtensionHelper::AutoLoadExtension(context, required_extension);
-			// success! glob again
-			// check the extension is loaded just in case to prevent an infinite loop here
-			if (!context.db->ExtensionIsLoaded(required_extension)) {
-				throw InternalException("Extension load \"%s\" did not throw but somehow the extension was not loaded",
-				                        required_extension);
-			}
-			return GlobFiles(pattern, context, input);
-		}
 		if (input.behavior == FileGlobOptions::FALLBACK_GLOB && !HasGlob(pattern)) {
 			// if we have no glob in the pattern and we have an extension, we try to glob
 			if (!HasGlob(pattern)) {

package/src/duckdb/src/common/sorting/sort.cpp

@@ -378,6 +378,15 @@ public:
 		return merger_global_state ? merger_global_state->MaxThreads() : 1;
 	}
 
+	void Destroy() {
+		if (!merger_global_state) {
+			return;
+		}
+		auto guard = merger_global_state->Lock();
+		merger.sorted_runs.clear();
+		sink.temporary_memory_state.reset();
+	}
+
 public:
 	//! The global sink state
 	SortGlobalSinkState &sink;
@@ -477,16 +486,26 @@ SourceResultType Sort::MaterializeColumnData(ExecutionContext &context, Operator
 	}
 
 	// Merge into global output collection
-	auto guard = gstate.Lock();
-	if (!gstate.column_data) {
-		gstate.column_data = std::move(local_column_data);
-	} else {
-		gstate.column_data->Merge(*local_column_data);
+	{
+		auto guard = gstate.Lock();
+		if (!gstate.column_data) {
+			gstate.column_data = std::move(local_column_data);
+		} else {
+			gstate.column_data->Merge(*local_column_data);
+		}
 	}
 
+	// Destroy local state before returning
+	input.local_state.Cast<SortLocalSourceState>().merger_local_state.reset();
+
 	// Return type indicates whether materialization is done
 	const auto progress_data = GetProgress(context.client, input.global_state);
-	return progress_data.done == progress_data.total ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT;
+	if (progress_data.done == progress_data.total) {
+		// Destroy global state before returning
+		gstate.Destroy();
+		return SourceResultType::FINISHED;
+	}
+	return SourceResultType::HAVE_MORE_OUTPUT;
 }
 
 unique_ptr<ColumnDataCollection> Sort::GetColumnData(OperatorSourceInput &input) const {

package/src/duckdb/src/common/sorting/sorted_run_merger.cpp

@@ -888,6 +888,7 @@ SortedRunMerger::SortedRunMerger(const Expression &decode_sort_key_p, shared_ptr
 unique_ptr<LocalSourceState> SortedRunMerger::GetLocalSourceState(ExecutionContext &,
                                                                   GlobalSourceState &gstate_p) const {
 	auto &gstate = gstate_p.Cast<SortedRunMergerGlobalState>();
+	auto guard = gstate.Lock();
 	return make_uniq<SortedRunMergerLocalState>(gstate);
 }
 

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

@@ -572,6 +572,15 @@ static unique_ptr<ComplexJSON> ParseJSON(const string &json, yyjson_doc *doc, yy
 		const bool bool_val = yyjson_get_bool(root);
 		return make_uniq<ComplexJSON>(bool_val ? "true" : "false");
 	}
+	case YYJSON_TYPE_NUM | YYJSON_SUBTYPE_UINT:
+		return make_uniq<ComplexJSON>(to_string(unsafe_yyjson_get_uint(root)));
+	case YYJSON_TYPE_NUM | YYJSON_SUBTYPE_SINT:
+		return make_uniq<ComplexJSON>(to_string(unsafe_yyjson_get_sint(root)));
+	case YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL:
+	case YYJSON_TYPE_RAW | YYJSON_SUBTYPE_NONE:
+		return make_uniq<ComplexJSON>(to_string(unsafe_yyjson_get_real(root)));
+	case YYJSON_TYPE_NULL | YYJSON_SUBTYPE_NONE:
+		return make_uniq<ComplexJSON>("null");
 	default:
 		yyjson_doc_free(doc);
 		throw SerializationException("Failed to parse JSON string: %s", json);
@@ -693,6 +702,21 @@ string StringUtil::ToComplexJSONMap(const ComplexJSON &complex_json) {
 	return ComplexJSON::GetValueRecursive(complex_json);
 }
 
+string StringUtil::ValidateJSON(const char *data, const idx_t &len) {
+	// Same flags as in JSON extension
+	static constexpr auto READ_FLAG =
+	    YYJSON_READ_ALLOW_INF_AND_NAN | YYJSON_READ_ALLOW_TRAILING_COMMAS | YYJSON_READ_BIGNUM_AS_RAW;
+	yyjson_read_err error;
+	yyjson_doc *doc = yyjson_read_opts((char *)data, len, READ_FLAG, nullptr, &error); // NOLINT: for yyjson
+	if (error.code != YYJSON_READ_SUCCESS) {
+		return StringUtil::Format("Malformed JSON at byte %lld of input: %s. Input: \"%s\"", error.pos, error.msg,
+		                          string(data, len));
+	}
+
+	yyjson_doc_free(doc);
+	return string();
+}
+
 string StringUtil::ExceptionToJSONMap(ExceptionType type, const string &message,
                                       const unordered_map<string, string> &map) {
 	D_ASSERT(map.find("exception_type") == map.end());

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

@@ -17,6 +17,7 @@ VirtualFileSystem::VirtualFileSystem(unique_ptr<FileSystem> &&inner) : default_f
 
 unique_ptr<FileHandle> VirtualFileSystem::OpenFileExtended(const OpenFileInfo &file, FileOpenFlags flags,
                                                            optional_ptr<FileOpener> opener) {
+
 	auto compression = flags.Compression();
 	if (compression == FileCompressionType::AUTO_DETECT) {
 		// auto-detect compression settings based on file name
@@ -34,8 +35,9 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFileExtended(const OpenFileInfo &f
 		}
 	}
 	// open the base file handle in UNCOMPRESSED mode
+
 	flags.SetCompression(FileCompressionType::UNCOMPRESSED);
-	auto file_handle = FindFileSystem(file.path).OpenFile(file, flags, opener);
+	auto file_handle = FindFileSystem(file.path, opener).OpenFile(file, flags, opener);
 	if (!file_handle) {
 		return nullptr;
 	}
@@ -111,7 +113,7 @@ void VirtualFileSystem::RemoveDirectory(const string &directory, optional_ptr<Fi
 bool VirtualFileSystem::ListFilesExtended(const string &directory,
                                           const std::function<void(OpenFileInfo &info)> &callback,
                                           optional_ptr<FileOpener> opener) {
-	return FindFileSystem(directory).ListFiles(directory, callback, opener);
+	return FindFileSystem(directory, opener).ListFiles(directory, callback, opener);
 }
 
 void VirtualFileSystem::MoveFile(const string &source, const string &target, optional_ptr<FileOpener> opener) {
@@ -119,7 +121,7 @@ void VirtualFileSystem::MoveFile(const string &source, const string &target, opt
 }
 
 bool VirtualFileSystem::FileExists(const string &filename, optional_ptr<FileOpener> opener) {
-	return FindFileSystem(filename).FileExists(filename, opener);
+	return FindFileSystem(filename, opener).FileExists(filename, opener);
 }
 
 bool VirtualFileSystem::IsPipe(const string &filename, optional_ptr<FileOpener> opener) {
@@ -139,7 +141,7 @@ string VirtualFileSystem::PathSeparator(const string &path) {
 }
 
 vector<OpenFileInfo> VirtualFileSystem::Glob(const string &path, FileOpener *opener) {
-	return FindFileSystem(path).Glob(path, opener);
+	return FindFileSystem(path, opener).Glob(path, opener);
 }
 
 void VirtualFileSystem::RegisterSubSystem(unique_ptr<FileSystem> fs) {
@@ -216,16 +218,61 @@ bool VirtualFileSystem::SubSystemIsDisabled(const string &name) {
 	return disabled_file_systems.find(name) != disabled_file_systems.end();
 }
 
+FileSystem &VirtualFileSystem::FindFileSystem(const string &path, optional_ptr<FileOpener> opener) {
+	return FindFileSystem(path, FileOpener::TryGetDatabase(opener));
+}
+
+FileSystem &VirtualFileSystem::FindFileSystem(const string &path, optional_ptr<DatabaseInstance> db_instance) {
+	auto fs = FindFileSystemInternal(path);
+
+	if (!fs && db_instance) {
+		string required_extension;
+
+		for (const auto &entry : EXTENSION_FILE_PREFIXES) {
+			if (StringUtil::StartsWith(path, entry.name)) {
+				required_extension = entry.extension;
+			}
+		}
+		if (!required_extension.empty() && db_instance && !db_instance->ExtensionIsLoaded(required_extension)) {
+			auto &dbconfig = DBConfig::GetConfig(*db_instance);
+			if (!ExtensionHelper::CanAutoloadExtension(required_extension) ||
+			    !dbconfig.options.autoload_known_extensions) {
+				auto error_message = "File " + path + " requires the extension " + required_extension + " to be loaded";
+				error_message =
+				    ExtensionHelper::AddExtensionInstallHintToErrorMsg(*db_instance, error_message, required_extension);
+				throw MissingExtensionException(error_message);
+			}
+			// an extension is required to read this file, but it is not loaded - try to load it
+			ExtensionHelper::AutoLoadExtension(*db_instance, required_extension);
+		}
+
+		// Retry after having autoloaded
+		fs = FindFileSystem(path);
+	}
+
+	if (!fs) {
+		fs = default_fs;
+	}
+	if (!disabled_file_systems.empty() && disabled_file_systems.find(fs->GetName()) != disabled_file_systems.end()) {
+		throw PermissionException("File system %s has been disabled by configuration", fs->GetName());
+	}
+	return *fs;
+}
+
 FileSystem &VirtualFileSystem::FindFileSystem(const string &path) {
-	auto &fs = FindFileSystemInternal(path);
-	if (!disabled_file_systems.empty() && disabled_file_systems.find(fs.GetName()) != disabled_file_systems.end()) {
-		throw PermissionException("File system %s has been disabled by configuration", fs.GetName());
+	auto fs = FindFileSystemInternal(path);
+	if (!fs) {
+		fs = default_fs;
+	}
+	if (!disabled_file_systems.empty() && disabled_file_systems.find(fs->GetName()) != disabled_file_systems.end()) {
+		throw PermissionException("File system %s has been disabled by configuration", fs->GetName());
 	}
-	return fs;
+	return *fs;
 }
 
-FileSystem &VirtualFileSystem::FindFileSystemInternal(const string &path) {
+optional_ptr<FileSystem> VirtualFileSystem::FindFileSystemInternal(const string &path) {
 	FileSystem *fs = nullptr;
+
 	for (auto &sub_system : sub_systems) {
 		if (sub_system->CanHandleFile(path)) {
 			if (sub_system->IsManuallySet()) {
@@ -237,7 +284,9 @@ FileSystem &VirtualFileSystem::FindFileSystemInternal(const string &path) {
 	if (fs) {
 		return *fs;
 	}
-	return *default_fs;
+
+	// We could use default_fs, that's on the caller
+	return nullptr;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/index/art/art_merger.cpp

@@ -217,9 +217,6 @@ void ARTMerger::MergeNodeAndPrefix(Node &node, Node &prefix, const GateStatus pa
 	auto child = node.GetChildMutable(art, byte);
 
 	// Reduce the prefix to the bytes after pos.
-	// We always reduce by at least one byte,
-	// thus, if the prefix was a gate, it no longer is.
-	prefix.SetGateStatus(GateStatus::GATE_NOT_SET);
 	Prefix::Reduce(art, prefix, pos);
 
 	if (child) {

package/src/duckdb/src/execution/index/art/prefix.cpp

@@ -100,6 +100,10 @@ void Prefix::Reduce(ART &art, Node &node, const idx_t pos) {
 	D_ASSERT(node.HasMetadata());
 	D_ASSERT(pos < Count(art));
 
+	// We always reduce by at least one byte,
+	// thus, if the prefix was a gate, it no longer is.
+	node.SetGateStatus(GateStatus::GATE_NOT_SET);
+
 	Prefix prefix(art, node);
 	if (pos == idx_t(prefix.data[Count(art)] - 1)) {
 		auto next = *prefix.ptr;

package/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp

@@ -797,7 +797,7 @@ void StringValueResult::NullPaddingQuotedNewlineCheck() const {
 		// If we have null_padding set, we found a quoted new line, we are scanning the file in parallel; We error.
 		LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read);
 		auto csv_error = CSVError::NullPaddingFail(state_machine.options, lines_per_batch, path);
-		error_handler.Error(csv_error, try_row);
+		error_handler.Error(csv_error, true);
 	}
 }
 

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -65,9 +65,9 @@ SourceResultType PhysicalReset::GetData(ExecutionContext &context, DataChunk &ch
 		}
 		if (variable_scope == SetScope::SESSION) {
 			auto &client_config = ClientConfig::GetConfig(context.client);
-			client_config.set_variables.erase(name.ToStdString());
+			client_config.set_variables.erase(option->name);
 		} else {
-			config.ResetGenericOption(name);
+			config.ResetGenericOption(option->name);
 		}
 		return SourceResultType::FINISHED;
 	}

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -36,7 +36,7 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c
 	if (info->on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT ||
 	    info->on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
 		// constant-time lookup in the catalog for the db name
-		auto existing_db = db_manager.GetDatabase(context.client, name);
+		auto existing_db = db_manager.GetDatabase(name);
 		if (existing_db) {
 			if ((existing_db->IsReadOnly() && options.access_mode == AccessMode::READ_WRITE) ||
 			    (!existing_db->IsReadOnly() && options.access_mode == AccessMode::READ_ONLY)) {

package/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp

@@ -27,7 +27,7 @@ PhysicalPlanGenerator::PlanAsOfLoopJoin(LogicalComparisonJoin &op, PhysicalOpera
 	//
 	//		 ∏ * \ pk
 	//		 |
-	//		 Γ pk;first(P),arg_xxx(B,inequality)
+	//		 Γ pk;first(P),arg_xxx_null(B,inequality)
 	//		 |
 	//		 ∏ *,inequality
 	//		 |
@@ -88,13 +88,13 @@ PhysicalPlanGenerator::PlanAsOfLoopJoin(LogicalComparisonJoin &op, PhysicalOpera
 		case ExpressionType::COMPARE_GREATERTHAN:
 			D_ASSERT(asof_idx == op.conditions.size());
 			asof_idx = i;
-			arg_min_max = "arg_max";
+			arg_min_max = "arg_max_null";
 			break;
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
 		case ExpressionType::COMPARE_LESSTHAN:
 			D_ASSERT(asof_idx == op.conditions.size());
 			asof_idx = i;
-			arg_min_max = "arg_min";
+			arg_min_max = "arg_min_null";
 			break;
 		case ExpressionType::COMPARE_EQUAL:
 		case ExpressionType::COMPARE_NOTEQUAL:

package/src/duckdb/src/function/table/system/duckdb_connection_count.cpp

@@ -0,0 +1,45 @@
+#include "duckdb/function/table/system_functions.hpp"
+
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/main/connection_manager.hpp"
+
+namespace duckdb {
+
+struct DuckDBConnectionCountData : public GlobalTableFunctionState {
+	DuckDBConnectionCountData() : count(0), finished(false) {
+	}
+	idx_t count;
+	bool finished;
+};
+
+static unique_ptr<FunctionData> DuckDBConnectionCountBind(ClientContext &context, TableFunctionBindInput &input,
+                                                          vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("count");
+	return_types.emplace_back(LogicalType::UBIGINT);
+	return nullptr;
+}
+
+unique_ptr<GlobalTableFunctionState> DuckDBConnectionCountInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto result = make_uniq<DuckDBConnectionCountData>();
+	auto &conn_manager = context.db->GetConnectionManager();
+	result->count = conn_manager.GetConnectionCount();
+	return std::move(result);
+}
+
+void DuckDBConnectionCountFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = data_p.global_state->Cast<DuckDBConnectionCountData>();
+	if (data.finished) {
+		return;
+	}
+	output.SetValue(0, 0, Value::UBIGINT(data.count));
+	output.SetCardinality(1);
+	data.finished = true;
+}
+
+void DuckDBConnectionCountFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(TableFunction("duckdb_connection_count", {}, DuckDBConnectionCountFunction,
+	                              DuckDBConnectionCountBind, DuckDBConnectionCountInit));
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/table/system/duckdb_settings.cpp

@@ -12,6 +12,10 @@ struct DuckDBSettingValue {
 	string input_type;
 	string scope;
 	vector<Value> aliases;
+
+	inline bool operator<(const DuckDBSettingValue &rhs) const {
+		return name < rhs.name;
+	};
 };
 
 struct DuckDBSettingsData : public GlobalTableFunctionState {
@@ -79,7 +83,12 @@ unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context,
 		if (entry != aliases.end()) {
 			value.aliases = std::move(entry->second);
 		}
-
+		for (auto &alias : value.aliases) {
+			DuckDBSettingValue alias_value = value;
+			alias_value.name = StringValue::Get(alias);
+			alias_value.aliases.clear();
+			result->settings.push_back(std::move(alias_value));
+		}
 		result->settings.push_back(std::move(value));
 	}
 	for (auto &ext_param : config.extension_parameters) {
@@ -98,6 +107,7 @@ unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context,
 
 		result->settings.push_back(std::move(value));
 	}
+	std::sort(result->settings.begin(), result->settings.end());
 	return std::move(result);
 }
 

package/src/duckdb/src/function/table/system_functions.cpp

@@ -18,6 +18,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaDatabaseSize::RegisterFunction(*this);
 	PragmaUserAgent::RegisterFunction(*this);
 
+	DuckDBConnectionCountFun::RegisterFunction(*this);
 	DuckDBApproxDatabaseCountFun::RegisterFunction(*this);
 	DuckDBColumnsFun::RegisterFunction(*this);
 	DuckDBConstraintsFun::RegisterFunction(*this);

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "0"
+#define DUCKDB_PATCH_VERSION "1"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 4
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.4.0"
+#define DUCKDB_VERSION "v1.4.1"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "b8a06e4a22"
+#define DUCKDB_SOURCE_ID "b390a7c376"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -234,6 +234,8 @@ enum class LogLevel : uint8_t;
 
 enum class LogMode : uint8_t;
 
+enum class LoggingTargetTable : uint8_t;
+
 enum class LogicalOperatorType : uint8_t;
 
 enum class LogicalTypeId : uint8_t;
@@ -748,6 +750,9 @@ const char* EnumUtil::ToChars<LogLevel>(LogLevel value);
 template<>
 const char* EnumUtil::ToChars<LogMode>(LogMode value);
 
+template<>
+const char* EnumUtil::ToChars<LoggingTargetTable>(LoggingTargetTable value);
+
 template<>
 const char* EnumUtil::ToChars<LogicalOperatorType>(LogicalOperatorType value);
 
@@ -1367,6 +1372,9 @@ LogLevel EnumUtil::FromString<LogLevel>(const char *value);
 template<>
 LogMode EnumUtil::FromString<LogMode>(const char *value);
 
+template<>
+LoggingTargetTable EnumUtil::FromString<LoggingTargetTable>(const char *value);
+
 template<>
 LogicalOperatorType EnumUtil::FromString<LogicalOperatorType>(const char *value);