duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/exception/conversion_exception.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/types/date.hpp"
@@ -11,6 +12,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/common/types/date_lookup_cache.hpp"
 
 namespace duckdb {
 
@@ -98,6 +100,20 @@ static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseS
 	return result.ToUnique();
 }
 
+template <class OP>
+struct DateCacheLocalState : public FunctionLocalState {
+	explicit DateCacheLocalState() {
+	}
+
+	DateLookupCache<OP> cache;
+};
+
+template <class OP>
+unique_ptr<FunctionLocalState> InitDateCacheLocalState(ExpressionState &state, const BoundFunctionExpression &expr,
+                                                       FunctionData *bind_data) {
+	return make_uniq<DateCacheLocalState<OP>>();
+}
+
 struct DatePart {
 	template <class T, class OP, class TR = int64_t>
 	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats,
@@ -403,6 +419,18 @@ struct DatePart {
 		}
 	};
 
+	struct NanosecondsOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return MicrosecondsOperator::Operation<TA, TR>(input) * Interval::NANOS_PER_MICRO;
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
+			return PropagateSimpleDatePartStatistics<0, 60000000000>(input.child_stats);
+		}
+	};
+
 	struct MicrosecondsOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
@@ -466,7 +494,7 @@ struct DatePart {
 	struct EpochOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return Date::Epoch(input);
+			return TR(Date::Epoch(input));
 		}
 
 		template <class T>
@@ -720,7 +748,7 @@ struct DatePart {
 			if (mask & EPOCH) {
 				auto double_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
 				if (double_data) {
-					double_data[idx] = Date::Epoch(input);
+					double_data[idx] = double(Date::Epoch(input));
 				}
 			}
 			if (mask & DOY) {
@@ -732,25 +760,19 @@ struct DatePart {
 			if (mask & JD) {
 				auto double_data = HasPartValue(double_values, DatePartSpecifier::JULIAN_DAY);
 				if (double_data) {
-					double_data[idx] = Date::ExtractJulianDay(input);
+					double_data[idx] = double(Date::ExtractJulianDay(input));
 				}
 			}
 		}
 	};
 };
 
-template <class T>
-static void LastYearFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	int32_t last_year = 0;
-	UnaryExecutor::ExecuteWithNulls<T, int64_t>(args.data[0], result, args.size(),
-	                                            [&](T input, ValidityMask &mask, idx_t idx) {
-		                                            if (Value::IsFinite(input)) {
-			                                            return Date::ExtractYear(input, &last_year);
-		                                            } else {
-			                                            mask.SetInvalid(idx);
-			                                            return 0;
-		                                            }
-	                                            });
+template <class OP, class T>
+static void DatePartCachedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<DateCacheLocalState<OP>>();
+	UnaryExecutor::ExecuteWithNulls<T, int64_t>(
+	    args.data[0], result, args.size(),
+	    [&](T input, ValidityMask &mask, idx_t idx) { return lstate.cache.ExtractElement(input, mask, idx); });
 }
 
 template <>
@@ -1073,6 +1095,19 @@ int64_t DatePart::EpochMillisOperator::Operation(dtime_tz_t input) {
 	return DatePart::EpochMillisOperator::Operation<dtime_t, int64_t>(input.time());
 }
 
