duckdb 0.3.2-dev874.0 → 0.3.2-dev898.0

package/package.json

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

package/src/duckdb.cpp

@@ -32120,7 +32120,9 @@ enum class DatePartSpecifier : uint8_t {
 	DOY,
 	YEARWEEK,
 	ERA,
-	OFFSET
+	TIMEZONE,
+	TIMEZONE_HOUR,
+	TIMEZONE_MINUTE
 };
 
 DUCKDB_API bool TryGetDatePartSpecifier(const string &specifier, DatePartSpecifier &result);
@@ -75008,6 +75010,10 @@ struct EpochFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct MakeDateFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct StrfTimeFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -75549,7 +75555,7 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 		result = DatePartSpecifier::DECADE;
 	} else if (specifier == "century" || specifier == "centuries") {
 		result = DatePartSpecifier::CENTURY;
-	} else if (specifier == "millennium" || specifier == "millennia") {
+	} else if (specifier == "millennium" || specifier == "millennia" || specifier == "millenium") {
 		result = DatePartSpecifier::MILLENNIUM;
 	} else if (specifier == "microseconds" || specifier == "microsecond") {
 		result = DatePartSpecifier::MICROSECONDS;
@@ -75585,8 +75591,12 @@ bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &resul
 		result = DatePartSpecifier::YEARWEEK;
 	} else if (specifier == "era") {
 		result = DatePartSpecifier::ERA;
-	} else if (specifier == "offset") {
-		result = DatePartSpecifier::OFFSET;
+	} else if (specifier == "timezone") {
+		result = DatePartSpecifier::TIMEZONE;
+	} else if (specifier == "timezone_hour") {
+		result = DatePartSpecifier::TIMEZONE_HOUR;
+	} else if (specifier == "timezone_minute") {
+		result = DatePartSpecifier::TIMEZONE_MINUTE;
 	} else {
 		return false;
 	}
@@ -75635,7 +75645,9 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		case DatePartSpecifier::MINUTE:
 		case DatePartSpecifier::HOUR:
 		case DatePartSpecifier::EPOCH:
-		case DatePartSpecifier::OFFSET:
+		case DatePartSpecifier::TIMEZONE:
+		case DatePartSpecifier::TIMEZONE_HOUR:
+		case DatePartSpecifier::TIMEZONE_MINUTE:
 			return part;
 		default:
 			break;
@@ -75760,9 +75772,15 @@ struct DatePart {
 	};
 
 	struct DecadeOperator {
+		// From the PG docs: "The year field divided by 10"
+		template <typename TR>
+		static inline TR DecadeFromYear(TR yyyy) {
+			return yyyy / 10;
+		}
+
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return YearOperator::Operation<TA, TR>(input) / 10;
+			return DecadeFromYear(YearOperator::Operation<TA, TR>(input));
 		}
 
 		template <class T>
@@ -75774,9 +75792,25 @@ struct DatePart {
 	};
 
 	struct CenturyOperator {
+		// From the PG docs:
+		// "The first century starts at 0001-01-01 00:00:00 AD, although they did not know it at the time.
+		// This definition applies to all Gregorian calendar countries.
+		// There is no century number 0, you go from -1 century to 1 century.
+		// If you disagree with this, please write your complaint to: Pope, Cathedral Saint-Peter of Roma, Vatican."
+		// (To be fair, His Holiness had nothing to do with this -
+		// it was the lack of zero in the counting systems of the time...)
+		template <typename TR>
+		static inline TR CenturyFromYear(TR yyyy) {
+			if (yyyy > 0) {
+				return ((yyyy - 1) / 100) + 1;
+			} else {
+				return (yyyy / 100) - 1;
+			}
+		}
+
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return ((YearOperator::Operation<TA, TR>(input) - 1) / 100) + 1;
+			return CenturyFromYear(YearOperator::Operation<TA, TR>(input));
 		}
 
 		template <class T>
@@ -75787,24 +75821,39 @@ struct DatePart {
 		}
 	};
 
-	struct MilleniumOperator {
+	struct MillenniumOperator {
+		// See the century comment
+		template <typename TR>
+		static inline TR MillenniumFromYear(TR yyyy) {
+			if (yyyy > 0) {
+				return ((yyyy - 1) / 1000) + 1;
+			} else {
+				return (yyyy / 1000) - 1;
+			}
+		}
+
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return ((YearOperator::Operation<TA, TR>(input) - 1) / 1000) + 1;
+			return MillenniumFromYear<TR>(YearOperator::Operation<TA, TR>(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, MilleniumOperator>(child_stats);
+			return PropagateDatePartStatistics<T, MillenniumOperator>(child_stats);
 		}
 	};
 
 	struct QuarterOperator {
+		template <class TR>
+		static inline TR QuarterFromMonth(TR mm) {
+			return (mm - 1) / Interval::MONTHS_PER_QUARTER + 1;
+		}
+
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return (Date::ExtractMonth(input) - 1) / Interval::MONTHS_PER_QUARTER + 1;
+			return QuarterFromMonth(Date::ExtractMonth(input));
 		}
 
 		template <class T>
@@ -75817,11 +75866,16 @@ struct DatePart {
 	};
 
 	struct DayOfWeekOperator {
-		template <class TA, class TR>
-		static inline TR Operation(TA input) {
+		template <class TR>
+		static inline TR DayOfWeekFromISO(TR isodow) {
 			// day of the week (Sunday = 0, Saturday = 6)
 			// turn sunday into 0 by doing mod 7
-			return Date::ExtractISODayOfTheWeek(input) % 7;
+			return isodow % 7;
+		}
+
+		template <class TA, class TR>
+		static inline TR Operation(TA input) {
+			return DayOfWeekFromISO(Date::ExtractISODayOfTheWeek(input));
 		}
 
 		template <class T>
@@ -75876,9 +75930,14 @@ struct DatePart {
 	};
 
 	struct YearWeekOperator {
+		template <class TR>
+		static inline TR YearWeekFromParts(TR yyyy, TR ww) {
+			return yyyy * 100 + ((yyyy > 0) ? ww : -ww);
+		}
+
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return YearOperator::Operation<TA, TR>(input) * 100 + WeekOperator::Operation<TA, TR>(input);
+			return YearWeekFromParts(YearOperator::Operation<TA, TR>(input), WeekOperator::Operation<TA, TR>(input));
 		}
 
 		template <class T>
@@ -75974,9 +76033,14 @@ struct DatePart {
 	};
 
 	struct EraOperator {
+		template <class TR>
+		static inline TR EraFromYear(TR yyyy) {
+			return yyyy > 0 ? 1 : 0;
+		}
+
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return Date::ExtractYear(input) > 0 ? 1 : 0;
+			return EraFromYear(Date::ExtractYear(input));
 		}
 
 		template <class T>
@@ -75987,7 +76051,7 @@ struct DatePart {
 		}
 	};
 
-	struct OffsetOperator {
+	struct TimezoneOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
 			// Regular timestamps are UTC.
@@ -76002,6 +76066,10 @@ struct DatePart {
 		}
 	};
 
+	// These are all zero and have the same restrictions
+	using TimezoneHourOperator = TimezoneOperator;
+	using TimezoneMinuteOperator = TimezoneOperator;
+
 	struct StructOperator {
 		using part_codes_t = vector<DatePartSpecifier>;
 		using part_mask_t = uint64_t;
@@ -76051,7 +76119,9 @@ struct DatePart {
 				case DatePartSpecifier::HOUR:
 					mask |= TIME;
 					break;
-				case DatePartSpecifier::OFFSET:
+				case DatePartSpecifier::TIMEZONE:
+				case DatePartSpecifier::TIMEZONE_HOUR:
+				case DatePartSpecifier::TIMEZONE_MINUTE:
 					mask |= ZONE;
 					break;
 				}
@@ -76083,19 +76153,19 @@ struct DatePart {
 					part_data[idx] = dd;
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DECADE))) {
-					part_data[idx] = yyyy / 10;
+					part_data[idx] = DecadeOperator::DecadeFromYear(yyyy);
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::CENTURY))) {
-					part_data[idx] = (yyyy - 1) / 100 + 1;
+					part_data[idx] = CenturyOperator::CenturyFromYear(yyyy);
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::MILLENNIUM))) {
-					part_data[idx] = (yyyy - 1) / 1000 + 1;
+					part_data[idx] = MillenniumOperator::MillenniumFromYear(yyyy);
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::QUARTER))) {
-					part_data[idx] = (mm - 1) / Interval::MONTHS_PER_QUARTER + 1;
+					part_data[idx] = QuarterOperator::QuarterFromMonth(mm);
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ERA))) {
-					part_data[idx] = yyyy > 0 ? 1 : 0;
+					part_data[idx] = EraOperator::EraFromYear(yyyy);
 				}
 			}
 
