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>