duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -7,7 +7,9 @@
 
 namespace duckdb {
 
-static string IntegralCompressFunctionName(const LogicalType &result_type) {
+namespace {
+
+string IntegralCompressFunctionName(const LogicalType &result_type) {
 	return StringUtil::Format("__internal_compress_integral_%s",
 	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
 }
@@ -37,7 +39,7 @@ struct TemplatedIntegralCompress<uhugeint_t, RESULT_TYPE> {
 };
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-static void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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];
@@ -54,13 +56,13 @@ static void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Ve
 }
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-static scalar_function_t GetIntegralCompressFunction(const LogicalType &input_type, const LogicalType &result_type) {
+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) {
+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);
@@ -75,8 +77,8 @@ static scalar_function_t GetIntegralCompressFunctionResultSwitch(const LogicalTy
 	}
 }
 
-static scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalType &input_type,
-                                                                const LogicalType &result_type) {
+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);
@@ -99,7 +101,7 @@ static scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalTyp
 	}
 }
 
-static string IntegralDecompressFunctionName(const LogicalType &result_type) {
+string IntegralDecompressFunctionName(const LogicalType &result_type) {
 	return StringUtil::Format("__internal_decompress_integral_%s",
 	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
 }
@@ -126,7 +128,7 @@ struct TemplatedIntegralDecompress<INPUT_TYPE, uhugeint_t> {
 };
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-static void IntegralDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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());
@@ -140,13 +142,13 @@ static void IntegralDecompressFunction(DataChunk &args, ExpressionState &state,
 }
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-static scalar_function_t GetIntegralDecompressFunction(const LogicalType &input_type, const LogicalType &result_type) {
+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) {
+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);
@@ -169,8 +171,8 @@ static scalar_function_t GetIntegralDecompressFunctionResultSwitch(const Logical
 	}
 }
 
-static scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalType &input_type,
-                                                                  const LogicalType &result_type) {
+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);
@@ -185,8 +187,8 @@ static scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalT
 	}
 }
 
-static void CMIntegralSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                const ScalarFunction &function) {
+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);
 }
@@ -199,15 +201,7 @@ unique_ptr<FunctionData> CMIntegralDeserialize(Deserializer &deserializer, Scala
 	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), CMUtils::Bind);
-	result.serialize = CMIntegralSerialize;
-	result.deserialize = CMIntegralDeserialize<GetIntegralCompressFunctionInputSwitch>;
-	return result;
-}
-
-static ScalarFunctionSet GetIntegralCompressFunctionSet(const LogicalType &result_type) {
+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())) {
@@ -217,15 +211,7 @@ static ScalarFunctionSet GetIntegralCompressFunctionSet(const LogicalType &resul
 	return set;
 }
 
-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), CMUtils::Bind);
-	result.serialize = CMIntegralSerialize;
-	result.deserialize = CMIntegralDeserialize<GetIntegralDecompressFunctionInputSwitch>;
-	return result;
-}
-
-static ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &result_type) {
+ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &result_type) {
 	ScalarFunctionSet set(IntegralDecompressFunctionName(result_type));
 	for (const auto &input_type : CMUtils::IntegralTypes()) {
 		if (GetTypeIdSize(result_type.InternalType()) > GetTypeIdSize(input_type.InternalType())) {
@@ -235,6 +221,29 @@ static ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &res
 	return set;
 }
 
+} // namespace
+
+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), CMUtils::Bind);
+	result.serialize = CMIntegralSerialize;
+	result.deserialize = CMIntegralDeserialize<GetIntegralCompressFunctionInputSwitch>;
+#if defined(D_ASSERT_IS_ENABLED)
+	result.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR; // Can only throw runtime error when assertions are enabled
+#else
+	result.errors = FunctionErrors::CANNOT_ERROR;
+#endif
+	return result;
+}
+
+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), CMUtils::Bind);
+	result.serialize = CMIntegralSerialize;
+	result.deserialize = CMIntegralDeserialize<GetIntegralDecompressFunctionInputSwitch>;
+	return result;
+}
+
 ScalarFunctionSet InternalCompressIntegralUtinyintFun::GetFunctions() {
 	return GetIntegralCompressFunctionSet(LogicalType(LogicalTypeId::UTINYINT));
 }

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

