duckdb 0.6.2-dev908.0 → 0.6.2-dev912.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev908.0",
+  "version": "0.6.2-dev912.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/types/vector.cpp

@@ -1674,6 +1674,9 @@ vector<idx_t> ListVector::Search(Vector &list, const Value &key, idx_t row) {
 	case PhysicalType::DOUBLE:
 		TemplatedSearchInMap<double>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
 		break;
+	case PhysicalType::INTERVAL:
+		TemplatedSearchInMap<interval_t>(list, key, offsets, key.IsNull(), entry.offset, entry.length);
+		break;
 	case PhysicalType::VARCHAR:
 		SearchStringInMap(list, StringValue::Get(key), offsets, key.IsNull(), entry.offset, entry.length);
 		break;

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

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