duckdb 0.6.2-dev901.0 → 0.6.2-dev908.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev901.0",
+  "version": "0.6.2-dev908.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/common/sort/comparators.cpp

@@ -58,7 +58,7 @@ int Comparators::CompareVal(const data_ptr_t l_ptr, const data_ptr_t r_ptr, cons
 	case PhysicalType::STRUCT: {
 		auto l_nested_ptr = Load<data_ptr_t>(l_ptr);
 		auto r_nested_ptr = Load<data_ptr_t>(r_ptr);
-		return CompareValAndAdvance(l_nested_ptr, r_nested_ptr, type);
+		return CompareValAndAdvance(l_nested_ptr, r_nested_ptr, type, true);
 	}
 	default:
 		throw NotImplementedException("Unimplemented CompareVal for type %s", type.ToString());
@@ -113,7 +113,7 @@ int Comparators::TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_
 	}
 }
 
-int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type) {
+int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type, bool valid) {
 	switch (type.InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -141,11 +141,11 @@ int Comparators::CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, cons
 	case PhysicalType::INTERVAL:
 		return TemplatedCompareAndAdvance<interval_t>(l_ptr, r_ptr);
 	case PhysicalType::VARCHAR:
-		return CompareStringAndAdvance(l_ptr, r_ptr);
+		return CompareStringAndAdvance(l_ptr, r_ptr, valid);
 	case PhysicalType::LIST:
-		return CompareListAndAdvance(l_ptr, r_ptr, ListType::GetChildType(type));
+		return CompareListAndAdvance(l_ptr, r_ptr, ListType::GetChildType(type), valid);
 	case PhysicalType::STRUCT:
-		return CompareStructAndAdvance(l_ptr, r_ptr, StructType::GetChildTypes(type));
+		return CompareStructAndAdvance(l_ptr, r_ptr, StructType::GetChildTypes(type), valid);
 	default:
 		throw NotImplementedException("Unimplemented CompareValAndAdvance for type %s", type.ToString());
 	}
@@ -159,7 +159,10 @@ int Comparators::TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &ri
 	return result;
 }
 
-int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr) {
+int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, bool valid) {
+	if (!valid) {
+		return 0;
+	}
 	// Construct the string_t
 	uint32_t left_string_size = Load<uint32_t>(left_ptr);
 	uint32_t right_string_size = Load<uint32_t>(right_ptr);
@@ -174,7 +177,7 @@ int Comparators::CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 }
 
 int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-                                         const child_list_t<LogicalType> &types) {
+                                         const child_list_t<LogicalType> &types, bool valid) {
 	idx_t count = types.size();
 	// Load validity masks
 	ValidityBytes left_validity(left_ptr);
@@ -193,8 +196,8 @@ int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 		left_valid = left_validity.RowIsValid(left_validity.GetValidityEntry(entry_idx), idx_in_entry);
 		right_valid = right_validity.RowIsValid(right_validity.GetValidityEntry(entry_idx), idx_in_entry);
 		auto &type = types[i].second;
-		if ((left_valid && right_valid) || TypeIsConstantSize(type.InternalType())) {
-			comp_res = CompareValAndAdvance(left_ptr, right_ptr, types[i].second);
+		if ((left_valid == right_valid) || TypeIsConstantSize(type.InternalType())) {
+			comp_res = CompareValAndAdvance(left_ptr, right_ptr, types[i].second, left_valid && valid);
 		}
 		if (!left_valid && !right_valid) {
 			comp_res = 0;
@@ -210,7 +213,11 @@ int Comparators::CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right
 	return comp_res;
 }
 
-int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type) {
+int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type,
+                                       bool valid) {
+	if (!valid) {
+		return 0;
+	}
 	// Load list lengths
 	auto left_len = Load<idx_t>(left_ptr);
 	auto right_len = Load<idx_t>(right_ptr);
@@ -284,13 +291,14 @@ int Comparators::CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_p
 			if (left_valid && right_valid) {
 				switch (type.InternalType()) {
 				case PhysicalType::LIST:
-					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type));
+					comp_res = CompareListAndAdvance(left_ptr, right_ptr, ListType::GetChildType(type), left_valid);
 					break;
 				case PhysicalType::VARCHAR:
-					comp_res = CompareStringAndAdvance(left_ptr, right_ptr);
+					comp_res = CompareStringAndAdvance(left_ptr, right_ptr, left_valid);
 					break;
 				case PhysicalType::STRUCT:
-					comp_res = CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type));
+					comp_res =
+					    CompareStructAndAdvance(left_ptr, right_ptr, StructType::GetChildTypes(type), left_valid);
 					break;
 				default:
 					throw NotImplementedException("CompareListAndAdvance for variable-size type %s", type.ToString());