@@ -6,27 +6,29 @@
 
 namespace duckdb {
 
-static string StringCompressFunctionName(const LogicalType &result_type) {
+namespace {
+
+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) {
+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) {
+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) {
+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) {
@@ -36,8 +38,9 @@ static inline RESULT_TYPE StringCompressInternal(const string_t &input) {
 		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());
+		const auto size = MinValue<idx_t>(sizeof(RESULT_TYPE), input.GetSize());
+		const auto remainder = sizeof(RESULT_TYPE) - size;
+		ReverseMemCpy(result_ptr + remainder, data_ptr_cast(input.GetPointer()), size);
 		memset(result_ptr, '\0', remainder);
 	}
 	result_ptr[0] = UnsafeNumericCast<data_t>(input.GetSize());
@@ -45,13 +48,13 @@ static inline RESULT_TYPE StringCompressInternal(const string_t &input) {
 }
 
 template <class RESULT_TYPE>
-static inline RESULT_TYPE StringCompress(const string_t &input) {
+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) {
+inline RESULT_TYPE MiniStringCompress(const string_t &input) {
 	if (sizeof(RESULT_TYPE) <= string_t::INLINE_LENGTH) {
 		return UnsafeNumericCast<RESULT_TYPE>(input.GetSize() + *const_data_ptr_cast(input.GetPrefix()));
 	} else if (input.GetSize() == 0) {
@@ -68,7 +71,7 @@ inline uint8_t StringCompress(const string_t &input) {
 }
 
 template <class RESULT_TYPE>
-static void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	UnaryExecutor::Execute<string_t, RESULT_TYPE>(
 	    args.data[0], result, args.size(), StringCompress<RESULT_TYPE>,
 #if defined(D_ASSERT_IS_ENABLED)
@@ -79,11 +82,11 @@ static void StringCompressFunction(DataChunk &args, ExpressionState &state, Vect
 }
 
 template <class RESULT_TYPE>
-static scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
+scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
 	return StringCompressFunction<RESULT_TYPE>;
 }
 
-static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
+scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
 	switch (result_type.id()) {
 	case LogicalTypeId::UTINYINT:
 		return GetStringCompressFunction<uint8_t>(result_type);
@@ -95,12 +98,15 @@ static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &resu
 		return GetStringCompressFunction<uint64_t>(result_type);
 	case LogicalTypeId::UHUGEINT:
 		return GetStringCompressFunction<uhugeint_t>(result_type);
+	case LogicalTypeId::HUGEINT:
+		// Never generated, only for backwards compatibility
+		return GetStringCompressFunction<hugeint_t>(result_type);
 	default:
 		throw InternalException("Unexpected type in GetStringCompressFunctionSwitch");
 	}
 }
 
-static string StringDecompressFunctionName() {
+string StringDecompressFunctionName() {
 	return "__internal_decompress_string";
 }
 
@@ -119,7 +125,7 @@ public:
 };
 
 template <class INPUT_TYPE>
-static inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+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) {
@@ -139,7 +145,7 @@ static inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator
 }
 
 template <class INPUT_TYPE>
-static inline string_t MiniStringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+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);
@@ -165,7 +171,7 @@ inline string_t StringDecompress(const uint8_t &input, ArenaAllocator &allocator
 }
 
 template <class INPUT_TYPE>
-static void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &allocator = ExecuteFunctionState::GetFunctionState(state)->Cast<StringDecompressLocalState>().allocator;
 	allocator.Reset();
 	UnaryExecutor::Execute<INPUT_TYPE, string_t>(
@@ -175,11 +181,11 @@ static void StringDecompressFunction(DataChunk &args, ExpressionState &state, Ve
 }
 
 template <class INPUT_TYPE>
-static scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
+scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
 	return StringDecompressFunction<INPUT_TYPE>;
 }
 
-static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
+scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
 	switch (input_type.id()) {
 	case LogicalTypeId::UTINYINT:
 		return GetStringDecompressFunction<uint8_t>(input_type);
@@ -191,13 +197,15 @@ static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &in
 		return GetStringDecompressFunction<uint64_t>(input_type);
 	case LogicalTypeId::UHUGEINT:
 		return GetStringDecompressFunction<uhugeint_t>(input_type);
+	case LogicalTypeId::HUGEINT:
+		return GetStringCompressFunction<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) {
+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);
 }
@@ -209,16 +217,8 @@ unique_ptr<FunctionData> CMStringCompressDeserialize(Deserializer &deserializer,
 	return nullptr;
 }
 
-ScalarFunction CMStringCompressFun::GetFunction(const LogicalType &result_type) {
-	ScalarFunction result(StringCompressFunctionName(result_type), {LogicalType::VARCHAR}, result_type,
-	                      GetStringCompressFunctionSwitch(result_type), CMUtils::Bind);
-	result.serialize = CMStringCompressSerialize;
-	result.deserialize = CMStringCompressDeserialize;
-	return result;
-}
-
-static void CMStringDecompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                        const ScalarFunction &function) {
+void CMStringDecompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
+                                 const ScalarFunction &function) {
 	serializer.WriteProperty(100, "arguments", function.arguments);
 }
 