@@ -76105,9 +76175,8 @@ struct DatePart {
 			if (mask & DOW) {
 				isodow = Date::ExtractISODayOfTheWeek(input);
 				ww = Date::ExtractISOWeekNumber(input);
-				int32_t dow = isodow % 7;
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::DOW))) {
-					part_data[idx] = dow;
+					part_data[idx] = DayOfWeekOperator::DayOfWeekFromISO(isodow);
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::ISODOW))) {
 					part_data[idx] = isodow;
@@ -76116,7 +76185,7 @@ struct DatePart {
 					part_data[idx] = ww;
 				}
 				if ((part_data = HasPartValue(part_values, DatePartSpecifier::YEARWEEK))) {
-					part_data[idx] = yyyy * 100 + ww;
+					part_data[idx] = YearWeekOperator::YearWeekFromParts(yyyy, ww);
 				}
 			}
 
@@ -76200,12 +76269,12 @@ int64_t DatePart::CenturyOperator::Operation(dtime_t input) {
 }
 
 template <>
-int64_t DatePart::MilleniumOperator::Operation(interval_t input) {
+int64_t DatePart::MillenniumOperator::Operation(interval_t input) {
 	return input.months / Interval::MONTHS_PER_MILLENIUM;
 }
 
 template <>
-int64_t DatePart::MilleniumOperator::Operation(dtime_t input) {
+int64_t DatePart::MillenniumOperator::Operation(dtime_t input) {
 	throw NotImplementedException("\"time\" units \"millennium\" not recognized");
 }
 
@@ -76422,17 +76491,17 @@ int64_t DatePart::EraOperator::Operation(dtime_t input) {
 }
 
 template <>
-int64_t DatePart::OffsetOperator::Operation(timestamp_t input) {
-	return 0;
+int64_t DatePart::TimezoneOperator::Operation(date_t input) {
+	throw NotImplementedException("\"date\" units \"timezone\" not recognized");
 }
 
 template <>
-int64_t DatePart::OffsetOperator::Operation(interval_t input) {
-	throw NotImplementedException("\"interval\" units \"offset\" not recognized");
+int64_t DatePart::TimezoneOperator::Operation(interval_t input) {
+	throw NotImplementedException("\"interval\" units \"timezone\" not recognized");
 }
 
 template <>
-int64_t DatePart::OffsetOperator::Operation(dtime_t input) {
+int64_t DatePart::TimezoneOperator::Operation(dtime_t input) {
 	return 0;
 }
 
@@ -76467,7 +76536,13 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const dtime_t &i
 	}
 
 	if (mask & ZONE) {
-		if ((part_data = HasPartValue(part_values, DatePartSpecifier::OFFSET))) {
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE))) {
+			part_data[idx] = 0;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_HOUR))) {
+			part_data[idx] = 0;
+		}
+		if ((part_data = HasPartValue(part_values, DatePartSpecifier::TIMEZONE_MINUTE))) {
 			part_data[idx] = 0;
 		}
 	}
