(ignite-3) branch main updated: IGNITE-23415 NumericBinaryOperationsExecutionTest fails with division by zero (#4564)

[zstan]

This is an automated email from the ASF dual-hosted git repository.

zstan pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/ignite-3.git


The following commit(s) were added to refs/heads/main by this push:
     new 3fbbdb033e IGNITE-23415 NumericBinaryOperationsExecutionTest fails 
with division by zero (#4564)
3fbbdb033e is described below

commit 3fbbdb033ebc548c8b5d80a92ced57d9edc530d6
Author: Evgeniy Stanilovskiy <stanilov...@gmail.com>
AuthorDate: Tue Oct 15 14:39:34 2024 +0300

    IGNITE-23415 NumericBinaryOperationsExecutionTest fails with division by 
zero (#4564)
---
 .../exec/coercion/BaseTypeCheckExecutionTest.java  | 84 ++++++++++++++++++++++
 .../NumericBinaryOperationsExecutionTest.java      |  2 +-
 2 files changed, 85 insertions(+), 1 deletion(-)

diff --git 
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/BaseTypeCheckExecutionTest.java
 
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/BaseTypeCheckExecutionTest.java
index af33a14840..468758d423 100644
--- 
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/BaseTypeCheckExecutionTest.java
+++ 
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/BaseTypeCheckExecutionTest.java
@@ -78,6 +78,14 @@ class BaseTypeCheckExecutionTest extends 
BaseIgniteAbstractTest {
         return DataProvider.fromRow(new Object[]{0, val1, val2}, 1);
     }
 
+    /** Data provider with non zero for second value. */
+    static DataProvider<Object[]> dataProviderWithNonZeroSecondValue(TypePair 
typePair) {
+        Object val1 = SqlTestUtils.generateValueByType(typePair.first());
+        Object val2 = generateNotZeroValueByType(typePair.second());
+
+        return DataProvider.fromRow(new Object[]{0, val1, val2}, 1);
+    }
+
     private static @Nullable Object generateReducedValueByType(NativeType 
nativeType) {
         ColumnType type = nativeType.spec().asColumnType();
 
@@ -134,6 +142,82 @@ class BaseTypeCheckExecutionTest extends 
BaseIgniteAbstractTest {
         return generateConstantValueByType(type, "2");
     }
 
+    private static Object generateNotZeroValueByType(NativeType nativeType) {
+        ColumnType type = nativeType.spec().asColumnType();
+
+        switch (type) {
+            case INT8: {
+                byte res;
+
+                do {
+                    res = (byte) (((byte) 
SqlTestUtils.generateValueByType(type, 0, 0)));
+                } while (res == 0);
+
+                return res;
+            }
+            case INT16: {
+                short res;
+
+                do {
+                    res = ((short) SqlTestUtils.generateValueByType(type, 0, 
0));
+                } while (res == 0);
+
+                return res;
+            }
+            case INT32: {
+                int res;
+
+                do {
+                    res = (int) SqlTestUtils.generateValueByType(type, 0, 0);
+                } while (res == 0);
+
+                return res;
+            }
+            case INT64: {
+                long res;
+
+                do {
+                    res = (long) SqlTestUtils.generateValueByType(type, 0, 0);
+                } while (res == 0);
+
+                return res;
+            }
+            case FLOAT: {
+                float res;
+
+                do {
+                    res = (float) SqlTestUtils.generateValueByType(type, 0, 0);
+                } while (Math.signum(res) == 0);
+
+                return res;
+            }
+            case DOUBLE: {
+                double res;
+
+                do {
+                    res = (double) SqlTestUtils.generateValueByType(type, 0, 
0);
+                } while (Math.signum(res) == 0);
+
+                return res;
+            }
+            case DECIMAL: {
+                int scale = ((DecimalNativeType) nativeType).scale();
+                int precision = ((DecimalNativeType) nativeType).precision();
+
+                BigDecimal res;
+
+                do {
+                    res = ((BigDecimal) SqlTestUtils.generateValueByType(type, 
precision, scale))
+                            .divide(BigDecimal.valueOf(2), 
RoundingMode.HALF_DOWN).setScale(scale, RoundingMode.HALF_DOWN);
+                } while (res.compareTo(BigDecimal.ZERO) == 0);
+
+                return res;
+            }
+            default:
+                throw new IllegalArgumentException("unsupported type " + type);
+        }
+    }
+
     static ClusterWrapper testCluster(TypePair typePair, 
DataProvider<Object[]> dataProvider) {
         TestCluster cluster = TestBuilders.cluster().nodes("N1")
                 .addTable().name("T")
diff --git 
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/NumericBinaryOperationsExecutionTest.java
 
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/NumericBinaryOperationsExecutionTest.java
index 4ae7031cc0..4ca9837426 100644
--- 
a/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/NumericBinaryOperationsExecutionTest.java
+++ 
b/modules/sql-engine/src/test/java/org/apache/ignite/internal/sql/engine/exec/coercion/NumericBinaryOperationsExecutionTest.java
@@ -75,7 +75,7 @@ public class NumericBinaryOperationsExecutionTest extends 
BaseTypeCheckExecution
 
         String sql = "SELECT c1 % c2 FROM t";
 
-        try (ClusterWrapper testCluster = testCluster(typePair, 
dataProvider(typePair))) {
+        try (ClusterWrapper testCluster = testCluster(typePair, 
dataProviderWithNonZeroSecondValue(typePair))) {
             testCluster.process(sql, checkReturnResult());
         }
     }