+template <>
+int64_t DatePart::NanosecondsOperator::Operation(timestamp_ns_t input) {
+	if (!Timestamp::IsFinite(input)) {
+		throw ConversionException("Can't get nanoseconds of infinite TIMESTAMP");
+	}
+	date_t date;
+	dtime_t time;
+	int32_t nanos;
+	Timestamp::Convert(input, date, time, nanos);
+	// remove everything but the second & nanosecond part
+	return (time.micros % Interval::MICROS_PER_MINUTE) * Interval::NANOS_PER_MICRO + nanos;
+}
+
 template <>
 int64_t DatePart::MicrosecondsOperator::Operation(timestamp_t input) {
 	D_ASSERT(Timestamp::IsFinite(input));
@@ -1189,7 +1224,7 @@ int64_t DatePart::HoursOperator::Operation(dtime_tz_t input) {
 template <>
 double DatePart::EpochOperator::Operation(timestamp_t input) {
 	D_ASSERT(Timestamp::IsFinite(input));
-	return Timestamp::GetEpochMicroSeconds(input) / double(Interval::MICROS_PER_SEC);
+	return double(Timestamp::GetEpochMicroSeconds(input)) / double(Interval::MICROS_PER_SEC);
 }
 
 template <>
@@ -1203,7 +1238,7 @@ double DatePart::EpochOperator::Operation(interval_t input) {
 	interval_epoch = interval_days * Interval::SECS_PER_DAY;
 	// we add 0.25 days per year to sort of account for leap days
 	interval_epoch += interval_years * (Interval::SECS_PER_DAY / 4);
-	return interval_epoch + input.micros / double(Interval::MICROS_PER_SEC);
+	return double(interval_epoch) + double(input.micros) / double(Interval::MICROS_PER_SEC);
 }
 
 //	TODO: We can't propagate interval statistics because we can't easily compare interval_t for order.
@@ -1215,7 +1250,7 @@ unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<interval
 
 template <>
 double DatePart::EpochOperator::Operation(dtime_t input) {
-	return input.micros / double(Interval::MICROS_PER_SEC);
+	return double(input.micros) / double(Interval::MICROS_PER_SEC);
 }
 
 template <>
@@ -1301,7 +1336,7 @@ int64_t DatePart::TimezoneMinuteOperator::Operation(dtime_tz_t input) {
 
 template <>
 double DatePart::JulianDayOperator::Operation(date_t input) {
-	return Date::ExtractJulianDay(input);
+	return double(Date::ExtractJulianDay(input));
 }
 
 template <>
@@ -1659,14 +1694,15 @@ static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunct
 	return nullptr;
 }
 
+template <init_local_state_t DATE_CACHE = nullptr>
 ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
                                              scalar_function_t interval_func, function_statistics_t date_stats,
                                              function_statistics_t ts_stats) {
 	ScalarFunctionSet operator_set;
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr,
+	                                        nullptr, date_stats, DATE_CACHE));
+	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr,
+	                                        nullptr, ts_stats, DATE_CACHE));
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
 	return operator_set;
 }
@@ -1945,20 +1981,24 @@ struct StructDatePart {
 		return result;
 	}
 };
+template <class OP>
+ScalarFunctionSet GetCachedDatepartFunction() {
+	return GetGenericDatePartFunction<InitDateCacheLocalState<OP>>(
+	    DatePartCachedFunction<OP, date_t>, DatePartCachedFunction<OP, timestamp_t>,
+	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, OP::template PropagateStatistics<date_t>,
+	    OP::template PropagateStatistics<timestamp_t>);
+}
 
 ScalarFunctionSet YearFun::GetFunctions() {
-	return GetGenericDatePartFunction(LastYearFunction<date_t>, LastYearFunction<timestamp_t>,
-	                                  ScalarFunction::UnaryFunction<interval_t, int64_t, DatePart::YearOperator>,
-	                                  DatePart::YearOperator::PropagateStatistics<date_t>,
-	                                  DatePart::YearOperator::PropagateStatistics<timestamp_t>);
+	return GetCachedDatepartFunction<DatePart::YearOperator>();
 }
 
 ScalarFunctionSet MonthFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::MonthOperator>();
+	return GetCachedDatepartFunction<DatePart::MonthOperator>();
 }
 
 ScalarFunctionSet DayFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DayOperator>();
