Package org.rocksdb

Class NativeComparatorWrapper

java.lang.Object
org.rocksdb.AbstractNativeReference
org.rocksdb.AbstractImmutableNativeReference
org.rocksdb.RocksCallbackObject
org.rocksdb.AbstractComparator
org.rocksdb.NativeComparatorWrapper
All Implemented Interfaces:
AutoCloseable
public abstract class NativeComparatorWrapper extends AbstractComparator
A simple abstraction to allow a Java class to wrap a custom comparator implemented in C++.

The native comparator must directly extend rocksdb::Comparator.

  • Constructor Details

    • NativeComparatorWrapper

      public NativeComparatorWrapper()

  • Method Details

    • name

      public final String name()
      Description copied from class: AbstractComparator
      The name of the comparator. Used to check for comparator mismatches (i.e., a DB created with one comparator is accessed using a different comparator).

      A new name should be used whenever the comparator implementation changes in a way that will cause the relative ordering of any two keys to change.

      Names starting with "rocksdb." are reserved and should not be used.

      Specified by:
      name in class AbstractComparator
      Returns:
      The name of this comparator implementation

    • compare

      public final int compare(ByteBuffer s1, ByteBuffer s2)
      Description copied from class: AbstractComparator
      Three-way key comparison. Implementations should provide a total order on keys that might be passed to it. The implementation may modify the ByteBuffers passed in, though it would be unconventional to modify the "limit" or any of the underlying bytes. As a callback, RocksJava will ensure that a is a different instance from b.
      Specified by:
      compare in class AbstractComparator
      Parameters:
      s1 - buffer containing the first key in its "remaining" elements
      s2 - buffer containing the second key in its "remaining" elements
      Returns:
      Should return either: 1) < 0 if "a" < "b" 2) == 0 if "a" == "b" 3) > 0 if "a" > "b"

    • findShortestSeparator

      public final void findShortestSeparator(ByteBuffer start, ByteBuffer limit)
      Description copied from class: AbstractComparator

      Used to reduce the space requirements for internal data structures like index blocks.

      If start < limit, you may modify start which is a shorter string in [start, limit).

      If you modify start, it is expected that you set the byte buffer so that a subsequent read of start.remaining() bytes from start.position() to start.limit() will obtain the new start value.

      Simple comparator implementations may return with start unchanged. i.e., an implementation of this method that does nothing is correct.

      Overrides:
      findShortestSeparator in class AbstractComparator
      Parameters:
      start - the start
      limit - the limit

    • findShortSuccessor

      public final void findShortSuccessor(ByteBuffer key)
      Description copied from class: AbstractComparator

      Used to reduce the space requirements for internal data structures like index blocks.

      You may change key to a shorter key (key1) where key1 ≥ key.

      Simple comparator implementations may return the key unchanged. i.e., an implementation of this method that does nothing is correct.

      Overrides:
      findShortSuccessor in class AbstractComparator
      Parameters:
      key - the key

    • disposeInternal

      protected void disposeInternal()
      We override RocksCallbackObject.disposeInternal() as disposing of a native rocksdb::Comparator extension requires a slightly different approach as it is not really a RocksCallbackObject
      Overrides:
      disposeInternal in class RocksCallbackObject