duckdb 1.3.4 → 1.4.0

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

@@ -10,6 +10,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/logging/file_system_logger.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 #include <cstdint>
 #include <cstdio>
@@ -237,7 +238,7 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) {
 
 	try {
 		auto cmdline_file = fs.OpenFile(StringUtil::Format("/proc/%d/cmdline", pid), FileFlags::FILE_FLAGS_READ);
-		auto cmdline = cmdline_file->ReadLine();
+		auto cmdline = cmdline_file->ReadLine(QueryContext());
 		process_name = basename(const_cast<char *>(cmdline.c_str())); // NOLINT: old C API does not take const
 	} catch (std::exception &) {
 		// ignore
@@ -257,7 +258,7 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) {
 	// try to find out who created that process
 	try {
 		auto loginuid_file = fs.OpenFile(StringUtil::Format("/proc/%d/loginuid", pid), FileFlags::FILE_FLAGS_READ);
-		auto uid = std::stoi(loginuid_file->ReadLine());
+		auto uid = std::stoi(loginuid_file->ReadLine(QueryContext()));
 		auto pw = getpwuid(uid);
 		if (pw) {
 			process_owner = pw->pw_name;
@@ -488,6 +489,7 @@ void LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, i
 		nr_bytes -= bytes_read;
 		location += UnsafeNumericCast<idx_t>(bytes_read);
 	}
+
 	DUCKDB_LOG_FILE_SYSTEM_READ(handle, bytes_to_read, location - UnsafeNumericCast<idx_t>(bytes_to_read));
 }
 
@@ -499,8 +501,10 @@ int64_t LocalFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes
 		throw IOException("Could not read from file \"%s\": %s", {{"errno", std::to_string(errno)}}, handle.path,
 		                  strerror(errno));
 	}
+
 	DUCKDB_LOG_FILE_SYSTEM_READ(handle, bytes_read, unix_handle.current_pos);
 	unix_handle.current_pos += UnsafeNumericCast<idx_t>(bytes_read);
+
 	return bytes_read;
 }
 
@@ -579,14 +583,14 @@ int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
 	return s.st_size;
 }
 
-time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
+timestamp_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
 	int fd = handle.Cast<UnixFileHandle>().fd;
 	struct stat s;
 	if (fstat(fd, &s) == -1) {
 		throw IOException("Failed to get last modified time for file \"%s\": %s", {{"errno", std::to_string(errno)}},
 		                  handle.path, strerror(errno));
 	}
