duckdb 1.3.3-dev4.0 → 1.3.3

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

@@ -7,9 +7,7 @@
 
 namespace duckdb {
 
-namespace {
-
-string IntegralCompressFunctionName(const LogicalType &result_type) {
+static string IntegralCompressFunctionName(const LogicalType &result_type) {
 	return StringUtil::Format("__internal_compress_integral_%s",
 	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
 }
@@ -39,7 +37,7 @@ struct TemplatedIntegralCompress<uhugeint_t, RESULT_TYPE> {
 };
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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];
@@ -56,13 +54,13 @@ void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-scalar_function_t GetIntegralCompressFunction(const LogicalType &input_type, const LogicalType &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>
-scalar_function_t GetIntegralCompressFunctionResultSwitch(const LogicalType &input_type,
-                                                          const LogicalType &result_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);
@@ -77,8 +75,8 @@ scalar_function_t GetIntegralCompressFunctionResultSwitch(const LogicalType &inp
 	}
 }
 
-scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalType &input_type,
-                                                         const LogicalType &result_type) {
+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);
@@ -101,7 +99,7 @@ scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalType &inpu
 	}
 }
 
-string IntegralDecompressFunctionName(const LogicalType &result_type) {
+static string IntegralDecompressFunctionName(const LogicalType &result_type) {
 	return StringUtil::Format("__internal_decompress_integral_%s",
 	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
 }
@@ -128,7 +126,7 @@ struct TemplatedIntegralDecompress<INPUT_TYPE, uhugeint_t> {
 };
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-void IntegralDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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());
@@ -142,13 +140,13 @@ void IntegralDecompressFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 template <class INPUT_TYPE, class RESULT_TYPE>
-scalar_function_t GetIntegralDecompressFunction(const LogicalType &input_type, const LogicalType &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>
-scalar_function_t GetIntegralDecompressFunctionResultSwitch(const LogicalType &input_type,
-                                                            const LogicalType &result_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);
@@ -171,8 +169,8 @@ scalar_function_t GetIntegralDecompressFunctionResultSwitch(const LogicalType &i
 	}
 }
 
-scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalType &input_type,
-                                                           const LogicalType &result_type) {
+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);
@@ -187,8 +185,8 @@ scalar_function_t GetIntegralDecompressFunctionInputSwitch(const LogicalType &in
 	}
 }
 
-void CMIntegralSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                         const ScalarFunction &function) {
+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);
 }
@@ -201,7 +199,15 @@ unique_ptr<FunctionData> CMIntegralDeserialize(Deserializer &deserializer, Scala
 	return nullptr;
 }
 
-ScalarFunctionSet GetIntegralCompressFunctionSet(const LogicalType &result_type) {
+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 set(IntegralCompressFunctionName(result_type));
 	for (const auto &input_type : LogicalType::Integral()) {
 		if (GetTypeIdSize(result_type.InternalType()) < GetTypeIdSize(input_type.InternalType())) {
@@ -211,7 +217,15 @@ ScalarFunctionSet GetIntegralCompressFunctionSet(const LogicalType &result_type)
 	return set;
 }
 
-ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &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), CMUtils::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 : CMUtils::IntegralTypes()) {
 		if (GetTypeIdSize(result_type.InternalType()) > GetTypeIdSize(input_type.InternalType())) {
@@ -221,29 +235,6 @@ ScalarFunctionSet GetIntegralDecompressFunctionSet(const LogicalType &result_typ
 	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,29 +6,27 @@
 
 namespace duckdb {
 
-namespace {
-
-string StringCompressFunctionName(const LogicalType &result_type) {
+static string StringCompressFunctionName(const LogicalType &result_type) {
 	return StringUtil::Format("__internal_compress_string_%s",
 	                          StringUtil::Lower(LogicalTypeIdToString(result_type.id())));
 }
 
 template <idx_t LENGTH>
-inline void TemplatedReverseMemCpy(const data_ptr_t &__restrict dest, const const_data_ptr_t &__restrict src) {
+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];
 	}
 }
 
-inline void ReverseMemCpy(const data_ptr_t &__restrict dest, const const_data_ptr_t &__restrict src,
-                          const idx_t &length) {
+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>
-inline RESULT_TYPE StringCompressInternal(const string_t &input) {
+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) {
@@ -38,9 +36,8 @@ 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 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);
+		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] = UnsafeNumericCast<data_t>(input.GetSize());
@@ -48,13 +45,13 @@ inline RESULT_TYPE StringCompressInternal(const string_t &input) {
 }
 
 template <class RESULT_TYPE>
-inline RESULT_TYPE StringCompress(const string_t &input) {
+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>
-inline RESULT_TYPE MiniStringCompress(const string_t &input) {
+static 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) {
@@ -71,7 +68,7 @@ inline uint8_t StringCompress(const string_t &input) {
 }
 
 template <class RESULT_TYPE>
-void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+static 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)
@@ -82,11 +79,11 @@ void StringCompressFunction(DataChunk &args, ExpressionState &state, Vector &res
 }
 
 template <class RESULT_TYPE>
-scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
+static scalar_function_t GetStringCompressFunction(const LogicalType &result_type) {
 	return StringCompressFunction<RESULT_TYPE>;
 }
 
-scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
+static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type) {
 	switch (result_type.id()) {
 	case LogicalTypeId::UTINYINT:
 		return GetStringCompressFunction<uint8_t>(result_type);
@@ -98,15 +95,12 @@ scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &result_type
 		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");
 	}
 }
 
-string StringDecompressFunctionName() {
+static string StringDecompressFunctionName() {
 	return "__internal_decompress_string";
 }
 
@@ -125,7 +119,7 @@ public:
 };
 
 template <class INPUT_TYPE>
-inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+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) {
@@ -145,7 +139,7 @@ inline string_t StringDecompress(const INPUT_TYPE &input, ArenaAllocator &alloca
 }
 
 template <class INPUT_TYPE>
-inline string_t MiniStringDecompress(const INPUT_TYPE &input, ArenaAllocator &allocator) {
+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);
@@ -171,7 +165,7 @@ inline string_t StringDecompress(const uint8_t &input, ArenaAllocator &allocator
 }
 
 template <class INPUT_TYPE>
-void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+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>(
@@ -181,11 +175,11 @@ void StringDecompressFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 template <class INPUT_TYPE>
-scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
+static scalar_function_t GetStringDecompressFunction(const LogicalType &input_type) {
 	return StringDecompressFunction<INPUT_TYPE>;
 }
 
-scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
+static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_type) {
 	switch (input_type.id()) {
 	case LogicalTypeId::UTINYINT:
 		return GetStringDecompressFunction<uint8_t>(input_type);
@@ -197,15 +191,13 @@ scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &input_typ
 		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");
 	}
 }
 
-void CMStringCompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                               const ScalarFunction &function) {
+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);
 }
@@ -217,8 +209,16 @@ unique_ptr<FunctionData> CMStringCompressDeserialize(Deserializer &deserializer,
 	return nullptr;
 }
 
-void CMStringDecompressSerialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data,
-                                 const ScalarFunction &function) {
+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) {
 	serializer.WriteProperty(100, "arguments", function.arguments);
 }
 
@@ -229,32 +229,6 @@ 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,
@@ -264,6 +238,14 @@ 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));
 }
@@ -280,11 +262,6 @@ 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));
 }