duckdb 0.8.2-dev1859.0 → 0.8.2-dev1968.0

package/src/duckdb/src/include/duckdb/common/bitpacking.hpp

@@ -13,11 +13,17 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
 using bitpacking_width_t = uint8_t;
 
+struct HugeIntPacker {
+	static void Pack(const hugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width);
+	static void Unpack(const uint32_t *__restrict in, hugeint_t *__restrict out, bitpacking_width_t width);
+};
+
 class BitpackingPrimitives {
 
 public:
@@ -37,9 +43,7 @@ public:
 			idx_t misaligned_count = count % BITPACKING_ALGORITHM_GROUP_SIZE;
 			T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE]; // TODO maybe faster on the heap?
 
-			if (misaligned_count) {
-				count -= misaligned_count;
-			}
+			count -= misaligned_count;
 
 			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
 				PackGroup<T>(dst + (i * width) / 8, src + i, width);
@@ -78,22 +82,22 @@ public:
 	}
 
 	// Calculates the minimum required number of bits per value that can store all values
-	template <class T>
+	template <class T, bool is_signed = NumericLimits<T>::IsSigned()>
 	inline static bitpacking_width_t MinimumBitWidth(T value) {
-		return FindMinimumBitWidth<T, BYTE_ALIGNED>(value, value);
+		return FindMinimumBitWidth<T, is_signed, BYTE_ALIGNED>(value, value);
 	}
 
 	// Calculates the minimum required number of bits per value that can store all values
-	template <class T>
+	template <class T, bool is_signed = NumericLimits<T>::IsSigned()>
 	inline static bitpacking_width_t MinimumBitWidth(T *values, idx_t count) {
-		return FindMinimumBitWidth<T, BYTE_ALIGNED>(values, count);
+		return FindMinimumBitWidth<T, is_signed, BYTE_ALIGNED>(values, count);
 	}
 
 	// Calculates the minimum required number of bits per value that can store all values,
 	// given a predetermined minimum and maximum value of the buffer
-	template <class T>
+	template <class T, bool is_signed = NumericLimits<T>::IsSigned()>
 	inline static bitpacking_width_t MinimumBitWidth(T minimum, T maximum) {
-		return FindMinimumBitWidth<T, BYTE_ALIGNED>(minimum, maximum);
+		return FindMinimumBitWidth<T, is_signed, BYTE_ALIGNED>(minimum, maximum);
 	}
 
 	inline static idx_t GetRequiredSize(idx_t count, bitpacking_width_t width) {
@@ -112,7 +116,7 @@ public:
 	}
 
 private:
-	template <class T, bool round_to_next_byte = false>
+	template <class T, bool is_signed, bool round_to_next_byte = false>
 	static bitpacking_width_t FindMinimumBitWidth(T *values, idx_t count) {
 		T min_value = values[0];
 		T max_value = values[0];
@@ -122,7 +126,7 @@ private:
 				max_value = values[i];
 			}
 