@@ -229,6 +229,32 @@ unique_ptr<FunctionData> CMStringDecompressDeserialize(Deserializer &deserialize
 	return nullptr;
 }
 
+ScalarFunctionSet GetStringDecompressFunctionSet() {
+	ScalarFunctionSet set(StringDecompressFunctionName());
+	auto string_types = CMUtils::StringTypes();
+	// For backwards compatibility, see internal issue 5306
+	string_types.push_back(LogicalType::HUGEINT);
+	for (const auto &input_type : string_types) {
+		set.AddFunction(CMStringDecompressFun::GetFunction(input_type));
+	}
+	return set;
+}
+
+} // namespace
+
+ScalarFunction CMStringCompressFun::GetFunction(const LogicalType &result_type) {
+	ScalarFunction result(StringCompressFunctionName(result_type), {LogicalType::VARCHAR}, result_type,
+	                      GetStringCompressFunctionSwitch(result_type), CMUtils::Bind);
+	result.serialize = CMStringCompressSerialize;
+	result.deserialize = CMStringCompressDeserialize;
+#if defined(D_ASSERT_IS_ENABLED)
+	result.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR; // Can only throw runtime error when assertions are enabled
+#else
+	result.errors = FunctionErrors::CANNOT_ERROR;
+#endif
+	return result;
+}
+
 ScalarFunction CMStringDecompressFun::GetFunction(const LogicalType &input_type) {
 	ScalarFunction result(StringDecompressFunctionName(), {input_type}, LogicalType::VARCHAR,
 	                      GetStringDecompressFunctionSwitch(input_type), CMUtils::Bind, nullptr, nullptr,
@@ -238,14 +264,6 @@ ScalarFunction CMStringDecompressFun::GetFunction(const LogicalType &input_type)
 	return result;
 }
 
-static ScalarFunctionSet GetStringDecompressFunctionSet() {
-	ScalarFunctionSet set(StringDecompressFunctionName());
-	for (const auto &input_type : CMUtils::StringTypes()) {
-		set.AddFunction(CMStringDecompressFun::GetFunction(input_type));
-	}
-	return set;
-}
-
 ScalarFunction InternalCompressStringUtinyintFun::GetFunction() {
 	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UTINYINT));
 }
@@ -262,6 +280,11 @@ ScalarFunction InternalCompressStringUbigintFun::GetFunction() {
 	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UBIGINT));
 }
 
+ScalarFunction InternalCompressStringHugeintFun::GetFunction() {
+	// We never generate this, but it's needed for backwards compatibility
+	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::HUGEINT));
+}
+
 ScalarFunction InternalCompressStringUhugeintFun::GetFunction() {
 	return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UHUGEINT));
 }