duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

package/src/duckdb/extension/core_functions/scalar/date/current.cpp

@@ -0,0 +1,29 @@
+#include "core_functions/scalar/date_functions.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/transaction/meta_transaction.hpp"
+
+namespace duckdb {
+
+static timestamp_t GetTransactionTimestamp(ExpressionState &state) {
+	return MetaTransaction::Get(state.GetContext()).start_timestamp;
+}
+
+static void CurrentTimestampFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 0);
+	auto ts = GetTransactionTimestamp(state);
+	auto val = Value::TIMESTAMPTZ(timestamp_tz_t(ts));
+	result.Reference(val);
+}
+
+ScalarFunction GetCurrentTimestampFun::GetFunction() {
+	ScalarFunction current_timestamp({}, LogicalType::TIMESTAMP_TZ, CurrentTimestampFunction);
+	current_timestamp.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
+	return current_timestamp;
+}
+
+} // namespace duckdb

package/src/duckdb/{src → extension}/core_functions/scalar/date/date_diff.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/subtract.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/date/date_part.cpp

@@ -1,18 +1,19 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/types/date.hpp"
+#include "duckdb/common/types/date_lookup_cache.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/common/types/date_lookup_cache.hpp"
 
 namespace duckdb {
 
@@ -400,7 +401,7 @@ struct DatePart {
 	struct EpochMillisOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			return Timestamp::GetEpochMs(input);
+			return Cast::Operation<TA, TR>(input);
 		}
 
 		template <class T>
@@ -1062,7 +1063,7 @@ int64_t DatePart::EpochMicrosecondsOperator::Operation(interval_t input) {
 template <>
 int64_t DatePart::EpochMillisOperator::Operation(timestamp_t input) {
 	D_ASSERT(Timestamp::IsFinite(input));
-	return Timestamp::GetEpochMs(input);
+	return Cast::Operation<timestamp_t, timestamp_ms_t>(input).value;
 }
 
 template <>
@@ -1704,6 +1705,9 @@ ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar
 	operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr,
 	                                        nullptr, ts_stats, DATE_CACHE));
 	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
+	for (auto &func : operator_set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return operator_set;
 }
 
@@ -2018,7 +2022,11 @@ ScalarFunctionSet QuarterFun::GetFunctions() {
 }
 
 ScalarFunctionSet DayOfWeekFun::GetFunctions() {
-	return GetDatePartFunction<DatePart::DayOfWeekOperator>();
+	auto set = GetDatePartFunction<DatePart::DayOfWeekOperator>();
+	for (auto &func : set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
+	return set;
 }
 
 ScalarFunctionSet ISODayOfWeekFun::GetFunctions() {
@@ -2045,9 +2053,14 @@ ScalarFunctionSet TimezoneFun::GetFunctions() {
 	auto operator_set = GetDatePartFunction<DatePart::TimezoneOperator>();
 
 	//	PG also defines timezone(INTERVAL, TIME_TZ) => TIME_TZ
-	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
-	                   DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>));
+	ScalarFunction function({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ,
+	                        DatePart::TimezoneOperator::BinaryFunction<interval_t, dtime_tz_t, dtime_tz_t>);
+
+	operator_set.AddFunction(function);
+
+	for (auto &func : operator_set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 
 	return operator_set;
 }
@@ -2064,6 +2077,19 @@ ScalarFunctionSet EpochFun::GetFunctions() {
 	return GetTimePartFunction<DatePart::EpochOperator, double>(LogicalType::DOUBLE);
 }
 
+struct GetEpochNanosOperator {
+	static int64_t Operation(timestamp_ns_t timestamp) {
+		return Timestamp::GetEpochNanoSeconds(timestamp);
+	}
+};
+
+static void ExecuteGetNanosFromTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 1);
+
+	auto func = GetEpochNanosOperator::Operation;
+	UnaryExecutor::Execute<timestamp_ns_t, int64_t>(input.data[0], result, input.size(), func);
+}
+
 ScalarFunctionSet EpochNsFun::GetFunctions() {
 	using OP = DatePart::EpochNanosecondsOperator;
 	auto operator_set = GetTimePartFunction<OP>();
@@ -2073,6 +2099,9 @@ ScalarFunctionSet EpochNsFun::GetFunctions() {
 	auto tstz_stats = OP::template PropagateStatistics<timestamp_t>;
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BIGINT, tstz_func, nullptr, nullptr, tstz_stats));
+
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::TIMESTAMP_NS}, LogicalType::BIGINT, ExecuteGetNanosFromTimestampNs));
 	return operator_set;
 }
 
@@ -2224,6 +2253,10 @@ ScalarFunctionSet DatePartFun::GetFunctions() {
 	date_part.AddFunction(StructDatePart::GetFunction<interval_t>(LogicalType::INTERVAL));
 	date_part.AddFunction(StructDatePart::GetFunction<dtime_tz_t>(LogicalType::TIME_TZ));
 
+	for (auto &func : date_part.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
+
 	return date_part;
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/date/date_sub.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/subtract.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/date/date_trunc.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/enums/date_part_specifier.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -728,6 +728,9 @@ ScalarFunctionSet DateTruncFun::GetFunctions() {
 	                                      DateTruncFunction<date_t, timestamp_t>, DateTruncBind));
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
 	                                      DateTruncFunction<interval_t, interval_t>));
+	for (auto &func : date_trunc.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return date_trunc;
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/date/epoch.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
@@ -11,7 +11,7 @@ struct EpochSecOperator {
 	static RESULT_TYPE Operation(INPUT_TYPE sec) {
 		int64_t result;
 		if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) {
-			throw ConversionException("Could not convert epoch seconds to TIMESTAMP WITH TIME ZONE");
+			throw ConversionException("Epoch seconds out of range for TIMESTAMP WITH TIME ZONE");
 		}
 		return timestamp_t(result);
 	}
@@ -28,6 +28,23 @@ ScalarFunction ToTimestampFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
 }
 
+struct NormalizedIntervalOperator {
+	template <typename INPUT_TYPE, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input) {
+		return input.Normalize();
+	}
+};
+
+static void NormalizedIntervalFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 1);
+
+	UnaryExecutor::Execute<interval_t, interval_t, NormalizedIntervalOperator>(input.data[0], result, input.size());
+}
+
+ScalarFunction NormalizedIntervalFun::GetFunction() {
+	return ScalarFunction({LogicalType::INTERVAL}, LogicalType::INTERVAL, NormalizedIntervalFunction);
+}
+
 struct TimeTZSortKeyOperator {
 	template <typename INPUT_TYPE, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(INPUT_TYPE input) {
@@ -44,5 +61,4 @@ static void TimeTZSortKeyFunction(DataChunk &input, ExpressionState &state, Vect
 ScalarFunction TimeTZSortKeyFun::GetFunction() {
 	return ScalarFunction({LogicalType::TIME_TZ}, LogicalType::UBIGINT, TimeTZSortKeyFunction);
 }
-
 } // namespace duckdb

package/src/duckdb/{src → extension}/core_functions/scalar/date/make_date.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
@@ -11,6 +11,11 @@
 
 namespace duckdb {
 
+static void MakeDateFromEpoch(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 1);
+	result.Reinterpret(input.data[0]);
+}
+
 struct MakeDateOperator {
 	template <typename YYYY, typename MM, typename DD, typename RESULT_TYPE>
 	static RESULT_TYPE Operation(YYYY yyyy, MM mm, DD dd) {
@@ -97,8 +102,12 @@ struct MakeTimestampOperator {
 	}
 
 	template <typename T, typename RESULT_TYPE>
-	static RESULT_TYPE Operation(T micros) {
-		return timestamp_t(micros);
+	static RESULT_TYPE Operation(T value) {
+		const auto result = RESULT_TYPE(value);
+		if (!Timestamp::IsFinite(result)) {
+			throw ConversionException("Timestamp microseconds out of range: %ld", value);
+		}
+		return RESULT_TYPE(value);
 	}
 };
 
@@ -116,8 +125,18 @@ static void ExecuteMakeTimestamp(DataChunk &input, ExpressionState &state, Vecto
 	SenaryExecutor::Execute<T, T, T, T, T, double, timestamp_t>(input, result, func);
 }
 
+template <typename T>
+static void ExecuteMakeTimestampNs(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 1);
+
+	auto func = MakeTimestampOperator::Operation<T, timestamp_ns_t>;
+	UnaryExecutor::Execute<T, timestamp_ns_t>(input.data[0], result, input.size(), func);
+	return;
+}
+
 ScalarFunctionSet MakeDateFun::GetFunctions() {
 	ScalarFunctionSet make_date("make_date");
+	make_date.AddFunction(ScalarFunction({LogicalType::INTEGER}, LogicalType::DATE, MakeDateFromEpoch));
 	make_date.AddFunction(ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
 	                                     LogicalType::DATE, ExecuteMakeDate<int64_t>));
 
@@ -125,12 +144,17 @@ ScalarFunctionSet MakeDateFun::GetFunctions() {
 	    {"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}};
 	make_date.AddFunction(
 	    ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate<int64_t>));
+	for (auto &func : make_date.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return make_date;
 }
 
 ScalarFunction MakeTimeFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
-	                      ExecuteMakeTime<int64_t>);
+	ScalarFunction function({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME,
+	                        ExecuteMakeTime<int64_t>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunctionSet MakeTimestampFun::GetFunctions() {
@@ -140,6 +164,17 @@ ScalarFunctionSet MakeTimestampFun::GetFunctions() {
 	                                        LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
 	operator_set.AddFunction(
 	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, ExecuteMakeTimestamp<int64_t>));
+
+	for (auto &func : operator_set.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
+	return operator_set;
+}
+
+ScalarFunctionSet MakeTimestampNsFun::GetFunctions() {
+	ScalarFunctionSet operator_set("make_timestamp_ns");
+	operator_set.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP_NS, ExecuteMakeTimestampNs<int64_t>));
 	return operator_set;
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/date/time_bucket.cpp

@@ -9,7 +9,7 @@
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 
 namespace duckdb {
 
@@ -364,6 +364,9 @@ ScalarFunctionSet TimeBucketFun::GetFunctions() {
 	                                       LogicalType::DATE, TimeBucketOriginFunction<date_t>));
 	time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP},
 	                                       LogicalType::TIMESTAMP, TimeBucketOriginFunction<timestamp_t>));
+	for (auto &func : time_bucket.functions) {
+		BaseScalarFunction::SetReturnsError(func);
+	}
 	return time_bucket;
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/date/to_interval.cpp

@@ -1,8 +1,8 @@
-#include "duckdb/core_functions/scalar/date_functions.hpp"
+#include "core_functions/scalar/date_functions.hpp"
 #include "duckdb/common/types/interval.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/core_functions/to_interval.hpp"
+#include "duckdb/function/to_interval.hpp"
 
 namespace duckdb {
 
@@ -165,68 +165,94 @@ struct ToMicroSecondsOperator {
 };
 
 ScalarFunction ToMillenniaFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToMillenniaOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToCenturiesFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToCenturiesOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToDecadesFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToDecadesOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToYearsFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToQuartersFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMonthsFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToWeeksFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToWeeksOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToDaysFun::GetFunction() {
-	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
+	ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int32_t, interval_t, ToDaysOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToHoursFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
+	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToHoursOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMinutesFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
+	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToMinutesOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToSecondsFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
+	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<double, interval_t, ToSecondsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMillisecondsFun::GetFunction() {
-	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
+	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<double, interval_t, ToMilliSecondsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 ScalarFunction ToMicrosecondsFun::GetFunction() {
-	return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                      ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
+	ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                        ScalarFunction::UnaryFunction<int64_t, interval_t, ToMicroSecondsOperator>);
+	BaseScalarFunction::SetReturnsError(function);
+	return function;
 }
 
 } // namespace duckdb

package/src/duckdb/{src → extension}/core_functions/scalar/debug/vector_type.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/debug_functions.hpp"
+#include "core_functions/scalar/debug_functions.hpp"
 
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/enum/enum_functions.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/enum_functions.hpp"
+#include "core_functions/scalar/enum_functions.hpp"
 
 namespace duckdb {
 
@@ -56,12 +56,7 @@ static void EnumRangeBoundaryFunction(DataChunk &input, ExpressionState &state,
 	for (idx_t i = start; i < end; i++) {
 		enum_values.emplace_back(enum_vector.GetValue(i));
 	}
-	Value val;
-	if (enum_values.empty()) {
-		val = Value::EMPTYLIST(LogicalType::VARCHAR);
-	} else {
-		val = Value::LIST(enum_values);
-	}
+	auto val = Value::LIST(LogicalType::VARCHAR, enum_values);
 	result.Reference(val);
 }
 

package/src/duckdb/{src → extension}/core_functions/scalar/generic/alias.cpp

@@ -1,11 +1,11 @@
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "core_functions/scalar/generic_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
 
 static void AliasFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-	Value v(state.expr.alias.empty() ? func_expr.children[0]->GetName() : state.expr.alias);
+	Value v(state.expr.GetAlias().empty() ? func_expr.children[0]->GetName() : state.expr.GetAlias());
 	result.Reference(v);
 }
 

package/src/duckdb/{src/function → extension/core_functions}/scalar/generic/binning.cpp

@@ -1,12 +1,12 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/operator/subtract.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/generic_executor.hpp"
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/serializer/deserializer.hpp"
+#include "core_functions/scalar/generic_functions.hpp"
 
 namespace duckdb {
 
@@ -500,6 +500,7 @@ ScalarFunctionSet EquiWidthBinsFun::GetFunctions() {
 	for (auto &function : functions.functions) {
 		function.serialize = EquiWidthBinSerialize;
 		function.deserialize = EquiWidthBinDeserialize;
+		BaseScalarFunction::SetReturnsError(function);
 	}
 	return functions;
 }

package/src/duckdb/{src → extension}/core_functions/scalar/generic/can_implicitly_cast.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "core_functions/scalar/generic_functions.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/generic/current_setting.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "core_functions/scalar/generic_functions.hpp"
 
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/client_context.hpp"

package/src/duckdb/{src → extension}/core_functions/scalar/generic/hash.cpp

@@ -1,4 +1,4 @@
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "core_functions/scalar/generic_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/{src → extension}/core_functions/scalar/generic/least.cpp

@@ -1,10 +1,26 @@
 #include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
-#include "duckdb/core_functions/create_sort_key.hpp"
+#include "core_functions/scalar/generic_functions.hpp"
+#include "duckdb/function/create_sort_key.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 
 namespace duckdb {
 
+struct LeastOp {
+	using OP = LessThan;
+
+	static OrderByNullType NullOrdering() {
+		return OrderByNullType::NULLS_LAST;
+	}
+};
+
+struct GreaterOp {
+	using OP = GreaterThan;
+
+	static OrderByNullType NullOrdering() {
+		return OrderByNullType::NULLS_FIRST;
+	}
+};
+
 template <class OP>
 struct LeastOperator {
 	template <class T>
@@ -14,8 +30,8 @@ struct LeastOperator {
 };
 
 struct LeastGreatestSortKeyState : public FunctionLocalState {
-	explicit LeastGreatestSortKeyState(idx_t column_count)
-	    : intermediate(LogicalType::BLOB), modifiers(OrderType::ASCENDING, OrderByNullType::NULLS_LAST) {
+	explicit LeastGreatestSortKeyState(idx_t column_count, OrderByNullType null_ordering)
+	    : intermediate(LogicalType::BLOB), modifiers(OrderType::ASCENDING, null_ordering) {
 		vector<LogicalType> types;
 		// initialize sort key chunk
 		for (idx_t i = 0; i < column_count; i++) {
@@ -29,9 +45,10 @@ struct LeastGreatestSortKeyState : public FunctionLocalState {
 	OrderModifiers modifiers;
 };
 
+template <class OP>
 unique_ptr<FunctionLocalState> LeastGreatestSortKeyInit(ExpressionState &state, const BoundFunctionExpression &expr,
                                                         FunctionData *bind_data) {
-	return make_uniq<LeastGreatestSortKeyState>(expr.children.size());
+	return make_uniq<LeastGreatestSortKeyState>(expr.children.size(), OP::NullOrdering());
 }
 
 template <bool STRING>
@@ -155,14 +172,14 @@ static void LeastGreatestFunction(DataChunk &args, ExpressionState &state, Vecto
 	result.SetVectorType(result_type);
 }
 
-template <class OP>
+template <class LEAST_GREATER_OP>
 unique_ptr<FunctionData> BindLeastGreatest(ClientContext &context, ScalarFunction &bound_function,
                                            vector<unique_ptr<Expression>> &arguments) {
 	LogicalType child_type = ExpressionBinder::GetExpressionReturnType(*arguments[0]);
 	for (idx_t i = 1; i < arguments.size(); i++) {
 		auto arg_type = ExpressionBinder::GetExpressionReturnType(*arguments[i]);
 		if (!LogicalType::TryGetMaxLogicalType(context, child_type, arg_type, child_type)) {
-			throw BinderException(arguments[i]->query_location,
+			throw BinderException(arguments[i]->GetQueryLocation(),
 			                      "Cannot combine types of %s and %s - an explicit cast is required",
 			                      child_type.ToString(), arg_type.ToString());
 		}
@@ -179,7 +196,9 @@ unique_ptr<FunctionData> BindLeastGreatest(ClientContext &context, ScalarFunctio
 	default:
 		break;
 	}
+	using OP = typename LEAST_GREATER_OP::OP;
 	switch (child_type.InternalType()) {
+#ifndef DUCKDB_SMALLER_BINARY
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
 		bound_function.function = LeastGreatestFunction<int8_t, OP>;
@@ -202,10 +221,11 @@ unique_ptr<FunctionData> BindLeastGreatest(ClientContext &context, ScalarFunctio
 	case PhysicalType::VARCHAR:
 		bound_function.function = LeastGreatestFunction<string_t, OP, StandardLeastGreatest<true>>;
 		break;
+#endif
 	default:
 		// fallback with sort keys
 		bound_function.function = LeastGreatestFunction<string_t, OP, SortKeyLeastGreatest>;
-		bound_function.init_local_state = LeastGreatestSortKeyInit;
+		bound_function.init_local_state = LeastGreatestSortKeyInit<LEAST_GREATER_OP>;
 		break;
 	}
 	bound_function.arguments[0] = child_type;
@@ -229,11 +249,11 @@ static ScalarFunctionSet GetLeastGreatestFunctions() {
 }
 
 ScalarFunctionSet LeastFun::GetFunctions() {
-	return GetLeastGreatestFunctions<LessThan>();
+	return GetLeastGreatestFunctions<LeastOp>();
 }
 
 ScalarFunctionSet GreatestFun::GetFunctions() {
-	return GetLeastGreatestFunctions<GreaterThan>();
+	return GetLeastGreatestFunctions<GreaterOp>();
 }
 
 } // namespace duckdb