duckdb 0.3.2-dev1127.0 → 0.3.2-dev1141.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev1127.0",
+  "version": "0.3.2-dev1141.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -30993,29 +30993,44 @@ int32_t Date::ExtractISODayOfTheWeek(date_t date) {
 	}
 }
 
-static int32_t GetISOWeek(int32_t year, int32_t month, int32_t day) {
+static int32_t GetISOYearWeek(int32_t &year, int32_t month, int32_t day) {
 	auto day_of_the_year =
 	    (Date::IsLeapYear(year) ? Date::CUMULATIVE_LEAP_DAYS[month] : Date::CUMULATIVE_DAYS[month]) + day;
 	// get the first day of the first week of the year
 	// the first week is the week that has the 4th of January in it
-	auto day_of_the_fourth = Date::ExtractISODayOfTheWeek(Date::FromDate(year, 1, 4));
+	const auto weekday_of_the_fourth = Date::ExtractISODayOfTheWeek(Date::FromDate(year, 1, 4));
 	// if fourth is monday, then fourth is the first day
 	// if fourth is tuesday, third is the first day
 	// if fourth is wednesday, second is the first day
-	// if fourth is thursday - sunday, first is the first day
-	auto first_day_of_the_first_week = day_of_the_fourth >= 4 ? 0 : 5 - day_of_the_fourth;
-	if (day_of_the_year < first_day_of_the_first_week) {
-		// day is part of last year
-		return GetISOWeek(year - 1, 12, day);
+	// if fourth is thursday, first is the first day
+	// if fourth is friday - sunday, day is in the previous year
+	// (day is 0-based, weekday is 1-based)
+	const auto first_day_of_the_first_isoweek = 4 - weekday_of_the_fourth;
+	if (day_of_the_year < first_day_of_the_first_isoweek) {
+		// day is part of last year (13th month)
+		--year;
+		return GetISOYearWeek(year, 12, day);
 	} else {
-		return ((day_of_the_year - first_day_of_the_first_week) / 7) + 1;
+		return ((day_of_the_year - first_day_of_the_first_isoweek) / 7) + 1;
 	}
 }
 
-int32_t Date::ExtractISOWeekNumber(date_t date) {
-	int32_t year, month, day;
+void Date::ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week) {
+	int32_t month, day;
 	Date::Convert(date, year, month, day);
-	return GetISOWeek(year, month - 1, day - 1);
+	week = GetISOYearWeek(year, month - 1, day - 1);
+}
+
+int32_t Date::ExtractISOWeekNumber(date_t date) {
+	int32_t year, week;
+	ExtractISOYearWeek(date, year, week);
+	return week;
+}
+
+int32_t Date::ExtractISOYearNumber(date_t date) {
+	int32_t year, week;
+	ExtractISOYearWeek(date, year, week);
+	return year;
 }
 
 int32_t Date::ExtractWeekNumberRegular(date_t date, bool monday_first) {
@@ -32110,6 +32125,7 @@ enum class DatePartSpecifier : uint8_t {
 	DOW,
 	ISODOW,
 	WEEK,
+	ISOYEAR,
 	QUARTER,
 	DOY,
 	YEARWEEK,
@@ -75244,6 +75260,13 @@ struct DateDiff {
 		}
 	};
 
+	struct ISOYearOperator {
+		template <class TA, class TB, class TR>
+		static inline TR Operation(TA startdate, TB enddate) {
+			return Date::ExtractISOYearNumber(enddate) - Date::ExtractISOYearNumber(startdate);
+		}
+	};
+
 	struct MicrosecondsOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA startdate, TB enddate) {
@@ -75329,6 +75352,12 @@ int64_t DateDiff::WeekOperator::Operation(timestamp_t startdate, timestamp_t end
 	return WeekOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate), Timestamp::GetDate(enddate));
 }
 
+template <>
+int64_t DateDiff::ISOYearOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
+	return ISOYearOperator::Operation<date_t, date_t, int64_t>(Timestamp::GetDate(startdate),
+	                                                           Timestamp::GetDate(enddate));
+}
+
 template <>
 int64_t DateDiff::MicrosecondsOperator::Operation(timestamp_t startdate, timestamp_t enddate) {
 	return Timestamp::GetEpochMicroSeconds(enddate) - Timestamp::GetEpochMicroSeconds(startdate);
@@ -75397,6 +75426,11 @@ int64_t DateDiff::WeekOperator::Operation(dtime_t startdate, dtime_t enddate) {
 	throw NotImplementedException("\"time\" units \"week\" not recognized");
 }
 
+template <>
+int64_t DateDiff::ISOYearOperator::Operation(dtime_t startdate, dtime_t enddate) {
+	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
+}
+
 template <>
 int64_t DateDiff::MicrosecondsOperator::Operation(dtime_t startdate, dtime_t enddate) {
 	return enddate.micros - startdate.micros;
@@ -75445,6 +75479,8 @@ static int64_t DifferenceDates(DatePartSpecifier type, TA startdate, TB enddate)
 	case DatePartSpecifier::WEEK:
 	case DatePartSpecifier::YEARWEEK:
 		return DateDiff::WeekOperator::template Operation<TA, TB, TR>(startdate, enddate);
+	case DatePartSpecifier::ISOYEAR:
+		return DateDiff::ISOYearOperator::template Operation<TA, TB, TR>(startdate, enddate);
 	case DatePartSpecifier::MICROSECONDS:
 		return DateDiff::MicrosecondsOperator::template Operation<TA, TB, TR>(startdate, enddate);
 	case DatePartSpecifier::MILLISECONDS:
@@ -75499,6 +75535,9 @@ static void DateDiffBinaryExecutor(DatePartSpecifier type, Vector &left, Vector
 	case DatePartSpecifier::YEARWEEK:
 		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::WeekOperator>(left, right, result, count);
 		break;
+	case DatePartSpecifier::ISOYEAR:
+		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::ISOYearOperator>(left, right, result, count);
+		break;
 	case DatePartSpecifier::MICROSECONDS:
 		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateDiff::MicrosecondsOperator>(left, right, result, count);
 		break;
@@ -75607,7 +75646,7 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 		// isodow (Monday = 1, Sunday = 7)
 		result = DatePartSpecifier::ISODOW;
 	} else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
-		// week number
+		// ISO week number
 		result = DatePartSpecifier::WEEK;
 	} else if (specifier == "doy" || specifier == "dayofyear") {
 		// day of the year (1-365/366)
@@ -75616,8 +75655,11 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 		// quarter of the year (1-4)
 		result = DatePartSpecifier::QUARTER;
 	} else if (specifier == "yearweek") {
-		// Combined year and week YYYYWW
+		// Combined isoyear and isoweek YYYYWW
 		result = DatePartSpecifier::YEARWEEK;
+	} else if (specifier == "isoyear") {
+		// ISO year (first week of the year may be in previous year)
+		result = DatePartSpecifier::ISOYEAR;
 	} else if (specifier == "era") {
 		result = DatePartSpecifier::ERA;
 	} else if (specifier == "timezone") {
@@ -75656,6 +75698,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		case DatePartSpecifier::MILLENNIUM:
 		case DatePartSpecifier::DOW:
 		case DatePartSpecifier::ISODOW:
+		case DatePartSpecifier::ISOYEAR:
 		case DatePartSpecifier::WEEK:
 		case DatePartSpecifier::QUARTER:
 		case DatePartSpecifier::DOY:
@@ -75958,6 +76001,20 @@ struct DatePart {
 		}
 	};
 
+	struct ISOYearOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return Date::ExtractISOYearNumber(input);
+		}
+
+		template <class T>
+		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, BoundFunctionExpression &expr,
+		                                                      FunctionData *bind_data,
+		                                                      vector<unique_ptr<BaseStatistics>> &child_stats) {
+			return PropagateDatePartStatistics<T, ISOYearOperator>(child_stats);
+		}
+	};
+
 	struct YearWeekOperator {
 		template <class TR>
 		static inline TR YearWeekFromParts(TR yyyy, TR ww) {
@@ -75966,7 +76023,9 @@ struct DatePart {
 
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return YearWeekFromParts(YearOperator::Operation<TA, TR>(input), WeekOperator::Operation<TA, TR>(input));
+			int32_t yyyy, ww;
+			Date::ExtractISOYearWeek(input, yyyy, ww);
+			return YearWeekFromParts(yyyy, ww);
 		}
 
 		template <class T>
@@ -76109,7 +76168,8 @@ struct DatePart {
 			DOY = 1 << 2,
 			EPOCH = 1 << 3,
 			TIME = 1 << 4,
-			ZONE = 1 << 5
+			ZONE = 1 << 5,
+			ISO = 1 << 6
 		};
 
 		static part_mask_t GetMask(const part_codes_t &part_codes) {
@@ -76127,12 +76187,12 @@ struct DatePart {
 					mask |= YMD;
 					break;
 				case DatePartSpecifier::YEARWEEK:
-					mask |= YMD;
-					mask |= DOW;
+				case DatePartSpecifier::WEEK:
+				case DatePartSpecifier::ISOYEAR:
+					mask |= ISO;
 					break;
 				case DatePartSpecifier::DOW:
 				case DatePartSpecifier::ISODOW:
-				case DatePartSpecifier::WEEK:
 					mask |= DOW;
 					break;
 				case DatePartSpecifier::DOY:
@@ -76199,22 +76259,29 @@ struct DatePart {
 			}
 
 			// Week calculations
-			int32_t isodow = 0;
-			int32_t ww = 0;
 			if (mask & DOW) {
-				isodow = Date::ExtractISODayOfTheWeek(input);
-				ww = Date::ExtractISOWeekNumber(input);
+				auto isodow = Date::ExtractISODayOfTheWeek(input);
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOW))) {
 					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW))) {
 					part_data[idx] = isodow;
 				}
