duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/storage/compression/bitpacking.cpp

@@ -1,19 +1,18 @@
 #include "duckdb/common/bitpacking.hpp"
 
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/numeric_utils.hpp"
+#include "duckdb/common/operator/add.hpp"
+#include "duckdb/common/operator/multiply.hpp"
+#include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/function/compression/compression.hpp"
 #include "duckdb/function/compression_function.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-
+#include "duckdb/storage/compression/bitpacking.hpp"
 #include "duckdb/storage/table/column_data_checkpointer.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
-#include "duckdb/common/operator/subtract.hpp"
-#include "duckdb/common/operator/multiply.hpp"
-#include "duckdb/common/operator/add.hpp"
-#include "duckdb/storage/compression/bitpacking.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
-#include "duckdb/common/numeric_utils.hpp"
 
 #include <functional>
 
@@ -63,7 +62,7 @@ typedef struct {
 typedef uint32_t bitpacking_metadata_encoded_t;
 
 static bitpacking_metadata_encoded_t EncodeMeta(bitpacking_metadata_t metadata) {
-	D_ASSERT(metadata.offset <= 16777215); // max uint24_t
+	D_ASSERT(metadata.offset <= 0x00FFFFFF); // max uint24_t
 	bitpacking_metadata_encoded_t encoded_value = metadata.offset;
 	encoded_value |= (uint8_t)metadata.mode << 24;
 	return encoded_value;
@@ -218,8 +217,11 @@ public:
 	template <class T_INNER>
 	void SubtractFrameOfReference(T_INNER *buffer, T_INNER frame_of_reference) {
 		static_assert(IsIntegral<T_INNER>::value, "Integral type required.");
+
+		using T_U = typename MakeUnsigned<T_INNER>::type;
+
 		for (idx_t i = 0; i < compression_buffer_idx; i++) {
-			buffer[i] -= static_cast<typename MakeUnsigned<T_INNER>::type>(frame_of_reference);
+			reinterpret_cast<T_U *>(buffer)[i] -= static_cast<T_U>(frame_of_reference);
 		}
 	}
 
@@ -250,10 +252,8 @@ public:
 			}
 
 			// Check if delta has benefit
-			// bitwidth is calculated differently between signed and unsigned values, but considering we do not have
-			// an unsigned version of hugeint, we need to explicitly specify (through boolean) that we wish to calculate
-			// the unsigned minimum bit-width instead of relying on MakeUnsigned and IsSigned
-			auto delta_required_bitwidth = BitpackingPrimitives::MinimumBitWidth<T, false>(min_max_delta_diff);
+			auto delta_required_bitwidth =
+			    BitpackingPrimitives::MinimumBitWidth<T, false>(static_cast<T>(min_max_delta_diff));
 			auto regular_required_bitwidth = BitpackingPrimitives::MinimumBitWidth(min_max_diff);
 
 			if (delta_required_bitwidth < regular_required_bitwidth && mode != BitpackingMode::FOR) {
@@ -331,7 +331,7 @@ unique_ptr<AnalyzeState> BitpackingInitAnalyze(ColumnData &col_data, PhysicalTyp
 
 template <class T>
 bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	auto &analyze_state = static_cast<BitpackingAnalyzeState<T> &>(state);
+	auto &analyze_state = state.Cast<BitpackingAnalyzeState<T>>();
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
@@ -347,7 +347,7 @@ bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 
 template <class T>
 idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
-	auto &bitpacking_state = static_cast<BitpackingAnalyzeState<T> &>(state);
+	auto &bitpacking_state = state.Cast<BitpackingAnalyzeState<T>>();
 	auto flush_result = bitpacking_state.state.template Flush<EmptyBitpackingWriter>();
 	if (!flush_result) {
 		return DConstants::INVALID_INDEX;
@@ -547,7 +547,7 @@ unique_ptr<CompressionState> BitpackingInitCompression(ColumnDataCheckpointer &c
 
 template <class T, bool WRITE_STATISTICS>
 void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = static_cast<BitpackingCompressState<T, WRITE_STATISTICS> &>(state_p);
+	auto &state = state_p.Cast<BitpackingCompressState<T, WRITE_STATISTICS>>();
 	UnifiedVectorFormat vdata;
 	scan_vector.ToUnifiedFormat(count, vdata);
 	state.Append(vdata, count);
@@ -555,7 +555,7 @@ void BitpackingCompress(CompressionState &state_p, Vector &scan_vector, idx_t co
 
 template <class T, bool WRITE_STATISTICS>
 void BitpackingFinalizeCompress(CompressionState &state_p) {
-	auto &state = static_cast<BitpackingCompressState<T, WRITE_STATISTICS> &>(state_p);
+	auto &state = state_p.Cast<BitpackingCompressState<T, WRITE_STATISTICS>>();
 	state.Finalize();
 }
 
@@ -564,11 +564,13 @@ void BitpackingFinalizeCompress(CompressionState &state_p) {
 //===--------------------------------------------------------------------===//
 template <class T>
 static void ApplyFrameOfReference(T *dst, T frame_of_reference, idx_t size) {
+	using T_U = typename MakeUnsigned<T>::type;
 	if (!frame_of_reference) {
 		return;
 	}
+
 	for (idx_t i = 0; i < size; i++) {
-		dst[i] += frame_of_reference;
+		reinterpret_cast<T_U *>(dst)[i] += static_cast<T_U>(frame_of_reference);
 	}
 }
 
@@ -688,55 +690,65 @@ public:
 		bool skip_sign_extend = true;
 
 		idx_t skipped = 0;
-		while (skipped < skip_count) {
-			// Exhausted this metadata group, move pointers to next group and load metadata for next group.
-			if (current_group_offset >= BITPACKING_METADATA_GROUP_SIZE) {
-				LoadNextGroup();
-			}
-
-			idx_t offset_in_compression_group =
-			    current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-			if (current_group.mode == BitpackingMode::CONSTANT) {
-				idx_t remaining = skip_count - skipped;
-				idx_t to_skip = MinValue(remaining, BITPACKING_METADATA_GROUP_SIZE - current_group_offset);
-				skipped += to_skip;
-				current_group_offset += to_skip;
-				continue;
-			}
-			if (current_group.mode == BitpackingMode::CONSTANT_DELTA) {
-				idx_t remaining = skip_count - skipped;
-				idx_t to_skip = MinValue(remaining, BITPACKING_METADATA_GROUP_SIZE - current_group_offset);
-				skipped += to_skip;
-				current_group_offset += to_skip;
-				continue;
-			}
-			D_ASSERT(current_group.mode == BitpackingMode::FOR || current_group.mode == BitpackingMode::DELTA_FOR);
-
-			idx_t to_skip =
-			    MinValue<idx_t>(skip_count - skipped,
-			                    BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - offset_in_compression_group);
-			// Calculate start of compression algorithm group
-			if (current_group.mode == BitpackingMode::DELTA_FOR) {
+		idx_t initial_group_offset = current_group_offset;
+
+		// This skips straight to the correct metadata group
+		idx_t meta_groups_to_skip = (skip_count + current_group_offset) / BITPACKING_METADATA_GROUP_SIZE;
+		if (meta_groups_to_skip) {
+
+			// bitpacking_metadata_ptr points to the next metadata: this means we need to advance the pointer by n-1
+			bitpacking_metadata_ptr -= (meta_groups_to_skip - 1) * sizeof(bitpacking_metadata_encoded_t);
+			LoadNextGroup();
+			// The first (partial) group we skipped
+			skipped += BITPACKING_METADATA_GROUP_SIZE - initial_group_offset;
+			// The remaining groups that were skipped
+			skipped += (meta_groups_to_skip - 1) * BITPACKING_METADATA_GROUP_SIZE;
+		}
+
+		// Assert we can are in the correct metadata group
+		idx_t remaining_to_skip = skip_count - skipped;
+		D_ASSERT(current_group_offset + remaining_to_skip < BITPACKING_METADATA_GROUP_SIZE);
+
+		if (current_group.mode == BitpackingMode::CONSTANT || current_group.mode == BitpackingMode::CONSTANT_DELTA ||
+		    current_group.mode == BitpackingMode::FOR) {
+			// Skipping within a constant or constant delta is done by increasing the current_group_offset
+			skipped += remaining_to_skip;
+			current_group_offset += remaining_to_skip;
+		} else {
+			// For DELTA we actually need to decompress from the current_group_offset up until the row we want to skip
+			// to this is because we need that delta to be able to continue scanning from here
+			D_ASSERT(current_group.mode == BitpackingMode::DELTA_FOR);
+
+			while (skipped < skip_count) {
+				// Calculate compression group offset and pointer
+				idx_t offset_in_compression_group =
+				    current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
 				data_ptr_t current_position_ptr = current_group_ptr + current_group_offset * current_width / 8;
 				data_ptr_t decompression_group_start_pointer =
 				    current_position_ptr - offset_in_compression_group * current_width / 8;
 
+				idx_t skipping_this_algorithm_group =
+				    MinValue(remaining_to_skip,
+				             BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - offset_in_compression_group);
+
 				BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(decompression_buffer),
 				                                     decompression_group_start_pointer, current_width,
 				                                     skip_sign_extend);
 
 				T *decompression_ptr = decompression_buffer + offset_in_compression_group;
 				ApplyFrameOfReference<T_S>(reinterpret_cast<T_S *>(decompression_ptr),
-				                           static_cast<T_S>(current_frame_of_reference), to_skip);
+				                           static_cast<T_S>(current_frame_of_reference), skipping_this_algorithm_group);
 				DeltaDecode<T_S>(reinterpret_cast<T_S *>(decompression_ptr), static_cast<T_S>(current_delta_offset),
-				                 to_skip);
-				current_delta_offset = decompression_ptr[to_skip - 1];
-			}
+				                 skipping_this_algorithm_group);
+				current_delta_offset = decompression_ptr[skipping_this_algorithm_group - 1];
 
-			skipped += to_skip;
-			current_group_offset += to_skip;
+				skipped += skipping_this_algorithm_group;
+				current_group_offset += skipping_this_algorithm_group;
+				remaining_to_skip -= skipping_this_algorithm_group;
+			}
 		}
+
+		D_ASSERT(skipped == skip_count);
 	}
 
 	data_ptr_t GetPtr(bitpacking_metadata_t group) {
@@ -756,7 +768,7 @@ unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
 template <class T, class T_S = typename MakeSigned<T>::type>
 void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
                            idx_t result_offset) {
-	auto &scan_state = static_cast<BitpackingScanState<T> &>(*state.scan_state);
+	auto &scan_state = state.scan_state->Cast<BitpackingScanState<T>>();
 
 	T *result_data = FlatVector::GetData<T>(result);
 	result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -766,8 +778,10 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 
 	idx_t scanned = 0;
 	while (scanned < scan_count) {
+		D_ASSERT(scan_state.current_group_offset <= BITPACKING_METADATA_GROUP_SIZE);
+
 		// Exhausted this metadata group, move pointers to next group and load metadata for next group.
-		if (scan_state.current_group_offset >= BITPACKING_METADATA_GROUP_SIZE) {
+		if (scan_state.current_group_offset == BITPACKING_METADATA_GROUP_SIZE) {
 			scan_state.LoadNextGroup();
 		}
 
@@ -853,6 +867,10 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
                         idx_t result_idx) {
 	BitpackingScanState<T> scan_state(segment);
 	scan_state.Skip(segment, row_id);
+
+	D_ASSERT(scan_state.current_group_offset < BITPACKING_METADATA_GROUP_SIZE);
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	T *result_data = FlatVector::GetData<T>(result);
 	T *current_result_ptr = result_data + result_idx;
 
@@ -898,6 +916,7 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
 		*current_result_ptr += scan_state.current_delta_offset;
 	}
 }
+
 template <class T>
 void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
 	auto &scan_state = static_cast<BitpackingScanState<T> &>(*state.scan_state);
@@ -937,6 +956,8 @@ CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
 		return GetBitpackingFunction<uint64_t>(type);
 	case PhysicalType::INT128:
 		return GetBitpackingFunction<hugeint_t>(type);
+	case PhysicalType::UINT128:
+		return GetBitpackingFunction<uhugeint_t>(type);
 	case PhysicalType::LIST:
 		return GetBitpackingFunction<uint64_t, false>(type);
 	default:
@@ -945,6 +966,15 @@ CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
 }
 
 bool BitpackingFun::TypeIsSupported(PhysicalType type) {
+
+	// we calculate on BITPACKING_METADATA_GROUP_SIZE tuples, but they can exceed the block size,
+	// in which case we have to disable bitpacking for that data type
+	// we are conservative here by multiplying by 2
+	auto type_size = GetTypeIdSize(type);
+	if (type_size * BITPACKING_METADATA_GROUP_SIZE * 2 > Storage::BLOCK_SIZE) {
+		return false;
+	}
+
 	switch (type) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -957,6 +987,7 @@ bool BitpackingFun::TypeIsSupported(PhysicalType type) {
 	case PhysicalType::UINT64:
 	case PhysicalType::LIST:
 	case PhysicalType::INT128:
+	case PhysicalType::UINT128:
 		return true;
 	default:
 		return false;

package/src/duckdb/src/storage/compression/bitpacking_hugeint.cpp

@@ -6,110 +6,110 @@ namespace duckdb {
 // Unpacking
 //===--------------------------------------------------------------------===//
 
-static void UnpackSingle(const uint32_t *__restrict &in, hugeint_t *__restrict out, uint16_t delta, uint16_t shr) {
+static void UnpackSingle(const uint32_t *__restrict &in, uhugeint_t *__restrict out, uint16_t delta, uint16_t shr) {
 	if (delta + shr < 32) {
-		*out = ((static_cast<hugeint_t>(in[0])) >> shr) % (hugeint_t(1) << delta);
+		*out = ((static_cast<uhugeint_t>(in[0])) >> shr) % (uhugeint_t(1) << delta);
 	}
 
 	else if (delta + shr >= 32 && delta + shr < 64) {
-		*out = static_cast<hugeint_t>(in[0]) >> shr;
+		*out = static_cast<uhugeint_t>(in[0]) >> shr;
 		++in;
 
 		if (delta + shr > 32) {
 			const uint16_t NEXT_SHR = shr + delta - 32;
-			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (32 - shr);
+			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (32 - shr);
 		}
 	}
 
 	else if (delta + shr >= 64 && delta + shr < 96) {
-		*out = static_cast<hugeint_t>(in[0]) >> shr;
-		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
+		*out = static_cast<uhugeint_t>(in[0]) >> shr;
+		*out |= static_cast<uhugeint_t>(in[1]) << (32 - shr);
 		in += 2;
 
 		if (delta + shr > 64) {
 			const uint16_t NEXT_SHR = delta + shr - 64;
-			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (64 - shr);
+			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (64 - shr);
 		}
 	}
 
 	else if (delta + shr >= 96 && delta + shr < 128) {
-		*out = static_cast<hugeint_t>(in[0]) >> shr;
-		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
-		*out |= static_cast<hugeint_t>(in[2]) << (64 - shr);
+		*out = static_cast<uhugeint_t>(in[0]) >> shr;
+		*out |= static_cast<uhugeint_t>(in[1]) << (32 - shr);
+		*out |= static_cast<uhugeint_t>(in[2]) << (64 - shr);
 		in += 3;
 
 		if (delta + shr > 96) {
 			const uint16_t NEXT_SHR = delta + shr - 96;
-			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (96 - shr);
+			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (96 - shr);
 		}
 	}
 
 	else if (delta + shr >= 128) {
-		*out = static_cast<hugeint_t>(in[0]) >> shr;
-		*out |= static_cast<hugeint_t>(in[1]) << (32 - shr);
-		*out |= static_cast<hugeint_t>(in[2]) << (64 - shr);
-		*out |= static_cast<hugeint_t>(in[3]) << (96 - shr);
+		*out = static_cast<uhugeint_t>(in[0]) >> shr;
+		*out |= static_cast<uhugeint_t>(in[1]) << (32 - shr);
+		*out |= static_cast<uhugeint_t>(in[2]) << (64 - shr);
+		*out |= static_cast<uhugeint_t>(in[3]) << (96 - shr);
 		in += 4;
 
 		if (delta + shr > 128) {
 			const uint16_t NEXT_SHR = delta + shr - 128;
-			*out |= static_cast<hugeint_t>((*in) % (1U << NEXT_SHR)) << (128 - shr);
+			*out |= static_cast<uhugeint_t>((*in) % (1U << NEXT_SHR)) << (128 - shr);
 		}
 	}
 }
 
-static void UnpackLast(const uint32_t *__restrict &in, hugeint_t *__restrict out, uint16_t delta) {
+static void UnpackLast(const uint32_t *__restrict &in, uhugeint_t *__restrict out, uint16_t delta) {
 	const uint8_t LAST_IDX = 31;
 	const uint16_t SHIFT = (delta * 31) % 32;
 	out[LAST_IDX] = in[0] >> SHIFT;
 	if (delta > 32) {
-		out[LAST_IDX] |= static_cast<hugeint_t>(in[1]) << (32 - SHIFT);
+		out[LAST_IDX] |= static_cast<uhugeint_t>(in[1]) << (32 - SHIFT);
 	}
 	if (delta > 64) {
-		out[LAST_IDX] |= static_cast<hugeint_t>(in[2]) << (64 - SHIFT);
+		out[LAST_IDX] |= static_cast<uhugeint_t>(in[2]) << (64 - SHIFT);
 	}
 	if (delta > 96) {
-		out[LAST_IDX] |= static_cast<hugeint_t>(in[3]) << (96 - SHIFT);
+		out[LAST_IDX] |= static_cast<uhugeint_t>(in[3]) << (96 - SHIFT);
 	}
 }
 
 // Unpacks for specific deltas
-static void UnpackDelta0(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+static void UnpackDelta0(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		out[i] = 0;
 	}
 }
 
-static void UnpackDelta32(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+static void UnpackDelta32(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
 	for (uint8_t k = 0; k < 32; ++k) {
-		out[k] = static_cast<hugeint_t>(in[k]);
+		out[k] = static_cast<uhugeint_t>(in[k]);
 	}
 }
 
-static void UnpackDelta64(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+static void UnpackDelta64(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		const uint8_t OFFSET = i * 2;
 		out[i] = in[OFFSET];
-		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 1]) << 32;
 	}
 }
 
-static void UnpackDelta96(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+static void UnpackDelta96(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		const uint8_t OFFSET = i * 3;
 		out[i] = in[OFFSET];
-		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
-		out[i] |= static_cast<hugeint_t>(in[OFFSET + 2]) << 64;
+		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 2]) << 64;
 	}
 }
 
-static void UnpackDelta128(const uint32_t *__restrict in, hugeint_t *__restrict out) {
+static void UnpackDelta128(const uint32_t *__restrict in, uhugeint_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		const uint8_t OFFSET = i * 4;
 		out[i] = in[OFFSET];
-		out[i] |= static_cast<hugeint_t>(in[OFFSET + 1]) << 32;
-		out[i] |= static_cast<hugeint_t>(in[OFFSET + 2]) << 64;
-		out[i] |= static_cast<hugeint_t>(in[OFFSET + 3]) << 96;
+		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 1]) << 32;
+		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 2]) << 64;
+		out[i] |= static_cast<uhugeint_t>(in[OFFSET + 3]) << 96;
 	}
 }
 
@@ -117,7 +117,7 @@ static void UnpackDelta128(const uint32_t *__restrict in, hugeint_t *__restrict
 // Packing
 //===--------------------------------------------------------------------===//
 
-static void PackSingle(const hugeint_t in, uint32_t *__restrict &out, uint16_t delta, uint16_t shl, hugeint_t mask) {
+static void PackSingle(const uhugeint_t in, uint32_t *__restrict &out, uint16_t delta, uint16_t shl, uhugeint_t mask) {
 	if (delta + shl < 32) {
 
 		if (shl == 0) {
@@ -186,7 +186,7 @@ static void PackSingle(const hugeint_t in, uint32_t *__restrict &out, uint16_t d
 	}
 }
 
-static void PackLast(const hugeint_t *__restrict in, uint32_t *__restrict out, uint16_t delta) {
+static void PackLast(const uhugeint_t *__restrict in, uint32_t *__restrict out, uint16_t delta) {
 	const uint8_t LAST_IDX = 31;
 	const uint16_t SHIFT = (delta * 31) % 32;
 	out[0] |= static_cast<uint32_t>(in[LAST_IDX] << SHIFT);
@@ -202,13 +202,13 @@ static void PackLast(const hugeint_t *__restrict in, uint32_t *__restrict out, u
 }
 
 // Packs for specific deltas
-static void PackDelta32(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+static void PackDelta32(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		out[i] = static_cast<uint32_t>(in[i]);
 	}
 }
 
-static void PackDelta64(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+static void PackDelta64(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		const uint8_t OFFSET = 2 * i;
 		out[OFFSET] = static_cast<uint32_t>(in[i]);
@@ -216,7 +216,7 @@ static void PackDelta64(const hugeint_t *__restrict in, uint32_t *__restrict out
 	}
 }
 
-static void PackDelta96(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+static void PackDelta96(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		const uint8_t OFFSET = 3 * i;
 		out[OFFSET] = static_cast<uint32_t>(in[i]);
@@ -225,7 +225,7 @@ static void PackDelta96(const hugeint_t *__restrict in, uint32_t *__restrict out
 	}
 }
 
-static void PackDelta128(const hugeint_t *__restrict in, uint32_t *__restrict out) {
+static void PackDelta128(const uhugeint_t *__restrict in, uint32_t *__restrict out) {
 	for (uint8_t i = 0; i < 32; ++i) {
 		const uint8_t OFFSET = 4 * i;
 		out[OFFSET] = static_cast<uint32_t>(in[i]);
@@ -239,7 +239,7 @@ static void PackDelta128(const hugeint_t *__restrict in, uint32_t *__restrict ou
 // HugeIntPacker
 //===--------------------------------------------------------------------===//
 
-void HugeIntPacker::Pack(const hugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width) {
+void HugeIntPacker::Pack(const uhugeint_t *__restrict in, uint32_t *__restrict out, bitpacking_width_t width) {
 	D_ASSERT(width <= 128);
 	switch (width) {
 	case 0:
@@ -259,13 +259,13 @@ void HugeIntPacker::Pack(const hugeint_t *__restrict in, uint32_t *__restrict ou
 	default:
 		for (idx_t oindex = 0; oindex < BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE - 1; ++oindex) {
 			PackSingle(in[oindex], out, width, (width * oindex) % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE,
-			           (hugeint_t(1) << width) - 1);
+			           (uhugeint_t(1) << width) - 1);
 		}
 		PackLast(in, out, width);
 	}
 }
 
-void HugeIntPacker::Unpack(const uint32_t *__restrict in, hugeint_t *__restrict out, bitpacking_width_t width) {
+void HugeIntPacker::Unpack(const uint32_t *__restrict in, uhugeint_t *__restrict out, bitpacking_width_t width) {
 	D_ASSERT(width <= 128);
 	switch (width) {
 	case 0:

package/src/duckdb/src/storage/compression/dictionary_compression.cpp

@@ -4,10 +4,8 @@
 #include "duckdb/common/types/vector_buffer.hpp"
 #include "duckdb/function/compression/compression.hpp"
 #include "duckdb/function/compression_function.hpp"
-#include "duckdb/main/config.hpp"
 #include "duckdb/storage/segment/uncompressed.hpp"
 #include "duckdb/storage/string_uncompressed.hpp"
-#include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/column_data_checkpointer.hpp"
 
 namespace duckdb {
@@ -612,7 +610,7 @@ void DictionaryCompressionStorage::SetDictionary(ColumnSegment &segment, BufferH
 string_t DictionaryCompressionStorage::FetchStringFromDict(ColumnSegment &segment, StringDictionaryContainer dict,
                                                            data_ptr_t baseptr, int32_t dict_offset,
                                                            uint16_t string_len) {
-	D_ASSERT(dict_offset >= 0 && dict_offset <= Storage::BLOCK_SIZE);
+	D_ASSERT(dict_offset >= 0 && dict_offset <= int32_t(Storage::BLOCK_SIZE));
 
 	if (dict_offset == 0) {
 		return string_t(nullptr, 0);

package/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp

@@ -284,6 +284,8 @@ CompressionFunction FixedSizeUncompressed::GetFunction(PhysicalType data_type) {
 		return FixedSizeGetFunction<uint64_t>(data_type);
 	case PhysicalType::INT128:
 		return FixedSizeGetFunction<hugeint_t>(data_type);
+	case PhysicalType::UINT128:
+		return FixedSizeGetFunction<uhugeint_t>(data_type);
 	case PhysicalType::FLOAT:
 		return FixedSizeGetFunction<float>(data_type);
 	case PhysicalType::DOUBLE:

package/src/duckdb/src/storage/compression/fsst.cpp

@@ -392,17 +392,17 @@ public:
 
 unique_ptr<CompressionState> FSSTStorage::InitCompression(ColumnDataCheckpointer &checkpointer,
                                                           unique_ptr<AnalyzeState> analyze_state_p) {
-	auto analyze_state = static_cast<FSSTAnalyzeState *>(analyze_state_p.get());
+	auto &analyze_state = analyze_state_p->Cast<FSSTAnalyzeState>();
 	auto compression_state = make_uniq<FSSTCompressionState>(checkpointer);
 
-	if (analyze_state->fsst_encoder == nullptr) {
+	if (analyze_state.fsst_encoder == nullptr) {
 		throw InternalException("No encoder found during FSST compression");
 	}
 
-	compression_state->fsst_encoder = analyze_state->fsst_encoder;
+	compression_state->fsst_encoder = analyze_state.fsst_encoder;
 	compression_state->fsst_serialized_symbol_table_size =
 	    duckdb_fsst_export(compression_state->fsst_encoder, &compression_state->fsst_serialized_symbol_table[0]);
-	analyze_state->fsst_encoder = nullptr;
+	analyze_state.fsst_encoder = nullptr;
 
 	return std::move(compression_state);
 }

package/src/duckdb/src/storage/compression/numeric_constant.cpp

@@ -128,6 +128,8 @@ CompressionFunction ConstantFun::GetFunction(PhysicalType data_type) {
 		return ConstantGetFunction<uint64_t>(data_type);
 	case PhysicalType::INT128:
 		return ConstantGetFunction<hugeint_t>(data_type);
+	case PhysicalType::UINT128:
+		return ConstantGetFunction<uhugeint_t>(data_type);
 	case PhysicalType::FLOAT:
 		return ConstantGetFunction<float>(data_type);
 	case PhysicalType::DOUBLE:
@@ -150,6 +152,7 @@ bool ConstantFun::TypeIsSupported(PhysicalType type) {
 	case PhysicalType::UINT32:
 	case PhysicalType::UINT64:
 	case PhysicalType::INT128:
+	case PhysicalType::UINT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
 		return true;

package/src/duckdb/src/storage/compression/rle.cpp

@@ -132,8 +132,7 @@ struct RLECompressState : public CompressionState {
 	static idx_t MaxRLECount() {
 		auto entry_size = sizeof(T) + sizeof(rle_count_t);
 		auto entry_count = (Storage::BLOCK_SIZE - RLEConstants::RLE_HEADER_SIZE) / entry_size;
-		auto max_vector_count = entry_count / STANDARD_VECTOR_SIZE;
-		return max_vector_count * STANDARD_VECTOR_SIZE;
+		return entry_count;
 	}
 
 	explicit RLECompressState(ColumnDataCheckpointer &checkpointer_p)
@@ -228,7 +227,7 @@ unique_ptr<CompressionState> RLEInitCompression(ColumnDataCheckpointer &checkpoi
 
 template <class T, bool WRITE_STATISTICS>
 void RLECompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
-	auto &state = (RLECompressState<T, WRITE_STATISTICS> &)state_p;
+	auto &state = state_p.Cast<RLECompressState<T, WRITE_STATISTICS>>();
 	UnifiedVectorFormat vdata;
 	scan_vector.ToUnifiedFormat(count, vdata);
 
@@ -237,7 +236,7 @@ void RLECompress(CompressionState &state_p, Vector &scan_vector, idx_t count) {
 
 template <class T, bool WRITE_STATISTICS>
 void RLEFinalizeCompress(CompressionState &state_p) {
-	auto &state = (RLECompressState<T, WRITE_STATISTICS> &)state_p;
+	auto &state = state_p.Cast<RLECompressState<T, WRITE_STATISTICS>>();
 	state.Finalize();
 }
 
@@ -411,6 +410,8 @@ CompressionFunction RLEFun::GetFunction(PhysicalType type) {
 		return GetRLEFunction<int64_t>(type);
 	case PhysicalType::INT128:
 		return GetRLEFunction<hugeint_t>(type);
+	case PhysicalType::UINT128:
+		return GetRLEFunction<uhugeint_t>(type);
 	case PhysicalType::UINT8:
 		return GetRLEFunction<uint8_t>(type);
 	case PhysicalType::UINT16:
@@ -442,6 +443,7 @@ bool RLEFun::TypeIsSupported(PhysicalType type) {
 	case PhysicalType::UINT16:
 	case PhysicalType::UINT32:
 	case PhysicalType::UINT64:
+	case PhysicalType::UINT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
 	case PhysicalType::LIST: