duckdb 0.8.2-dev87.0 → 0.9.1-dev0.0

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

@@ -92,46 +92,4 @@ string MacroFunction::ToSQL(const string &schema, const string &name) const {
 	return StringUtil::Format("CREATE MACRO %s.%s(%s) AS ", schema, name, StringUtil::Join(param_strings, ", "));
 }
 
-void MacroFunction::Serialize(Serializer &main_serializer) const {
-	FieldWriter writer(main_serializer);
-	writer.WriteField(type);
-	writer.WriteSerializableList(parameters);
-	writer.WriteField<uint32_t>((uint32_t)default_parameters.size());
-	auto &serializer = writer.GetSerializer();
-	for (auto &kv : default_parameters) {
-		serializer.WriteString(kv.first);
-		kv.second->Serialize(serializer);
-	}
-	SerializeInternal(writer);
-	writer.Finalize();
-}
-
-unique_ptr<MacroFunction> MacroFunction::Deserialize(Deserializer &main_source) {
-	FieldReader reader(main_source);
-	auto type = reader.ReadRequired<MacroType>();
-	auto parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
-	auto default_param_count = reader.ReadRequired<uint32_t>();
-	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < default_param_count; i++) {
-		auto name = source.Read<string>();
-		default_parameters[name] = ParsedExpression::Deserialize(source);
-	}
-	unique_ptr<MacroFunction> result;
-	switch (type) {
-	case MacroType::SCALAR_MACRO:
-		result = ScalarMacroFunction::Deserialize(reader);
-		break;
-	case MacroType::TABLE_MACRO:
-		result = TableMacroFunction::Deserialize(reader);
-		break;
-	default:
-		throw InternalException("Cannot deserialize macro type");
-	}
-	result->parameters = std::move(parameters);
-	result->default_parameters = std::move(default_parameters);
-	reader.Finalize();
-	return result;
-}
-
 } // namespace duckdb

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

@@ -80,6 +80,10 @@ static void PragmaEnableForceParallelism(ClientContext &context, const FunctionP
 	ClientConfig::GetConfig(context).verify_parallelism = true;
 }
 
+static void PragmaEnableIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
+	ClientConfig::GetConfig(context).enable_index_join = true;
+}
+
 static void PragmaEnableForceIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
 	ClientConfig::GetConfig(context).force_index_join = true;
 }
@@ -140,6 +144,7 @@ void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_optimizer", PragmaEnableOptimizer));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_optimizer", PragmaDisableOptimizer));
 
+	set.AddFunction(PragmaFunction::PragmaStatement("enable_index_join", PragmaEnableIndexJoin));
 	set.AddFunction(PragmaFunction::PragmaStatement("force_index_join", PragmaEnableForceIndexJoin));
 	set.AddFunction(PragmaFunction::PragmaStatement("force_checkpoint", PragmaForceCheckpoint));
 

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

@@ -123,12 +123,16 @@ string PragmaShow(ClientContext &context, const FunctionParameters &parameters)
 	LEFT JOIN duckdb_columns cols 
 	ON cols.column_name = pragma_table_info.name 
 	AND cols.table_name='%table_name%'
-	AND cols.schema_name='%table_schema%';)";
+	AND cols.schema_name='%table_schema%'
+	AND cols.database_name = '%table_database%'
+	ORDER BY column_index;)";
 	// clang-format on
 
 	sql = StringUtil::Replace(sql, "%func_param_table%", parameters.values[0].ToString());
 	sql = StringUtil::Replace(sql, "%table_name%", table.name);
 	sql = StringUtil::Replace(sql, "%table_schema%", table.schema.empty() ? DEFAULT_SCHEMA : table.schema);
+	sql = StringUtil::Replace(sql, "%table_database%",
+	                          table.catalog.empty() ? DatabaseManager::GetDefaultDatabase(context) : table.catalog);
 	return sql;
 }
 
@@ -136,6 +140,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) {
@@ -182,9 +190,14 @@ string PragmaStorageInfo(ClientContext &context, const FunctionParameters &param
 	return StringUtil::Format("SELECT * FROM pragma_storage_info('%s');", parameters.values[0].ToString());
 }
 
+string PragmaMetadataInfo(ClientContext &context, const FunctionParameters &parameters) {
+	return "SELECT * FROM pragma_metadata_info();";
+}
+
 void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaCall("table_info", PragmaTableInfo, {LogicalType::VARCHAR}));
 	set.AddFunction(PragmaFunction::PragmaCall("storage_info", PragmaStorageInfo, {LogicalType::VARCHAR}));
+	set.AddFunction(PragmaFunction::PragmaCall("metadata_info", PragmaMetadataInfo, {}));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_tables", PragmaShowTables));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_tables_expanded", PragmaShowTablesExpanded));
 	set.AddFunction(PragmaFunction::PragmaStatement("show_databases", PragmaShowDatabases));
@@ -192,6 +205,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,214 @@
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.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(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                const ScalarFunction &function) {
+	serializer.WriteProperty(100, "arguments", function.arguments);
+	serializer.WriteProperty(101, "return_type", function.return_type);
+}
+
+template <scalar_function_t (*GET_FUNCTION)(const LogicalType &, const LogicalType &)>
+unique_ptr<FunctionData> CMIntegralDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
+	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
+	function.function = GET_FUNCTION(function.arguments[0], return_type);
+	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,250 @@
+#include "duckdb/common/bswap.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/common/serializer/deserializer.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(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                      const ScalarFunction &function) {
+	serializer.WriteProperty(100, "arguments", function.arguments);
+	serializer.WriteProperty(101, "return_type", function.return_type);
+}
+
+unique_ptr<FunctionData> CMStringCompressDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
+	auto return_type = deserializer.ReadProperty<LogicalType>(101, "return_type");
+	function.function = GetStringCompressFunctionSwitch(return_type);
+	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(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                        const ScalarFunction &function) {
+	serializer.WriteProperty(100, "arguments", function.arguments);
+}
+
+unique_ptr<FunctionData> CMStringDecompressDeserialize(Deserializer &deserializer, ScalarFunction &function) {
+	function.arguments = deserializer.ReadProperty<vector<LogicalType>>(100, "arguments");
+	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