+			}
+
+			// ISO calculations
+			if (mask & ISO) {
+				int32_t ww = 0;
+				int32_t iyyy = 0;
+				Date::ExtractISOYearWeek(input, iyyy, ww);
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::WEEK))) {
 					part_data[idx] = ww;
 				}
+				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISOYEAR))) {
+					part_data[idx] = iyyy;
+				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK))) {
-					part_data[idx] = YearWeekOperator::YearWeekFromParts(yyyy, ww);
+					part_data[idx] = YearWeekOperator::YearWeekFromParts(iyyy, ww);
 				}
 			}
 
@@ -76382,6 +76449,33 @@ int64_t DatePart::WeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"week\" not recognized");
 }
 
+template <>
+int64_t DatePart::ISOYearOperator::Operation(timestamp_t input) {
+	return ISOYearOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
+}
+
+template <>
+int64_t DatePart::ISOYearOperator::Operation(interval_t input) {
+	throw NotImplementedException("interval units \"isoyear\" not recognized");
+}
+
+template <>
+int64_t DatePart::ISOYearOperator::Operation(dtime_t input) {
+	throw NotImplementedException("\"time\" units \"isoyear\" not recognized");
+}
+
+template <>
+int64_t DatePart::YearWeekOperator::Operation(timestamp_t input) {
+	return YearWeekOperator::Operation<date_t, int64_t>(Timestamp::GetDate(input));
+}
+
+template <>
+int64_t DatePart::YearWeekOperator::Operation(interval_t input) {
+	const auto yyyy = YearOperator::Operation<interval_t, int64_t>(input);
+	const auto ww = WeekOperator::Operation<interval_t, int64_t>(input);
+	return YearWeekOperator::YearWeekFromParts<int64_t>(yyyy, ww);
+}
+
 template <>
 int64_t DatePart::YearWeekOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"yearweek\" not recognized");
