duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

package/src/duckdb/src/function/scalar/math/numeric.cpp

@@ -2,13 +2,13 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/scalar/trigonometric_functions.hpp"
 #include "duckdb/common/operator/abs.hpp"
+#include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/likely.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include <cmath>
 #include <errno.h>
@@ -77,25 +77,22 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &lstats = (NumericStatistics &)*child_stats[0];
+	auto &lstats = child_stats[0];
 	Value new_min, new_max;
 	bool potential_overflow = true;
-	if (!lstats.min.IsNull() && !lstats.max.IsNull()) {
+	if (NumericStats::HasMinMax(lstats)) {
 		switch (expr.return_type.InternalType()) {
 		case PhysicalType::INT8:
-			potential_overflow = lstats.min.GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
 			break;
 		case PhysicalType::INT16:
-			potential_overflow = lstats.min.GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
 			break;
 		case PhysicalType::INT32:
-			potential_overflow = lstats.min.GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
 			break;
 		case PhysicalType::INT64:
-			potential_overflow = lstats.min.GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
 			break;
 		default:
 			return nullptr;
@@ -108,8 +105,8 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 		// no potential overflow
 
 		// compute stats
-		auto current_min = lstats.min.GetValue<int64_t>();
-		auto current_max = lstats.max.GetValue<int64_t>();
+		auto current_min = NumericStats::Min(lstats).GetValue<int64_t>();
+		auto current_max = NumericStats::Max(lstats).GetValue<int64_t>();
 
 		int64_t min_val, max_val;
 
@@ -125,16 +122,17 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 		} else {
 			// if both current_min and current_max are > 0, then the abs is a no-op and can be removed entirely
 			*input.expr_ptr = std::move(input.expr.children[0]);
-			return std::move(child_stats[0]);
+			return child_stats[0].ToUnique();
 		}
 		new_min = Value::Numeric(expr.return_type, min_val);
 		new_max = Value::Numeric(expr.return_type, max_val);
 		expr.function.function = ScalarFunction::GetScalarUnaryFunction<AbsOperator>(expr.return_type);
 	}
-	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
-	                                            StatisticsType::LOCAL_STATS);
-	stats->validity_stats = lstats.validity_stats->Copy();
-	return std::move(stats);
+	auto stats = NumericStats::CreateEmpty(expr.return_type);
+	NumericStats::SetMin(stats, new_min);
+	NumericStats::SetMax(stats, new_max);
+	stats.CopyValidity(lstats);
+	return stats.ToUnique();
 }
 
 template <class OP>
@@ -312,7 +310,7 @@ struct CeilOperator {
 
 template <class T, class POWERS_OF_TEN, class OP>
 static void GenericRoundFunctionDecimal(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	OP::template Operation<T, POWERS_OF_TEN>(input, DecimalType::GetScale(func_expr.children[0]->return_type), result);
 }
 
@@ -445,6 +443,63 @@ void FloorFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(floor);
 }
 
+//===--------------------------------------------------------------------===//
+// trunc
+//===--------------------------------------------------------------------===//
+struct TruncOperator {
+	// Integer truncation is a NOP
+	template <class TA, class TR>
+	static inline TR Operation(TA left) {
+		return std::trunc(left);
+	}
+};
+
+struct TruncDecimalOperator {
+	template <class T, class POWERS_OF_TEN_CLASS>
+	static void Operation(DataChunk &input, uint8_t scale, Vector &result) {
+		T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[scale];
+		UnaryExecutor::Execute<T, T>(input.data[0], result, input.size(), [&](T input) {
+			//	Always floor
+			return (input / power_of_ten);
+		});
+	}
+};
+
+void TruncFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet floor("trunc");
+	for (auto &type : LogicalType::Numeric()) {
+		scalar_function_t func = nullptr;
+		bind_scalar_function_t bind_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>;
+			break;
+		case LogicalTypeId::DOUBLE:
+			func = ScalarFunction::UnaryFunction<double, double, TruncOperator>;
+			break;
+		case LogicalTypeId::DECIMAL:
+			bind_func = BindGenericRoundFunctionDecimal<TruncDecimalOperator>;
+			break;
+		case LogicalTypeId::TINYINT:
+		case LogicalTypeId::SMALLINT:
+		case LogicalTypeId::INTEGER:
+		case LogicalTypeId::BIGINT:
+		case LogicalTypeId::HUGEINT:
+		case LogicalTypeId::UTINYINT:
+		case LogicalTypeId::USMALLINT:
+		case LogicalTypeId::UINTEGER:
+		case LogicalTypeId::UBIGINT:
+			func = ScalarFunction::NopFunction;
+			break;
+		default:
+			throw InternalException("Unimplemented numeric type for function \"trunc\"");
+		}
+		floor.AddFunction(ScalarFunction({type}, type, func, bind_func));
+	}
+	set.AddFunction(floor);
+}
+
 //===--------------------------------------------------------------------===//
 // round
 //===--------------------------------------------------------------------===//
