duckdb 0.3.2-dev876.0 → 0.3.2-dev901.0

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>();
@@ -96895,7 +97168,7 @@ namespace duckdb {
 template <class T>
 void WriteData(duckdb_result *out, ChunkCollection &source, idx_t col) {
 	idx_t row = 0;
-	auto target = (T *)out->columns[col].data;
+	auto target = (T *)out->__deprecated_columns[col].__deprecated_data;
 	for (auto &chunk : source.Chunks()) {
 		auto source = FlatVector::GetData<T>(chunk->data[col]);
 		auto &mask = FlatVector::Validity(chunk->data[col]);
@@ -96918,46 +97191,49 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 	memset(out, 0, sizeof(duckdb_result));
 	if (!result->success) {
 		// write the error message
-		out->error_message = strdup(result->error.c_str());
+		out->__deprecated_error_message = strdup(result->error.c_str());
 		return DuckDBError;
 	}
 	// copy the data
 	// first write the meta data
-	out->column_count = result->types.size();
-	out->row_count = result->collection.Count();
-	out->rows_changed = 0;
-	if (out->row_count > 0 && StatementTypeReturnChanges(result->statement_type)) {
+	out->__deprecated_column_count = result->types.size();
+	out->__deprecated_row_count = result->collection.Count();
+	out->__deprecated_rows_changed = 0;
+	if (out->__deprecated_row_count > 0 && StatementTypeReturnChanges(result->statement_type)) {
 		// update total changes
 		auto row_changes = result->GetValue(0, 0);
 		if (!row_changes.is_null && row_changes.TryCastAs(LogicalType::BIGINT)) {
-			out->rows_changed = row_changes.GetValue<int64_t>();
+			out->__deprecated_rows_changed = row_changes.GetValue<int64_t>();
 		}
 	}
-	out->columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * out->column_count);
-	if (!out->columns) { // LCOV_EXCL_START
+	out->__deprecated_columns = (duckdb_column *)duckdb_malloc(sizeof(duckdb_column) * out->__deprecated_column_count);
+	if (!out->__deprecated_columns) { // LCOV_EXCL_START
 		// malloc failure
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
 
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
-	memset(out->columns, 0, sizeof(duckdb_column) * out->column_count);
-	for (idx_t i = 0; i < out->column_count; i++) {
-		out->columns[i].type = ConvertCPPTypeToC(result->types[i]);
-		out->columns[i].name = strdup(result->names[i].c_str());
-		out->columns[i].nullmask = (bool *)duckdb_malloc(sizeof(bool) * out->row_count);
-		out->columns[i].data = duckdb_malloc(GetCTypeSize(out->columns[i].type) * out->row_count);
-		if (!out->columns[i].nullmask || !out->columns[i].name || !out->columns[i].data) { // LCOV_EXCL_START
+	memset(out->__deprecated_columns, 0, sizeof(duckdb_column) * out->__deprecated_column_count);
+	for (idx_t i = 0; i < out->__deprecated_column_count; i++) {
+		out->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result->types[i]);
+		out->__deprecated_columns[i].__deprecated_name = strdup(result->names[i].c_str());
+		out->__deprecated_columns[i].__deprecated_nullmask =
+		    (bool *)duckdb_malloc(sizeof(bool) * out->__deprecated_row_count);
+		out->__deprecated_columns[i].__deprecated_data =
+		    duckdb_malloc(GetCTypeSize(out->__deprecated_columns[i].__deprecated_type) * out->__deprecated_row_count);
+		if (!out->__deprecated_columns[i].__deprecated_nullmask || !out->__deprecated_columns[i].__deprecated_name ||
+		    !out->__deprecated_columns[i].__deprecated_data) { // LCOV_EXCL_START
 			// malloc failure
 			return DuckDBError;
 		} // LCOV_EXCL_STOP
 	}
 	// now write the data
-	for (idx_t col = 0; col < out->column_count; col++) {
+	for (idx_t col = 0; col < out->__deprecated_column_count; col++) {
 		// first set the nullmask
 		idx_t row = 0;
 		for (auto &chunk : result->collection.Chunks()) {
 			for (idx_t k = 0; k < chunk->size(); k++) {
-				out->columns[col].nullmask[row++] = FlatVector::IsNull(chunk->data[col], k);
+				out->__deprecated_columns[col].__deprecated_nullmask[row++] = FlatVector::IsNull(chunk->data[col], k);
 			}
 		}
 		// then write the data
@@ -97008,7 +97284,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			break;
 		case LogicalTypeId::VARCHAR: {
 			idx_t row = 0;
-			auto target = (const char **)out->columns[col].data;
+			auto target = (const char **)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<string_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97028,7 +97304,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		}
 		case LogicalTypeId::BLOB: {
 			idx_t row = 0;
-			auto target = (duckdb_blob *)out->columns[col].data;
+			auto target = (duckdb_blob *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<string_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97050,7 +97326,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_SEC: {
 			idx_t row = 0;
-			auto target = (timestamp_t *)out->columns[col].data;
+			auto target = (timestamp_t *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<timestamp_t>(chunk->data[col]);
 
@@ -97072,7 +97348,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		}
 		case LogicalTypeId::HUGEINT: {
 			idx_t row = 0;
-			auto target = (duckdb_hugeint *)out->columns[col].data;
+			auto target = (duckdb_hugeint *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97087,7 +97363,7 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 		}
 		case LogicalTypeId::INTERVAL: {
 			idx_t row = 0;
-			auto target = (duckdb_interval *)out->columns[col].data;
+			auto target = (duckdb_interval *)out->__deprecated_columns[col].__deprecated_data;
 			for (auto &chunk : result->collection.Chunks()) {
 				auto source = FlatVector::GetData<interval_t>(chunk->data[col]);
 				for (idx_t k = 0; k < chunk->size(); k++) {
@@ -97113,101 +97389,101 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 } // namespace duckdb
 
 static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
-	if (column.data) {
-		if (column.type == DUCKDB_TYPE_VARCHAR) {
+	if (column.__deprecated_data) {
+		if (column.__deprecated_type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
-			auto data = (char **)column.data;
+			auto data = (char **)column.__deprecated_data;
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i]) {
 					duckdb_free(data[i]);
 				}
 			}
-		} else if (column.type == DUCKDB_TYPE_BLOB) {
+		} else if (column.__deprecated_type == DUCKDB_TYPE_BLOB) {
 			// blob, delete individual blobs
-			auto data = (duckdb_blob *)column.data;
+			auto data = (duckdb_blob *)column.__deprecated_data;
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i].data) {
 					duckdb_free((void *)data[i].data);
 				}
 			}
 		}
-		duckdb_free(column.data);
+		duckdb_free(column.__deprecated_data);
 	}
-	if (column.nullmask) {
-		duckdb_free(column.nullmask);
+	if (column.__deprecated_nullmask) {
+		duckdb_free(column.__deprecated_nullmask);
 	}
-	if (column.name) {
-		duckdb_free(column.name);
+	if (column.__deprecated_name) {
+		duckdb_free(column.__deprecated_name);
 	}
 }
 
 void duckdb_destroy_result(duckdb_result *result) {
-	if (result->error_message) {
-		duckdb_free(result->error_message);
+	if (result->__deprecated_error_message) {
+		duckdb_free(result->__deprecated_error_message);
 	}
-	if (result->columns) {
-		for (idx_t i = 0; i < result->column_count; i++) {
-			DuckdbDestroyColumn(result->columns[i], result->row_count);
+	if (result->__deprecated_columns) {
+		for (idx_t i = 0; i < result->__deprecated_column_count; i++) {
+			DuckdbDestroyColumn(result->__deprecated_columns[i], result->__deprecated_row_count);
 		}
-		duckdb_free(result->columns);
+		duckdb_free(result->__deprecated_columns);
 	}
 	memset(result, 0, sizeof(duckdb_result));
 }
 
 const char *duckdb_column_name(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	return result->columns[col].name;
+	return result->__deprecated_columns[col].__deprecated_name;
 }
 
 duckdb_type duckdb_column_type(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	return result->columns[col].type;
+	return result->__deprecated_columns[col].__deprecated_type;
 }
 
 idx_t duckdb_column_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	return result->column_count;
+	return result->__deprecated_column_count;
 }
 
 idx_t duckdb_row_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	return result->row_count;
+	return result->__deprecated_row_count;
 }
 
 idx_t duckdb_rows_changed(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	return result->rows_changed;
+	return result->__deprecated_rows_changed;
 }
 
 void *duckdb_column_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	return result->columns[col].data;
+	return result->__deprecated_columns[col].__deprecated_data;
 }
 
 bool *duckdb_nullmask_data(duckdb_result *result, idx_t col) {
-	if (!result || col >= result->column_count) {
+	if (!result || col >= result->__deprecated_column_count) {
 		return nullptr;
 	}
-	return result->columns[col].nullmask;
+	return result->__deprecated_columns[col].__deprecated_nullmask;
 }
 
 char *duckdb_result_error(duckdb_result *result) {
 	if (!result) {
 		return nullptr;
 	}
-	return result->error_message;
+	return result->__deprecated_error_message;
 }
 
 
@@ -97238,8 +97514,8 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 template <class T>
 T UnsafeFetch(duckdb_result *result, idx_t col, idx_t row) {
-	D_ASSERT(row < result->row_count);
-	return ((T *)result->columns[col].data)[row];
+	D_ASSERT(row < result->__deprecated_row_count);
+	return ((T *)result->__deprecated_columns[col].__deprecated_data)[row];
 }
 
 //===--------------------------------------------------------------------===//
@@ -97360,10 +97636,10 @@ RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
 }
 
 static bool CanFetchValue(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result || col >= result->column_count || row >= result->row_count) {
+	if (!result || col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
 		return false;
 	}
-	if (result->columns[col].nullmask[row]) {
+	if (result->__deprecated_columns[col].__deprecated_nullmask[row]) {
 		return false;
 	}
 	return true;
@@ -97374,7 +97650,7 @@ static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row
 	if (!CanFetchValue(result, col, row)) {
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	}
-	switch (result->columns[col].type) {
+	switch (result->__deprecated_columns[col].__deprecated_type) {
 	case DUCKDB_TYPE_BOOLEAN:
 		return TryCastCInternal<bool, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_TINYINT:
@@ -97515,7 +97791,7 @@ char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row)
 }
 
 duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
-	if (CanFetchValue(result, col, row) && result->columns[col].type == DUCKDB_TYPE_BLOB) {
+	if (CanFetchValue(result, col, row) && result->__deprecated_columns[col].__deprecated_type == DUCKDB_TYPE_BLOB) {
 		auto internal_result = UnsafeFetch<duckdb_blob>(result, col, row);
 
 		duckdb_blob result_blob;
@@ -97528,10 +97804,10 @@ duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row) {
 }
 
 bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
-	if (!result || col >= result->column_count || row >= result->row_count) {
+	if (!result || col >= result->__deprecated_column_count || row >= result->__deprecated_row_count) {
 		return false;
 	}
-	return result->columns[col].nullmask[row];
+	return result->__deprecated_columns[col].__deprecated_nullmask[row];
 }
 
 //===----------------------------------------------------------------------===//