duckdb 0.3.2-dev1133.0 → 0.3.2-dev1141.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.2-dev1133.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

@@ -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 "6e1155e14"
-#define DUCKDB_VERSION "v0.3.2-dev1133"
+#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