duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/extension/core_functions/scalar/math/numeric.cpp

@@ -1,10 +1,16 @@
 #include "duckdb/common/operator/decimal_cast_operators.hpp"
+#include "duckdb/common/vector_operations/vector_operations.hpp"
+#include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/likely.hpp"
 #include "duckdb/common/operator/abs.hpp"
 #include "duckdb/common/operator/multiply.hpp"
+#include "duckdb/common/operator/numeric_binary_operators.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/types/uhugeint.hpp"
+#include "duckdb/common/types/validity_mask.hpp"
+#include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/vector_operations/unary_executor.hpp"
 #include "core_functions/scalar/math_functions.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -12,6 +18,9 @@
 
 #include <cmath>
 #include <cstdint>
+#include <errno.h>
+#include <limits>
+#include <type_traits>
 
 namespace duckdb {
 
@@ -43,9 +52,6 @@ static scalar_function_t GetScalarIntegerUnaryFunctionFixedReturn(const LogicalT
 //===--------------------------------------------------------------------===//
 // nextafter
 //===--------------------------------------------------------------------===//
-
-namespace {
-
 struct NextAfterOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA base, TB exponent) {
@@ -62,8 +68,6 @@ struct NextAfterOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunctionSet NextAfterFun::GetFunctions() {
 	ScalarFunctionSet next_after_fun;
 	next_after_fun.AddFunction(
@@ -200,9 +204,6 @@ ScalarFunctionSet AbsOperatorFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // bit_count
 //===--------------------------------------------------------------------===//
-
-namespace {
-
 struct BitCntOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -235,11 +236,10 @@ struct BitStringBitCntOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		TR count = Bit::BitCount(input);
-		return UnsafeNumericCast<TR>(count);
+		return count;
 	}
 };
 
-} // namespace
 ScalarFunctionSet BitCountFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	functions.AddFunction(ScalarFunction({LogicalType::TINYINT}, LogicalType::TINYINT,
@@ -253,15 +253,13 @@ ScalarFunctionSet BitCountFun::GetFunctions() {
 	functions.AddFunction(ScalarFunction({LogicalType::HUGEINT}, LogicalType::TINYINT,
 	                                     ScalarFunction::UnaryFunction<hugeint_t, int8_t, HugeIntBitCntOperator>));
 	functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIGINT,
-	                                     ScalarFunction::UnaryFunction<string_t, int64_t, BitStringBitCntOperator>));
+	                                     ScalarFunction::UnaryFunction<string_t, idx_t, BitStringBitCntOperator>));
 	return functions;
 }
 
 //===--------------------------------------------------------------------===//
 // sign
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct SignOperator {
 	template <class TA, class TR>
 	static TR Operation(TA input) {
@@ -297,7 +295,6 @@ int8_t SignOperator::Operation(double input) {
 	}
 }
 
-} // namespace
 ScalarFunctionSet SignFun::GetFunctions() {
 	ScalarFunctionSet sign;
 	for (auto &type : LogicalType::Numeric()) {
@@ -315,14 +312,12 @@ ScalarFunctionSet SignFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // ceil
 //===--------------------------------------------------------------------===//
-namespace {
 struct CeilOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
 		return std::ceil(left);
 	}
 };
-} // namespace
 
 template <class T, class POWERS_OF_TEN, class OP>
 static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state, Vector &result) {
@@ -331,8 +326,8 @@ static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state
 }
 
 template <class OP>
-static unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context, ScalarFunction &bound_function,
-                                                                vector<unique_ptr<Expression>> &arguments) {
+unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context, ScalarFunction &bound_function,
+                                                         vector<unique_ptr<Expression>> &arguments) {
 	// ceil essentially removes the scale
 	auto &decimal_type = arguments[0]->return_type;
 	auto scale = DecimalType::GetScale(decimal_type);
@@ -360,7 +355,6 @@ static unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &c
 	return nullptr;
 }
 
-namespace {
 struct CeilDecimalOperator {
 	template <class T, class POWERS_OF_TEN_CLASS>
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
@@ -376,7 +370,6 @@ struct CeilDecimalOperator {
 		});
 	}
 };
-} // namespace
 
 ScalarFunctionSet CeilFun::GetFunctions() {
 	ScalarFunctionSet ceil;
@@ -408,7 +401,6 @@ ScalarFunctionSet CeilFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // floor
 //===--------------------------------------------------------------------===//
-namespace {
 struct FloorOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -431,7 +423,6 @@ struct FloorDecimalOperator {
 		});
 	}
 };
-} // namespace
 
 ScalarFunctionSet FloorFun::GetFunctions() {
 	ScalarFunctionSet floor;
@@ -463,118 +454,6 @@ ScalarFunctionSet FloorFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // trunc
 //===--------------------------------------------------------------------===//
-namespace {
-
-struct RoundPrecisionFunctionData : public FunctionData {
-	explicit RoundPrecisionFunctionData(int32_t target_scale) : target_scale(target_scale) {
-	}
-
-	int32_t target_scale;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<RoundPrecisionFunctionData>(target_scale);
-	}
-
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<RoundPrecisionFunctionData>();
-		return target_scale == other.target_scale;
-	}
-};
-
-template <class T, class POWERS_OF_TEN, class OP>
-static void GenericRoundPrecisionDecimal(DataChunk &input, ExpressionState &state, Vector &result) {
-	OP::template Operation<T, POWERS_OF_TEN>(input, state, result);
-}
-
-template <typename NEGOP, typename POSOP>
-static unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, ScalarFunction &bound_function,
-                                                          vector<unique_ptr<Expression>> &arguments) {
-	auto &decimal_type = arguments[0]->return_type;
-	if (arguments[1]->HasParameter()) {
-		throw ParameterNotResolvedException();
-	}
-	auto fname = StringUtil::Upper(bound_function.name);
-	if (!arguments[1]->IsFoldable()) {
-		throw NotImplementedException("%s(DECIMAL, INTEGER) with non-constant precision is not supported", fname);
-	}
-	Value val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]).DefaultCastAs(LogicalType::INTEGER);
-	if (val.IsNull()) {
-		throw NotImplementedException("%s(DECIMAL, INTEGER) with non-constant precision is not supported", fname);
-	}
-	// our new precision becomes the round value
-	// e.g. ROUND(DECIMAL(18,3), 1) -> DECIMAL(18,1)
-	// but ONLY if the round value is positive
-	// if it is negative the scale becomes zero
-	// i.e. ROUND(DECIMAL(18,3), -1) -> DECIMAL(18,0)
-	int32_t round_value = IntegerValue::Get(val);
-	uint8_t target_scale;
-	auto width = DecimalType::GetWidth(decimal_type);
-	auto scale = DecimalType::GetScale(decimal_type);
-	if (round_value < 0) {
-		target_scale = 0;
-		switch (decimal_type.InternalType()) {
-		case PhysicalType::INT16:
-			bound_function.function = GenericRoundPrecisionDecimal<int16_t, NumericHelper, NEGOP>;
-			break;
-		case PhysicalType::INT32:
-			bound_function.function = GenericRoundPrecisionDecimal<int32_t, NumericHelper, NEGOP>;
-			break;
-		case PhysicalType::INT64:
-			bound_function.function = GenericRoundPrecisionDecimal<int64_t, NumericHelper, NEGOP>;
-			break;
-		default:
-			bound_function.function = GenericRoundPrecisionDecimal<hugeint_t, Hugeint, NEGOP>;
-			break;
-		}
-	} else {
-		if (round_value >= (int32_t)scale) {
-			// if round_value is bigger than or equal to scale we do nothing
-			bound_function.function = ScalarFunction::NopFunction;
-			target_scale = scale;
-		} else {
-			target_scale = NumericCast<uint8_t>(round_value);
-			switch (decimal_type.InternalType()) {
-			case PhysicalType::INT16:
-				bound_function.function = GenericRoundPrecisionDecimal<int16_t, NumericHelper, POSOP>;
-				break;
-			case PhysicalType::INT32:
-				bound_function.function = GenericRoundPrecisionDecimal<int32_t, NumericHelper, POSOP>;
-				break;
-			case PhysicalType::INT64:
-				bound_function.function = GenericRoundPrecisionDecimal<int64_t, NumericHelper, POSOP>;
-				break;
-			default:
-				bound_function.function = GenericRoundPrecisionDecimal<hugeint_t, Hugeint, POSOP>;
-				break;
-			}
-		}
-	}
-	bound_function.arguments[0] = decimal_type;
-	bound_function.return_type = LogicalType::DECIMAL(width, target_scale);
-	return make_uniq<RoundPrecisionFunctionData>(round_value);
-}
-
-struct TruncOperatorPrecision {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB precision) {
-		double trunc_value;
-		if (precision < 0) {
-			double modifier = std::pow(10, -TA(precision));
-			trunc_value = (std::trunc(input / modifier)) * modifier;
-			if (std::isinf(trunc_value) || std::isnan(trunc_value)) {
-				return input;
-			}
-		} else {
-			double modifier = std::pow(10, TA(precision));
-			trunc_value = (std::trunc(input * modifier)) / modifier;
-			if (std::isinf(trunc_value) || std::isnan(trunc_value)) {
-				return input;
-			}
-		}
-		return LossyNumericCast<TR>(trunc_value);
-	}
-};
-
 struct TruncOperator {
 	// Integer truncation is a NOP
 	template <class TA, class TR>
@@ -594,134 +473,38 @@ struct TruncDecimalOperator {
 	}
 };
 
-struct TruncDecimalNegativePrecisionOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
-		auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-		auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-		if (info.target_scale <= -int32_t(width - source_scale)) {
-			// scale too big for width
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			result.SetValue(0, Value::INTEGER(0));
-			return;
-		}
-		T divide_power_of_ten =
-		    UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]);
-		T multiply_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]);
-
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			return UnsafeNumericCast<T>(input / divide_power_of_ten * multiply_power_of_ten);
-		});
-	}
-};
-
-struct TruncDecimalPositivePrecisionOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
-		auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]);
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(),
-		                             [&](T input) { return UnsafeNumericCast<T>(input / power_of_ten); });
-	}
-};
-
-struct TruncIntegerOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA input, TB precision) {
-		if (precision < 0) {
-			//	Do all the arithmetic at higher precision
-			using POWERS_OF_TEN_CLASS = typename DecimalCastTraits<TA>::POWERS_OF_TEN_CLASS;
-			if (precision <= -POWERS_OF_TEN_CLASS::CACHED_POWERS_OF_TEN) {
-				return 0;
-			}
-			const auto power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-precision];
-			auto result = input;
-			result /= power_of_ten;
-			if (result) {
-				return UnsafeNumericCast<TR>(result * power_of_ten);
-			} else {
-				return 0;
-			}
-		} else {
-			//	Truncating integers to higher precision is a NOP
-			return input;
-		}
-	}
-};
-
-} // namespace
-
 ScalarFunctionSet TruncFun::GetFunctions() {
 	ScalarFunctionSet trunc;
 	for (auto &type : LogicalType::Numeric()) {
-		scalar_function_t trunc_func = nullptr;
-		scalar_function_t trunc_prec_func = nullptr;
+		scalar_function_t func = nullptr;
 		bind_scalar_function_t bind_func = nullptr;
-		bind_scalar_function_t bind_prec_func = nullptr;
 		//	Truncation of integers gets generated by some tools (e.g., Tableau/JDBC:Postgres)
 		switch (type.id()) {
 		case LogicalTypeId::FLOAT:
-			trunc_func = ScalarFunction::UnaryFunction<float, float, TruncOperator>;
-			trunc_prec_func = ScalarFunction::BinaryFunction<float, int32_t, float, TruncOperatorPrecision>;
+			func = ScalarFunction::UnaryFunction<float, float, TruncOperator>;
 			break;
 		case LogicalTypeId::DOUBLE:
-			trunc_func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
-			trunc_prec_func = ScalarFunction::BinaryFunction<double, int32_t, double, TruncOperatorPrecision>;
+			func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
 			break;
 		case LogicalTypeId::DECIMAL:
 			bind_func = BindGenericRoundFunctionDecimal<TruncDecimalOperator>;
-			bind_prec_func =
-			    BindDecimalRoundPrecision<TruncDecimalNegativePrecisionOperator, TruncDecimalPositivePrecisionOperator>;
 			break;
 		case LogicalTypeId::TINYINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<int8_t, int32_t, int8_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::SMALLINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<int16_t, int32_t, int16_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::INTEGER:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<int32_t, int32_t, int32_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::BIGINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<int64_t, int32_t, int64_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::HUGEINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<hugeint_t, int32_t, hugeint_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::UTINYINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<uint8_t, int32_t, uint8_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::USMALLINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<uint16_t, int32_t, uint16_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::UINTEGER:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<uint32_t, int32_t, uint32_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::UBIGINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<uint64_t, int32_t, uint64_t, TruncIntegerOperator>;
-			break;
 		case LogicalTypeId::UHUGEINT:
-			trunc_func = ScalarFunction::NopFunction;
-			trunc_prec_func = ScalarFunction::BinaryFunction<uhugeint_t, int32_t, uhugeint_t, TruncIntegerOperator>;
+			func = ScalarFunction::NopFunction;
 			break;
 		default:
 			throw InternalException("Unimplemented numeric type for function \"trunc\"");
 		}
-		trunc.AddFunction(ScalarFunction({type}, type, trunc_func, bind_func));
-		trunc.AddFunction(ScalarFunction({type, LogicalType::INTEGER}, type, trunc_prec_func, bind_prec_func));
+		trunc.AddFunction(ScalarFunction({type}, type, func, bind_func));
 	}
 	return trunc;
 }
