This is an automated email from the ASF dual-hosted git repository.
github-merge-queue[bot] pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/hudi.git
The following commit(s) were added to refs/heads/master by this push:
new 15277ae4562c fix(flink): preserve precision in decimal conversions
(#20566)
15277ae4562c is described below
commit 15277ae4562c1621289870e3a9d7316df108c88d
Author: Danny Chan <[email protected]>
AuthorDate: Thu Nov 12 03:48:37 2026 +0000
fix(flink): preserve precision in decimal conversions (#20566)
* fix(flink): preserve precision in decimal conversions
* refactor(flink): select decimal converters by source type
* fix(flink): trim strings before decimal conversion
---
.../java/org/apache/hudi/util/TypeConverters.java | 30 ++++----
.../org/apache/hudi/util/TestTypeConverters.java | 83 ++++++++++++++++++++++
2 files changed, 97 insertions(+), 16 deletions(-)
diff --git
a/hudi-client/hudi-flink-client/src/main/java/org/apache/hudi/util/TypeConverters.java
b/hudi-client/hudi-flink-client/src/main/java/org/apache/hudi/util/TypeConverters.java
index cef2df7c037f..eaebf74ee795 100644
---
a/hudi-client/hudi-flink-client/src/main/java/org/apache/hudi/util/TypeConverters.java
+++
b/hudi-client/hudi-flink-client/src/main/java/org/apache/hudi/util/TypeConverters.java
@@ -134,13 +134,23 @@ public class TypeConverters {
}
case DECIMAL: {
- if (from == INTEGER || from == BIGINT || from == DOUBLE) {
+ if (from == INTEGER || from == BIGINT) {
return new TypeConverter() {
private static final long serialVersionUID = 1L;
@Override
public Object convert(Object val) {
- return toDecimalData((Number) val, toType);
+ return toDecimalData(BigDecimal.valueOf(((Number)
val).longValue()), toType);
+ }
+ };
+ }
+ if (from == DOUBLE) {
+ return new TypeConverter() {
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ public Object convert(Object val) {
+ return toDecimalData(BigDecimal.valueOf(((Number)
val).doubleValue()), toType);
}
};
}
@@ -150,7 +160,7 @@ public class TypeConverters {
@Override
public Object convert(Object val) {
- return toDecimalData(Double.parseDouble(val.toString()), toType);
+ return
toDecimalData(BigDecimal.valueOf(Double.parseDouble(val.toString())), toType);
}
};
}
@@ -160,7 +170,7 @@ public class TypeConverters {
@Override
public Object convert(Object val) {
- return toDecimalData(Double.parseDouble(val.toString()), toType);
+ return toDecimalData(new BigDecimal(val.toString().trim()),
toType);
}
};
}
@@ -370,18 +380,6 @@ public class TypeConverters {
return !isComplex && fromType.equals(toType);
}
- /**
- * Helper function to convert a Number object to Flink's DecimalData format.
- *
- * @param val Number object to be converted
- * @param decimalType DecimalType containing the output decimal's precision
and scale specifications
- * @return Converted decimal that is wrapped in Flink's DecimalData object.
- */
- private static DecimalData toDecimalData(Number val, LogicalType
decimalType) {
- BigDecimal valAsDecimal = BigDecimal.valueOf(val.doubleValue());
- return toDecimalData(valAsDecimal, decimalType);
- }
-
/**
* Helper function to convert a BigDecimal object to Flink's DecimalData
format.
*
diff --git
a/hudi-client/hudi-flink-client/src/test/java/org/apache/hudi/util/TestTypeConverters.java
b/hudi-client/hudi-flink-client/src/test/java/org/apache/hudi/util/TestTypeConverters.java
new file mode 100644
index 000000000000..2b0bb70d691d
--- /dev/null
+++
b/hudi-client/hudi-flink-client/src/test/java/org/apache/hudi/util/TestTypeConverters.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.util;
+
+import org.apache.flink.table.api.DataTypes;
+import org.apache.flink.table.data.DecimalData;
+import org.apache.flink.table.data.StringData;
+import org.apache.flink.table.types.logical.LogicalType;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.math.BigDecimal;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class TestTypeConverters {
+
+ @ParameterizedTest
+ @ValueSource(longs = {0L, 9007199254740993L, -9007199254740993L,
Long.MAX_VALUE, Long.MIN_VALUE})
+ void testLongToDecimalPreservesPrecision(long value) {
+ assertDecimal(DataTypes.BIGINT().getLogicalType(), value, 19, 0,
Long.toString(value));
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"9007199254740993.01", "-9007199254740993.01",
"12345678901234567890.12"})
+ void testStringToDecimalPreservesPrecision(String value) {
+ assertDecimal(DataTypes.STRING().getLogicalType(),
StringData.fromString(value), 22, 2, value);
+ }
+
+ @Test
+ void testPaddedStringToDecimalPreservesPrecision() {
+ assertDecimal(DataTypes.STRING().getLogicalType(), StringData.fromString("
\t9007199254740993.01\r\n"),
+ 22, 2, "9007199254740993.01");
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {" 1.5", "1.5 ", " \t1.5\r\n"})
+ void testStringToDecimalTrimsWhitespace(String value) {
+ assertDecimal(DataTypes.STRING().getLogicalType(),
StringData.fromString(value), 3, 2, "1.50");
+ }
+
+ @Test
+ void testDecimalScaleAndNumericConversions() {
+ assertDecimal(DataTypes.INT().getLogicalType(), Integer.MAX_VALUE, 12, 2,
"2147483647.00");
+ assertDecimal(DataTypes.BIGINT().getLogicalType(), 9007199254740993L, 18,
2, "9007199254740993.00");
+ assertDecimal(DataTypes.FLOAT().getLogicalType(), 1.23f, 5, 2, "1.23");
+ assertDecimal(DataTypes.DOUBLE().getLogicalType(), 1.23d, 5, 2, "1.23");
+ assertDecimal(DataTypes.STRING().getLogicalType(),
StringData.fromString("9007199254740993.015"),
+ 18, 2, "9007199254740993.02");
+ }
+
+ @Test
+ void testDecimalOverflow() {
+ assertNull(TypeConverters.getInstance(DataTypes.BIGINT().getLogicalType(),
DataTypes.DECIMAL(18, 0).getLogicalType())
+ .convert(Long.MAX_VALUE));
+ assertNull(TypeConverters.getInstance(DataTypes.STRING().getLogicalType(),
DataTypes.DECIMAL(18, 2).getLogicalType())
+ .convert(StringData.fromString("12345678901234567890.12")));
+ }
+
+ private static void assertDecimal(LogicalType fromType, Object value, int
precision, int scale, String expected) {
+ DecimalData result = (DecimalData) TypeConverters.getInstance(fromType,
DataTypes.DECIMAL(precision, scale).getLogicalType())
+ .convert(value);
+ assertEquals(new BigDecimal(expected), result.toBigDecimal());
+ }
+}