@@ -76479,9 +76554,18 @@ void DatePart::StructOperator::Operation(int64_t **part_values, const timestamp_
 	date_t d;
 	dtime_t t;
 	Timestamp::Convert(input, d, t);
-	// Time first because they both define epoch.
-	Operation(part_values, t, idx, mask);
-	Operation(part_values, d, idx, mask);
+
+	// Both define epoch, and the correct value is the sum.
+	// So mask it out and compute it separately.
+	Operation(part_values, d, idx, mask & ~EPOCH);
+	Operation(part_values, t, idx, mask & ~EPOCH);
+
+	if (mask & EPOCH) {
+		auto part_data = HasPartValue(part_values, DatePartSpecifier::EPOCH);
+		if (part_data) {
+			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(input);
+		}
+	}
 }
 
 template <>
@@ -76553,7 +76637,7 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 	case DatePartSpecifier::CENTURY:
 		return DatePart::CenturyOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::MILLENNIUM:
-		return DatePart::MilleniumOperator::template Operation<T, int64_t>(element);
+		return DatePart::MillenniumOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::QUARTER:
 		return DatePart::QuarterOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::DOW:
@@ -76580,8 +76664,10 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 		return DatePart::HoursOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::ERA:
 		return DatePart::EraOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::OFFSET:
-		return DatePart::OffsetOperator::template Operation<T, int64_t>(element);
+	case DatePartSpecifier::TIMEZONE:
+	case DatePartSpecifier::TIMEZONE_HOUR:
+	case DatePartSpecifier::TIMEZONE_MINUTE:
+		return DatePart::TimezoneOperator::template Operation<T, int64_t>(element);
 	default:
 		throw NotImplementedException("Specifier type not implemented for DATEPART");
 	}
