leveldb-ruby 0.14 → 0.15

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011--2012 William Morgan.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -1,28 +1,72 @@
-LevelDB Ruby bindings.
+LevelDB is a very fast, persistent, in-process key-value store.
+Read more about it here: http://code.google.com/p/leveldb/.
 
-Do this:
+This gem contains Ruby bindings so that you can use it from your
+Ruby process.
 
-  gem install leveldb-ruby
+INSTALLATION
 
+  gem install leveldb-ruby
 
-And then run this:
+SYNOPSIS
 
-  require 'rubygems' # on ruby < 1.9
+  require 'rubygems' # on for ruby 1.8
   require 'leveldb'
 
+  ## make a new database
   db = LevelDB::DB.new "/tmp/asdf"
-  db.put "it", "works"
-  db.get "it"
 
-Only a very few operations are supported right now:
+  ## getting and setting
+  db.put "it", "works"               # => "works"
+  db.get "it"                        # => "works"
+
+  db["hello"] = "there"              # => "there"
+  db["hello"]                        # => "there"
+
+  db["nonexistent"]                  # => nil
+
+  ## testing
+  db.includes? "hello"               # => true
+  db.contains? "hello"               # => true
+
+  ## keys and values
+  db.keys                            # => "it", "hello"
+  db.values                          # => "there", "works"
+
+  ## iterating
+  db.each { |k, v| ... }
+  db.map { |k, v| ... }
+  db.each                            # => LevelDB::Iterator
+
+  ## ranges
+  db.each(:from => "a", :to => "b")  # => LevelDB::Iterator
+  db.each(:from => "a", :to => "b").
+    map { |k, v| ... }
+  # etc...
+
+  ## deleting
+  db.delete "hello"       # => "there"
+  db.delete "hello"       # => nil
+
+LICENSE
+
+  Leveldb-ruby is available for your use under the terms of
+  the New BSD License. See the LICENSE file for details.
+
+CREDIT
+
+  This gem brought to you by William Morgan <http://masanjin.net/>
+  and the following honorable contributors:
+  - Rick Olson
+  - byplayer
+  - Yukio Goto
+  - Johannes Holzfuß
+  - Steve Wilhelm
+  - Gabriel Ebner
+  and by users like you.
+
+BUGS
 
-  DB.new    # creates or loads as necessary
-  DB.create # dies if it already exists
-  DB.load   # dies unless it alread exists
+  Please report bugs to https://github.com/wmorgan/leveldb-ruby/issues.
 
-  DB#get    # alias: DB#[]
-  DB#put    # alias: DB#[]=
-  DB#delete
 
-  DB#each
-  ... and all the enumerable methods

data/ext/leveldb/extconf.rb

@@ -3,7 +3,7 @@ require 'fileutils'
 require "./platform.rb"
 
 Dir.chdir "../../leveldb"
-system "make libleveldb.a" or abort
+system "OPT=\"-O2 -DNDEBUG -fPIC\" make libleveldb.a" or abort
 Dir.chdir "../ext/leveldb"
 
 set_platform_specific_variables!

data/ext/leveldb/leveldb.cc

@@ -1,14 +1,20 @@
 #include <ruby.h>
+#include <memory>
 
 #include "leveldb/db.h"
+#include "leveldb/cache.h"
 #include "leveldb/slice.h"
 #include "leveldb/write_batch.h"
 
+using namespace std;
+
 static VALUE m_leveldb;
 static VALUE c_db;
 static VALUE c_iter;
 static VALUE c_batch;
 static VALUE c_error;
+static VALUE c_no_compression;
+static VALUE c_snappy_compression;
 static VALUE k_fill;
 static VALUE k_verify;
 static VALUE k_sync;
@@ -17,9 +23,20 @@ static VALUE k_to;
 static VALUE k_reversed;
 static VALUE k_class;
 static VALUE k_name;
-static ID to_s;
+static ID k_to_s;
 static leveldb::ReadOptions uncached_read_options;
 