-	return s.st_mtime;
+	return Timestamp::FromEpochSeconds(s.st_mtime);
 }
 
 FileType LocalFileSystem::GetFileType(FileHandle &handle) {
@@ -791,12 +795,18 @@ std::string LocalFileSystem::GetLastErrorAsString() {
 	if (errorMessageID == 0)
 		return std::string(); // No error message has been recorded
 
-	LPSTR messageBuffer = nullptr;
-	idx_t size =
-	    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-	                   NULL, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&messageBuffer, 0, NULL);
+	LPWSTR messageBuffer = nullptr;
+	idx_t size = FormatMessageW(
+	    FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
+	    errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, NULL);
 
-	std::string message(messageBuffer, size);
+	if (size == 0) {
+		return std::string();
+	}
+
+	// Convert wide string to UTF-8
+	std::wstring wideMessage(messageBuffer, size);
+	std::string message = WindowsUtil::UnicodeToUTF8(wideMessage.c_str());
 
 	// Free the buffer.
 	LocalFree(messageBuffer);
@@ -1087,7 +1097,7 @@ int64_t LocalFileSystem::GetFileSize(FileHandle &handle) {
 	return result.QuadPart;
 }
 
-time_t FiletimeToTimeT(FILETIME file_time) {
+timestamp_t FiletimeToTimeStamp(FILETIME file_time) {
 	// https://stackoverflow.com/questions/29266743/what-is-dwlowdatetime-and-dwhighdatetime
 	ULARGE_INTEGER ul;
 	ul.LowPart = file_time.dwLowDateTime;
@@ -1101,11 +1111,10 @@ time_t FiletimeToTimeT(FILETIME file_time) {
 	// Adapted from: https://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux
 	const auto WINDOWS_TICK = 10000000;
 	const auto SEC_TO_UNIX_EPOCH = 11644473600LL;
-	time_t result = (fileTime64 / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
-	return result;
+	return Timestamp::FromTimeT(fileTime64 / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
 }
 
-time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
+timestamp_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
 	HANDLE hFile = handle.Cast<WindowsFileHandle>().fd;
 
 	// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfiletime
@@ -1114,7 +1123,7 @@ time_t LocalFileSystem::GetLastModifiedTime(FileHandle &handle) {
 		auto error = LocalFileSystem::GetLastErrorAsString();
 		throw IOException("Failed to get last modified time for file \"%s\": %s", handle.path, error);
 	}
-	return FiletimeToTimeT(last_write);
+	return FiletimeToTimeStamp(last_write);
 }
 
 void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
@@ -1214,8 +1223,8 @@ bool LocalFileSystem::ListFilesExtended(const string &directory,
 		    (static_cast<int64_t>(ffd.nFileSizeHigh) << 32) | static_cast<int64_t>(ffd.nFileSizeLow);
 		options.emplace("file_size", Value::BIGINT(file_size_bytes));
 		// last modified time
-		auto last_modified_time = FiletimeToTimeT(ffd.ftLastWriteTime);
-		options.emplace("last_modified", Value::TIMESTAMP(Timestamp::FromTimeT(last_modified_time)));
+		auto last_modified_time = FiletimeToTimeStamp(ffd.ftLastWriteTime);
+		options.emplace("last_modified", Value::TIMESTAMP(last_modified_time));
 
 		// callback
 		callback(info);

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

@@ -21,4 +21,8 @@ double BaseFileReader::GetProgressInFile(ClientContext &context) {
 	return 0;
 }
 
+unique_ptr<BaseStatistics> BaseUnionData::GetStatistics(ClientContext &context, const string &name) {
+	return nullptr;
+}
+
 } // namespace duckdb

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

@@ -1030,14 +1030,9 @@ static unique_ptr<TableFilter> TryCastTableFilter(const TableFilter &global_filt
 	}
 }
 
-void SetIndexToZero(Expression &expr) {
-	if (expr.type == ExpressionType::BOUND_REF) {
-		auto &ref = expr.Cast<BoundReferenceExpression>();
-		ref.index = 0;
-		return;
-	}
-
-	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { SetIndexToZero(child); });
+void SetIndexToZero(unique_ptr<Expression> &root_expr) {
+	ExpressionIterator::VisitExpressionMutable<BoundReferenceExpression>(
+	    root_expr, [&](BoundReferenceExpression &ref, unique_ptr<Expression> &expr) { ref.index = 0; });
 }
 
 bool CanPropagateCast(const MultiFileIndexMapping &mapping, const LogicalType &local_type,
@@ -1096,11 +1091,12 @@ unique_ptr<TableFilterSet> MultiFileColumnMapper::CreateFilters(map<idx_t, refer
 
 			// add the expression to the expression map - we are now evaluating this inside the reader directly
 			// we need to set the index of the references inside the expression to 0
-			SetIndexToZero(*reader_data.expressions[local_id]);
-			reader.expression_map[filter_idx] = std::move(reader_data.expressions[local_id]);
+			auto &expr = reader_data.expressions[global_index];
+			SetIndexToZero(expr);
+			reader.expression_map[filter_idx] = std::move(expr);
 
 			// reset the expression - since we are evaluating it in the reader we can just reference it
-			reader_data.expressions[local_id] = make_uniq<BoundReferenceExpression>(global_type, local_id);
+			expr = make_uniq<BoundReferenceExpression>(global_type, local_id);
 		}
 	}
 	return result;

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

@@ -6,6 +6,10 @@ namespace duckdb {
 MultiFileReaderInterface::~MultiFileReaderInterface() {
 }
 
+void MultiFileReaderInterface::InitializeInterface(ClientContext &context, MultiFileReader &reader,
+                                                   MultiFileList &file_list) {
+}
+
 void MultiFileReaderInterface::FinalizeCopyBind(ClientContext &context, BaseFileReaderOptions &options,
                                                 const vector<string> &expected_names,
                                                 const vector<LogicalType> &expected_types) {
@@ -41,4 +45,8 @@ unique_ptr<MultiFileReaderInterface> MultiFileReaderInterface::Copy() {
 	throw InternalException("MultiFileReaderInterface::Copy is not implemented for this file interface");
 }
 
+FileGlobInput MultiFileReaderInterface::GetGlobInput() {
+	return FileGlobOptions::DISALLOW_EMPTY;
+}
+
 } // namespace duckdb

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

@@ -136,8 +136,12 @@ const OpenFileInfo &MultiFileListIterationHelper::MultiFileListIterator::operato
 //===--------------------------------------------------------------------===//
 // MultiFileList
 //===--------------------------------------------------------------------===//
+MultiFileList::MultiFileList(vector<OpenFileInfo> paths, FileGlobInput glob_input_p)
+    : paths(std::move(paths)), glob_input(std::move(glob_input_p)) {
+}
+
 MultiFileList::MultiFileList(vector<OpenFileInfo> paths, FileGlobOptions options)
-    : paths(std::move(paths)), glob_options(options) {
+    : MultiFileList(std::move(paths), FileGlobInput(options)) {
 }
 
 MultiFileList::~MultiFileList() {
@@ -270,8 +274,8 @@ idx_t SimpleMultiFileList::GetTotalFileCount() {
 //===--------------------------------------------------------------------===//
 // GlobMultiFileList
 //===--------------------------------------------------------------------===//
-GlobMultiFileList::GlobMultiFileList(ClientContext &context_p, vector<OpenFileInfo> paths_p, FileGlobOptions options)
-    : MultiFileList(std::move(paths_p), options), context(context_p), current_path(0) {
+GlobMultiFileList::GlobMultiFileList(ClientContext &context_p, vector<OpenFileInfo> paths_p, FileGlobInput glob_input)
+    : MultiFileList(std::move(paths_p), std::move(glob_input)), context(context_p), current_path(0) {
 }
 
 unique_ptr<MultiFileList> GlobMultiFileList::ComplexFilterPushdown(ClientContext &context_p,
@@ -369,7 +373,7 @@ bool GlobMultiFileList::ExpandPathInternal(idx_t &current_path, vector<OpenFileI
 	}
 
 	auto &fs = FileSystem::GetFileSystem(context);
-	auto glob_files = fs.GlobFiles(paths[current_path].path, context, glob_options);
+	auto glob_files = fs.GlobFiles(paths[current_path].path, context, glob_input);
 	std::sort(glob_files.begin(), glob_files.end());
 	result.insert(result.end(), glob_files.begin(), glob_files.end());
 

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

@@ -116,22 +116,22 @@ vector<string> MultiFileReader::ParsePaths(const Value &input) {
 }
 
 shared_ptr<MultiFileList> MultiFileReader::CreateFileList(ClientContext &context, const vector<string> &paths,
-                                                          FileGlobOptions options) {
+                                                          const FileGlobInput &glob_input) {
 	vector<OpenFileInfo> open_files;
 	for (auto &path : paths) {
 		open_files.emplace_back(path);
 	}
-	auto res = make_uniq<GlobMultiFileList>(context, std::move(open_files), options);
-	if (res->GetExpandResult() == FileExpandResult::NO_FILES && options == FileGlobOptions::DISALLOW_EMPTY) {
+	auto res = make_uniq<GlobMultiFileList>(context, std::move(open_files), glob_input);
+	if (res->GetExpandResult() == FileExpandResult::NO_FILES && glob_input.behavior != FileGlobOptions::ALLOW_EMPTY) {
 		throw IOException("%s needs at least one file to read", function_name);
 	}
 	return std::move(res);
 }
 
 shared_ptr<MultiFileList> MultiFileReader::CreateFileList(ClientContext &context, const Value &input,
-                                                          FileGlobOptions options) {
+                                                          const FileGlobInput &glob_input) {
 	auto paths = ParsePaths(input);
-	return CreateFileList(context, paths, options);
+	return CreateFileList(context, paths, glob_input);
 }
 
 bool MultiFileReader::ParseOption(const string &key, const Value &val, MultiFileOptions &options,
@@ -645,6 +645,10 @@ void MultiFileReader::PruneReaders(MultiFileBindData &data, MultiFileList &file_
 	}
 }
 
+FileGlobInput MultiFileReader::GetGlobInput(MultiFileReaderInterface &interface) {
+	return interface.GetGlobInput();
+}
+
 HivePartitioningIndex::HivePartitioningIndex(string value_p, idx_t index) : value(std::move(value_p)), index(index) {
 }
 

package/src/duckdb/src/common/operator/cast_operators.cpp

@@ -13,7 +13,6 @@
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/decimal.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/uuid.hpp"
 #include "duckdb/common/types/interval.hpp"
@@ -22,7 +21,6 @@
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/types.hpp"
 #include "fast_float/fast_float.h"
-#include "fmt/format.h"
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/operator/integer_cast_operator.hpp"
 #include "duckdb/common/operator/double_cast_operator.hpp"
@@ -1041,6 +1039,27 @@ bool TryCast::Operation(dtime_t input, dtime_t &result, bool strict) {
 	return true;
 }
 
+template <>
+bool TryCast::Operation(dtime_ns_t input, dtime_ns_t &result, bool strict) {
+	result.micros = input.micros;
+	return true;
+}
+
+template <>
+bool TryCast::Operation(dtime_ns_t input, dtime_t &result, bool strict) {
+	//	Round
+	result.micros = (input.micros + (Interval::NANOS_PER_MICRO / 2)) / Interval::NANOS_PER_MICRO;
+	return true;
+}
+
+template <>
+bool TryCast::Operation(dtime_t input, dtime_ns_t &result, bool strict) {
+	if (!TryMultiplyOperator::Operation(input.micros, Interval::NANOS_PER_MICRO, result.micros)) {
+		throw ConversionException("Could not convert TIME to TIME_NS");
+	}
+	return true;
+}
+
 template <>
 bool TryCast::Operation(dtime_t input, dtime_tz_t &result, bool strict) {
 	result = dtime_tz_t(input, 0);
@@ -1260,6 +1279,11 @@ dtime_t CastTimestampNsToTime::Operation(timestamp_t input) {
 	return Timestamp::GetTime(us);
 }
 
+template <>
+dtime_ns_t CastTimestampNsToTimeNs::Operation(timestamp_ns_t input) {
+	return Timestamp::GetTimeNs(input);
+}
+
 template <>
 timestamp_t CastTimestampSecToMs::Operation(timestamp_t input) {
 	if (!Timestamp::IsFinite(input)) {
@@ -1477,6 +1501,22 @@ string_t CastFromUUID::Operation(hugeint_t input, Vector &vector) {
 	return result;
 }
 
+//===--------------------------------------------------------------------===//
+// Cast From UUID To Blob
+//===--------------------------------------------------------------------===//
+template <>
+string_t CastFromUUIDToBlob::Operation(hugeint_t input, Vector &vector) {
+	// UUID is 16 bytes (128 bits)
+	string_t result = StringVector::EmptyString(vector, 16);
+	auto data = result.GetDataWriteable();
+
+	// Use the utility function from BaseUUID
+	BaseUUID::ToBlob(input, data_ptr_cast(data));
+
+	result.Finalize();
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast To UUID
 //===--------------------------------------------------------------------===//
@@ -1485,6 +1525,41 @@ bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_
 	return UUID::FromString(input.GetString(), result, parameters.strict);
 }
 
+//===--------------------------------------------------------------------===//
+// Cast Blob To UUID
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCastBlobToUUID::Operation(string_t input, hugeint_t &result, Vector &result_vector,
+                                  CastParameters &parameters) {
+	// BLOB must be exactly 16 bytes for UUID
+	if (input.GetSize() != 16) {
+		HandleCastError::AssignError("BLOB must be exactly 16 bytes to convert to UUID", parameters);
+		return false;
+	}
+
+	auto data = const_data_ptr_cast(input.GetData());
+
+	// Use the utility function from BaseUUID
+	result = BaseUUID::FromBlob(data);
+
+	return true;
+}
+
+template <>
+bool TryCastBlobToUUID::Operation(string_t input, hugeint_t &result, bool strict) {
+	// BLOB must be exactly 16 bytes for UUID
+	if (input.GetSize() != 16) {
+		return false;
+	}
+
+	auto data = const_data_ptr_cast(input.GetData());
+
+	// Use the utility function from BaseUUID
+	result = BaseUUID::FromBlob(data);
+
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast To Date
 //===--------------------------------------------------------------------===//
@@ -1541,6 +1616,41 @@ dtime_t Cast::Operation(string_t input) {
 	return Time::FromCString(input.GetData(), input.GetSize());
 }
 
+//===--------------------------------------------------------------------===//
+// Cast To Time (ns)
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCastErrorMessage::Operation(string_t input, dtime_ns_t &result, CastParameters &parameters) {
+	if (!TryCast::Operation<string_t, dtime_ns_t>(input, result, parameters.strict)) {
+		HandleCastError::AssignError(Time::ConversionError(input), parameters);
+		return false;
+	}
+	return true;
+}
+
+template <>
+bool TryCast::Operation(string_t input, dtime_ns_t &result, bool strict) {
+	idx_t pos;
+	dtime_t micros;
+	int32_t nanos = 0;
+	if (!Time::TryConvertTime(input.GetData(), input.GetSize(), pos, micros, strict, &nanos)) {
+		return false;
+	}
+	if (!TryCast::Operation(micros, result)) {
+		return false;
+	}
+	return TryAddOperator::Operation<int64_t, int64_t, int64_t>(result.micros, nanos, result.micros);
+}
+
+template <>
+dtime_ns_t Cast::Operation(string_t input) {
+	dtime_ns_t result;
+	if (!TryCast::Operation(input, result, false)) {
+		throw ConversionException(Time::ConversionError(input));
+	}
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast To TimeTZ
 //===--------------------------------------------------------------------===//
@@ -1574,7 +1684,26 @@ dtime_tz_t Cast::Operation(string_t input) {
 //===--------------------------------------------------------------------===//
 template <>
 bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters &parameters) {
-	switch (Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result)) {
+	switch (Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result, false)) {
+	case TimestampCastResult::SUCCESS:
+	case TimestampCastResult::STRICT_UTC:
+		return true;
+	case TimestampCastResult::ERROR_INCORRECT_FORMAT:
+		HandleCastError::AssignError(Timestamp::FormatError(input), parameters);
+		break;
+	case TimestampCastResult::ERROR_NON_UTC_TIMEZONE:
+		HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), parameters);
+		break;
+	case TimestampCastResult::ERROR_RANGE:
+		HandleCastError::AssignError(Timestamp::RangeError(input), parameters);
+		break;
+	}
+	return false;
+}
+
+template <>
+bool TryCastErrorMessage::Operation(string_t input, timestamp_tz_t &result, CastParameters &parameters) {
+	switch (Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result, true)) {
 	case TimestampCastResult::SUCCESS:
 	case TimestampCastResult::STRICT_UTC:
 		return true;
@@ -1593,7 +1722,14 @@ bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastPar
 
 template <>
 bool TryCast::Operation(string_t input, timestamp_t &result, bool strict) {
-	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result) == TimestampCastResult::SUCCESS;
+	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result, false) ==
+	       TimestampCastResult::SUCCESS;
+}
+
+template <>
+bool TryCast::Operation(string_t input, timestamp_tz_t &result, bool strict) {
+	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result, true) ==
+	       TimestampCastResult::SUCCESS;
 }
 
 template <>
@@ -1603,13 +1739,18 @@ bool TryCast::Operation(string_t input, timestamp_ns_t &result, bool strict) {
 
 template <>
 timestamp_t Cast::Operation(string_t input) {
-	return Timestamp::FromCString(input.GetData(), input.GetSize());
+	return Timestamp::FromCString(input.GetData(), input.GetSize(), false);
+}
+
+template <>
+timestamp_tz_t Cast::Operation(string_t input) {
+	return timestamp_tz_t(Timestamp::FromCString(input.GetData(), input.GetSize(), true));
 }
 
 template <>
 timestamp_ns_t Cast::Operation(string_t input) {
 	int32_t nanos;
-	const auto ts = Timestamp::FromCString(input.GetData(), input.GetSize(), &nanos);
+	const auto ts = Timestamp::FromCString(input.GetData(), input.GetSize(), false, &nanos);
 	timestamp_ns_t result;
 	if (!Timestamp::TryFromTimestampNanos(ts, nanos, result)) {
 		throw ConversionException(Timestamp::RangeError(input));

package/src/duckdb/src/common/operator/string_cast.cpp

@@ -2,8 +2,6 @@
 #include "duckdb/common/operator/string_cast.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/types/date.hpp"
-#include "duckdb/common/types/decimal.hpp"
-#include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -88,9 +86,9 @@ duckdb::string_t StringCast::Operation(uhugeint_t input, Vector &vector) {
 template <>
 duckdb::string_t StringCast::Operation(date_t input, Vector &vector) {
 	if (input == date_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
+		return StringVector::AddString(vector, Date::PINF.str);
 	} else if (input == date_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
+		return StringVector::AddString(vector, Date::NINF.str);
 	}
 	int32_t date[3];
 	Date::Convert(input, date[0], date[1], date[2]);
@@ -108,30 +106,61 @@ duckdb::string_t StringCast::Operation(date_t input, Vector &vector) {
 	return result;
 }
 
-template <>
-duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
+template <bool HAS_NANOS>
+duckdb::string_t StringAsTime(dtime_t input, Vector &vector) {
+	int32_t picos = 0;
+	if (HAS_NANOS) {
+		picos = UnsafeNumericCast<int32_t>(input.micros % 1000);
+		picos *= 1000;
+		input.micros /= 1000;
+	}
 	int32_t time[4];
 	Time::Convert(input, time[0], time[1], time[2], time[3]);
 
 	char micro_buffer[10] = {};
-	idx_t length = TimeToStringCast::Length(time, micro_buffer);
+	char nano_buffer[6] = {};
+	idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
+	idx_t nano_length = 0;
+	if (picos) {
+		//	If there are ps, we need all the µs
+		if (!time[3]) {
+			TimeToStringCast::FormatMicros(time[3], micro_buffer);
+		}
+		time_length = 15;
+		nano_length = 6;
+		nano_length -= NumericCast<idx_t>(TimeToStringCast::FormatMicros(picos, nano_buffer));
+	}
+	const idx_t length = time_length + nano_length;
 
 	string_t result = StringVector::EmptyString(vector, length);
 	auto data = result.GetDataWriteable();
 
-	TimeToStringCast::Format(data, length, time, micro_buffer);
+	TimeToStringCast::Format(data, time_length, time, micro_buffer);
+	data += time_length;
+	memcpy(data, nano_buffer, nano_length);
+	D_ASSERT(data + nano_length <= result.GetDataWriteable() + length);
 
 	result.Finalize();
 	return result;
 }
 
+template <>
+duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
+	return StringAsTime<false>(input, vector);
+}
+
+template <>
+duckdb::string_t StringCast::Operation(dtime_ns_t input, Vector &vector) {
+	return StringAsTime<true>(input, vector);
+}
+
 template <bool HAS_NANOS>
 duckdb::string_t StringFromTimestamp(timestamp_t input, Vector &vector) {
 	if (input == timestamp_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
+		return StringVector::AddString(vector, Date::PINF.str);
 	}
 	if (input == timestamp_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
+		return StringVector::AddString(vector, Date::NINF.str);
 	}
 
 	date_t date_entry;
@@ -264,10 +293,10 @@ string_t StringCastTZ::Operation(dtime_tz_t input, Vector &vector) {
 template <>
 string_t StringCastTZ::Operation(timestamp_t input, Vector &vector) {
 	if (input == timestamp_t::infinity()) {
-		return StringVector::AddString(vector, Date::PINF);
+		return StringVector::AddString(vector, Date::PINF.str);
 	}
 	if (input == timestamp_t::ninfinity()) {
-		return StringVector::AddString(vector, Date::NINF);
+		return StringVector::AddString(vector, Date::NINF.str);
 	}
 
 	date_t date_entry;

package/src/duckdb/src/common/pipe_file_system.cpp

@@ -3,13 +3,15 @@
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/numeric_utils.hpp"
+#include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
+
 class PipeFile : public FileHandle {
 public:
-	explicit PipeFile(unique_ptr<FileHandle> child_handle_p)
+	explicit PipeFile(QueryContext context_p, unique_ptr<FileHandle> child_handle_p)
 	    : FileHandle(pipe_fs, child_handle_p->path, child_handle_p->GetFlags()),
-	      child_handle(std::move(child_handle_p)) {
+	      child_handle(std::move(child_handle_p)), context(context_p) {
 	}
 
 	PipeFileSystem pipe_fs;
@@ -21,10 +23,13 @@ public:
 
 	void Close() override {
 	}
+
+private:
+	QueryContext context;
 };
 
 int64_t PipeFile::ReadChunk(void *buffer, int64_t nr_bytes) {
-	return child_handle->Read(buffer, UnsafeNumericCast<idx_t>(nr_bytes));
+	return child_handle->Read(context, buffer, UnsafeNumericCast<idx_t>(nr_bytes));
 }
 int64_t PipeFile::WriteChunk(void *buffer, int64_t nr_bytes) {
 	return child_handle->Write(buffer, UnsafeNumericCast<idx_t>(nr_bytes));
@@ -51,8 +56,8 @@ int64_t PipeFileSystem::GetFileSize(FileHandle &handle) {
 void PipeFileSystem::FileSync(FileHandle &handle) {
 }
 
-unique_ptr<FileHandle> PipeFileSystem::OpenPipe(unique_ptr<FileHandle> handle) {
-	return make_uniq<PipeFile>(std::move(handle));
+unique_ptr<FileHandle> PipeFileSystem::OpenPipe(QueryContext context, unique_ptr<FileHandle> handle) {
+	return make_uniq<PipeFile>(context, std::move(handle));
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/progress_bar/progress_bar.cpp

@@ -133,12 +133,12 @@ void ProgressBar::Update(bool final) {
 		if (final) {
 			FinishProgressBarPrint();
 		} else {
-			PrintProgress(LossyNumericCast<int>(query_progress.percentage.load()));
+			PrintProgress(query_progress.percentage.load());
 		}
 	}
 }
 
-void ProgressBar::PrintProgress(int current_percentage_p) {
+void ProgressBar::PrintProgress(double current_percentage_p) {
 	D_ASSERT(display);
 	display->Update(current_percentage_p);
 }