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 {
}