This is an automated email from the ASF dual-hosted git repository.
zhenchen pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/calcite.git
The following commit(s) were added to refs/heads/main by this push:
new 3d143325fd [CALCITE-7349] Upgrade the types of FETCH and OFFSET in
SORT to BigDecimal
3d143325fd is described below
commit 3d143325fdb4c1f45ca4ef9ac5f446884895d412
Author: Zhen Chen <[email protected]>
AuthorDate: Wed Dec 31 22:19:56 2025 +0800
[CALCITE-7349] Upgrade the types of FETCH and OFFSET in SORT to BigDecimal
---
.../calcite/adapter/enumerable/EnumerableMergeUnionRule.java | 4 ++--
.../main/java/org/apache/calcite/rel/metadata/RelMdUtil.java | 11 ++++++++---
.../java/org/apache/calcite/rel/rules/PruneEmptyRules.java | 4 ++--
.../org/apache/calcite/rel/rules/SortJoinTransposeRule.java | 10 ++++++----
.../org/apache/calcite/rel/rules/SortRemoveRedundantRule.java | 5 ++---
core/src/main/java/org/apache/calcite/rex/RexLiteral.java | 6 ++++++
core/src/main/java/org/apache/calcite/tools/RelBuilder.java | 4 ++--
7 files changed, 28 insertions(+), 16 deletions(-)
diff --git
a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
index bfe0555b3f..7d47e639b7 100644
---
a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
+++
b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
@@ -92,8 +92,8 @@ public EnumerableMergeUnionRule(Config config) {
inputFetch = sort.fetch;
} else if (sort.fetch instanceof RexLiteral && sort.offset instanceof
RexLiteral) {
inputFetch =
- call.builder().literal(RexLiteral.longValue(sort.fetch)
- + RexLiteral.longValue(sort.offset));
+ call.builder().literal(RexLiteral.bigDecimalValue(sort.fetch)
+ .add(RexLiteral.bigDecimalValue(sort.offset)));
}
}
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
index 3412e70eee..1f65022436 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
@@ -1048,9 +1048,14 @@ private static boolean alreadySmaller(RelMetadataQuery
mq, RelNode input,
// Cannot be determined
return false;
}
- final long offsetVal = offset == null ? 0 : RexLiteral.longValue(offset);
- final long limit = RexLiteral.longValue(fetch);
- return (double) offsetVal + (double) limit >= rowCount;
+ final BigDecimal offsetVal = offset == null
+ ? BigDecimal.ZERO
+ : RexLiteral.bigDecimalValue(offset);
+ final BigDecimal limit = RexLiteral.bigDecimalValue(fetch);
+ if (!Double.isFinite(rowCount)) {
+ return false;
+ }
+ return offsetVal.add(limit).compareTo(BigDecimal.valueOf(rowCount)) >= 0;
}
/**
diff --git
a/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
b/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
index 2001c81128..221cfac09d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
@@ -47,6 +47,7 @@
import org.immutables.value.Value;
+import java.math.BigDecimal;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
@@ -500,9 +501,8 @@ public interface SortFetchZeroRuleConfig extends
PruneEmptyRule.Config {
Sort sort = call.rel(0);
return sort.fetch != null
&& !(sort.fetch instanceof RexDynamicParam)
- && RexLiteral.longValue(sort.fetch) == 0;
+ &&
RexLiteral.bigDecimalValue(sort.fetch).equals(BigDecimal.ZERO);
}
-
};
}
}
diff --git
a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
index ec29fb92a4..4310d6d655 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
@@ -202,10 +202,12 @@ public SortJoinTransposeRule(Class<? extends Sort>
sortClass,
if (sort.fetch == null) {
return null;
}
- final long outerFetch = RexLiteral.longValue(sort.fetch);
- final long outerOffset = sort.offset != null ?
RexLiteral.longValue(sort.offset) : 0;
- final long totalFetch = outerOffset + outerFetch;
- return rexBuilder.makeExactLiteral(BigDecimal.valueOf(totalFetch));
+ final BigDecimal outerFetch = RexLiteral.bigDecimalValue(sort.fetch);
+ final BigDecimal outerOffset = sort.offset != null
+ ? RexLiteral.bigDecimalValue(sort.offset)
+ : BigDecimal.ZERO;
+ final BigDecimal totalFetch = outerOffset.add(outerFetch);
+ return rexBuilder.makeExactLiteral(totalFetch);
}
/** Rule configuration. */
diff --git
a/core/src/main/java/org/apache/calcite/rel/rules/SortRemoveRedundantRule.java
b/core/src/main/java/org/apache/calcite/rel/rules/SortRemoveRedundantRule.java
index 9c950df5cb..9bcf026fc6 100644
---
a/core/src/main/java/org/apache/calcite/rel/rules/SortRemoveRedundantRule.java
+++
b/core/src/main/java/org/apache/calcite/rel/rules/SortRemoveRedundantRule.java
@@ -125,7 +125,7 @@ protected SortRemoveRedundantRule(final
SortRemoveRedundantRule.Config config) {
// then we could remove the redundant sort.
if (inputMaxRowCount != null
&& Double.isFinite(inputMaxRowCount)
- && new BigDecimal(inputMaxRowCount).compareTo(rowCountThreshold.get())
<= 0) {
+ &&
BigDecimal.valueOf(inputMaxRowCount).compareTo(rowCountThreshold.get()) <= 0) {
call.transformTo(sort.getInput());
}
}
@@ -133,10 +133,9 @@ && new
BigDecimal(inputMaxRowCount).compareTo(rowCountThreshold.get()) <= 0) {
private static Optional<BigDecimal> getRowCountThreshold(Sort sort) {
if (RelOptUtil.isLimit(sort)) {
assert sort.fetch != null;
- final BigDecimal fetch = ((RexLiteral)
sort.fetch).getValueAs(BigDecimal.class);
+ final BigDecimal fetch = RexLiteral.bigDecimalValue(sort.fetch);
// We don't need to deal with fetch is 0.
- assert fetch != null;
if (fetch.equals(BigDecimal.ZERO)) {
return Optional.empty();
}
diff --git a/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
b/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
index ce7ac68abb..2dc8249208 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
@@ -1290,6 +1290,12 @@ public static long longValue(RexNode node) {
return number.longValue();
}
+ /** Returns the value of a literal, cast, or unary minus, as a BigDecimal;
+ * never null. */
+ public static BigDecimal bigDecimalValue(RexNode node) {
+ return (BigDecimal) numberValue(node);
+ }
+
public static @Nullable String stringValue(RexNode node) {
final Comparable value = findValue(node);
return (value == null) ? null : ((NlsString) value).getValue();
diff --git a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
index 8f9e117974..a1ab24a19d 100644
--- a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
+++ b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
@@ -117,6 +117,7 @@
import org.apache.calcite.util.ImmutableNullableList;
import org.apache.calcite.util.Litmus;
import org.apache.calcite.util.NlsString;
+import org.apache.calcite.util.NumberUtil;
import org.apache.calcite.util.Optionality;
import org.apache.calcite.util.Pair;
import org.apache.calcite.util.Util;
@@ -494,8 +495,7 @@ public RexLiteral literal(@Nullable Object value) {
return rexBuilder.makeApproxLiteral(
((Number) value).doubleValue(),
getTypeFactory().createSqlType(SqlTypeName.DOUBLE));
} else if (value instanceof Number) {
- return rexBuilder.makeExactLiteral(
- BigDecimal.valueOf(((Number) value).longValue()));
+ return rexBuilder.makeExactLiteral(NumberUtil.toBigDecimal((Number)
value));
} else if (value instanceof String) {
return rexBuilder.makeLiteral((String) value);
} else if (value instanceof Enum) {