+	return GetCachedDatepartFunction<DatePart::DayOperator>();
 }
 
 ScalarFunctionSet DecadeFun::GetFunctions() {
@@ -2065,6 +2105,26 @@ ScalarFunctionSet EpochMsFun::GetFunctions() {
 	return operator_set;
 }
 
+ScalarFunctionSet NanosecondsFun::GetFunctions() {
+	using OP = DatePart::NanosecondsOperator;
+	using TR = int64_t;
+	const LogicalType &result_type = LogicalType::BIGINT;
+	auto operator_set = GetTimePartFunction<OP, TR>();
+
+	auto ns_func = DatePart::UnaryFunction<timestamp_ns_t, TR, OP>;
+	auto ns_stats = OP::template PropagateStatistics<timestamp_ns_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_NS}, result_type, ns_func, nullptr, nullptr, ns_stats));
+
+	//	TIMESTAMP WITH TIME ZONE has the same representation as TIMESTAMP so no need to defer to ICU
+	auto tstz_func = DatePart::UnaryFunction<timestamp_t, TR, OP>;
+	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+
+	return operator_set;
+}
+
 ScalarFunctionSet MicrosecondsFun::GetFunctions() {
 	return GetTimePartFunction<DatePart::MicrosecondsOperator>();
 }

package/src/duckdb/src/core_functions/scalar/date/date_trunc.cpp

@@ -138,7 +138,7 @@ struct DateTrunc {
 			dtime_t time;
 			Timestamp::Convert(input, date, time);
 			Time::Convert(time, hour, min, sec, micros);
-			micros -= micros % Interval::MICROS_PER_MSEC;
+			micros -= UnsafeNumericCast<int32_t>(micros % Interval::MICROS_PER_MSEC);
 			return Timestamp::FromDatetime(date, Time::FromTime(hour, min, sec, micros));
 		}
 	};

package/src/duckdb/src/core_functions/scalar/date/make_date.cpp

@@ -66,9 +66,9 @@ struct MakeTimeOperator {
 		if (ss < 0 || ss > Interval::SECS_PER_MINUTE) {
 			ss_32 = Cast::Operation<SS, int32_t>(ss);
 		} else {
-			ss_32 = UnsafeNumericCast<int32_t>(ss);
+			ss_32 = LossyNumericCast<int32_t>(ss);
 		}
-		auto micros = UnsafeNumericCast<int32_t>(std::round((ss - ss_32) * Interval::MICROS_PER_SEC));
+		auto micros = LossyNumericCast<int32_t>(std::round((ss - ss_32) * Interval::MICROS_PER_SEC));
 
 		if (!Time::IsValidTime(hh_32, mm_32, ss_32, micros)) {
 			throw ConversionException("Time out of range: %d:%d:%d.%d", hh_32, mm_32, ss_32, micros);

package/src/duckdb/src/core_functions/scalar/date/strftime.cpp

@@ -80,6 +80,19 @@ static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, V
 	info.format.ConvertTimestampVector(args.data[REVERSED ? 1 : 0], result, args.size());
 }
 
+template <bool REVERSED>
+static void StrfTimeFunctionTimestampNS(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<StrfTimeBindData>();
+
+	if (info.is_null) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+	info.format.ConvertTimestampNSVector(args.data[REVERSED ? 1 : 0], result, args.size());
+}
+
 ScalarFunctionSet StrfTimeFun::GetFunctions() {
 	ScalarFunctionSet strftime;
 
@@ -87,10 +100,14 @@ ScalarFunctionSet StrfTimeFun::GetFunctions() {
 	                                    StrfTimeFunctionDate<false>, StrfTimeBindFunction<false>));
 	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                                    StrfTimeFunctionTimestamp<false>, StrfTimeBindFunction<false>));
+	strftime.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_NS, LogicalType::VARCHAR}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionTimestampNS<false>, StrfTimeBindFunction<false>));
 	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::VARCHAR,
 	                                    StrfTimeFunctionDate<true>, StrfTimeBindFunction<true>));
 	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::VARCHAR,
 	                                    StrfTimeFunctionTimestamp<true>, StrfTimeBindFunction<true>));
+	strftime.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP_NS}, LogicalType::VARCHAR,
+	                                    StrfTimeFunctionTimestampNS<true>, StrfTimeBindFunction<true>));
 	return strftime;
 }
 
@@ -126,60 +143,29 @@ struct StrpTimeBindData : public FunctionData {
 	}
 };
 