@@ -510,7 +565,7 @@ struct RoundPrecisionFunctionData : public FunctionData {
 	int32_t target_scale;
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<RoundPrecisionFunctionData>(target_scale);
+		return make_uniq<RoundPrecisionFunctionData>(target_scale);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -521,7 +576,7 @@ struct RoundPrecisionFunctionData : public FunctionData {
 
 template <class T, class POWERS_OF_TEN_CLASS>
 static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	auto width = DecimalType::GetWidth(func_expr.children[0]->return_type);
@@ -547,7 +602,7 @@ static void DecimalRoundNegativePrecisionFunction(DataChunk &input, ExpressionSt
 
 template <class T, class POWERS_OF_TEN_CLASS>
 static void DecimalRoundPositivePrecisionFunction(DataChunk &input, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
 	auto &info = (RoundPrecisionFunctionData &)*func_expr.bind_info;
 	auto source_scale = DecimalType::GetScale(func_expr.children[0]->return_type);
 	T power_of_ten = POWERS_OF_TEN_CLASS::POWERS_OF_TEN[source_scale - info.target_scale];
@@ -625,7 +680,7 @@ unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, Scala
 	}
 	bound_function.arguments[0] = decimal_type;
 	bound_function.return_type = LogicalType::DECIMAL(width, target_scale);
-	return make_unique<RoundPrecisionFunctionData>(round_value);
+	return make_uniq<RoundPrecisionFunctionData>(round_value);
 }
 
 void RoundFun::RegisterFunction(BuiltinFunctions &set) {
@@ -1164,4 +1219,90 @@ void EvenFun::RegisterFunction(BuiltinFunctions &set) {
 	                               ScalarFunction::UnaryFunction<double, double, EvenOperator>));
 }
 
+//===--------------------------------------------------------------------===//
+// gcd
+//===--------------------------------------------------------------------===//
+
+// should be replaced with std::gcd in a newer C++ standard
+template <class TA>
+TA GreatestCommonDivisor(TA left, TA right) {
+	TA a = left;
+	TA b = right;
+
+	// This protects the following modulo operations from a corner case,
+	// where we would get a runtime error due to an integer overflow.
+	if ((left == NumericLimits<TA>::Minimum() && right == -1) ||
+	    (left == -1 && right == NumericLimits<TA>::Minimum())) {
+		return 1;
+	}
+
+	while (true) {
+		if (a == 0) {
+			return TryAbsOperator::Operation<TA, TA>(b);
+		}
+		b %= a;
+
+		if (b == 0) {
+			return TryAbsOperator::Operation<TA, TA>(a);
+		}
+		a %= b;
+	}
+}
+
+struct GreatestCommonDivisorOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return GreatestCommonDivisor(left, right);
+	}
+};
+
+void GreatestCommonDivisorFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("gcd");
+
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
+	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, GreatestCommonDivisorOperator>));
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
+	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, GreatestCommonDivisorOperator>));
+
+	set.AddFunction(funcs);
+	funcs.name = "greatest_common_divisor";
+	set.AddFunction(funcs);
+}
+
+//===--------------------------------------------------------------------===//
+// lcm
+//===--------------------------------------------------------------------===//
+
+// should be replaced with std::lcm in a newer C++ standard
+struct LeastCommonMultipleOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		if (left == 0 || right == 0) {
+			return 0;
+		}
+		TR result;
+		if (!TryMultiplyOperator::Operation<TA, TB, TR>(left, right / GreatestCommonDivisor(left, right), result)) {
+			throw OutOfRangeException("lcm value is out of range");
+		}
+		return TryAbsOperator::Operation<TR, TR>(result);
+	}
+};
+
+void LeastCommonMultipleFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("lcm");
+
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
+	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, LeastCommonMultipleOperator>));
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
+	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, LeastCommonMultipleOperator>));
+
+	set.AddFunction(funcs);
+	funcs.name = "least_common_multiple";
+	set.AddFunction(funcs);
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/scalar/math/random.cpp

