Update vendored DuckDB sources to 60a92c8693

Author: duckdblabs-bot

src/duckdb/extension/core_functions/function_list.cpp

@@ -294,6 +294,7 @@ static const StaticFunctionDefinition core_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(ParseDirnameFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ParseDirpathFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ParseFilenameFun),
+	DUCKDB_SCALAR_FUNCTION(ParseFormattedBytesFun),
 	DUCKDB_SCALAR_FUNCTION_SET(ParsePathFun),
 	DUCKDB_SCALAR_FUNCTION(PiFun),
 	DUCKDB_SCALAR_FUNCTION_ALIAS(PositionFun),

src/duckdb/extension/core_functions/include/core_functions/scalar/string_functions.hpp

@@ -113,6 +113,16 @@ struct FormatreadablesizeFun {
 	static constexpr const char *Name = "formatReadableSize";
 };
 
+struct ParseFormattedBytesFun {
+	static constexpr const char *Name = "parse_formatted_bytes";
+	static constexpr const char *Parameters = "string";
+	static constexpr const char *Description = "Parses a human-readable representation of a size in bytes into an integer.";
+	static constexpr const char *Example = "parse_formatted_bytes('16 KiB')";
+	static constexpr const char *Categories = "string,numeric";
+
+	static ScalarFunction GetFunction();
+};
+
 struct FormatreadabledecimalsizeFun {
 	static constexpr const char *Name = "formatReadableDecimalSize";
 	static constexpr const char *Parameters = "integer";

src/duckdb/extension/core_functions/scalar/string/parse_formatted_bytes.cpp

@@ -0,0 +1,17 @@
+#include "duckdb/function/scalar_function.hpp"
+
+#include "core_functions/scalar/string_functions.hpp"
+
+namespace duckdb {
+static void ParseFormattedBytesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto arg0 = args.data[0];
+	UnaryExecutor::Execute<string_t, idx_t>(arg0, result, args.size(), [&](string_t str) {
+		// Invalid input exceptions thrown from ParseFormattedBytes won't be handled but will be thrown as is
+		return StringUtil::ParseFormattedBytes(str.GetString());
+	});
+}
+
+ScalarFunction ParseFormattedBytesFun::GetFunction() {
+	return ScalarFunction({LogicalType::VARCHAR}, LogicalType::UBIGINT, ParseFormattedBytesFunction);
+}
+} // namespace duckdb

src/duckdb/src/common/enum_util.cpp

@@ -174,7 +174,7 @@
 #include "duckdb/planner/bound_result_modifier.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/buffer/block_handle.hpp"
-#include "duckdb/storage/caching_file_system_wrapper.hpp"
+#include "duckdb/storage/caching_mode.hpp"
 #include "duckdb/storage/compression/bitpacking.hpp"
 #include "duckdb/storage/magic_bytes.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
@@ -913,19 +913,20 @@ CacheValidationMode EnumUtil::FromString<CacheValidationMode>(const char *value)
 const StringUtil::EnumStringLiteral *GetCachingModeValues() {
 	static constexpr StringUtil::EnumStringLiteral values[] {
 		{ static_cast<uint32_t>(CachingMode::ALWAYS_CACHE), "ALWAYS_CACHE" },
-		{ static_cast<uint32_t>(CachingMode::CACHE_REMOTE_ONLY), "CACHE_REMOTE_ONLY" }
+		{ static_cast<uint32_t>(CachingMode::CACHE_REMOTE_ONLY), "CACHE_REMOTE_ONLY" },
+		{ static_cast<uint32_t>(CachingMode::NO_CACHING), "NO_CACHING" }
 	};
 	return values;
 }
 
 template<>
 const char* EnumUtil::ToChars<CachingMode>(CachingMode value) {
-	return StringUtil::EnumToString(GetCachingModeValues(), 2, "CachingMode", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetCachingModeValues(), 3, "CachingMode", static_cast<uint32_t>(value));
 }
 
 template<>
 CachingMode EnumUtil::FromString<CachingMode>(const char *value) {
-	return static_cast<CachingMode>(StringUtil::StringToEnum(GetCachingModeValues(), 2, "CachingMode", value));
+	return static_cast<CachingMode>(StringUtil::StringToEnum(GetCachingModeValues(), 3, "CachingMode", value));
 }
 
 const StringUtil::EnumStringLiteral *GetCatalogLookupBehaviorValues() {

src/duckdb/src/common/sort/sorted_run_merger.cpp

@@ -299,7 +299,7 @@ SortedRunMergerLocalState::SortedRunMergerLocalState(SortedRunMergerGlobalState
     : iterator_state_type(gstate.iterator_state_type), sort_key_type(gstate.sort_key_type),
       task(SortedRunMergerTask::FINISHED), run_boundaries(gstate.num_runs),
       merged_partition_count(DConstants::INVALID_INDEX), merged_partition_index(DConstants::INVALID_INDEX),
-      sorted_run_scan_state(gstate.context, gstate.merger.sort), sort_key_pointers(LogicalType::POINTER) {
+      sort_key_pointers(LogicalType::POINTER), sorted_run_scan_state(gstate.context, gstate.merger.sort) {
 	for (const auto &run : gstate.merger.sorted_runs) {
 		auto &key_data = *run->key_data;
 		switch (iterator_state_type) {

src/duckdb/src/common/string_util.cpp

@@ -11,6 +11,7 @@
 #include "jaro_winkler.hpp"
 #include "utf8proc_wrapper.hpp"
 #include "duckdb/common/types/string_type.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 
 #include <algorithm>
 #include <cctype>
@@ -266,6 +267,89 @@ string StringUtil::BytesToHumanReadableString(idx_t bytes, idx_t multiplier) {
 	return to_string(array[0]) + (bytes == 1 ? " byte" : " bytes");
 }
 
+string StringUtil::TryParseFormattedBytes(const string &arg, idx_t &result) {
+	// split based on the number/non-number
+	idx_t idx = 0;
+	while (StringUtil::CharacterIsSpace(arg[idx])) {
+		idx++;
+	}
+	idx_t num_start = idx;
+	while ((arg[idx] >= '0' && arg[idx] <= '9') || arg[idx] == '.' || arg[idx] == 'e' || arg[idx] == 'E' ||
+	       arg[idx] == '-') {
+		idx++;
+	}
+	if (idx == num_start) {
+		return "Memory must have a number (e.g. 1GB)";
+	}
+	string number = arg.substr(num_start, idx - num_start);
+
+	// try to parse the number
+	double limit;
+	bool success = TryCast::Operation<string_t, double>(string_t(number), limit);
+	if (!success) {
+		return StringUtil::Format("Invalid memory limit: '%s'", number);
+	}
+
+	// now parse the memory limit unit (e.g. bytes, gb, etc)
+	while (StringUtil::CharacterIsSpace(arg[idx])) {
+		idx++;
+	}
+	idx_t start = idx;
+	while (idx < arg.size() && !StringUtil::CharacterIsSpace(arg[idx])) {
+		idx++;
+	}
+
+	if (limit < 0) {
+		return "Memory cannot be negative";
+	}
+
+	string unit = StringUtil::Lower(arg.substr(start, idx - start));
+	idx_t multiplier;
+	if (unit == "byte" || unit == "bytes" || unit == "b") {
+		multiplier = 1;
+	} else if (unit == "kilobyte" || unit == "kilobytes" || unit == "kb" || unit == "k") {
+		multiplier = 1000LL;
+	} else if (unit == "megabyte" || unit == "megabytes" || unit == "mb" || unit == "m") {
+		multiplier = 1000LL * 1000LL;
+	} else if (unit == "gigabyte" || unit == "gigabytes" || unit == "gb" || unit == "g") {
+		multiplier = 1000LL * 1000LL * 1000LL;
+	} else if (unit == "terabyte" || unit == "terabytes" || unit == "tb" || unit == "t") {
+		multiplier = 1000LL * 1000LL * 1000LL * 1000LL;
+	} else if (unit == "kib") {
+		multiplier = 1024LL;
+	} else if (unit == "mib") {
+		multiplier = 1024LL * 1024LL;
+	} else if (unit == "gib") {
+		multiplier = 1024LL * 1024LL * 1024LL;
+	} else if (unit == "tib") {
+		multiplier = 1024LL * 1024LL * 1024LL * 1024LL;
+	} else {
+		return StringUtil::Format("Unknown unit for memory: '%s' (expected: KB, MB, GB, TB for 1000^i units or KiB, "
+		                          "MiB, GiB, TiB for 1024^i units)",
+		                          unit);
+	}
+
+	// Make sure the result is not greater than `idx_t` max value
+	constexpr double max_value = static_cast<double>(NumericLimits<idx_t>::Maximum());
+	const double double_multiplier = static_cast<double>(multiplier);
+
+	if (limit > (max_value / double_multiplier)) {
+		return "Memory value out of range: value is too large";
+	}
+
+	result = LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
+	return string();
+}
+
+idx_t StringUtil::ParseFormattedBytes(const string &arg) {
+	idx_t result;
+	const string error = TryParseFormattedBytes(arg, result);
+	if (!error.empty()) {
+		throw InvalidInputException(error);
+	}
+	return result;
+}
+
 string StringUtil::Upper(const string &str) {
 	string copy(str);
 	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return std::toupper(c); });

src/duckdb/src/common/virtual_file_system.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/common/pipe_file_system.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/client_context.hpp"
+#include "duckdb/storage/caching_file_system_wrapper.hpp"
 
 namespace duckdb {
 
@@ -33,14 +34,29 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFileExtended(const OpenFileInfo &f
 			compression = FileCompressionType::UNCOMPRESSED;
 		}
 	}
-	// open the base file handle in UNCOMPRESSED mode
 
+	// open the base file handle in UNCOMPRESSED mode
 	flags.SetCompression(FileCompressionType::UNCOMPRESSED);
-	auto file_handle = FindFileSystem(file.path, opener).OpenFile(file, flags, opener);
+
+	auto &internal_filesystem = FindFileSystem(file.path, opener);
+
+	// File handle gets created.
+	unique_ptr<FileHandle> file_handle = nullptr;
+
+	// Handle caching logic.
+	if (flags.GetCachingMode() != CachingMode::NO_CACHING) {
+		auto caching_filesystem =
+		    make_shared_ptr<CachingFileSystemWrapper>(internal_filesystem, opener, flags.GetCachingMode());
+		// caching filesystem's lifecycle is extended inside of caching file handle.
+		file_handle = caching_filesystem->OpenFile(file, flags, opener);
+	} else {
+		file_handle = internal_filesystem.OpenFile(file, flags, opener);
+	}
 	if (!file_handle) {
 		return nullptr;
 	}
 
+	// Evaluate and apply compression option then.
 	const auto context = !flags.MultiClientAccess() ? FileOpener::TryGetClientContext(opener) : QueryContext();
 	if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) {
 		file_handle = PipeFileSystem::OpenPipe(context, std::move(file_handle));

src/duckdb/src/function/scalar/string/concat.cpp

@@ -305,9 +305,22 @@ unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, Scal
 			all_null = false;
 		}
 	}
-	if (list_concat || all_null) {
+	if (list_concat) {
 		return BindListConcat(context, bound_function, arguments, is_operator);
 	}
+	if (all_null) {
+		if (is_operator) {
+			SetArgumentType(bound_function, LogicalTypeId::SQLNULL, is_operator);
+			return make_uniq<ConcatFunctionData>(bound_function.GetReturnType(), is_operator);
+		} else if (bound_function.varargs.id() == LogicalTypeId::LIST ||
+		           bound_function.varargs.id() == LogicalTypeId::ARRAY) {
+			SetArgumentType(bound_function, LogicalTypeId::SQLNULL, is_operator);
+			return make_uniq<ConcatFunctionData>(bound_function.GetReturnType(), is_operator);
+		} else {
+			SetArgumentType(bound_function, LogicalTypeId::VARCHAR, is_operator);
+			return make_uniq<ConcatFunctionData>(bound_function.GetReturnType(), is_operator);
+		}
+	}
 	auto return_type = all_blob ? LogicalType::BLOB : LogicalType::VARCHAR;
 
 	// we can now assume that the input is a string or castable to a string

src/duckdb/src/function/table/direct_file_reader.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/serializer/memory_stream.hpp"
 #include "duckdb/function/table/read_file.hpp"
 #include "duckdb/storage/caching_file_system_wrapper.hpp"
+#include "duckdb/storage/caching_mode.hpp"
 
 namespace duckdb {
 
@@ -55,7 +56,7 @@ AsyncResult DirectFileReader::Scan(ClientContext &context, GlobalTableFunctionSt
 
 	auto files = state.file_list;
 
-	auto caching_fs = CachingFileSystemWrapper::Get(context);
+	auto &fs = FileSystem::GetFileSystem(context);
 	const idx_t out_idx = 0;
 
 	// We utilize projection pushdown here to only read the file content if the 'data' column is requested
@@ -67,11 +68,12 @@ AsyncResult DirectFileReader::Scan(ClientContext &context, GlobalTableFunctionSt
 		if (FileSystem::IsRemoteFile(file.path)) {
 			flags |= FileFlags::FILE_FLAGS_DIRECT_IO;
 		}
-		file_handle = caching_fs.OpenFile(file, flags);
+		flags.SetCachingMode(CachingMode::CACHE_REMOTE_ONLY);
+		file_handle = fs.OpenFile(file, flags);
 	} else {
 		// At least verify that the file exist
 		// The globbing behavior in remote filesystems can lead to files being listed that do not actually exist
-		if (FileSystem::IsRemoteFile(file.path) && !caching_fs.FileExists(file.path)) {
+		if (FileSystem::IsRemoteFile(file.path) && !fs.FileExists(file.path)) {
 			output.SetCardinality(0);
 			done = true;
 			return SourceResultType::FINISHED;
@@ -146,7 +148,7 @@ AsyncResult DirectFileReader::Scan(ClientContext &context, GlobalTableFunctionSt
 				// This can sometimes fail (e.g. httpfs file system cant always parse the last modified time
 				// correctly)
 				try {
-					const auto timestamp_seconds = caching_fs.GetLastModifiedTime(*file_handle);
+					const auto timestamp_seconds = fs.GetLastModifiedTime(*file_handle);
 					FlatVector::GetData<timestamp_tz_t>(last_modified_vector)[out_idx] =
 					    timestamp_tz_t(timestamp_seconds);
 				} catch (std::exception &ex) {

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

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "0-dev5206"
+#define DUCKDB_PATCH_VERSION "0-dev5253"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 5
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.5.0-dev5206"
+#define DUCKDB_VERSION "v1.5.0-dev5253"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "99a37abe11"
+#define DUCKDB_SOURCE_ID "60a92c8693"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"