Merge pull request #330 from fyrz/setFilterPolicyForBBTConfig

BlockBasedTableConfig Filter policy support RocksJava

java/Makefile

@@ -26,6 +26,7 @@ test: java
 	javac org/rocksdb/test/*.java
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.WriteBatchTest
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.BackupableDBTest
+	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.FilterTest
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.OptionsTest
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.ReadOptionsTest
 	java -ea -Djava.library.path=.:../ -cp "$(ROCKSDB_JAR):.:./*" org.rocksdb.test.StatisticsCollectorTest

java/RocksDBSample.java

@@ -80,9 +80,10 @@ public class RocksDBSample {
             10000, 10));
     options.setRateLimiterConfig(new GenericRateLimiterConfig(10000000));
 
+    Filter bloomFilter = new BloomFilter(10);
     BlockBasedTableConfig table_options = new BlockBasedTableConfig();
     table_options.setBlockCacheSize(64 * SizeUnit.KB)
-                 .setFilterBitsPerKey(10)
+                 .setFilter(bloomFilter)
                  .setCacheNumShardBits(6)
                  .setBlockSizeDeviation(5)
                  .setBlockRestartInterval(10)

java/org/rocksdb/BlockBasedTableConfig.java

@@ -18,7 +18,7 @@ public class BlockBasedTableConfig extends TableFormatConfig {
     blockSizeDeviation_ = 10;
     blockRestartInterval_ = 16;
     wholeKeyFiltering_ = true;
-    bitsPerKey_ = 10;
+    filter_ = null;
     cacheIndexAndFilterBlocks_ = false;
     hashIndexAllowCollision_ = true;
     blockCacheCompressedSize_ = 0;
@@ -182,30 +182,30 @@ public class BlockBasedTableConfig extends TableFormatConfig {
    *
    * Filter instance can be re-used in multiple options instances.
    *
-   * @param Filter policy java instance.
+   * @param Filter Filter Policy java instance.
    * @return the reference to the current config.
    */
-  public BlockBasedTableConfig setFilterBitsPerKey(int bitsPerKey) {
-    bitsPerKey_ = bitsPerKey;
+  public BlockBasedTableConfig setFilter(Filter filter) {
+    filter_ = filter;
     return this;
   }
-  
+
   /**
    * Indicating if we'd put index/filter blocks to the block cache.
      If not specified, each "table reader" object will pre-load index/filter
      block during table initialization.
-   * 
+   *
    * @return if index and filter blocks should be put in block cache.
    */
   public boolean cacheIndexAndFilterBlocks() {
     return cacheIndexAndFilterBlocks_;
   }
-  
+
   /**
    * Indicating if we'd put index/filter blocks to the block cache.
      If not specified, each "table reader" object will pre-load index/filter
      block during table initialization.
-   * 
+   *
    * @param index and filter blocks should be put in block cache.
    * @return the reference to the current config.
    */
@@ -214,25 +214,25 @@ public class BlockBasedTableConfig extends TableFormatConfig {
     cacheIndexAndFilterBlocks_ = cacheIndexAndFilterBlocks;
     return this;
   }
-  
+
   /**
    * Influence the behavior when kHashSearch is used.
      if false, stores a precise prefix to block range mapping
      if true, does not store prefix and allows prefix hash collision
      (less memory consumption)
-   * 
+   *
    * @return if hash collisions should be allowed.
    */
   public boolean hashIndexAllowCollision() {
     return hashIndexAllowCollision_;
   }
-  
+
   /**
    * Influence the behavior when kHashSearch is used.
      if false, stores a precise prefix to block range mapping
      if true, does not store prefix and allows prefix hash collision
      (less memory consumption)
-   * 
+   *
    * @param if hash collisions should be allowed.
    * @return the reference to the current config.
    */
@@ -241,21 +241,21 @@ public class BlockBasedTableConfig extends TableFormatConfig {
     hashIndexAllowCollision_ = hashIndexAllowCollision;
     return this;
   }
-  
+
   /**
    * Size of compressed block cache. If 0, then block_cache_compressed is set
    * to null.
-   * 
+   *
    * @return size of compressed block cache.
    */
   public long blockCacheCompressedSize() {
     return blockCacheCompressedSize_;
   }
-  
+
   /**
    * Size of compressed block cache. If 0, then block_cache_compressed is set
    * to null.
-   * 
+   *
    * @param size of compressed block cache.
    * @return the reference to the current config.
    */
@@ -264,7 +264,7 @@ public class BlockBasedTableConfig extends TableFormatConfig {
     blockCacheCompressedSize_ = blockCacheCompressedSize;
     return this;
   }
-  
+
   /**
    * Controls the number of shards for the block compressed cache.
    * This is applied only if blockCompressedCacheSize is set to non-negative.
@@ -276,7 +276,7 @@ public class BlockBasedTableConfig extends TableFormatConfig {
   public int blockCacheCompressedNumShardBits() {
     return blockCacheCompressedNumShardBits_;
   }
-  
+
   /**
    * Controls the number of shards for the block compressed cache.
    * This is applied only if blockCompressedCacheSize is set to non-negative.
@@ -293,17 +293,23 @@ public class BlockBasedTableConfig extends TableFormatConfig {
   }
 
   @Override protected long newTableFactoryHandle() {
+    long filterHandle = 0;
+    if (filter_ != null) {
+      filterHandle = filter_.nativeHandle_;
+    }
+
     return newTableFactoryHandle(noBlockCache_, blockCacheSize_,
         blockCacheNumShardBits_, blockSize_, blockSizeDeviation_,
-        blockRestartInterval_, wholeKeyFiltering_, bitsPerKey_,
-        cacheIndexAndFilterBlocks_, hashIndexAllowCollision_,
-        blockCacheCompressedSize_, blockCacheCompressedNumShardBits_);
+        blockRestartInterval_, wholeKeyFiltering_,
+        filterHandle, cacheIndexAndFilterBlocks_,
+        hashIndexAllowCollision_, blockCacheCompressedSize_,
+        blockCacheCompressedNumShardBits_);
   }
 
   private native long newTableFactoryHandle(
       boolean noBlockCache, long blockCacheSize, int blockCacheNumShardBits,
       long blockSize, int blockSizeDeviation, int blockRestartInterval,
-      boolean wholeKeyFiltering, int bitsPerKey,
+      boolean wholeKeyFiltering, long filterPolicyHandle,
       boolean cacheIndexAndFilterBlocks, boolean hashIndexAllowCollision,
       long blockCacheCompressedSize, int blockCacheCompressedNumShardBits);
 
@@ -315,7 +321,7 @@ public class BlockBasedTableConfig extends TableFormatConfig {
   private int blockSizeDeviation_;
   private int blockRestartInterval_;
   private boolean wholeKeyFiltering_;
-  private int bitsPerKey_;
+  private Filter filter_;
   private boolean cacheIndexAndFilterBlocks_;
   private boolean hashIndexAllowCollision_;
   private long blockCacheCompressedSize_;

java/org/rocksdb/test/FilterTest.java

@@ -0,0 +1,27 @@
+// Copyright (c) 2014, Facebook, Inc.  All rights reserved.
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree. An additional grant
+// of patent rights can be found in the PATENTS file in the same directory.
+
+package org.rocksdb.test;
+
+import org.rocksdb.*;
+
+public class FilterTest {
+  static {
+    RocksDB.loadLibrary();
+  }
+  public static void main(String[] args) {
+    Options options = new Options();
+    // test table config without filter
+    BlockBasedTableConfig blockConfig = new BlockBasedTableConfig();
+    options.setTableFormatConfig(blockConfig);
+    options.dispose();
+    // new Bloom filter
+    options = new Options();
+    blockConfig = new BlockBasedTableConfig();
+    blockConfig.setFilter(new BloomFilter());
+    options.setTableFormatConfig(blockConfig);
+    System.out.println("Filter test passed");
+  }
+}

java/rocksjni/table.cc

@@ -37,7 +37,7 @@ jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle(
     JNIEnv* env, jobject jobj, jboolean no_block_cache, jlong block_cache_size,
     jint block_cache_num_shardbits, jlong block_size, jint block_size_deviation,
     jint block_restart_interval, jboolean whole_key_filtering,
-    jint bits_per_key, jboolean cache_index_and_filter_blocks,
+    jlong jfilterPolicy, jboolean cache_index_and_filter_blocks,
     jboolean hash_index_allow_collision, jlong block_cache_compressed_size,
     jint block_cache_compressd_num_shard_bits) {
   rocksdb::BlockBasedTableOptions options;
@@ -55,8 +55,9 @@ jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle(
   options.block_size_deviation = block_size_deviation;
   options.block_restart_interval = block_restart_interval;
   options.whole_key_filtering = whole_key_filtering;
-  if (bits_per_key > 0) {
-    options.filter_policy.reset(rocksdb::NewBloomFilterPolicy(bits_per_key));
+  if (jfilterPolicy > 0) {
+    options.filter_policy.reset(
+        reinterpret_cast<rocksdb::FilterPolicy*>(jfilterPolicy));
   }
   options.cache_index_and_filter_blocks = cache_index_and_filter_blocks;
   options.hash_index_allow_collision = hash_index_allow_collision;
@@ -69,6 +70,6 @@ jlong Java_org_rocksdb_BlockBasedTableConfig_newTableFactoryHandle(
       options.block_cache = rocksdb::NewLRUCache(block_cache_compressed_size);
     }
   }
-  
+
   return reinterpret_cast<jlong>(rocksdb::NewBlockBasedTableFactory(options));
 }