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

tkalkirill pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite.git


The following commit(s) were added to refs/heads/master by this push:
     new 76bc7966fb6 IGNITE-29306 SQL Calcite: Hash join misses equal DECIMAL 
keys with different scales (#13845)
76bc7966fb6 is described below

commit 76bc7966fb6cc0608d4d9cbe876fd425e25c59cb
Author: Kirill Tkalenko <[email protected]>
AuthorDate: Wed Nov 18 12:11:56 2026 +0300

    IGNITE-29306 SQL Calcite: Hash join misses equal DECIMAL keys with 
different scales (#13845)
---
 .../query/calcite/util/SqlValueUtils.java          |  7 ++
 .../DecimalHashJoinIntegrationTest.java            | 56 +++++++++++++++
 .../query/calcite/util/SqlValueUtilsTest.java      | 82 ++++++++++++++++++++++
 .../ignite/testsuites/IntegrationTestSuite.java    |  2 +
 4 files changed, 147 insertions(+)

diff --git 
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtils.java
 
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtils.java
index 739adf4d02a..edecb4de7c2 100644
--- 
a/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtils.java
+++ 
b/modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtils.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.processors.query.calcite.util;
 
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
@@ -65,6 +66,9 @@ public final class SqlValueUtils {
         if (left.getClass().isArray() && right.getClass().isArray())
             return Arrays.deepEquals(new Object[] {left}, new Object[] 
{right});
 
+        if (left instanceof BigDecimal && right instanceof BigDecimal)
+            return ((BigDecimal)left).compareTo((BigDecimal)right) == 0;
+
         return left.equals(right);
     }
 
@@ -126,6 +130,9 @@ public final class SqlValueUtils {
         if (val.getClass().isArray())
             return Arrays.deepHashCode(new Object[] {val});
 
+        if (val instanceof BigDecimal)
+            return ((BigDecimal)val).stripTrailingZeros().hashCode();
+
         return val.hashCode();
     }
 
diff --git 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DecimalHashJoinIntegrationTest.java
 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DecimalHashJoinIntegrationTest.java
new file mode 100644
index 00000000000..6e82e77fdb4
--- /dev/null
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/integration/DecimalHashJoinIntegrationTest.java
@@ -0,0 +1,56 @@
+/*
+ * 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.ignite.internal.processors.query.calcite.integration;
+
+import java.math.BigDecimal;
+import org.junit.jupiter.api.Test;
+
+import static 
org.apache.ignite.internal.processors.query.calcite.QueryChecker.containsSubPlan;
+
+/** */
+public class DecimalHashJoinIntegrationTest extends 
AbstractBasicIntegrationTest {
+    /** {@inheritDoc} */
+    @Override protected int nodeCount() {
+        return 1;
+    }
+
+    /** */
+    @Test
+    public void testEqualDecimalKeysWithDifferentScales() {
+        sql("CREATE TABLE LEFT_ROWS (id INT PRIMARY KEY, k DECIMAL)");
+        sql("CREATE TABLE RIGHT_ROWS (id INT PRIMARY KEY, k DECIMAL)");
+
+        sql("INSERT INTO LEFT_ROWS (id, k) VALUES (1, ?)", new 
BigDecimal("11845600"));
+        sql("INSERT INTO RIGHT_ROWS (id, k) VALUES (1, ?)", new 
BigDecimal("1.18456E+7"));
+
+        BigDecimal leftRowsVal = (BigDecimal)sql("SELECT k FROM LEFT_ROWS 
WHERE id = 1").get(0).get(0);
+        BigDecimal rightRowsVal = (BigDecimal)sql("SELECT k FROM RIGHT_ROWS 
WHERE id = 1").get(0).get(0);
+
+        assertEquals(0, leftRowsVal.compareTo(rightRowsVal));
+        assertEquals(0, leftRowsVal.scale());
+        assertEquals(-2, rightRowsVal.scale());
+
+        assertQuery("SELECT /*+ HASH_JOIN */ l.k, r.k FROM LEFT_ROWS l JOIN 
RIGHT_ROWS r ON l.k = r.k WHERE l.k = 11845600")
+            .matches(containsSubPlan("IgniteHashJoin"))
+            .resultSize(1)
+            .check();
+
+        assertQuery("SELECT l.k, r.k FROM LEFT_ROWS l JOIN RIGHT_ROWS r ON l.k 
= r.k WHERE l.k = 11845600")
+            .resultSize(1)
+            .check();
+    }
+}
diff --git 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtilsTest.java
 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtilsTest.java
index e91caed0ddb..2249abede3a 100644
--- 
a/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtilsTest.java
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/internal/processors/query/calcite/util/SqlValueUtilsTest.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.processors.query.calcite.util;
 
+import java.math.BigDecimal;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
@@ -143,6 +144,8 @@ public class SqlValueUtilsTest {
             Object[] right = {Collections.singletonList(new Object[] {i})};
 
             assertEquals(dest.targets(left), dest.targets(right));
+            assertEquals(dest.targets(new Object[] {BigDecimal.valueOf(i)}),
+                dest.targets(new Object[] 
{BigDecimal.valueOf(i).setScale(2)}));
         }
 
         assertNotEquals(dest.targets(new Object[] 
{Collections.singletonList(new Object[] {0})}),
@@ -158,10 +161,89 @@ public class SqlValueUtilsTest {
         assertEquals(assignments.get(7), affDest.targets(new Object[] {42}));
     }
 
+    /** */
+    @Test
+    public void testDecimalValues() {
+        for (String[] pair : new String[][] {
+            {"11845600", "11845600"},
+            {"11845600", "1.18456E+7"},
+            {"11845600", "11845600.00"},
+            {"11845600.00", "11845600.00"},
+            {"1.18456E+7", "1.18456E+7"},
+            {"0", "0"},
+            {"0", "0.000"},
+            {"-11845600", "-11845600"},
+            {"-11845600.00", "-11845600.00"},
+            {"-11845600", "-11845600.00"},
+            {"-11845600", "-1.18456E+7"}
+        }) {
+            BigDecimal left = new BigDecimal(pair[0]);
+            BigDecimal right = new BigDecimal(pair[1]);
+
+            assertSameValue(left, right);
+            assertSameValue(new Object[] {left}, new Object[] {right});
+            assertSameValue(List.of(left), List.of(right));
+            assertSameValue(Collections.singletonMap(left, left), 
Collections.singletonMap(right, right));
+
+            GroupKey<Object[]> first = GroupKey.of(new Object[] {left}, 
ArrayRowHandler.INSTANCE);
+            GroupKey<Object[]> second = GroupKey.of(new Object[] {right}, 
ArrayRowHandler.INSTANCE);
+            Map<GroupKey<Object[]>, String> idx = new HashMap<>();
+
+            idx.put(first, "found");
+
+            assertEquals(first, second);
+            assertEquals(first.hashCode(), second.hashCode());
+            assertEquals("found", idx.get(second));
+        }
+    }
+
+    /** */
+    @Test
+    public void testDifferentDecimalValues() {
+        for (String[] pair : new String[][] {
+            {"11845600", "11845601"},
+            {"11845600.00", "11845601.00"},
+            {"11845600", "1.18457E+7"},
+            {"11845600", "11845601.00"},
+            {"0", "0.001"},
+            {"-11845600", "-11845601"},
+            {"-11845600.00", "-11845601.00"},
+            {"-11845600", "-11845601.00"},
+            {"-11845600", "-1.18457E+7"},
+            {"11845600", "-1.18456E+7"}
+        }) {
+            BigDecimal left = new BigDecimal(pair[0]);
+            BigDecimal right = new BigDecimal(pair[1]);
+
+            assertDifferentValue(left, right);
+            assertDifferentValue(new Object[] {left}, new Object[] {right});
+            assertDifferentValue(List.of(left), List.of(right));
+            assertDifferentValue(Collections.singletonMap(left, "value"), 
Collections.singletonMap(right, "value"));
+            assertDifferentValue(Collections.singletonMap("key", left), 
Collections.singletonMap("key", right));
+
+            GroupKey<Object[]> first = GroupKey.of(new Object[] {left}, 
ArrayRowHandler.INSTANCE);
+            GroupKey<Object[]> second = GroupKey.of(new Object[] {right}, 
ArrayRowHandler.INSTANCE);
+            Map<GroupKey<Object[]>, String> idx = new HashMap<>();
+
+            idx.put(first, "found");
+
+            assertNotEquals(first, second);
+            assertNull(idx.get(second));
+        }
+
+        assertDifferentValue(new BigDecimal("1"), 1);
+    }
+
     /** */
     private static void assertSameValue(Object left, Object right) {
         assertTrue(SqlValueUtils.deepEquals(left, right));
         assertTrue(SqlValueUtils.deepEquals(right, left));
         assertEquals(SqlValueUtils.deepHashCode(left), 
SqlValueUtils.deepHashCode(right));
     }
+
+    /** */
+    private static void assertDifferentValue(Object left, Object right) {
+        assertFalse(SqlValueUtils.deepEquals(left, right));
+        assertFalse(SqlValueUtils.deepEquals(right, left));
+    }
 }
diff --git 
a/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
 
b/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
index 2d972610b94..22b9407a4c8 100644
--- 
a/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
+++ 
b/modules/calcite/src/test/java/org/apache/ignite/testsuites/IntegrationTestSuite.java
@@ -37,6 +37,7 @@ import 
org.apache.ignite.internal.processors.query.calcite.integration.CollectIn
 import 
org.apache.ignite.internal.processors.query.calcite.integration.CorrelatesIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.DataTypesTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.DateTimeTest;
+import 
org.apache.ignite.internal.processors.query.calcite.integration.DecimalHashJoinIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.DistributedJoinIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.DynamicParametersIntegrationTest;
 import 
org.apache.ignite.internal.processors.query.calcite.integration.ExpiredEntriesIntegrationTest;
@@ -191,6 +192,7 @@ import org.junit.platform.suite.api.Suite;
     SelectForUpdateIntegrationTest.class,
     LitmusCheckIntegrationTest.class,
     QueryCleanupRaceIntegrationTest.class,
+    DecimalHashJoinIntegrationTest.class,
 })
 public class IntegrationTestSuite {
 }

Reply via email to