duckdb 1.1.4-dev9.0 → 1.2.1-dev4.0

package/src/duckdb/extension/icu/icu-makedate.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "include/icu-casts.hpp"
 #include "include/icu-datefunc.hpp"
 #include "include/icu-datetrunc.hpp"
 
@@ -16,55 +17,58 @@
 
 namespace duckdb {
 
-struct ICUMakeDate : public ICUDateFunc {
-	static inline date_t Operation(icu::Calendar *calendar, timestamp_t instant) {
-		if (!Timestamp::IsFinite(instant)) {
-			return Timestamp::GetDate(instant);
-		}
-
-		// Extract the time zone parts
-		SetTime(calendar, instant);
-		const auto era = ExtractField(calendar, UCAL_ERA);
-		const auto year = ExtractField(calendar, UCAL_YEAR);
-		const auto mm = ExtractField(calendar, UCAL_MONTH) + 1;
-		const auto dd = ExtractField(calendar, UCAL_DATE);
-
-		const auto yyyy = era ? year : (-year + 1);
-		date_t result;
-		if (!Date::TryFromDate(yyyy, mm, dd, result)) {
-			throw ConversionException("Unable to convert TIMESTAMPTZ to DATE");
-		}
+date_t ICUMakeDate::Operation(icu::Calendar *calendar, timestamp_t instant) {
+	if (!Timestamp::IsFinite(instant)) {
+		return Timestamp::GetDate(instant);
+	}
 
-		return result;
+	// Extract the time zone parts
+	SetTime(calendar, instant);
+	const auto era = ExtractField(calendar, UCAL_ERA);
+	const auto year = ExtractField(calendar, UCAL_YEAR);
+	const auto mm = ExtractField(calendar, UCAL_MONTH) + 1;
+	const auto dd = ExtractField(calendar, UCAL_DATE);
+
+	const auto yyyy = era ? year : (-year + 1);
+	date_t result;
+	if (!Date::TryFromDate(yyyy, mm, dd, result)) {
+		throw ConversionException("Unable to convert TIMESTAMPTZ to DATE");
 	}
 
-	static bool CastToDate(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &cast_data = parameters.cast_data->Cast<CastData>();
-		auto &info = cast_data.info->Cast<BindData>();
-		CalendarPtr calendar(info.calendar->clone());
+	return result;
+}
 
-		UnaryExecutor::Execute<timestamp_t, date_t>(
-		    source, result, count, [&](timestamp_t input) { return Operation(calendar.get(), input); });
-		return true;
-	}
+date_t ICUMakeDate::ToDate(ClientContext &context, timestamp_t instant) {
+	ICUDateFunc::BindData data(context);
+	return Operation(data.calendar.get(), instant);
+}
 
-	static BoundCastInfo BindCastToDate(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-		if (!input.context) {
-			throw InternalException("Missing context for TIMESTAMPTZ to DATE cast.");
-		}
+bool ICUMakeDate::CastToDate(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<CastData>();
+	auto &info = cast_data.info->Cast<BindData>();
+	CalendarPtr calendar(info.calendar->clone());
 
-		auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
+	UnaryExecutor::Execute<timestamp_t, date_t>(source, result, count,
+	                                            [&](timestamp_t input) { return Operation(calendar.get(), input); });
+	return true;
+}
 
-		return BoundCastInfo(CastToDate, std::move(cast_data));
+BoundCastInfo ICUMakeDate::BindCastToDate(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+	if (!input.context) {
+		throw InternalException("Missing context for TIMESTAMPTZ to DATE cast.");
 	}
 
-	static void AddCasts(DatabaseInstance &db) {
-		auto &config = DBConfig::GetConfig(db);
-		auto &casts = config.GetCastFunctions();
+	auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
 
-		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::DATE, BindCastToDate);
-	}
-};
+	return BoundCastInfo(CastToDate, std::move(cast_data));
+}
+
+void ICUMakeDate::AddCasts(DatabaseInstance &db) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
+
+	casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::DATE, BindCastToDate);
+}
 
 struct ICUMakeTimestampTZFunc : public ICUDateFunc {
 	template <typename T>

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "include/icu-casts.hpp"
 #include "include/icu-datefunc.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -326,82 +327,81 @@ struct ICULocalTimeFunc : public ICUDateFunc {
 	}
 };
 
