duckdb 0.8.2-dev87.0 → 0.9.0

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

@@ -9,8 +9,11 @@
 #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>
 
@@ -20,8 +23,7 @@ static constexpr const idx_t BITPACKING_METADATA_GROUP_SIZE = STANDARD_VECTOR_SI
 
 BitpackingMode BitpackingModeFromString(const string &str) {
 	auto mode = StringUtil::Lower(str);
-
-	if (mode == "auto") {
+	if (mode == "auto" || mode == "none") {
 		return BitpackingMode::AUTO;
 	} else if (mode == "constant") {
 		return BitpackingMode::CONSTANT;
@@ -32,21 +34,21 @@ BitpackingMode BitpackingModeFromString(const string &str) {
 	} else if (mode == "for") {
 		return BitpackingMode::FOR;
 	} else {
-		return BitpackingMode::AUTO;
+		return BitpackingMode::INVALID;
 	}
 }
 
 string BitpackingModeToString(const BitpackingMode &mode) {
 	switch (mode) {
-	case (BitpackingMode::AUTO):
+	case BitpackingMode::AUTO:
 		return "auto";
-	case (BitpackingMode::CONSTANT):
+	case BitpackingMode::CONSTANT:
 		return "constant";
-	case (BitpackingMode::CONSTANT_DELTA):
+	case BitpackingMode::CONSTANT_DELTA:
 		return "constant_delta";
-	case (BitpackingMode::DELTA_FOR):
+	case BitpackingMode::DELTA_FOR:
 		return "delta_for";
-	case (BitpackingMode::FOR):
+	case BitpackingMode::FOR:
 		return "for";
 	default:
 		throw NotImplementedException("Unknown bitpacking mode: " + to_string((uint8_t)mode) + "\n");
@@ -77,11 +79,11 @@ struct EmptyBitpackingWriter {
 	template <class T>
 	static void WriteConstant(T constant, idx_t count, void *data_ptr, bool all_invalid) {
 	}
-	template <class T, class T_S = typename std::make_signed<T>::type>
+	template <class T, class T_S = typename MakeSigned<T>::type>
 	static void WriteConstantDelta(T_S constant, T frame_of_reference, idx_t count, T *values, bool *validity,
 	                               void *data_ptr) {
 	}
-	template <class T, class T_S = typename std::make_signed<T>::type>
+	template <class T, class T_S = typename MakeSigned<T>::type>
 	static void WriteDeltaFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference,
 	                          T_S delta_offset, T *original_values, idx_t count, void *data_ptr) {
 	}
@@ -91,11 +93,11 @@ struct EmptyBitpackingWriter {
 	}
 };
 
-template <class T, class T_U = typename std::make_unsigned<T>::type, class T_S = typename std::make_signed<T>::type>
+template <class T, class T_S = typename MakeSigned<T>::type>
 struct BitpackingState {
 public:
 	BitpackingState() : compression_buffer_idx(0), total_size(0), data_ptr(nullptr) {
-		compression_buffer_internal[0] = (T)0;
+		compression_buffer_internal[0] = T(0);
 		compression_buffer = &compression_buffer_internal[1];
 		Reset();
 	}
@@ -151,14 +153,14 @@ public:
 	void CalculateDeltaStats() {
 		// TODO: currently we dont support delta compression of values above NumericLimits<T_S>::Maximum(),
 		// 		 we could support this with some clever substract trickery?
-		if (maximum > (T)NumericLimits<T_S>::Maximum()) {
+		if (maximum > static_cast<T>(NumericLimits<T_S>::Maximum())) {
 			return;
 		}
 
 		// Don't delta encoding 1 value makes no sense
 		if (compression_buffer_idx < 2) {
 			return;
-		};
+		}
 
 		// TODO: handle NULLS here?
 		// Currently we cannot handle nulls because we would need an additional step of patching for this.
@@ -172,21 +174,25 @@ public:
 		// Note: since we dont allow any values over NumericLimits<T_S>::Maximum(), all subtractions for unsigned types
 		// are guaranteed not to overflow
 		bool can_do_all = true;
-		if (std::is_signed<T>()) {
+		if (NumericLimits<T>::IsSigned()) {
 			T_S bogus;
-			can_do_all = TrySubtractOperator::Operation((T_S)(minimum), (T_S)(maximum), bogus) &&
-			             TrySubtractOperator::Operation((T_S)(maximum), (T_S)(minimum), bogus);
+			can_do_all = TrySubtractOperator::Operation(static_cast<T_S>(minimum), static_cast<T_S>(maximum), bogus) &&
+			             TrySubtractOperator::Operation(static_cast<T_S>(maximum), static_cast<T_S>(minimum), bogus);
 		}
 
 		// Calculate delta's
+		// compression_buffer pointer points one element ahead of the internal buffer making the use of signed index
+		// integer (-1) possible
+		D_ASSERT(compression_buffer_idx <= NumericLimits<int64_t>::Maximum());
 		if (can_do_all) {
-			for (int64_t i = 0; i < (int64_t)compression_buffer_idx; i++) {
-				delta_buffer[i] = (T_S)compression_buffer[i] - (T_S)compression_buffer[i - 1];
+			for (int64_t i = 0; i < static_cast<int64_t>(compression_buffer_idx); i++) {
+				delta_buffer[i] = static_cast<T_S>(compression_buffer[i]) - static_cast<T_S>(compression_buffer[i - 1]);
 			}
 		} else {
-			for (int64_t i = 0; i < (int64_t)compression_buffer_idx; i++) {
-				auto success = TrySubtractOperator::Operation((T_S)(compression_buffer[i]),
-				                                              (T_S)(compression_buffer[i - 1]), delta_buffer[i]);
+			for (int64_t i = 0; i < static_cast<int64_t>(compression_buffer_idx); i++) {
+				auto success =
+				    TrySubtractOperator::Operation(static_cast<T_S>(compression_buffer[i]),
+				                                   static_cast<T_S>(compression_buffer[i - 1]), delta_buffer[i]);
 				if (!success) {
 					return;
 				}
@@ -195,7 +201,7 @@ public:
 
 		can_do_delta = true;
 
-		for (int64_t i = 1; i < (int64_t)compression_buffer_idx; i++) {
+		for (idx_t i = 1; i < compression_buffer_idx; i++) {
 			maximum_delta = MaxValue<T_S>(maximum_delta, delta_buffer[i]);
 			minimum_delta = MinValue<T_S>(minimum_delta, delta_buffer[i]);
 		}
@@ -205,15 +211,15 @@ public:
 		delta_buffer[0] = minimum_delta;
 
 		can_do_delta = can_do_delta && TrySubtractOperator::Operation(maximum_delta, minimum_delta, min_max_delta_diff);
-		can_do_delta =
-		    can_do_delta && TrySubtractOperator::Operation((T_S)(compression_buffer[0]), minimum_delta, delta_offset);
+		can_do_delta = can_do_delta && TrySubtractOperator::Operation(static_cast<T_S>(compression_buffer[0]),
+		                                                              minimum_delta, delta_offset);
 	}
 
 	template <class T_INNER>
 	void SubtractFrameOfReference(T_INNER *buffer, T_INNER frame_of_reference) {
-		static_assert(std::is_integral<T_INNER>::value, "Integral type required.");
+		static_assert(IsIntegral<T_INNER>::value, "Integral type required.");
 		for (idx_t i = 0; i < compression_buffer_idx; i++) {
-			buffer[i] -= uint64_t(frame_of_reference);
+			buffer[i] -= static_cast<typename MakeUnsigned<T_INNER>::type>(frame_of_reference);
 		}
 	}
 
@@ -234,23 +240,28 @@ public:
 
 		if (can_do_delta) {
 			if (maximum_delta == minimum_delta && mode != BitpackingMode::FOR && mode != BitpackingMode::DELTA_FOR) {
-				idx_t frame_of_reference = compression_buffer[0];
-				OP::WriteConstantDelta((T_S)maximum_delta, (T)frame_of_reference, compression_buffer_idx,
-				                       (T *)compression_buffer, (bool *)compression_buffer_validity, data_ptr);
+				// FOR needs to be T (considering hugeint is bigger than idx_t)
+				T frame_of_reference = compression_buffer[0];
+
+				OP::WriteConstantDelta(maximum_delta, static_cast<T>(frame_of_reference), compression_buffer_idx,
+				                       compression_buffer, compression_buffer_validity, data_ptr);
 				total_size += sizeof(T) + sizeof(T) + sizeof(bitpacking_metadata_encoded_t);
 				return true;
 			}
 
 			// Check if delta has benefit
-			auto delta_required_bitwidth = BitpackingPrimitives::MinimumBitWidth<T_U>(min_max_delta_diff);
+			// 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 regular_required_bitwidth = BitpackingPrimitives::MinimumBitWidth(min_max_diff);
 
 			if (delta_required_bitwidth < regular_required_bitwidth && mode != BitpackingMode::FOR) {
 				SubtractFrameOfReference(delta_buffer, minimum_delta);
 
-				OP::WriteDeltaFor((T *)delta_buffer, compression_buffer_validity, delta_required_bitwidth,
-				                  (T)minimum_delta, delta_offset, (T *)compression_buffer, compression_buffer_idx,
-				                  data_ptr);
+				OP::WriteDeltaFor(reinterpret_cast<T *>(delta_buffer), compression_buffer_validity,
+				                  delta_required_bitwidth, static_cast<T>(minimum_delta), delta_offset,
+				                  compression_buffer, compression_buffer_idx, data_ptr);
 
 				total_size += BitpackingPrimitives::GetRequiredSize(compression_buffer_idx, delta_required_bitwidth);
 				total_size += sizeof(T);                              // FOR value
@@ -262,7 +273,7 @@ public:
 		}
 
 		if (can_do_for) {
-			auto width = BitpackingPrimitives::MinimumBitWidth<T_U>(min_max_diff);
+			auto width = BitpackingPrimitives::MinimumBitWidth<T, false>(min_max_diff);
 			SubtractFrameOfReference(compression_buffer, minimum);
 			OP::WriteFor(compression_buffer, compression_buffer_validity, width, minimum, compression_buffer_idx,
 			             data_ptr);
@@ -320,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 = (BitpackingAnalyzeState<T> &)state;
+	auto &analyze_state = static_cast<BitpackingAnalyzeState<T> &>(state);
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
@@ -336,7 +347,7 @@ bool BitpackingAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 
 template <class T>
 idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
-	auto &bitpacking_state = (BitpackingAnalyzeState<T> &)state;
+	auto &bitpacking_state = static_cast<BitpackingAnalyzeState<T> &>(state);
 	auto flush_result = bitpacking_state.state.template Flush<EmptyBitpackingWriter>();
 	if (!flush_result) {
 		return DConstants::INVALID_INDEX;
@@ -347,7 +358,7 @@ idx_t BitpackingFinalAnalyze(AnalyzeState &state) {
 //===--------------------------------------------------------------------===//
 // Compress
 //===--------------------------------------------------------------------===//
-template <class T, bool WRITE_STATISTICS, class T_S = typename std::make_signed<T>::type>
+template <class T, bool WRITE_STATISTICS, class T_S = typename MakeSigned<T>::type>
 struct BitpackingCompressState : public CompressionState {
 public:
 	explicit BitpackingCompressState(ColumnDataCheckpointer &checkpointer)
@@ -355,7 +366,7 @@ public:
 	      function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING)) {
 		CreateEmptySegment(checkpointer.GetRowGroup().start);
 
-		state.data_ptr = (void *)this;
+		state.data_ptr = reinterpret_cast<void *>(this);
 
 		auto &config = DBConfig::GetConfig(checkpointer.GetDatabase());
 		state.mode = config.options.force_bitpacking_mode;
@@ -376,7 +387,7 @@ public:
 public:
 	struct BitpackingWriter {
 		static void WriteConstant(T constant, idx_t count, void *data_ptr, bool all_invalid) {
-			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
+			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
 
 			ReserveSpace(state, sizeof(T));
 			WriteMetaData(state, BitpackingMode::CONSTANT);
@@ -387,7 +398,7 @@ public:
 
 		static void WriteConstantDelta(T_S constant, T frame_of_reference, idx_t count, T *values, bool *validity,
 		                               void *data_ptr) {
-			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
+			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
 
 			ReserveSpace(state, 2 * sizeof(T));
 			WriteMetaData(state, BitpackingMode::CONSTANT_DELTA);
@@ -396,17 +407,16 @@ public:
 
 			UpdateStats(state, count);
 		}
-
 		static void WriteDeltaFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference,
 		                          T_S delta_offset, T *original_values, idx_t count, void *data_ptr) {
-			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
+			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
 
 			auto bp_size = BitpackingPrimitives::GetRequiredSize(count, width);
 			ReserveSpace(state, bp_size + 3 * sizeof(T));
 
 			WriteMetaData(state, BitpackingMode::DELTA_FOR);
 			WriteData(state->data_ptr, frame_of_reference);
-			WriteData(state->data_ptr, (T)width);
+			WriteData(state->data_ptr, static_cast<T>(width));
 			WriteData(state->data_ptr, delta_offset);
 
 			BitpackingPrimitives::PackBuffer<T, false>(state->data_ptr, values, count, width);
@@ -417,7 +427,7 @@ public:
 
 		static void WriteFor(T *values, bool *validity, bitpacking_width_t width, T frame_of_reference, idx_t count,
 		                     void *data_ptr) {
-			auto state = (BitpackingCompressState<T, WRITE_STATISTICS> *)data_ptr;
+			auto state = reinterpret_cast<BitpackingCompressState<T, WRITE_STATISTICS> *>(data_ptr);
 
 			auto bp_size = BitpackingPrimitives::GetRequiredSize(count, width);
 			ReserveSpace(state, bp_size + 2 * sizeof(T));
@@ -434,7 +444,7 @@ public:
 
 		template <class T_OUT>
 		static void WriteData(data_ptr_t &ptr, T_OUT val) {
-			*((T_OUT *)ptr) = val;
+			*reinterpret_cast<T_OUT *>(ptr) = val;
 			ptr += sizeof(T_OUT);
 		}
 
@@ -485,7 +495,7 @@ public:
 		auto data = UnifiedVectorFormat::GetData<T>(vdata);
 
 		for (idx_t i = 0; i < count; i++) {
-			auto idx = vdata.sel->get_index(i);
+			idx_t idx = vdata.sel->get_index(i);
 			state.template Update<BitpackingCompressState<T, WRITE_STATISTICS, T_S>::BitpackingWriter>(
 			    data[idx], vdata.validity.RowIsValid(idx));
 		}
@@ -493,7 +503,7 @@ public:
 
 	void FlushAndCreateSegmentIfFull(idx_t required_data_bytes, idx_t required_meta_bytes) {
 		if (!CanStore(required_data_bytes, required_meta_bytes)) {
-			auto row_start = current_segment->start + current_segment->count;
+			idx_t row_start = current_segment->start + current_segment->count;
 			FlushSegment();
 			CreateEmptySegment(row_start);
 		}
@@ -537,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 = (BitpackingCompressState<T, WRITE_STATISTICS> &)state_p;
+	auto &state = static_cast<BitpackingCompressState<T, WRITE_STATISTICS> &>(state_p);
 	UnifiedVectorFormat vdata;
 	scan_vector.ToUnifiedFormat(count, vdata);
 	state.Append(vdata, count);
@@ -545,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 = (BitpackingCompressState<T, WRITE_STATISTICS> &)state_p;
+	auto &state = static_cast<BitpackingCompressState<T, WRITE_STATISTICS> &>(state_p);
 	state.Finalize();
 }
 
@@ -588,7 +598,7 @@ static T DeltaDecode(T *data, T previous_value, const size_t size) {
 	return data[size - 1];
 }
 
-template <class T, class T_S = typename std::make_signed<T>::type>
+template <class T, class T_S = typename MakeSigned<T>::type>
 struct BitpackingScanState : public SegmentScanState {
 public:
 	explicit BitpackingScanState(ColumnSegment &segment) : current_segment(segment) {
@@ -629,7 +639,7 @@ public:
 		D_ASSERT(bitpacking_metadata_ptr > handle.Ptr() &&
 		         bitpacking_metadata_ptr < handle.Ptr() + Storage::BLOCK_SIZE);
 		current_group_offset = 0;
-		current_group = DecodeMeta((bitpacking_metadata_encoded_t *)bitpacking_metadata_ptr);
+		current_group = DecodeMeta(reinterpret_cast<bitpacking_metadata_encoded_t *>(bitpacking_metadata_ptr));
 
 		bitpacking_metadata_ptr -= sizeof(bitpacking_metadata_encoded_t);
 		current_group_ptr = GetPtr(current_group);
@@ -637,13 +647,13 @@ public:
 		// Read first value
 		switch (current_group.mode) {
 		case BitpackingMode::CONSTANT:
-			current_constant = *(T *)(current_group_ptr);
+			current_constant = *reinterpret_cast<T *>(current_group_ptr);
 			current_group_ptr += sizeof(T);
 			break;
 		case BitpackingMode::FOR:
 		case BitpackingMode::CONSTANT_DELTA:
 		case BitpackingMode::DELTA_FOR:
-			current_frame_of_reference = *(T *)(current_group_ptr);
+			current_frame_of_reference = *reinterpret_cast<T *>(current_group_ptr);
 			current_group_ptr += sizeof(T);
 			break;
 		default:
@@ -653,12 +663,12 @@ public:
 		// Read second value
 		switch (current_group.mode) {
 		case BitpackingMode::CONSTANT_DELTA:
-			current_constant = *(T *)(current_group_ptr);
+			current_constant = *reinterpret_cast<T *>(current_group_ptr);
 			current_group_ptr += sizeof(T);
 			break;
 		case BitpackingMode::FOR:
 		case BitpackingMode::DELTA_FOR:
-			current_width = (bitpacking_width_t) * (T *)(current_group_ptr);
+			current_width = (bitpacking_width_t)(*reinterpret_cast<T *>(current_group_ptr));
 			current_group_ptr += MaxValue(sizeof(T), sizeof(bitpacking_width_t));
 			break;
 		case BitpackingMode::CONSTANT:
@@ -669,54 +679,63 @@ public:
 
 		// Read third value
 		if (current_group.mode == BitpackingMode::DELTA_FOR) {
-			current_delta_offset = *(T *)(current_group_ptr);
+			current_delta_offset = *reinterpret_cast<T *>(current_group_ptr);
 			current_group_ptr += sizeof(T);
 		}
 	}
 
 	void Skip(ColumnSegment &segment, idx_t skip_count) {
-		while (skip_count > 0) {
-			if (current_group_offset + skip_count < BITPACKING_METADATA_GROUP_SIZE) {
-				// Skipping Delta FOR requires a bit of decoding to figure out the new delta
-				if (current_group.mode == BitpackingMode::DELTA_FOR) {
-					// if current_group_offset points into the middle of a
-					// BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE, we need to scan a few
-					// values before current_group_offset to align with the algorithm groups
-					idx_t extra_count = current_group_offset % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE;
-
-					// Calculate total offset and count to bitunpack
-					idx_t base_decompress_count = BitpackingPrimitives::RoundUpToAlgorithmGroupSize(skip_count);
-					idx_t decompress_count = base_decompress_count + extra_count;
-					idx_t decompress_offset = current_group_offset - extra_count;
-					bool skip_sign_extension = true;
-
-					BitpackingPrimitives::UnPackBuffer<T>(data_ptr_cast(decompression_buffer),
-					                                      current_group_ptr + decompress_offset, decompress_count,
-					                                      current_width, skip_sign_extension);
-
-					ApplyFrameOfReference<T_S>((T_S *)&decompression_buffer[extra_count], current_frame_of_reference,
-					                           skip_count);
-					DeltaDecode<T_S>((T_S *)&decompression_buffer[extra_count], (T_S)current_delta_offset,
-					                 (idx_t)skip_count);
-					current_delta_offset = decompression_buffer[extra_count + skip_count - 1];
-
-					current_group_offset += skip_count;
-				} else {
-					current_group_offset += skip_count;
-				}
-				break;
-			} else {
-				auto left_in_this_group = BITPACKING_METADATA_GROUP_SIZE - current_group_offset;
-				auto number_of_groups_to_skip = (skip_count - left_in_this_group) / BITPACKING_METADATA_GROUP_SIZE;
-
-				current_group_offset = 0;
-				bitpacking_metadata_ptr -= number_of_groups_to_skip * sizeof(bitpacking_metadata_encoded_t);
+		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;
 
-				skip_count -= left_in_this_group;
-				skip_count -= number_of_groups_to_skip * BITPACKING_METADATA_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) {
+				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;
+
+				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);
+				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];
 			}
+
+			skipped += to_skip;
+			current_group_offset += to_skip;
 		}
 	}
 
@@ -734,10 +753,10 @@ unique_ptr<SegmentScanState> BitpackingInitScan(ColumnSegment &segment) {
 //===--------------------------------------------------------------------===//
 // Scan base data
 //===--------------------------------------------------------------------===//
-template <class T, class T_S = typename std::make_signed<T>::type>
+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 = (BitpackingScanState<T> &)*state.scan_state;
+	auto &scan_state = static_cast<BitpackingScanState<T> &>(*state.scan_state);
 
 	T *result_data = FlatVector::GetData<T>(result);
 	result.SetVectorType(VectorType::FLAT_VECTOR);
@@ -746,7 +765,6 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 	bool skip_sign_extend = true;
 
 	idx_t scanned = 0;
-
 	while (scanned < scan_count) {
 		// 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) {
@@ -772,7 +790,7 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 			T *target_ptr = result_data + result_offset + scanned;
 
 			for (idx_t i = 0; i < to_scan; i++) {
-				target_ptr[i] = ((scan_state.current_group_offset + i) * scan_state.current_constant) +
+				target_ptr[i] = (static_cast<T>(scan_state.current_group_offset + i) * scan_state.current_constant) +
 				                scan_state.current_frame_of_reference;
 			}
 
@@ -808,9 +826,11 @@ void BitpackingScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t
 		}
 
 		if (scan_state.current_group.mode == BitpackingMode::DELTA_FOR) {
-			ApplyFrameOfReference<T_S>((T_S *)current_result_ptr, (T_S)scan_state.current_frame_of_reference, to_scan);
-			DeltaDecode<T_S>((T_S *)current_result_ptr, (T_S)scan_state.current_delta_offset, to_scan);
-			scan_state.current_delta_offset = ((T *)current_result_ptr)[to_scan - 1];
+			ApplyFrameOfReference<T_S>(reinterpret_cast<T_S *>(current_result_ptr),
+			                           static_cast<T_S>(scan_state.current_frame_of_reference), to_scan);
+			DeltaDecode<T_S>(reinterpret_cast<T_S *>(current_result_ptr),
+			                 static_cast<T_S>(scan_state.current_delta_offset), to_scan);
+			scan_state.current_delta_offset = current_result_ptr[to_scan - 1];
 		} else {
 			ApplyFrameOfReference<T>(current_result_ptr, scan_state.current_frame_of_reference, to_scan);
 		}
@@ -833,7 +853,7 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
                         idx_t result_idx) {
 	BitpackingScanState<T> scan_state(segment);
 	scan_state.Skip(segment, row_id);
-	auto result_data = FlatVector::GetData<T>(result);
+	T *result_data = FlatVector::GetData<T>(result);
 	T *current_result_ptr = result_data + result_idx;
 
 	idx_t offset_in_compression_group =
@@ -852,8 +872,16 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
 	}
 
 	if (scan_state.current_group.mode == BitpackingMode::CONSTANT_DELTA) {
-		*current_result_ptr =
-		    ((scan_state.current_group_offset) * scan_state.current_constant) + scan_state.current_frame_of_reference;
+#ifdef DEBUG
+		// overflow check
+		T result;
+		bool multiply = TryMultiplyOperator::Operation(static_cast<T>(scan_state.current_group_offset),
+		                                               scan_state.current_constant, result);
+		bool add = TryAddOperator::Operation(result, scan_state.current_frame_of_reference, result);
+		D_ASSERT(multiply && add);
+#endif
+		*current_result_ptr = (static_cast<T>(scan_state.current_group_offset) * scan_state.current_constant) +
+		                      scan_state.current_frame_of_reference;
 		return;
 	}
 
@@ -863,7 +891,7 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
 	BitpackingPrimitives::UnPackBlock<T>(data_ptr_cast(scan_state.decompression_buffer),
 	                                     decompression_group_start_pointer, scan_state.current_width, skip_sign_extend);
 
-	*current_result_ptr = *(T *)(scan_state.decompression_buffer + offset_in_compression_group);
+	*current_result_ptr = scan_state.decompression_buffer[offset_in_compression_group];
 	*current_result_ptr += scan_state.current_frame_of_reference;
 
 	if (scan_state.current_group.mode == BitpackingMode::DELTA_FOR) {
@@ -872,7 +900,7 @@ void BitpackingFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t r
 }
 template <class T>
 void BitpackingSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
-	auto &scan_state = (BitpackingScanState<T> &)*state.scan_state;
+	auto &scan_state = static_cast<BitpackingScanState<T> &>(*state.scan_state);
 	scan_state.Skip(segment, skip_count);
 }
 
@@ -907,6 +935,8 @@ CompressionFunction BitpackingFun::GetFunction(PhysicalType type) {
 		return GetBitpackingFunction<uint32_t>(type);
 	case PhysicalType::UINT64:
 		return GetBitpackingFunction<uint64_t>(type);
+	case PhysicalType::INT128:
+		return GetBitpackingFunction<hugeint_t>(type);
 	case PhysicalType::LIST:
 		return GetBitpackingFunction<uint64_t, false>(type);
 	default:
@@ -926,6 +956,7 @@ bool BitpackingFun::TypeIsSupported(PhysicalType type) {
 	case PhysicalType::UINT32:
 	case PhysicalType::UINT64:
 	case PhysicalType::LIST:
+	case PhysicalType::INT128:
 		return true;
 	default:
 		return false;