duckdb 0.6.2-dev904.0 → 0.6.2-dev910.0

package/package.json

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

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

@@ -1,6 +1,7 @@
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "include/icu-datefunc.hpp"
@@ -85,12 +86,16 @@ static void ICUTimeZoneFunction(ClientContext &context, TableFunctionInput &data
 	output.SetCardinality(index);
 }
 
-struct ICUFromLocalTimestamp : public ICUDateFunc {
-	static inline timestamp_t Operation(icu::Calendar *calendar, timestamp_t local) {
+struct ICUFromNaiveTimestamp : public ICUDateFunc {
+	static inline timestamp_t Operation(icu::Calendar *calendar, timestamp_t naive) {
+		if (!Timestamp::IsFinite(naive)) {
+			return naive;
+		}
+
 		// Extract the parts from the "instant"
 		date_t local_date;
 		dtime_t local_time;
-		Timestamp::Convert(local, local_date, local_time);
+		Timestamp::Convert(naive, local_date, local_time);
 
 		int32_t year;
 		int32_t mm;
@@ -116,19 +121,52 @@ struct ICUFromLocalTimestamp : public ICUDateFunc {
 
 		return GetTime(calendar, micros);
 	}
+
+	static bool CastFromNaive(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+		auto &cast_data = (CastData &)*parameters.cast_data;
+		auto info = (BindData *)cast_data.info.get();
+		CalendarPtr calendar(info->calendar->clone());
+
+		UnaryExecutor::Execute<timestamp_t, timestamp_t>(
+		    source, result, count, [&](timestamp_t input) { return Operation(calendar.get(), input); });
+		return true;
+	}
+
+	static BoundCastInfo BindCastFromNaive(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+		if (!input.context) {
+			throw InternalException("Missing context for TIMESTAMP to TIMESTAMPTZ cast.");
+		}
+
+		auto cast_data = make_unique<CastData>(make_unique<BindData>(*input.context));
+
+		return BoundCastInfo(CastFromNaive, move(cast_data));
+	}
+
+	static void AddCasts(ClientContext &context) {
+		auto &config = DBConfig::GetConfig(context);
+		auto &casts = config.GetCastFunctions();
+
+		casts.RegisterCastFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
+	}
 };
 
-struct ICUToLocalTimestamp : public ICUDateFunc {
+struct ICUToNaiveTimestamp : public ICUDateFunc {
 	static inline timestamp_t Operation(icu::Calendar *calendar, timestamp_t instant) {
+		if (!Timestamp::IsFinite(instant)) {
+			return instant;
+		}
+
 		// Extract the time zone parts
 		auto micros = 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 local_date;
-		if (!Date::TryFromDate(year, mm, dd, local_date)) {
-			throw ConversionException("Unable to create local date in TIMEZONE function");
+		if (!Date::TryFromDate(yyyy, mm, dd, local_date)) {
+			throw ConversionException("Unable to convert TIMESTAMPTZ to local date");
 		}
 
 		const auto hr = ExtractField(calendar, UCAL_HOUR_OF_DAY);
@@ -139,12 +177,39 @@ struct ICUToLocalTimestamp : public ICUDateFunc {
 		micros += millis * Interval::MICROS_PER_MSEC;
 		dtime_t local_time = Time::FromTime(hr, mn, secs, micros);
 
-		timestamp_t result;
-		if (!Timestamp::TryFromDatetime(local_date, local_time, result)) {
-			throw ConversionException("Unable to create local timestamp in TIMEZONE function");
+		timestamp_t naive;
+		if (!Timestamp::TryFromDatetime(local_date, local_time, naive)) {
+			throw ConversionException("Unable to convert TIMESTAMPTZ to local TIMESTAMP");
 		}
 
-		return result;
+		return naive;
+	}
+
+	static bool CastToNaive(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
+		auto &cast_data = (CastData &)*parameters.cast_data;
+		auto info = (BindData *)cast_data.info.get();
+		CalendarPtr calendar(info->calendar->clone());
+
+		UnaryExecutor::Execute<timestamp_t, timestamp_t>(
+		    source, result, count, [&](timestamp_t input) { return Operation(calendar.get(), input); });
+		return true;
+	}
+
+	static BoundCastInfo BindCastToNaive(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
+		if (!input.context) {
+			throw InternalException("Missing context for TIMESTAMPTZ to TIMESTAMP cast.");
+		}
+
+		auto cast_data = make_unique<CastData>(make_unique<BindData>(*input.context));
+
+		return BoundCastInfo(CastToNaive, move(cast_data));
+	}
+
+	static void AddCasts(ClientContext &context) {
+		auto &config = DBConfig::GetConfig(context);
+		auto &casts = config.GetCastFunctions();
+
+		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP, BindCastToNaive);
 	}
 };
 
@@ -186,7 +251,7 @@ struct ICULocalTimestampFunc : public ICUDateFunc {
 		auto calendar = calendar_ptr.get();
 
 		const auto now = info.now;
-		return ICUToLocalTimestamp::Operation(calendar, now);
+		return ICUToNaiveTimestamp::Operation(calendar, now);
 	}
 
 	static void Execute(DataChunk &input, ExpressionState &state, Vector &result) {
@@ -244,13 +309,8 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 				ConstantVector::SetNull(result, true);
 			} else {
 				SetTimeZone(calendar, *ConstantVector::GetData<string_t>(tz_vec));
-				UnaryExecutor::Execute<timestamp_t, timestamp_t>(ts_vec, result, input.size(), [&](timestamp_t ts) {
-					if (Timestamp::IsFinite(ts)) {
-						return OP::Operation(calendar, ts);
-					} else {
-						return ts;
-					}
-				});
+				UnaryExecutor::Execute<timestamp_t, timestamp_t>(
+				    ts_vec, result, input.size(), [&](timestamp_t ts) { return OP::Operation(calendar, ts); });
 			}
 		} else {
 			BinaryExecutor::Execute<string_t, timestamp_t, timestamp_t>(tz_vec, ts_vec, result, input.size(),
@@ -268,9 +328,9 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 	static void AddFunction(const string &name, ClientContext &context) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP_TZ,
-		                               Execute<ICUFromLocalTimestamp>, Bind));
+		                               Execute<ICUFromNaiveTimestamp>, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, LogicalType::TIMESTAMP,
-		                               Execute<ICUToLocalTimestamp>, Bind));
+		                               Execute<ICUToNaiveTimestamp>, Bind));
 
 		CreateScalarFunctionInfo func_info(set);
 		auto &catalog = Catalog::GetSystemCatalog(context);
@@ -279,14 +339,20 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 };
 
 void RegisterICUTimeZoneFunctions(ClientContext &context) {
+	//	Table functions
 	auto &catalog = Catalog::GetSystemCatalog(context);
 	TableFunction tz_names("pg_timezone_names", {}, ICUTimeZoneFunction, ICUTimeZoneBind, ICUTimeZoneInit);
 	CreateTableFunctionInfo tz_names_info(move(tz_names));
 	catalog.CreateTableFunction(context, &tz_names_info);
 
+	//	Scalar functions
 	ICUTimeZoneFunc::AddFunction("timezone", context);
 	ICULocalTimestampFunc::AddFunction("current_localtimestamp", context);
 	ICULocalTimeFunc::AddFunction("current_localtime", context);
+
+	// 	Casts
+	ICUFromNaiveTimestamp::AddCasts(context);
+	ICUToNaiveTimestamp::AddCasts(context);
 }
 
 } // namespace duckdb

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/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev904"
+#define DUCKDB_VERSION "0.6.2-dev910"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "b844a10312"
+#define DUCKDB_SOURCE_ID "e74e2471a5"
 #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,