An odd fix for GCC 7

Disable warning as error
Add some include<functional>
2026-11-06 02:52:35 -05:00 · 2019-10-31 15:09:55 -07:00 · 2019-10-31 15:09:49 -07:00 · 2019-10-31 15:09:36 -07:00 · 2019-10-31 15:09:36 -07:00 · 2017-07-17 15:50:03 -07:00
206 changed files with 5786 additions and 15419 deletions
@@ -32,4 +32,3 @@ coverage/COVERAGE_REPORT
 tags
 java/*.log
 java/include/org_rocksdb_*.h
-unity.cc
@@ -1,35 +1,5 @@
 # Rocksdb Change Log

-### Unreleased
-### New Features
-* Add include/utilities/write_batch_with_index.h, providing a utilitiy class to query data out of WriteBatch when building it.
-* Move BlockBasedTable related options to BlockBasedTableOptions from Options. Change corresponding JNI interface. Options affected include:
-  no_block_cache, block_cache, block_cache_compressed, block_size, block_size_deviation, block_restart_interval, filter_policy, whole_key_filtering. filter_policy is changed to shared_ptr from a raw pointer.
-* Remove deprecated options: disable_seek_compaction and db_stats_log_interval
-* OptimizeForPointLookup() takes one parameter for block cache size. It now builds hash index, bloom filter, and block cache.
-
-### Public API changes
-* The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key.
-
-
----- Past Releases -----
-
-
-## 3.4.0 (8/18/2014)
-### New Features
-* Support Multiple DB paths in universal style compactions
-* Add feature of storing plain table index and bloom filter in SST file.
-* CompactRange() will never output compacted files to level 0. This used to be the case when all the compaction input files were at level 0.
-
-### Public API changes
-* DBOptions.db_paths now is a vector of a DBPath structure which indicates both of path and target size
-* NewPlainTableFactory instead of bunch of parameters now accepts PlainTableOptions, which is defined in include/rocksdb/table.h
-* Moved include/utilities/*.h to include/rocksdb/utilities/*.h
-* Statistics APIs now take uint32_t as type instead of Tickers. Also make two access functions getTickerCount and histogramData const
-* Add DB property rocksdb.estimate-num-keys, estimated number of live keys in DB.
-* Add DB::GetIntProperty(), which returns DB properties that are integer as uint64_t.
-* The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key.
-
 ## 3.3.0 (7/10/2014)
 ### New Features
 * Added JSON API prototype.
@@ -49,7 +49,6 @@ else
 	PLATFORM_CCFLAGS += $(JEMALLOC_INCLUDE) -DHAVE_JEMALLOC
 endif

-WARNING_FLAGS = -Wall -Werror -Wsign-compare
 CFLAGS += $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CCFLAGS) $(OPT)
 CXXFLAGS += $(WARNING_FLAGS) -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT) -Woverloaded-virtual

@@ -69,7 +68,6 @@ VALGRIND_OPTS = --error-exitcode=$(VALGRIND_ERROR) --leak-check=full

 TESTS = \
 	db_test \
-	db_iter_test \
 	block_hash_index_test \
 	autovector_test \
 	column_family_test \
@@ -107,7 +105,6 @@ TESTS = \
 	backupable_db_test \
 	document_db_test \
 	json_document_test \
-	spatial_db_test \
 	version_edit_test \
 	version_set_test \
 	file_indexer_test \
@@ -115,13 +112,8 @@ TESTS = \
 	deletefile_test \
 	table_test \
 	thread_local_test \
-	geodb_test \
-	rate_limiter_test \
-	options_test \
-	cuckoo_table_builder_test \
-	cuckoo_table_reader_test \
-	cuckoo_table_db_test \
-	write_batch_with_index_test
+        geodb_test \
+        rate_limiter_test

 TOOLS = \
        sst_dump \
@@ -129,7 +121,6 @@ TOOLS = \
        db_stress \
        ldb \
 	db_repl_stress \
-  options_test \
 	blob_store_bench

 PROGRAMS = db_bench signal_test table_reader_bench log_and_apply_bench $(TOOLS)
@@ -157,7 +148,7 @@ SHARED = $(SHARED1)
 else
 # Update db.h if you change these.
 SHARED_MAJOR = 3
-SHARED_MINOR = 4
+SHARED_MINOR = 3
 SHARED1 = ${LIBNAME}.$(PLATFORM_SHARED_EXT)
 SHARED2 = $(SHARED1).$(SHARED_MAJOR)
 SHARED3 = $(SHARED1).$(SHARED_MAJOR).$(SHARED_MINOR)
@@ -236,14 +227,8 @@ valgrind_check: all $(PROGRAMS) $(TESTS)
 		echo $$t $$((etime - stime)) >> $(VALGRIND_DIR)/valgrind_tests_times; \
 	done

-unity.cc:
-	$(shell (export ROCKSDB_ROOT="$(CURDIR)"; "$(CURDIR)/build_tools/unity" "$(CURDIR)/unity.cc"))
-
-unity: unity.cc unity.o
-	$(CXX) unity.o $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
 clean:
-	-rm -f $(PROGRAMS) $(TESTS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) build_config.mk unity.cc
+	-rm -f $(PROGRAMS) $(TESTS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) build_config.mk
 	-rm -rf ios-x86/* ios-arm/*
 	-find . -name "*.[od]" -exec rm {} \;
 	-find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
@@ -336,9 +321,6 @@ crc32c_test: util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS)
 db_test: db/db_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) db/db_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)

-db_iter_test: db/db_iter_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/db_iter_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
 log_write_bench: util/log_write_bench.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) util/log_write_bench.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS) -pg

@@ -369,15 +351,9 @@ document_db_test: utilities/document/document_db_test.o $(LIBOBJECTS) $(TESTHARN
 json_document_test: utilities/document/json_document_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) utilities/document/json_document_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)

-spatial_db_test: utilities/spatialdb/spatial_db_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) utilities/spatialdb/spatial_db_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
-
 ttl_test: utilities/ttl/ttl_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) utilities/ttl/ttl_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)

-write_batch_with_index_test: utilities/write_batch_with_index/write_batch_with_index_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) utilities/write_batch_with_index/write_batch_with_index_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@  $(LDFLAGS) $(COVERAGEFLAGS)
-
 dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)

@@ -429,18 +405,6 @@ deletefile_test: db/deletefile_test.o $(LIBOBJECTS) $(TESTHARNESS)
 geodb_test: utilities/geodb/geodb_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(CXX) utilities/geodb/geodb_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)

-cuckoo_table_builder_test: table/cuckoo_table_builder_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) table/cuckoo_table_builder_test.o  $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-cuckoo_table_reader_test: table/cuckoo_table_reader_test.o $(LIBOBJECTS) $(TESTHARNESS) $(BENCHHARNESS)
-	$(CXX) table/cuckoo_table_reader_test.o  $(LIBOBJECTS) $(TESTHARNESS) $(BENCHHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-cuckoo_table_db_test: db/cuckoo_table_db_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) db/cuckoo_table_db_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
-options_test: util/options_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(CXX) util/options_test.o $(LIBOBJECTS) $(TESTHARNESS) $(EXEC_LDFLAGS) -o $@ $(LDFLAGS) $(COVERAGEFLAGS)
-
 $(MEMENVLIBRARY) : $(MEMENVOBJECTS)
 	rm -f $@
 	$(AR) -rs $@ $(MEMENVOBJECTS)
@@ -475,20 +439,18 @@ ldb: tools/ldb.o $(LIBOBJECTS)

 JNI_NATIVE_SOURCES = ./java/rocksjni/*.cc
 JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux
-ROCKSDBJNILIB = librocksdbjni.so
-ROCKSDB_JAR = rocksdbjni.jar
+ROCKSDBJNILIB = ./java/librocksdbjni.so

 ifeq ($(PLATFORM), OS_MACOSX)
-ROCKSDBJNILIB = librocksdbjni.jnilib
+ROCKSDBJNILIB = ./java/librocksdbjni.jnilib
 JAVA_INCLUDE = -I/System/Library/Frameworks/JavaVM.framework/Headers/
 endif

 rocksdbjava:
 	OPT="-fPIC -DNDEBUG -O2" $(MAKE) $(LIBRARY) -j32
 	cd java;$(MAKE) java;
-	rm -f ./java/$(ROCKSDBJNILIB)
-	$(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC -o ./java/$(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) $(LIBOBJECTS) $(JAVA_LDFLAGS) $(COVERAGEFLAGS)
-	cd java;jar -cf $(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class HISTORY*.md $(ROCKSDBJNILIB)
+	rm -f $(ROCKSDBJNILIB)
+	$(CXX) $(CXXFLAGS) -I./java/. $(JAVA_INCLUDE) -shared -fPIC -o $(ROCKSDBJNILIB) $(JNI_NATIVE_SOURCES) $(LIBOBJECTS) $(LDFLAGS) $(COVERAGEFLAGS)

 jclean:
 	cd java;$(MAKE) clean;
@@ -7,7 +7,6 @@
 #   CC                          C Compiler path
 #   CXX                         C++ Compiler path
 #   PLATFORM_LDFLAGS            Linker flags
-#   JAVA_LDFLAGS                Linker flags for RocksDBJava
 #   PLATFORM_SHARED_EXT         Extension for shared libraries
 #   PLATFORM_SHARED_LDFLAGS     Flags for building shared library
 #   PLATFORM_SHARED_CFLAGS      Flags for compiling objects for shared library
@@ -49,13 +48,7 @@ COMMON_FLAGS="-DROCKSDB_PLATFORM_POSIX"
 if [ -d /mnt/gvfs/third-party -a -z "$CXX" ]; then
    FBCODE_BUILD="true"
    if [ -z "$USE_CLANG" ]; then
-        CENTOS_VERSION=`rpm -q --qf "%{VERSION}" \
-          $(rpm -q --whatprovides redhat-release)`
-        if [ "$CENTOS_VERSION" = "6" ]; then
-          source "$PWD/build_tools/fbcode.gcc481.sh"
-        else
-          source "$PWD/build_tools/fbcode.gcc471.sh"
-        fi
+        source $PWD/build_tools/fbcode_config.sh
    else
        source "$PWD/build_tools/fbcode.clang31.sh"
    fi
@@ -158,8 +151,6 @@ case "$TARGET_OS" in
        exit 1
 esac

-JAVA_LDFLAGS="$PLATFORM_LDFLAGS"
-
 if test -z "$DO_NOT_RUN_BUILD_DETECT_VERSION"; then
  "$PWD/build_tools/build_detect_version"
 fi
@@ -218,7 +209,6 @@ EOF
    if [ "$?" = 0 ]; then
        COMMON_FLAGS="$COMMON_FLAGS -DSNAPPY"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lsnappy"
-        JAVA_LDFLAGS="$JAVA_LDFLAGS -lsnappy"
    fi


@@ -242,7 +232,7 @@ EOF
      int main() {}
 EOF
    if [ "$?" = 0 ]; then
-        COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=google"
+        COMMON_FLAGS="$COMMON_FLAGS -DGFLAGS=gflags"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lgflags"
    fi

@@ -254,7 +244,6 @@ EOF
    if [ "$?" = 0 ]; then
        COMMON_FLAGS="$COMMON_FLAGS -DZLIB"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lz"
-        JAVA_LDFLAGS="$JAVA_LDFLAGS -lz"
    fi

    # Test whether bzip library is installed
@@ -265,7 +254,6 @@ EOF
    if [ "$?" = 0 ]; then
        COMMON_FLAGS="$COMMON_FLAGS -DBZIP2"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lbz2"
-        JAVA_LDFLAGS="$JAVA_LDFLAGS -lbz2"
    fi

    # Test whether lz4 library is installed
@@ -277,7 +265,6 @@ EOF
    if [ "$?" = 0 ]; then
        COMMON_FLAGS="$COMMON_FLAGS -DLZ4"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -llz4"
-        JAVA_LDFLAGS="$JAVA_LDFLAGS -llz4"
    fi

    # Test whether numa is available
@@ -289,7 +276,6 @@ EOF
    if [ "$?" = 0 ]; then
        COMMON_FLAGS="$COMMON_FLAGS -DNUMA"
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lnuma"
-        JAVA_LDFLAGS="$JAVA_LDFLAGS -lnuma"
    fi

    # Test whether tcmalloc is available
@@ -298,7 +284,6 @@ EOF
 EOF
    if [ "$?" = 0 ]; then
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -ltcmalloc"
-        JAVA_LDFLAGS="$JAVA_LDFLAGS -ltcmalloc"
    fi
 fi

@@ -315,7 +300,6 @@ if test "$USE_HDFS"; then
  HDFS_LDFLAGS="$HDFS_LDFLAGS -ldl -lverify -ljava -ljvm"
  COMMON_FLAGS="$COMMON_FLAGS $HDFS_CCFLAGS"
  PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS $HDFS_LDFLAGS"
-  JAVA_LDFLAGS="$JAVA_LDFLAGS $HDFS_LDFLAGS"
 fi

 # if Intel SSE instruction set is supported, set USE_SSE=" -msse -msse4.2 "
@@ -330,7 +314,6 @@ echo "CC=$CC" >> "$OUTPUT"
 echo "CXX=$CXX" >> "$OUTPUT"
 echo "PLATFORM=$PLATFORM" >> "$OUTPUT"
 echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> "$OUTPUT"
-echo "JAVA_LDFLAGS=$JAVA_LDFLAGS" >> "$OUTPUT"
 echo "VALGRIND_VER=$VALGRIND_VER" >> "$OUTPUT"
 echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> "$OUTPUT"
 echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> "$OUTPUT"
@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+GCC_BASE=/mnt/gvfs/third-party2/gcc/7331085db891a2ef4a88a48a751d834e8d68f4cb/7.x/centos7-native/b2ef2b6
+CLANG_BASE=/mnt/gvfs/third-party2/llvm-fb/963d9aeda70cc4779885b1277484fe7544a04e3e/9.0.0/platform007/9e92d53/
+LIBGCC_BASE=/mnt/gvfs/third-party2/libgcc/6ace84e956873d53638c738b6f65f3f469cca74c/7.x/platform007/5620abc
+GLIBC_BASE=/mnt/gvfs/third-party2/glibc/192b0f42d63dcf6210d6ceae387b49af049e6e0c/2.26/platform007/f259413
+SNAPPY_BASE=/mnt/gvfs/third-party2/snappy/7f9bdaada18f59bc27ec2b0871eb8a6144343aef/1.1.3/platform007/ca4da3d
+ZLIB_BASE=/mnt/gvfs/third-party2/zlib/2d9f0b9a4274cc21f61272a9e89bdb859bce8f1f/1.2.8/platform007/ca4da3d
+BZIP2_BASE=/mnt/gvfs/third-party2/bzip2/dc49a21c5fceec6456a7a28a94dcd16690af1337/1.0.6/platform007/ca4da3d
+LZ4_BASE=/mnt/gvfs/third-party2/lz4/0f607f8fc442ea7d6b876931b1898bb573d5e5da/1.9.1/platform007/ca4da3d
+ZSTD_BASE=/mnt/gvfs/third-party2/zstd/ca22bc441a4eb709e9e0b1f9fec9750fed7b31c5/1.4.x/platform007/15a3614
+GFLAGS_BASE=/mnt/gvfs/third-party2/gflags/0b9929d2588991c65a57168bf88aff2db87c5d48/2.2.0/platform007/ca4da3d
+JEMALLOC_BASE=/mnt/gvfs/third-party2/jemalloc/c26f08f47ac35fc31da2633b7da92d6b863246eb/master/platform007/c26c002
+NUMA_BASE=/mnt/gvfs/third-party2/numa/3f3fb57a5ccc5fd21c66416c0b83e0aa76a05376/2.0.11/platform007/ca4da3d
+LIBUNWIND_BASE=/mnt/gvfs/third-party2/libunwind/40c73d874898b386a71847f1b99115d93822d11f/1.4/platform007/6f3e0a9
+TBB_BASE=/mnt/gvfs/third-party2/tbb/4ce8e8dba77cdbd81b75d6f0c32fd7a1b76a11ec/2018_U5/platform007/ca4da3d
+KERNEL_HEADERS_BASE=/mnt/gvfs/third-party2/kernel-headers/fb251ecd2f5ae16f8671f7014c246e52a748fe0b/fb/platform007/da39a3e
+BINUTILS_BASE=/mnt/gvfs/third-party2/binutils/ab9f09bba370e7066cafd4eb59752db93f2e8312/2.29.1/platform007/15a3614
+VALGRIND_BASE=/mnt/gvfs/third-party2/valgrind/d42d152a15636529b0861ec493927200ebebca8e/3.15.0/platform007/ca4da3d
+LUA_BASE=/mnt/gvfs/third-party2/lua/f0cd714433206d5139df61659eb7b28b1dea6683/5.3.4/platform007/5007832
@@ -0,0 +1,134 @@
+#!/bin/sh
+#
+# Set environment variables so that we can compile rocksdb using
+# fbcode settings.  It uses the latest g++ and clang compilers and also
+# uses jemalloc
+# Environment variables that change the behavior of this script:
+# PIC_BUILD -- if true, it will only take pic versions of libraries from fbcode. libraries that don't have pic variant will not be included
+
+
+BASEDIR=`dirname $BASH_SOURCE`
+source "$BASEDIR/dependencies.sh"
+
+CFLAGS=""
+
+# libgcc
+LIBGCC_INCLUDE="$LIBGCC_BASE/include/c++/7.3.0"
+LIBGCC_LIBS=" -L $LIBGCC_BASE/lib"
+
+# glibc
+GLIBC_INCLUDE="$GLIBC_BASE/include"
+GLIBC_LIBS=" -L $GLIBC_BASE/lib"
+
+# snappy
+SNAPPY_INCLUDE=" -I $SNAPPY_BASE/include/"
+if test -z $PIC_BUILD; then
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy.a"
+else
+  SNAPPY_LIBS=" $SNAPPY_BASE/lib/libsnappy_pic.a"
+fi
+CFLAGS+=" -DSNAPPY"
+
+if test -z $PIC_BUILD; then
+  # location of zlib headers and libraries
+  ZLIB_INCLUDE=" -I $ZLIB_BASE/include/"
+  ZLIB_LIBS=" $ZLIB_BASE/lib/libz.a"
+  CFLAGS+=" -DZLIB"
+
+  LZ4_INCLUDE=" -I $LZ4_BASE/include/"
+  LZ4_LIBS=" $LZ4_BASE/lib/liblz4.a"
+  CFLAGS+=" -DLZ4"
+fi
+
+# location of gflags headers and libraries
+GFLAGS_INCLUDE=" -I $GFLAGS_BASE/include/"
+if test -z $PIC_BUILD; then
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags.a"
+else
+  GFLAGS_LIBS=" $GFLAGS_BASE/lib/libgflags_pic.a"
+fi
+CFLAGS+=" -DGFLAGS=gflags"
+
+# location of jemalloc
+JEMALLOC_INCLUDE=" -I $JEMALLOC_BASE/include/"
+JEMALLOC_LIB=" $JEMALLOC_BASE/lib/libjemalloc.a"
+
+if test -z $PIC_BUILD; then
+  # location of libunwind
+  LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
+fi
+
+# location of TBB
+TBB_INCLUDE=" -isystem $TBB_BASE/include/"
+if test -z $PIC_BUILD; then
+  TBB_LIBS="$TBB_BASE/lib/libtbb.a"
+else
+  TBB_LIBS="$TBB_BASE/lib/libtbb_pic.a"
+fi
+CFLAGS+=" -DTBB"
+
+# use Intel SSE support for checksum calculations
+export USE_SSE=" -msse -msse4.2 "
+
+BINUTILS="$BINUTILS_BASE/bin"
+AR="$BINUTILS/ar"
+
+DEPS_INCLUDE="$SNAPPY_INCLUDE $ZLIB_INCLUDE $LZ4_INCLUDE $GFLAGS_INCLUDE"
+
+STDLIBS="-L $GCC_BASE/lib64"
+
+CLANG_BIN="$CLANG_BASE/bin"
+CLANG_LIB="$CLANG_BASE/lib"
+CLANG_SRC="$CLANG_BASE/../../src"
+
+CLANG_ANALYZER="$CLANG_BIN/clang++"
+CLANG_SCAN_BUILD="$CLANG_SRC/llvm/tools/clang/tools/scan-build/bin/scan-build"
+
+if [ -z "$USE_CLANG" ]; then
+  # gcc
+  CC="$GCC_BASE/bin/gcc"
+  CXX="$GCC_BASE/bin/g++"
+
+  CFLAGS+=" -B$BINUTILS/gold"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  JEMALLOC=1
+else
+  # clang
+  CLANG_INCLUDE="$CLANG_LIB/clang/stable/include"
+  CC="$CLANG_BIN/clang"
+  CXX="$CLANG_BIN/clang++"
+
+  KERNEL_HEADERS_INCLUDE="$KERNEL_HEADERS_BASE/include"
+
+  CFLAGS+=" -B$BINUTILS/gold -nostdinc -nostdlib"
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x "
+  CFLAGS+=" -isystem $LIBGCC_BASE/include/c++/7.x/x86_64-facebook-linux "
+  CFLAGS+=" -isystem $GLIBC_INCLUDE"
+  CFLAGS+=" -isystem $LIBGCC_INCLUDE"
+  CFLAGS+=" -isystem $CLANG_INCLUDE"
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE/linux "
+  CFLAGS+=" -isystem $KERNEL_HEADERS_INCLUDE "
+  CFLAGS+=" -Wno-expansion-to-defined "
+  CXXFLAGS="-nostdinc++"
+fi
+
+CFLAGS+=" $DEPS_INCLUDE"
+CFLAGS+=" -DROCKSDB_PLATFORM_POSIX -DROCKSDB_LIB_IO_POSIX -DROCKSDB_FALLOCATE_PRESENT -DROCKSDB_MALLOC_USABLE_SIZE -DROCKSDB_RANGESYNC_PRESENT -DROCKSDB_SCHED_GETCPU_PRESENT -DROCKSDB_SUPPORT_THREAD_LOCAL -DHAVE_SSE42"
+CXXFLAGS+=" $CFLAGS"
+
+EXEC_LDFLAGS=" $SNAPPY_LIBS $ZLIB_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $NUMA_LIB $TBB_LIBS"
+EXEC_LDFLAGS+=" -B$BINUTILS/gold"
+EXEC_LDFLAGS+=" -Wl,--dynamic-linker,/usr/local/fbcode/platform007/lib/ld.so"
+EXEC_LDFLAGS+=" $LIBUNWIND"
+EXEC_LDFLAGS+=" -Wl,-rpath=/usr/local/fbcode/platform007/lib"
+# required by libtbb
+EXEC_LDFLAGS+=" -ldl"
+
+PLATFORM_LDFLAGS="$LIBGCC_LIBS $GLIBC_LIBS $STDLIBS -lgcc -lstdc++"
+
+EXEC_LDFLAGS_SHARED="$SNAPPY_LIBS $ZLIB_LIBS $LZ4_LIBS $ZSTD_LIBS $GFLAGS_LIBS $TBB_LIBS"
+
+VALGRIND_VER="$VALGRIND_BASE/bin/"
+
+export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD 
@@ -1,78 +0,0 @@
-#!/bin/sh
-#
-# Create the unity file
-#
-
-OUTPUT=$1
-if test -z "$OUTPUT"; then
-  echo "usage: $0 <output-filename>" >&2
-  exit 1
-fi
-
-# Delete existing file, if it exists
-rm -f "$OUTPUT"
-touch "$OUTPUT"
-
-# Detect OS
-if test -z "$TARGET_OS"; then
-    TARGET_OS=`uname -s`
-fi
-
-# generic port files (working on all platform by #ifdef) go directly in /port
-GENERIC_PORT_FILES=`cd "$ROCKSDB_ROOT"; find port -name '*.cc' | tr "\n" " "`
-
-# On GCC, we pick libc's memcmp over GCC's memcmp via -fno-builtin-memcmp
-case "$TARGET_OS" in
-    Darwin)
-        # PORT_FILES=port/darwin/darwin_specific.cc
-        ;;
-    IOS)
-        ;;
-    Linux)
-        # PORT_FILES=port/linux/linux_specific.cc
-        ;;
-    SunOS)
-        # PORT_FILES=port/sunos/sunos_specific.cc
-        ;;
-    FreeBSD)
-        # PORT_FILES=port/freebsd/freebsd_specific.cc
-        ;;
-    NetBSD)
-        # PORT_FILES=port/netbsd/netbsd_specific.cc
-        ;;
-    OpenBSD)
-        # PORT_FILES=port/openbsd/openbsd_specific.cc
-        ;;
-    DragonFly)
-        # PORT_FILES=port/dragonfly/dragonfly_specific.cc
-        ;;
-    OS_ANDROID_CROSSCOMPILE)
-        # PORT_FILES=port/android/android.cc
-        ;;
-    *)
-        echo "Unknown platform!" >&2
-        exit 1
-esac
-
-# We want to make a list of all cc files within util, db, table, and helpers
-# except for the test and benchmark files. By default, find will output a list
-# of all files matching either rule, so we need to append -print to make the
-# prune take effect.
-DIRS="util db table utilities"
-
-set -f # temporarily disable globbing so that our patterns arent expanded
-PRUNE_TEST="-name *test*.cc -prune"
-PRUNE_BENCH="-name *bench*.cc -prune"
-PORTABLE_FILES=`cd "$ROCKSDB_ROOT"; find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cc' -print | sort`
-PORTABLE_CPP=`cd "$ROCKSDB_ROOT"; find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cpp' -print | sort`
-set +f # re-enable globbing
-
-# The sources consist of the portable files, plus the platform-specific port
-# file.
-for SOURCE_FILE in $PORTABLE_FILES $GENERIC_PORT_FILES $PORT_FILES $PORTABLE_CPP
-do
-	echo "#include <$SOURCE_FILE>" >> "$OUTPUT"
-done
-
-echo "int main(int argc, char** argv){ return 0; }" >> "$OUTPUT"
-
@@ -113,13 +113,6 @@ Status BuildTable(const std::string& dbname, Env* env, const Options& options,
          is_first_key = false;

          if (this_ikey.type == kTypeMerge) {
-            // TODO(tbd): Add a check here to prevent RocksDB from crash when
-            // reopening a DB w/o properly specifying the merge operator.  But
-            // currently we observed a memory leak on failing in RocksDB
-            // recovery, so we decide to let it crash instead of causing
-            // memory leak for now before we have identified the real cause
-            // of the memory leak.
-
            // Handle merge-type keys using the MergeHelper
            // TODO: pass statistics to MergeUntil
            merge.MergeUntil(iter, 0 /* don't worry about snapshot */);
@@ -36,9 +36,6 @@ using rocksdb::ColumnFamilyHandle;
 using rocksdb::ColumnFamilyOptions;
 using rocksdb::CompactionFilter;
 using rocksdb::CompactionFilterFactory;
-using rocksdb::CompactionFilterV2;
-using rocksdb::CompactionFilterFactoryV2;
-using rocksdb::CompactionFilterContext;
 using rocksdb::CompactionOptionsFIFO;
 using rocksdb::Comparator;
 using rocksdb::CompressionType;
@@ -55,7 +52,6 @@ using rocksdb::MergeOperator;
 using rocksdb::NewBloomFilterPolicy;
 using rocksdb::NewLRUCache;
 using rocksdb::Options;
-using rocksdb::BlockBasedTableOptions;
 using rocksdb::RandomAccessFile;
 using rocksdb::Range;
 using rocksdb::ReadOptions;
@@ -82,7 +78,6 @@ struct rocksdb_fifo_compaction_options_t { CompactionOptionsFIFO rep; };
 struct rocksdb_readoptions_t     { ReadOptions       rep; };
 struct rocksdb_writeoptions_t    { WriteOptions      rep; };
 struct rocksdb_options_t         { Options           rep; };
-struct rocksdb_block_based_table_options_t  { BlockBasedTableOptions rep; };
 struct rocksdb_seqfile_t         { SequentialFile*   rep; };
 struct rocksdb_randomfile_t      { RandomAccessFile* rep; };
 struct rocksdb_writablefile_t    { WritableFile*     rep; };
@@ -159,104 +154,6 @@ struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
  virtual const char* Name() const { return (*name_)(state_); }
 };

-struct rocksdb_compactionfilterv2_t : public CompactionFilterV2 {
-  void* state_;
-  void (*destructor_)(void*);
-  const char* (*name_)(void*);
-  void (*filter_)(void*, int level, size_t num_keys,
-                  const char* const* keys_list, const size_t* keys_list_sizes,
-                  const char* const* existing_values_list, const size_t* existing_values_list_sizes,
-                  char** new_values_list, size_t* new_values_list_sizes,
-                  unsigned char* to_delete_list);
-
-  virtual ~rocksdb_compactionfilterv2_t() {
-    (*destructor_)(state_);
-  }
-
-  virtual const char* Name() const {
-    return (*name_)(state_);
-  }
-
-  virtual std::vector<bool> Filter(int level,
-                                   const SliceVector& keys,
-                                   const SliceVector& existing_values,
-                                   std::vector<std::string>* new_values,
-                                   std::vector<bool>* values_changed) const {
-    // Make a vector pointing to the underlying key data.
-    size_t num_keys = keys.size();
-    std::vector<const char*> keys_list(num_keys);
-    std::vector<size_t> keys_list_sizes(num_keys);
-    for (size_t i = 0; i < num_keys; ++i) {
-      keys_list[i] = keys[i].data();
-      keys_list_sizes[i] = keys[i].size();
-    }
-    // Make a vector pointing to the underlying value data.
-    std::vector<const char*> existing_values_list(num_keys);
-    std::vector<size_t> existing_values_list_sizes(num_keys);
-    for (size_t i = 0; i < num_keys; ++i) {
-      existing_values_list[i] = existing_values[i].data();
-      existing_values_list_sizes[i] = existing_values[i].size();
-    }
-    // Make a vector which will accept newly-allocated char* arrays
-    // which we will take ownership of and assign to strings in new_values.
-    new_values->clear();
-    std::vector<char*> new_values_list(num_keys);
-    std::vector<size_t> new_values_list_sizes(num_keys);
-    // Resize values_changed to hold all keys.
-    values_changed->resize(num_keys);
-    // Make a vector for bools indicating a value should be deleted
-    // on compaction (true) or maintained (false).
-    std::vector<unsigned char> to_delete_list(num_keys);
-
-    (*filter_)(
-        state_, level, num_keys, &keys_list[0], &keys_list_sizes[0],
-        &existing_values_list[0], &existing_values_list_sizes[0],
-        &new_values_list[0], &new_values_list_sizes[0], &to_delete_list[0]);
-
-    // Now, we transfer any changed values, setting values_changed and
-    // initializing new_values in the event a value changed.
-    std::vector<bool> to_delete(num_keys);
-    for (size_t i = 0; i < num_keys; ++i) {
-      to_delete[i] = to_delete_list[i];
-      (*values_changed)[i] = new_values_list[i] != nullptr;
-      if ((*values_changed)[i]) {
-        new_values->push_back(std::string(new_values_list[i], new_values_list_sizes[i]));
-        free(new_values_list[i]);
-      }
-    }
-    return to_delete;
-  }
-};
-
-struct rocksdb_compactionfilterfactoryv2_t : public CompactionFilterFactoryV2 {
-  void* state_;
-  void (*destructor_)(void*);
-  const char* (*name_)(void*);
-  rocksdb_compactionfilterv2_t* (*create_compaction_filter_v2_)(
-      void* state, const rocksdb_compactionfiltercontext_t* context);
-
-  rocksdb_compactionfilterfactoryv2_t(const SliceTransform* prefix_extractor)
-      : CompactionFilterFactoryV2(prefix_extractor) {
-  }
-
-  virtual ~rocksdb_compactionfilterfactoryv2_t() {
-    (*destructor_)(state_);
-  }
-
-  virtual const char* Name() const {
-    return (*name_)(state_);
-  }
-
-  virtual std::unique_ptr<CompactionFilterV2> CreateCompactionFilterV2(
-      const CompactionFilterContext& context) {
-    struct rocksdb_compactionfiltercontext_t c_context;
-    c_context.rep.is_full_compaction = context.is_full_compaction;
-    c_context.rep.is_manual_compaction = context.is_manual_compaction;
-    return std::unique_ptr<CompactionFilterV2>(
-        (*create_compaction_filter_v2_)(state_, &c_context));
-  }
-};
-
 struct rocksdb_comparator_t : public Comparator {
  void* state_;
  void (*destructor_)(void*);
@@ -1055,74 +952,6 @@ const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) {
  return b->rep.Data().c_str();
 }

-rocksdb_block_based_table_options_t*
-rocksdb_block_based_options_create() {
-  return new rocksdb_block_based_table_options_t;
-}
-
-void rocksdb_block_based_options_destroy(
-    rocksdb_block_based_table_options_t* options) {
-  delete options;
-}
-
-void rocksdb_block_based_options_set_block_size(
-    rocksdb_block_based_table_options_t* options, size_t block_size) {
-  options->rep.block_size = block_size;
-}
-
-void rocksdb_block_based_options_set_block_size_deviation(
-    rocksdb_block_based_table_options_t* options, int block_size_deviation) {
-  options->rep.block_size_deviation = block_size_deviation;
-}
-
-void rocksdb_block_based_options_set_block_restart_interval(
-    rocksdb_block_based_table_options_t* options, int block_restart_interval) {
-  options->rep.block_restart_interval = block_restart_interval;
-}
-
-void rocksdb_block_based_options_set_filter_policy(
-    rocksdb_block_based_table_options_t* options,
-    rocksdb_filterpolicy_t* filter_policy) {
-  options->rep.filter_policy.reset(filter_policy);
-}
-
-void rocksdb_block_based_options_set_no_block_cache(
-    rocksdb_block_based_table_options_t* options,
-    unsigned char no_block_cache) {
-  options->rep.no_block_cache = no_block_cache;
-}
-
-void rocksdb_block_based_options_set_block_cache(
-    rocksdb_block_based_table_options_t* options,
-    rocksdb_cache_t* block_cache) {
-  if (block_cache) {
-    options->rep.block_cache = block_cache->rep;
-  }
-}
-
-void rocksdb_block_based_options_set_block_cache_compressed(
-    rocksdb_block_based_table_options_t* options,
-    rocksdb_cache_t* block_cache_compressed) {
-  if (block_cache_compressed) {
-    options->rep.block_cache_compressed = block_cache_compressed->rep;
-  }
-}
-
-void rocksdb_block_based_options_set_whole_key_filtering(
-    rocksdb_block_based_table_options_t* options, unsigned char v) {
-  options->rep.whole_key_filtering = v;
-}
-
-void rocksdb_options_set_block_based_table_factory(
-    rocksdb_options_t *opt,
-    rocksdb_block_based_table_options_t* table_options) {
-  if (table_options) {
-    opt->rep.table_factory.reset(
-        rocksdb::NewBlockBasedTableFactory(table_options->rep));
-  }
-}
-
-
 rocksdb_options_t* rocksdb_options_create() {
  return new rocksdb_options_t;
 }
@@ -1137,8 +966,8 @@ void rocksdb_options_increase_parallelism(
 }

 void rocksdb_options_optimize_for_point_lookup(
-    rocksdb_options_t* opt, uint64_t block_cache_size_mb) {
-  opt->rep.OptimizeForPointLookup(block_cache_size_mb);
+    rocksdb_options_t* opt) {
+  opt->rep.OptimizeForPointLookup();
 }

 void rocksdb_options_optimize_level_style_compaction(
@@ -1175,10 +1004,10 @@ void rocksdb_options_set_merge_operator(
  opt->rep.merge_operator = std::shared_ptr<MergeOperator>(merge_operator);
 }

-void rocksdb_options_set_compaction_filter_factory_v2(
+void rocksdb_options_set_filter_policy(
    rocksdb_options_t* opt,
-    rocksdb_compactionfilterfactoryv2_t* compaction_filter_factory_v2) {
-  opt->rep.compaction_filter_factory_v2 = std::shared_ptr<CompactionFilterFactoryV2>(compaction_filter_factory_v2);
+    rocksdb_filterpolicy_t* policy) {
+  opt->rep.filter_policy = policy;
 }

 void rocksdb_options_set_create_if_missing(
@@ -1224,6 +1053,26 @@ void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int n) {
  opt->rep.max_open_files = n;
 }

+void rocksdb_options_set_cache(rocksdb_options_t* opt, rocksdb_cache_t* c) {
+  if (c) {
+    opt->rep.block_cache = c->rep;
+  }
+}
+
+void rocksdb_options_set_cache_compressed(rocksdb_options_t* opt, rocksdb_cache_t* c) {
+  if (c) {
+    opt->rep.block_cache_compressed = c->rep;
+  }
+}
+
+void rocksdb_options_set_block_size(rocksdb_options_t* opt, size_t s) {
+  opt->rep.block_size = s;
+}
+
+void rocksdb_options_set_block_restart_interval(rocksdb_options_t* opt, int n) {
+  opt->rep.block_restart_interval = n;
+}
+
 void rocksdb_options_set_target_file_size_base(
    rocksdb_options_t* opt, uint64_t n) {
  opt->rep.target_file_size_base = n;
@@ -1316,6 +1165,11 @@ void rocksdb_options_set_prefix_extractor(
  opt->rep.prefix_extractor.reset(prefix_extractor);
 }

+void rocksdb_options_set_whole_key_filtering(
+    rocksdb_options_t* opt, unsigned char v) {
+  opt->rep.whole_key_filtering = v;
+}
+
 void rocksdb_options_set_disable_data_sync(
    rocksdb_options_t* opt, int disable_data_sync) {
  opt->rep.disableDataSync = disable_data_sync;
@@ -1326,6 +1180,11 @@ void rocksdb_options_set_use_fsync(
  opt->rep.use_fsync = use_fsync;
 }

+void rocksdb_options_set_db_stats_log_interval(
+    rocksdb_options_t* opt, int db_stats_log_interval) {
+  opt->rep.db_stats_log_interval = db_stats_log_interval;
+}
+
 void rocksdb_options_set_db_log_dir(
    rocksdb_options_t* opt, const char* db_log_dir) {
  opt->rep.db_log_dir = db_log_dir;
@@ -1385,6 +1244,11 @@ void rocksdb_options_set_stats_dump_period_sec(
  opt->rep.stats_dump_period_sec = v;
 }

+void rocksdb_options_set_block_size_deviation(
+    rocksdb_options_t* opt, int v) {
+  opt->rep.block_size_deviation = v;
+}
+
 void rocksdb_options_set_advise_random_on_open(
    rocksdb_options_t* opt, unsigned char v) {
  opt->rep.advise_random_on_open = v;
@@ -1479,6 +1343,11 @@ void rocksdb_options_set_max_manifest_file_size(
  opt->rep.max_manifest_file_size = v;
 }

+void rocksdb_options_set_no_block_cache(
+    rocksdb_options_t* opt, unsigned char v) {
+  opt->rep.no_block_cache = v;
+}
+
 void rocksdb_options_set_table_cache_numshardbits(
    rocksdb_options_t* opt, int v) {
  opt->rep.table_cache_numshardbits = v;
@@ -1498,6 +1367,10 @@ void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, int di
  opt->rep.disable_auto_compactions = disable;
 }

+void rocksdb_options_set_disable_seek_compaction(rocksdb_options_t* opt, int disable) {
+  opt->rep.disable_seek_compaction = disable;
+}
+
 void rocksdb_options_set_delete_obsolete_files_period_micros(
    rocksdb_options_t* opt, uint64_t v) {
  opt->rep.delete_obsolete_files_period_micros = v;
@@ -1555,13 +1428,9 @@ void rocksdb_options_set_plain_table_factory(
    double hash_table_ratio, size_t index_sparseness) {
  static rocksdb::TableFactory* factory = 0;
  if (!factory) {
-    rocksdb::PlainTableOptions options;
-    options.user_key_len = user_key_len;
-    options.bloom_bits_per_key = bloom_bits_per_key;
-    options.hash_table_ratio = hash_table_ratio;
-    options.index_sparseness = index_sparseness;
-
-    factory = rocksdb::NewPlainTableFactory(options);
+    factory = rocksdb::NewPlainTableFactory(
+        user_key_len, bloom_bits_per_key,
+        hash_table_ratio, index_sparseness);
  }
  opt->rep.table_factory.reset(factory);
 }
@@ -1677,46 +1546,6 @@ void rocksdb_compactionfilterfactory_destroy(
  delete factory;
 }

-rocksdb_compactionfilterv2_t* rocksdb_compactionfilterv2_create(
-    void* state,
-    void (*destructor)(void*),
-    void (*filter)(void*, int level, size_t num_keys,
-                   const char* const* keys_list, const size_t* keys_list_sizes,
-                   const char* const* existing_values_list, const size_t* existing_values_list_sizes,
-                   char** new_values_list, size_t* new_values_list_sizes,
-                   unsigned char* to_delete_list),
-    const char* (*name)(void*)) {
-  rocksdb_compactionfilterv2_t* result = new rocksdb_compactionfilterv2_t;
-  result->state_ = state;
-  result->destructor_ = destructor;
-  result->filter_ = filter;
-  result->name_ = name;
-  return result;
-}
-
-void rocksdb_compactionfilterv2_destroy(rocksdb_compactionfilterv2_t* filter) {
-  delete filter;
-}
-
-rocksdb_compactionfilterfactoryv2_t* rocksdb_compactionfilterfactoryv2_create(
-    void* state,
-    rocksdb_slicetransform_t* prefix_extractor,
-    void (*destructor)(void*),
-    rocksdb_compactionfilterv2_t* (*create_compaction_filter_v2)(
-        void* state, const rocksdb_compactionfiltercontext_t* context),
-    const char* (*name)(void*)) {
-  rocksdb_compactionfilterfactoryv2_t* result = new rocksdb_compactionfilterfactoryv2_t(prefix_extractor);
-  result->state_ = state;
-  result->destructor_ = destructor;
-  result->create_compaction_filter_v2_ = create_compaction_filter_v2;
-  result->name_ = name;
-  return result;
-}
-
-void rocksdb_compactionfilterfactoryv2_destroy(rocksdb_compactionfilterfactoryv2_t* factory) {
-  delete factory;
-}
-
 rocksdb_comparator_t* rocksdb_comparator_create(
    void* state,
    void (*destructor)(void*),
@@ -225,79 +225,6 @@ static rocksdb_t* CheckCompaction(rocksdb_t* db, rocksdb_options_t* options,
  return db;
 }

-// Custom compaction filter V2.
-static void CompactionFilterV2Destroy(void* arg) { }
-static const char* CompactionFilterV2Name(void* arg) {
-  return "TestCompactionFilterV2";
-}
-static void CompactionFilterV2Filter(
-    void* arg, int level, size_t num_keys,
-    const char* const* keys_list, const size_t* keys_list_sizes,
-    const char* const* existing_values_list, const size_t* existing_values_list_sizes,
-    char** new_values_list, size_t* new_values_list_sizes,
-    unsigned char* to_delete_list) {
-  size_t i;
-  for (i = 0; i < num_keys; i++) {
-    // If any value is "gc", it's removed.
-    if (existing_values_list_sizes[i] == 2 && memcmp(existing_values_list[i], "gc", 2) == 0) {
-      to_delete_list[i] = 1;
-    } else if (existing_values_list_sizes[i] == 6 && memcmp(existing_values_list[i], "gc all", 6) == 0) {
-      // If any value is "gc all", all keys are removed.
-      size_t j;
-      for (j = 0; j < num_keys; j++) {
-        to_delete_list[j] = 1;
-      }
-      return;
-    } else if (existing_values_list_sizes[i] == 6 && memcmp(existing_values_list[i], "change", 6) == 0) {
-      // If value is "change", set changed value to "changed".
-      size_t len;
-      len = strlen("changed");
-      new_values_list[i] = malloc(len);
-      memcpy(new_values_list[i], "changed", len);
-      new_values_list_sizes[i] = len;
-    } else {
-      // Otherwise, no keys are removed.
-    }
-  }
-}
-
-// Custom prefix extractor for compaction filter V2 which extracts first 3 characters.
-static void CFV2PrefixExtractorDestroy(void* arg) { }
-static char* CFV2PrefixExtractorTransform(void* arg, const char* key, size_t length, size_t* dst_length) {
-  // Verify keys are maximum length 4; this verifies fix for a
-  // prior bug which was passing the RocksDB-encoded key with
-  // logical timestamp suffix instead of parsed user key.
-  if (length > 4) {
-    fprintf(stderr, "%s:%d: %s: key %s is not user key\n", __FILE__, __LINE__, phase, key);
-    abort();
-  }
-  *dst_length = length < 3 ? length : 3;
-  return (char*)key;
-}
-static unsigned char CFV2PrefixExtractorInDomain(void* state, const char* key, size_t length) {
-  return 1;
-}
-static unsigned char CFV2PrefixExtractorInRange(void* state, const char* key, size_t length) {
-  return 1;
-}
-static const char* CFV2PrefixExtractorName(void* state) {
-  return "TestCFV2PrefixExtractor";
-}
-
-// Custom compaction filter factory V2.
-static void CompactionFilterFactoryV2Destroy(void* arg) {
-  rocksdb_slicetransform_destroy((rocksdb_slicetransform_t*)arg);
-}
-static const char* CompactionFilterFactoryV2Name(void* arg) {
-  return "TestCompactionFilterFactoryV2";
-}
-static rocksdb_compactionfilterv2_t* CompactionFilterFactoryV2Create(
-    void* state, const rocksdb_compactionfiltercontext_t* context) {
-  return rocksdb_compactionfilterv2_create(state, CompactionFilterV2Destroy,
-                                           CompactionFilterV2Filter,
-                                           CompactionFilterV2Name);
-}
-
 // Custom merge operator
 static void MergeOperatorDestroy(void* arg) { }
 static const char* MergeOperatorName(void* arg) {
@@ -335,7 +262,6 @@ int main(int argc, char** argv) {
  rocksdb_cache_t* cache;
  rocksdb_env_t* env;
  rocksdb_options_t* options;
-  rocksdb_block_based_table_options_t* table_options;
  rocksdb_readoptions_t* roptions;
  rocksdb_writeoptions_t* woptions;
  char* err = NULL;
@@ -354,15 +280,14 @@ int main(int argc, char** argv) {
  options = rocksdb_options_create();
  rocksdb_options_set_comparator(options, cmp);
  rocksdb_options_set_error_if_exists(options, 1);
+  rocksdb_options_set_cache(options, cache);
  rocksdb_options_set_env(options, env);
  rocksdb_options_set_info_log(options, NULL);
  rocksdb_options_set_write_buffer_size(options, 100000);
  rocksdb_options_set_paranoid_checks(options, 1);
  rocksdb_options_set_max_open_files(options, 10);
-  table_options = rocksdb_block_based_options_create();
-  rocksdb_block_based_options_set_block_cache(table_options, cache);
-  rocksdb_options_set_block_based_table_factory(options, table_options);
-
+  rocksdb_options_set_block_size(options, 1024);
+  rocksdb_options_set_block_restart_interval(options, 8);
  rocksdb_options_set_compression(options, rocksdb_no_compression);
  rocksdb_options_set_compression_options(options, -14, -1, 0);
  int compression_levels[] = {rocksdb_no_compression, rocksdb_no_compression,
@@ -542,12 +467,10 @@ int main(int argc, char** argv) {
      policy = rocksdb_filterpolicy_create_bloom(10);
    }

-    rocksdb_block_based_options_set_filter_policy(table_options, policy);
-
    // Create new database
    rocksdb_close(db);
    rocksdb_destroy_db(options, dbname, &err);
-    rocksdb_options_set_block_based_table_factory(options, table_options);
+    rocksdb_options_set_filter_policy(options, policy);
    db = rocksdb_open(options, dbname, &err);
    CheckNoError(err);
    rocksdb_put(db, woptions, "foo", 3, "foovalue", 8, &err);
@@ -569,9 +492,8 @@ int main(int argc, char** argv) {
      CheckGet(db, roptions, "foo", "foovalue");
      CheckGet(db, roptions, "bar", "barvalue");
    }
-    // Reset the policy
-    rocksdb_block_based_options_set_filter_policy(table_options, NULL);
-    rocksdb_options_set_block_based_table_factory(options, table_options);
+    rocksdb_options_set_filter_policy(options, NULL);
+    rocksdb_filterpolicy_destroy(policy);
  }

  StartPhase("compaction_filter");
@@ -609,50 +531,6 @@ int main(int argc, char** argv) {
    rocksdb_options_destroy(options);
  }

-  StartPhase("compaction_filter_v2");
-  {
-    rocksdb_compactionfilterfactoryv2_t* factory;
-    rocksdb_slicetransform_t* prefix_extractor;
-    prefix_extractor = rocksdb_slicetransform_create(
-        NULL, CFV2PrefixExtractorDestroy, CFV2PrefixExtractorTransform,
-        CFV2PrefixExtractorInDomain, CFV2PrefixExtractorInRange,
-        CFV2PrefixExtractorName);
-    factory = rocksdb_compactionfilterfactoryv2_create(
-        prefix_extractor, prefix_extractor, CompactionFilterFactoryV2Destroy,
-        CompactionFilterFactoryV2Create, CompactionFilterFactoryV2Name);
-    // Create new database
-    rocksdb_close(db);
-    rocksdb_destroy_db(options, dbname, &err);
-    rocksdb_options_set_compaction_filter_factory_v2(options, factory);
-    db = rocksdb_open(options, dbname, &err);
-    CheckNoError(err);
-    // Only foo2 is GC'd, foo3 is changed.
-    rocksdb_put(db, woptions, "foo1", 4, "no gc", 5, &err);
-    CheckNoError(err);
-    rocksdb_put(db, woptions, "foo2", 4, "gc", 2, &err);
-    CheckNoError(err);
-    rocksdb_put(db, woptions, "foo3", 4, "change", 6, &err);
-    CheckNoError(err);
-    // All bars are GC'd.
-    rocksdb_put(db, woptions, "bar1", 4, "no gc", 5, &err);
-    CheckNoError(err);
-    rocksdb_put(db, woptions, "bar2", 4, "gc all", 6, &err);
-    CheckNoError(err);
-    rocksdb_put(db, woptions, "bar3", 4, "no gc", 5, &err);
-    CheckNoError(err);
-    // Compact the DB to garbage collect.
-    rocksdb_compact_range(db, NULL, 0, NULL, 0);
-
-    // Verify foo entries.
-    CheckGet(db, roptions, "foo1", "no gc");
-    CheckGet(db, roptions, "foo2", NULL);
-    CheckGet(db, roptions, "foo3", "changed");
-    // Verify bar entries were all deleted.
-    CheckGet(db, roptions, "bar1", NULL);
-    CheckGet(db, roptions, "bar2", NULL);
-    CheckGet(db, roptions, "bar3", NULL);
-  }
-
  StartPhase("merge_operator");
  {
    rocksdb_mergeoperator_t* merge_operator;
@@ -762,7 +640,8 @@ int main(int argc, char** argv) {
  StartPhase("prefix");
  {
    // Create new database
-    rocksdb_options_set_allow_mmap_reads(options, 1);
+    rocksdb_filterpolicy_t* policy = rocksdb_filterpolicy_create_bloom(10);
+    rocksdb_options_set_filter_policy(options, policy);
    rocksdb_options_set_prefix_extractor(options, rocksdb_slicetransform_create_fixed_prefix(3));
    rocksdb_options_set_hash_skip_list_rep(options, 5000, 4, 4);
    rocksdb_options_set_plain_table_factory(options, 4, 10, 0.75, 16);
@@ -799,13 +678,13 @@ int main(int argc, char** argv) {
    rocksdb_iter_get_error(iter, &err);
    CheckNoError(err);
    rocksdb_iter_destroy(iter);
+    rocksdb_filterpolicy_destroy(policy);
  }


  StartPhase("cleanup");
  rocksdb_close(db);
  rocksdb_options_destroy(options);
-  rocksdb_block_based_options_destroy(table_options);
  rocksdb_readoptions_destroy(roptions);
  rocksdb_writeoptions_destroy(woptions);
  rocksdb_cache_destroy(cache);
@@ -49,10 +49,21 @@ ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {

 uint32_t ColumnFamilyHandleImpl::GetID() const { return cfd()->GetID(); }

+namespace {
+// Fix user-supplied options to be reasonable
+template <class T, class V>
+static void ClipToRange(T* ptr, V minvalue, V maxvalue) {
+  if (static_cast<V>(*ptr) > maxvalue) *ptr = maxvalue;
+  if (static_cast<V>(*ptr) < minvalue) *ptr = minvalue;
+}
+}  // anonymous namespace
+
 ColumnFamilyOptions SanitizeOptions(const InternalKeyComparator* icmp,
+                                    const InternalFilterPolicy* ipolicy,
                                    const ColumnFamilyOptions& src) {
  ColumnFamilyOptions result = src;
  result.comparator = icmp;
+  result.filter_policy = (src.filter_policy != nullptr) ? ipolicy : nullptr;
 #ifdef OS_MACOSX
  // TODO(icanadi) make write_buffer_size uint64_t instead of size_t
  ClipToRange(&result.write_buffer_size, ((size_t)64) << 10, ((size_t)1) << 30);
@@ -68,7 +79,13 @@ ColumnFamilyOptions SanitizeOptions(const InternalKeyComparator* icmp,
  result.min_write_buffer_number_to_merge =
      std::min(result.min_write_buffer_number_to_merge,
               result.max_write_buffer_number - 1);
+  if (result.block_cache == nullptr && !result.no_block_cache) {
+    result.block_cache = NewLRUCache(8 << 20);
+  }
  result.compression_per_level = src.compression_per_level;
+  if (result.block_size_deviation < 0 || result.block_size_deviation > 100) {
+    result.block_size_deviation = 0;
+  }
  if (result.max_mem_compaction_level >= result.num_levels) {
    result.max_mem_compaction_level = result.num_levels - 1;
  }
@@ -174,7 +191,8 @@ void SuperVersionUnrefHandle(void* ptr) {
 }
 }  // anonymous namespace

-ColumnFamilyData::ColumnFamilyData(uint32_t id, const std::string& name,
+ColumnFamilyData::ColumnFamilyData(const std::string& dbname, uint32_t id,
+                                   const std::string& name,
                                   Version* dummy_versions, Cache* table_cache,
                                   const ColumnFamilyOptions& options,
                                   const DBOptions* db_options,
@@ -187,7 +205,9 @@ ColumnFamilyData::ColumnFamilyData(uint32_t id, const std::string& name,
      refs_(0),
      dropped_(false),
      internal_comparator_(options.comparator),
-      options_(*db_options, SanitizeOptions(&internal_comparator_, options)),
+      internal_filter_policy_(options.filter_policy),
+      options_(*db_options, SanitizeOptions(&internal_comparator_,
+                                            &internal_filter_policy_, options)),
      mem_(nullptr),
      imm_(options_.min_write_buffer_number_to_merge),
      super_version_(nullptr),
@@ -202,8 +222,8 @@ ColumnFamilyData::ColumnFamilyData(uint32_t id, const std::string& name,

  // if dummy_versions is nullptr, then this is a dummy column family.
  if (dummy_versions != nullptr) {
-    internal_stats_.reset(
-        new InternalStats(options_.num_levels, db_options->env, this));
+    internal_stats_.reset(new InternalStats(
+        options_.num_levels, db_options->env, db_options->statistics.get()));
    table_cache_.reset(new TableCache(&options_, storage_options, table_cache));
    if (options_.compaction_style == kCompactionStyleUniversal) {
      compaction_picker_.reset(
@@ -332,13 +352,11 @@ Compaction* ColumnFamilyData::PickCompaction(LogBuffer* log_buffer) {
 }

 Compaction* ColumnFamilyData::CompactRange(int input_level, int output_level,
-                                           uint32_t output_path_id,
                                           const InternalKey* begin,
                                           const InternalKey* end,
                                           InternalKey** compaction_end) {
  return compaction_picker_->CompactRange(current_, input_level, output_level,
-                                          output_path_id, begin, end,
-                                          compaction_end);
+                                          begin, end, compaction_end);
 }

 SuperVersion* ColumnFamilyData::GetReferencedSuperVersion(
@@ -465,7 +483,7 @@ ColumnFamilySet::ColumnFamilySet(const std::string& dbname,
                                 const EnvOptions& storage_options,
                                 Cache* table_cache)
    : max_column_family_(0),
-      dummy_cfd_(new ColumnFamilyData(0, "", nullptr, nullptr,
+      dummy_cfd_(new ColumnFamilyData(dbname, 0, "", nullptr, nullptr,
                                      ColumnFamilyOptions(), db_options,
                                      storage_options_, nullptr)),
      default_cfd_cache_(nullptr),
@@ -536,8 +554,8 @@ ColumnFamilyData* ColumnFamilySet::CreateColumnFamily(
    const ColumnFamilyOptions& options) {
  assert(column_families_.find(name) == column_families_.end());
  ColumnFamilyData* new_cfd =
-      new ColumnFamilyData(id, name, dummy_versions, table_cache_, options,
-                           db_options_, storage_options_, this);
+      new ColumnFamilyData(db_name_, id, name, dummy_versions, table_cache_,
+                           options, db_options_, storage_options_, this);
  Lock();
  column_families_.insert({name, id});
  column_family_data_.insert({id, new_cfd});
@@ -621,13 +639,4 @@ ColumnFamilyHandle* ColumnFamilyMemTablesImpl::GetColumnFamilyHandle() {
  return &handle_;
 }

-uint32_t GetColumnFamilyID(ColumnFamilyHandle* column_family) {
-  uint32_t column_family_id = 0;
-  if (column_family != nullptr) {
-    auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
-    column_family_id = cfh->GetID();
-  }
-  return column_family_id;
-}
-
 }  // namespace rocksdb
@@ -113,6 +113,7 @@ struct SuperVersion {
 };

 extern ColumnFamilyOptions SanitizeOptions(const InternalKeyComparator* icmp,
+                                           const InternalFilterPolicy* ipolicy,
                                           const ColumnFamilyOptions& src);

 class ColumnFamilySet;
@@ -184,8 +185,7 @@ class ColumnFamilyData {
  // See documentation in compaction_picker.h
  Compaction* PickCompaction(LogBuffer* log_buffer);
  Compaction* CompactRange(int input_level, int output_level,
-                           uint32_t output_path_id, const InternalKey* begin,
-                           const InternalKey* end,
+                           const InternalKey* begin, const InternalKey* end,
                           InternalKey** compaction_end);

  CompactionPicker* compaction_picker() { return compaction_picker_.get(); }
@@ -247,9 +247,9 @@ class ColumnFamilyData {

 private:
  friend class ColumnFamilySet;
-  ColumnFamilyData(uint32_t id, const std::string& name,
-                   Version* dummy_versions, Cache* table_cache,
-                   const ColumnFamilyOptions& options,
+  ColumnFamilyData(const std::string& dbname, uint32_t id,
+                   const std::string& name, Version* dummy_versions,
+                   Cache* table_cache, const ColumnFamilyOptions& options,
                   const DBOptions* db_options,
                   const EnvOptions& storage_options,
                   ColumnFamilySet* column_family_set);
@@ -271,6 +271,7 @@ class ColumnFamilyData {
  bool dropped_;               // true if client dropped it

  const InternalKeyComparator internal_comparator_;
+  const InternalFilterPolicy internal_filter_policy_;

  Options const options_;

@@ -455,6 +456,4 @@ class ColumnFamilyMemTablesImpl : public ColumnFamilyMemTables {
  ColumnFamilyHandleInternal handle_;
 };

-extern uint32_t GetColumnFamilyID(ColumnFamilyHandle* column_family);
-
 }  // namespace rocksdb
@@ -408,15 +408,9 @@ TEST(ColumnFamilyTest, WriteBatchFailure) {
  Open();
  CreateColumnFamiliesAndReopen({"one", "two"});
  WriteBatch batch;
-  batch.Put(handles_[0], Slice("existing"), Slice("column-family"));
  batch.Put(handles_[1], Slice("non-existing"), Slice("column-family"));
  ASSERT_OK(db_->Write(WriteOptions(), &batch));
  DropColumnFamilies({1});
-  WriteOptions woptions_ignore_missing_cf;
-  woptions_ignore_missing_cf.ignore_missing_column_families = true;
-  batch.Put(handles_[0], Slice("still here"), Slice("column-family"));
-  ASSERT_OK(db_->Write(woptions_ignore_missing_cf, &batch));
-  ASSERT_EQ("column-family", Get(0, "still here"));
  Status s = db_->Write(WriteOptions(), &batch);
  ASSERT_TRUE(s.IsInvalidArgument());
  Close();
@@ -752,10 +746,9 @@ TEST(ColumnFamilyTest, DifferentCompactionStyles) {
  default_cf.num_levels = 3;
  default_cf.write_buffer_size = 64 << 10;  // 64KB
  default_cf.target_file_size_base = 30 << 10;
+  default_cf.filter_policy = nullptr;
+  default_cf.no_block_cache = true;
  default_cf.source_compaction_factor = 100;
-  BlockBasedTableOptions table_options;
-  table_options.no_block_cache = true;
-  default_cf.table_factory.reset(NewBlockBasedTableFactory(table_options));

  one.compaction_style = kCompactionStyleUniversal;
  // trigger compaction if there are >= 4 files
@@ -864,7 +857,6 @@ TEST(ColumnFamilyTest, NewIteratorsTest) {
 TEST(ColumnFamilyTest, ReadOnlyDBTest) {
  Open();
  CreateColumnFamiliesAndReopen({"one", "two", "three", "four"});
-  ASSERT_OK(Put(0, "a", "b"));
  ASSERT_OK(Put(1, "foo", "bla"));
  ASSERT_OK(Put(2, "foo", "blabla"));
  ASSERT_OK(Put(3, "foo", "blablabla"));
@@ -878,29 +870,6 @@ TEST(ColumnFamilyTest, ReadOnlyDBTest) {
  ASSERT_EQ("bla", Get(1, "foo"));
  ASSERT_EQ("blablablabla", Get(2, "foo"));

-
-  // test newiterators
-  {
-    std::vector<Iterator*> iterators;
-    ASSERT_OK(db_->NewIterators(ReadOptions(), handles_, &iterators));
-    for (auto it : iterators) {
-      it->SeekToFirst();
-    }
-    ASSERT_EQ(IterStatus(iterators[0]), "a->b");
-    ASSERT_EQ(IterStatus(iterators[1]), "foo->bla");
-    ASSERT_EQ(IterStatus(iterators[2]), "foo->blablablabla");
-    for (auto it : iterators) {
-      it->Next();
-    }
-    ASSERT_EQ(IterStatus(iterators[0]), "(invalid)");
-    ASSERT_EQ(IterStatus(iterators[1]), "(invalid)");
-    ASSERT_EQ(IterStatus(iterators[2]), "(invalid)");
-
-    for (auto it : iterators) {
-      delete it;
-    }
-  }
-
  Close();
  // can't open dropped column family
  Status s = OpenReadOnly({"default", "one", "two"});
@@ -920,9 +889,7 @@ TEST(ColumnFamilyTest, DontRollEmptyLogs) {
  }
  int num_writable_file_start = env_->GetNumberOfNewWritableFileCalls();
  // this will trigger the flushes
-  for (size_t i = 0; i <= 4; ++i) {
-    ASSERT_OK(Flush(i));
-  }
+  ASSERT_OK(db_->Write(WriteOptions(), nullptr));

  for (int i = 0; i < 4; ++i) {
    dbfull()->TEST_WaitForFlushMemTable(handles_[i]);
@@ -18,7 +18,7 @@

 namespace rocksdb {

-uint64_t TotalFileSize(const std::vector<FileMetaData*>& files) {
+static uint64_t TotalFileSize(const std::vector<FileMetaData*>& files) {
  uint64_t sum = 0;
  for (size_t i = 0; i < files.size() && files[i]; i++) {
    sum += files[i]->fd.GetFileSize();
@@ -26,14 +26,14 @@ uint64_t TotalFileSize(const std::vector<FileMetaData*>& files) {
  return sum;
 }

-Compaction::Compaction(Version* input_version, int start_level, int out_level,
+Compaction::Compaction(Version* input_version, int level, int out_level,
                       uint64_t target_file_size,
                       uint64_t max_grandparent_overlap_bytes,
                       uint32_t output_path_id,
                       CompressionType output_compression, bool seek_compaction,
                       bool deletion_compaction)
-    : start_level_(start_level),
-      output_level_(out_level),
+    : level_(level),
+      out_level_(out_level),
      max_output_file_size_(target_file_size),
      max_grandparent_overlap_bytes_(max_grandparent_overlap_bytes),
      input_version_(input_version),
@@ -61,12 +61,6 @@ Compaction::Compaction(Version* input_version, int start_level, int out_level,
  for (int i = 0; i < number_levels_; i++) {
    level_ptrs_[i] = 0;
  }
-  int num_levels = output_level_ - start_level_ + 1;
-  input_levels_.resize(num_levels);
-  inputs_.resize(num_levels);
-  for (int i = 0; i < num_levels; ++i) {
-    inputs_[i].level = start_level_ + i;
-  }
 }

 Compaction::~Compaction() {
@@ -81,50 +75,43 @@ Compaction::~Compaction() {
  }
 }

-void Compaction::GenerateFileLevels() {
-  input_levels_.resize(num_input_levels());
-  for (int which = 0; which < num_input_levels(); which++) {
-    DoGenerateFileLevel(&input_levels_[which], inputs_[which].files, &arena_);
-  }
-}
-
 bool Compaction::IsTrivialMove() const {
  // Avoid a move if there is lots of overlapping grandparent data.
  // Otherwise, the move could create a parent file that will require
  // a very expensive merge later on.
-  // If start_level_== output_level_, the purpose is to force compaction
-  // filter to be applied to that level, and thus cannot be a trivia move.
-  return (start_level_ != output_level_ &&
-          num_input_levels() == 2 &&
+  // If level_== out_level_, the purpose is to force compaction filter to be
+  // applied to that level, and thus cannot be a trivia move.
+  return (level_ != out_level_ &&
          num_input_files(0) == 1 &&
          num_input_files(1) == 0 &&
          TotalFileSize(grandparents_) <= max_grandparent_overlap_bytes_);
 }

+bool Compaction::IsDeletionCompaction() const { return deletion_compaction_; }
+
 void Compaction::AddInputDeletions(VersionEdit* edit) {
-  for (int which = 0; which < num_input_levels(); which++) {
+  for (int which = 0; which < 2; which++) {
    for (size_t i = 0; i < inputs_[which].size(); i++) {
-      edit->DeleteFile(level(which), inputs_[which][i]->fd.GetNumber());
+      edit->DeleteFile(level_ + which, inputs_[which][i]->fd.GetNumber());
    }
  }
 }

-bool Compaction::KeyNotExistsBeyondOutputLevel(const Slice& user_key) {
+bool Compaction::IsBaseLevelForKey(const Slice& user_key) {
  assert(cfd_->options()->compaction_style != kCompactionStyleFIFO);
  if (cfd_->options()->compaction_style == kCompactionStyleUniversal) {
    return bottommost_level_;
  }
  // Maybe use binary search to find right entry instead of linear search?
  const Comparator* user_cmp = cfd_->user_comparator();
-  for (int lvl = output_level_ + 1; lvl < number_levels_; lvl++) {
+  for (int lvl = level_ + 2; lvl < number_levels_; lvl++) {
    const std::vector<FileMetaData*>& files = input_version_->files_[lvl];
    for (; level_ptrs_[lvl] < files.size(); ) {
      FileMetaData* f = files[level_ptrs_[lvl]];
      if (user_cmp->Compare(user_key, f->largest.user_key()) <= 0) {
        // We've advanced far enough
        if (user_cmp->Compare(user_key, f->smallest.user_key()) >= 0) {
-          // Key falls in this file's range, so definitely
-          // exists beyond output level
+          // Key falls in this file's range, so definitely not base level
          return false;
        }
        break;
@@ -162,18 +149,19 @@ bool Compaction::ShouldStopBefore(const Slice& internal_key) {
 }

 // Mark (or clear) each file that is being compacted
-void Compaction::MarkFilesBeingCompacted(bool mark_as_compacted) {
-  for (int i = 0; i < num_input_levels(); i++) {
+void Compaction::MarkFilesBeingCompacted(bool value) {
+  for (int i = 0; i < 2; i++) {
+    std::vector<FileMetaData*> v = inputs_[i];
    for (unsigned int j = 0; j < inputs_[i].size(); j++) {
-      assert(mark_as_compacted ? !inputs_[i][j]->being_compacted :
-                                  inputs_[i][j]->being_compacted);
-      inputs_[i][j]->being_compacted = mark_as_compacted;
+      assert(value ? !inputs_[i][j]->being_compacted :
+                      inputs_[i][j]->being_compacted);
+      inputs_[i][j]->being_compacted = value;
    }
  }
 }

 // Is this compaction producing files at the bottommost level?
-void Compaction::SetupBottomMostLevel(bool is_manual) {
+void Compaction::SetupBottomMostLevel(bool isManual) {
  assert(cfd_->options()->compaction_style != kCompactionStyleFIFO);
  if (cfd_->options()->compaction_style == kCompactionStyleUniversal) {
    // If universal compaction style is used and manual
@@ -182,14 +170,13 @@ void Compaction::SetupBottomMostLevel(bool is_manual) {
    // run. We can safely set bottommost_level_ = true.
    // If it is not manual compaction, then bottommost_level_
    // is already set when the Compaction was created.
-    if (is_manual) {
+    if (isManual) {
      bottommost_level_ = true;
    }
    return;
  }
  bottommost_level_ = true;
-  // checks whether there are files living beyond the output_level.
-  for (int i = output_level_ + 1; i < number_levels_; i++) {
+  for (int i = output_level() + 1; i < number_levels_; i++) {
    if (input_version_->NumLevelFiles(i) > 0) {
      bottommost_level_ = false;
      break;
@@ -215,7 +202,7 @@ void Compaction::ReleaseCompactionFiles(Status status) {
 }

 void Compaction::ResetNextCompactionIndex() {
-  input_version_->ResetNextCompactionIndex(start_level_);
+  input_version_->ResetNextCompactionIndex(level_);
 }

 namespace {
@@ -242,23 +229,24 @@ void Compaction::Summary(char* output, int len) {
  int write =
      snprintf(output, len, "Base version %" PRIu64
                            " Base level %d, seek compaction:%d, inputs: [",
-               input_version_->GetVersionNumber(),
-               start_level_, seek_compaction_);
+               input_version_->GetVersionNumber(), level_, seek_compaction_);
  if (write < 0 || write >= len) {
    return;
  }

-  for (int level = 0; level < num_input_levels(); ++level) {
-    if (level > 0) {
-      write += snprintf(output + write, len - write, "], [");
-      if (write < 0 || write >= len) {
-        return;
-      }
-    }
-    write += InputSummary(inputs_[level].files, output + write, len - write);
-    if (write < 0 || write >= len) {
-      return;
-    }
+  write += InputSummary(inputs_[0], output + write, len - write);
+  if (write < 0 || write >= len) {
+    return;
+  }
+
+  write += snprintf(output + write, len - write, "], [");
+  if (write < 0 || write >= len) {
+    return;
+  }
+
+  write += InputSummary(inputs_[1], output + write, len - write);
+  if (write < 0 || write >= len) {
+    return;
  }

  snprintf(output + write, len - write, "]");
@@ -271,10 +259,8 @@ uint64_t Compaction::OutputFilePreallocationSize() {
    preallocation_size =
        cfd_->compaction_picker()->MaxFileSizeForLevel(output_level());
  } else {
-    for (int level = 0; level < num_input_levels(); ++level) {
-      for (const auto& f : inputs_[level].files) {
-        preallocation_size += f->fd.GetFileSize();
-      }
+    for (const auto& f : inputs_[0]) {
+      preallocation_size += f->fd.GetFileSize();
    }
  }
  // Over-estimate slightly so we don't end up just barely crossing
@@ -8,90 +8,41 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #pragma once
-#include "util/arena.h"
-#include "util/autovector.h"
 #include "db/version_set.h"

 namespace rocksdb {

-// The structure that manages compaction input files associated
-// with the same physical level.
-struct CompactionInputFiles {
-  int level;
-  std::vector<FileMetaData*> files;
-  inline bool empty() const { return files.empty(); }
-  inline size_t size() const { return files.size(); }
-  inline void clear() { files.clear(); }
-  inline FileMetaData* operator[](int i) const { return files[i]; }
-};
-
 class Version;
 class ColumnFamilyData;

 // A Compaction encapsulates information about a compaction.
 class Compaction {
 public:
-  // No copying allowed
-  Compaction(const Compaction&) = delete;
-  void operator=(const Compaction&) = delete;
-
  ~Compaction();

-  // Returns the level associated to the specified compaction input level.
-  // If compaction_input_level is not specified, then input_level is set to 0.
-  int level(int compaction_input_level = 0) const {
-    return inputs_[compaction_input_level].level;
-  }
+  // Return the level that is being compacted.  Inputs from "level"
+  // will be merged.
+  int level() const { return level_; }

  // Outputs will go to this level
-  int output_level() const { return output_level_; }
-
-  // Returns the number of input levels in this compaction.
-  int num_input_levels() const { return inputs_.size(); }
+  int output_level() const { return out_level_; }

  // Return the object that holds the edits to the descriptor done
  // by this compaction.
-  VersionEdit* edit() const { return edit_; }
+  VersionEdit* edit() { return edit_; }

-  // Returns the number of input files associated to the specified
-  // compaction input level.
-  // The function will return 0 if when "compaction_input_level" < 0
-  // or "compaction_input_level" >= "num_input_levels()".
-  int num_input_files(size_t compaction_input_level) const {
-    if (compaction_input_level < inputs_.size()) {
-      return inputs_[compaction_input_level].size();
-    }
-    return 0;
-  }
+  // "which" must be either 0 or 1
+  int num_input_files(int which) const { return inputs_[which].size(); }

  // Returns input version of the compaction
  Version* input_version() const { return input_version_; }

-  // Returns the ColumnFamilyData associated with the compaction.
  ColumnFamilyData* column_family_data() const { return cfd_; }

-  // Returns the file meta data of the 'i'th input file at the
-  // specified compaction input level.
-  // REQUIREMENT: "compaction_input_level" must be >= 0 and
-  //              < "input_levels()"
-  FileMetaData* input(size_t compaction_input_level, int i) const {
-    assert(compaction_input_level < inputs_.size());
-    return inputs_[compaction_input_level][i];
-  }
+  // Return the ith input file at "level()+which" ("which" must be 0 or 1).
+  FileMetaData* input(int which, int i) const { return inputs_[which][i]; }

-  // Returns the list of file meta data of the specified compaction
-  // input level.
-  // REQUIREMENT: "compaction_input_level" must be >= 0 and
-  //              < "input_levels()"
-  std::vector<FileMetaData*>* const inputs(size_t compaction_input_level) {
-    assert(compaction_input_level < inputs_.size());
-    return &inputs_[compaction_input_level].files;
-  }
-
-  // Returns the FileLevel of the specified compaction input level.
-  FileLevel* input_levels(int compaction_input_level) {
-    return &input_levels_[compaction_input_level];
-  }
+  std::vector<FileMetaData*>* inputs(int which) { return &inputs_[which]; }

  // Maximum size of files to build during this compaction.
  uint64_t MaxOutputFileSize() const { return max_output_file_size_; }
@@ -102,25 +53,20 @@ class Compaction {
  // Whether need to write output file to second DB path.
  uint32_t GetOutputPathId() const { return output_path_id_; }

-  // Generate input_levels_ from inputs_
-  // Should be called when inputs_ is stable
-  void GenerateFileLevels();
-
-  // Is this a trivial compaction that can be implemented by just
+    // Is this a trivial compaction that can be implemented by just
  // moving a single input file to the next level (no merging or splitting)
  bool IsTrivialMove() const;

-  // If true, then the comaction can be done by simply deleting input files.
-  bool IsDeletionCompaction() const {
-    return deletion_compaction_;
-  }
+  // If true, just delete all files in inputs_[0]
+  bool IsDeletionCompaction() const;

  // Add all inputs to this compaction as delete operations to *edit.
  void AddInputDeletions(VersionEdit* edit);

-  // Returns true if the available information we have guarantees that
-  // the input "user_key" does not exist in any level beyond "output_level()".
-  bool KeyNotExistsBeyondOutputLevel(const Slice& user_key);
+  // Returns true if the information we have available guarantees that
+  // the compaction is producing data in "level+1" for which no data exists
+  // in levels greater than "level+1".
+  bool IsBaseLevelForKey(const Slice& user_key);

  // Returns true iff we should stop building the current output
  // before processing "internal_key".
@@ -134,9 +80,6 @@ class Compaction {
  // Delete this compaction from the list of running compactions.
  void ReleaseCompactionFiles(Status status);

-  // Returns the summary of the compaction in "output" with maximum "len"
-  // in bytes.  The caller is responsible for the memory management of
-  // "output".
  void Summary(char* output, int len);

  // Return the score that was used to pick this compaction run.
@@ -151,9 +94,9 @@ class Compaction {
  // Was this compaction triggered manually by the client?
  bool IsManualCompaction() { return is_manual_compaction_; }

-  // Returns the size in bytes that the output file should be preallocated to.
+  // Returns a number of byte that the output file should be preallocated to
  // In level compaction, that is max_file_size_. In universal compaction, that
-  // is the sum of all input file sizes.
+  // is the sum of all input file sizes
  uint64_t OutputFilePreallocationSize();

 private:
@@ -162,45 +105,39 @@ class Compaction {
  friend class FIFOCompactionPicker;
  friend class LevelCompactionPicker;

-  Compaction(Version* input_version, int start_level, int out_level,
+  Compaction(Version* input_version, int level, int out_level,
             uint64_t target_file_size, uint64_t max_grandparent_overlap_bytes,
             uint32_t output_path_id, CompressionType output_compression,
             bool seek_compaction = false, bool deletion_compaction = false);

-  const int start_level_;    // the lowest level to be compacted
-  const int output_level_;  // levels to which output files are stored
+  int level_;
+  int out_level_; // levels to which output files are stored
  uint64_t max_output_file_size_;
  uint64_t max_grandparent_overlap_bytes_;
  Version* input_version_;
  VersionEdit* edit_;
  int number_levels_;
  ColumnFamilyData* cfd_;
-  Arena arena_;          // Arena used to allocate space for file_levels_

  uint32_t output_path_id_;
  CompressionType output_compression_;
  bool seek_compaction_;
-  // If true, then the comaction can be done by simply deleting input files.
+  // if true, just delete files in inputs_[0]
  bool deletion_compaction_;

-  // Compaction input files organized by level.
-  autovector<CompactionInputFiles> inputs_;
-
-  // A copy of inputs_, organized more closely in memory
-  autovector<FileLevel, 2> input_levels_;
+  // Each compaction reads inputs from "level_" and "level_+1"
+  std::vector<FileMetaData*> inputs_[2];      // The two sets of inputs

  // State used to check for number of of overlapping grandparent files
-  // (grandparent == "output_level_ + 1")
-  // This vector is updated by Version::GetOverlappingInputs().
+  // (parent == level_ + 1, grandparent == level_ + 2)
  std::vector<FileMetaData*> grandparents_;
-  size_t grandparent_index_;   // Index in grandparent_starts_
-  bool seen_key_;              // Some output key has been seen
+  size_t grandparent_index_;  // Index in grandparent_starts_
+  bool seen_key_;             // Some output key has been seen
  uint64_t overlapped_bytes_;  // Bytes of overlap between current output
-                               // and grandparent files
-  int base_index_;    // index of the file in files_[start_level_]
-  int parent_index_;  // index of some file with same range in
-                      // files_[start_level_+1]
-  double score_;      // score that was used to pick this compaction.
+                              // and grandparent files
+  int base_index_;   // index of the file in files_[level_]
+  int parent_index_; // index of some file with same range in files_[level_+1]
+  double score_;     // score that was used to pick this compaction.

  // Is this compaction creating a file in the bottom most level?
  bool bottommost_level_;
@@ -210,28 +147,21 @@ class Compaction {
  // Is this compaction requested by the client?
  bool is_manual_compaction_;

-  // "level_ptrs_" holds indices into "input_version_->levels_", where each
-  // index remembers which file of an associated level we are currently used
-  // to check KeyNotExistsBeyondOutputLevel() for deletion operation.
-  // As it is for checking KeyNotExistsBeyondOutputLevel(), it only
-  // records indices for all levels beyond "output_level_".
+  // level_ptrs_ holds indices into input_version_->levels_: our state
+  // is that we are positioned at one of the file ranges for each
+  // higher level than the ones involved in this compaction (i.e. for
+  // all L >= level_ + 2).
  std::vector<size_t> level_ptrs_;

  // mark (or clear) all files that are being compacted
-  void MarkFilesBeingCompacted(bool mark_as_compacted);
+  void MarkFilesBeingCompacted(bool);

-  // Initialize whether the compaction is producing files at the
-  // bottommost level.
-  //
-  // @see BottomMostLevel()
-  void SetupBottomMostLevel(bool is_manual);
+  // Initialize whether compaction producing files at the bottommost level
+  void SetupBottomMostLevel(bool isManual);

  // In case of compaction error, reset the nextIndex that is used
  // to pick up the next file to be compacted from files_by_size_
  void ResetNextCompactionIndex();
 };

-// Utility function
-extern uint64_t TotalFileSize(const std::vector<FileMetaData*>& files);
-
 }  // namespace rocksdb
@@ -18,14 +18,6 @@

 namespace rocksdb {

-uint64_t TotalCompensatedFileSize(const std::vector<FileMetaData*>& files) {
-  uint64_t sum = 0;
-  for (size_t i = 0; i < files.size() && files[i]; i++) {
-    sum += files[i]->compensated_file_size;
-  }
-  return sum;
-}
-
 namespace {
 // Determine compression type, based on user options, level of the output
 // file and whether compression is disabled.
@@ -53,6 +45,14 @@ CompressionType GetCompressionType(const Options& options, int level,
  }
 }

+uint64_t TotalCompensatedFileSize(const std::vector<FileMetaData*>& files) {
+  uint64_t sum = 0;
+  for (size_t i = 0; i < files.size() && files[i]; i++) {
+    sum += files[i]->compensated_file_size;
+  }
+  return sum;
+}
+
 // Multiple two operands. If they overflow, return op1.
 uint64_t MultiplyCheckOverflow(uint64_t op1, int op2) {
  if (op1 == 0) {
@@ -173,12 +173,9 @@ void CompactionPicker::GetRange(const std::vector<FileMetaData*>& inputs1,
 }

 bool CompactionPicker::ExpandWhileOverlapping(Compaction* c) {
-  assert(c != nullptr);
  // If inputs are empty then there is nothing to expand.
-  if (c->inputs_[0].empty()) {
-    assert(c->inputs_[1].empty());
-    // This isn't good compaction
-    return false;
+  if (!c || c->inputs_[0].empty()) {
+    return true;
  }

  // GetOverlappingInputs will always do the right thing for level-0.
@@ -197,15 +194,14 @@ bool CompactionPicker::ExpandWhileOverlapping(Compaction* c) {
  size_t old_size;
  do {
    old_size = c->inputs_[0].size();
-    GetRange(c->inputs_[0].files, &smallest, &largest);
+    GetRange(c->inputs_[0], &smallest, &largest);
    c->inputs_[0].clear();
    c->input_version_->GetOverlappingInputs(
-        level, &smallest, &largest, &c->inputs_[0].files,
-        hint_index, &hint_index);
+        level, &smallest, &largest, &c->inputs_[0], hint_index, &hint_index);
  } while(c->inputs_[0].size() > old_size);

  // Get the new range
-  GetRange(c->inputs_[0].files, &smallest, &largest);
+  GetRange(c->inputs_[0], &smallest, &largest);

  // If, after the expansion, there are files that are already under
  // compaction, then we must drop/cancel this compaction.
@@ -215,7 +211,7 @@ bool CompactionPicker::ExpandWhileOverlapping(Compaction* c) {
        "[%s] ExpandWhileOverlapping() failure because zero input files",
        c->column_family_data()->GetName().c_str());
  }
-  if (c->inputs_[0].empty() || FilesInCompaction(c->inputs_[0].files) ||
+  if (c->inputs_[0].empty() || FilesInCompaction(c->inputs_[0]) ||
      (c->level() != c->output_level() &&
       ParentRangeInCompaction(c->input_version_, &smallest, &largest, level,
                               &parent_index))) {
@@ -271,17 +267,16 @@ void CompactionPicker::SetupOtherInputs(Compaction* c) {
  InternalKey smallest, largest;

  // Get the range one last time.
-  GetRange(c->inputs_[0].files, &smallest, &largest);
+  GetRange(c->inputs_[0], &smallest, &largest);

  // Populate the set of next-level files (inputs_[1]) to include in compaction
-  c->input_version_->GetOverlappingInputs(
-      level + 1, &smallest, &largest,
-      &c->inputs_[1].files, c->parent_index_,
-      &c->parent_index_);
+  c->input_version_->GetOverlappingInputs(level + 1, &smallest, &largest,
+                                          &c->inputs_[1], c->parent_index_,
+                                          &c->parent_index_);

  // Get entire range covered by compaction
  InternalKey all_start, all_limit;
-  GetRange(c->inputs_[0].files, c->inputs_[1].files, &all_start, &all_limit);
+  GetRange(c->inputs_[0], c->inputs_[1], &all_start, &all_limit);

  // See if we can further grow the number of inputs in "level" without
  // changing the number of "level+1" files we pick up. We also choose NOT
@@ -292,8 +287,8 @@ void CompactionPicker::SetupOtherInputs(Compaction* c) {
    std::vector<FileMetaData*> expanded0;
    c->input_version_->GetOverlappingInputs(
        level, &all_start, &all_limit, &expanded0, c->base_index_, nullptr);
-    const uint64_t inputs0_size = TotalCompensatedFileSize(c->inputs_[0].files);
-    const uint64_t inputs1_size = TotalCompensatedFileSize(c->inputs_[1].files);
+    const uint64_t inputs0_size = TotalCompensatedFileSize(c->inputs_[0]);
+    const uint64_t inputs1_size = TotalCompensatedFileSize(c->inputs_[1]);
    const uint64_t expanded0_size = TotalCompensatedFileSize(expanded0);
    uint64_t limit = ExpandedCompactionByteSizeLimit(level);
    if (expanded0.size() > c->inputs_[0].size() &&
@@ -317,10 +312,9 @@ void CompactionPicker::SetupOtherInputs(Compaction* c) {
            inputs1_size);
        smallest = new_start;
        largest = new_limit;
-        c->inputs_[0].files = expanded0;
-        c->inputs_[1].files = expanded1;
-        GetRange(c->inputs_[0].files, c->inputs_[1].files,
-                 &all_start, &all_limit);
+        c->inputs_[0] = expanded0;
+        c->inputs_[1] = expanded1;
+        GetRange(c->inputs_[0], c->inputs_[1], &all_start, &all_limit);
      }
    }
  }
@@ -333,9 +327,9 @@ void CompactionPicker::SetupOtherInputs(Compaction* c) {
  }
 }

+
 Compaction* CompactionPicker::CompactRange(Version* version, int input_level,
                                           int output_level,
-                                           uint32_t output_path_id,
                                           const InternalKey* begin,
                                           const InternalKey* end,
                                           InternalKey** compaction_end) {
@@ -375,13 +369,12 @@ Compaction* CompactionPicker::CompactRange(Version* version, int input_level,
      }
    }
  }
-  assert(output_path_id < static_cast<uint32_t>(options_->db_paths.size()));
-  Compaction* c = new Compaction(
-      version, input_level, output_level, MaxFileSizeForLevel(output_level),
-      MaxGrandParentOverlapBytes(input_level), output_path_id,
-      GetCompressionType(*options_, output_level));
+  Compaction* c = new Compaction(version, input_level, output_level,
+                                 MaxFileSizeForLevel(output_level),
+                                 MaxGrandParentOverlapBytes(input_level), 0,
+                                 GetCompressionType(*options_, output_level));

-  c->inputs_[0].files = inputs;
+  c->inputs_[0] = inputs;
  if (ExpandWhileOverlapping(c) == false) {
    delete c;
    Log(options_->info_log,
@@ -430,7 +423,7 @@ Compaction* LevelCompactionPicker::PickCompaction(Version* version,
    level = version->compaction_level_[i];
    if ((version->compaction_score_[i] >= 1)) {
      c = PickCompactionBySize(version, level, version->compaction_score_[i]);
-      if (c == nullptr || ExpandWhileOverlapping(c) == false) {
+      if (ExpandWhileOverlapping(c) == false) {
        delete c;
        c = nullptr;
      } else {
@@ -448,18 +441,18 @@ Compaction* LevelCompactionPicker::PickCompaction(Version* version,
  if (level == 0) {
    assert(compactions_in_progress_[0].empty());
    InternalKey smallest, largest;
-    GetRange(c->inputs_[0].files, &smallest, &largest);
+    GetRange(c->inputs_[0], &smallest, &largest);
    // Note that the next call will discard the file we placed in
    // c->inputs_[0] earlier and replace it with an overlapping set
    // which will include the picked file.
    c->inputs_[0].clear();
    c->input_version_->GetOverlappingInputs(0, &smallest, &largest,
-                                            &c->inputs_[0].files);
+                                            &c->inputs_[0]);

    // If we include more L0 files in the same compaction run it can
    // cause the 'smallest' and 'largest' key to get extended to a
    // larger range. So, re-invoke GetRange to get the new key range
-    GetRange(c->inputs_[0].files, &smallest, &largest);
+    GetRange(c->inputs_[0], &smallest, &largest);
    if (ParentRangeInCompaction(c->input_version_, &smallest, &largest, level,
                                &c->parent_index_)) {
      delete c;
@@ -540,7 +533,7 @@ Compaction* LevelCompactionPicker::PickCompactionBySize(Version* version,
                                level, &parent_index)) {
      continue;
    }
-    c->inputs_[0].files.push_back(f);
+    c->inputs_[0].push_back(f);
    c->base_index_ = index;
    c->parent_index_ = parent_index;
    break;
@@ -622,11 +615,11 @@ Compaction* UniversalCompactionPicker::PickCompaction(Version* version,

  // Is the earliest file part of this compaction?
  FileMetaData* last_file = c->input_version_->files_[level].back();
-  c->bottommost_level_ = c->inputs_[0].files.back() == last_file;
+  c->bottommost_level_ = c->inputs_[0].back() == last_file;

  // update statistics
-  MeasureTime(options_->statistics.get(),
-              NUM_FILES_IN_SINGLE_COMPACTION, c->inputs_[0].size());
+  MeasureTime(options_->statistics.get(), NUM_FILES_IN_SINGLE_COMPACTION,
+              c->inputs_[0].size());

  // mark all the files that are being compacted
  c->MarkFilesBeingCompacted(true);
@@ -642,37 +635,6 @@ Compaction* UniversalCompactionPicker::PickCompaction(Version* version,
  return c;
 }

-uint32_t UniversalCompactionPicker::GetPathId(const Options& options,
-                                              uint64_t file_size) {
-  // Two conditions need to be satisfied:
-  // (1) the target path needs to be able to hold the file's size
-  // (2) Total size left in this and previous paths need to be not
-  //     smaller than expected future file size before this new file is
-  //     compacted, which is estimated based on size_ratio.
-  // For example, if now we are compacting files of size (1, 1, 2, 4, 8),
-  // we will make sure the target file, probably with size of 16, will be
-  // placed in a path so that eventually when new files are generated and
-  // compacted to (1, 1, 2, 4, 8, 16), all those files can be stored in or
-  // before the path we chose.
-  //
-  // TODO(sdong): now the case of multiple column families is not
-  // considered in this algorithm. So the target size can be violated in
-  // that case. We need to improve it.
-  uint64_t accumulated_size = 0;
-  uint64_t future_size =
-      file_size * (100 - options.compaction_options_universal.size_ratio) / 100;
-  uint32_t p = 0;
-  for (; p < options.db_paths.size() - 1; p++) {
-    uint64_t target_size = options.db_paths[p].target_size;
-    if (target_size > file_size &&
-        accumulated_size + (target_size - file_size) > future_size) {
-      return p;
-    }
-    accumulated_size += target_size;
-  }
-  return p;
-}
-
 //
 // Consider compaction files based on their size differences with
 // the next file in time order.
@@ -723,11 +685,10 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalReadAmp(
    // first candidate to be compacted.
    uint64_t candidate_size =  f != nullptr? f->compensated_file_size : 0;
    if (f != nullptr) {
-      char file_num_buf[kFormatFileNumberBufSize];
-      FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId(), file_num_buf,
-                       sizeof(file_num_buf));
-      LogToBuffer(log_buffer, "[%s] Universal: Possible candidate file %s[%d].",
-                  version->cfd_->GetName().c_str(), file_num_buf, loop);
+      LogToBuffer(
+          log_buffer, "[%s] Universal: Possible candidate file %s[%d].",
+          version->cfd_->GetName().c_str(),
+          FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId()).c_str(), loop);
    }

    // Check if the suceeding files need compaction.
@@ -804,29 +765,20 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalReadAmp(
      }
    }
  }
-
-  uint64_t estimated_total_size = 0;
-  for (unsigned int i = 0; i < first_index_after; i++) {
-    estimated_total_size += files[i]->fd.GetFileSize();
-  }
-  uint32_t path_id = GetPathId(*options_, estimated_total_size);
-
  Compaction* c = new Compaction(
-      version, level, level, MaxFileSizeForLevel(level), LLONG_MAX, path_id,
+      version, level, level, MaxFileSizeForLevel(level), LLONG_MAX, 0,
      GetCompressionType(*options_, level, enable_compression));
  c->score_ = score;

  for (unsigned int i = start_index; i < first_index_after; i++) {
    FileMetaData* f = c->input_version_->files_[level][i];
-    c->inputs_[0].files.push_back(f);
-    char file_num_buf[kFormatFileNumberBufSize];
-    FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId(), file_num_buf,
-                     sizeof(file_num_buf));
+    c->inputs_[0].push_back(f);
    LogToBuffer(log_buffer,
                "[%s] Universal: Picking file %s[%d] "
                "with size %" PRIu64 " (compensated size %" PRIu64 ")\n",
-                version->cfd_->GetName().c_str(), file_num_buf, i,
-                f->fd.GetFileSize(), f->compensated_file_size);
+                version->cfd_->GetName().c_str(),
+                FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId()).c_str(),
+                i, f->fd.GetFileSize(), f->compensated_file_size);
  }
  return c;
 }
@@ -860,35 +812,29 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalSizeAmp(
      start_index = loop;         // Consider this as the first candidate.
      break;
    }
-    char file_num_buf[kFormatFileNumberBufSize];
-    FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId(), file_num_buf,
-                     sizeof(file_num_buf));
    LogToBuffer(log_buffer, "[%s] Universal: skipping file %s[%d] compacted %s",
-                version->cfd_->GetName().c_str(), file_num_buf, loop,
-                " cannot be a candidate to reduce size amp.\n");
+                version->cfd_->GetName().c_str(),
+                FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId()).c_str(),
+                loop, " cannot be a candidate to reduce size amp.\n");
    f = nullptr;
  }
  if (f == nullptr) {
    return nullptr;             // no candidate files
  }

-  char file_num_buf[kFormatFileNumberBufSize];
-  FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId(), file_num_buf,
-                   sizeof(file_num_buf));
  LogToBuffer(log_buffer, "[%s] Universal: First candidate file %s[%d] %s",
-              version->cfd_->GetName().c_str(), file_num_buf, start_index,
-              " to reduce size amp.\n");
+              version->cfd_->GetName().c_str(),
+              FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId()).c_str(),
+              start_index, " to reduce size amp.\n");

  // keep adding up all the remaining files
  for (unsigned int loop = start_index; loop < files.size() - 1; loop++) {
    f = files[loop];
    if (f->being_compacted) {
-      char file_num_buf[kFormatFileNumberBufSize];
-      FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId(), file_num_buf,
-                       sizeof(file_num_buf));
      LogToBuffer(
          log_buffer, "[%s] Universal: Possible candidate file %s[%d] %s.",
-          version->cfd_->GetName().c_str(), file_num_buf, loop,
+          version->cfd_->GetName().c_str(),
+          FormatFileNumber(f->fd.GetNumber(), f->fd.GetPathId()).c_str(), loop,
          " is already being compacted. No size amp reduction possible.\n");
      return nullptr;
    }
@@ -919,22 +865,15 @@ Compaction* UniversalCompactionPicker::PickCompactionUniversalSizeAmp(
  }
  assert(start_index >= 0 && start_index < files.size() - 1);

-  // Estimate total file size
-  uint64_t estimated_total_size = 0;
-  for (unsigned int loop = start_index; loop < files.size(); loop++) {
-    estimated_total_size += files[loop]->fd.GetFileSize();
-  }
-  uint32_t path_id = GetPathId(*options_, estimated_total_size);
-
  // create a compaction request
  // We always compact all the files, so always compress.
  Compaction* c =
      new Compaction(version, level, level, MaxFileSizeForLevel(level),
-                     LLONG_MAX, path_id, GetCompressionType(*options_, level));
+                     LLONG_MAX, 0, GetCompressionType(*options_, level));
  c->score_ = score;
  for (unsigned int loop = start_index; loop < files.size(); loop++) {
    f = c->input_version_->files_[level][loop];
-    c->inputs_[0].files.push_back(f);
+    c->inputs_[0].push_back(f);
    LogToBuffer(log_buffer,
        "[%s] Universal: size amp picking file %" PRIu64 "[%d] "
        "with size %" PRIu64 " (compensated size %" PRIu64 ")",
@@ -979,7 +918,7 @@ Compaction* FIFOCompactionPicker::PickCompaction(Version* version,
       ritr != version->files_[0].rend(); ++ritr) {
    auto f = *ritr;
    total_size -= f->compensated_file_size;
-    c->inputs_[0].files.push_back(f);
+    c->inputs_[0].push_back(f);
    char tmp_fsize[16];
    AppendHumanBytes(f->fd.GetFileSize(), tmp_fsize, sizeof(tmp_fsize));
    LogToBuffer(log_buffer, "[%s] FIFO compaction: picking file %" PRIu64
@@ -996,19 +935,17 @@ Compaction* FIFOCompactionPicker::PickCompaction(Version* version,
  return c;
 }

-Compaction* FIFOCompactionPicker::CompactRange(
-    Version* version, int input_level, int output_level,
-    uint32_t output_path_id, const InternalKey* begin, const InternalKey* end,
-    InternalKey** compaction_end) {
+Compaction* FIFOCompactionPicker::CompactRange(Version* version,
+                                               int input_level,
+                                               int output_level,
+                                               const InternalKey* begin,
+                                               const InternalKey* end,
+                                               InternalKey** compaction_end) {
  assert(input_level == 0);
  assert(output_level == 0);
  *compaction_end = nullptr;
  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, options_->info_log.get());
-  Compaction* c = PickCompaction(version, &log_buffer);
-  if (c != nullptr) {
-    assert(output_path_id < static_cast<uint32_t>(options_->db_paths.size()));
-    c->output_path_id_ = output_path_id;
-  }
+  auto c = PickCompaction(version, &log_buffer);
  log_buffer.FlushBufferToLog();
  return c;
 }
@@ -48,15 +48,10 @@ class CompactionPicker {
  // Client is responsible for compaction_end storage -- when called,
  // *compaction_end should point to valid InternalKey!
  virtual Compaction* CompactRange(Version* version, int input_level,
-                                   int output_level, uint32_t output_path_id,
-                                   const InternalKey* begin,
+                                   int output_level, const InternalKey* begin,
                                   const InternalKey* end,
                                   InternalKey** compaction_end);

-  // Given the current number of levels, returns the lowest allowed level
-  // for compaction input.
-  virtual int MaxInputLevel(int current_num_levels) const = 0;
-
  // Free up the files that participated in a compaction
  void ReleaseCompactionFiles(Compaction* c, Status status);

@@ -140,11 +135,6 @@ class UniversalCompactionPicker : public CompactionPicker {
  virtual Compaction* PickCompaction(Version* version,
                                     LogBuffer* log_buffer) override;

-  // The maxinum allowed input level.  Always return 0.
-  virtual int MaxInputLevel(int current_num_levels) const override {
-    return 0;
-  }
-
 private:
  // Pick Universal compaction to limit read amplification
  Compaction* PickCompactionUniversalReadAmp(Version* version, double score,
@@ -155,10 +145,6 @@ class UniversalCompactionPicker : public CompactionPicker {
  // Pick Universal compaction to limit space amplification.
  Compaction* PickCompactionUniversalSizeAmp(Version* version, double score,
                                             LogBuffer* log_buffer);
-
-  // Pick a path ID to place a newly generated file, with its estimated file
-  // size.
-  static uint32_t GetPathId(const Options& options, uint64_t file_size);
 };

 class LevelCompactionPicker : public CompactionPicker {
@@ -169,12 +155,6 @@ class LevelCompactionPicker : public CompactionPicker {
  virtual Compaction* PickCompaction(Version* version,
                                     LogBuffer* log_buffer) override;

-  // Returns current_num_levels - 2, meaning the last level cannot be
-  // compaction input level.
-  virtual int MaxInputLevel(int current_num_levels) const override {
-    return current_num_levels - 2;
-  }
-
 private:
  // For the specfied level, pick a compaction.
  // Returns nullptr if there is no compaction to be done.
@@ -193,18 +173,9 @@ class FIFOCompactionPicker : public CompactionPicker {
                                     LogBuffer* log_buffer) override;

  virtual Compaction* CompactRange(Version* version, int input_level,
-                                   int output_level, uint32_t output_path_id,
-                                   const InternalKey* begin,
+                                   int output_level, const InternalKey* begin,
                                   const InternalKey* end,
                                   InternalKey** compaction_end) override;
-
-  // The maxinum allowed input level.  Always return 0.
-  virtual int MaxInputLevel(int current_num_levels) const override {
-    return 0;
-  }
 };

-// Utility function
-extern uint64_t TotalCompensatedFileSize(const std::vector<FileMetaData*>& files);
-
 }  // namespace rocksdb
@@ -45,9 +45,7 @@ class CorruptionTest {

    db_ = nullptr;
    options_.create_if_missing = true;
-    BlockBasedTableOptions table_options;
-    table_options.block_size_deviation = 0;  // make unit test pass for now
-    options_.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    options_.block_size_deviation = 0; // make unit test pass for now
    Reopen();
    options_.create_if_missing = false;
  }
@@ -62,11 +60,9 @@ class CorruptionTest {
    db_ = nullptr;
    Options opt = (options ? *options : options_);
    opt.env = &env_;
+    opt.block_cache = tiny_cache_;
+    opt.block_size_deviation = 0;
    opt.arena_block_size = 4096;
-    BlockBasedTableOptions table_options;
-    table_options.block_cache = tiny_cache_;
-    table_options.block_size_deviation = 0;
-    opt.table_factory.reset(NewBlockBasedTableFactory(table_options));
    return DB::Open(opt, dbname_, &db_);
  }

@@ -1,321 +0,0 @@
-//  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.
-
-#include "db/db_impl.h"
-#include "rocksdb/db.h"
-#include "rocksdb/env.h"
-#include "table/meta_blocks.h"
-#include "table/cuckoo_table_factory.h"
-#include "table/cuckoo_table_reader.h"
-#include "util/testharness.h"
-#include "util/testutil.h"
-
-namespace rocksdb {
-
-class CuckooTableDBTest {
- private:
-  std::string dbname_;
-  Env* env_;
-  DB* db_;
-
- public:
-  CuckooTableDBTest() : env_(Env::Default()) {
-    dbname_ = test::TmpDir() + "/cuckoo_table_db_test";
-    ASSERT_OK(DestroyDB(dbname_, Options()));
-    db_ = nullptr;
-    Reopen();
-  }
-
-  ~CuckooTableDBTest() {
-    delete db_;
-    ASSERT_OK(DestroyDB(dbname_, Options()));
-  }
-
-  Options CurrentOptions() {
-    Options options;
-    options.table_factory.reset(NewCuckooTableFactory());
-    options.memtable_factory.reset(NewHashLinkListRepFactory(4, 0, 3, true));
-    options.allow_mmap_reads = true;
-    options.create_if_missing = true;
-    options.max_mem_compaction_level = 0;
-    return options;
-  }
-
-  DBImpl* dbfull() {
-    return reinterpret_cast<DBImpl*>(db_);
-  }
-
-  // The following util methods are copied from plain_table_db_test.
-  void Reopen(Options* options = nullptr) {
-    delete db_;
-    db_ = nullptr;
-    Options opts;
-    if (options != nullptr) {
-      opts = *options;
-    } else {
-      opts = CurrentOptions();
-      opts.create_if_missing = true;
-    }
-    ASSERT_OK(DB::Open(opts, dbname_, &db_));
-  }
-
-  Status Put(const Slice& k, const Slice& v) {
-    return db_->Put(WriteOptions(), k, v);
-  }
-
-  Status Delete(const std::string& k) {
-    return db_->Delete(WriteOptions(), k);
-  }
-
-  std::string Get(const std::string& k) {
-    ReadOptions options;
-    std::string result;
-    Status s = db_->Get(options, k, &result);
-    if (s.IsNotFound()) {
-      result = "NOT_FOUND";
-    } else if (!s.ok()) {
-      result = s.ToString();
-    }
-    return result;
-  }
-
-  int NumTableFilesAtLevel(int level) {
-    std::string property;
-    ASSERT_TRUE(
-        db_->GetProperty("rocksdb.num-files-at-level" + NumberToString(level),
-                         &property));
-    return atoi(property.c_str());
-  }
-
-  // Return spread of files per level
-  std::string FilesPerLevel() {
-    std::string result;
-    int last_non_zero_offset = 0;
-    for (int level = 0; level < db_->NumberLevels(); level++) {
-      int f = NumTableFilesAtLevel(level);
-      char buf[100];
-      snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
-      result += buf;
-      if (f > 0) {
-        last_non_zero_offset = result.size();
-      }
-    }
-    result.resize(last_non_zero_offset);
-    return result;
-  }
-};
-
-TEST(CuckooTableDBTest, Flush) {
-  // Try with empty DB first.
-  ASSERT_TRUE(dbfull() != nullptr);
-  ASSERT_EQ("NOT_FOUND", Get("key2"));
-
-  // Add some values to db.
-  Options options = CurrentOptions();
-  Reopen(&options);
-
-  ASSERT_OK(Put("key1", "v1"));
-  ASSERT_OK(Put("key2", "v2"));
-  ASSERT_OK(Put("key3", "v3"));
-  dbfull()->TEST_FlushMemTable();
-
-  TablePropertiesCollection ptc;
-  reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc);
-  ASSERT_EQ(1U, ptc.size());
-  ASSERT_EQ(3U, ptc.begin()->second->num_entries);
-  ASSERT_EQ("1", FilesPerLevel());
-
-  ASSERT_EQ("v1", Get("key1"));
-  ASSERT_EQ("v2", Get("key2"));
-  ASSERT_EQ("v3", Get("key3"));
-  ASSERT_EQ("NOT_FOUND", Get("key4"));
-
-  // Now add more keys and flush.
-  ASSERT_OK(Put("key4", "v4"));
-  ASSERT_OK(Put("key5", "v5"));
-  ASSERT_OK(Put("key6", "v6"));
-  dbfull()->TEST_FlushMemTable();
-
-  reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc);
-  ASSERT_EQ(2U, ptc.size());
-  auto row = ptc.begin();
-  ASSERT_EQ(3U, row->second->num_entries);
-  ASSERT_EQ(3U, (++row)->second->num_entries);
-  ASSERT_EQ("2", FilesPerLevel());
-  ASSERT_EQ("v1", Get("key1"));
-  ASSERT_EQ("v2", Get("key2"));
-  ASSERT_EQ("v3", Get("key3"));
-  ASSERT_EQ("v4", Get("key4"));
-  ASSERT_EQ("v5", Get("key5"));
-  ASSERT_EQ("v6", Get("key6"));
-
-  ASSERT_OK(Delete("key6"));
-  ASSERT_OK(Delete("key5"));
-  ASSERT_OK(Delete("key4"));
-  dbfull()->TEST_FlushMemTable();
-  reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc);
-  ASSERT_EQ(3U, ptc.size());
-  row = ptc.begin();
-  ASSERT_EQ(3U, row->second->num_entries);
-  ASSERT_EQ(3U, (++row)->second->num_entries);
-  ASSERT_EQ(3U, (++row)->second->num_entries);
-  ASSERT_EQ("3", FilesPerLevel());
-  ASSERT_EQ("v1", Get("key1"));
-  ASSERT_EQ("v2", Get("key2"));
-  ASSERT_EQ("v3", Get("key3"));
-  ASSERT_EQ("NOT_FOUND", Get("key4"));
-  ASSERT_EQ("NOT_FOUND", Get("key5"));
-  ASSERT_EQ("NOT_FOUND", Get("key6"));
-}
-
-TEST(CuckooTableDBTest, FlushWithDuplicateKeys) {
-  Options options = CurrentOptions();
-  Reopen(&options);
-  ASSERT_OK(Put("key1", "v1"));
-  ASSERT_OK(Put("key2", "v2"));
-  ASSERT_OK(Put("key1", "v3"));  // Duplicate
-  dbfull()->TEST_FlushMemTable();
-
-  TablePropertiesCollection ptc;
-  reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc);
-  ASSERT_EQ(1U, ptc.size());
-  ASSERT_EQ(2U, ptc.begin()->second->num_entries);
-  ASSERT_EQ("1", FilesPerLevel());
-  ASSERT_EQ("v3", Get("key1"));
-  ASSERT_EQ("v2", Get("key2"));
-}
-
-namespace {
-static std::string Key(int i) {
-  char buf[100];
-  snprintf(buf, sizeof(buf), "key_______%06d", i);
-  return std::string(buf);
-}
-static std::string Uint64Key(uint64_t i) {
-  std::string str;
-  str.resize(8);
-  memcpy(&str[0], static_cast<void*>(&i), 8);
-  return str;
-}
-}  // namespace.
-
-TEST(CuckooTableDBTest, Uint64Comparator) {
-  Options options = CurrentOptions();
-  options.comparator = test::Uint64Comparator();
-  Reopen(&options);
-
-  ASSERT_OK(Put(Uint64Key(1), "v1"));
-  ASSERT_OK(Put(Uint64Key(2), "v2"));
-  ASSERT_OK(Put(Uint64Key(3), "v3"));
-  dbfull()->TEST_FlushMemTable();
-
-  ASSERT_EQ("v1", Get(Uint64Key(1)));
-  ASSERT_EQ("v2", Get(Uint64Key(2)));
-  ASSERT_EQ("v3", Get(Uint64Key(3)));
-  ASSERT_EQ("NOT_FOUND", Get(Uint64Key(4)));
-
-  // Add more keys.
-  ASSERT_OK(Delete(Uint64Key(2)));  // Delete.
-  ASSERT_OK(Put(Uint64Key(3), "v0"));  // Update.
-  ASSERT_OK(Put(Uint64Key(4), "v4"));
-  dbfull()->TEST_FlushMemTable();
-  ASSERT_EQ("v1", Get(Uint64Key(1)));
-  ASSERT_EQ("NOT_FOUND", Get(Uint64Key(2)));
-  ASSERT_EQ("v0", Get(Uint64Key(3)));
-  ASSERT_EQ("v4", Get(Uint64Key(4)));
-}
-
-TEST(CuckooTableDBTest, CompactionTrigger) {
-  Options options = CurrentOptions();
-  options.write_buffer_size = 100 << 10;  // 100KB
-  options.level0_file_num_compaction_trigger = 2;
-  Reopen(&options);
-
-  // Write 11 values, each 10016 B
-  for (int idx = 0; idx < 11; ++idx) {
-    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + idx)));
-  }
-  dbfull()->TEST_WaitForFlushMemTable();
-  ASSERT_EQ("1", FilesPerLevel());
-
-  // Generate one more file in level-0, and should trigger level-0 compaction
-  for (int idx = 11; idx < 22; ++idx) {
-    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + idx)));
-  }
-  dbfull()->TEST_WaitForFlushMemTable();
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
-
-  ASSERT_EQ("0,2", FilesPerLevel());
-  for (int idx = 0; idx < 22; ++idx) {
-    ASSERT_EQ(std::string(10000, 'a' + idx), Get(Key(idx)));
-  }
-}
-
-TEST(CuckooTableDBTest, SameKeyInsertedInTwoDifferentFilesAndCompacted) {
-  // Insert same key twice so that they go to different SST files. Then wait for
-  // compaction and check if the latest value is stored and old value removed.
-  Options options = CurrentOptions();
-  options.write_buffer_size = 100 << 10;  // 100KB
-  options.level0_file_num_compaction_trigger = 2;
-  Reopen(&options);
-
-  // Write 11 values, each 10016 B
-  for (int idx = 0; idx < 11; ++idx) {
-    ASSERT_OK(Put(Key(idx), std::string(10000, 'a')));
-  }
-  dbfull()->TEST_WaitForFlushMemTable();
-  ASSERT_EQ("1", FilesPerLevel());
-
-  // Generate one more file in level-0, and should trigger level-0 compaction
-  for (int idx = 0; idx < 11; ++idx) {
-    ASSERT_OK(Put(Key(idx), std::string(10000, 'a' + idx)));
-  }
-  dbfull()->TEST_WaitForFlushMemTable();
-  dbfull()->TEST_CompactRange(0, nullptr, nullptr);
-
-  ASSERT_EQ("0,1", FilesPerLevel());
-  for (int idx = 0; idx < 11; ++idx) {
-    ASSERT_EQ(std::string(10000, 'a' + idx), Get(Key(idx)));
-  }
-}
-
-TEST(CuckooTableDBTest, AdaptiveTable) {
-  Options options = CurrentOptions();
-
-  // Write some keys using cuckoo table.
-  options.table_factory.reset(NewCuckooTableFactory());
-  Reopen(&options);
-
-  ASSERT_OK(Put("key1", "v1"));
-  ASSERT_OK(Put("key2", "v2"));
-  ASSERT_OK(Put("key3", "v3"));
-  dbfull()->TEST_FlushMemTable();
-
-  // Write some keys using plain table.
-  options.create_if_missing = false;
-  options.table_factory.reset(NewPlainTableFactory());
-  Reopen(&options);
-  ASSERT_OK(Put("key4", "v4"));
-  ASSERT_OK(Put("key1", "v5"));
-  dbfull()->TEST_FlushMemTable();
-
-  // Write some keys using block based table.
-  std::shared_ptr<TableFactory> block_based_factory(
-      NewBlockBasedTableFactory());
-  options.table_factory.reset(NewAdaptiveTableFactory(block_based_factory));
-  Reopen(&options);
-  ASSERT_OK(Put("key5", "v6"));
-  ASSERT_OK(Put("key2", "v7"));
-  dbfull()->TEST_FlushMemTable();
-
-  ASSERT_EQ("v5", Get("key1"));
-  ASSERT_EQ("v7", Get("key2"));
-  ASSERT_EQ("v3", Get("key3"));
-  ASSERT_EQ("v4", Get("key4"));
-  ASSERT_EQ("v6", Get("key5"));
-}
-}  // namespace rocksdb
-
-int main(int argc, char** argv) { return rocksdb::test::RunAllTests(); }
@@ -30,6 +30,7 @@ int main() {
 #include <gflags/gflags.h>
 #include "db/db_impl.h"
 #include "db/version_set.h"
+#include "rocksdb/statistics.h"
 #include "rocksdb/options.h"
 #include "rocksdb/cache.h"
 #include "rocksdb/db.h"
@@ -146,7 +147,6 @@ DEFINE_int64(merge_keys, -1,
             "Number of distinct keys to use for MergeRandom and "
             "ReadRandomMergeRandom. "
             "If negative, there will be FLAGS_num keys.");
-DEFINE_int32(num_column_families, 1, "Number of Column Families to use.");

 DEFINE_int64(reads, -1, "Number of read operations to do.  "
             "If negative, do FLAGS_num reads.");
@@ -163,7 +163,6 @@ DEFINE_int32(duration, 0, "Time in seconds for the random-ops tests to run."

 DEFINE_int32(value_size, 100, "Size of each value");

-DEFINE_bool(use_uint64_comparator, false, "use Uint64 user comparator");

 static bool ValidateKeySize(const char* flagname, int32_t value) {
  return true;
@@ -240,14 +239,9 @@ DEFINE_int32(universal_compression_size_percent, -1,
 DEFINE_int64(cache_size, -1, "Number of bytes to use as a cache of uncompressed"
             "data. Negative means use default settings.");

-DEFINE_int32(block_size, rocksdb::BlockBasedTableOptions().block_size,
+DEFINE_int32(block_size, rocksdb::Options().block_size,
             "Number of bytes in a block.");

-DEFINE_int32(block_restart_interval,
-             rocksdb::BlockBasedTableOptions().block_restart_interval,
-             "Number of keys between restart points "
-             "for delta encoding of keys.");
-
 DEFINE_int64(compressed_cache_size, -1,
             "Number of bytes to use as a cache of compressed data.");

@@ -510,8 +504,6 @@ DEFINE_int32(prefix_size, 0, "control the prefix size for HashSkipList and "
 DEFINE_int64(keys_per_prefix, 0, "control average number of keys generated "
             "per prefix, 0 means no special handling of the prefix, "
             "i.e. use the prefix comes with the generated random number.");
-DEFINE_bool(enable_io_prio, false, "Lower the background flush/compaction "
-            "threads' IO priority");

 enum RepFactory {
  kSkipList,
@@ -546,11 +538,6 @@ DEFINE_string(memtablerep, "skip_list", "");
 DEFINE_int64(hash_bucket_count, 1024 * 1024, "hash bucket count");
 DEFINE_bool(use_plain_table, false, "if use plain table "
            "instead of block-based table format");
-DEFINE_bool(use_cuckoo_table, false, "if use cuckoo table format");
-DEFINE_double(cuckoo_hash_ratio, 0.9, "Hash ratio for Cuckoo SST table.");
-DEFINE_bool(use_hash_search, false, "if use kHashSearch "
-            "instead of kBinarySearch. "
-            "This is valid if only we use BlockTable");

 DEFINE_string(merge_operator, "", "The merge operator to use with the database."
              "If a new merge operator is specified, be sure to use fresh"
@@ -846,19 +833,12 @@ class Duration {

 class Benchmark {
 private:
-  std::shared_ptr<Cache> cache_;
-  std::shared_ptr<Cache> compressed_cache_;
-  std::shared_ptr<const FilterPolicy> filter_policy_;
+  shared_ptr<Cache> cache_;
+  shared_ptr<Cache> compressed_cache_;
+  const FilterPolicy* filter_policy_;
  const SliceTransform* prefix_extractor_;
-  struct DBWithColumnFamilies {
-    std::vector<ColumnFamilyHandle*> cfh;
-    DB* db;
-    DBWithColumnFamilies() : db(nullptr) {
-      cfh.clear();
-    }
-  };
-  DBWithColumnFamilies db_;
-  std::vector<DBWithColumnFamilies> multi_dbs_;
+  DB* db_;
+  std::vector<DB*> multi_dbs_;
  int64_t num_;
  int value_size_;
  int key_size_;
@@ -1078,6 +1058,7 @@ class Benchmark {
                   ? NewBloomFilterPolicy(FLAGS_bloom_bits)
                   : nullptr),
    prefix_extractor_(NewFixedPrefixTransform(FLAGS_prefix_size)),
+    db_(nullptr),
    num_(FLAGS_num),
    value_size_(FLAGS_value_size),
    key_size_(FLAGS_key_size),
@@ -1108,7 +1089,8 @@ class Benchmark {
  }

  ~Benchmark() {
-    delete db_.db;
+    delete db_;
+    delete filter_policy_;
    delete prefix_extractor_;
  }

@@ -1167,16 +1149,6 @@ class Benchmark {
    return base_name + std::to_string(id);
  }

-  std::string ColumnFamilyName(int i) {
-    if (i == 0) {
-      return kDefaultColumnFamilyName;
-    } else {
-      char name[100];
-      snprintf(name, sizeof(name), "column_family_name_%06d", i);
-      return std::string(name);
-    }
-  }
-
  void Run() {
    if (!SanityCheck()) {
      exit(1);
@@ -1331,14 +1303,13 @@ class Benchmark {
                  name.ToString().c_str());
          method = nullptr;
        } else {
-          if (db_.db != nullptr) {
-            delete db_.db;
-            db_.db = nullptr;
-            db_.cfh.clear();
+          if (db_ != nullptr) {
+            delete db_;
+            db_ = nullptr;
            DestroyDB(FLAGS_db, Options());
          }
          for (size_t i = 0; i < multi_dbs_.size(); i++) {
-            delete multi_dbs_[i].db;
+            delete multi_dbs_[i];
            DestroyDB(GetDbNameForMultiple(FLAGS_db, i), Options());
          }
          multi_dbs_.clear();
@@ -1510,7 +1481,7 @@ class Benchmark {

  void Compress(ThreadState *thread) {
    RandomGenerator gen;
-    Slice input = gen.Generate(FLAGS_block_size);
+    Slice input = gen.Generate(Options().block_size);
    int64_t bytes = 0;
    int64_t produced = 0;
    bool ok = true;
@@ -1560,7 +1531,7 @@ class Benchmark {

  void Uncompress(ThreadState *thread) {
    RandomGenerator gen;
-    Slice input = gen.Generate(FLAGS_block_size);
+    Slice input = gen.Generate(Options().block_size);
    std::string compressed;

    bool ok;
@@ -1636,10 +1607,14 @@ class Benchmark {
  }

  void Open() {
-    assert(db_.db == nullptr);
+    assert(db_ == nullptr);
    Options options;
    options.create_if_missing = !FLAGS_use_existing_db;
-    options.create_missing_column_families = FLAGS_num_column_families > 1;
+    options.block_cache = cache_;
+    options.block_cache_compressed = compressed_cache_;
+    if (cache_ == nullptr) {
+      options.no_block_cache = true;
+    }
    options.write_buffer_size = FLAGS_write_buffer_size;
    options.max_write_buffer_number = FLAGS_max_write_buffer_number;
    options.min_write_buffer_number_to_merge =
@@ -1647,25 +1622,16 @@ class Benchmark {
    options.max_background_compactions = FLAGS_max_background_compactions;
    options.max_background_flushes = FLAGS_max_background_flushes;
    options.compaction_style = FLAGS_compaction_style_e;
-    if (FLAGS_prefix_size != 0) {
+    options.block_size = FLAGS_block_size;
+    options.filter_policy = filter_policy_;
+    if (FLAGS_use_plain_table) {
      options.prefix_extractor.reset(
          NewFixedPrefixTransform(FLAGS_prefix_size));
    }
-    if (FLAGS_use_uint64_comparator) {
-      options.comparator = test::Uint64Comparator();
-      if (FLAGS_key_size != 8) {
-        fprintf(stderr, "Using Uint64 comparator but key size is not 8.\n");
-        exit(1);
-      }
-    }
    options.memtable_prefix_bloom_bits = FLAGS_memtable_bloom_bits;
    options.bloom_locality = FLAGS_bloom_locality;
    options.max_open_files = FLAGS_open_files;
    options.statistics = dbstats;
-    if (FLAGS_enable_io_prio) {
-      FLAGS_env->LowerThreadPoolIOPriority(Env::LOW);
-      FLAGS_env->LowerThreadPoolIOPriority(Env::HIGH);
-    }
    options.env = FLAGS_env;
    options.disableDataSync = FLAGS_disable_data_sync;
    options.use_fsync = FLAGS_use_fsync;
@@ -1719,42 +1685,8 @@ class Benchmark {
      if (bloom_bits_per_key < 0) {
        bloom_bits_per_key = 0;
      }
-
-      PlainTableOptions plain_table_options;
-      plain_table_options.user_key_len = FLAGS_key_size;
-      plain_table_options.bloom_bits_per_key = bloom_bits_per_key;
-      plain_table_options.hash_table_ratio = 0.75;
      options.table_factory = std::shared_ptr<TableFactory>(
-          NewPlainTableFactory(plain_table_options));
-    } else if (FLAGS_use_cuckoo_table) {
-      if (FLAGS_cuckoo_hash_ratio > 1 || FLAGS_cuckoo_hash_ratio < 0) {
-        fprintf(stderr, "Invalid cuckoo_hash_ratio\n");
-        exit(1);
-      }
-      options.table_factory = std::shared_ptr<TableFactory>(
-          NewCuckooTableFactory(FLAGS_cuckoo_hash_ratio));
-    } else {
-      BlockBasedTableOptions block_based_options;
-      if (FLAGS_use_hash_search) {
-        if (FLAGS_prefix_size == 0) {
-          fprintf(stderr,
-              "prefix_size not assigned when enable use_hash_search \n");
-          exit(1);
-        }
-        block_based_options.index_type = BlockBasedTableOptions::kHashSearch;
-      } else {
-        block_based_options.index_type = BlockBasedTableOptions::kBinarySearch;
-      }
-      if (cache_ == nullptr) {
-        block_based_options.no_block_cache = true;
-      }
-      block_based_options.block_cache = cache_;
-      block_based_options.block_cache_compressed = compressed_cache_;
-      block_based_options.block_size = FLAGS_block_size;
-      block_based_options.block_restart_interval = FLAGS_block_restart_interval;
-      block_based_options.filter_policy = filter_policy_;
-      options.table_factory.reset(
-          NewBlockBasedTableFactory(block_based_options));
+          NewPlainTableFactory(FLAGS_key_size, bloom_bits_per_key, 0.75));
    }
    if (FLAGS_max_bytes_for_level_multiplier_additional_v.size() > 0) {
      if (FLAGS_max_bytes_for_level_multiplier_additional_v.size() !=
@@ -1843,9 +1775,10 @@ class Benchmark {
      OpenDb(options, FLAGS_db, &db_);
    } else {
      multi_dbs_.clear();
-      multi_dbs_.resize(FLAGS_num_multi_db);
      for (int i = 0; i < FLAGS_num_multi_db; i++) {
-        OpenDb(options, GetDbNameForMultiple(FLAGS_db, i), &multi_dbs_[i]);
+        DB* db;
+        OpenDb(options, GetDbNameForMultiple(FLAGS_db, i), &db);
+        multi_dbs_.push_back(db);
      }
    }
    if (FLAGS_min_level_to_compress >= 0) {
@@ -1853,27 +1786,12 @@ class Benchmark {
    }
  }

-  void OpenDb(const Options& options, const std::string& db_name,
-      DBWithColumnFamilies* db) {
+  void OpenDb(Options options, std::string db_name, DB** db) {
    Status s;
-    // Open with column families if necessary.
-    if (FLAGS_num_column_families > 1) {
-      db->cfh.resize(FLAGS_num_column_families);
-      std::vector<ColumnFamilyDescriptor> column_families;
-      for (int i = 0; i < FLAGS_num_column_families; i++) {
-        column_families.push_back(ColumnFamilyDescriptor(
-              ColumnFamilyName(i), ColumnFamilyOptions(options)));
-      }
-      if (FLAGS_readonly) {
-        s = DB::OpenForReadOnly(options, db_name, column_families,
-            &db->cfh, &db->db);
-      } else {
-        s = DB::Open(options, db_name, column_families, &db->cfh, &db->db);
-      }
-    } else if (FLAGS_readonly) {
-      s = DB::OpenForReadOnly(options, db_name, &db->db);
+    if(FLAGS_readonly) {
+      s = DB::OpenForReadOnly(options, db_name, db);
    } else {
-      s = DB::Open(options, db_name, &db->db);
+      s = DB::Open(options, db_name, db);
    }
    if (!s.ok()) {
      fprintf(stderr, "open error: %s\n", s.ToString().c_str());
@@ -1941,18 +1859,10 @@ class Benchmark {
  };

  DB* SelectDB(ThreadState* thread) {
-    return SelectDBWithCfh(thread)->db;
-  }
-
-  DBWithColumnFamilies* SelectDBWithCfh(ThreadState* thread) {
-    return SelectDBWithCfh(thread->rand.Next());
-  }
-
-  DBWithColumnFamilies* SelectDBWithCfh(uint64_t rand_int) {
-    if (db_.db != nullptr) {
-      return &db_;
-    } else  {
-      return &multi_dbs_[rand_int % multi_dbs_.size()];
+    if (db_ != nullptr) {
+      return db_;
+    } else {
+      return multi_dbs_[thread->rand.Next() % multi_dbs_.size()];
    }
  }

@@ -1961,7 +1871,7 @@ class Benchmark {
    const int64_t num_ops = writes_ == 0 ? num_ : writes_;

    size_t num_key_gens = 1;
-    if (db_.db == nullptr) {
+    if (db_ == nullptr) {
      num_key_gens = multi_dbs_.size();
    }
    std::vector<std::unique_ptr<KeyGenerator>> key_gens(num_key_gens);
@@ -1984,25 +1894,20 @@ class Benchmark {
    Slice key = AllocateKey();
    std::unique_ptr<const char[]> key_guard(key.data());
    while (!duration.Done(entries_per_batch_)) {
-      size_t id = thread->rand.Next() % num_key_gens;
-      DBWithColumnFamilies* db_with_cfh = SelectDBWithCfh(id);
+      size_t id = 0;
+      DB* db_to_write = db_;
+      if (db_to_write == nullptr) {
+        id = thread->rand.Next() % num_key_gens;
+        db_to_write = multi_dbs_[id];
+      }
      batch.Clear();
      for (int64_t j = 0; j < entries_per_batch_; j++) {
-        int64_t rand_num = key_gens[id]->Next();
-        GenerateKeyFromInt(rand_num, FLAGS_num, &key);
-        if (FLAGS_num_column_families <= 1) {
-          batch.Put(key, gen.Generate(value_size_));
-        } else {
-          // We use same rand_num as seed for key and column family so that we
-          // can deterministically find the cfh corresponding to a particular
-          // key while reading the key.
-          batch.Put(db_with_cfh->cfh[rand_num % db_with_cfh->cfh.size()],
-              key, gen.Generate(value_size_));
-        }
+        GenerateKeyFromInt(key_gens[id]->Next(), FLAGS_num, &key);
+        batch.Put(key, gen.Generate(value_size_));
        bytes += value_size_ + key_size_;
      }
-      s = db_with_cfh->db->Write(write_options_, &batch);
-      thread->stats.FinishedOps(db_with_cfh->db, entries_per_batch_);
+      s = db_to_write->Write(write_options_, &batch);
+      thread->stats.FinishedOps(db_to_write, entries_per_batch_);
      if (!s.ok()) {
        fprintf(stderr, "put error: %s\n", s.ToString().c_str());
        exit(1);
@@ -2012,11 +1917,11 @@ class Benchmark {
  }

  void ReadSequential(ThreadState* thread) {
-    if (db_.db != nullptr) {
-      ReadSequential(thread, db_.db);
+    if (db_ != nullptr) {
+      ReadSequential(thread, db_);
    } else {
-      for (const auto& db_with_cfh : multi_dbs_) {
-        ReadSequential(thread, db_with_cfh.db);
+      for (DB* db : multi_dbs_) {
+        ReadSequential(thread, db);
      }
    }
  }
@@ -2035,11 +1940,11 @@ class Benchmark {
  }

  void ReadReverse(ThreadState* thread) {
-    if (db_.db != nullptr) {
-      ReadReverse(thread, db_.db);
+    if (db_ != nullptr) {
+      ReadReverse(thread, db_);
    } else {
-      for (const auto& db_with_cfh : multi_dbs_) {
-        ReadReverse(thread, db_with_cfh.db);
+      for (DB* db : multi_dbs_) {
+        ReadReverse(thread, db);
      }
    }
  }
@@ -2050,7 +1955,7 @@ class Benchmark {
    int64_t bytes = 0;
    for (iter->SeekToLast(); i < reads_ && iter->Valid(); iter->Prev()) {
      bytes += iter->key().size() + iter->value().size();
-      thread->stats.FinishedOps(db, 1);
+      thread->stats.FinishedOps(db_, 1);
      ++i;
    }
    delete iter;
@@ -2067,24 +1972,13 @@ class Benchmark {

    Duration duration(FLAGS_duration, reads_);
    while (!duration.Done(1)) {
-      DBWithColumnFamilies* db_with_cfh = SelectDBWithCfh(thread);
-      // We use same key_rand as seed for key and column family so that we can
-      // deterministically find the cfh corresponding to a particular key, as it
-      // is done in DoWrite method.
-      int64_t key_rand = thread->rand.Next() % FLAGS_num;
-      GenerateKeyFromInt(key_rand, FLAGS_num, &key);
+      DB* db = SelectDB(thread);
+      GenerateKeyFromInt(thread->rand.Next() % FLAGS_num, FLAGS_num, &key);
      read++;
-      Status s;
-      if (FLAGS_num_column_families > 1) {
-        s = db_with_cfh->db->Get(options,
-            db_with_cfh->cfh[key_rand % db_with_cfh->cfh.size()], key, &value);
-      } else {
-        s = db_with_cfh->db->Get(options, key, &value);
-      }
-      if (s.ok()) {
+      if (db->Get(options, key, &value).ok()) {
        found++;
      }
-      thread->stats.FinishedOps(db_with_cfh->db, 1);
+      thread->stats.FinishedOps(db_, 1);
    }

    char msg[100];
@@ -2126,7 +2020,6 @@ class Benchmark {
          ++found;
        }
      }
-      thread->stats.FinishedOps(db, entries_per_batch_);
    }
    for (auto& k : keys) {
      delete k.data();
@@ -2165,11 +2058,11 @@ class Benchmark {

    Iterator* single_iter = nullptr;
    std::vector<Iterator*> multi_iters;
-    if (db_.db != nullptr) {
-      single_iter = db_.db->NewIterator(options);
+    if (db_ != nullptr) {
+      single_iter = db_->NewIterator(options);
    } else {
-      for (const auto& db_with_cfh : multi_dbs_) {
-        multi_iters.push_back(db_with_cfh.db->NewIterator(options));
+      for (DB* db : multi_dbs_) {
+        multi_iters.push_back(db->NewIterator(options));
      }
    }
    uint64_t last_refresh = FLAGS_env->NowMicros();
@@ -2182,16 +2075,16 @@ class Benchmark {
      if (!FLAGS_use_tailing_iterator && FLAGS_iter_refresh_interval_us >= 0) {
        uint64_t now = FLAGS_env->NowMicros();
        if (now - last_refresh > (uint64_t)FLAGS_iter_refresh_interval_us) {
-          if (db_.db != nullptr) {
+          if (db_ != nullptr) {
            delete single_iter;
-            single_iter = db_.db->NewIterator(options);
+            single_iter = db_->NewIterator(options);
          } else {
            for (auto iter : multi_iters) {
              delete iter;
            }
            multi_iters.clear();
-            for (const auto& db_with_cfh : multi_dbs_) {
-              multi_iters.push_back(db_with_cfh.db->NewIterator(options));
+            for (DB* db : multi_dbs_) {
+              multi_iters.push_back(db->NewIterator(options));
            }
          }
        }
@@ -2209,7 +2102,7 @@ class Benchmark {
      if (iter_to_use->Valid() && iter_to_use->key().compare(key) == 0) {
        found++;
      }
-      thread->stats.FinishedOps(db_.db, 1);
+      thread->stats.FinishedOps(db_, 1);
    }
    delete single_iter;
    for (auto iter : multi_iters) {
@@ -2309,7 +2202,7 @@ class Benchmark {
        fprintf(stderr, "put error: %s\n", s.ToString().c_str());
        exit(1);
      }
-      thread->stats.FinishedOps(db_.db, 1);
+      thread->stats.FinishedOps(db_, 1);

      ++num_writes;
      if (writes_per_second_by_10 && num_writes >= writes_per_second_by_10) {
@@ -2469,7 +2362,7 @@ class Benchmark {
        deletes_done++;
      }

-      thread->stats.FinishedOps(db_.db, 1);
+      thread->stats.FinishedOps(db_, 1);
    }
    char msg[100];
    snprintf(msg, sizeof(msg),
@@ -2608,7 +2501,7 @@ class Benchmark {
        fprintf(stderr, "put error: %s\n", s.ToString().c_str());
        exit(1);
      }
-      thread->stats.FinishedOps(db, 1);
+      thread->stats.FinishedOps(db_, 1);
    }

    char msg[100];
@@ -2644,7 +2537,7 @@ class Benchmark {
        fprintf(stderr, "merge error: %s\n", s.ToString().c_str());
        exit(1);
      }
-      thread->stats.FinishedOps(db, 1);
+      thread->stats.FinishedOps(db_, 1);
    }

    // Print some statistics
@@ -2705,7 +2598,7 @@ class Benchmark {

      }

-      thread->stats.FinishedOps(db, 1);
+      thread->stats.FinishedOps(db_, 1);
    }

    char msg[100];
@@ -2722,11 +2615,11 @@ class Benchmark {
  }

  void PrintStats(const char* key) {
-    if (db_.db != nullptr) {
-      PrintStats(db_.db, key, false);
+    if (db_ != nullptr) {
+      PrintStats(db_, key, false);
    }
-    for (const auto& db_with_cfh : multi_dbs_) {
-      PrintStats(db_with_cfh.db, key, true);
+    for (DB* db : multi_dbs_) {
+      PrintStats(db, key, true);
    }
  }

@@ -66,10 +66,6 @@ Status DBImpl::EnableFileDeletions(bool force) {
  return Status::OK();
 }

-int DBImpl::IsFileDeletionsEnabled() const {
-  return disable_delete_obsolete_files_;
-}
-
 Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
                            uint64_t* manifest_file_size,
                            bool flush_memtable) {
@@ -28,6 +28,7 @@
 #include "rocksdb/memtablerep.h"
 #include "rocksdb/transaction_log.h"
 #include "util/autovector.h"
+#include "util/stats_logger.h"
 #include "util/stop_watch.h"
 #include "util/thread_local.h"
 #include "db/internal_stats.h"
@@ -96,17 +97,13 @@ class DBImpl : public DB {
  using DB::GetProperty;
  virtual bool GetProperty(ColumnFamilyHandle* column_family,
                           const Slice& property, std::string* value);
-  using DB::GetIntProperty;
-  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
-                              const Slice& property, uint64_t* value) override;
  using DB::GetApproximateSizes;
  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
                                   const Range* range, int n, uint64_t* sizes);
  using DB::CompactRange;
  virtual Status CompactRange(ColumnFamilyHandle* column_family,
                              const Slice* begin, const Slice* end,
-                              bool reduce_level = false, int target_level = -1,
-                              uint32_t target_path_id = 0);
+                              bool reduce_level = false, int target_level = -1);

  using DB::NumberLevels;
  virtual int NumberLevels(ColumnFamilyHandle* column_family);
@@ -127,7 +124,6 @@ class DBImpl : public DB {
 #ifndef ROCKSDB_LITE
  virtual Status DisableFileDeletions();
  virtual Status EnableFileDeletions(bool force);
-  virtual int IsFileDeletionsEnabled() const;
  // All the returned filenames start with "/"
  virtual Status GetLiveFiles(std::vector<std::string>&,
                              uint64_t* manifest_file_size,
@@ -150,8 +146,8 @@ class DBImpl : public DB {
  virtual Status GetDbIdentity(std::string& identity);

  Status RunManualCompaction(ColumnFamilyData* cfd, int input_level,
-                             int output_level, uint32_t output_path_id,
-                             const Slice* begin, const Slice* end);
+                             int output_level, const Slice* begin,
+                             const Slice* end);

 #ifndef ROCKSDB_LITE
  // Extra methods (for testing) that are not in the public DB interface
@@ -294,7 +290,6 @@ class DBImpl : public DB {
  const std::string dbname_;
  unique_ptr<VersionSet> versions_;
  const DBOptions options_;
-  Statistics* stats_;

  Iterator* NewInternalIterator(const ReadOptions&, ColumnFamilyData* cfd,
                                SuperVersion* super_version,
@@ -310,7 +305,6 @@ class DBImpl : public DB {
  friend struct SuperVersion;
  struct CompactionState;
  struct Writer;
-  struct WriteContext;

  Status NewDB();

@@ -349,38 +343,13 @@ class DBImpl : public DB {

  uint64_t SlowdownAmount(int n, double bottom, double top);

-  // Before applying write operation (such as DBImpl::Write, DBImpl::Flush)
-  // thread should grab the mutex_ and be the first on writers queue.
-  // BeginWrite is used for it.
-  // Be aware! Writer's job can be done by other thread (see DBImpl::Write
-  // for examples), so check it via w.done before applying changes.
-  //
-  // Writer* w:                writer to be placed in the queue
-  // uint64_t expiration_time: maximum time to be in the queue
-  // See also: EndWrite
-  Status BeginWrite(Writer* w, uint64_t expiration_time);
-
-  // After doing write job, we need to remove already used writers from
-  // writers_ queue and notify head of the queue about it.
-  // EndWrite is used for this.
-  //
-  // Writer* w:           Writer, that was added by BeginWrite function
-  // Writer* last_writer: Since we can join a few Writers (as DBImpl::Write
-  //                      does)
-  //                      we should pass last_writer as a parameter to
-  //                      EndWrite
-  //                      (if you don't touch other writers, just pass w)
-  // Status status:       Status of write operation
-  // See also: BeginWrite
-  void EndWrite(Writer* w, Writer* last_writer, Status status);
-
+  // TODO(icanadi) free superversion_to_free and old_log outside of mutex
  Status MakeRoomForWrite(ColumnFamilyData* cfd,
-                          WriteContext* context,
+                          bool force /* flush even if there is room? */,
+                          autovector<SuperVersion*>* superversions_to_free,
+                          autovector<log::Writer*>* logs_to_free,
                          uint64_t expiration_time);

-  Status SetNewMemtableAndNewLogFile(ColumnFamilyData* cfd,
-                                     WriteContext* context);
-
  void BuildBatchGroup(Writer** last_writer,
                       autovector<WriteBatch*>* write_batch_group);

@@ -393,6 +362,13 @@ class DBImpl : public DB {
  void RecordFlushIOStats();
  void RecordCompactionIOStats();

+  void MaybeScheduleLogDBDeployStats();
+
+#ifndef ROCKSDB_LITE
+  static void BGLogDBDeployStats(void* db);
+  void LogDBDeployStats();
+#endif  // ROCKSDB_LITE
+
  void MaybeScheduleFlushOrCompaction();
  static void BGWorkCompaction(void* db);
  static void BGWorkFlush(void* db);
@@ -502,12 +478,12 @@ class DBImpl : public DB {
  // * whenever bg_flush_scheduled_ value decreases (i.e. whenever a flush is
  // done, even if it didn't make any progress)
  // * whenever there is an error in background flush or compaction
+  // * whenever bg_logstats_scheduled_ turns to false
  port::CondVar bg_cv_;
  uint64_t logfile_number_;
  unique_ptr<log::Writer> log_;
  bool log_empty_;
  ColumnFamilyHandleImpl* default_cf_handle_;
-  InternalStats* default_cf_internal_stats_;
  unique_ptr<ColumnFamilyMemTablesImpl> column_family_memtables_;
  struct LogFileNumberSize {
    explicit LogFileNumberSize(uint64_t _number)
@@ -526,6 +502,8 @@ class DBImpl : public DB {
  // some code-paths
  bool single_column_family_mode_;

+  std::string host_name_;
+
  std::unique_ptr<Directory> db_directory_;

  // Queue of writers.
@@ -558,12 +536,14 @@ class DBImpl : public DB {
  // number of background memtable flush jobs, submitted to the HIGH pool
  int bg_flush_scheduled_;

+  // Has a background stats log thread scheduled?
+  bool bg_logstats_scheduled_;
+
  // Information for a manual compaction
  struct ManualCompaction {
    ColumnFamilyData* cfd;
    int input_level;
    int output_level;
-    uint32_t output_path_id;
    bool done;
    Status status;
    bool in_progress;           // compaction request being processed?
@@ -576,6 +556,10 @@ class DBImpl : public DB {
  // Have we encountered a background error in paranoid mode?
  Status bg_error_;

+  std::unique_ptr<StatsLogger> logger_;
+
+  int64_t volatile last_log_ts;
+
  // shall we disable deletion of obsolete files
  // if 0 the deletion is enabled.
  // if non-zero, files will not be getting deleted
@@ -638,16 +622,6 @@ class DBImpl : public DB {
  void InstallSuperVersion(ColumnFamilyData* cfd,
                           DeletionState& deletion_state);

-  // Find Super version and reference it. Based on options, it might return
-  // the thread local cached one.
-  inline SuperVersion* GetAndRefSuperVersion(ColumnFamilyData* cfd);
-
-  // Un-reference the super version and return it to thread local cache if
-  // needed. If it is the last reference of the super version. Clean it up
-  // after un-referencing it.
-  inline void ReturnAndCleanupSuperVersion(ColumnFamilyData* cfd,
-                                           SuperVersion* sv);
-
 #ifndef ROCKSDB_LITE
  using DB::GetPropertiesOfAllTables;
  virtual Status GetPropertiesOfAllTables(ColumnFamilyHandle* column_family,
@@ -660,28 +634,14 @@ class DBImpl : public DB {
  Status GetImpl(const ReadOptions& options, ColumnFamilyHandle* column_family,
                 const Slice& key, std::string* value,
                 bool* value_found = nullptr);
-
-  bool GetIntPropertyInternal(ColumnFamilyHandle* column_family,
-                              DBPropertyType property_type,
-                              bool need_out_of_mutex, uint64_t* value);
 };

 // Sanitize db options.  The caller should delete result.info_log if
 // it is not equal to src.info_log.
 extern Options SanitizeOptions(const std::string& db,
                               const InternalKeyComparator* icmp,
+                               const InternalFilterPolicy* ipolicy,
                               const Options& src);
 extern DBOptions SanitizeOptions(const std::string& db, const DBOptions& src);

-// Fix user-supplied options to be reasonable
-template <class T, class V>
-static void ClipToRange(T* ptr, V minvalue, V maxvalue) {
-  if (static_cast<V>(*ptr) > maxvalue) *ptr = maxvalue;
-  if (static_cast<V>(*ptr) < minvalue) *ptr = minvalue;
-}
-
-// Dump db file summary, implemented in util/
-extern void DumpDBFileSummary(const DBOptions& options,
-                              const std::string& dbname);
-
 }  // namespace rocksdb
@@ -85,7 +85,7 @@ Status DBImpl::TEST_CompactRange(int level, const Slice* begin,
       cfd->options()->compaction_style == kCompactionStyleFIFO)
          ? level
          : level + 1;
-  return RunManualCompaction(cfd, level, output_level, 0, begin, end);
+  return RunManualCompaction(cfd, level, output_level, begin, end);
 }

 Status DBImpl::TEST_FlushMemTable(bool wait) {
@@ -16,6 +16,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <vector>
+#include <algorithm>
 #include "db/db_iter.h"
 #include "db/dbformat.h"
 #include "db/filename.h"
@@ -75,42 +76,12 @@ Iterator* DBImplReadOnly::NewIterator(const ReadOptions& options,
  auto cfd = cfh->cfd();
  SuperVersion* super_version = cfd->GetSuperVersion()->Ref();
  SequenceNumber latest_snapshot = versions_->LastSequence();
-  auto db_iter = NewArenaWrappedDbIterator(
-      env_, *cfd->options(), cfd->user_comparator(),
+  Iterator* internal_iter = NewInternalIterator(options, cfd, super_version);
+  return NewDBIterator(
+      env_, *cfd->options(), cfd->user_comparator(), internal_iter,
      (options.snapshot != nullptr
           ? reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_
           : latest_snapshot));
-  auto internal_iter =
-      NewInternalIterator(options, cfd, super_version, db_iter->GetArena());
-  db_iter->SetIterUnderDBIter(internal_iter);
-  return db_iter;
-}
-
-Status DBImplReadOnly::NewIterators(
-    const ReadOptions& options,
-    const std::vector<ColumnFamilyHandle*>& column_families,
-    std::vector<Iterator*>* iterators) {
-  if (iterators == nullptr) {
-    return Status::InvalidArgument("iterators not allowed to be nullptr");
-  }
-  iterators->clear();
-  iterators->reserve(column_families.size());
-  SequenceNumber latest_snapshot = versions_->LastSequence();
-
-  for (auto cfh : column_families) {
-    auto cfd = reinterpret_cast<ColumnFamilyHandleImpl*>(cfh)->cfd();
-    auto db_iter = NewArenaWrappedDbIterator(
-        env_, *cfd->options(), cfd->user_comparator(),
-        options.snapshot != nullptr
-            ? reinterpret_cast<const SnapshotImpl*>(options.snapshot)->number_
-            : latest_snapshot);
-    auto internal_iter = NewInternalIterator(
-        options, cfd, cfd->GetSuperVersion()->Ref(), db_iter->GetArena());
-    db_iter->SetIterUnderDBIter(internal_iter);
-    iterators->push_back(db_iter);
-  }
-
-  return Status::OK();
 }

 Status DB::OpenForReadOnly(const Options& options, const std::string& dbname,
@@ -20,6 +20,7 @@
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "port/port.h"
+#include "util/stats_logger.h"

 namespace rocksdb {

@@ -32,66 +33,63 @@ class DBImplReadOnly : public DBImpl {
  using DB::Get;
  virtual Status Get(const ReadOptions& options,
                     ColumnFamilyHandle* column_family, const Slice& key,
-                     std::string* value) override;
+                     std::string* value);

  // TODO: Implement ReadOnly MultiGet?

  using DBImpl::NewIterator;
  virtual Iterator* NewIterator(const ReadOptions&,
-                                ColumnFamilyHandle* column_family) override;
+                                ColumnFamilyHandle* column_family);

  virtual Status NewIterators(
      const ReadOptions& options,
-      const std::vector<ColumnFamilyHandle*>& column_families,
-      std::vector<Iterator*>* iterators) override;
+      const std::vector<ColumnFamilyHandle*>& column_family,
+      std::vector<Iterator*>* iterators) {
+   // TODO
+    return Status::NotSupported("Not supported yet.");
+  }

  using DBImpl::Put;
  virtual Status Put(const WriteOptions& options,
                     ColumnFamilyHandle* column_family, const Slice& key,
-                     const Slice& value) override {
+                     const Slice& value) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
  using DBImpl::Merge;
  virtual Status Merge(const WriteOptions& options,
                       ColumnFamilyHandle* column_family, const Slice& key,
-                       const Slice& value) override {
+                       const Slice& value) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
  using DBImpl::Delete;
  virtual Status Delete(const WriteOptions& options,
-                        ColumnFamilyHandle* column_family,
-                        const Slice& key) override {
+                        ColumnFamilyHandle* column_family, const Slice& key) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
-  virtual Status Write(const WriteOptions& options,
-                       WriteBatch* updates) override {
+  virtual Status Write(const WriteOptions& options, WriteBatch* updates) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
  using DBImpl::CompactRange;
  virtual Status CompactRange(ColumnFamilyHandle* column_family,
                              const Slice* begin, const Slice* end,
-                              bool reduce_level = false, int target_level = -1,
-                              uint32_t target_path_id = 0) override {
+                              bool reduce_level = false,
+                              int target_level = -1) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
-
-#ifndef ROCKSDB_LITE
-  virtual Status DisableFileDeletions() override {
+  virtual Status DisableFileDeletions() {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
-  virtual Status EnableFileDeletions(bool force) override {
+  virtual Status EnableFileDeletions(bool force) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
  virtual Status GetLiveFiles(std::vector<std::string>&,
                              uint64_t* manifest_file_size,
-                              bool flush_memtable = true) override {
+                              bool flush_memtable = true) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }
-#endif  // ROCKSDB_LITE
-
  using DBImpl::Flush;
  virtual Status Flush(const FlushOptions& options,
-                       ColumnFamilyHandle* column_family) override {
+                       ColumnFamilyHandle* column_family) {
    return Status::NotSupported("Not supported operation in read only mode.");
  }

@@ -10,8 +10,6 @@
 #include "db/db_iter.h"
 #include <stdexcept>
 #include <deque>
-#include <string>
-#include <limits>

 #include "db/filename.h"
 #include "db/dbformat.h"
@@ -71,8 +69,7 @@ class DBIter: public Iterator {
        valid_(false),
        current_entry_is_merged_(false),
        statistics_(options.statistics.get()) {
-    RecordTick(statistics_, NO_ITERATORS);
-    has_prefix_extractor_ = (options.prefix_extractor.get() != nullptr);
+    RecordTick(statistics_, NO_ITERATORS, 1);
    max_skip_ = options.max_sequential_skip_in_iterations;
  }
  virtual ~DBIter() {
@@ -112,14 +109,9 @@ class DBIter: public Iterator {
  virtual void SeekToLast();

 private:
-  void PrevInternal();
-  void FindParseableKey(ParsedInternalKey* ikey, Direction direction);
-  bool FindValueForCurrentKey();
-  bool FindValueForCurrentKeyUsingSeek();
-  void FindPrevUserKey();
-  void FindNextUserKey();
  inline void FindNextUserEntry(bool skipping);
  void FindNextUserEntryInternal(bool skipping);
+  void FindPrevUserEntry();
  bool ParseKey(ParsedInternalKey* key);
  void MergeValuesNewToOld();

@@ -132,7 +124,6 @@ class DBIter: public Iterator {
    }
  }

-  bool has_prefix_extractor_;
  bool arena_mode_;
  Env* const env_;
  Logger* logger_;
@@ -142,8 +133,8 @@ class DBIter: public Iterator {
  SequenceNumber const sequence_;

  Status status_;
-  IterKey saved_key_;
-  std::string saved_value_;
+  IterKey saved_key_;   // == current key when direction_==kReverse
+  std::string saved_value_;   // == current raw value when direction_==kReverse
  Direction direction_;
  bool valid_;
  bool current_entry_is_merged_;
@@ -169,11 +160,20 @@ inline bool DBIter::ParseKey(ParsedInternalKey* ikey) {
 void DBIter::Next() {
  assert(valid_);

-  if (direction_ == kReverse) {
-    FindNextUserKey();
+  if (direction_ == kReverse) {  // Switch directions?
    direction_ = kForward;
+    // iter_ is pointing just before the entries for this->key(),
+    // so advance into the range of entries for this->key() and then
+    // use the normal skipping code below.
    if (!iter_->Valid()) {
      iter_->SeekToFirst();
+    } else {
+      iter_->Next();
+    }
+    if (!iter_->Valid()) {
+      valid_ = false;
+      saved_key_.Clear();
+      return;
    }
  }

@@ -185,6 +185,7 @@ void DBIter::Next() {
  FindNextUserEntry(true /* skipping the current user key */);
 }

+
 // PRE: saved_key_ has the current user key if skipping
 // POST: saved_key_ should have the next user key if valid_,
 //       if the current entry is a result of merge
@@ -194,8 +195,9 @@ void DBIter::Next() {
 // NOTE: In between, saved_key_ can point to a user key that has
 //       a delete marker
 inline void DBIter::FindNextUserEntry(bool skipping) {
-  PERF_TIMER_GUARD(find_next_user_entry_time);
+  PERF_TIMER_AUTO(find_next_user_entry_time);
  FindNextUserEntryInternal(skipping);
+  PERF_TIMER_STOP(find_next_user_entry_time);
 }

 // Actual implementation of DBIter::FindNextUserEntry()
@@ -325,243 +327,110 @@ void DBIter::MergeValuesNewToOld() {

 void DBIter::Prev() {
  assert(valid_);
-  if (direction_ == kForward) {
-    FindPrevUserKey();
-    direction_ = kReverse;
-  }
-  PrevInternal();
-}

-void DBIter::PrevInternal() {
-  if (!iter_->Valid()) {
-    valid_ = false;
-    return;
+  // Throw an exception now if merge_operator is provided
+  // TODO: support backward iteration
+  if (user_merge_operator_) {
+    Log(logger_, "Prev not supported yet if merge_operator is provided");
+    throw std::logic_error("DBIter::Prev backward iteration not supported"
+                           " if merge_operator is provided");
  }

-  ParsedInternalKey ikey;
-
-  while (iter_->Valid()) {
+  if (direction_ == kForward) {  // Switch directions?
+    // iter_ is pointing at the current entry.  Scan backwards until
+    // the key changes so we can use the normal reverse scanning code.
+    assert(iter_->Valid());  // Otherwise valid_ would have been false
    saved_key_.SetKey(ExtractUserKey(iter_->key()));
-    if (FindValueForCurrentKey()) {
-      valid_ = true;
+    while (true) {
+      iter_->Prev();
      if (!iter_->Valid()) {
+        valid_ = false;
+        saved_key_.Clear();
+        ClearSavedValue();
        return;
      }
-      FindParseableKey(&ikey, kReverse);
-      if (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) == 0) {
-        FindPrevUserKey();
+      if (user_comparator_->Compare(ExtractUserKey(iter_->key()),
+                                    saved_key_.GetKey()) < 0) {
+        break;
      }
-      return;
-    }
-    if (!iter_->Valid()) {
-      break;
-    }
-    FindParseableKey(&ikey, kReverse);
-    if (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) == 0) {
-
-      FindPrevUserKey();
    }
+    direction_ = kReverse;
  }
-  // We haven't found any key - iterator is not valid
-  assert(!iter_->Valid());
-  valid_ = false;
+
+  FindPrevUserEntry();
 }

-// This function checks, if the entry with biggest sequence_number <= sequence_
-// is non kTypeDeletion. If it's not, we save value in saved_value_
-bool DBIter::FindValueForCurrentKey() {
-  assert(iter_->Valid());
-  // Contains operands for merge operator.
-  std::deque<std::string> operands;
-  // last entry before merge (could be kTypeDeletion or kTypeValue)
-  ValueType last_not_merge_type = kTypeDeletion;
-  ValueType last_key_entry_type = kTypeDeletion;
+void DBIter::FindPrevUserEntry() {
+  assert(direction_ == kReverse);
+  uint64_t num_skipped = 0;

-  ParsedInternalKey ikey;
-  FindParseableKey(&ikey, kReverse);
-
-  size_t num_skipped = 0;
-  while (iter_->Valid() && ikey.sequence <= sequence_ &&
-         (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) == 0)) {
-    // We iterate too much: let's use Seek() to avoid too much key comparisons
-    if (num_skipped >= max_skip_) {
-      return FindValueForCurrentKeyUsingSeek();
-    }
-
-    last_key_entry_type = ikey.type;
-    switch (last_key_entry_type) {
-      case kTypeValue:
-        operands.clear();
-        saved_value_ = iter_->value().ToString();
-        last_not_merge_type = kTypeValue;
-        break;
-      case kTypeDeletion:
-        operands.clear();
-        last_not_merge_type = kTypeDeletion;
-        break;
-      case kTypeMerge:
-        assert(user_merge_operator_ != nullptr);
-        operands.push_back(iter_->value().ToString());
-        break;
-      default:
-        assert(false);
-    }
-
-    assert(user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) == 0);
-    iter_->Prev();
-    ++num_skipped;
-    FindParseableKey(&ikey, kReverse);
-  }
-
-  switch (last_key_entry_type) {
-    case kTypeDeletion:
-      valid_ = false;
-      return false;
-    case kTypeMerge:
-      if (last_not_merge_type == kTypeDeletion) {
-        user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr, operands,
-                                        &saved_value_, logger_);
+  ValueType value_type = kTypeDeletion;
+  bool saved_key_valid = true;
+  if (iter_->Valid()) {
+    do {
+      ParsedInternalKey ikey;
+      if (ParseKey(&ikey) && ikey.sequence <= sequence_) {
+        if ((value_type != kTypeDeletion) &&
+            user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) < 0) {
+          // We encountered a non-deleted value in entries for previous keys,
+          break;
+        }
+        value_type = ikey.type;
+        if (value_type == kTypeDeletion) {
+          saved_key_.Clear();
+          ClearSavedValue();
+          saved_key_valid = false;
+        } else {
+          Slice raw_value = iter_->value();
+          if (saved_value_.capacity() > raw_value.size() + 1048576) {
+            std::string empty;
+            swap(empty, saved_value_);
+          }
+          saved_key_.SetKey(ExtractUserKey(iter_->key()));
+          saved_value_.assign(raw_value.data(), raw_value.size());
+        }
      } else {
-        assert(last_not_merge_type == kTypeValue);
-        std::string last_put_value = saved_value_;
-        Slice temp_slice(last_put_value);
-        user_merge_operator_->FullMerge(saved_key_.GetKey(), &temp_slice,
-                                        operands, &saved_value_, logger_);
+        // In the case of ikey.sequence > sequence_, we might have already
+        // iterated to a different user key.
+        saved_key_valid = false;
      }
-      break;
-    case kTypeValue:
-      // do nothing - we've already has value in saved_value_
-      break;
-    default:
-      assert(false);
-      break;
+      num_skipped++;
+      // If we have sequentially iterated via numerous keys and still not
+      // found the prev user-key, then it is better to seek so that we can
+      // avoid too many key comparisons. We seek to the first occurence of
+      // our current key by looking for max sequence number.
+      if (saved_key_valid && num_skipped > max_skip_) {
+        num_skipped = 0;
+        std::string last_key;
+        AppendInternalKey(&last_key, ParsedInternalKey(saved_key_.GetKey(),
+                                                       kMaxSequenceNumber,
+                                                       kValueTypeForSeek));
+        iter_->Seek(last_key);
+        RecordTick(statistics_, NUMBER_OF_RESEEKS_IN_ITERATION);
+      } else {
+        iter_->Prev();
+      }
+    } while (iter_->Valid());
  }
-  valid_ = true;
-  return true;
-}

-// This function is used in FindValueForCurrentKey.
-// We use Seek() function instead of Prev() to find necessary value
-bool DBIter::FindValueForCurrentKeyUsingSeek() {
-  std::string last_key;
-  AppendInternalKey(&last_key, ParsedInternalKey(saved_key_.GetKey(), sequence_,
-                                                 kValueTypeForSeek));
-  iter_->Seek(last_key);
-  RecordTick(statistics_, NUMBER_OF_RESEEKS_IN_ITERATION);
-
-  // assume there is at least one parseable key for this user key
-  ParsedInternalKey ikey;
-  FindParseableKey(&ikey, kForward);
-
-  if (ikey.type == kTypeValue || ikey.type == kTypeDeletion) {
-    if (ikey.type == kTypeValue) {
-      saved_value_ = iter_->value().ToString();
-      valid_ = true;
-      return true;
-    }
+  if (value_type == kTypeDeletion) {
+    // End
    valid_ = false;
-    return false;
-  }
-
-  // kTypeMerge. We need to collect all kTypeMerge values and save them
-  // in operands
-  std::deque<std::string> operands;
-  while (iter_->Valid() &&
-         (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) == 0) &&
-         ikey.type == kTypeMerge) {
-    operands.push_front(iter_->value().ToString());
-    iter_->Next();
-    FindParseableKey(&ikey, kForward);
-  }
-
-  if (!iter_->Valid() ||
-      (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) != 0) ||
-      ikey.type == kTypeDeletion) {
-    user_merge_operator_->FullMerge(saved_key_.GetKey(), nullptr, operands,
-                                    &saved_value_, logger_);
-
-    // Make iter_ valid and point to saved_key_
-    if (!iter_->Valid() ||
-        (user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) != 0)) {
-      iter_->Seek(last_key);
-      RecordTick(statistics_, NUMBER_OF_RESEEKS_IN_ITERATION);
-    }
+    saved_key_.Clear();
+    ClearSavedValue();
+    direction_ = kForward;
+  } else {
    valid_ = true;
-    return true;
-  }
-
-  const Slice& value = iter_->value();
-  user_merge_operator_->FullMerge(saved_key_.GetKey(), &value, operands,
-                                  &saved_value_, logger_);
-  valid_ = true;
-  return true;
-}
-
-// Used in Next to change directions
-// Go to next user key
-// Don't use Seek(),
-// because next user key will be very close
-void DBIter::FindNextUserKey() {
-  if (!iter_->Valid()) {
-    return;
-  }
-  ParsedInternalKey ikey;
-  FindParseableKey(&ikey, kForward);
-  while (iter_->Valid() &&
-         user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) != 0) {
-    iter_->Next();
-    FindParseableKey(&ikey, kForward);
-  }
-}
-
-// Go to previous user_key
-void DBIter::FindPrevUserKey() {
-  if (!iter_->Valid()) {
-    return;
-  }
-  size_t num_skipped = 0;
-  ParsedInternalKey ikey;
-  FindParseableKey(&ikey, kReverse);
-  while (iter_->Valid() &&
-         user_comparator_->Compare(ikey.user_key, saved_key_.GetKey()) == 0) {
-    if (num_skipped >= max_skip_) {
-      num_skipped = 0;
-      IterKey last_key;
-      last_key.SetInternalKey(ParsedInternalKey(
-          saved_key_.GetKey(), kMaxSequenceNumber, kValueTypeForSeek));
-      iter_->Seek(last_key.GetKey());
-      RecordTick(statistics_, NUMBER_OF_RESEEKS_IN_ITERATION);
-    }
-
-    iter_->Prev();
-    ++num_skipped;
-    FindParseableKey(&ikey, kReverse);
-  }
-}
-
-// Skip all unparseable keys
-void DBIter::FindParseableKey(ParsedInternalKey* ikey, Direction direction) {
-  while (iter_->Valid() && !ParseKey(ikey)) {
-    if (direction == kReverse) {
-      iter_->Prev();
-    } else {
-      iter_->Next();
-    }
  }
 }

 void DBIter::Seek(const Slice& target) {
-  StopWatch sw(env_, statistics_, DB_SEEK);
-
  saved_key_.Clear();
  // now savved_key is used to store internal key.
  saved_key_.SetInternalKey(target, sequence_);
-
-  {
-    PERF_TIMER_GUARD(seek_internal_seek_time);
-    iter_->Seek(saved_key_.GetKey());
-  }
-
+  PERF_TIMER_AUTO(seek_internal_seek_time);
+  iter_->Seek(saved_key_.GetKey());
+  PERF_TIMER_STOP(seek_internal_seek_time);
  if (iter_->Valid()) {
    direction_ = kForward;
    ClearSavedValue();
@@ -572,19 +441,11 @@ void DBIter::Seek(const Slice& target) {
 }

 void DBIter::SeekToFirst() {
-  // Don't use iter_::Seek() if we set a prefix extractor
-  // because prefix seek wiil be used.
-  if (has_prefix_extractor_) {
-    max_skip_ = std::numeric_limits<uint64_t>::max();
-  }
  direction_ = kForward;
  ClearSavedValue();
-
-  {
-    PERF_TIMER_GUARD(seek_internal_seek_time);
-    iter_->SeekToFirst();
-  }
-
+  PERF_TIMER_AUTO(seek_internal_seek_time);
+  iter_->SeekToFirst();
+  PERF_TIMER_STOP(seek_internal_seek_time);
  if (iter_->Valid()) {
    FindNextUserEntry(false /* not skipping */);
  } else {
@@ -593,20 +454,20 @@ void DBIter::SeekToFirst() {
 }

 void DBIter::SeekToLast() {
-  // Don't use iter_::Seek() if we set a prefix extractor
-  // because prefix seek wiil be used.
-  if (has_prefix_extractor_) {
-    max_skip_ = std::numeric_limits<uint64_t>::max();
+  // Throw an exception for now if merge_operator is provided
+  // TODO: support backward iteration
+  if (user_merge_operator_) {
+    Log(logger_, "SeekToLast not supported yet if merge_operator is provided");
+    throw std::logic_error("DBIter::SeekToLast: backward iteration not"
+                           " supported if merge_operator is provided");
  }
+
  direction_ = kReverse;
  ClearSavedValue();
-
-  {
-    PERF_TIMER_GUARD(seek_internal_seek_time);
-    iter_->SeekToLast();
-  }
-
-  PrevInternal();
+  PERF_TIMER_AUTO(seek_internal_seek_time);
+  iter_->SeekToLast();
+  PERF_TIMER_STOP(seek_internal_seek_time);
+  FindPrevUserEntry();
 }

 Iterator* NewDBIterator(Env* env, const Options& options,
@@ -0,0 +1,95 @@
+//  Copyright (c) 2013, 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.
+//
+// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+// 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.
+
+#include "db/db_impl.h"
+#include <string>
+#include <stdint.h>
+#include <stdio.h>
+#include "db/version_set.h"
+#include "rocksdb/db.h"
+#include "rocksdb/env.h"
+#include "port/port.h"
+#include "util/mutexlock.h"
+
+namespace rocksdb {
+
+void DBImpl::MaybeScheduleLogDBDeployStats() {
+// we did say maybe
+#ifndef ROCKSDB_LITE
+  // There is a lock in the actual logger.
+  if (!logger_ || options_.db_stats_log_interval < 0
+      || host_name_.empty()) {
+    return;
+  }
+
+  if(bg_logstats_scheduled_ || shutting_down_.Acquire_Load()) {
+    // Already scheduled
+  } else {
+    int64_t current_ts = 0;
+    Status st = env_->GetCurrentTime(&current_ts);
+    if (!st.ok()) {
+      return;
+    }
+    if ((current_ts - last_log_ts) < options_.db_stats_log_interval) {
+      return;
+    }
+    last_log_ts = current_ts;
+    bg_logstats_scheduled_ = true;
+    env_->Schedule(&DBImpl::BGLogDBDeployStats, this);
+  }
+}
+
+void DBImpl::BGLogDBDeployStats(void* db) {
+  DBImpl* db_inst = reinterpret_cast<DBImpl*>(db);
+  db_inst->LogDBDeployStats();
+}
+
+void DBImpl::LogDBDeployStats() {
+  mutex_.Lock();
+
+  if (shutting_down_.Acquire_Load()) {
+    bg_logstats_scheduled_ = false;
+    bg_cv_.SignalAll();
+    mutex_.Unlock();
+    return;
+  }
+
+  char tmp_ver[100];
+  sprintf(tmp_ver, "%d.%d", kMajorVersion, kMinorVersion);
+  std::string version_info(tmp_ver);
+
+  uint64_t file_total_size = 0;
+  uint32_t file_total_num = 0;
+  Version* current = default_cf_handle_->cfd()->current();
+  for (int i = 0; i < current->NumberLevels(); i++) {
+    file_total_num += current->NumLevelFiles(i);
+    file_total_size += current->NumLevelBytes(i);
+  }
+
+  Version::LevelSummaryStorage scratch;
+  const char* file_num_summary = current->LevelSummary(&scratch);
+  std::string file_num_per_level(file_num_summary);
+  std::string data_size_per_level(file_num_summary);
+
+  mutex_.Unlock();
+
+  int64_t unix_ts;
+  env_->GetCurrentTime(&unix_ts);
+
+  logger_->Log_Deploy_Stats(version_info, host_name_,
+      db_absolute_path_, file_total_size, file_total_num, file_num_per_level,
+      data_size_per_level, unix_ts);
+
+  mutex_.Lock();
+  bg_logstats_scheduled_ = false;
+  bg_cv_.SignalAll();
+  mutex_.Unlock();
+#endif
+}
+}
@@ -127,6 +127,26 @@ void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
  }
 }

+const char* InternalFilterPolicy::Name() const {
+  return user_policy_->Name();
+}
+
+void InternalFilterPolicy::CreateFilter(const Slice* keys, int n,
+                                        std::string* dst) const {
+  // We rely on the fact that the code in table.cc does not mind us
+  // adjusting keys[].
+  Slice* mkey = const_cast<Slice*>(keys);
+  for (int i = 0; i < n; i++) {
+    mkey[i] = ExtractUserKey(keys[i]);
+    // TODO(sanjay): Suppress dups?
+  }
+  user_policy_->CreateFilter(keys, n, dst);
+}
+
+bool InternalFilterPolicy::KeyMayMatch(const Slice& key, const Slice& f) const {
+  return user_policy_->KeyMayMatch(ExtractUserKey(key), f);
+}
+
 LookupKey::LookupKey(const Slice& user_key, SequenceNumber s) {
  size_t usize = user_key.size();
  size_t needed = usize + 13;  // A conservative estimate
@@ -9,7 +9,6 @@

 #pragma once
 #include <stdio.h>
-#include <string>
 #include "rocksdb/comparator.h"
 #include "rocksdb/db.h"
 #include "rocksdb/filter_policy.h"
@@ -124,6 +123,17 @@ class InternalKeyComparator : public Comparator {
  int Compare(const ParsedInternalKey& a, const ParsedInternalKey& b) const;
 };

+// Filter policy wrapper that converts from internal keys to user keys
+class InternalFilterPolicy : public FilterPolicy {
+ private:
+  const FilterPolicy* const user_policy_;
+ public:
+  explicit InternalFilterPolicy(const FilterPolicy* p) : user_policy_(p) { }
+  virtual const char* Name() const;
+  virtual void CreateFilter(const Slice* keys, int n, std::string* dst) const;
+  virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const;
+};
+
 // Modules in this directory should keep internal keys wrapped inside
 // the following class instead of plain strings so that we do not
 // incorrectly use string comparisons instead of an InternalKeyComparator.
@@ -244,38 +254,8 @@ class IterKey {

  Slice GetKey() const { return Slice(key_, key_size_); }

-  const size_t Size() { return key_size_; }
-
  void Clear() { key_size_ = 0; }

-  // Append "non_shared_data" to its back, from "shared_len"
-  // This function is used in Block::Iter::ParseNextKey
-  // shared_len: bytes in [0, shard_len-1] would be remained
-  // non_shared_data: data to be append, its length must be >= non_shared_len
-  void TrimAppend(const size_t shared_len, const char* non_shared_data,
-                  const size_t non_shared_len) {
-    assert(shared_len <= key_size_);
-
-    size_t total_size = shared_len + non_shared_len;
-    if (total_size <= buf_size_) {
-      key_size_ = total_size;
-    } else {
-      // Need to allocate space, delete previous space
-      char* p = new char[total_size];
-      memcpy(p, key_, shared_len);
-
-      if (key_ != nullptr && key_ != space_) {
-        delete[] key_;
-      }
-
-      key_ = p;
-      key_size_ = total_size;
-      buf_size_ = total_size;
-    }
-
-    memcpy(key_ + shared_len, non_shared_data, non_shared_len);
-  }
-
  void SetKey(const Slice& key) {
    size_t size = key.size();
    EnlargeBufferIfNeeded(size);
@@ -390,12 +370,4 @@ class InternalKeySliceTransform : public SliceTransform {
  const SliceTransform* const transform_;
 };

-// Read record from a write batch piece from input.
-// tag, column_family, key, value and blob are return values. Callers own the
-// Slice they point to.
-// Tag is defined as ValueType.
-// input will be advanced to after the record.
-extern Status ReadRecordFromWriteBatch(Slice* input, char* tag,
-                                       uint32_t* column_family, Slice* key,
-                                       Slice* value, Slice* blob);
 }  // namespace rocksdb
@@ -110,45 +110,6 @@ TEST(FormatTest, InternalKeyShortestSuccessor) {
            ShortSuccessor(IKey("\xff\xff", 100, kTypeValue)));
 }

-TEST(FormatTest, IterKeyOperation) {
-  IterKey k;
-  const char p[] = "abcdefghijklmnopqrstuvwxyz";
-  const char q[] = "0123456789";
-
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string(""));
-
-  k.TrimAppend(0, p, 3);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("abc"));
-
-  k.TrimAppend(1, p, 3);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("aabc"));
-
-  k.TrimAppend(0, p, 26);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("abcdefghijklmnopqrstuvwxyz"));
-
-  k.TrimAppend(26, q, 10);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("abcdefghijklmnopqrstuvwxyz0123456789"));
-
-  k.TrimAppend(36, q, 1);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("abcdefghijklmnopqrstuvwxyz01234567890"));
-
-  k.TrimAppend(26, q, 1);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("abcdefghijklmnopqrstuvwxyz0"));
-
-  // Size going up, memory allocation is triggered
-  k.TrimAppend(27, p, 26);
-  ASSERT_EQ(std::string(k.GetKey().data(), k.GetKey().size()),
-            std::string("abcdefghijklmnopqrstuvwxyz0"
-              "abcdefghijklmnopqrstuvwxyz"));
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -14,15 +14,21 @@

 namespace rocksdb {

-FileIndexer::FileIndexer(const Comparator* ucmp)
-    : num_levels_(0), ucmp_(ucmp), level_rb_(nullptr) {}
+FileIndexer::FileIndexer(const uint32_t num_levels,
+                         const Comparator* ucmp)
+  : num_levels_(num_levels),
+    ucmp_(ucmp),
+    next_level_index_(num_levels),
+    level_rb_(num_levels, -1) {
+}
+

 uint32_t FileIndexer::NumLevelIndex() {
  return next_level_index_.size();
 }

 uint32_t FileIndexer::LevelIndexSize(uint32_t level) {
-  return next_level_index_[level].num_index;
+  return next_level_index_[level].size();
 }

 void FileIndexer::GetNextLevelIndex(
@@ -40,13 +46,11 @@ void FileIndexer::GetNextLevelIndex(
  assert(level < num_levels_ - 1);
  assert(static_cast<int32_t>(file_index) <= level_rb_[level]);

-  const IndexUnit* index_units = next_level_index_[level].index_units;
-  const auto& index = index_units[file_index];
+  const auto& index = next_level_index_[level][file_index];

  if (cmp_smallest < 0) {
-    *left_bound = (level > 0 && file_index > 0)
-                      ? index_units[file_index - 1].largest_lb
-                      : 0;
+    *left_bound = (level > 0 && file_index > 0) ?
+      next_level_index_[level][file_index - 1].largest_lb : 0;
    *right_bound = index.smallest_rb;
  } else if (cmp_smallest == 0) {
    *left_bound = index.smallest_lb;
@@ -69,25 +73,16 @@ void FileIndexer::GetNextLevelIndex(
  assert(*right_bound <= level_rb_[level + 1]);
 }

-void FileIndexer::UpdateIndex(Arena* arena, const uint32_t num_levels,
-                              std::vector<FileMetaData*>* const files) {
+void FileIndexer::ClearIndex() {
+  for (uint32_t level = 1; level < num_levels_; ++level) {
+    next_level_index_[level].clear();
+  }
+}
+
+void FileIndexer::UpdateIndex(std::vector<FileMetaData*>* const files) {
  if (files == nullptr) {
    return;
  }
-  if (num_levels == 0) {  // uint_32 0-1 would cause bad behavior
-    num_levels_ = num_levels;
-    return;
-  }
-  assert(level_rb_ == nullptr);  // level_rb_ should be init here
-
-  num_levels_ = num_levels;
-  next_level_index_.resize(num_levels);
-
-  char* mem = arena->AllocateAligned(num_levels_ * sizeof(int32_t));
-  level_rb_ = new (mem) int32_t[num_levels_];
-  for (size_t i = 0; i < num_levels_; i++) {
-    level_rb_[i] = -1;
-  }

  // L1 - Ln-1
  for (uint32_t level = 1; level < num_levels_ - 1; ++level) {
@@ -98,56 +93,55 @@ void FileIndexer::UpdateIndex(Arena* arena, const uint32_t num_levels,
    if (upper_size == 0) {
      continue;
    }
-    IndexLevel& index_level = next_level_index_[level];
-    index_level.num_index = upper_size;
-    char* mem = arena->AllocateAligned(upper_size * sizeof(IndexUnit));
-    index_level.index_units = new (mem) IndexUnit[upper_size];
+    auto& index = next_level_index_[level];
+    index.resize(upper_size);

-    CalculateLB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData * a, const FileMetaData * b)->int {
+    CalculateLB(upper_files, lower_files, &index,
+        [this](const FileMetaData* a, const FileMetaData* b) -> int {
          return ucmp_->Compare(a->smallest.user_key(), b->largest.user_key());
        },
-        [](IndexUnit* index, int32_t f_idx) { index->smallest_lb = f_idx; });
-    CalculateLB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData * a, const FileMetaData * b)->int {
+        [](IndexUnit* index, int32_t f_idx) {
+          index->smallest_lb = f_idx;
+        });
+    CalculateLB(upper_files, lower_files, &index,
+        [this](const FileMetaData* a, const FileMetaData* b) -> int {
          return ucmp_->Compare(a->largest.user_key(), b->largest.user_key());
        },
-        [](IndexUnit* index, int32_t f_idx) { index->largest_lb = f_idx; });
-    CalculateRB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData * a, const FileMetaData * b)->int {
+        [](IndexUnit* index, int32_t f_idx) {
+          index->largest_lb = f_idx;
+        });
+    CalculateRB(upper_files, lower_files, &index,
+        [this](const FileMetaData* a, const FileMetaData* b) -> int {
          return ucmp_->Compare(a->smallest.user_key(), b->smallest.user_key());
        },
-        [](IndexUnit* index, int32_t f_idx) { index->smallest_rb = f_idx; });
-    CalculateRB(
-        upper_files, lower_files, &index_level,
-        [this](const FileMetaData * a, const FileMetaData * b)->int {
+        [](IndexUnit* index, int32_t f_idx) {
+          index->smallest_rb = f_idx;
+        });
+    CalculateRB(upper_files, lower_files, &index,
+        [this](const FileMetaData* a, const FileMetaData* b) -> int {
          return ucmp_->Compare(a->largest.user_key(), b->smallest.user_key());
        },
-        [](IndexUnit* index, int32_t f_idx) { index->largest_rb = f_idx; });
+        [](IndexUnit* index, int32_t f_idx) {
+          index->largest_rb = f_idx;
+        });
  }
-
  level_rb_[num_levels_ - 1] = files[num_levels_ - 1].size() - 1;
 }

-void FileIndexer::CalculateLB(
-    const std::vector<FileMetaData*>& upper_files,
-    const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
+void FileIndexer::CalculateLB(const std::vector<FileMetaData*>& upper_files,
+    const std::vector<FileMetaData*>& lower_files,
+    std::vector<IndexUnit>* index,
    std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
    std::function<void(IndexUnit*, int32_t)> set_index) {
  const int32_t upper_size = upper_files.size();
  const int32_t lower_size = lower_files.size();
  int32_t upper_idx = 0;
  int32_t lower_idx = 0;
-
-  IndexUnit* index = index_level->index_units;
  while (upper_idx < upper_size && lower_idx < lower_size) {
    int cmp = cmp_op(upper_files[upper_idx], lower_files[lower_idx]);

    if (cmp == 0) {
-      set_index(&index[upper_idx], lower_idx);
+      set_index(&(*index)[upper_idx], lower_idx);
      ++upper_idx;
      ++lower_idx;
    } else if (cmp > 0) {
@@ -157,7 +151,7 @@ void FileIndexer::CalculateLB(
    } else {
      // Lower level's file becomes larger, update the index, and
      // move to the next upper file
-      set_index(&index[upper_idx], lower_idx);
+      set_index(&(*index)[upper_idx], lower_idx);
      ++upper_idx;
    }
  }
@@ -165,27 +159,25 @@ void FileIndexer::CalculateLB(
  while (upper_idx < upper_size) {
    // Lower files are exhausted, that means the remaining upper files are
    // greater than any lower files. Set the index to be the lower level size.
-    set_index(&index[upper_idx], lower_size);
+    set_index(&(*index)[upper_idx], lower_size);
    ++upper_idx;
  }
 }

-void FileIndexer::CalculateRB(
-    const std::vector<FileMetaData*>& upper_files,
-    const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
+void FileIndexer::CalculateRB(const std::vector<FileMetaData*>& upper_files,
+    const std::vector<FileMetaData*>& lower_files,
+    std::vector<IndexUnit>* index,
    std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
    std::function<void(IndexUnit*, int32_t)> set_index) {
  const int32_t upper_size = upper_files.size();
  const int32_t lower_size = lower_files.size();
  int32_t upper_idx = upper_size - 1;
  int32_t lower_idx = lower_size - 1;
-
-  IndexUnit* index = index_level->index_units;
  while (upper_idx >= 0 && lower_idx >= 0) {
    int cmp = cmp_op(upper_files[upper_idx], lower_files[lower_idx]);

    if (cmp == 0) {
-      set_index(&index[upper_idx], lower_idx);
+      set_index(&(*index)[upper_idx], lower_idx);
      --upper_idx;
      --lower_idx;
    } else if (cmp < 0) {
@@ -195,14 +187,14 @@ void FileIndexer::CalculateRB(
    } else {
      // Lower level's file becomes smaller, update the index, and move to
      // the next the upper file
-      set_index(&index[upper_idx], lower_idx);
+      set_index(&(*index)[upper_idx], lower_idx);
      --upper_idx;
    }
  }
  while (upper_idx >= 0) {
    // Lower files are exhausted, that means the remaining upper files are
    // smaller than any lower files. Set it to -1.
-    set_index(&index[upper_idx], -1);
+    set_index(&(*index)[upper_idx], -1);
    --upper_idx;
  }
 }
@@ -12,15 +12,11 @@
 #include <functional>
 #include <limits>
 #include <vector>
-#include "util/arena.h"
-#include "util/autovector.h"

 namespace rocksdb {

 class Comparator;
 struct FileMetaData;
-struct FdWithKeyRange;
-struct FileLevel;

 // The file tree structure in Version is prebuilt and the range of each file
 // is known. On Version::Get(), it uses binary search to find a potential file
@@ -40,7 +36,7 @@ struct FileLevel;
 // naive approach.
 class FileIndexer {
 public:
-  explicit FileIndexer(const Comparator* ucmp);
+  FileIndexer(const uint32_t num_levels, const Comparator* ucmp);

  uint32_t NumLevelIndex();

@@ -54,15 +50,16 @@ class FileIndexer {
    const uint32_t level, const uint32_t file_index, const int cmp_smallest,
    const int cmp_largest, int32_t* left_bound, int32_t* right_bound);

-  void UpdateIndex(Arena* arena, const uint32_t num_levels,
-                   std::vector<FileMetaData*>* const files);
+  void ClearIndex();
+
+  void UpdateIndex(std::vector<FileMetaData*>* const files);

  enum {
    kLevelMaxIndex = std::numeric_limits<int32_t>::max()
  };

 private:
-  uint32_t num_levels_;
+  const uint32_t num_levels_;
  const Comparator* ucmp_;

  struct IndexUnit {
@@ -113,28 +110,20 @@ class FileIndexer {
    int32_t largest_rb;
  };

-  // Data structure to store IndexUnits in a whole level
-  struct IndexLevel {
-    size_t num_index;
-    IndexUnit* index_units;
+  void CalculateLB(const std::vector<FileMetaData*>& upper_files,
+    const std::vector<FileMetaData*>& lower_files,
+    std::vector<IndexUnit>* index,
+    std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
+    std::function<void(IndexUnit*, int32_t)> set_index);

-    IndexLevel() : num_index(0), index_units(nullptr) {}
-  };
+  void CalculateRB(const std::vector<FileMetaData*>& upper_files,
+    const std::vector<FileMetaData*>& lower_files,
+    std::vector<IndexUnit>* index,
+    std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
+    std::function<void(IndexUnit*, int32_t)> set_index);

-  void CalculateLB(
-      const std::vector<FileMetaData*>& upper_files,
-      const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
-      std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
-      std::function<void(IndexUnit*, int32_t)> set_index);
-
-  void CalculateRB(
-      const std::vector<FileMetaData*>& upper_files,
-      const std::vector<FileMetaData*>& lower_files, IndexLevel* index_level,
-      std::function<int(const FileMetaData*, const FileMetaData*)> cmp_op,
-      std::function<void(IndexUnit*, int32_t)> set_index);
-
-  autovector<IndexLevel> next_level_index_;
-  int32_t* level_rb_;
+  std::vector<std::vector<IndexUnit>> next_level_index_;
+  std::vector<int32_t> level_rb_;
 };

 }  // namespace rocksdb
@@ -35,13 +35,16 @@ class IntComparator : public Comparator {
  void FindShortSuccessor(std::string* key) const {}
 };

+
 struct FileIndexerTest {
 public:
-  FileIndexerTest()
-      : kNumLevels(4), files(new std::vector<FileMetaData*>[kNumLevels]) {}
+  FileIndexerTest() :
+    kNumLevels(4), indexer(kNumLevels, &ucmp),
+    files(new std::vector<FileMetaData*>[kNumLevels]) {
+  }

  ~FileIndexerTest() {
-    ClearFiles();
+    Reset();
    delete[] files;
  }

@@ -56,13 +59,14 @@ struct FileIndexerTest {
    return InternalKey(Slice(reinterpret_cast<char*>(&v), 8), 0, kTypeValue);
  }

-  void ClearFiles() {
+  void Reset() {
    for (uint32_t i = 0; i < kNumLevels; ++i) {
      for (auto* f : files[i]) {
        delete f;
      }
      files[i].clear();
    }
+    indexer.ClearIndex();
  }

  void GetNextLevelIndex(const uint32_t level, const uint32_t file_index,
@@ -70,32 +74,23 @@ struct FileIndexerTest {
      int32_t* right_index) {
    *left_index = 100;
    *right_index = 100;
-    indexer->GetNextLevelIndex(level, file_index, cmp_smallest, cmp_largest,
-                               left_index, right_index);
+    indexer.GetNextLevelIndex(level, file_index, cmp_smallest, cmp_largest,
+        left_index, right_index);
  }

-  int32_t left = 100;
-  int32_t right = 100;
  const uint32_t kNumLevels;
  IntComparator ucmp;
-  FileIndexer* indexer;
+  FileIndexer indexer;

  std::vector<FileMetaData*>* files;
 };

-// Case 0: Empty
-TEST(FileIndexerTest, Empty) {
-  Arena arena;
-  indexer = new FileIndexer(&ucmp);
-  indexer->UpdateIndex(&arena, 0, files);
-  delete indexer;
-}
+TEST(FileIndexerTest, next_level_hint) {
+  for (uint32_t i = 0; i < kNumLevels; ++i) {
+    ASSERT_EQ(0U, indexer.LevelIndexSize(i));
+  }

-// Case 1: no overlap, files are on the left of next level files
-TEST(FileIndexerTest, no_overlap_left) {
-  Arena arena;
-  uint32_t kNumLevels = 4;
-  indexer = new FileIndexer(&ucmp);
+  // Case 1: no overlap, files are on the left of next level files
  // level 1
  AddFile(1, 100, 200);
  AddFile(1, 300, 400);
@@ -108,7 +103,9 @@ TEST(FileIndexerTest, no_overlap_left) {
  AddFile(3, 2500, 2600);
  AddFile(3, 2601, 2699);
  AddFile(3, 2700, 2800);
-  indexer->UpdateIndex(&arena, kNumLevels, files);
+  indexer.UpdateIndex(files);
+  int32_t left = 100;
+  int32_t right = 100;
  for (uint32_t level = 1; level < 3; ++level) {
    for (uint32_t f = 0; f < 3; ++f) {
      GetNextLevelIndex(level, f, -1, -1, &left, &right);
@@ -128,15 +125,12 @@ TEST(FileIndexerTest, no_overlap_left) {
      ASSERT_EQ(2, right);
    }
  }
-  delete indexer;
-  ClearFiles();
-}

-// Case 2: no overlap, files are on the right of next level files
-TEST(FileIndexerTest, no_overlap_right) {
-  Arena arena;
-  uint32_t kNumLevels = 4;
-  indexer = new FileIndexer(&ucmp);
+  // Case 2: no overlap, files are on the right of next level files
+  Reset();
+  for (uint32_t i = 1; i < kNumLevels; ++i) {
+    ASSERT_EQ(0U, indexer.LevelIndexSize(i));
+  }
  // level 1
  AddFile(1, 2100, 2200);
  AddFile(1, 2300, 2400);
@@ -149,7 +143,7 @@ TEST(FileIndexerTest, no_overlap_right) {
  AddFile(3, 500, 600);
  AddFile(3, 501, 699);
  AddFile(3, 700, 800);
-  indexer->UpdateIndex(&arena, kNumLevels, files);
+  indexer.UpdateIndex(files);
  for (uint32_t level = 1; level < 3; ++level) {
    for (uint32_t f = 0; f < 3; ++f) {
      GetNextLevelIndex(level, f, -1, -1, &left, &right);
@@ -172,16 +166,11 @@ TEST(FileIndexerTest, no_overlap_right) {
      ASSERT_EQ(2, right);
    }
  }
-  delete indexer;
-}

-// Case 3: empty L2
-TEST(FileIndexerTest, empty_L2) {
-  Arena arena;
-  uint32_t kNumLevels = 4;
-  indexer = new FileIndexer(&ucmp);
+  // Case 3: empty L2
+  Reset();
  for (uint32_t i = 1; i < kNumLevels; ++i) {
-    ASSERT_EQ(0U, indexer->LevelIndexSize(i));
+    ASSERT_EQ(0U, indexer.LevelIndexSize(i));
  }
  // level 1
  AddFile(1, 2100, 2200);
@@ -191,7 +180,7 @@ TEST(FileIndexerTest, empty_L2) {
  AddFile(3, 500, 600);
  AddFile(3, 501, 699);
  AddFile(3, 700, 800);
-  indexer->UpdateIndex(&arena, kNumLevels, files);
+  indexer.UpdateIndex(files);
  for (uint32_t f = 0; f < 3; ++f) {
    GetNextLevelIndex(1, f, -1, -1, &left, &right);
    ASSERT_EQ(0, left);
@@ -212,14 +201,13 @@ TEST(FileIndexerTest, empty_L2) {
    ASSERT_EQ(0, left);
    ASSERT_EQ(-1, right);
  }
-  delete indexer;
-  ClearFiles();
-}

-// Case 4: mixed
-TEST(FileIndexerTest, mixed) {
-  Arena arena;
-  indexer = new FileIndexer(&ucmp);
+
+  // Case 4: mixed
+  Reset();
+  for (uint32_t i = 1; i < kNumLevels; ++i) {
+    ASSERT_EQ(0U, indexer.LevelIndexSize(i));
+  }
  // level 1
  AddFile(1, 100, 200);
  AddFile(1, 250, 400);
@@ -234,7 +222,7 @@ TEST(FileIndexerTest, mixed) {
  AddFile(3, 0, 50);
  AddFile(3, 100, 200);
  AddFile(3, 201, 250);
-  indexer->UpdateIndex(&arena, kNumLevels, files);
+  indexer.UpdateIndex(files);
  // level 1, 0
  GetNextLevelIndex(1, 0, -1, -1, &left, &right);
  ASSERT_EQ(0, left);
@@ -333,8 +321,6 @@ TEST(FileIndexerTest, mixed) {
    ASSERT_EQ(3, left);
    ASSERT_EQ(2, right);
  }
-  delete indexer;
-  ClearFiles();
 }

 }  // namespace rocksdb
@@ -6,9 +6,8 @@
 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // 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.
-#define __STDC_FORMAT_MACROS
+
 #include "db/filename.h"
-#include <inttypes.h>

 #include <ctype.h>
 #include <stdio.h>
@@ -20,16 +19,14 @@
 namespace rocksdb {

 // Given a path, flatten the path name by replacing all chars not in
-// {[0-9,a-z,A-Z,-,_,.]} with _. And append '_LOG\0' at the end.
+// {[0-9,a-z,A-Z,-,_,.]} with _. And append '\0' at the end.
 // Return the number of chars stored in dest not including the trailing '\0'.
-static size_t GetInfoLogPrefix(const std::string& path, char* dest, int len) {
-  const char suffix[] = "_LOG";
+static int FlattenPath(const std::string& path, char* dest, int len) {
+  int write_idx = 0;
+  int i = 0;
+  int src_len = path.size();

-  size_t write_idx = 0;
-  size_t i = 0;
-  size_t src_len = path.size();
-
-  while (i < src_len && write_idx < len - sizeof(suffix)) {
+  while (i < src_len && write_idx < len - 1) {
    if ((path[i] >= 'a' && path[i] <= 'z') ||
        (path[i] >= '0' && path[i] <= '9') ||
        (path[i] >= 'A' && path[i] <= 'Z') ||
@@ -43,10 +40,8 @@ static size_t GetInfoLogPrefix(const std::string& path, char* dest, int len) {
    }
    i++;
  }
-  assert(sizeof(suffix) <= len - write_idx);
-  // "\0" is automatically added by snprintf
-  snprintf(dest + write_idx, len - write_idx, suffix);
-  write_idx += sizeof(suffix) - 1;
+
+  dest[write_idx] = '\0';
  return write_idx;
 }

@@ -76,29 +71,23 @@ std::string MakeTableFileName(const std::string& path, uint64_t number) {
  return MakeFileName(path, number, "sst");
 }

-std::string TableFileName(const std::vector<DbPath>& db_paths, uint64_t number,
-                          uint32_t path_id) {
+std::string TableFileName(const std::vector<std::string> db_paths,
+                          uint64_t number, uint32_t path_id) {
  assert(number > 0);
  std::string path;
  if (path_id >= db_paths.size()) {
-    path = db_paths.back().path;
+    path = db_paths.back();
  } else {
-    path = db_paths[path_id].path;
+    path = db_paths[path_id];
  }
  return MakeTableFileName(path, number);
 }

-const size_t kFormatFileNumberBufSize = 38;
-
-void FormatFileNumber(uint64_t number, uint32_t path_id, char* out_buf,
-                      size_t out_buf_size) {
+std::string FormatFileNumber(uint64_t number, uint32_t path_id) {
  if (path_id == 0) {
-    snprintf(out_buf, out_buf_size, "%" PRIu64, number);
+    return std::to_string(number);
  } else {
-    snprintf(out_buf, out_buf_size, "%" PRIu64
-                                    "(path "
-                                    "%" PRIu32 ")",
-             number, path_id);
+    return std::to_string(number) + "(path " + std::to_string(path_id) + ")";
  }
 }

@@ -122,26 +111,14 @@ std::string TempFileName(const std::string& dbname, uint64_t number) {
  return MakeFileName(dbname, number, "dbtmp");
 }

-InfoLogPrefix::InfoLogPrefix(bool has_log_dir,
-                             const std::string& db_absolute_path) {
-  if (!has_log_dir) {
-    const char kInfoLogPrefix[] = "LOG";
-    // "\0" is automatically added to the end
-    snprintf(buf, sizeof(buf), kInfoLogPrefix);
-    prefix = Slice(buf, sizeof(kInfoLogPrefix) - 1);
-  } else {
-    size_t len = GetInfoLogPrefix(db_absolute_path, buf, sizeof(buf));
-    prefix = Slice(buf, len);
-  }
-}
-
 std::string InfoLogFileName(const std::string& dbname,
    const std::string& db_path, const std::string& log_dir) {
  if (log_dir.empty())
    return dbname + "/LOG";

-  InfoLogPrefix info_log_prefix(true, db_path);
-  return log_dir + "/" + info_log_prefix.buf;
+  char flatten_db_path[256];
+  FlattenPath(db_path, flatten_db_path, 256);
+  return log_dir + "/" + flatten_db_path + "_LOG";
 }

 // Return the name of the old info log file for "dbname".
@@ -153,8 +130,9 @@ std::string OldInfoLogFileName(const std::string& dbname, uint64_t ts,
  if (log_dir.empty())
    return dbname + "/LOG.old." + buf;

-  InfoLogPrefix info_log_prefix(true, db_path);
-  return log_dir + "/" + info_log_prefix.buf + ".old." + buf;
+  char flatten_db_path[256];
+  FlattenPath(db_path, flatten_db_path, 256);
+  return log_dir + "/" + flatten_db_path + "_LOG.old." + buf;
 }

 std::string MetaDatabaseName(const std::string& dbname, uint64_t number) {
@@ -172,8 +150,8 @@ std::string IdentityFileName(const std::string& dbname) {
 //    dbname/IDENTITY
 //    dbname/CURRENT
 //    dbname/LOCK
-//    dbname/<info_log_name_prefix>
-//    dbname/<info_log_name_prefix>.old.[0-9]+
+//    dbname/LOG
+//    dbname/LOG.old.[0-9]+
 //    dbname/MANIFEST-[0-9]+
 //    dbname/[0-9]+.(log|sst)
 //    dbname/METADB-[0-9]+
@@ -182,12 +160,6 @@ bool ParseFileName(const std::string& fname,
                   uint64_t* number,
                   FileType* type,
                   WalFileType* log_type) {
-  return ParseFileName(fname, number, "", type, log_type);
-}
-
-bool ParseFileName(const std::string& fname, uint64_t* number,
-                   const Slice& info_log_name_prefix, FileType* type,
-                   WalFileType* log_type) {
  Slice rest(fname);
  if (fname.length() > 1 && fname[0] == '/') {
    rest.remove_prefix(1);
@@ -201,22 +173,18 @@ bool ParseFileName(const std::string& fname, uint64_t* number,
  } else if (rest == "LOCK") {
    *number = 0;
    *type = kDBLockFile;
-  } else if (info_log_name_prefix.size() > 0 &&
-             rest.starts_with(info_log_name_prefix)) {
-    rest.remove_prefix(info_log_name_prefix.size());
-    if (rest == "" || rest == ".old") {
-      *number = 0;
-      *type = kInfoLogFile;
-    } else if (rest.starts_with(".old.")) {
-      uint64_t ts_suffix;
-      // sizeof also counts the trailing '\0'.
-      rest.remove_prefix(sizeof(".old.") - 1);
-      if (!ConsumeDecimalNumber(&rest, &ts_suffix)) {
-        return false;
-      }
-      *number = ts_suffix;
-      *type = kInfoLogFile;
+  } else if (rest == "LOG" || rest == "LOG.old") {
+    *number = 0;
+    *type = kInfoLogFile;
+  } else if (rest.starts_with("LOG.old.")) {
+    uint64_t ts_suffix;
+    // sizeof also counts the trailing '\0'.
+    rest.remove_prefix(sizeof("LOG.old.") - 1);
+    if (!ConsumeDecimalNumber(&rest, &ts_suffix)) {
+      return false;
    }
+    *number = ts_suffix;
+    *type = kInfoLogFile;
  } else if (rest.starts_with("MANIFEST-")) {
    rest.remove_prefix(strlen("MANIFEST-"));
    uint64_t num;
@@ -58,14 +58,10 @@ extern std::string MakeTableFileName(const std::string& name, uint64_t number);
 // Return the name of the sstable with the specified number
 // in the db named by "dbname".  The result will be prefixed with
 // "dbname".
-extern std::string TableFileName(const std::vector<DbPath>& db_paths,
+extern std::string TableFileName(const std::vector<std::string> db_paths,
                                 uint64_t number, uint32_t path_id);

-// Sufficient buffer size for FormatFileNumber.
-extern const size_t kFormatFileNumberBufSize;
-
-extern void FormatFileNumber(uint64_t number, uint32_t path_id, char* out_buf,
-                             size_t out_buf_size);
+extern std::string FormatFileNumber(uint64_t number, uint32_t path_id);

 // Return the name of the descriptor file for the db named by
 // "dbname" and the specified incarnation number.  The result will be
@@ -86,16 +82,6 @@ extern std::string LockFileName(const std::string& dbname);
 // The result will be prefixed with "dbname".
 extern std::string TempFileName(const std::string& dbname, uint64_t number);

-// A helper structure for prefix of info log names.
-struct InfoLogPrefix {
-  char buf[260];
-  Slice prefix;
-  // Prefix with DB absolute path encoded
-  explicit InfoLogPrefix(bool has_log_dir, const std::string& db_absolute_path);
-  // Default Prefix
-  explicit InfoLogPrefix();
-};
-
 // Return the name of the info log file for "dbname".
 extern std::string InfoLogFileName(const std::string& dbname,
    const std::string& db_path="", const std::string& log_dir="");
@@ -117,13 +103,10 @@ extern std::string IdentityFileName(const std::string& dbname);
 // If filename is a rocksdb file, store the type of the file in *type.
 // The number encoded in the filename is stored in *number.  If the
 // filename was successfully parsed, returns true.  Else return false.
-// info_log_name_prefix is the path of info logs.
-extern bool ParseFileName(const std::string& filename, uint64_t* number,
-                          const Slice& info_log_name_prefix, FileType* type,
+extern bool ParseFileName(const std::string& filename,
+                          uint64_t* number,
+                          FileType* type,
                          WalFileType* log_type = nullptr);
-// Same as previous function, but skip info log files.
-extern bool ParseFileName(const std::string& filename, uint64_t* number,
-                          FileType* type, WalFileType* log_type = nullptr);

 // Make the CURRENT file point to the descriptor file with the
 // specified number.
@@ -23,50 +23,30 @@ TEST(FileNameTest, Parse) {
  FileType type;
  uint64_t number;

-  char kDefautInfoLogDir = 1;
-  char kDifferentInfoLogDir = 2;
-  char kNoCheckLogDir = 4;
-  char kAllMode = kDefautInfoLogDir | kDifferentInfoLogDir | kNoCheckLogDir;
-
  // Successful parses
  static struct {
    const char* fname;
    uint64_t number;
    FileType type;
-    char mode;
  } cases[] = {
-        {"100.log", 100, kLogFile, kAllMode},
-        {"0.log", 0, kLogFile, kAllMode},
-        {"0.sst", 0, kTableFile, kAllMode},
-        {"CURRENT", 0, kCurrentFile, kAllMode},
-        {"LOCK", 0, kDBLockFile, kAllMode},
-        {"MANIFEST-2", 2, kDescriptorFile, kAllMode},
-        {"MANIFEST-7", 7, kDescriptorFile, kAllMode},
-        {"METADB-2", 2, kMetaDatabase, kAllMode},
-        {"METADB-7", 7, kMetaDatabase, kAllMode},
-        {"LOG", 0, kInfoLogFile, kDefautInfoLogDir},
-        {"LOG.old", 0, kInfoLogFile, kDefautInfoLogDir},
-        {"LOG.old.6688", 6688, kInfoLogFile, kDefautInfoLogDir},
-        {"rocksdb_dir_LOG", 0, kInfoLogFile, kDifferentInfoLogDir},
-        {"rocksdb_dir_LOG.old", 0, kInfoLogFile, kDifferentInfoLogDir},
-        {"rocksdb_dir_LOG.old.6688", 6688, kInfoLogFile, kDifferentInfoLogDir},
-        {"18446744073709551615.log", 18446744073709551615ull, kLogFile,
-         kAllMode}, };
-  for (char mode : {kDifferentInfoLogDir, kDefautInfoLogDir, kNoCheckLogDir}) {
-    for (unsigned int i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
-      InfoLogPrefix info_log_prefix(mode != kDefautInfoLogDir, "/rocksdb/dir");
-      if (cases[i].mode & mode) {
-        std::string f = cases[i].fname;
-        if (mode == kNoCheckLogDir) {
-          ASSERT_TRUE(ParseFileName(f, &number, &type)) << f;
-        } else {
-          ASSERT_TRUE(ParseFileName(f, &number, info_log_prefix.prefix, &type))
-              << f;
-        }
-        ASSERT_EQ(cases[i].type, type) << f;
-        ASSERT_EQ(cases[i].number, number) << f;
-      }
-    }
+    { "100.log",            100,   kLogFile },
+    { "0.log",              0,     kLogFile },
+    { "0.sst",              0,     kTableFile },
+    { "CURRENT",            0,     kCurrentFile },
+    { "LOCK",               0,     kDBLockFile },
+    { "MANIFEST-2",         2,     kDescriptorFile },
+    { "MANIFEST-7",         7,     kDescriptorFile },
+    { "METADB-2",           2,     kMetaDatabase },
+    { "METADB-7",           7,     kMetaDatabase },
+    { "LOG",                0,     kInfoLogFile },
+    { "LOG.old",            0,     kInfoLogFile },
+    { "18446744073709551615.log", 18446744073709551615ull, kLogFile },
+  };
+  for (unsigned int i = 0; i < sizeof(cases) / sizeof(cases[0]); i++) {
+    std::string f = cases[i].fname;
+    ASSERT_TRUE(ParseFileName(f, &number, &type)) << f;
+    ASSERT_EQ(cases[i].type, type) << f;
+    ASSERT_EQ(cases[i].number, number) << f;
  }

  // Errors
@@ -105,22 +85,6 @@ TEST(FileNameTest, Parse) {
  };
 }

-TEST(FileNameTest, InfoLogFileName) {
-  std::string dbname = ("/data/rocksdb");
-  std::string db_absolute_path;
-  Env::Default()->GetAbsolutePath(dbname, &db_absolute_path);
-
-  ASSERT_EQ("/data/rocksdb/LOG", InfoLogFileName(dbname, db_absolute_path, ""));
-  ASSERT_EQ("/data/rocksdb/LOG.old.666",
-            OldInfoLogFileName(dbname, 666u, db_absolute_path, ""));
-
-  ASSERT_EQ("/data/rocksdb_log/data_rocksdb_LOG",
-            InfoLogFileName(dbname, db_absolute_path, "/data/rocksdb_log"));
-  ASSERT_EQ(
-      "/data/rocksdb_log/data_rocksdb_LOG.old.666",
-      OldInfoLogFileName(dbname, 666u, db_absolute_path, "/data/rocksdb_log"));
-}
-
 TEST(FileNameTest, Construction) {
  uint64_t number;
  FileType type;
@@ -144,9 +108,8 @@ TEST(FileNameTest, Construction) {
  ASSERT_EQ(192U, number);
  ASSERT_EQ(kLogFile, type);

-  fname = TableFileName({DbPath("bar", 0)}, 200, 0);
-  std::string fname1 =
-      TableFileName({DbPath("foo", 0), DbPath("bar", 0)}, 200, 1);
+  fname = TableFileName({"bar"}, 200, 0);
+  std::string fname1 = TableFileName({"foo", "bar"}, 200, 1);
  ASSERT_EQ(fname, fname1);
  ASSERT_EQ("bar/", std::string(fname.data(), 4));
  ASSERT_TRUE(ParseFileName(fname.c_str() + 4, &number, &type));
@@ -6,10 +6,9 @@
 #ifndef ROCKSDB_LITE
 #include "db/forward_iterator.h"

-#include <limits>
 #include <string>
 #include <utility>
-
+#include <limits>
 #include "db/db_impl.h"
 #include "db/db_iter.h"
 #include "db/column_family.h"
@@ -38,16 +37,12 @@ class LevelIterator : public Iterator {
    assert(file_index < files_.size());
    if (file_index != file_index_) {
      file_index_ = file_index;
-      Reset();
+      file_iter_.reset(cfd_->table_cache()->NewIterator(
+          read_options_, *(cfd_->soptions()), cfd_->internal_comparator(),
+          files_[file_index_]->fd, nullptr /* table_reader_ptr */, false));
    }
    valid_ = false;
  }
-  void Reset() {
-    assert(file_index_ < files_.size());
-    file_iter_.reset(cfd_->table_cache()->NewIterator(
-        read_options_, *(cfd_->soptions()), cfd_->internal_comparator(),
-        files_[file_index_]->fd, nullptr /* table_reader_ptr */, false));
-  }
  void SeekToLast() override {
    status_ = Status::NotSupported("LevelIterator::SeekToLast()");
    valid_ = false;
@@ -68,15 +63,12 @@ class LevelIterator : public Iterator {
    assert(file_iter_ != nullptr);
    file_iter_->Seek(internal_key);
    valid_ = file_iter_->Valid();
+    assert(valid_);
  }
  void Next() override {
    assert(valid_);
    file_iter_->Next();
-    for (;;) {
-      if (file_iter_->status().IsIncomplete() || file_iter_->Valid()) {
-        valid_ = !file_iter_->status().IsIncomplete();
-        return;
-      }
+    while (!file_iter_->Valid()) {
      if (file_index_ + 1 >= files_.size()) {
        valid_ = false;
        return;
@@ -84,6 +76,7 @@ class LevelIterator : public Iterator {
      SetFileIndex(file_index_ + 1);
      file_iter_->SeekToFirst();
    }
+    valid_ = file_iter_->Valid();
  }
  Slice key() const override {
    assert(valid_);
@@ -167,8 +160,6 @@ void ForwardIterator::SeekToFirst() {
  if (sv_ == nullptr ||
      sv_ ->version_number != cfd_->GetSuperVersionNumber()) {
    RebuildIterators();
-  } else if (status_.IsIncomplete()) {
-    ResetIncompleteIterators();
  }
  SeekInternal(Slice(), true);
 }
@@ -177,8 +168,6 @@ void ForwardIterator::Seek(const Slice& internal_key) {
  if (sv_ == nullptr ||
      sv_ ->version_number != cfd_->GetSuperVersionNumber()) {
    RebuildIterators();
-  } else if (status_.IsIncomplete()) {
-    ResetIncompleteIterators();
  }
  SeekInternal(internal_key, false);
 }
@@ -222,15 +211,7 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
        }
        l0_iters_[i]->Seek(internal_key);
      }
-
-      if (l0_iters_[i]->status().IsIncomplete()) {
-        // if any of the immutable iterators is incomplete (no-io option was
-        // used), we are unable to reliably find the smallest key
-        assert(read_options_.read_tier == kBlockCacheTier);
-        status_ = l0_iters_[i]->status();
-        valid_ = false;
-        return;
-      } else if (l0_iters_[i]->Valid()) {
+      if (l0_iters_[i]->Valid()) {
        immutable_min_heap_.push(l0_iters_[i]);
      }
    }
@@ -299,14 +280,7 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
        level_iters_[level - 1]->SetFileIndex(f_idx);
        seek_to_first ? level_iters_[level - 1]->SeekToFirst() :
                        level_iters_[level - 1]->Seek(internal_key);
-
-        if (level_iters_[level - 1]->status().IsIncomplete()) {
-          // see above
-          assert(read_options_.read_tier == kBlockCacheTier);
-          status_ = level_iters_[level - 1]->status();
-          valid_ = false;
-          return;
-        } else if (level_iters_[level - 1]->Valid()) {
+        if (level_iters_[level - 1]->Valid()) {
          immutable_min_heap_.push(level_iters_[level - 1]);
        }
      }
@@ -318,9 +292,6 @@ void ForwardIterator::SeekInternal(const Slice& internal_key,
      prev_key_.SetKey(internal_key);
      is_prev_set_ = true;
    }
-  } else if (current_ && current_ != mutable_iter_) {
-    // current_ is one of immutable iterators, push it back to the heap
-    immutable_min_heap_.push(current_);
  }

  UpdateCurrent();
@@ -330,7 +301,7 @@ void ForwardIterator::Next() {
  assert(valid_);

  if (sv_ == nullptr ||
-      sv_->version_number != cfd_->GetSuperVersionNumber()) {
+      sv_ ->version_number != cfd_->GetSuperVersionNumber()) {
    std::string current_key = key().ToString();
    Slice old_key(current_key.data(), current_key.size());

@@ -346,17 +317,9 @@ void ForwardIterator::Next() {
  }

  current_->Next();
-  if (current_ != mutable_iter_) {
-    if (current_->status().IsIncomplete()) {
-      assert(read_options_.read_tier == kBlockCacheTier);
-      status_ = current_->status();
-      valid_ = false;
-      return;
-    } else if (current_->Valid()) {
-      immutable_min_heap_.push(current_);
-    }
+  if (current_->Valid() && current_ != mutable_iter_) {
+    immutable_min_heap_.push(current_);
  }
-
  UpdateCurrent();
 }

@@ -423,29 +386,6 @@ void ForwardIterator::RebuildIterators() {
  is_prev_set_ = false;
 }

-void ForwardIterator::ResetIncompleteIterators() {
-  const auto& l0_files = sv_->current->files_[0];
-  for (uint32_t i = 0; i < l0_iters_.size(); ++i) {
-    assert(i < l0_files.size());
-    if (!l0_iters_[i]->status().IsIncomplete()) {
-      continue;
-    }
-    delete l0_iters_[i];
-    l0_iters_[i] = cfd_->table_cache()->NewIterator(
-        read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
-        l0_files[i]->fd);
-  }
-
-  for (auto* level_iter : level_iters_) {
-    if (level_iter && level_iter->status().IsIncomplete()) {
-      level_iter->Reset();
-    }
-  }
-
-  current_ = nullptr;
-  is_prev_set_ = false;
-}
-
 void ForwardIterator::UpdateCurrent() {
  if (immutable_min_heap_.empty() && !mutable_iter_->Valid()) {
    current_ = nullptr;
@@ -474,7 +414,7 @@ void ForwardIterator::UpdateCurrent() {
 }

 bool ForwardIterator::NeedToSeekImmutable(const Slice& target) {
-  if (!valid_ || !is_prev_set_) {
+  if (!is_prev_set_) {
    return true;
  }
  Slice prev_key = prev_key_.GetKey();
@@ -73,7 +73,6 @@ class ForwardIterator : public Iterator {
 private:
  void Cleanup();
  void RebuildIterators();
-  void ResetIncompleteIterators();
  void SeekInternal(const Slice& internal_key, bool seek_to_first);
  void UpdateCurrent();
  bool NeedToSeekImmutable(const Slice& internal_key);
@@ -7,97 +7,16 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #include "db/internal_stats.h"
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-#include <vector>
 #include "db/column_family.h"
-#include "db/db_impl.h"
+
+#include <vector>

 namespace rocksdb {

-namespace {
-const double kMB = 1048576.0;
-const double kGB = kMB * 1024;
-
-void PrintLevelStatsHeader(char* buf, size_t len, const std::string& cf_name) {
-  snprintf(
-      buf, len,
-      "\n** Compaction Stats [%s] **\n"
-      "Level   Files   Size(MB) Score Read(GB)  Rn(GB) Rnp1(GB) "
-      "Write(GB) Wnew(GB) RW-Amp W-Amp Rd(MB/s) Wr(MB/s)  Rn(cnt) "
-      "Rnp1(cnt) Wnp1(cnt) Wnew(cnt)  Comp(sec) Comp(cnt) Avg(sec) "
-      "Stall(sec) Stall(cnt) Avg(ms)\n"
-      "--------------------------------------------------------------------"
-      "--------------------------------------------------------------------"
-      "--------------------------------------------------------------------\n",
-      cf_name.c_str());
-}
-
-void PrintLevelStats(char* buf, size_t len, const std::string& name,
-    int num_files, int being_compacted, double total_file_size, double score,
-    double rw_amp, double w_amp, double stall_us, uint64_t stalls,
-    const InternalStats::CompactionStats& stats) {
-  uint64_t bytes_read = stats.bytes_readn + stats.bytes_readnp1;
-  uint64_t bytes_new = stats.bytes_written - stats.bytes_readnp1;
-  double elapsed = (stats.micros + 1) / 1000000.0;
-
-  snprintf(buf, len,
-    "%4s %5d/%-3d %8.0f %5.1f " /* Level, Files, Size(MB), Score */
-    "%8.1f " /* Read(GB) */
-    "%7.1f " /* Rn(GB) */
-    "%8.1f " /* Rnp1(GB) */
-    "%9.1f " /* Write(GB) */
-    "%8.1f " /* Wnew(GB) */
-    "%6.1f " /* RW-Amp */
-    "%5.1f " /* W-Amp */
-    "%8.1f " /* Rd(MB/s) */
-    "%8.1f " /* Wr(MB/s) */
-    "%8d " /* Rn(cnt) */
-    "%9d " /* Rnp1(cnt) */
-    "%9d " /* Wnp1(cnt) */
-    "%9d " /* Wnew(cnt) */
-    "%10.0f " /* Comp(sec) */
-    "%9d " /* Comp(cnt) */
-    "%8.3f " /* Avg(sec) */
-    "%10.2f " /* Stall(sec) */
-    "%10" PRIu64 " " /* Stall(cnt) */
-    "%7.2f\n" /* Avg(ms) */,
-    name.c_str(), num_files, being_compacted, total_file_size / kMB, score,
-    bytes_read / kGB,
-    stats.bytes_readn / kGB,
-    stats.bytes_readnp1 / kGB,
-    stats.bytes_written / kGB,
-    bytes_new / kGB,
-    rw_amp,
-    w_amp,
-    bytes_read / kMB / elapsed,
-    stats.bytes_written / kMB / elapsed,
-    stats.files_in_leveln,
-    stats.files_in_levelnp1,
-    stats.files_out_levelnp1,
-    stats.files_out_levelnp1 - stats.files_in_levelnp1,
-    stats.micros / 1000000.0,
-    stats.count,
-    stats.count == 0 ? 0 : stats.micros / 1000000.0 / stats.count,
-    stall_us / 1000000.0,
-    stalls,
-    stalls == 0 ? 0 : stall_us / 1000.0 / stalls);
-}
-
-
-}
-
-DBPropertyType GetPropertyType(const Slice& property, bool* is_int_property,
-                               bool* need_out_of_mutex) {
-  assert(is_int_property != nullptr);
-  assert(need_out_of_mutex != nullptr);
+DBPropertyType GetPropertyType(const Slice& property) {
  Slice in = property;
  Slice prefix("rocksdb.");
-  *need_out_of_mutex = false;
-  *is_int_property = false;
-  if (!in.starts_with(prefix)) {
-    return kUnknown;
-  }
+  if (!in.starts_with(prefix)) return kUnknown;
  in.remove_prefix(prefix.size());

  if (in.starts_with("num-files-at-level")) {
@@ -106,16 +25,9 @@ DBPropertyType GetPropertyType(const Slice& property, bool* is_int_property,
    return kLevelStats;
  } else if (in == "stats") {
    return kStats;
-  } else if (in == "cfstats") {
-    return kCFStats;
-  } else if (in == "dbstats") {
-    return kDBStats;
  } else if (in == "sstables") {
    return kSsTables;
-  }
-
-  *is_int_property = true;
-  if (in == "num-immutable-mem-table") {
+  } else if (in == "num-immutable-mem-table") {
    return kNumImmutableMemTable;
  } else if (in == "mem-table-flush-pending") {
    return kMemtableFlushPending;
@@ -129,37 +41,14 @@ DBPropertyType GetPropertyType(const Slice& property, bool* is_int_property,
    return kNumEntriesInMutableMemtable;
  } else if (in == "num-entries-imm-mem-tables") {
    return kNumEntriesInImmutableMemtable;
-  } else if (in == "estimate-num-keys") {
-    return kEstimatedNumKeys;
-  } else if (in == "estimate-table-readers-mem") {
-    *need_out_of_mutex = true;
-    return kEstimatedUsageByTableReaders;
-  } else if (in == "is-file-deletions-enabled") {
-    return kIsFileDeletionEnabled;
  }
  return kUnknown;
 }

-bool InternalStats::GetIntPropertyOutOfMutex(DBPropertyType property_type,
-                                             Version* version,
-                                             uint64_t* value) const {
-  assert(value != nullptr);
-  if (property_type != kEstimatedUsageByTableReaders) {
-    return false;
-  }
-  if (version == nullptr) {
-    *value = 0;
-  } else {
-    *value = version->GetMemoryUsageByTableReaders();
-  }
-  return true;
-}
-
-bool InternalStats::GetStringProperty(DBPropertyType property_type,
-                                      const Slice& property,
-                                      std::string* value) {
-  assert(value != nullptr);
-  Version* current = cfd_->current();
+bool InternalStats::GetProperty(DBPropertyType property_type,
+                                const Slice& property, std::string* value,
+                                ColumnFamilyData* cfd) {
+  Version* current = cfd->current();
  Slice in = property;

  switch (property_type) {
@@ -187,292 +76,294 @@ bool InternalStats::GetStringProperty(DBPropertyType property_type,
      for (int level = 0; level < number_levels_; level++) {
        snprintf(buf, sizeof(buf), "%3d %8d %8.0f\n", level,
                 current->NumLevelFiles(level),
-                 current->NumLevelBytes(level) / kMB);
+                 current->NumLevelBytes(level) / 1048576.0);
        value->append(buf);
      }
      return true;
    }
    case kStats: {
-      if (!GetStringProperty(kCFStats, "rocksdb.cfstats", value)) {
-        return false;
+      char buf[1000];
+
+      uint64_t wal_bytes = 0;
+      uint64_t wal_synced = 0;
+      uint64_t user_bytes_written = 0;
+      uint64_t write_other = 0;
+      uint64_t write_self = 0;
+      uint64_t write_with_wal = 0;
+      uint64_t total_bytes_written = 0;
+      uint64_t total_bytes_read = 0;
+      uint64_t micros_up = env_->NowMicros() - started_at_;
+      // Add "+1" to make sure seconds_up is > 0 and avoid NaN later
+      double seconds_up = (micros_up + 1) / 1000000.0;
+      uint64_t total_slowdown = 0;
+      uint64_t total_slowdown_count = 0;
+      uint64_t interval_bytes_written = 0;
+      uint64_t interval_bytes_read = 0;
+      uint64_t interval_bytes_new = 0;
+      double interval_seconds_up = 0;
+
+      if (statistics_) {
+        wal_bytes = statistics_->getTickerCount(WAL_FILE_BYTES);
+        wal_synced = statistics_->getTickerCount(WAL_FILE_SYNCED);
+        user_bytes_written = statistics_->getTickerCount(BYTES_WRITTEN);
+        write_other = statistics_->getTickerCount(WRITE_DONE_BY_OTHER);
+        write_self = statistics_->getTickerCount(WRITE_DONE_BY_SELF);
+        write_with_wal = statistics_->getTickerCount(WRITE_WITH_WAL);
      }
-      if (!GetStringProperty(kDBStats, "rocksdb.dbstats", value)) {
-        return false;
+
+      snprintf(
+          buf, sizeof(buf),
+          "                               Compactions\n"
+          "Level  Files Size(MB) Score Time(sec)  Read(MB) Write(MB)    Rn(MB) "
+          " "
+          "Rnp1(MB)  Wnew(MB) RW-Amplify Read(MB/s) Write(MB/s)      Rn     "
+          "Rnp1 "
+          "    Wnp1     NewW    Count   msComp   msStall  Ln-stall Stall-cnt\n"
+          "--------------------------------------------------------------------"
+          "--"
+          "--------------------------------------------------------------------"
+          "--"
+          "----------------------------------------------------------------\n");
+      value->append(buf);
+      for (int level = 0; level < number_levels_; level++) {
+        int files = current->NumLevelFiles(level);
+        if (compaction_stats_[level].micros > 0 || files > 0) {
+          int64_t bytes_read = compaction_stats_[level].bytes_readn +
+                               compaction_stats_[level].bytes_readnp1;
+          int64_t bytes_new = compaction_stats_[level].bytes_written -
+                              compaction_stats_[level].bytes_readnp1;
+          double amplify =
+              (compaction_stats_[level].bytes_readn == 0)
+                  ? 0.0
+                  : (compaction_stats_[level].bytes_written +
+                     compaction_stats_[level].bytes_readnp1 +
+                     compaction_stats_[level].bytes_readn) /
+                        (double)compaction_stats_[level].bytes_readn;
+
+          total_bytes_read += bytes_read;
+          total_bytes_written += compaction_stats_[level].bytes_written;
+
+          uint64_t stalls = level == 0 ? (stall_counts_[LEVEL0_SLOWDOWN] +
+                                          stall_counts_[LEVEL0_NUM_FILES] +
+                                          stall_counts_[MEMTABLE_COMPACTION])
+                                       : stall_leveln_slowdown_count_[level];
+
+          double stall_us = level == 0 ? (stall_micros_[LEVEL0_SLOWDOWN] +
+                                          stall_micros_[LEVEL0_NUM_FILES] +
+                                          stall_micros_[MEMTABLE_COMPACTION])
+                                       : stall_leveln_slowdown_[level];
+
+          snprintf(buf, sizeof(buf),
+                   "%3d %8d %8.0f %5.1f %9.0f %9.0f %9.0f %9.0f %9.0f %9.0f "
+                   "%10.1f %9.1f %11.1f %8d %8d %8d %8d %8d %8d %9.1f %9.1f "
+                   "%9lu\n",
+                   level, files, current->NumLevelBytes(level) / 1048576.0,
+                   current->NumLevelBytes(level) /
+                       cfd->compaction_picker()->MaxBytesForLevel(level),
+                   compaction_stats_[level].micros / 1e6,
+                   bytes_read / 1048576.0,
+                   compaction_stats_[level].bytes_written / 1048576.0,
+                   compaction_stats_[level].bytes_readn / 1048576.0,
+                   compaction_stats_[level].bytes_readnp1 / 1048576.0,
+                   bytes_new / 1048576.0, amplify,
+                   // +1 to avoid division by 0
+                   (bytes_read / 1048576.0) /
+                       ((compaction_stats_[level].micros + 1) / 1000000.0),
+                   (compaction_stats_[level].bytes_written / 1048576.0) /
+                       ((compaction_stats_[level].micros + 1) / 1000000.0),
+                   compaction_stats_[level].files_in_leveln,
+                   compaction_stats_[level].files_in_levelnp1,
+                   compaction_stats_[level].files_out_levelnp1,
+                   compaction_stats_[level].files_out_levelnp1 -
+                       compaction_stats_[level].files_in_levelnp1,
+                   compaction_stats_[level].count,
+                   (int)((double)compaction_stats_[level].micros / 1000.0 /
+                         (compaction_stats_[level].count + 1)),
+                   (double)stall_us / 1000.0 / (stalls + 1),
+                   stall_us / 1000000.0, (unsigned long)stalls);
+          total_slowdown += stall_leveln_slowdown_[level];
+          total_slowdown_count += stall_leveln_slowdown_count_[level];
+          value->append(buf);
+        }
      }
-      return true;
-    }
-    case kCFStats: {
-      DumpCFStats(value);
-      return true;
-    }
-    case kDBStats: {
-      DumpDBStats(value);
+
+      interval_bytes_new = user_bytes_written - last_stats_.ingest_bytes_;
+      interval_bytes_read =
+          total_bytes_read - last_stats_.compaction_bytes_read_;
+      interval_bytes_written =
+          total_bytes_written - last_stats_.compaction_bytes_written_;
+      interval_seconds_up = seconds_up - last_stats_.seconds_up_;
+
+      snprintf(buf, sizeof(buf), "Uptime(secs): %.1f total, %.1f interval\n",
+               seconds_up, interval_seconds_up);
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "Writes cumulative: %llu total, %llu batches, "
+               "%.1f per batch, %.2f ingest GB\n",
+               (unsigned long long)(write_other + write_self),
+               (unsigned long long)write_self,
+               (write_other + write_self) / (double)(write_self + 1),
+               user_bytes_written / (1048576.0 * 1024));
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "WAL cumulative: %llu WAL writes, %llu WAL syncs, "
+               "%.2f writes per sync, %.2f GB written\n",
+               (unsigned long long)write_with_wal,
+               (unsigned long long)wal_synced,
+               write_with_wal / (double)(wal_synced + 1),
+               wal_bytes / (1048576.0 * 1024));
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "Compaction IO cumulative (GB): "
+               "%.2f new, %.2f read, %.2f write, %.2f read+write\n",
+               user_bytes_written / (1048576.0 * 1024),
+               total_bytes_read / (1048576.0 * 1024),
+               total_bytes_written / (1048576.0 * 1024),
+               (total_bytes_read + total_bytes_written) / (1048576.0 * 1024));
+      value->append(buf);
+
+      snprintf(
+          buf, sizeof(buf),
+          "Compaction IO cumulative (MB/sec): "
+          "%.1f new, %.1f read, %.1f write, %.1f read+write\n",
+          user_bytes_written / 1048576.0 / seconds_up,
+          total_bytes_read / 1048576.0 / seconds_up,
+          total_bytes_written / 1048576.0 / seconds_up,
+          (total_bytes_read + total_bytes_written) / 1048576.0 / seconds_up);
+      value->append(buf);
+
+      // +1 to avoid divide by 0 and NaN
+      snprintf(
+          buf, sizeof(buf),
+          "Amplification cumulative: %.1f write, %.1f compaction\n",
+          (double)(total_bytes_written + wal_bytes) / (user_bytes_written + 1),
+          (double)(total_bytes_written + total_bytes_read + wal_bytes) /
+              (user_bytes_written + 1));
+      value->append(buf);
+
+      uint64_t interval_write_other = write_other - last_stats_.write_other_;
+      uint64_t interval_write_self = write_self - last_stats_.write_self_;
+
+      snprintf(buf, sizeof(buf),
+               "Writes interval: %llu total, %llu batches, "
+               "%.1f per batch, %.1f ingest MB\n",
+               (unsigned long long)(interval_write_other + interval_write_self),
+               (unsigned long long)interval_write_self,
+               (double)(interval_write_other + interval_write_self) /
+                   (interval_write_self + 1),
+               (user_bytes_written - last_stats_.ingest_bytes_) / 1048576.0);
+      value->append(buf);
+
+      uint64_t interval_write_with_wal =
+          write_with_wal - last_stats_.write_with_wal_;
+
+      uint64_t interval_wal_synced = wal_synced - last_stats_.wal_synced_;
+      uint64_t interval_wal_bytes = wal_bytes - last_stats_.wal_bytes_;
+
+      snprintf(buf, sizeof(buf),
+               "WAL interval: %llu WAL writes, %llu WAL syncs, "
+               "%.2f writes per sync, %.2f MB written\n",
+               (unsigned long long)interval_write_with_wal,
+               (unsigned long long)interval_wal_synced,
+               interval_write_with_wal / (double)(interval_wal_synced + 1),
+               interval_wal_bytes / (1048576.0 * 1024));
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "Compaction IO interval (MB): "
+               "%.2f new, %.2f read, %.2f write, %.2f read+write\n",
+               interval_bytes_new / 1048576.0, interval_bytes_read / 1048576.0,
+               interval_bytes_written / 1048576.0,
+               (interval_bytes_read + interval_bytes_written) / 1048576.0);
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "Compaction IO interval (MB/sec): "
+               "%.1f new, %.1f read, %.1f write, %.1f read+write\n",
+               interval_bytes_new / 1048576.0 / interval_seconds_up,
+               interval_bytes_read / 1048576.0 / interval_seconds_up,
+               interval_bytes_written / 1048576.0 / interval_seconds_up,
+               (interval_bytes_read + interval_bytes_written) / 1048576.0 /
+                   interval_seconds_up);
+      value->append(buf);
+
+      // +1 to avoid divide by 0 and NaN
+      snprintf(
+          buf, sizeof(buf),
+          "Amplification interval: %.1f write, %.1f compaction\n",
+          (double)(interval_bytes_written + interval_wal_bytes) /
+              (interval_bytes_new + 1),
+          (double)(interval_bytes_written + interval_bytes_read + interval_wal_bytes) /
+              (interval_bytes_new + 1));
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "Stalls(secs): %.3f level0_slowdown, %.3f level0_numfiles, "
+               "%.3f memtable_compaction, %.3f leveln_slowdown\n",
+               stall_micros_[LEVEL0_SLOWDOWN] / 1000000.0,
+               stall_micros_[LEVEL0_NUM_FILES] / 1000000.0,
+               stall_micros_[MEMTABLE_COMPACTION] / 1000000.0,
+               total_slowdown / 1000000.0);
+      value->append(buf);
+
+      snprintf(buf, sizeof(buf),
+               "Stalls(count): %lu level0_slowdown, %lu level0_numfiles, "
+               "%lu memtable_compaction, %lu leveln_slowdown\n",
+               (unsigned long)stall_counts_[LEVEL0_SLOWDOWN],
+               (unsigned long)stall_counts_[LEVEL0_NUM_FILES],
+               (unsigned long)stall_counts_[MEMTABLE_COMPACTION],
+               (unsigned long)total_slowdown_count);
+      value->append(buf);
+
+      last_stats_.compaction_bytes_read_ = total_bytes_read;
+      last_stats_.compaction_bytes_written_ = total_bytes_written;
+      last_stats_.ingest_bytes_ = user_bytes_written;
+      last_stats_.seconds_up_ = seconds_up;
+      last_stats_.wal_bytes_ = wal_bytes;
+      last_stats_.wal_synced_ = wal_synced;
+      last_stats_.write_with_wal_ = write_with_wal;
+      last_stats_.write_other_ = write_other;
+      last_stats_.write_self_ = write_self;
+
      return true;
    }
    case kSsTables:
      *value = current->DebugString();
      return true;
-    default:
-      return false;
-  }
-}
-
-bool InternalStats::GetIntProperty(DBPropertyType property_type,
-                                   uint64_t* value, DBImpl* db) const {
-  Version* current = cfd_->current();
-
-  switch (property_type) {
    case kNumImmutableMemTable:
-      *value = cfd_->imm()->size();
+      *value = std::to_string(cfd->imm()->size());
      return true;
    case kMemtableFlushPending:
      // Return number of mem tables that are ready to flush (made immutable)
-      *value = (cfd_->imm()->IsFlushPending() ? 1 : 0);
+      *value = std::to_string(cfd->imm()->IsFlushPending() ? 1 : 0);
      return true;
    case kCompactionPending:
      // 1 if the system already determines at least one compacdtion is needed.
      // 0 otherwise,
-      *value = (current->NeedsCompaction() ? 1 : 0);
+      *value = std::to_string(current->NeedsCompaction() ? 1 : 0);
      return true;
    case kBackgroundErrors:
      // Accumulated number of  errors in background flushes or compactions.
-      *value = GetBackgroundErrorCount();
+      *value = std::to_string(GetBackgroundErrorCount());
      return true;
    case kCurSizeActiveMemTable:
      // Current size of the active memtable
-      *value = cfd_->mem()->ApproximateMemoryUsage();
+      *value = std::to_string(cfd->mem()->ApproximateMemoryUsage());
      return true;
    case kNumEntriesInMutableMemtable:
      // Current size of the active memtable
-      *value = cfd_->mem()->GetNumEntries();
+      *value = std::to_string(cfd->mem()->GetNumEntries());
      return true;
    case kNumEntriesInImmutableMemtable:
      // Current size of the active memtable
-      *value = cfd_->imm()->current()->GetTotalNumEntries();
+      *value = std::to_string(cfd->imm()->current()->GetTotalNumEntries());
      return true;
-    case kEstimatedNumKeys:
-      // Estimate number of entries in the column family:
-      // Use estimated entries in tables + total entries in memtables.
-      *value = cfd_->mem()->GetNumEntries() +
-               cfd_->imm()->current()->GetTotalNumEntries() +
-               current->GetEstimatedActiveKeys();
-      return true;
-#ifndef ROCKSDB_LITE
-    case kIsFileDeletionEnabled:
-      *value = db->IsFileDeletionsEnabled();
-      return true;
-#endif
    default:
      return false;
  }
 }

-void InternalStats::DumpDBStats(std::string* value) {
-  char buf[1000];
-  // DB-level stats, only available from default column family
-  double seconds_up = (env_->NowMicros() - started_at_ + 1) / 1000000.0;
-  double interval_seconds_up = seconds_up - db_stats_snapshot_.seconds_up;
-  snprintf(buf, sizeof(buf),
-           "\n** DB Stats **\nUptime(secs): %.1f total, %.1f interval\n",
-           seconds_up, interval_seconds_up);
-  value->append(buf);
-  // Cumulative
-  uint64_t user_bytes_written = db_stats_[InternalStats::BYTES_WRITTEN];
-  uint64_t write_other = db_stats_[InternalStats::WRITE_DONE_BY_OTHER];
-  uint64_t write_self = db_stats_[InternalStats::WRITE_DONE_BY_SELF];
-  uint64_t wal_bytes = db_stats_[InternalStats::WAL_FILE_BYTES];
-  uint64_t wal_synced = db_stats_[InternalStats::WAL_FILE_SYNCED];
-  uint64_t write_with_wal = db_stats_[InternalStats::WRITE_WITH_WAL];
-  // Data
-  snprintf(buf, sizeof(buf),
-           "Cumulative writes: %" PRIu64 " writes, %" PRIu64 " batches, "
-           "%.1f writes per batch, %.2f GB user ingest\n",
-           write_other + write_self, write_self,
-           (write_other + write_self) / static_cast<double>(write_self + 1),
-           user_bytes_written / kGB);
-  value->append(buf);
-  // WAL
-  snprintf(buf, sizeof(buf),
-           "Cumulative WAL: %" PRIu64 " writes, %" PRIu64 " syncs, "
-           "%.2f writes per sync, %.2f GB written\n",
-           write_with_wal, wal_synced,
-           write_with_wal / static_cast<double>(wal_synced + 1),
-           wal_bytes / kGB);
-  value->append(buf);
-
-  // Interval
-  uint64_t interval_write_other = write_other - db_stats_snapshot_.write_other;
-  uint64_t interval_write_self = write_self - db_stats_snapshot_.write_self;
-  snprintf(buf, sizeof(buf),
-           "Interval writes: %" PRIu64 " writes, %" PRIu64 " batches, "
-           "%.1f writes per batch, %.1f MB user ingest\n",
-           interval_write_other + interval_write_self,
-           interval_write_self,
-           static_cast<double>(interval_write_other + interval_write_self) /
-               (interval_write_self + 1),
-           (user_bytes_written - db_stats_snapshot_.ingest_bytes) / kMB);
-  value->append(buf);
-
-  uint64_t interval_write_with_wal =
-      write_with_wal - db_stats_snapshot_.write_with_wal;
-  uint64_t interval_wal_synced = wal_synced - db_stats_snapshot_.wal_synced;
-  uint64_t interval_wal_bytes = wal_bytes - db_stats_snapshot_.wal_bytes;
-
-  snprintf(buf, sizeof(buf),
-           "Interval WAL: %" PRIu64 " writes, %" PRIu64 " syncs, "
-           "%.2f writes per sync, %.2f MB written\n",
-           interval_write_with_wal,
-           interval_wal_synced,
-           interval_write_with_wal /
-              static_cast<double>(interval_wal_synced + 1),
-           interval_wal_bytes / kGB);
-  value->append(buf);
-
-  db_stats_snapshot_.seconds_up = seconds_up;
-  db_stats_snapshot_.ingest_bytes = user_bytes_written;
-  db_stats_snapshot_.write_other = write_other;
-  db_stats_snapshot_.write_self = write_self;
-  db_stats_snapshot_.wal_bytes = wal_bytes;
-  db_stats_snapshot_.wal_synced = wal_synced;
-  db_stats_snapshot_.write_with_wal = write_with_wal;
-}
-
-void InternalStats::DumpCFStats(std::string* value) {
-  Version* current = cfd_->current();
-
-  int num_levels_to_check =
-      (cfd_->options()->compaction_style != kCompactionStyleUniversal &&
-       cfd_->options()->compaction_style != kCompactionStyleFIFO)
-          ? current->NumberLevels() - 1
-          : 1;
-  // Compaction scores are sorted base on its value. Restore them to the
-  // level order
-  std::vector<double> compaction_score(number_levels_, 0);
-  for (int i = 0; i < num_levels_to_check; ++i) {
-    compaction_score[current->compaction_level_[i]] =
-      current->compaction_score_[i];
-  }
-  // Count # of files being compacted for each level
-  std::vector<int> files_being_compacted(number_levels_, 0);
-  for (int level = 0; level < num_levels_to_check; ++level) {
-    for (auto* f : current->files_[level]) {
-      if (f->being_compacted) {
-        ++files_being_compacted[level];
-      }
-    }
-  }
-
-  char buf[1000];
-  // Per-ColumnFamily stats
-  PrintLevelStatsHeader(buf, sizeof(buf), cfd_->GetName());
-  value->append(buf);
-
-  CompactionStats stats_sum(0);
-  int total_files = 0;
-  int total_files_being_compacted = 0;
-  double total_file_size = 0;
-  uint64_t total_slowdown_soft = 0;
-  uint64_t total_slowdown_count_soft = 0;
-  uint64_t total_slowdown_hard = 0;
-  uint64_t total_slowdown_count_hard = 0;
-  uint64_t total_stall_count = 0;
-  double total_stall_us = 0;
-  for (int level = 0; level < number_levels_; level++) {
-    int files = current->NumLevelFiles(level);
-    total_files += files;
-    total_files_being_compacted += files_being_compacted[level];
-    if (comp_stats_[level].micros > 0 || files > 0) {
-      uint64_t stalls = level == 0 ?
-        (cf_stats_count_[LEVEL0_SLOWDOWN] +
-         cf_stats_count_[LEVEL0_NUM_FILES] +
-         cf_stats_count_[MEMTABLE_COMPACTION])
-        : (stall_leveln_slowdown_count_soft_[level] +
-           stall_leveln_slowdown_count_hard_[level]);
-
-      double stall_us = level == 0 ?
-         (cf_stats_value_[LEVEL0_SLOWDOWN] +
-          cf_stats_value_[LEVEL0_NUM_FILES] +
-          cf_stats_value_[MEMTABLE_COMPACTION])
-         : (stall_leveln_slowdown_soft_[level] +
-            stall_leveln_slowdown_hard_[level]);
-
-      stats_sum.Add(comp_stats_[level]);
-      total_file_size += current->NumLevelBytes(level);
-      total_stall_us += stall_us;
-      total_stall_count += stalls;
-      total_slowdown_soft += stall_leveln_slowdown_soft_[level];
-      total_slowdown_count_soft += stall_leveln_slowdown_count_soft_[level];
-      total_slowdown_hard += stall_leveln_slowdown_hard_[level];
-      total_slowdown_count_hard += stall_leveln_slowdown_count_hard_[level];
-      int64_t bytes_read = comp_stats_[level].bytes_readn +
-                           comp_stats_[level].bytes_readnp1;
-      double rw_amp = (comp_stats_[level].bytes_readn == 0) ? 0.0
-          : (comp_stats_[level].bytes_written + bytes_read) /
-            static_cast<double>(comp_stats_[level].bytes_readn);
-      double w_amp = (comp_stats_[level].bytes_readn == 0) ? 0.0
-          : comp_stats_[level].bytes_written /
-            static_cast<double>(comp_stats_[level].bytes_readn);
-      PrintLevelStats(buf, sizeof(buf), "L" + std::to_string(level),
-          files, files_being_compacted[level], current->NumLevelBytes(level),
-          compaction_score[level], rw_amp, w_amp, stall_us, stalls,
-          comp_stats_[level]);
-      value->append(buf);
-    }
-  }
-  uint64_t curr_ingest = cf_stats_value_[BYTES_FLUSHED];
-  // Cumulative summary
-  double rw_amp = (stats_sum.bytes_written + stats_sum.bytes_readn +
-      stats_sum.bytes_readnp1) / static_cast<double>(curr_ingest + 1);
-  double w_amp = stats_sum.bytes_written / static_cast<double>(curr_ingest + 1);
-  // Stats summary across levels
-  PrintLevelStats(buf, sizeof(buf), "Sum", total_files,
-      total_files_being_compacted, total_file_size, 0, rw_amp, w_amp,
-      total_stall_us, total_stall_count, stats_sum);
-  value->append(buf);
-  // Interval summary
-  uint64_t interval_ingest =
-      curr_ingest - cf_stats_snapshot_.ingest_bytes + 1;
-  CompactionStats interval_stats(stats_sum);
-  interval_stats.Subtract(cf_stats_snapshot_.comp_stats);
-  rw_amp = (interval_stats.bytes_written +
-      interval_stats.bytes_readn + interval_stats.bytes_readnp1) /
-      static_cast<double>(interval_ingest);
-  w_amp = interval_stats.bytes_written / static_cast<double>(interval_ingest);
-  PrintLevelStats(buf, sizeof(buf), "Int", 0, 0, 0, 0,
-      rw_amp, w_amp, total_stall_us - cf_stats_snapshot_.stall_us,
-      total_stall_count - cf_stats_snapshot_.stall_count, interval_stats);
-  value->append(buf);
-
-  snprintf(buf, sizeof(buf),
-           "Flush(GB): accumulative %.3f, interval %.3f\n",
-           curr_ingest / kGB, interval_ingest / kGB);
-  value->append(buf);
-  snprintf(buf, sizeof(buf),
-           "Stalls(secs): %.3f level0_slowdown, %.3f level0_numfiles, "
-           "%.3f memtable_compaction, %.3f leveln_slowdown_soft, "
-           "%.3f leveln_slowdown_hard\n",
-           cf_stats_value_[LEVEL0_SLOWDOWN] / 1000000.0,
-           cf_stats_value_[LEVEL0_NUM_FILES] / 1000000.0,
-           cf_stats_value_[MEMTABLE_COMPACTION] / 1000000.0,
-           total_slowdown_soft / 1000000.0,
-           total_slowdown_hard / 1000000.0);
-  value->append(buf);
-
-  snprintf(buf, sizeof(buf),
-           "Stalls(count): %" PRIu64 " level0_slowdown, "
-           "%" PRIu64 " level0_numfiles, %" PRIu64 " memtable_compaction, "
-           "%" PRIu64 " leveln_slowdown_soft, "
-           "%" PRIu64 " leveln_slowdown_hard\n",
-           cf_stats_count_[LEVEL0_SLOWDOWN],
-           cf_stats_count_[LEVEL0_NUM_FILES],
-           cf_stats_count_[MEMTABLE_COMPACTION],
-           total_slowdown_count_soft, total_slowdown_count_hard);
-  value->append(buf);
-
-  cf_stats_snapshot_.ingest_bytes = curr_ingest;
-  cf_stats_snapshot_.comp_stats = stats_sum;
-  cf_stats_snapshot_.stall_us = total_stall_us;
-  cf_stats_snapshot_.stall_count = total_stall_count;
-}
-
 }  // namespace rocksdb
@@ -9,6 +9,8 @@
 //

 #pragma once
+#include "rocksdb/statistics.h"
+#include "util/statistics.h"
 #include "db/version_set.h"

 #include <vector>
@@ -21,15 +23,11 @@ namespace rocksdb {
 class MemTableList;
 class DBImpl;

-enum DBPropertyType : uint32_t {
-  kUnknown,
+enum DBPropertyType {
  kNumFilesAtLevel,  // Number of files at a specific level
  kLevelStats,       // Return number of files and total sizes of each level
-  kCFStats,          // Return general statitistics of CF
-  kDBStats,          // Return general statitistics of DB
-  kStats,            // Return general statitistics of both DB and CF
+  kStats,            // Return general statitistics of DB
  kSsTables,         // Return a human readable string of current SST files
-  kStartIntTypes,    // ---- Dummy value to indicate the start of integer values
  kNumImmutableMemTable,   // Return number of immutable mem tables
  kMemtableFlushPending,   // Return 1 if mem table flushing is pending,
                           // otherwise 0.
@@ -40,79 +38,45 @@ enum DBPropertyType : uint32_t {
                                   // memtable.
  kNumEntriesInImmutableMemtable,  // Return sum of number of entries in all
                                   // the immutable mem tables.
-  kEstimatedNumKeys,  // Estimated total number of keys in the database.
-  kEstimatedUsageByTableReaders,  // Estimated memory by table readers.
-  kIsFileDeletionEnabled,         // Equals disable_delete_obsolete_files_,
-                                  // 0 means file deletions enabled
+  kUnknown,
 };

-extern DBPropertyType GetPropertyType(const Slice& property,
-                                      bool* is_int_property,
-                                      bool* need_out_of_mutex);
+extern DBPropertyType GetPropertyType(const Slice& property);

 class InternalStats {
 public:
-  enum InternalCFStatsType {
+  enum WriteStallType {
    LEVEL0_SLOWDOWN,
    MEMTABLE_COMPACTION,
    LEVEL0_NUM_FILES,
    WRITE_STALLS_ENUM_MAX,
-    BYTES_FLUSHED,
-    INTERNAL_CF_STATS_ENUM_MAX,
  };

-  enum InternalDBStatsType {
-    WAL_FILE_BYTES,
-    WAL_FILE_SYNCED,
-    BYTES_WRITTEN,
-    WRITE_DONE_BY_OTHER,
-    WRITE_DONE_BY_SELF,
-    WRITE_WITH_WAL,
-    INTERNAL_DB_STATS_ENUM_MAX,
-  };
-
-  InternalStats(int num_levels, Env* env, ColumnFamilyData* cfd)
-      : db_stats_(INTERNAL_DB_STATS_ENUM_MAX),
-        cf_stats_value_(INTERNAL_CF_STATS_ENUM_MAX),
-        cf_stats_count_(INTERNAL_CF_STATS_ENUM_MAX),
-        comp_stats_(num_levels),
-        stall_leveln_slowdown_hard_(num_levels),
-        stall_leveln_slowdown_count_hard_(num_levels),
-        stall_leveln_slowdown_soft_(num_levels),
-        stall_leveln_slowdown_count_soft_(num_levels),
+  InternalStats(int num_levels, Env* env, Statistics* statistics)
+      : compaction_stats_(num_levels),
+        stall_micros_(WRITE_STALLS_ENUM_MAX, 0),
+        stall_counts_(WRITE_STALLS_ENUM_MAX, 0),
+        stall_leveln_slowdown_(num_levels, 0),
+        stall_leveln_slowdown_count_(num_levels, 0),
        bg_error_count_(0),
        number_levels_(num_levels),
+        statistics_(statistics),
        env_(env),
-        cfd_(cfd),
-        started_at_(env->NowMicros()) {
-    for (int i = 0; i< INTERNAL_DB_STATS_ENUM_MAX; ++i) {
-      db_stats_[i] = 0;
-    }
-    for (int i = 0; i< INTERNAL_CF_STATS_ENUM_MAX; ++i) {
-      cf_stats_value_[i] = 0;
-      cf_stats_count_[i] = 0;
-    }
-    for (int i = 0; i < num_levels; ++i) {
-      stall_leveln_slowdown_hard_[i] = 0;
-      stall_leveln_slowdown_count_hard_[i] = 0;
-      stall_leveln_slowdown_soft_[i] = 0;
-      stall_leveln_slowdown_count_soft_[i] = 0;
-    }
-  }
+        started_at_(env->NowMicros()) {}

-  // Per level compaction stats.  comp_stats_[level] stores the stats for
+  // Per level compaction stats.  compaction_stats_[level] stores the stats for
  // compactions that produced data for the specified "level".
  struct CompactionStats {
    uint64_t micros;

    // Bytes read from level N during compaction between levels N and N+1
-    uint64_t bytes_readn;
+    int64_t bytes_readn;

    // Bytes read from level N+1 during compaction between levels N and N+1
-    uint64_t bytes_readnp1;
+    int64_t bytes_readnp1;

    // Total bytes written during compaction between levels N and N+1
-    uint64_t bytes_written;
+    int64_t bytes_written;

    // Files read from level N during compaction between levels N and N+1
    int files_in_leveln;
@@ -126,7 +90,7 @@ class InternalStats {
    // Number of compactions done
    int count;

-    explicit CompactionStats(int count = 0)
+    CompactionStats()
        : micros(0),
          bytes_readn(0),
          bytes_readnp1(0),
@@ -134,17 +98,7 @@ class InternalStats {
          files_in_leveln(0),
          files_in_levelnp1(0),
          files_out_levelnp1(0),
-          count(count) {}
-
-    explicit CompactionStats(const CompactionStats& c)
-        : micros(c.micros),
-          bytes_readn(c.bytes_readn),
-          bytes_readnp1(c.bytes_readnp1),
-          bytes_written(c.bytes_written),
-          files_in_leveln(c.files_in_leveln),
-          files_in_levelnp1(c.files_in_levelnp1),
-          files_out_levelnp1(c.files_out_levelnp1),
-          count(c.count) {}
+          count(0) {}

    void Add(const CompactionStats& c) {
      this->micros += c.micros;
@@ -154,110 +108,68 @@ class InternalStats {
      this->files_in_leveln += c.files_in_leveln;
      this->files_in_levelnp1 += c.files_in_levelnp1;
      this->files_out_levelnp1 += c.files_out_levelnp1;
-      this->count += c.count;
-    }
-
-    void Subtract(const CompactionStats& c) {
-      this->micros -= c.micros;
-      this->bytes_readn -= c.bytes_readn;
-      this->bytes_readnp1 -= c.bytes_readnp1;
-      this->bytes_written -= c.bytes_written;
-      this->files_in_leveln -= c.files_in_leveln;
-      this->files_in_levelnp1 -= c.files_in_levelnp1;
-      this->files_out_levelnp1 -= c.files_out_levelnp1;
-      this->count -= c.count;
+      this->count += 1;
    }
  };

  void AddCompactionStats(int level, const CompactionStats& stats) {
-    comp_stats_[level].Add(stats);
+    compaction_stats_[level].Add(stats);
  }

-  void RecordLevelNSlowdown(int level, uint64_t micros, bool soft) {
-    if (soft) {
-      stall_leveln_slowdown_soft_[level] += micros;
-      ++stall_leveln_slowdown_count_soft_[level];
-    } else {
-      stall_leveln_slowdown_hard_[level] += micros;
-      ++stall_leveln_slowdown_count_hard_[level];
-    }
+  void RecordWriteStall(WriteStallType write_stall_type, uint64_t micros) {
+    stall_micros_[write_stall_type] += micros;
+    ++stall_counts_[write_stall_type];
  }

-  void AddCFStats(InternalCFStatsType type, uint64_t value) {
-    cf_stats_value_[type] += value;
-    ++cf_stats_count_[type];
-  }
-
-  void AddDBStats(InternalDBStatsType type, uint64_t value) {
-    db_stats_[type] += value;
+  void RecordLevelNSlowdown(int level, uint64_t micros) {
+    stall_leveln_slowdown_[level] += micros;
+    ++stall_leveln_slowdown_count_[level];
  }

  uint64_t GetBackgroundErrorCount() const { return bg_error_count_; }

  uint64_t BumpAndGetBackgroundErrorCount() { return ++bg_error_count_; }

-  bool GetStringProperty(DBPropertyType property_type, const Slice& property,
-                         std::string* value);
-
-  bool GetIntProperty(DBPropertyType property_type, uint64_t* value,
-                      DBImpl* db) const;
-
-  bool GetIntPropertyOutOfMutex(DBPropertyType property_type, Version* version,
-                                uint64_t* value) const;
+  bool GetProperty(DBPropertyType property_type, const Slice& property,
+                   std::string* value, ColumnFamilyData* cfd);

 private:
-  void DumpDBStats(std::string* value);
-  void DumpCFStats(std::string* value);
-
-  // Per-DB stats
-  std::vector<uint64_t> db_stats_;
-  // Per-ColumnFamily stats
-  std::vector<uint64_t> cf_stats_value_;
-  std::vector<uint64_t> cf_stats_count_;
-  // Per-ColumnFamily/level compaction stats
-  std::vector<CompactionStats> comp_stats_;
-  // These count the number of microseconds for which MakeRoomForWrite stalls.
-  std::vector<uint64_t> stall_leveln_slowdown_hard_;
-  std::vector<uint64_t> stall_leveln_slowdown_count_hard_;
-  std::vector<uint64_t> stall_leveln_slowdown_soft_;
-  std::vector<uint64_t> stall_leveln_slowdown_count_soft_;
+  std::vector<CompactionStats> compaction_stats_;

  // Used to compute per-interval statistics
-  struct CFStatsSnapshot {
-    // ColumnFamily-level stats
-    CompactionStats comp_stats;
-    uint64_t ingest_bytes;            // Bytes written to L0
-    uint64_t stall_us;                // Stall time in micro-seconds
-    uint64_t stall_count;             // Stall count
-
-    CFStatsSnapshot()
-        : comp_stats(0),
-          ingest_bytes(0),
-          stall_us(0),
-          stall_count(0) {}
-  } cf_stats_snapshot_;
-
-  struct DBStatsSnapshot {
-    // DB-level stats
-    uint64_t ingest_bytes;            // Bytes written by user
-    uint64_t wal_bytes;               // Bytes written to WAL
-    uint64_t wal_synced;              // Number of times WAL is synced
-    uint64_t write_with_wal;          // Number of writes that request WAL
+  struct StatsSnapshot {
+    uint64_t compaction_bytes_read_;     // Bytes read by compaction
+    uint64_t compaction_bytes_written_;  // Bytes written by compaction
+    uint64_t ingest_bytes_;              // Bytes written by user
+    uint64_t wal_bytes_;                 // Bytes written to WAL
+    uint64_t wal_synced_;                // Number of times WAL is synced
+    uint64_t write_with_wal_;            // Number of writes that request WAL
    // These count the number of writes processed by the calling thread or
    // another thread.
-    uint64_t write_other;
-    uint64_t write_self;
-    double seconds_up;
+    uint64_t write_other_;
+    uint64_t write_self_;
+    double seconds_up_;

-    DBStatsSnapshot()
-        : ingest_bytes(0),
-          wal_bytes(0),
-          wal_synced(0),
-          write_with_wal(0),
-          write_other(0),
-          write_self(0),
-          seconds_up(0) {}
-  } db_stats_snapshot_;
+    StatsSnapshot()
+        : compaction_bytes_read_(0),
+          compaction_bytes_written_(0),
+          ingest_bytes_(0),
+          wal_bytes_(0),
+          wal_synced_(0),
+          write_with_wal_(0),
+          write_other_(0),
+          write_self_(0),
+          seconds_up_(0) {}
+  };
+
+  // Counters from the previous time per-interval stats were computed
+  StatsSnapshot last_stats_;
+
+  // These count the number of microseconds for which MakeRoomForWrite stalls.
+  std::vector<uint64_t> stall_micros_;
+  std::vector<uint64_t> stall_counts_;
+  std::vector<uint64_t> stall_leveln_slowdown_;
+  std::vector<uint64_t> stall_leveln_slowdown_count_;

  // Total number of background errors encountered. Every time a flush task
  // or compaction task fails, this counter is incremented. The failure can
@@ -266,10 +178,10 @@ class InternalStats {
  // or compaction will cause the counter to increase too.
  uint64_t bg_error_count_;

-  const int number_levels_;
+  int number_levels_;
+  Statistics* statistics_;
  Env* env_;
-  ColumnFamilyData* cfd_;
-  const uint64_t started_at_;
+  uint64_t started_at_;
 };

 }  // namespace rocksdb
@@ -42,11 +42,6 @@ void BM_LogAndApply(int iters, int num_base_files) {

    Options options;
    EnvOptions sopt;
-    // Notice we are using the default options not through SanitizeOptions().
-    // We might want to initialize some options manually if needed.
-    options.db_paths.emplace_back(dbname, 0);
-    // The parameter of table cache is passed in as null, so any file I/O
-    // operation is likely to fail.
    vset = new VersionSet(dbname, &options, sopt, nullptr);
    std::vector<ColumnFamilyDescriptor> dummy;
    dummy.push_back(ColumnFamilyDescriptor());
@@ -174,13 +174,13 @@ const char* EncodeKey(std::string* scratch, const Slice& target) {

 class MemTableIterator: public Iterator {
 public:
-  MemTableIterator(
-      const MemTable& mem, const ReadOptions& options, Arena* arena)
+  MemTableIterator(const MemTable& mem, const ReadOptions& options,
+                   bool enforce_total_order, Arena* arena)
      : bloom_(nullptr),
        prefix_extractor_(mem.prefix_extractor_),
        valid_(false),
        arena_mode_(arena != nullptr) {
-    if (prefix_extractor_ != nullptr && !options.total_order_seek) {
+    if (prefix_extractor_ != nullptr && !enforce_total_order) {
      bloom_ = mem.prefix_bloom_.get();
      iter_ = mem.table_->GetDynamicPrefixIterator(arena);
    } else {
@@ -248,13 +248,14 @@ class MemTableIterator: public Iterator {
  void operator=(const MemTableIterator&);
 };

-Iterator* MemTable::NewIterator(const ReadOptions& options, Arena* arena) {
+Iterator* MemTable::NewIterator(const ReadOptions& options,
+                                bool enforce_total_order, Arena* arena) {
  if (arena == nullptr) {
-    return new MemTableIterator(*this, options, nullptr);
+    return new MemTableIterator(*this, options, enforce_total_order, nullptr);
  } else {
    auto mem = arena->AllocateAligned(sizeof(MemTableIterator));
    return new (mem)
-        MemTableIterator(*this, options, arena);
+        MemTableIterator(*this, options, enforce_total_order, arena);
  }
 }

@@ -389,16 +390,6 @@ static bool SaveValue(void* arg, const char* entry) {
        return false;
      }
      case kTypeMerge: {
-        if (!merge_operator) {
-          *(s->status) = Status::InvalidArgument(
-              "merge_operator is not properly initialized.");
-          // Normally we continue the loop (return true) when we see a merge
-          // operand.  But in case of an error, we should stop the loop
-          // immediately and pretend we have found the value to stop further
-          // seek.  Otherwise, the later call will override this error status.
-          *(s->found_final_value) = true;
-          return false;
-        }
        std::string merge_result;  // temporary area for merge results later
        Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
        *(s->merge_in_progress) = true;
@@ -417,12 +408,7 @@ static bool SaveValue(void* arg, const char* entry) {

 bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
                   MergeContext& merge_context, const Options& options) {
-  // The sequence number is updated synchronously in version_set.h
-  if (first_seqno_ == 0) {
-    // Avoiding recording stats for speed.
-    return false;
-  }
-  PERF_TIMER_GUARD(get_from_memtable_time);
+  PERF_TIMER_AUTO(get_from_memtable_time);

  Slice user_key = key.user_key();
  bool found_final_value = false;
@@ -452,6 +438,7 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
  if (!found_final_value && merge_in_progress) {
    *s = Status::MergeInProgress("");
  }
+  PERF_TIMER_STOP(get_from_memtable_time);
  PERF_COUNTER_ADD(get_from_memtable_count, 1);
  return found_final_value;
 }
@@ -82,6 +82,7 @@ class MemTable {
  //        Calling ~Iterator of the iterator will destroy all the states but
  //        those allocated in arena.
  Iterator* NewIterator(const ReadOptions& options,
+                        bool enforce_total_order = false,
                        Arena* arena = nullptr);

  // Add an entry into memtable that maps key to value at the
@@ -24,12 +24,10 @@ void MergeHelper::MergeUntil(Iterator* iter, SequenceNumber stop_before,
                             bool at_bottom, Statistics* stats, int* steps) {
  // Get a copy of the internal key, before it's invalidated by iter->Next()
  // Also maintain the list of merge operands seen.
-  assert(HasOperator());
  keys_.clear();
  operands_.clear();
  keys_.push_front(iter->key().ToString());
  operands_.push_front(iter->value().ToString());
-  assert(user_merge_operator_);

  success_ = false;   // Will become true if we hit Put/Delete or bottom

@@ -78,16 +78,13 @@ class MergeHelper {
  //   IMPORTANT 2: The entries were traversed in order from BACK to FRONT.
  //                So keys().back() was the first key seen by iterator.
  // TODO: Re-style this comment to be like the first one
-  bool IsSuccess() const { return success_; }
-  Slice key() const { assert(success_); return Slice(keys_.back()); }
-  Slice value() const { assert(success_); return Slice(operands_.back()); }
-  const std::deque<std::string>& keys() const {
-    assert(!success_); return keys_;
-  }
-  const std::deque<std::string>& values() const {
+  bool IsSuccess() { return success_; }
+  Slice key() { assert(success_); return Slice(keys_.back()); }
+  Slice value() { assert(success_); return Slice(operands_.back()); }
+  const std::deque<std::string>& keys() { assert(!success_); return keys_; }
+  const std::deque<std::string>& values() {
    assert(!success_); return operands_;
  }
-  bool HasOperator() const { return user_merge_operator_ != nullptr; }

 private:
  const Comparator* user_comparator_;
@@ -12,12 +12,12 @@
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/merge_operator.h"
-#include "rocksdb/utilities/db_ttl.h"
 #include "db/dbformat.h"
 #include "db/db_impl.h"
 #include "db/write_batch_internal.h"
 #include "utilities/merge_operators.h"
 #include "util/testharness.h"
+#include "utilities/db_ttl.h"

 using namespace std;
 using namespace rocksdb;
@@ -212,7 +212,7 @@ class Counters {
  void assert_add(const string& key, uint64_t value) {
    int result = add(key, value);
    assert(result);
-    if (result == 0) exit(1); // Disable unused variable warning.
+    if (result == 0) exit(1); // Disable unused variable warning. 
  }
 };

@@ -460,41 +460,6 @@ void runTest(int argc, const string& dbname, const bool use_ttl = false) {
      }
    }
  }
-
-  {
-    cout << "Test merge-operator not set after reopen\n";
-    {
-      auto db = OpenDb(dbname);
-      MergeBasedCounters counters(db, 0);
-      counters.add("test-key", 1);
-      counters.add("test-key", 1);
-      counters.add("test-key", 1);
-      db->CompactRange(nullptr, nullptr);
-    }
-
-    DB* reopen_db;
-    ASSERT_OK(DB::Open(Options(), dbname, &reopen_db));
-    std::string value;
-    ASSERT_TRUE(!(reopen_db->Get(ReadOptions(), "test-key", &value).ok()));
-    delete reopen_db;
-    DestroyDB(dbname, Options());
-  }
-
-  /* Temporary remove this test
-  {
-    cout << "Test merge-operator not set after reopen (recovery case)\n";
-    {
-      auto db = OpenDb(dbname);
-      MergeBasedCounters counters(db, 0);
-      counters.add("test-key", 1);
-      counters.add("test-key", 1);
-      counters.add("test-key", 1);
-    }
-
-    DB* reopen_db;
-    ASSERT_TRUE(DB::Open(Options(), dbname, &reopen_db).IsInvalidArgument());
-  }
-  */
 }
 }  // namespace

@@ -23,7 +23,6 @@
 #include "rocksdb/slice_transform.h"
 #include "rocksdb/table.h"
 #include "table/meta_blocks.h"
-#include "table/bloom_block.h"
 #include "table/plain_table_factory.h"
 #include "table/plain_table_reader.h"
 #include "util/hash.h"
@@ -62,20 +61,8 @@ class PlainTableDBTest {
  // Return the current option configuration.
  Options CurrentOptions() {
    Options options;
-
-    PlainTableOptions plain_table_options;
-    plain_table_options.user_key_len = 0;
-    plain_table_options.bloom_bits_per_key = 2;
-    plain_table_options.hash_table_ratio = 0.8;
-    plain_table_options.index_sparseness = 3;
-    plain_table_options.huge_page_tlb_size = 0;
-    plain_table_options.encoding_type = kPrefix;
-    plain_table_options.full_scan_mode = false;
-    plain_table_options.store_index_in_file = false;
-
-    options.table_factory.reset(NewPlainTableFactory(plain_table_options));
-    options.memtable_factory.reset(NewHashLinkListRepFactory(4, 0, 3, true));
-
+    options.table_factory.reset(NewPlainTableFactory(0, 2, 0.8, 3, 0, kPrefix));
+    options.memtable_factory.reset(NewHashLinkListRepFactory(4, 0, 3, true, 3));
    options.prefix_extractor.reset(NewFixedPrefixTransform(8));
    options.allow_mmap_reads = true;
    return options;
@@ -188,8 +175,6 @@ TEST(PlainTableDBTest, Empty) {
  ASSERT_EQ("NOT_FOUND", Get("0000000000000foo"));
 }

-extern const uint64_t kPlainTableMagicNumber;
-
 class TestPlainTableReader : public PlainTableReader {
 public:
  TestPlainTableReader(const EnvOptions& storage_options,
@@ -199,8 +184,7 @@ class TestPlainTableReader : public PlainTableReader {
                       size_t index_sparseness,
                       const TableProperties* table_properties,
                       unique_ptr<RandomAccessFile>&& file,
-                       const Options& options, bool* expect_bloom_not_match,
-                       bool store_index_in_file)
+                       const Options& options, bool* expect_bloom_not_match)
      : PlainTableReader(options, std::move(file), storage_options, icomparator,
                         encoding_type, file_size, table_properties),
        expect_bloom_not_match_(expect_bloom_not_match) {
@@ -211,19 +195,6 @@ class TestPlainTableReader : public PlainTableReader {
                      bloom_bits_per_key, hash_table_ratio, index_sparseness,
                      2 * 1024 * 1024);
    ASSERT_TRUE(s.ok());
-
-    TableProperties* props = const_cast<TableProperties*>(table_properties);
-    if (store_index_in_file) {
-      auto bloom_version_ptr = props->user_collected_properties.find(
-          PlainTablePropertyNames::kBloomVersion);
-      ASSERT_TRUE(bloom_version_ptr != props->user_collected_properties.end());
-      ASSERT_EQ(bloom_version_ptr->second, std::string("1"));
-      if (options.bloom_locality > 0) {
-        auto num_blocks_ptr = props->user_collected_properties.find(
-            PlainTablePropertyNames::kNumBloomBlocks);
-        ASSERT_TRUE(num_blocks_ptr != props->user_collected_properties.end());
-      }
-    }
  }

  virtual ~TestPlainTableReader() {}
@@ -231,11 +202,7 @@ class TestPlainTableReader : public PlainTableReader {
 private:
  virtual bool MatchBloom(uint32_t hash) const override {
    bool ret = PlainTableReader::MatchBloom(hash);
-    if (*expect_bloom_not_match_) {
-      ASSERT_TRUE(!ret);
-    } else {
-      ASSERT_TRUE(ret);
-    }
+    ASSERT_TRUE(!*expect_bloom_not_match_ || !ret);
    return ret;
  }
  bool* expect_bloom_not_match_;
@@ -245,12 +212,16 @@ extern const uint64_t kPlainTableMagicNumber;
 class TestPlainTableFactory : public PlainTableFactory {
 public:
  explicit TestPlainTableFactory(bool* expect_bloom_not_match,
-                                 const PlainTableOptions& options)
-      : PlainTableFactory(options),
-        bloom_bits_per_key_(options.bloom_bits_per_key),
-        hash_table_ratio_(options.hash_table_ratio),
-        index_sparseness_(options.index_sparseness),
-        store_index_in_file_(options.store_index_in_file),
+                                 uint32_t user_key_len, int bloom_bits_per_key,
+                                 double hash_table_ratio,
+                                 size_t index_sparseness,
+                                 size_t huge_page_tlb_size,
+                                 EncodingType encoding_type)
+      : PlainTableFactory(user_key_len, bloom_bits_per_key, hash_table_ratio,
+                          index_sparseness, huge_page_tlb_size, encoding_type),
+        bloom_bits_per_key_(bloom_bits_per_key),
+        hash_table_ratio_(hash_table_ratio),
+        index_sparseness_(index_sparseness),
        expect_bloom_not_match_(expect_bloom_not_match) {}

  Status NewTableReader(const Options& options, const EnvOptions& soptions,
@@ -262,20 +233,6 @@ class TestPlainTableFactory : public PlainTableFactory {
                                 options.env, options.info_log.get(), &props);
    ASSERT_TRUE(s.ok());

-    if (store_index_in_file_) {
-      BlockHandle bloom_block_handle;
-      s = FindMetaBlock(file.get(), file_size, kPlainTableMagicNumber,
-                        options.env, BloomBlockBuilder::kBloomBlock,
-                        &bloom_block_handle);
-      ASSERT_TRUE(s.ok());
-
-      BlockHandle index_block_handle;
-      s = FindMetaBlock(
-          file.get(), file_size, kPlainTableMagicNumber, options.env,
-          PlainTableIndexBuilder::kPlainTableIndexBlock, &index_block_handle);
-      ASSERT_TRUE(s.ok());
-    }
-
    auto& user_props = props->user_collected_properties;
    auto encoding_type_prop =
        user_props.find(PlainTablePropertyNames::kEncodingType);
@@ -286,8 +243,7 @@ class TestPlainTableFactory : public PlainTableFactory {
    std::unique_ptr<PlainTableReader> new_reader(new TestPlainTableReader(
        soptions, internal_comparator, encoding_type, file_size,
        bloom_bits_per_key_, hash_table_ratio_, index_sparseness_, props,
-        std::move(file), options, expect_bloom_not_match_,
-        store_index_in_file_));
+        std::move(file), options, expect_bloom_not_match_));

    *table = std::move(new_reader);
    return s;
@@ -297,7 +253,6 @@ class TestPlainTableFactory : public PlainTableFactory {
  int bloom_bits_per_key_;
  double hash_table_ratio_;
  size_t index_sparseness_;
-  bool store_index_in_file_;
  bool* expect_bloom_not_match_;
 };

@@ -307,84 +262,40 @@ TEST(PlainTableDBTest, Flush) {
    for (EncodingType encoding_type : {kPlain, kPrefix}) {
    for (int bloom_bits = 0; bloom_bits <= 117; bloom_bits += 117) {
      for (int total_order = 0; total_order <= 1; total_order++) {
-        for (int store_index_in_file = 0; store_index_in_file <= 1;
-             ++store_index_in_file) {
-          if (!bloom_bits && store_index_in_file) {
-            continue;
-          }
-
-          Options options = CurrentOptions();
-          options.create_if_missing = true;
-          // Set only one bucket to force bucket conflict.
-          // Test index interval for the same prefix to be 1, 2 and 4
-          if (total_order) {
-            options.prefix_extractor.reset();
-
-            PlainTableOptions plain_table_options;
-            plain_table_options.user_key_len = 0;
-            plain_table_options.bloom_bits_per_key = bloom_bits;
-            plain_table_options.hash_table_ratio = 0;
-            plain_table_options.index_sparseness = 2;
-            plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-            plain_table_options.encoding_type = encoding_type;
-            plain_table_options.full_scan_mode = false;
-            plain_table_options.store_index_in_file = store_index_in_file;
-
-            options.table_factory.reset(
-                NewPlainTableFactory(plain_table_options));
-          } else {
-            PlainTableOptions plain_table_options;
-            plain_table_options.user_key_len = 0;
-            plain_table_options.bloom_bits_per_key = bloom_bits;
-            plain_table_options.hash_table_ratio = 0.75;
-            plain_table_options.index_sparseness = 16;
-            plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-            plain_table_options.encoding_type = encoding_type;
-            plain_table_options.full_scan_mode = false;
-            plain_table_options.store_index_in_file = store_index_in_file;
-
-            options.table_factory.reset(
-                NewPlainTableFactory(plain_table_options));
-          }
-          DestroyAndReopen(&options);
-          uint64_t int_num;
-          ASSERT_TRUE(dbfull()->GetIntProperty(
-              "rocksdb.estimate-table-readers-mem", &int_num));
-          ASSERT_EQ(int_num, 0U);
-
-          ASSERT_OK(Put("1000000000000foo", "v1"));
-          ASSERT_OK(Put("0000000000000bar", "v2"));
-          ASSERT_OK(Put("1000000000000foo", "v3"));
-          dbfull()->TEST_FlushMemTable();
-
-          ASSERT_TRUE(dbfull()->GetIntProperty(
-              "rocksdb.estimate-table-readers-mem", &int_num));
-          ASSERT_GT(int_num, 0U);
-
-          TablePropertiesCollection ptc;
-          reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc);
-          ASSERT_EQ(1U, ptc.size());
-          auto row = ptc.begin();
-          auto tp = row->second;
-
-          if (!store_index_in_file) {
-            ASSERT_EQ(total_order ? "4" : "12",
-                      (tp->user_collected_properties)
-                          .at("plain_table_hash_table_size"));
-            ASSERT_EQ("0", (tp->user_collected_properties)
-                               .at("plain_table_sub_index_size"));
-          } else {
-            ASSERT_EQ("0", (tp->user_collected_properties)
-                               .at("plain_table_hash_table_size"));
-            ASSERT_EQ("0", (tp->user_collected_properties)
-                               .at("plain_table_sub_index_size"));
-          }
-          ASSERT_EQ("v3", Get("1000000000000foo"));
-          ASSERT_EQ("v2", Get("0000000000000bar"));
-        }
+        Options options = CurrentOptions();
+        options.create_if_missing = true;
+        // Set only one bucket to force bucket conflict.
+        // Test index interval for the same prefix to be 1, 2 and 4
+        if (total_order) {
+          options.prefix_extractor.reset();
+          options.table_factory.reset(NewPlainTableFactory(
+              0, bloom_bits, 0, 2, huge_page_tlb_size, encoding_type));
+        } else {
+          options.table_factory.reset(NewPlainTableFactory(
+              0, bloom_bits, 0.75, 16, huge_page_tlb_size, encoding_type));
        }
+        DestroyAndReopen(&options);
+
+        ASSERT_OK(Put("1000000000000foo", "v1"));
+        ASSERT_OK(Put("0000000000000bar", "v2"));
+        ASSERT_OK(Put("1000000000000foo", "v3"));
+        dbfull()->TEST_FlushMemTable();
+
+        TablePropertiesCollection ptc;
+        reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc);
+        ASSERT_EQ(1U, ptc.size());
+        auto row = ptc.begin();
+        auto tp = row->second;
+        ASSERT_EQ(total_order ? "4" : "12", (tp->user_collected_properties).at(
+                                                "plain_table_hash_table_size"));
+        ASSERT_EQ("0", (tp->user_collected_properties)
+                           .at("plain_table_sub_index_size"));
+
+        ASSERT_EQ("v3", Get("1000000000000foo"));
+        ASSERT_EQ("v2", Get("0000000000000bar"));
      }
    }
+    }
  }
 }

@@ -394,15 +305,7 @@ TEST(PlainTableDBTest, Flush2) {
    for (EncodingType encoding_type : {kPlain, kPrefix}) {
    for (int bloom_bits = 0; bloom_bits <= 117; bloom_bits += 117) {
      for (int total_order = 0; total_order <= 1; total_order++) {
-        for (int store_index_in_file = 0; store_index_in_file <= 1;
-             ++store_index_in_file) {
-          if (encoding_type == kPrefix && total_order) {
-            continue;
-          }
-          if (!bloom_bits && store_index_in_file) {
-            continue;
-          }
-          if (total_order && store_index_in_file) {
+        if (encoding_type == kPrefix && total_order == 1) {
          continue;
        }
        bool expect_bloom_not_match = false;
@@ -410,23 +313,16 @@ TEST(PlainTableDBTest, Flush2) {
        options.create_if_missing = true;
        // Set only one bucket to force bucket conflict.
        // Test index interval for the same prefix to be 1, 2 and 4
-        PlainTableOptions plain_table_options;
        if (total_order) {
          options.prefix_extractor = nullptr;
-          plain_table_options.hash_table_ratio = 0;
-          plain_table_options.index_sparseness = 2;
+          options.table_factory.reset(new TestPlainTableFactory(
+              &expect_bloom_not_match, 0, bloom_bits, 0, 2, huge_page_tlb_size,
+              encoding_type));
        } else {
-          plain_table_options.hash_table_ratio = 0.75;
-          plain_table_options.index_sparseness = 16;
+          options.table_factory.reset(new TestPlainTableFactory(
+              &expect_bloom_not_match, 0, bloom_bits, 0.75, 16,
+              huge_page_tlb_size, encoding_type));
        }
-        plain_table_options.user_key_len = kPlainTableVariableLength;
-        plain_table_options.bloom_bits_per_key = bloom_bits;
-        plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-        plain_table_options.encoding_type = encoding_type;
-        plain_table_options.store_index_in_file = store_index_in_file;
-        options.table_factory.reset(new TestPlainTableFactory(
-            &expect_bloom_not_match, plain_table_options));
-
        DestroyAndReopen(&options);
        ASSERT_OK(Put("0000000000000bar", "b"));
        ASSERT_OK(Put("1000000000000foo", "v1"));
@@ -454,6 +350,7 @@ TEST(PlainTableDBTest, Flush2) {
          // Neither key nor value should exist.
          expect_bloom_not_match = true;
          ASSERT_EQ("NOT_FOUND", Get("5_not00000000bar"));
+
          // Key doesn't exist any more but prefix exists.
          if (total_order) {
            ASSERT_EQ("NOT_FOUND", Get("1000000000000not"));
@@ -462,7 +359,6 @@ TEST(PlainTableDBTest, Flush2) {
          expect_bloom_not_match = false;
        }
      }
-      }
    }
    }
  }
@@ -484,28 +380,13 @@ TEST(PlainTableDBTest, Iterator) {
        // Test index interval for the same prefix to be 1, 2 and 4
        if (total_order) {
          options.prefix_extractor = nullptr;
-
-          PlainTableOptions plain_table_options;
-          plain_table_options.user_key_len = 16;
-          plain_table_options.bloom_bits_per_key = bloom_bits;
-          plain_table_options.hash_table_ratio = 0;
-          plain_table_options.index_sparseness = 2;
-          plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-          plain_table_options.encoding_type = encoding_type;
-
          options.table_factory.reset(new TestPlainTableFactory(
-              &expect_bloom_not_match, plain_table_options));
+              &expect_bloom_not_match, 16, bloom_bits, 0, 2, huge_page_tlb_size,
+              encoding_type));
        } else {
-          PlainTableOptions plain_table_options;
-          plain_table_options.user_key_len = 16;
-          plain_table_options.bloom_bits_per_key = bloom_bits;
-          plain_table_options.hash_table_ratio = 0.75;
-          plain_table_options.index_sparseness = 16;
-          plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-          plain_table_options.encoding_type = encoding_type;
-
          options.table_factory.reset(new TestPlainTableFactory(
-              &expect_bloom_not_match, plain_table_options));
+              &expect_bloom_not_match, 16, bloom_bits, 0.75, 16,
+              huge_page_tlb_size, encoding_type));
        }
        DestroyAndReopen(&options);

@@ -604,13 +485,7 @@ std::string MakeLongKey(size_t length, char c) {

 TEST(PlainTableDBTest, IteratorLargeKeys) {
  Options options = CurrentOptions();
-
-  PlainTableOptions plain_table_options;
-  plain_table_options.user_key_len = 0;
-  plain_table_options.bloom_bits_per_key = 0;
-  plain_table_options.hash_table_ratio = 0;
-
-  options.table_factory.reset(NewPlainTableFactory(plain_table_options));
+  options.table_factory.reset(NewPlainTableFactory(0, 0, 0));
  options.create_if_missing = true;
  options.prefix_extractor.reset();
  DestroyAndReopen(&options);
@@ -654,16 +529,7 @@ std::string MakeLongKeyWithPrefix(size_t length, char c) {

 TEST(PlainTableDBTest, IteratorLargeKeysWithPrefix) {
  Options options = CurrentOptions();
-
-  PlainTableOptions plain_table_options;
-  plain_table_options.user_key_len = 16;
-  plain_table_options.bloom_bits_per_key = 0;
-  plain_table_options.hash_table_ratio = 0.8;
-  plain_table_options.index_sparseness = 3;
-  plain_table_options.huge_page_tlb_size = 0;
-  plain_table_options.encoding_type = kPrefix;
-
-  options.table_factory.reset(NewPlainTableFactory(plain_table_options));
+  options.table_factory.reset(NewPlainTableFactory(16, 0, 0.8, 3, 0, kPrefix));
  options.create_if_missing = true;
  DestroyAndReopen(&options);

@@ -799,16 +665,8 @@ TEST(PlainTableDBTest, HashBucketConflict) {
      options.create_if_missing = true;
      // Set only one bucket to force bucket conflict.
      // Test index interval for the same prefix to be 1, 2 and 4
-
-      PlainTableOptions plain_table_options;
-      plain_table_options.user_key_len = 16;
-      plain_table_options.bloom_bits_per_key = 0;
-      plain_table_options.hash_table_ratio = 0;
-      plain_table_options.index_sparseness = 2 ^ i;
-      plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-
-      options.table_factory.reset(NewPlainTableFactory(plain_table_options));
-
+      options.table_factory.reset(
+          NewPlainTableFactory(16, 0, 0, 2 ^ i, huge_page_tlb_size));
      DestroyAndReopen(&options);
      ASSERT_OK(Put("5000000000000fo0", "v1"));
      ASSERT_OK(Put("5000000000000fo1", "v2"));
@@ -894,15 +752,8 @@ TEST(PlainTableDBTest, HashBucketConflictReverseSuffixComparator) {
      options.comparator = &comp;
      // Set only one bucket to force bucket conflict.
      // Test index interval for the same prefix to be 1, 2 and 4
-
-      PlainTableOptions plain_table_options;
-      plain_table_options.user_key_len = 16;
-      plain_table_options.bloom_bits_per_key = 0;
-      plain_table_options.hash_table_ratio = 0;
-      plain_table_options.index_sparseness = 2 ^ i;
-      plain_table_options.huge_page_tlb_size = huge_page_tlb_size;
-
-      options.table_factory.reset(NewPlainTableFactory(plain_table_options));
+      options.table_factory.reset(
+          NewPlainTableFactory(16, 0, 0, 2 ^ i, huge_page_tlb_size));
      DestroyAndReopen(&options);
      ASSERT_OK(Put("5000000000000fo0", "v1"));
      ASSERT_OK(Put("5000000000000fo1", "v2"));
@@ -982,13 +833,7 @@ TEST(PlainTableDBTest, NonExistingKeyToNonEmptyBucket) {
  options.create_if_missing = true;
  // Set only one bucket to force bucket conflict.
  // Test index interval for the same prefix to be 1, 2 and 4
-  PlainTableOptions plain_table_options;
-  plain_table_options.user_key_len = 16;
-  plain_table_options.bloom_bits_per_key = 0;
-  plain_table_options.hash_table_ratio = 0;
-  plain_table_options.index_sparseness = 5;
-
-  options.table_factory.reset(NewPlainTableFactory(plain_table_options));
+  options.table_factory.reset(NewPlainTableFactory(16, 0, 0, 5));
  DestroyAndReopen(&options);
  ASSERT_OK(Put("5000000000000fo0", "v1"));
  ASSERT_OK(Put("5000000000000fo1", "v2"));
@@ -57,7 +57,8 @@ class Repairer {
      : dbname_(dbname),
        env_(options.env),
        icmp_(options.comparator),
-        options_(SanitizeOptions(dbname, &icmp_, options)),
+        ipolicy_(options.filter_policy),
+        options_(SanitizeOptions(dbname, &icmp_, &ipolicy_, options)),
        raw_table_cache_(
            // TableCache can be small since we expect each table to be opened
            // once.
@@ -108,6 +109,7 @@ class Repairer {
  std::string const dbname_;
  Env* const env_;
  InternalKeyComparator const icmp_;
+  InternalFilterPolicy const ipolicy_;
  Options const options_;
  std::shared_ptr<Cache> raw_table_cache_;
  TableCache* table_cache_;
@@ -124,8 +126,7 @@ class Repairer {
    std::vector<std::string> filenames;
    bool found_file = false;
    for (uint32_t path_id = 0; path_id < options_.db_paths.size(); path_id++) {
-      Status status =
-          env_->GetChildren(options_.db_paths[path_id].path, &filenames);
+      Status status = env_->GetChildren(options_.db_paths[path_id], &filenames);
      if (!status.ok()) {
        return status;
      }
@@ -237,8 +238,7 @@ class Repairer {
    FileMetaData meta;
    meta.fd = FileDescriptor(next_file_number_++, 0, 0);
    ReadOptions ro;
-    ro.total_order_seek = true;
-    Iterator* iter = mem->NewIterator(ro);
+    Iterator* iter = mem->NewIterator(ro, true /* enforce_total_order */);
    status = BuildTable(dbname_, env_, options_, storage_options_, table_cache_,
                        iter, &meta, icmp_, 0, 0, kNoCompression);
    delete iter;
@@ -264,10 +264,9 @@ class Repairer {
      if (!status.ok()) {
        std::string fname = TableFileName(
            options_.db_paths, t.meta.fd.GetNumber(), t.meta.fd.GetPathId());
-        char file_num_buf[kFormatFileNumberBufSize];
-        FormatFileNumber(t.meta.fd.GetNumber(), t.meta.fd.GetPathId(),
-                         file_num_buf, sizeof(file_num_buf));
-        Log(options_.info_log, "Table #%s: ignoring %s", file_num_buf,
+        Log(options_.info_log, "Table #%s: ignoring %s",
+            FormatFileNumber(t.meta.fd.GetNumber(), t.meta.fd.GetPathId())
+                .c_str(),
            status.ToString().c_str());
        ArchiveFile(fname);
      } else {
@@ -92,8 +92,6 @@ public:

  uint64_t ApproximateOffsetOf(const Slice& key) override;

-  virtual size_t ApproximateMemoryUsage() const override { return 0; }
-
  void SetupForCompaction() override;

  std::shared_ptr<const TableProperties> GetTableProperties() const override;
@@ -555,14 +553,6 @@ public:
                                const InternalKeyComparator& internal_key,
                                WritableFile* file,
                                CompressionType compression_type) const;
-
-  virtual Status SanitizeDBOptions(const DBOptions* db_opts) const override {
-    return Status::OK();
-  }
-
-  virtual std::string GetPrintableTableOptions() const override {
-    return std::string();
-  }
 };

 Status SimpleTableFactory::NewTableReader(
@@ -185,29 +185,6 @@ Status TableCache::GetTableProperties(
  return s;
 }

-size_t TableCache::GetMemoryUsageByTableReader(
-    const EnvOptions& toptions,
-    const InternalKeyComparator& internal_comparator,
-    const FileDescriptor& fd) {
-  Status s;
-  auto table_reader = fd.table_reader;
-  // table already been pre-loaded?
-  if (table_reader) {
-    return table_reader->ApproximateMemoryUsage();
-  }
-
-  Cache::Handle* table_handle = nullptr;
-  s = FindTable(toptions, internal_comparator, fd, &table_handle, true);
-  if (!s.ok()) {
-    return 0;
-  }
-  assert(table_handle);
-  auto table = GetTableReaderFromHandle(table_handle);
-  auto ret = table->ApproximateMemoryUsage();
-  ReleaseHandle(table_handle);
-  return ret;
-}
-
 void TableCache::Evict(Cache* cache, uint64_t file_number) {
  cache->Erase(GetSliceForFileNumber(&file_number));
 }
@@ -80,19 +80,12 @@ class TableCache {
                            std::shared_ptr<const TableProperties>* properties,
                            bool no_io = false);

-  // Return total memory usage of the table reader of the file.
-  // 0 of table reader of the file is not loaded.
-  size_t GetMemoryUsageByTableReader(
-      const EnvOptions& toptions,
-      const InternalKeyComparator& internal_comparator,
-      const FileDescriptor& fd);
-
  // Release the handle from a cache
  void ReleaseHandle(Cache::Handle* handle);

 private:
  Env* const env_;
-  const std::vector<DbPath> db_paths_;
+  const std::vector<std::string> db_paths_;
  const Options* options_;
  const EnvOptions& storage_options_;
  Cache* const cache_;
@@ -213,14 +213,7 @@ TEST(TablePropertiesTest, CustomizedTablePropertiesCollector) {
  Options options;
  options.table_properties_collector_factories.emplace_back(
      new RegularKeysStartWithAFactory());
-
-  PlainTableOptions plain_table_options;
-  plain_table_options.user_key_len = 8;
-  plain_table_options.bloom_bits_per_key = 8;
-  plain_table_options.hash_table_ratio = 0;
-
-  options.table_factory =
-      std::make_shared<PlainTableFactory>(plain_table_options);
+  options.table_factory = std::make_shared<PlainTableFactory>(8, 8, 0);
  test::PlainInternalKeyComparator ikc(options.comparator);
  TestCustomizedTablePropertiesCollector(kPlainTableMagicNumber, true, options,
                                         ikc);
@@ -257,7 +250,7 @@ void TestInternalKeyPropertiesCollector(
    // SanitizeOptions().
    options.info_log = std::make_shared<DumbLogger>();
    options = SanitizeOptions("db",            // just a place holder
-                              &pikc,
+                              &pikc, nullptr,  // don't care filter policy
                              options);
    options.comparator = comparator;
  } else {
@@ -306,15 +299,11 @@ TEST(TablePropertiesTest, InternalKeyPropertiesCollector) {
      true /* not sanitize */,
      std::make_shared<BlockBasedTableFactory>()
  );
-
-  PlainTableOptions plain_table_options;
-  plain_table_options.user_key_len = 8;
-  plain_table_options.bloom_bits_per_key = 8;
-  plain_table_options.hash_table_ratio = 0;
-
  TestInternalKeyPropertiesCollector(
-      kPlainTableMagicNumber, false /* not sanitize */,
-      std::make_shared<PlainTableFactory>(plain_table_options));
+      kPlainTableMagicNumber,
+      false /* not sanitize */,
+      std::make_shared<PlainTableFactory>(8, 8, 0)
+  );
 }

 }  // namespace rocksdb
@@ -0,0 +1,221 @@
+//  Copyright (c) 2013, 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.
+
+#ifndef ROCKSDB_LITE
+#include "db/tailing_iter.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+#include "db/db_impl.h"
+#include "db/db_iter.h"
+#include "db/column_family.h"
+#include "rocksdb/env.h"
+#include "rocksdb/slice.h"
+#include "rocksdb/slice_transform.h"
+#include "table/merger.h"
+
+namespace rocksdb {
+
+TailingIterator::TailingIterator(Env* const env, DBImpl* db,
+    const ReadOptions& read_options, ColumnFamilyData* cfd)
+    : env_(env),
+      db_(db),
+      read_options_(read_options),
+      cfd_(cfd),
+      super_version_(nullptr),
+      current_(nullptr),
+      status_(Status::InvalidArgument("Seek() not called on this iterator")) {}
+
+TailingIterator::~TailingIterator() {
+  Cleanup();
+}
+
+bool TailingIterator::Valid() const {
+  return current_ != nullptr;
+}
+
+void TailingIterator::SeekToFirst() {
+  if (!IsCurrentVersion()) {
+    CreateIterators();
+  }
+
+  mutable_->SeekToFirst();
+  immutable_->SeekToFirst();
+  UpdateCurrent();
+}
+
+void TailingIterator::Seek(const Slice& target) {
+  if (!IsCurrentVersion()) {
+    CreateIterators();
+  }
+
+  mutable_->Seek(target);
+
+  // We maintain the interval (prev_key_, immutable_->key()] such that there
+  // are no records with keys within that range in immutable_ other than
+  // immutable_->key(). Since immutable_ can't change in this version, we don't
+  // need to do a seek if 'target' belongs to that interval (i.e. immutable_ is
+  // already at the correct position)!
+  //
+  // If prefix seek is used and immutable_ is not valid, seek if target has a
+  // different prefix than prev_key.
+  //
+  // prev_key_ is updated by Next(). SeekImmutable() sets prev_key_ to
+  // 'target' -- in this case, prev_key_ is included in the interval, so
+  // prev_inclusive_ has to be set.
+
+  const Comparator* cmp = cfd_->user_comparator();
+  if (!is_prev_set_ || cmp->Compare(prev_key_, target) >= !is_prev_inclusive_ ||
+      (immutable_->Valid() && cmp->Compare(target, immutable_->key()) > 0) ||
+      (cfd_->options()->prefix_extractor != nullptr && !IsSamePrefix(target))) {
+    SeekImmutable(target);
+  }
+
+  UpdateCurrent();
+}
+
+void TailingIterator::Next() {
+  assert(Valid());
+
+  if (!IsCurrentVersion()) {
+    // save the current key, create new iterators and then seek
+    std::string current_key = key().ToString();
+    Slice key_slice(current_key.data(), current_key.size());
+
+    CreateIterators();
+    Seek(key_slice);
+
+    if (!Valid() || key().compare(key_slice) != 0) {
+      // record with current_key no longer exists
+      return;
+    }
+
+  } else if (current_ == immutable_.get()) {
+    // immutable iterator is advanced -- update prev_key_
+    prev_key_ = key().ToString();
+    is_prev_inclusive_ = false;
+    is_prev_set_ = true;
+  }
+
+  current_->Next();
+  UpdateCurrent();
+}
+
+Slice TailingIterator::key() const {
+  assert(Valid());
+  return current_->key();
+}
+
+Slice TailingIterator::value() const {
+  assert(Valid());
+  return current_->value();
+}
+
+Status TailingIterator::status() const {
+  if (!status_.ok()) {
+    return status_;
+  } else if (!mutable_->status().ok()) {
+    return mutable_->status();
+  } else {
+    return immutable_->status();
+  }
+}
+
+void TailingIterator::Prev() {
+  status_ = Status::NotSupported("This iterator doesn't support Prev()");
+}
+
+void TailingIterator::SeekToLast() {
+  status_ = Status::NotSupported("This iterator doesn't support SeekToLast()");
+}
+
+void TailingIterator::Cleanup() {
+  // Release old super version if necessary
+  mutable_.reset();
+  immutable_.reset();
+  if (super_version_ != nullptr && super_version_->Unref()) {
+    DBImpl::DeletionState deletion_state;
+    db_->mutex_.Lock();
+    super_version_->Cleanup();
+    db_->FindObsoleteFiles(deletion_state, false, true);
+    db_->mutex_.Unlock();
+    delete super_version_;
+    if (deletion_state.HaveSomethingToDelete()) {
+      db_->PurgeObsoleteFiles(deletion_state);
+    }
+  }
+}
+
+void TailingIterator::CreateIterators() {
+  Cleanup();
+  super_version_= cfd_->GetReferencedSuperVersion(&(db_->mutex_));
+
+  Iterator* mutable_iter = super_version_->mem->NewIterator(read_options_);
+  // create a DBIter that only uses memtable content; see NewIterator()
+  mutable_.reset(
+      NewDBIterator(env_, *cfd_->options(), cfd_->user_comparator(),
+                    mutable_iter, kMaxSequenceNumber));
+
+  std::vector<Iterator*> list;
+  super_version_->imm->AddIterators(read_options_, &list);
+  super_version_->current->AddIterators(
+      read_options_, *cfd_->soptions(), &list);
+  Iterator* immutable_iter =
+      NewMergingIterator(&cfd_->internal_comparator(), &list[0], list.size());
+
+  // create a DBIter that only uses memtable content; see NewIterator()
+  immutable_.reset(
+      NewDBIterator(env_, *cfd_->options(), cfd_->user_comparator(),
+                    immutable_iter, kMaxSequenceNumber));
+
+  current_ = nullptr;
+  is_prev_set_ = false;
+}
+
+void TailingIterator::UpdateCurrent() {
+  current_ = nullptr;
+
+  if (mutable_->Valid()) {
+    current_ = mutable_.get();
+  }
+  const Comparator* cmp = cfd_->user_comparator();
+  if (immutable_->Valid() &&
+      (current_ == nullptr ||
+       cmp->Compare(immutable_->key(), current_->key()) < 0)) {
+    current_ = immutable_.get();
+  }
+
+  if (!status_.ok()) {
+    // reset status that was set by Prev() or SeekToLast()
+    status_ = Status::OK();
+  }
+}
+
+bool TailingIterator::IsCurrentVersion() const {
+  return super_version_ != nullptr &&
+         super_version_->version_number == cfd_->GetSuperVersionNumber();
+}
+
+bool TailingIterator::IsSamePrefix(const Slice& target) const {
+  const SliceTransform* extractor = cfd_->options()->prefix_extractor.get();
+
+  assert(extractor);
+  assert(is_prev_set_);
+
+  return extractor->Transform(target)
+    .compare(extractor->Transform(prev_key_)) == 0;
+}
+
+void TailingIterator::SeekImmutable(const Slice& target) {
+  prev_key_ = target.ToString();
+  is_prev_inclusive_ = true;
+  is_prev_set_ = true;
+
+  immutable_->Seek(target);
+}
+
+}  // namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -0,0 +1,97 @@
+//  Copyright (c) 2013, 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.
+#pragma once
+
+#ifndef ROCKSDB_LITE
+
+#include <string>
+
+#include "rocksdb/db.h"
+#include "rocksdb/iterator.h"
+#include "rocksdb/options.h"
+
+namespace rocksdb {
+
+class DBImpl;
+class Env;
+struct SuperVersion;
+class ColumnFamilyData;
+
+/**
+ * TailingIterator is a special type of iterator that doesn't use an (implicit)
+ * snapshot. In other words, it can be used to read data that was added to the
+ * db after the iterator had been created.
+ *
+ * TailingIterator is optimized for sequential reading. It doesn't support
+ * Prev() and SeekToLast() operations.
+ */
+class TailingIterator : public Iterator {
+ public:
+  TailingIterator(Env* const env, DBImpl* db, const ReadOptions& read_options,
+                  ColumnFamilyData* cfd);
+  virtual ~TailingIterator();
+
+  virtual bool Valid() const override;
+  virtual void SeekToFirst() override;
+  virtual void SeekToLast() override;
+  virtual void Seek(const Slice& target) override;
+  virtual void Next() override;
+  virtual void Prev() override;
+  virtual Slice key() const override;
+  virtual Slice value() const override;
+  virtual Status status() const override;
+
+ private:
+  void Cleanup();
+
+  Env* const env_;
+  DBImpl* const db_;
+  const ReadOptions read_options_;
+  ColumnFamilyData* const cfd_;
+  SuperVersion* super_version_;
+
+  // TailingIterator merges the contents of the two iterators below (one using
+  // mutable memtable contents only, other over SSTs and immutable memtables).
+  // See DBIter::GetTailingIteratorPair().
+  std::unique_ptr<Iterator> mutable_;
+  std::unique_ptr<Iterator> immutable_;
+
+  // points to either mutable_ or immutable_
+  Iterator* current_;
+
+  // key that precedes immutable iterator's current key
+  std::string prev_key_;
+
+  // unless prev_set is true, prev_key/prev_head is not valid and shouldn't be
+  // used; reset by createIterators()
+  bool is_prev_set_;
+
+  // prev_key_ was set by SeekImmutable(), which means that the interval of
+  // keys covered by immutable_ is [prev_key_, current], i.e. it includes the
+  // left endpoint
+  bool is_prev_inclusive_;
+
+  // internal iterator status
+  Status status_;
+
+  // check if this iterator's version matches DB's version
+  bool IsCurrentVersion() const;
+
+  // check if SeekImmutable() is needed due to target having a different prefix
+  // than prev_key_ (used when in prefix seek mode)
+  bool IsSamePrefix(const Slice& target) const;
+
+  // creates mutable_ and immutable_ iterators and updates version_number_
+  void CreateIterators();
+
+  // set current_ to be one of the iterators with the smallest key
+  void UpdateCurrent();
+
+  // seek on immutable_ and update prev_key
+  void SeekImmutable(const Slice& target);
+};
+
+}  // namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -14,8 +14,6 @@
 #include <string>
 #include "rocksdb/cache.h"
 #include "db/dbformat.h"
-#include "util/arena.h"
-#include "util/autovector.h"

 namespace rocksdb {

@@ -81,8 +79,6 @@ struct FileMetaData {
  uint64_t num_deletions;          // the number of deletion entries.
  uint64_t raw_key_size;           // total uncompressed key size.
  uint64_t raw_value_size;         // total uncompressed value size.
-  bool init_stats_from_file;   // true if the data-entry stats of this file
-                               // has initialized from file.

  FileMetaData()
      : refs(0),
@@ -92,8 +88,7 @@ struct FileMetaData {
        num_entries(0),
        num_deletions(0),
        raw_key_size(0),
-        raw_value_size(0),
-        init_stats_from_file(false) {}
+        raw_value_size(0) {}
 };

 // A compressed copy of file meta data that just contain
@@ -53,6 +53,14 @@ class ColumnFamilySet;
 class TableCache;
 class MergeIteratorBuilder;

+
+// Return the smallest index i such that files[i]->largest >= key.
+// Return files.size() if there is no such file.
+// REQUIRES: "files" contains a sorted list of non-overlapping files.
+extern int FindFile(const InternalKeyComparator& icmp,
+                    const std::vector<FileMetaData*>& files,
+                    const Slice& key);
+
 // Return the smallest index i such that file_level.files[i]->largest >= key.
 // Return file_level.num_files if there is no such file.
 // REQUIRES: "file_level.files" contains a sorted list of
@@ -74,13 +82,6 @@ extern bool SomeFileOverlapsRange(
    const Slice* smallest_user_key,
    const Slice* largest_user_key);

-// Generate FileLevel from vector<FdWithKeyRange*>
-// Would copy smallest_key and largest_key data to sequential memory
-// arena: Arena used to allocate the memory
-extern void DoGenerateFileLevel(FileLevel* file_level,
-        const std::vector<FileMetaData*>& files,
-        Arena* arena);
-
 class Version {
 public:
  // Append to *iters a sequence of iterators that will
@@ -232,10 +233,6 @@ class Version {
  // tables' propertis, represented as shared_ptr.
  Status GetPropertiesOfAllTables(TablePropertiesCollection* props);

-  uint64_t GetEstimatedActiveKeys();
-
-  size_t GetMemoryUsageByTableReaders();
-
  // used to sort files by size
  struct Fsize {
    int index;
@@ -252,7 +249,6 @@ class Version {
  friend class UniversalCompactionPicker;
  friend class FIFOCompactionPicker;
  friend class ForwardIterator;
-  friend class InternalStats;

  class LevelFileNumIterator;
  class LevelFileIteratorState;
@@ -288,7 +284,6 @@ class Version {
  int num_levels_;              // Number of levels
  int num_non_empty_levels_;    // Number of levels. Any level larger than it
                                // is guaranteed to be empty.
-  FileIndexer file_indexer_;
  VersionSet* vset_;            // VersionSet to which this Version belongs
  Arena arena_;                 // Used to allocate space for file_levels_
  Version* next_;               // Next version in linked list
@@ -299,6 +294,7 @@ class Version {
  // in increasing order of keys
  std::vector<FileMetaData*>* files_;

+
  // A list for the same set of files that are stored in files_,
  // but files in each level are now sorted based on file
  // size. The file with the largest size is at the front.
@@ -331,6 +327,7 @@ class Version {
  uint64_t version_number_;

  Version(ColumnFamilyData* cfd, VersionSet* vset, uint64_t version_number = 0);
+  FileIndexer file_indexer_;

  // total file size
  uint64_t total_file_size_;
@@ -340,8 +337,7 @@ class Version {
  uint64_t total_raw_value_size_;
  // total number of non-deletion entries
  uint64_t num_non_deletions_;
-  // total number of deletion entries
-  uint64_t num_deletions_;
+

  ~Version();

@@ -14,15 +14,14 @@

 namespace rocksdb {

-class GenerateFileLevelTest {
+class FindFileTest {
 public:
  std::vector<FileMetaData*> files_;
-  FileLevel file_level_;
-  Arena arena_;
+  bool disjoint_sorted_files_;

-  GenerateFileLevelTest() { }
+  FindFileTest() : disjoint_sorted_files_(true) { }

-  ~GenerateFileLevelTest() {
+  ~FindFileTest() {
    for (unsigned int i = 0; i < files_.size(); i++) {
      delete files_[i];
    }
@@ -38,44 +37,55 @@ class GenerateFileLevelTest {
    files_.push_back(f);
  }

-  int Compare() {
-    int diff = 0;
-    for (size_t i = 0; i < files_.size(); i++) {
-      if (file_level_.files[i].fd.GetNumber() != files_[i]->fd.GetNumber()) {
-        diff++;
-      }
-    }
-    return diff;
+  int Find(const char* key) {
+    InternalKey target(key, 100, kTypeValue);
+    InternalKeyComparator cmp(BytewiseComparator());
+    return FindFile(cmp, files_, target.Encode());
  }
 };

-TEST(GenerateFileLevelTest, Empty) {
-  DoGenerateFileLevel(&file_level_, files_, &arena_);
-  ASSERT_EQ(0u, file_level_.num_files);
-  ASSERT_EQ(0, Compare());
+TEST(FindFileTest, Empty) {
+  ASSERT_EQ(0, Find("foo"));
 }

-TEST(GenerateFileLevelTest, Single) {
+TEST(FindFileTest, Single) {
  Add("p", "q");
-  DoGenerateFileLevel(&file_level_, files_, &arena_);
-  ASSERT_EQ(1u, file_level_.num_files);
-  ASSERT_EQ(0, Compare());
+  ASSERT_EQ(0, Find("a"));
+  ASSERT_EQ(0, Find("p"));
+  ASSERT_EQ(0, Find("p1"));
+  ASSERT_EQ(0, Find("q"));
+  ASSERT_EQ(1, Find("q1"));
+  ASSERT_EQ(1, Find("z"));
 }


-TEST(GenerateFileLevelTest, Multiple) {
+TEST(FindFileTest, Multiple) {
  Add("150", "200");
  Add("200", "250");
  Add("300", "350");
  Add("400", "450");
-  DoGenerateFileLevel(&file_level_, files_, &arena_);
-  ASSERT_EQ(4u, file_level_.num_files);
-  ASSERT_EQ(0, Compare());
+  ASSERT_EQ(0, Find("100"));
+  ASSERT_EQ(0, Find("150"));
+  ASSERT_EQ(0, Find("151"));
+  ASSERT_EQ(0, Find("199"));
+  ASSERT_EQ(0, Find("200"));
+  ASSERT_EQ(1, Find("201"));
+  ASSERT_EQ(1, Find("249"));
+  ASSERT_EQ(1, Find("250"));
+  ASSERT_EQ(2, Find("251"));
+  ASSERT_EQ(2, Find("299"));
+  ASSERT_EQ(2, Find("300"));
+  ASSERT_EQ(2, Find("349"));
+  ASSERT_EQ(2, Find("350"));
+  ASSERT_EQ(3, Find("351"));
+  ASSERT_EQ(3, Find("400"));
+  ASSERT_EQ(3, Find("450"));
+  ASSERT_EQ(4, Find("451"));
 }

 class FindLevelFileTest {
 public:
-  FileLevel file_level_;
+  FileLevel level_files_;
  bool disjoint_sorted_files_;
  Arena arena_;

@@ -86,8 +96,8 @@ class FindLevelFileTest {

  void LevelFileInit(size_t num = 0) {
    char* mem = arena_.AllocateAligned(num * sizeof(FdWithKeyRange));
-    file_level_.files = new (mem)FdWithKeyRange[num];
-    file_level_.num_files = 0;
+    level_files_.files = new (mem)FdWithKeyRange[num];
+    level_files_.num_files = 0;
  }

  void Add(const char* smallest, const char* largest,
@@ -105,27 +115,27 @@ class FindLevelFileTest {
    memcpy(mem + smallest_slice.size(), largest_slice.data(),
        largest_slice.size());

-    // add to file_level_
-    size_t num = file_level_.num_files;
-    auto& file = file_level_.files[num];
+    // add compressd_level_
+    size_t num = level_files_.num_files;
+    auto& file = level_files_.files[num];
    file.fd = FileDescriptor(num + 1, 0, 0);
    file.smallest_key = Slice(mem, smallest_slice.size());
    file.largest_key = Slice(mem + smallest_slice.size(),
        largest_slice.size());
-    file_level_.num_files++;
+    level_files_.num_files++;
  }

  int Find(const char* key) {
    InternalKey target(key, 100, kTypeValue);
    InternalKeyComparator cmp(BytewiseComparator());
-    return FindFile(cmp, file_level_, target.Encode());
+    return FindFile(cmp, level_files_, target.Encode());
  }

  bool Overlaps(const char* smallest, const char* largest) {
    InternalKeyComparator cmp(BytewiseComparator());
    Slice s(smallest != nullptr ? smallest : "");
    Slice l(largest != nullptr ? largest : "");
-    return SomeFileOverlapsRange(cmp, disjoint_sorted_files_, file_level_,
+    return SomeFileOverlapsRange(cmp, disjoint_sorted_files_, level_files_,
                                 (smallest != nullptr ? &s : nullptr),
                                 (largest != nullptr ? &l : nullptr));
  }
@@ -27,7 +27,6 @@
 #include "rocksdb/merge_operator.h"
 #include "db/dbformat.h"
 #include "db/db_impl.h"
-#include "db/column_family.h"
 #include "db/memtable.h"
 #include "db/snapshot.h"
 #include "db/write_batch_internal.h"
@@ -81,58 +80,6 @@ int WriteBatch::Count() const {
  return WriteBatchInternal::Count(this);
 }

-Status ReadRecordFromWriteBatch(Slice* input, char* tag,
-                                uint32_t* column_family, Slice* key,
-                                Slice* value, Slice* blob) {
-  assert(key != nullptr && value != nullptr);
-  *tag = (*input)[0];
-  input->remove_prefix(1);
-  *column_family = 0;  // default
-  switch (*tag) {
-    case kTypeColumnFamilyValue:
-      if (!GetVarint32(input, column_family)) {
-        return Status::Corruption("bad WriteBatch Put");
-      }
-    // intentional fallthrough
-    case kTypeValue:
-      if (!GetLengthPrefixedSlice(input, key) ||
-          !GetLengthPrefixedSlice(input, value)) {
-        return Status::Corruption("bad WriteBatch Put");
-      }
-      break;
-    case kTypeColumnFamilyDeletion:
-      if (!GetVarint32(input, column_family)) {
-        return Status::Corruption("bad WriteBatch Delete");
-      }
-    // intentional fallthrough
-    case kTypeDeletion:
-      if (!GetLengthPrefixedSlice(input, key)) {
-        return Status::Corruption("bad WriteBatch Delete");
-      }
-      break;
-    case kTypeColumnFamilyMerge:
-      if (!GetVarint32(input, column_family)) {
-        return Status::Corruption("bad WriteBatch Merge");
-      }
-    // intentional fallthrough
-    case kTypeMerge:
-      if (!GetLengthPrefixedSlice(input, key) ||
-          !GetLengthPrefixedSlice(input, value)) {
-        return Status::Corruption("bad WriteBatch Merge");
-      }
-      break;
-    case kTypeLogData:
-      assert(blob != nullptr);
-      if (!GetLengthPrefixedSlice(input, blob)) {
-        return Status::Corruption("bad WriteBatch Blob");
-      }
-      break;
-    default:
-      return Status::Corruption("unknown WriteBatch tag");
-  }
-  return Status::OK();
-}
-
 Status WriteBatch::Iterate(Handler* handler) const {
  Slice input(rep_);
  if (input.size() < kHeader) {
@@ -144,33 +91,57 @@ Status WriteBatch::Iterate(Handler* handler) const {
  int found = 0;
  Status s;
  while (s.ok() && !input.empty() && handler->Continue()) {
-    char tag = 0;
+    char tag = input[0];
+    input.remove_prefix(1);
    uint32_t column_family = 0;  // default
-
-    s = ReadRecordFromWriteBatch(&input, &tag, &column_family, &key, &value,
-                                 &blob);
-    if (!s.ok()) {
-      return s;
-    }
-
    switch (tag) {
      case kTypeColumnFamilyValue:
+        if (!GetVarint32(&input, &column_family)) {
+          return Status::Corruption("bad WriteBatch Put");
+        }
+      // intentional fallthrough
      case kTypeValue:
-        s = handler->PutCF(column_family, key, value);
-        found++;
+        if (GetLengthPrefixedSlice(&input, &key) &&
+            GetLengthPrefixedSlice(&input, &value)) {
+          s = handler->PutCF(column_family, key, value);
+          found++;
+        } else {
+          return Status::Corruption("bad WriteBatch Put");
+        }
        break;
      case kTypeColumnFamilyDeletion:
+        if (!GetVarint32(&input, &column_family)) {
+          return Status::Corruption("bad WriteBatch Delete");
+        }
+      // intentional fallthrough
      case kTypeDeletion:
-        s = handler->DeleteCF(column_family, key);
-        found++;
+        if (GetLengthPrefixedSlice(&input, &key)) {
+          s = handler->DeleteCF(column_family, key);
+          found++;
+        } else {
+          return Status::Corruption("bad WriteBatch Delete");
+        }
        break;
      case kTypeColumnFamilyMerge:
+        if (!GetVarint32(&input, &column_family)) {
+          return Status::Corruption("bad WriteBatch Merge");
+        }
+      // intentional fallthrough
      case kTypeMerge:
-        s = handler->MergeCF(column_family, key, value);
-        found++;
+        if (GetLengthPrefixedSlice(&input, &key) &&
+            GetLengthPrefixedSlice(&input, &value)) {
+          s = handler->MergeCF(column_family, key, value);
+          found++;
+        } else {
+          return Status::Corruption("bad WriteBatch Merge");
+        }
        break;
      case kTypeLogData:
-        handler->LogData(blob);
+        if (GetLengthPrefixedSlice(&input, &blob)) {
+          handler->LogData(blob);
+        } else {
+          return Status::Corruption("bad WriteBatch Blob");
+        }
        break;
      default:
        return Status::Corruption("unknown WriteBatch tag");
@@ -215,6 +186,17 @@ void WriteBatchInternal::Put(WriteBatch* b, uint32_t column_family_id,
  PutLengthPrefixedSlice(&b->rep_, value);
 }

+namespace {
+inline uint32_t GetColumnFamilyID(ColumnFamilyHandle* column_family) {
+  uint32_t column_family_id = 0;
+  if (column_family != nullptr) {
+    auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
+    column_family_id = cfh->GetID();
+  }
+  return column_family_id;
+}
+}  // namespace
+
 void WriteBatch::Put(ColumnFamilyHandle* column_family, const Slice& key,
                     const Slice& value) {
  WriteBatchInternal::Put(this, GetColumnFamilyID(column_family), key, value);
@@ -299,17 +281,17 @@ class MemTableInserter : public WriteBatch::Handler {
 public:
  SequenceNumber sequence_;
  ColumnFamilyMemTables* cf_mems_;
-  bool ignore_missing_column_families_;
+  bool recovery_;
  uint64_t log_number_;
  DBImpl* db_;
  const bool dont_filter_deletes_;

  MemTableInserter(SequenceNumber sequence, ColumnFamilyMemTables* cf_mems,
-                   bool ignore_missing_column_families, uint64_t log_number,
-                   DB* db, const bool dont_filter_deletes)
+                   bool recovery, uint64_t log_number, DB* db,
+                   const bool dont_filter_deletes)
      : sequence_(sequence),
        cf_mems_(cf_mems),
-        ignore_missing_column_families_(ignore_missing_column_families),
+        recovery_(recovery),
        log_number_(log_number),
        db_(reinterpret_cast<DBImpl*>(db)),
        dont_filter_deletes_(dont_filter_deletes) {
@@ -321,18 +303,12 @@ class MemTableInserter : public WriteBatch::Handler {

  bool SeekToColumnFamily(uint32_t column_family_id, Status* s) {
    bool found = cf_mems_->Seek(column_family_id);
-    if (!found) {
-      if (ignore_missing_column_families_) {
-        *s = Status::OK();
-      } else {
-        *s = Status::InvalidArgument(
-            "Invalid column family specified in write batch");
-      }
-      return false;
-    }
-    if (log_number_ != 0 && log_number_ < cf_mems_->GetLogNumber()) {
-      // This is true only in recovery environment (log_number_ is always 0 in
-      // non-recovery, regular write code-path)
+    if (recovery_ && (!found || log_number_ < cf_mems_->GetLogNumber())) {
+      // if in recovery envoronment:
+      // * If column family was not found, it might mean that the WAL write
+      // batch references to the column family that was dropped after the
+      // insert. We don't want to fail the whole write batch in that case -- we
+      // just ignore the update.
      // * If log_number_ < cf_mems_->GetLogNumber(), this means that column
      // family already contains updates from this log. We can't apply updates
      // twice because of update-in-place or merge workloads -- ignore the
@@ -340,8 +316,18 @@ class MemTableInserter : public WriteBatch::Handler {
      *s = Status::OK();
      return false;
    }
+    if (!found) {
+      assert(!recovery_);
+      // If the column family was not found in non-recovery enviornment
+      // (client's write code-path), we have to fail the write and return
+      // the failure status to the client.
+      *s = Status::InvalidArgument(
+          "Invalid column family specified in write batch");
+      return false;
+    }
    return true;
  }
+
  virtual Status PutCF(uint32_t column_family_id, const Slice& key,
                       const Slice& value) {
    Status seek_status;
@@ -450,8 +436,8 @@ class MemTableInserter : public WriteBatch::Handler {
          // Failed to merge!
        RecordTick(options->statistics.get(), NUMBER_MERGE_FAILURES);

-        // Store the delta in memtable
-        perform_merge = false;
+          // Store the delta in memtable
+          perform_merge = false;
      } else {
        // 3) Add value to memtable
        mem->Add(sequence_, kTypeValue, key, new_value);
@@ -499,12 +485,10 @@ class MemTableInserter : public WriteBatch::Handler {

 Status WriteBatchInternal::InsertInto(const WriteBatch* b,
                                      ColumnFamilyMemTables* memtables,
-                                      bool ignore_missing_column_families,
-                                      uint64_t log_number, DB* db,
-                                      const bool dont_filter_deletes) {
+                                      bool recovery, uint64_t log_number,
+                                      DB* db, const bool dont_filter_deletes) {
  MemTableInserter inserter(WriteBatchInternal::Sequence(b), memtables,
-                            ignore_missing_column_families, log_number, db,
-                            dont_filter_deletes);
+                            recovery, log_number, db, dont_filter_deletes);
  return b->Iterate(&inserter);
 }

@@ -106,18 +106,18 @@ class WriteBatchInternal {
  // Inserts batch entries into memtable
  // If dont_filter_deletes is false AND options.filter_deletes is true,
  // then --> Drops deletes in batch if db->KeyMayExist returns false
-  // If ignore_missing_column_families == true. WriteBatch referencing
-  // non-existing column family should be ignored.
-  // However, if ignore_missing_column_families == false, any WriteBatch
-  // referencing non-existing column family will return a InvalidArgument()
-  // failure.
-  //
-  // If log_number is non-zero, the memtable will be updated only if
+  // If recovery == true, this means InsertInto is executed on a recovery
+  // code-path. WriteBatch referencing a dropped column family can be
+  // found on a recovery code-path and should be ignored (recovery should not
+  // fail). Additionally, the memtable will be updated only if
  // memtables->GetLogNumber() >= log_number
+  // However, if recovery == false, any WriteBatch referencing
+  // non-existing column family will return a failure. Also, log_number is
+  // ignored in that case
  static Status InsertInto(const WriteBatch* batch,
                           ColumnFamilyMemTables* memtables,
-                           bool ignore_missing_column_families = false,
-                           uint64_t log_number = 0, DB* db = nullptr,
+                           bool recovery = false, uint64_t log_number = 0,
+                           DB* db = nullptr,
                           const bool dont_filter_deletes = true);

  static void Append(WriteBatch* dst, const WriteBatch* src);
@@ -15,7 +15,6 @@
 #include "db/write_batch_internal.h"
 #include "rocksdb/env.h"
 #include "rocksdb/memtablerep.h"
-#include "rocksdb/utilities/write_batch_with_index.h"
 #include "util/logging.h"
 #include "util/testharness.h"

@@ -317,88 +316,6 @@ TEST(WriteBatchTest, ColumnFamiliesBatchTest) {
      handler.seen);
 }

-TEST(WriteBatchTest, ColumnFamiliesBatchWithIndexTest) {
-  WriteBatchWithIndex batch(BytewiseComparator(), 20);
-  ColumnFamilyHandleImplDummy zero(0), two(2), three(3), eight(8);
-  batch.Put(&zero, Slice("foo"), Slice("bar"));
-  batch.Put(&two, Slice("twofoo"), Slice("bar2"));
-  batch.Put(&eight, Slice("eightfoo"), Slice("bar8"));
-  batch.Delete(&eight, Slice("eightfoo"));
-  batch.Merge(&three, Slice("threethree"), Slice("3three"));
-  batch.Put(&zero, Slice("foo"), Slice("bar"));
-  batch.Merge(Slice("omom"), Slice("nom"));
-
-  std::unique_ptr<WBWIIterator> iter;
-
-  iter.reset(batch.NewIterator(&eight));
-  iter->Seek("eightfoo");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(WriteType::kPutRecord, iter->Entry().type);
-  ASSERT_EQ("eightfoo", iter->Entry().key.ToString());
-  ASSERT_EQ("bar8", iter->Entry().value.ToString());
-
-  iter->Next();
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(WriteType::kDeleteRecord, iter->Entry().type);
-  ASSERT_EQ("eightfoo", iter->Entry().key.ToString());
-
-  iter->Next();
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(!iter->Valid());
-
-  iter.reset(batch.NewIterator());
-  iter->Seek("gggg");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(WriteType::kMergeRecord, iter->Entry().type);
-  ASSERT_EQ("omom", iter->Entry().key.ToString());
-  ASSERT_EQ("nom", iter->Entry().value.ToString());
-
-  iter->Next();
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(!iter->Valid());
-
-  iter.reset(batch.NewIterator(&zero));
-  iter->Seek("foo");
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(WriteType::kPutRecord, iter->Entry().type);
-  ASSERT_EQ("foo", iter->Entry().key.ToString());
-  ASSERT_EQ("bar", iter->Entry().value.ToString());
-
-  iter->Next();
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(WriteType::kPutRecord, iter->Entry().type);
-  ASSERT_EQ("foo", iter->Entry().key.ToString());
-  ASSERT_EQ("bar", iter->Entry().value.ToString());
-
-  iter->Next();
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(WriteType::kMergeRecord, iter->Entry().type);
-  ASSERT_EQ("omom", iter->Entry().key.ToString());
-  ASSERT_EQ("nom", iter->Entry().value.ToString());
-
-  iter->Next();
-  ASSERT_OK(iter->status());
-  ASSERT_TRUE(!iter->Valid());
-
-  TestHandler handler;
-  batch.GetWriteBatch()->Iterate(&handler);
-  ASSERT_EQ(
-      "Put(foo, bar)"
-      "PutCF(2, twofoo, bar2)"
-      "PutCF(8, eightfoo, bar8)"
-      "DeleteCF(8, eightfoo)"
-      "MergeCF(3, threethree, 3three)"
-      "Put(foo, bar)"
-      "Merge(omom, nom)",
-      handler.seen);
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -6,8 +6,8 @@
  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.

-  C bindings for rocksdb.  May be useful as a stable ABI that can be
-  used by programs that keep rocksdb in a shared library, or for
+  C bindings for leveldb.  May be useful as a stable ABI that can be
+  used by programs that keep leveldb in a shared library, or for
  a JNI api.

  Does not support:
@@ -61,10 +61,6 @@ typedef struct rocksdb_compactionfiltercontext_t
    rocksdb_compactionfiltercontext_t;
 typedef struct rocksdb_compactionfilterfactory_t
    rocksdb_compactionfilterfactory_t;
-typedef struct rocksdb_compactionfilterv2_t
-    rocksdb_compactionfilterv2_t;
-typedef struct rocksdb_compactionfilterfactoryv2_t
-    rocksdb_compactionfilterfactoryv2_t;
 typedef struct rocksdb_comparator_t      rocksdb_comparator_t;
 typedef struct rocksdb_env_t             rocksdb_env_t;
 typedef struct rocksdb_fifo_compaction_options_t rocksdb_fifo_compaction_options_t;
@@ -75,8 +71,6 @@ typedef struct rocksdb_iterator_t        rocksdb_iterator_t;
 typedef struct rocksdb_logger_t          rocksdb_logger_t;
 typedef struct rocksdb_mergeoperator_t   rocksdb_mergeoperator_t;
 typedef struct rocksdb_options_t         rocksdb_options_t;
-typedef struct rocksdb_block_based_table_options_t
-    rocksdb_block_based_table_options_t;
 typedef struct rocksdb_randomfile_t      rocksdb_randomfile_t;
 typedef struct rocksdb_readoptions_t     rocksdb_readoptions_t;
 typedef struct rocksdb_seqfile_t         rocksdb_seqfile_t;
@@ -348,34 +342,6 @@ extern void rocksdb_writebatch_iterate(
    void (*deleted)(void*, const char* k, size_t klen));
 extern const char* rocksdb_writebatch_data(rocksdb_writebatch_t*, size_t *size);

-/* Block based table options */
-
-extern rocksdb_block_based_table_options_t*
-    rocksdb_block_based_options_create();
-extern void rocksdb_block_based_options_destroy(
-    rocksdb_block_based_table_options_t* options);
-extern void rocksdb_block_based_options_set_block_size(
-    rocksdb_block_based_table_options_t* options, size_t block_size);
-extern void rocksdb_block_based_options_set_block_size_deviation(
-    rocksdb_block_based_table_options_t* options, int block_size_deviation);
-extern void rocksdb_block_based_options_set_block_restart_interval(
-    rocksdb_block_based_table_options_t* options, int block_restart_interval);
-extern void rocksdb_block_based_options_set_filter_policy(
-    rocksdb_block_based_table_options_t* options,
-    rocksdb_filterpolicy_t* filter_policy);
-extern void rocksdb_block_based_options_set_no_block_cache(
-    rocksdb_block_based_table_options_t* options,
-    unsigned char no_block_cache);
-extern void rocksdb_block_based_options_set_block_cache(
-    rocksdb_block_based_table_options_t* options, rocksdb_cache_t* block_cache);
-extern void rocksdb_block_based_options_set_block_cache_compressed(
-    rocksdb_block_based_table_options_t* options,
-    rocksdb_cache_t* block_cache_compressed);
-extern void rocksdb_block_based_options_set_whole_key_filtering(
-    rocksdb_block_based_table_options_t*, unsigned char);
-extern void rocksdb_options_set_block_based_table_factory(
-    rocksdb_options_t *opt, rocksdb_block_based_table_options_t* table_options);
-
 /* Options */

 extern rocksdb_options_t* rocksdb_options_create();
@@ -383,7 +349,7 @@ extern void rocksdb_options_destroy(rocksdb_options_t*);
 extern void rocksdb_options_increase_parallelism(
    rocksdb_options_t* opt, int total_threads);
 extern void rocksdb_options_optimize_for_point_lookup(
-    rocksdb_options_t* opt, uint64_t block_cache_size_mb);
+    rocksdb_options_t* opt);
 extern void rocksdb_options_optimize_level_style_compaction(
    rocksdb_options_t* opt, uint64_t memtable_memory_budget);
 extern void rocksdb_options_optimize_universal_style_compaction(
@@ -393,19 +359,18 @@ extern void rocksdb_options_set_compaction_filter(
    rocksdb_compactionfilter_t*);
 extern void rocksdb_options_set_compaction_filter_factory(
    rocksdb_options_t*, rocksdb_compactionfilterfactory_t*);
-extern void rocksdb_options_set_compaction_filter_factory_v2(
-    rocksdb_options_t*,
-    rocksdb_compactionfilterfactoryv2_t*);
 extern void rocksdb_options_set_comparator(
    rocksdb_options_t*,
    rocksdb_comparator_t*);
-extern void rocksdb_options_set_merge_operator(
-    rocksdb_options_t*,
-    rocksdb_mergeoperator_t*);
+extern void rocksdb_options_set_merge_operator(rocksdb_options_t*,
+                                               rocksdb_mergeoperator_t*);
 extern void rocksdb_options_set_compression_per_level(
  rocksdb_options_t* opt,
  int* level_values,
  size_t num_levels);
+extern void rocksdb_options_set_filter_policy(
+    rocksdb_options_t*,
+    rocksdb_filterpolicy_t*);
 extern void rocksdb_options_set_create_if_missing(
    rocksdb_options_t*, unsigned char);
 extern void rocksdb_options_set_create_missing_column_families(
@@ -419,8 +384,13 @@ extern void rocksdb_options_set_info_log(rocksdb_options_t*, rocksdb_logger_t*);
 extern void rocksdb_options_set_info_log_level(rocksdb_options_t*, int);
 extern void rocksdb_options_set_write_buffer_size(rocksdb_options_t*, size_t);
 extern void rocksdb_options_set_max_open_files(rocksdb_options_t*, int);
+extern void rocksdb_options_set_cache(rocksdb_options_t*, rocksdb_cache_t*);
+extern void rocksdb_options_set_cache_compressed(rocksdb_options_t*, rocksdb_cache_t*);
+extern void rocksdb_options_set_block_size(rocksdb_options_t*, size_t);
+extern void rocksdb_options_set_block_restart_interval(rocksdb_options_t*, int);
 extern void rocksdb_options_set_compression_options(
    rocksdb_options_t*, int, int, int);
+extern void rocksdb_options_set_whole_key_filtering(rocksdb_options_t*, unsigned char);
 extern void rocksdb_options_set_prefix_extractor(
    rocksdb_options_t*, rocksdb_slicetransform_t*);
 extern void rocksdb_options_set_num_levels(rocksdb_options_t*, int);
@@ -471,6 +441,8 @@ extern void rocksdb_options_set_arena_block_size(
    rocksdb_options_t*, size_t);
 extern void rocksdb_options_set_use_fsync(
    rocksdb_options_t*, int);
+extern void rocksdb_options_set_db_stats_log_interval(
+    rocksdb_options_t*, int);
 extern void rocksdb_options_set_db_log_dir(
    rocksdb_options_t*, const char*);
 extern void rocksdb_options_set_wal_dir(
@@ -513,6 +485,7 @@ extern void rocksdb_options_set_max_sequential_skip_in_iterations(
    rocksdb_options_t*, uint64_t);
 extern void rocksdb_options_set_disable_data_sync(rocksdb_options_t*, int);
 extern void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t*, int);
+extern void rocksdb_options_set_disable_seek_compaction(rocksdb_options_t*, int);
 extern void rocksdb_options_set_delete_obsolete_files_period_micros(
    rocksdb_options_t*, uint64_t);
 extern void rocksdb_options_set_source_compaction_factor(rocksdb_options_t*, int);
@@ -598,35 +571,6 @@ extern rocksdb_compactionfilterfactory_t*
 extern void rocksdb_compactionfilterfactory_destroy(
    rocksdb_compactionfilterfactory_t*);

-/* Compaction Filter V2 */
-
-extern rocksdb_compactionfilterv2_t* rocksdb_compactionfilterv2_create(
-    void* state,
-    void (*destructor)(void*),
-    // num_keys specifies the number of array entries in every *list parameter.
-    // New values added to the new_values_list should be malloc'd and will be
-    // freed by the caller. Specify true in the to_delete_list to remove an
-    // entry during compaction; false to keep it.
-    void (*filter)(
-        void*, int level, size_t num_keys,
-        const char* const* keys_list, const size_t* keys_list_sizes,
-        const char* const* existing_values_list, const size_t* existing_values_list_sizes,
-        char** new_values_list, size_t* new_values_list_sizes,
-        unsigned char* to_delete_list),
-    const char* (*name)(void*));
-extern void rocksdb_compactionfilterv2_destroy(rocksdb_compactionfilterv2_t*);
-
-/* Compaction Filter Factory V2 */
-
-extern rocksdb_compactionfilterfactoryv2_t* rocksdb_compactionfilterfactoryv2_create(
-    void* state,
-    rocksdb_slicetransform_t* prefix_extractor,
-    void (*destructor)(void*),
-    rocksdb_compactionfilterv2_t* (*create_compaction_filter_v2)(
-        void*, const rocksdb_compactionfiltercontext_t* context),
-    const char* (*name)(void*));
-extern void rocksdb_compactionfilterfactoryv2_destroy(rocksdb_compactionfilterfactoryv2_t*);
-
 /* Comparator */

 extern rocksdb_comparator_t* rocksdb_comparator_create(
@@ -9,7 +9,6 @@
 #ifndef STORAGE_ROCKSDB_INCLUDE_COMPACTION_FILTER_H_
 #define STORAGE_ROCKSDB_INCLUDE_COMPACTION_FILTER_H_

-#include <memory>
 #include <string>
 #include <vector>

@@ -160,7 +160,6 @@ class DB {
  virtual Status DropColumnFamily(ColumnFamilyHandle* column_family);

  // Set the database entry for "key" to "value".
-  // If "key" already exists, it will be overwritten.
  // Returns OK on success, and a non-OK status on error.
  // Note: consider setting options.sync = true.
  virtual Status Put(const WriteOptions& options,
@@ -307,14 +306,6 @@ class DB {
    return GetProperty(DefaultColumnFamily(), property, value);
  }

-  // Similar to GetProperty(), but only works for a subset of properties whose
-  // return value is an integer. Return the value by integer.
-  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
-                              const Slice& property, uint64_t* value) = 0;
-  virtual bool GetIntProperty(const Slice& property, uint64_t* value) {
-    return GetIntProperty(DefaultColumnFamily(), property, value);
-  }
-
  // For each i in [0,n-1], store in "sizes[i]", the approximate
  // file system space used by keys in "[range[i].start .. range[i].limit)".
  //
@@ -347,17 +338,15 @@ class DB {
  // hosting all the files. In this case, client could set reduce_level
  // to true, to move the files back to the minimum level capable of holding
  // the data set or a given level (specified by non-negative target_level).
-  // Compaction outputs should be placed in options.db_paths[target_path_id].
-  // Behavior is undefined if target_path_id is out of range.
  virtual Status CompactRange(ColumnFamilyHandle* column_family,
                              const Slice* begin, const Slice* end,
-                              bool reduce_level = false, int target_level = -1,
-                              uint32_t target_path_id = 0) = 0;
+                              bool reduce_level = false,
+                              int target_level = -1) = 0;
  virtual Status CompactRange(const Slice* begin, const Slice* end,
-                              bool reduce_level = false, int target_level = -1,
-                              uint32_t target_path_id = 0) {
+                              bool reduce_level = false,
+                              int target_level = -1) {
    return CompactRange(DefaultColumnFamily(), begin, end, reduce_level,
-                        target_level, target_path_id);
+                        target_level);
  }

  // Number of levels used for this DB.
@@ -201,7 +201,7 @@ class Env {
  // Priority for scheduling job in thread pool
  enum Priority { LOW, HIGH, TOTAL };

-  // Priority for requesting bytes in rate limiter scheduler
+  // Priority for scheduling job in thread pool
  enum IOPriority {
    IO_LOW = 0,
    IO_HIGH = 1,
@@ -272,9 +272,6 @@ class Env {
  // default number: 1
  virtual void SetBackgroundThreads(int number, Priority pri = LOW) = 0;

-  // Lower IO priority for threads from the specified pool.
-  virtual void LowerThreadPoolIOPriority(Priority pool = LOW) {}
-
  // Converts seconds-since-Jan-01-1970 to a printable string
  virtual std::string TimeToString(uint64_t time) = 0;

@@ -782,9 +779,6 @@ class EnvWrapper : public Env {
  void SetBackgroundThreads(int num, Priority pri) {
    return target_->SetBackgroundThreads(num, pri);
  }
-  void LowerThreadPoolIOPriority(Priority pool = LOW) override {
-    target_->LowerThreadPoolIOPriority(pool);
-  }
  std::string TimeToString(uint64_t time) {
    return target_->TimeToString(time);
  }
@@ -6,7 +6,6 @@
 #pragma once

 #include <string>
-#include "rocksdb/table.h"

 namespace rocksdb {

@@ -38,8 +37,7 @@ class FlushBlockPolicyFactory {
  // Callers must delete the result after any database that is using the
  // result has been closed.
  virtual FlushBlockPolicy* NewFlushBlockPolicy(
-      const BlockBasedTableOptions& table_options,
-      const BlockBuilder& data_block_builder) const = 0;
+      const Options& options, const BlockBuilder& data_block_builder) const = 0;

  virtual ~FlushBlockPolicyFactory() { }
 };
@@ -53,7 +51,7 @@ class FlushBlockBySizePolicyFactory : public FlushBlockPolicyFactory {
  }

  virtual FlushBlockPolicy* NewFlushBlockPolicy(
-      const BlockBasedTableOptions& table_options,
+      const Options& options,
      const BlockBuilder& data_block_builder) const override;
 };

@@ -27,9 +27,7 @@ struct IOStatsContext {
  uint64_t bytes_read;
 };

-#ifndef IOS_CROSS_COMPILE
 extern __thread IOStatsContext iostats_context;
-#endif  // IOS_CROSS_COMPILE

 }  // namespace rocksdb

@@ -39,6 +39,7 @@ class Slice;
 class SliceTransform;
 class Statistics;
 class InternalKeyComparator;
+class RateLimiter;

 // DB contents are stored in a set of blocks, each of which holds a
 // sequence of key,value pairs.  Each block may be compressed before
@@ -82,14 +83,6 @@ enum UpdateStatus {    // Return status For inplace update callback
  UPDATED         = 2, // No inplace update. Merged value set
 };

-struct DbPath {
-  std::string path;
-  uint64_t target_size;  // Target size of total files under the path, in byte.
-
-  DbPath() : target_size(0) {}
-  DbPath(const std::string& p, uint64_t t) : path(p), target_size(t) {}
-};
-
 struct Options;

 struct ColumnFamilyOptions {
@@ -97,8 +90,7 @@ struct ColumnFamilyOptions {

  // Use this if you don't need to keep the data sorted, i.e. you'll never use
  // an iterator, only Put() and Get() API calls
-  ColumnFamilyOptions* OptimizeForPointLookup(
-      uint64_t block_cache_size_mb);
+  ColumnFamilyOptions* OptimizeForPointLookup();

  // Default values for some parameters in ColumnFamilyOptions are not
  // optimized for heavy workloads and big datasets, which means you might
@@ -207,6 +199,34 @@ struct ColumnFamilyOptions {
  // individual write buffers.  Default: 1
  int min_write_buffer_number_to_merge;

+  // Control over blocks (user data is stored in a set of blocks, and
+  // a block is the unit of reading from disk).
+
+  // If non-NULL use the specified cache for blocks.
+  // If NULL, rocksdb will automatically create and use an 8MB internal cache.
+  // Default: nullptr
+  std::shared_ptr<Cache> block_cache;
+
+  // If non-NULL use the specified cache for compressed blocks.
+  // If NULL, rocksdb will not use a compressed block cache.
+  // Default: nullptr
+  std::shared_ptr<Cache> block_cache_compressed;
+
+  // 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
+  size_t block_size;
+
+  // 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
+  int block_restart_interval;
+
  // Compress blocks using the specified compression algorithm.  This
  // parameter can be changed dynamically.
  //
@@ -240,6 +260,13 @@ struct ColumnFamilyOptions {
  // different options for compression algorithms
  CompressionOptions compression_opts;

+  // If non-nullptr, use the specified filter policy to reduce disk reads.
+  // Many applications will benefit from passing the result of
+  // NewBloomFilterPolicy() here.
+  //
+  // Default: nullptr
+  const FilterPolicy* filter_policy;
+
  // If non-nullptr, use the specified function to determine the
  // prefixes for keys.  These prefixes will be placed in the filter.
  // Depending on the workload, this can reduce the number of read-IOP
@@ -256,6 +283,12 @@ struct ColumnFamilyOptions {
  // Default: nullptr
  std::shared_ptr<const SliceTransform> prefix_extractor;

+  // If true, place whole keys in the filter (not just prefixes).
+  // This must generally be true for gets to be efficient.
+  //
+  // Default: true
+  bool whole_key_filtering;
+
  // Number of levels for this database
  int num_levels;

@@ -335,6 +368,18 @@ struct ColumnFamilyOptions {
  // stop building a single file in a level->level+1 compaction.
  int max_grandparent_overlap_factor;

+  // We decided to remove seek compaction from RocksDB because:
+  // 1) It makes more sense for spinning disk workloads, while RocksDB is
+  // primarily designed for flash and memory,
+  // 2) It added some complexity to the important code-paths,
+  // 3) None of our internal customers were really using it.
+  //
+  // Since we removed seek compaction, this option is now obsolete.
+  // We left it here for backwards compatiblity (otherwise it would break the
+  // build), but we'll remove it at some point.
+  // Default: true
+  bool disable_seek_compaction;
+
  // Puts are delayed 0-1 ms when any level has a compaction score that exceeds
  // soft_rate_limit. This is ignored when == 0.0.
  // CONSTRAINT: soft_rate_limit <= hard_rate_limit. If this constraint does not
@@ -352,6 +397,12 @@ struct ColumnFamilyOptions {
  // Default: 1000
  unsigned int rate_limit_delay_max_milliseconds;

+  // Disable block cache. If this is set to true,
+  // then no block cache should be used, and the block_cache should
+  // point to a nullptr object.
+  // Default: false
+  bool no_block_cache;
+
  // size of one block in arena memory allocation.
  // If <= 0, a proper value is automatically calculated (usually 1/10 of
  // writer_buffer_size).
@@ -375,6 +426,14 @@ struct ColumnFamilyOptions {
  // Default: true
  bool purge_redundant_kvs_while_flush;

+  // This is used to close a block before it reaches the configured
+  // 'block_size'. If the percentage of free space in the current block is less
+  // than this specified number and adding a new record to the block will
+  // exceed the configured block size, then this block will be closed and the
+  // new record will be written to the next block.
+  // Default is 10.
+  int block_size_deviation;
+
  // The compaction style. Default: kCompactionStyleLevel
  CompactionStyle compaction_style;

@@ -421,9 +480,7 @@ struct ColumnFamilyOptions {
      TablePropertiesCollectorFactories;
  TablePropertiesCollectorFactories table_properties_collector_factories;

-  // Allows thread-safe inplace updates. If this is true, there is no way to
-  // achieve point-in-time consistency using snapshot or iterator (assuming
-  // concurrent updates).
+  // Allows thread-safe inplace updates.
  // If inplace_callback function is not set,
  //   Put(key, new_value) will update inplace the existing_value iff
  //   * key exists in current memtable
@@ -570,7 +627,6 @@ struct DBOptions {

  // Use to control write rate of flush and compaction. Flush has higher
  // priority than compaction. Rate limiting is disabled if nullptr.
-  // If rate limiter is enabled, bytes_per_sync is set to 1MB by default.
  // Default: nullptr
  std::shared_ptr<RateLimiter> rate_limiter;

@@ -618,31 +674,18 @@ struct DBOptions {
  // Default: false
  bool use_fsync;

-  // A list of paths where SST files can be put into, with its target size.
-  // Newer data is placed into paths specified earlier in the vector while
-  // older data gradually moves to paths specified later in the vector.
-  //
-  // For example, you have a flash device with 10GB allocated for the DB,
-  // as well as a hard drive of 2TB, you should config it to be:
-  //   [{"/flash_path", 10GB}, {"/hard_drive", 2TB}]
-  //
-  // The system will try to guarantee data under each path is close to but
-  // not larger than the target size. But current and future file sizes used
-  // by determining where to place a file are based on best-effort estimation,
-  // which means there is a chance that the actual size under the directory
-  // is slightly more than target size under some workloads. User should give
-  // some buffer room for those cases.
-  //
-  // If none of the paths has sufficient room to place a file, the file will
-  // be placed to the last path anyway, despite to the target size.
-  //
-  // Placing newer data to ealier paths is also best-efforts. User should
-  // expect user files to be placed in higher levels in some extreme cases.
-  //
+  // This number controls how often a new scribe log about
+  // db deploy stats is written out.
+  // -1 indicates no logging at all.
+  // Default value is 1800 (half an hour).
+  int db_stats_log_interval;
+
+  // A list paths where SST files can be put into. A compaction style can
+  // determine which of those paths it will put the file to.
  // If left empty, only one path will be used, which is db_name passed when
  // opening the DB.
  // Default: empty
-  std::vector<DbPath> db_paths;
+  std::vector<std::string> db_paths;

  // This specifies the info LOG dir.
  // If it is empty, the log files will be in the same dir as data.
@@ -789,6 +832,12 @@ struct DBOptions {
  // Default: false
  bool use_adaptive_mutex;

+  // Allows OS to incrementally sync files to disk while they are being
+  // written, asynchronously, in the background.
+  // Issue one request for every bytes_per_sync written. 0 turns it off.
+  // Default: 0
+  uint64_t bytes_per_sync;
+
  // Allow RocksDB to use thread local storage to optimize performance.
  // Default: true
  bool allow_thread_local;
@@ -799,16 +848,6 @@ struct DBOptions {
  explicit DBOptions(const Options& options);

  void Dump(Logger* log) const;
-
-  // Allows OS to incrementally sync files to disk while they are being
-  // written, asynchronously, in the background.
-  // Issue one request for every bytes_per_sync written. 0 turns it off.
-  // Default: 0
-  //
-  // You may consider using rate_limiter to regulate write rate to device.
-  // When rate limiter is enabled, it automatically enables bytes_per_sync
-  // to 1MB.
-  uint64_t bytes_per_sync;
 };

 // Options to control the behavior of a database (passed to DB::Open)
@@ -903,25 +942,18 @@ struct ReadOptions {
  // Not supported in ROCKSDB_LITE mode!
  bool tailing;

-  // Enable a total order seek regardless of index format (e.g. hash index)
-  // used in the table. Some table format (e.g. plain table) may not support
-  // this option.
-  bool total_order_seek;
-
  ReadOptions()
      : verify_checksums(true),
        fill_cache(true),
        snapshot(nullptr),
        read_tier(kReadAllTier),
-        tailing(false),
-        total_order_seek(false) {}
+        tailing(false) {}
  ReadOptions(bool cksum, bool cache)
      : verify_checksums(cksum),
        fill_cache(cache),
        snapshot(nullptr),
        read_tier(kReadAllTier),
-        tailing(false),
-        total_order_seek(false) {}
+        tailing(false) {}
 };

 // Options that control write operations
@@ -959,17 +991,7 @@ struct WriteOptions {
  // Default: 0
  uint64_t timeout_hint_us;

-  // If true and if user is trying to write to column families that don't exist
-  // (they were dropped),  ignore the write (don't return an error). If there
-  // are multiple writes in a WriteBatch, other writes will succeed.
-  // Default: false
-  bool ignore_missing_column_families;
-
-  WriteOptions()
-      : sync(false),
-        disableWAL(false),
-        timeout_hint_us(0),
-        ignore_missing_column_families(false) {}
+  WriteOptions() : sync(false), disableWAL(false), timeout_hint_us(0) {}
 };

 // Options that control flush operations
@@ -981,16 +1003,21 @@ struct FlushOptions {
  FlushOptions() : wait(true) {}
 };

-// Get options based on some guidelines. Now only tune parameter based on
-// flush/compaction and fill default parameters for other parameters.
-// total_write_buffer_limit: budget for memory spent for mem tables
-// read_amplification_threshold: comfortable value of read amplification
-// write_amplification_threshold: comfortable value of write amplification.
-// target_db_size: estimated total DB size.
-extern Options GetOptions(size_t total_write_buffer_limit,
-                          int read_amplification_threshold = 8,
-                          int write_amplification_threshold = 32,
-                          uint64_t target_db_size = 68719476736 /* 64GB */);
+
+// Create a RateLimiter object, which can be shared among RocksDB instances to
+// control write rate of flush and compaction.
+// @rate_bytes_per_sec: desired total write rate in bytes per second.
+// @refill_period_us: token refill interval in micro-second.
+// @fairness: RateLimiter accepts high-pri requests and low-pri requests.
+// low-pri request is usually blocked in favor of hi-pri request. To prevent
+// low-pri request from being blocked for too long, it can get processed first
+// by 1/fairness chance.
+extern RateLimiter* NewRateLimiter(
+    int64_t rate_bytes_per_sec,
+    int64_t refill_period_us = 100 * 1000,
+    int32_t fairness = 10);
+
+
 }  // namespace rocksdb

 #endif  // STORAGE_ROCKSDB_INCLUDE_OPTIONS_H_
@@ -1,60 +0,0 @@
-//  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.
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// 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.
-
-#pragma once
-
-#include "rocksdb/env.h"
-
-namespace rocksdb {
-
-class RateLimiter {
- public:
-  virtual ~RateLimiter() {}
-
-  // Request for token to write bytes. If this request can not be satisfied,
-  // the call is blocked. Caller is responsible to make sure
-  // bytes < GetSingleBurstBytes()
-  virtual void Request(const int64_t bytes, const Env::IOPriority pri) = 0;
-
-  // Max bytes can be granted in a single burst
-  virtual int64_t GetSingleBurstBytes() const = 0;
-
-  // Total bytes that go though rate limiter
-  virtual int64_t GetTotalBytesThrough(
-      const Env::IOPriority pri = Env::IO_TOTAL) const = 0;
-
-  // Total # of requests that go though rate limiter
-  virtual int64_t GetTotalRequests(
-      const Env::IOPriority pri = Env::IO_TOTAL) const = 0;
-};
-
-// Create a RateLimiter object, which can be shared among RocksDB instances to
-// control write rate of flush and compaction.
-// @rate_bytes_per_sec: this is the only parameter you want to set most of the
-// time. It controls the total write rate of compaction and flush in bytes per
-// second. Currently, RocksDB does not enforce rate limit for anything other
-// than flush and compaction, e.g. write to WAL.
-// @refill_period_us: this controls how often tokens are refilled. For example,
-// when rate_bytes_per_sec is set to 10MB/s and refill_period_us is set to
-// 100ms, then 1MB is refilled every 100ms internally. Larger value can lead to
-// burstier writes while smaller value introduces more CPU overhead.
-// The default should work for most cases.
-// @fairness: RateLimiter accepts high-pri requests and low-pri requests.
-// A low-pri request is usually blocked in favor of hi-pri request. Currently,
-// RocksDB assigns low-pri to request from compaciton and high-pri to request
-// from flush. Low-pri requests can get blocked if flush requests come in
-// continuouly. This fairness parameter grants low-pri requests permission by
-// 1/fairness chance even though high-pri requests exist to avoid starvation.
-// You should be good by leaving it at default 10.
-extern RateLimiter* NewGenericRateLimiter(
-    int64_t rate_bytes_per_sec,
-    int64_t refill_period_us = 100 * 1000,
-    int32_t fairness = 10);
-
-}  // namespace rocksdb
@@ -20,12 +20,12 @@ namespace rocksdb {
 *  1. Any ticker should be added before TICKER_ENUM_MAX.
 *  2. Add a readable string in TickersNameMap below for the newly added ticker.
 */
-enum Tickers : uint32_t {
+enum Tickers {
  // total block cache misses
  // REQUIRES: BLOCK_CACHE_MISS == BLOCK_CACHE_INDEX_MISS +
  //                               BLOCK_CACHE_FILTER_MISS +
  //                               BLOCK_CACHE_DATA_MISS;
-  BLOCK_CACHE_MISS = 0,
+  BLOCK_CACHE_MISS,
  // total block cache hit
  // REQUIRES: BLOCK_CACHE_HIT == BLOCK_CACHE_INDEX_HIT +
  //                              BLOCK_CACHE_FILTER_HIT +
@@ -198,8 +198,8 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
 * Add a string representation in HistogramsNameMap below
 * And increment HISTOGRAM_ENUM_MAX
 */
-enum Histograms : uint32_t {
-  DB_GET = 0,
+enum Histograms {
+  DB_GET,
  DB_WRITE,
  COMPACTION_TIME,
  TABLE_SYNC_MICROS,
@@ -219,7 +219,6 @@ enum Histograms : uint32_t {
  HARD_RATE_LIMIT_DELAY_COUNT,
  SOFT_RATE_LIMIT_DELAY_COUNT,
  NUM_FILES_IN_SINGLE_COMPACTION,
-  DB_SEEK,
  HISTOGRAM_ENUM_MAX,
 };

@@ -242,7 +241,6 @@ const std::vector<std::pair<Histograms, std::string>> HistogramsNameMap = {
  { HARD_RATE_LIMIT_DELAY_COUNT, "rocksdb.hard.rate.limit.delay.count"},
  { SOFT_RATE_LIMIT_DELAY_COUNT, "rocksdb.soft.rate.limit.delay.count"},
  { NUM_FILES_IN_SINGLE_COMPACTION, "rocksdb.numfiles.in.singlecompaction" },
-  { DB_SEEK, "rocksdb.db.seek.micros" },
 };

 struct HistogramData {
@@ -258,24 +256,14 @@ class Statistics {
 public:
  virtual ~Statistics() {}

-  virtual uint64_t getTickerCount(uint32_t tickerType) const = 0;
-  virtual void histogramData(uint32_t type,
-                             HistogramData* const data) const = 0;
-
-  virtual void recordTick(uint32_t tickerType, uint64_t count = 0) = 0;
-  virtual void setTickerCount(uint32_t tickerType, uint64_t count) = 0;
-  virtual void measureTime(uint32_t histogramType, uint64_t time) = 0;
+  virtual long getTickerCount(Tickers tickerType) = 0;
+  virtual void recordTick(Tickers tickerType, uint64_t count = 0) = 0;
+  virtual void setTickerCount(Tickers tickerType, uint64_t count) = 0;
+  virtual void measureTime(Histograms histogramType, uint64_t time) = 0;

+  virtual void histogramData(Histograms type, HistogramData* const data) = 0;
  // String representation of the statistic object.
-  virtual std::string ToString() const {
-    // Do nothing by default
-    return std::string("ToString(): not implemented");
-  }
-
-  // Override this function to disable particular histogram collection
-  virtual bool HistEnabledForType(uint32_t type) const {
-    return type < HISTOGRAM_ENUM_MAX;
-  }
+  std::string ToString();
 };

 // Create a concrete DBStatistics object
@@ -96,7 +96,7 @@ class Status {
  // Returns true iff the status indicates Incomplete
  bool IsIncomplete() const { return code() == kIncomplete; }

-  // Returns true iff the status indicates Shutdown In progress
+  // Returns true iff the status indicates Incomplete
  bool IsShutdownInProgress() const { return code() == kShutdownInProgress; }

  bool IsTimedOut() const { return code() == kTimedOut; }
@@ -84,46 +84,6 @@ struct BlockBasedTableOptions {
  // protected with this checksum type. Old table files will still be readable,
  // even though they have different checksum type.
  ChecksumType checksum = kCRC32c;
-
-  // Disable block cache. If this is set to true,
-  // then no block cache should be used, and the block_cache should
-  // point to a nullptr object.
-  bool no_block_cache = false;
-
-  // If non-NULL use the specified cache for blocks.
-  // If NULL, rocksdb will automatically create and use an 8MB internal cache.
-  std::shared_ptr<Cache> block_cache = nullptr;
-
-  // If non-NULL use the specified cache for compressed blocks.
-  // If NULL, rocksdb will not use a compressed block cache.
-  std::shared_ptr<Cache> block_cache_compressed = nullptr;
-
-  // 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.
-  size_t block_size = 4 * 1024;
-
-  // This is used to close a block before it reaches the configured
-  // 'block_size'. If the percentage of free space in the current block is less
-  // than this specified number and adding a new record to the block will
-  // exceed the configured block size, then this block will be closed and the
-  // new record will be written to the next block.
-  int block_size_deviation = 10;
-
-  // Number of keys between restart points for delta encoding of keys.
-  // This parameter can be changed dynamically.  Most clients should
-  // leave this parameter alone.
-  int block_restart_interval = 16;
-
-  // If non-nullptr, use the specified filter policy to reduce disk reads.
-  // Many applications will benefit from passing the result of
-  // NewBloomFilterPolicy() here.
-  std::shared_ptr<const FilterPolicy> filter_policy = nullptr;
-
-  // If true, place whole keys in the filter (not just prefixes).
-  // This must generally be true for gets to be efficient.
-  bool whole_key_filtering = true;
 };

 // Table Properties that are specific to block-based table properties.
@@ -159,62 +119,6 @@ enum EncodingType : char {
 struct PlainTablePropertyNames {
  static const std::string kPrefixExtractorName;
  static const std::string kEncodingType;
-  static const std::string kBloomVersion;
-  static const std::string kNumBloomBlocks;
-};
-
-const uint32_t kPlainTableVariableLength = 0;
-
-struct PlainTableOptions {
-  // @user_key_len: plain table has optimization for fix-sized keys, which can
-  //                be specified via user_key_len.  Alternatively, you can pass
-  //                `kPlainTableVariableLength` if your keys have variable
-  //                lengths.
-  uint32_t user_key_len = kPlainTableVariableLength;
-
-  // @bloom_bits_per_key: the number of bits used for bloom filer per prefix.
-  //                      You may disable it by passing a zero.
-  int bloom_bits_per_key = 10;
-
-  // @hash_table_ratio: the desired utilization of the hash table used for
-  //                    prefix hashing.
-  //                    hash_table_ratio = number of prefixes / #buckets in the
-  //                    hash table
-  double hash_table_ratio = 0.75;
-
-  // @index_sparseness: inside each prefix, need to build one index record for
-  //                    how many keys for binary search inside each hash bucket.
-  //                    For encoding type kPrefix, the value will be used when
-  //                    writing to determine an interval to rewrite the full
-  //                    key. It will also be used as a suggestion and satisfied
-  //                    when possible.
-  size_t index_sparseness = 16;
-
-  // @huge_page_tlb_size: if <=0, allocate hash indexes and blooms from malloc.
-  //                      Otherwise from huge page TLB. The user needs to
-  //                      reserve huge pages for it to be allocated, like:
-  //                          sysctl -w vm.nr_hugepages=20
-  //                      See linux doc Documentation/vm/hugetlbpage.txt
-  size_t huge_page_tlb_size = 0;
-
-  // @encoding_type: how to encode the keys. See enum EncodingType above for
-  //                 the choices. The value will determine how to encode keys
-  //                 when writing to a new SST file. This value will be stored
-  //                 inside the SST file which will be used when reading from
-  //                 the file, which makes it possible for users to choose
-  //                 different encoding type when reopening a DB. Files with
-  //                 different encoding types can co-exist in the same DB and
-  //                 can be read.
-  EncodingType encoding_type = kPlain;
-
-  // @full_scan_mode: mode for reading the whole file one record by one without
-  //                  using the index.
-  bool full_scan_mode = false;
-
-  // @store_index_in_file: compute plain table index and bloom filter during
-  //                       file building and store it in file. When reading
-  //                       file, index will be mmaped instead of recomputation.
-  bool store_index_in_file = false;
 };

 // -- Plain Table with prefix-only seek
@@ -222,51 +126,40 @@ struct PlainTableOptions {
 // work. Look-up will starts with prefix hash lookup for key prefix. Inside the
 // hash bucket found, a binary search is executed for hash conflicts. Finally,
 // a linear search is used.
+// @user_key_len: plain table has optimization for fix-sized keys, which can be
+//                specified via user_key_len.  Alternatively, you can pass
+//                `kPlainTableVariableLength` if your keys have variable
+//                lengths.
+// @bloom_bits_per_key: the number of bits used for bloom filer per prefix. You
+//                      may disable it by passing a zero.
+// @hash_table_ratio: the desired utilization of the hash table used for prefix
+//                    hashing. hash_table_ratio = number of prefixes / #buckets
+//                    in the hash table
+// @index_sparseness: inside each prefix, need to build one index record for how
+//                    many keys for binary search inside each hash bucket.
+//                    For encoding type kPrefix, the value will be used when
+//                    writing to determine an interval to rewrite the full key.
+//                    It will also be used as a suggestion and satisfied when
+//                    possible.
+// @huge_page_tlb_size: if <=0, allocate hash indexes and blooms from malloc.
+//                      Otherwise from huge page TLB. The user needs to reserve
+//                      huge pages for it to be allocated, like:
+//                          sysctl -w vm.nr_hugepages=20
+//                      See linux doc Documentation/vm/hugetlbpage.txt
+// @encoding_type: how to encode the keys. See enum EncodingType above for
+//                 the choices. The value will determine how to encode keys
+//                 when writing to a new SST file. This value will be stored
+//                 inside the SST file which will be used when reading from the
+//                 file, which makes it possible for users to choose different
+//                 encoding type when reopening a DB. Files with different
+//                 encoding types can co-exist in the same DB and can be read.

-extern TableFactory* NewPlainTableFactory(const PlainTableOptions& options =
-                                              PlainTableOptions());
-
-struct CuckooTablePropertyNames {
-  // The key that is used to fill empty buckets.
-  static const std::string kEmptyKey;
-  // Fixed length of value.
-  static const std::string kValueLength;
-  // Number of hash functions used in Cuckoo Hash.
-  static const std::string kNumHashFunc;
-  // It denotes the number of buckets in a Cuckoo Block. Given a key and a
-  // particular hash function, a Cuckoo Block is a set of consecutive buckets,
-  // where starting bucket id is given by the hash function on the key. In case
-  // of a collision during inserting the key, the builder tries to insert the
-  // key in other locations of the cuckoo block before using the next hash
-  // function. This reduces cache miss during read operation in case of
-  // collision.
-  static const std::string kCuckooBlockSize;
-  // Size of the hash table. Use this number to compute the modulo of hash
-  // function. The actual number of buckets will be kMaxHashTableSize +
-  // kCuckooBlockSize - 1. The last kCuckooBlockSize-1 buckets are used to
-  // accommodate the Cuckoo Block from end of hash table, due to cache friendly
-  // implementation.
-  static const std::string kHashTableSize;
-  // Denotes if the key sorted in the file is Internal Key (if false)
-  // or User Key only (if true).
-  static const std::string kIsLastLevel;
-};
-
-// Cuckoo Table Factory for SST table format using Cache Friendly Cuckoo Hashing
-// @hash_table_ratio: Determines the utilization of hash tables. Smaller values
-//                    result in larger hash tables with fewer collisions.
-// @max_search_depth: A property used by builder to determine the depth to go to
-//                    to search for a path to displace elements in case of
-//                    collision. See Builder.MakeSpaceForKey method.  Higher
-//                    values result in more efficient hash tables with fewer
-//                    lookups but take more time to build.
-// @cuckoo_block_size: In case of collision while inserting, the builder
-//                     attempts to insert in the next cuckoo_block_size
-//                     locations before skipping over to the next Cuckoo hash
-//                     function. This makes lookups more cache friendly in case
-//                     of collisions.
-extern TableFactory* NewCuckooTableFactory(double hash_table_ratio = 0.9,
-    uint32_t max_search_depth = 100, uint32_t cuckoo_block_size = 5);
+const uint32_t kPlainTableVariableLength = 0;
+extern TableFactory* NewPlainTableFactory(
+    uint32_t user_key_len = kPlainTableVariableLength,
+    int bloom_bits_per_prefix = 10, double hash_table_ratio = 0.75,
+    size_t index_sparseness = 16, size_t huge_page_tlb_size = 0,
+    EncodingType encoding_type = kPlain, bool full_scan_mode = false);

 #endif  // ROCKSDB_LITE

@@ -326,16 +219,6 @@ class TableFactory {
  virtual TableBuilder* NewTableBuilder(
      const Options& options, const InternalKeyComparator& internal_comparator,
      WritableFile* file, CompressionType compression_type) const = 0;
-
-  // Sanitizes the specified DB Options.
-  //
-  // If the function cannot find a way to sanitize the input DB Options,
-  // a non-ok Status will be returned.
-  virtual Status SanitizeDBOptions(const DBOptions* db_opts) const = 0;
-
-  // Return a string that contains printable format of table configurations.
-  // RocksDB prints configurations at DB Open().
-  virtual std::string GetPrintableTableOptions() const = 0;
 };

 #ifndef ROCKSDB_LITE
@@ -349,8 +232,7 @@ class TableFactory {
 extern TableFactory* NewAdaptiveTableFactory(
    std::shared_ptr<TableFactory> table_factory_to_write = nullptr,
    std::shared_ptr<TableFactory> block_based_table_factory = nullptr,
-    std::shared_ptr<TableFactory> plain_table_factory = nullptr,
-    std::shared_ptr<TableFactory> cuckoo_table_factory = nullptr);
+    std::shared_ptr<TableFactory> plain_table_factory = nullptr);

 #endif  // ROCKSDB_LITE

@@ -1,252 +0,0 @@
-//  Copyright (c) 2013, 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.
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// 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.
-
-#pragma once
-#ifndef ROCKSDB_LITE
-
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-#include <string>
-#include <map>
-#include <vector>
-
-#include "rocksdb/utilities/stackable_db.h"
-
-#include "rocksdb/env.h"
-#include "rocksdb/status.h"
-
-namespace rocksdb {
-
-struct BackupableDBOptions {
-  // Where to keep the backup files. Has to be different than dbname_
-  // Best to set this to dbname_ + "/backups"
-  // Required
-  std::string backup_dir;
-
-  // Backup Env object. It will be used for backup file I/O. If it's
-  // nullptr, backups will be written out using DBs Env. If it's
-  // non-nullptr, backup's I/O will be performed using this object.
-  // If you want to have backups on HDFS, use HDFS Env here!
-  // Default: nullptr
-  Env* backup_env;
-
-  // If share_table_files == true, backup will assume that table files with
-  // same name have the same contents. This enables incremental backups and
-  // avoids unnecessary data copies.
-  // If share_table_files == false, each backup will be on its own and will
-  // not share any data with other backups.
-  // default: true
-  bool share_table_files;
-
-  // Backup info and error messages will be written to info_log
-  // if non-nullptr.
-  // Default: nullptr
-  Logger* info_log;
-
-  // If sync == true, we can guarantee you'll get consistent backup even
-  // on a machine crash/reboot. Backup process is slower with sync enabled.
-  // If sync == false, we don't guarantee anything on machine reboot. However,
-  // chances are some of the backups are consistent.
-  // Default: true
-  bool sync;
-
-  // If true, it will delete whatever backups there are already
-  // Default: false
-  bool destroy_old_data;
-
-  // If false, we won't backup log files. This option can be useful for backing
-  // up in-memory databases where log file are persisted, but table files are in
-  // memory.
-  // Default: true
-  bool backup_log_files;
-
-  // Max bytes that can be transferred in a second during backup.
-  // If 0, go as fast as you can
-  // Default: 0
-  uint64_t backup_rate_limit;
-
-  // Max bytes that can be transferred in a second during restore.
-  // If 0, go as fast as you can
-  // Default: 0
-  uint64_t restore_rate_limit;
-
-  // Only used if share_table_files is set to true. If true, will consider that
-  // backups can come from different databases, hence a sst is not uniquely
-  // identifed by its name, but by the triple (file name, crc32, file length)
-  // Default: false
-  // Note: this is an experimental option, and you'll need to set it manually
-  // *turn it on only if you know what you're doing*
-  bool share_files_with_checksum;
-
-  void Dump(Logger* logger) const;
-
-  explicit BackupableDBOptions(const std::string& _backup_dir,
-                               Env* _backup_env = nullptr,
-                               bool _share_table_files = true,
-                               Logger* _info_log = nullptr, bool _sync = true,
-                               bool _destroy_old_data = false,
-                               bool _backup_log_files = true,
-                               uint64_t _backup_rate_limit = 0,
-                               uint64_t _restore_rate_limit = 0)
-      : backup_dir(_backup_dir),
-        backup_env(_backup_env),
-        share_table_files(_share_table_files),
-        info_log(_info_log),
-        sync(_sync),
-        destroy_old_data(_destroy_old_data),
-        backup_log_files(_backup_log_files),
-        backup_rate_limit(_backup_rate_limit),
-        restore_rate_limit(_restore_rate_limit),
-        share_files_with_checksum(false) {
-    assert(share_table_files || !share_files_with_checksum);
-  }
-};
-
-struct RestoreOptions {
-  // If true, restore won't overwrite the existing log files in wal_dir. It will
-  // also move all log files from archive directory to wal_dir. Use this option
-  // in combination with BackupableDBOptions::backup_log_files = false for
-  // persisting in-memory databases.
-  // Default: false
-  bool keep_log_files;
-
-  explicit RestoreOptions(bool _keep_log_files = false)
-      : keep_log_files(_keep_log_files) {}
-};
-
-typedef uint32_t BackupID;
-
-struct BackupInfo {
-  BackupID backup_id;
-  int64_t timestamp;
-  uint64_t size;
-
-  BackupInfo() {}
-  BackupInfo(BackupID _backup_id, int64_t _timestamp, uint64_t _size)
-      : backup_id(_backup_id), timestamp(_timestamp), size(_size) {}
-};
-
-class BackupEngineReadOnly {
- public:
-  virtual ~BackupEngineReadOnly() {}
-
-  static BackupEngineReadOnly* NewReadOnlyBackupEngine(
-      Env* db_env, const BackupableDBOptions& options);
-
-  // You can GetBackupInfo safely, even with other BackupEngine performing
-  // backups on the same directory
-  virtual void GetBackupInfo(std::vector<BackupInfo>* backup_info) = 0;
-
-  // Restoring DB from backup is NOT safe when there is another BackupEngine
-  // running that might call DeleteBackup() or PurgeOldBackups(). It is caller's
-  // responsibility to synchronize the operation, i.e. don't delete the backup
-  // when you're restoring from it
-  virtual Status RestoreDBFromBackup(
-      BackupID backup_id, const std::string& db_dir, const std::string& wal_dir,
-      const RestoreOptions& restore_options = RestoreOptions()) = 0;
-  virtual Status RestoreDBFromLatestBackup(
-      const std::string& db_dir, const std::string& wal_dir,
-      const RestoreOptions& restore_options = RestoreOptions()) = 0;
-};
-
-// Please see the documentation in BackupableDB and RestoreBackupableDB
-class BackupEngine {
- public:
-  virtual ~BackupEngine() {}
-
-  static BackupEngine* NewBackupEngine(Env* db_env,
-                                       const BackupableDBOptions& options);
-
-  virtual Status CreateNewBackup(DB* db, bool flush_before_backup = false) = 0;
-  virtual Status PurgeOldBackups(uint32_t num_backups_to_keep) = 0;
-  virtual Status DeleteBackup(BackupID backup_id) = 0;
-  virtual void StopBackup() = 0;
-
-  virtual void GetBackupInfo(std::vector<BackupInfo>* backup_info) = 0;
-  virtual Status RestoreDBFromBackup(
-      BackupID backup_id, const std::string& db_dir, const std::string& wal_dir,
-      const RestoreOptions& restore_options = RestoreOptions()) = 0;
-  virtual Status RestoreDBFromLatestBackup(
-      const std::string& db_dir, const std::string& wal_dir,
-      const RestoreOptions& restore_options = RestoreOptions()) = 0;
-};
-
-// Stack your DB with BackupableDB to be able to backup the DB
-class BackupableDB : public StackableDB {
- public:
-  // BackupableDBOptions have to be the same as the ones used in a previous
-  // incarnation of the DB
-  //
-  // BackupableDB ownes the pointer `DB* db` now. You should not delete it or
-  // use it after the invocation of BackupableDB
-  BackupableDB(DB* db, const BackupableDBOptions& options);
-  virtual ~BackupableDB();
-
-  // Captures the state of the database in the latest backup
-  // NOT a thread safe call
-  Status CreateNewBackup(bool flush_before_backup = false);
-  // Returns info about backups in backup_info
-  void GetBackupInfo(std::vector<BackupInfo>* backup_info);
-  // deletes old backups, keeping latest num_backups_to_keep alive
-  Status PurgeOldBackups(uint32_t num_backups_to_keep);
-  // deletes a specific backup
-  Status DeleteBackup(BackupID backup_id);
-  // Call this from another thread if you want to stop the backup
-  // that is currently happening. It will return immediatelly, will
-  // not wait for the backup to stop.
-  // The backup will stop ASAP and the call to CreateNewBackup will
-  // return Status::Incomplete(). It will not clean up after itself, but
-  // the state will remain consistent. The state will be cleaned up
-  // next time you create BackupableDB or RestoreBackupableDB.
-  void StopBackup();
-
- private:
-  BackupEngine* backup_engine_;
-};
-
-// Use this class to access information about backups and restore from them
-class RestoreBackupableDB {
- public:
-  RestoreBackupableDB(Env* db_env, const BackupableDBOptions& options);
-  ~RestoreBackupableDB();
-
-  // Returns info about backups in backup_info
-  void GetBackupInfo(std::vector<BackupInfo>* backup_info);
-
-  // restore from backup with backup_id
-  // IMPORTANT -- if options_.share_table_files == true and you restore DB
-  // from some backup that is not the latest, and you start creating new
-  // backups from the new DB, they will probably fail
-  //
-  // Example: Let's say you have backups 1, 2, 3, 4, 5 and you restore 3.
-  // If you add new data to the DB and try creating a new backup now, the
-  // database will diverge from backups 4 and 5 and the new backup will fail.
-  // If you want to create new backup, you will first have to delete backups 4
-  // and 5.
-  Status RestoreDBFromBackup(BackupID backup_id, const std::string& db_dir,
-                             const std::string& wal_dir,
-                             const RestoreOptions& restore_options =
-                                 RestoreOptions());
-
-  // restore from the latest backup
-  Status RestoreDBFromLatestBackup(const std::string& db_dir,
-                                   const std::string& wal_dir,
-                                   const RestoreOptions& restore_options =
-                                       RestoreOptions());
-  // deletes old backups, keeping latest num_backups_to_keep alive
-  Status PurgeOldBackups(uint32_t num_backups_to_keep);
-  // deletes a specific backup
-  Status DeleteBackup(BackupID backup_id);
-
- private:
-  BackupEngine* backup_engine_;
-};
-
-}  // namespace rocksdb
-#endif  // ROCKSDB_LITE
@@ -1,68 +0,0 @@
-//  Copyright (c) 2013, 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.
-
-#pragma once
-#ifndef ROCKSDB_LITE
-
-#include <string>
-#include <vector>
-
-#include "rocksdb/utilities/stackable_db.h"
-#include "rocksdb/db.h"
-
-namespace rocksdb {
-
-// Database with TTL support.
-//
-// USE-CASES:
-// This API should be used to open the db when key-values inserted are
-//  meant to be removed from the db in a non-strict 'ttl' amount of time
-//  Therefore, this guarantees that key-values inserted will remain in the
-//  db for >= ttl amount of time and the db will make efforts to remove the
-//  key-values as soon as possible after ttl seconds of their insertion.
-//
-// BEHAVIOUR:
-// TTL is accepted in seconds
-// (int32_t)Timestamp(creation) is suffixed to values in Put internally
-// Expired TTL values deleted in compaction only:(Timestamp+ttl<time_now)
-// Get/Iterator may return expired entries(compaction not run on them yet)
-// Different TTL may be used during different Opens
-// Example: Open1 at t=0 with ttl=4 and insert k1,k2, close at t=2
-//          Open2 at t=3 with ttl=5. Now k1,k2 should be deleted at t>=5
-// read_only=true opens in the usual read-only mode. Compactions will not be
-//  triggered(neither manual nor automatic), so no expired entries removed
-//
-// CONSTRAINTS:
-// Not specifying/passing or non-positive TTL behaves like TTL = infinity
-//
-// !!!WARNING!!!:
-// Calling DB::Open directly to re-open a db created by this API will get
-//  corrupt values(timestamp suffixed) and no ttl effect will be there
-//  during the second Open, so use this API consistently to open the db
-// Be careful when passing ttl with a small positive value because the
-//  whole database may be deleted in a small amount of time
-
-class DBWithTTL : public StackableDB {
- public:
-  virtual Status CreateColumnFamilyWithTtl(
-      const ColumnFamilyOptions& options, const std::string& column_family_name,
-      ColumnFamilyHandle** handle, int ttl) = 0;
-
-  static Status Open(const Options& options, const std::string& dbname,
-                     DBWithTTL** dbptr, int32_t ttl = 0,
-                     bool read_only = false);
-
-  static Status Open(const DBOptions& db_options, const std::string& dbname,
-                     const std::vector<ColumnFamilyDescriptor>& column_families,
-                     std::vector<ColumnFamilyHandle*>* handles,
-                     DBWithTTL** dbptr, std::vector<int32_t> ttls,
-                     bool read_only = false);
-
- protected:
-  explicit DBWithTTL(DB* db) : StackableDB(db) {}
-};
-
-}  // namespace rocksdb
-#endif  // ROCKSDB_LITE
@@ -1,149 +0,0 @@
-//  Copyright (c) 2013, 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.
-
-#pragma once
-#ifndef ROCKSDB_LITE
-
-#include <string>
-#include <vector>
-
-#include "rocksdb/utilities/stackable_db.h"
-#include "rocksdb/utilities/json_document.h"
-#include "rocksdb/db.h"
-
-namespace rocksdb {
-
-// IMPORTANT: DocumentDB is a work in progress. It is unstable and we might
-// change the API without warning. Talk to RocksDB team before using this in
-// production ;)
-
-// DocumentDB is a layer on top of RocksDB that provides a very simple JSON API.
-// When creating a DB, you specify a list of indexes you want to keep on your
-// data. You can insert a JSON document to the DB, which is automatically
-// indexed. Every document added to the DB needs to have "_id" field which is
-// automatically indexed and is an unique primary key. All other indexes are
-// non-unique.
-
-// NOTE: field names in the JSON are NOT allowed to start with '$' or
-// contain '.'. We don't currently enforce that rule, but will start behaving
-// badly.
-
-// Cursor is what you get as a result of executing query. To get all
-// results from a query, call Next() on a Cursor while  Valid() returns true
-class Cursor {
- public:
-  Cursor() = default;
-  virtual ~Cursor() {}
-
-  virtual bool Valid() const = 0;
-  virtual void Next() = 0;
-  // Lifecycle of the returned JSONDocument is until the next Next() call
-  virtual const JSONDocument& document() const = 0;
-  virtual Status status() const = 0;
-
- private:
-  // No copying allowed
-  Cursor(const Cursor&);
-  void operator=(const Cursor&);
-};
-
-struct DocumentDBOptions {
-  int background_threads = 4;
-  uint64_t memtable_size = 128 * 1024 * 1024;    // 128 MB
-  uint64_t cache_size = 1 * 1024 * 1024 * 1024;  // 1 GB
-};
-
-// TODO(icanadi) Add `JSONDocument* info` parameter to all calls that can be
-// used by the caller to get more information about the call execution (number
-// of dropped records, number of updated records, etc.)
-class DocumentDB : public StackableDB {
- public:
-  struct IndexDescriptor {
-    // Currently, you can only define an index on a single field. To specify an
-    // index on a field X, set index description to JSON "{X: 1}"
-    // Currently the value needs to be 1, which means ascending.
-    // In the future, we plan to also support indexes on multiple keys, where
-    // you could mix ascending sorting (1) with descending sorting indexes (-1)
-    JSONDocument* description;
-    std::string name;
-  };
-
-  // Open DocumentDB with specified indexes. The list of indexes has to be
-  // complete, i.e. include all indexes present in the DB, except the primary
-  // key index.
-  // Otherwise, Open() will return an error
-  static Status Open(const DocumentDBOptions& options, const std::string& name,
-                     const std::vector<IndexDescriptor>& indexes,
-                     DocumentDB** db, bool read_only = false);
-
-  explicit DocumentDB(DB* db) : StackableDB(db) {}
-
-  // Create a new index. It will stop all writes for the duration of the call.
-  // All current documents in the DB are scanned and corresponding index entries
-  // are created
-  virtual Status CreateIndex(const WriteOptions& write_options,
-                             const IndexDescriptor& index) = 0;
-
-  // Drop an index. Client is responsible to make sure that index is not being
-  // used by currently executing queries
-  virtual Status DropIndex(const std::string& name) = 0;
-
-  // Insert a document to the DB. The document needs to have a primary key "_id"
-  // which can either be a string or an integer. Otherwise the write will fail
-  // with InvalidArgument.
-  virtual Status Insert(const WriteOptions& options,
-                        const JSONDocument& document) = 0;
-
-  // Deletes all documents matching a filter atomically
-  virtual Status Remove(const ReadOptions& read_options,
-                        const WriteOptions& write_options,
-                        const JSONDocument& query) = 0;
-
-  // Does this sequence of operations:
-  // 1. Find all documents matching a filter
-  // 2. For all documents, atomically:
-  // 2.1. apply the update operators
-  // 2.2. update the secondary indexes
-  //
-  // Currently only $set update operator is supported.
-  // Syntax is: {$set: {key1: value1, key2: value2, etc...}}
-  // This operator will change a document's key1 field to value1, key2 to
-  // value2, etc. New values will be set even if a document didn't have an entry
-  // for the specified key.
-  //
-  // You can not change a primary key of a document.
-  //
-  // Update example: Update({id: {$gt: 5}, $index: id}, {$set: {enabled: true}})
-  virtual Status Update(const ReadOptions& read_options,
-                        const WriteOptions& write_options,
-                        const JSONDocument& filter,
-                        const JSONDocument& updates) = 0;
-
-  // query has to be an array in which every element is an operator. Currently
-  // only $filter operator is supported. Syntax of $filter operator is:
-  // {$filter: {key1: condition1, key2: condition2, etc.}} where conditions can
-  // be either:
-  // 1) a single value in which case the condition is equality condition, or
-  // 2) a defined operators, like {$gt: 4}, which will match all documents that
-  // have key greater than 4.
-  //
-  // Supported operators are:
-  // 1) $gt -- greater than
-  // 2) $gte -- greater than or equal
-  // 3) $lt -- less than
-  // 4) $lte -- less than or equal
-  // If you want the filter to use an index, you need to specify it like this:
-  // {$filter: {...(conditions)..., $index: index_name}}
-  //
-  // Example query:
-  // * [{$filter: {name: John, age: {$gte: 18}, $index: age}}]
-  // will return all Johns whose age is greater or equal to 18 and it will use
-  // index "age" to satisfy the query.
-  virtual Cursor* Query(const ReadOptions& read_options,
-                        const JSONDocument& query) = 0;
-};
-
-}  // namespace rocksdb
-#endif  // ROCKSDB_LITE
@@ -1,105 +0,0 @@
-//  Copyright (c) 2013, 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.
-//
-
-#ifndef ROCKSDB_LITE
-#pragma once
-#include <string>
-#include <vector>
-
-#include "rocksdb/utilities/stackable_db.h"
-#include "rocksdb/status.h"
-
-namespace rocksdb {
-
-//
-// Configurable options needed for setting up a Geo database
-//
-struct GeoDBOptions {
-  // Backup info and error messages will be written to info_log
-  // if non-nullptr.
-  // Default: nullptr
-  Logger* info_log;
-
-  explicit GeoDBOptions(Logger* _info_log = nullptr):info_log(_info_log) { }
-};
-
-//
-// A position in the earth's geoid
-//
-class GeoPosition {
- public:
-  double latitude;
-  double longitude;
-
-  explicit GeoPosition(double la = 0, double lo = 0) :
-    latitude(la), longitude(lo) {
-  }
-};
-
-//
-// Description of an object on the Geoid. It is located by a GPS location,
-// and is identified by the id. The value associated with this object is
-// an opaque string 'value'. Different objects identified by unique id's
-// can have the same gps-location associated with them.
-//
-class GeoObject {
- public:
-  GeoPosition position;
-  std::string id;
-  std::string value;
-
-  GeoObject() {}
-
-  GeoObject(const GeoPosition& pos, const std::string& i,
-            const std::string& val) :
-    position(pos), id(i), value(val) {
-  }
-};
-
-//
-// Stack your DB with GeoDB to be able to get geo-spatial support
-//
-class GeoDB : public StackableDB {
- public:
-  // GeoDBOptions have to be the same as the ones used in a previous
-  // incarnation of the DB
-  //
-  // GeoDB owns the pointer `DB* db` now. You should not delete it or
-  // use it after the invocation of GeoDB
-  // GeoDB(DB* db, const GeoDBOptions& options) : StackableDB(db) {}
-  GeoDB(DB* db, const GeoDBOptions& options) : StackableDB(db) {}
-  virtual ~GeoDB() {}
-
-  // Insert a new object into the location database. The object is
-  // uniquely identified by the id. If an object with the same id already
-  // exists in the db, then the old one is overwritten by the new
-  // object being inserted here.
-  virtual Status Insert(const GeoObject& object) = 0;
-
-  // Retrieve the value of the object located at the specified GPS
-  // location and is identified by the 'id'.
-  virtual Status GetByPosition(const GeoPosition& pos,
-                               const Slice& id, std::string* value) = 0;
-
-  // Retrieve the value of the object identified by the 'id'. This method
-  // could be potentially slower than GetByPosition
-  virtual Status GetById(const Slice& id, GeoObject*  object) = 0;
-
-  // Delete the specified object
-  virtual Status Remove(const Slice& id) = 0;
-
-  // Returns a list of all items within a circular radius from the
-  // specified gps location. If 'number_of_values' is specified,
-  // then this call returns at most that many number of objects.
-  // The radius is specified in 'meters'.
-  virtual Status SearchRadial(const GeoPosition& pos,
-                              double radius,
-                              std::vector<GeoObject>* values,
-                              int number_of_values = INT_MAX) = 0;
-};
-
-}  // namespace rocksdb
-#endif  // ROCKSDB_LITE
@@ -1,174 +0,0 @@
-//  Copyright (c) 2013, 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.
-#pragma once
-#ifndef ROCKSDB_LITE
-
-#include <string>
-#include <map>
-#include <unordered_map>
-#include <vector>
-
-#include "rocksdb/slice.h"
-
-// We use JSONDocument for DocumentDB API
-// Implementation inspired by folly::dynamic and rapidjson
-
-namespace rocksdb {
-
-// NOTE: none of this is thread-safe
-class JSONDocument {
- public:
-  // return nullptr on parse failure
-  static JSONDocument* ParseJSON(const char* json);
-
-  enum Type {
-    kNull,
-    kArray,
-    kBool,
-    kDouble,
-    kInt64,
-    kObject,
-    kString,
-  };
-
-  JSONDocument();  // null
-  /* implicit */ JSONDocument(bool b);
-  /* implicit */ JSONDocument(double d);
-  /* implicit */ JSONDocument(int64_t i);
-  /* implicit */ JSONDocument(const std::string& s);
-  /* implicit */ JSONDocument(const char* s);
-  // constructs JSONDocument of specific type with default value
-  explicit JSONDocument(Type type);
-
-  // copy constructor
-  JSONDocument(const JSONDocument& json_document);
-
-  ~JSONDocument();
-
-  Type type() const;
-
-  // REQUIRES: IsObject()
-  bool Contains(const std::string& key) const;
-  // Returns nullptr if !Contains()
-  // don't delete the returned pointer
-  // REQUIRES: IsObject()
-  const JSONDocument* Get(const std::string& key) const;
-  // REQUIRES: IsObject()
-  JSONDocument& operator[](const std::string& key);
-  // REQUIRES: IsObject()
-  const JSONDocument& operator[](const std::string& key) const;
-  // returns `this`, so you can chain operations.
-  // Copies value
-  // REQUIRES: IsObject()
-  JSONDocument* Set(const std::string& key, const JSONDocument& value);
-
-  // REQUIRES: IsArray() == true || IsObject() == true
-  size_t Count() const;
-
-  // REQUIRES: IsArray()
-  const JSONDocument* GetFromArray(size_t i) const;
-  // REQUIRES: IsArray()
-  JSONDocument& operator[](size_t i);
-  // REQUIRES: IsArray()
-  const JSONDocument& operator[](size_t i) const;
-  // returns `this`, so you can chain operations.
-  // Copies the value
-  // REQUIRES: IsArray() && i < Count()
-  JSONDocument* SetInArray(size_t i, const JSONDocument& value);
-  // REQUIRES: IsArray()
-  JSONDocument* PushBack(const JSONDocument& value);
-
-  bool IsNull() const;
-  bool IsArray() const;
-  bool IsBool() const;
-  bool IsDouble() const;
-  bool IsInt64() const;
-  bool IsObject() const;
-  bool IsString() const;
-
-  // REQUIRES: IsBool() == true
-  bool GetBool() const;
-  // REQUIRES: IsDouble() == true
-  double GetDouble() const;
-  // REQUIRES: IsInt64() == true
-  int64_t GetInt64() const;
-  // REQUIRES: IsString() == true
-  const std::string& GetString() const;
-
-  bool operator==(const JSONDocument& rhs) const;
-
-  std::string DebugString() const;
-
- private:
-  class ItemsIteratorGenerator;
-
- public:
-  // REQUIRES: IsObject()
-  ItemsIteratorGenerator Items() const;
-
-  // appends serialized object to dst
-  void Serialize(std::string* dst) const;
-  // returns nullptr if Slice doesn't represent valid serialized JSONDocument
-  static JSONDocument* Deserialize(const Slice& src);
-
- private:
-  void SerializeInternal(std::string* dst, bool type_prefix) const;
-  // returns false if Slice doesn't represent valid serialized JSONDocument.
-  // Otherwise, true
-  bool DeserializeInternal(Slice* input);
-
-  typedef std::vector<JSONDocument*> Array;
-  typedef std::unordered_map<std::string, JSONDocument*> Object;
-
-  // iteration on objects
-  class const_item_iterator {
-   public:
-    typedef Object::const_iterator It;
-    typedef Object::value_type value_type;
-    /* implicit */ const_item_iterator(It it) : it_(it) {}
-    It& operator++() { return ++it_; }
-    bool operator!=(const const_item_iterator& other) {
-      return it_ != other.it_;
-    }
-    value_type operator*() { return *it_; }
-
-   private:
-    It it_;
-  };
-  class ItemsIteratorGenerator {
-   public:
-    /* implicit */ ItemsIteratorGenerator(const Object& object)
-        : object_(object) {}
-    const_item_iterator begin() { return object_.begin(); }
-    const_item_iterator end() { return object_.end(); }
-
-   private:
-    const Object& object_;
-  };
-
-  union Data {
-    Data() : n(nullptr) {}
-    ~Data() {}
-
-    void* n;
-    Array a;
-    bool b;
-    double d;
-    int64_t i;
-    std::string s;
-    Object o;
-  } data_;
-  const Type type_;
-
-  // Our serialization format's first byte specifies the encoding version. That
-  // way, we can easily change our format while providing backwards
-  // compatibility. This constant specifies the current version of the
-  // serialization format
-  static const char kSerializationFormatVersion;
-};
-
-}  // namespace rocksdb
-
-#endif  // ROCKSDB_LITE
@@ -1,236 +0,0 @@
-//  Copyright (c) 2013, 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.
-
-#pragma once
-#ifndef ROCKSDB_LITE
-
-#include <string>
-#include <vector>
-
-#include "rocksdb/db.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/utilities/stackable_db.h"
-
-namespace rocksdb {
-namespace spatial {
-
-// NOTE: SpatialDB is experimental and we might change its API without warning.
-// Please talk to us before developing against SpatialDB API.
-//
-// SpatialDB is a support for spatial indexes built on top of RocksDB.
-// When creating a new SpatialDB, clients specifies a list of spatial indexes to
-// build on their data. Each spatial index is defined by the area and
-// granularity. If you're storing map data, different spatial index
-// granularities can be used for different zoom levels.
-//
-// Each element inserted into SpatialDB has:
-// * a bounding box, which determines how will the element be indexed
-// * string blob, which will usually be WKB representation of the polygon
-// (http://en.wikipedia.org/wiki/Well-known_text)
-// * feature set, which is a map of key-value pairs, where value can be null,
-// int, double, bool, string
-// * a list of indexes to insert the element in
-//
-// Each query is executed on a single spatial index. Query guarantees that it
-// will return all elements intersecting the specified bounding box, but it
-// might also return some extra non-intersecting elements.
-
-// Variant is a class that can be many things: null, bool, int, double or string
-// It is used to store different value types in FeatureSet (see below)
-struct Variant {
-  // Don't change the values here, they are persisted on disk
-  enum Type {
-    kNull = 0x0,
-    kBool = 0x1,
-    kInt = 0x2,
-    kDouble = 0x3,
-    kString = 0x4,
-  };
-
-  Variant() : type_(kNull) {}
-  /* implicit */ Variant(bool b) : type_(kBool) { data_.b = b; }
-  /* implicit */ Variant(uint64_t i) : type_(kInt) { data_.i = i; }
-  /* implicit */ Variant(double d) : type_(kDouble) { data_.d = d; }
-  /* implicit */ Variant(const std::string& s) : type_(kString) {
-    new (&data_.s) std::string(s);
-  }
-
-  Variant(const Variant& v);
-
-  ~Variant() {
-    if (type_ == kString) {
-      using std::string;
-      (&data_.s)->~string();
-    }
-  }
-
-  Type type() const { return type_; }
-  bool get_bool() const { return data_.b; }
-  uint64_t get_int() const { return data_.i; }
-  double get_double() const { return data_.d; }
-  const std::string& get_string() const { return data_.s; }
-
-  bool operator==(const Variant& other);
-  bool operator!=(const Variant& other);
-
- private:
-  Type type_;
-  union Data {
-    Data() {}
-    ~Data() {}
-    bool b;
-    uint64_t i;
-    double d;
-    std::string s;
-  } data_;
-};
-
-// FeatureSet is a map of key-value pairs. One feature set is associated with
-// each element in SpatialDB. It can be used to add rich data about the element.
-class FeatureSet {
- private:
-  typedef std::unordered_map<std::string, Variant> map;
-
- public:
-  class iterator {
-   public:
-    /* implicit */ iterator(const map::const_iterator itr) : itr_(itr) {}
-    iterator& operator++() {
-      ++itr_;
-      return *this;
-    }
-    bool operator!=(const iterator& other) { return itr_ != other.itr_; }
-    bool operator==(const iterator& other) { return itr_ == other.itr_; }
-    map::value_type operator*() { return *itr_; }
-
-   private:
-    map::const_iterator itr_;
-  };
-  FeatureSet() = default;
-
-  FeatureSet* Set(const std::string& key, const Variant& value);
-  bool Contains(const std::string& key) const;
-  // REQUIRES: Contains(key)
-  const Variant& Get(const std::string& key) const;
-  iterator Find(const std::string& key) const;
-
-  iterator begin() const { return map_.begin(); }
-  iterator end() const { return map_.end(); }
-
-  void Clear();
-  size_t Size() const { return map_.size(); }
-
-  void Serialize(std::string* output) const;
-  // REQUIRED: empty FeatureSet
-  bool Deserialize(const Slice& input);
-
-  std::string DebugString() const;
-
- private:
-  map map_;
-};
-
-// BoundingBox is a helper structure for defining rectangles representing
-// bounding boxes of spatial elements.
-template <typename T>
-struct BoundingBox {
-  T min_x, min_y, max_x, max_y;
-  BoundingBox() = default;
-  BoundingBox(T _min_x, T _min_y, T _max_x, T _max_y)
-      : min_x(_min_x), min_y(_min_y), max_x(_max_x), max_y(_max_y) {}
-
-  bool Intersects(const BoundingBox<T>& a) const {
-    return !(min_x > a.max_x || min_y > a.max_y || a.min_x > max_x ||
-             a.min_y > max_y);
-  }
-};
-
-struct SpatialDBOptions {
-  uint64_t cache_size = 1 * 1024 * 1024 * 1024LL;  // 1GB
-  int num_threads = 16;
-  bool bulk_load = true;
-};
-
-// Cursor is used to return data from the query to the client. To get all the
-// data from the query, just call Next() while Valid() is true
-class Cursor {
- public:
-  Cursor() = default;
-  virtual ~Cursor() {}
-
-  virtual bool Valid() const = 0;
-  // REQUIRES: Valid()
-  virtual void Next() = 0;
-
-  // Lifetime of the underlying storage until the next call to Next()
-  // REQUIRES: Valid()
-  virtual const Slice blob() = 0;
-  // Lifetime of the underlying storage until the next call to Next()
-  // REQUIRES: Valid()
-  virtual const FeatureSet& feature_set() = 0;
-
-  virtual Status status() const = 0;
-
- private:
-  // No copying allowed
-  Cursor(const Cursor&);
-  void operator=(const Cursor&);
-};
-
-// SpatialIndexOptions defines a spatial index that will be built on the data
-struct SpatialIndexOptions {
-  // Spatial indexes are referenced by names
-  std::string name;
-  // An area that is indexed. If the element is not intersecting with spatial
-  // index's bbox, it will not be inserted into the index
-  BoundingBox<double> bbox;
-  // tile_bits control the granularity of the spatial index. Each dimension of
-  // the bbox will be split into (1 << tile_bits) tiles, so there will be a
-  // total of (1 << tile_bits)^2 tiles. It is recommended to configure a size of
-  // each  tile to be approximately the size of the query on that spatial index
-  uint32_t tile_bits;
-  SpatialIndexOptions() {}
-  SpatialIndexOptions(const std::string& _name,
-                      const BoundingBox<double>& _bbox, uint32_t _tile_bits)
-      : name(_name), bbox(_bbox), tile_bits(_tile_bits) {}
-};
-
-class SpatialDB : public StackableDB {
- public:
-  // Creates the SpatialDB with specified list of indexes.
-  // REQUIRED: db doesn't exist
-  static Status Create(const SpatialDBOptions& options, const std::string& name,
-                       const std::vector<SpatialIndexOptions>& spatial_indexes);
-
-  // Open the existing SpatialDB.  The resulting db object will be returned
-  // through db parameter.
-  // REQUIRED: db was created using SpatialDB::Create
-  static Status Open(const SpatialDBOptions& options, const std::string& name,
-                     SpatialDB** db, bool read_only = false);
-
-  explicit SpatialDB(DB* db) : StackableDB(db) {}
-
-  // Insert the element into the DB. Element will be inserted into specified
-  // spatial_indexes, based on specified bbox.
-  // REQUIRES: spatial_indexes.size() > 0
-  virtual Status Insert(const WriteOptions& write_options,
-                        const BoundingBox<double>& bbox, const Slice& blob,
-                        const FeatureSet& feature_set,
-                        const std::vector<std::string>& spatial_indexes) = 0;
-
-  // Calling Compact() after inserting a bunch of elements should speed up
-  // reading. This is especially useful if you use SpatialDBOptions::bulk_load
-  virtual Status Compact() = 0;
-
-  // Query the specified spatial_index. Query will return all elements that
-  // intersect bbox, but it may also return some extra elements.
-  virtual Cursor* Query(const ReadOptions& read_options,
-                        const BoundingBox<double>& bbox,
-                        const std::string& spatial_index) = 0;
-};
-
-}  // namespace spatial
-}  // namespace rocksdb
-#endif  // ROCKSDB_LITE
@@ -1,226 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// 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.
-
-#pragma once
-#include "rocksdb/db.h"
-
-namespace rocksdb {
-
-// This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d
-class StackableDB : public DB {
- public:
-  // StackableDB is the owner of db now!
-  explicit StackableDB(DB* db) : db_(db) {}
-
-  ~StackableDB() {
-    delete db_;
-  }
-
-  virtual DB* GetBaseDB() {
-    return db_;
-  }
-
-  virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
-                                    const std::string& column_family_name,
-                                    ColumnFamilyHandle** handle) {
-    return db_->CreateColumnFamily(options, column_family_name, handle);
-  }
-
-  virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) {
-    return db_->DropColumnFamily(column_family);
-  }
-
-  using DB::Put;
-  virtual Status Put(const WriteOptions& options,
-                     ColumnFamilyHandle* column_family, const Slice& key,
-                     const Slice& val) override {
-    return db_->Put(options, column_family, key, val);
-  }
-
-  using DB::Get;
-  virtual Status Get(const ReadOptions& options,
-                     ColumnFamilyHandle* column_family, const Slice& key,
-                     std::string* value) override {
-    return db_->Get(options, column_family, key, value);
-  }
-
-  using DB::MultiGet;
-  virtual std::vector<Status> MultiGet(
-      const ReadOptions& options,
-      const std::vector<ColumnFamilyHandle*>& column_family,
-      const std::vector<Slice>& keys,
-      std::vector<std::string>* values) override {
-    return db_->MultiGet(options, column_family, keys, values);
-  }
-
-  using DB::KeyMayExist;
-  virtual bool KeyMayExist(const ReadOptions& options,
-                           ColumnFamilyHandle* column_family, const Slice& key,
-                           std::string* value,
-                           bool* value_found = nullptr) override {
-    return db_->KeyMayExist(options, column_family, key, value, value_found);
-  }
-
-  using DB::Delete;
-  virtual Status Delete(const WriteOptions& wopts,
-                        ColumnFamilyHandle* column_family,
-                        const Slice& key) override {
-    return db_->Delete(wopts, column_family, key);
-  }
-
-  using DB::Merge;
-  virtual Status Merge(const WriteOptions& options,
-                       ColumnFamilyHandle* column_family, const Slice& key,
-                       const Slice& value) override {
-    return db_->Merge(options, column_family, key, value);
-  }
-
-
-  virtual Status Write(const WriteOptions& opts, WriteBatch* updates)
-    override {
-      return db_->Write(opts, updates);
-  }
-
-  using DB::NewIterator;
-  virtual Iterator* NewIterator(const ReadOptions& opts,
-                                ColumnFamilyHandle* column_family) override {
-    return db_->NewIterator(opts, column_family);
-  }
-
-  virtual Status NewIterators(
-      const ReadOptions& options,
-      const std::vector<ColumnFamilyHandle*>& column_families,
-      std::vector<Iterator*>* iterators) {
-    return db_->NewIterators(options, column_families, iterators);
-  }
-
-
-  virtual const Snapshot* GetSnapshot() override {
-    return db_->GetSnapshot();
-  }
-
-  virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
-    return db_->ReleaseSnapshot(snapshot);
-  }
-
-  using DB::GetProperty;
-  virtual bool GetProperty(ColumnFamilyHandle* column_family,
-                           const Slice& property, std::string* value) override {
-    return db_->GetProperty(column_family, property, value);
-  }
-
-  using DB::GetIntProperty;
-  virtual bool GetIntProperty(ColumnFamilyHandle* column_family,
-                              const Slice& property, uint64_t* value) override {
-    return db_->GetIntProperty(column_family, property, value);
-  }
-
-  using DB::GetApproximateSizes;
-  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
-                                   const Range* r, int n,
-                                   uint64_t* sizes) override {
-      return db_->GetApproximateSizes(column_family, r, n, sizes);
-  }
-
-  using DB::CompactRange;
-  virtual Status CompactRange(ColumnFamilyHandle* column_family,
-                              const Slice* begin, const Slice* end,
-                              bool reduce_level = false, int target_level = -1,
-                              uint32_t target_path_id = 0) override {
-    return db_->CompactRange(column_family, begin, end, reduce_level,
-                             target_level, target_path_id);
-  }
-
-  using DB::NumberLevels;
-  virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
-    return db_->NumberLevels(column_family);
-  }
-
-  using DB::MaxMemCompactionLevel;
-  virtual int MaxMemCompactionLevel(ColumnFamilyHandle* column_family)
-      override {
-    return db_->MaxMemCompactionLevel(column_family);
-  }
-
-  using DB::Level0StopWriteTrigger;
-  virtual int Level0StopWriteTrigger(ColumnFamilyHandle* column_family)
-      override {
-    return db_->Level0StopWriteTrigger(column_family);
-  }
-
-  virtual const std::string& GetName() const override {
-    return db_->GetName();
-  }
-
-  virtual Env* GetEnv() const override {
-    return db_->GetEnv();
-  }
-
-  using DB::GetOptions;
-  virtual const Options& GetOptions(ColumnFamilyHandle* column_family) const
-      override {
-    return db_->GetOptions(column_family);
-  }
-
-  using DB::Flush;
-  virtual Status Flush(const FlushOptions& fopts,
-                       ColumnFamilyHandle* column_family) override {
-    return db_->Flush(fopts, column_family);
-  }
-
-  virtual Status DisableFileDeletions() override {
-    return db_->DisableFileDeletions();
-  }
-
-  virtual Status EnableFileDeletions(bool force) override {
-    return db_->EnableFileDeletions(force);
-  }
-
-  virtual void GetLiveFilesMetaData(
-      std::vector<LiveFileMetaData>* metadata) override {
-    db_->GetLiveFilesMetaData(metadata);
-  }
-
-  virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
-                              bool flush_memtable = true) override {
-      return db_->GetLiveFiles(vec, mfs, flush_memtable);
-  }
-
-  virtual SequenceNumber GetLatestSequenceNumber() const override {
-    return db_->GetLatestSequenceNumber();
-  }
-
-  virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
-    return db_->GetSortedWalFiles(files);
-  }
-
-  virtual Status DeleteFile(std::string name) override {
-    return db_->DeleteFile(name);
-  }
-
-  virtual Status GetDbIdentity(std::string& identity) {
-    return db_->GetDbIdentity(identity);
-  }
-
-  using DB::GetPropertiesOfAllTables;
-  virtual Status GetPropertiesOfAllTables(ColumnFamilyHandle* column_family,
-                                          TablePropertiesCollection* props) {
-    return db_->GetPropertiesOfAllTables(column_family, props);
-  }
-
-  virtual Status GetUpdatesSince(
-      SequenceNumber seq_number, unique_ptr<TransactionLogIterator>* iter,
-      const TransactionLogIterator::ReadOptions& read_options) override {
-    return db_->GetUpdatesSince(seq_number, iter, read_options);
-  }
-
-  virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
-    return db_->DefaultColumnFamily();
-  }
-
- protected:
-  DB* db_;
-};
-
-} //  namespace rocksdb
@@ -1,30 +0,0 @@
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// 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.
-
-#pragma once
-#ifndef ROCKSDB_LITE
-#include <vector>
-#include <string>
-
-#include "rocksdb/utilities/stackable_db.h"
-#include "rocksdb/utilities/db_ttl.h"
-#include "rocksdb/db.h"
-
-namespace rocksdb {
-
-// Please don't use this class. It's deprecated
-class UtilityDB {
- public:
-  // This function is here only for backwards compatibility. Please use the
-  // functions defined in DBWithTTl (rocksdb/utilities/db_ttl.h)
-  // (deprecated)
-  __attribute__((deprecated)) static Status OpenTtlDB(const Options& options,
-                                                      const std::string& name,
-                                                      StackableDB** dbptr,
-                                                      int32_t ttl = 0,
-                                                      bool read_only = false);
-};
-
-} //  namespace rocksdb
-#endif  // ROCKSDB_LITE
@@ -1,102 +0,0 @@
-// Copyright (c) 2013, 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.
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// 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.
-//
-// A WriteBatchWithIndex with a binary searchable index built for all the keys
-// inserted.
-
-#pragma once
-
-#include "rocksdb/status.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/write_batch.h"
-
-namespace rocksdb {
-
-class ColumnFamilyHandle;
-struct SliceParts;
-class Comparator;
-
-enum WriteType { kPutRecord, kMergeRecord, kDeleteRecord, kLogDataRecord };
-
-// an entry for Put, Merge or Delete entry for write batches. Used in
-// WBWIIterator.
-struct WriteEntry {
-  WriteType type;
-  Slice key;
-  Slice value;
-};
-
-// Iterator of one column family out of a WriteBatchWithIndex.
-class WBWIIterator {
- public:
-  virtual ~WBWIIterator() {}
-
-  virtual bool Valid() const = 0;
-
-  virtual void Seek(const Slice& key) = 0;
-
-  virtual void Next() = 0;
-
-  virtual const WriteEntry& Entry() const = 0;
-
-  virtual Status status() const = 0;
-};
-
-// A WriteBatchWithIndex with a binary searchable index built for all the keys
-// inserted.
-// In Put(), Merge() or Delete(), the same function of the wrapped will be
-// called. At the same time, indexes will be built.
-// By calling GetWriteBatch(), a user will get the WriteBatch for the data
-// they inserted, which can be used for DB::Write().
-// A user can call NewIterator() to create an iterator.
-class WriteBatchWithIndex {
- public:
-  // index_comparator indicates the order when iterating data in the write
-  // batch. Technically, it doesn't have to be the same as the one used in
-  // the DB.
-  // reserved_bytes: reserved bytes in underlying WriteBatch
-  explicit WriteBatchWithIndex(const Comparator* index_comparator,
-                               size_t reserved_bytes = 0);
-  virtual ~WriteBatchWithIndex();
-
-  WriteBatch* GetWriteBatch();
-
-  virtual void Put(ColumnFamilyHandle* column_family, const Slice& key,
-                   const Slice& value);
-
-  virtual void Put(const Slice& key, const Slice& value);
-
-  virtual void Merge(ColumnFamilyHandle* column_family, const Slice& key,
-                     const Slice& value);
-
-  virtual void Merge(const Slice& key, const Slice& value);
-
-  virtual void PutLogData(const Slice& blob);
-
-  virtual void Delete(ColumnFamilyHandle* column_family, const Slice& key);
-  virtual void Delete(const Slice& key);
-
-  virtual void Delete(ColumnFamilyHandle* column_family, const SliceParts& key);
-
-  virtual void Delete(const SliceParts& key);
-
-  // Create an iterator of a column family. User can call iterator.Seek() to
-  // search to the next entry of or after a key. Keys will be iterated in the
-  // order given by index_comparator. For multiple updates on the same key,
-  // each update will be returned as a separate entry, in the order of update
-  // time.
-  virtual WBWIIterator* NewIterator(ColumnFamilyHandle* column_family);
-  // Create an iterator of the default column family.
-  virtual WBWIIterator* NewIterator();
-
- private:
-  struct Rep;
-  Rep* rep;
-};
-
-}  // namespace rocksdb
@@ -6,7 +6,7 @@

 // Also update Makefile if you change these
 #define ROCKSDB_MAJOR 3
-#define ROCKSDB_MINOR 5
+#define ROCKSDB_MINOR 3
 #define ROCKSDB_PATCH 0

 // Do not use these. We made the mistake of declaring macros starting with
@@ -152,7 +152,6 @@ class WriteBatch {
 private:
  friend class WriteBatchInternal;

- protected:
  std::string rep_;  // See comment in write_batch.cc for the format of rep_

  // Intentionally copyable
@@ -8,5 +8,244 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #pragma once
-#warning This file was moved to rocksdb/utilities/backupable_db.h
-#include "rocksdb/utilities/backupable_db.h"
+#ifndef ROCKSDB_LITE
+
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include <string>
+#include <map>
+#include <vector>
+
+#include "utilities/stackable_db.h"
+#include "rocksdb/env.h"
+#include "rocksdb/status.h"
+
+namespace rocksdb {
+
+struct BackupableDBOptions {
+  // Where to keep the backup files. Has to be different than dbname_
+  // Best to set this to dbname_ + "/backups"
+  // Required
+  std::string backup_dir;
+
+  // Backup Env object. It will be used for backup file I/O. If it's
+  // nullptr, backups will be written out using DBs Env. If it's
+  // non-nullptr, backup's I/O will be performed using this object.
+  // If you want to have backups on HDFS, use HDFS Env here!
+  // Default: nullptr
+  Env* backup_env;
+
+  // If share_table_files == true, backup will assume that table files with
+  // same name have the same contents. This enables incremental backups and
+  // avoids unnecessary data copies.
+  // If share_table_files == false, each backup will be on its own and will
+  // not share any data with other backups.
+  // default: true
+  bool share_table_files;
+
+  // Backup info and error messages will be written to info_log
+  // if non-nullptr.
+  // Default: nullptr
+  Logger* info_log;
+
+  // If sync == true, we can guarantee you'll get consistent backup even
+  // on a machine crash/reboot. Backup process is slower with sync enabled.
+  // If sync == false, we don't guarantee anything on machine reboot. However,
+  // chances are some of the backups are consistent.
+  // Default: true
+  bool sync;
+
+  // If true, it will delete whatever backups there are already
+  // Default: false
+  bool destroy_old_data;
+
+  // If false, we won't backup log files. This option can be useful for backing
+  // up in-memory databases where log file are persisted, but table files are in
+  // memory.
+  // Default: true
+  bool backup_log_files;
+
+  // Max bytes that can be transferred in a second during backup.
+  // If 0, go as fast as you can
+  // Default: 0
+  uint64_t backup_rate_limit;
+
+  // Max bytes that can be transferred in a second during restore.
+  // If 0, go as fast as you can
+  // Default: 0
+  uint64_t restore_rate_limit;
+
+  // Only used if share_table_files is set to true. If true, will consider that
+  // backups can come from different databases, hence a sst is not uniquely
+  // identifed by its name, but by the triple (file name, crc32, file length)
+  // Default: false
+  // Note: this is an experimental option, and you'll need to set it manually
+  // *turn it on only if you know what you're doing*
+  bool share_files_with_checksum;
+
+  void Dump(Logger* logger) const;
+
+  explicit BackupableDBOptions(const std::string& _backup_dir,
+                               Env* _backup_env = nullptr,
+                               bool _share_table_files = true,
+                               Logger* _info_log = nullptr, bool _sync = true,
+                               bool _destroy_old_data = false,
+                               bool _backup_log_files = true,
+                               uint64_t _backup_rate_limit = 0,
+                               uint64_t _restore_rate_limit = 0)
+      : backup_dir(_backup_dir),
+        backup_env(_backup_env),
+        share_table_files(_share_table_files),
+        info_log(_info_log),
+        sync(_sync),
+        destroy_old_data(_destroy_old_data),
+        backup_log_files(_backup_log_files),
+        backup_rate_limit(_backup_rate_limit),
+        restore_rate_limit(_restore_rate_limit),
+        share_files_with_checksum(false) {
+    assert(share_table_files || !share_files_with_checksum);
+  }
+};
+
+struct RestoreOptions {
+  // If true, restore won't overwrite the existing log files in wal_dir. It will
+  // also move all log files from archive directory to wal_dir. Use this option
+  // in combination with BackupableDBOptions::backup_log_files = false for
+  // persisting in-memory databases.
+  // Default: false
+  bool keep_log_files;
+
+  explicit RestoreOptions(bool _keep_log_files = false)
+      : keep_log_files(_keep_log_files) {}
+};
+
+typedef uint32_t BackupID;
+
+struct BackupInfo {
+  BackupID backup_id;
+  int64_t timestamp;
+  uint64_t size;
+
+  BackupInfo() {}
+  BackupInfo(BackupID _backup_id, int64_t _timestamp, uint64_t _size)
+      : backup_id(_backup_id), timestamp(_timestamp), size(_size) {}
+};
+
+class BackupEngineReadOnly {
+ public:
+  virtual ~BackupEngineReadOnly() {}
+
+  static BackupEngineReadOnly* NewReadOnlyBackupEngine(
+      Env* db_env, const BackupableDBOptions& options);
+
+  // You can GetBackupInfo safely, even with other BackupEngine performing
+  // backups on the same directory
+  virtual void GetBackupInfo(std::vector<BackupInfo>* backup_info) = 0;
+
+  // Restoring DB from backup is NOT safe when there is another BackupEngine
+  // running that might call DeleteBackup() or PurgeOldBackups(). It is caller's
+  // responsibility to synchronize the operation, i.e. don't delete the backup
+  // when you're restoring from it
+  virtual Status RestoreDBFromBackup(
+      BackupID backup_id, const std::string& db_dir, const std::string& wal_dir,
+      const RestoreOptions& restore_options = RestoreOptions()) = 0;
+  virtual Status RestoreDBFromLatestBackup(
+      const std::string& db_dir, const std::string& wal_dir,
+      const RestoreOptions& restore_options = RestoreOptions()) = 0;
+};
+
+// Please see the documentation in BackupableDB and RestoreBackupableDB
+class BackupEngine {
+ public:
+  virtual ~BackupEngine() {}
+
+  static BackupEngine* NewBackupEngine(Env* db_env,
+                                       const BackupableDBOptions& options);
+
+  virtual Status CreateNewBackup(DB* db, bool flush_before_backup = false) = 0;
+  virtual Status PurgeOldBackups(uint32_t num_backups_to_keep) = 0;
+  virtual Status DeleteBackup(BackupID backup_id) = 0;
+  virtual void StopBackup() = 0;
+
+  virtual void GetBackupInfo(std::vector<BackupInfo>* backup_info) = 0;
+  virtual Status RestoreDBFromBackup(
+      BackupID backup_id, const std::string& db_dir, const std::string& wal_dir,
+      const RestoreOptions& restore_options = RestoreOptions()) = 0;
+  virtual Status RestoreDBFromLatestBackup(
+      const std::string& db_dir, const std::string& wal_dir,
+      const RestoreOptions& restore_options = RestoreOptions()) = 0;
+};
+
+// Stack your DB with BackupableDB to be able to backup the DB
+class BackupableDB : public StackableDB {
+ public:
+  // BackupableDBOptions have to be the same as the ones used in a previous
+  // incarnation of the DB
+  //
+  // BackupableDB ownes the pointer `DB* db` now. You should not delete it or
+  // use it after the invocation of BackupableDB
+  BackupableDB(DB* db, const BackupableDBOptions& options);
+  virtual ~BackupableDB();
+
+  // Captures the state of the database in the latest backup
+  // NOT a thread safe call
+  Status CreateNewBackup(bool flush_before_backup = false);
+  // Returns info about backups in backup_info
+  void GetBackupInfo(std::vector<BackupInfo>* backup_info);
+  // deletes old backups, keeping latest num_backups_to_keep alive
+  Status PurgeOldBackups(uint32_t num_backups_to_keep);
+  // deletes a specific backup
+  Status DeleteBackup(BackupID backup_id);
+  // Call this from another thread if you want to stop the backup
+  // that is currently happening. It will return immediatelly, will
+  // not wait for the backup to stop.
+  // The backup will stop ASAP and the call to CreateNewBackup will
+  // return Status::Incomplete(). It will not clean up after itself, but
+  // the state will remain consistent. The state will be cleaned up
+  // next time you create BackupableDB or RestoreBackupableDB.
+  void StopBackup();
+
+ private:
+  BackupEngine* backup_engine_;
+};
+
+// Use this class to access information about backups and restore from them
+class RestoreBackupableDB {
+ public:
+  RestoreBackupableDB(Env* db_env, const BackupableDBOptions& options);
+  ~RestoreBackupableDB();
+
+  // Returns info about backups in backup_info
+  void GetBackupInfo(std::vector<BackupInfo>* backup_info);
+
+  // restore from backup with backup_id
+  // IMPORTANT -- if options_.share_table_files == true and you restore DB
+  // from some backup that is not the latest, and you start creating new
+  // backups from the new DB, they will probably fail
+  //
+  // Example: Let's say you have backups 1, 2, 3, 4, 5 and you restore 3.
+  // If you add new data to the DB and try creating a new backup now, the
+  // database will diverge from backups 4 and 5 and the new backup will fail.
+  // If you want to create new backup, you will first have to delete backups 4
+  // and 5.
+  Status RestoreDBFromBackup(BackupID backup_id, const std::string& db_dir,
+                             const std::string& wal_dir,
+                             const RestoreOptions& restore_options =
+                                 RestoreOptions());
+
+  // restore from the latest backup
+  Status RestoreDBFromLatestBackup(const std::string& db_dir,
+                                   const std::string& wal_dir,
+                                   const RestoreOptions& restore_options =
+                                       RestoreOptions());
+  // deletes old backups, keeping latest num_backups_to_keep alive
+  Status PurgeOldBackups(uint32_t num_backups_to_keep);
+  // deletes a specific backup
+  Status DeleteBackup(BackupID backup_id);
+
+ private:
+  BackupEngine* backup_engine_;
+};
+
+}  // namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -4,5 +4,65 @@
 //  of patent rights can be found in the PATENTS file in the same directory.

 #pragma once
-#warning This file was moved to rocksdb/utilities/db_ttl.h
-#include "rocksdb/utilities/db_ttl.h"
+#ifndef ROCKSDB_LITE
+
+#include <string>
+#include <vector>
+
+#include "utilities/stackable_db.h"
+#include "rocksdb/db.h"
+
+namespace rocksdb {
+
+// Database with TTL support.
+//
+// USE-CASES:
+// This API should be used to open the db when key-values inserted are
+//  meant to be removed from the db in a non-strict 'ttl' amount of time
+//  Therefore, this guarantees that key-values inserted will remain in the
+//  db for >= ttl amount of time and the db will make efforts to remove the
+//  key-values as soon as possible after ttl seconds of their insertion.
+//
+// BEHAVIOUR:
+// TTL is accepted in seconds
+// (int32_t)Timestamp(creation) is suffixed to values in Put internally
+// Expired TTL values deleted in compaction only:(Timestamp+ttl<time_now)
+// Get/Iterator may return expired entries(compaction not run on them yet)
+// Different TTL may be used during different Opens
+// Example: Open1 at t=0 with ttl=4 and insert k1,k2, close at t=2
+//          Open2 at t=3 with ttl=5. Now k1,k2 should be deleted at t>=5
+// read_only=true opens in the usual read-only mode. Compactions will not be
+//  triggered(neither manual nor automatic), so no expired entries removed
+//
+// CONSTRAINTS:
+// Not specifying/passing or non-positive TTL behaves like TTL = infinity
+//
+// !!!WARNING!!!:
+// Calling DB::Open directly to re-open a db created by this API will get
+//  corrupt values(timestamp suffixed) and no ttl effect will be there
+//  during the second Open, so use this API consistently to open the db
+// Be careful when passing ttl with a small positive value because the
+//  whole database may be deleted in a small amount of time
+
+class DBWithTTL : public StackableDB {
+ public:
+  virtual Status CreateColumnFamilyWithTtl(
+      const ColumnFamilyOptions& options, const std::string& column_family_name,
+      ColumnFamilyHandle** handle, int ttl) = 0;
+
+  static Status Open(const Options& options, const std::string& dbname,
+                     DBWithTTL** dbptr, int32_t ttl = 0,
+                     bool read_only = false);
+
+  static Status Open(const DBOptions& db_options, const std::string& dbname,
+                     const std::vector<ColumnFamilyDescriptor>& column_families,
+                     std::vector<ColumnFamilyHandle*>* handles,
+                     DBWithTTL** dbptr, std::vector<int32_t> ttls,
+                     bool read_only = false);
+
+ protected:
+  explicit DBWithTTL(DB* db) : StackableDB(db) {}
+};
+
+}  // namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -4,5 +4,146 @@
 //  of patent rights can be found in the PATENTS file in the same directory.

 #pragma once
-#warning This file was moved to rocksdb/utilities/document_db.h
-#include "rocksdb/utilities/document_db.h"
+#ifndef ROCKSDB_LITE
+
+#include <string>
+#include <vector>
+
+#include "utilities/stackable_db.h"
+#include "utilities/json_document.h"
+#include "rocksdb/db.h"
+
+namespace rocksdb {
+
+// IMPORTANT: DocumentDB is a work in progress. It is unstable and we might
+// change the API without warning. Talk to RocksDB team before using this in
+// production ;)
+
+// DocumentDB is a layer on top of RocksDB that provides a very simple JSON API.
+// When creating a DB, you specify a list of indexes you want to keep on your
+// data. You can insert a JSON document to the DB, which is automatically
+// indexed. Every document added to the DB needs to have "_id" field which is
+// automatically indexed and is an unique primary key. All other indexes are
+// non-unique.
+
+// NOTE: field names in the JSON are NOT allowed to start with '$' or
+// contain '.'. We don't currently enforce that rule, but will start behaving
+// badly.
+
+// Cursor is what you get as a result of executing query. To get all
+// results from a query, call Next() on a Cursor while  Valid() returns true
+class Cursor {
+ public:
+  Cursor() = default;
+  virtual ~Cursor() {}
+
+  virtual bool Valid() const = 0;
+  virtual void Next() = 0;
+  // Lifecycle of the returned JSONDocument is until the next Next() call
+  virtual const JSONDocument& document() const = 0;
+  virtual Status status() const = 0;
+
+ private:
+  // No copying allowed
+  Cursor(const Cursor&);
+  void operator=(const Cursor&);
+};
+
+struct DocumentDBOptions {
+  int background_threads = 4;
+  uint64_t memtable_size = 128 * 1024 * 1024;    // 128 MB
+  uint64_t cache_size = 1 * 1024 * 1024 * 1024;  // 1 GB
+};
+
+// TODO(icanadi) Add `JSONDocument* info` parameter to all calls that can be
+// used by the caller to get more information about the call execution (number
+// of dropped records, number of updated records, etc.)
+class DocumentDB : public StackableDB {
+ public:
+  struct IndexDescriptor {
+    // Currently, you can only define an index on a single field. To specify an
+    // index on a field X, set index description to JSON "{X: 1}"
+    // Currently the value needs to be 1, which means ascending.
+    // In the future, we plan to also support indexes on multiple keys, where
+    // you could mix ascending sorting (1) with descending sorting indexes (-1)
+    JSONDocument* description;
+    std::string name;
+  };
+
+  // Open DocumentDB with specified indexes. The list of indexes has to be
+  // complete, i.e. include all indexes present in the DB, except the primary
+  // key index.
+  // Otherwise, Open() will return an error
+  static Status Open(const DocumentDBOptions& options, const std::string& name,
+                     const std::vector<IndexDescriptor>& indexes,
+                     DocumentDB** db, bool read_only = false);
+
+  explicit DocumentDB(DB* db) : StackableDB(db) {}
+
+  // Create a new index. It will stop all writes for the duration of the call.
+  // All current documents in the DB are scanned and corresponding index entries
+  // are created
+  virtual Status CreateIndex(const WriteOptions& write_options,
+                             const IndexDescriptor& index) = 0;
+
+  // Drop an index. Client is responsible to make sure that index is not being
+  // used by currently executing queries
+  virtual Status DropIndex(const std::string& name) = 0;
+
+  // Insert a document to the DB. The document needs to have a primary key "_id"
+  // which can either be a string or an integer. Otherwise the write will fail
+  // with InvalidArgument.
+  virtual Status Insert(const WriteOptions& options,
+                        const JSONDocument& document) = 0;
+
+  // Deletes all documents matching a filter atomically
+  virtual Status Remove(const ReadOptions& read_options,
+                        const WriteOptions& write_options,
+                        const JSONDocument& query) = 0;
+
+  // Does this sequence of operations:
+  // 1. Find all documents matching a filter
+  // 2. For all documents, atomically:
+  // 2.1. apply the update operators
+  // 2.2. update the secondary indexes
+  //
+  // Currently only $set update operator is supported.
+  // Syntax is: {$set: {key1: value1, key2: value2, etc...}}
+  // This operator will change a document's key1 field to value1, key2 to
+  // value2, etc. New values will be set even if a document didn't have an entry
+  // for the specified key.
+  //
+  // You can not change a primary key of a document.
+  //
+  // Update example: Update({id: {$gt: 5}, $index: id}, {$set: {enabled: true}})
+  virtual Status Update(const ReadOptions& read_options,
+                        const WriteOptions& write_options,
+                        const JSONDocument& filter,
+                        const JSONDocument& updates) = 0;
+
+  // query has to be an array in which every element is an operator. Currently
+  // only $filter operator is supported. Syntax of $filter operator is:
+  // {$filter: {key1: condition1, key2: condition2, etc.}} where conditions can
+  // be either:
+  // 1) a single value in which case the condition is equality condition, or
+  // 2) a defined operators, like {$gt: 4}, which will match all documents that
+  // have key greater than 4.
+  //
+  // Supported operators are:
+  // 1) $gt -- greater than
+  // 2) $gte -- greater than or equal
+  // 3) $lt -- less than
+  // 4) $lte -- less than or equal
+  // If you want the filter to use an index, you need to specify it like this:
+  // {$filter: {...(conditions)..., $index: index_name}}
+  //
+  // Example query:
+  // * [{$filter: {name: John, age: {$gte: 18}, $index: age}}]
+  // will return all Johns whose age is greater or equal to 18 and it will use
+  // index "age" to satisfy the query.
+  virtual Cursor* Query(const ReadOptions& read_options,
+                        const JSONDocument& query) = 0;
+};
+
+}  // namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -2,7 +2,104 @@
 //  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.
+//

+#ifndef ROCKSDB_LITE
 #pragma once
-#warning This file was moved to rocksdb/utilities/geo_db.h
-#include "rocksdb/utilities/geo_db.h"
+#include <string>
+#include <vector>
+
+#include "utilities/stackable_db.h"
+#include "rocksdb/status.h"
+
+namespace rocksdb {
+
+//
+// Configurable options needed for setting up a Geo database
+//
+struct GeoDBOptions {
+  // Backup info and error messages will be written to info_log
+  // if non-nullptr.
+  // Default: nullptr
+  Logger* info_log;
+
+  explicit GeoDBOptions(Logger* _info_log = nullptr):info_log(_info_log) { }
+};
+
+//
+// A position in the earth's geoid
+//
+class GeoPosition {
+ public:
+  double latitude;
+  double longitude;
+
+  explicit GeoPosition(double la = 0, double lo = 0) :
+    latitude(la), longitude(lo) {
+  }
+};
+
+//
+// Description of an object on the Geoid. It is located by a GPS location,
+// and is identified by the id. The value associated with this object is
+// an opaque string 'value'. Different objects identified by unique id's
+// can have the same gps-location associated with them.
+//
+class GeoObject {
+ public:
+  GeoPosition position;
+  std::string id;
+  std::string value;
+
+  GeoObject() {}
+
+  GeoObject(const GeoPosition& pos, const std::string& i,
+            const std::string& val) :
+    position(pos), id(i), value(val) {
+  }
+};
+
+//
+// Stack your DB with GeoDB to be able to get geo-spatial support
+//
+class GeoDB : public StackableDB {
+ public:
+  // GeoDBOptions have to be the same as the ones used in a previous
+  // incarnation of the DB
+  //
+  // GeoDB owns the pointer `DB* db` now. You should not delete it or
+  // use it after the invocation of GeoDB
+  // GeoDB(DB* db, const GeoDBOptions& options) : StackableDB(db) {}
+  GeoDB(DB* db, const GeoDBOptions& options) : StackableDB(db) {}
+  virtual ~GeoDB() {}
+
+  // Insert a new object into the location database. The object is
+  // uniquely identified by the id. If an object with the same id already
+  // exists in the db, then the old one is overwritten by the new
+  // object being inserted here.
+  virtual Status Insert(const GeoObject& object) = 0;
+
+  // Retrieve the value of the object located at the specified GPS
+  // location and is identified by the 'id'.
+  virtual Status GetByPosition(const GeoPosition& pos,
+                               const Slice& id, std::string* value) = 0;
+
+  // Retrieve the value of the object identified by the 'id'. This method
+  // could be potentially slower than GetByPosition
+  virtual Status GetById(const Slice& id, GeoObject*  object) = 0;
+
+  // Delete the specified object
+  virtual Status Remove(const Slice& id) = 0;
+
+  // Returns a list of all items within a circular radius from the
+  // specified gps location. If 'number_of_values' is specified,
+  // then this call returns at most that many number of objects.
+  // The radius is specified in 'meters'.
+  virtual Status SearchRadial(const GeoPosition& pos,
+                              double radius,
+                              std::vector<GeoObject>* values,
+                              int number_of_values = INT_MAX) = 0;
+};
+
+}  // namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -3,5 +3,172 @@
 //  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.
 #pragma once
-#warning This file was moved to rocksdb/utilities/json_document.h
-#include "rocksdb/utilities/json_document.h"
+#ifndef ROCKSDB_LITE
+
+#include <string>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include "rocksdb/slice.h"
+
+// We use JSONDocument for DocumentDB API
+// Implementation inspired by folly::dynamic and rapidjson
+
+namespace rocksdb {
+
+// NOTE: none of this is thread-safe
+class JSONDocument {
+ public:
+  // return nullptr on parse failure
+  static JSONDocument* ParseJSON(const char* json);
+
+  enum Type {
+    kNull,
+    kArray,
+    kBool,
+    kDouble,
+    kInt64,
+    kObject,
+    kString,
+  };
+
+  JSONDocument();  // null
+  /* implicit */ JSONDocument(bool b);
+  /* implicit */ JSONDocument(double d);
+  /* implicit */ JSONDocument(int64_t i);
+  /* implicit */ JSONDocument(const std::string& s);
+  /* implicit */ JSONDocument(const char* s);
+  // constructs JSONDocument of specific type with default value
+  explicit JSONDocument(Type type);
+
+  // copy constructor
+  JSONDocument(const JSONDocument& json_document);
+
+  ~JSONDocument();
+
+  Type type() const;
+
+  // REQUIRES: IsObject()
+  bool Contains(const std::string& key) const;
+  // Returns nullptr if !Contains()
+  // don't delete the returned pointer
+  // REQUIRES: IsObject()
+  const JSONDocument* Get(const std::string& key) const;
+  // REQUIRES: IsObject()
+  JSONDocument& operator[](const std::string& key);
+  // REQUIRES: IsObject()
+  const JSONDocument& operator[](const std::string& key) const;
+  // returns `this`, so you can chain operations.
+  // Copies value
+  // REQUIRES: IsObject()
+  JSONDocument* Set(const std::string& key, const JSONDocument& value);
+
+  // REQUIRES: IsArray() == true || IsObject() == true
+  size_t Count() const;
+
+  // REQUIRES: IsArray()
+  const JSONDocument* GetFromArray(size_t i) const;
+  // REQUIRES: IsArray()
+  JSONDocument& operator[](size_t i);
+  // REQUIRES: IsArray()
+  const JSONDocument& operator[](size_t i) const;
+  // returns `this`, so you can chain operations.
+  // Copies the value
+  // REQUIRES: IsArray() && i < Count()
+  JSONDocument* SetInArray(size_t i, const JSONDocument& value);
+  // REQUIRES: IsArray()
+  JSONDocument* PushBack(const JSONDocument& value);
+
+  bool IsNull() const;
+  bool IsArray() const;
+  bool IsBool() const;
+  bool IsDouble() const;
+  bool IsInt64() const;
+  bool IsObject() const;
+  bool IsString() const;
+
+  // REQUIRES: IsBool() == true
+  bool GetBool() const;
+  // REQUIRES: IsDouble() == true
+  double GetDouble() const;
+  // REQUIRES: IsInt64() == true
+  int64_t GetInt64() const;
+  // REQUIRES: IsString() == true
+  const std::string& GetString() const;
+
+  bool operator==(const JSONDocument& rhs) const;
+
+  std::string DebugString() const;
+
+ private:
+  class ItemsIteratorGenerator;
+
+ public:
+  // REQUIRES: IsObject()
+  ItemsIteratorGenerator Items() const;
+
+  // appends serialized object to dst
+  void Serialize(std::string* dst) const;
+  // returns nullptr if Slice doesn't represent valid serialized JSONDocument
+  static JSONDocument* Deserialize(const Slice& src);
+
+ private:
+  void SerializeInternal(std::string* dst, bool type_prefix) const;
+  // returns false if Slice doesn't represent valid serialized JSONDocument.
+  // Otherwise, true
+  bool DeserializeInternal(Slice* input);
+
+  typedef std::vector<JSONDocument*> Array;
+  typedef std::unordered_map<std::string, JSONDocument*> Object;
+
+  // iteration on objects
+  class const_item_iterator {
+   public:
+    typedef Object::const_iterator It;
+    typedef Object::value_type value_type;
+    /* implicit */ const_item_iterator(It it) : it_(it) {}
+    It& operator++() { return ++it_; }
+    bool operator!=(const const_item_iterator& other) {
+      return it_ != other.it_;
+    }
+    value_type operator*() { return *it_; }
+
+   private:
+    It it_;
+  };
+  class ItemsIteratorGenerator {
+   public:
+    /* implicit */ ItemsIteratorGenerator(const Object& object)
+        : object_(object) {}
+    const_item_iterator begin() { return object_.begin(); }
+    const_item_iterator end() { return object_.end(); }
+
+   private:
+    const Object& object_;
+  };
+
+  union Data {
+    Data() : n(nullptr) {}
+    ~Data() {}
+
+    void* n;
+    Array a;
+    bool b;
+    double d;
+    int64_t i;
+    std::string s;
+    Object o;
+  } data_;
+  const Type type_;
+
+  // Our serialization format's first byte specifies the encoding version. That
+  // way, we can easily change our format while providing backwards
+  // compatibility. This constant specifies the current version of the
+  // serialization format
+  static const char kSerializationFormatVersion;
+};
+
+}  // namespace rocksdb
+
+#endif  // ROCKSDB_LITE
@@ -3,5 +3,218 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #pragma once
-#warning This file was moved to rocksdb/utilities/stackable_db.h
-#include "rocksdb/utilities/stackable_db.h"
+#include "rocksdb/db.h"
+
+namespace rocksdb {
+
+// This class contains APIs to stack rocksdb wrappers.Eg. Stack TTL over base d
+class StackableDB : public DB {
+ public:
+  // StackableDB is the owner of db now!
+  explicit StackableDB(DB* db) : db_(db) {}
+
+  ~StackableDB() {
+    delete db_;
+  }
+
+  virtual DB* GetBaseDB() {
+    return db_;
+  }
+
+  virtual Status CreateColumnFamily(const ColumnFamilyOptions& options,
+                                    const std::string& column_family_name,
+                                    ColumnFamilyHandle** handle) {
+    return db_->CreateColumnFamily(options, column_family_name, handle);
+  }
+
+  virtual Status DropColumnFamily(ColumnFamilyHandle* column_family) {
+    return db_->DropColumnFamily(column_family);
+  }
+
+  using DB::Put;
+  virtual Status Put(const WriteOptions& options,
+                     ColumnFamilyHandle* column_family, const Slice& key,
+                     const Slice& val) override {
+    return db_->Put(options, column_family, key, val);
+  }
+
+  using DB::Get;
+  virtual Status Get(const ReadOptions& options,
+                     ColumnFamilyHandle* column_family, const Slice& key,
+                     std::string* value) override {
+    return db_->Get(options, column_family, key, value);
+  }
+
+  using DB::MultiGet;
+  virtual std::vector<Status> MultiGet(
+      const ReadOptions& options,
+      const std::vector<ColumnFamilyHandle*>& column_family,
+      const std::vector<Slice>& keys,
+      std::vector<std::string>* values) override {
+    return db_->MultiGet(options, column_family, keys, values);
+  }
+
+  using DB::KeyMayExist;
+  virtual bool KeyMayExist(const ReadOptions& options,
+                           ColumnFamilyHandle* column_family, const Slice& key,
+                           std::string* value,
+                           bool* value_found = nullptr) override {
+    return db_->KeyMayExist(options, column_family, key, value, value_found);
+  }
+
+  using DB::Delete;
+  virtual Status Delete(const WriteOptions& wopts,
+                        ColumnFamilyHandle* column_family,
+                        const Slice& key) override {
+    return db_->Delete(wopts, column_family, key);
+  }
+
+  using DB::Merge;
+  virtual Status Merge(const WriteOptions& options,
+                       ColumnFamilyHandle* column_family, const Slice& key,
+                       const Slice& value) override {
+    return db_->Merge(options, column_family, key, value);
+  }
+
+
+  virtual Status Write(const WriteOptions& opts, WriteBatch* updates)
+    override {
+      return db_->Write(opts, updates);
+  }
+
+  using DB::NewIterator;
+  virtual Iterator* NewIterator(const ReadOptions& opts,
+                                ColumnFamilyHandle* column_family) override {
+    return db_->NewIterator(opts, column_family);
+  }
+
+  virtual Status NewIterators(
+      const ReadOptions& options,
+      const std::vector<ColumnFamilyHandle*>& column_families,
+      std::vector<Iterator*>* iterators) {
+    return db_->NewIterators(options, column_families, iterators);
+  }
+
+
+  virtual const Snapshot* GetSnapshot() override {
+    return db_->GetSnapshot();
+  }
+
+  virtual void ReleaseSnapshot(const Snapshot* snapshot) override {
+    return db_->ReleaseSnapshot(snapshot);
+  }
+
+  using DB::GetProperty;
+  virtual bool GetProperty(ColumnFamilyHandle* column_family,
+                           const Slice& property, std::string* value) override {
+      return db_->GetProperty(column_family, property, value);
+  }
+
+  using DB::GetApproximateSizes;
+  virtual void GetApproximateSizes(ColumnFamilyHandle* column_family,
+                                   const Range* r, int n,
+                                   uint64_t* sizes) override {
+      return db_->GetApproximateSizes(column_family, r, n, sizes);
+  }
+
+  using DB::CompactRange;
+  virtual Status CompactRange(ColumnFamilyHandle* column_family,
+                              const Slice* begin, const Slice* end,
+                              bool reduce_level = false,
+                              int target_level = -1) override {
+    return db_->CompactRange(column_family, begin, end, reduce_level,
+                             target_level);
+  }
+
+  using DB::NumberLevels;
+  virtual int NumberLevels(ColumnFamilyHandle* column_family) override {
+    return db_->NumberLevels(column_family);
+  }
+
+  using DB::MaxMemCompactionLevel;
+  virtual int MaxMemCompactionLevel(ColumnFamilyHandle* column_family)
+      override {
+    return db_->MaxMemCompactionLevel(column_family);
+  }
+
+  using DB::Level0StopWriteTrigger;
+  virtual int Level0StopWriteTrigger(ColumnFamilyHandle* column_family)
+      override {
+    return db_->Level0StopWriteTrigger(column_family);
+  }
+
+  virtual const std::string& GetName() const override {
+    return db_->GetName();
+  }
+
+  virtual Env* GetEnv() const override {
+    return db_->GetEnv();
+  }
+
+  using DB::GetOptions;
+  virtual const Options& GetOptions(ColumnFamilyHandle* column_family) const
+      override {
+    return db_->GetOptions(column_family);
+  }
+
+  using DB::Flush;
+  virtual Status Flush(const FlushOptions& fopts,
+                       ColumnFamilyHandle* column_family) override {
+    return db_->Flush(fopts, column_family);
+  }
+
+  virtual Status DisableFileDeletions() override {
+    return db_->DisableFileDeletions();
+  }
+
+  virtual Status EnableFileDeletions(bool force) override {
+    return db_->EnableFileDeletions(force);
+  }
+
+  virtual void GetLiveFilesMetaData(
+      std::vector<LiveFileMetaData>* metadata) override {
+    db_->GetLiveFilesMetaData(metadata);
+  }
+
+  virtual Status GetLiveFiles(std::vector<std::string>& vec, uint64_t* mfs,
+                              bool flush_memtable = true) override {
+      return db_->GetLiveFiles(vec, mfs, flush_memtable);
+  }
+
+  virtual SequenceNumber GetLatestSequenceNumber() const override {
+    return db_->GetLatestSequenceNumber();
+  }
+
+  virtual Status GetSortedWalFiles(VectorLogPtr& files) override {
+    return db_->GetSortedWalFiles(files);
+  }
+
+  virtual Status DeleteFile(std::string name) override {
+    return db_->DeleteFile(name);
+  }
+
+  virtual Status GetDbIdentity(std::string& identity) {
+    return db_->GetDbIdentity(identity);
+  }
+
+  using DB::GetPropertiesOfAllTables;
+  virtual Status GetPropertiesOfAllTables(ColumnFamilyHandle* column_family,
+                                          TablePropertiesCollection* props) {
+    return db_->GetPropertiesOfAllTables(column_family, props);
+  }
+
+  virtual Status GetUpdatesSince(
+      SequenceNumber seq_number, unique_ptr<TransactionLogIterator>* iter,
+      const TransactionLogIterator::ReadOptions& read_options) override {
+    return db_->GetUpdatesSince(seq_number, iter, read_options);
+  }
+
+  virtual ColumnFamilyHandle* DefaultColumnFamily() const override {
+    return db_->DefaultColumnFamily();
+  }
+
+ protected:
+  DB* db_;
+};
+
+} //  namespace rocksdb
@@ -3,5 +3,28 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.

 #pragma once
-#warning This file was moved to rocksdb/utilities/utility_db.h
-#include "rocksdb/utilities/utility_db.h"
+#ifndef ROCKSDB_LITE
+#include <vector>
+#include <string>
+
+#include "utilities/stackable_db.h"
+#include "utilities/db_ttl.h"
+#include "rocksdb/db.h"
+
+namespace rocksdb {
+
+// Please don't use this class. It's deprecated
+class UtilityDB {
+ public:
+  // This function is here only for backwards compatibility. Please use the
+  // functions defined in DBWithTTl (utilities/db_ttl.h)
+  // (deprecated)
+  __attribute__((deprecated)) static Status OpenTtlDB(const Options& options,
+                                                      const std::string& name,
+                                                      StackableDB** dbptr,
+                                                      int32_t ttl = 0,
+                                                      bool read_only = false);
+};
+
+} //  namespace rocksdb
+#endif  // ROCKSDB_LITE
@@ -1,8 +1,13 @@
-NATIVE_JAVA_CLASSES = org.rocksdb.RocksDB org.rocksdb.Options org.rocksdb.WriteBatch org.rocksdb.WriteBatchInternal org.rocksdb.WriteBatchTest org.rocksdb.WriteOptions org.rocksdb.BackupableDB org.rocksdb.BackupableDBOptions org.rocksdb.Statistics org.rocksdb.RocksIterator org.rocksdb.VectorMemTableConfig org.rocksdb.SkipListMemTableConfig org.rocksdb.HashLinkedListMemTableConfig org.rocksdb.HashSkipListMemTableConfig org.rocksdb.PlainTableConfig org.rocksdb.BlockBasedTableConfig org.rocksdb.ReadOptions org.rocksdb.Filter org.rocksdb.BloomFilter org.rocksdb.RestoreOptions org.rocksdb.RestoreBackupableDB org.rocksdb.RocksEnv
+NATIVE_JAVA_CLASSES = org.rocksdb.RocksDB org.rocksdb.Options org.rocksdb.WriteBatch org.rocksdb.WriteBatchInternal org.rocksdb.WriteBatchTest org.rocksdb.WriteOptions org.rocksdb.BackupableDB org.rocksdb.BackupableDBOptions org.rocksdb.Statistics org.rocksdb.RocksIterator org.rocksdb.VectorMemTableConfig org.rocksdb.SkipListMemTableConfig org.rocksdb.HashLinkedListMemTableConfig org.rocksdb.HashSkipListMemTableConfig org.rocksdb.PlainTableConfig org.rocksdb.ReadOptions org.rocksdb.Filter org.rocksdb.BloomFilter org.rocksdb.RestoreOptions org.rocksdb.RestoreBackupableDB org.rocksdb.RocksEnv

 NATIVE_INCLUDE = ./include
 ROCKSDB_JAR = rocksdbjni.jar

+ROCKSDBJNILIB = ./librocksdbjni.so
+ifeq ($(PLATFORM), OS_MACOSX)
+  ROCKSDBJNILIB = ./librocksdbjni.jnilib
+endif
+
 clean:
 	-find . -name "*.class" -exec rm {} \;
 	-find . -name "hs*.log" -exec rm {} \;
@@ -11,6 +16,7 @@ clean:
 java:
 	javac org/rocksdb/util/*.java org/rocksdb/*.java
 	@cp ../HISTORY.md ./HISTORY-CPP.md
+	jar -cf $(ROCKSDB_JAR) org/rocksdb/*.class org/rocksdb/util/*.class HISTORY*.md $(ROCKSDBJNILIB)
 	@rm -f ./HISTORY-CPP.md
 	javah -d $(NATIVE_INCLUDE) -jni $(NATIVE_JAVA_CLASSES)

@@ -35,21 +35,25 @@ public class RocksDBSample {
      assert(db == null);
    }

+    Filter filter = new BloomFilter(10);
    options.setCreateIfMissing(true)
        .createStatistics()
        .setWriteBufferSize(8 * SizeUnit.KB)
        .setMaxWriteBufferNumber(3)
+        .setDisableSeekCompaction(true)
+        .setBlockSize(64 * SizeUnit.KB)
        .setMaxBackgroundCompactions(10)
-        .setCompressionType(CompressionType.SNAPPY_COMPRESSION)
-        .setCompactionStyle(CompactionStyle.UNIVERSAL);
+        .setFilter(filter)
+        .setCompressionType(CompressionType.SNAPPY_COMPRESSION);
    Statistics stats = options.statisticsPtr();

    assert(options.createIfMissing() == true);
    assert(options.writeBufferSize() == 8 * SizeUnit.KB);
    assert(options.maxWriteBufferNumber() == 3);
+    assert(options.disableSeekCompaction() == true);
+    assert(options.blockSize() == 64 * SizeUnit.KB);
    assert(options.maxBackgroundCompactions() == 10);
    assert(options.compressionType() == CompressionType.SNAPPY_COMPRESSION);
-    assert(options.compactionStyle() == CompactionStyle.UNIVERSAL);

    assert(options.memTableFactoryName().equals("SkipListFactory"));
    options.setMemTableConfig(
@@ -74,15 +78,6 @@ public class RocksDBSample {
    options.setTableFormatConfig(new PlainTableConfig());
    assert(options.tableFactoryName().equals("PlainTable"));

-    BlockBasedTableConfig table_options = new BlockBasedTableConfig();
-    table_options.setBlockCacheSize(64 * SizeUnit.KB)
-                 .setFilterBitsPerKey(10)
-                 .setCacheNumShardBits(6);
-    assert(table_options.blockCacheSize() == 64 * SizeUnit.KB);
-    assert(table_options.cacheNumShardBits() == 6);
-    options.setTableFormatConfig(table_options);
-    assert(options.tableFactoryName().equals("BlockBasedTable"));
-
    try {
      db = RocksDB.open(options, db_path_not_found);
      db.put("hello".getBytes(), "world".getBytes());
@@ -255,5 +250,6 @@ public class RocksDBSample {
    // be sure to dispose c++ pointers
    options.dispose();
    readOptions.dispose();
+    filter.dispose();
  }
 }
@@ -47,15 +47,6 @@ public class BackupableDB extends RocksDB {
  public void createNewBackup(boolean flushBeforeBackup) {
    createNewBackup(nativeHandle_, flushBeforeBackup);
  }
-  
-  /**
-   * Deletes old backups, keeping latest numBackupsToKeep alive.
-   * 
-   * @param numBackupsToKeep Number of latest backups to keep.
-   */
-  public void purgeOldBackups(int numBackupsToKeep) {
-    purgeOldBackups(nativeHandle_, numBackupsToKeep);
-  }


  /**
@@ -86,5 +77,4 @@ public class BackupableDB extends RocksDB {

  protected native void open(long rocksDBHandle, long backupDBOptionsHandle);
  protected native void createNewBackup(long handle, boolean flag);
-  protected native void purgeOldBackups(long handle, int numBackupsToKeep);
 }
@@ -1,210 +0,0 @@
-// 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;
-
-/**
- * The config for plain table sst format.
- *
- * BlockBasedTable is a RocksDB's default SST file format.
- */
-public class BlockBasedTableConfig extends TableFormatConfig {
-
-  public BlockBasedTableConfig() {
-    noBlockCache_ = false;
-    blockCacheSize_ = 8 * 1024 * 1024;
-    blockSize_ =  4 * 1024;
-    blockSizeDeviation_ =10;
-    blockRestartInterval_ =16;
-    wholeKeyFiltering_ = true;
-    bitsPerKey_ = 0;
-  }
-
-  /**
-   * Disable block cache. If this is set to true,
-   * then no block cache should be used, and the block_cache should
-   * point to a nullptr object.
-   * Default: false
-   *
-   * @param noBlockCache if use block cache
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setNoBlockCache(boolean noBlockCache) {
-    noBlockCache_ = noBlockCache;
-    return this;
-  }
-
-  /**
-   * @return if block cache is disabled
-   */
-  public boolean noBlockCache() {
-    return noBlockCache_;
-  }
-
-  /**
-   * Set the amount of cache in bytes that will be used by RocksDB.
-   * If cacheSize is non-positive, then cache will not be used.
-   * DEFAULT: 8M
-   *
-   * @param blockCacheSize block cache size in bytes
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setBlockCacheSize(long blockCacheSize) {
-    blockCacheSize_ = blockCacheSize;
-    return this;
-  }
-
-  /**
-   * @return block cache size in bytes
-   */
-  public long blockCacheSize() {
-    return blockCacheSize_;
-  }
-
-  /**
-   * Controls the number of shards for the block cache.
-   * This is applied only if cacheSize is set to non-negative.
-   *
-   * @param numShardBits the number of shard bits.  The resulting
-   *     number of shards would be 2 ^ numShardBits.  Any negative
-   *     number means use default settings."
-   * @return the reference to the current option.
-   */
-  public BlockBasedTableConfig setCacheNumShardBits(int numShardBits) {
-    numShardBits_ = numShardBits;
-    return this;
-  }
-
-  /**
-   * Returns the number of shard bits used in the block cache.
-   * The resulting number of shards would be 2 ^ (returned value).
-   * Any negative number means use default settings.
-   *
-   * @return the number of shard bits used in the block cache.
-   */
-  public int cacheNumShardBits() {
-    return numShardBits_;
-  }
-
-  /**
-   * 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
-   *
-   * @param blockSize block size in bytes
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setBlockSize(long blockSize) {
-    blockSize_ = blockSize;
-    return this;
-  }
-
-  /**
-   * @return block size in bytes
-   */
-  public long blockSize() {
-    return blockSize_;
-  }
-
-  /**
-   * This is used to close a block before it reaches the configured
-   * 'block_size'. If the percentage of free space in the current block is less
-   * than this specified number and adding a new record to the block will
-   * exceed the configured block size, then this block will be closed and the
-   * new record will be written to the next block.
-   * Default is 10.
-   *
-   * @param blockSizeDeviation the deviation to block size allowed
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setBlockSizeDeviation(int blockSizeDeviation) {
-    blockSizeDeviation_ = blockSizeDeviation;
-    return this;
-  }
-
-  /**
-   * @return the hash table ratio.
-   */
-  public int blockSizeDeviation() {
-    return blockSizeDeviation_;
-  }
-
-  /**
-   * Set block restart interval
-   *
-   * @param restartInterval block restart interval.
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setBlockRestartInterval(int restartInterval) {
-    blockRestartInterval_ = restartInterval;
-    return this;
-  }
-
-  /**
-   * @return block restart interval
-   */
-  public int blockRestartInterval() {
-    return blockRestartInterval_;
-  }
-
-  /**
-   * If true, place whole keys in the filter (not just prefixes).
-   * This must generally be true for gets to be efficient.
-   * Default: true
-   *
-   * @param wholeKeyFiltering if enable whole key filtering
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setWholeKeyFiltering(boolean wholeKeyFiltering) {
-    wholeKeyFiltering_ = wholeKeyFiltering;
-    return this;
-  }
-
-  /**
-   * @return if whole key filtering is enabled
-   */
-  public boolean wholeKeyFiltering() {
-    return wholeKeyFiltering_;
-  }
-
-  /**
-   * Use the specified filter policy to reduce disk reads.
-   *
-   * Filter should not be disposed before options instances using this filter is
-   * disposed. If dispose() function is not called, then filter object will be
-   * GC'd automatically.
-   *
-   * Filter instance can be re-used in multiple options instances.
-   *
-   * @param Filter policy java instance.
-   * @return the reference to the current config.
-   */
-  public BlockBasedTableConfig setFilterBitsPerKey(int bitsPerKey) {
-    bitsPerKey_ = bitsPerKey;
-    return this;
-  }
-
-  @Override protected long newTableFactoryHandle() {
-    return newTableFactoryHandle(noBlockCache_, blockCacheSize_, numShardBits_,
-        blockSize_, blockSizeDeviation_, blockRestartInterval_,
-        wholeKeyFiltering_, bitsPerKey_);
-  }
-
-  private native long newTableFactoryHandle(
-      boolean noBlockCache, long blockCacheSize, int numShardbits,
-      long blockSize, int blockSizeDeviation, int blockRestartInterval,
-      boolean wholeKeyFiltering, int bitsPerKey);
-
-  private boolean noBlockCache_;
-  private long blockCacheSize_;
-  private int numShardBits_;
-  private long shard;
-  private long blockSize_;
-  private int blockSizeDeviation_;
-  private int blockRestartInterval_;
-  private boolean wholeKeyFiltering_;
-  private int bitsPerKey_;
-}
@@ -1,22 +0,0 @@
-// 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;
-
-public enum CompactionStyle {
-  LEVEL((byte) 0),
-  UNIVERSAL((byte) 1),
-  FIFO((byte) 2);
-  
-  private final byte value_;
-
-  private CompactionStyle(byte value) {
-    value_ = value;
-  }
-
-  public byte getValue() {
-    return value_;
-  }
-}
@@ -9,12 +9,11 @@ package org.rocksdb;
 * Options to control the behavior of a database.  It will be used
 * during the creation of a RocksDB (i.e., RocksDB.open()).
 *
- * If dispose() function is not called, then it will be GC'd automatically and
- * native resources will be released as part of the process.
+ * Note that dispose() must be called before an Options instance
+ * become out-of-scope to release the allocated memory in c++.
 */
 public class Options extends RocksObject {
  static final long DEFAULT_CACHE_SIZE = 8 << 20;
-  static final int DEFAULT_NUM_SHARD_BITS = -1;
  /**
   * Construct options for opening a RocksDB.
   *
@@ -24,7 +23,6 @@ public class Options extends RocksObject {
  public Options() {
    super();
    cacheSize_ = DEFAULT_CACHE_SIZE;
-    numShardBits_ = DEFAULT_NUM_SHARD_BITS;
    newOptions();
    env_ = RocksEnv.getDefault();
  }
@@ -136,6 +134,100 @@ public class Options extends RocksObject {
    return maxWriteBufferNumber(nativeHandle_);
  }

+  /*
+   * 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
+   *
+   * @param blockSize the size of each block in bytes.
+   * @return the instance of the current Options.
+   * @see RocksDB.open()
+   */
+  public Options setBlockSize(long blockSize) {
+    assert(isInitialized());
+    setBlockSize(nativeHandle_, blockSize);
+    return this;
+  }
+
+  /*
+   * Returns the size of a block in bytes.
+   *
+   * @return block size.
+   * @see setBlockSize()
+   */
+  public long blockSize() {
+    assert(isInitialized());
+    return blockSize(nativeHandle_);
+  }
+
+  /**
+   * Use the specified filter policy to reduce disk reads.
+   *
+   * Note that the caller should not dispose the input filter as
+   * Options.dispose() will dispose this filter.
+   *
+   * @param Filter policy java instance.
+   * @return the instance of the current Options.
+   * @see RocksDB.open()
+   */
+  public Options setFilter(Filter filter) {
+    assert(isInitialized());
+    setFilterHandle(nativeHandle_, filter.nativeHandle_);
+    filter_ = filter;
+    return this;
+  }
+  private native void setFilterHandle(long optHandle, long filterHandle);
+
+  /*
+   * Disable compaction triggered by seek.
+   * With bloomfilter and fast storage, a miss on one level
+   * is very cheap if the file handle is cached in table cache
+   * (which is true if max_open_files is large).
+   * Default: true
+   *
+   * @param disableSeekCompaction a boolean value to specify whether
+   *     to disable seek compaction.
+   * @return the instance of the current Options.
+   * @see RocksDB.open()
+   */
+  public Options setDisableSeekCompaction(boolean disableSeekCompaction) {
+    assert(isInitialized());
+    setDisableSeekCompaction(nativeHandle_, disableSeekCompaction);
+    return this;
+  }
+
+  /*
+   * Returns true if disable seek compaction is set to true.
+   *
+   * @return true if disable seek compaction is set to true.
+   * @see setDisableSeekCompaction()
+   */
+  public boolean disableSeekCompaction() {
+    assert(isInitialized());
+    return disableSeekCompaction(nativeHandle_);
+  }
+
+  /**
+   * Set the amount of cache in bytes that will be used by RocksDB.
+   * If cacheSize is non-positive, then cache will not be used.
+   *
+   * DEFAULT: 8M
+   */
+  public Options setCacheSize(long cacheSize) {
+    cacheSize_ = cacheSize;
+    return this;
+  }
+
+  /**
+   * @return the amount of cache in bytes that will be used by RocksDB.
+   */
+  public long cacheSize() {
+    return cacheSize_;
+  }
+
  /**
   * If true, an error will be thrown during RocksDB.open() if the
   * database already exists.
@@ -1215,26 +1307,26 @@ public class Options extends RocksObject {
  }
  private native void setBlockRestartInterval(
      long handle, int blockRestartInterval);
-
+      
  /**
   * Compress blocks using the specified compression algorithm.  This
     parameter can be changed dynamically.
-   *
+   * 
   * Default: SNAPPY_COMPRESSION, which gives lightweight but fast compression.
-   *
+   * 
   * @return Compression type.
-   */
+   */ 
  public CompressionType compressionType() {
    return CompressionType.values()[compressionType(nativeHandle_)];
  }
  private native byte compressionType(long handle);
-
+      
  /**
   * Compress blocks using the specified compression algorithm.  This
     parameter can be changed dynamically.
-   *
+   * 
   * Default: SNAPPY_COMPRESSION, which gives lightweight but fast compression.
-   *
+   * 
   * @param compressionType Compression Type.
   * @return the reference to the current option.
   */
@@ -1244,29 +1336,32 @@ public class Options extends RocksObject {
  }
  private native void setCompressionType(long handle, byte compressionType);

-   /**
-   * Compaction style for DB.
+  /**
+   * If true, place whole keys in the filter (not just prefixes).
+   * This must generally be true for gets to be efficient.
+   * Default: true
   *
-   * @return Compaction style.
+   * @return if true, then whole-key-filtering is on.
   */
-  public CompactionStyle compactionStyle() {
-    return CompactionStyle.values()[compactionStyle(nativeHandle_)];
+  public boolean wholeKeyFiltering() {
+    return wholeKeyFiltering(nativeHandle_);
  }
-  private native byte compactionStyle(long handle);
+  private native boolean wholeKeyFiltering(long handle);

  /**
-   * Set compaction style for DB.
+   * If true, place whole keys in the filter (not just prefixes).
+   * This must generally be true for gets to be efficient.
+   * Default: true
   *
-   * Default: LEVEL.
-   *
-   * @param compactionStyle Compaction style.
+   * @param wholeKeyFiltering if true, then whole-key-filtering is on.
   * @return the reference to the current option.
   */
-  public Options setCompactionStyle(CompactionStyle compactionStyle) {
-    setCompactionStyle(nativeHandle_, compactionStyle.getValue());
+  public Options setWholeKeyFiltering(boolean wholeKeyFiltering) {
+    setWholeKeyFiltering(nativeHandle_, wholeKeyFiltering);
    return this;
  }
-  private native void setCompactionStyle(long handle, byte compactionStyle);
+  private native void setWholeKeyFiltering(
+      long handle, boolean wholeKeyFiltering);

  /**
   * If level-styled compaction is used, then this number determines
@@ -1741,6 +1836,35 @@ public class Options extends RocksObject {
  private native void setRateLimitDelayMaxMilliseconds(
      long handle, int rateLimitDelayMaxMilliseconds);

+  /**
+   * Disable block cache. If this is set to true,
+   * then no block cache should be used, and the block_cache should
+   * point to a nullptr object.
+   * Default: false
+   *
+   * @return true if block cache is disabled.
+   */
+  public boolean noBlockCache() {
+    return noBlockCache(nativeHandle_);
+  }
+  private native boolean noBlockCache(long handle);
+
+  /**
+   * Disable block cache. If this is set to true,
+   * then no block cache should be used, and the block_cache should
+   * point to a nullptr object.
+   * Default: false
+   *
+   * @param noBlockCache true if block-cache is disabled.
+   * @return the reference to the current option.
+   */
+  public Options setNoBlockCache(boolean noBlockCache) {
+    setNoBlockCache(nativeHandle_, noBlockCache);
+    return this;
+  }
+  private native void setNoBlockCache(
+      long handle, boolean noBlockCache);
+
  /**
   * The size of one block in arena memory allocation.
   * If <= 0, a proper value is automatically calculated (usually 1/10 of
@@ -1838,6 +1962,39 @@ public class Options extends RocksObject {
  private native void setPurgeRedundantKvsWhileFlush(
      long handle, boolean purgeRedundantKvsWhileFlush);

+  /**
+   * This is used to close a block before it reaches the configured
+   * 'block_size'. If the percentage of free space in the current block is less
+   * than this specified number and adding a new record to the block will
+   * exceed the configured block size, then this block will be closed and the
+   * new record will be written to the next block.
+   * Default is 10.
+   *
+   * @return the target block size
+   */
+  public int blockSizeDeviation() {
+    return blockSizeDeviation(nativeHandle_);
+  }
+  private native int blockSizeDeviation(long handle);
+
+  /**
+   * This is used to close a block before it reaches the configured
+   * 'block_size'. If the percentage of free space in the current block is less
+   * than this specified number and adding a new record to the block will
+   * exceed the configured block size, then this block will be closed and the
+   * new record will be written to the next block.
+   * Default is 10.
+   *
+   * @param blockSizeDeviation the target block size
+   * @return the reference to the current option.
+   */
+  public Options setBlockSizeDeviation(int blockSizeDeviation) {
+    setBlockSizeDeviation(nativeHandle_, blockSizeDeviation);
+    return this;
+  }
+  private native void setBlockSizeDeviation(
+      long handle, int blockSizeDeviation);
+
  /**
   * If true, compaction will verify checksum on every read that happens
   * as part of compaction
@@ -2219,6 +2376,11 @@ public class Options extends RocksObject {
  private native void setMaxWriteBufferNumber(
      long handle, int maxWriteBufferNumber);
  private native int maxWriteBufferNumber(long handle);
+  private native void setBlockSize(long handle, long blockSize);
+  private native long blockSize(long handle);
+  private native void setDisableSeekCompaction(
+      long handle, boolean disableSeekCompaction);
+  private native boolean disableSeekCompaction(long handle);
  private native void setMaxBackgroundCompactions(
      long handle, int maxBackgroundCompactions);
  private native int maxBackgroundCompactions(long handle);
@@ -2235,6 +2397,6 @@ public class Options extends RocksObject {
      long handle, int prefixLength);

  long cacheSize_;
-  int numShardBits_;
+  Filter filter_;
  RocksEnv env_;
 }
@@ -99,15 +99,6 @@ public class RocksDB extends RocksObject {
  /**
   * The factory constructor of RocksDB that opens a RocksDB instance given
   * the path to the database using the specified options and db path.
-   *
-   * Options instance *should* not be disposed before all DBs using this options
-   * instance have been closed. If user doesn't call options dispose explicitly,
-   * then this options instance will be GC'd automatically.
-   *
-   * Options instance can be re-used to open multiple DBs if DB statistics is
-   * not used. If DB statistics are required, then its recommended to open DB
-   * with new Options instance as underlying native statistics instance does not
-   * use any locks to prevent concurrent updates.
   */
  public static RocksDB open(Options options, String path)
      throws RocksDBException {
@@ -115,16 +106,11 @@ public class RocksDB extends RocksObject {
    // in RocksDB can prevent Java to GC during the life-time of
    // the currently-created RocksDB.
    RocksDB db = new RocksDB();
-    db.open(options.nativeHandle_, path);
-
-    db.storeOptionsInstance(options);
+    db.open(options.nativeHandle_, options.cacheSize_, path);
+    db.transferCppRawPointersOwnershipFrom(options);
    return db;
  }

-  private void storeOptionsInstance(Options options) {
-    options_ = options;
-  }
-
  @Override protected void disposeInternal() {
    assert(isInitialized());
    disposeInternal(nativeHandle_);
@@ -331,9 +317,20 @@ public class RocksDB extends RocksObject {
    super();
  }

+  /**
+   * Transfer the ownership of all c++ raw-pointers from Options
+   * to RocksDB to ensure the life-time of those raw-pointers
+   * will be at least as long as the life-time of any RocksDB
+   * that uses these raw-pointers.
+   */
+  protected void transferCppRawPointersOwnershipFrom(Options opt) {
+    filter_ = opt.filter_;
+    opt.filter_ = null;
+  }
+
  // native methods
  protected native void open(
-      long optionsHandle, String path) throws RocksDBException;
+      long optionsHandle, long cacheSize, String path) throws RocksDBException;
  protected native void put(
      long handle, byte[] key, int keyLen,
      byte[] value, int valueLen) throws RocksDBException;
@@ -366,5 +363,5 @@ public class RocksDB extends RocksObject {
  protected native long iterator0(long optHandle);
  private native void disposeInternal(long handle);

-  protected Options options_;
+  protected Filter filter_;
 }
Author	SHA1	Message	Date
sdong	92df749a96	An odd fix for GCC 7	2019-10-31 15:09:55 -07:00
sdong	09040bff08	Disable warning as error	2019-10-31 15:09:49 -07:00
sdong	2591096d40	Add some include<functional>	2019-10-31 15:09:36 -07:00
sdong	c381701bdd	[FB Internal] Point to the latest tool chain.	2019-10-31 15:09:36 -07:00
sdong	da2ae09293	[FB Only] use gcc-5	2017-07-17 15:50:03 -07:00
sdong	1f303c11a3	fb internal: Should also use GCC 4.8.1 for CentOS 7	2016-10-13 13:38:23 -07:00