@@ -729,7 +512,6 @@ ScalarFunctionSet TruncFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // round
 //===--------------------------------------------------------------------===//
-namespace {
 struct RoundOperatorPrecision {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB precision) {
@@ -813,55 +595,130 @@ struct RoundIntegerOperator {
 	}
 };
 
-} // namespace
+struct RoundPrecisionFunctionData : public FunctionData {
+	explicit RoundPrecisionFunctionData(int32_t target_scale) : target_scale(target_scale) {
+	}
 
-struct DecimalRoundNegativePrecisionOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
-		auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-		auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
-		if (info.target_scale <= -int32_t(width - source_scale)) {
-			// scale too big for width
-			result.SetVectorType(VectorType::CONSTANT_VECTOR);
-			result.SetValue(0, Value::INTEGER(0));
-			return;
-		}
-		T divide_power_of_ten =
-		    UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]);
-		T multiply_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]);
-		T addition = divide_power_of_ten / 2;
+	int32_t target_scale;
 
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				input -= addition;
-			} else {
-				input += addition;
-			}
-			return UnsafeNumericCast<T>(input / divide_power_of_ten * multiply_power_of_ten);
-		});
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<RoundPrecisionFunctionData>(target_scale);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = other_p.Cast<RoundPrecisionFunctionData>();
+		return target_scale == other.target_scale;
 	}
 };
 