+static VALUE c_db_options;
+static VALUE k_create_if_missing;
+static VALUE k_error_if_exists;
+static VALUE k_paranoid_checks;
+static VALUE k_write_buffer_size;
+static VALUE k_block_cache_size;
+static VALUE k_block_size;
+static VALUE k_block_restart_interval;
+static VALUE k_compression;
+static VALUE k_max_open_files;
+
 // support 1.9 and 1.8
 #ifndef RSTRING_PTR
 #define RSTRING_PTR(v) RSTRING(v)->ptr
@@ -45,21 +62,154 @@ static void db_free(bound_db* db) {
   delete db;
 }
 
-static VALUE db_make(VALUE klass, VALUE v_pathname, VALUE v_create_if_necessary, VALUE v_break_if_exists) {
+static void sync_vals(VALUE opts, VALUE key, VALUE db_options, bool* pOptionVal) {
+  VALUE v = rb_hash_aref(opts, key);
+
+  if(!NIL_P(v)) *pOptionVal = RTEST(v);
+  string param("@");
+  param += rb_id2name(SYM2ID(key));
+  rb_iv_set(db_options, param.c_str(), *pOptionVal ? Qtrue : Qfalse);
+}
+
+static void sync_vals(VALUE opts, VALUE key, VALUE db_options, size_t* pOptionVal) {
+  VALUE v = rb_hash_aref(opts, key);
+
+  if(!NIL_P(v)) *pOptionVal = NUM2UINT(v);
+  string param("@");
+  param += rb_id2name(SYM2ID(key));
+  rb_iv_set(db_options, param.c_str(), UINT2NUM(*pOptionVal));
+}
+
+static void sync_vals(VALUE opts, VALUE key, VALUE db_options, int* pOptionVal) {
+  VALUE v = rb_hash_aref(opts, key);
+
+  if(!NIL_P(v)) *pOptionVal = NUM2INT(v);
+  string param("@");
+  param += rb_id2name(SYM2ID(key));
+  rb_iv_set(db_options, param.c_str(), INT2NUM(*pOptionVal));
+}
+
+static void set_db_option(VALUE o_options, VALUE opts, leveldb::Options* options) {
+  if(NIL_P(o_options)) return;
+  Check_Type(opts, T_HASH);
+
+  sync_vals(opts, k_create_if_missing, o_options, &(options->create_if_missing));
+  sync_vals(opts, k_error_if_exists, o_options, &(options->error_if_exists));
+  sync_vals(opts, k_paranoid_checks, o_options, &(options->paranoid_checks));
+  sync_vals(opts, k_write_buffer_size, o_options, &(options->write_buffer_size));
+  sync_vals(opts, k_max_open_files, o_options, &(options->max_open_files));
+  sync_vals(opts, k_block_size, o_options, &(options->block_size));
+  sync_vals(opts, k_block_restart_interval, o_options, &(options->block_restart_interval));
+
+  VALUE v = rb_hash_aref(opts, k_block_cache_size);
+  if(!NIL_P(v)) {
+    options->block_cache = leveldb::NewLRUCache(NUM2INT(v));
+    rb_iv_set(o_options, "@block_cache_size", v);
+  }
+
+  v = rb_hash_aref(opts, k_compression);
+  if(!NIL_P(v)) {
+    if(v == c_no_compression) options->compression = leveldb::kNoCompression;
+    else if(v == c_snappy_compression) options->compression = leveldb::kSnappyCompression;
+    else rb_raise(rb_eTypeError, "invalid type for %s", rb_id2name(SYM2ID(k_compression)));
+  }
+
+  if(options->compression == leveldb::kNoCompression) rb_iv_set(o_options, "@compression", c_no_compression);
+  else if(options->compression == leveldb::kSnappyCompression) rb_iv_set(o_options, "@compression", c_snappy_compression);
+}
+
+/*
+ * call-seq:
+ *   make(pathname, options)
+ *
+ * open level-db database
+ *
+ * pathname path for database
+ *
+ * [options[ :create_if_missing ]] create if database doesn't exit
+ *
+ * [options[ :error_if_exists ]] raise error if database exists
+ *
+ * [options[ :paranoid_checks ]] If true, the implementation will do aggressive checking of the
+ *                               data it is processing and will stop early if it detects any
+ *                               errors.  This may have unforeseen ramifications: for example, a
+ *                               corruption of one DB entry may cause a large number of entries to
+ *                               become unreadable or for the entire DB to become unopenable.
+ *
+ *                               Default: false
+ * [options[ :write_buffer_size ]] Amount of data to build up in memory (backed by an unsorted log
+ *                                 on disk) before converting to a sorted on-disk file.
+ *
+ *                                 Larger values increase performance, especially during bulk
+ *                                 loads.
+ *                                 Up to two write buffers may be held in memory at the same time,
+ *                                 so you may wish to adjust this parameter to control memory
+ *                                 usage.
+ *                                 Also, a larger write buffer will result in a longer recovery
+ *                                 time the next time the database is opened.
+ *
+ *                                 Default: 4MB
+ * [options[ :max_open_files ]] Number of open files that can be used by the DB.  You may need to
+ *                              increase this if your database has a large working set (budget
+ *                              one open file per 2MB of working set).
+ *
+ *                              Default: 1000
+ * [options[ :block_cache_size ]] Control over blocks (user data is stored in a set of blocks,
+ *                                and a block is the unit of reading from disk).
+ *
+ *                                If non nil, use the specified cache size.
+ *                                If nil, leveldb will automatically create and use an 8MB
+ *                                internal cache.
+ *
+ *                                Default: nil
+ * [options[ :block_size ]] Approximate size of user data packed per block.  Note that the
+ *                          block size specified here corresponds to uncompressed data.  The
+ *                          actual size of the unit read from disk may be smaller if
+ *                          compression is enabled.  This parameter can be changed dynamically.
+ *
+ *                          Default: 4K
+ * [options[ :block_restart_interval ]] Number of keys between restart points for delta
+ *                                      encoding of keys.
+ *                                      This parameter can be changed dynamically.
+ *                                      Most clients should leave this parameter alone.
+ *
+ *                                      Default: 16
+ * [options[ :compression ]] LevelDB::CompressionType::SnappyCompression or
+ *                           LevelDB::CompressionType::NoCompression.
+ *
+ *                           Compress blocks using the specified compression algorithm.
+ *                           This parameter can be changed dynamically.
+ *
+ *                           Default: LevelDB::CompressionType::SnappyCompression,
+ *                           which gives lightweight but fast compression.
+ *
+ *                           Typical speeds of SnappyCompression on an Intel(R) Core(TM)2 2.4GHz:
+ *                               ~200-500MB/s compression
+ *                               ~400-800MB/s decompression
+ *                           Note that these speeds are significantly faster than most
+ *                           persistent storage speeds, and therefore it is typically never
+ *                           worth switching to NoCompression.  Even if the input data is
+ *                           incompressible, the SnappyCompression implementation will
+ *                           efficiently detect that and will switch to uncompressed mode.
+ * [return] LevelDB::DB instance
+ */
+static VALUE db_make(VALUE self, VALUE v_pathname, VALUE v_options) {
   Check_Type(v_pathname, T_STRING);
 
-  bound_db* db = new bound_db;
+  auto_ptr<bound_db> db(new bound_db);
   std::string pathname = std::string((char*)RSTRING_PTR(v_pathname));
 
   leveldb::Options options;
-  if(RTEST(v_create_if_necessary)) options.create_if_missing = true;
-  if(RTEST(v_break_if_exists)) options.error_if_exists = true;
+  VALUE o_options = rb_class_new_instance(0, NULL, c_db_options);
+  set_db_option(o_options, v_options, &options);
+
   leveldb::Status status = leveldb::DB::Open(options, pathname, &db->db);
+  VALUE o_db = Data_Wrap_Struct(self, NULL, db_free, db.release());
   RAISE_ON_ERROR(status);
 
-  VALUE o_db = Data_Wrap_Struct(klass, NULL, db_free, db);
-  VALUE argv[1] = { v_pathname };
-  rb_obj_call_init(o_db, 1, argv);
+  rb_iv_set(o_db, "@options", o_options);
+  VALUE init_argv[1] = { v_pathname };
+  rb_obj_call_init(o_db, 1, init_argv);
 
   return o_db;
 }
@@ -80,10 +230,12 @@ static leveldb::ReadOptions parse_read_options(VALUE options) {
 
   if(!NIL_P(options)) {
     Check_Type(options, T_HASH);
-    if(rb_hash_aref(options, k_fill) == Qfalse)
-      readOptions.fill_cache = false;
-    if(rb_hash_aref(options, k_verify) == Qtrue)
-      readOptions.verify_checksums = true;
+
+    VALUE v_fill = rb_hash_aref(options, k_fill);
+    VALUE v_verify = rb_hash_aref(options, k_verify);
+
+    if(!NIL_P(v_fill)) readOptions.fill_cache = RTEST(v_fill);
+    if(!NIL_P(v_verify)) readOptions.verify_checksums = RTEST(v_verify);
   }
 
   return readOptions;
@@ -94,8 +246,8 @@ static leveldb::WriteOptions parse_write_options(VALUE options) {
 
   if(!NIL_P(options)) {
     Check_Type(options, T_HASH);
-    if(rb_hash_aref(options, k_sync) == Qtrue)
-      writeOptions.sync = true;
+    VALUE v_sync = rb_hash_aref(options, k_sync);
+    if(!NIL_P(v_sync)) writeOptions.sync = RTEST(v_sync);
   }
 
   return writeOptions;
@@ -299,7 +451,7 @@ static VALUE iter_init(VALUE self, VALUE db, VALUE options) {
 
     if(RTEST(key_to)) {
       iter->check_limit = true;
-      iter->key_to_str = RUBY_STRING_TO_SLICE(rb_funcall(key_to, to_s, 0)).ToString();
+      iter->key_to_str = RUBY_STRING_TO_SLICE(rb_funcall(key_to, k_to_s, 0)).ToString();
     }
 
     rb_iv_set(self, "@from", key_from);
@@ -314,7 +466,7 @@ static VALUE iter_init(VALUE self, VALUE db, VALUE options) {
   }
 
   if(RTEST(key_from)) {
-    iter->iterator->Seek(RUBY_STRING_TO_SLICE(rb_funcall(key_from, to_s, 0)));
+    iter->iterator->Seek(RUBY_STRING_TO_SLICE(rb_funcall(key_from, k_to_s, 0)));
   } else {
     if(iter->reversed) {
       iter->iterator->SeekToLast();
@@ -494,14 +646,24 @@ void Init_leveldb() {
   k_reversed = ID2SYM(rb_intern("reversed"));
   k_class = rb_intern("class");
   k_name = rb_intern("name");
-  to_s = rb_intern("to_s");
+  k_create_if_missing = ID2SYM(rb_intern("create_if_missing"));
+  k_error_if_exists = ID2SYM(rb_intern("error_if_exists"));
+  k_paranoid_checks = ID2SYM(rb_intern("paranoid_checks"));
+  k_write_buffer_size = ID2SYM(rb_intern("write_buffer_size"));
+  k_block_cache_size = ID2SYM(rb_intern("block_cache_size"));
+  k_block_size = ID2SYM(rb_intern("block_size"));
+  k_block_restart_interval = ID2SYM(rb_intern("block_restart_interval"));
+  k_compression = ID2SYM(rb_intern("compression"));
+  k_max_open_files = ID2SYM(rb_intern("max_open_files"));
+  k_to_s = rb_intern("to_s");
+
   uncached_read_options = leveldb::ReadOptions();
   uncached_read_options.fill_cache = false;
 
   m_leveldb = rb_define_module("LevelDB");
 
   c_db = rb_define_class_under(m_leveldb, "DB", rb_cObject);
-  rb_define_singleton_method(c_db, "make", RUBY_METHOD_FUNC(db_make), 3);
+  rb_define_singleton_method(c_db, "make", RUBY_METHOD_FUNC(db_make), 2);
   rb_define_method(c_db, "initialize", RUBY_METHOD_FUNC(db_init), 1);
   rb_define_method(c_db, "get", RUBY_METHOD_FUNC(db_get), -1);
   rb_define_method(c_db, "delete", RUBY_METHOD_FUNC(db_delete), -1);
@@ -525,6 +687,13 @@ void Init_leveldb() {
   rb_define_method(c_batch, "put", RUBY_METHOD_FUNC(batch_put), 2);
   rb_define_method(c_batch, "delete", RUBY_METHOD_FUNC(batch_delete), 1);
 
+  c_db_options = rb_define_class_under(m_leveldb, "Options", rb_cObject);
+
+  VALUE m_ctype = rb_define_module_under(m_leveldb, "CompressionType");
+  VALUE c_base = rb_define_class_under(m_ctype, "Base", rb_cObject);
+  c_no_compression = rb_define_class_under(m_ctype, "NoCompression", c_base);
+  c_snappy_compression = rb_define_class_under(m_ctype, "SnappyCompression", c_base);
+
   c_error = rb_define_class_under(m_leveldb, "Error", rb_eStandardError);
 }
 }

data/leveldb/Makefile

@@ -2,87 +2,37 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file. See the AUTHORS file for names of contributors.
 
-CXX ?= g++
-CC  ?= gcc
+# Inherit some settings from environment variables, if available
+INSTALL_PATH ?= $(CURDIR)
 
 #-----------------------------------------------
 # Uncomment exactly one of the lines labelled (A), (B), and (C) below
 # to switch between compilation modes.
 
-OPT ?= -O2 -DNDEBUG -fPIC # (A) Production use (optimized mode)
+OPT ?= -O2 -DNDEBUG       # (A) Production use (optimized mode)
 # OPT ?= -g2              # (B) Debug mode, w/ full line-level debugging symbols
 # OPT ?= -O2 -g2 -DNDEBUG # (C) Profiling mode: opt, but w/debugging symbols
 #-----------------------------------------------
 
 # detect what platform we're building on
-$(shell sh ./build_detect_platform)
-# this file is generated by build_detect_platform to set build flags
+$(shell ./build_detect_platform build_config.mk)
+# this file is generated by the previous line to set build flags and sources
 include build_config.mk
 
-# If Snappy is installed, add compilation and linker flags
-# (see http://code.google.com/p/snappy/)
-ifeq ($(SNAPPY), 1)
-SNAPPY_CFLAGS=-DSNAPPY
-SNAPPY_LDFLAGS=-lsnappy
-else
-SNAPPY_CFLAGS=
-SNAPPY_LDFLAGS=
-endif
+CFLAGS += -I. -I./include $(PLATFORM_CCFLAGS) $(OPT)
+CXXFLAGS += -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT)
 
-# If Google Perf Tools are installed, add compilation and linker flags
-# (see http://code.google.com/p/google-perftools/)
-ifeq ($(GOOGLE_PERFTOOLS), 1)
-GOOGLE_PERFTOOLS_LDFLAGS=-ltcmalloc
-else
-GOOGLE_PERFTOOLS_LDFLAGS=
-endif
+LDFLAGS += $(PLATFORM_LDFLAGS)
 
-CFLAGS = -c -I. -I./include $(PORT_CFLAGS) $(PLATFORM_CFLAGS) $(OPT) $(SNAPPY_CFLAGS)
-
-LDFLAGS += $(PLATFORM_LDFLAGS) $(SNAPPY_LDFLAGS) $(GOOGLE_PERFTOOLS_LDFLAGS)
-
-LIBOBJECTS = \
-	./db/builder.o \
-	./db/c.o \
-	./db/db_impl.o \
-	./db/db_iter.o \
-	./db/filename.o \
-	./db/dbformat.o \
-	./db/log_reader.o \
-	./db/log_writer.o \
-	./db/memtable.o \
-	./db/repair.o \
-	./db/table_cache.o \
-	./db/version_edit.o \
-	./db/version_set.o \
-	./db/write_batch.o \
-	./port/port_posix.o \
-	./table/block.o \
-	./table/block_builder.o \
-	./table/format.o \
-	./table/iterator.o \
-	./table/merger.o \
-	./table/table.o \
-	./table/table_builder.o \
-	./table/two_level_iterator.o \
-	./util/arena.o \
-	./util/cache.o \
-	./util/coding.o \
-	./util/comparator.o \
-	./util/crc32c.o \
-	./util/env.o \
-	./util/env_posix.o \
-	./util/hash.o \
-	./util/histogram.o \
-	./util/logging.o \
-	./util/options.o \
-	./util/status.o
+LIBOBJECTS = $(SOURCES:.cc=.o)
+MEMENVOBJECTS = $(MEMENV_SOURCES:.cc=.o)
 
 TESTUTIL = ./util/testutil.o
 TESTHARNESS = ./util/testharness.o $(TESTUTIL)
 
 TESTS = \
 	arena_test \
+	bloom_test \
 	c_test \
 	cache_test \
 	coding_test \
@@ -92,6 +42,7 @@ TESTS = \
 	dbformat_test \
 	env_test \
 	filename_test \
+	filter_block_test \
 	log_test \
 	memenv_test \
 	skiplist_test \
@@ -106,109 +57,144 @@ BENCHMARKS = db_bench_sqlite3 db_bench_tree_db
 LIBRARY = libleveldb.a
 MEMENVLIBRARY = libmemenv.a
 
-all: $(LIBRARY)
+default: all
 
-check: $(PROGRAMS) $(TESTS)
+# Should we build shared libraries?
+ifneq ($(PLATFORM_SHARED_EXT),)
+
+ifneq ($(PLATFORM_SHARED_VERSIONED),true)
+SHARED1 = libleveldb.$(PLATFORM_SHARED_EXT)
+SHARED2 = $(SHARED1)
+SHARED3 = $(SHARED1)
+SHARED = $(SHARED1)
+else
+# Update db.h if you change these.
+SHARED_MAJOR = 1
+SHARED_MINOR = 5
+SHARED1 = libleveldb.$(PLATFORM_SHARED_EXT)
+SHARED2 = $(SHARED1).$(SHARED_MAJOR)
+SHARED3 = $(SHARED1).$(SHARED_MAJOR).$(SHARED_MINOR)
+SHARED = $(SHARED1) $(SHARED2) $(SHARED3)
+$(SHARED1): $(SHARED3)
+	ln -fs $(SHARED3) $(SHARED1)
+$(SHARED2): $(SHARED3)
+	ln -fs $(SHARED3) $(SHARED2)
+endif
+
+$(SHARED3):
+	$(CXX) $(LDFLAGS) $(PLATFORM_SHARED_LDFLAGS)$(SHARED2) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) $(SOURCES) -o $(SHARED3)
+
+endif  # PLATFORM_SHARED_EXT
+
+all: $(SHARED) $(LIBRARY)
+
+check: all $(PROGRAMS) $(TESTS)
 	for t in $(TESTS); do echo "***** Running $$t"; ./$$t || exit 1; done
 
 clean:
-	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(MEMENVLIBRARY) */*.o */*/*.o ios-x86/*/*.o ios-arm/*/*.o
+	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) */*.o */*/*.o ios-x86/*/*.o ios-arm/*/*.o build_config.mk
 	-rm -rf ios-x86/* ios-arm/*
-	-rm build_config.mk
 
 $(LIBRARY): $(LIBOBJECTS)
 	rm -f $@
 	$(AR) -rs $@ $(LIBOBJECTS)
 
 db_bench: db/db_bench.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) $(LDFLAGS) db/db_bench.o $(LIBOBJECTS) $(TESTUTIL) -o $@
+	$(CXX) db/db_bench.o $(LIBOBJECTS) $(TESTUTIL) -o $@  $(LDFLAGS)
 
 db_bench_sqlite3: doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) $(LDFLAGS) -lsqlite3 doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL) -o $@
+	$(CXX) doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL) -o $@ $(LDFLAGS) -lsqlite3
 
 db_bench_tree_db: doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL)
-	$(CXX) $(LDFLAGS) -lkyotocabinet doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL) -o $@
+	$(CXX) doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL) -o $@ $(LDFLAGS) -lkyotocabinet
 
 arena_test: util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
+
+bloom_test: util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(CXX) util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 c_test: db/c_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/c_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/c_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 cache_test: util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 coding_test: util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 corruption_test: db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 crc32c_test: util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 db_test: db/db_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/db_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/db_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 env_test: util/env_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) util/env_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) util/env_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 filename_test: db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
+
+filter_block_test: table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS)
+	$(CXX) table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 log_test: db/log_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/log_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/log_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 table_test: table/table_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) table/table_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) table/table_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 skiplist_test: db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 version_edit_test: db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 version_set_test: db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 write_batch_test: db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@
+	$(CXX) db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
-$(MEMENVLIBRARY) : helpers/memenv/memenv.o
+$(MEMENVLIBRARY) : $(MEMENVOBJECTS)
 	rm -f $@
-	$(AR) -rs $@ helpers/memenv/memenv.o
+	$(AR) -rs $@ $(MEMENVOBJECTS)
 
 memenv_test : helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS)
-	$(CXX) $(LDFLAGS) helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS) -o $@
+	$(CXX) helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS) -o $@ $(LDFLAGS)
 
 ifeq ($(PLATFORM), IOS)
 # For iOS, create universal object files to be used on both the simulator and
 # a device.
-SIMULATORROOT=/Developer/Platforms/iPhoneSimulator.platform/Developer
-DEVICEROOT=/Developer/Platforms/iPhoneOS.platform/Developer
-IOSVERSION=$(shell defaults read /Developer/Platforms/iPhoneOS.platform/version CFBundleShortVersionString)
+PLATFORMSROOT=/Applications/Xcode.app/Contents/Developer/Platforms
+SIMULATORROOT=$(PLATFORMSROOT)/iPhoneSimulator.platform/Developer
+DEVICEROOT=$(PLATFORMSROOT)/iPhoneOS.platform/Developer
+IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/version CFBundleShortVersionString)
 
 .cc.o:
 	mkdir -p ios-x86/$(dir $@)
-	$(SIMULATORROOT)/usr/bin/$(CXX) $(CFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 $< -o ios-x86/$@
+	$(SIMULATORROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 -c $< -o ios-x86/$@
 	mkdir -p ios-arm/$(dir $@)
-	$(DEVICEROOT)/usr/bin/$(CXX) $(CFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 $< -o ios-arm/$@
+	$(DEVICEROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 -c $< -o ios-arm/$@
 	lipo ios-x86/$@ ios-arm/$@ -create -output $@
 
 .c.o:
 	mkdir -p ios-x86/$(dir $@)
-	$(SIMULATORROOT)/usr/bin/$(CC) $(CFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 $< -o ios-x86/$@
+	$(SIMULATORROOT)/usr/bin/$(CC) $(CFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 -c $< -o ios-x86/$@
 	mkdir -p ios-arm/$(dir $@)
-	$(DEVICEROOT)/usr/bin/$(CC) $(CFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 $< -o ios-arm/$@
+	$(DEVICEROOT)/usr/bin/$(CC) $(CFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 -c $< -o ios-arm/$@
 	lipo ios-x86/$@ ios-arm/$@ -create -output $@
 
 else
 .cc.o:
-	$(CXX) $(CFLAGS) $< -o $@
+	$(CXX) $(CXXFLAGS) -c $< -o $@
 
 .c.o:
-	$(CC) $(CFLAGS) $< -o $@
+	$(CC) $(CFLAGS) -c $< -o $@
 endif