@@ -76677,6 +76771,8 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 		return DatePart::DayOfYearOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::WEEK:
 		return DatePart::WeekOperator::template Operation<T, int64_t>(element);
+	case DatePartSpecifier::ISOYEAR:
+		return DatePart::ISOYearOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::YEARWEEK:
 		return DatePart::YearWeekOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::EPOCH:
@@ -76969,6 +77065,7 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	AddDatePartOperator<DatePart::ISODayOfWeekOperator>(set, "isodow");
 	AddDatePartOperator<DatePart::DayOfYearOperator>(set, "dayofyear");
 	AddDatePartOperator<DatePart::WeekOperator>(set, "week");
+	AddDatePartOperator<DatePart::ISOYearOperator>(set, "isoyear");
 	AddDatePartOperator<DatePart::EraOperator>(set, "era");
 	AddDatePartOperator<DatePart::TimezoneOperator>(set, "timezone");
 	AddDatePartOperator<DatePart::TimezoneHourOperator>(set, "timezone_hour");
@@ -77091,6 +77188,7 @@ struct DateSub {
 			return MonthOperator::Operation<TA, TB, TR>(start_ts, end_ts) / Interval::MONTHS_PER_QUARTER;
 		}
 	};
+
 	struct YearOperator {
 		template <class TA, class TB, class TR>
 		static inline TR Operation(TA start_ts, TB end_ts) {
@@ -77337,6 +77435,7 @@ template <typename TA, typename TB, typename TR>
 static int64_t SubtractDateParts(DatePartSpecifier type, TA startdate, TB enddate) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
+	case DatePartSpecifier::ISOYEAR:
 		return DateSub::YearOperator::template Operation<TA, TB, TR>(startdate, enddate);
 	case DatePartSpecifier::MONTH:
 		return DateSub::MonthOperator::template Operation<TA, TB, TR>(startdate, enddate);
@@ -77383,6 +77482,7 @@ template <typename TA, typename TB, typename TR>
 static void DateSubBinaryExecutor(DatePartSpecifier type, Vector &left, Vector &right, Vector &result, idx_t count) {
 	switch (type) {
 	case DatePartSpecifier::YEAR:
+	case DatePartSpecifier::ISOYEAR:
 		BinaryExecutor::ExecuteStandard<TA, TB, TR, DateSub::YearOperator>(left, right, result, count);
 		break;
 	case DatePartSpecifier::MONTH:
@@ -77543,6 +77643,16 @@ struct DateTrunc {
 		}
 	};
 
+	struct ISOYearOperator {
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			date_t date = Date::GetMondayOfCurrentWeek(input);
+			date.days -= (Date::ExtractISOWeekNumber(date) - 1) * Interval::DAYS_PER_WEEK;
+
+			return Timestamp::FromDatetime(date, dtime_t(0));
+		}
+	};
+
 	struct DayOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
@@ -77644,6 +77754,11 @@ timestamp_t DateTrunc::WeekOperator::Operation(date_t input) {
 	return WeekOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
 }
 
+template <>
+timestamp_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
+	return ISOYearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
 template <>
 timestamp_t DateTrunc::DayOperator::Operation(date_t input) {
 	return Timestamp::FromDatetime(input, dtime_t(0));
@@ -77692,6 +77807,8 @@ static TR TruncateElement(DatePartSpecifier type, TA element) {
 	case DatePartSpecifier::WEEK:
 	case DatePartSpecifier::YEARWEEK:
 		return DateTrunc::WeekOperator::Operation<TA, TR>(element);
+	case DatePartSpecifier::ISOYEAR:
+		return DateTrunc::ISOYearOperator::Operation<TA, TR>(element);
 	case DatePartSpecifier::DAY:
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:
@@ -77745,6 +77862,9 @@ static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector
 	case DatePartSpecifier::YEARWEEK:
 		UnaryExecutor::Execute<TA, TR, DateTrunc::WeekOperator>(left, result, count);
 		break;
+	case DatePartSpecifier::ISOYEAR:
+		UnaryExecutor::Execute<TA, TR, DateTrunc::ISOYearOperator>(left, result, count);
+		break;
 	case DatePartSpecifier::DAY:
 	case DatePartSpecifier::DOW:
 	case DatePartSpecifier::ISODOW:

package/src/duckdb.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2018 DuckDB Contributors (see https://github.com/duckdb/duckdb/graphs/contributors)
+Copyright 2018-2022 Stichting DuckDB Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "9640de292"
-#define DUCKDB_VERSION "v0.3.2-dev1127"
+#define DUCKDB_SOURCE_ID "37e046ec0"
+#define DUCKDB_VERSION "v0.3.2-dev1141"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12826,7 +12826,9 @@ public:
 	//! contains January 4 of that year.
 	//! In the ISO week-numbering system, it is possible for early-January dates
 	//! to be part of the 52nd or 53rd week of the previous year.
+	DUCKDB_API static void ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week);
 	DUCKDB_API static int32_t ExtractISOWeekNumber(date_t date);
+	DUCKDB_API static int32_t ExtractISOYearNumber(date_t date);
 	//! Extract the week number as Python handles it.
 	//! Either Monday or Sunday is the first day of the week,
 	//! and any date before the first Monday/Sunday returns week 0