duckdb 0.8.2-dev33.0 → 0.8.2-dev3300.0

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -39,8 +39,8 @@ struct CountStarFunction : public BaseCountFunction {
 	                   Vector &result, idx_t rid, idx_t bias) {
 		D_ASSERT(input_count == 0);
 		auto data = FlatVector::GetData<RESULT_TYPE>(result);
-		const auto begin = frame.first;
-		const auto end = frame.second;
+		const auto begin = frame.start;
+		const auto end = frame.end;
 		// Slice to any filtered rows
 		if (!filter_mask.AllValid()) {
 			RESULT_TYPE filtered = 0;
@@ -218,22 +218,11 @@ AggregateFunction CountFun::GetFunction() {
 	return fun;
 }
 
-static void CountStarSerialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
-}
-
-static unique_ptr<FunctionData> CountStarDeserialize(PlanDeserializationState &state, FieldReader &reader,
-                                                     AggregateFunction &function) {
-	return nullptr;
-}
-
 AggregateFunction CountStarFun::GetFunction() {
 	auto fun = AggregateFunction::NullaryAggregate<int64_t, int64_t, CountStarFunction>(LogicalType::BIGINT);
 	fun.name = "count_star";
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.window = CountStarFunction::Window<int64_t>;
-	// TODO is there a better way to set those?
-	fun.serialize = CountStarSerialize;
-	fun.deserialize = CountStarDeserialize;
 	return fun;
 }
 

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -374,7 +374,8 @@ struct SortedAggregateFunction {
 
 		// State variables
 		auto bind_info = order_bind.bind_info.get();
-		AggregateInputData aggr_bind_info(bind_info, Allocator::DefaultAllocator());
+		ArenaAllocator allocator(Allocator::DefaultAllocator());
+		AggregateInputData aggr_bind_info(bind_info, allocator);
 
 		// Inner aggregate APIs
 		auto initialize = order_bind.function.initialize;
@@ -467,11 +468,12 @@ struct SortedAggregateFunction {
 
 					// These are all simple updates, so use it if available
 					if (simple_update) {
-						simple_update(sliced.data.data(), aggr_bind_info, 1, agg_state.data(), sliced.size());
+						simple_update(sliced.data.data(), aggr_bind_info, sliced.data.size(), agg_state.data(),
+						              sliced.size());
 					} else {
 						// We are only updating a constant state
 						agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-						update(sliced.data.data(), aggr_bind_info, 1, agg_state_vec, sliced.size());
+						update(sliced.data.data(), aggr_bind_info, sliced.data.size(), agg_state_vec, sliced.size());
 					}
 
 					consumed += input_count;
@@ -515,14 +517,6 @@ struct SortedAggregateFunction {
 
 		result.Verify(count);
 	}
-
-	static void Serialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {
-		throw NotImplementedException("FIXME: serialize sorted aggregate not supported");
-	}
-	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &state, FieldReader &reader,
-	                                            AggregateFunction &function) {
-		throw NotImplementedException("FIXME: deserialize sorted aggregate not supported");
-	}
 };
 
 void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr,
@@ -581,7 +575,7 @@ void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateE
 	    AggregateFunction::StateCombine<SortedAggregateState, SortedAggregateFunction>,
 	    SortedAggregateFunction::Finalize, bound_function.null_handling, SortedAggregateFunction::SimpleUpdate, nullptr,
 	    AggregateFunction::StateDestroy<SortedAggregateState, SortedAggregateFunction>, nullptr,
-	    SortedAggregateFunction::Window, SortedAggregateFunction::Serialize, SortedAggregateFunction::Deserialize);
+	    SortedAggregateFunction::Window);
 
 	expr.function = std::move(ordered_aggregate);
 	expr.bind_info = std::move(sorted_bind);

package/src/duckdb/src/function/cast/bit_cast.cpp

@@ -1,3 +1,6 @@
+#include "duckdb/common/hugeint.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/types.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/vector_cast_helpers.hpp"
 
@@ -6,9 +9,38 @@ namespace duckdb {
 BoundCastInfo DefaultCasts::BitCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) {
 	// now switch on the result type
 	switch (target.id()) {
+	// Numerics
+	case LogicalTypeId::BOOLEAN:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, bool, CastFromBitToNumeric>);
+	case LogicalTypeId::TINYINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int8_t, CastFromBitToNumeric>);
+	case LogicalTypeId::SMALLINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int16_t, CastFromBitToNumeric>);
+	case LogicalTypeId::INTEGER:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int32_t, CastFromBitToNumeric>);
+	case LogicalTypeId::BIGINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, int64_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UTINYINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint8_t, CastFromBitToNumeric>);
+	case LogicalTypeId::USMALLINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint16_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UINTEGER:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint32_t, CastFromBitToNumeric>);
+	case LogicalTypeId::UBIGINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, uint64_t, CastFromBitToNumeric>);
+	case LogicalTypeId::HUGEINT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, hugeint_t, CastFromBitToNumeric>);
+	case LogicalTypeId::FLOAT:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, float, CastFromBitToNumeric>);
+	case LogicalTypeId::DOUBLE:
+		return BoundCastInfo(&VectorCastHelpers::TryCastLoop<string_t, double, CastFromBitToNumeric>);
+
+	case LogicalTypeId::BLOB:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToBlob>);
+
 	case LogicalTypeId::VARCHAR:
-		// bit to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBit>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, CastFromBitToString>);
+
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/blob_cast.cpp

