duckdb 1.3.3-dev0.0 → 1.3.3-dev4.0

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

@@ -1,16 +1,10 @@
 #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"
@@ -18,9 +12,6 @@
 
 #include <cmath>
 #include <cstdint>
-#include <errno.h>
-#include <limits>
-#include <type_traits>
 
 namespace duckdb {
 
@@ -52,6 +43,9 @@ 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) {
@@ -68,6 +62,8 @@ struct NextAfterOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunctionSet NextAfterFun::GetFunctions() {
 	ScalarFunctionSet next_after_fun;
 	next_after_fun.AddFunction(
@@ -204,6 +200,9 @@ ScalarFunctionSet AbsOperatorFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // bit_count
 //===--------------------------------------------------------------------===//
+
+namespace {
+
 struct BitCntOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -236,10 +235,11 @@ struct BitStringBitCntOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
 		TR count = Bit::BitCount(input);
-		return count;
+		return UnsafeNumericCast<TR>(count);
 	}
 };
 
+} // namespace
 ScalarFunctionSet BitCountFun::GetFunctions() {
 	ScalarFunctionSet functions;
 	functions.AddFunction(ScalarFunction({LogicalType::TINYINT}, LogicalType::TINYINT,
@@ -253,13 +253,15 @@ 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, idx_t, BitStringBitCntOperator>));
+	                                     ScalarFunction::UnaryFunction<string_t, int64_t, BitStringBitCntOperator>));
 	return functions;
 }
 
 //===--------------------------------------------------------------------===//
 // sign
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct SignOperator {
 	template <class TA, class TR>
 	static TR Operation(TA input) {
@@ -295,6 +297,7 @@ int8_t SignOperator::Operation(double input) {
 	}
 }
 
+} // namespace
 ScalarFunctionSet SignFun::GetFunctions() {
 	ScalarFunctionSet sign;
 	for (auto &type : LogicalType::Numeric()) {
@@ -312,12 +315,14 @@ 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) {
@@ -326,8 +331,8 @@ static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state
 }
 
 template <class OP>
-unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context, ScalarFunction &bound_function,
-                                                         vector<unique_ptr<Expression>> &arguments) {
+static 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);
@@ -355,6 +360,7 @@ unique_ptr<FunctionData> BindGenericRoundFunctionDecimal(ClientContext &context,
 	return nullptr;
 }
 
+namespace {
 struct CeilDecimalOperator {
 	template <class T, class POWERS_OF_TEN_CLASS>
 	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
@@ -370,6 +376,7 @@ struct CeilDecimalOperator {
 		});
 	}
 };
+} // namespace
 
 ScalarFunctionSet CeilFun::GetFunctions() {
 	ScalarFunctionSet ceil;
@@ -401,6 +408,7 @@ ScalarFunctionSet CeilFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // floor
 //===--------------------------------------------------------------------===//
+namespace {
 struct FloorOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -423,6 +431,7 @@ struct FloorDecimalOperator {
 		});
 	}
 };
+} // namespace
 
 ScalarFunctionSet FloorFun::GetFunctions() {
 	ScalarFunctionSet floor;
@@ -454,6 +463,118 @@ 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>
@@ -473,38 +594,134 @@ 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 func = nullptr;
+		scalar_function_t trunc_func = nullptr;
+		scalar_function_t trunc_prec_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:
-			func = ScalarFunction::UnaryFunction<float, float, TruncOperator>;
+			trunc_func = ScalarFunction::UnaryFunction<float, float, TruncOperator>;
+			trunc_prec_func = ScalarFunction::BinaryFunction<float, int32_t, float, TruncOperatorPrecision>;
 			break;
 		case LogicalTypeId::DOUBLE:
-			func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
+			trunc_func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
+			trunc_prec_func = ScalarFunction::BinaryFunction<double, int32_t, double, TruncOperatorPrecision>;
 			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:
-			func = ScalarFunction::NopFunction;
+			trunc_func = ScalarFunction::NopFunction;
+			trunc_prec_func = ScalarFunction::BinaryFunction<uhugeint_t, int32_t, uhugeint_t, TruncIntegerOperator>;
 			break;
 		default:
 			throw InternalException("Unimplemented numeric type for function \"trunc\"");
 		}
-		trunc.AddFunction(ScalarFunction({type}, type, func, bind_func));
+		trunc.AddFunction(ScalarFunction({type}, type, trunc_func, bind_func));
+		trunc.AddFunction(ScalarFunction({type, LogicalType::INTEGER}, type, trunc_prec_func, bind_prec_func));
 	}
 	return trunc;
 }
@@ -512,6 +729,7 @@ ScalarFunctionSet TruncFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // round
 //===--------------------------------------------------------------------===//