-struct ICUToTimeTZ : public ICUDateFunc {
-	static inline dtime_tz_t Operation(icu::Calendar *calendar, dtime_tz_t timetz) {
-		// Normalise to +00:00, add TZ offset, then set offset to TZ
-		auto time = Time::NormalizeTimeTZ(timetz);
+dtime_tz_t ICUToTimeTZ::Operation(icu::Calendar *calendar, dtime_tz_t timetz) {
+	// Normalise to +00:00, add TZ offset, then set offset to TZ
+	auto time = Time::NormalizeTimeTZ(timetz);
 
-		auto offset = ExtractField(calendar, UCAL_ZONE_OFFSET);
-		offset += ExtractField(calendar, UCAL_DST_OFFSET);
-		offset /= Interval::MSECS_PER_SEC;
+	auto offset = ExtractField(calendar, UCAL_ZONE_OFFSET);
+	offset += ExtractField(calendar, UCAL_DST_OFFSET);
+	offset /= Interval::MSECS_PER_SEC;
 
-		date_t date(0);
-		time = Interval::Add(time, {0, 0, offset * Interval::MICROS_PER_SEC}, date);
-		return dtime_tz_t(time, offset);
-	}
+	date_t date(0);
+	time = Interval::Add(time, {0, 0, offset * Interval::MICROS_PER_SEC}, date);
+	return dtime_tz_t(time, offset);
+}
 
-	static inline bool ToTimeTZ(icu::Calendar *calendar, timestamp_t instant, dtime_tz_t &result) {
-		if (!ICUIsFinite(instant)) {
-			return false;
-		}
+bool ICUToTimeTZ::ToTimeTZ(icu::Calendar *calendar, timestamp_t instant, dtime_tz_t &result) {
+	if (!ICUIsFinite(instant)) {
+		return false;
+	}
 
-		//	Time in current TZ
-		auto micros = int32_t(SetTime(calendar, instant));
-		const auto hour = ExtractField(calendar, UCAL_HOUR_OF_DAY);
-		const auto minute = ExtractField(calendar, UCAL_MINUTE);
-		const auto second = ExtractField(calendar, UCAL_SECOND);
-		const auto millis = ExtractField(calendar, UCAL_MILLISECOND);
-		micros += millis * int32_t(Interval::MICROS_PER_MSEC);
-		if (!Time::IsValidTime(hour, minute, second, micros)) {
-			return false;
-		}
-		const auto time = Time::FromTime(hour, minute, second, micros);
+	//	Time in current TZ
+	auto micros = int32_t(SetTime(calendar, instant));
+	const auto hour = ExtractField(calendar, UCAL_HOUR_OF_DAY);
+	const auto minute = ExtractField(calendar, UCAL_MINUTE);
+	const auto second = ExtractField(calendar, UCAL_SECOND);
+	const auto millis = ExtractField(calendar, UCAL_MILLISECOND);
+	micros += millis * int32_t(Interval::MICROS_PER_MSEC);
+	if (!Time::IsValidTime(hour, minute, second, micros)) {
+		return false;
+	}
+	const auto time = Time::FromTime(hour, minute, second, micros);
 
-		//	Offset in current TZ
-		auto offset = ExtractField(calendar, UCAL_ZONE_OFFSET);
-		offset += ExtractField(calendar, UCAL_DST_OFFSET);
-		offset /= Interval::MSECS_PER_SEC;
+	//	Offset in current TZ
+	auto offset = ExtractField(calendar, UCAL_ZONE_OFFSET);
+	offset += ExtractField(calendar, UCAL_DST_OFFSET);
+	offset /= Interval::MSECS_PER_SEC;
 
-		result = dtime_tz_t(time, offset);
-		return true;
-	}
+	result = dtime_tz_t(time, offset);
+	return true;
+}
 
-	static bool CastToTimeTZ(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
-		auto &cast_data = parameters.cast_data->Cast<CastData>();
-		auto &info = cast_data.info->Cast<BindData>();
-		CalendarPtr calendar(info.calendar->clone());
+bool ICUToTimeTZ::CastToTimeTZ(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+	auto &cast_data = parameters.cast_data->Cast<CastData>();
+	auto &info = cast_data.info->Cast<BindData>();
+	CalendarPtr calendar(info.calendar->clone());
+
+	UnaryExecutor::ExecuteWithNulls<timestamp_t, dtime_tz_t>(source, result, count,
+	                                                         [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
+		                                                         dtime_tz_t output;
+		                                                         if (ToTimeTZ(calendar.get(), input, output)) {
+			                                                         return output;
+		                                                         } else {
+			                                                         mask.SetInvalid(idx);
+			                                                         return dtime_tz_t();
+		                                                         }
+	                                                         });
+	return true;
+}
 
-		UnaryExecutor::ExecuteWithNulls<timestamp_t, dtime_tz_t>(source, result, count,
-		                                                         [&](timestamp_t input, ValidityMask &mask, idx_t idx) {
-			                                                         dtime_tz_t output;
-			                                                         if (ToTimeTZ(calendar.get(), input, output)) {
-				                                                         return output;
-			                                                         } else {
-				                                                         mask.SetInvalid(idx);
-				                                                         return dtime_tz_t();
-			                                                         }
-		                                                         });
-		return true;
+BoundCastInfo ICUToTimeTZ::BindCastToTimeTZ(BindCastInput &input, const LogicalType &source,
+                                            const LogicalType &target) {
+	if (!input.context) {
+		throw InternalException("Missing context for TIMESTAMPTZ to TIMETZ cast.");
 	}
 
-	static BoundCastInfo BindCastToTimeTZ(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
-		if (!input.context) {
-			throw InternalException("Missing context for TIMESTAMPTZ to TIMETZ cast.");
-		}
-
-		auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
+	auto cast_data = make_uniq<CastData>(make_uniq<BindData>(*input.context));
 
-		return BoundCastInfo(CastToTimeTZ, std::move(cast_data));
-	}
+	return BoundCastInfo(CastToTimeTZ, std::move(cast_data));
+}
 
-	static void AddCasts(DatabaseInstance &db) {
-		auto &config = DBConfig::GetConfig(db);
-		auto &casts = config.GetCastFunctions();
+void ICUToTimeTZ::AddCasts(DatabaseInstance &db) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
 
-		const auto implicit_cost = CastRules::ImplicitCast(LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ);
-		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ, BindCastToTimeTZ, implicit_cost);
-	}
-};
+	const auto implicit_cost = CastRules::ImplicitCast(LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ);
+	casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::TIME_TZ, BindCastToTimeTZ, implicit_cost);
+}
 
 struct ICUTimeZoneFunc : public ICUDateFunc {
 	template <typename OP, typename T>

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "include/icu-current.hpp"
 #include "include/icu-dateadd.hpp"
 #include "include/icu-datepart.hpp"
 #include "include/icu-datesub.hpp"
@@ -382,6 +383,7 @@ static void LoadInternal(DuckDB &ddb) {
 	config.AddExtensionOption("TimeZone", "The current time zone", LogicalType::VARCHAR, Value(tz_string),
 	                          SetICUTimeZone);
 
+	RegisterICUCurrentFunctions(db);
 	RegisterICUDateAddFunctions(db);
 	RegisterICUDatePartFunctions(db);
 	RegisterICUDateSubFunctions(db);

package/src/duckdb/extension/icu/include/icu-casts.hpp

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-datefunc.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "icu-datefunc.hpp"
+
+namespace duckdb {
+
+struct ICUMakeDate : public ICUDateFunc {
+	static date_t Operation(icu::Calendar *calendar, timestamp_t instant);
+
+	static bool CastToDate(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+
+	static BoundCastInfo BindCastToDate(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+
+	static void AddCasts(DatabaseInstance &db);
+
+	static date_t ToDate(ClientContext &context, timestamp_t instant);
+};
+
+struct ICUToTimeTZ : public ICUDateFunc {
+	static dtime_tz_t Operation(icu::Calendar *calendar, dtime_tz_t timetz);
+
+	static bool ToTimeTZ(icu::Calendar *calendar, timestamp_t instant, dtime_tz_t &result);
+
+	static bool CastToTimeTZ(Vector &source, Vector &result, idx_t count, CastParameters &parameters);
+
+	static BoundCastInfo BindCastToTimeTZ(BindCastInput &input, const LogicalType &source, const LogicalType &target);
+
+	static void AddCasts(DatabaseInstance &db);
+};
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-current.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-current.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUCurrentFunctions(DatabaseInstance &db);
+
+} // namespace duckdb