@@ -11,6 +11,9 @@ BoundCastInfo DefaultCasts::BlobCastSwitch(BindCastInput &input, const LogicalTy
 		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlob>);
 	case LogicalTypeId::AGGREGATE_STATE:
 		return DefaultCasts::ReinterpretCast;
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<string_t, duckdb::CastFromBlobToBit>);
+
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/numeric_casts.cpp

@@ -37,6 +37,8 @@ static BoundCastInfo InternalNumericCastSwitch(const LogicalType &source, const
 		return BoundCastInfo(&VectorCastHelpers::ToDecimalCast<SRC>);
 	case LogicalTypeId::VARCHAR:
 		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::StringCast>);
+	case LogicalTypeId::BIT:
+		return BoundCastInfo(&VectorCastHelpers::StringCast<SRC, duckdb::NumericTryCastToBit>);
 	default:
 		return DefaultCasts::TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/string_cast.cpp

@@ -36,7 +36,6 @@ bool StringEnumCastLoop(const string_t *source_data, ValidityMask &source_mask,
 template <class T>
 bool StringEnumCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(source.GetType().id() == LogicalTypeId::VARCHAR);
-	auto enum_name = EnumType::GetTypeName(result.GetType());
 	switch (source.GetVectorType()) {
 	case VectorType::CONSTANT_VECTOR: {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -368,8 +367,9 @@ BoundCastInfo DefaultCasts::StringCastSwitch(BindCastInput &input, const Logical
 	case LogicalTypeId::DATE:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, date_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_t, duckdb::TryCastErrorMessage>);
+	case LogicalTypeId::TIME_TZ:
+		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, dtime_tz_t, duckdb::TryCastErrorMessage>);
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		return BoundCastInfo(&VectorCastHelpers::TryCastErrorLoop<string_t, timestamp_t, duckdb::TryCastErrorMessage>);

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -32,7 +32,7 @@ BoundCastInfo DefaultCasts::TimeCastSwitch(BindCastInput &input, const LogicalTy
 		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCast>);
 	case LogicalTypeId::TIME_TZ:
 		// time to time with time zone
-		return ReinterpretCast;
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_t, dtime_tz_t, duckdb::Cast>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -44,10 +44,10 @@ BoundCastInfo DefaultCasts::TimeTzCastSwitch(BindCastInput &input, const Logical
 	switch (target.id()) {
 	case LogicalTypeId::VARCHAR:
 		// time with time zone to varchar
-		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_t, duckdb::StringCastTZ>);
+		return BoundCastInfo(&VectorCastHelpers::StringCast<dtime_tz_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME:
 		// time with time zone to time
-		return ReinterpretCast;
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<dtime_tz_t, dtime_t, duckdb::Cast>);
 	default:
 		return TryVectorNullCast;
 	}
@@ -64,9 +64,11 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 		// timestamp to date
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, date_t, duckdb::Cast>);
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		// timestamp to time
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
+	case LogicalTypeId::TIME_TZ:
+		// timestamp to time_tz
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// timestamp (us) to timestamp with time zone
 		return ReinterpretCast;
@@ -96,8 +98,7 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 		return BoundCastInfo(&VectorCastHelpers::StringCast<timestamp_t, duckdb::StringCastTZ>);
 	case LogicalTypeId::TIME_TZ:
 		// timestamp with time zone to time with time zone.
-		// TODO: set the offset to +00
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
+		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_tz_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp with time zone to timestamp (us)
 		return ReinterpretCast;

package/src/duckdb/src/function/function.cpp

@@ -94,6 +94,8 @@ void BuiltinFunctions::Initialize() {
 
 	RegisterDistributiveAggregates();
 
+	RegisterCompressedMaterializationFunctions();
+
 	RegisterGenericFunctions();
 	RegisterOperators();
 	RegisterSequenceFunctions();
@@ -111,7 +113,7 @@ void BuiltinFunctions::Initialize() {
 hash_t BaseScalarFunction::Hash() const {
 	hash_t hash = return_type.Hash();
 	for (auto &arg : arguments) {
-		duckdb::CombineHash(hash, arg.Hash());
+		hash = duckdb::CombineHash(hash, arg.Hash());
 	}
 	return hash;
 }

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -136,6 +136,10 @@ string PragmaVersion(ClientContext &context, const FunctionParameters &parameter
 	return "SELECT * FROM pragma_version();";
 }
 
+string PragmaPlatform(ClientContext &context, const FunctionParameters &parameters) {
+	return "SELECT * FROM pragma_platform();";
+}
+
 string PragmaImportDatabase(ClientContext &context, const FunctionParameters &parameters) {
 	auto &config = DBConfig::GetConfig(context);
 	if (!config.options.enable_external_access) {
@@ -192,6 +196,7 @@ void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("collations", PragmaCollations));
 	set.AddFunction(PragmaFunction::PragmaCall("show", PragmaShow, {LogicalType::VARCHAR}));
 	set.AddFunction(PragmaFunction::PragmaStatement("version", PragmaVersion));
+	set.AddFunction(PragmaFunction::PragmaStatement("platform", PragmaPlatform));
 	set.AddFunction(PragmaFunction::PragmaStatement("database_size", PragmaDatabaseSize));
 	set.AddFunction(PragmaFunction::PragmaStatement("functions", PragmaFunctionsQuery));
 	set.AddFunction(PragmaFunction::PragmaCall("import_database", PragmaImportDatabase, {LogicalType::VARCHAR}));

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