duckdb 0.3.5-dev16.0 → 0.3.5-dev26.0

package/package.json

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

package/src/duckdb.cpp

@@ -84973,9 +84973,6 @@ void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
-// TODO date_trunc function should also handle interval data type when it is implemented. See
-// https://www.postgresql.org/docs/9.1/functions-datetime.html
-
 namespace duckdb {
 
 struct DateTrunc {
@@ -85186,6 +85183,101 @@ timestamp_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+// INTERVAL specialisations
+template <>
+interval_t DateTrunc::MillenniumOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_MILLENIUM) * Interval::MONTHS_PER_MILLENIUM;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::CenturyOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_CENTURY) * Interval::MONTHS_PER_CENTURY;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::DecadeOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_DECADE) * Interval::MONTHS_PER_DECADE;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::YearOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_YEAR) * Interval::MONTHS_PER_YEAR;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::QuarterOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_QUARTER) * Interval::MONTHS_PER_QUARTER;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MonthOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::WeekOperator::Operation(interval_t input) {
+	input.micros = 0;
+	input.days = (input.days / Interval::DAYS_PER_WEEK) * Interval::DAYS_PER_WEEK;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::ISOYearOperator::Operation(interval_t input) {
+	return YearOperator::Operation<interval_t, interval_t>(input);
+}
+
+template <>
+interval_t DateTrunc::DayOperator::Operation(interval_t input) {
+	input.micros = 0;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::HourOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_HOUR) * Interval::MICROS_PER_HOUR;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MinuteOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_MINUTE) * Interval::MICROS_PER_MINUTE;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::SecondOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_SEC) * Interval::MICROS_PER_SEC;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MillisecondOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_MSEC) * Interval::MICROS_PER_MSEC;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
+	return input;
+}
+
 template <class TA, class TR>
 static TR TruncateElement(DatePartSpecifier type, TA element) {
 	switch (type) {
@@ -85289,7 +85381,7 @@ static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector
 	}
 }
 
-template <typename T>
+template <typename TA, typename TR>
 static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
 	auto &part_arg = args.data[0];
@@ -85302,20 +85394,22 @@ static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &r
 			ConstantVector::SetNull(result, true);
 		} else {
 			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateTruncUnaryExecutor<T, timestamp_t>(type, date_arg, result, args.size());
+			DateTruncUnaryExecutor<TA, TR>(type, date_arg, result, args.size());
 		}
 	} else {
-		BinaryExecutor::ExecuteStandard<string_t, T, timestamp_t, DateTruncBinaryOperator>(part_arg, date_arg, result,
-		                                                                                   args.size());
+		BinaryExecutor::ExecuteStandard<string_t, TA, TR, DateTruncBinaryOperator>(part_arg, date_arg, result,
+		                                                                           args.size());
 	}
 }
 
 void DateTruncFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet date_trunc("date_trunc");
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<timestamp_t>));
-	date_trunc.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP, DateTruncFunction<date_t>));
+	                                      DateTruncFunction<timestamp_t, timestamp_t>));
+	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP,
+	                                      DateTruncFunction<date_t, timestamp_t>));
+	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
+	                                      DateTruncFunction<interval_t, interval_t>));
 	set.AddFunction(date_trunc);
 	date_trunc.name = "datetrunc";
 	set.AddFunction(date_trunc);
@@ -103872,44 +103966,74 @@ void BaseAppender::AppendValueInternal(T input) {
 		throw InvalidInputException("Too many appends for chunk!");
 	}
 	auto &col = chunk->data[column];
-	switch (col.GetType().InternalType()) {
-	case PhysicalType::BOOL:
+	switch (col.GetType().id()) {
+	case LogicalTypeId::BOOLEAN:
 		AppendValueInternal<T, bool>(col, input);
 		break;
-	case PhysicalType::UINT8:
+	case LogicalTypeId::UTINYINT:
 		AppendValueInternal<T, uint8_t>(col, input);
 		break;
-	case PhysicalType::INT8:
+	case LogicalTypeId::TINYINT:
 		AppendValueInternal<T, int8_t>(col, input);
 		break;
-	case PhysicalType::UINT16:
+	case LogicalTypeId::USMALLINT:
 		AppendValueInternal<T, uint16_t>(col, input);
 		break;
-	case PhysicalType::INT16:
+	case LogicalTypeId::SMALLINT:
 		AppendValueInternal<T, int16_t>(col, input);
 		break;
-	case PhysicalType::UINT32:
+	case LogicalTypeId::UINTEGER:
 		AppendValueInternal<T, uint32_t>(col, input);
 		break;
-	case PhysicalType::INT32:
+	case LogicalTypeId::INTEGER:
 		AppendValueInternal<T, int32_t>(col, input);
 		break;
-	case PhysicalType::UINT64:
+	case LogicalTypeId::UBIGINT:
 		AppendValueInternal<T, uint64_t>(col, input);
 		break;
-	case PhysicalType::INT64:
+	case LogicalTypeId::BIGINT:
 		AppendValueInternal<T, int64_t>(col, input);
 		break;
-	case PhysicalType::INT128:
+	case LogicalTypeId::HUGEINT:
 		AppendValueInternal<T, hugeint_t>(col, input);
 		break;
-	case PhysicalType::FLOAT:
+	case LogicalTypeId::FLOAT:
 		AppendValueInternal<T, float>(col, input);
 		break;
-	case PhysicalType::DOUBLE:
+	case LogicalTypeId::DOUBLE:
 		AppendValueInternal<T, double>(col, input);
 		break;
-	case PhysicalType::VARCHAR:
+	case LogicalTypeId::DECIMAL:
+		switch (col.GetType().InternalType()) {
+		case PhysicalType::INT8:
+			AppendValueInternal<T, int8_t>(col, input);
+			break;
+		case PhysicalType::INT16:
+			AppendValueInternal<T, int16_t>(col, input);
+			break;
+		case PhysicalType::INT32:
+			AppendValueInternal<T, int32_t>(col, input);
+			break;
+		default:
+			AppendValueInternal<T, int64_t>(col, input);
+			break;
+		}
+		break;
+	case LogicalTypeId::DATE:
+		AppendValueInternal<T, date_t>(col, input);
+		break;
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+		AppendValueInternal<T, timestamp_t>(col, input);
+		break;
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+		AppendValueInternal<T, dtime_t>(col, input);
+		break;
+	case LogicalTypeId::INTERVAL:
+		AppendValueInternal<T, interval_t>(col, input);
+		break;
+	case LogicalTypeId::VARCHAR:
 		FlatVector::GetData<string_t>(col)[chunk->size()] = StringCast::Operation<T>(input, col);
 		break;
 	default:
@@ -103995,17 +104119,17 @@ void BaseAppender::Append(double value) {
 
 template <>
 void BaseAppender::Append(date_t value) {
-	AppendValueInternal<int32_t>(value.days);
+	AppendValueInternal<date_t>(value);
 }
 
 template <>
 void BaseAppender::Append(dtime_t value) {
-	AppendValueInternal<int64_t>(value.micros);
+	AppendValueInternal<dtime_t>(value);
 }
 
 template <>
 void BaseAppender::Append(timestamp_t value) {
-	AppendValueInternal<int64_t>(value.value);
+	AppendValueInternal<timestamp_t>(value);
 }
 
 template <>

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 "67c1e0ee0"
-#define DUCKDB_VERSION "v0.3.5-dev16"
+#define DUCKDB_SOURCE_ID "b6daef25a"
+#define DUCKDB_VERSION "v0.3.5-dev26"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //