duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp

@@ -0,0 +1,244 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/compression/alp/alp_scan.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/compression/alp/algorithm/alp.hpp"
+
+#include "duckdb/common/limits.hpp"
+#include "duckdb/common/types/null_value.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/table/column_data_checkpointer.hpp"
+#include "duckdb/storage/table/column_segment.hpp"
+#include "duckdb/common/operator/subtract.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
+
+namespace duckdb {
+
+template <class T>
+struct AlpVectorState {
+public:
+	void Reset() {
+		index = 0;
+	}
+
+	// Scan of the data itself
+	template <bool SKIP = false>
+	void Scan(uint8_t *dest, idx_t count) {
+		if (!SKIP) {
+			memcpy(dest, (void *)(decoded_values + index), sizeof(T) * count);
+		}
+		index += count;
+	}
+
+	template <bool SKIP>
+	void LoadValues(T *value_buffer, idx_t count) {
+		if (SKIP) {
+			return;
+		}
+		value_buffer[0] = (T)0;
+		alp::AlpDecompression<T>::Decompress(for_encoded, value_buffer, count, v_factor, v_exponent, exceptions_count,
+		                                     exceptions, exceptions_positions, frame_of_reference, bit_width);
+	}
+
+public:
+	idx_t index;
+	T decoded_values[AlpConstants::ALP_VECTOR_SIZE];
+	T exceptions[AlpConstants::ALP_VECTOR_SIZE];
+	uint16_t exceptions_positions[AlpConstants::ALP_VECTOR_SIZE];
+	uint8_t for_encoded[AlpConstants::ALP_VECTOR_SIZE * 8];
+	uint8_t v_exponent;
+	uint8_t v_factor;
+	uint16_t exceptions_count;
+	uint64_t frame_of_reference;
+	uint8_t bit_width;
+};
+
+template <class T>
+struct AlpScanState : public SegmentScanState {
+public:
+	using EXACT_TYPE = typename FloatingToExact<T>::type;
+
+	explicit AlpScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
+		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);
+		handle = buffer_manager.Pin(segment.block);
+		// ScanStates never exceed the boundaries of a Segment,
+		// but are not guaranteed to start at the beginning of the Block
+		segment_data = handle.Ptr() + segment.GetBlockOffset();
+		auto metadata_offset = Load<uint32_t>(segment_data);
+		metadata_ptr = segment_data + metadata_offset;
+	}
+
+	BufferHandle handle;
+	data_ptr_t metadata_ptr;
+	data_ptr_t segment_data;
+	idx_t total_value_count = 0;
+	AlpVectorState<T> vector_state;
+
+	ColumnSegment &segment;
+	idx_t count;
+
+	idx_t LeftInVector() const {
+		return AlpConstants::ALP_VECTOR_SIZE - (total_value_count % AlpConstants::ALP_VECTOR_SIZE);
+	}
+
+	inline bool VectorFinished() const {
+		return (total_value_count % AlpConstants::ALP_VECTOR_SIZE) == 0;
+	}
+
+	// Scan up to a vector boundary
+	template <class EXACT_TYPE, bool SKIP = false>
+	void ScanVector(T *values, idx_t vector_size) {
+		D_ASSERT(vector_size <= AlpConstants::ALP_VECTOR_SIZE);
+		D_ASSERT(vector_size <= LeftInVector());
+		if (VectorFinished() && total_value_count < count) {
+			if (vector_size == AlpConstants::ALP_VECTOR_SIZE) {
+				LoadVector<SKIP>(values);
+				total_value_count += vector_size;
+				return;
+			} else {
+				// Even if SKIP is given, the vector size is not big enough to be able to fully skip the entire vector
+				LoadVector<false>(vector_state.decoded_values);
+			}
+		}
+		vector_state.template Scan<SKIP>((uint8_t *)values, vector_size);
+
+		total_value_count += vector_size;
+	}
+
+	// Using the metadata, we can avoid loading any of the data if we don't care about the vector at all
+	void SkipVector() {
+		// Skip the offset indicating where the data starts
+		metadata_ptr -= AlpConstants::METADATA_POINTER_SIZE;
+		idx_t vector_size = MinValue((idx_t)AlpConstants::ALP_VECTOR_SIZE, count - total_value_count);
+		total_value_count += vector_size;
+	}
+
+	template <bool SKIP = false>
+	void LoadVector(T *value_buffer) {
+		vector_state.Reset();
+
+		// Load the offset (metadata) indicating where the vector data starts
+		metadata_ptr -= AlpConstants::METADATA_POINTER_SIZE;
+		auto data_byte_offset = Load<uint32_t>(metadata_ptr);
+		D_ASSERT(data_byte_offset < Storage::BLOCK_SIZE);
+
+		idx_t vector_size = MinValue((idx_t)AlpConstants::ALP_VECTOR_SIZE, (count - total_value_count));
+
+		data_ptr_t vector_ptr = segment_data + data_byte_offset;
+
+		// Load the vector data
+		vector_state.v_exponent = Load<uint8_t>(vector_ptr);
+		vector_ptr += AlpConstants::EXPONENT_SIZE;
+
+		vector_state.v_factor = Load<uint8_t>(vector_ptr);
+		vector_ptr += AlpConstants::FACTOR_SIZE;
+
+		vector_state.exceptions_count = Load<uint16_t>(vector_ptr);
+		vector_ptr += AlpConstants::EXCEPTIONS_COUNT_SIZE;
+
+		vector_state.frame_of_reference = Load<uint64_t>(vector_ptr);
+		vector_ptr += AlpConstants::FOR_SIZE;
+
+		vector_state.bit_width = Load<uint8_t>(vector_ptr);
+		vector_ptr += AlpConstants::BIT_WIDTH_SIZE;
+
+		D_ASSERT(vector_state.exceptions_count <= vector_size);
+		D_ASSERT(vector_state.v_exponent <= AlpTypedConstants<T>::MAX_EXPONENT);
+		D_ASSERT(vector_state.v_factor <= vector_state.v_exponent);
+		D_ASSERT(vector_state.bit_width <= sizeof(uint64_t) * 8);
+
+		if (vector_state.bit_width > 0) {
+			auto bp_size = BitpackingPrimitives::GetRequiredSize(vector_size, vector_state.bit_width);
+			memcpy(vector_state.for_encoded, (void *)vector_ptr, bp_size);
+			vector_ptr += bp_size;
+		}
+
+		if (vector_state.exceptions_count > 0) {
+			memcpy(vector_state.exceptions, (void *)vector_ptr, sizeof(EXACT_TYPE) * vector_state.exceptions_count);
+			vector_ptr += sizeof(EXACT_TYPE) * vector_state.exceptions_count;
+			memcpy(vector_state.exceptions_positions, (void *)vector_ptr,
+			       AlpConstants::EXCEPTION_POSITION_SIZE * vector_state.exceptions_count);
+		}
+
+		// Decode all the vector values to the specified 'value_buffer'
+		vector_state.template LoadValues<SKIP>(value_buffer, vector_size);
+	}
+
+public:
+	//! Skip the next 'skip_count' values, we don't store the values
+	void Skip(ColumnSegment &col_segment, idx_t skip_count) {
+
+		if (total_value_count != 0 && !VectorFinished()) {
+			// Finish skipping the current vector
+			idx_t to_skip = LeftInVector();
+			skip_count -= to_skip;
+			ScanVector<T, true>(nullptr, to_skip);
+		}
+		// Figure out how many entire vectors we can skip
+		// For these vectors, we don't even need to process the metadata or values
+		idx_t vectors_to_skip = skip_count / AlpConstants::ALP_VECTOR_SIZE;
+		for (idx_t i = 0; i < vectors_to_skip; i++) {
+			SkipVector();
+		}
+		skip_count -= AlpConstants::ALP_VECTOR_SIZE * vectors_to_skip;
+		if (skip_count == 0) {
+			return;
+		}
+		// For the last vector that this skip (partially) touches, we do need to
+		// load the metadata and values into the vector_state because
+		// we don't know exactly how many they are
+		ScanVector<T, true>(nullptr, skip_count);
+	}
+};
+
+template <class T>
+unique_ptr<SegmentScanState> AlpInitScan(ColumnSegment &segment) {
+	auto result = make_uniq_base<SegmentScanState, AlpScanState<T>>(segment);
+	return result;
+}
+
+//===--------------------------------------------------------------------===//
+// Scan base data
+//===--------------------------------------------------------------------===//
+template <class T>
+void AlpScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result,
+                    idx_t result_offset) {
+	auto &scan_state = (AlpScanState<T> &)*state.scan_state;
+
+	// Get the pointer to the result values
+	auto current_result_ptr = FlatVector::GetData<T>(result);
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	current_result_ptr += result_offset;
+
+	idx_t scanned = 0;
+	while (scanned < scan_count) {
+		const auto remaining = scan_count - scanned;
+		const idx_t to_scan = MinValue(remaining, scan_state.LeftInVector());
+
+		scan_state.template ScanVector<T>(current_result_ptr + scanned, to_scan);
+		scanned += to_scan;
+	}
+}
+
+template <class T>
+void AlpSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) {
+	auto &scan_state = (AlpScanState<T> &)*state.scan_state;
+	scan_state.Skip(segment, skip_count);
+}
+
+template <class T>
+void AlpScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) {
+	AlpScanPartial<T>(segment, state, scan_count, result, 0);
+}
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_utils.hpp

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/compression/alp/alp_utils.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/compression_function.hpp"
+#include "duckdb/storage/compression/alp/alp_constants.hpp"
+#include "duckdb/storage/compression/patas/patas.hpp"
+
+#include <cmath>
+
+namespace duckdb {
+
+namespace alp {
+
+struct AlpSamplingParameters {
+	uint32_t n_lookup_values;
+	uint32_t n_sampled_increments;
+	uint32_t n_sampled_values;
+
+	AlpSamplingParameters(uint32_t n_lookup_values, uint32_t n_sampled_increments, uint32_t n_sampled_values)
+	    : n_lookup_values(n_lookup_values), n_sampled_increments(n_sampled_increments),
+	      n_sampled_values(n_sampled_values) {
+	}
+};
+
+class AlpUtils {
+public:
+	AlpUtils() {
+	}
+
+public:
+	static AlpSamplingParameters GetSamplingParameters(idx_t current_vector_n_values) {
+
+		uint32_t n_lookup_values = MinValue(current_vector_n_values, (idx_t)AlpConstants::ALP_VECTOR_SIZE);
+		//! We sample equidistant values within a vector; to do this we jump a fixed number of values
+		uint32_t n_sampled_increments =
+		    MaxValue(1, (int32_t)std::ceil((double)n_lookup_values / AlpConstants::SAMPLES_PER_VECTOR));
+		uint32_t n_sampled_values = std::ceil((double)n_lookup_values / n_sampled_increments);
+		D_ASSERT(n_sampled_values < AlpConstants::ALP_VECTOR_SIZE);
+
+		AlpSamplingParameters sampling_params = {n_lookup_values, n_sampled_increments, n_sampled_values};
+		return sampling_params;
+	}
+
+	static bool MustSkipSamplingFromCurrentVector(idx_t vectors_count, idx_t vectors_sampled_count,
+	                                              idx_t current_vector_n_values) {
+		//! We sample equidistant vectors; to do this we skip a fixed values of vectors
+		bool must_select_rowgroup_samples = (vectors_count % AlpConstants::RG_SAMPLES_DUCKDB_JUMP) == 0;
+
+		//! If we are not in the correct jump, we do not take sample from this vector
+		if (!must_select_rowgroup_samples) {
+			return true;
+		}
+
+		//! We do not take samples of non-complete duckdb vectors (usually the last one)
+		//! Except in the case of too little data
+		if (current_vector_n_values < AlpConstants::SAMPLES_PER_VECTOR && vectors_sampled_count != 0) {
+			return true;
+		}
+		return false;
+	}
+
+	template <class T>
+	static T FindFirstValueNotInPositionsArray(const T *input_vector, const uint16_t *positions, idx_t values_count) {
+		T a_non_special_value = 0;
+		for (idx_t i = 0; i < values_count; i++) {
+			if (i != positions[i]) {
+				a_non_special_value = input_vector[i];
+				break;
+			}
+		}
+		return a_non_special_value;
+	}
+
+	template <class T>
+	static void ReplaceValueInVectorPositions(T *input_vector, const uint16_t *positions_to_replace,
+	                                          idx_t special_values_count, T value_to_replace) {
+		for (idx_t i = 0; i < special_values_count; i++) {
+			uint16_t null_value_pos = positions_to_replace[i];
+			input_vector[null_value_pos] = value_to_replace;
+		}
+	}
+
+	template <class T>
+	static void FindAndReplaceNullsInVector(T *input_vector, const uint16_t *vector_null_positions, idx_t values_count,
+	                                        idx_t nulls_count) {
+		if (nulls_count == 0) {
+			return;
+		}
+		T a_non_null_value = FindFirstValueNotInPositionsArray(input_vector, vector_null_positions, values_count);
+		ReplaceValueInVectorPositions(input_vector, vector_null_positions, nulls_count, a_non_null_value);
+	}
+};
+
+} // namespace alp
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/alprd/algorithm/alprd.hpp

@@ -0,0 +1,235 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/compression/alprd/algorithm/alprd.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/compression/patas/patas.hpp"
+#include "duckdb/storage/compression/alprd/alprd_constants.hpp"
+
+#include "duckdb/common/bitpacking.hpp"
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/pair.hpp"
+#include "duckdb/common/unordered_map.hpp"
+#include "duckdb/common/limits.hpp"
+
+#include <cmath>
+
+namespace duckdb {
+
+namespace alp {
+
+struct AlpRDLeftPartInfo {
+	uint32_t count;
+	uint64_t hash;
+	AlpRDLeftPartInfo(uint32_t count, uint64_t hash) : count(count), hash(hash) {
+	}
+};
+
+template <class T, bool EMPTY>
+class AlpRDCompressionState {
+public:
+	using EXACT_TYPE = typename FloatingToExact<T>::type;
+
+	AlpRDCompressionState() : right_bit_width(0), left_bit_width(0), exceptions_count(0) {
+	}
+
+	void Reset() {
+		left_bit_packed_size = 0;
+		right_bit_packed_size = 0;
+		exceptions_count = 0;
+	}
+
+public:
+	uint8_t right_bit_width; // 'right' & 'left' refer to the respective parts of the floating numbers after splitting
+	uint8_t left_bit_width;
+	uint16_t exceptions_count;
+	uint8_t right_parts_encoded[AlpRDConstants::ALP_VECTOR_SIZE * 8];
+	uint8_t left_parts_encoded[AlpRDConstants::ALP_VECTOR_SIZE * 8];
+	uint16_t left_parts_dict[AlpRDConstants::MAX_DICTIONARY_SIZE];
+	uint16_t exceptions[AlpRDConstants::ALP_VECTOR_SIZE];
+	uint16_t exceptions_positions[AlpRDConstants::ALP_VECTOR_SIZE];
+	idx_t left_bit_packed_size;
+	idx_t right_bit_packed_size;
+	unordered_map<uint16_t, uint16_t> left_parts_dict_map;
+	uint8_t actual_dictionary_size;
+};
+
+template <class T, bool EMPTY>
+struct AlpRDCompression {
+	using State = AlpRDCompressionState<T, EMPTY>;
+	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	static constexpr uint8_t EXACT_TYPE_BITSIZE = sizeof(EXACT_TYPE) * 8;
+
+	/*
+	 * Estimate the bits per value of ALPRD within a sample
+	 */
+	static double EstimateCompressionSize(uint8_t right_bit_width, uint8_t left_bit_width, uint16_t exceptions_count,
+	                                      uint64_t sample_count) {
+		double exceptions_size =
+		    exceptions_count * ((AlpRDConstants::EXCEPTION_POSITION_SIZE + AlpRDConstants::EXCEPTION_SIZE) * 8);
+		double estimated_size = right_bit_width + left_bit_width + (exceptions_size / sample_count);
+		return estimated_size;
+	}
+
+	template <bool PERSIST_DICT>
+	static double BuildLeftPartsDictionary(const vector<EXACT_TYPE> &values, uint8_t right_bit_width, State &state) {
+		unordered_map<EXACT_TYPE, int32_t> left_parts_hash;
+		vector<AlpRDLeftPartInfo> left_parts_sorted_repetitions;
+
+		// Building a hash for all the left parts and how many times they appear
+		for (auto &value : values) {
+			auto left_tmp = value >> right_bit_width;
+			left_parts_hash[left_tmp]++;
+		}
+
+		// We build a vector from the hash to be able to sort it by repetition count
+		left_parts_sorted_repetitions.reserve(left_parts_hash.size());
+		for (auto &hash_pair : left_parts_hash) {
+			left_parts_sorted_repetitions.emplace_back(hash_pair.second, hash_pair.first);
+		}
+		sort(left_parts_sorted_repetitions.begin(), left_parts_sorted_repetitions.end(),
+		     [](const AlpRDLeftPartInfo &a, const AlpRDLeftPartInfo &b) { return a.count > b.count; });
+
+		// Exceptions are left parts which do not fit in the fixed dictionary size
+		uint32_t exceptions_count = 0;
+		for (idx_t i = AlpRDConstants::MAX_DICTIONARY_SIZE; i < left_parts_sorted_repetitions.size(); i++) {
+			exceptions_count += left_parts_sorted_repetitions[i].count;
+		}
+
+		// The left parts bit width after compression is determined by how many elements are in the dictionary
+		uint64_t actual_dictionary_size =
+		    MinValue<uint64_t>(AlpRDConstants::MAX_DICTIONARY_SIZE, left_parts_sorted_repetitions.size());
+		uint8_t left_bit_width = MaxValue<uint8_t>(1, std::ceil(std::log2(actual_dictionary_size)));
+
+		if (PERSIST_DICT) {
+			for (idx_t dict_idx = 0; dict_idx < actual_dictionary_size; dict_idx++) {
+				//! The dict keys are mapped to the left part themselves
+				state.left_parts_dict[dict_idx] = left_parts_sorted_repetitions[dict_idx].hash;
+				state.left_parts_dict_map.insert({state.left_parts_dict[dict_idx], dict_idx});
+			}
+			//! Pararelly we store a map of the dictionary to quickly resolve exceptions during encoding
+			for (idx_t i = actual_dictionary_size + 1; i < left_parts_sorted_repetitions.size(); i++) {
+				state.left_parts_dict_map.insert({left_parts_sorted_repetitions[i].hash, i});
+			}
+			state.left_bit_width = left_bit_width;
+			state.right_bit_width = right_bit_width;
+			state.actual_dictionary_size = actual_dictionary_size;
+
+			D_ASSERT(state.left_bit_width > 0 && state.right_bit_width > 0 &&
+			         state.left_bit_width <= AlpRDConstants::MAX_DICTIONARY_BIT_WIDTH &&
+			         state.actual_dictionary_size <= AlpRDConstants::MAX_DICTIONARY_SIZE);
+		}
+
+		double estimated_size =
+		    EstimateCompressionSize(right_bit_width, left_bit_width, exceptions_count, values.size());
+		return estimated_size;
+	}
+
+	static double FindBestDictionary(const vector<EXACT_TYPE> &values, State &state) {
+		uint8_t right_bit_width;
+		double best_dict_size = NumericLimits<int32_t>::Maximum();
+		//! Finding the best position to CUT the values
+		for (idx_t i = 1; i <= AlpRDConstants::CUTTING_LIMIT; i++) {
+			uint8_t candidate_right_bit_width = EXACT_TYPE_BITSIZE - i;
+			double estimated_size = BuildLeftPartsDictionary<false>(values, candidate_right_bit_width, state);
+			if (estimated_size <= best_dict_size) {
+				right_bit_width = candidate_right_bit_width;
+				best_dict_size = estimated_size;
+			}
+			// TODO: We could implement an early exit mechanism similar to normal ALP
+		}
+		double estimated_size = BuildLeftPartsDictionary<true>(values, right_bit_width, state);
+		return estimated_size;
+	}
+
+	static void Compress(const EXACT_TYPE *input_vector, idx_t n_values, State &state) {
+
+		uint64_t right_parts[AlpRDConstants::ALP_VECTOR_SIZE];
+		uint16_t left_parts[AlpRDConstants::ALP_VECTOR_SIZE];
+
+		// Cutting the floating point values
+		for (idx_t i = 0; i < n_values; i++) {
+			EXACT_TYPE tmp = input_vector[i];
+			right_parts[i] = tmp & ((1ULL << state.right_bit_width) - 1);
+			left_parts[i] = (tmp >> state.right_bit_width);
+		}
+
+		// Dictionary encoding for left parts
+		for (idx_t i = 0; i < n_values; i++) {
+			uint16_t dictionary_index;
+			auto dictionary_key = left_parts[i];
+			if (state.left_parts_dict_map.find(dictionary_key) == state.left_parts_dict_map.end()) {
+				//! If not found on the dictionary we store the smallest non-key index as exception (the dict size)
+				dictionary_index = state.actual_dictionary_size;
+			} else {
+				dictionary_index = state.left_parts_dict_map[dictionary_key];
+			}
+			left_parts[i] = dictionary_index;
+
+			//! Left parts not found in the dictionary are stored as exceptions
+			if (dictionary_index >= state.actual_dictionary_size) {
+				state.exceptions[state.exceptions_count] = dictionary_key;
+				state.exceptions_positions[state.exceptions_count] = i;
+				state.exceptions_count++;
+			}
+		}
+
+		auto right_bit_packed_size = BitpackingPrimitives::GetRequiredSize(n_values, state.right_bit_width);
+		auto left_bit_packed_size = BitpackingPrimitives::GetRequiredSize(n_values, state.left_bit_width);
+
+		if (!EMPTY) {
+			// Bitpacking Left and Right parts
+			BitpackingPrimitives::PackBuffer<uint16_t, false>(state.left_parts_encoded, left_parts, n_values,
+			                                                  state.left_bit_width);
+			BitpackingPrimitives::PackBuffer<uint64_t, false>(state.right_parts_encoded, right_parts, n_values,
+			                                                  state.right_bit_width);
+		}
+
+		state.left_bit_packed_size = left_bit_packed_size;
+		state.right_bit_packed_size = right_bit_packed_size;
+	}
+};
+
+template <class T>
+struct AlpRDDecompression {
+	using EXACT_TYPE = typename FloatingToExact<T>::type;
+
+	static void Decompress(uint8_t *left_encoded, uint8_t *right_encoded, const uint16_t *left_parts_dict,
+	                       EXACT_TYPE *output, idx_t values_count, uint16_t exceptions_count,
+	                       const uint16_t *exceptions, const uint16_t *exceptions_positions, uint8_t left_bit_width,
+	                       uint8_t right_bit_width) {
+
+		uint8_t left_decoded[AlpRDConstants::ALP_VECTOR_SIZE * 8] = {0};
+		uint8_t right_decoded[AlpRDConstants::ALP_VECTOR_SIZE * 8] = {0};
+
+		// Bitunpacking left and right parts
+		BitpackingPrimitives::UnPackBuffer<uint16_t>(left_decoded, left_encoded, values_count, left_bit_width);
+		BitpackingPrimitives::UnPackBuffer<EXACT_TYPE>(right_decoded, right_encoded, values_count, right_bit_width);
+
+		uint16_t *left_parts = reinterpret_cast<uint16_t *>(data_ptr_cast(left_decoded));
+		EXACT_TYPE *right_parts = reinterpret_cast<EXACT_TYPE *>(data_ptr_cast(right_decoded));
+
+		// Decoding
+		for (idx_t i = 0; i < values_count; i++) {
+			uint16_t left = left_parts_dict[left_parts[i]];
+			EXACT_TYPE right = right_parts[i];
+			output[i] = (static_cast<EXACT_TYPE>(left) << right_bit_width) | right;
+		}
+
+		// Exceptions Patching (exceptions only occur in left parts)
+		for (idx_t i = 0; i < exceptions_count; i++) {
+			EXACT_TYPE right = right_parts[exceptions_positions[i]];
+			uint16_t left = exceptions[i];
+			output[exceptions_positions[i]] = (static_cast<EXACT_TYPE>(left) << right_bit_width) | right;
+		}
+	}
+};
+
+} // namespace alp
+
+} // namespace duckdb