package/src/duckdb/src/common/types/date.cpp

@@ -502,32 +502,51 @@ int32_t Date::ExtractISODayOfTheWeek(date_t date) {
 	}
 }
 
-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
-	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, 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_isoweek) / 7) + 1;
+template <typename T>
+static T PythonDivMod(const T &x, const T &y, T &r) {
+	// D_ASSERT(y > 0);
+	T quo = x / y;
+	r = x - quo * y;
+	if (r < 0) {
+		--quo;
+		r += y;
 	}
+	// D_ASSERT(0 <= r && r < y);
+	return quo;
 }
 
-void Date::ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week) {
+static date_t GetISOWeekOne(int32_t year) {
+	const auto first_day = Date::FromDate(year, 1, 1); /* ord of 1/1 */
+	/* 0 if 1/1 is a Monday, 1 if a Tue, etc. */
+	const auto first_weekday = Date::ExtractISODayOfTheWeek(first_day) - 1;
+	/* ordinal of closest Monday at or before 1/1 */
+	auto week1_monday = first_day - first_weekday;
+
+	if (first_weekday > 3) { /* if 1/1 was Fri, Sat, Sun */
+		week1_monday += 7;
+	}
+
+	return week1_monday;
+}
+
+static int32_t GetISOYearWeek(const date_t date, int32_t &year) {
 	int32_t month, day;
 	Date::Convert(date, year, month, day);
-	week = GetISOYearWeek(year, month - 1, day - 1);
+	auto week1_monday = GetISOWeekOne(year);
+	auto week = PythonDivMod((date.days - week1_monday.days), 7, day);
+	if (week < 0) {
+		week1_monday = GetISOWeekOne(--year);
+		week = PythonDivMod((date.days - week1_monday.days), 7, day);
+	} else if (week >= 52 && date >= GetISOWeekOne(year + 1)) {
+		++year;
+		week = 0;
+	}
+
+	return week + 1;
+}
+
+void Date::ExtractISOYearWeek(date_t date, int32_t &year, int32_t &week) {
+	week = GetISOYearWeek(date, year);
 }
 
 int32_t Date::ExtractISOWeekNumber(date_t date) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev901"
+#define DUCKDB_VERSION "0.6.2-dev908"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "f805b1f98a"
+#define DUCKDB_SOURCE_ID "c3791b63d0"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/sort/comparators.hpp

@@ -38,17 +38,17 @@ private:
 	static int TemplatedCompareVal(const data_ptr_t &left_ptr, const data_ptr_t &right_ptr);
 
 	//! Compare two values at the pointers (can be recursive if nested type)
-	static int CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type);
+	static int CompareValAndAdvance(data_ptr_t &l_ptr, data_ptr_t &r_ptr, const LogicalType &type, bool valid);
 	//! Compares two fixed-size values at the given pointers
 	template <class T>
 	static int TemplatedCompareAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
 	//! Compares two string values at the given pointers
-	static int CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr);
+	static int CompareStringAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, bool valid);
 	//! Compares two struct values at the given pointers (recursive)
 	static int CompareStructAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr,
-	                                   const child_list_t<LogicalType> &types);
+	                                   const child_list_t<LogicalType> &types, bool valid);
 	//! Compare two list values at the pointers (can be recursive if nested type)
-	static int CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type);
+	static int CompareListAndAdvance(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const LogicalType &type, bool valid);
 	//! Compares a list of fixed-size values
 	template <class T>
 	static int TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &right_ptr, const ValidityBytes &left_validity,