ceph/src/rocksdb/java/src/test/java/org/rocksdb/ComparatorTest.java

   1 // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
   2 // This source code is licensed under the BSD-style license found in the
   3 // LICENSE file in the root directory of this source tree. An additional grant
   4 // of patent rights can be found in the PATENTS file in the same directory.
   5
   6 package org.rocksdb;
   7
   8 import org.junit.ClassRule;
   9 import org.junit.Rule;
  10 import org.junit.Test;
  11 import org.junit.rules.TemporaryFolder;
  12
  13 import java.io.IOException;
  14 import java.nio.file.FileSystems;
  15
  16 import static org.assertj.core.api.Assertions.assertThat;
  17
  18 public class ComparatorTest {
  19
  20   @ClassRule
  21   public static final RocksMemoryResource rocksMemoryResource =
  22       new RocksMemoryResource();
  23
  24   @Rule
  25   public TemporaryFolder dbFolder = new TemporaryFolder();
  26
  27   @Test
  28      public void javaComparator() throws IOException, RocksDBException {
  29
  30     final AbstractComparatorTest comparatorTest = new AbstractComparatorTest() {
  31       @Override
  32       public AbstractComparator getAscendingIntKeyComparator() {
  33         return new Comparator(new ComparatorOptions()) {
  34
  35           @Override
  36           public String name() {
  37             return "test.AscendingIntKeyComparator";
  38           }
  39
  40           @Override
  41           public int compare(final Slice a, final Slice b) {
  42             return compareIntKeys(a.data(), b.data());
  43           }
  44         };
  45       }
  46     };
  47
  48     // test the round-tripability of keys written and read with the Comparator
  49     comparatorTest.testRoundtrip(FileSystems.getDefault().getPath(
  50         dbFolder.getRoot().getAbsolutePath()));
  51   }
  52
  53   @Test
  54   public void javaComparatorCf() throws IOException, RocksDBException {
  55
  56     final AbstractComparatorTest comparatorTest = new AbstractComparatorTest() {
  57       @Override
  58       public AbstractComparator getAscendingIntKeyComparator() {
  59         return new Comparator(new ComparatorOptions()) {
  60
  61           @Override
  62           public String name() {
  63             return "test.AscendingIntKeyComparator";
  64           }
  65
  66           @Override
  67           public int compare(final Slice a, final Slice b) {
  68             return compareIntKeys(a.data(), b.data());
  69           }
  70         };
  71       }
  72     };
  73
  74     // test the round-tripability of keys written and read with the Comparator
  75     comparatorTest.testRoundtripCf(FileSystems.getDefault().getPath(
  76         dbFolder.getRoot().getAbsolutePath()));
  77   }
  78
  79   @Test
  80   public void builtinForwardComparator()
  81       throws RocksDBException {
  82     try (final Options options = new Options()
  83           .setCreateIfMissing(true)
  84           .setComparator(BuiltinComparator.BYTEWISE_COMPARATOR);
  85          final RocksDB rocksDb = RocksDB.open(options,
  86              dbFolder.getRoot().getAbsolutePath())
  87     ) {
  88       rocksDb.put("abc1".getBytes(), "abc1".getBytes());
  89       rocksDb.put("abc2".getBytes(), "abc2".getBytes());
  90       rocksDb.put("abc3".getBytes(), "abc3".getBytes());
  91
  92       try(final RocksIterator rocksIterator = rocksDb.newIterator()) {
  93         // Iterate over keys using a iterator
  94         rocksIterator.seekToFirst();
  95         assertThat(rocksIterator.isValid()).isTrue();
  96         assertThat(rocksIterator.key()).isEqualTo(
  97             "abc1".getBytes());
  98         assertThat(rocksIterator.value()).isEqualTo(
  99             "abc1".getBytes());
 100         rocksIterator.next();
 101         assertThat(rocksIterator.isValid()).isTrue();
 102         assertThat(rocksIterator.key()).isEqualTo(
 103             "abc2".getBytes());
 104         assertThat(rocksIterator.value()).isEqualTo(
 105             "abc2".getBytes());
 106         rocksIterator.next();
 107         assertThat(rocksIterator.isValid()).isTrue();
 108         assertThat(rocksIterator.key()).isEqualTo(
 109             "abc3".getBytes());
 110         assertThat(rocksIterator.value()).isEqualTo(
 111             "abc3".getBytes());
 112         rocksIterator.next();
 113         assertThat(rocksIterator.isValid()).isFalse();
 114         // Get last one
 115         rocksIterator.seekToLast();
 116         assertThat(rocksIterator.isValid()).isTrue();
 117         assertThat(rocksIterator.key()).isEqualTo(
 118             "abc3".getBytes());
 119         assertThat(rocksIterator.value()).isEqualTo(
 120             "abc3".getBytes());
 121         // Seek for abc
 122         rocksIterator.seek("abc".getBytes());
 123         assertThat(rocksIterator.isValid()).isTrue();
 124         assertThat(rocksIterator.key()).isEqualTo(
 125             "abc1".getBytes());
 126         assertThat(rocksIterator.value()).isEqualTo(
 127             "abc1".getBytes());
 128       }
 129     }
 130   }
 131
 132   @Test
 133   public void builtinReverseComparator()
 134       throws RocksDBException {
 135     try (final Options options = new Options()
 136       .setCreateIfMissing(true)
 137       .setComparator(BuiltinComparator.REVERSE_BYTEWISE_COMPARATOR);
 138          final RocksDB rocksDb = RocksDB.open(options,
 139              dbFolder.getRoot().getAbsolutePath())
 140     ) {
 141
 142       rocksDb.put("abc1".getBytes(), "abc1".getBytes());
 143       rocksDb.put("abc2".getBytes(), "abc2".getBytes());
 144       rocksDb.put("abc3".getBytes(), "abc3".getBytes());
 145
 146       try (final RocksIterator rocksIterator = rocksDb.newIterator()) {
 147         // Iterate over keys using a iterator
 148         rocksIterator.seekToFirst();
 149         assertThat(rocksIterator.isValid()).isTrue();
 150         assertThat(rocksIterator.key()).isEqualTo(
 151             "abc3".getBytes());
 152         assertThat(rocksIterator.value()).isEqualTo(
 153             "abc3".getBytes());
 154         rocksIterator.next();
 155         assertThat(rocksIterator.isValid()).isTrue();
 156         assertThat(rocksIterator.key()).isEqualTo(
 157             "abc2".getBytes());
 158         assertThat(rocksIterator.value()).isEqualTo(
 159             "abc2".getBytes());
 160         rocksIterator.next();
 161         assertThat(rocksIterator.isValid()).isTrue();
 162         assertThat(rocksIterator.key()).isEqualTo(
 163             "abc1".getBytes());
 164         assertThat(rocksIterator.value()).isEqualTo(
 165             "abc1".getBytes());
 166         rocksIterator.next();
 167         assertThat(rocksIterator.isValid()).isFalse();
 168         // Get last one
 169         rocksIterator.seekToLast();
 170         assertThat(rocksIterator.isValid()).isTrue();
 171         assertThat(rocksIterator.key()).isEqualTo(
 172             "abc1".getBytes());
 173         assertThat(rocksIterator.value()).isEqualTo(
 174             "abc1".getBytes());
 175         // Will be invalid because abc is after abc1
 176         rocksIterator.seek("abc".getBytes());
 177         assertThat(rocksIterator.isValid()).isFalse();
 178         // Will be abc3 because the next one after abc999
 179         // is abc3
 180         rocksIterator.seek("abc999".getBytes());
 181         assertThat(rocksIterator.key()).isEqualTo(
 182             "abc3".getBytes());
 183         assertThat(rocksIterator.value()).isEqualTo(
 184             "abc3".getBytes());
 185       }
 186     }
 187   }
 188
 189   @Test
 190   public void builtinComparatorEnum(){
 191     assertThat(BuiltinComparator.BYTEWISE_COMPARATOR.ordinal())
 192         .isEqualTo(0);
 193     assertThat(
 194         BuiltinComparator.REVERSE_BYTEWISE_COMPARATOR.ordinal())
 195         .isEqualTo(1);
 196     assertThat(BuiltinComparator.values().length).isEqualTo(2);
 197     assertThat(BuiltinComparator.valueOf("BYTEWISE_COMPARATOR")).
 198         isEqualTo(BuiltinComparator.BYTEWISE_COMPARATOR);
 199   }
 200 }