-struct DecimalRoundPositivePrecisionOperator {
-	template <class T, class POWERS_OF_TEN_CLASS>
-	static void Operation(DataChunk &input, ExpressionState &state, Vector &result) {
-		auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
-		auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
-		auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
-		T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]);
-		T addition = power_of_ten / 2;
-		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
-			if (input < 0) {
-				input -= addition;
-			} else {
-				input += addition;
+template <class T, class POWERS_OF_TEN_CLASS>
+static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
+	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
+	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
+	if (info.target_scale <= -int32_t(width - source_scale)) {
+		// scale too big for width
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		result.SetValue(0, Value::INTEGER(0));
+		return;
+	}
+	T divide_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale + source_scale]);
+	T multiply_power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[-info.target_scale]);
+	T addition = divide_power_of_ten / 2;
+
+	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
+		if (input < 0) {
+			input -= addition;
+		} else {
+			input += addition;
+		}
+		return UnsafeNumericCast<T>(input / divide_power_of_ten * multiply_power_of_ten);
+	});
+}
+
+template <class T, class POWERS_OF_TEN_CLASS>
+static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<RoundPrecisionFunctionData>();
+	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
+	T power_of_ten = UnsafeNumericCast<T>(POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale]);
+	T addition = power_of_ten / 2;
+	UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
+		if (input < 0) {
+			input -= addition;
+		} else {
+			input += addition;
+		}
+		return UnsafeNumericCast<T>(input / power_of_ten);
+	});
+}
+
+unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
+	auto &decimal_type = arguments[0]->return_type;
+	if (arguments[1]->HasParameter()) {
+		throw ParameterNotResolvedException();
+	}
+	if (!arguments[1]->IsFoldable()) {
+		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
+	}
+	Value val = ExpressionExecutor::EvaluateScalar(context, *arguments[1]).DefaultCastAs(LogicalType::INTEGER);
+	if (val.IsNull()) {
+		throw NotImplementedException("ROUND(DECIMAL, INTEGER) with non-constant precision is not supported");
+	}
+	// our new precision becomes the round value
+	// e.g. ROUND(DECIMAL(18,3), 1) -> DECIMAL(18,1)
+	// but ONLY if the round value is positive
+	// if it is negative the scale becomes zero
+	// i.e. ROUND(DECIMAL(18,3), -1) -> DECIMAL(18,0)
+	int32_t round_value = IntegerValue::Get(val);
+	uint8_t target_scale;
+	auto width = DecimalType::GetWidth(decimal_type);
+	auto scale = DecimalType::GetScale(decimal_type);
+	if (round_value < 0) {
+		target_scale = 0;
+		switch (decimal_type.InternalType()) {
+		case PhysicalType::INT16:
+			bound_function.function = DecimalRoundNegativePrecisionFunction<int16_t, NumericHelper>;
+			break;
+		case PhysicalType::INT32:
+			bound_function.function = DecimalRoundNegativePrecisionFunction<int32_t, NumericHelper>;
+			break;
+		case PhysicalType::INT64:
+			bound_function.function = DecimalRoundNegativePrecisionFunction<int64_t, NumericHelper>;
+			break;
+		default:
+			bound_function.function = DecimalRoundNegativePrecisionFunction<hugeint_t, Hugeint>;
+			break;
+		}
+	} else {
+		if (round_value >= (int32_t)scale) {
+			// if round_value is bigger than or equal to scale we do nothing
+			bound_function.function = ScalarFunction::NopFunction;
+			target_scale = scale;
+		} else {
+			target_scale = NumericCast<uint8_t>(round_value);
+			switch (decimal_type.InternalType()) {
+			case PhysicalType::INT16:
+				bound_function.function = DecimalRoundPositivePrecisionFunction<int16_t, NumericHelper>;
+				break;
+			case PhysicalType::INT32:
+				bound_function.function = DecimalRoundPositivePrecisionFunction<int32_t, NumericHelper>;
+				break;
+			case PhysicalType::INT64:
+				bound_function.function = DecimalRoundPositivePrecisionFunction<int64_t, NumericHelper>;
+				break;
+			default:
+				bound_function.function = DecimalRoundPositivePrecisionFunction<hugeint_t, Hugeint>;
+				break;
 			}
-			return UnsafeNumericCast<T>(input / power_of_ten);
-		});
+		}
 	}
-};
+	bound_function.arguments[0] = decimal_type;
+	bound_function.return_type = LogicalType::DECIMAL(width, target_scale);
+	return make_uniq<RoundPrecisionFunctionData>(round_value);
+}
 
 ScalarFunctionSet RoundFun::GetFunctions() {
 	ScalarFunctionSet round;
@@ -881,8 +738,7 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 			break;
 		case LogicalTypeId::DECIMAL:
 			bind_func = BindGenericRoundFunctionDecimal<RoundDecimalOperator>;
-			bind_prec_func =
-			    BindDecimalRoundPrecision<DecimalRoundNegativePrecisionOperator, DecimalRoundPositivePrecisionOperator>;
+			bind_prec_func = BindDecimalRoundPrecision;
 			break;
 		case LogicalTypeId::TINYINT:
 			round_func = ScalarFunction::NopFunction;
@@ -909,7 +765,7 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 				// no round for integral numbers
 				continue;
 			}
-			throw InternalException("Unimplemented numeric type for function \"round\"");
+			throw InternalException("Unimplemented numeric type for function \"floor\"");
 		}
 		round.AddFunction(ScalarFunction({type}, type, round_func, bind_func));
 		round.AddFunction(ScalarFunction({type, LogicalType::INTEGER}, type, round_prec_func, bind_prec_func));
@@ -920,8 +776,6 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // exp
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct ExpOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -929,8 +783,6 @@ struct ExpOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunction ExpFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                      ScalarFunction::UnaryFunction<double, double, ExpOperator>);
@@ -939,8 +791,6 @@ ScalarFunction ExpFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // pow
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct PowOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA base, TB exponent) {
@@ -948,7 +798,6 @@ struct PowOperator {
 	}
 };
 
-} // namespace
 ScalarFunction PowOperatorFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                      ScalarFunction::BinaryFunction<double, double, double, PowOperator>);
@@ -957,7 +806,6 @@ ScalarFunction PowOperatorFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // sqrt
 //===--------------------------------------------------------------------===//
-namespace {
 struct SqrtOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -967,7 +815,6 @@ struct SqrtOperator {
 		return std::sqrt(input);
 	}
 };
-} // namespace
 
 ScalarFunction SqrtFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -979,8 +826,6 @@ ScalarFunction SqrtFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cbrt
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct CbRtOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -988,8 +833,6 @@ struct CbRtOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunction CbrtFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                      ScalarFunction::UnaryFunction<double, double, CbRtOperator>);
@@ -998,7 +841,6 @@ ScalarFunction CbrtFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // ln
 //===--------------------------------------------------------------------===//
-namespace {
 
 struct LnOperator {
 	template <class TA, class TR>
@@ -1013,7 +855,6 @@ struct LnOperator {
 	}
 };
 
-} // namespace
 ScalarFunction LnFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, LnOperator>);
@@ -1024,8 +865,6 @@ ScalarFunction LnFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // log
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct Log10Operator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1039,8 +878,6 @@ struct Log10Operator {
 	}
 };
 
-} // namespace
-
 ScalarFunction Log10Fun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, Log10Operator>);
@@ -1051,8 +888,6 @@ ScalarFunction Log10Fun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // log with base
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct LogBaseOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA b, TB x) {
@@ -1064,8 +899,6 @@ struct LogBaseOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunctionSet LogFun::GetFunctions() {
 	ScalarFunctionSet funcs;
 	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1081,7 +914,6 @@ ScalarFunctionSet LogFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // log2
 //===--------------------------------------------------------------------===//
-namespace {
 struct Log2Operator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1094,7 +926,6 @@ struct Log2Operator {
 		return std::log2(input);
 	}
 };
-} // namespace
 
 ScalarFunction Log2Fun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1119,14 +950,12 @@ ScalarFunction PiFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // degrees
 //===--------------------------------------------------------------------===//
-namespace {
 struct DegreesOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
 		return left * (180 / PI);
 	}
 };
-} // namespace
 
 ScalarFunction DegreesFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1136,14 +965,12 @@ ScalarFunction DegreesFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // radians
 //===--------------------------------------------------------------------===//
-namespace {
 struct RadiansOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
 		return left * (PI / 180);
 	}
 };
-} // namespace
 
 ScalarFunction RadiansFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1153,14 +980,12 @@ ScalarFunction RadiansFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // isnan
 //===--------------------------------------------------------------------===//
-namespace {
 struct IsNanOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return Value::IsNan(input);
 	}
 };
-} // namespace
 
 ScalarFunctionSet IsNanFun::GetFunctions() {
 	ScalarFunctionSet funcs;
@@ -1174,14 +999,12 @@ ScalarFunctionSet IsNanFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // signbit
 //===--------------------------------------------------------------------===//
-namespace {
 struct SignBitOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return std::signbit(input);
 	}
 };
-} // namespace
 
 ScalarFunctionSet SignBitFun::GetFunctions() {
 	ScalarFunctionSet funcs;
@@ -1195,7 +1018,6 @@ ScalarFunctionSet SignBitFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // isinf
 //===--------------------------------------------------------------------===//
-namespace {
 struct IsInfiniteOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1213,8 +1035,6 @@ bool IsInfiniteOperator::Operation(timestamp_t input) {
 	return !Value::IsFinite(input);
 }
 
-} // namespace
-
 ScalarFunctionSet IsInfiniteFun::GetFunctions() {
 	ScalarFunctionSet funcs("isinf");
 	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
@@ -1233,8 +1053,6 @@ ScalarFunctionSet IsInfiniteFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // isfinite
 //===--------------------------------------------------------------------===//
-namespace {
-
 struct IsFiniteOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1242,8 +1060,6 @@ struct IsFiniteOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunctionSet IsFiniteFun::GetFunctions() {
 	ScalarFunctionSet funcs;
 	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
@@ -1262,7 +1078,6 @@ ScalarFunctionSet IsFiniteFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // sin
 //===--------------------------------------------------------------------===//
-namespace {
 template <class OP>
 struct NoInfiniteDoubleWrapper {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -1284,8 +1099,6 @@ struct SinOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunction SinFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<SinOperator>>);
@@ -1296,14 +1109,12 @@ ScalarFunction SinFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cos
 //===--------------------------------------------------------------------===//
-namespace {
 struct CosOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::cos(input);
 	}
 };
-} // namespace
 
 ScalarFunction CosFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1315,14 +1126,12 @@ ScalarFunction CosFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // tan
 //===--------------------------------------------------------------------===//
-namespace {
 struct TanOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::tan(input);
 	}
 };
-} // namespace
 
 ScalarFunction TanFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1334,7 +1143,6 @@ ScalarFunction TanFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // asin
 //===--------------------------------------------------------------------===//
-namespace {
 struct ASinOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1344,7 +1152,6 @@ struct ASinOperator {
 		return (double)std::asin(input);
 	}
 };
-} // namespace
 
 ScalarFunction AsinFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1356,14 +1163,12 @@ ScalarFunction AsinFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // atan
 //===--------------------------------------------------------------------===//
-namespace {
 struct ATanOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::atan(input);
 	}
 };
-} // namespace
 
 ScalarFunction AtanFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1373,14 +1178,12 @@ ScalarFunction AtanFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // atan2
 //===--------------------------------------------------------------------===//
-namespace {
 struct ATan2 {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA left, TB right) {
 		return (double)std::atan2(left, right);
 	}
 };
-} // namespace
 
 ScalarFunction Atan2Fun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1390,7 +1193,6 @@ ScalarFunction Atan2Fun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // acos
 //===--------------------------------------------------------------------===//
-namespace {
 struct ACos {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1400,7 +1202,6 @@ struct ACos {
 		return (double)std::acos(input);
 	}
 };
-} // namespace
 
 ScalarFunction AcosFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1412,14 +1213,12 @@ ScalarFunction AcosFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cosh
 //===--------------------------------------------------------------------===//
-namespace {
 struct CoshOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::cosh(input);
 	}
 };
-} // namespace
 
 ScalarFunction CoshFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1429,14 +1228,12 @@ ScalarFunction CoshFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // acosh
 //===--------------------------------------------------------------------===//
-namespace {
 struct AcoshOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::acosh(input);
 	}
 };
-} // namespace
 
 ScalarFunction AcoshFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1446,14 +1243,12 @@ ScalarFunction AcoshFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // sinh
 //===--------------------------------------------------------------------===//
-namespace {
 struct SinhOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::sinh(input);
 	}
 };
-} // namespace
 
 ScalarFunction SinhFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1463,14 +1258,12 @@ ScalarFunction SinhFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // asinh
 //===--------------------------------------------------------------------===//
-namespace {
 struct AsinhOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::asinh(input);
 	}
 };
-} // namespace
 
 ScalarFunction AsinhFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1480,14 +1273,12 @@ ScalarFunction AsinhFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // tanh
 //===--------------------------------------------------------------------===//
-namespace {
 struct TanhOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		return (double)std::tanh(input);
 	}
 };
-} // namespace
 
 ScalarFunction TanhFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1497,7 +1288,6 @@ ScalarFunction TanhFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // atanh
 //===--------------------------------------------------------------------===//
-namespace {
 struct AtanhOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1510,7 +1300,6 @@ struct AtanhOperator {
 		return (double)std::atanh(input);
 	}
 };
-} // namespace
 
 ScalarFunction AtanhFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1522,7 +1311,6 @@ ScalarFunction AtanhFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cot
 //===--------------------------------------------------------------------===//
-namespace {
 template <class OP>
 struct NoInfiniteNoZeroDoubleWrapper {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -1546,7 +1334,7 @@ struct CotOperator {
 		return 1.0 / (double)std::tan(input);
 	}
 };
-} // namespace
+
 ScalarFunction CotFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteNoZeroDoubleWrapper<CotOperator>>);
@@ -1557,7 +1345,6 @@ ScalarFunction CotFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // gamma
 //===--------------------------------------------------------------------===//
-namespace {
 struct GammaOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1567,7 +1354,6 @@ struct GammaOperator {
 		return std::tgamma(input);
 	}
 };
-} // namespace
 
 ScalarFunction GammaFun::GetFunction() {
 	auto func = ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1579,7 +1365,6 @@ ScalarFunction GammaFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // gamma
 //===--------------------------------------------------------------------===//
-namespace {
 struct LogGammaOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1589,7 +1374,6 @@ struct LogGammaOperator {
 		return std::lgamma(input);
 	}
 };
-} // namespace
 
 ScalarFunction LogGammaFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1601,7 +1385,6 @@ ScalarFunction LogGammaFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // factorial(), !
 //===--------------------------------------------------------------------===//
-namespace {
 struct FactorialOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -1614,7 +1397,6 @@ struct FactorialOperator {
 		return ret;
 	}
 };
-} // namespace
 
 ScalarFunction FactorialOperatorFun::GetFunction() {
 	ScalarFunction function({LogicalType::INTEGER}, LogicalType::HUGEINT,
@@ -1626,7 +1408,6 @@ ScalarFunction FactorialOperatorFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // even
 //===--------------------------------------------------------------------===//
-namespace {
 struct EvenOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -1646,7 +1427,6 @@ struct EvenOperator {
 		return value;
 	}
 };
-} // namespace
 
 ScalarFunction EvenFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1658,7 +1438,6 @@ ScalarFunction EvenFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 
 // should be replaced with std::gcd in a newer C++ standard
-namespace {
 template <class TA>
 TA GreatestCommonDivisor(TA left, TA right) {
 	TA a = left;
@@ -1691,8 +1470,6 @@ struct GreatestCommonDivisorOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunctionSet GreatestCommonDivisorFun::GetFunctions() {
 	ScalarFunctionSet funcs;
 	funcs.AddFunction(
@@ -1707,7 +1484,7 @@ ScalarFunctionSet GreatestCommonDivisorFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // lcm
 //===--------------------------------------------------------------------===//
-namespace {
+
 // should be replaced with std::lcm in a newer C++ standard
 struct LeastCommonMultipleOperator {
 	template <class TA, class TB, class TR>
@@ -1723,8 +1500,6 @@ struct LeastCommonMultipleOperator {
 	}
 };
 
-} // namespace
-
 ScalarFunctionSet LeastCommonMultipleFun::GetFunctions() {
 	ScalarFunctionSet funcs;