+namespace {
 struct RoundOperatorPrecision {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA input, TB precision) {
@@ -595,130 +813,55 @@ struct RoundIntegerOperator {
 	}
 };
 
-struct RoundPrecisionFunctionData : public FunctionData {
-	explicit RoundPrecisionFunctionData(int32_t target_scale) : target_scale(target_scale) {
-	}
+} // namespace
 
-	int32_t target_scale;
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_uniq<RoundPrecisionFunctionData>(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;
 
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<RoundPrecisionFunctionData>();
-		return target_scale == other.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);
+		});
 	}
 };
 
-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;
+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;
 			}
-		}
+			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;
@@ -738,7 +881,8 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 			break;
 		case LogicalTypeId::DECIMAL:
 			bind_func = BindGenericRoundFunctionDecimal<RoundDecimalOperator>;
-			bind_prec_func = BindDecimalRoundPrecision;
+			bind_prec_func =
+			    BindDecimalRoundPrecision<DecimalRoundNegativePrecisionOperator, DecimalRoundPositivePrecisionOperator>;
 			break;
 		case LogicalTypeId::TINYINT:
 			round_func = ScalarFunction::NopFunction;
@@ -765,7 +909,7 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 				// no round for integral numbers
 				continue;
 			}
-			throw InternalException("Unimplemented numeric type for function \"floor\"");
+			throw InternalException("Unimplemented numeric type for function \"round\"");
 		}
 		round.AddFunction(ScalarFunction({type}, type, round_func, bind_func));
 		round.AddFunction(ScalarFunction({type, LogicalType::INTEGER}, type, round_prec_func, bind_prec_func));
@@ -776,6 +920,8 @@ ScalarFunctionSet RoundFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // exp
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct ExpOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -783,6 +929,8 @@ struct ExpOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunction ExpFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                      ScalarFunction::UnaryFunction<double, double, ExpOperator>);
@@ -791,6 +939,8 @@ ScalarFunction ExpFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // pow
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct PowOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA base, TB exponent) {
@@ -798,6 +948,7 @@ struct PowOperator {
 	}
 };
 
+} // namespace
 ScalarFunction PowOperatorFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                      ScalarFunction::BinaryFunction<double, double, double, PowOperator>);
@@ -806,6 +957,7 @@ ScalarFunction PowOperatorFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // sqrt
 //===--------------------------------------------------------------------===//
+namespace {
 struct SqrtOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -815,6 +967,7 @@ struct SqrtOperator {
 		return std::sqrt(input);
 	}
 };
+} // namespace
 
 ScalarFunction SqrtFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -826,6 +979,8 @@ ScalarFunction SqrtFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cbrt
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct CbRtOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -833,6 +988,8 @@ struct CbRtOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunction CbrtFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                      ScalarFunction::UnaryFunction<double, double, CbRtOperator>);
@@ -841,6 +998,7 @@ ScalarFunction CbrtFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // ln
 //===--------------------------------------------------------------------===//
+namespace {
 
 struct LnOperator {
 	template <class TA, class TR>
@@ -855,6 +1013,7 @@ struct LnOperator {
 	}
 };
 
+} // namespace
 ScalarFunction LnFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, LnOperator>);
@@ -865,6 +1024,8 @@ ScalarFunction LnFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // log
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct Log10Operator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -878,6 +1039,8 @@ struct Log10Operator {
 	}
 };
 
+} // namespace
+
 ScalarFunction Log10Fun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, Log10Operator>);
