#269 Initial iterator performance enhancements and testing.

stroomdev66 · stroomdev66 · commit 7d0444585409 · 2025-11-05T17:32:56.000Z
diff --git a/src/main/java/org/lmdbjava/LmdbStream.java b/src/main/java/org/lmdbjava/LmdbStream.java
@@ -51,6 +51,7 @@ private static <T> LmdbSpliterator<T> createSpliterator(
             new LmdbRangeSpliterator<>(
                 cursor,
                 comparator,
+                createEntryComparator(comparator),
                 keyRange.getStart(),
                 keyRange.getStop(),
                 keyRange.isStartKeyInclusive(),
@@ -60,16 +61,19 @@ private static <T> LmdbSpliterator<T> createSpliterator(
             new LmdbRangeReversedSpliterator<>(
                 cursor,
                 comparator,
+                createReversedEntryComparator(comparator),
                 keyRange.getStart(),
                 keyRange.getStop(),
                 keyRange.isStartKeyInclusive(),
                 keyRange.isStopKeyInclusive());
       }
     } else {
       if (keyRange.directionForward) {
-        spliterator = new LmdbSpliterator<>(cursor, comparator);
+        spliterator = new LmdbSpliterator<>(cursor, comparator, createEntryComparator(comparator));
       } else {
-        spliterator = new LmdbReversedSpliterator<>(cursor, comparator);
+        spliterator =
+            new LmdbReversedSpliterator<>(
+                cursor, comparator, createReversedEntryComparator(comparator));
       }
     }
     return spliterator;
@@ -80,13 +84,19 @@ private static class LmdbSpliterator<T> implements Spliterator<KeyVal<T>> {
     final Cursor<T> cursor;
     Boolean isFound;
     final KeyVal<T> entry = new KeyVal<>();
+    final Comparator<T> comparator;
     final Comparator<KeyVal<T>> entryComparator;
 
-    private LmdbSpliterator(final Cursor<T> cursor, final Comparator<T> comparator) {
+    private LmdbSpliterator(
+        final Cursor<T> cursor,
+        final Comparator<T> comparator,
+        final Comparator<KeyVal<T>> entryComparator) {
       this.cursor = cursor;
-      entryComparator = (o1, o2) -> comparator.compare(o1.key(), o2.key());
+      this.comparator = comparator;
+      this.entryComparator = entryComparator;
     }
 
+    @Override
     public final boolean tryAdvance(final Consumer<? super KeyVal<T>> action) {
       if (hasNext()) {
         action.accept(createEntry());
@@ -95,6 +105,7 @@ public final boolean tryAdvance(final Consumer<? super KeyVal<T>> action) {
       return false;
     }
 
+    @Override
     public final void forEachRemaining(final Consumer<? super KeyVal<T>> action) {
       while (hasNext()) {
         action.accept(createEntry());
@@ -138,14 +149,22 @@ public Comparator<? super KeyVal<T>> getComparator() {
     }
   }
 
-  private static class LmdbReversedSpliterator<T> extends LmdbSpliterator<T> {
+  private static <T> Comparator<KeyVal<T>> createEntryComparator(final Comparator<T> comparator) {
+    return (o1, o2) -> comparator.compare(o1.key(), o2.key());
+  }
 
-    final Comparator<KeyVal<T>> entryComparator;
+  private static <T> Comparator<KeyVal<T>> createReversedEntryComparator(
+      final Comparator<T> comparator) {
+    return (o1, o2) -> comparator.compare(o1.key(), o2.key());
+  }
 
-    private LmdbReversedSpliterator(final Cursor<T> cursor, final Comparator<T> comparator) {
-      super(cursor, comparator);
-      // Create a reversed comparator.
-      entryComparator = (o1, o2) -> comparator.compare(o2.key(), o1.key());
+  private static class LmdbReversedSpliterator<T> extends LmdbSpliterator<T> {
+
+    private LmdbReversedSpliterator(
+        final Cursor<T> cursor,
+        final Comparator<T> comparator,
+        final Comparator<KeyVal<T>> entryComparator) {
+      super(cursor, comparator, entryComparator);
     }
 
     @Override
@@ -175,11 +194,12 @@ private static class LmdbRangeSpliterator<T> extends LmdbSpliterator<T> {
     private LmdbRangeSpliterator(
         final Cursor<T> cursor,
         final Comparator<T> comparator,
+        final Comparator<KeyVal<T>> entryComparator,
         final T start,
         final T stop,
         final boolean startInclusive,
         final boolean stopInclusive) {
-      super(cursor, comparator);
+      super(cursor, comparator, entryComparator);
       this.comparator = comparator;
       this.start = start;
       this.stop = stop;
@@ -227,11 +247,12 @@ private static class LmdbRangeReversedSpliterator<T> extends LmdbReversedSpliter
     private LmdbRangeReversedSpliterator(
         final Cursor<T> cursor,
         final Comparator<T> comparator,
+        final Comparator<KeyVal<T>> entryComparator,
         final T start,
         final T stop,
         final boolean startInclusive,
         final boolean stopInclusive) {
-      super(cursor, comparator);
+      super(cursor, comparator, entryComparator);
       this.comparator = comparator;
       this.start = start;
       this.stop = stop;
@@ -298,7 +319,7 @@ private LmdbPrefixSpliterator(
         final Comparator<T> comparator,
         final BufferProxy<T> proxy,
         final T prefix) {
-      super(cursor, comparator);
+      super(cursor, comparator, createEntryComparator(comparator));
       this.proxy = proxy;
       this.prefix = prefix;
     }
@@ -330,7 +351,7 @@ private LmdbPrefixReversedSpliterator(
         final Comparator<T> comparator,
         final BufferProxy<T> proxy,
         final T prefix) {
-      super(cursor, comparator);
+      super(cursor, comparator, createReversedEntryComparator(comparator));
       this.proxy = proxy;
       this.prefix = prefix;
 