-static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
-                                                     vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	if (!arguments[1]->IsFoldable()) {
-		throw InvalidInputException(*arguments[0], "strptime format must be a constant");
-	}
-	Value format_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-	string format_string;
-	StrpTimeFormat format;
-	if (format_value.IsNull()) {
-		return make_uniq<StrpTimeBindData>(format, format_string);
-	} else if (format_value.type().id() == LogicalTypeId::VARCHAR) {
-		format_string = format_value.ToString();
-		format.format_specifier = format_string;
-		string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-		if (!error.empty()) {
-			throw InvalidInputException(*arguments[0], "Failed to parse format specifier %s: %s", format_string, error);
-		}
-		if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
-			bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-		}
-		return make_uniq<StrpTimeBindData>(format, format_string);
-	} else if (format_value.type() == LogicalType::LIST(LogicalType::VARCHAR)) {
-		const auto &children = ListValue::GetChildren(format_value);
-		if (children.empty()) {
-			throw InvalidInputException(*arguments[0], "strptime format list must not be empty");
-		}
-		vector<string> format_strings;
-		vector<StrpTimeFormat> formats;
-		for (const auto &child : children) {
-			format_string = child.ToString();
-			format.format_specifier = format_string;
-			string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
-			if (!error.empty()) {
-				throw InvalidInputException(*arguments[0], "Failed to parse format specifier %s: %s", format_string,
-				                            error);
-			}
-			// If any format has UTC offsets, then we have to produce TSTZ
-			if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
-				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
-			}
-			format_strings.emplace_back(format_string);
-			formats.emplace_back(format);
-		}
-		return make_uniq<StrpTimeBindData>(formats, format_strings);
-	} else {
-		throw InvalidInputException(*arguments[0], "strptime format must be a string");
-	}
+template <typename T>
+inline T StrpTimeResult(StrpTimeFormat::ParseResult &parsed) {
+	return parsed.ToTimestamp();
+}
+
+template <>
+inline timestamp_ns_t StrpTimeResult(StrpTimeFormat::ParseResult &parsed) {
+	return parsed.ToTimestampNS();
+}
+
+template <typename T>
+inline bool StrpTimeTryResult(StrpTimeFormat &format, string_t &input, T &result, string &error) {
+	return format.TryParseTimestamp(input, result, error);
+}
+
+template <>
+inline bool StrpTimeTryResult(StrpTimeFormat &format, string_t &input, timestamp_ns_t &result, string &error) {
+	return format.TryParseTimestampNS(input, result, error);
 }
 
 struct StrpTimeFunction {
 
+	template <typename T>
 	static void Parse(DataChunk &args, ExpressionState &state, Vector &result) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
@@ -196,17 +182,18 @@ struct StrpTimeFunction {
 			ConstantVector::SetNull(result, true);
 			return;
 		}
-		UnaryExecutor::Execute<string_t, timestamp_t>(args.data[0], result, args.size(), [&](string_t input) {
+		UnaryExecutor::Execute<string_t, T>(args.data[0], result, args.size(), [&](string_t input) {
 			StrpTimeFormat::ParseResult result;
 			for (auto &format : info.formats) {
 				if (format.Parse(input, result)) {
-					return result.ToTimestamp();
+					return StrpTimeResult<T>(result);
 				}
 			}
 			throw InvalidInputException(result.FormatError(input, info.formats[0].format_specifier));
 		});
 	}
 
+	template <typename T>
 	static void TryParse(DataChunk &args, ExpressionState &state, Vector &result) {
 		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 		auto &info = func_expr.bind_info->Cast<StrpTimeBindData>();
@@ -217,19 +204,94 @@ struct StrpTimeFunction {
 			return;
 		}
 
-		UnaryExecutor::ExecuteWithNulls<string_t, timestamp_t>(
-		    args.data[0], result, args.size(), [&](string_t input, ValidityMask &mask, idx_t idx) {
-			    timestamp_t result;
-			    string error;
-			    for (auto &format : info.formats) {
-				    if (format.TryParseTimestamp(input, result, error)) {
-					    return result;
-				    }
-			    }
-
-			    mask.SetInvalid(idx);
-			    return timestamp_t();
-		    });
+		UnaryExecutor::ExecuteWithNulls<string_t, T>(args.data[0], result, args.size(),
+		                                             [&](string_t input, ValidityMask &mask, idx_t idx) {
+			                                             T result;
+			                                             string error;
+			                                             for (auto &format : info.formats) {
+				                                             if (StrpTimeTryResult(format, input, result, error)) {
+					                                             return result;
+				                                             }
+			                                             }
+
+			                                             mask.SetInvalid(idx);
+			                                             return T();
+		                                             });
+	}
+
+	static unique_ptr<FunctionData> Bind(ClientContext &context, ScalarFunction &bound_function,
+	                                     vector<unique_ptr<Expression>> &arguments) {
+		if (arguments[1]->HasParameter()) {
+			throw ParameterNotResolvedException();
+		}
+		if (!arguments[1]->IsFoldable()) {
+			throw InvalidInputException(*arguments[0], "strptime format must be a constant");
+		}
+		Value format_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
+		string format_string;
+		StrpTimeFormat format;
+		if (format_value.IsNull()) {
+			return make_uniq<StrpTimeBindData>(format, format_string);
+		} else if (format_value.type().id() == LogicalTypeId::VARCHAR) {
+			format_string = format_value.ToString();
+			format.format_specifier = format_string;
+			string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+			if (!error.empty()) {
+				throw InvalidInputException(*arguments[0], "Failed to parse format specifier %s: %s", format_string,
+				                            error);
+			}
+			if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
+				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
+			} else if (format.HasFormatSpecifier(StrTimeSpecifier::NANOSECOND_PADDED)) {
+				bound_function.return_type = LogicalType::TIMESTAMP_NS;
+				if (bound_function.name == "strptime") {
+					bound_function.function = Parse<timestamp_ns_t>;
+				} else {
+					bound_function.function = TryParse<timestamp_ns_t>;
+				}
+			}
+			return make_uniq<StrpTimeBindData>(format, format_string);
+		} else if (format_value.type() == LogicalType::LIST(LogicalType::VARCHAR)) {
+			const auto &children = ListValue::GetChildren(format_value);
+			if (children.empty()) {
+				throw InvalidInputException(*arguments[0], "strptime format list must not be empty");
+			}
+			vector<string> format_strings;
+			vector<StrpTimeFormat> formats;
+			bool has_offset = false;
+			bool has_nanos = false;
+
+			for (const auto &child : children) {
+				format_string = child.ToString();
+				format.format_specifier = format_string;
+				string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+				if (!error.empty()) {
+					throw InvalidInputException(*arguments[0], "Failed to parse format specifier %s: %s", format_string,
+					                            error);
+				}
+				has_offset = has_offset || format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET);
+				has_nanos = has_nanos || format.HasFormatSpecifier(StrTimeSpecifier::NANOSECOND_PADDED);
+				format_strings.emplace_back(format_string);
+				formats.emplace_back(format);
+			}
+
+			if (has_offset) {
+				// If any format has UTC offsets, then we have to produce TSTZ
+				bound_function.return_type = LogicalType::TIMESTAMP_TZ;
+			} else if (has_nanos) {
+				// If any format has nanoseconds, then we have to produce TSNS
+				// unless there is an offset, in which case we produce
+				bound_function.return_type = LogicalType::TIMESTAMP_NS;
+				if (bound_function.name == "strptime") {
+					bound_function.function = Parse<timestamp_ns_t>;
+				} else {
+					bound_function.function = TryParse<timestamp_ns_t>;
+				}
+			}
+			return make_uniq<StrpTimeBindData>(formats, format_strings);
+		} else {
+			throw InvalidInputException(*arguments[0], "strptime format must be a string");
+		}
 	}
 };
 
@@ -238,12 +300,12 @@ ScalarFunctionSet StrpTimeFun::GetFunctions() {
 
 	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
 	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                          StrpTimeFunction::Parse, StrpTimeBindFunction);
+	                          StrpTimeFunction::Parse<timestamp_t>, StrpTimeFunction::Bind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	strptime.AddFunction(fun);
 
-	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::Parse,
-	                     StrpTimeBindFunction);
+	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP,
+	                     StrpTimeFunction::Parse<timestamp_t>, StrpTimeFunction::Bind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	strptime.AddFunction(fun);
 	return strptime;
@@ -254,12 +316,12 @@ ScalarFunctionSet TryStrpTimeFun::GetFunctions() {
 
 	const auto list_type = LogicalType::LIST(LogicalType::VARCHAR);
 	auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP,
-	                          StrpTimeFunction::TryParse, StrpTimeBindFunction);
+	                          StrpTimeFunction::TryParse<timestamp_t>, StrpTimeFunction::Bind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	try_strptime.AddFunction(fun);
 
-	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::TryParse,
-	                     StrpTimeBindFunction);
+	fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP,
+	                     StrpTimeFunction::TryParse<timestamp_t>, StrpTimeFunction::Bind);
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	try_strptime.AddFunction(fun);
 

package/src/duckdb/src/core_functions/scalar/date/to_interval.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 
 template <>
 bool TryMultiplyOperator::Operation(double left, int64_t right, int64_t &result) {
-	return TryCast::Operation<double, int64_t>(left * right, result);
+	return TryCast::Operation<double, int64_t>(left * double(right), result);
 }
 
 struct ToMillenniaOperator {

package/src/duckdb/src/core_functions/scalar/enum/enum_functions.cpp

@@ -28,7 +28,7 @@ static void EnumRangeFunction(DataChunk &input, ExpressionState &state, Vector &
 	for (idx_t i = 0; i < enum_size; i++) {
 		enum_values.emplace_back(enum_vector.GetValue(i));
 	}
-	auto val = Value::LIST(enum_values);
+	auto val = Value::LIST(LogicalType::VARCHAR, enum_values);
 	result.Reference(val);
 }
 

package/src/duckdb/src/core_functions/scalar/generic/can_implicitly_cast.cpp

@@ -0,0 +1,40 @@
+#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast_rules.hpp"
+
+namespace duckdb {
+
+bool CanCastImplicitly(ClientContext &context, const LogicalType &source, const LogicalType &target) {
+	return CastFunctionSet::Get(context).ImplicitCastCost(source, target) >= 0;
+}
+
+static void CanCastImplicitlyFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &context = state.GetContext();
+	bool can_cast_implicitly = CanCastImplicitly(context, args.data[0].GetType(), args.data[1].GetType());
+	auto v = Value::BOOLEAN(can_cast_implicitly);
+	result.Reference(v);
+}
+
+unique_ptr<Expression> BindCanCastImplicitlyExpression(FunctionBindExpressionInput &input) {
+	auto &source_type = input.function.children[0]->return_type;
+	auto &target_type = input.function.children[1]->return_type;
+	if (source_type.id() == LogicalTypeId::UNKNOWN || source_type.id() == LogicalTypeId::SQLNULL ||
+	    target_type.id() == LogicalTypeId::UNKNOWN || target_type.id() == LogicalTypeId::SQLNULL) {
+		// parameter - unknown return type
+		return nullptr;
+	}
+	// emit a constant expression
+	return make_uniq<BoundConstantExpression>(
+	    Value::BOOLEAN(CanCastImplicitly(input.context, source_type, target_type)));
+}
+
+ScalarFunction CanCastImplicitlyFun::GetFunction() {
+	auto fun = ScalarFunction({LogicalType::ANY, LogicalType::ANY}, LogicalType::BOOLEAN, CanCastImplicitlyFunction);
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.bind_expression = BindCanCastImplicitlyExpression;
+	return fun;
+}
+
+} // namespace duckdb

package/src/duckdb/src/core_functions/scalar/generic/error.cpp

@@ -11,7 +11,7 @@ struct ErrorOperator {
 };
 
 ScalarFunction ErrorFun::GetFunction() {
-	auto fun = ScalarFunction({LogicalType::VARCHAR}, LogicalType::SQLNULL,
+	auto fun = ScalarFunction("error", {LogicalType::VARCHAR}, LogicalType::SQLNULL,
 	                          ScalarFunction::UnaryFunction<string_t, int32_t, ErrorOperator>);
 	// Set the function with side effects to avoid the optimization.
 	fun.stability = FunctionStability::VOLATILE;