@@ -76741,14 +76827,14 @@ struct StructDatePart {
 
 		const auto count = args.size();
 		Vector &input = args.data[0];
-		vector<int64_t *> part_values(int(DatePartSpecifier::OFFSET) + 1, nullptr);
+		vector<int64_t *> part_values(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, nullptr);
 		const auto part_mask = DatePart::StructOperator::GetMask(info.part_codes);
 
 		auto &child_entries = StructVector::GetEntries(result);
 
 		// The first computer of a part "owns" it
 		// and other requestors just reference the owner
-		vector<size_t> owners(int(DatePartSpecifier::OFFSET) + 1, child_entries.size());
+		vector<size_t> owners(int(DatePartSpecifier::TIMEZONE_MINUTE) + 1, child_entries.size());
 		for (size_t col = 0; col < child_entries.size(); ++col) {
 			const auto part_index = size_t(info.part_codes[col]);
 			if (owners[part_index] == child_entries.size()) {
@@ -76847,13 +76933,16 @@ void DatePartFun::RegisterFunction(BuiltinFunctions &set) {
 	AddDatePartOperator<DatePart::DayOperator>(set, "day");
 	AddDatePartOperator<DatePart::DecadeOperator>(set, "decade");
 	AddDatePartOperator<DatePart::CenturyOperator>(set, "century");
-	AddDatePartOperator<DatePart::MilleniumOperator>(set, "millennium");
+	AddDatePartOperator<DatePart::MillenniumOperator>(set, "millennium");
 	AddDatePartOperator<DatePart::QuarterOperator>(set, "quarter");
 	AddDatePartOperator<DatePart::DayOfWeekOperator>(set, "dayofweek");
 	AddDatePartOperator<DatePart::ISODayOfWeekOperator>(set, "isodow");
 	AddDatePartOperator<DatePart::DayOfYearOperator>(set, "dayofyear");
 	AddDatePartOperator<DatePart::WeekOperator>(set, "week");
 	AddDatePartOperator<DatePart::EraOperator>(set, "era");
+	AddDatePartOperator<DatePart::TimezoneOperator>(set, "timezone");
+	AddDatePartOperator<DatePart::TimezoneHourOperator>(set, "timezone_hour");
+	AddDatePartOperator<DatePart::TimezoneMinuteOperator>(set, "timezone_minute");
 	AddTimePartOperator<DatePart::EpochOperator>(set, "epoch");
 	AddTimePartOperator<DatePart::MicrosecondsOperator>(set, "microsecond");
 	AddTimePartOperator<DatePart::MillisecondsOperator>(set, "millisecond");
@@ -77737,6 +77826,189 @@ void EpochFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/vector_operations/senary_executor.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+struct SenaryExecutor {
+	static const size_t NCOLS = 6;
+
+	template <class TA, class TB, class TC, class TD, class TE, class TF, class TR,
+	          class FUN = std::function<TR(TA, TB, TC, TD, TE, TF)>>
+	static void Execute(DataChunk &input, Vector &result, FUN fun) {
+		D_ASSERT(input.ColumnCount() >= NCOLS);
+		const auto count = input.size();
+
+		bool all_constant = true;
+		bool any_null = false;
+		for (const auto &v : input.data) {
+			if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+				if (ConstantVector::IsNull(v)) {
+					any_null = true;
+				}
+			} else {
+				all_constant = false;
+				break;
+			}
+		}
+
+		if (all_constant) {
+			result.SetVectorType(VectorType::CONSTANT_VECTOR);
+			if (any_null) {
+				ConstantVector::SetNull(result, true);
+			} else {
+				auto adata = ConstantVector::GetData<TA>(input.data[0]);
+				auto bdata = ConstantVector::GetData<TB>(input.data[1]);
+				auto cdata = ConstantVector::GetData<TC>(input.data[2]);
+				auto ddata = ConstantVector::GetData<TD>(input.data[3]);
+				auto edata = ConstantVector::GetData<TE>(input.data[4]);
+				auto fdata = ConstantVector::GetData<TF>(input.data[5]);
+				auto result_data = ConstantVector::GetData<TR>(result);
+				result_data[0] = fun(*adata, *bdata, *cdata, *ddata, *edata, *fdata);
+			}
+		} else {
+			result.SetVectorType(VectorType::FLAT_VECTOR);
+			auto result_data = FlatVector::GetData<TR>(result);
+			auto &result_validity = FlatVector::Validity(result);
+
+			bool all_valid = true;
+			vector<VectorData> vdata(NCOLS);
+			for (size_t c = 0; c < NCOLS; ++c) {
+				input.data[c].Orrify(count, vdata[c]);
+				all_valid = all_valid && vdata[c].validity.AllValid();
+			}
+
+			auto adata = (const TA *)(vdata[0].data);
+			auto bdata = (const TB *)(vdata[1].data);
+			auto cdata = (const TC *)(vdata[2].data);
+			auto ddata = (const TD *)(vdata[3].data);
+			auto edata = (const TE *)(vdata[4].data);
+			auto fdata = (const TF *)(vdata[5].data);
+
+			vector<idx_t> idx(NCOLS);
+			if (all_valid) {
+				for (idx_t r = 0; r < count; ++r) {
+					for (size_t c = 0; c < NCOLS; ++c) {
+						idx[c] = vdata[c].sel->get_index(r);
+					}
+					result_data[r] =
+					    fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]], fdata[idx[5]]);
+				}
+			} else {
+				for (idx_t r = 0; r < count; ++r) {
+					all_valid = true;
+					for (size_t c = 0; c < NCOLS; ++c) {
+						idx[c] = vdata[c].sel->get_index(r);
+						if (!vdata[c].validity.RowIsValid(idx[c])) {
+							result_validity.SetInvalid(r);
+							all_valid = false;
+							break;
+						}
+					}
+					if (all_valid) {
+						result_data[r] = fun(adata[idx[0]], bdata[idx[1]], cdata[idx[2]], ddata[idx[3]], edata[idx[4]],
+						                     fdata[idx[5]]);
+					}
+				}
+			}
+		}
+	}
+};
+
+} // namespace duckdb
+
+
+namespace duckdb {
+
+struct MakeDateOperator {
+	template <typename YYYY, typename MM, typename DD, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) {
+		return Date::FromDate(yyyy, mm, dd);
+	}
+};
+
+template <typename T>
+static void ExecuteMakeDate(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 3);
+	auto &yyyy = input.data[0];
+	auto &mm = input.data[1];
+	auto &dd = input.data[2];
+
+	TernaryExecutor::Execute<T, T, T, date_t>(yyyy, mm, dd, result, input.size(),
+	                                          MakeDateOperator::Operation<T, T, T, date_t>);
+}
+
+struct MakeTimeOperator {
+	template <typename HH, typename MM, typename SS, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(HH hh, MM mm, SS ss) {
+		int64_t secs = ss;
+		int64_t micros = std::round((ss - secs) * Interval::MICROS_PER_SEC);
+		return Time::FromTime(hh, mm, secs, micros);
+	}
+};
+
+template <typename T>
+static void ExecuteMakeTime(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 3);
+	auto &yyyy = input.data[0];
+	auto &mm = input.data[1];
+	auto &dd = input.data[2];
+
+	TernaryExecutor::Execute<T, T, double, dtime_t>(yyyy, mm, dd, result, input.size(),
+	                                                MakeTimeOperator::Operation<T, T, double, dtime_t>);
+}
+
+struct MakeTimestampOperator {
+	template <typename YYYY, typename MM, typename DD, typename HR, typename MN, typename SS, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd, HR hr, MN mn, SS ss) {
+		const auto d = MakeDateOperator::Operation<YYYY, MM, DD, date_t>(yyyy, mm, dd);
+		const auto t = MakeTimeOperator::Operation<HR, MN, SS, dtime_t>(hr, mn, ss);
+		return Timestamp::FromDatetime(d, t);
+	}
+};
+
+template <typename T>
+static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 6);
+
+	auto func = MakeTimestampOperator::Operation<T, T, T, T, T, double, timestamp_t>;
+	SenaryExecutor::Execute<T, T, T, T, T, double, timestamp_t>(input, result, func);
+}
+
+void MakeDateFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet make_date("make_date");
+	make_date.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
+	                                     LogicalType::DATE, ExecuteMakeDate<int64_t>));
+	set.AddFunction(make_date);
+
+	ScalarFunctionSet make_time("make_time");
+	make_time.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
+	                                     LogicalType::TIME, ExecuteMakeTime<int64_t>));
+	set.AddFunction(make_time);
+
+	ScalarFunctionSet make_timestamp("make_timestamp");
+	make_timestamp.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT,
+	                                           LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE},
+	                                          LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
+	set.AddFunction(make_timestamp);
+}
+
+} // namespace duckdb
+
+
+
+
+
 
 
 
@@ -79067,6 +79339,7 @@ void BuiltinFunctions::RegisterDateFunctions() {
 	Register<CurrentDateFun>();
 	Register<CurrentTimestampFun>();
 	Register<EpochFun>();
+	Register<MakeDateFun>();
 	Register<StrfTimeFun>();
 	Register<StrpTimeFun>();
 	Register<ToIntervalFun>();
@@ -137063,6 +137336,10 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw ParserException("ORDER BY is not implemented for window functions!");
 		}
 
+		if (root->agg_filter) {
+			throw ParserException("FILTER is not implemented for window functions!");
+		}
+
 		const auto win_fun_type = WindowToExpressionType(lowercase_name);
 		if (win_fun_type == ExpressionType::INVALID) {
 			throw InternalException("Unknown/unsupported window function");

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 "be48a65ba"
-#define DUCKDB_VERSION "0.3.2-dev874"
+#define DUCKDB_SOURCE_ID "e15519f1c"
+#define DUCKDB_VERSION "0.3.2-dev898"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //