duckdb 0.8.2-dev145.0 → 0.8.2-dev1493.0

package/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp

@@ -0,0 +1,212 @@
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+
+namespace duckdb {
+
+static string IntegralCompressFunctionName(const LogicalType &result_type) {
+	return StringUtil::Format("__internal_compress_integral_%s",
+	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
+}
+
+template <class INPUT_TYPE, class RESULT_TYPE>
+struct TemplatedIntegralCompress {
+	static inline RESULT_TYPE Operation(const INPUT_TYPE &input, const INPUT_TYPE &min_val) {
+		D_ASSERT(min_val <= input);
+		return input - min_val;
+	}
+};
+
+template <class RESULT_TYPE>
+struct TemplatedIntegralCompress<hugeint_t, RESULT_TYPE> {
+	static inline RESULT_TYPE Operation(const hugeint_t &input, const hugeint_t &min_val) {
+		D_ASSERT(min_val <= input);
+		return (input - min_val).lower;
+	}
+};
+
+template <class INPUT_TYPE, class RESULT_TYPE>
+static void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 2);
+	D_ASSERT(args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR);
+	const auto min_val = ConstantVector::GetData<INPUT_TYPE>(args.data[1])[0];
+	UnaryExecutor::Execute<INPUT_TYPE, RESULT_TYPE>(args.data[0], result, args.size(), [&](const INPUT_TYPE &input) {
+		return TemplatedIntegralCompress<INPUT_TYPE, RESULT_TYPE>::Operation(input, min_val);
+	});
+}
+
+template <class INPUT_TYPE, class RESULT_TYPE>
+static scalar_function_t GetIntegralCompressFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	return IntegralCompressFunction<INPUT_TYPE, RESULT_TYPE>;
+}
+
+template <class INPUT_TYPE>
+static scalar_function_t GetIntegralCompressFunctionResultSwitch(const LogicalType &input_type,
+                                                                 const LogicalType &result_type) {
+	switch (result_type.id()) {
+	case LogicalTypeId::UTINYINT:
+		return GetIntegralCompressFunction<INPUT_TYPE, uint8_t>(input_type, result_type);
+	case LogicalTypeId::USMALLINT:
+		return GetIntegralCompressFunction<INPUT_TYPE, uint16_t>(input_type, result_type);
+	case LogicalTypeId::UINTEGER:
+		return GetIntegralCompressFunction<INPUT_TYPE, uint32_t>(input_type, result_type);
+	case LogicalTypeId::UBIGINT:
+		return GetIntegralCompressFunction<INPUT_TYPE, uint64_t>(input_type, result_type);
+	default:
+		throw InternalException("Unexpected result type in GetIntegralCompressFunctionResultSwitch");
+	}
+}
+
+static scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalType &input_type,
+                                                                const LogicalType &result_type) {
+	switch (input_type.id()) {
+	case LogicalTypeId::SMALLINT:
+		return GetIntegralCompressFunctionResultSwitch<int16_t>(input_type, result_type);
+	case LogicalTypeId::INTEGER:
+		return GetIntegralCompressFunctionResultSwitch<int32_t>(input_type, result_type);
+	case LogicalTypeId::BIGINT:
+		return GetIntegralCompressFunctionResultSwitch<int64_t>(input_type, result_type);
+	case LogicalTypeId::HUGEINT:
+		return GetIntegralCompressFunctionResultSwitch<hugeint_t>(input_type, result_type);
+	case LogicalTypeId::USMALLINT:
+		return GetIntegralCompressFunctionResultSwitch<uint16_t>(input_type, result_type);
+	case LogicalTypeId::UINTEGER:
+		return GetIntegralCompressFunctionResultSwitch<uint32_t>(input_type, result_type);
+	case LogicalTypeId::UBIGINT:
+		return GetIntegralCompressFunctionResultSwitch<uint64_t>(input_type, result_type);
+	default:
+		throw InternalException("Unexpected input type in GetIntegralCompressFunctionInputSwitch");
+	}
+}
+
+static string IntegralDecompressFunctionName(const LogicalType &result_type) {
+	return StringUtil::Format("__internal_decompress_integral_%s",
+	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
+}
+
+template <class INPUT_TYPE, class RESULT_TYPE>
+static inline RESULT_TYPE TemplatedIntegralDecompress(const INPUT_TYPE &input, const RESULT_TYPE &min_val) {
+	return min_val + input;
+}
+
+template <class INPUT_TYPE, class RESULT_TYPE>
+static void IntegralDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.ColumnCount() == 2);
+	D_ASSERT(args.data[1].GetVectorType() == VectorType::CONSTANT_VECTOR);
+	D_ASSERT(args.data[1].GetType() == result.GetType());
+	const auto min_val = ConstantVector::GetData<RESULT_TYPE>(args.data[1])[0];
+	UnaryExecutor::Execute<INPUT_TYPE, RESULT_TYPE>(args.data[0], result, args.size(), [&](const INPUT_TYPE &input) {
+		return TemplatedIntegralDecompress<INPUT_TYPE, RESULT_TYPE>(input, min_val);
+	});
+}
+
+template <class INPUT_TYPE, class RESULT_TYPE>
+static scalar_function_t GetIntegralDecompressFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	return IntegralDecompressFunction<INPUT_TYPE, RESULT_TYPE>;
+}
+
+template <class INPUT_TYPE>
+static scalar_function_t GetIntegralDecompressFunctionResultSwitch(const LogicalType &input_type,
+                                                                   const LogicalType &result_type) {
+	switch (result_type.id()) {
+	case LogicalTypeId::SMALLINT:
+		return GetIntegralDecompressFunction<INPUT_TYPE, int16_t>(input_type, result_type);
+	case LogicalTypeId::INTEGER:
+		return GetIntegralDecompressFunction<INPUT_TYPE, int32_t>(input_type, result_type);
+	case LogicalTypeId::BIGINT:
+		return GetIntegralDecompressFunction<INPUT_TYPE, int64_t>(input_type, result_type);
+	case LogicalTypeId::HUGEINT:
+		return GetIntegralDecompressFunction<INPUT_TYPE, hugeint_t>(input_type, result_type);
+	case LogicalTypeId::USMALLINT:
+		return GetIntegralDecompressFunction<INPUT_TYPE, uint16_t>(input_type, result_type);
+	case LogicalTypeId::UINTEGER:
+		return GetIntegralDecompressFunction<INPUT_TYPE, uint32_t>(input_type, result_type);
+	case LogicalTypeId::UBIGINT:
+		return GetIntegralDecompressFunction<INPUT_TYPE, uint64_t>(input_type, result_type);
+	default:
+		throw InternalException("Unexpected input type in GetIntegralDecompressFunctionSetSwitch");
+	}
+}
+
+static scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalType &input_type,
+                                                                  const LogicalType &result_type) {
+	switch (input_type.id()) {
+	case LogicalTypeId::UTINYINT:
+		return GetIntegralDecompressFunctionResultSwitch<uint8_t>(input_type, result_type);
+	case LogicalTypeId::USMALLINT:
+		return GetIntegralDecompressFunctionResultSwitch<uint16_t>(input_type, result_type);
+	case LogicalTypeId::UINTEGER:
+		return GetIntegralDecompressFunctionResultSwitch<uint32_t>(input_type, result_type);
+	case LogicalTypeId::UBIGINT:
+		return GetIntegralDecompressFunctionResultSwitch<uint64_t>(input_type, result_type);
+	default:
+		throw InternalException("Unexpected result type in GetIntegralDecompressFunctionInputSwitch");
+	}
+}
+
+static void CMIntegralSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const ScalarFunction &function) {
+	writer.WriteRegularSerializableList(function.arguments);
+	writer.WriteSerializable(function.return_type);
+}
+
+template <scalar_function_t (*GET_FUNCTION)(const LogicalType &, const LogicalType &)>
+unique_ptr<FunctionData> CMIntegralDeserialize(PlanDeserializationState &state, FieldReader &reader,
+                                               ScalarFunction &function) {
+	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	function.function =
+	    GET_FUNCTION(function.arguments[0], reader.ReadRequiredSerializable<LogicalType, LogicalType>());
+	return nullptr;
+}
+
+ScalarFunction CMIntegralCompressFun::GetFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	ScalarFunction result(IntegralCompressFunctionName(result_type), {input_type, input_type}, result_type,
+	                      GetIntegralCompressFunctionInputSwitch(input_type, result_type),
+	                      CompressedMaterializationFunctions::Bind);
+	result.serialize = CMIntegralSerialize;
+	result.deserialize = CMIntegralDeserialize<GetIntegralCompressFunctionInputSwitch>;
+	return result;
+}
+
+static ScalarFunctionSet GetIntegralCompressFunctionSet(const LogicalType &result_type) {
+	ScalarFunctionSet set(IntegralCompressFunctionName(result_type));
+	for (const auto &input_type : LogicalType::Integral()) {
+		if (GetTypeIdSize(result_type.InternalType()) < GetTypeIdSize(input_type.InternalType())) {
+			set.AddFunction(CMIntegralCompressFun::GetFunction(input_type, result_type));
+		}
+	}
+	return set;
+}
+
+void CMIntegralCompressFun::RegisterFunction(BuiltinFunctions &set) {
+	for (const auto &result_type : CompressedMaterializationFunctions::IntegralTypes()) {
+		set.AddFunction(GetIntegralCompressFunctionSet(result_type));
+	}
+}
+
+ScalarFunction CMIntegralDecompressFun::GetFunction(const LogicalType &input_type, const LogicalType &result_type) {
+	ScalarFunction result(IntegralDecompressFunctionName(result_type), {input_type, result_type}, result_type,
+	                      GetIntegralDecompressFunctionInputSwitch(input_type, result_type),
+	                      CompressedMaterializationFunctions::Bind);
+	result.serialize = CMIntegralSerialize;
+	result.deserialize = CMIntegralDeserialize<GetIntegralDecompressFunctionInputSwitch>;
+	return result;
+}
+
+static ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &result_type) {
+	ScalarFunctionSet set(IntegralDecompressFunctionName(result_type));
+	for (const auto &input_type : CompressedMaterializationFunctions::IntegralTypes()) {
+		if (GetTypeIdSize(result_type.InternalType()) > GetTypeIdSize(input_type.InternalType())) {
+			set.AddFunction(CMIntegralDecompressFun::GetFunction(input_type, result_type));
+		}
+	}
+	return set;
+}
+
+void CMIntegralDecompressFun::RegisterFunction(BuiltinFunctions &set) {
+	for (const auto &result_type : LogicalType::Integral()) {
+		if (GetTypeIdSize(result_type.InternalType()) > 1) {
+			set.AddFunction(GetIntegralDecompressFunctionSet(result_type));
+		}
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/compressed_materialization/compress_string.cpp

@@ -0,0 +1,249 @@
+#include "duckdb/common/bswap.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+
+namespace duckdb {
+
+static string StringCompressFunctionName(const LogicalType &result_type) {
+	return StringUtil::Format("__internal_compress_string_%s",
+	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
+}
+
+template <idx_t LENGTH>
+static inline void TemplatedReverseMemCpy(const data_ptr_t __restrict &dest, const const_data_ptr_t __restrict &src) {
+	for (idx_t i = 0; i < LENGTH; i++) {
+		dest[i] = src[LENGTH - 1 - i];
+	}
+}
+
+static inline void ReverseMemCpy(const data_ptr_t __restrict &dest, const const_data_ptr_t __restrict &src,
+                                 const idx_t &length) {
+	for (idx_t i = 0; i < length; i++) {
+		dest[i] = src[length - 1 - i];
+	}
+}
+
+template <class RESULT_TYPE>
+static inline RESULT_TYPE StringCompressInternal(const string_t &input) {
+	RESULT_TYPE result;
+	const auto result_ptr = data_ptr_cast(&result);
+	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
+		TemplatedReverseMemCpy<sizeof(RESULT_TYPE)>(result_ptr, const_data_ptr_cast(input.GetPrefix()));
+	} else if (input.IsInlined()) {
+		static constexpr auto REMAINDER = sizeof(RESULT_TYPE) - string_t::INLINE_LENGTH;
+		TemplatedReverseMemCpy<string_t::INLINE_LENGTH>(result_ptr + REMAINDER, const_data_ptr_cast(input.GetPrefix()));
+		memset(result_ptr, '\0', REMAINDER);
+	} else {
+		const auto remainder = sizeof(RESULT_TYPE) - input.GetSize();
+		ReverseMemCpy(result_ptr + remainder, data_ptr_cast(input.GetPointer()), input.GetSize());
+		memset(result_ptr, '\0', remainder);
+	}
+	result_ptr[0] = input.GetSize();
+	return result;
+}
+
+template <class RESULT_TYPE>
+static inline RESULT_TYPE StringCompress(const string_t &input) {
+	D_ASSERT(input.GetSize() < sizeof(RESULT_TYPE));
+	return StringCompressInternal<RESULT_TYPE>(input);
+}
+
+template <class RESULT_TYPE>
+static inline RESULT_TYPE MiniStringCompress(const string_t &input) {
+	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
+		return input.GetSize() + *const_data_ptr_cast(input.GetPrefix());
+	} else if (input.GetSize() == 0) {
+		return 0;
+	} else {
+		return input.GetSize() + *const_data_ptr_cast(input.GetPointer());
+	}
+}
+
+template <>
+inline uint8_t StringCompress(const string_t &input) {
+	D_ASSERT(input.GetSize() <= sizeof(uint8_t));
+	return MiniStringCompress<uint8_t>(input);
+}
+
+template <class RESULT_TYPE>
+static void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	UnaryExecutor::Execute<string_t, RESULT_TYPE>(args.data[0], result, args.size(), StringCompress<RESULT_TYPE>);
+}
+
+template <class RESULT_TYPE>
+static scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
+	return StringCompressFunction<RESULT_TYPE>;
+}
+
+static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
+	switch (result_type.id()) {
+	case LogicalTypeId::UTINYINT:
+		return GetStringCompressFunction<uint8_t>(result_type);
+	case LogicalTypeId::USMALLINT:
+		return GetStringCompressFunction<uint16_t>(result_type);
+	case LogicalTypeId::UINTEGER:
+		return GetStringCompressFunction<uint32_t>(result_type);
+	case LogicalTypeId::UBIGINT:
+		return GetStringCompressFunction<uint64_t>(result_type);
+	case LogicalTypeId::HUGEINT:
+		return GetStringCompressFunction<hugeint_t>(result_type);
+	default:
+		throw InternalException("Unexpected type in GetStringCompressFunctionSwitch");
+	}
+}
+
+static string StringDecompressFunctionName() {
+	return "__internal_decompress_string";
+}
+
+struct StringDecompressLocalState : public FunctionLocalState {
+public:
+	explicit StringDecompressLocalState(ClientContext &context) : allocator(Allocator::Get(context)) {
+	}
+
+	static unique_ptr<FunctionLocalState> Init(ExpressionState &state, const BoundFunctionExpression &expr,
+	                                           FunctionData *bind_data) {
+		return make_uniq<StringDecompressLocalState>(state.GetContext());
+	}
+
+public:
+	ArenaAllocator allocator;
+};
+
+template <class INPUT_TYPE>
+static inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+	const auto input_ptr = const_data_ptr_cast(&input);
+	string_t result(input_ptr[0]);
+	if (sizeof(INPUT_TYPE) <= string_t::INLINE_LENGTH) {
+		const auto result_ptr = data_ptr_cast(result.GetPrefixWriteable());
+		TemplatedReverseMemCpy<sizeof(INPUT_TYPE)>(result_ptr, input_ptr);
+		memset(result_ptr + sizeof(INPUT_TYPE) - 1, '\0', string_t::INLINE_LENGTH - sizeof(INPUT_TYPE) + 1);
+	} else if (result.GetSize() <= string_t::INLINE_LENGTH) {
+		static constexpr auto REMAINDER = sizeof(INPUT_TYPE) - string_t::INLINE_LENGTH;
+		const auto result_ptr = data_ptr_cast(result.GetPrefixWriteable());
+		TemplatedReverseMemCpy<string_t::INLINE_LENGTH>(result_ptr, input_ptr + REMAINDER);
+	} else {
+		result.SetPointer(char_ptr_cast(allocator.Allocate(sizeof(INPUT_TYPE))));
+		TemplatedReverseMemCpy<sizeof(INPUT_TYPE)>(data_ptr_cast(result.GetPointer()), input_ptr);
+		memcpy(result.GetPrefixWriteable(), result.GetPointer(), string_t::PREFIX_LENGTH);
+	}
+	return result;
+}
+
+template <class INPUT_TYPE>
+static inline string_t MiniStringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+	if (input == 0) {
+		string_t result(uint32_t(0));
+		memset(result.GetPrefixWriteable(), '\0', string_t::INLINE_BYTES);
+		return result;
+	}
+
+	string_t result(1);
+	if (sizeof(INPUT_TYPE) <= string_t::INLINE_LENGTH) {
+		memset(result.GetPrefixWriteable(), '\0', string_t::INLINE_BYTES);
+		*data_ptr_cast(result.GetPrefixWriteable()) = input - 1;
+	} else {
+		result.SetPointer(char_ptr_cast(allocator.Allocate(1)));
+		*data_ptr_cast(result.GetPointer()) = input - 1;
+		memset(result.GetPrefixWriteable(), '\0', string_t::PREFIX_LENGTH);
+		*result.GetPrefixWriteable() = *result.GetPointer();
+	}
+	return result;
+}
+
+template <>
+inline string_t StringDecompress(const uint8_t &input, ArenaAllocator &allocator) {
+	return MiniStringDecompress<uint8_t>(input, allocator);
+}
+
+template <class INPUT_TYPE>
+static void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &allocator = ExecuteFunctionState::GetFunctionState(state)->Cast<StringDecompressLocalState>().allocator;
+	allocator.Reset();
+	UnaryExecutor::Execute<INPUT_TYPE, string_t>(args.data[0], result, args.size(), [&](const INPUT_TYPE &input) {
+		return StringDecompress<INPUT_TYPE>(input, allocator);
+	});
+}
+
+template <class INPUT_TYPE>
+static scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
+	return StringDecompressFunction<INPUT_TYPE>;
+}
+
+static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
+	switch (input_type.id()) {
+	case LogicalTypeId::UTINYINT:
+		return GetStringDecompressFunction<uint8_t>(input_type);
+	case LogicalTypeId::USMALLINT:
+		return GetStringDecompressFunction<uint16_t>(input_type);
+	case LogicalTypeId::UINTEGER:
+		return GetStringDecompressFunction<uint32_t>(input_type);
+	case LogicalTypeId::UBIGINT:
+		return GetStringDecompressFunction<uint64_t>(input_type);
+	case LogicalTypeId::HUGEINT:
+		return GetStringDecompressFunction<hugeint_t>(input_type);
+	default:
+		throw InternalException("Unexpected type in GetStringDecompressFunctionSwitch");
+	}
+}
+
+static void CMStringCompressSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+                                      const ScalarFunction &function) {
+	writer.WriteRegularSerializableList(function.arguments);
+	writer.WriteSerializable(function.return_type);
+}
+
+unique_ptr<FunctionData> CMStringCompressDeserialize(PlanDeserializationState &state, FieldReader &reader,
+                                                     ScalarFunction &function) {
+	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	function.function = GetStringCompressFunctionSwitch(reader.ReadRequiredSerializable<LogicalType, LogicalType>());
+	return nullptr;
+}
+
+ScalarFunction CMStringCompressFun::GetFunction(const LogicalType &result_type) {
+	ScalarFunction result(StringCompressFunctionName(result_type), {LogicalType::VARCHAR}, result_type,
+	                      GetStringCompressFunctionSwitch(result_type), CompressedMaterializationFunctions::Bind);
+	result.serialize = CMStringCompressSerialize;
+	result.deserialize = CMStringCompressDeserialize;
+	return result;
+}
+
+void CMStringCompressFun::RegisterFunction(BuiltinFunctions &set) {
+	for (const auto &result_type : CompressedMaterializationFunctions::StringTypes()) {
+		set.AddFunction(CMStringCompressFun::GetFunction(result_type));
+	}
+}
+
+static void CMStringDecompressSerialize(FieldWriter &writer, const FunctionData *bind_data_p,
+                                        const ScalarFunction &function) {
+	writer.WriteRegularSerializableList(function.arguments);
+}
+
+unique_ptr<FunctionData> CMStringDecompressDeserialize(PlanDeserializationState &state, FieldReader &reader,
+                                                       ScalarFunction &function) {
+	function.arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	function.function = GetStringDecompressFunctionSwitch(function.arguments[0]);
+	return nullptr;
+}
+
+ScalarFunction CMStringDecompressFun::GetFunction(const LogicalType &input_type) {
+	ScalarFunction result(StringDecompressFunctionName(), {input_type}, LogicalType::VARCHAR,
+	                      GetStringDecompressFunctionSwitch(input_type), CompressedMaterializationFunctions::Bind,
+	                      nullptr, nullptr, StringDecompressLocalState::Init);
+	result.serialize = CMStringDecompressSerialize;
+	result.deserialize = CMStringDecompressDeserialize;
+	return result;
+}
+
+static ScalarFunctionSet GetStringDecompressFunctionSet() {
+	ScalarFunctionSet set(StringDecompressFunctionName());
+	for (const auto &input_type : CompressedMaterializationFunctions::StringTypes()) {
+		set.AddFunction(CMStringDecompressFun::GetFunction(input_type));
+	}
+	return set;
+}
+
+void CMStringDecompressFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(GetStringDecompressFunctionSet());
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,29 @@
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+
+namespace duckdb {
+
+const vector<LogicalType> CompressedMaterializationFunctions::IntegralTypes() {
+	return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT};
+}
+
+const vector<LogicalType> CompressedMaterializationFunctions::StringTypes() {
+	return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT,
+	        LogicalType::HUGEINT};
+}
+
+// LCOV_EXCL_START
+unique_ptr<FunctionData> CompressedMaterializationFunctions::Bind(ClientContext &context,
+                                                                  ScalarFunction &bound_function,
+                                                                  vector<unique_ptr<Expression>> &arguments) {
+	throw BinderException("Compressed materialization functions are for internal use only!");
+}
+// LCOV_EXCL_STOP
+
+void BuiltinFunctions::RegisterCompressedMaterializationFunctions() {
+	Register<CMIntegralCompressFun>();
+	Register<CMIntegralDecompressFun>();
+	Register<CMStringCompressFun>();
+	Register<CMStringDecompressFun>();
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/list/list_resize.cpp

@@ -0,0 +1,162 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/function/built_in_functions.hpp"
+
+namespace duckdb {
+
+void ListResizeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	D_ASSERT(args.data[1].GetType().id() == LogicalTypeId::UBIGINT);
+	if (result.GetType().id() == LogicalTypeId::SQLNULL) {
+		FlatVector::SetNull(result, 0, true);
+		return;
+	}
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	auto count = args.size();
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+
+	auto &lists = args.data[0];
+	auto &child = ListVector::GetEntry(args.data[0]);
+	auto &new_sizes = args.data[1];
+
+	UnifiedVectorFormat list_data;
+	lists.ToUnifiedFormat(count, list_data);
+	auto list_entries = UnifiedVectorFormat::GetData<list_entry_t>(list_data);
+
+	UnifiedVectorFormat new_size_data;
+	new_sizes.ToUnifiedFormat(count, new_size_data);
+	auto new_size_entries = UnifiedVectorFormat::GetData<int64_t>(new_size_data);
+
+	UnifiedVectorFormat child_data;
+	child.ToUnifiedFormat(count, child_data);
+
+	// Find the new size of the result child vector
+	idx_t new_child_size = 0;
+	for (idx_t i = 0; i < count; i++) {
+		auto index = new_size_data.sel->get_index(i);
+		if (new_size_data.validity.RowIsValid(index)) {
+			new_child_size += new_size_entries[index];
+		}
+	}
+
+	// Create the default vector if it exists
+	UnifiedVectorFormat default_data;
+	optional_ptr<Vector> default_vector;
+	if (args.ColumnCount() == 3) {
+		default_vector = &args.data[2];
+		default_vector->ToUnifiedFormat(count, default_data);
+		default_vector->SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+
+	ListVector::Reserve(result, new_child_size);
+	ListVector::SetListSize(result, new_child_size);
+
+	auto result_entries = FlatVector::GetData<list_entry_t>(result);
+	auto &result_child = ListVector::GetEntry(result);
+
+	// for each lists in the args
+	idx_t result_child_offset = 0;
+	for (idx_t args_index = 0; args_index < count; args_index++) {
+		auto l_index = list_data.sel->get_index(args_index);
+		auto new_index = new_size_data.sel->get_index(args_index);
+
+		// set null if lists is null
+		if (!list_data.validity.RowIsValid(l_index)) {
+			FlatVector::SetNull(result, args_index, true);
+			continue;
+		}
+
+		idx_t new_size_entry = 0;
+		if (new_size_data.validity.RowIsValid(new_index)) {
+			new_size_entry = new_size_entries[new_index];
+		}
+
+		// find the smallest size between lists and new_sizes
+		auto values_to_copy = MinValue<idx_t>(list_entries[l_index].length, new_size_entry);
+
+		// set the result entry
+		result_entries[args_index].offset = result_child_offset;
+		result_entries[args_index].length = new_size_entry;
+
+		// copy the values from the child vector
+		VectorOperations::Copy(child, result_child, list_entries[l_index].offset + values_to_copy,
+		                       list_entries[l_index].offset, result_child_offset);
+		result_child_offset += values_to_copy;
+
+		// set default value if it exists
+		idx_t def_index = 0;
+		if (args.ColumnCount() == 3) {
+			def_index = default_data.sel->get_index(args_index);
+		}
+
+		// if the new size is larger than the old size, fill in the default value
+		if (values_to_copy < new_size_entry) {
+			if (default_vector && default_data.validity.RowIsValid(def_index)) {
+				VectorOperations::Copy(*default_vector, result_child, new_size_entry - values_to_copy, def_index,
+				                       result_child_offset);
+				result_child_offset += new_size_entry - values_to_copy;
+			} else {
+				for (idx_t j = values_to_copy; j < new_size_entry; j++) {
+					FlatVector::SetNull(result_child, result_child_offset, true);
+					result_child_offset++;
+				}
+			}
+		}
+	}
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+}
+
+static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+	D_ASSERT(bound_function.arguments.size() == 2 || arguments.size() == 3);
+	bound_function.arguments[1] = LogicalType::UBIGINT;
+
+	// first argument is constant NULL
+	if (arguments[0]->return_type == LogicalType::SQLNULL) {
+		bound_function.arguments[0] = LogicalType::SQLNULL;
+		bound_function.return_type = LogicalType::SQLNULL;
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	// prepared statements
+	if (arguments[0]->return_type == LogicalType::UNKNOWN) {
+		bound_function.return_type = arguments[0]->return_type;
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	// default type does not match list type
+	if (bound_function.arguments.size() == 3 &&
+	    ListType::GetChildType(arguments[0]->return_type) != arguments[2]->return_type &&
+	    arguments[2]->return_type != LogicalTypeId::SQLNULL) {
+		bound_function.arguments[2] = ListType::GetChildType(arguments[0]->return_type);
+	}
+
+	bound_function.return_type = arguments[0]->return_type;
+	return make_uniq<VariableReturnBindData>(bound_function.return_type);
+}
+
+void ListResizeFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction sfun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY},
+	                    LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
+	sfun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+
+	ScalarFunction dfun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY, LogicalTypeId::ANY},
+	                    LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind);
+	dfun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+
+	ScalarFunctionSet list_resize("list_resize");
+	list_resize.AddFunction(sfun);
+	list_resize.AddFunction(dfun);
+	set.AddFunction(list_resize);
+
+	ScalarFunctionSet array_resize("array_resize");
+	array_resize.AddFunction(sfun);
+	array_resize.AddFunction(dfun);
+	set.AddFunction(array_resize);
+}
+
+} // namespace duckdb

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

@@ -8,6 +8,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListContainsFun>();
 	Register<ListPositionFun>();
 	Register<ListExtractFun>();
+	Register<ListResizeFun>();
 }
 
 } // namespace duckdb