lmdbjava · at055612 · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -16,10 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -69,36 +65,23 @@ protected BufferProxy() {}
    */
   protected abstract byte[] getBytes(T buffer);
 
-  /**
-   * Get a suitable default {@link Comparator} given the provided flags.
-   *
-   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
-   * LMDB database.
-   *
-   * @param flags for the database
-   * @return a comparator that can be used (never null)
-   */
-  protected Comparator<T> getComparator(DbiFlags... flags) {
-    final int intFlag = mask(flags);
-
-    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY)
-        ? getUnsignedComparator()
-        : getSignedComparator();
-  }
-
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as signed.
    *
+   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
+   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
+   * order. Use with caution.
+   *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getSignedComparator();
+  public abstract Comparator<T> getSignedComparator();
 
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
    *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getUnsignedComparator();
+  public abstract Comparator<T> getUnsignedComparator();
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
@@ -138,4 +121,13 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
   final KeyVal<T> keyVal() {
     return new KeyVal<>(this);
   }
+
+  /**
+   * Create a new {@link Key} to hold pointers for this buffer proxy.
+   *
+   * @return a non-null key holder
+   */
+  final Key<T> key() {
+    return new Key<>(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -104,12 +104,12 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  protected Comparator<byte[]> getSignedComparator() {
+  public Comparator<byte[]> getSignedComparator() {
     return signedComparator;
   }
 
   @Override
-  protected Comparator<byte[]> getUnsignedComparator() {
+  public Comparator<byte[]> getUnsignedComparator() {
     return unsignedComparator;
   }
 

diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -114,12 +114,12 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  protected Comparator<ByteBuf> getSignedComparator() {
+  public Comparator<ByteBuf> getSignedComparator() {
     return comparator;
   }
 
   @Override
-  protected Comparator<ByteBuf> getUnsignedComparator() {
+  public Comparator<ByteBuf> getUnsignedComparator() {
     return comparator;
   }
 

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -182,12 +182,12 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected Comparator<ByteBuffer> getSignedComparator() {
+    public Comparator<ByteBuffer> getSignedComparator() {
       return signedComparator;
     }
 
     @Override
-    protected Comparator<ByteBuffer> getUnsignedComparator() {
+    public Comparator<ByteBuffer> getUnsignedComparator() {
       return unsignedComparator;
     }
 

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
@@ -112,7 +112,7 @@ public void delete(final PutFlags... f) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(true, f);
+    final int flags = mask(f);
     checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
   }
 
@@ -203,6 +203,10 @@ public T key() {
     return kv.key();
   }
 
+  KeyVal<T> keyVal() {
+    return kv;
+  }
+
   /**
    * Position at last key/data item.
    *
@@ -252,7 +256,7 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final int mask = mask(true, op);
+    final int mask = mask(op);
     final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
@@ -292,7 +296,7 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(true, op);
+    final int mask = mask(op);
     if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
@@ -353,7 +357,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -21,10 +21,14 @@
 import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
 import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
+import static org.lmdbjava.Library.LIB;
 
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.function.Supplier;
+import jnr.ffi.Pointer;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
@@ -38,24 +42,40 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  private final Comparator<T> comparator;
+  private final RangeComparator rangeComparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
   private boolean iteratorReturned;
   private final KeyRange<T> range;
   private State state = REQUIRES_INITIAL_OP;
 
   CursorIterable(
-      final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range, final Comparator<T> comparator) {
+      final Txn<T> txn,
+      final Dbi<T> dbi,
+      final KeyRange<T> range,
+      final Comparator<T> comparator,
+      final BufferProxy<T> proxy) {
     this.cursor = dbi.openCursor(txn);
     this.range = range;
-    this.comparator = comparator;
     this.entry = new KeyVal<>();
+
+    if (comparator != null) {
+      // User supplied java-side comparator so use that
+      this.rangeComparator = new JavaRangeComparator<>(range, comparator, entry::key);
+    } else {
+      // No java-side comparator so call down to LMDB to do the comparison
+      this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
+    }
   }
 
   @Override
   public void close() {
     cursor.close();
+    try {
+      rangeComparator.close();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
   }
 
   /**
@@ -129,8 +149,7 @@ private void executeCursorOp(final CursorOp op) {
   }
 
   private void executeIteratorOp() {
-    final IteratorOp op =
-        range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), comparator);
+    final IteratorOp op = range.getType().iteratorOp(entry.key(), rangeComparator);
     switch (op) {
       case CALL_NEXT_OP:
         executeCursorOp(range.getType().nextOp());
@@ -219,4 +238,100 @@ enum State {
     RELEASED,
     TERMINATED
   }
+
+  static class JavaRangeComparator<T> implements RangeComparator {
+
+    private final Comparator<T> comparator;
+    private final Supplier<T> currentKeySupplier;
+    private final T start;
+    private final T stop;
+
+    JavaRangeComparator(
+        final KeyRange<T> range,
+        final Comparator<T> comparator,
+        final Supplier<T> currentKeySupplier) {
+      this.comparator = comparator;
+      this.currentKeySupplier = currentKeySupplier;
+      this.start = range.getStart();
+      this.stop = range.getStop();
+    }
+
+    @Override
+    public int compareToStartKey() {
+      return comparator.compare(currentKeySupplier.get(), start);
+    }
+
+    @Override
+    public int compareToStopKey() {
+      return comparator.compare(currentKeySupplier.get(), stop);
+    }
+
+    @Override
+    public void close() throws Exception {
+      // Nothing to close
+    }
+  }
+
+  /**
+   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
+   * very slight overhead as compared to {@link JavaRangeComparator}.
+   */
+  private static class LmdbRangeComparator<T> implements RangeComparator {
+
+    private final Pointer txnPointer;
+    private final Pointer dbiPointer;
+    private final Pointer cursorKeyPointer;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
+    private final Pointer startKeyPointer;
+    private final Pointer stopKeyPointer;
+
+    public LmdbRangeComparator(
+        final Txn<T> txn,
+        final Dbi<T> dbi,
+        final Cursor<T> cursor,
+        final KeyRange<T> range,
+        final BufferProxy<T> proxy) {
+      txnPointer = Objects.requireNonNull(txn).pointer();
+      dbiPointer = Objects.requireNonNull(dbi).pointer();
+      cursorKeyPointer = Objects.requireNonNull(cursor).keyVal().pointerKey();
+      // Allocate buffers for use with the start/stop keys if required.
+      // Saves us copying bytes on each comparison
+      Objects.requireNonNull(range);
+      startKey = createKey(range.getStart(), proxy);
+      stopKey = createKey(range.getStop(), proxy);
+      startKeyPointer = startKey != null ? startKey.pointer() : null;
+      stopKeyPointer = stopKey != null ? stopKey.pointer() : null;
+    }
+
+    @Override
+    public int compareToStartKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, startKeyPointer);
+    }
+
+    @Override
+    public int compareToStopKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, stopKeyPointer);
+    }
+
+    @Override
+    public void close() {
+      if (startKey != null) {
+        startKey.close();
+      }
+      if (stopKey != null) {
+        stopKey.close();
+      }
+    }
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+      if (keyBuffer != null) {
+        final Key<T> key = proxy.key();
+        key.keyIn(keyBuffer);
+        return key;
+      } else {
+        return null;
+      }
+    }
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
@@ -54,6 +54,7 @@ public final class Dbi<T> {
   private final Env<T> env;
   private final byte[] name;
   private final Pointer ptr;
+  private final BufferProxy<T> proxy;
 
   Dbi(
       final Env<T> env,
@@ -69,16 +70,14 @@ public final class Dbi<T> {
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    if (comparator == null) {
-      this.comparator = proxy.getComparator(flags);
-    } else {
-      this.comparator = comparator;
-    }
-    final int flagsMask = mask(true, flags);
+    this.proxy = proxy;
+    this.comparator = comparator;
+    final int flagsMask = mask(flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
+      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       this.ccb =
           (keyA, keyB) -> {
             final T compKeyA = proxy.allocate();
@@ -96,6 +95,10 @@ public final class Dbi<T> {
     }
   }
 
+  Pointer pointer() {
+    return ptr;
+  }
+
   /**
    * Close the database handle (normally unnecessary; use with caution).
    *
@@ -280,7 +283,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
       env.checkNotClosed();
       txn.checkReady();
     }
-    return new CursorIterable<>(txn, this, range, comparator);
+    return new CursorIterable<>(txn, this, range, comparator, proxy);
   }
 
   /**
@@ -373,7 +376,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int mask = mask(true, flags);
+    final int mask = mask(flags);
     final int rc =
         LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
@@ -417,7 +420,7 @@ public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags..
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
     ReferenceUtil.reachabilityFence0(transientKey);