-			if (std::is_signed<T>::value) {
+			if (is_signed) {
 				if (values[i] < min_value) {
 					min_value = values[i];
 				}
@@ -132,12 +136,12 @@ private:
 		return FindMinimumBitWidth<T, round_to_next_byte>(min_value, max_value);
 	}
 
-	template <class T, bool round_to_next_byte = false>
+	template <class T, bool is_signed, bool round_to_next_byte = false>
 	static bitpacking_width_t FindMinimumBitWidth(T min_value, T max_value) {
 		bitpacking_width_t bitwidth;
 		T value;
 
-		if (std::is_signed<T>::value) {
+		if (is_signed) {
 			if (min_value == NumericLimits<T>::Minimum()) {
 				// handle special case of the minimal value, as it cannot be negated like all other values.
 				return sizeof(T) * 8;
@@ -152,7 +156,7 @@ private:
 			return 0;
 		}
 
-		if (std::is_signed<T>::value) {
+		if (is_signed) {
 			bitwidth = 1;
 		} else {
 			bitwidth = 0;
@@ -168,58 +172,37 @@ private:
 		// Assert results are correct
 #ifdef DEBUG
 		if (bitwidth < sizeof(T) * 8 && bitwidth != 0) {
-			if (std::is_signed<T>::value) {
-				D_ASSERT((int64_t)max_value <= (int64_t)(1L << (bitwidth - 1)) - 1);
-				D_ASSERT((int64_t)min_value >= (int64_t)(-1 * ((1L << (bitwidth - 1)) - 1) - 1));
+			if (is_signed) {
+				D_ASSERT(max_value <= (T(1) << (bitwidth - 1)) - 1);
+				D_ASSERT(min_value >= (T(-1) * ((T(1) << (bitwidth - 1)) - 1) - 1));
 			} else {
-				D_ASSERT((uint64_t)max_value <= (uint64_t)(1L << (bitwidth)) - 1);
+				D_ASSERT(max_value <= (T(1) << (bitwidth)) - 1);
 			}
 		}
 #endif
 		if (round_to_next_byte) {
 			return (bitwidth / 8 + (bitwidth % 8 != 0)) * 8;
-		} else {
-			return bitwidth;
 		}
+		return bitwidth;
 	}
 
 	// Sign bit extension
-	template <class T, class T_U = typename std::make_unsigned<T>::type>
+	template <class T, class T_U = typename MakeUnsigned<T>::type>
 	static void SignExtend(data_ptr_t dst, bitpacking_width_t width) {
-		T const mask = ((T_U)1) << (width - 1);
+		T const mask = T_U(1) << (width - 1);
 		for (idx_t i = 0; i < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; ++i) {
 			T value = Load<T>(dst + i * sizeof(T));
-			value = value & ((((T_U)1) << width) - ((T_U)1));
+			value = value & ((T_U(1) << width) - T_U(1));
 			T result = (value ^ mask) - mask;
 			Store(result, dst + i * sizeof(T));
 		}
 	}
 
-	template <class T>
-	static void UnPackGroup(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
-	                        bool skip_sign_extension = false) {
-		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint8_t *)src, (uint8_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint16_t *)src, (uint16_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint32_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
-			duckdb_fastpforlib::fastunpack((const uint32_t *)src, (uint64_t *)dst, (uint32_t)width);
-		} else {
-			throw InternalException("Unsupported type found in bitpacking.");
-		}
-
-		if (NumericLimits<T>::IsSigned() && !skip_sign_extension && width > 0 && width < sizeof(T) * 8) {
-			SignExtend<T>(dst, width);
-		}
-	}
-
 	// Prevent compression at widths that are ineffective
 	template <class T>
 	static bitpacking_width_t GetEffectiveWidth(bitpacking_width_t width) {
-		auto bits_of_type = sizeof(T) * 8;
-		auto type_size = sizeof(T);
+		bitpacking_width_t bits_of_type = sizeof(T) * 8;
+		bitpacking_width_t type_size = sizeof(T);
 		if (width + type_size > bits_of_type) {
 			return bits_of_type;
 		}
@@ -227,17 +210,49 @@ private:
 	}
 
 	template <class T>
-	static void PackGroup(data_ptr_t dst, T *values, bitpacking_width_t width) {
-		if (std::is_same<T, uint8_t>::value || std::is_same<T, int8_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint8_t *)values, (uint8_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint16_t>::value || std::is_same<T, int16_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint16_t *)values, (uint16_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint32_t>::value || std::is_same<T, int32_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint32_t *)values, (uint32_t *)dst, (uint32_t)width);
-		} else if (std::is_same<T, uint64_t>::value || std::is_same<T, int64_t>::value) {
-			duckdb_fastpforlib::fastpack((const uint64_t *)values, (uint32_t *)dst, (uint32_t)width);
+	static inline void PackGroup(data_ptr_t dst, T *values, bitpacking_width_t width) {
+		if (std::is_same<T, int8_t>::value || std::is_same<T, uint8_t>::value) {
+			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint8_t *>(values), reinterpret_cast<uint8_t *>(dst),
+			                             static_cast<uint32_t>(width));
+		} else if (std::is_same<T, int16_t>::value || std::is_same<T, uint16_t>::value) {
+			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint16_t *>(values), reinterpret_cast<uint16_t *>(dst),
+			                             static_cast<uint32_t>(width));
+		} else if (std::is_same<T, int32_t>::value || std::is_same<T, uint32_t>::value) {
+			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint32_t *>(values), reinterpret_cast<uint32_t *>(dst),
+			                             static_cast<uint32_t>(width));
+		} else if (std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value) {
+			duckdb_fastpforlib::fastpack(reinterpret_cast<const uint64_t *>(values), reinterpret_cast<uint32_t *>(dst),
+			                             static_cast<uint32_t>(width));
+		} else if (std::is_same<T, hugeint_t>::value) {
+			HugeIntPacker::Pack(reinterpret_cast<const hugeint_t *>(values), reinterpret_cast<uint32_t *>(dst), width);
 		} else {
-			throw InternalException("Unsupported type found in bitpacking.");
+			throw InternalException("Unsupported type for bitpacking");
+		}
+	}
+
+	template <class T>
+	static inline void UnPackGroup(data_ptr_t dst, data_ptr_t src, bitpacking_width_t width,
+	                               bool skip_sign_extension = false) {
+		if (std::is_same<T, int8_t>::value || std::is_same<T, uint8_t>::value) {
+			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint8_t *>(src), reinterpret_cast<uint8_t *>(dst),
+			                               static_cast<uint32_t>(width));
+		} else if (std::is_same<T, int16_t>::value || std::is_same<T, uint16_t>::value) {
+			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint16_t *>(src), reinterpret_cast<uint16_t *>(dst),
+			                               static_cast<uint32_t>(width));
+		} else if (std::is_same<T, int32_t>::value || std::is_same<T, uint32_t>::value) {
+			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uint32_t *>(dst),
+			                               static_cast<uint32_t>(width));
+		} else if (std::is_same<T, int64_t>::value || std::is_same<T, uint64_t>::value) {
+			duckdb_fastpforlib::fastunpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<uint64_t *>(dst),
+			                               static_cast<uint32_t>(width));
+		} else if (std::is_same<T, hugeint_t>::value) {
+			HugeIntPacker::Unpack(reinterpret_cast<const uint32_t *>(src), reinterpret_cast<hugeint_t *>(dst), width);
+		} else {
+			throw InternalException("Unsupported type for bitpacking");
+		}
+
+		if (NumericLimits<T>::IsSigned() && !skip_sign_extension && width > 0 && width < sizeof(T) * 8) {
+			SignExtend<T>(dst, width);
 		}
 	}
 };