@@ -888,6 +1051,8 @@ ScalarFunction Log10Fun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // log with base
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct LogBaseOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA b, TB x) {
@@ -899,6 +1064,8 @@ struct LogBaseOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunctionSet LogFun::GetFunctions() {
 	ScalarFunctionSet funcs;
 	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -914,6 +1081,7 @@ ScalarFunctionSet LogFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // log2
 //===--------------------------------------------------------------------===//
+namespace {
 struct Log2Operator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -926,6 +1094,7 @@ struct Log2Operator {
 		return std::log2(input);
 	}
 };
+} // namespace
 
 ScalarFunction Log2Fun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -950,12 +1119,14 @@ 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,
@@ -965,12 +1136,14 @@ 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,
@@ -980,12 +1153,14 @@ 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;
@@ -999,12 +1174,14 @@ 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;
@@ -1018,6 +1195,7 @@ ScalarFunctionSet SignBitFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // isinf
 //===--------------------------------------------------------------------===//
+namespace {
 struct IsInfiniteOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1035,6 +1213,8 @@ bool IsInfiniteOperator::Operation(timestamp_t input) {
 	return !Value::IsFinite(input);
 }
 
+} // namespace
+
 ScalarFunctionSet IsInfiniteFun::GetFunctions() {
 	ScalarFunctionSet funcs("isinf");
 	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
@@ -1053,6 +1233,8 @@ ScalarFunctionSet IsInfiniteFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // isfinite
 //===--------------------------------------------------------------------===//
+namespace {
+
 struct IsFiniteOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1060,6 +1242,8 @@ struct IsFiniteOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunctionSet IsFiniteFun::GetFunctions() {
 	ScalarFunctionSet funcs;
 	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
@@ -1078,6 +1262,7 @@ ScalarFunctionSet IsFiniteFun::GetFunctions() {
 //===--------------------------------------------------------------------===//
 // sin
 //===--------------------------------------------------------------------===//
+namespace {
 template <class OP>
 struct NoInfiniteDoubleWrapper {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -1099,6 +1284,8 @@ struct SinOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunction SinFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
 	                        ScalarFunction::UnaryFunction<double, double, NoInfiniteDoubleWrapper<SinOperator>>);
@@ -1109,12 +1296,14 @@ 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,
@@ -1126,12 +1315,14 @@ 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,
@@ -1143,6 +1334,7 @@ ScalarFunction TanFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // asin
 //===--------------------------------------------------------------------===//
+namespace {
 struct ASinOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1152,6 +1344,7 @@ struct ASinOperator {
 		return (double)std::asin(input);
 	}
 };
+} // namespace
 
 ScalarFunction AsinFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1163,12 +1356,14 @@ 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,
@@ -1178,12 +1373,14 @@ 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,
@@ -1193,6 +1390,7 @@ ScalarFunction Atan2Fun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // acos
 //===--------------------------------------------------------------------===//
+namespace {
 struct ACos {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1202,6 +1400,7 @@ struct ACos {
 		return (double)std::acos(input);
 	}
 };
+} // namespace
 
 ScalarFunction AcosFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1213,12 +1412,14 @@ 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,
@@ -1228,12 +1429,14 @@ 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,
@@ -1243,12 +1446,14 @@ 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,
@@ -1258,12 +1463,14 @@ 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,
@@ -1273,12 +1480,14 @@ 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,
@@ -1288,6 +1497,7 @@ ScalarFunction TanhFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // atanh
 //===--------------------------------------------------------------------===//
+namespace {
 struct AtanhOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1300,6 +1510,7 @@ struct AtanhOperator {
 		return (double)std::atanh(input);
 	}
 };
+} // namespace
 
 ScalarFunction AtanhFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1311,6 +1522,7 @@ ScalarFunction AtanhFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // cot
 //===--------------------------------------------------------------------===//
+namespace {
 template <class OP>
 struct NoInfiniteNoZeroDoubleWrapper {
 	template <class INPUT_TYPE, class RESULT_TYPE>
@@ -1334,7 +1546,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>>);
@@ -1345,6 +1557,7 @@ ScalarFunction CotFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // gamma
 //===--------------------------------------------------------------------===//
+namespace {
 struct GammaOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1354,6 +1567,7 @@ struct GammaOperator {
 		return std::tgamma(input);
 	}
 };
+} // namespace
 
 ScalarFunction GammaFun::GetFunction() {
 	auto func = ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1365,6 +1579,7 @@ ScalarFunction GammaFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // gamma
 //===--------------------------------------------------------------------===//
+namespace {
 struct LogGammaOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -1374,6 +1589,7 @@ struct LogGammaOperator {
 		return std::lgamma(input);
 	}
 };
+} // namespace
 
 ScalarFunction LogGammaFun::GetFunction() {
 	ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1385,6 +1601,7 @@ ScalarFunction LogGammaFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // factorial(), !
 //===--------------------------------------------------------------------===//
+namespace {
 struct FactorialOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -1397,6 +1614,7 @@ struct FactorialOperator {
 		return ret;
 	}
 };
+} // namespace
 
 ScalarFunction FactorialOperatorFun::GetFunction() {
 	ScalarFunction function({LogicalType::INTEGER}, LogicalType::HUGEINT,
@@ -1408,6 +1626,7 @@ ScalarFunction FactorialOperatorFun::GetFunction() {
 //===--------------------------------------------------------------------===//
 // even
 //===--------------------------------------------------------------------===//
+namespace {
 struct EvenOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA left) {
@@ -1427,6 +1646,7 @@ struct EvenOperator {
 		return value;
 	}
 };
+} // namespace
 
 ScalarFunction EvenFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE,
@@ -1438,6 +1658,7 @@ 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;
@@ -1470,6 +1691,8 @@ struct GreatestCommonDivisorOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunctionSet GreatestCommonDivisorFun::GetFunctions() {
 	ScalarFunctionSet funcs;
 	funcs.AddFunction(
@@ -1484,7 +1707,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>
@@ -1500,6 +1723,8 @@ struct LeastCommonMultipleOperator {
 	}
 };
 
+} // namespace
+
 ScalarFunctionSet LeastCommonMultipleFun::GetFunctions() {
 	ScalarFunctionSet funcs;