Added bloom filter support. Improve concurrency and fix some issues.

.gitattributes

@@ -0,0 +1,2 @@
+* text=auto
+*.java text eol=lf

README.md

@@ -19,7 +19,6 @@ Recommended Package imports:
 
 ```java
 import org.iq80.leveldb.*;
-import static org.iq80.leveldb.impl.Iq80DBFactory.*;
 import java.io.*;
 ```
 

leveldb-api/src/main/java/org/iq80/leveldb/DB.java

@@ -88,10 +88,17 @@ void suspendCompactions()
     void resumeCompactions();
 
     /**
-     * Force a compaction of the specified key range.
+     * Compact the underlying storage for the key range [begin, end].
+     * In particular, deleted and overwritten versions are discarded,
+     * and the data is rearranged to reduce the cost of operations
+     * needed to access the data.  This operation should typically only
+     * be invoked by users who understand the underlying implementation.
+     * <p>
+     * Call to {@code db.compactRange(null, null);} will compact the
+     * entire database.
      *
      * @param begin if null then compaction start from the first key
-     * @param end if null then compaction ends at the last key
+     * @param end   if null then compaction ends at the last key
      */
     void compactRange(byte[] begin, byte[] end)
             throws DBException;

leveldb-api/src/main/java/org/iq80/leveldb/DBIterator.java

@@ -62,4 +62,7 @@ public interface DBIterator
      * Repositions the iterator so it is at the end of of the Database.
      */
     void seekToLast();
+
+    @Override
+    void close();
 }

leveldb-api/src/main/java/org/iq80/leveldb/Options.java

@@ -33,6 +33,30 @@ public class Options
     private DBComparator comparator;
     private Logger logger;
     private long cacheSize;
+    private boolean allowMmapReads = true;
+    private boolean allowMmapWrites = true;
+    private XFilterPolicy filterPolicy;
+
+    public static Options fromOptions(Options options)
+    {
+        final Options options1 = new Options();
+        options1.createIfMissing = options.createIfMissing;
+        options1.errorIfExists = options.errorIfExists;
+        options1.writeBufferSize = options.writeBufferSize;
+        options1.maxOpenFiles = options.maxOpenFiles;
+        options1.blockRestartInterval = options.blockRestartInterval;
+        options1.blockSize = options.blockSize;
+        options1.compressionType = options.compressionType;
+        options1.verifyChecksums = options.verifyChecksums;
+        options1.paranoidChecks = options.paranoidChecks;
+        options1.comparator = options.comparator;
+        options1.logger = options.logger;
+        options1.cacheSize = options.cacheSize;
+        options1.allowMmapReads = options.allowMmapReads;
+        options1.allowMmapWrites = options.allowMmapWrites;
+        options1.filterPolicy = options.filterPolicy;
+        return options1;
+    }
 
     static void checkArgNotNull(Object value, String name)
     {
@@ -173,4 +197,43 @@ public Options paranoidChecks(boolean paranoidChecks)
         this.paranoidChecks = paranoidChecks;
         return this;
     }
+
+    public Options allowMmapReads(boolean allowMmapReads)
+    {
+        this.allowMmapReads = allowMmapReads;
+        return this;
+    }
+
+    public boolean allowMmapReads()
+    {
+        return allowMmapReads;
+    }
+
+    public Options allowMmapWrites(boolean allowMmapWrites)
+    {
+        this.allowMmapWrites = allowMmapWrites;
+        return this;
+    }
+
+    public boolean allowMmapWrites()
+    {
+        return allowMmapWrites;
+    }
+
+    /**
+     * Set table filter policy
+     *
+     * @param filterPolicy new filter policy
+     * @return self
+     */
+    public Options filterPolicy(XFilterPolicy filterPolicy)
+    {
+        this.filterPolicy = filterPolicy;
+        return this;
+    }
+
+    public XFilterPolicy filterPolicy()
+    {
+        return filterPolicy;
+    }
 }

leveldb-api/src/main/java/org/iq80/leveldb/WriteOptions.java

@@ -22,6 +22,25 @@ public class WriteOptions
     private boolean sync;
     private boolean snapshot;
 
+    /**
+     * If true, the write will be flushed from the operating system
+     * buffer cache (by calling WritableFile::Sync()) before the write
+     * is considered complete.  If this flag is true, writes will be
+     * slower.
+     * <p>
+     * If this flag is false, and the machine crashes, some recent
+     * writes may be lost.  Note that if it is just the process that
+     * crashes (i.e., the machine does not reboot), no writes will be
+     * lost even if sync==false.
+     * <p>
+     * In other words, a DB write with sync==false has similar
+     * crash semantics as the "write()" system call.  A DB write
+     * with sync==true has similar crash semantics to a "write()"
+     * system call followed by "fsync()".
+     * <p>
+     *     In java Implementation if process crash
+     * Default: false
+     **/
     public boolean sync()
     {
         return sync;

leveldb-api/src/main/java/org/iq80/leveldb/XFilterPolicy.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2011 the original author or authors.
+ * See the notice.md file distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.iq80.leveldb;
+
+/**
+ * A database can be configured with a custom FilterPolicy object.
+ * This object is responsible for creating a small filter from a set
+ * of keys.  These filters are stored in leveldb and are consulted
+ * automatically by leveldb to decide whether or not to read some
+ * information from disk. In many cases, a filter can cut down the
+ * number of disk seeks form a handful to a single disk seek per
+ * DB::Get() call.
+ * <p>
+ * Most people will want to use the builtin bloom filter support (see
+ * NewBloomFilterPolicy() below).
+ *
+ * @author Honore Vasconcelos
+ */
+public interface XFilterPolicy
+{
+}

leveldb-benchmark/pom.xml

@@ -30,6 +30,7 @@
 
     <properties>
         <air.main.basedir>${project.parent.basedir}</air.main.basedir>
+        <air.check.fail-checkstyle>false</air.check.fail-checkstyle>
     </properties>
 
     <dependencies>