package/src/duckdb/src/include/duckdb/common/enum_util.hpp

@@ -214,6 +214,8 @@ enum class SetType : uint8_t;
 
 enum class SimplifiedTokenType : uint8_t;
 
+enum class SinkCombineResultType : uint8_t;
+
 enum class SinkFinalizeType : uint8_t;
 
 enum class SinkResultType : uint8_t;
@@ -544,6 +546,9 @@ const char* EnumUtil::ToChars<SetType>(SetType value);
 template<>
 const char* EnumUtil::ToChars<SimplifiedTokenType>(SimplifiedTokenType value);
 
+template<>
+const char* EnumUtil::ToChars<SinkCombineResultType>(SinkCombineResultType value);
+
 template<>
 const char* EnumUtil::ToChars<SinkFinalizeType>(SinkFinalizeType value);
 
@@ -902,6 +907,9 @@ SetType EnumUtil::FromString<SetType>(const char *value);
 template<>
 SimplifiedTokenType EnumUtil::FromString<SimplifiedTokenType>(const char *value);
 
+template<>
+SinkCombineResultType EnumUtil::FromString<SinkCombineResultType>(const char *value);
+
 template<>
 SinkFinalizeType EnumUtil::FromString<SinkFinalizeType>(const char *value);
 

package/src/duckdb/src/include/duckdb/common/enums/operator_result_type.hpp

@@ -46,10 +46,14 @@ enum class SourceResultType : uint8_t { HAVE_MORE_OUTPUT, FINISHED, BLOCKED };
 //! BLOCKED means the sink is currently blocked, e.g. by some async I/O.
 enum class SinkResultType : uint8_t { NEED_MORE_INPUT, FINISHED, BLOCKED };
 
+// todo comment
+enum class SinkCombineResultType : uint8_t { FINISHED, BLOCKED };
+
 //! The SinkFinalizeType is used to indicate the result of a Finalize call on a sink
 //! There are two possible results:
 //! READY means the sink is ready for further processing
 //! NO_OUTPUT_POSSIBLE means the sink will never provide output, and any pipelines involving the sink can be skipped
-enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE };
+//! BLOCKED means the finalize call to the sink is currently blocked, e.g. by some async I/O.
+enum class SinkFinalizeType : uint8_t { READY, NO_OUTPUT_POSSIBLE, BLOCKED };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/hugeint.hpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/string.hpp"
 #include <stdint.h>
+#include "duckdb/common/typedefs.hpp"
 
 namespace duckdb {
 
@@ -58,6 +59,20 @@ public:
 	DUCKDB_API hugeint_t &operator&=(const hugeint_t &rhs);
 	DUCKDB_API hugeint_t &operator|=(const hugeint_t &rhs);
 	DUCKDB_API hugeint_t &operator^=(const hugeint_t &rhs);
+
+	// boolean operators
+	DUCKDB_API explicit operator bool() const;
+	DUCKDB_API bool operator!() const;
+
+	// cast operators
+	DUCKDB_API explicit operator uint8_t() const;
+	DUCKDB_API explicit operator uint16_t() const;
+	DUCKDB_API explicit operator uint32_t() const;
+	DUCKDB_API explicit operator uint64_t() const;
+	DUCKDB_API explicit operator int8_t() const;
+	DUCKDB_API explicit operator int16_t() const;
+	DUCKDB_API explicit operator int32_t() const;
+	DUCKDB_API explicit operator int64_t() const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/limits.hpp

@@ -8,8 +8,11 @@
 
 #pragma once
 
+#include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/types.hpp"
 
+#include <type_traits>
+
 // Undef annoying windows macro
 #undef max
 
@@ -21,75 +24,16 @@ template <class T>
 struct NumericLimits {
 	static constexpr T Minimum() {
 		return std::numeric_limits<T>::lowest();
-	};
+	}
 	static constexpr T Maximum() {
 		return std::numeric_limits<T>::max();
-	};
-	DUCKDB_API static bool IsSigned();
-	DUCKDB_API static idx_t Digits();
-};
-
-template <>
-struct NumericLimits<int8_t> {
-	static constexpr int8_t Minimum() {
-		return std::numeric_limits<int8_t>::lowest();
-	};
-	static constexpr int8_t Maximum() {
-		return std::numeric_limits<int8_t>::max();
-	};
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 3;
-	}
-};
-template <>
-struct NumericLimits<int16_t> {
-	static constexpr int16_t Minimum() {
-		return std::numeric_limits<int16_t>::lowest();
-	};
-	static constexpr int16_t Maximum() {
-		return std::numeric_limits<int16_t>::max();
-	};
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 5;
-	}
-};
-template <>
-struct NumericLimits<int32_t> {
-	static constexpr int32_t Minimum() {
-		return std::numeric_limits<int32_t>::lowest();
-	};
-	static constexpr int32_t Maximum() {
-		return std::numeric_limits<int32_t>::max();
-	};
-	static bool IsSigned() {
-		return true;
 	}
-	static idx_t Digits() {
-		return 10;
+	DUCKDB_API static constexpr bool IsSigned() {
+		return std::is_signed<T>::value;
 	}
+	DUCKDB_API static constexpr idx_t Digits();
 };
 
-template <>
-struct NumericLimits<int64_t> {
-	static constexpr int64_t Minimum() {
-		return std::numeric_limits<int64_t>::lowest();
-	};
-	static constexpr int64_t Maximum() {
-		return std::numeric_limits<int64_t>::max();
-	};
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 19;
-	}
-};
 template <>
 struct NumericLimits<hugeint_t> {
 	static constexpr hugeint_t Minimum() {
@@ -98,104 +42,63 @@ struct NumericLimits<hugeint_t> {
 	static constexpr hugeint_t Maximum() {
 		return {std::numeric_limits<int64_t>::max(), std::numeric_limits<uint64_t>::max()};
 	};
-	static bool IsSigned() {
+	static constexpr bool IsSigned() {
 		return true;
 	}
-	static idx_t Digits() {
+
+	static constexpr idx_t Digits() {
 		return 39;
 	}
 };
 
 template <>
-struct NumericLimits<uint8_t> {
-	static constexpr uint8_t Minimum() {
-		return std::numeric_limits<uint8_t>::lowest();
-	};
-	static constexpr uint8_t Maximum() {
-		return std::numeric_limits<uint8_t>::max();
-	};
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 3;
-	}
-};
+constexpr idx_t NumericLimits<int8_t>::Digits() {
+	return 3;
+}
 
 template <>
-struct NumericLimits<uint16_t> {
-	static constexpr uint16_t Minimum() {
-		return std::numeric_limits<uint16_t>::lowest();
-	};
-	static constexpr uint16_t Maximum() {
-		return std::numeric_limits<uint16_t>::max();
-	};
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 5;
-	}
-};
+constexpr idx_t NumericLimits<int16_t>::Digits() {
+	return 5;
+}
+
 template <>
-struct NumericLimits<uint32_t> {
-	static constexpr uint32_t Minimum() {
-		return std::numeric_limits<uint32_t>::lowest();
-	};
-	static constexpr uint32_t Maximum() {
-		return std::numeric_limits<uint32_t>::max();
-	};
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 10;
-	}
-};
+constexpr idx_t NumericLimits<int32_t>::Digits() {
+	return 10;
+}
+
 template <>
-struct NumericLimits<uint64_t> {
-	static constexpr uint64_t Minimum() {
-		return std::numeric_limits<uint64_t>::lowest();
-	};
-	static constexpr uint64_t Maximum() {
-		return std::numeric_limits<uint64_t>::max();
-	};
-	static bool IsSigned() {
-		return false;
-	}
-	static idx_t Digits() {
-		return 20;
-	}
-};
+constexpr idx_t NumericLimits<int64_t>::Digits() {
+	return 19;
+}
+
 template <>
-struct NumericLimits<float> {
-	static constexpr float Minimum() {
-		return std::numeric_limits<float>::lowest();
-	};
-	static constexpr float Maximum() {
-		return std::numeric_limits<float>::max();
-	};
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 127;
-	}
-};
+constexpr idx_t NumericLimits<uint8_t>::Digits() {
+	return 3;
+}
+
 template <>