@@ -18,7 +18,7 @@ struct RandomLocalState : public FunctionLocalState {
 
 static void RandomFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<double>(result);
@@ -31,7 +31,7 @@ static unique_ptr<FunctionLocalState> RandomInitLocalState(ExpressionState &stat
                                                            FunctionData *bind_data) {
 	auto &random_engine = RandomEngine::Get(state.GetContext());
 	lock_guard<mutex> guard(random_engine.lock);
-	return make_unique<RandomLocalState>(random_engine.NextRandomInteger());
+	return make_uniq<RandomLocalState>(random_engine.NextRandomInteger());
 }
 
 void RandomFun::RegisterFunction(BuiltinFunctions &set) {
@@ -43,7 +43,7 @@ void RandomFun::RegisterFunction(BuiltinFunctions &set) {
 
 static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 0);
-	auto &lstate = (RandomLocalState &)*ExecuteFunctionState::GetFunctionState(state);
+	auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast<RandomLocalState>();
 
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<hugeint_t>(result);

package/src/duckdb/src/function/scalar/math/setseed.cpp

@@ -17,7 +17,7 @@ struct SetseedBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<SetseedBindData>(context);
+		return make_uniq<SetseedBindData>(context);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
@@ -26,8 +26,8 @@ struct SetseedBindData : public FunctionData {
 };
 
 static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	auto &func_expr = (BoundFunctionExpression &)state.expr;
-	auto &info = (SetseedBindData &)*func_expr.bind_info;
+	auto &func_expr = state.expr.Cast<BoundFunctionExpression>();
+	auto &info = func_expr.bind_info->Cast<SetseedBindData>();
 	auto &input = args.data[0];
 	input.Flatten(args.size());
 
@@ -49,7 +49,7 @@ static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 unique_ptr<FunctionData> SetSeedBind(ClientContext &context, ScalarFunction &bound_function,
                                      vector<unique_ptr<Expression>> &arguments) {
-	return make_unique<SetseedBindData>(context);
+	return make_uniq<SetseedBindData>(context);
 }
 
 void SetseedFun::RegisterFunction(BuiltinFunctions &set) {

package/src/duckdb/src/function/scalar/math_functions.cpp

@@ -10,6 +10,7 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<CeilFun>();
 	Register<FloorFun>();
 	Register<RoundFun>();
+	Register<TruncFun>();
 
 	Register<DegreesFun>();
 	Register<RadiansFun>();
@@ -41,6 +42,9 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<SignBitFun>();
 	Register<IsInfiniteFun>();
 	Register<IsFiniteFun>();
+
+	Register<GreatestCommonDivisorFun>();
+	Register<LeastCommonMultipleFun>();
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -12,7 +12,6 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/scalar/operators.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 
 #include <limits>
@@ -78,15 +77,15 @@ static scalar_function_t GetScalarBinaryFunction(PhysicalType type) {
 //===--------------------------------------------------------------------===//
 struct AddPropagateStatistics {
 	template <class T, class OP>
-	static bool Operation(LogicalType type, NumericStatistics &lstats, NumericStatistics &rstats, Value &new_min,
+	static bool Operation(LogicalType type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
 	                      Value &new_max) {
 		T min, max;
 		// new min is min+min
-		if (!OP::Operation(lstats.min.GetValueUnsafe<T>(), rstats.min.GetValueUnsafe<T>(), min)) {
+		if (!OP::Operation(NumericStats::GetMin<T>(lstats), NumericStats::GetMin<T>(rstats), min)) {
 			return true;
 		}
 		// new max is max+max
-		if (!OP::Operation(lstats.max.GetValueUnsafe<T>(), rstats.max.GetValueUnsafe<T>(), max)) {
+		if (!OP::Operation(NumericStats::GetMax<T>(lstats), NumericStats::GetMax<T>(rstats), max)) {
 			return true;
 		}
 		new_min = Value::Numeric(type, min);
@@ -97,13 +96,13 @@ struct AddPropagateStatistics {
 
 struct SubtractPropagateStatistics {
 	template <class T, class OP>
-	static bool Operation(LogicalType type, NumericStatistics &lstats, NumericStatistics &rstats, Value &new_min,
+	static bool Operation(LogicalType type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
 	                      Value &new_max) {
 		T min, max;
-		if (!OP::Operation(lstats.min.GetValueUnsafe<T>(), rstats.max.GetValueUnsafe<T>(), min)) {
+		if (!OP::Operation(NumericStats::GetMin<T>(lstats), NumericStats::GetMax<T>(rstats), min)) {
 			return true;
 		}
-		if (!OP::Operation(lstats.max.GetValueUnsafe<T>(), rstats.min.GetValueUnsafe<T>(), max)) {
+		if (!OP::Operation(NumericStats::GetMax<T>(lstats), NumericStats::GetMin<T>(rstats), max)) {
 			return true;
 		}
 		new_min = Value::Numeric(type, min);
@@ -117,13 +116,13 @@ struct DecimalArithmeticBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		auto res = make_unique<DecimalArithmeticBindData>();
+		auto res = make_uniq<DecimalArithmeticBindData>();
 		res->check_overflow = check_overflow;
 		return std::move(res);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto other = (DecimalArithmeticBindData &)other_p;
+		auto other = other_p.Cast<DecimalArithmeticBindData>();
 		return other.check_overflow == check_overflow;
 	}
 
@@ -136,14 +135,11 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 2);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0] || !child_stats[1]) {
-		return nullptr;
-	}
-	auto &lstats = (NumericStatistics &)*child_stats[0];
-	auto &rstats = (NumericStatistics &)*child_stats[1];
+	auto &lstats = child_stats[0];
+	auto &rstats = child_stats[1];
 	Value new_min, new_max;
 	bool potential_overflow = true;
-	if (!lstats.min.IsNull() && !lstats.max.IsNull() && !rstats.min.IsNull() && !rstats.max.IsNull()) {
+	if (NumericStats::HasMinMax(lstats) && NumericStats::HasMinMax(rstats)) {
 		switch (expr.return_type.InternalType()) {
 		case PhysicalType::INT8:
 			potential_overflow =
@@ -176,17 +172,18 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 		}
 		expr.function.function = GetScalarIntegerFunction<BASEOP>(expr.return_type.InternalType());
 	}
-	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
-	                                            StatisticsType::LOCAL_STATS);
-	stats->validity_stats = ValidityStatistics::Combine(lstats.validity_stats, rstats.validity_stats);
-	return std::move(stats);
+	auto result = NumericStats::CreateEmpty(expr.return_type);
+	NumericStats::SetMin(result, new_min);
+	NumericStats::SetMax(result, new_max);
+	result.CombineValidity(lstats, rstats);
+	return result.ToUnique();
 }
 
 template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
 unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFunction &bound_function,
                                                 vector<unique_ptr<Expression>> &arguments) {
 
-	auto bind_data = make_unique<DecimalArithmeticBindData>();
+	auto bind_data = make_uniq<DecimalArithmeticBindData>();
 
 	// get the max width and scale of the input arguments
 	uint8_t max_width = 0, max_scale = 0, max_width_over_scale = 0;
@@ -276,7 +273,7 @@ unique_ptr<FunctionData> DeserializeDecimalArithmetic(ClientContext &context, Fi
 	bound_function.return_type = return_type;
 	bound_function.arguments = arguments;
 
-	auto bind_data = make_unique<DecimalArithmeticBindData>();
+	auto bind_data = make_uniq<DecimalArithmeticBindData>();
 	bind_data->check_overflow = check_overflow;
 	return std::move(bind_data);
 }
@@ -453,13 +450,13 @@ struct DecimalNegateBindData : public FunctionData {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
-		auto res = make_unique<DecimalNegateBindData>();
+		auto res = make_uniq<DecimalNegateBindData>();
 		res->bound_type = bound_type;
 		return std::move(res);
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto other = (DecimalNegateBindData &)other_p;
+		auto other = other_p.Cast<DecimalNegateBindData>();
 		return other.bound_type == bound_type;
 	}
 
@@ -469,7 +466,7 @@ struct DecimalNegateBindData : public FunctionData {
 unique_ptr<FunctionData> DecimalNegateBind(ClientContext &context, ScalarFunction &bound_function,
                                            vector<unique_ptr<Expression>> &arguments) {
 
-	auto bind_data = make_unique<DecimalNegateBindData>();
+	auto bind_data = make_uniq<DecimalNegateBindData>();
 
 	auto &decimal_type = arguments[0]->return_type;
 	auto width = DecimalType::GetWidth(decimal_type);
@@ -491,9 +488,9 @@ unique_ptr<FunctionData> DecimalNegateBind(ClientContext &context, ScalarFunctio
 
 struct NegatePropagateStatistics {
 	template <class T>
-	static bool Operation(LogicalType type, NumericStatistics &istats, Value &new_min, Value &new_max) {
-		auto max_value = istats.max.GetValueUnsafe<T>();
-		auto min_value = istats.min.GetValueUnsafe<T>();
+	static bool Operation(LogicalType type, BaseStatistics &istats, Value &new_min, Value &new_max) {
+		auto max_value = NumericStats::GetMax<T>(istats);
+		auto min_value = NumericStats::GetMin<T>(istats);
 		if (!NegateOperator::CanNegate<T>(min_value) || !NegateOperator::CanNegate<T>(max_value)) {
 			return true;
 		}
@@ -510,13 +507,10 @@ static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, F
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &istats = (NumericStatistics &)*child_stats[0];
+	auto &istats = child_stats[0];
 	Value new_min, new_max;
 	bool potential_overflow = true;
-	if (!istats.min.IsNull() && !istats.max.IsNull()) {
+	if (NumericStats::HasMinMax(istats)) {
 		switch (expr.return_type.InternalType()) {
 		case PhysicalType::INT8:
 			potential_overflow =
@@ -542,12 +536,11 @@ static unique_ptr<BaseStatistics> NegateBindStatistics(ClientContext &context, F
 		new_min = Value(expr.return_type);
 		new_max = Value(expr.return_type);
 	}
-	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
-	                                            StatisticsType::LOCAL_STATS);
-	if (istats.validity_stats) {
-		stats->validity_stats = istats.validity_stats->Copy();
-	}
-	return std::move(stats);
+	auto stats = NumericStats::CreateEmpty(expr.return_type);
+	NumericStats::SetMin(stats, new_min);
+	NumericStats::SetMax(stats, new_max);
+	stats.CopyValidity(istats);
+	return stats.ToUnique();
 }
 
 ScalarFunction SubtractFun::GetFunction(const LogicalType &type) {
@@ -662,7 +655,7 @@ void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 struct MultiplyPropagateStatistics {
 	template <class T, class OP>
-	static bool Operation(LogicalType type, NumericStatistics &lstats, NumericStatistics &rstats, Value &new_min,
+	static bool Operation(LogicalType type, BaseStatistics &lstats, BaseStatistics &rstats, Value &new_min,
 	                      Value &new_max) {
 		// statistics propagation on the multiplication is slightly less straightforward because of negative numbers
 		// the new min/max depend on the signs of the input types
@@ -671,8 +664,8 @@ struct MultiplyPropagateStatistics {
 		// etc
 		// rather than doing all this switcheroo we just multiply all combinations of lmin/lmax with rmin/rmax
 		// and check what the minimum/maximum value is
-		T lvals[] {lstats.min.GetValueUnsafe<T>(), lstats.max.GetValueUnsafe<T>()};
-		T rvals[] {rstats.min.GetValueUnsafe<T>(), rstats.max.GetValueUnsafe<T>()};
+		T lvals[] {NumericStats::GetMin<T>(lstats), NumericStats::GetMax<T>(lstats)};
+		T rvals[] {NumericStats::GetMin<T>(rstats), NumericStats::GetMax<T>(rstats)};
 		T min = NumericLimits<T>::Maximum();
 		T max = NumericLimits<T>::Minimum();
 		// multiplications
@@ -700,7 +693,7 @@ struct MultiplyPropagateStatistics {
 unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunction &bound_function,
                                              vector<unique_ptr<Expression>> &arguments) {
 
-	auto bind_data = make_unique<DecimalArithmeticBindData>();
+	auto bind_data = make_uniq<DecimalArithmeticBindData>();
 
 	uint8_t result_width = 0, result_scale = 0;
 	uint8_t max_width = 0;
@@ -914,23 +907,29 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
 }
 
 void DivideFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("/");
+	ScalarFunctionSet fp_divide("/");
+	fp_divide.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::FLOAT)));
+	fp_divide.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::DOUBLE)));
+	fp_divide.AddFunction(
+	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
+	set.AddFunction(fp_divide);
+
+	ScalarFunctionSet full_divide("//");
 	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			continue;
 		} else {
-			functions.AddFunction(
+			full_divide.AddFunction(
 			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type)));
 		}
 	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
+	set.AddFunction(full_divide);
 
-	set.AddFunction(functions);
-
-	functions.name = "divide";
-	set.AddFunction(functions);
+	full_divide.name = "divide";
+	set.AddFunction(full_divide);
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/function/scalar/operators/multiply.cpp

@@ -178,6 +178,11 @@ bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result
 	return true;
 }
 
+template <>
+bool TryMultiplyOperator::Operation(hugeint_t left, hugeint_t right, hugeint_t &result) {
+	return Hugeint::TryMultiply(left, right, result);
+}
+
 //===--------------------------------------------------------------------===//
 // multiply  decimal with overflow check
 //===--------------------------------------------------------------------===//