duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -7,7 +7,7 @@
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/main/config.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 
 #include <algorithm>
@@ -38,8 +38,16 @@ unique_ptr<MultiFileReader> MultiFileReader::CreateDefault(const string &functio
 	return res;
 }
 
+Value MultiFileReader::CreateValueFromFileList(const vector<string> &file_list) {
+	vector<Value> files;
+	for (auto &file : file_list) {
+		files.push_back(file);
+	}
+	return Value::LIST(std::move(files));
+}
+
 void MultiFileReader::AddParameters(TableFunction &table_function) {
-	table_function.named_parameters["filename"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["filename"] = LogicalType::ANY;
 	table_function.named_parameters["hive_partitioning"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["union_by_name"] = LogicalType::BOOLEAN;
 	table_function.named_parameters["hive_types"] = LogicalType::ANY;
@@ -95,7 +103,18 @@ bool MultiFileReader::ParseOption(const string &key, const Value &val, MultiFile
                                   ClientContext &context) {
 	auto loption = StringUtil::Lower(key);
 	if (loption == "filename") {
-		options.filename = BooleanValue::Get(val);
+		if (val.type() == LogicalType::VARCHAR) {
+			// If not, we interpret it as the name of the column containing the filename
+			options.filename = true;
+			options.filename_column = StringValue::Get(val);
+		} else {
+			Value boolean_value;
+			string error_message;
+			if (val.DefaultTryCastAs(LogicalType::BOOLEAN, boolean_value, &error_message)) {
+				// If the argument can be cast to boolean, we just interpret it as a boolean
+				options.filename = BooleanValue::Get(boolean_value);
+			}
+		}
 	} else if (loption == "hive_partitioning") {
 		options.hive_partitioning = BooleanValue::Get(val);
 		options.auto_detect_hive_partitioning = false;
@@ -130,9 +149,19 @@ bool MultiFileReader::ParseOption(const string &key, const Value &val, MultiFile
 }
 
 unique_ptr<MultiFileList> MultiFileReader::ComplexFilterPushdown(ClientContext &context, MultiFileList &files,
-                                                                 const MultiFileReaderOptions &options, LogicalGet &get,
+                                                                 const MultiFileReaderOptions &options,
+                                                                 MultiFilePushdownInfo &info,
                                                                  vector<unique_ptr<Expression>> &filters) {
-	return files.ComplexFilterPushdown(context, options, get, filters);
+	return files.ComplexFilterPushdown(context, options, info, filters);
+}
+
+unique_ptr<MultiFileList> MultiFileReader::DynamicFilterPushdown(ClientContext &context, const MultiFileList &files,
+                                                                 const MultiFileReaderOptions &options,
+                                                                 const vector<string> &names,
+                                                                 const vector<LogicalType> &types,
+                                                                 const vector<column_t> &column_ids,
+                                                                 TableFilterSet &filters) {
+	return files.DynamicFilterPushdown(context, options, names, types, column_ids, filters);
 }
 
 bool MultiFileReader::Bind(MultiFileReaderOptions &options, MultiFileList &files, vector<LogicalType> &return_types,
@@ -146,12 +175,14 @@ void MultiFileReader::BindOptions(MultiFileReaderOptions &options, MultiFileList
                                   MultiFileReaderBindData &bind_data) {
 	// Add generated constant column for filename
 	if (options.filename) {
-		if (std::find(names.begin(), names.end(), "filename") != names.end()) {
-			throw BinderException("Using filename option on file with column named filename is not supported");
+		if (std::find(names.begin(), names.end(), options.filename_column) != names.end()) {
+			throw BinderException("Option filename adds column \"%s\", but a column with this name is also in the "
+			                      "file. Try setting a different name: filename='<filename column name>'",
+			                      options.filename_column);
 		}
 		bind_data.filename_idx = names.size();
 		return_types.emplace_back(LogicalType::VARCHAR);
-		names.emplace_back("filename");
+		names.emplace_back(options.filename_column);
 	}
 
 	// Add generated constant columns from hive partitioning scheme
@@ -392,7 +423,7 @@ HivePartitioningIndex::HivePartitioningIndex(string value_p, idx_t index) : valu
 }
 
 void MultiFileReaderOptions::AddBatchInfo(BindInfo &bind_info) const {
-	bind_info.InsertOption("filename", Value::BOOLEAN(filename));
+	bind_info.InsertOption("filename", Value(filename_column));
 	bind_info.InsertOption("hive_partitioning", Value::BOOLEAN(hive_partitioning));
 	bind_info.InsertOption("auto_detect_hive_partitioning", Value::BOOLEAN(auto_detect_hive_partitioning));
 	bind_info.InsertOption("union_by_name", Value::BOOLEAN(union_by_name));
@@ -421,35 +452,23 @@ void UnionByName::CombineUnionTypes(const vector<string> &col_names, const vecto
 }
 
 bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(MultiFileList &files, ClientContext &context) {
-	std::unordered_set<string> partitions;
-	auto &fs = FileSystem::GetFileSystem(context);
-
 	auto first_file = files.GetFirstFile();
-	auto splits_first_file = StringUtil::Split(first_file, fs.PathSeparator(first_file));
-	if (splits_first_file.size() < 2) {
-		return false;
-	}
-	for (auto &split : splits_first_file) {
-		auto partition = StringUtil::Split(split, "=");
-		if (partition.size() == 2) {
-			partitions.insert(partition.front());
-		}
-	}
+	auto partitions = HivePartitioning::Parse(first_file);
 	if (partitions.empty()) {
+		// no partitions found in first file
 		return false;
 	}
 
 	for (const auto &file : files.Files()) {
-		auto splits = StringUtil::Split(file, fs.PathSeparator(file));
-		if (splits.size() != splits_first_file.size()) {
+		auto new_partitions = HivePartitioning::Parse(file);
+		if (new_partitions.size() != partitions.size()) {
+			// partition count mismatch
 			return false;
 		}
-		for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
-			auto part = StringUtil::Split(*it, "=");
-			if (part.size() != 2) {
-				continue;
-			}
-			if (partitions.find(part.front()) == partitions.end()) {
+		for (auto &part : new_partitions) {
+			auto entry = partitions.find(part.first);
+			if (entry == partitions.end()) {
+				// differing partitions between files
 				return false;
 			}
 		}
@@ -459,21 +478,9 @@ bool MultiFileReaderOptions::AutoDetectHivePartitioningInternal(MultiFileList &f
 void MultiFileReaderOptions::AutoDetectHiveTypesInternal(MultiFileList &files, ClientContext &context) {
 	const LogicalType candidates[] = {LogicalType::DATE, LogicalType::TIMESTAMP, LogicalType::BIGINT};
 
-	auto &fs = FileSystem::GetFileSystem(context);
-
 	unordered_map<string, LogicalType> detected_types;
 	for (const auto &file : files.Files()) {
-		unordered_map<string, string> partitions;
-		auto splits = StringUtil::Split(file, fs.PathSeparator(file));
-		if (splits.size() < 2) {
-			return;
-		}
-		for (auto it = splits.begin(); it != std::prev(splits.end()); it++) {
-			auto part = StringUtil::Split(*it, "=");
-			if (part.size() == 2) {
-				partitions[part.front()] = part.back();
-			}
-		}
+		auto partitions = HivePartitioning::Parse(file);
 		if (partitions.empty()) {
 			return;
 		}
@@ -545,24 +552,18 @@ LogicalType MultiFileReaderOptions::GetHiveLogicalType(const string &hive_partit
 	}
 	return LogicalType::VARCHAR;
 }
-Value MultiFileReaderOptions::GetHivePartitionValue(const string &base, const string &entry,
-                                                    ClientContext &context) const {
-	Value value(base);
-	auto it = hive_types_schema.find(entry);
-	if (it == hive_types_schema.end()) {
-		return value;
-	}
 
-	// Handle nulls
-	if (base.empty() || StringUtil::CIEquals(base, "NULL")) {
-		return Value(it->second);
-	}
+bool MultiFileReaderOptions::AnySet() {
+	return filename || hive_partitioning || union_by_name;
+}
 
-	if (!value.TryCastAs(context, it->second)) {
-		throw InvalidInputException("Unable to cast '%s' (from hive partition column '%s') to: '%s'", value.ToString(),
-		                            StringUtil::Upper(it->first), it->second.ToString());
+Value MultiFileReaderOptions::GetHivePartitionValue(const string &value, const string &key,
+                                                    ClientContext &context) const {
+	auto it = hive_types_schema.find(key);
+	if (it == hive_types_schema.end()) {
+		return HivePartitioning::GetValue(context, key, value, LogicalType::VARCHAR);
 	}
-	return value;
+	return HivePartitioning::GetValue(context, key, value, it->second);
 }
 
 } // namespace duckdb

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

@@ -922,26 +922,45 @@ bool TryCast::Operation(double input, double &result, bool strict) {
 //===--------------------------------------------------------------------===//
 template <>
 bool TryCast::Operation(string_t input, bool &result, bool strict) {
-	auto input_data = input.GetData();
+	auto input_data = reinterpret_cast<const uint8_t *>(input.GetData());
 	auto input_size = input.GetSize();
 
 	switch (input_size) {
 	case 1: {
-		char c = UnsafeNumericCast<char>(std::tolower(*input_data));
-		if (c == 't' || (!strict && c == '1')) {
+		unsigned char c = UnsafeNumericCast<uint8_t>(std::tolower(*input_data));
+		if (c == 't' || (!strict && c == 'y') || (!strict && c == '1')) {
 			result = true;
 			return true;
-		} else if (c == 'f' || (!strict && c == '0')) {
+		} else if (c == 'f' || (!strict && c == 'n') || (!strict && c == '0')) {
 			result = false;
 			return true;
 		}
 		return false;
 	}
+	case 2: {
+		unsigned char n = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
+		unsigned char o = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
+		if (n == 'n' && o == 'o') {
+			result = false;
+			return true;
+		}
+		return false;
+	}
+	case 3: {
+		unsigned char y = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
+		unsigned char e = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
+		unsigned char s = UnsafeNumericCast<uint8_t>(std::tolower(input_data[2]));
+		if (y == 'y' && e == 'e' && s == 's') {
+			result = true;
+			return true;
+		}
+		return false;
+	}
 	case 4: {
-		char t = UnsafeNumericCast<char>(std::tolower(input_data[0]));
-		char r = UnsafeNumericCast<char>(std::tolower(input_data[1]));
-		char u = UnsafeNumericCast<char>(std::tolower(input_data[2]));
-		char e = UnsafeNumericCast<char>(std::tolower(input_data[3]));
+		unsigned char t = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
+		unsigned char r = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
+		unsigned char u = UnsafeNumericCast<uint8_t>(std::tolower(input_data[2]));
+		unsigned char e = UnsafeNumericCast<uint8_t>(std::tolower(input_data[3]));
 		if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
 			result = true;
 			return true;
@@ -949,11 +968,11 @@ bool TryCast::Operation(string_t input, bool &result, bool strict) {
 		return false;
 	}
 	case 5: {
-		char f = UnsafeNumericCast<char>(std::tolower(input_data[0]));
-		char a = UnsafeNumericCast<char>(std::tolower(input_data[1]));
-		char l = UnsafeNumericCast<char>(std::tolower(input_data[2]));
-		char s = UnsafeNumericCast<char>(std::tolower(input_data[3]));
-		char e = UnsafeNumericCast<char>(std::tolower(input_data[4]));
+		unsigned char f = UnsafeNumericCast<uint8_t>(std::tolower(input_data[0]));
+		unsigned char a = UnsafeNumericCast<uint8_t>(std::tolower(input_data[1]));
+		unsigned char l = UnsafeNumericCast<uint8_t>(std::tolower(input_data[2]));
+		unsigned char s = UnsafeNumericCast<uint8_t>(std::tolower(input_data[3]));
+		unsigned char e = UnsafeNumericCast<uint8_t>(std::tolower(input_data[4]));
 		if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
 			result = false;
 			return true;
@@ -1125,8 +1144,8 @@ bool TryCast::Operation(interval_t input, interval_t &result, bool strict) {
 // Non-Standard Timestamps
 //===--------------------------------------------------------------------===//
 template <>
-duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_t input, Vector &result) {
-	return StringCast::Operation<timestamp_t>(CastTimestampNsToUs::Operation<timestamp_t, timestamp_t>(input), result);
+duckdb::string_t CastFromTimestampNS::Operation(duckdb::timestamp_ns_t input, Vector &result) {
+	return StringCast::Operation<timestamp_ns_t>(input, result);
 }
 template <>
 duckdb::string_t CastFromTimestampMS::Operation(duckdb::timestamp_t input, Vector &result) {
@@ -1258,20 +1277,8 @@ dtime_t CastTimestampSecToTime::Operation(timestamp_t input) {
 // Cast To Timestamp
 //===--------------------------------------------------------------------===//
 template <>
-bool TryCastToTimestampNS::Operation(string_t input, timestamp_t &result, bool strict) {
-	if (!TryCast::Operation<string_t, timestamp_t>(input, result, strict)) {
-		return false;
-	}
-	if (!Timestamp::IsFinite(result)) {
-		return true;
-	}
-
-	int64_t nanoseconds;
-	if (!Timestamp::TryGetEpochNanoSeconds(result, nanoseconds)) {
-		throw ConversionException("Could not convert VARCHAR value '%s' to Timestamp(NS)", input.GetString());
-	}
-	result = nanoseconds;
-	return true;
+bool TryCastToTimestampNS::Operation(string_t input, timestamp_ns_t &result, bool strict) {
+	return TryCast::Operation<string_t, timestamp_ns_t>(input, result, strict);
 }
 
 template <>
@@ -1293,7 +1300,7 @@ bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool
 }
 
 template <>
-bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool strict) {
+bool TryCastToTimestampNS::Operation(date_t input, timestamp_ns_t &result, bool strict) {
 	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
 		return false;
 	}
@@ -1558,11 +1565,27 @@ bool TryCast::Operation(string_t input, timestamp_t &result, bool strict) {
 	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result) == TimestampCastResult::SUCCESS;
 }
 
+template <>
+bool TryCast::Operation(string_t input, timestamp_ns_t &result, bool strict) {
+	return Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result) == TimestampCastResult::SUCCESS;
+}
+
 template <>
 timestamp_t Cast::Operation(string_t input) {
 	return Timestamp::FromCString(input.GetData(), input.GetSize());
 }
 
+template <>
+timestamp_ns_t Cast::Operation(string_t input) {
+	int32_t nanos;
+	const auto ts = Timestamp::FromCString(input.GetData(), input.GetSize(), &nanos);
+	timestamp_ns_t result;
+	if (!Timestamp::TryFromTimestampNanos(ts, nanos, result)) {
+		throw ConversionException(Timestamp::ConversionError(input));
+	}
+	return result;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From Interval
 //===--------------------------------------------------------------------===//
@@ -2275,9 +2298,6 @@ bool TryCastToDecimal::Operation(uhugeint_t input, hugeint_t &result, CastParame
 template <class SRC, class DST>
 bool DoubleToDecimalCast(SRC input, DST &result, CastParameters &parameters, uint8_t width, uint8_t scale) {
 	double value = input * NumericHelper::DOUBLE_POWERS_OF_TEN[scale];
-	// Add the sign (-1, 0, 1) times a tiny value to fix floating point issues (issue 3091)
-	double sign = (double(0) < value) - (value < double(0));
-	value += 1e-9 * sign;
 	if (value <= -NumericHelper::DOUBLE_POWERS_OF_TEN[width] || value >= NumericHelper::DOUBLE_POWERS_OF_TEN[width]) {
 		string error = StringUtil::Format("Could not cast value %f to DECIMAL(%d,%d)", value, width, scale);
 		HandleCastError::AssignError(error, parameters);
@@ -2611,9 +2631,88 @@ bool TryCastFromDecimal::Operation(hugeint_t input, uhugeint_t &result, CastPara
 //===--------------------------------------------------------------------===//
 // Decimal -> Float/Double Cast
 //===--------------------------------------------------------------------===//
+template <class SRC, class DST>
+static bool IsRepresentableExactly(SRC input, DST);
+
+template <>
+bool IsRepresentableExactly(int16_t input, float dst) {
+	return true;
+}
+
+const int64_t MAX_INT_REPRESENTABLE_IN_FLOAT = 0x001000000LL;
+const int64_t MAX_INT_REPRESENTABLE_IN_DOUBLE = 0x0020000000000000LL;
+
+template <>
+bool IsRepresentableExactly(int32_t input, float dst) {
+	return (input <= MAX_INT_REPRESENTABLE_IN_FLOAT && input >= -MAX_INT_REPRESENTABLE_IN_FLOAT);
+}
+
+template <>
+bool IsRepresentableExactly(int64_t input, float dst) {
+	return (input <= MAX_INT_REPRESENTABLE_IN_FLOAT && input >= -MAX_INT_REPRESENTABLE_IN_FLOAT);
+}
+
+template <>
+bool IsRepresentableExactly(hugeint_t input, float dst) {
+	return (input <= MAX_INT_REPRESENTABLE_IN_FLOAT && input >= -MAX_INT_REPRESENTABLE_IN_FLOAT);
+}
+
+template <>
+bool IsRepresentableExactly(int16_t input, double dst) {
+	return true;
+}
+
+template <>
+bool IsRepresentableExactly(int32_t input, double dst) {
+	return true;
+}
+
+template <>
+bool IsRepresentableExactly(int64_t input, double dst) {
+	return (input <= MAX_INT_REPRESENTABLE_IN_DOUBLE && input >= -MAX_INT_REPRESENTABLE_IN_DOUBLE);
+}
+
+template <>
+bool IsRepresentableExactly(hugeint_t input, double dst) {
+	return (input <= MAX_INT_REPRESENTABLE_IN_DOUBLE && input >= -MAX_INT_REPRESENTABLE_IN_DOUBLE);
+}
+
+template <class SRC>
+static SRC GetPowerOfTen(SRC input, uint8_t scale) {
+	return static_cast<SRC>(NumericHelper::POWERS_OF_TEN[scale]);
+}
+
+template <>
+hugeint_t GetPowerOfTen(hugeint_t input, uint8_t scale) {
+	return Hugeint::POWERS_OF_TEN[scale];
+}
+
+template <class SRC>
+static void GetDivMod(SRC lhs, SRC rhs, SRC &div, SRC &mod) {
+	div = lhs / rhs;
+	mod = lhs % rhs;
+}
+
+template <>
+void GetDivMod(hugeint_t lhs, hugeint_t rhs, hugeint_t &div, hugeint_t &mod) {
+	div = Hugeint::DivMod(lhs, rhs, mod);
+}
+
 template <class SRC, class DST>
 bool TryCastDecimalToFloatingPoint(SRC input, DST &result, uint8_t scale) {
-	result = Cast::Operation<SRC, DST>(input) / DST(NumericHelper::DOUBLE_POWERS_OF_TEN[scale]);
+	if (IsRepresentableExactly<SRC, DST>(input, DST(0.0)) || scale == 0) {
+		// Fast path, integer is representable exaclty as a float/double
+		result = Cast::Operation<SRC, DST>(input) / DST(NumericHelper::DOUBLE_POWERS_OF_TEN[scale]);
+		return true;
+	}
+	auto power_of_ten = GetPowerOfTen(input, scale);
+
+	SRC div = 0;
+	SRC mod = 0;
+	GetDivMod(input, power_of_ten, div, mod);
+
+	result = Cast::Operation<SRC, DST>(div) +
+	         Cast::Operation<SRC, DST>(mod) / DST(NumericHelper::DOUBLE_POWERS_OF_TEN[scale]);
 	return true;
 }
 

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

@@ -75,7 +75,7 @@ string_t StringCast::Operation(double input, Vector &vector) {
 
 template <>
 string_t StringCast::Operation(interval_t input, Vector &vector) {
-	char buffer[70];
+	char buffer[70] = {};
 	idx_t length = IntervalToStringCast::Format(input, buffer);
 	return StringVector::AddString(vector, buffer, length);
 }
@@ -113,7 +113,7 @@ duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
 	int32_t time[4];
 	Time::Convert(input, time[0], time[1], time[2], time[3]);
 
-	char micro_buffer[10];
+	char micro_buffer[10] = {};
 	idx_t length = TimeToStringCast::Length(time, micro_buffer);
 
 	string_t result = StringVector::EmptyString(vector, length);
@@ -125,8 +125,8 @@ duckdb::string_t StringCast::Operation(dtime_t input, Vector &vector) {
 	return result;
 }
 
-template <>
-duckdb::string_t StringCast::Operation(timestamp_t input, Vector &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);
 	} else if (input == timestamp_t::ninfinity()) {
@@ -134,7 +134,16 @@ duckdb::string_t StringCast::Operation(timestamp_t input, Vector &vector) {
 	}
 	date_t date_entry;
 	dtime_t time_entry;
-	Timestamp::Convert(input, date_entry, time_entry);
+	int32_t picos = 0;
+	if (HAS_NANOS) {
+		timestamp_ns_t ns;
+		ns.value = input.value;
+		Timestamp::Convert(ns, date_entry, time_entry, picos);
+		// Use picoseconds so we have 6 digits
+		picos *= 1000;
+	} else {
+		Timestamp::Convert(input, date_entry, time_entry);
+	}
 
 	int32_t date[3], time[4];
 	Date::Convert(date_entry, date[0], date[1], date[2]);
@@ -143,22 +152,44 @@ duckdb::string_t StringCast::Operation(timestamp_t input, Vector &vector) {
 	// format for timestamp is DATE TIME (separated by space)
 	idx_t year_length;
 	bool add_bc;
-	char micro_buffer[6];
+	char micro_buffer[6] = {};
+	char nano_buffer[6] = {};
 	idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
 	idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
-	idx_t length = date_length + time_length + 1;
+	idx_t nano_length = 0;
+	if (picos) {
+		//	If there are ps, we need all the µs
+		time_length = 15;
+		nano_length = 6;
+		nano_length -= NumericCast<idx_t>(TimeToStringCast::FormatMicros(picos, nano_buffer));
+	}
+	const idx_t length = date_length + 1 + time_length + nano_length;
 
 	string_t result = StringVector::EmptyString(vector, length);
 	auto data = result.GetDataWriteable();
 
 	DateToStringCast::Format(data, date, year_length, add_bc);
-	data[date_length] = ' ';
-	TimeToStringCast::Format(data + date_length + 1, time_length, time, micro_buffer);
+	data += date_length;
+	*data++ = ' ';
+	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(timestamp_t input, Vector &vector) {
+	return StringFromTimestamp<false>(input, vector);
+}
+
+template <>
+duckdb::string_t StringCast::Operation(timestamp_ns_t input, Vector &vector) {
+	return StringFromTimestamp<true>(input, vector);
+}
+
 template <>
 duckdb::string_t StringCast::Operation(duckdb::string_t input, Vector &result) {
 	return StringVector::AddStringOrBlob(result, input);
@@ -169,7 +200,7 @@ string_t StringCastTZ::Operation(dtime_tz_t input, Vector &vector) {
 	int32_t time[4];
 	Time::Convert(input.time(), time[0], time[1], time[2], time[3]);
 
-	char micro_buffer[10];
+	char micro_buffer[10] = {};
 	const auto time_length = TimeToStringCast::Length(time, micro_buffer);
 	idx_t length = time_length;
 
@@ -243,7 +274,7 @@ string_t StringCastTZ::Operation(timestamp_t input, Vector &vector) {
 	// format for timestamptz is DATE TIME+00 (separated by space)
 	idx_t year_length;
 	bool add_bc;
-	char micro_buffer[6];
+	char micro_buffer[6] = {};
 	const idx_t date_length = DateToStringCast::Length(date, year_length, add_bc);
 	const idx_t time_length = TimeToStringCast::Length(time, micro_buffer);
 	const idx_t length = date_length + 1 + time_length + 3;

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

@@ -84,7 +84,7 @@ bool ProgressBar::ShouldPrint(bool final) const {
 		return false;
 	}
 	// FIXME - do we need to check supported before running `profiler.Elapsed()` ?
-	auto sufficient_time_elapsed = profiler.Elapsed() > show_progress_after / 1000.0;
+	auto sufficient_time_elapsed = profiler.Elapsed() > static_cast<double>(show_progress_after) / 1000.0;
 	if (!sufficient_time_elapsed) {
 		// Don't print yet
 		return false;
@@ -121,7 +121,7 @@ void ProgressBar::Update(bool final) {
 		if (final) {
 			FinishProgressBarPrint();
 		} else {
-			PrintProgress(NumericCast<int>(query_progress.percentage.load()));
+			PrintProgress(LossyNumericCast<int>(query_progress.percentage.load()));
 		}
 #endif
 	}

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

@@ -40,7 +40,7 @@ void TerminalProgressBarDisplay::PrintProgressInternal(int32_t percentage) {
 	}
 	if (i < PROGRESS_BAR_WIDTH) {
 		// print a partial block based on the percentage of the progress bar remaining
-		idx_t index = idx_t((blocks_to_draw - idx_t(blocks_to_draw)) * PARTIAL_BLOCK_COUNT);
+		idx_t index = idx_t((blocks_to_draw - static_cast<double>(idx_t(blocks_to_draw))) * PARTIAL_BLOCK_COUNT);
 		if (index >= PARTIAL_BLOCK_COUNT) {
 			index = PARTIAL_BLOCK_COUNT - 1;
 		}