-struct NumericLimits<double> {
-	static constexpr double Minimum() {
-		return std::numeric_limits<double>::lowest();
-	};
-	static constexpr double Maximum() {
-		return std::numeric_limits<double>::max();
-	};
-	static bool IsSigned() {
-		return true;
-	}
-	static idx_t Digits() {
-		return 250;
-	}
-};
+constexpr idx_t NumericLimits<uint16_t>::Digits() {
+	return 5;
+}
+
+template <>
+constexpr idx_t NumericLimits<uint32_t>::Digits() {
+	return 10;
+}
+
+template <>
+constexpr idx_t NumericLimits<uint64_t>::Digits() {
+	return 20;
+}
+
+template <>
+constexpr idx_t NumericLimits<float>::Digits() {
+	return 127;
+}
+
+template <>
+constexpr idx_t NumericLimits<double>::Digits() {
+	return 250;
+}
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/numeric_utils.hpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/numeric_utils.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <type_traits>
+#include "duckdb/common/hugeint.hpp"
+
+namespace duckdb {
+
+template <class T>
+struct MakeSigned {
+	using type = typename std::make_signed<T>::type;
+};
+
+template <>
+struct MakeSigned<hugeint_t> {
+	using type = hugeint_t;
+};
+
+template <class T>
+struct MakeUnsigned {
+	using type = typename std::make_unsigned<T>::type;
+};
+
+// hugeint_t does not actually have an unsigned variant (yet), but this is required to make compression work
+// if an unsigned variant gets implemented this (probably) can be changed without breaking anything
+template <>
+struct MakeUnsigned<hugeint_t> {
+	using type = hugeint_t;
+};
+
+template <class T>
+struct IsIntegral {
+	static constexpr bool value = std::is_integral<T>::value;
+};
+
+template <>
+struct IsIntegral<hugeint_t> {
+	static constexpr bool value = true;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/core_functions/aggregate/distributive_functions.hpp

@@ -199,7 +199,7 @@ struct StringAggFun {
 	static constexpr const char *Name = "string_agg";
 	static constexpr const char *Parameters = "str,arg";
 	static constexpr const char *Description = "Concatenates the column string values with an optional separator.";
-	static constexpr const char *Example = "string_agg(A, '-)";
+	static constexpr const char *Example = "string_agg(A, '-')";
 
 	static AggregateFunctionSet GetFunctions();
 };

package/src/duckdb/src/include/duckdb/core_functions/scalar/operators_functions.hpp

@@ -28,7 +28,7 @@ struct BitwiseOrFun {
 	static constexpr const char *Name = "|";
 	static constexpr const char *Parameters = "left,right";
 	static constexpr const char *Description = "Bitwise OR";
-	static constexpr const char *Example = "32 & 3";
+	static constexpr const char *Example = "32 | 3";
 
 	static ScalarFunctionSet GetFunctions();
 };

package/src/duckdb/src/include/duckdb/core_functions/scalar/string_functions.hpp

@@ -453,4 +453,13 @@ struct OrdFun {
 	static constexpr const char *Name = "ord";
 };
 
+struct ToBaseFun {
+	static constexpr const char *Name = "to_base";
+	static constexpr const char *Parameters = "number,radix,min_length";
+	static constexpr const char *Description = "Converts a value to a string in the given base radix, optionally padding with leading zeros to the minimum length";
+	static constexpr const char *Example = "to_base(42, 16)";
+
+	static ScalarFunctionSet GetFunctions();
+};
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp

@@ -106,9 +106,9 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
-	                          GlobalSinkState &gstate) const override;
+	                          OperatorSinkFinalizeInput &input) const override;
 	SinkFinalizeType FinalizeInternal(Pipeline &pipeline, Event &event, ClientContext &context, GlobalSinkState &gstate,
 	                                  bool check_distinct) const;
 
@@ -141,7 +141,7 @@ private:
 	SinkFinalizeType FinalizeDistinct(Pipeline &pipeline, Event &event, ClientContext &context,
 	                                  GlobalSinkState &gstate) const;
 	//! Combine the distinct aggregates
-	void CombineDistinct(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const;
+	void CombineDistinct(ExecutionContext &context, OperatorSinkCombineInput &input) const;
 	//! Sink the distinct aggregates for a single grouping
 	void SinkDistinctGrouping(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input,
 	                          idx_t grouping_idx) const;

package/src/duckdb/src/include/duckdb/execution/operator/aggregate/physical_perfecthash_aggregate.hpp

@@ -46,7 +46,7 @@ public:
 public:
 	// Sink interface
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
-	void Combine(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate) const override;
+	SinkCombineResultType Combine(ExecutionContext &context, OperatorSinkCombineInput &input) const override;
 
 	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;