This is an automated email from the ASF dual-hosted git repository.
zhonghongsheng pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 2a4e622bcd3 Improve IntegerRangeSplittingIterator to support
BigInteger (#37568)
2a4e622bcd3 is described below
commit 2a4e622bcd3c7562bca9ba7cdefee181ccedd986
Author: Hongsheng Zhong <[email protected]>
AuthorDate: Mon Dec 29 18:02:12 2025 +0800
Improve IntegerRangeSplittingIterator to support BigInteger (#37568)
---
.../query/IntegerRangeSplittingIterator.java | 26 +++++------
.../InventoryPositionEstimatedCalculator.java | 14 +++---
.../query/IntegerRangeSplittingIteratorTest.java | 50 ++++++++++++++--------
3 files changed, 53 insertions(+), 37 deletions(-)
diff --git
a/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIterator.java
b/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIterator.java
index ce21597e988..51916a73bc6 100644
---
a/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIterator.java
+++
b/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIterator.java
@@ -26,38 +26,38 @@ import java.util.NoSuchElementException;
*
* <p>It's not thread-safe.</p>
*/
-public final class IntegerRangeSplittingIterator implements
Iterator<Range<Long>> {
+public final class IntegerRangeSplittingIterator implements
Iterator<Range<BigInteger>> {
- private final BigInteger maximum;
+ private final BigInteger upperBound;
private final BigInteger stepSize;
private BigInteger current;
- public IntegerRangeSplittingIterator(final long minimum, final long
maximum, final long stepSize) {
- if (minimum > maximum) {
- throw new IllegalArgumentException("minimum greater than maximum");
+ public IntegerRangeSplittingIterator(final BigInteger lowerBound, final
BigInteger upperBound, final BigInteger stepSize) {
+ if (lowerBound.compareTo(upperBound) > 0) {
+ throw new IllegalArgumentException("lower bounder greater than
upper bound");
}
- if (stepSize < 0L) {
+ if (stepSize.compareTo(BigInteger.ZERO) < 0) {
throw new IllegalArgumentException("step size is less than zero");
}
- this.maximum = BigInteger.valueOf(maximum);
- this.stepSize = BigInteger.valueOf(stepSize);
- current = BigInteger.valueOf(minimum);
+ this.upperBound = upperBound;
+ this.stepSize = stepSize;
+ current = lowerBound;
}
@Override
public boolean hasNext() {
- return current.compareTo(maximum) <= 0;
+ return current.compareTo(upperBound) <= 0;
}
@Override
- public Range<Long> next() {
+ public Range<BigInteger> next() {
if (!hasNext()) {
throw new NoSuchElementException("");
}
- BigInteger upperLimit = min(maximum, current.add(stepSize));
- Range<Long> result = Range.closed(current.longValue(),
upperLimit.longValue());
+ BigInteger upperLimit = min(upperBound, current.add(stepSize));
+ Range<BigInteger> result = Range.closed(current, upperLimit);
current = upperLimit.add(BigInteger.ONE);
return result;
}
diff --git
a/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/preparer/inventory/calculator/position/estimated/InventoryPositionEstimatedCalculator.java
b/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/preparer/inventory/calculator/position/estimated/InventoryPositionEstimatedCalculator.java
index d6f19017173..901b16cffb8 100644
---
a/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/preparer/inventory/calculator/position/estimated/InventoryPositionEstimatedCalculator.java
+++
b/kernel/data-pipeline/core/src/main/java/org/apache/shardingsphere/data/pipeline/core/preparer/inventory/calculator/position/estimated/InventoryPositionEstimatedCalculator.java
@@ -75,18 +75,18 @@ public final class InventoryPositionEstimatedCalculator {
* @return positions
*/
public static List<IngestPosition> getIntegerPositions(final long
tableRecordsCount, final Range<Long> uniqueKeyValuesRange, final long
shardingSize) {
- Long minimum = uniqueKeyValuesRange.getLowerBound();
- Long maximum = uniqueKeyValuesRange.getUpperBound();
- if (0 == tableRecordsCount || null == minimum || null == maximum) {
+ Long lowerBound = uniqueKeyValuesRange.getLowerBound();
+ Long upperBound = uniqueKeyValuesRange.getUpperBound();
+ if (0 == tableRecordsCount || null == lowerBound || null ==
upperBound) {
return Collections.singletonList(new
IntegerPrimaryKeyIngestPosition(null, null));
}
List<IngestPosition> result = new LinkedList<>();
long splitCount = tableRecordsCount / shardingSize +
(tableRecordsCount % shardingSize > 0 ? 1 : 0);
- long stepSize =
BigInteger.valueOf(maximum).subtract(BigInteger.valueOf(minimum)).divide(BigInteger.valueOf(splitCount)).longValue();
- IntegerRangeSplittingIterator rangeIterator = new
IntegerRangeSplittingIterator(minimum, maximum, stepSize);
+ BigInteger stepSize =
BigInteger.valueOf(upperBound).subtract(BigInteger.valueOf(lowerBound)).divide(BigInteger.valueOf(splitCount));
+ IntegerRangeSplittingIterator rangeIterator = new
IntegerRangeSplittingIterator(BigInteger.valueOf(lowerBound),
BigInteger.valueOf(upperBound), stepSize);
while (rangeIterator.hasNext()) {
- Range<Long> range = rangeIterator.next();
- result.add(new
IntegerPrimaryKeyIngestPosition(range.getLowerBound(), range.getUpperBound()));
+ Range<BigInteger> range = rangeIterator.next();
+ result.add(new
IntegerPrimaryKeyIngestPosition(range.getLowerBound().longValue(),
range.getUpperBound().longValue()));
}
return result;
}
diff --git
a/kernel/data-pipeline/core/src/test/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIteratorTest.java
b/kernel/data-pipeline/core/src/test/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIteratorTest.java
index cdf44899b8c..8d8b1e56d41 100644
---
a/kernel/data-pipeline/core/src/test/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIteratorTest.java
+++
b/kernel/data-pipeline/core/src/test/java/org/apache/shardingsphere/data/pipeline/core/ingest/dumper/inventory/query/IntegerRangeSplittingIteratorTest.java
@@ -19,6 +19,7 @@ package
org.apache.shardingsphere.data.pipeline.core.ingest.dumper.inventory.que
import org.junit.jupiter.api.Test;
+import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
@@ -30,18 +31,18 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
class IntegerRangeSplittingIteratorTest {
@Test
- void assertMinimumGreaterThanMaximum() {
- assertThrows(IllegalArgumentException.class, () -> new
IntegerRangeSplittingIterator(200L, 100L, 10L));
+ void assertLowerGtUpper() {
+ assertThrows(IllegalArgumentException.class, () -> new
IntegerRangeSplittingIterator(BigInteger.valueOf(200L),
BigInteger.valueOf(100L), BigInteger.valueOf(10L)));
}
@Test
- void assertIntervalLessThanZero() {
- assertThrows(IllegalArgumentException.class, () -> new
IntegerRangeSplittingIterator(100L, 200L, -10L));
+ void assertStepSizeLtZero() {
+ assertThrows(IllegalArgumentException.class, () -> new
IntegerRangeSplittingIterator(BigInteger.valueOf(100L),
BigInteger.valueOf(200L), BigInteger.valueOf(-10L)));
}
@Test
void assertInvalidNext() {
- IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(200L, 200L, 0L);
+ IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(BigInteger.valueOf(200L),
BigInteger.valueOf(200L), BigInteger.valueOf(0L));
if (iterator.hasNext()) {
iterator.next();
}
@@ -49,28 +50,43 @@ class IntegerRangeSplittingIteratorTest {
}
@Test
- void assertSmallRangeCorrect() {
- IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(200L, 200L, 0L);
- List<Range<Long>> actual = new LinkedList<>();
+ void assertStepSizeEqZero() {
+ IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(BigInteger.valueOf(200L),
BigInteger.valueOf(200L), BigInteger.valueOf(0L));
+ List<Range<BigInteger>> actual = new LinkedList<>();
while (iterator.hasNext()) {
actual.add(iterator.next());
}
assertThat(actual.size(), is(1));
- assertThat(actual.get(0).getLowerBound(), is(200L));
- assertThat(actual.get(0).getUpperBound(), is(200L));
+ assertRange(actual.get(0), Range.closed(BigInteger.valueOf(200L),
BigInteger.valueOf(200L)));
+ }
+
+ private void assertRange(final Range<BigInteger> actual, final
Range<BigInteger> expected) {
+ assertThat(actual.getLowerBound(), is(expected.getLowerBound()));
+ assertThat(actual.getUpperBound(), is(expected.getUpperBound()));
+ }
+
+ @Test
+ void assertIntegerRange() {
+ IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(BigInteger.valueOf(200L),
BigInteger.valueOf(400L), BigInteger.valueOf(100L));
+ List<Range<BigInteger>> actual = new LinkedList<>();
+ while (iterator.hasNext()) {
+ actual.add(iterator.next());
+ }
+ assertThat(actual.size(), is(2));
+ assertRange(actual.get(0), Range.closed(BigInteger.valueOf(200L),
BigInteger.valueOf(300L)));
+ assertRange(actual.get(1), Range.closed(BigInteger.valueOf(301L),
BigInteger.valueOf(400L)));
}
@Test
- void assertLargeRangeCorrect() {
- IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(200L, 400L, 100L);
- List<Range<Long>> actual = new LinkedList<>();
+ void assertBigIntegerRange() {
+ IntegerRangeSplittingIterator iterator = new
IntegerRangeSplittingIterator(
+ new BigInteger("1234567890123456789012345678"), new
BigInteger("1234567890123456789032345678"), new BigInteger("10000000"));
+ List<Range<BigInteger>> actual = new LinkedList<>();
while (iterator.hasNext()) {
actual.add(iterator.next());
}
assertThat(actual.size(), is(2));
- assertThat(actual.get(0).getLowerBound(), is(200L));
- assertThat(actual.get(0).getUpperBound(), is(300L));
- assertThat(actual.get(1).getLowerBound(), is(301L));
- assertThat(actual.get(1).getUpperBound(), is(400L));
+ assertRange(actual.get(0), Range.closed(new
BigInteger("1234567890123456789012345678"), new
BigInteger("1234567890123456789022345678")));
+ assertRange(actual.get(1), Range.closed(new
BigInteger("1234567890123456789022345679"), new
BigInteger("1234567890123456789032345678")));
}
}
