Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 )

Summary: Making platform 007 (gcc 7) default in build_detect_platform.sh. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5947 Differential Revision: D18038837 Pulled By: vjnadimpalli fbshipit-source-id: 9ac2ddaa93bf328a416faec028970e039886378e
Fixes for building RocksJava releases on arm64v8
2026-11-06 11:02:36 -05:00 · 2019-10-30 10:30:21 -07:00 · 2019-10-23 15:19:39 -07:00 · 2019-10-01 17:04:43 -07:00 · 2019-10-01 16:48:35 -07:00 · 2019-09-17 17:32:10 -07:00
424 changed files with 10003 additions and 39258 deletions
@@ -24,7 +24,6 @@ make_config.mk
 *.vcxproj.filters
 *.sln
 *.cmake
-.watchmanconfig
 CMakeCache.txt
 CMakeFiles/
 build/
@@ -33,8 +32,6 @@ ldb
 manifest_dump
 sst_dump
 blob_dump
-block_cache_trace_analyzer
-tools/block_cache_analyzer/*.pyc
 column_aware_encoding_exp
 util/build_version.cc
 build_tools/VALGRIND_LOGS/
@@ -50,7 +47,6 @@ rocksdb_undump
 db_test2
 trace_analyzer
 trace_analyzer_test
-block_cache_trace_analyzer
 .DS_Store

 java/out
@@ -1,6 +0,0 @@
-{
-  "content_hash_warming": true,
-  "content_hash_max_items": 333333,
-  "hint_num_files_per_dir": 8,
-  "fsevents_latency": 0.05
-}
@@ -32,19 +32,18 @@
 # 3. cmake ..
 # 4. make -j

-cmake_minimum_required(VERSION 3.5.1)
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/modules/")
-include(ReadVersion)
-get_rocksdb_version(rocksdb_VERSION)
-project(rocksdb
-  VERSION ${rocksdb_VERSION}
-  LANGUAGES CXX C ASM)
+cmake_minimum_required(VERSION 2.8.12)
+project(rocksdb)
+enable_language(CXX)
+enable_language(C)
+enable_language(ASM)

 if(POLICY CMP0042)
  cmake_policy(SET CMP0042 NEW)
 endif()

+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/modules/")
+
 find_program(CCACHE_FOUND ccache)
 if(CCACHE_FOUND)
  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
@@ -60,13 +59,6 @@ option(WITH_WINDOWS_UTF8_FILENAMES "use UTF8 as characterset for opening files,
 if (WITH_WINDOWS_UTF8_FILENAMES)
  add_definitions(-DROCKSDB_WINDOWS_UTF8_FILENAMES)
 endif()
-# third-party/folly is only validated to work on Linux and Windows for now.
-# So only turn it on there by default.
-if(CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "Windows")
-  option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" ON)
-else()
-  option(WITH_FOLLY_DISTRIBUTED_MUTEX "build with folly::DistributedMutex" OFF)
-endif()
 if(MSVC)
  # Defaults currently different for GFLAGS.
  #  We will address find_package work a little later
@@ -82,7 +74,8 @@ else()
    if(WITH_JEMALLOC)
      find_package(JeMalloc REQUIRED)
      add_definitions(-DROCKSDB_JEMALLOC -DJEMALLOC_NO_DEMANGLE)
-      list(APPEND THIRDPARTY_LIBS JeMalloc::JeMalloc)
+      include_directories(${JEMALLOC_INCLUDE_DIR})
+      list(APPEND THIRDPARTY_LIBS ${JEMALLOC_LIBRARIES})
    endif()
  endif()

@@ -100,43 +93,47 @@ else()
  if(WITH_SNAPPY)
    find_package(snappy REQUIRED)
    add_definitions(-DSNAPPY)
-    list(APPEND THIRDPARTY_LIBS snappy::snappy)
+    include_directories(${SNAPPY_INCLUDE_DIR})
+    list(APPEND THIRDPARTY_LIBS ${SNAPPY_LIBRARIES})
  endif()

  if(WITH_ZLIB)
    find_package(ZLIB REQUIRED)
    add_definitions(-DZLIB)
-    list(APPEND THIRDPARTY_LIBS ZLIB::ZLIB)
+    if(ZLIB_INCLUDE_DIRS)
+      # CMake 3
+      include_directories(${ZLIB_INCLUDE_DIRS})
+    else()
+      # CMake 2
+      include_directories(${ZLIB_INCLUDE_DIR})
+    endif()
+    list(APPEND THIRDPARTY_LIBS ${ZLIB_LIBRARIES})
  endif()

  option(WITH_BZ2 "build with bzip2" OFF)
  if(WITH_BZ2)
-    find_package(BZip2 REQUIRED)
+    find_package(bzip2 REQUIRED)
    add_definitions(-DBZIP2)
-    if(BZIP2_INCLUDE_DIRS)
-      include_directories(${BZIP2_INCLUDE_DIRS})
-    else()
-      include_directories(${BZIP2_INCLUDE_DIR})
-    endif()
+    include_directories(${BZIP2_INCLUDE_DIR})
    list(APPEND THIRDPARTY_LIBS ${BZIP2_LIBRARIES})
  endif()

  if(WITH_LZ4)
    find_package(lz4 REQUIRED)
    add_definitions(-DLZ4)
-    list(APPEND THIRDPARTY_LIBS lz4::lz4)
+    include_directories(${LZ4_INCLUDE_DIR})
+    list(APPEND THIRDPARTY_LIBS ${LZ4_LIBRARIES})
  endif()

  if(WITH_ZSTD)
    find_package(zstd REQUIRED)
    add_definitions(-DZSTD)
    include_directories(${ZSTD_INCLUDE_DIR})
-    list(APPEND THIRDPARTY_LIBS zstd::zstd)
+    list(APPEND THIRDPARTY_LIBS ${ZSTD_LIBRARIES})
  endif()
 endif()

-string(TIMESTAMP TS "%Y/%m/%d %H:%M:%S" UTC)
-set(GIT_DATE_TIME "${TS}" CACHE STRING "the time we first built rocksdb")
+string(TIMESTAMP GIT_DATE_TIME "%Y/%m/%d %H:%M:%S" UTC)

 find_package(Git)

@@ -153,6 +150,17 @@ endif()
 string(REGEX REPLACE "[^0-9a-f]+" "" GIT_SHA "${GIT_SHA}")


+# Read rocksdb version from version.h header file.
+file(READ include/rocksdb/version.h version_header_file)
+string(REGEX MATCH "#define ROCKSDB_MAJOR ([0-9]+)" _ ${version_header_file})
+set(ROCKSDB_VERSION_MAJOR ${CMAKE_MATCH_1})
+string(REGEX MATCH "#define ROCKSDB_MINOR ([0-9]+)" _ ${version_header_file})
+set(ROCKSDB_VERSION_MINOR ${CMAKE_MATCH_1})
+string(REGEX MATCH "#define ROCKSDB_PATCH ([0-9]+)" _ ${version_header_file})
+set(ROCKSDB_VERSION_PATCH ${CMAKE_MATCH_1})
+set(ROCKSDB_VERSION ${ROCKSDB_VERSION_MAJOR}.${ROCKSDB_VERSION_MINOR}.${ROCKSDB_VERSION_PATCH})
+
+
 option(WITH_MD_LIBRARY "build with MD" ON)
 if(WIN32 AND MSVC)
  if(WITH_MD_LIBRARY)
@@ -201,11 +209,11 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")
 endif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le")

 if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64")
-        CHECK_C_COMPILER_FLAG("-march=armv8-a+crc+crypto" HAS_ARMV8_CRC)
+        CHECK_C_COMPILER_FLAG("-march=armv8-a+crc" HAS_ARMV8_CRC)
  if(HAS_ARMV8_CRC)
    message(STATUS " HAS_ARMV8_CRC yes")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8-a+crc+crypto -Wno-unused-function")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8-a+crc+crypto -Wno-unused-function")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8-a+crc -Wno-unused-function")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8-a+crc -Wno-unused-function")
  endif(HAS_ARMV8_CRC)
 endif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|AARCH64")

@@ -308,14 +316,15 @@ if(WITH_NUMA)
  find_package(NUMA REQUIRED)
  add_definitions(-DNUMA)
  include_directories(${NUMA_INCLUDE_DIR})
-  list(APPEND THIRDPARTY_LIBS NUMA::NUMA)
+  list(APPEND THIRDPARTY_LIBS ${NUMA_LIBRARIES})
 endif()

 option(WITH_TBB "build with Threading Building Blocks (TBB)" OFF)
 if(WITH_TBB)
  find_package(TBB REQUIRED)
  add_definitions(-DTBB)
-  list(APPEND THIRDPARTY_LIBS TBB::TBB)
+  include_directories(${TBB_INCLUDE_DIR})
+  list(APPEND THIRDPARTY_LIBS ${TBB_LIBRARIES})
 endif()

 # Stall notifications eat some performance from inserts
@@ -469,10 +478,7 @@ endif()

 include_directories(${PROJECT_SOURCE_DIR})
 include_directories(${PROJECT_SOURCE_DIR}/include)
-include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/third-party/gtest-1.8.1/fused-src)
-if(WITH_FOLLY_DISTRIBUTED_MUTEX)
-  include_directories(${PROJECT_SOURCE_DIR}/third-party/folly)
-endif()
+include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/third-party/gtest-1.7.0/fused-src)
 find_package(Threads REQUIRED)

 # Main library source code
@@ -514,7 +520,6 @@ set(SOURCES
        db/flush_job.cc
        db/flush_scheduler.cc
        db/forward_iterator.cc
-        db/import_column_family_job.cc
        db/internal_stats.cc
        db/logs_with_prep_tracker.cc
        db/log_reader.cc
@@ -531,7 +536,6 @@ set(SOURCES
        db/table_cache.cc
        db/table_properties_collector.cc
        db/transaction_log_impl.cc
-        db/trim_history_scheduler.cc
        db/version_builder.cc
        db/version_edit.cc
        db/version_set.cc
@@ -591,13 +595,12 @@ set(SOURCES
        table/block_based/block_prefix_index.cc
        table/block_based/data_block_hash_index.cc
        table/block_based/data_block_footer.cc
-        table/block_based/filter_block_reader_common.cc
        table/block_based/flush_block_policy.cc
        table/block_based/full_filter_block.cc
        table/block_based/index_builder.cc
        table/block_based/partitioned_filter_block.cc
-        table/block_based/uncompression_dict_reader.cc
        table/block_fetcher.cc
+        table/bloom_block.cc
        table/cuckoo/cuckoo_table_builder.cc
        table/cuckoo/cuckoo_table_factory.cc
        table/cuckoo/cuckoo_table_reader.cc
@@ -607,7 +610,6 @@ set(SOURCES
        table/merging_iterator.cc
        table/meta_blocks.cc
        table/persistent_cache_helper.cc
-        table/plain/plain_table_bloom.cc
        table/plain/plain_table_builder.cc
        table/plain/plain_table_factory.cc
        table/plain/plain_table_index.cc
@@ -621,7 +623,7 @@ set(SOURCES
        test_util/sync_point_impl.cc
        test_util/testutil.cc
        test_util/transaction_test_util.cc
-        tools/block_cache_analyzer/block_cache_trace_analyzer.cc
+        tools/block_cache_trace_analyzer.cc
        tools/db_bench_tool.cc
        tools/dump/db_dump_tool.cc
        tools/ldb_cmd.cc
@@ -673,11 +675,9 @@ set(SOURCES
        utilities/merge_operators/bytesxor.cc
        utilities/merge_operators/max.cc
        utilities/merge_operators/put.cc
-        utilities/merge_operators/sortlist.cc
        utilities/merge_operators/string_append/stringappend.cc
        utilities/merge_operators/string_append/stringappend2.cc
        utilities/merge_operators/uint64add.cc
-        utilities/object_registry.cc
        utilities/option_change_migration/option_change_migration.cc
        utilities/options/options_util.cc
        utilities/persistent_cache/block_cache_tier.cc
@@ -685,7 +685,6 @@ set(SOURCES
        utilities/persistent_cache/block_cache_tier_metadata.cc
        utilities/persistent_cache/persistent_cache_tier.cc
        utilities/persistent_cache/volatile_tier_impl.cc
-        utilities/simulator_cache/cache_simulator.cc
        utilities/simulator_cache/sim_cache.cc
        utilities/table_properties_collectors/compact_on_deletion_collector.cc
        utilities/trace/file_trace_reader_writer.cc
@@ -750,15 +749,6 @@ else()
    env/io_posix.cc)
 endif()

-if(WITH_FOLLY_DISTRIBUTED_MUTEX)
-  list(APPEND SOURCES
-    third-party/folly/folly/detail/Futex.cpp
-    third-party/folly/folly/synchronization/AtomicNotification.cpp
-    third-party/folly/folly/synchronization/DistributedMutex.cpp
-    third-party/folly/folly/synchronization/ParkingLot.cpp
-    third-party/folly/folly/synchronization/WaitOptions.cpp)
-endif()
-
 set(ROCKSDB_STATIC_LIB rocksdb${ARTIFACT_SUFFIX})
 set(ROCKSDB_SHARED_LIB rocksdb-shared${ARTIFACT_SUFFIX})
 set(ROCKSDB_IMPORT_LIB ${ROCKSDB_SHARED_LIB})
@@ -782,8 +772,8 @@ else()
    ${THIRDPARTY_LIBS} ${SYSTEM_LIBS})
  set_target_properties(${ROCKSDB_SHARED_LIB} PROPERTIES
                        LINKER_LANGUAGE CXX
-                        VERSION ${rocksdb_VERSION}
-                        SOVERSION ${rocksdb_VERSION_MAJOR}
+                        VERSION ${ROCKSDB_VERSION}
+                        SOVERSION ${ROCKSDB_VERSION_MAJOR}
                        CXX_STANDARD 11
                        OUTPUT_NAME "rocksdb")
 endif()
@@ -838,7 +828,7 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)

  write_basic_package_version_file(
    RocksDBConfigVersion.cmake
-    VERSION ${rocksdb_VERSION}
+    VERSION ${ROCKSDB_VERSION}
    COMPATIBILITY SameMajorVersion
  )

@@ -880,7 +870,7 @@ endif()

 option(WITH_TESTS "build with tests" ON)
 if(WITH_TESTS)
-  add_subdirectory(third-party/gtest-1.8.1/fused-src/gtest)
+  add_subdirectory(third-party/gtest-1.7.0/fused-src/gtest)
  set(TESTS
        cache/cache_test.cc
        cache/lru_cache_test.cc
@@ -909,7 +899,6 @@ if(WITH_TESTS)
        db/db_log_iter_test.cc
        db/db_memtable_test.cc
        db/db_merge_operator_test.cc
-        db/db_merge_operand_test.cc
        db/db_options_test.cc
        db/db_properties_test.cc
        db/db_range_del_test.cc
@@ -959,7 +948,6 @@ if(WITH_TESTS)
        env/mock_env_test.cc
        file/delete_scheduler_test.cc
        logging/auto_roll_logger_test.cc
-        logging/env_logger_test.cc
        logging/event_logger_test.cc
        memory/arena_test.cc
        memtable/inlineskiplist_test.cc
@@ -982,7 +970,7 @@ if(WITH_TESTS)
        table/merger_test.cc
        table/sst_file_reader_test.cc
        table/table_test.cc
-        tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc
+        tools/block_cache_trace_analyzer_test.cc
        tools/ldb_cmd_test.cc
        tools/reduce_levels_test.cc
        tools/sst_dump_test.cc
@@ -1016,7 +1004,6 @@ if(WITH_TESTS)
        utilities/options/options_util_test.cc
        utilities/persistent_cache/hash_table_test.cc
        utilities/persistent_cache/persistent_cache_test.cc
-        utilities/simulator_cache/cache_simulator_test.cc
        utilities/simulator_cache/sim_cache_test.cc
        utilities/table_properties_collectors/compact_on_deletion_collector_test.cc
        utilities/transactions/optimistic_transaction_test.cc
@@ -1030,10 +1017,6 @@ if(WITH_TESTS)
    list(APPEND TESTS utilities/env_librados_test.cc)
  endif()

-  if(WITH_FOLLY_DISTRIBUTED_MUTEX)
-    list(APPEND TESTS third-party/folly/folly/synchronization/test/DistributedMutexTest.cpp)
-  endif()
-
  set(BENCHMARKS
    cache/cache_bench.cc
    memtable/memtablerep_bench.cc
@@ -1,77 +1,3 @@
 # Code of Conduct

-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to make participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies within all project spaces, and it also applies when
-an individual is representing the project or its community in public spaces.
-Examples of representing a project or community include using an official
-project e-mail address, posting via an official social media account, or acting
-as an appointed representative at an online or offline event. Representation of
-a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at <opensource-conduct@fb.com>. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq
-
+Facebook has adopted a Code of Conduct that we expect project participants to adhere to. Please [read the full text](https://code.facebook.com/codeofconduct) so that you can understand what actions will and will not be tolerated.
@@ -1,73 +1,17 @@
 # Rocksdb Change Log
-## 6.5.3 (1/10/2020)
-### Bug Fixes
-* Fixed two performance issues related to memtable history trimming. First, a new SuperVersion is now created only if some memtables were actually trimmed. Second, trimming is only scheduled if there is at least one flushed memtable that is kept in memory for the purposes of transaction conflict checking.
+## 6.3.6 (10/1/2019)
+* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strong results when reseek happens with a different iterator upper bound.

-## 6.5.2 (11/15/2019)
-### Bug Fixes
-* Fix a assertion failure in MultiGe4t() when BlockBasedTableOptions::no_block_cache is true and there is no compressed block cache
-* Fix a buffer overrun problem in BlockBasedTable::MultiGet() when compression is enabled and no compressed block cache is configured.
-* If a call to BackupEngine::PurgeOldBackups or BackupEngine::DeleteBackup suffered a crash, power failure, or I/O error, files could be left over from old backups that could only be purged with a call to GarbageCollect. Any call to PurgeOldBackups, DeleteBackup, or GarbageCollect should now suffice to purge such files.
+## 6.3.5 (9/17/2019)
+* Fix a bug introduced 6.3 which could cause wrong results in a corner case when prefix bloom filter is used and the iterator is reseeked.

-## 6.5.1 (10/16/2019)
+## 6.3.4 (9/3/2019)
 ### Bug Fixes
-* Revert the feature "Merging iterator to avoid child iterator reseek for some cases (#5286)" since it might cause strange results when reseek happens with a different iterator upper bound.
-* Fix a bug in BlockBasedTableIterator that might return incorrect results when reseek happens with a different iterator upper bound.
-* Fix a bug when partitioned filters and prefix search are used in conjunction, ::SeekForPrev could return invalid for an existing prefix. ::SeekForPrev might be called by the user, or internally on ::Prev, or within ::Seek if the return value involves Delete or a Merge operand.
-
-## 6.5.0 (9/13/2019)
-### Bug Fixes
-* Fixed a number of data races in BlobDB.
-* Fix a bug where the compaction snapshot refresh feature is not disabled as advertised when `snap_refresh_nanos` is set to 0..
-* Fix bloom filter lookups by the MultiGet batching API when BlockBasedTableOptions::whole_key_filtering is false, by checking that a key is in the perfix_extractor domain and extracting the prefix before looking up.
 * Fix a bug in file ingestion caused by incorrect file number allocation when the number of column families involved in the ingestion exceeds 2.
-### New Features
-* Introduced DBOptions::max_write_batch_group_size_bytes to configure maximum limit on number of bytes that are written in a single batch of WAL or memtable write. It is followed when the leader write size is larger than 1/8 of this limit.
-* VerifyChecksum() by default will issue readahead. Allow ReadOptions to be passed in to those functions to override the readhead size. For checksum verifying before external SST file ingestion, a new option IngestExternalFileOptions.verify_checksums_readahead_size, is added for this readahead setting.
-* When user uses options.force_consistency_check in RocksDb, instead of crashing the process, we now pass the error back to the users without killing the process.
-* Add an option `memtable_insert_hint_per_batch` to WriteOptions. If it is true, each WriteBatch will maintain its own insert hints for each memtable in concurrent write. See include/rocksdb/options.h for more details.
-### Public API Change
-* Added max_write_buffer_size_to_maintain option to better control memory usage of immutable memtables.
-* Added a lightweight API GetCurrentWalFile() to get last live WAL filename and size. Meant to be used as a helper for backup/restore tooling in a larger ecosystem such as MySQL with a MyRocks storage engine.
-* The MemTable Bloom filter, when enabled, now always uses cache locality. Options::bloom_locality now only affects the PlainTable SST format.
-### Performance Improvements
-* Improve the speed of the MemTable Bloom filter, reducing the write overhead of enabling it by 1/3 to 1/2, with similar benefit to read performance.
-
-## 6.4.0 (7/30/2019)
-### Default Option Change
-* LRUCacheOptions.high_pri_pool_ratio is set to 0.5 (previously 0.0) by default, which means that by default midpoint insertion is enabled. The same change is made for the default value of high_pri_pool_ratio argument in NewLRUCache(). When block cache is not explictly created, the small block cache created by BlockBasedTable will still has this option to be 0.0.
-* Change BlockBasedTableOptions.cache_index_and_filter_blocks_with_high_priority's default value from false to true.
-
-### Public API Change
-* Filter and compression dictionary blocks are now handled similarly to data blocks with regards to the block cache: instead of storing objects in the cache, only the blocks themselves are cached. In addition, filter and compression dictionary blocks (as well as filter partitions) no longer get evicted from the cache when a table is closed.
-* Due to the above refactoring, block cache eviction statistics for filter and compression dictionary blocks are temporarily broken. We plan to reintroduce them in a later phase.
-* The semantics of the per-block-type block read counts in the performance context now match those of the generic block_read_count.
-* Errors related to the retrieval of the compression dictionary are now propagated to the user.
-* db_bench adds a "benchmark" stats_history, which prints out the whole stats history.
-* Overload GetAllKeyVersions() to support non-default column family.
-* Added new APIs ExportColumnFamily() and CreateColumnFamilyWithImport() to support export and import of a Column Family. https://github.com/facebook/rocksdb/issues/3469
-* ldb sometimes uses a string-append merge operator if no merge operator is passed in. This is to allow users to print keys from a DB with a merge operator.
-* Replaces old Registra with ObjectRegistry to allow user to create custom object from string, also add LoadEnv() to Env.
-* Added new overload of GetApproximateSizes which gets SizeApproximationOptions object and returns a Status. The older overloads are redirecting their calls to this new method and no longer assert if the include_flags doesn't have either of INCLUDE_MEMTABLES or INCLUDE_FILES bits set. It's recommended to use the new method only, as it is more type safe and returns a meaningful status in case of errors.
-* LDBCommandRunner::RunCommand() to return the status code as an integer, rather than call exit() using the code.
-
-### New Features
-* Add argument `--secondary_path` to ldb to open the database as the secondary instance. This would keep the original DB intact.
-* Compression dictionary blocks are now prefetched and pinned in the cache (based on the customer's settings) the same way as index and filter blocks.
-* Added DBOptions::log_readahead_size which specifies the number of bytes to prefetch when reading the log. This is mostly useful for reading a remotely located log, as it can save the number of round-trips. If 0 (default), then the prefetching is disabled.
-* Added new option in SizeApproximationOptions used with DB::GetApproximateSizes. When approximating the files total size that is used to store a keys range, allow approximation with an error margin of up to total_files_size * files_size_error_margin. This allows to take some shortcuts in files size approximation, resulting in better performance, while guaranteeing the resulting error is within a reasonable margin.
-* Support loading custom objects in unit tests. In the affected unit tests, RocksDB will create custom Env objects based on environment variable TEST_ENV_URI. Users need to make sure custom object types are properly registered. For example, a static library should expose a `RegisterCustomObjects` function. By linking the unit test binary with the static library, the unit test can execute this function.
-
-### Performance Improvements
-* Reduce iterator key comparision for upper/lower bound check.
-* Improve performance of row_cache: make reads with newer snapshots than data in an SST file share the same cache key, except in some transaction cases.
-* The compression dictionary is no longer copied to a new object upon retrieval.

+## 6.3.3 (8/20/2019)
 ### Bug Fixes
-* Fix ingested file and directory not being fsync.
-* Return TryAgain status in place of Corruption when new tail is not visible to TransactionLogIterator.
-* Fixed a regression where the fill_cache read option also affected index blocks.
-* Fixed an issue where using cache_index_and_filter_blocks==false affected partitions of partitioned indexes/filters as well.
+* Fix a bug where the compaction snapshot refresh feature is not disabled as advertised when `snap_refresh_nanos` is set to 0..

 ## 6.3.2 (8/15/2019)
 ### Public API Change
@@ -98,7 +42,6 @@
 * Add an option `unordered_write` which trades snapshot guarantees with higher write throughput. When used with WRITE_PREPARED transactions with two_write_queues=true, it offers higher throughput with however no compromise on guarantees.
 * Allow DBImplSecondary to remove memtables with obsolete data after replaying MANIFEST and WAL.
 * Add an option `failed_move_fall_back_to_copy` (default is true) for external SST ingestion. When `move_files` is true and hard link fails, ingestion falls back to copy if `failed_move_fall_back_to_copy` is true. Otherwise, ingestion reports an error.
-* Add command `list_file_range_deletes` in ldb, which prints out tombstones in SST files.

 ### Performance Improvements
 * Reduce binary search when iterator reseek into the same data block.
@@ -126,7 +69,6 @@
 * Block-based table index now contains exact highest key in the file, rather than an upper bound. This may improve Get() and iterator Seek() performance in some situations, especially when direct IO is enabled and block cache is disabled. A setting BlockBasedTableOptions::index_shortening is introduced to control this behavior. Set it to kShortenSeparatorsAndSuccessor to get the old behavior.
 * When reading from option file/string/map, customized envs can be filled according to object registry.
 * Improve range scan performance when using explicit user readahead by not creating new table readers for every iterator.
-* Add index type BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey. It significantly reduces read amplification in some setups, especially for iterator seeks. It's not fully implemented yet: IO errors are not handled right.

 ### Public API Change
 * Change the behavior of OptimizeForPointLookup(): move away from hash-based block-based-table index, and use whole key memtable filtering.
@@ -89,7 +89,7 @@ endif

 ifeq ($(MAKECMDGOALS),rocksdbjavastaticreleasedocker)
 	ifneq ($(DEBUG_LEVEL),2)
-		DEBUG_LEVEL=0
+        	DEBUG_LEVEL=0
 	endif
 endif

@@ -143,9 +143,9 @@ CFLAGS +=  -DHAVE_POWER8
 HAVE_POWER8=1
 endif

-ifeq (,$(shell $(CXX) -fsyntax-only -march=armv8-a+crc+crypto -xc /dev/null 2>&1))
-CXXFLAGS += -march=armv8-a+crc+crypto
-CFLAGS += -march=armv8-a+crc+crypto
+ifeq (,$(shell $(CXX) -fsyntax-only -march=armv8-a+crc -xc /dev/null 2>&1))
+CXXFLAGS += -march=armv8-a+crc
+CFLAGS += -march=armv8-a+crc
 ARMCRC_SOURCE=1
 endif

@@ -256,8 +256,8 @@ endif
 ifdef COMPILE_WITH_TSAN
 	DISABLE_JEMALLOC=1
 	EXEC_LDFLAGS += -fsanitize=thread
-	PLATFORM_CCFLAGS += -fsanitize=thread -fPIC -DFOLLY_SANITIZE_THREAD
-	PLATFORM_CXXFLAGS += -fsanitize=thread -fPIC -DFOLLY_SANITIZE_THREAD
+	PLATFORM_CCFLAGS += -fsanitize=thread -fPIC
+	PLATFORM_CXXFLAGS += -fsanitize=thread -fPIC
        # Turn off -pg when enabling TSAN testing, because that induces
        # a link failure.  TODO: find the root cause
 	PROFILING_FLAGS =
@@ -304,13 +304,9 @@ ifndef DISABLE_JEMALLOC
 	PLATFORM_CCFLAGS += $(JEMALLOC_INCLUDE)
 endif

-ifndef USE_FOLLY_DISTRIBUTED_MUTEX
-	USE_FOLLY_DISTRIBUTED_MUTEX=0
-endif
-
 export GTEST_THROW_ON_FAILURE=1
 export GTEST_HAS_EXCEPTIONS=1
-GTEST_DIR = ./third-party/gtest-1.8.1/fused-src
+GTEST_DIR = ./third-party/gtest-1.7.0/fused-src
 # AIX: pre-defined system headers are surrounded by an extern "C" block
 ifeq ($(PLATFORM), OS_AIX)
 	PLATFORM_CCFLAGS += -I$(GTEST_DIR)
@@ -320,23 +316,6 @@ else
 	PLATFORM_CXXFLAGS += -isystem $(GTEST_DIR)
 endif

-ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
-	FOLLY_DIR = ./third-party/folly
-	# AIX: pre-defined system headers are surrounded by an extern "C" block
-	ifeq ($(PLATFORM), OS_AIX)
-		PLATFORM_CCFLAGS += -I$(FOLLY_DIR)
-		PLATFORM_CXXFLAGS += -I$(FOLLY_DIR)
-	else
-		PLATFORM_CCFLAGS += -isystem $(FOLLY_DIR)
-		PLATFORM_CXXFLAGS += -isystem $(FOLLY_DIR)
-	endif
-endif
-
-ifdef TEST_CACHE_LINE_SIZE
-  PLATFORM_CCFLAGS += -DTEST_CACHE_LINE_SIZE=$(TEST_CACHE_LINE_SIZE)
-  PLATFORM_CXXFLAGS += -DTEST_CACHE_LINE_SIZE=$(TEST_CACHE_LINE_SIZE)
-endif
-
 # This (the first rule) must depend on "all".
 default: all

@@ -423,9 +402,6 @@ endif

 LIBOBJECTS += $(TOOL_LIB_SOURCES:.cc=.o)
 MOCKOBJECTS = $(MOCK_LIB_SOURCES:.cc=.o)
-ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
-  FOLLYOBJECTS = $(FOLLY_SOURCES:.cpp=.o)
-endif

 GTEST = $(GTEST_DIR)/gtest/gtest-all.o
 TESTUTIL = ./test_util/testutil.o
@@ -456,7 +432,6 @@ TESTS = \
 	inlineskiplist_test \
 	env_basic_test \
 	env_test \
-	env_logger_test \
 	hash_test \
 	thread_local_test \
 	rate_limiter_test \
@@ -466,10 +441,10 @@ TESTS = \
 	db_block_cache_test \
 	db_test \
 	db_blob_index_test \
+	db_bloom_filter_test \
 	db_iter_test \
 	db_iter_stress_test \
 	db_log_iter_test \
-	db_bloom_filter_test \
 	db_compaction_filter_test \
 	db_compaction_test \
 	db_dynamic_level_test \
@@ -478,7 +453,6 @@ TESTS = \
 	db_iterator_test \
 	db_memtable_test \
 	db_merge_operator_test \
-	db_merge_operand_test \
 	db_options_test \
 	db_range_del_test \
 	db_secondary_test \
@@ -525,7 +499,6 @@ TESTS = \
 	plain_table_db_test \
 	comparator_db_test \
 	external_sst_file_test \
-	import_column_family_test \
 	prefix_test \
 	skiplist_test \
 	write_buffer_manager_test \
@@ -536,7 +509,6 @@ TESTS = \
 	cassandra_serialize_test \
 	ttl_test \
 	backupable_db_test \
-	cache_simulator_test \
 	sim_cache_test \
 	version_edit_test \
 	version_set_test \
@@ -593,13 +565,8 @@ TESTS = \
 	block_cache_tracer_test \
 	block_cache_trace_analyzer_test \

-ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
-	TESTS += folly_synchronization_distributed_mutex_test
-endif
-
 PARALLEL_TEST = \
 	backupable_db_test \
-	db_bloom_filter_test \
 	db_compaction_filter_test \
 	db_compaction_test \
 	db_merge_operator_test \
@@ -608,9 +575,7 @@ PARALLEL_TEST = \
 	db_universal_compaction_test \
 	db_wal_test \
 	external_sst_file_test \
-	import_column_family_test \
 	fault_injection_test \
-	file_reader_writer_test \
 	inlineskiplist_test \
 	manual_compaction_test \
 	persistent_cache_test \
@@ -955,7 +920,7 @@ blackbox_crash_test: db_stress
 	python -u tools/db_crashtest.py blackbox $(CRASH_TEST_EXT_ARGS)

 blackbox_crash_test_with_atomic_flush: db_stress
-	python -u tools/db_crashtest.py --cf_consistency blackbox $(CRASH_TEST_EXT_ARGS)
+	python -u tools/db_crashtest.py --enable_atomic_flush blackbox $(CRASH_TEST_EXT_ARGS)

 ifeq ($(CRASH_TEST_KILL_ODD),)
  CRASH_TEST_KILL_ODD=888887
@@ -968,7 +933,7 @@ whitebox_crash_test: db_stress
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

 whitebox_crash_test_with_atomic_flush: db_stress
-	python -u tools/db_crashtest.py --cf_consistency whitebox  --random_kill_odd \
+	python -u tools/db_crashtest.py --enable_atomic_flush whitebox  --random_kill_odd \
      $(CRASH_TEST_KILL_ODD) $(CRASH_TEST_EXT_ARGS)

 asan_check:
@@ -1099,7 +1064,7 @@ rocksdb.h rocksdb.cc: build_tools/amalgamate.py Makefile $(LIB_SOURCES) unity.cc
 	build_tools/amalgamate.py -I. -i./include unity.cc -x include/rocksdb/c.h -H rocksdb.h -o rocksdb.cc

 clean:
-	rm -f $(BENCHMARKS) $(TOOLS) $(TESTS) $(PARALLEL_TEST) $(LIBRARY) $(SHARED)
+	rm -f $(BENCHMARKS) $(TOOLS) $(TESTS) $(LIBRARY) $(SHARED)
 	rm -rf $(CLEAN_FILES) ios-x86 ios-arm scan_build_report
 	$(FIND) . -name "*.[oda]" -exec rm -f {} \;
 	$(FIND) . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
@@ -1145,14 +1110,9 @@ db_bench: tools/db_bench.o $(BENCHTOOLOBJECTS)
 trace_analyzer: tools/trace_analyzer.o $(ANALYZETOOLOBJECTS) $(LIBOBJECTS)
 	$(AM_LINK)

-block_cache_trace_analyzer: tools/block_cache_analyzer/block_cache_trace_analyzer_tool.o $(ANALYZETOOLOBJECTS) $(LIBOBJECTS)
+block_cache_trace_analyzer: tools/block_cache_trace_analyzer_tool.o $(ANALYZETOOLOBJECTS) $(LIBOBJECTS)
 	$(AM_LINK)

-ifeq ($(USE_FOLLY_DISTRIBUTED_MUTEX),1)
-folly_synchronization_distributed_mutex_test: $(LIBOBJECTS) $(TESTHARNESS) $(FOLLYOBJECTS) third-party/folly/folly/synchronization/test/DistributedMutexTest.o
-	$(AM_LINK)
-endif
-
 cache_bench: cache/cache_bench.o $(LIBOBJECTS) $(TESTUTIL)
 	$(AM_LINK)

@@ -1231,7 +1191,7 @@ histogram_test: monitoring/histogram_test.o $(LIBOBJECTS) $(TESTHARNESS)
 thread_local_test: util/thread_local_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-corruption_test: db/corruption_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
+corruption_test: db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

 crc32c_test: util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS)
@@ -1288,9 +1248,6 @@ db_memtable_test: db/db_memtable_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHA
 db_merge_operator_test: db/db_merge_operator_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-db_merge_operand_test: db/db_merge_operand_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 db_options_test: db/db_options_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1315,9 +1272,6 @@ external_sst_file_basic_test: db/external_sst_file_basic_test.o db/db_test_util.
 external_sst_file_test: db/external_sst_file_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-import_column_family_test: db/import_column_family_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 db_tailing_iter_test: db/db_tailing_iter_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1366,9 +1320,6 @@ backupable_db_test: utilities/backupable/backupable_db_test.o $(LIBOBJECTS) $(TE
 checkpoint_test: utilities/checkpoint/checkpoint_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-cache_simulator_test: utilities/simulator_cache/cache_simulator_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 sim_cache_test: utilities/simulator_cache/sim_cache_test.o db/db_test_util.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1578,9 +1529,6 @@ filelock_test: util/filelock_test.o $(LIBOBJECTS) $(TESTHARNESS)
 auto_roll_logger_test: logging/auto_roll_logger_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-env_logger_test: logging/env_logger_test.o $(LIBOBJECTS) $(TESTHARNESS)
-	$(AM_LINK)
-
 memtable_list_test: db/memtable_list_test.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

@@ -1653,7 +1601,7 @@ db_secondary_test: db/db_impl/db_secondary_test.o db/db_test_util.o $(LIBOBJECTS
 block_cache_tracer_test: trace_replay/block_cache_tracer_test.o trace_replay/block_cache_tracer.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

-block_cache_trace_analyzer_test: tools/block_cache_analyzer/block_cache_trace_analyzer_test.o tools/block_cache_analyzer/block_cache_trace_analyzer.o $(LIBOBJECTS) $(TESTHARNESS)
+block_cache_trace_analyzer_test: tools/block_cache_trace_analyzer_test.o tools/block_cache_trace_analyzer.o $(LIBOBJECTS) $(TESTHARNESS)
 	$(AM_LINK)

 #-------------------------------------------------
@@ -96,6 +96,3 @@ LzLabs is using RocksDB as a storage engine in their multi-database distributed

 ## IOTA Foundation
 [IOTA Foundation](https://www.iota.org/) is using RocksDB in the [IOTA Reference Implementation (IRI)](https://github.com/iotaledger/iri) to store the local state of the Tangle. The Tangle is the first open-source distributed ledger powering the future of the Internet of Things.
- 
-## Crux
-[Crux](https://github.com/juxt/crux) is a document database that uses RocksDB for local [EAV](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model) index storage to enable point-in-time bitemporal Datalog queries. The "unbundled" architecture uses Kafka to provide horizontal scalability.
@@ -1,67 +1,15 @@
 version: 1.0.{build}
-
 image: Visual Studio 2017
-
-environment:
-  JAVA_HOME: C:\Program Files\Java\jdk1.8.0
-  THIRDPARTY_HOME: $(APPVEYOR_BUILD_FOLDER)\thirdparty
-  SNAPPY_HOME: $(THIRDPARTY_HOME)\snappy-1.1.7
-  SNAPPY_INCLUDE: $(SNAPPY_HOME);$(SNAPPY_HOME)\build
-  SNAPPY_LIB_DEBUG: $(SNAPPY_HOME)\build\Debug\snappy.lib
-  SNAPPY_LIB_RELEASE: $(SNAPPY_HOME)\build\Release\snappy.lib
-  LZ4_HOME: $(THIRDPARTY_HOME)\lz4-1.8.3
-  LZ4_INCLUDE: $(LZ4_HOME)\lib
-  LZ4_LIB_DEBUG: $(LZ4_HOME)\visual\VS2010\bin\x64_Debug\liblz4_static.lib
-  LZ4_LIB_RELEASE: $(LZ4_HOME)\visual\VS2010\bin\x64_Release\liblz4_static.lib
-  ZSTD_HOME: $(THIRDPARTY_HOME)\zstd-1.4.0
-  ZSTD_INCLUDE: $(ZSTD_HOME)\lib;$(ZSTD_HOME)\lib\dictBuilder
-  ZSTD_LIB_DEBUG: $(ZSTD_HOME)\build\VS2010\bin\x64_Debug\libzstd_static.lib
-  ZSTD_LIB_RELEASE: $(ZSTD_HOME)\build\VS2010\bin\x64_Release\libzstd_static.lib
-
-install:
-  - md %THIRDPARTY_HOME%
-  - echo "Building Snappy dependency..."
-  - cd %THIRDPARTY_HOME%
-  - curl -fsSL -o snappy-1.1.7.zip https://github.com/google/snappy/archive/1.1.7.zip
-  - unzip snappy-1.1.7.zip
-  - cd snappy-1.1.7
-  - mkdir build
-  - cd build
-  - cmake -DCMAKE_GENERATOR_PLATFORM=x64 ..
-  - msbuild Snappy.sln /p:Configuration=Debug /p:Platform=x64
-  - msbuild Snappy.sln /p:Configuration=Release /p:Platform=x64
-  - echo "Building LZ4 dependency..."
-  - cd %THIRDPARTY_HOME%
-  - curl -fsSL -o lz4-1.8.3.zip https://github.com/lz4/lz4/archive/v1.8.3.zip
-  - unzip lz4-1.8.3.zip
-  - cd lz4-1.8.3\visual\VS2010
-  - ps: $CMD="C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\devenv.com"; & $CMD lz4.sln /upgrade
-  - msbuild lz4.sln /p:Configuration=Debug /p:Platform=x64
-  - msbuild lz4.sln /p:Configuration=Release /p:Platform=x64
-  - echo "Building ZStd dependency..."
-  - cd %THIRDPARTY_HOME%
-  - curl -fsSL -o zstd-1.4.0.zip https://github.com/facebook/zstd/archive/v1.4.0.zip
-  - unzip zstd-1.4.0.zip
-  - cd zstd-1.4.0\build\VS2010
-  - ps: $CMD="C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\devenv.com"; & $CMD zstd.sln /upgrade
-  - msbuild zstd.sln /p:Configuration=Debug /p:Platform=x64
-  - msbuild zstd.sln /p:Configuration=Release /p:Platform=x64
-
 before_build:
-  - md %APPVEYOR_BUILD_FOLDER%\build
-  - cd %APPVEYOR_BUILD_FOLDER%\build
-  - cmake -G "Visual Studio 15 Win64" -DOPTDBG=1 -DPORTABLE=1 -DSNAPPY=1 -DLZ4=1 -DZSTD=1 -DXPRESS=1 -DJNI=1 ..
-  - cd ..
+- md %APPVEYOR_BUILD_FOLDER%\build
+- cd %APPVEYOR_BUILD_FOLDER%\build
+- cmake -G "Visual Studio 15 Win64" -DOPTDBG=1 -DWITH_XPRESS=1 -DPORTABLE=1 -DJNI=1 ..
+- cd ..
 build:
  project: build\rocksdb.sln
  parallel: true
  verbosity: normal
-
 test:
-
 test_script:
-  - ps: build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test2,db_test,env_basic_test,env_test,db_merge_operand_test -Concurrency 8
-
-on_failure:
-  - cmd: 7z a build-failed.zip %APPVEYOR_BUILD_FOLDER%\build\ && appveyor PushArtifact build-failed.zip
+- ps: build_tools\run_ci_db_test.ps1 -SuiteRun db_basic_test,db_test2,db_test,env_basic_test,env_test -Concurrency 8

@@ -4,31 +4,12 @@ from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
 from targets_builder import TARGETSBuilder
-import json
 import os
 import fnmatch
 import sys

 from util import ColorString

-# This script generates TARGETS file for Buck.
-# Buck is a build tool specifying dependencies among different build targets.
-# User can pass extra dependencies as a JSON object via command line, and this
-# script can include these dependencies in the generate TARGETS file.
-# Usage:
-# $python buckifier/buckify_rocksdb.py
-# (This generates a TARGET file without user-specified dependency for unit
-# tests.)
-# $python buckifier/buckify_rocksdb.py \
-#        '{"fake": { \
-#                      "extra_deps": [":test_dep", "//fakes/module:mock1"],  \
-#                      "extra_compiler_flags": ["-DROCKSDB_LITE", "-Os"], \
-#                  } \
-#         }'
-# (Generated TARGETS file has test_dep and mock1 as dependencies for RocksDB
-# unit tests, and will use the extra_compiler_flags to compile the unit test
-# source.)
-
 # tests to export as libraries for inclusion in other projects
 _EXPORTED_TEST_LIBS = ["env_basic_test"]

@@ -105,38 +86,8 @@ def get_tests(repo_path):
    return tests


-# Parse extra dependencies passed by user from command line
-def get_dependencies():
-    deps_map = {
-        ''.encode('ascii'): {
-            'extra_deps'.encode('ascii'): [],
-            'extra_compiler_flags'.encode('ascii'): []
-        }
-    }
-    if len(sys.argv) < 2:
-        return deps_map
-
-    def encode_dict(data):
-        rv = {}
-        for k, v in data.items():
-            if isinstance(k, unicode):
-                k = k.encode('ascii')
-            if isinstance(v, unicode):
-                v = v.encode('ascii')
-            elif isinstance(v, list):
-                v = [x.encode('ascii') for x in v]
-            elif isinstance(v, dict):
-                v = encode_dict(v)
-            rv[k] = v
-        return rv
-    extra_deps = json.loads(sys.argv[1], object_hook=encode_dict)
-    for target_alias, deps in extra_deps.items():
-        deps_map[target_alias] = deps
-    return deps_map
-
-
 # Prepare TARGETS file for buck
-def generate_targets(repo_path, deps_map):
+def generate_targets(repo_path):
    print(ColorString.info("Generating TARGETS"))
    # parsed src.mk file
    src_mk = parse_src_mk(repo_path)
@@ -170,33 +121,24 @@ def generate_targets(repo_path, deps_map):
        ["test_util/testutil.cc"],
        [":rocksdb_lib"])

-    print("Extra dependencies:\n{0}".format(str(deps_map)))
    # test for every test we found in the Makefile
-    for target_alias, deps in deps_map.items():
-        for test in sorted(tests):
-            match_src = [src for src in cc_files if ("/%s.c" % test) in src]
-            if len(match_src) == 0:
-                print(ColorString.warning("Cannot find .cc file for %s" % test))
-                continue
-            elif len(match_src) > 1:
-                print(ColorString.warning("Found more than one .cc for %s" % test))
-                print(match_src)
-                continue
+    for test in sorted(tests):
+        match_src = [src for src in cc_files if ("/%s.c" % test) in src]
+        if len(match_src) == 0:
+            print(ColorString.warning("Cannot find .cc file for %s" % test))
+            continue
+        elif len(match_src) > 1:
+            print(ColorString.warning("Found more than one .cc for %s" % test))
+            print(match_src)
+            continue

-            assert(len(match_src) == 1)
-            is_parallel = tests[test]
-            test_target_name = \
-                test if not target_alias else test + "_" + target_alias
-            TARGETS.register_test(
-                test_target_name,
-                match_src[0],
-                is_parallel,
-                deps['extra_deps'],
-                deps['extra_compiler_flags'])
+        assert(len(match_src) == 1)
+        is_parallel = tests[test]
+        TARGETS.register_test(test, match_src[0], is_parallel)

-            if test in _EXPORTED_TEST_LIBS:
-                test_library = "%s_lib" % test_target_name
-                TARGETS.add_library(test_library, match_src, [":rocksdb_test_lib"])
+        if test in _EXPORTED_TEST_LIBS:
+            test_library = "%s_lib" % test
+            TARGETS.add_library(test_library, match_src, [":rocksdb_test_lib"])
    TARGETS.flush_tests()

    print(ColorString.info("Generated TARGETS Summary:"))
@@ -221,9 +163,8 @@ def exit_with_error(msg):


 def main():
-    deps_map = get_dependencies()
    # Generate TARGETS file for buck
-    ok = generate_targets(get_rocksdb_path(), deps_map)
+    ok = generate_targets(get_rocksdb_path())
    if not ok:
        exit_with_error("Failed to generate TARGETS files")

@@ -51,21 +51,14 @@ class TARGETSBuilder:
            pretty_list(deps)))
        self.total_bin = self.total_bin + 1

-    def register_test(self,
-                      test_name,
-                      src,
-                      is_parallel,
-                      extra_deps,
-                      extra_compiler_flags):
+    def register_test(self, test_name, src, is_parallel):
        exec_mode = "serial"
        if is_parallel:
            exec_mode = "parallel"
        self.tests_cfg += targets_cfg.test_cfg_template % (
            test_name,
            str(src),
-            str(exec_mode),
-            extra_deps,
-            extra_compiler_flags)
+            str(exec_mode))

        self.total_test = self.total_test + 1

@@ -11,9 +11,29 @@ REPO_PATH = package_name() + "/"

 ROCKSDB_COMPILER_FLAGS = [
    "-fno-builtin-memcmp",
+    "-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",
+    "-DOS_LINUX",
+    # Flags to enable libs we include
+    "-DSNAPPY",
+    "-DZLIB",
+    "-DBZIP2",
+    "-DLZ4",
+    "-DZSTD",
+    "-DZSTD_STATIC_LINKING_ONLY",
+    "-DGFLAGS=gflags",
+    "-DNUMA",
+    "-DTBB",
    # Needed to compile in fbcode
    "-Wno-expansion-to-defined",
    # Added missing flags from output of build_detect_platform
+    "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
+    "-DROCKSDB_BACKTRACE",
    "-Wnarrowing",
    "-DROCKSDB_NO_DYNAMIC_EXTENSION",
 ]
@@ -26,54 +46,11 @@ ROCKSDB_EXTERNAL_DEPS = [
    ("lz4", None, "lz4"),
    ("zstd", None),
    ("tbb", None),
+    ("numa", None, "numa"),
    ("googletest", None, "gtest"),
 ]

-ROCKSDB_OS_DEPS = [
-    (
-        "linux",
-        ["third-party//numa:numa"],
-    ),
-]
-
-ROCKSDB_OS_PREPROCESSOR_FLAGS = [
-    (
-        "linux",
-        [
-            "-DOS_LINUX",
-            "-DROCKSDB_FALLOCATE_PRESENT",
-            "-DROCKSDB_MALLOC_USABLE_SIZE",
-            "-DROCKSDB_PTHREAD_ADAPTIVE_MUTEX",
-            "-DROCKSDB_RANGESYNC_PRESENT",
-            "-DROCKSDB_SCHED_GETCPU_PRESENT",
-            "-DHAVE_SSE42",
-            "-DNUMA",
-        ],
-    ),
-    (
-        "macos",
-        ["-DOS_MACOSX"],
-    ),
-]
-
 ROCKSDB_PREPROCESSOR_FLAGS = [
-    "-DROCKSDB_PLATFORM_POSIX",
-    "-DROCKSDB_LIB_IO_POSIX",
-    "-DROCKSDB_SUPPORT_THREAD_LOCAL",
-
-    # Flags to enable libs we include
-    "-DSNAPPY",
-    "-DZLIB",
-    "-DBZIP2",
-    "-DLZ4",
-    "-DZSTD",
-    "-DZSTD_STATIC_LINKING_ONLY",
-    "-DGFLAGS=gflags",
-    "-DTBB",
-
-    # Added missing flags from output of build_detect_platform
-    "-DROCKSDB_BACKTRACE",
-
    # Directories with files for #include
    "-I" + REPO_PATH + "include/",
    "-I" + REPO_PATH,
@@ -81,6 +58,7 @@ ROCKSDB_PREPROCESSOR_FLAGS = [

 ROCKSDB_ARCH_PREPROCESSOR_FLAGS = {
    "x86_64": [
+        "-DHAVE_SSE42",
        "-DHAVE_PCLMUL",
    ],
 }
@@ -97,15 +75,9 @@ sanitizer = read_config("fbcode", "sanitizer")

 # Do not enable jemalloc if sanitizer presents. RocksDB will further detect
 # whether the binary is linked with jemalloc at runtime.
-ROCKSDB_OS_PREPROCESSOR_FLAGS += ([(
-    "linux",
-    ["-DROCKSDB_JEMALLOC"],
-)] if sanitizer == "" else [])
+ROCKSDB_COMPILER_FLAGS += (["-DROCKSDB_JEMALLOC"] if sanitizer == "" else [])

-ROCKSDB_OS_DEPS += ([(
-    "linux",
-    ["third-party//jemalloc:headers"],
-)] if sanitizer == "" else [])
+ROCKSDB_EXTERNAL_DEPS += ([("jemalloc", None, "headers")] if sanitizer == "" else [])
 """


@@ -116,8 +88,6 @@ cpp_library(
    {headers_attr_prefix}headers = {headers},
    arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
    compiler_flags = ROCKSDB_COMPILER_FLAGS,
-    os_deps = ROCKSDB_OS_DEPS,
-    os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
    preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
    deps = [{deps}],
    external_deps = ROCKSDB_EXTERNAL_DEPS,
@@ -140,13 +110,11 @@ test_cfg_template = """    [
        "%s",
        "%s",
        "%s",
-        %s,
-        %s,
    ],
 """

 unittests_template = """
-# [test_name, test_src, test_type, extra_deps, extra_compiler_flags]
+# [test_name, test_src, test_type]
 ROCKS_TESTS = [
 %s]

@@ -155,19 +123,15 @@ ROCKS_TESTS = [
 # will not be included.
 [
    test_binary(
-        extra_compiler_flags = extra_compiler_flags,
-        extra_deps = extra_deps,
        parallelism = parallelism,
        rocksdb_arch_preprocessor_flags = ROCKSDB_ARCH_PREPROCESSOR_FLAGS,
        rocksdb_compiler_flags = ROCKSDB_COMPILER_FLAGS,
        rocksdb_external_deps = ROCKSDB_EXTERNAL_DEPS,
-        rocksdb_os_deps = ROCKSDB_OS_DEPS,
-        rocksdb_os_preprocessor_flags = ROCKSDB_OS_PREPROCESSOR_FLAGS,
        rocksdb_preprocessor_flags = ROCKSDB_PREPROCESSOR_FLAGS,
        test_cc = test_cc,
        test_name = test_name,
    )
-    for test_name, test_cc, parallelism, extra_deps, extra_compiler_flags in ROCKS_TESTS
+    for test_name, test_cc, parallelism in ROCKS_TESTS
    if not is_opt_mode
 ]
 """
@@ -150,9 +150,6 @@ case "$TARGET_OS" in
            PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -latomic"
        fi
        PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -lpthread -lrt"
-        if test -z "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
-          USE_FOLLY_DISTRIBUTED_MUTEX=1
-        fi
        # PORT_FILES=port/linux/linux_specific.cc
        ;;
    SunOS)
@@ -533,7 +530,7 @@ if test "$USE_HDFS"; then
  JAVA_LDFLAGS="$JAVA_LDFLAGS $HDFS_LDFLAGS"
 fi

-if test "0$PORTABLE" -eq 0; then
+if test -z "$PORTABLE"; then
  if test -n "`echo $TARGET_ARCHITECTURE | grep ^ppc64`"; then
    # Tune for this POWER processor, treating '+' models as base models
    POWER=`LD_SHOW_AUXV=1 /bin/true | grep AT_PLATFORM | grep -E -o power[0-9]+`
@@ -547,34 +544,16 @@ if test "0$PORTABLE" -eq 0; then
    COMMON_FLAGS="$COMMON_FLAGS"
  elif [ "$TARGET_OS" == "IOS" ]; then
    COMMON_FLAGS="$COMMON_FLAGS"
-  elif [ "$TARGET_OS" == "AIX" ] || [ "$TARGET_OS" == "SunOS" ]; then
-    # TODO: Not sure why we don't use -march=native on these OSes
-    if test "$USE_SSE"; then
-      TRY_SSE_ETC="1"
-    fi
-  else
+  elif [ "$TARGET_OS" != "AIX" ] && [ "$TARGET_OS" != "SunOS" ]; then
    COMMON_FLAGS="$COMMON_FLAGS -march=native "
+  elif test "$USE_SSE"; then
+    COMMON_FLAGS="$COMMON_FLAGS -msse4.2 -mpclmul"
  fi
-else
-  # PORTABLE=1
-  if test "$USE_SSE"; then
-    TRY_SSE_ETC="1"
-  fi
+elif test "$USE_SSE"; then
+  COMMON_FLAGS="$COMMON_FLAGS -msse4.2 -mpclmul"
 fi

-if test "$TRY_SSE_ETC"; then
-  # The USE_SSE flag now means "attempt to compile with widely-available
-  # Intel architecture extensions utilized by specific optimizations in the
-  # source code." It's a qualifier on PORTABLE=1 that means "mostly portable."
-  # It doesn't even really check that your current CPU is compatible.
-  #
-  # SSE4.2 available since nehalem, ca. 2008-2010
-  TRY_SSE42="-msse4.2"
-  # PCLMUL available since westmere, ca. 2010-2011
-  TRY_PCLMUL="-mpclmul"
-fi
-
-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF
  #include <cstdint>
  #include <nmmintrin.h>
  int main() {
@@ -583,12 +562,13 @@ $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_SSE42 -x c++ - -o /dev/null 2>/dev/nu
  }
 EOF
 if [ "$?" = 0 ]; then
-  COMMON_FLAGS="$COMMON_FLAGS $TRY_SSE42 -DHAVE_SSE42"
+  COMMON_FLAGS="$COMMON_FLAGS -DHAVE_SSE42"
 elif test "$USE_SSE"; then
  echo "warning: USE_SSE specified but compiler could not use SSE intrinsics, disabling" >&2
+  exit 1
 fi

-$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o /dev/null 2>/dev/null <<EOF
+$CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS -x c++ - -o /dev/null 2>/dev/null <<EOF
  #include <cstdint>
  #include <wmmintrin.h>
  int main() {
@@ -600,9 +580,10 @@ $CXX $PLATFORM_CXXFLAGS $COMMON_FLAGS $TRY_PCLMUL -x c++ - -o /dev/null 2>/dev/n
  }
 EOF
 if [ "$?" = 0 ]; then
-  COMMON_FLAGS="$COMMON_FLAGS $TRY_PCLMUL -DHAVE_PCLMUL"
+  COMMON_FLAGS="$COMMON_FLAGS -DHAVE_PCLMUL"
 elif test "$USE_SSE"; then
  echo "warning: USE_SSE specified but compiler could not use PCLMUL intrinsics, disabling" >&2
+  exit 1
 fi

 # iOS doesn't support thread-local storage, but this check would erroneously
@@ -680,6 +661,3 @@ if test -n "$WITH_JEMALLOC_FLAG"; then
  echo "WITH_JEMALLOC_FLAG=$WITH_JEMALLOC_FLAG" >> "$OUTPUT"
 fi
 echo "LUA_PATH=$LUA_PATH" >> "$OUTPUT"
-if test -n "$USE_FOLLY_DISTRIBUTED_MUTEX"; then
-  echo "USE_FOLLY_DISTRIBUTED_MUTEX=$USE_FOLLY_DISTRIBUTED_MUTEX" >> "$OUTPUT"
-fi
@@ -86,10 +86,9 @@ else
 fi
 CFLAGS+=" -DTBB"

-test "$USE_SSE" || USE_SSE=1
-export USE_SSE
-test "$PORTABLE" || PORTABLE=1
-export PORTABLE
+# use Intel SSE support for checksum calculations
+export USE_SSE=1
+export PORTABLE=1

 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"
@@ -160,6 +159,4 @@ else
  LUA_LIB=" $LUA_PATH/lib/liblua_pic.a"
 fi

-USE_FOLLY_DISTRIBUTED_MUTEX=1
-
 export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
@@ -53,10 +53,9 @@ LIBUNWIND="$LIBUNWIND_BASE/lib/libunwind.a"
 TBB_INCLUDE=" -isystem $TBB_BASE/include/"
 TBB_LIBS="$TBB_BASE/lib/libtbb.a"

-test "$USE_SSE" || USE_SSE=1
-export USE_SSE
-test "$PORTABLE" || PORTABLE=1
-export PORTABLE
+# use Intel SSE support for checksum calculations
+export USE_SSE=1
+export PORTABLE=1

 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"
@@ -86,10 +86,9 @@ else
 fi
 CFLAGS+=" -DTBB"

-test "$USE_SSE" || USE_SSE=1
-export USE_SSE
-test "$PORTABLE" || PORTABLE=1
-export PORTABLE
+# use Intel SSE support for checksum calculations
+export USE_SSE=1
+export PORTABLE=1

 BINUTILS="$BINUTILS_BASE/bin"
 AR="$BINUTILS/ar"
@@ -156,6 +155,4 @@ VALGRIND_VER="$VALGRIND_BASE/bin/"
 LUA_PATH=
 LUA_LIB=

-USE_FOLLY_DISTRIBUTED_MUTEX=1
-
 export CC CXX AR CFLAGS CXXFLAGS EXEC_LDFLAGS EXEC_LDFLAGS_SHARED VALGRIND_VER JEMALLOC_LIB JEMALLOC_INCLUDE CLANG_ANALYZER CLANG_SCAN_BUILD LUA_PATH LUA_LIB
@@ -63,21 +63,6 @@ CLEANUP_ENV="
    'user':'root'
 }"

-UPLOAD_DB_DIR="
-{
-    'name':'Upload database directory',
-    'shell':'tar -cvzf rocksdb_db.tar.gz /dev/shm/rocksdb/',
-    'user':'root',
-    'cleanup':true,
-    'provide_artifacts': [
-    {
-      'name':'rocksdb_db_dir',
-      'paths': ['rocksdb_db.tar.gz'],
-      'bundle': false,
-    },
-    ],
-}"
-
 # We will eventually set the RATIO to 1, but we want do this
 # in steps. RATIO=$(nproc) will make it work as J=1
 if [ -z $RATIO ]; then
@@ -443,8 +428,7 @@ STRESS_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 crash_test_with_atomic_flush || $CONTRUN_NAME=crash_test_with_atomic_flush $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
-            },
-            $UPLOAD_DB_DIR,
+            }
        ],
        $REPORT
    }
@@ -535,7 +519,6 @@ ASAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
                'user':'root',
                $PARSER
            },
-            $UPLOAD_DB_DIR,
        ],
        $REPORT
    }
@@ -603,7 +586,6 @@ UBSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
                'user':'root',
                $PARSER
            },
-            $UPLOAD_DB_DIR,
        ],
        $REPORT
    }
@@ -696,7 +678,6 @@ TSAN_CRASH_TEST_WITH_ATOMIC_FLUSH_COMMANDS="[
                'user':'root',
                $PARSER
            },
-            $UPLOAD_DB_DIR,
        ],
        $REPORT
    }
@@ -90,7 +90,7 @@ class CacheTest : public testing::TestWithParam<std::string> {
                                  bool strict_capacity_limit) {
    auto type = GetParam();
    if (type == kLRU) {
-      return NewLRUCache(capacity, num_shard_bits, strict_capacity_limit, 0.0);
+      return NewLRUCache(capacity, num_shard_bits, strict_capacity_limit);
    }
    if (type == kClock) {
      return NewClockCache(capacity, num_shard_bits, strict_capacity_limit);
@@ -562,7 +562,6 @@ TEST_P(CacheTest, SetStrictCapacityLimit) {
    ASSERT_OK(s);
    ASSERT_NE(nullptr, handles[i]);
  }
-  ASSERT_EQ(10, cache->GetUsage());

  // test2: set the flag to true. Insert and check if it fails.
  std::string extra_key = "extra";
@@ -572,7 +571,6 @@ TEST_P(CacheTest, SetStrictCapacityLimit) {
  s = cache->Insert(extra_key, extra_value, 1, &deleter, &handle);
  ASSERT_TRUE(s.IsIncomplete());
  ASSERT_EQ(nullptr, handle);
-  ASSERT_EQ(10, cache->GetUsage());

  for (size_t i = 0; i < 10; i++) {
    cache->Release(handles[i]);
@@ -593,7 +591,7 @@ TEST_P(CacheTest, SetStrictCapacityLimit) {
  s = cache2->Insert(extra_key, extra_value, 1, &deleter);
  // AS if the key have been inserted into cache but get evicted immediately.
  ASSERT_OK(s);
-  ASSERT_EQ(5, cache2->GetUsage());
+  ASSERT_EQ(5, cache->GetUsage());
  ASSERT_EQ(nullptr, cache2->Lookup(extra_key));

  for (size_t i = 0; i < 5; i++) {
@@ -24,7 +24,7 @@ LRUHandleTable::LRUHandleTable() : list_(nullptr), length_(0), elems_(0) {

 LRUHandleTable::~LRUHandleTable() {
  ApplyToAllCacheEntries([](LRUHandle* h) {
-    if (!h->HasRefs()) {
+    if (h->refs == 1) {
      h->Free();
    }
  });
@@ -113,17 +113,29 @@ LRUCacheShard::LRUCacheShard(size_t capacity, bool strict_capacity_limit,
  SetCapacity(capacity);
 }

+LRUCacheShard::~LRUCacheShard() {}
+
+bool LRUCacheShard::Unref(LRUHandle* e) {
+  assert(e->refs > 0);
+  e->refs--;
+  return e->refs == 0;
+}
+
+// Call deleter and free
+
 void LRUCacheShard::EraseUnRefEntries() {
  autovector<LRUHandle*> last_reference_list;
  {
    MutexLock l(&mutex_);
    while (lru_.next != &lru_) {
      LRUHandle* old = lru_.next;
-      // LRU list contains only elements which can be evicted
-      assert(old->InCache() && !old->HasRefs());
+      assert(old->InCache());
+      assert(old->refs ==
+             1);  // LRU list contains elements which may be evicted
      LRU_Remove(old);
      table_.Remove(old->key(), old->hash);
      old->SetInCache(false);
+      Unref(old);
      usage_ -= old->charge;
      last_reference_list.push_back(old);
    }
@@ -136,27 +148,22 @@ void LRUCacheShard::EraseUnRefEntries() {

 void LRUCacheShard::ApplyToAllCacheEntries(void (*callback)(void*, size_t),
                                           bool thread_safe) {
-  const auto applyCallback = [&]() {
-    table_.ApplyToAllCacheEntries(
-        [callback](LRUHandle* h) { callback(h->value, h->charge); });
-  };
-
  if (thread_safe) {
-    MutexLock l(&mutex_);
-    applyCallback();
-  } else {
-    applyCallback();
+    mutex_.Lock();
+  }
+  table_.ApplyToAllCacheEntries(
+      [callback](LRUHandle* h) { callback(h->value, h->charge); });
+  if (thread_safe) {
+    mutex_.Unlock();
  }
 }

 void LRUCacheShard::TEST_GetLRUList(LRUHandle** lru, LRUHandle** lru_low_pri) {
-  MutexLock l(&mutex_);
  *lru = &lru_;
  *lru_low_pri = lru_low_pri_;
 }

 size_t LRUCacheShard::TEST_GetLRUSize() {
-  MutexLock l(&mutex_);
  LRUHandle* lru_handle = lru_.next;
  size_t lru_size = 0;
  while (lru_handle != &lru_) {
@@ -224,13 +231,14 @@ void LRUCacheShard::MaintainPoolSize() {

 void LRUCacheShard::EvictFromLRU(size_t charge,
                                 autovector<LRUHandle*>* deleted) {
-  while ((usage_ + charge) > capacity_ && lru_.next != &lru_) {
+  while (usage_ + charge > capacity_ && lru_.next != &lru_) {
    LRUHandle* old = lru_.next;
-    // LRU list contains only elements which can be evicted
-    assert(old->InCache() && !old->HasRefs());
+    assert(old->InCache());
+    assert(old->refs == 1);  // LRU list contains elements which may be evicted
    LRU_Remove(old);
    table_.Remove(old->key(), old->hash);
    old->SetInCache(false);
+    Unref(old);
    usage_ -= old->charge;
    deleted->push_back(old);
  }
@@ -244,8 +252,8 @@ void LRUCacheShard::SetCapacity(size_t capacity) {
    high_pri_pool_capacity_ = capacity_ * high_pri_pool_ratio_;
    EvictFromLRU(0, &last_reference_list);
  }
-
-  // Free the entries outside of mutex for performance reasons
+  // we free the entries here outside of mutex for
+  // performance reasons
  for (auto entry : last_reference_list) {
    entry->Free();
  }
@@ -261,22 +269,22 @@ Cache::Handle* LRUCacheShard::Lookup(const Slice& key, uint32_t hash) {
  LRUHandle* e = table_.Lookup(key, hash);
  if (e != nullptr) {
    assert(e->InCache());
-    if (!e->HasRefs()) {
-      // The entry is in LRU since it's in hash and has no external references
+    if (e->refs == 1) {
      LRU_Remove(e);
    }
-    e->Ref();
+    e->refs++;
    e->SetHit();
  }
  return reinterpret_cast<Cache::Handle*>(e);
 }

 bool LRUCacheShard::Ref(Cache::Handle* h) {
-  LRUHandle* e = reinterpret_cast<LRUHandle*>(h);
+  LRUHandle* handle = reinterpret_cast<LRUHandle*>(h);
  MutexLock l(&mutex_);
-  // To create another reference - entry must be already externally referenced
-  assert(e->HasRefs());
-  e->Ref();
+  if (handle->InCache() && handle->refs == 1) {
+    LRU_Remove(handle);
+  }
+  handle->refs++;
  return true;
 }

@@ -295,27 +303,30 @@ bool LRUCacheShard::Release(Cache::Handle* handle, bool force_erase) {
  bool last_reference = false;
  {
    MutexLock l(&mutex_);
-    last_reference = e->Unref();
-    if (last_reference && e->InCache()) {
-      // The item is still in cache, and nobody else holds a reference to it
-      if (usage_ > capacity_ || force_erase) {
-        // The LRU list must be empty since the cache is full
-        assert(lru_.next == &lru_ || force_erase);
-        // Take this opportunity and remove the item
-        table_.Remove(e->key(), e->hash);
-        e->SetInCache(false);
-      } else {
-        // Put the item back on the LRU list, and don't free it
-        LRU_Insert(e);
-        last_reference = false;
-      }
-    }
+    last_reference = Unref(e);
    if (last_reference) {
      usage_ -= e->charge;
    }
+    if (e->refs == 1 && e->InCache()) {
+      // The item is still in cache, and nobody else holds a reference to it
+      if (usage_ > capacity_ || force_erase) {
+        // the cache is full
+        // The LRU list must be empty since the cache is full
+        assert(!(usage_ > capacity_) || lru_.next == &lru_);
+        // take this opportunity and remove the item
+        table_.Remove(e->key(), e->hash);
+        e->SetInCache(false);
+        Unref(e);
+        usage_ -= e->charge;
+        last_reference = true;
+      } else {
+        // put the item on the list to be potentially freed
+        LRU_Insert(e);
+      }
+    }
  }

-  // Free the entry here outside of mutex for performance reasons
+  // free outside of mutex
  if (last_reference) {
    e->Free();
  }
@@ -331,7 +342,7 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  // It shouldn't happen very often though.
  LRUHandle* e = reinterpret_cast<LRUHandle*>(
      new char[sizeof(LRUHandle) - 1 + key.size()]);
-  Status s = Status::OK();
+  Status s;
  autovector<LRUHandle*> last_reference_list;

  e->value = value;
@@ -340,7 +351,9 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
  e->key_length = key.size();
  e->flags = 0;
  e->hash = hash;
-  e->refs = 0;
+  e->refs = (handle == nullptr
+                 ? 1
+                 : 2);  // One from LRUCache, one for the returned handle
  e->next = e->prev = nullptr;
  e->SetInCache(true);
  e->SetPriority(priority);
@@ -353,12 +366,11 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
    // is freed or the lru list is empty
    EvictFromLRU(charge, &last_reference_list);

-    if ((usage_ + charge) > capacity_ &&
+    if (usage_ - lru_usage_ + charge > capacity_ &&
        (strict_capacity_limit_ || handle == nullptr)) {
      if (handle == nullptr) {
        // Don't insert the entry but still return ok, as if the entry inserted
        // into cache and get evicted immediately.
-        e->SetInCache(false);
        last_reference_list.push_back(e);
      } else {
        delete[] reinterpret_cast<char*>(e);
@@ -366,30 +378,32 @@ Status LRUCacheShard::Insert(const Slice& key, uint32_t hash, void* value,
        s = Status::Incomplete("Insert failed due to LRU cache being full.");
      }
    } else {
-      // Insert into the cache. Note that the cache might get larger than its
-      // capacity if not enough space was freed up.
+      // insert into the cache
+      // note that the cache might get larger than its capacity if not enough
+      // space was freed
      LRUHandle* old = table_.Insert(e);
      usage_ += e->charge;
      if (old != nullptr) {
-        assert(old->InCache());
        old->SetInCache(false);
-        if (!old->HasRefs()) {
-          // old is on LRU because it's in cache and its reference count is 0
-          LRU_Remove(old);
+        if (Unref(old)) {
          usage_ -= old->charge;
+          // old is on LRU because it's in cache and its reference count
+          // was just 1 (Unref returned 0)
+          LRU_Remove(old);
          last_reference_list.push_back(old);
        }
      }
      if (handle == nullptr) {
        LRU_Insert(e);
      } else {
-        e->Ref();
        *handle = reinterpret_cast<Cache::Handle*>(e);
      }
+      s = Status::OK();
    }
  }

-  // Free the entries here outside of mutex for performance reasons
+  // we free the entries here outside of mutex for
+  // performance reasons
  for (auto entry : last_reference_list) {
    entry->Free();
  }
@@ -404,18 +418,18 @@ void LRUCacheShard::Erase(const Slice& key, uint32_t hash) {
    MutexLock l(&mutex_);
    e = table_.Remove(key, hash);
    if (e != nullptr) {
-      assert(e->InCache());
-      e->SetInCache(false);
-      if (!e->HasRefs()) {
-        // The entry is in LRU since it's in hash and has no external references
-        LRU_Remove(e);
+      last_reference = Unref(e);
+      if (last_reference) {
        usage_ -= e->charge;
-        last_reference = true;
      }
+      if (last_reference && e->InCache()) {
+        LRU_Remove(e);
+      }
+      e->SetInCache(false);
    }
  }

-  // Free the entry here outside of mutex for performance reasons
+  // mutex not held here
  // last_reference will only be true if e != nullptr
  if (last_reference) {
    e->Free();
@@ -17,34 +17,31 @@

 namespace rocksdb {

-// LRU cache implementation. This class is not thread-safe.
+// LRU cache implementation

 // An entry is a variable length heap-allocated structure.
 // Entries are referenced by cache and/or by any external entity.
-// The cache keeps all its entries in a hash table. Some elements
+// The cache keeps all its entries in table. Some elements
 // are also stored on LRU list.
 //
 // LRUHandle can be in these states:
 // 1. Referenced externally AND in hash table.
-//    In that case the entry is *not* in the LRU list
-//    (refs >= 1 && in_cache == true)
-// 2. Not referenced externally AND in hash table.
-//    In that case the entry is in the LRU list and can be freed.
-//    (refs == 0 && in_cache == true)
-// 3. Referenced externally AND not in hash table.
-//    In that case the entry is not in the LRU list and not in hash table.
-//    The entry can be freed when refs becomes 0.
-//    (refs >= 1 && in_cache == false)
+//  In that case the entry is *not* in the LRU. (refs > 1 && in_cache == true)
+// 2. Not referenced externally and in hash table. In that case the entry is
+// in the LRU and can be freed. (refs == 1 && in_cache == true)
+// 3. Referenced externally and not in hash table. In that case the entry is
+// in not on LRU and not in table. (refs >= 1 && in_cache == false)
 //
 // All newly created LRUHandles are in state 1. If you call
-// LRUCacheShard::Release on entry in state 1, it will go into state 2.
-// To move from state 1 to state 3, either call LRUCacheShard::Erase or
-// LRUCacheShard::Insert with the same key (but possibly different value).
+// LRUCacheShard::Release
+// on entry in state 1, it will go into state 2. To move from state 1 to
+// state 3, either call LRUCacheShard::Erase or LRUCacheShard::Insert with the
+// same key.
 // To move from state 2 to state 1, use LRUCacheShard::Lookup.
 // Before destruction, make sure that no handles are in state 1. This means
 // that any successful LRUCacheShard::Lookup/LRUCacheShard::Insert have a
-// matching LRUCache::Release (to move into state 2) or LRUCacheShard::Erase
-// (to move into state 3).
+// matching
+// RUCache::Release (to move into state 2) or LRUCacheShard::Erase (for state 3)

 struct LRUHandle {
  void* value;
@@ -54,42 +51,37 @@ struct LRUHandle {
  LRUHandle* prev;
  size_t charge;  // TODO(opt): Only allow uint32_t?
  size_t key_length;
-  // The hash of key(). Used for fast sharding and comparisons.
-  uint32_t hash;
-  // The number of external refs to this entry. The cache itself is not counted.
-  uint32_t refs;
+  uint32_t refs;     // a number of refs to this entry
+                     // cache itself is counted as 1

+  // Include the following flags:
+  //   IN_CACHE:         whether this entry is referenced by the hash table.
+  //   IS_HIGH_PRI:      whether this entry is high priority entry.
+  //   IN_HIGH_PRI_POOL: whether this entry is in high-pri pool.
+  //   HAS_HIT:          whether this entry has had any lookups (hits).
  enum Flags : uint8_t {
-    // Whether this entry is referenced by the hash table.
    IN_CACHE = (1 << 0),
-    // Whether this entry is high priority entry.
    IS_HIGH_PRI = (1 << 1),
-    // Whether this entry is in high-pri pool.
    IN_HIGH_PRI_POOL = (1 << 2),
-    // Wwhether this entry has had any lookups (hits).
    HAS_HIT = (1 << 3),
  };

  uint8_t flags;

-  // Beginning of the key (MUST BE THE LAST FIELD IN THIS STRUCT!)
-  char key_data[1];
+  uint32_t hash;     // Hash of key(); used for fast sharding and comparisons

-  Slice key() const { return Slice(key_data, key_length); }
+  char key_data[1];  // Beginning of key

-  // Increase the reference count by 1.
-  void Ref() { refs++; }
-
-  // Just reduce the reference count by 1. Return true if it was last reference.
-  bool Unref() {
-    assert(refs > 0);
-    refs--;
-    return refs == 0;
+  Slice key() const {
+    // For cheaper lookups, we allow a temporary Handle object
+    // to store a pointer to a key in "value".
+    if (next == this) {
+      return *(reinterpret_cast<Slice*>(value));
+    } else {
+      return Slice(key_data, key_length);
+    }
  }

-  // Return true if there are external refs, false otherwise.
-  bool HasRefs() const { return refs > 0; }
-
  bool InCache() const { return flags & IN_CACHE; }
  bool IsHighPri() const { return flags & IS_HIGH_PRI; }
  bool InHighPriPool() const { return flags & IN_HIGH_PRI_POOL; }
@@ -122,7 +114,7 @@ struct LRUHandle {
  void SetHit() { flags |= HAS_HIT; }

  void Free() {
-    assert(refs == 0);
+    assert((refs == 1 && InCache()) || (refs == 0 && !InCache()));
    if (deleter) {
      (*deleter)(key(), value);
    }
@@ -177,7 +169,7 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
 public:
  LRUCacheShard(size_t capacity, bool strict_capacity_limit,
                double high_pri_pool_ratio, bool use_adaptive_mutex);
-  virtual ~LRUCacheShard() override = default;
+  virtual ~LRUCacheShard();

  // Separate from constructor so caller can easily make an array of LRUCache
  // if current usage is more than new capacity, the function will attempt to
@@ -233,6 +225,10 @@ class ALIGN_AS(CACHE_LINE_SIZE) LRUCacheShard final : public CacheShard {
  // high-pri pool is no larger than the size specify by high_pri_pool_pct.
  void MaintainPoolSize();

+  // Just reduce the reference count by 1.
+  // Return true if last reference
+  bool Unref(LRUHandle* e);
+
  // Free some space following strict LRU policy until enough space
  // to hold (usage_ + charge) is freed or the lru list is empty
  // This function is not thread safe - it needs to be executed while
@@ -1,29 +1,21 @@
 # - Find JeMalloc library
 # Find the native JeMalloc includes and library
 #
-# JeMalloc_INCLUDE_DIRS - where to find jemalloc.h, etc.
-# JeMalloc_LIBRARIES - List of libraries when using jemalloc.
-# JeMalloc_FOUND - True if jemalloc found.
+# JEMALLOC_INCLUDE_DIR - where to find jemalloc.h, etc.
+# JEMALLOC_LIBRARIES - List of libraries when using jemalloc.
+# JEMALLOC_FOUND - True if jemalloc found.

-find_path(JeMalloc_INCLUDE_DIRS
+find_path(JEMALLOC_INCLUDE_DIR
  NAMES jemalloc/jemalloc.h
  HINTS ${JEMALLOC_ROOT_DIR}/include)

-find_library(JeMalloc_LIBRARIES
+find_library(JEMALLOC_LIBRARIES
  NAMES jemalloc
  HINTS ${JEMALLOC_ROOT_DIR}/lib)

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(JeMalloc DEFAULT_MSG JeMalloc_LIBRARIES JeMalloc_INCLUDE_DIRS)
+find_package_handle_standard_args(jemalloc DEFAULT_MSG JEMALLOC_LIBRARIES JEMALLOC_INCLUDE_DIR)

 mark_as_advanced(
-  JeMalloc_LIBRARIES
-  JeMalloc_INCLUDE_DIRS)
-
-if(JeMalloc_FOUND AND NOT (TARGET JeMalloc::JeMalloc))
-  add_library (JeMalloc::JeMalloc UNKNOWN IMPORTED)
-  set_target_properties(JeMalloc::JeMalloc
-    PROPERTIES
-      IMPORTED_LOCATION ${JeMalloc_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${JeMalloc_INCLUDE_DIRS})
-endif()
+  JEMALLOC_LIBRARIES
+  JEMALLOC_INCLUDE_DIR)
@@ -1,11 +1,11 @@
 # - Find NUMA
 # Find the NUMA library and includes
 #
-# NUMA_INCLUDE_DIRS - where to find numa.h, etc.
+# NUMA_INCLUDE_DIR - where to find numa.h, etc.
 # NUMA_LIBRARIES - List of libraries when using NUMA.
 # NUMA_FOUND - True if NUMA found.

-find_path(NUMA_INCLUDE_DIRS
+find_path(NUMA_INCLUDE_DIR
  NAMES numa.h numaif.h
  HINTS ${NUMA_ROOT_DIR}/include)

@@ -14,16 +14,8 @@ find_library(NUMA_LIBRARIES
  HINTS ${NUMA_ROOT_DIR}/lib)

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(NUMA DEFAULT_MSG NUMA_LIBRARIES NUMA_INCLUDE_DIRS)
+find_package_handle_standard_args(NUMA DEFAULT_MSG NUMA_LIBRARIES NUMA_INCLUDE_DIR)

 mark_as_advanced(
  NUMA_LIBRARIES
-  NUMA_INCLUDE_DIRS)
-
-if(NUMA_FOUND AND NOT (TARGET NUMA::NUMA))
-  add_library (NUMA::NUMA UNKNOWN IMPORTED)
-  set_target_properties(NUMA::NUMA
-    PROPERTIES
-      IMPORTED_LOCATION ${NUMA_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${NUMA_INCLUDE_DIRS})
-endif()
+  NUMA_INCLUDE_DIR)
@@ -1,7 +1,7 @@
 # - Find TBB
 # Find the Thread Building Blocks library and includes
 #
-# TBB_INCLUDE_DIRS - where to find tbb.h, etc.
+# TBB_INCLUDE_DIR - where to find tbb.h, etc.
 # TBB_LIBRARIES - List of libraries when using TBB.
 # TBB_FOUND - True if TBB found.

@@ -9,25 +9,17 @@ if(NOT DEFINED TBB_ROOT_DIR)
  set(TBB_ROOT_DIR "$ENV{TBBROOT}")
 endif()

-find_path(TBB_INCLUDE_DIRS
-  NAMES tbb/tbb.h
-  HINTS ${TBB_ROOT_DIR}/include)
+find_path(TBB_INCLUDE_DIR
+NAMES tbb/tbb.h
+HINTS ${TBB_ROOT_DIR}/include)

 find_library(TBB_LIBRARIES
-  NAMES tbb
-  HINTS ${TBB_ROOT_DIR}/lib ENV LIBRARY_PATH)
+NAMES tbb
+HINTS ${TBB_ROOT_DIR}/lib ENV LIBRARY_PATH)

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(TBB DEFAULT_MSG TBB_LIBRARIES TBB_INCLUDE_DIRS)
+find_package_handle_standard_args(TBB DEFAULT_MSG TBB_LIBRARIES TBB_INCLUDE_DIR)

 mark_as_advanced(
-  TBB_LIBRARIES
-  TBB_INCLUDE_DIRS)
-
-if(TBB_FOUND AND NOT (TARGET TBB::TBB))
-  add_library (TBB::TBB UNKNOWN IMPORTED)
-  set_target_properties(TBB::TBB
-    PROPERTIES
-      IMPORTED_LOCATION ${TBB_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${TBB_INCLUDE_DIRS})
-endif()
+TBB_LIBRARIES
+TBB_INCLUDE_DIR)
@@ -0,0 +1,21 @@
+# - Find Bzip2
+# Find the bzip2 compression library and includes
+#
+# BZIP2_INCLUDE_DIR - where to find bzlib.h, etc.
+# BZIP2_LIBRARIES - List of libraries when using bzip2.
+# BZIP2_FOUND - True if bzip2 found.
+
+find_path(BZIP2_INCLUDE_DIR
+  NAMES bzlib.h
+  HINTS ${BZIP2_ROOT_DIR}/include)
+
+find_library(BZIP2_LIBRARIES
+  NAMES bz2
+  HINTS ${BZIP2_ROOT_DIR}/lib)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(bzip2 DEFAULT_MSG BZIP2_LIBRARIES BZIP2_INCLUDE_DIR)
+
+mark_as_advanced(
+  BZIP2_LIBRARIES
+  BZIP2_INCLUDE_DIR)
@@ -1,29 +1,21 @@
 # - Find Lz4
 # Find the lz4 compression library and includes
 #
-# lz4_INCLUDE_DIRS - where to find lz4.h, etc.
-# lz4_LIBRARIES - List of libraries when using lz4.
-# lz4_FOUND - True if lz4 found.
+# LZ4_INCLUDE_DIR - where to find lz4.h, etc.
+# LZ4_LIBRARIES - List of libraries when using lz4.
+# LZ4_FOUND - True if lz4 found.

-find_path(lz4_INCLUDE_DIRS
+find_path(LZ4_INCLUDE_DIR
  NAMES lz4.h
-  HINTS ${lz4_ROOT_DIR}/include)
+  HINTS ${LZ4_ROOT_DIR}/include)

-find_library(lz4_LIBRARIES
+find_library(LZ4_LIBRARIES
  NAMES lz4
-  HINTS ${lz4_ROOT_DIR}/lib)
+  HINTS ${LZ4_ROOT_DIR}/lib)

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(lz4 DEFAULT_MSG lz4_LIBRARIES lz4_INCLUDE_DIRS)
+find_package_handle_standard_args(lz4 DEFAULT_MSG LZ4_LIBRARIES LZ4_INCLUDE_DIR)

 mark_as_advanced(
-  lz4_LIBRARIES
-  lz4_INCLUDE_DIRS)
-
-if(lz4_FOUND AND NOT (TARGET lz4::lz4))
-  add_library(lz4::lz4 UNKNOWN IMPORTED)
-  set_target_properties(lz4::lz4
-    PROPERTIES
-      IMPORTED_LOCATION ${lz4_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${lz4_INCLUDE_DIRS})
-endif()
+  LZ4_LIBRARIES
+  LZ4_INCLUDE_DIR)
@@ -1,29 +1,21 @@
 # - Find Snappy
 # Find the snappy compression library and includes
 #
-# snappy_INCLUDE_DIRS - where to find snappy.h, etc.
-# snappy_LIBRARIES - List of libraries when using snappy.
-# snappy_FOUND - True if snappy found.
+# SNAPPY_INCLUDE_DIR - where to find snappy.h, etc.
+# SNAPPY_LIBRARIES - List of libraries when using snappy.
+# SNAPPY_FOUND - True if snappy found.

-find_path(snappy_INCLUDE_DIRS
+find_path(SNAPPY_INCLUDE_DIR
  NAMES snappy.h
-  HINTS ${snappy_ROOT_DIR}/include)
+  HINTS ${SNAPPY_ROOT_DIR}/include)

-find_library(snappy_LIBRARIES
+find_library(SNAPPY_LIBRARIES
  NAMES snappy
-  HINTS ${snappy_ROOT_DIR}/lib)
+  HINTS ${SNAPPY_ROOT_DIR}/lib)

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(snappy DEFAULT_MSG snappy_LIBRARIES snappy_INCLUDE_DIRS)
+find_package_handle_standard_args(snappy DEFAULT_MSG SNAPPY_LIBRARIES SNAPPY_INCLUDE_DIR)

 mark_as_advanced(
-  snappy_LIBRARIES
-  snappy_INCLUDE_DIRS)
-
-if(snappy_FOUND AND NOT (TARGET snappy::snappy))
-  add_library (snappy::snappy UNKNOWN IMPORTED)
-  set_target_properties(snappy::snappy
-    PROPERTIES
-      IMPORTED_LOCATION ${snappy_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${snappy_INCLUDE_DIRS})
-endif()
+  SNAPPY_LIBRARIES
+  SNAPPY_INCLUDE_DIR)
@@ -1,29 +1,21 @@
 # - Find zstd
 # Find the zstd compression library and includes
 #
-# zstd_INCLUDE_DIRS - where to find zstd.h, etc.
-# zstd_LIBRARIES - List of libraries when using zstd.
-# zstd_FOUND - True if zstd found.
+# ZSTD_INCLUDE_DIR - where to find zstd.h, etc.
+# ZSTD_LIBRARIES - List of libraries when using zstd.
+# ZSTD_FOUND - True if zstd found.

-find_path(zstd_INCLUDE_DIRS
+find_path(ZSTD_INCLUDE_DIR
  NAMES zstd.h
-  HINTS ${zstd_ROOT_DIR}/include)
+  HINTS ${ZSTD_ROOT_DIR}/include)

-find_library(zstd_LIBRARIES
+find_library(ZSTD_LIBRARIES
  NAMES zstd
-  HINTS ${zstd_ROOT_DIR}/lib)
+  HINTS ${ZSTD_ROOT_DIR}/lib)

 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(zstd DEFAULT_MSG zstd_LIBRARIES zstd_INCLUDE_DIRS)
+find_package_handle_standard_args(zstd DEFAULT_MSG ZSTD_LIBRARIES ZSTD_INCLUDE_DIR)

 mark_as_advanced(
-  zstd_LIBRARIES
-  zstd_INCLUDE_DIRS)
-
-if(zstd_FOUND AND NOT (TARGET zstd::zstd))
-  add_library (zstd::zstd UNKNOWN IMPORTED)
-  set_target_properties(zstd::zstd
-    PROPERTIES
-      IMPORTED_LOCATION ${zstd_LIBRARIES}
-      INTERFACE_INCLUDE_DIRECTORIES ${zstd_INCLUDE_DIRS})
-endif()
+  ZSTD_LIBRARIES
+  ZSTD_INCLUDE_DIR)
@@ -1,10 +0,0 @@
-# Read rocksdb version from version.h header file.
-
-function(get_rocksdb_version version_var)
-  file(READ "${CMAKE_SOURCE_DIR}/include/rocksdb/version.h" version_header_file)
-  foreach(component MAJOR MINOR PATCH)
-    string(REGEX MATCH "#define ROCKSDB_${component} ([0-9]+)" _ ${version_header_file})
-    set(ROCKSDB_VERSION_${component} ${CMAKE_MATCH_1})
-  endforeach()
-  set(${version_var} "${ROCKSDB_VERSION_MAJOR}.${ROCKSDB_VERSION_MINOR}.${ROCKSDB_VERSION_PATCH}" PARENT_SCOPE)
-endfunction()
@@ -1,4 +1,3 @@
-#!/usr/bin/env python2
 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
 import re
 import sys
@@ -221,9 +221,8 @@ Status BuildTable(
          mutable_cf_options.prefix_extractor.get(), nullptr,
          (internal_stats == nullptr) ? nullptr
                                      : internal_stats->GetFileReadHist(0),
-          TableReaderCaller::kFlush, /*arena=*/nullptr,
-          /*skip_filter=*/false, level, /*smallest_compaction_key=*/nullptr,
-          /*largest_compaction_key*/ nullptr));
+          false /* for_compaction */, nullptr /* arena */,
+          false /* skip_filter */, level));
      s = it->status();
      if (s.ok() && paranoid_file_checks) {
        for (it->SeekToFirst(); it->Valid(); it->Next()) {
@@ -1034,7 +1034,7 @@ void rocksdb_wal_iter_destroy (const rocksdb_wal_iterator_t* iter) {
 rocksdb_writebatch_t* rocksdb_wal_iter_get_batch (const rocksdb_wal_iterator_t* iter, uint64_t* seq) {
  rocksdb_writebatch_t* result = rocksdb_writebatch_create();
  BatchResult wal_batch = iter->rep->GetBatch();
-  result->rep = std::move(*wal_batch.writeBatchPtr);
+  result->rep = * wal_batch.writeBatchPtr.release();
  if (seq != nullptr) {
    *seq = wal_batch.sequence;
  }
@@ -2514,11 +2514,6 @@ void rocksdb_options_set_max_write_buffer_number_to_maintain(
  opt->rep.max_write_buffer_number_to_maintain = n;
 }

-void rocksdb_options_set_max_write_buffer_size_to_maintain(
-    rocksdb_options_t* opt, int64_t n) {
-  opt->rep.max_write_buffer_size_to_maintain = n;
-}
-
 void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt,
                                                unsigned char v) {
  opt->rep.enable_pipelined_write = v;
@@ -3224,11 +3219,6 @@ void rocksdb_writeoptions_set_low_pri(
  opt->rep.low_pri = v;
 }

-void rocksdb_writeoptions_set_memtable_insert_hint_per_batch(
-    rocksdb_writeoptions_t* opt, unsigned char v) {
-  opt->rep.memtable_insert_hint_per_batch = v;
-}
-
 rocksdb_compactoptions_t* rocksdb_compactoptions_create() {
  return new rocksdb_compactoptions_t;
 }
@@ -227,14 +227,7 @@ ColumnFamilyOptions SanitizeOptions(const ImmutableDBOptions& db_options,
  if (result.max_write_buffer_number < 2) {
    result.max_write_buffer_number = 2;
  }
-  // fall back max_write_buffer_number_to_maintain if
-  // max_write_buffer_size_to_maintain is not set
-  if (result.max_write_buffer_size_to_maintain < 0) {
-    result.max_write_buffer_size_to_maintain =
-        result.max_write_buffer_number *
-        static_cast<int64_t>(result.write_buffer_size);
-  } else if (result.max_write_buffer_size_to_maintain == 0 &&
-             result.max_write_buffer_number_to_maintain < 0) {
+  if (result.max_write_buffer_number_to_maintain < 0) {
    result.max_write_buffer_number_to_maintain = result.max_write_buffer_number;
  }
  // bloom filter size shouldn't exceed 1/4 of memtable size.
@@ -430,8 +423,7 @@ ColumnFamilyData::ColumnFamilyData(
      write_buffer_manager_(write_buffer_manager),
      mem_(nullptr),
      imm_(ioptions_.min_write_buffer_number_to_merge,
-           ioptions_.max_write_buffer_number_to_maintain,
-           ioptions_.max_write_buffer_size_to_maintain),
+           ioptions_.max_write_buffer_number_to_maintain),
      super_version_(nullptr),
      super_version_number_(0),
      local_sv_(new ThreadLocalPtr(&SuperVersionUnrefHandle)),
@@ -275,7 +275,7 @@ class ColumnFamilyData {
  // Ref() can only be called from a context where the caller can guarantee
  // that ColumnFamilyData is alive (while holding a non-zero ref already,
  // holding a DB mutex, or as the leader in a write batch group).
-  void Ref() { refs_.fetch_add(1); }
+  void Ref() { refs_.fetch_add(1, std::memory_order_relaxed); }

  // Unref decreases the reference count, but does not handle deletion
  // when the count goes to 0.  If this method returns true then the
@@ -283,7 +283,7 @@ class ColumnFamilyData {
  // FreeDeadColumnFamilies().  Unref() can only be called while holding
  // a DB mutex, or during single-threaded recovery.
  bool Unref() {
-    int old_refs = refs_.fetch_sub(1);
+    int old_refs = refs_.fetch_sub(1, std::memory_order_relaxed);
    assert(old_refs > 0);
    return old_refs == 1;
  }
@@ -17,11 +17,9 @@
 #include "memtable/hash_skiplist_rep.h"
 #include "options/options_parser.h"
 #include "port/port.h"
-#include "port/stack_trace.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
 #include "rocksdb/iterator.h"
-#include "rocksdb/utilities/object_registry.h"
 #include "test_util/fault_injection_test_env.h"
 #include "test_util/sync_point.h"
 #include "test_util/testharness.h"
@@ -62,20 +60,8 @@ class EnvCounter : public EnvWrapper {

 class ColumnFamilyTestBase : public testing::Test {
 public:
-  explicit ColumnFamilyTestBase(uint32_t format) : rnd_(139), format_(format) {
-    Env* base_env = Env::Default();
-#ifndef ROCKSDB_LITE
-    const char* test_env_uri = getenv("TEST_ENV_URI");
-    if (test_env_uri) {
-      Status s = ObjectRegistry::NewInstance()->NewSharedObject(test_env_uri,
-                                                                &env_guard_);
-      base_env = env_guard_.get();
-      EXPECT_OK(s);
-      EXPECT_NE(Env::Default(), base_env);
-    }
-#endif  // !ROCKSDB_LITE
-    EXPECT_NE(nullptr, base_env);
-    env_ = new EnvCounter(base_env);
+  ColumnFamilyTestBase(uint32_t format) : rnd_(139), format_(format) {
+    env_ = new EnvCounter(Env::Default());
    dbname_ = test::PerThreadDBPath("column_family_test");
    db_options_.create_if_missing = true;
    db_options_.fail_if_options_file_error = true;
@@ -546,7 +532,6 @@ class ColumnFamilyTestBase : public testing::Test {
  std::string dbname_;
  DB* db_ = nullptr;
  EnvCounter* env_;
-  std::shared_ptr<Env> env_guard_;
  Random rnd_;
  uint32_t format_;
 };
@@ -1132,25 +1117,22 @@ TEST_P(ColumnFamilyTest, DifferentWriteBufferSizes) {
  default_cf.arena_block_size = 4 * 4096;
  default_cf.max_write_buffer_number = 10;
  default_cf.min_write_buffer_number_to_merge = 1;
-  default_cf.max_write_buffer_size_to_maintain = 0;
+  default_cf.max_write_buffer_number_to_maintain = 0;
  one.write_buffer_size = 200000;
  one.arena_block_size = 4 * 4096;
  one.max_write_buffer_number = 10;
  one.min_write_buffer_number_to_merge = 2;
-  one.max_write_buffer_size_to_maintain =
-      static_cast<int>(one.write_buffer_size);
+  one.max_write_buffer_number_to_maintain = 1;
  two.write_buffer_size = 1000000;
  two.arena_block_size = 4 * 4096;
  two.max_write_buffer_number = 10;
  two.min_write_buffer_number_to_merge = 3;
-  two.max_write_buffer_size_to_maintain =
-      static_cast<int>(two.write_buffer_size);
+  two.max_write_buffer_number_to_maintain = 2;
  three.write_buffer_size = 4096 * 22;
  three.arena_block_size = 4096;
  three.max_write_buffer_number = 10;
  three.min_write_buffer_number_to_merge = 4;
-  three.max_write_buffer_size_to_maintain =
-      static_cast<int>(three.write_buffer_size);
+  three.max_write_buffer_number_to_maintain = -1;

  Reopen({default_cf, one, two, three});

@@ -3330,17 +3312,7 @@ TEST_P(ColumnFamilyTest, MultipleCFPathsTest) {

 }  // namespace rocksdb

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -37,7 +37,7 @@ Status CompactedDBImpl::Get(const ReadOptions& options, ColumnFamilyHandle*,
                            const Slice& key, PinnableSlice* value) {
  GetContext get_context(user_comparator_, nullptr, nullptr, nullptr,
                         GetContext::kNotFound, key, value, nullptr, nullptr,
-                         true, nullptr, nullptr);
+                         nullptr, nullptr);
  LookupKey lkey(key, kMaxSequenceNumber);
  files_.files[FindFile(key)].fd.table_reader->Get(options, lkey.internal_key(),
                                                   &get_context, nullptr);
@@ -70,7 +70,7 @@ std::vector<Status> CompactedDBImpl::MultiGet(const ReadOptions& options,
      std::string& value = (*values)[idx];
      GetContext get_context(user_comparator_, nullptr, nullptr, nullptr,
                             GetContext::kNotFound, keys[idx], &pinnable_val,
-                             nullptr, nullptr, true, nullptr, nullptr);
+                             nullptr, nullptr, nullptr, nullptr);
      LookupKey lkey(keys[idx], kMaxSequenceNumber);
      r->Get(options, lkey.internal_key(), &get_context, nullptr);
      value.assign(pinnable_val.data(), pinnable_val.size());
@@ -14,10 +14,6 @@ namespace rocksdb {
 class CompactedDBImpl : public DBImpl {
 public:
  CompactedDBImpl(const DBOptions& options, const std::string& dbname);
-  // No copying allowed
-  CompactedDBImpl(const CompactedDBImpl&) = delete;
-  void operator=(const CompactedDBImpl&) = delete;
-
  virtual ~CompactedDBImpl();

  static Status Open(const Options& options, const std::string& dbname,
@@ -89,15 +85,6 @@ class CompactedDBImpl : public DBImpl {
      const IngestExternalFileOptions& /*ingestion_options*/) override {
    return Status::NotSupported("Not supported in compacted db mode.");
  }
-  using DB::CreateColumnFamilyWithImport;
-  virtual Status CreateColumnFamilyWithImport(
-      const ColumnFamilyOptions& /*options*/,
-      const std::string& /*column_family_name*/,
-      const ImportColumnFamilyOptions& /*import_options*/,
-      const ExportImportFilesMetaData& /*metadata*/,
-      ColumnFamilyHandle** /*handle*/) override {
-    return Status::NotSupported("Not supported in compacted db mode.");
-  }

 private:
  friend class DB;
@@ -108,6 +95,10 @@ class CompactedDBImpl : public DBImpl {
  Version* version_;
  const Comparator* user_comparator_;
  LevelFilesBrief files_;
+
+  // No copying allowed
+  CompactedDBImpl(const CompactedDBImpl&);
+  void operator=(const CompactedDBImpl&);
 };
 }
 #endif  // ROCKSDB_LITE
@@ -520,9 +520,8 @@ void CompactionJob::GenSubcompactionBoundaries() {
    // to the index block and may incur I/O cost in the process. Unlock db
    // mutex to reduce contention
    db_mutex_->Unlock();
-    uint64_t size = versions_->ApproximateSize(SizeApproximationOptions(), v, a,
-                                               b, start_lvl, out_lvl + 1,
-                                               TableReaderCaller::kCompaction);
+    uint64_t size = versions_->ApproximateSize(v, a, b, start_lvl, out_lvl + 1,
+                                               /*for_compaction*/ true);
    db_mutex_->Lock();
    ranges.emplace_back(a, b, size);
    sum += size;
@@ -647,14 +646,12 @@ Status CompactionJob::Run() {
        // to cache it here for further user reads
        InternalIterator* iter = cfd->table_cache()->NewIterator(
            ReadOptions(), env_options_, cfd->internal_comparator(),
-            *files_meta[file_idx], /*range_del_agg=*/nullptr, prefix_extractor,
-            /*table_reader_ptr=*/nullptr,
+            *files_meta[file_idx], nullptr /* range_del_agg */,
+            prefix_extractor, nullptr,
            cfd->internal_stats()->GetFileReadHist(
                compact_->compaction->output_level()),
-            TableReaderCaller::kCompactionRefill, /*arena=*/nullptr,
-            /*skip_filters=*/false, compact_->compaction->output_level(),
-            /*smallest_compaction_key=*/nullptr,
-            /*largest_compaction_key=*/nullptr);
+            false, nullptr /* arena */, false /* skip_filters */,
+            compact_->compaction->output_level());
        auto s = iter->status();

        if (s.ok() && paranoid_file_checks_) {
@@ -14,7 +14,6 @@

 #include "db/column_family.h"
 #include "db/compaction/compaction_job.h"
-#include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "db/version_set.h"
 #include "rocksdb/cache.h"
@@ -205,15 +204,8 @@ class CompactionJobTest : public testing::Test {
                                   &write_controller_,
                                   /*block_cache_tracer=*/nullptr));
    compaction_job_stats_.Reset();
-    SetIdentityFile(env_, dbname_);

    VersionEdit new_db;
-    if (db_options_.write_dbid_to_manifest) {
-      DBImpl* impl = new DBImpl(DBOptions(), dbname_);
-      std::string db_id;
-      impl->GetDbIdentityFromIdentityFile(&db_id);
-      new_db.SetDBId(db_id);
-    }
    new_db.SetLogNumber(0);
    new_db.SetNextFile(2);
    new_db.SetLastSequence(0);
@@ -54,15 +54,6 @@ Compaction* FIFOCompactionPicker::PickTTLCompaction(
  }
  const uint64_t current_time = static_cast<uint64_t>(_current_time);

-  if (!level0_compactions_in_progress_.empty()) {
-    ROCKS_LOG_BUFFER(
-        log_buffer,
-        "[%s] FIFO compaction: Already executing compaction. No need "
-        "to run parallel compactions since compactions are very fast",
-        cf_name.c_str());
-    return nullptr;
-  }
-
  std::vector<CompactionInputFiles> inputs;
  inputs.emplace_back();
  inputs[0].level = 0;
@@ -1504,7 +1504,7 @@ TEST_F(CompactionPickerTest, IntraL0MaxCompactionBytesNotHit) {
  ASSERT_EQ(5U, compaction->num_input_files(0));
  ASSERT_EQ(CompactionReason::kLevelL0FilesNum,
            compaction->compaction_reason());
-  ASSERT_EQ(0, compaction->output_level());
+  ASSERT_EQ(0U, compaction->output_level());
 }

 TEST_F(CompactionPickerTest, IntraL0MaxCompactionBytesHit) {
@@ -1534,7 +1534,7 @@ TEST_F(CompactionPickerTest, IntraL0MaxCompactionBytesHit) {
  ASSERT_EQ(4U, compaction->num_input_files(0));
  ASSERT_EQ(CompactionReason::kLevelL0FilesNum,
            compaction->compaction_reason());
-  ASSERT_EQ(0, compaction->output_level());
+  ASSERT_EQ(0U, compaction->output_level());
 }

 }  // namespace rocksdb
@@ -35,12 +35,6 @@ Status DeleteFilesInRanges(DB* db, ColumnFamilyHandle* column_family,
 Status VerifySstFileChecksum(const Options& options,
                             const EnvOptions& env_options,
                             const std::string& file_path) {
-  return VerifySstFileChecksum(options, env_options, ReadOptions(), file_path);
-}
-Status VerifySstFileChecksum(const Options& options,
-                             const EnvOptions& env_options,
-                             const ReadOptions& read_options,
-                             const std::string& file_path) {
  std::unique_ptr<RandomAccessFile> file;
  uint64_t file_size;
  InternalKeyComparator internal_comparator(options.comparator);
@@ -65,8 +59,7 @@ Status VerifySstFileChecksum(const Options& options,
  if (!s.ok()) {
    return s;
  }
-  s = table_reader->VerifyChecksum(read_options,
-                                   TableReaderCaller::kUserVerifyChecksum);
+  s = table_reader->VerifyChecksum();
  return s;
 }

@@ -13,11 +13,10 @@

 #include <errno.h>
 #include <fcntl.h>
+#include <cinttypes>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <cinttypes>
 #include "db/db_impl/db_impl.h"
-#include "db/db_test_util.h"
 #include "db/log_format.h"
 #include "db/version_set.h"
 #include "file/filename.h"
@@ -77,11 +76,7 @@ class CorruptionTest : public testing::Test {
    delete db_;
    db_ = nullptr;
    Options opt = (options ? *options : options_);
-    if (opt.env == Options().env) {
-      // If env is not overridden, replace it with ErrorEnv.
-      // Otherwise, the test already uses a non-default Env.
-      opt.env = &env_;
-    }
+    opt.env = &env_;
    opt.arena_block_size = 4096;
    BlockBasedTableOptions table_options;
    table_options.block_cache = tiny_cache_;
@@ -326,59 +321,6 @@ TEST_F(CorruptionTest, TableFile) {
  ASSERT_NOK(dbi->VerifyChecksum());
 }

-TEST_F(CorruptionTest, VerifyChecksumReadahead) {
-  Options options;
-  SpecialEnv senv(Env::Default());
-  options.env = &senv;
-  // Disable block cache as we are going to check checksum for
-  // the same file twice and measure number of reads.
-  BlockBasedTableOptions table_options_no_bc;
-  table_options_no_bc.no_block_cache = true;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options_no_bc));
-
-  Reopen(&options);
-
-  Build(10000);
-  DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
-  dbi->TEST_FlushMemTable();
-  dbi->TEST_CompactRange(0, nullptr, nullptr);
-  dbi->TEST_CompactRange(1, nullptr, nullptr);
-
-  senv.count_random_reads_ = true;
-  senv.random_read_counter_.Reset();
-  ASSERT_OK(dbi->VerifyChecksum());
-
-  // Make sure the counter is enabled.
-  ASSERT_GT(senv.random_read_counter_.Read(), 0);
-
-  // The SST file is about 10MB. Default readahead size is 256KB.
-  // Give a conservative 20 reads for metadata blocks, The number
-  // of random reads should be within 10 MB / 256KB + 20 = 60.
-  ASSERT_LT(senv.random_read_counter_.Read(), 60);
-
-  senv.random_read_bytes_counter_ = 0;
-  ReadOptions ro;
-  ro.readahead_size = size_t{32 * 1024};
-  ASSERT_OK(dbi->VerifyChecksum(ro));
-  // The SST file is about 10MB. We set readahead size to 32KB.
-  // Give 0 to 20 reads for metadata blocks, and allow real read
-  // to range from 24KB to 48KB. The lower bound would be:
-  //   10MB / 48KB + 0 = 213
-  // The higher bound is
-  //   10MB / 24KB + 20 = 447.
-  ASSERT_GE(senv.random_read_counter_.Read(), 213);
-  ASSERT_LE(senv.random_read_counter_.Read(), 447);
-
-  // Test readahead shouldn't break mmap mode (where it should be
-  // disabled).
-  options.allow_mmap_reads = true;
-  Reopen(&options);
-  dbi = static_cast<DBImpl*>(db_);
-  ASSERT_OK(dbi->VerifyChecksum(ro));
-
-  CloseDb();
-}
-
 TEST_F(CorruptionTest, TableFileIndexData) {
  Options options;
  // very big, we'll trigger flushes manually
@@ -10,8 +10,6 @@
 #include "db/db_test_util.h"
 #include "port/stack_trace.h"
 #include "rocksdb/perf_context.h"
-#include "rocksdb/utilities/debug.h"
-#include "table/block_based/block_based_table_reader.h"
 #include "table/block_based/block_builder.h"
 #include "test_util/fault_injection_test_env.h"
 #if !defined(ROCKSDB_LITE)
@@ -71,44 +69,6 @@ TEST_F(DBBasicTest, ReadOnlyDB) {
  ASSERT_TRUE(db_->SyncWAL().IsNotSupported());
 }

-TEST_F(DBBasicTest, ReadOnlyDBWithWriteDBIdToManifestSet) {
-  ASSERT_OK(Put("foo", "v1"));
-  ASSERT_OK(Put("bar", "v2"));
-  ASSERT_OK(Put("foo", "v3"));
-  Close();
-
-  auto options = CurrentOptions();
-  options.write_dbid_to_manifest = true;
-  assert(options.env == env_);
-  ASSERT_OK(ReadOnlyReopen(options));
-  std::string db_id1;
-  db_->GetDbIdentity(db_id1);
-  ASSERT_EQ("v3", Get("foo"));
-  ASSERT_EQ("v2", Get("bar"));
-  Iterator* iter = db_->NewIterator(ReadOptions());
-  int count = 0;
-  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
-    ASSERT_OK(iter->status());
-    ++count;
-  }
-  ASSERT_EQ(count, 2);
-  delete iter;
-  Close();
-
-  // Reopen and flush memtable.
-  Reopen(options);
-  Flush();
-  Close();
-  // Now check keys in read only mode.
-  ASSERT_OK(ReadOnlyReopen(options));
-  ASSERT_EQ("v3", Get("foo"));
-  ASSERT_EQ("v2", Get("bar"));
-  ASSERT_TRUE(db_->SyncWAL().IsNotSupported());
-  std::string db_id2;
-  db_->GetDbIdentity(db_id2);
-  ASSERT_EQ(db_id1, db_id2);
-}
-
 TEST_F(DBBasicTest, CompactedDB) {
  const uint64_t kFileSize = 1 << 20;
  Options options = CurrentOptions();
@@ -336,7 +296,7 @@ TEST_F(DBBasicTest, FlushMultipleMemtable) {
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
-    options.max_write_buffer_size_to_maintain = -1;
+    options.max_write_buffer_number_to_maintain = -1;
    CreateAndReopenWithCF({"pikachu"}, options);
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
    ASSERT_OK(Flush(1));
@@ -366,8 +326,7 @@ TEST_F(DBBasicTest, FlushEmptyColumnFamily) {
  writeOpt.disableWAL = true;
  options.max_write_buffer_number = 2;
  options.min_write_buffer_number_to_merge = 1;
-  options.max_write_buffer_size_to_maintain =
-      static_cast<int64_t>(options.write_buffer_size);
+  options.max_write_buffer_number_to_maintain = 1;
  CreateAndReopenWithCF({"pikachu"}, options);

  // Compaction can still go through even if no thread can flush the
@@ -463,7 +422,7 @@ TEST_F(DBBasicTest, ManifestRollOver) {
  } while (ChangeCompactOptions());
 }

-TEST_F(DBBasicTest, IdentityAcrossRestarts1) {
+TEST_F(DBBasicTest, IdentityAcrossRestarts) {
  do {
    std::string id1;
    ASSERT_OK(db_->GetDbIdentity(id1));
@@ -475,40 +434,13 @@ TEST_F(DBBasicTest, IdentityAcrossRestarts1) {
    // id1 should match id2 because identity was not regenerated
    ASSERT_EQ(id1.compare(id2), 0);

-    std::string idfilename = IdentityFileName(dbname_);
-    ASSERT_OK(env_->DeleteFile(idfilename));
-    Reopen(options);
-    std::string id3;
-    ASSERT_OK(db_->GetDbIdentity(id3));
-    if (options.write_dbid_to_manifest) {
-      ASSERT_EQ(id1.compare(id3), 0);
-    } else {
-      // id1 should NOT match id3 because identity was regenerated
-      ASSERT_NE(id1.compare(id3), 0);
-    }
-  } while (ChangeCompactOptions());
-}
-
-TEST_F(DBBasicTest, IdentityAcrossRestarts2) {
-  do {
-    std::string id1;
-    ASSERT_OK(db_->GetDbIdentity(id1));
-
-    Options options = CurrentOptions();
-    options.write_dbid_to_manifest = true;
-    Reopen(options);
-    std::string id2;
-    ASSERT_OK(db_->GetDbIdentity(id2));
-    // id1 should match id2 because identity was not regenerated
-    ASSERT_EQ(id1.compare(id2), 0);
-
    std::string idfilename = IdentityFileName(dbname_);
    ASSERT_OK(env_->DeleteFile(idfilename));
    Reopen(options);
    std::string id3;
    ASSERT_OK(db_->GetDbIdentity(id3));
    // id1 should NOT match id3 because identity was regenerated
-    ASSERT_EQ(id1, id3);
+    ASSERT_NE(id1.compare(id3), 0);
  } while (ChangeCompactOptions());
 }

@@ -1354,233 +1286,6 @@ TEST_F(DBBasicTest, MultiGetBatchedMultiLevel) {
  }
 }

-// Test class for batched MultiGet with prefix extractor
-// Param bool - If true, use partitioned filters
-//              If false, use full filter block
-class MultiGetPrefixExtractorTest
-    : public DBBasicTest,
-      public ::testing::WithParamInterface<bool> {};
-
-TEST_P(MultiGetPrefixExtractorTest, Batched) {
-  Options options = CurrentOptions();
-  options.prefix_extractor.reset(NewFixedPrefixTransform(2));
-  BlockBasedTableOptions bbto;
-  if (GetParam()) {
-    bbto.index_type = BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch;
-    bbto.partition_filters = true;
-  }
-  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
-  bbto.whole_key_filtering = false;
-  bbto.cache_index_and_filter_blocks = false;
-  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
-  Reopen(options);
-
-  // First key is not in the prefix_extractor domain
-  ASSERT_OK(Put("k", "v0"));
-  ASSERT_OK(Put("kk1", "v1"));
-  ASSERT_OK(Put("kk2", "v2"));
-  ASSERT_OK(Put("kk3", "v3"));
-  ASSERT_OK(Put("kk4", "v4"));
-  ASSERT_OK(Flush());
-
-  std::vector<std::string> keys({"k", "kk1", "kk2", "kk3", "kk4"});
-  std::vector<std::string> values;
-  SetPerfLevel(kEnableCount);
-  get_perf_context()->Reset();
-  values = MultiGet(keys, nullptr);
-  ASSERT_EQ(values[0], "v0");
-  ASSERT_EQ(values[1], "v1");
-  ASSERT_EQ(values[2], "v2");
-  ASSERT_EQ(values[3], "v3");
-  ASSERT_EQ(values[4], "v4");
-  // Filter hits for 4 in-domain keys
-  ASSERT_EQ(get_perf_context()->bloom_sst_hit_count, 4);
-}
-
-INSTANTIATE_TEST_CASE_P(
-    MultiGetPrefix, MultiGetPrefixExtractorTest,
-    ::testing::Bool());
-
-#ifndef ROCKSDB_LITE
-class DBMultiGetRowCacheTest
-    : public DBBasicTest,
-      public ::testing::WithParamInterface<bool> {};
-
-TEST_P(DBMultiGetRowCacheTest, MultiGetBatched) {
-  do {
-    option_config_ = kRowCache;
-    Options options = CurrentOptions();
-    options.statistics = rocksdb::CreateDBStatistics();
-    CreateAndReopenWithCF({"pikachu"}, options);
-    SetPerfLevel(kEnableCount);
-    ASSERT_OK(Put(1, "k1", "v1"));
-    ASSERT_OK(Put(1, "k2", "v2"));
-    ASSERT_OK(Put(1, "k3", "v3"));
-    ASSERT_OK(Put(1, "k4", "v4"));
-    Flush(1);
-    ASSERT_OK(Put(1, "k5", "v5"));
-    const Snapshot* snap1 = dbfull()->GetSnapshot();
-    ASSERT_OK(Delete(1, "k4"));
-    Flush(1);
-    const Snapshot* snap2 = dbfull()->GetSnapshot();
-
-    get_perf_context()->Reset();
-
-    std::vector<Slice> keys({"no_key", "k5", "k4", "k3", "k1"});
-    std::vector<PinnableSlice> values(keys.size());
-    std::vector<ColumnFamilyHandle*> cfs(keys.size(), handles_[1]);
-    std::vector<Status> s(keys.size());
-
-    ReadOptions ro;
-    bool use_snapshots = GetParam();
-    if (use_snapshots) {
-      ro.snapshot = snap2;
-    }
-    db_->MultiGet(ro, handles_[1], keys.size(), keys.data(), values.data(),
-                  s.data(), false);
-
-    ASSERT_EQ(values.size(), keys.size());
-    ASSERT_EQ(std::string(values[4].data(), values[4].size()), "v1");
-    ASSERT_EQ(std::string(values[3].data(), values[3].size()), "v3");
-    ASSERT_EQ(std::string(values[1].data(), values[1].size()), "v5");
-    // four kv pairs * two bytes per value
-    ASSERT_EQ(6, (int)get_perf_context()->multiget_read_bytes);
-
-    ASSERT_TRUE(s[0].IsNotFound());
-    ASSERT_OK(s[1]);
-    ASSERT_TRUE(s[2].IsNotFound());
-    ASSERT_OK(s[3]);
-    ASSERT_OK(s[4]);
-
-    // Call MultiGet() again with some intersection with the previous set of
-    // keys. Those should already be in the row cache.
-    keys.assign({"no_key", "k5", "k3", "k2"});
-    for (size_t i = 0; i < keys.size(); ++i) {
-      values[i].Reset();
-      s[i] = Status::OK();
-    }
-    get_perf_context()->Reset();
-
-    if (use_snapshots) {
-      ro.snapshot = snap1;
-    }
-    db_->MultiGet(ReadOptions(), handles_[1], keys.size(), keys.data(),
-                  values.data(), s.data(), false);
-
-    ASSERT_EQ(std::string(values[3].data(), values[3].size()), "v2");
-    ASSERT_EQ(std::string(values[2].data(), values[2].size()), "v3");
-    ASSERT_EQ(std::string(values[1].data(), values[1].size()), "v5");
-    // four kv pairs * two bytes per value
-    ASSERT_EQ(6, (int)get_perf_context()->multiget_read_bytes);
-
-    ASSERT_TRUE(s[0].IsNotFound());
-    ASSERT_OK(s[1]);
-    ASSERT_OK(s[2]);
-    ASSERT_OK(s[3]);
-    if (use_snapshots) {
-      // Only reads from the first SST file would have been cached, since
-      // snapshot seq no is > fd.largest_seqno
-      ASSERT_EQ(1, TestGetTickerCount(options, ROW_CACHE_HIT));
-    } else {
-      ASSERT_EQ(2, TestGetTickerCount(options, ROW_CACHE_HIT));
-    }
-
-    SetPerfLevel(kDisable);
-    dbfull()->ReleaseSnapshot(snap1);
-    dbfull()->ReleaseSnapshot(snap2);
-  } while (ChangeCompactOptions());
-}
-
-INSTANTIATE_TEST_CASE_P(DBMultiGetRowCacheTest, DBMultiGetRowCacheTest,
-                        testing::Values(true, false));
-
-TEST_F(DBBasicTest, GetAllKeyVersions) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.disable_auto_compactions = true;
-  CreateAndReopenWithCF({"pikachu"}, options);
-  ASSERT_EQ(2, handles_.size());
-  const size_t kNumInserts = 4;
-  const size_t kNumDeletes = 4;
-  const size_t kNumUpdates = 4;
-
-  // Check default column family
-  for (size_t i = 0; i != kNumInserts; ++i) {
-    ASSERT_OK(Put(std::to_string(i), "value"));
-  }
-  for (size_t i = 0; i != kNumUpdates; ++i) {
-    ASSERT_OK(Put(std::to_string(i), "value1"));
-  }
-  for (size_t i = 0; i != kNumDeletes; ++i) {
-    ASSERT_OK(Delete(std::to_string(i)));
-  }
-  std::vector<KeyVersion> key_versions;
-  ASSERT_OK(rocksdb::GetAllKeyVersions(db_, Slice(), Slice(),
-                                       std::numeric_limits<size_t>::max(),
-                                       &key_versions));
-  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates, key_versions.size());
-  ASSERT_OK(rocksdb::GetAllKeyVersions(db_, handles_[0], Slice(), Slice(),
-                                       std::numeric_limits<size_t>::max(),
-                                       &key_versions));
-  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates, key_versions.size());
-
-  // Check non-default column family
-  for (size_t i = 0; i != kNumInserts - 1; ++i) {
-    ASSERT_OK(Put(1, std::to_string(i), "value"));
-  }
-  for (size_t i = 0; i != kNumUpdates - 1; ++i) {
-    ASSERT_OK(Put(1, std::to_string(i), "value1"));
-  }
-  for (size_t i = 0; i != kNumDeletes - 1; ++i) {
-    ASSERT_OK(Delete(1, std::to_string(i)));
-  }
-  ASSERT_OK(rocksdb::GetAllKeyVersions(db_, handles_[1], Slice(), Slice(),
-                                       std::numeric_limits<size_t>::max(),
-                                       &key_versions));
-  ASSERT_EQ(kNumInserts + kNumDeletes + kNumUpdates - 3, key_versions.size());
-}
-#endif  // !ROCKSDB_LITE
-
-TEST_F(DBBasicTest, MultiGetIOBufferOverrun) {
-  Options options = CurrentOptions();
-  Random rnd(301);
-  BlockBasedTableOptions table_options;
-  table_options.pin_l0_filter_and_index_blocks_in_cache = true;
-  table_options.block_size = 16 * 1024;
-  assert(table_options.block_size >
-          BlockBasedTable::kMultiGetReadStackBufSize);
-  options.table_factory.reset(new BlockBasedTableFactory(table_options));
-  Reopen(options);
-
-  std::string zero_str(128, '\0');
-  for (int i = 0; i < 100; ++i) {
-    // Make the value compressible. A purely random string doesn't compress
-    // and the resultant data block will not be compressed
-    std::string value(RandomString(&rnd, 128) + zero_str);
-    assert(Put(Key(i), value) == Status::OK());
-  }
-  Flush();
-
-  std::vector<std::string> key_data(10);
-  std::vector<Slice> keys;
-  // We cannot resize a PinnableSlice vector, so just set initial size to
-  // largest we think we will need
-  std::vector<PinnableSlice> values(10);
-  std::vector<Status> statuses;
-  ReadOptions ro;
-
-  // Warm up the cache first
-  key_data.emplace_back(Key(0));
-  keys.emplace_back(Slice(key_data.back()));
-  key_data.emplace_back(Key(50));
-  keys.emplace_back(Slice(key_data.back()));
-  statuses.resize(keys.size());
-
-  dbfull()->MultiGet(ro, dbfull()->DefaultColumnFamily(), keys.size(),
-                     keys.data(), values.data(), statuses.data(), true);
-}
-
 class DBBasicTestWithParallelIO
    : public DBTestBase,
      public testing::WithParamInterface<std::tuple<bool,bool,bool,bool>> {
@@ -1606,12 +1311,8 @@ class DBBasicTestWithParallelIO
    Options options = CurrentOptions();
    Random rnd(301);
    BlockBasedTableOptions table_options;
+    table_options.pin_l0_filter_and_index_blocks_in_cache = true;
    table_options.block_cache = uncompressed_cache_;
-    if (table_options.block_cache == nullptr) {
-      table_options.no_block_cache = true;
-    } else {
-      table_options.pin_l0_filter_and_index_blocks_in_cache = true;
-    }
    table_options.block_cache_compressed = compressed_cache_;
    table_options.flush_block_policy_factory.reset(
                      new MyFlushBlockPolicyFactory());
@@ -1653,9 +1354,6 @@ class DBBasicTestWithParallelIO
  }

  bool fill_cache() { return fill_cache_; }
-  bool compression_enabled() { return compression_enabled_; }
-  bool has_compressed_cache() { return compressed_cache_ != nullptr; }
-  bool has_uncompressed_cache() { return uncompressed_cache_ != nullptr; }

  static void SetUpTestCase() {}
  static void TearDownTestCase() {}
@@ -1840,16 +1538,7 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
  ASSERT_TRUE(CheckValue(1, values[0].ToString()));
  ASSERT_TRUE(CheckValue(51, values[1].ToString()));

-  bool read_from_cache = false;
-  if (fill_cache()) {
-    if (has_uncompressed_cache()) {
-      read_from_cache = true;
-    } else if (has_compressed_cache() && compression_enabled()) {
-      read_from_cache = true;
-    }
-  }
-
-  int expected_reads = random_reads + (read_from_cache ? 0 : 2);
+  int expected_reads = random_reads + (fill_cache() ? 0 : 2);
  ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);

  keys.resize(10);
@@ -1867,7 +1556,7 @@ TEST_P(DBBasicTestWithParallelIO, MultiGet) {
    ASSERT_OK(statuses[i]);
    ASSERT_TRUE(CheckValue(key_ints[i], values[i].ToString()));
  }
-  expected_reads += (read_from_cache ? 2 : 4);
+  expected_reads += (fill_cache() ? 2 : 4);
  ASSERT_EQ(env_->random_read_counter_.Read(), expected_reads);
 }

@@ -1878,8 +1567,12 @@ INSTANTIATE_TEST_CASE_P(
    // Param 1 - Uncompressed cache enabled
    // Param 2 - Data compression enabled
    // Param 3 - ReadOptions::fill_cache
-    ::testing::Combine(::testing::Bool(), ::testing::Bool(),
-                       ::testing::Bool(), ::testing::Bool()));
+    ::testing::Values(std::make_tuple(false, true, true, true),
+                      std::make_tuple(true, true, true, true),
+                      std::make_tuple(false, true, false, true),
+                      std::make_tuple(false, true, true, false),
+                      std::make_tuple(true, true, true, false),
+                      std::make_tuple(false, true, false, false)));

 class DBBasicTestWithTimestampWithParam
    : public DBTestBase,
@@ -2033,17 +1726,8 @@ INSTANTIATE_TEST_CASE_P(Timestamp, DBBasicTestWithTimestampWithParam,

 }  // namespace rocksdb

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  rocksdb::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -63,11 +63,9 @@ class DBBlobIndexTest : public DBTestBase {
    ReadOptions read_options;
    read_options.snapshot = snapshot;
    PinnableSlice value;
-    DBImpl::GetImplOptions get_impl_options;
-    get_impl_options.column_family = cfh();
-    get_impl_options.value = &value;
-    get_impl_options.is_blob_index = is_blob_index;
-    auto s = dbfull()->GetImpl(read_options, key, get_impl_options);
+    auto s = dbfull()->GetImpl(read_options, cfh(), key, &value,
+                               nullptr /*value_found*/, nullptr /*callback*/,
+                               is_blob_index);
    if (s.IsNotFound()) {
      return "NOT_FOUND";
    }
@@ -19,9 +19,6 @@ class DBBlockCacheTest : public DBTestBase {
  size_t hit_count_ = 0;
  size_t insert_count_ = 0;
  size_t failure_count_ = 0;
-  size_t compression_dict_miss_count_ = 0;
-  size_t compression_dict_hit_count_ = 0;
-  size_t compression_dict_insert_count_ = 0;
  size_t compressed_miss_count_ = 0;
  size_t compressed_hit_count_ = 0;
  size_t compressed_insert_count_ = 0;
@@ -72,15 +69,6 @@ class DBBlockCacheTest : public DBTestBase {
        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSED_ADD_FAILURES);
  }

-  void RecordCacheCountersForCompressionDict(const Options& options) {
-    compression_dict_miss_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS);
-    compression_dict_hit_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_HIT);
-    compression_dict_insert_count_ =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_ADD);
-  }
-
  void CheckCacheCounters(const Options& options, size_t expected_misses,
                          size_t expected_hits, size_t expected_inserts,
                          size_t expected_failures) {
@@ -99,28 +87,6 @@ class DBBlockCacheTest : public DBTestBase {
    failure_count_ = new_failure_count;
  }

-  void CheckCacheCountersForCompressionDict(
-      const Options& options, size_t expected_compression_dict_misses,
-      size_t expected_compression_dict_hits,
-      size_t expected_compression_dict_inserts) {
-    size_t new_compression_dict_miss_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS);
-    size_t new_compression_dict_hit_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_HIT);
-    size_t new_compression_dict_insert_count =
-        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_ADD);
-    ASSERT_EQ(compression_dict_miss_count_ + expected_compression_dict_misses,
-              new_compression_dict_miss_count);
-    ASSERT_EQ(compression_dict_hit_count_ + expected_compression_dict_hits,
-              new_compression_dict_hit_count);
-    ASSERT_EQ(
-        compression_dict_insert_count_ + expected_compression_dict_inserts,
-        new_compression_dict_insert_count);
-    compression_dict_miss_count_ = new_compression_dict_miss_count;
-    compression_dict_hit_count_ = new_compression_dict_hit_count;
-    compression_dict_insert_count_ = new_compression_dict_insert_count;
-  }
-
  void CheckCompressedCacheCounters(const Options& options,
                                    size_t expected_misses,
                                    size_t expected_hits,
@@ -399,11 +365,11 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
  ASSERT_EQ(cache->GetUsage(), index_bytes_insert + filter_bytes_insert);
  // set the cache capacity to the current usage
  cache->SetCapacity(index_bytes_insert + filter_bytes_insert);
-  // The index and filter eviction statistics were broken by the refactoring
-  // that moved the readers out of the block cache. Disabling these until we can
+  // The index eviction statistics were broken by the refactoring that moved
+  // the index readers out of the block cache. Disabling these until we can
  // bring the stats back.
  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_INDEX_BYTES_EVICT), 0);
-  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_EVICT), 0);
+  ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_EVICT), 0);
  // Note that the second key needs to be no longer than the first one.
  // Otherwise the second index block may not fit in cache.
  ASSERT_OK(Put(1, "key", "val"));
@@ -414,13 +380,13 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksStats) {
            index_bytes_insert);
  ASSERT_GT(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_INSERT),
            filter_bytes_insert);
-  // The index and filter eviction statistics were broken by the refactoring
-  // that moved the readers out of the block cache. Disabling these until we can
+  // The index eviction statistics were broken by the refactoring that moved
+  // the index readers out of the block cache. Disabling these until we can
  // bring the stats back.
  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_INDEX_BYTES_EVICT),
  //           index_bytes_insert);
-  // ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_EVICT),
-  //           filter_bytes_insert);
+  ASSERT_EQ(TestGetTickerCount(options, BLOCK_CACHE_FILTER_BYTES_EVICT),
+            filter_bytes_insert);
 }

 namespace {
@@ -484,11 +450,11 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksCachePriority) {
              TestGetTickerCount(options, BLOCK_CACHE_ADD));
    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_DATA_MISS));
    if (priority == Cache::Priority::LOW) {
-      ASSERT_EQ(0u, MockCache::high_pri_insert_count);
-      ASSERT_EQ(2u, MockCache::low_pri_insert_count);
+      ASSERT_EQ(0, MockCache::high_pri_insert_count);
+      ASSERT_EQ(2, MockCache::low_pri_insert_count);
    } else {
-      ASSERT_EQ(2u, MockCache::high_pri_insert_count);
-      ASSERT_EQ(0u, MockCache::low_pri_insert_count);
+      ASSERT_EQ(2, MockCache::high_pri_insert_count);
+      ASSERT_EQ(0, MockCache::low_pri_insert_count);
    }

    // Access data block.
@@ -502,11 +468,11 @@ TEST_F(DBBlockCacheTest, IndexAndFilterBlocksCachePriority) {

    // Data block should be inserted with low priority.
    if (priority == Cache::Priority::LOW) {
-      ASSERT_EQ(0u, MockCache::high_pri_insert_count);
-      ASSERT_EQ(3u, MockCache::low_pri_insert_count);
+      ASSERT_EQ(0, MockCache::high_pri_insert_count);
+      ASSERT_EQ(3, MockCache::low_pri_insert_count);
    } else {
-      ASSERT_EQ(2u, MockCache::high_pri_insert_count);
-      ASSERT_EQ(1u, MockCache::low_pri_insert_count);
+      ASSERT_EQ(2, MockCache::high_pri_insert_count);
+      ASSERT_EQ(1, MockCache::low_pri_insert_count);
    }
  }
 }
@@ -705,8 +671,6 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
    options.table_factory.reset(new BlockBasedTableFactory(table_options));
    DestroyAndReopen(options);

-    RecordCacheCountersForCompressionDict(options);
-
    for (int i = 0; i < kNumFiles; ++i) {
      ASSERT_EQ(i, NumTableFilesAtLevel(0, 0));
      for (int j = 0; j < kNumEntriesPerFile; ++j) {
@@ -719,26 +683,27 @@ TEST_F(DBBlockCacheTest, CacheCompressionDict) {
    ASSERT_EQ(0, NumTableFilesAtLevel(0));
    ASSERT_EQ(kNumFiles, NumTableFilesAtLevel(1));

-    // Compression dictionary blocks are preloaded.
-    CheckCacheCountersForCompressionDict(
-        options, kNumFiles /* expected_compression_dict_misses */,
-        0 /* expected_compression_dict_hits */,
-        kNumFiles /* expected_compression_dict_inserts */);
-
    // Seek to a key in a file. It should cause the SST's dictionary meta-block
    // to be read.
    RecordCacheCounters(options);
-    RecordCacheCountersForCompressionDict(options);
+    ASSERT_EQ(0,
+              TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
+    ASSERT_EQ(0, TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_ADD));
+    ASSERT_EQ(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        0);
    ReadOptions read_options;
    ASSERT_NE("NOT_FOUND", Get(Key(kNumFiles * kNumEntriesPerFile - 1)));
-    // Two block hits: index and dictionary since they are prefetched
-    // One block missed/added: data block
-    CheckCacheCounters(options, 1 /* expected_misses */, 2 /* expected_hits */,
-                       1 /* expected_inserts */, 0 /* expected_failures */);
-    CheckCacheCountersForCompressionDict(
-        options, 0 /* expected_compression_dict_misses */,
-        1 /* expected_compression_dict_hits */,
-        0 /* expected_compression_dict_inserts */);
+    // Two blocks missed/added: dictionary and data block
+    // One block hit: index since it's prefetched
+    CheckCacheCounters(options, 2 /* expected_misses */, 1 /* expected_hits */,
+                       2 /* expected_inserts */, 0 /* expected_failures */);
+    ASSERT_EQ(1,
+              TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_MISS));
+    ASSERT_EQ(1, TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_ADD));
+    ASSERT_GT(
+        TestGetTickerCount(options, BLOCK_CACHE_COMPRESSION_DICT_BYTES_INSERT),
+        0);
  }
 }

@@ -720,7 +720,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
  cfilter_count = 0;
  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
  // The filter should delete 40 records.
-  ASSERT_EQ(40, cfilter_count);
+  ASSERT_EQ(40U, cfilter_count);

  {
    // Scan the entire database as of the snapshot to ensure
@@ -141,7 +141,7 @@ Options DeletionTriggerOptions(Options options) {
  options.compression = kNoCompression;
  options.write_buffer_size = kCDTKeysPerBuffer * (kCDTValueSize + 24);
  options.min_write_buffer_number_to_merge = 1;
-  options.max_write_buffer_size_to_maintain = 0;
+  options.max_write_buffer_number_to_maintain = 0;
  options.num_levels = kCDTNumLevels;
  options.level0_file_num_compaction_trigger = 1;
  options.target_file_size_base = options.write_buffer_size * 2;
@@ -497,14 +497,14 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {

  // Create new iterator for:
  // (1) 1 for verifying flush results
-  // (2) 1 for verifying compaction results.
-  // (3) New TableReaders will not be created for compaction inputs
-  ASSERT_EQ(num_new_table_reader, 2);
+  // (2) 3 for compaction input files
+  // (3) 1 for verifying compaction results.
+  ASSERT_EQ(num_new_table_reader, 5);

  num_table_cache_lookup = 0;
  num_new_table_reader = 0;
  ASSERT_EQ(Key(1), Get(Key(1)));
-  ASSERT_EQ(num_table_cache_lookup + old_num_table_cache_lookup2, 5);
+  ASSERT_EQ(num_table_cache_lookup + old_num_table_cache_lookup2, 3);
  ASSERT_EQ(num_new_table_reader, 0);

  num_table_cache_lookup = 0;
@@ -519,14 +519,13 @@ TEST_F(DBCompactionTest, TestTableReaderForCompaction) {
  // May preload table cache too.
  ASSERT_GE(num_table_cache_lookup, 1);
  old_num_table_cache_lookup2 = num_table_cache_lookup;
-  // One for verifying compaction results.
-  // No new iterator created for compaction.
-  ASSERT_EQ(num_new_table_reader, 1);
+  // One for compaction input, one for verifying compaction results.
+  ASSERT_EQ(num_new_table_reader, 2);

  num_table_cache_lookup = 0;
  num_new_table_reader = 0;
  ASSERT_EQ(Key(1), Get(Key(1)));
-  ASSERT_EQ(num_table_cache_lookup + old_num_table_cache_lookup2, 3);
+  ASSERT_EQ(num_table_cache_lookup + old_num_table_cache_lookup2, 2);
  ASSERT_EQ(num_new_table_reader, 0);

  rocksdb::SyncPoint::GetInstance()->ClearAllCallBacks();
@@ -732,7 +731,7 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {

  // Now all column families qualify compaction but only one should be
  // scheduled, because no column family hits speed up condition.
-  ASSERT_EQ(1u, env_->GetThreadPoolQueueLen(Env::Priority::LOW));
+  ASSERT_EQ(1, env_->GetThreadPoolQueueLen(Env::Priority::LOW));

  // Create two more files for one column family, which triggers speed up
  // condition, three compactions will be scheduled.
@@ -746,7 +745,7 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {
    ASSERT_EQ(options.level0_file_num_compaction_trigger + num + 1,
              NumTableFilesAtLevel(0, 2));
  }
-  ASSERT_EQ(3U, env_->GetThreadPoolQueueLen(Env::Priority::LOW));
+  ASSERT_EQ(3, env_->GetThreadPoolQueueLen(Env::Priority::LOW));

  // Unblock all threads to unblock all compactions.
  for (size_t i = 0; i < kTotalTasks; i++) {
@@ -777,7 +776,7 @@ TEST_F(DBCompactionTest, BGCompactionsAllowed) {

  // Now all column families qualify compaction but only one should be
  // scheduled, because no column family hits speed up condition.
-  ASSERT_EQ(1U, env_->GetThreadPoolQueueLen(Env::Priority::LOW));
+  ASSERT_EQ(1, env_->GetThreadPoolQueueLen(Env::Priority::LOW));

  for (size_t i = 0; i < kTotalTasks; i++) {
    sleeping_tasks[i].WakeUp();
@@ -4165,7 +4164,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {

  const char* cf_names[] = {"default", "0", "1", "2", "3", "4", "5",
    "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
-  const unsigned int cf_count = sizeof cf_names / sizeof cf_names[0];
+  const int cf_count = sizeof cf_names / sizeof cf_names[0];

  std::unordered_map<std::string, CompactionLimiter*> cf_to_limiter;

@@ -4184,7 +4183,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
  std::vector<Options> option_vector;
  option_vector.reserve(cf_count);

-  for (unsigned int cf = 0; cf < cf_count; cf++) {
+  for (int cf = 0; cf < cf_count; cf++) {
    ColumnFamilyOptions cf_opt(options);
    if (cf == 0) {
      // "Default" CF does't use compaction limiter
@@ -4202,7 +4201,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
    option_vector.emplace_back(DBOptions(options), cf_opt);
  }

-  for (unsigned int cf = 1; cf < cf_count; cf++) {
+  for (int cf = 1; cf < cf_count; cf++) {
    CreateColumnFamilies({cf_names[cf]}, option_vector[cf]);
  }

@@ -4254,7 +4253,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
  int keyIndex = 0;

  for (int n = 0; n < options.level0_file_num_compaction_trigger; n++) {
-    for (unsigned int cf = 0; cf < cf_count; cf++) {
+    for (int cf = 0; cf < cf_count; cf++) {
      for (int i = 0; i < kNumKeysPerFile; i++) {
        ASSERT_OK(Put(cf, Key(keyIndex++), ""));
      }
@@ -4262,13 +4261,13 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
      ASSERT_OK(Put(cf, "", ""));
    }

-    for (unsigned int cf = 0; cf < cf_count; cf++) {
+    for (int cf = 0; cf < cf_count; cf++) {
      dbfull()->TEST_WaitForFlushMemTable(handles_[cf]);
    }
  }

  // Enough L0 files to trigger compaction
-  for (unsigned int cf = 0; cf < cf_count; cf++) {
+  for (int cf = 0; cf < cf_count; cf++) {
    ASSERT_EQ(NumTableFilesAtLevel(0, cf),
      options.level0_file_num_compaction_trigger);
  }
@@ -4295,7 +4294,7 @@ TEST_F(DBCompactionTest, CompactionLimiter) {
    sleeping_compact_tasks[i].WaitUntilDone();
  }

-  for (unsigned int cf = 0; cf < cf_count; cf++) {
+  for (int cf = 0; cf < cf_count; cf++) {
    dbfull()->TEST_WaitForFlushMemTable(handles_[cf]);
  }

@@ -4340,6 +4339,12 @@ TEST_P(DBCompactionDirectIOTest, DirectIO) {
  options.env = new MockEnv(Env::Default());
  Reopen(options);
  bool readahead = false;
+  SyncPoint::GetInstance()->SetCallBack(
+      "TableCache::NewIterator:for_compaction", [&](void* arg) {
+        bool* use_direct_reads = static_cast<bool*>(arg);
+        ASSERT_EQ(*use_direct_reads,
+                  options.use_direct_reads);
+      });
  SyncPoint::GetInstance()->SetCallBack(
      "CompactionJob::OpenCompactionOutputFile", [&](void* arg) {
        bool* use_direct_writes = static_cast<bool*>(arg);
@@ -4658,31 +4663,7 @@ TEST_P(DBCompactionTestWithParam, FixFileIngestionCompactionDeadlock) {
  ASSERT_OK(dbfull()->TEST_WaitForCompact());
  Close();
 }
-TEST_F(DBCompactionTest, ConsistencyFailTest) {
-  Options options = CurrentOptions();
-  DestroyAndReopen(options);

-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "VersionBuilder::CheckConsistency", [&](void* arg) {
-      auto p =
-            reinterpret_cast<std::pair<FileMetaData**, FileMetaData**>*>(arg);
-        // just swap the two FileMetaData so that we hit error
-        // in CheckConsistency funcion
-        FileMetaData* temp = *(p->first);
-        *(p->first) = *(p->second);
-        *(p->second) = temp;
-      });
-
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  for (int k = 0; k < 2; ++k) {
-    ASSERT_OK(Put("foo", "bar"));
-    Flush();
-  }
-
-  ASSERT_NOK(Put("foo", "bar"));
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
 #endif // !defined(ROCKSDB_LITE)
 }  // namespace rocksdb

@@ -83,34 +83,6 @@ TEST_F(DBEncryptionTest, CheckEncrypted) {
  }
 }

-TEST_F(DBEncryptionTest, ReadEmptyFile) {
-  auto defaultEnv = Env::Default();
-
-  // create empty file for reading it back in later
-  auto envOptions = EnvOptions(CurrentOptions());
-  auto filePath = dbname_ + "/empty.empty";
-
-  Status status;
-  {
-    std::unique_ptr<WritableFile> writableFile;
-    status = defaultEnv->NewWritableFile(filePath, &writableFile, envOptions);
-    ASSERT_OK(status);
-  }
-
-  std::unique_ptr<SequentialFile> seqFile;
-  status = defaultEnv->NewSequentialFile(filePath, &seqFile, envOptions);
-  ASSERT_OK(status);
-
-  std::string scratch;
-  Slice data;
-  // reading back 16 bytes from the empty file shouldn't trigger an assertion.
-  // it should just work and return an empty string
-  status = seqFile->Read(16, &data, (char*)scratch.data());
-  ASSERT_OK(status);
-
-  ASSERT_TRUE(data.empty());
-}
-
 #endif // ROCKSDB_LITE

 }  // namespace rocksdb
@@ -163,16 +163,6 @@ Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
  return wal_manager_.GetSortedWalFiles(files);
 }

-Status DBImpl::GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) {
-  uint64_t current_logfile_number;
-  {
-    InstrumentedMutexLock l(&mutex_);
-    current_logfile_number = logfile_number_;
-  }
-
-  return wal_manager_.GetLiveWalFile(current_logfile_number, current_log_file);
-}
-
 }

 #endif  // ROCKSDB_LITE
@@ -14,7 +14,6 @@
 #endif

 #include <algorithm>
-#include <cinttypes>
 #include <cstdio>
 #include <map>
 #include <set>
@@ -35,7 +34,6 @@
 #include "db/external_sst_file_ingestion_job.h"
 #include "db/flush_job.h"
 #include "db/forward_iterator.h"
-#include "db/import_column_family_job.h"
 #include "db/job_context.h"
 #include "db/log_reader.h"
 #include "db/log_writer.h"
@@ -91,7 +89,6 @@
 #include "tools/sst_dump_tool_imp.h"
 #include "util/autovector.h"
 #include "util/build_version.h"
-#include "util/cast_util.h"
 #include "util/coding.h"
 #include "util/compression.h"
 #include "util/crc32c.h"
@@ -104,6 +101,7 @@ namespace rocksdb {
 const std::string kDefaultColumnFamilyName("default");
 const std::string kPersistentStatsColumnFamilyName(
    "___rocksdb_stats_history___");
+const int kMicrosInSecond = 1000 * 1000;
 void DumpRocksDBBuildVersion(Logger* log);

 CompressionType GetCompressionFlush(
@@ -472,7 +470,6 @@ Status DBImpl::CloseHelper() {
                           &files_grabbed_for_purge_);
  EraseThreadStatusDbInfo();
  flush_scheduler_.Clear();
-  trim_history_scheduler_.Clear();

  while (!flush_queue_.empty()) {
    const FlushRequest& flush_req = PopFirstFromFlushQueue();
@@ -701,15 +698,10 @@ void DBImpl::PersistStats() {
  if (!statistics->getTickerMap(&stats_map)) {
    return;
  }
-  ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                 "------- PERSISTING STATS -------");

  if (immutable_db_options_.persist_stats_to_disk) {
    WriteBatch batch;
    if (stats_slice_initialized_) {
-      ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                     "Reading %" ROCKSDB_PRIszt " stats from statistics\n",
-                     stats_slice_.size());
      for (const auto& stat : stats_map) {
        char key[100];
        int length =
@@ -731,13 +723,8 @@ void DBImpl::PersistStats() {
    Status s = Write(wo, &batch);
    if (!s.ok()) {
      ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                     "Writing to persistent stats CF failed -- %s",
+                     "Writing to persistent stats CF failed -- %s\n",
                     s.ToString().c_str());
-    } else {
-      ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                     "Writing %" ROCKSDB_PRIszt " stats with timestamp %" PRIu64
-                     " to persistent stats CF succeeded",
-                     stats_slice_.size(), now_seconds);
    }
    // TODO(Zhongyi): add purging for persisted data
  } else {
@@ -750,10 +737,6 @@ void DBImpl::PersistStats() {
          stats_delta[stat.first] = stat.second - stats_slice_[stat.first];
        }
      }
-      ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                     "Storing %" ROCKSDB_PRIszt " stats with timestamp %" PRIu64
-                     " to in-memory stats history",
-                     stats_slice_.size(), now_seconds);
      stats_history_[now_seconds] = stats_delta;
    }
    stats_slice_initialized_ = true;
@@ -761,22 +744,15 @@ void DBImpl::PersistStats() {
    TEST_SYNC_POINT("DBImpl::PersistStats:StatsCopied");

    // delete older stats snapshots to control memory consumption
-    size_t stats_history_size = EstimateInMemoryStatsHistorySize();
-    bool purge_needed = stats_history_size > stats_history_size_limit;
-    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "[Pre-GC] In-memory stats history size: %" ROCKSDB_PRIszt
-                   " bytes, slice count: %" ROCKSDB_PRIszt,
-                   stats_history_size, stats_history_.size());
+    bool purge_needed =
+        EstimateInMemoryStatsHistorySize() > stats_history_size_limit;
    while (purge_needed && !stats_history_.empty()) {
      stats_history_.erase(stats_history_.begin());
      purge_needed =
          EstimateInMemoryStatsHistorySize() > stats_history_size_limit;
    }
-    ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                   "[Post-GC] In-memory stats history size: %" ROCKSDB_PRIszt
-                   " bytes, slice count: %" ROCKSDB_PRIszt,
-                   stats_history_size, stats_history_.size());
  }
+  // TODO: persist stats to disk
 #endif  // !ROCKSDB_LITE
 }

@@ -866,24 +842,6 @@ void DBImpl::DumpStats() {
  PrintStatistics();
 }

-Status DBImpl::TablesRangeTombstoneSummary(ColumnFamilyHandle* column_family,
-                                           int max_entries_to_print,
-                                           std::string* out_str) {
-  auto* cfh =
-      static_cast_with_check<ColumnFamilyHandleImpl, ColumnFamilyHandle>(
-          column_family);
-  ColumnFamilyData* cfd = cfh->cfd();
-
-  SuperVersion* super_version = cfd->GetReferencedSuperVersion(&mutex_);
-  Version* version = super_version->current;
-
-  Status s =
-      version->TablesRangeTombstoneSummary(max_entries_to_print, out_str);
-
-  CleanupSuperVersion(super_version);
-  return s;
-}
-
 void DBImpl::ScheduleBgLogWriterClose(JobContext* job_context) {
  if (!job_context->logs_to_free.empty()) {
    for (auto l : job_context->logs_to_free) {
@@ -903,6 +861,16 @@ Directory* DBImpl::GetDataDir(ColumnFamilyData* cfd, size_t path_id) const {
  return ret_dir;
 }

+Directory* DBImpl::Directories::GetDataDir(size_t path_id) const {
+  assert(path_id < data_dirs_.size());
+  Directory* ret_dir = data_dirs_[path_id].get();
+  if (ret_dir == nullptr) {
+    // Should use db_dir_
+    return db_dir_.get();
+  }
+  return ret_dir;
+}
+
 Status DBImpl::SetOptions(
    ColumnFamilyHandle* column_family,
    const std::unordered_map<std::string, std::string>& options_map) {
@@ -1461,22 +1429,28 @@ ColumnFamilyHandle* DBImpl::PersistentStatsColumnFamily() const {
 Status DBImpl::Get(const ReadOptions& read_options,
                   ColumnFamilyHandle* column_family, const Slice& key,
                   PinnableSlice* value) {
-  GetImplOptions get_impl_options;
-  get_impl_options.column_family = column_family;
-  get_impl_options.value = value;
-  return GetImpl(read_options, key, get_impl_options);
+  if (nullptr == read_options.timestamp) {
+    return GetImpl(read_options, column_family, key, value);
+  }
+  Slice akey;
+  std::string buf;
+  Status s = AppendTimestamp(key, *(read_options.timestamp), &akey, &buf);
+  if (s.ok()) {
+    s = GetImpl(read_options, column_family, akey, value);
+  }
+  return s;
 }

-Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
-                       GetImplOptions get_impl_options) {
-  assert(get_impl_options.value != nullptr ||
-         get_impl_options.merge_operands != nullptr);
+Status DBImpl::GetImpl(const ReadOptions& read_options,
+                       ColumnFamilyHandle* column_family, const Slice& key,
+                       PinnableSlice* pinnable_val, bool* value_found,
+                       ReadCallback* callback, bool* is_blob_index) {
+  assert(pinnable_val != nullptr);
  PERF_CPU_TIMER_GUARD(get_cpu_nanos, env_);
  StopWatch sw(env_, stats_, DB_GET);
  PERF_TIMER_GUARD(get_snapshot_time);

-  auto cfh =
-      reinterpret_cast<ColumnFamilyHandleImpl*>(get_impl_options.column_family);
+  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();

  if (tracer_) {
@@ -1484,7 +1458,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
    // tracing is enabled.
    InstrumentedMutexLock lock(&trace_mutex_);
    if (tracer_) {
-      tracer_->Get(get_impl_options.column_family, key);
+      tracer_->Get(column_family, key);
    }
  }

@@ -1496,9 +1470,9 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,

  SequenceNumber snapshot;
  if (read_options.snapshot != nullptr) {
-    if (get_impl_options.callback) {
+    if (callback) {
      // Already calculated based on read_options.snapshot
-      snapshot = get_impl_options.callback->max_visible_seq();
+      snapshot = callback->max_visible_seq();
    } else {
      snapshot =
          reinterpret_cast<const SnapshotImpl*>(read_options.snapshot)->number_;
@@ -1512,23 +1486,8 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
    snapshot = last_seq_same_as_publish_seq_
                   ? versions_->LastSequence()
                   : versions_->LastPublishedSequence();
-    if (get_impl_options.callback) {
-      // The unprep_seqs are not published for write unprepared, so it could be
-      // that max_visible_seq is larger. Seek to the std::max of the two.
-      // However, we still want our callback to contain the actual snapshot so
-      // that it can do the correct visibility filtering.
-      get_impl_options.callback->Refresh(snapshot);
-
-      // Internally, WriteUnpreparedTxnReadCallback::Refresh would set
-      // max_visible_seq = max(max_visible_seq, snapshot)
-      //
-      // Currently, the commented out assert is broken by
-      // InvalidSnapshotReadCallback, but if write unprepared recovery followed
-      // the regular transaction flow, then this special read callback would not
-      // be needed.
-      //
-      // assert(callback->max_visible_seq() >= snapshot);
-      snapshot = get_impl_options.callback->max_visible_seq();
+    if (callback) {
+      callback->Refresh(snapshot);
    }
  }
  TEST_SYNC_POINT("DBImpl::GetImpl:3");
@@ -1542,46 +1501,26 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
  // First look in the memtable, then in the immutable memtable (if any).
  // s is both in/out. When in, s could either be OK or MergeInProgress.
  // merge_operands will contain the sequence of merges in the latter case.
-  LookupKey lkey(key, snapshot, read_options.timestamp);
+  LookupKey lkey(key, snapshot);
  PERF_TIMER_STOP(get_snapshot_time);

  bool skip_memtable = (read_options.read_tier == kPersistedTier &&
                        has_unpersisted_data_.load(std::memory_order_relaxed));
  bool done = false;
  if (!skip_memtable) {
-    // Get value associated with key
-    if (get_impl_options.get_value) {
-      if (sv->mem->Get(lkey, get_impl_options.value->GetSelf(), &s,
-                       &merge_context, &max_covering_tombstone_seq,
-                       read_options, get_impl_options.callback,
-                       get_impl_options.is_blob_index)) {
-        done = true;
-        get_impl_options.value->PinSelf();
-        RecordTick(stats_, MEMTABLE_HIT);
-      } else if ((s.ok() || s.IsMergeInProgress()) &&
-                 sv->imm->Get(lkey, get_impl_options.value->GetSelf(), &s,
-                              &merge_context, &max_covering_tombstone_seq,
-                              read_options, get_impl_options.callback,
-                              get_impl_options.is_blob_index)) {
-        done = true;
-        get_impl_options.value->PinSelf();
-        RecordTick(stats_, MEMTABLE_HIT);
-      }
-    } else {
-      // Get Merge Operands associated with key, Merge Operands should not be
-      // merged and raw values should be returned to the user.
-      if (sv->mem->Get(lkey, nullptr, &s, &merge_context,
-                       &max_covering_tombstone_seq, read_options, nullptr,
-                       nullptr, false)) {
-        done = true;
-        RecordTick(stats_, MEMTABLE_HIT);
-      } else if ((s.ok() || s.IsMergeInProgress()) &&
-                 sv->imm->GetMergeOperands(lkey, &s, &merge_context,
-                                           &max_covering_tombstone_seq,
-                                           read_options)) {
-        done = true;
-        RecordTick(stats_, MEMTABLE_HIT);
-      }
+    if (sv->mem->Get(lkey, pinnable_val->GetSelf(), &s, &merge_context,
+                     &max_covering_tombstone_seq, read_options, callback,
+                     is_blob_index)) {
+      done = true;
+      pinnable_val->PinSelf();
+      RecordTick(stats_, MEMTABLE_HIT);
+    } else if ((s.ok() || s.IsMergeInProgress()) &&
+               sv->imm->Get(lkey, pinnable_val->GetSelf(), &s, &merge_context,
+                            &max_covering_tombstone_seq, read_options, callback,
+                            is_blob_index)) {
+      done = true;
+      pinnable_val->PinSelf();
+      RecordTick(stats_, MEMTABLE_HIT);
    }
    if (!done && !s.ok() && !s.IsMergeInProgress()) {
      ReturnAndCleanupSuperVersion(cfd, sv);
@@ -1590,14 +1529,9 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
  }
  if (!done) {
    PERF_TIMER_GUARD(get_from_output_files_time);
-    sv->current->Get(
-        read_options, lkey, get_impl_options.value, &s, &merge_context,
-        &max_covering_tombstone_seq,
-        get_impl_options.get_value ? get_impl_options.value_found : nullptr,
-        nullptr, nullptr,
-        get_impl_options.get_value ? get_impl_options.callback : nullptr,
-        get_impl_options.get_value ? get_impl_options.is_blob_index : nullptr,
-        get_impl_options.get_value);
+    sv->current->Get(read_options, lkey, pinnable_val, &s, &merge_context,
+                     &max_covering_tombstone_seq, value_found, nullptr, nullptr,
+                     callback, is_blob_index);
    RecordTick(stats_, MEMTABLE_MISS);
  }

@@ -1609,25 +1543,7 @@ Status DBImpl::GetImpl(const ReadOptions& read_options, const Slice& key,
    RecordTick(stats_, NUMBER_KEYS_READ);
    size_t size = 0;
    if (s.ok()) {
-      if (get_impl_options.get_value) {
-        size = get_impl_options.value->size();
-      } else {
-        // Return all merge operands for get_impl_options.key
-        *get_impl_options.number_of_operands =
-            static_cast<int>(merge_context.GetNumOperands());
-        if (*get_impl_options.number_of_operands >
-            get_impl_options.get_merge_operands_options
-                ->expected_max_number_of_operands) {
-          s = Status::Incomplete(
-              Status::SubCode::KMergeOperandsInsufficientCapacity);
-        } else {
-          for (const Slice& sl : merge_context.GetOperands()) {
-            size += sl.size();
-            get_impl_options.merge_operands->PinSelf(sl);
-            get_impl_options.merge_operands++;
-          }
-        }
-      }
+      size = pinnable_val->size();
      RecordTick(stats_, BYTES_READ, size);
      PERF_COUNTER_ADD(get_read_bytes, size);
    }
@@ -1923,24 +1839,6 @@ void DBImpl::MultiGetImpl(
    snapshot = last_seq_same_as_publish_seq_
                   ? versions_->LastSequence()
                   : versions_->LastPublishedSequence();
-    if (callback) {
-      // The unprep_seqs are not published for write unprepared, so it could be
-      // that max_visible_seq is larger. Seek to the std::max of the two.
-      // However, we still want our callback to contain the actual snapshot so
-      // that it can do the correct visibility filtering.
-      callback->Refresh(snapshot);
-
-      // Internally, WriteUnpreparedTxnReadCallback::Refresh would set
-      // max_visible_seq = max(max_visible_seq, snapshot)
-      //
-      // Currently, the commented out assert is broken by
-      // InvalidSnapshotReadCallback, but if write unprepared recovery followed
-      // the regular transaction flow, then this special read callback would not
-      // be needed.
-      //
-      // assert(callback->max_visible_seq() >= snapshot);
-      snapshot = callback->max_visible_seq();
-    }
  }

  // For each of the given keys, apply the entire "get" process as follows:
@@ -2288,11 +2186,7 @@ bool DBImpl::KeyMayExist(const ReadOptions& read_options,
  ReadOptions roptions = read_options;
  roptions.read_tier = kBlockCacheTier;  // read from block cache only
  PinnableSlice pinnable_val;
-  GetImplOptions get_impl_options;
-  get_impl_options.column_family = column_family;
-  get_impl_options.value = &pinnable_val;
-  get_impl_options.value_found = value_found;
-  auto s = GetImpl(roptions, key, get_impl_options);
+  auto s = GetImpl(roptions, column_family, key, &pinnable_val, value_found);
  value->assign(pinnable_val.data(), pinnable_val.size());

  // If block_cache is enabled and the index block of the table didn't
@@ -2858,13 +2752,11 @@ void DBImpl::GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
  ReturnAndCleanupSuperVersion(cfd, sv);
 }

-Status DBImpl::GetApproximateSizes(const SizeApproximationOptions& options,
-                                   ColumnFamilyHandle* column_family,
-                                   const Range* range, int n, uint64_t* sizes) {
-  if (!options.include_memtabtles && !options.include_files) {
-    return Status::InvalidArgument("Invalid options");
-  }
-
+void DBImpl::GetApproximateSizes(ColumnFamilyHandle* column_family,
+                                 const Range* range, int n, uint64_t* sizes,
+                                 uint8_t include_flags) {
+  assert(include_flags & DB::SizeApproximationFlags::INCLUDE_FILES ||
+         include_flags & DB::SizeApproximationFlags::INCLUDE_MEMTABLES);
  Version* v;
  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family);
  auto cfd = cfh->cfd();
@@ -2876,19 +2768,18 @@ Status DBImpl::GetApproximateSizes(const SizeApproximationOptions& options,
    InternalKey k1(range[i].start, kMaxSequenceNumber, kValueTypeForSeek);
    InternalKey k2(range[i].limit, kMaxSequenceNumber, kValueTypeForSeek);
    sizes[i] = 0;
-    if (options.include_files) {
+    if (include_flags & DB::SizeApproximationFlags::INCLUDE_FILES) {
      sizes[i] += versions_->ApproximateSize(
-          options, v, k1.Encode(), k2.Encode(), /*start_level=*/0,
-          /*end_level=*/-1, TableReaderCaller::kUserApproximateSize);
+          v, k1.Encode(), k2.Encode(), /*start_level=*/0, /*end_level=*/-1,
+          /*for_compaction=*/false);
    }
-    if (options.include_memtabtles) {
+    if (include_flags & DB::SizeApproximationFlags::INCLUDE_MEMTABLES) {
      sizes[i] += sv->mem->ApproximateStats(k1.Encode(), k2.Encode()).size;
      sizes[i] += sv->imm->ApproximateStats(k1.Encode(), k2.Encode()).size;
    }
  }

  ReturnAndCleanupSuperVersion(cfd, sv);
-  return Status::OK();
 }

 std::list<uint64_t>::iterator
@@ -3158,11 +3049,6 @@ Status DBImpl::CheckConsistency() {
 }

 Status DBImpl::GetDbIdentity(std::string& identity) const {
-  identity.assign(db_id_);
-  return Status::OK();
-}
-
-Status DBImpl::GetDbIdentityFromIdentityFile(std::string* identity) const {
  std::string idfilename = IdentityFileName(dbname_);
  const EnvOptions soptions;
  std::unique_ptr<SequentialFileReader> id_file_reader;
@@ -3189,10 +3075,10 @@ Status DBImpl::GetDbIdentityFromIdentityFile(std::string* identity) const {
  if (!s.ok()) {
    return s;
  }
-  identity->assign(id.ToString());
+  identity.assign(id.ToString());
  // If last character is '\n' remove it from identity
-  if (identity->size() > 0 && identity->back() == '\n') {
-    identity->pop_back();
+  if (identity.size() > 0 && identity.back() == '\n') {
+    identity.pop_back();
  }
  return s;
 }
@@ -3764,7 +3650,7 @@ Status DBImpl::IngestExternalFiles(
    auto* cfd = static_cast<ColumnFamilyHandleImpl*>(arg.column_family)->cfd();
    ingestion_jobs.emplace_back(env_, versions_.get(), cfd,
                                immutable_db_options_, env_options_,
-                                &snapshots_, arg.options, &directories_);
+                                &snapshots_, arg.options);
  }
  std::vector<std::pair<bool, Status>> exec_results;
  for (size_t i = 0; i != num_cfs; ++i) {
@@ -3997,128 +3883,7 @@ Status DBImpl::IngestExternalFiles(
  return status;
 }

-Status DBImpl::CreateColumnFamilyWithImport(
-    const ColumnFamilyOptions& options, const std::string& column_family_name,
-    const ImportColumnFamilyOptions& import_options,
-    const ExportImportFilesMetaData& metadata,
-    ColumnFamilyHandle** handle) {
-  assert(handle != nullptr);
-  assert(*handle == nullptr);
-  std::string cf_comparator_name = options.comparator->Name();
-  if (cf_comparator_name != metadata.db_comparator_name) {
-    return Status::InvalidArgument("Comparator name mismatch");
-  }
-
-  // Create column family.
-  auto status = CreateColumnFamily(options, column_family_name, handle);
-  if (!status.ok()) {
-    return status;
-  }
-
-  // Import sst files from metadata.
-  auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(*handle);
-  auto cfd = cfh->cfd();
-  ImportColumnFamilyJob import_job(env_, versions_.get(), cfd,
-                                   immutable_db_options_, env_options_,
-                                   import_options, metadata.files);
-
-  SuperVersionContext dummy_sv_ctx(/* create_superversion */ true);
-  VersionEdit dummy_edit;
-  uint64_t next_file_number = 0;
-  std::list<uint64_t>::iterator pending_output_elem;
-  {
-    // Lock db mutex
-    InstrumentedMutexLock l(&mutex_);
-    if (error_handler_.IsDBStopped()) {
-      // Don't import files when there is a bg_error
-      status = error_handler_.GetBGError();
-    }
-
-    // Make sure that bg cleanup wont delete the files that we are importing
-    pending_output_elem = CaptureCurrentFileNumberInPendingOutputs();
-
-    if (status.ok()) {
-      // If crash happen after a hard link established, Recover function may
-      // reuse the file number that has already assigned to the internal file,
-      // and this will overwrite the external file. To protect the external
-      // file, we have to make sure the file number will never being reused.
-      next_file_number =
-          versions_->FetchAddFileNumber(metadata.files.size());
-      auto cf_options = cfd->GetLatestMutableCFOptions();
-      status = versions_->LogAndApply(cfd, *cf_options, &dummy_edit, &mutex_,
-                                      directories_.GetDbDir());
-      if (status.ok()) {
-        InstallSuperVersionAndScheduleWork(cfd, &dummy_sv_ctx, *cf_options);
-      }
-    }
-  }
-  dummy_sv_ctx.Clean();
-
-  if (status.ok()) {
-    SuperVersion* sv = cfd->GetReferencedSuperVersion(&mutex_);
-    status = import_job.Prepare(next_file_number, sv);
-    CleanupSuperVersion(sv);
-  }
-
-  if (status.ok()) {
-    SuperVersionContext sv_context(true /*create_superversion*/);
-    {
-      // Lock db mutex
-      InstrumentedMutexLock l(&mutex_);
-
-      // Stop writes to the DB by entering both write threads
-      WriteThread::Writer w;
-      write_thread_.EnterUnbatched(&w, &mutex_);
-      WriteThread::Writer nonmem_w;
-      if (two_write_queues_) {
-        nonmem_write_thread_.EnterUnbatched(&nonmem_w, &mutex_);
-      }
-
-      num_running_ingest_file_++;
-      assert(!cfd->IsDropped());
-      status = import_job.Run();
-
-      // Install job edit [Mutex will be unlocked here]
-      if (status.ok()) {
-        auto cf_options = cfd->GetLatestMutableCFOptions();
-        status = versions_->LogAndApply(cfd, *cf_options, import_job.edit(),
-                                        &mutex_, directories_.GetDbDir());
-        if (status.ok()) {
-          InstallSuperVersionAndScheduleWork(cfd, &sv_context, *cf_options);
-        }
-      }
-
-      // Resume writes to the DB
-      if (two_write_queues_) {
-        nonmem_write_thread_.ExitUnbatched(&nonmem_w);
-      }
-      write_thread_.ExitUnbatched(&w);
-
-      num_running_ingest_file_--;
-      if (num_running_ingest_file_ == 0) {
-        bg_cv_.SignalAll();
-      }
-    }
-    // mutex_ is unlocked here
-
-    sv_context.Clean();
-  }
-
-  {
-    InstrumentedMutexLock l(&mutex_);
-    ReleaseFileNumberFromPendingOutputs(pending_output_elem);
-  }
-
-  import_job.Cleanup(status);
-  if (!status.ok()) {
-    DropColumnFamily(*handle);
-    DestroyColumnFamilyHandle(*handle);
-    *handle = nullptr;
-  }
-  return status;
-}
-
-Status DBImpl::VerifyChecksum(const ReadOptions& read_options) {
+Status DBImpl::VerifyChecksum() {
  Status s;
  std::vector<ColumnFamilyData*> cfd_list;
  {
@@ -4149,8 +3914,7 @@ Status DBImpl::VerifyChecksum(const ReadOptions& read_options) {
        const auto& fd = vstorage->LevelFilesBrief(i).files[j].fd;
        std::string fname = TableFileName(cfd->ioptions()->cf_paths,
                                          fd.GetNumber(), fd.GetPathId());
-        s = rocksdb::VerifySstFileChecksum(opts, env_options_, read_options,
-                                           fname);
+        s = rocksdb::VerifySstFileChecksum(opts, env_options_, fname);
      }
    }
    if (!s.ok()) {
@@ -27,7 +27,6 @@
 #include "db/external_sst_file_ingestion_job.h"
 #include "db/flush_job.h"
 #include "db/flush_scheduler.h"
-#include "db/import_column_family_job.h"
 #include "db/internal_stats.h"
 #include "db/log_writer.h"
 #include "db/logs_with_prep_tracker.h"
@@ -37,7 +36,6 @@
 #include "db/read_callback.h"
 #include "db/snapshot_checker.h"
 #include "db/snapshot_impl.h"
-#include "db/trim_history_scheduler.h"
 #include "db/version_edit.h"
 #include "db/wal_manager.h"
 #include "db/write_controller.h"
@@ -79,38 +77,6 @@ struct JobContext;
 struct ExternalSstFileInfo;
 struct MemTableInfo;

-// Class to maintain directories for all database paths other than main one.
-class Directories {
- public:
-  Status SetDirectories(Env* env, const std::string& dbname,
-                        const std::string& wal_dir,
-                        const std::vector<DbPath>& data_paths);
-
-  Directory* GetDataDir(size_t path_id) const {
-    assert(path_id < data_dirs_.size());
-    Directory* ret_dir = data_dirs_[path_id].get();
-    if (ret_dir == nullptr) {
-      // Should use db_dir_
-      return db_dir_.get();
-    }
-    return ret_dir;
-  }
-
-  Directory* GetWalDir() {
-    if (wal_dir_) {
-      return wal_dir_.get();
-    }
-    return db_dir_.get();
-  }
-
-  Directory* GetDbDir() { return db_dir_.get(); }
-
- private:
-  std::unique_ptr<Directory> db_dir_;
-  std::vector<std::unique_ptr<Directory>> data_dirs_;
-  std::unique_ptr<Directory> wal_dir_;
-};
-
 // While DB is the public interface of RocksDB, and DBImpl is the actual
 // class implementing it. It's the entrance of the core RocksdB engine.
 // All other DB implementations, e.g. TransactionDB, BlobDB, etc, wrap a
@@ -128,10 +94,6 @@ class DBImpl : public DB {
 public:
  DBImpl(const DBOptions& options, const std::string& dbname,
         const bool seq_per_batch = false, const bool batch_per_txn = true);
-  // No copying allowed
-  DBImpl(const DBImpl&) = delete;
-  void operator=(const DBImpl&) = delete;
-
  virtual ~DBImpl();

  // ---- Implementations of the DB interface ----
@@ -164,21 +126,6 @@ class DBImpl : public DB {
                     ColumnFamilyHandle* column_family, const Slice& key,
                     PinnableSlice* value) override;

-  using DB::GetMergeOperands;
-  Status GetMergeOperands(const ReadOptions& options,
-                          ColumnFamilyHandle* column_family, const Slice& key,
-                          PinnableSlice* merge_operands,
-                          GetMergeOperandsOptions* get_merge_operands_options,
-                          int* number_of_operands) override {
-    GetImplOptions get_impl_options;
-    get_impl_options.column_family = column_family;
-    get_impl_options.merge_operands = merge_operands;
-    get_impl_options.get_merge_operands_options = get_merge_operands_options;
-    get_impl_options.number_of_operands = number_of_operands;
-    get_impl_options.get_value = false;
-    return GetImpl(options, key, get_impl_options);
-  }
-
  using DB::MultiGet;
  virtual std::vector<Status> MultiGet(
      const ReadOptions& options,
@@ -253,10 +200,9 @@ class DBImpl : public DB {
  virtual bool GetAggregatedIntProperty(const Slice& property,
                                        uint64_t* aggregated_value) override;
  using DB::GetApproximateSizes;
-  virtual Status GetApproximateSizes(const SizeApproximationOptions& options,
-                                     ColumnFamilyHandle* column_family,
-                                     const Range* range, int n,
-                                     uint64_t* sizes) override;
+  virtual void GetApproximateSizes(
+      ColumnFamilyHandle* column_family, const Range* range, int n,
+      uint64_t* sizes, uint8_t include_flags = INCLUDE_FILES) override;
  using DB::GetApproximateMemTableStats;
  virtual void GetApproximateMemTableStats(ColumnFamilyHandle* column_family,
                                           const Range& range,
@@ -321,8 +267,6 @@ class DBImpl : public DB {

  virtual Status GetDbIdentity(std::string& identity) const override;

-  virtual Status GetDbIdentityFromIdentityFile(std::string* identity) const;
-
  ColumnFamilyHandle* DefaultColumnFamily() const override;

  ColumnFamilyHandle* PersistentStatsColumnFamily() const;
@@ -344,7 +288,6 @@ class DBImpl : public DB {
                              uint64_t* manifest_file_size,
                              bool flush_memtable = true) override;
  virtual Status GetSortedWalFiles(VectorLogPtr& files) override;
-  virtual Status GetCurrentWalFile(std::unique_ptr<LogFile>* current_log_file) override;

  virtual Status GetUpdatesSince(
      SequenceNumber seq_number, std::unique_ptr<TransactionLogIterator>* iter,
@@ -381,15 +324,7 @@ class DBImpl : public DB {
  virtual Status IngestExternalFiles(
      const std::vector<IngestExternalFileArg>& args) override;

-  using DB::CreateColumnFamilyWithImport;
-  virtual Status CreateColumnFamilyWithImport(
-      const ColumnFamilyOptions& options, const std::string& column_family_name,
-      const ImportColumnFamilyOptions& import_options,
-      const ExportImportFilesMetaData& metadata,
-      ColumnFamilyHandle** handle) override;
-
-  using DB::VerifyChecksum;
-  virtual Status VerifyChecksum(const ReadOptions& /*read_options*/) override;
+  virtual Status VerifyChecksum() override;

  using DB::StartTrace;
  virtual Status StartTrace(
@@ -419,32 +354,12 @@ class DBImpl : public DB {

  // ---- End of implementations of the DB interface ----

-  struct GetImplOptions {
-    ColumnFamilyHandle* column_family = nullptr;
-    PinnableSlice* value = nullptr;
-    bool* value_found = nullptr;
-    ReadCallback* callback = nullptr;
-    bool* is_blob_index = nullptr;
-    // If true return value associated with key via value pointer else return
-    // all merge operands for key via merge_operands pointer
-    bool get_value = true;
-    // Pointer to an array of size
-    // get_merge_operands_options.expected_max_number_of_operands allocated by
-    // user
-    PinnableSlice* merge_operands = nullptr;
-    GetMergeOperandsOptions* get_merge_operands_options = nullptr;
-    int* number_of_operands = nullptr;
-  };
-
  // Function that Get and KeyMayExist call with no_io true or false
  // Note: 'value_found' from KeyMayExist propagates here
-  // This function is also called by GetMergeOperands
-  // If get_impl_options.get_value = true get value associated with
-  // get_impl_options.key via get_impl_options.value
-  // If get_impl_options.get_value = false get merge operands associated with
-  // get_impl_options.key via get_impl_options.merge_operands
-  Status GetImpl(const ReadOptions& options, const Slice& key,
-                 GetImplOptions get_impl_options);
+  Status GetImpl(const ReadOptions& options, ColumnFamilyHandle* column_family,
+                 const Slice& key, PinnableSlice* value,
+                 bool* value_found = nullptr, ReadCallback* callback = nullptr,
+                 bool* is_blob_index = nullptr);

  ArenaWrappedDBIter* NewIteratorImpl(const ReadOptions& options,
                                      ColumnFamilyData* cfd,
@@ -821,13 +736,6 @@ class DBImpl : public DB {
                       uint64_t* new_time,
                       std::map<std::string, uint64_t>* stats_map);

-  // Print information of all tombstones of all iterators to the std::string
-  // This is only used by ldb. The output might be capped. Tombstones
-  // printed out are not guaranteed to be in any order.
-  Status TablesRangeTombstoneSummary(ColumnFamilyHandle* column_family,
-                                     int max_entries_to_print,
-                                     std::string* out_str);
-
 #ifndef NDEBUG
  // Compact any files in the named level that overlap [*begin, *end]
  Status TEST_CompactRange(int level, const Slice* begin, const Slice* end,
@@ -928,12 +836,12 @@ class DBImpl : public DB {
  void TEST_WaitForPersistStatsRun(std::function<void()> callback) const;
  bool TEST_IsPersistentStatsEnabled() const;
  size_t TEST_EstimateInMemoryStatsHistorySize() const;
+
 #endif  // NDEBUG

 protected:
  Env* const env_;
  const std::string dbname_;
-  std::string db_id_;
  std::unique_ptr<VersionSet> versions_;
  // Flag to check whether we allocated and own the info log file
  bool own_info_log_;
@@ -1149,6 +1057,30 @@ class DBImpl : public DB {
    }
  };

+  // Class to maintain directories for all database paths other than main one.
+  class Directories {
+   public:
+    Status SetDirectories(Env* env, const std::string& dbname,
+                          const std::string& wal_dir,
+                          const std::vector<DbPath>& data_paths);
+
+    Directory* GetDataDir(size_t path_id) const;
+
+    Directory* GetWalDir() {
+      if (wal_dir_) {
+        return wal_dir_.get();
+      }
+      return db_dir_.get();
+    }
+
+    Directory* GetDbDir() { return db_dir_.get(); }
+
+   private:
+    std::unique_ptr<Directory> db_dir_;
+    std::vector<std::unique_ptr<Directory>> data_dirs_;
+    std::unique_ptr<Directory> wal_dir_;
+  };
+
  struct LogFileNumberSize {
    explicit LogFileNumberSize(uint64_t _number) : number(_number) {}
    void AddSize(uint64_t new_size) { size += new_size; }
@@ -1362,10 +1294,6 @@ class DBImpl : public DB {

  Status ScheduleFlushes(WriteContext* context);

-  void MaybeFlushStatsCF(autovector<ColumnFamilyData*>* cfds);
-
-  Status TrimMemtableHistory(WriteContext* context);
-
  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context);

  void SelectColumnFamiliesForAtomicFlush(autovector<ColumnFamilyData*>* cfds);
@@ -1567,6 +1495,10 @@ class DBImpl : public DB {

  void WaitForBackgroundWork();

+  // No copying allowed
+  DBImpl(const DBImpl&);
+  void operator=(const DBImpl&);
+
  // Background threads call this function, which is just a wrapper around
  // the InstallSuperVersion() function. Background threads carry
  // sv_context which can have new_superversion already
@@ -1740,8 +1672,6 @@ class DBImpl : public DB {

  FlushScheduler flush_scheduler_;

-  TrimHistoryScheduler trim_history_scheduler_;
-
  SnapshotList snapshots_;

  // For each background job, pending_outputs_ keeps the current file number at
@@ -1863,8 +1793,7 @@ class DBImpl : public DB {

  std::string db_absolute_path_;

-  // Number of running IngestExternalFile() or CreateColumnFamilyWithImport()
-  // calls.
+  // Number of running IngestExternalFile() calls.
  // REQUIRES: mutex held
  int num_running_ingest_file_;

@@ -19,7 +19,6 @@
 #include "monitoring/thread_status_updater.h"
 #include "monitoring/thread_status_util.h"
 #include "test_util/sync_point.h"
-#include "util/cast_util.h"
 #include "util/concurrent_task_limiter_impl.h"

 namespace rocksdb {
@@ -1554,39 +1553,13 @@ Status DBImpl::FlushMemTable(ColumnFamilyData* cfd,
    if (!cfd->mem()->IsEmpty() || !cached_recoverable_state_empty_.load()) {
      s = SwitchMemtable(cfd, &context);
    }
+
    if (s.ok()) {
      if (cfd->imm()->NumNotFlushed() != 0 || !cfd->mem()->IsEmpty() ||
          !cached_recoverable_state_empty_.load()) {
        flush_memtable_id = cfd->imm()->GetLatestMemTableID();
        flush_req.emplace_back(cfd, flush_memtable_id);
      }
-      if (immutable_db_options_.persist_stats_to_disk) {
-        ColumnFamilyData* cfd_stats =
-            versions_->GetColumnFamilySet()->GetColumnFamily(
-                kPersistentStatsColumnFamilyName);
-        if (cfd_stats != nullptr && cfd_stats != cfd &&
-            !cfd_stats->mem()->IsEmpty()) {
-          // only force flush stats CF when it will be the only CF lagging
-          // behind after the current flush
-          bool stats_cf_flush_needed = true;
-          for (auto* loop_cfd : *versions_->GetColumnFamilySet()) {
-            if (loop_cfd == cfd_stats || loop_cfd == cfd) {
-              continue;
-            }
-            if (loop_cfd->GetLogNumber() <= cfd_stats->GetLogNumber()) {
-              stats_cf_flush_needed = false;
-            }
-          }
-          if (stats_cf_flush_needed) {
-            ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                           "Force flushing stats CF with manual flush of %s "
-                           "to avoid holding old logs", cfd->GetName().c_str());
-            s = SwitchMemtable(cfd_stats, &context);
-            flush_memtable_id = cfd_stats->imm()->GetLatestMemTableID();
-            flush_req.emplace_back(cfd_stats, flush_memtable_id);
-          }
-        }
-      }
    }

    if (s.ok() && !flush_req.empty()) {
@@ -2073,8 +2046,7 @@ void DBImpl::BGWorkFlush(void* arg) {

  IOSTATS_SET_THREAD_POOL_ID(fta.thread_pri_);
  TEST_SYNC_POINT("DBImpl::BGWorkFlush");
-  static_cast_with_check<DBImpl, DB>(fta.db_)->BackgroundCallFlush(
-      fta.thread_pri_);
+  reinterpret_cast<DBImpl*>(fta.db_)->BackgroundCallFlush(fta.thread_pri_);
  TEST_SYNC_POINT("DBImpl::BGWorkFlush:done");
 }

@@ -2085,7 +2057,7 @@ void DBImpl::BGWorkCompaction(void* arg) {
  TEST_SYNC_POINT("DBImpl::BGWorkCompaction");
  auto prepicked_compaction =
      static_cast<PrepickedCompaction*>(ca.prepicked_compaction);
-  static_cast_with_check<DBImpl, DB>(ca.db)->BackgroundCallCompaction(
+  reinterpret_cast<DBImpl*>(ca.db)->BackgroundCallCompaction(
      prepicked_compaction, Env::Priority::LOW);
  delete prepicked_compaction;
 }
@@ -9,13 +9,12 @@

 #ifndef NDEBUG

-#include "db/column_family.h"
 #include "db/db_impl/db_impl.h"
 #include "db/error_handler.h"
 #include "monitoring/thread_status_updater.h"
-#include "util/cast_util.h"

 namespace rocksdb {
+
 uint64_t DBImpl::TEST_GetLevel0TotalSize() {
  InstrumentedMutexLock l(&mutex_);
  return default_cf_handle_->cfd()->current()->storage_info()->NumLevelBytes(0);
@@ -316,9 +316,11 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {
      candidate_files.size() + state.sst_delete_files.size() +
      state.log_delete_files.size() + state.manifest_delete_files.size());
  // We may ignore the dbname when generating the file names.
+  const char* kDumbDbName = "";
  for (auto& file : state.sst_delete_files) {
    candidate_files.emplace_back(
-        MakeTableFileName(file.metadata->fd.GetNumber()), file.path);
+        MakeTableFileName(kDumbDbName, file.metadata->fd.GetNumber()),
+        file.path);
    if (file.metadata->table_reader_handle) {
      table_cache_->Release(file.metadata->table_reader_handle);
    }
@@ -327,7 +329,7 @@ void DBImpl::PurgeObsoleteFiles(JobContext& state, bool schedule_only) {

  for (auto file_num : state.log_delete_files) {
    if (file_num > 0) {
-      candidate_files.emplace_back(LogFileName(file_num),
+      candidate_files.emplace_back(LogFileName(kDumbDbName, file_num),
                                   immutable_db_options_.wal_dir);
    }
  }
@@ -231,19 +231,12 @@ Status DBImpl::ValidateOptions(const DBOptions& db_options) {

 Status DBImpl::NewDB() {
  VersionEdit new_db;
-  Status s = SetIdentityFile(env_, dbname_);
-  if (!s.ok()) {
-    return s;
-  }
-  if (immutable_db_options_.write_dbid_to_manifest) {
-    std::string temp_db_id;
-    GetDbIdentityFromIdentityFile(&temp_db_id);
-    new_db.SetDBId(temp_db_id);
-  }
  new_db.SetLogNumber(0);
  new_db.SetNextFile(2);
  new_db.SetLastSequence(0);

+  Status s;
+
  ROCKS_LOG_INFO(immutable_db_options_.info_log, "Creating manifest 1 \n");
  const std::string manifest = DescriptorFileName(dbname_, 1);
  {
@@ -291,9 +284,9 @@ Status DBImpl::CreateAndNewDirectory(Env* env, const std::string& dirname,
  return env->NewDirectory(dirname, directory);
 }

-Status Directories::SetDirectories(Env* env, const std::string& dbname,
-                                   const std::string& wal_dir,
-                                   const std::vector<DbPath>& data_paths) {
+Status DBImpl::Directories::SetDirectories(
+    Env* env, const std::string& dbname, const std::string& wal_dir,
+    const std::vector<DbPath>& data_paths) {
  Status s = DBImpl::CreateAndNewDirectory(env, dbname, &db_dir_);
  if (!s.ok()) {
    return s;
@@ -346,9 +339,6 @@ Status DBImpl::Recover(
    s = env_->FileExists(CurrentFileName(dbname_));
    if (s.IsNotFound()) {
      if (immutable_db_options_.create_if_missing) {
-        // Has to be called only after Identity File creation is successful
-        // because DB ID is stored in Manifest if
-        // immutable_db_options_.write_dbid_to_manifest = true
        s = NewDB();
        is_new_db = true;
        if (!s.ok()) {
@@ -368,19 +358,30 @@ Status DBImpl::Recover(
      assert(s.IsIOError());
      return s;
    }
+    // Check for the IDENTITY file and create it if not there
+    s = env_->FileExists(IdentityFileName(dbname_));
+    if (s.IsNotFound()) {
+      s = SetIdentityFile(env_, dbname_);
+      if (!s.ok()) {
+        return s;
+      }
+    } else if (!s.ok()) {
+      assert(s.IsIOError());
+      return s;
+    }
    // Verify compatibility of env_options_ and filesystem
    {
      std::unique_ptr<RandomAccessFile> idfile;
      EnvOptions customized_env(env_options_);
      customized_env.use_direct_reads |=
          immutable_db_options_.use_direct_io_for_flush_and_compaction;
-      s = env_->NewRandomAccessFile(CurrentFileName(dbname_), &idfile,
+      s = env_->NewRandomAccessFile(IdentityFileName(dbname_), &idfile,
                                    customized_env);
      if (!s.ok()) {
        std::string error_str = s.ToString();
        // Check if unsupported Direct I/O is the root cause
        customized_env.use_direct_reads = false;
-        s = env_->NewRandomAccessFile(CurrentFileName(dbname_), &idfile,
+        s = env_->NewRandomAccessFile(IdentityFileName(dbname_), &idfile,
                                      customized_env);
        if (s.ok()) {
          return Status::InvalidArgument(
@@ -392,42 +393,8 @@ Status DBImpl::Recover(
      }
    }
  }
-  assert(db_id_.empty());
-  Status s = versions_->Recover(column_families, read_only, &db_id_);
-  if (!s.ok()) {
-    return s;
-  }
-  // Happens when immutable_db_options_.write_dbid_to_manifest is set to true
-  // the very first time.
-  if (db_id_.empty()) {
-    // Check for the IDENTITY file and create it if not there.
-    s = env_->FileExists(IdentityFileName(dbname_));
-    // Typically Identity file is created in NewDB() and for some reason if
-    // it is no longer available then at this point DB ID is not in Identity
-    // file or Manifest.
-    if (s.IsNotFound()) {
-      s = SetIdentityFile(env_, dbname_);
-      if (!s.ok()) {
-        return s;
-      }
-    } else if (!s.ok()) {
-      assert(s.IsIOError());
-      return s;
-    }
-    GetDbIdentityFromIdentityFile(&db_id_);
-    if (immutable_db_options_.write_dbid_to_manifest) {
-      VersionEdit edit;
-      edit.SetDBId(db_id_);
-      Options options;
-      MutableCFOptions mutable_cf_options(options);
-      versions_->db_id_ = db_id_;
-      versions_->LogAndApply(versions_->GetColumnFamilySet()->GetDefault(),
-                             mutable_cf_options, &edit, &mutex_, nullptr,
-                             false);
-    }
-  } else {
-    SetIdentityFile(env_, dbname_, db_id_);
-  }
+
+  Status s = versions_->Recover(column_families, read_only);

  if (immutable_db_options_.paranoid_checks && s.ok()) {
    s = CheckConsistency();
@@ -754,8 +721,7 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
          continue;
        }
      }
-      file_reader.reset(new SequentialFileReader(
-          std::move(file), fname, immutable_db_options_.log_readahead_size));
+      file_reader.reset(new SequentialFileReader(std::move(file), fname));
    }

    // Create the log reader.
@@ -895,10 +861,9 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
      // That's why we set ignore missing column families to true
      bool has_valid_writes = false;
      status = WriteBatchInternal::InsertInto(
-          &batch, column_family_memtables_.get(), &flush_scheduler_,
-          &trim_history_scheduler_, true, log_number, this,
-          false /* concurrent_memtable_writes */, next_sequence,
-          &has_valid_writes, seq_per_batch_, batch_per_txn_);
+          &batch, column_family_memtables_.get(), &flush_scheduler_, true,
+          log_number, this, false /* concurrent_memtable_writes */,
+          next_sequence, &has_valid_writes, seq_per_batch_, batch_per_txn_);
      MaybeIgnoreError(&status);
      if (!status.ok()) {
        // We are treating this as a failure while reading since we read valid
@@ -965,7 +930,6 @@ Status DBImpl::RecoverLogFiles(const std::vector<uint64_t>& log_numbers,
    }

    flush_scheduler_.Clear();
-    trim_history_scheduler_.Clear();
    auto last_sequence = *next_sequence - 1;
    if ((*next_sequence != kMaxSequenceNumber) &&
        (versions_->LastSequence() <= last_sequence)) {
@@ -16,10 +16,6 @@ namespace rocksdb {
 class DBImplReadOnly : public DBImpl {
 public:
  DBImplReadOnly(const DBOptions& options, const std::string& dbname);
-  // No copying allowed
-  DBImplReadOnly(const DBImplReadOnly&) = delete;
-  void operator=(const DBImplReadOnly&) = delete;
-
  virtual ~DBImplReadOnly();

  // Implementations of the DB interface
@@ -119,18 +115,12 @@ class DBImplReadOnly : public DBImpl {
    return Status::NotSupported("Not supported operation in read only mode.");
  }

-  using DB::CreateColumnFamilyWithImport;
-  virtual Status CreateColumnFamilyWithImport(
-      const ColumnFamilyOptions& /*options*/,
-      const std::string& /*column_family_name*/,
-      const ImportColumnFamilyOptions& /*import_options*/,
-      const ExportImportFilesMetaData& /*metadata*/,
-      ColumnFamilyHandle** /*handle*/) override {
-    return Status::NotSupported("Not supported operation in read only mode.");
-  }
-
 private:
  friend class DB;
+
+  // No copying allowed
+  DBImplReadOnly(const DBImplReadOnly&);
+  void operator=(const DBImplReadOnly&);
 };
 }  // namespace rocksdb

@@ -150,8 +150,7 @@ Status DBImplSecondary::MaybeInitLogReader(
        *log_reader = nullptr;
        return status;
      }
-      file_reader.reset(new SequentialFileReader(
-          std::move(file), fname, immutable_db_options_.log_readahead_size));
+      file_reader.reset(new SequentialFileReader(std::move(file), fname));
    }

    // Create the log reader.
@@ -253,9 +252,9 @@ Status DBImplSecondary::RecoverLogFiles(
        bool has_valid_writes = false;
        status = WriteBatchInternal::InsertInto(
            &batch, column_family_memtables_.get(),
-            nullptr /* flush_scheduler */, nullptr /* trim_history_scheduler*/,
-            true, log_number, this, false /* concurrent_memtable_writes */,
-            next_sequence, &has_valid_writes, seq_per_batch_, batch_per_txn_);
+            nullptr /* flush_scheduler */, true, log_number, this,
+            false /* concurrent_memtable_writes */, next_sequence,
+            &has_valid_writes, seq_per_batch_, batch_per_txn_);
      }
      // If column family was not found, it might mean that the WAL write
      // batch references to the column family that was dropped after the
@@ -588,9 +587,6 @@ Status DB::OpenAsSecondary(
      &impl->write_controller_));
  impl->column_family_memtables_.reset(
      new ColumnFamilyMemTablesImpl(impl->versions_->GetColumnFamilySet()));
-  impl->wal_in_db_path_ =
-      IsWalDirSameAsDBPath(&impl->immutable_db_options_);
-
  impl->mutex_.Lock();
  s = impl->Recover(column_families, true, false, false);
  if (s.ok()) {
@@ -171,10 +171,8 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
          versions_->GetColumnFamilySet());
      w.status = WriteBatchInternal::InsertInto(
          &w, w.sequence, &column_family_memtables, &flush_scheduler_,
-          &trim_history_scheduler_,
          write_options.ignore_missing_column_families, 0 /*log_number*/, this,
-          true /*concurrent_memtable_writes*/, seq_per_batch_, w.batch_cnt,
-          batch_per_txn_, write_options.memtable_insert_hint_per_batch);
+          true /*concurrent_memtable_writes*/, seq_per_batch_, w.batch_cnt);

      PERF_TIMER_START(write_pre_and_post_process_time);
    }
@@ -294,19 +292,18 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
    // We're optimistic, updating the stats before we successfully
    // commit.  That lets us release our leader status early.
    auto stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::kIntStatsNumKeysWritten, total_count,
+    stats->AddDBStats(InternalStats::NUMBER_KEYS_WRITTEN, total_count,
                      concurrent_update);
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
-    stats->AddDBStats(InternalStats::kIntStatsBytesWritten, total_byte_size,
+    stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size,
                      concurrent_update);
    RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-    stats->AddDBStats(InternalStats::kIntStatsWriteDoneBySelf, 1,
-                      concurrent_update);
+    stats->AddDBStats(InternalStats::WRITE_DONE_BY_SELF, 1, concurrent_update);
    RecordTick(stats_, WRITE_DONE_BY_SELF);
    auto write_done_by_other = write_group.size - 1;
    if (write_done_by_other > 0) {
-      stats->AddDBStats(InternalStats::kIntStatsWriteDoneByOther,
-                        write_done_by_other, concurrent_update);
+      stats->AddDBStats(InternalStats::WRITE_DONE_BY_OTHER, write_done_by_other,
+                        concurrent_update);
      RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
    }
    RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
@@ -377,8 +374,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
        // w.sequence will be set inside InsertInto
        w.status = WriteBatchInternal::InsertInto(
            write_group, current_sequence, column_family_memtables_.get(),
-            &flush_scheduler_, &trim_history_scheduler_,
-            write_options.ignore_missing_column_families,
+            &flush_scheduler_, write_options.ignore_missing_column_families,
            0 /*recovery_log_number*/, this, parallel, seq_per_batch_,
            batch_per_txn_);
      } else {
@@ -394,11 +390,9 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
          assert(w.sequence == current_sequence);
          w.status = WriteBatchInternal::InsertInto(
              &w, w.sequence, &column_family_memtables, &flush_scheduler_,
-              &trim_history_scheduler_,
              write_options.ignore_missing_column_families, 0 /*log_number*/,
              this, true /*concurrent_memtable_writes*/, seq_per_batch_,
-              w.batch_cnt, batch_per_txn_,
-              write_options.memtable_insert_hint_per_batch);
+              w.batch_cnt, batch_per_txn_);
        }
      }
      if (seq_used != nullptr) {
@@ -505,9 +499,9 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    }

    auto stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::kIntStatsNumKeysWritten, total_count);
+    stats->AddDBStats(InternalStats::NUMBER_KEYS_WRITTEN, total_count);
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);
-    stats->AddDBStats(InternalStats::kIntStatsBytesWritten, total_byte_size);
+    stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size);
    RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
    RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);

@@ -515,10 +509,10 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,

    if (w.status.ok() && !write_options.disableWAL) {
      PERF_TIMER_GUARD(write_wal_time);
-      stats->AddDBStats(InternalStats::kIntStatsWriteDoneBySelf, 1);
+      stats->AddDBStats(InternalStats::WRITE_DONE_BY_SELF, 1);
      RecordTick(stats_, WRITE_DONE_BY_SELF, 1);
      if (wal_write_group.size > 1) {
-        stats->AddDBStats(InternalStats::kIntStatsWriteDoneByOther,
+        stats->AddDBStats(InternalStats::WRITE_DONE_BY_OTHER,
                          wal_write_group.size - 1);
        RecordTick(stats_, WRITE_DONE_BY_OTHER, wal_write_group.size - 1);
      }
@@ -550,9 +544,9 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
    } else {
      memtable_write_group.status = WriteBatchInternal::InsertInto(
          memtable_write_group, w.sequence, column_family_memtables_.get(),
-          &flush_scheduler_, &trim_history_scheduler_,
-          write_options.ignore_missing_column_families, 0 /*log_number*/, this,
-          false /*concurrent_memtable_writes*/, seq_per_batch_, batch_per_txn_);
+          &flush_scheduler_, write_options.ignore_missing_column_families,
+          0 /*log_number*/, this, false /*concurrent_memtable_writes*/,
+          seq_per_batch_, batch_per_txn_);
      versions_->SetLastSequence(memtable_write_group.last_sequence);
      write_thread_.ExitAsMemTableWriter(&w, memtable_write_group);
    }
@@ -564,10 +558,8 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
        versions_->GetColumnFamilySet());
    w.status = WriteBatchInternal::InsertInto(
        &w, w.sequence, &column_family_memtables, &flush_scheduler_,
-        &trim_history_scheduler_, write_options.ignore_missing_column_families,
-        0 /*log_number*/, this, true /*concurrent_memtable_writes*/,
-        false /*seq_per_batch*/, 0 /*batch_cnt*/, true /*batch_per_txn*/,
-        write_options.memtable_insert_hint_per_batch);
+        write_options.ignore_missing_column_families, 0 /*log_number*/, this,
+        true /*concurrent_memtable_writes*/);
    if (write_thread_.CompleteParallelMemTableWriter(&w)) {
      MemTableInsertStatusCheck(w.status);
      versions_->SetLastSequence(w.write_group->last_sequence);
@@ -597,17 +589,15 @@ Status DBImpl::UnorderedWriteMemtable(const WriteOptions& write_options,
    w.sequence = seq;
    size_t total_count = WriteBatchInternal::Count(my_batch);
    InternalStats* stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::kIntStatsNumKeysWritten, total_count);
+    stats->AddDBStats(InternalStats::NUMBER_KEYS_WRITTEN, total_count);
    RecordTick(stats_, NUMBER_KEYS_WRITTEN, total_count);

    ColumnFamilyMemTablesImpl column_family_memtables(
        versions_->GetColumnFamilySet());
    w.status = WriteBatchInternal::InsertInto(
        &w, w.sequence, &column_family_memtables, &flush_scheduler_,
-        &trim_history_scheduler_, write_options.ignore_missing_column_families,
-        0 /*log_number*/, this, true /*concurrent_memtable_writes*/,
-        seq_per_batch_, sub_batch_cnt, true /*batch_per_txn*/,
-        write_options.memtable_insert_hint_per_batch);
+        write_options.ignore_missing_column_families, 0 /*log_number*/, this,
+        true /*concurrent_memtable_writes*/, seq_per_batch_, sub_batch_cnt);

    WriteStatusCheck(w.status);
    if (write_options.disableWAL) {
@@ -708,16 +698,15 @@ Status DBImpl::WriteImplWALOnly(
  // We're optimistic, updating the stats before we successfully
  // commit.  That lets us release our leader status early.
  auto stats = default_cf_internal_stats_;
-  stats->AddDBStats(InternalStats::kIntStatsBytesWritten, total_byte_size,
+  stats->AddDBStats(InternalStats::BYTES_WRITTEN, total_byte_size,
                    concurrent_update);
  RecordTick(stats_, BYTES_WRITTEN, total_byte_size);
-  stats->AddDBStats(InternalStats::kIntStatsWriteDoneBySelf, 1,
-                    concurrent_update);
+  stats->AddDBStats(InternalStats::WRITE_DONE_BY_SELF, 1, concurrent_update);
  RecordTick(stats_, WRITE_DONE_BY_SELF);
  auto write_done_by_other = write_group.size - 1;
  if (write_done_by_other > 0) {
-    stats->AddDBStats(InternalStats::kIntStatsWriteDoneByOther,
-                      write_done_by_other, concurrent_update);
+    stats->AddDBStats(InternalStats::WRITE_DONE_BY_OTHER, write_done_by_other,
+                      concurrent_update);
    RecordTick(stats_, WRITE_DONE_BY_OTHER, write_done_by_other);
  }
  RecordInHistogram(stats_, BYTES_PER_WRITE, total_byte_size);
@@ -866,10 +855,6 @@ Status DBImpl::PreprocessWrite(const WriteOptions& write_options,
    status = HandleWriteBufferFull(write_context);
  }

-  if (UNLIKELY(status.ok() && !trim_history_scheduler_.Empty())) {
-    status = TrimMemtableHistory(write_context);
-  }
-
  if (UNLIKELY(status.ok() && !flush_scheduler_.Empty())) {
    WaitForPendingWrites();
    status = ScheduleFlushes(write_context);
@@ -1049,12 +1034,12 @@ Status DBImpl::WriteToWAL(const WriteThread::WriteGroup& write_group,
  if (status.ok()) {
    auto stats = default_cf_internal_stats_;
    if (need_log_sync) {
-      stats->AddDBStats(InternalStats::kIntStatsWalFileSynced, 1);
+      stats->AddDBStats(InternalStats::WAL_FILE_SYNCED, 1);
      RecordTick(stats_, WAL_FILE_SYNCED);
    }
-    stats->AddDBStats(InternalStats::kIntStatsWalFileBytes, log_size);
+    stats->AddDBStats(InternalStats::WAL_FILE_BYTES, log_size);
    RecordTick(stats_, WAL_FILE_BYTES, log_size);
-    stats->AddDBStats(InternalStats::kIntStatsWriteWithWal, write_with_wal);
+    stats->AddDBStats(InternalStats::WRITE_WITH_WAL, write_with_wal);
    RecordTick(stats_, WRITE_WITH_WAL, write_with_wal);
  }
  return status;
@@ -1100,10 +1085,9 @@ Status DBImpl::ConcurrentWriteToWAL(const WriteThread::WriteGroup& write_group,
  if (status.ok()) {
    const bool concurrent = true;
    auto stats = default_cf_internal_stats_;
-    stats->AddDBStats(InternalStats::kIntStatsWalFileBytes, log_size,
-                      concurrent);
+    stats->AddDBStats(InternalStats::WAL_FILE_BYTES, log_size, concurrent);
    RecordTick(stats_, WAL_FILE_BYTES, log_size);
-    stats->AddDBStats(InternalStats::kIntStatsWriteWithWal, write_with_wal,
+    stats->AddDBStats(InternalStats::WRITE_WITH_WAL, write_with_wal,
                      concurrent);
    RecordTick(stats_, WRITE_WITH_WAL, write_with_wal);
  }
@@ -1127,9 +1111,9 @@ Status DBImpl::WriteRecoverableState() {
    WriteBatchInternal::SetSequence(&cached_recoverable_state_, seq + 1);
    auto status = WriteBatchInternal::InsertInto(
        &cached_recoverable_state_, column_family_memtables_.get(),
-        &flush_scheduler_, &trim_history_scheduler_, true,
-        0 /*recovery_log_number*/, this, false /* concurrent_memtable_writes */,
-        &next_seq, &dont_care_bool, seq_per_batch_);
+        &flush_scheduler_, true, 0 /*recovery_log_number*/, this,
+        false /* concurrent_memtable_writes */, &next_seq, &dont_care_bool,
+        seq_per_batch_);
    auto last_seq = next_seq - 1;
    if (two_write_queues_) {
      versions_->FetchAddLastAllocatedSequence(last_seq - seq);
@@ -1244,7 +1228,6 @@ Status DBImpl::SwitchWAL(WriteContext* write_context) {
        cfds.push_back(cfd);
      }
    }
-    MaybeFlushStatsCF(&cfds);
  }
  for (const auto cfd : cfds) {
    cfd->Ref();
@@ -1311,7 +1294,6 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
    if (cfd_picked != nullptr) {
      cfds.push_back(cfd_picked);
    }
-    MaybeFlushStatsCF(&cfds);
  }

  for (const auto cfd : cfds) {
@@ -1405,8 +1387,8 @@ Status DBImpl::DelayWrite(uint64_t num_bytes,
  }
  assert(!delayed || !write_options.no_slowdown);
  if (delayed) {
-    default_cf_internal_stats_->AddDBStats(
-        InternalStats::kIntStatsWriteStallMicros, time_delayed);
+    default_cf_internal_stats_->AddDBStats(InternalStats::WRITE_STALL_MICROS,
+                                           time_delayed);
    RecordTick(stats_, STALL_MICROS, time_delayed);
  }

@@ -1455,67 +1437,6 @@ Status DBImpl::ThrottleLowPriWritesIfNeeded(const WriteOptions& write_options,
  return Status::OK();
 }

-void DBImpl::MaybeFlushStatsCF(autovector<ColumnFamilyData*>* cfds) {
-  assert(cfds != nullptr);
-  if (!cfds->empty() && immutable_db_options_.persist_stats_to_disk) {
-    ColumnFamilyData* cfd_stats =
-        versions_->GetColumnFamilySet()->GetColumnFamily(
-            kPersistentStatsColumnFamilyName);
-    if (cfd_stats != nullptr && !cfd_stats->mem()->IsEmpty()) {
-      for (ColumnFamilyData* cfd : *cfds) {
-        if (cfd == cfd_stats) {
-          // stats CF already included in cfds
-          return;
-        }
-      }
-      // force flush stats CF when its log number is less than all other CF's
-      // log numbers
-      bool force_flush_stats_cf = true;
-      for (auto* loop_cfd : *versions_->GetColumnFamilySet()) {
-        if (loop_cfd == cfd_stats) {
-          continue;
-        }
-        if (loop_cfd->GetLogNumber() <= cfd_stats->GetLogNumber()) {
-          force_flush_stats_cf = false;
-        }
-      }
-      if (force_flush_stats_cf) {
-        cfds->push_back(cfd_stats);
-        ROCKS_LOG_INFO(immutable_db_options_.info_log,
-                       "Force flushing stats CF with automated flush "
-                       "to avoid holding old logs");
-      }
-    }
-  }
-}
-
-Status DBImpl::TrimMemtableHistory(WriteContext* context) {
-  autovector<ColumnFamilyData*> cfds;
-  ColumnFamilyData* tmp_cfd;
-  while ((tmp_cfd = trim_history_scheduler_.TakeNextColumnFamily()) !=
-         nullptr) {
-    cfds.push_back(tmp_cfd);
-  }
-  for (auto& cfd : cfds) {
-    autovector<MemTable*> to_delete;
-    cfd->imm()->TrimHistory(&to_delete, cfd->mem()->ApproximateMemoryUsage());
-    if (!to_delete.empty()) {
-      for (auto m : to_delete) {
-        delete m;
-      }
-      context->superversion_context.NewSuperVersion();
-      assert(context->superversion_context.new_superversion.get() != nullptr);
-      cfd->InstallSuperVersion(&context->superversion_context, &mutex_);
-    }
-
-    if (cfd->Unref()) {
-      delete cfd;
-      cfd = nullptr;
-    }
-  }
-  return Status::OK();
-}
-
 Status DBImpl::ScheduleFlushes(WriteContext* context) {
  autovector<ColumnFamilyData*> cfds;
  if (immutable_db_options_.atomic_flush) {
@@ -1529,7 +1450,6 @@ Status DBImpl::ScheduleFlushes(WriteContext* context) {
    while ((tmp_cfd = flush_scheduler_.TakeNextColumnFamily()) != nullptr) {
      cfds.push_back(tmp_cfd);
    }
-    MaybeFlushStatsCF(&cfds);
  }
  Status status;
  for (auto& cfd : cfds) {
@@ -1776,16 +1696,14 @@ Status DB::Put(const WriteOptions& opt, ColumnFamilyHandle* column_family,
    }
    return Write(opt, &batch);
  }
-  const Slice* ts = opt.timestamp;
-  assert(nullptr != ts);
-  size_t ts_sz = ts->size();
-  WriteBatch batch(key.size() + ts_sz + value.size() + 24, /*max_bytes=*/0,
-                   ts_sz);
-  Status s = batch.Put(column_family, key, value);
+  Slice akey;
+  std::string buf;
+  Status s = AppendTimestamp(key, *(opt.timestamp), &akey, &buf);
  if (!s.ok()) {
    return s;
  }
-  s = batch.AssignTimestamp(*ts);
+  WriteBatch batch(akey.size() + value.size() + 24);
+  s = batch.Put(column_family, akey, value);
  if (!s.ok()) {
    return s;
  }
@@ -155,10 +155,6 @@ class DBIter final: public Iterator {
      iter_.iter()->SetPinnedItersMgr(&pinned_iters_mgr_);
    }
  }
-  // No copying allowed
-  DBIter(const DBIter&) = delete;
-  void operator=(const DBIter&) = delete;
-
  ~DBIter() override {
    // Release pinned data if any
    if (pinned_iters_mgr_.PinningEnabled()) {
@@ -267,6 +263,12 @@ class DBIter final: public Iterator {
  bool TooManyInternalKeysSkipped(bool increment = true);
  inline bool IsVisible(SequenceNumber sequence);

+  // CanReseekToSkip() returns whether the iterator can use the optimization
+  // where it reseek by sequence number to get the next key when there are too
+  // many versions. This is disabled for write unprepared because seeking to
+  // sequence number does not guarantee that it is visible.
+  inline bool CanReseekToSkip();
+
  // Temporarily pin the blocks that we encounter until ReleaseTempPinnedData()
  // is called
  void TempPinData() {
@@ -349,17 +351,15 @@ class DBIter final: public Iterator {
  ReadRangeDelAggregator range_del_agg_;
  LocalStatistics local_stats_;
  PinnedIteratorsManager pinned_iters_mgr_;
-#ifdef ROCKSDB_LITE
-  ROCKSDB_FIELD_UNUSED
-#endif
  DBImpl* db_impl_;
-#ifdef ROCKSDB_LITE
-  ROCKSDB_FIELD_UNUSED
-#endif
  ColumnFamilyData* cfd_;
  // for diff snapshots we want the lower bound on the seqnum;
  // if this value > 0 iterator will return internal keys
  SequenceNumber start_seqnum_;
+
+  // No copying allowed
+  DBIter(const DBIter&);
+  void operator=(const DBIter&);
 };

 inline bool DBIter::ParseKey(ParsedInternalKey* ikey) {
@@ -453,11 +453,6 @@ inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check)
  //                         greater than that,
  //  - none of the above  : saved_key_ can contain anything, it doesn't matter.
  uint64_t num_skipped = 0;
-  // For write unprepared, the target sequence number in reseek could be larger
-  // than the snapshot, and thus needs to be skipped again. This could result in
-  // an infinite loop of reseeks. To avoid that, we limit the number of reseeks
-  // to one.
-  bool reseek_done = false;

  is_blob_ = false;

@@ -472,9 +467,7 @@ inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check)

    is_key_seqnum_zero_ = (ikey_.sequence == 0);

-    assert(iterate_upper_bound_ == nullptr || iter_.MayBeOutOfUpperBound() ||
-           user_comparator_.Compare(ikey_.user_key, *iterate_upper_bound_) < 0);
-    if (iterate_upper_bound_ != nullptr && iter_.MayBeOutOfUpperBound() &&
+    if (iterate_upper_bound_ != nullptr &&
        user_comparator_.Compare(ikey_.user_key, *iterate_upper_bound_) >= 0) {
      break;
    }
@@ -503,7 +496,6 @@ inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check)
        assert(!skipping || user_comparator_.Compare(
                                ikey_.user_key, saved_key_.GetUserKey()) > 0);
        num_skipped = 0;
-        reseek_done = false;
        switch (ikey_.type) {
          case kTypeDeletion:
          case kTypeSingleDeletion:
@@ -557,7 +549,6 @@ inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check)
                // they are hidden by this deletion.
                skipping = true;
                num_skipped = 0;
-                reseek_done = false;
                PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
              } else if (ikey_.type == kTypeBlobIndex) {
                if (!allow_blob_) {
@@ -588,7 +579,6 @@ inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check)
              // they are hidden by this deletion.
              skipping = true;
              num_skipped = 0;
-              reseek_done = false;
              PERF_COUNTER_ADD(internal_delete_skipped_count, 1);
            } else {
              // By now, we are sure the current ikey is going to yield a
@@ -619,23 +609,14 @@ inline bool DBIter::FindNextUserEntryInternal(bool skipping, bool prefix_check)
            !iter_.iter()->IsKeyPinned() || !pin_thru_lifetime_ /* copy */);
        skipping = false;
        num_skipped = 0;
-        reseek_done = false;
      }
    }

    // If we have sequentially iterated via numerous equal keys, then it's
    // better to seek so that we can avoid too many key comparisons.
-    //
-    // To avoid infinite loops, do not reseek if we have already attempted to
-    // reseek previously.
-    //
-    // TODO(lth): If we reseek to sequence number greater than ikey_.sequence,
-    // than it does not make sense to reseek as we would actually land further
-    // away from the desired key. There is opportunity for optimization here.
-    if (num_skipped > max_skip_ && !reseek_done) {
+    if (num_skipped > max_skip_ && CanReseekToSkip()) {
      is_key_seqnum_zero_ = false;
      num_skipped = 0;
-      reseek_done = true;
      std::string last_key;
      if (skipping) {
        // We're looking for the next user-key but all we see are the same
@@ -878,10 +859,7 @@ void DBIter::PrevInternal() {
      return;
    }

-    assert(iterate_lower_bound_ == nullptr || iter_.MayBeOutOfLowerBound() ||
-           user_comparator_.Compare(saved_key_.GetUserKey(),
-                                    *iterate_lower_bound_) >= 0);
-    if (iterate_lower_bound_ != nullptr && iter_.MayBeOutOfLowerBound() &&
+    if (iterate_lower_bound_ != nullptr &&
        user_comparator_.Compare(saved_key_.GetUserKey(),
                                 *iterate_lower_bound_) < 0) {
      // We've iterated earlier than the user-specified lower bound.
@@ -954,7 +932,7 @@ bool DBIter::FindValueForCurrentKey() {
    // This user key has lots of entries.
    // We're going from old to new, and it's taking too long. Let's do a Seek()
    // and go from new to old. This helps when a key was overwritten many times.
-    if (num_skipped >= max_skip_) {
+    if (num_skipped >= max_skip_ && CanReseekToSkip()) {
      return FindValueForCurrentKeyUsingSeek();
    }

@@ -1251,7 +1229,7 @@ bool DBIter::FindUserKeyBeforeSavedKey() {
      PERF_COUNTER_ADD(internal_key_skipped_count, 1);
    }

-    if (num_skipped >= max_skip_) {
+    if (num_skipped >= max_skip_ && CanReseekToSkip()) {
      num_skipped = 0;
      IterKey last_key;
      last_key.SetInternalKey(ParsedInternalKey(
@@ -1298,6 +1276,10 @@ bool DBIter::IsVisible(SequenceNumber sequence) {
  }
 }

+bool DBIter::CanReseekToSkip() {
+  return read_callback_ == nullptr || read_callback_->CanReseekToSkip();
+}
+
 void DBIter::Seek(const Slice& target) {
  PERF_CPU_TIMER_GUARD(iter_seek_cpu_nanos, env_);
  StopWatch sw(env_, statistics_, DB_SEEK);
@@ -182,33 +182,6 @@ TEST_P(DBIteratorTest, IterSeekBeforePrev) {
  delete iter;
 }

-TEST_P(DBIteratorTest, IterReseekNewUpperBound) {
-  Random rnd(301);
-  Options options = CurrentOptions();
-  BlockBasedTableOptions table_options;
-  table_options.block_size = 1024;
-  table_options.block_size_deviation = 50;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  options.compression = kNoCompression;
-  Reopen(options);
-
-  ASSERT_OK(Put("a", RandomString(&rnd, 400)));
-  ASSERT_OK(Put("aabb", RandomString(&rnd, 400)));
-  ASSERT_OK(Put("aaef", RandomString(&rnd, 400)));
-  ASSERT_OK(Put("b", RandomString(&rnd, 400)));
-  dbfull()->Flush(FlushOptions());
-  ReadOptions opts;
-  Slice ub = Slice("aa");
-  opts.iterate_upper_bound = &ub;
-  auto iter = NewIterator(opts);
-  iter->Seek(Slice("a"));
-  ub = Slice("b");
-  iter->Seek(Slice("aabc"));
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_EQ(iter->key().ToString(), "aaef");
-  delete iter;
-}
-
 TEST_P(DBIteratorTest, IterSeekForPrevBeforeNext) {
  ASSERT_OK(Put("a", "b"));
  ASSERT_OK(Put("c", "d"));
@@ -1076,148 +1049,6 @@ TEST_P(DBIteratorTest, DBIteratorBoundOptimizationTest) {
    ASSERT_EQ(upper_bound_hits, 1);
  }
 }
-
-// Enable kBinarySearchWithFirstKey, do some iterator operations and check that
-// they don't do unnecessary block reads.
-TEST_P(DBIteratorTest, IndexWithFirstKey) {
-  for (int tailing = 0; tailing < 2; ++tailing) {
-    SCOPED_TRACE("tailing = " + std::to_string(tailing));
-    Options options = CurrentOptions();
-    options.env = env_;
-    options.create_if_missing = true;
-    options.prefix_extractor = nullptr;
-    options.merge_operator = MergeOperators::CreateStringAppendOperator();
-    options.statistics = rocksdb::CreateDBStatistics();
-    Statistics* stats = options.statistics.get();
-    BlockBasedTableOptions table_options;
-    table_options.index_type =
-        BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey;
-    table_options.index_shortening =
-        BlockBasedTableOptions::IndexShorteningMode::kNoShortening;
-    table_options.flush_block_policy_factory =
-        std::make_shared<FlushBlockEveryKeyPolicyFactory>();
-    table_options.block_cache = NewLRUCache(1000);  // fits all blocks
-    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-    DestroyAndReopen(options);
-    ASSERT_OK(Merge("a1", "x1"));
-    ASSERT_OK(Merge("b1", "y1"));
-    ASSERT_OK(Merge("c0", "z1"));
-    ASSERT_OK(Flush());
-    ASSERT_OK(Merge("a2", "x2"));
-    ASSERT_OK(Merge("b2", "y2"));
-    ASSERT_OK(Merge("c0", "z2"));
-    ASSERT_OK(Flush());
-    ASSERT_OK(Merge("a3", "x3"));
-    ASSERT_OK(Merge("b3", "y3"));
-    ASSERT_OK(Merge("c3", "z3"));
-    ASSERT_OK(Flush());
-
-    // Block cache is not important for this test.
-    // We use BLOCK_CACHE_DATA_* counters just because they're the most readily
-    // available way of counting block accesses.
-
-    ReadOptions ropt;
-    ropt.tailing = tailing;
-    std::unique_ptr<Iterator> iter(NewIterator(ropt));
-
-    iter->Seek("b10");
-    ASSERT_TRUE(iter->Valid());
-    EXPECT_EQ("b2", iter->key().ToString());
-    EXPECT_EQ("y2", iter->value().ToString());
-    EXPECT_EQ(1, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    EXPECT_EQ("b3", iter->key().ToString());
-    EXPECT_EQ("y3", iter->value().ToString());
-    EXPECT_EQ(2, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-    EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-
-    iter->Seek("c0");
-    ASSERT_TRUE(iter->Valid());
-    EXPECT_EQ("c0", iter->key().ToString());
-    EXPECT_EQ("z1,z2", iter->value().ToString());
-    EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-    EXPECT_EQ(4, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-
-    iter->Next();
-    ASSERT_TRUE(iter->Valid());
-    EXPECT_EQ("c3", iter->key().ToString());
-    EXPECT_EQ("z3", iter->value().ToString());
-    EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-    EXPECT_EQ(5, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-
-    iter.reset();
-
-    // Enable iterate_upper_bound and check that iterator is not trying to read
-    // blocks that are fully above upper bound.
-    std::string ub = "b3";
-    Slice ub_slice(ub);
-    ropt.iterate_upper_bound = &ub_slice;
-    iter.reset(NewIterator(ropt));
-
-    iter->Seek("b2");
-    ASSERT_TRUE(iter->Valid());
-    EXPECT_EQ("b2", iter->key().ToString());
-    EXPECT_EQ("y2", iter->value().ToString());
-    EXPECT_EQ(1, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-    EXPECT_EQ(5, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-
-    iter->Next();
-    ASSERT_FALSE(iter->Valid());
-    EXPECT_EQ(1, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-    EXPECT_EQ(5, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-  }
-}
-
-TEST_P(DBIteratorTest, IndexWithFirstKeyGet) {
-  Options options = CurrentOptions();
-  options.env = env_;
-  options.create_if_missing = true;
-  options.prefix_extractor = nullptr;
-  options.merge_operator = MergeOperators::CreateStringAppendOperator();
-  options.statistics = rocksdb::CreateDBStatistics();
-  Statistics* stats = options.statistics.get();
-  BlockBasedTableOptions table_options;
-  table_options.index_type =
-      BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey;
-  table_options.index_shortening =
-      BlockBasedTableOptions::IndexShorteningMode::kNoShortening;
-  table_options.flush_block_policy_factory =
-      std::make_shared<FlushBlockEveryKeyPolicyFactory>();
-  table_options.block_cache = NewLRUCache(1000);  // fits all blocks
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-
-  DestroyAndReopen(options);
-  ASSERT_OK(Merge("a", "x1"));
-  ASSERT_OK(Merge("c", "y1"));
-  ASSERT_OK(Merge("e", "z1"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("c", "y2"));
-  ASSERT_OK(Merge("e", "z2"));
-  ASSERT_OK(Flush());
-
-  // Get() between blocks shouldn't read any blocks.
-  ASSERT_EQ("NOT_FOUND", Get("b"));
-  EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-  EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-
-  // Get() of an existing key shouldn't read any unnecessary blocks when there's
-  // only one key per block.
-
-  ASSERT_EQ("y1,y2", Get("c"));
-  EXPECT_EQ(2, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-  EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-
-  ASSERT_EQ("x1", Get("a"));
-  EXPECT_EQ(3, stats->getTickerCount(BLOCK_CACHE_DATA_MISS));
-  EXPECT_EQ(0, stats->getTickerCount(BLOCK_CACHE_DATA_HIT));
-
-  EXPECT_EQ(std::vector<std::string>({"NOT_FOUND", "z1,z2"}),
-            MultiGet({"b", "e"}));
-}
-
 // TODO(3.13): fix the issue of Seek() + Prev() which might not necessary
 //             return the biggest key which is smaller than the seek key.
 TEST_P(DBIteratorTest, PrevAfterAndNextAfterMerge) {
@@ -2717,94 +2548,6 @@ TEST_P(DBIteratorTest, AvoidReseekLevelIterator) {
  SyncPoint::GetInstance()->DisableProcessing();
 }

-// MyRocks may change iterate bounds before seek. Simply test to make sure such
-// usage doesn't break iterator.
-TEST_P(DBIteratorTest, IterateBoundChangedBeforeSeek) {
-  Options options = CurrentOptions();
-  options.compression = CompressionType::kNoCompression;
-  BlockBasedTableOptions table_options;
-  table_options.block_size = 100;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  std::string value(50, 'v');
-  Reopen(options);
-  ASSERT_OK(Put("aaa", value));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("bbb", "v"));
-  ASSERT_OK(Put("ccc", "v"));
-  ASSERT_OK(Put("ddd", "v"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("eee", "v"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  std::string ub1 = "e";
-  std::string ub2 = "c";
-  Slice ub(ub1);
-  ReadOptions read_opts1;
-  read_opts1.iterate_upper_bound = &ub;
-  Iterator* iter = NewIterator(read_opts1);
-  // Seek and iterate accross block boundary.
-  iter->Seek("b");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  ASSERT_EQ("bbb", iter->key());
-  ub = Slice(ub2);
-  iter->Seek("b");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  ASSERT_EQ("bbb", iter->key());
-  iter->Next();
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
-  delete iter;
-
-  std::string lb1 = "a";
-  std::string lb2 = "c";
-  Slice lb(lb1);
-  ReadOptions read_opts2;
-  read_opts2.iterate_lower_bound = &lb;
-  iter = NewIterator(read_opts2);
-  iter->SeekForPrev("d");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  ASSERT_EQ("ccc", iter->key());
-  lb = Slice(lb2);
-  iter->SeekForPrev("d");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  ASSERT_EQ("ccc", iter->key());
-  iter->Prev();
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
-  delete iter;
-}
-
-TEST_P(DBIteratorTest, IterateWithLowerBoundAcrossFileBoundary) {
-  ASSERT_OK(Put("aaa", "v"));
-  ASSERT_OK(Put("bbb", "v"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Put("ccc", "v"));
-  ASSERT_OK(Put("ddd", "v"));
-  ASSERT_OK(Flush());
-  // Move both files to bottom level.
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  Slice lower_bound("b");
-  ReadOptions read_opts;
-  read_opts.iterate_lower_bound = &lower_bound;
-  std::unique_ptr<Iterator> iter(NewIterator(read_opts));
-  iter->SeekForPrev("d");
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  ASSERT_EQ("ccc", iter->key());
-  iter->Prev();
-  ASSERT_TRUE(iter->Valid());
-  ASSERT_OK(iter->status());
-  ASSERT_EQ("bbb", iter->key());
-  iter->Prev();
-  ASSERT_FALSE(iter->Valid());
-  ASSERT_OK(iter->status());
-}
-
 INSTANTIATE_TEST_CASE_P(DBIteratorTestInstance, DBIteratorTest,
                        testing::Values(true, false));

@@ -322,7 +322,7 @@ TEST_F(DBMemTableTest, ColumnFamilyId) {
  DestroyAndReopen(options);
  CreateAndReopenWithCF({"pikachu"}, options);

-  for (uint32_t cf = 0; cf < 2; ++cf) {
+  for (int cf = 0; cf < 2; ++cf) {
    ASSERT_OK(Put(cf, "key", "val"));
    ASSERT_OK(Flush(cf));
    ASSERT_EQ(
@@ -1,240 +0,0 @@
-//  Copyright (c) 2018-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/db_test_util.h"
-#include "port/stack_trace.h"
-#include "rocksdb/perf_context.h"
-#include "rocksdb/utilities/debug.h"
-#include "table/block_based/block_builder.h"
-#include "test_util/fault_injection_test_env.h"
-#if !defined(ROCKSDB_LITE)
-#include "test_util/sync_point.h"
-#endif
-#include "rocksdb/merge_operator.h"
-#include "utilities/merge_operators.h"
-#include "utilities/merge_operators/sortlist.h"
-#include "utilities/merge_operators/string_append/stringappend2.h"
-
-namespace rocksdb {
-
-class DBMergeOperandTest : public DBTestBase {
- public:
-  DBMergeOperandTest() : DBTestBase("/db_merge_operand_test") {}
-};
-
-TEST_F(DBMergeOperandTest, GetMergeOperandsBasic) {
-  class LimitedStringAppendMergeOp : public StringAppendTESTOperator {
-   public:
-    LimitedStringAppendMergeOp(int limit, char delim)
-        : StringAppendTESTOperator(delim), limit_(limit) {}
-
-    const char* Name() const override {
-      return "DBMergeOperatorTest::LimitedStringAppendMergeOp";
-    }
-
-    bool ShouldMerge(const std::vector<Slice>& operands) const override {
-      if (operands.size() > 0 && limit_ > 0 && operands.size() >= limit_) {
-        return true;
-      }
-      return false;
-    }
-
-   private:
-    size_t limit_ = 0;
-  };
-
-  Options options;
-  options.create_if_missing = true;
-  // Use only the latest two merge operands.
-  options.merge_operator = std::make_shared<LimitedStringAppendMergeOp>(2, ',');
-  options.env = env_;
-  Reopen(options);
-  int num_records = 4;
-  int number_of_operands = 0;
-  std::vector<PinnableSlice> values(num_records);
-  GetMergeOperandsOptions merge_operands_info;
-  merge_operands_info.expected_max_number_of_operands = num_records;
-
-  // k0 value in memtable
-  Put("k0", "PutARock");
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k0",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "PutARock");
-
-  // k0.1 value in SST
-  Put("k0.1", "RockInSST");
-  ASSERT_OK(Flush());
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k0.1",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "RockInSST");
-
-  // All k1 values are in memtable.
-  ASSERT_OK(Merge("k1", "a"));
-  Put("k1", "x");
-  ASSERT_OK(Merge("k1", "b"));
-  ASSERT_OK(Merge("k1", "c"));
-  ASSERT_OK(Merge("k1", "d"));
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "x");
-  ASSERT_EQ(values[1], "b");
-  ASSERT_EQ(values[2], "c");
-  ASSERT_EQ(values[3], "d");
-
-  // expected_max_number_of_operands is less than number of merge operands so
-  // status should be Incomplete.
-  merge_operands_info.expected_max_number_of_operands = num_records - 1;
-  Status status = db_->GetMergeOperands(
-      ReadOptions(), db_->DefaultColumnFamily(), "k1", values.data(),
-      &merge_operands_info, &number_of_operands);
-  ASSERT_EQ(status.IsIncomplete(), true);
-  merge_operands_info.expected_max_number_of_operands = num_records;
-
-  // All k1.1 values are in memtable.
-  ASSERT_OK(Merge("k1.1", "r"));
-  Delete("k1.1");
-  ASSERT_OK(Merge("k1.1", "c"));
-  ASSERT_OK(Merge("k1.1", "k"));
-  ASSERT_OK(Merge("k1.1", "s"));
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1.1",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "c");
-  ASSERT_EQ(values[1], "k");
-  ASSERT_EQ(values[2], "s");
-
-  // All k2 values are flushed to L0 into a single file.
-  ASSERT_OK(Merge("k2", "q"));
-  ASSERT_OK(Merge("k2", "w"));
-  ASSERT_OK(Merge("k2", "e"));
-  ASSERT_OK(Merge("k2", "r"));
-  ASSERT_OK(Flush());
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k2",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "q");
-  ASSERT_EQ(values[1], "w");
-  ASSERT_EQ(values[2], "e");
-  ASSERT_EQ(values[3], "r");
-
-  // All k2.1 values are flushed to L0 into a single file.
-  ASSERT_OK(Merge("k2.1", "m"));
-  Put("k2.1", "l");
-  ASSERT_OK(Merge("k2.1", "n"));
-  ASSERT_OK(Merge("k2.1", "o"));
-  ASSERT_OK(Flush());
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k2.1",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "l,n,o");
-
-  // All k2.2 values are flushed to L0 into a single file.
-  ASSERT_OK(Merge("k2.2", "g"));
-  Delete("k2.2");
-  ASSERT_OK(Merge("k2.2", "o"));
-  ASSERT_OK(Merge("k2.2", "t"));
-  ASSERT_OK(Flush());
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k2.2",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "o,t");
-
-  // Do some compaction that will make the following tests more predictable
-  //  Slice start("PutARock");
-  //  Slice end("t");
-  db_->CompactRange(CompactRangeOptions(), nullptr, nullptr);
-
-  // All k3 values are flushed and are in different files.
-  ASSERT_OK(Merge("k3", "ab"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3", "bc"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3", "cd"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3", "de"));
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k3",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "ab");
-  ASSERT_EQ(values[1], "bc");
-  ASSERT_EQ(values[2], "cd");
-  ASSERT_EQ(values[3], "de");
-
-  // All k3.1 values are flushed and are in different files.
-  ASSERT_OK(Merge("k3.1", "ab"));
-  ASSERT_OK(Flush());
-  Put("k3.1", "bc");
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3.1", "cd"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3.1", "de"));
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k3.1",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "bc");
-  ASSERT_EQ(values[1], "cd");
-  ASSERT_EQ(values[2], "de");
-
-  // All k3.2 values are flushed and are in different files.
-  ASSERT_OK(Merge("k3.2", "ab"));
-  ASSERT_OK(Flush());
-  Delete("k3.2");
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3.2", "cd"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(Merge("k3.2", "de"));
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k3.2",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "cd");
-  ASSERT_EQ(values[1], "de");
-
-  // All K4 values are in different levels
-  ASSERT_OK(Merge("k4", "ba"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(4);
-  ASSERT_OK(Merge("k4", "cb"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(3);
-  ASSERT_OK(Merge("k4", "dc"));
-  ASSERT_OK(Flush());
-  MoveFilesToLevel(1);
-  ASSERT_OK(Merge("k4", "ed"));
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k4",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "ba");
-  ASSERT_EQ(values[1], "cb");
-  ASSERT_EQ(values[2], "dc");
-  ASSERT_EQ(values[3], "ed");
-
-  // First 3 k5 values are in SST and next 4 k5 values are in Immutable Memtable
-  ASSERT_OK(Merge("k5", "who"));
-  ASSERT_OK(Merge("k5", "am"));
-  ASSERT_OK(Merge("k5", "i"));
-  ASSERT_OK(Flush());
-  Put("k5", "remember");
-  ASSERT_OK(Merge("k5", "i"));
-  ASSERT_OK(Merge("k5", "am"));
-  ASSERT_OK(Merge("k5", "rocks"));
-  dbfull()->TEST_SwitchMemtable();
-  db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k5",
-                        values.data(), &merge_operands_info,
-                        &number_of_operands);
-  ASSERT_EQ(values[0], "remember");
-  ASSERT_EQ(values[1], "i");
-  ASSERT_EQ(values[2], "am");
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
@@ -46,11 +46,9 @@ class DBMergeOperatorTest : public DBTestBase {
    ReadOptions read_opt;
    read_opt.snapshot = snapshot;
    PinnableSlice value;
-    DBImpl::GetImplOptions get_impl_options;
-    get_impl_options.column_family = db_->DefaultColumnFamily();
-    get_impl_options.value = &value;
-    get_impl_options.callback = &read_callback;
-    Status s = dbfull()->GetImpl(read_opt, key, get_impl_options);
+    Status s =
+        dbfull()->GetImpl(read_opt, db_->DefaultColumnFamily(), key, &value,
+                          nullptr /*value_found*/, &read_callback);
    if (!s.ok()) {
      return s.ToString();
    }
@@ -277,6 +275,68 @@ TEST_P(MergeOperatorPinningTest, OperandsMultiBlocks) {
  VerifyDBFromMap(true_data);
 }

+TEST_P(MergeOperatorPinningTest, Randomized) {
+  do {
+    Options options = CurrentOptions();
+    options.merge_operator = MergeOperators::CreateMaxOperator();
+    BlockBasedTableOptions table_options;
+    table_options.no_block_cache = disable_block_cache_;
+    options.table_factory.reset(NewBlockBasedTableFactory(table_options));
+    DestroyAndReopen(options);
+
+    Random rnd(301);
+    std::map<std::string, std::string> true_data;
+
+    const int kTotalMerges = 5000;
+    // Every key gets ~10 operands
+    const int kKeyRange = kTotalMerges / 10;
+    const int kOperandSize = 20;
+    const int kNumPutBefore = kKeyRange / 10;  // 10% value
+    const int kNumPutAfter = kKeyRange / 10;   // 10% overwrite
+    const int kNumDelete = kKeyRange / 10;     // 10% delete
+
+    // kNumPutBefore keys will have base values
+    for (int i = 0; i < kNumPutBefore; i++) {
+      std::string key = Key(rnd.Next() % kKeyRange);
+      std::string value = RandomString(&rnd, kOperandSize);
+      ASSERT_OK(db_->Put(WriteOptions(), key, value));
+
+      true_data[key] = value;
+    }
+
+    // Do kTotalMerges merges
+    for (int i = 0; i < kTotalMerges; i++) {
+      std::string key = Key(rnd.Next() % kKeyRange);
+      std::string value = RandomString(&rnd, kOperandSize);
+      ASSERT_OK(db_->Merge(WriteOptions(), key, value));
+
+      if (true_data[key] < value) {
+        true_data[key] = value;
+      }
+    }
+
+    // Overwrite random kNumPutAfter keys
+    for (int i = 0; i < kNumPutAfter; i++) {
+      std::string key = Key(rnd.Next() % kKeyRange);
+      std::string value = RandomString(&rnd, kOperandSize);
+      ASSERT_OK(db_->Put(WriteOptions(), key, value));
+
+      true_data[key] = value;
+    }
+
+    // Delete random kNumDelete keys
+    for (int i = 0; i < kNumDelete; i++) {
+      std::string key = Key(rnd.Next() % kKeyRange);
+      ASSERT_OK(db_->Delete(WriteOptions(), key));
+
+      true_data.erase(key);
+    }
+
+    VerifyDBFromMap(true_data);
+
+  } while (ChangeOptions(kSkipMergePut));
+}
+
 class MergeOperatorHook : public MergeOperator {
 public:
  explicit MergeOperatorHook(std::shared_ptr<MergeOperator> _merge_op)
@@ -577,86 +637,6 @@ TEST_F(DBMergeOperatorTest, SnapshotCheckerAndReadCallback) {
  db_->ReleaseSnapshot(snapshot2);
 }

-class PerConfigMergeOperatorPinningTest
-    : public DBMergeOperatorTest,
-      public testing::WithParamInterface<std::tuple<bool, int>> {
- public:
-  PerConfigMergeOperatorPinningTest() {
-    std::tie(disable_block_cache_, option_config_) = GetParam();
-  }
-
-  bool disable_block_cache_;
-};
-
-INSTANTIATE_TEST_CASE_P(
-    MergeOperatorPinningTest, PerConfigMergeOperatorPinningTest,
-    ::testing::Combine(::testing::Bool(),
-                       ::testing::Range(static_cast<int>(DBTestBase::kDefault),
-                                        static_cast<int>(DBTestBase::kEnd))));
-
-TEST_P(PerConfigMergeOperatorPinningTest, Randomized) {
-  if (ShouldSkipOptions(option_config_, kSkipMergePut)) {
-    return;
-  }
-
-  Options options = CurrentOptions();
-  options.merge_operator = MergeOperators::CreateMaxOperator();
-  BlockBasedTableOptions table_options;
-  table_options.no_block_cache = disable_block_cache_;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  DestroyAndReopen(options);
-
-  Random rnd(301);
-  std::map<std::string, std::string> true_data;
-
-  const int kTotalMerges = 5000;
-  // Every key gets ~10 operands
-  const int kKeyRange = kTotalMerges / 10;
-  const int kOperandSize = 20;
-  const int kNumPutBefore = kKeyRange / 10;  // 10% value
-  const int kNumPutAfter = kKeyRange / 10;   // 10% overwrite
-  const int kNumDelete = kKeyRange / 10;     // 10% delete
-
-  // kNumPutBefore keys will have base values
-  for (int i = 0; i < kNumPutBefore; i++) {
-    std::string key = Key(rnd.Next() % kKeyRange);
-    std::string value = RandomString(&rnd, kOperandSize);
-    ASSERT_OK(db_->Put(WriteOptions(), key, value));
-
-    true_data[key] = value;
-  }
-
-  // Do kTotalMerges merges
-  for (int i = 0; i < kTotalMerges; i++) {
-    std::string key = Key(rnd.Next() % kKeyRange);
-    std::string value = RandomString(&rnd, kOperandSize);
-    ASSERT_OK(db_->Merge(WriteOptions(), key, value));
-
-    if (true_data[key] < value) {
-      true_data[key] = value;
-    }
-  }
-
-  // Overwrite random kNumPutAfter keys
-  for (int i = 0; i < kNumPutAfter; i++) {
-    std::string key = Key(rnd.Next() % kKeyRange);
-    std::string value = RandomString(&rnd, kOperandSize);
-    ASSERT_OK(db_->Put(WriteOptions(), key, value));
-
-    true_data[key] = value;
-  }
-
-  // Delete random kNumDelete keys
-  for (int i = 0; i < kNumDelete; i++) {
-    std::string key = Key(rnd.Next() % kKeyRange);
-    ASSERT_OK(db_->Delete(WriteOptions(), key));
-
-    true_data.erase(key);
-  }
-
-  VerifyDBFromMap(true_data);
-}
-
 }  // namespace rocksdb

 int main(int argc, char** argv) {
@@ -505,10 +505,10 @@ TEST_F(DBOptionsTest, SetStatsDumpPeriodSec) {
  options.stats_dump_period_sec = 5;
  options.env = env_;
  Reopen(options);
-  ASSERT_EQ(5u, dbfull()->GetDBOptions().stats_dump_period_sec);
+  ASSERT_EQ(5, dbfull()->GetDBOptions().stats_dump_period_sec);

  for (int i = 0; i < 20; i++) {
-    unsigned int num = rand() % 5000 + 1;
+    int num = rand() % 5000 + 1;
    ASSERT_OK(
        dbfull()->SetDBOptions({{"stats_dump_period_sec", ToString(num)}}));
    ASSERT_EQ(num, dbfull()->GetDBOptions().stats_dump_period_sec);
@@ -522,12 +522,12 @@ TEST_F(DBOptionsTest, SetOptionsStatsPersistPeriodSec) {
  options.stats_persist_period_sec = 5;
  options.env = env_;
  Reopen(options);
-  ASSERT_EQ(5u, dbfull()->GetDBOptions().stats_persist_period_sec);
+  ASSERT_EQ(5, dbfull()->GetDBOptions().stats_persist_period_sec);

  ASSERT_OK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "12345"}}));
-  ASSERT_EQ(12345u, dbfull()->GetDBOptions().stats_persist_period_sec);
+  ASSERT_EQ(12345, dbfull()->GetDBOptions().stats_persist_period_sec);
  ASSERT_NOK(dbfull()->SetDBOptions({{"stats_persist_period_sec", "abcde"}}));
-  ASSERT_EQ(12345u, dbfull()->GetDBOptions().stats_persist_period_sec);
+  ASSERT_EQ(12345, dbfull()->GetDBOptions().stats_persist_period_sec);
 }

 static void assert_candidate_files_empty(DBImpl* dbfull, const bool empty) {
@@ -212,8 +212,7 @@ void VerifySimilar(uint64_t a, uint64_t b, double bias) {

 void VerifyTableProperties(const TableProperties& base_tp,
                           const TableProperties& new_tp,
-                           double filter_size_bias =
-                               CACHE_LINE_SIZE >= 256 ? 0.15 : 0.1,
+                           double filter_size_bias = 0.1,
                           double index_size_bias = 0.1,
                           double data_size_bias = 0.1,
                           double num_data_blocks_bias = 0.05) {
@@ -267,8 +266,7 @@ void GetExpectedTableProperties(
       // discount 1 byte as value size is not encoded in value delta encoding
       (value_delta_encoding ? 1 : 0));
  expected_tp->filter_size =
-      kTableCount * ((kKeysPerTable * kBloomBitsPerKey + 7) / 8 +
-                     /*average-ish overhead*/ CACHE_LINE_SIZE / 2);
+      kTableCount * (kKeysPerTable * kBloomBitsPerKey / 8);
 }
 }  // anonymous namespace

@@ -617,9 +615,8 @@ TEST_F(DBPropertiesTest, NumImmutableMemTable) {
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
+    options.max_write_buffer_number_to_maintain = 4;
    options.write_buffer_size = 1000000;
-    options.max_write_buffer_size_to_maintain =
-        5 * static_cast<int64_t>(options.write_buffer_size);
    CreateAndReopenWithCF({"pikachu"}, options);

    std::string big_value(1000000 * 2, 'x');
@@ -750,7 +747,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
  options.max_background_flushes = 1;
  options.max_write_buffer_number = 10;
  options.min_write_buffer_number_to_merge = 1;
-  options.max_write_buffer_size_to_maintain = 0;
+  options.max_write_buffer_number_to_maintain = 0;
  options.write_buffer_size = 1000000;
  Reopen(options);

@@ -1000,7 +997,7 @@ TEST_F(DBPropertiesTest, EstimatePendingCompBytes) {
  options.max_background_flushes = 1;
  options.max_write_buffer_number = 10;
  options.min_write_buffer_number_to_merge = 1;
-  options.max_write_buffer_size_to_maintain = 0;
+  options.max_write_buffer_number_to_maintain = 0;
  options.write_buffer_size = 1000000;
  Reopen(options);

@@ -230,7 +230,7 @@ TEST_F(DBTablePropertiesTest, GetColumnFamilyNameProperty) {

  // Create one table per CF, then verify it was created with the column family
  // name property.
-  for (uint32_t cf = 0; cf < 2; ++cf) {
+  for (int cf = 0; cf < 2; ++cf) {
    Put(cf, "key", "val");
    Flush(cf);

@@ -883,7 +883,7 @@ TEST_F(DBTest, FlushMultipleMemtable) {
    writeOpt.disableWAL = true;
    options.max_write_buffer_number = 4;
    options.min_write_buffer_number_to_merge = 3;
-    options.max_write_buffer_size_to_maintain = -1;
+    options.max_write_buffer_number_to_maintain = -1;
    CreateAndReopenWithCF({"pikachu"}, options);
    ASSERT_OK(dbfull()->Put(writeOpt, handles_[1], "foo", "v1"));
    ASSERT_OK(Flush(1));
@@ -901,8 +901,7 @@ TEST_F(DBTest, FlushSchedule) {
  options.level0_stop_writes_trigger = 1 << 10;
  options.level0_slowdown_writes_trigger = 1 << 10;
  options.min_write_buffer_number_to_merge = 1;
-  options.max_write_buffer_size_to_maintain =
-      static_cast<int64_t>(options.write_buffer_size);
+  options.max_write_buffer_number_to_maintain = 1;
  options.max_write_buffer_number = 2;
  options.write_buffer_size = 120 * 1024;
  CreateAndReopenWithCF({"pikachu"}, options);
@@ -1258,7 +1257,6 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  options.compression = kNoCompression;
  options.create_if_missing = true;
  DestroyAndReopen(options);
-  auto default_cf = db_->DefaultColumnFamily();

  const int N = 128;
  Random rnd(301);
@@ -1270,10 +1268,9 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  std::string start = Key(50);
  std::string end = Key(60);
  Range r(start, end);
-  SizeApproximationOptions size_approx_options;
-  size_approx_options.include_memtabtles = true;
-  size_approx_options.include_files = true;
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  uint8_t include_both = DB::SizeApproximationFlags::INCLUDE_FILES |
+                         DB::SizeApproximationFlags::INCLUDE_MEMTABLES;
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_GT(size, 6000);
  ASSERT_LT(size, 204800);
  // Zero if not including mem table
@@ -1283,7 +1280,7 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(500);
  end = Key(600);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_EQ(size, 0);

  for (int i = 0; i < N; i++) {
@@ -1293,20 +1290,19 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(500);
  end = Key(600);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_EQ(size, 0);

  start = Key(100);
  end = Key(1020);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_GT(size, 6000);

  options.max_write_buffer_number = 8;
  options.min_write_buffer_number_to_merge = 5;
  options.write_buffer_size = 1024 * N;  // Not very large
  DestroyAndReopen(options);
-  default_cf = db_->DefaultColumnFamily();

  int keys[N * 3];
  for (int i = 0; i < N; i++) {
@@ -1323,27 +1319,26 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(100);
  end = Key(300);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_GT(size, 6000);

  start = Key(2100);
  end = Key(2300);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
+  db_->GetApproximateSizes(&r, 1, &size, include_both);
  ASSERT_EQ(size, 0);

  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
  uint64_t size_with_mt, size_without_mt;
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1,
-                           &size_with_mt);
+  db_->GetApproximateSizes(&r, 1, &size_with_mt, include_both);
  ASSERT_GT(size_with_mt, 6000);
  db_->GetApproximateSizes(&r, 1, &size_without_mt);
  ASSERT_EQ(size_without_mt, 0);
@@ -1357,80 +1352,10 @@ TEST_F(DBTest, ApproximateSizesMemTable) {
  start = Key(1050);
  end = Key(1080);
  r = Range(start, end);
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1,
-                           &size_with_mt);
+  db_->GetApproximateSizes(&r, 1, &size_with_mt, include_both);
  db_->GetApproximateSizes(&r, 1, &size_without_mt);
  ASSERT_GT(size_with_mt, size_without_mt);
  ASSERT_GT(size_without_mt, 6000);
-
-  // Check that include_memtabtles flag works as expected
-  size_approx_options.include_memtabtles = false;
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
-  ASSERT_EQ(size, size_without_mt);
-
-  // Check that files_size_error_margin works as expected, when the heuristic
-  // conditions are not met
-  start = Key(1);
-  end = Key(1000 + N - 2);
-  r = Range(start, end);
-  size_approx_options.files_size_error_margin = -1.0;  // disabled
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
-  uint64_t size2;
-  size_approx_options.files_size_error_margin = 0.5;  // enabled, but not used
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size2);
-  ASSERT_EQ(size, size2);
-}
-
-TEST_F(DBTest, ApproximateSizesFilesWithErrorMargin) {
-  Options options = CurrentOptions();
-  options.write_buffer_size = 1024 * 1024;
-  options.compression = kNoCompression;
-  options.create_if_missing = true;
-  options.target_file_size_base = 1024 * 1024;
-  DestroyAndReopen(options);
-  const auto default_cf = db_->DefaultColumnFamily();
-
-  const int N = 64000;
-  Random rnd(301);
-  for (int i = 0; i < N; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
-  }
-  // Flush everything to files
-  Flush();
-  // Compact the entire key space into the next level
-  db_->CompactRange(CompactRangeOptions(), default_cf, nullptr, nullptr);
-
-  // Write more keys
-  for (int i = N; i < (N + N / 4); i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 1024)));
-  }
-  // Flush everything to files again
-  Flush();
-
-  // Wait for compaction to finish
-  ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-  const std::string start = Key(0);
-  const std::string end = Key(2 * N);
-  const Range r(start, end);
-
-  SizeApproximationOptions size_approx_options;
-  size_approx_options.include_memtabtles = false;
-  size_approx_options.include_files = true;
-  size_approx_options.files_size_error_margin = -1.0;  // disabled
-
-  // Get the precise size without any approximation heuristic
-  uint64_t size;
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size);
-  ASSERT_NE(size, 0);
-
-  // Get the size with an approximation heuristic
-  uint64_t size2;
-  const double error_margin = 0.2;
-  size_approx_options.files_size_error_margin = error_margin;
-  db_->GetApproximateSizes(size_approx_options, default_cf, &r, 1, &size2);
-  ASSERT_LT(size2, size * (1 + error_margin));
-  ASSERT_GT(size2, size * (1 - error_margin));
 }

 TEST_F(DBTest, GetApproximateMemTableStats) {
@@ -2541,15 +2466,6 @@ class ModelDB : public DB {
    return Status::NotSupported(key);
  }

-  using DB::GetMergeOperands;
-  virtual Status GetMergeOperands(
-      const ReadOptions& /*options*/, ColumnFamilyHandle* /*column_family*/,
-      const Slice& key, PinnableSlice* /*slice*/,
-      GetMergeOperandsOptions* /*merge_operands_options*/,
-      int* /*number_of_operands*/) override {
-    return Status::NotSupported(key);
-  }
-
  using DB::MultiGet;
  std::vector<Status> MultiGet(
      const ReadOptions& /*options*/,
@@ -2576,18 +2492,7 @@ class ModelDB : public DB {
    return Status::NotSupported("Not implemented");
  }

-  using DB::CreateColumnFamilyWithImport;
-  virtual Status CreateColumnFamilyWithImport(
-      const ColumnFamilyOptions& /*options*/,
-      const std::string& /*column_family_name*/,
-      const ImportColumnFamilyOptions& /*import_options*/,
-      const ExportImportFilesMetaData& /*metadata*/,
-      ColumnFamilyHandle** /*handle*/) override {
-    return Status::NotSupported("Not implemented.");
-  }
-
-  using DB::VerifyChecksum;
-  Status VerifyChecksum(const ReadOptions&) override {
+  Status VerifyChecksum() override {
    return Status::NotSupported("Not implemented.");
  }

@@ -2683,14 +2588,13 @@ class ModelDB : public DB {
    return false;
  }
  using DB::GetApproximateSizes;
-  Status GetApproximateSizes(const SizeApproximationOptions& /*options*/,
-                             ColumnFamilyHandle* /*column_family*/,
-                             const Range* /*range*/, int n,
-                             uint64_t* sizes) override {
+  void GetApproximateSizes(ColumnFamilyHandle* /*column_family*/,
+                           const Range* /*range*/, int n, uint64_t* sizes,
+                           uint8_t /*include_flags*/
+                           = INCLUDE_FILES) override {
    for (int i = 0; i < n; i++) {
      sizes[i] = 0;
    }
-    return Status::OK();
  }
  using DB::GetApproximateMemTableStats;
  void GetApproximateMemTableStats(ColumnFamilyHandle* /*column_family*/,
@@ -2790,10 +2694,6 @@ class ModelDB : public DB {
    return Status::OK();
  }

-  Status GetCurrentWalFile(std::unique_ptr<LogFile>* /*current_log_file*/) override {
-    return Status::OK();
-  }
-
  Status DeleteFile(std::string /*name*/) override { return Status::OK(); }

  Status GetUpdatesSince(
@@ -4790,15 +4690,15 @@ TEST_F(DBTest, DynamicUniversalCompactionOptions) {
  DestroyAndReopen(options);

  // Initial defaults
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 1U);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 1);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.min_merge_width,
-            2u);
+            2);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.max_merge_width,
            UINT_MAX);
  ASSERT_EQ(dbfull()
                ->GetOptions()
                .compaction_options_universal.max_size_amplification_percent,
-            200u);
+            200);
  ASSERT_EQ(dbfull()
                ->GetOptions()
                .compaction_options_universal.compression_size_percent,
@@ -4811,15 +4711,15 @@ TEST_F(DBTest, DynamicUniversalCompactionOptions) {

  ASSERT_OK(dbfull()->SetOptions(
      {{"compaction_options_universal", "{size_ratio=7;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 7u);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 7);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.min_merge_width,
-            2u);
+            2);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.max_merge_width,
            UINT_MAX);
  ASSERT_EQ(dbfull()
                ->GetOptions()
                .compaction_options_universal.max_size_amplification_percent,
-            200u);
+            200);
  ASSERT_EQ(dbfull()
                ->GetOptions()
                .compaction_options_universal.compression_size_percent,
@@ -4832,15 +4732,15 @@ TEST_F(DBTest, DynamicUniversalCompactionOptions) {

  ASSERT_OK(dbfull()->SetOptions(
      {{"compaction_options_universal", "{min_merge_width=11;}"}}));
-  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 7u);
+  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.size_ratio, 7);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.min_merge_width,
-            11u);
+            11);
  ASSERT_EQ(dbfull()->GetOptions().compaction_options_universal.max_merge_width,
            UINT_MAX);
  ASSERT_EQ(dbfull()
                ->GetOptions()
                .compaction_options_universal.max_size_amplification_percent,
-            200u);
+            200);
  ASSERT_EQ(dbfull()
                ->GetOptions()
                .compaction_options_universal.compression_size_percent,
@@ -6256,30 +6156,10 @@ TEST_F(DBTest, ThreadLocalPtrDeadlock) {
  fprintf(stderr, "Done. Flushed %d times, destroyed %d threads\n",
          flushes_done.load(), threads_destroyed.load());
 }
-
-TEST_F(DBTest, LargeBlockSizeTest) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"pikachu"}, options);
-  ASSERT_OK(Put(0, "foo", "bar"));
-  BlockBasedTableOptions table_options;
-  table_options.block_size = 8LL*1024*1024*1024LL;
-  options.table_factory.reset(NewBlockBasedTableFactory(table_options));
-  ASSERT_NOK(TryReopenWithColumnFamilies({"default", "pikachu"}, options));
-}
-
 }  // namespace rocksdb

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  rocksdb::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -2797,12 +2797,8 @@ TEST_F(DBTest2, ReadCallbackTest) {
    ReadOptions roptions;
    TestReadCallback callback(seq);
    bool dont_care = true;
-    DBImpl::GetImplOptions get_impl_options;
-    get_impl_options.column_family = dbfull()->DefaultColumnFamily();
-    get_impl_options.value = &pinnable_val;
-    get_impl_options.value_found = &dont_care;
-    get_impl_options.callback = &callback;
-    Status s = dbfull()->GetImpl(roptions, key, get_impl_options);
+    Status s = dbfull()->GetImpl(roptions, dbfull()->DefaultColumnFamily(), key,
+                                 &pinnable_val, &dont_care, &callback);
    ASSERT_TRUE(s.ok());
    // Assuming that after each Put the DB increased seq by one, the value and
    // seq number must be equal since we also inc value by 1 after each Put.
@@ -3776,64 +3772,49 @@ TEST_F(DBTest2, CloseWithUnreleasedSnapshot) {
  db_ = nullptr;
 }

-#ifndef ROCKSDB_LITE
-TEST_F(DBTest2, RowCacheSnapshot) {
+TEST_F(DBTest2, PrefixBloomReseek) {
  Options options = CurrentOptions();
-  options.statistics = rocksdb::CreateDBStatistics();
-  options.row_cache = NewLRUCache(8192);
+  options.create_if_missing = true;
+  options.prefix_extractor.reset(NewCappedPrefixTransform(3));
+  BlockBasedTableOptions bbto;
+  bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
+  bbto.whole_key_filtering = false;
+  options.table_factory.reset(NewBlockBasedTableFactory(bbto));
  DestroyAndReopen(options);

-  ASSERT_OK(Put("foo", "bar1"));
-
-  const Snapshot* s1 = db_->GetSnapshot();
-
-  ASSERT_OK(Put("foo", "bar2"));
+  // Construct two L1 files with keys:
+  // f1:[aaa1 ccc1] f2:[ddd0]
+  ASSERT_OK(Put("aaa1", ""));
+  ASSERT_OK(Put("ccc1", ""));
  ASSERT_OK(Flush());
+  ASSERT_OK(Put("ddd0", ""));
+  ASSERT_OK(Flush());
+  CompactRangeOptions cro;
+  cro.bottommost_level_compaction = BottommostLevelCompaction::kSkip;
+  ASSERT_OK(db_->CompactRange(cro, nullptr, nullptr));

-  ASSERT_OK(Put("foo2", "bar"));
-  const Snapshot* s2 = db_->GetSnapshot();
-  ASSERT_OK(Put("foo3", "bar"));
-  const Snapshot* s3 = db_->GetSnapshot();
+  ASSERT_OK(Put("bbb1", ""));

-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 0);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 0);
-  ASSERT_EQ(Get("foo"), "bar2");
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 0);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 1);
-  ASSERT_EQ(Get("foo"), "bar2");
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 1);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 1);
-  ASSERT_EQ(Get("foo", s1), "bar1");
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 1);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 2);
-  ASSERT_EQ(Get("foo", s2), "bar2");
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 2);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 2);
-  ASSERT_EQ(Get("foo", s1), "bar1");
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 3);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 2);
-  ASSERT_EQ(Get("foo", s3), "bar2");
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_HIT), 4);
-  ASSERT_EQ(TestGetTickerCount(options, ROW_CACHE_MISS), 2);
+  Iterator* iter = db_->NewIterator(ReadOptions());

-  db_->ReleaseSnapshot(s1);
-  db_->ReleaseSnapshot(s2);
-  db_->ReleaseSnapshot(s3);
+  // Seeking into f1, the iterator will check bloom filter which returns the
+  // file iterator ot be invalidate, and the cursor will put into f2, with
+  // the next key to be "ddd0".
+  iter->Seek("bbb1");
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_EQ("bbb1", iter->key().ToString());
+
+  // Reseek ccc1, the L1 iterator needs to go back to f1 and reseek.
+  iter->Seek("ccc1");
+  ASSERT_TRUE(iter->Valid());
+  ASSERT_EQ("ccc1", iter->key().ToString());
+
+  delete iter;
 }
-#endif  // ROCKSDB_LITE
 }  // namespace rocksdb

-#ifdef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-extern "C" {
-void RegisterCustomObjects(int argc, char** argv);
-}
-#else
-void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
-#endif  // !ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
-
 int main(int argc, char** argv) {
  rocksdb::port::InstallStackTraceHandler();
  ::testing::InitGoogleTest(&argc, argv);
-  RegisterCustomObjects(argc, argv);
  return RUN_ALL_TESTS();
 }
@@ -10,7 +10,6 @@
 #include "db/db_test_util.h"
 #include "db/forward_iterator.h"
 #include "rocksdb/env_encryption.h"
-#include "rocksdb/utilities/object_registry.h"

 namespace rocksdb {

@@ -48,32 +47,20 @@ ROT13BlockCipher rot13Cipher_(16);
 #endif  // ROCKSDB_LITE

 DBTestBase::DBTestBase(const std::string path)
-    : mem_env_(nullptr),
+    : mem_env_(!getenv("MEM_ENV") ? nullptr : new MockEnv(Env::Default())),
+#ifndef ROCKSDB_LITE
+      encrypted_env_(
+          !getenv("ENCRYPTED_ENV")
+              ? nullptr
+              : NewEncryptedEnv(mem_env_ ? mem_env_ : Env::Default(),
+                                new CTREncryptionProvider(rot13Cipher_))),
+#else
      encrypted_env_(nullptr),
+#endif  // ROCKSDB_LITE
+      env_(new SpecialEnv(encrypted_env_
+                              ? encrypted_env_
+                              : (mem_env_ ? mem_env_ : Env::Default()))),
      option_config_(kDefault) {
-  Env* base_env = Env::Default();
-#ifndef ROCKSDB_LITE
-  const char* test_env_uri = getenv("TEST_ENV_URI");
-  if (test_env_uri) {
-    Status s = ObjectRegistry::NewInstance()->NewSharedObject(test_env_uri,
-                                                              &env_guard_);
-    base_env = env_guard_.get();
-    EXPECT_OK(s);
-    EXPECT_NE(Env::Default(), base_env);
-  }
-#endif  // !ROCKSDB_LITE
-  EXPECT_NE(nullptr, base_env);
-  if (getenv("MEM_ENV")) {
-    mem_env_ = new MockEnv(base_env);
-  }
-#ifndef ROCKSDB_LITE
-  if (getenv("ENCRYPTED_ENV")) {
-    encrypted_env_ = NewEncryptedEnv(mem_env_ ? mem_env_ : base_env,
-                                     new CTREncryptionProvider(rot13Cipher_));
-  }
-#endif  // !ROCKSDB_LITE
-  env_ = new SpecialEnv(encrypted_env_ ? encrypted_env_
-                                       : (mem_env_ ? mem_env_ : base_env));
  env_->SetBackgroundThreads(1, Env::LOW);
  env_->SetBackgroundThreads(1, Env::HIGH);
  dbname_ = test::PerThreadDBPath(env_, path);
@@ -702,7 +702,6 @@ class DBTestBase : public testing::Test {
  MockEnv* mem_env_;
  Env* encrypted_env_;
  SpecialEnv* env_;
-  std::shared_ptr<Env> env_guard_;
  DB* db_;
  std::vector<ColumnFamilyHandle*> handles_;

@@ -441,17 +441,17 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionSizeAmplification) {
  ASSERT_EQ(dbfull()
                ->GetOptions(handles_[1])
                .compaction_options_universal.max_size_amplification_percent,
-            200U);
+            200);
  ASSERT_OK(dbfull()->SetOptions(handles_[1],
                                 {{"compaction_options_universal",
                                   "{max_size_amplification_percent=110;}"}}));
  ASSERT_EQ(dbfull()
                ->GetOptions(handles_[1])
                .compaction_options_universal.max_size_amplification_percent,
-            110u);
+            110);
  ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
                                                     &mutable_cf_options));
-  ASSERT_EQ(110u, mutable_cf_options.compaction_options_universal
+  ASSERT_EQ(110, mutable_cf_options.compaction_options_universal
                     .max_size_amplification_percent);

  dbfull()->TEST_WaitForCompact();
@@ -522,20 +522,20 @@ TEST_P(DBTestUniversalCompaction, DynamicUniversalCompactionReadAmplification) {
  ASSERT_EQ(dbfull()
                ->GetOptions(handles_[1])
                .compaction_options_universal.min_merge_width,
-            2u);
+            2);
  ASSERT_EQ(dbfull()
                ->GetOptions(handles_[1])
                .compaction_options_universal.max_merge_width,
-            2u);
+            2);
  ASSERT_EQ(
      dbfull()->GetOptions(handles_[1]).compaction_options_universal.size_ratio,
-      100u);
+      100);

  ASSERT_OK(dbfull()->TEST_GetLatestMutableCFOptions(handles_[1],
                                                     &mutable_cf_options));
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.size_ratio, 100u);
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.min_merge_width, 2u);
-  ASSERT_EQ(mutable_cf_options.compaction_options_universal.max_merge_width, 2u);
+  ASSERT_EQ(mutable_cf_options.compaction_options_universal.size_ratio, 100);
+  ASSERT_EQ(mutable_cf_options.compaction_options_universal.min_merge_width, 2);
+  ASSERT_EQ(mutable_cf_options.compaction_options_universal.max_merge_width, 2);

  dbfull()->TEST_WaitForCompact();

@@ -569,56 +569,6 @@ TEST_F(DBWALTest, GetSortedWalFiles) {
  } while (ChangeWalOptions());
 }

-TEST_F(DBWALTest, GetCurrentWalFile) {
-  do {
-    CreateAndReopenWithCF({"pikachu"}, CurrentOptions());
-
-    std::unique_ptr<LogFile>* bad_log_file = nullptr;
-    ASSERT_NOK(dbfull()->GetCurrentWalFile(bad_log_file));
-
-    std::unique_ptr<LogFile> log_file;
-    ASSERT_OK(dbfull()->GetCurrentWalFile(&log_file));
-
-    // nothing has been written to the log yet
-    ASSERT_EQ(log_file->StartSequence(), 0);
-    ASSERT_EQ(log_file->SizeFileBytes(), 0);
-    ASSERT_EQ(log_file->Type(), kAliveLogFile);
-    ASSERT_GT(log_file->LogNumber(), 0);
-
-    // add some data and verify that the file size actually moves foward
-    ASSERT_OK(Put(0, "foo", "v1"));
-    ASSERT_OK(Put(0, "foo2", "v2"));
-    ASSERT_OK(Put(0, "foo3", "v3"));
-
-    ASSERT_OK(dbfull()->GetCurrentWalFile(&log_file));
-
-    ASSERT_EQ(log_file->StartSequence(), 0);
-    ASSERT_GT(log_file->SizeFileBytes(), 0);
-    ASSERT_EQ(log_file->Type(), kAliveLogFile);
-    ASSERT_GT(log_file->LogNumber(), 0);
-
-    // force log files to cycle and add some more data, then check if
-    // log number moves forward
-
-    ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    for (int i = 0; i < 10; i++) {
-      ReopenWithColumnFamilies({"default", "pikachu"}, CurrentOptions());
-    }
-
-    ASSERT_OK(Put(0, "foo4", "v4"));
-    ASSERT_OK(Put(0, "foo5", "v5"));
-    ASSERT_OK(Put(0, "foo6", "v6"));
-
-    ASSERT_OK(dbfull()->GetCurrentWalFile(&log_file));
-
-    ASSERT_EQ(log_file->StartSequence(), 0);
-    ASSERT_GT(log_file->SizeFileBytes(), 0);
-    ASSERT_EQ(log_file->Type(), kAliveLogFile);
-    ASSERT_GT(log_file->LogNumber(), 0);
-
-  } while (ChangeWalOptions());
-}
-
 TEST_F(DBWALTest, RecoveryWithLogDataForSomeCFs) {
  // Test for regression of WAL cleanup missing files that don't contain data
  // for every column family.
@@ -874,9 +824,7 @@ class RecoveryTestHelper {
  // Create WAL files with values filled in
  static void FillData(DBWALTest* test, const Options& options,
                       const size_t wal_count, size_t* count) {
-    // Calling internal functions requires sanitized options.
-    Options sanitized_options = SanitizeOptions(test->dbname_, options);
-    const ImmutableDBOptions db_options(sanitized_options);
+    const ImmutableDBOptions db_options(options);

    *count = 0;

@@ -159,11 +159,9 @@ void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
  }
 }

-LookupKey::LookupKey(const Slice& _user_key, SequenceNumber s,
-                     const Slice* ts) {
+LookupKey::LookupKey(const Slice& _user_key, SequenceNumber s) {
  size_t usize = _user_key.size();
-  size_t ts_sz = (nullptr == ts) ? 0 : ts->size();
-  size_t needed = usize + ts_sz + 13;  // A conservative estimate
+  size_t needed = usize + 13;  // A conservative estimate
  char* dst;
  if (needed <= sizeof(space_)) {
    dst = space_;
@@ -172,14 +170,10 @@ LookupKey::LookupKey(const Slice& _user_key, SequenceNumber s,
  }
  start_ = dst;
  // NOTE: We don't support users keys of more than 2GB :)
-  dst = EncodeVarint32(dst, static_cast<uint32_t>(usize + ts_sz + 8));
+  dst = EncodeVarint32(dst, static_cast<uint32_t>(usize + 8));
  kstart_ = dst;
  memcpy(dst, _user_key.data(), usize);
  dst += usize;
-  if (nullptr != ts) {
-    memcpy(dst, ts->data(), ts_sz);
-    dst += ts_sz;
-  }
  EncodeFixed64(dst, PackSequenceAndType(s, kValueTypeForSeek));
  dst += 8;
  end_ = dst;
@@ -326,9 +326,6 @@ class IterKey {
        key_size_(0),
        buf_size_(sizeof(space_)),
        is_user_key_(true) {}
-  // No copying allowed
-  IterKey(const IterKey&) = delete;
-  void operator=(const IterKey&) = delete;

  ~IterKey() { ResetBuffer(); }

@@ -526,6 +523,10 @@ class IterKey {
  }

  void EnlargeBuffer(size_t key_size);
+
+  // No copying allowed
+  IterKey(const IterKey&) = delete;
+  void operator=(const IterKey&) = delete;
 };

 // Convert from a SliceTranform of user keys, to a SliceTransform of
@@ -668,4 +669,20 @@ struct ParsedInternalKeyComparator {
  const InternalKeyComparator* cmp;
 };

+// TODO (yanqin): this causes extra memory allocation and copy. Should be
+// addressed in the future.
+inline Status AppendTimestamp(const Slice& key, const Slice& timestamp,
+                              Slice* ret_key, std::string* ret_buf) {
+  assert(ret_key != nullptr);
+  assert(ret_buf != nullptr);
+  if (key.data() + key.size() == timestamp.data()) {
+    *ret_key = Slice(key.data(), key.size() + timestamp.size());
+  } else {
+    ret_buf->assign(key.data(), key.size());
+    ret_buf->append(timestamp.data(), timestamp.size());
+    *ret_key = Slice(*ret_buf);
+  }
+  return Status::OK();
+}
+
 }  // namespace rocksdb
@@ -284,8 +284,6 @@ TEST_F(DeleteFileTest, BackgroundPurgeIteratorTest) {
 TEST_F(DeleteFileTest, BackgroundPurgeCFDropTest) {
  auto do_test = [&](bool bg_purge) {
    ColumnFamilyOptions co;
-    co.max_write_buffer_size_to_maintain =
-        static_cast<int64_t>(co.write_buffer_size);
    WriteOptions wo;
    FlushOptions fo;
    ColumnFamilyHandle* cfh = nullptr;
@@ -106,7 +106,7 @@ void EventHelpers::LogAndNotifyTableFileCreationFinished(
              << "num_entries" << table_properties.num_entries
              << "num_deletions" << table_properties.num_deletions
              << "num_merge_operands" << table_properties.num_merge_operands
-              << "num_range_deletions" << table_properties.num_range_deletions
+              << "num_range_deletions" << table_properties.num_merge_operands
              << "format_version" << table_properties.format_version
              << "fixed_key_len" << table_properties.fixed_key_len
              << "filter_policy" << table_properties.filter_policy_name
@@ -9,7 +9,6 @@
 #include "port/port.h"
 #include "port/stack_trace.h"
 #include "rocksdb/sst_file_writer.h"
-#include "test_util/fault_injection_test_env.h"
 #include "test_util/testutil.h"

 namespace rocksdb {
@@ -21,7 +20,6 @@ class ExternalSSTFileBasicTest
 public:
  ExternalSSTFileBasicTest() : DBTestBase("/external_sst_file_basic_test") {
    sst_files_dir_ = dbname_ + "/sst_files/";
-    fault_injection_test_env_.reset(new FaultInjectionTestEnv(Env::Default()));
    DestroyAndRecreateExternalSSTFilesDir();
  }

@@ -142,7 +140,6 @@ class ExternalSSTFileBasicTest

 protected:
  std::string sst_files_dir_;
-  std::unique_ptr<FaultInjectionTestEnv> fault_injection_test_env_;
 };

 TEST_F(ExternalSSTFileBasicTest, Basic) {
@@ -692,110 +689,6 @@ TEST_F(ExternalSSTFileBasicTest, FadviseTrigger) {
  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }

-TEST_F(ExternalSSTFileBasicTest, SyncFailure) {
-  Options options;
-  options.create_if_missing = true;
-  options.env = fault_injection_test_env_.get();
-
-  std::vector<std::pair<std::string, std::string>> test_cases = {
-      {"ExternalSstFileIngestionJob::BeforeSyncIngestedFile",
-       "ExternalSstFileIngestionJob::AfterSyncIngestedFile"},
-      {"ExternalSstFileIngestionJob::BeforeSyncDir",
-       "ExternalSstFileIngestionJob::AfterSyncDir"},
-      {"ExternalSstFileIngestionJob::BeforeSyncGlobalSeqno",
-       "ExternalSstFileIngestionJob::AfterSyncGlobalSeqno"}};
-
-  for (size_t i = 0; i < test_cases.size(); i++) {
-    SyncPoint::GetInstance()->SetCallBack(test_cases[i].first, [&](void*) {
-      fault_injection_test_env_->SetFilesystemActive(false);
-    });
-    SyncPoint::GetInstance()->SetCallBack(test_cases[i].second, [&](void*) {
-      fault_injection_test_env_->SetFilesystemActive(true);
-    });
-    SyncPoint::GetInstance()->EnableProcessing();
-
-    DestroyAndReopen(options);
-    if (i == 2) {
-      ASSERT_OK(Put("foo", "v1"));
-    }
-
-    Options sst_file_writer_options;
-    std::unique_ptr<SstFileWriter> sst_file_writer(
-        new SstFileWriter(EnvOptions(), sst_file_writer_options));
-    std::string file_name =
-        sst_files_dir_ + "sync_failure_test_" + ToString(i) + ".sst";
-    ASSERT_OK(sst_file_writer->Open(file_name));
-    ASSERT_OK(sst_file_writer->Put("bar", "v2"));
-    ASSERT_OK(sst_file_writer->Finish());
-
-    IngestExternalFileOptions ingest_opt;
-    if (i == 0) {
-      ingest_opt.move_files = true;
-    }
-    const Snapshot* snapshot = db_->GetSnapshot();
-    if (i == 2) {
-      ingest_opt.write_global_seqno = true;
-    }
-    ASSERT_FALSE(db_->IngestExternalFile({file_name}, ingest_opt).ok());
-    db_->ReleaseSnapshot(snapshot);
-
-    SyncPoint::GetInstance()->DisableProcessing();
-    SyncPoint::GetInstance()->ClearAllCallBacks();
-    Destroy(options);
-  }
-}
-
-TEST_F(ExternalSSTFileBasicTest, VerifyChecksumReadahead) {
-  Options options;
-  options.create_if_missing = true;
-  SpecialEnv senv(Env::Default());
-  options.env = &senv;
-  DestroyAndReopen(options);
-
-  Options sst_file_writer_options;
-  std::unique_ptr<SstFileWriter> sst_file_writer(
-      new SstFileWriter(EnvOptions(), sst_file_writer_options));
-  std::string file_name = sst_files_dir_ + "verify_checksum_readahead_test.sst";
-  ASSERT_OK(sst_file_writer->Open(file_name));
-  Random rnd(301);
-  std::string value = DBTestBase::RandomString(&rnd, 4000);
-  for (int i = 0; i < 5000; i++) {
-    ASSERT_OK(sst_file_writer->Put(DBTestBase::Key(i), value));
-  }
-  ASSERT_OK(sst_file_writer->Finish());
-
-  // Ingest it once without verifying checksums to see the baseline
-  // preads.
-  IngestExternalFileOptions ingest_opt;
-  ingest_opt.move_files = false;
-  senv.count_random_reads_ = true;
-  senv.random_read_bytes_counter_ = 0;
-  ASSERT_OK(db_->IngestExternalFile({file_name}, ingest_opt));
-
-  auto base_num_reads = senv.random_read_counter_.Read();
-  // Make sure the counter is enabled.
-  ASSERT_GT(base_num_reads, 0);
-
-  // Ingest again and observe the reads made for for readahead.
-  ingest_opt.move_files = false;
-  ingest_opt.verify_checksums_before_ingest = true;
-  ingest_opt.verify_checksums_readahead_size = size_t{2 * 1024 * 1024};
-
-  senv.count_random_reads_ = true;
-  senv.random_read_bytes_counter_ = 0;
-  ASSERT_OK(db_->IngestExternalFile({file_name}, ingest_opt));
-
-  // Make sure the counter is enabled.
-  ASSERT_GT(senv.random_read_counter_.Read() - base_num_reads, 0);
-
-  // The SST file is about 20MB. Readahead size is 2MB.
-  // Give a conservative 15 reads for metadata blocks, the number
-  // of random reads should be within 20 MB / 2MB + 15 = 25.
-  ASSERT_LE(senv.random_read_counter_.Read() - base_num_reads, 40);
-
-  Destroy(options);
-}
-
 TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
  int kNumLevels = 7;
  Options options = CurrentOptions();
@@ -886,48 +779,6 @@ TEST_P(ExternalSSTFileBasicTest, IngestionWithRangeDeletions) {
  ASSERT_EQ(2, NumTableFilesAtLevel(options.num_levels - 1));
 }

-TEST_F(ExternalSSTFileBasicTest, AdjacentRangeDeletionTombstones) {
-  Options options = CurrentOptions();
-  SstFileWriter sst_file_writer(EnvOptions(), options);
-
-  // file8.sst (delete 300 => 400)
-  std::string file8 = sst_files_dir_ + "file8.sst";
-  ASSERT_OK(sst_file_writer.Open(file8));
-  ASSERT_OK(sst_file_writer.DeleteRange(Key(300), Key(400)));
-  ExternalSstFileInfo file8_info;
-  Status s = sst_file_writer.Finish(&file8_info);
-  ASSERT_TRUE(s.ok()) << s.ToString();
-  ASSERT_EQ(file8_info.file_path, file8);
-  ASSERT_EQ(file8_info.num_entries, 0);
-  ASSERT_EQ(file8_info.smallest_key, "");
-  ASSERT_EQ(file8_info.largest_key, "");
-  ASSERT_EQ(file8_info.num_range_del_entries, 1);
-  ASSERT_EQ(file8_info.smallest_range_del_key, Key(300));
-  ASSERT_EQ(file8_info.largest_range_del_key, Key(400));
-
-  // file9.sst (delete 400 => 500)
-  std::string file9 = sst_files_dir_ + "file9.sst";
-  ASSERT_OK(sst_file_writer.Open(file9));
-  ASSERT_OK(sst_file_writer.DeleteRange(Key(400), Key(500)));
-  ExternalSstFileInfo file9_info;
-  s = sst_file_writer.Finish(&file9_info);
-  ASSERT_TRUE(s.ok()) << s.ToString();
-  ASSERT_EQ(file9_info.file_path, file9);
-  ASSERT_EQ(file9_info.num_entries, 0);
-  ASSERT_EQ(file9_info.smallest_key, "");
-  ASSERT_EQ(file9_info.largest_key, "");
-  ASSERT_EQ(file9_info.num_range_del_entries, 1);
-  ASSERT_EQ(file9_info.smallest_range_del_key, Key(400));
-  ASSERT_EQ(file9_info.largest_range_del_key, Key(500));
-
-  // Range deletion tombstones are exclusive on their end key, so these SSTs
-  // should not be considered as overlapping.
-  s = DeprecatedAddFile({file8, file9});
-  ASSERT_TRUE(s.ok()) << s.ToString();
-  ASSERT_EQ(db_->GetLatestSequenceNumber(), 0U);
-  DestroyAndRecreateExternalSSTFilesDir();
-}
-
 TEST_P(ExternalSSTFileBasicTest, IngestFileWithBadBlockChecksum) {
  bool change_checksum_called = false;
  const auto& change_checksum = [&](void* arg) {
@@ -7,13 +7,11 @@

 #include "db/external_sst_file_ingestion_job.h"

-#include <algorithm>
 #include <cinttypes>
+#include <algorithm>
 #include <string>
-#include <unordered_set>
 #include <vector>

-#include "db/db_impl/db_impl.h"
 #include "db/version_edit.h"
 #include "file/file_util.h"
 #include "table/merging_iterator.h"
@@ -64,13 +62,13 @@ Status ExternalSstFileIngestionJob::Prepare(
    std::sort(
        sorted_files.begin(), sorted_files.end(),
        [&ucmp](const IngestedFileInfo* info1, const IngestedFileInfo* info2) {
-          return sstableKeyCompare(ucmp, info1->smallest_internal_key,
-                                   info2->smallest_internal_key) < 0;
+          return ucmp->Compare(info1->smallest_user_key,
+                               info2->smallest_user_key) < 0;
        });

    for (size_t i = 0; i < num_files - 1; i++) {
-      if (sstableKeyCompare(ucmp, sorted_files[i]->largest_internal_key,
-                            sorted_files[i + 1]->smallest_internal_key) >= 0) {
+      if (ucmp->Compare(sorted_files[i]->largest_user_key,
+                        sorted_files[i + 1]->smallest_user_key) >= 0) {
        return Status::NotSupported("Files have overlapping ranges");
      }
    }
@@ -81,14 +79,13 @@ Status ExternalSstFileIngestionJob::Prepare(
      return Status::InvalidArgument("File contain no entries");
    }

-    if (!f.smallest_internal_key.Valid() ||
-        !f.largest_internal_key.Valid()) {
+    if (!f.smallest_internal_key().Valid() ||
+        !f.largest_internal_key().Valid()) {
      return Status::Corruption("Generated table have corrupted keys");
    }
  }

  // Copy/Move external files into DB
-  std::unordered_set<size_t> ingestion_path_ids;
  for (IngestedFileInfo& f : files_to_ingest_) {
    f.fd = FileDescriptor(next_file_number++, 0, f.file_size);
    f.copy_file = false;
@@ -98,26 +95,8 @@ Status ExternalSstFileIngestionJob::Prepare(
                      f.fd.GetPathId());
    if (ingestion_options_.move_files) {
      status = env_->LinkFile(path_outside_db, path_inside_db);
-      if (status.ok()) {
-        // It is unsafe to assume application had sync the file and file
-        // directory before ingest the file. For integrity of RocksDB we need
-        // to sync the file.
-        std::unique_ptr<WritableFile> file_to_sync;
-        status = env_->ReopenWritableFile(path_inside_db, &file_to_sync,
-                                          env_options_);
-        if (status.ok()) {
-          TEST_SYNC_POINT(
-              "ExternalSstFileIngestionJob::BeforeSyncIngestedFile");
-          status = SyncIngestedFile(file_to_sync.get());
-          TEST_SYNC_POINT("ExternalSstFileIngestionJob::AfterSyncIngestedFile");
-          if (!status.ok()) {
-            ROCKS_LOG_WARN(db_options_.info_log,
-                           "Failed to sync ingested file %s: %s",
-                           path_inside_db.c_str(), status.ToString().c_str());
-          }
-        }
-      } else if (status.IsNotSupported() &&
-                 ingestion_options_.failed_move_fall_back_to_copy) {
+      if (status.IsNotSupported() &&
+          ingestion_options_.failed_move_fall_back_to_copy) {
        // Original file is on a different FS, use copy instead of hard linking.
        f.copy_file = true;
      }
@@ -128,7 +107,6 @@ Status ExternalSstFileIngestionJob::Prepare(
    if (f.copy_file) {
      TEST_SYNC_POINT_CALLBACK("ExternalSstFileIngestionJob::Prepare:CopyFile",
                               nullptr);
-      // CopyFile also sync the new file.
      status = CopyFile(env_, path_outside_db, path_inside_db, 0,
                        db_options_.use_fsync);
    }
@@ -137,25 +115,8 @@ Status ExternalSstFileIngestionJob::Prepare(
      break;
    }
    f.internal_file_path = path_inside_db;
-    ingestion_path_ids.insert(f.fd.GetPathId());
  }

-  TEST_SYNC_POINT("ExternalSstFileIngestionJob::BeforeSyncDir");
-  if (status.ok()) {
-    for (auto path_id : ingestion_path_ids) {
-      status = directories_->GetDataDir(path_id)->Fsync();
-      if (!status.ok()) {
-        ROCKS_LOG_WARN(db_options_.info_log,
-                       "Failed to sync directory %" ROCKSDB_PRIszt
-                       " while ingest file: %s",
-                       path_id, status.ToString().c_str());
-        break;
-      }
-    }
-  }
-  TEST_SYNC_POINT("ExternalSstFileIngestionJob::AfterSyncDir");
-
-  // TODO: The following is duplicated with Cleanup().
  if (!status.ok()) {
    // We failed, remove all files that we copied into the db
    for (IngestedFileInfo& f : files_to_ingest_) {
@@ -178,8 +139,8 @@ Status ExternalSstFileIngestionJob::NeedsFlush(bool* flush_needed,
                                               SuperVersion* super_version) {
  autovector<Range> ranges;
  for (const IngestedFileInfo& file_to_ingest : files_to_ingest_) {
-    ranges.emplace_back(file_to_ingest.smallest_internal_key.user_key(),
-                        file_to_ingest.largest_internal_key.user_key());
+    ranges.emplace_back(file_to_ingest.smallest_user_key,
+                        file_to_ingest.largest_user_key);
  }
  Status status =
      cfd_->RangesOverlapWithMemtables(ranges, super_version, flush_needed);
@@ -238,8 +199,8 @@ Status ExternalSstFileIngestionJob::Run() {
      return status;
    }
    edit_.AddFile(f.picked_level, f.fd.GetNumber(), f.fd.GetPathId(),
-                  f.fd.GetFileSize(), f.smallest_internal_key,
-                  f.largest_internal_key, f.assigned_seqno, f.assigned_seqno,
+                  f.fd.GetFileSize(), f.smallest_internal_key(),
+                  f.largest_internal_key(), f.assigned_seqno, f.assigned_seqno,
                  false);
  }
  return status;
@@ -350,13 +311,7 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
  }

  if (ingestion_options_.verify_checksums_before_ingest) {
-    // If customized readahead size is needed, we can pass a user option
-    // all the way to here. Right now we just rely on the default readahead
-    // to keep things simple.
-    ReadOptions ro;
-    ro.readahead_size = ingestion_options_.verify_checksums_readahead_size;
-    status = table_reader->VerifyChecksum(
-        ro, TableReaderCaller::kExternalSSTIngestion);
+    status = table_reader->VerifyChecksum();
  }
  if (!status.ok()) {
    return status;
@@ -416,14 +371,11 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
  // updating the block cache.
  ro.fill_cache = false;
  std::unique_ptr<InternalIterator> iter(table_reader->NewIterator(
-      ro, sv->mutable_cf_options.prefix_extractor.get(), /*arena=*/nullptr,
-      /*skip_filters=*/false, TableReaderCaller::kExternalSSTIngestion));
+      ro, sv->mutable_cf_options.prefix_extractor.get()));
  std::unique_ptr<InternalIterator> range_del_iter(
      table_reader->NewRangeTombstoneIterator(ro));

  // Get first (smallest) and last (largest) key from file.
-  file_to_ingest->smallest_internal_key = InternalKey("", 0, ValueType::kTypeValue);
-  file_to_ingest->largest_internal_key = InternalKey("", 0, ValueType::kTypeValue);
  bool bounds_set = false;
  iter->SeekToFirst();
  if (iter->Valid()) {
@@ -433,7 +385,7 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
    if (key.sequence != 0) {
      return Status::Corruption("external file have non zero sequence number");
    }
-    file_to_ingest->smallest_internal_key.SetFrom(key);
+    file_to_ingest->smallest_user_key = key.user_key.ToString();

    iter->SeekToLast();
    if (!ParseInternalKey(iter->key(), &key)) {
@@ -442,7 +394,7 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
    if (key.sequence != 0) {
      return Status::Corruption("external file have non zero sequence number");
    }
-    file_to_ingest->largest_internal_key.SetFrom(key);
+    file_to_ingest->largest_user_key = key.user_key.ToString();

    bounds_set = true;
  }
@@ -458,13 +410,13 @@ Status ExternalSstFileIngestionJob::GetIngestedFileInfo(
      }
      RangeTombstone tombstone(key, range_del_iter->value());

-      InternalKey start_key = tombstone.SerializeKey();
-      if (!bounds_set || sstableKeyCompare(ucmp, start_key, file_to_ingest->smallest_internal_key) < 0) {
-        file_to_ingest->smallest_internal_key = start_key;
+      if (!bounds_set || ucmp->Compare(tombstone.start_key_,
+                                       file_to_ingest->smallest_user_key) < 0) {
+        file_to_ingest->smallest_user_key = tombstone.start_key_.ToString();
      }
-      InternalKey end_key = tombstone.SerializeEndKey();
-      if (!bounds_set || sstableKeyCompare(ucmp, end_key, file_to_ingest->largest_internal_key) > 0) {
-        file_to_ingest->largest_internal_key = end_key;
+      if (!bounds_set || ucmp->Compare(tombstone.end_key_,
+                                       file_to_ingest->largest_user_key) > 0) {
+        file_to_ingest->largest_user_key = tombstone.end_key_.ToString();
      }
      bounds_set = true;
    }
@@ -506,7 +458,7 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
    if (vstorage->NumLevelFiles(lvl) > 0) {
      bool overlap_with_level = false;
      status = sv->current->OverlapWithLevelIterator(ro, env_options_,
-          file_to_ingest->smallest_internal_key.user_key(), file_to_ingest->largest_internal_key.user_key(),
+          file_to_ingest->smallest_user_key, file_to_ingest->largest_user_key,
          lvl, &overlap_with_level);
      if (!status.ok()) {
        return status;
@@ -608,18 +560,6 @@ Status ExternalSstFileIngestionJob::AssignGlobalSeqnoForIngestedFile(
      std::string seqno_val;
      PutFixed64(&seqno_val, seqno);
      status = rwfile->Write(file_to_ingest->global_seqno_offset, seqno_val);
-      if (status.ok()) {
-        TEST_SYNC_POINT("ExternalSstFileIngestionJob::BeforeSyncGlobalSeqno");
-        status = SyncIngestedFile(rwfile.get());
-        TEST_SYNC_POINT("ExternalSstFileIngestionJob::AfterSyncGlobalSeqno");
-        if (!status.ok()) {
-          ROCKS_LOG_WARN(db_options_.info_log,
-                         "Failed to sync ingested file %s after writing global "
-                         "sequence number: %s",
-                         file_to_ingest->internal_file_path.c_str(),
-                         status.ToString().c_str());
-        }
-      }
      if (!status.ok()) {
        return status;
      }
@@ -640,8 +580,8 @@ bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
  }

  auto* vstorage = cfd_->current()->storage_info();
-  Slice file_smallest_user_key(file_to_ingest->smallest_internal_key.user_key());
-  Slice file_largest_user_key(file_to_ingest->largest_internal_key.user_key());
+  Slice file_smallest_user_key(file_to_ingest->smallest_user_key);
+  Slice file_largest_user_key(file_to_ingest->largest_user_key);

  if (vstorage->OverlapInLevel(level, &file_smallest_user_key,
                               &file_largest_user_key)) {
@@ -660,16 +600,6 @@ bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
  return true;
 }

-template <typename TWritableFile>
-Status ExternalSstFileIngestionJob::SyncIngestedFile(TWritableFile* file) {
-  assert(file != nullptr);
-  if (db_options_.use_fsync) {
-    return file->Fsync();
-  } else {
-    return file->Sync();
-  }
-}
-
 }  // namespace rocksdb

 #endif  // !ROCKSDB_LITE
@@ -20,15 +20,13 @@

 namespace rocksdb {

-class Directories;
-
 struct IngestedFileInfo {
  // External file path
  std::string external_file_path;
-  // Smallest internal key in external file
-  InternalKey smallest_internal_key;
-  // Largest internal key in external file
-  InternalKey largest_internal_key;
+  // Smallest user key in external file
+  std::string smallest_user_key;
+  // Largest user key in external file
+  std::string largest_user_key;
  // Sequence number for keys in external file
  SequenceNumber original_seqno;
  // Offset of the global sequence number field in the file, will
@@ -62,6 +60,15 @@ struct IngestedFileInfo {
  // ingestion_options.move_files is false by default, thus copy_file is true
  // by default.
  bool copy_file = true;
+
+  InternalKey smallest_internal_key() const {
+    return InternalKey(smallest_user_key, assigned_seqno,
+                       ValueType::kTypeValue);
+  }
+
+  InternalKey largest_internal_key() const {
+    return InternalKey(largest_user_key, assigned_seqno, ValueType::kTypeValue);
+  }
 };

 class ExternalSstFileIngestionJob {
@@ -70,8 +77,7 @@ class ExternalSstFileIngestionJob {
      Env* env, VersionSet* versions, ColumnFamilyData* cfd,
      const ImmutableDBOptions& db_options, const EnvOptions& env_options,
      SnapshotList* db_snapshots,
-      const IngestExternalFileOptions& ingestion_options,
-      Directories* directories)
+      const IngestExternalFileOptions& ingestion_options)
      : env_(env),
        versions_(versions),
        cfd_(cfd),
@@ -79,11 +85,8 @@ class ExternalSstFileIngestionJob {
        env_options_(env_options),
        db_snapshots_(db_snapshots),
        ingestion_options_(ingestion_options),
-        directories_(directories),
        job_start_time_(env_->NowMicros()),
-        consumed_seqno_(false) {
-    assert(directories != nullptr);
-  }
+        consumed_seqno_(false) {}

  // Prepare the job by copying external files into the DB.
  Status Prepare(const std::vector<std::string>& external_files_paths,
@@ -150,10 +153,6 @@ class ExternalSstFileIngestionJob {
  bool IngestedFileFitInLevel(const IngestedFileInfo* file_to_ingest,
                              int level);

-  // Helper method to sync given file.
-  template <typename TWritableFile>
-  Status SyncIngestedFile(TWritableFile* file);
-
  Env* env_;
  VersionSet* versions_;
  ColumnFamilyData* cfd_;
@@ -162,7 +161,6 @@ class ExternalSstFileIngestionJob {
  SnapshotList* db_snapshots_;
  autovector<IngestedFileInfo> files_to_ingest_;
  const IngestExternalFileOptions& ingestion_options_;
-  Directories* directories_;
  VersionEdit edit_;
  uint64_t job_start_time_;
  bool consumed_seqno_;
@@ -696,10 +696,10 @@ TEST_F(ExternalSSTFileTest, AddList) {
    ASSERT_EQ(file6_info.smallest_range_del_key, Key(0));
    ASSERT_EQ(file6_info.largest_range_del_key, Key(100));

-    // file7.sst (delete 99 => 201)
+    // file7.sst (delete 100 => 200)
    std::string file7 = sst_files_dir_ + "file7.sst";
    ASSERT_OK(sst_file_writer.Open(file7));
-    ASSERT_OK(sst_file_writer.DeleteRange(Key(99), Key(201)));
+    ASSERT_OK(sst_file_writer.DeleteRange(Key(100), Key(200)));
    ExternalSstFileInfo file7_info;
    s = sst_file_writer.Finish(&file7_info);
    ASSERT_TRUE(s.ok()) << s.ToString();
@@ -708,8 +708,8 @@ TEST_F(ExternalSSTFileTest, AddList) {
    ASSERT_EQ(file7_info.smallest_key, "");
    ASSERT_EQ(file7_info.largest_key, "");
    ASSERT_EQ(file7_info.num_range_del_entries, 1);
-    ASSERT_EQ(file7_info.smallest_range_del_key, Key(99));
-    ASSERT_EQ(file7_info.largest_range_del_key, Key(201));
+    ASSERT_EQ(file7_info.smallest_range_del_key, Key(100));
+    ASSERT_EQ(file7_info.largest_range_del_key, Key(200));

    // list 1 has internal key range conflict
    std::vector<std::string> file_list0({file1, file2});
@@ -724,7 +724,9 @@ TEST_F(ExternalSSTFileTest, AddList) {
    // These lists of files have key ranges that overlap with each other
    s = DeprecatedAddFile(file_list1);
    ASSERT_FALSE(s.ok()) << s.ToString();
-    // Both of the following overlap on the range deletion tombstone.
+    // Both of the following overlap on the end key of a range deletion
+    // tombstone. This is a limitation because these tombstones have exclusive
+    // end keys that should not count as overlapping with other keys.
    s = DeprecatedAddFile(file_list4);
    ASSERT_FALSE(s.ok()) << s.ToString();
    s = DeprecatedAddFile(file_list5);
@@ -8,7 +8,6 @@
 #include <string>

 #include "db/column_family.h"
-#include "db/db_impl/db_impl.h"
 #include "db/flush_job.h"
 #include "db/version_set.h"
 #include "rocksdb/cache.h"
@@ -56,14 +55,7 @@ class FlushJobTest : public testing::Test {
  }

  void NewDB() {
-    SetIdentityFile(env_, dbname_);
    VersionEdit new_db;
-    if (db_options_.write_dbid_to_manifest) {
-      DBImpl* impl = new DBImpl(DBOptions(), dbname_);
-      std::string db_id;
-      impl->GetDbIdentityFromIdentityFile(&db_id);
-      new_db.SetDBId(db_id);
-    }
    new_db.SetLogNumber(0);
    new_db.SetNextFile(2);
    new_db.SetLastSequence(0);
@@ -11,7 +11,7 @@

 namespace rocksdb {

-void FlushScheduler::ScheduleWork(ColumnFamilyData* cfd) {
+void FlushScheduler::ScheduleFlush(ColumnFamilyData* cfd) {
 #ifndef NDEBUG
  {
    std::lock_guard<std::mutex> lock(checking_mutex_);
@@ -9,29 +9,26 @@
 #include <atomic>
 #include <mutex>
 #include <set>
-#include "util/autovector.h"

 namespace rocksdb {

 class ColumnFamilyData;

-// FlushScheduler keeps track of all column families whose memtable may
-// be full and require flushing. Unless otherwise noted, all methods on
-// FlushScheduler should be called only with the DB mutex held or from
-// a single-threaded recovery context.
+// Unless otherwise noted, all methods on FlushScheduler should be called
+// only with the DB mutex held or from a single-threaded recovery context.
 class FlushScheduler {
 public:
  FlushScheduler() : head_(nullptr) {}

  // May be called from multiple threads at once, but not concurrent with
  // any other method calls on this instance
-  void ScheduleWork(ColumnFamilyData* cfd);
+  void ScheduleFlush(ColumnFamilyData* cfd);

  // Removes and returns Ref()-ed column family. Client needs to Unref().
  // Filters column families that have been dropped.
  ColumnFamilyData* TakeNextColumnFamily();

-  // This can be called concurrently with ScheduleWork but it would miss all
+  // This can be called concurrently with ScheduleFlush but it would miss all
  // the scheduled flushes after the last synchronization. This would result
  // into less precise enforcement of memtable sizes but should not matter much.
  bool Empty();
@@ -79,11 +79,7 @@ class ForwardLevelIterator : public InternalIterator {
        read_options_, *(cfd_->soptions()), cfd_->internal_comparator(),
        *files_[file_index_],
        read_options_.ignore_range_deletions ? nullptr : &range_del_agg,
-        prefix_extractor_, /*table_reader_ptr=*/nullptr,
-        /*file_read_hist=*/nullptr, TableReaderCaller::kUserIterator,
-        /*arena=*/nullptr, /*skip_filters=*/false, /*level=*/-1,
-        /*smallest_compaction_key=*/nullptr,
-        /*largest_compaction_key=*/nullptr);
+        prefix_extractor_, nullptr /* table_reader_ptr */, nullptr, false);
    file_iter_->SetPinnedItersMgr(pinned_iters_mgr_);
    valid_ = false;
    if (!range_del_agg.IsEmpty()) {
@@ -646,12 +642,7 @@ void ForwardIterator::RebuildIterators(bool refresh_sv) {
    l0_iters_.push_back(cfd_->table_cache()->NewIterator(
        read_options_, *cfd_->soptions(), cfd_->internal_comparator(), *l0,
        read_options_.ignore_range_deletions ? nullptr : &range_del_agg,
-        sv_->mutable_cf_options.prefix_extractor.get(),
-        /*table_reader_ptr=*/nullptr, /*file_read_hist=*/nullptr,
-        TableReaderCaller::kUserIterator, /*arena=*/nullptr,
-        /*skip_filters=*/false, /*level=*/-1,
-        /*smallest_compaction_key=*/nullptr,
-        /*largest_compaction_key=*/nullptr));
+        sv_->mutable_cf_options.prefix_extractor.get()));
  }
  BuildLevelIterators(vstorage);
  current_ = nullptr;
@@ -723,12 +714,7 @@ void ForwardIterator::RenewIterators() {
        read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
        *l0_files_new[inew],
        read_options_.ignore_range_deletions ? nullptr : &range_del_agg,
-        svnew->mutable_cf_options.prefix_extractor.get(),
-        /*table_reader_ptr=*/nullptr, /*file_read_hist=*/nullptr,
-        TableReaderCaller::kUserIterator, /*arena=*/nullptr,
-        /*skip_filters=*/false, /*level=*/-1,
-        /*smallest_compaction_key=*/nullptr,
-        /*largest_compaction_key=*/nullptr));
+        svnew->mutable_cf_options.prefix_extractor.get()));
  }

  for (auto* f : l0_iters_) {
@@ -786,13 +772,8 @@ void ForwardIterator::ResetIncompleteIterators() {
    DeleteIterator(l0_iters_[i]);
    l0_iters_[i] = cfd_->table_cache()->NewIterator(
        read_options_, *cfd_->soptions(), cfd_->internal_comparator(),
-        *l0_files[i], /*range_del_agg=*/nullptr,
-        sv_->mutable_cf_options.prefix_extractor.get(),
-        /*table_reader_ptr=*/nullptr, /*file_read_hist=*/nullptr,
-        TableReaderCaller::kUserIterator, /*arena=*/nullptr,
-        /*skip_filters=*/false, /*level=*/-1,
-        /*smallest_compaction_key=*/nullptr,
-        /*largest_compaction_key=*/nullptr);
+        *l0_files[i], nullptr /* range_del_agg */,
+        sv_->mutable_cf_options.prefix_extractor.get());
    l0_iters_[i]->SetPinnedItersMgr(pinned_iters_mgr_);
  }

@@ -1,257 +0,0 @@
-#ifndef ROCKSDB_LITE
-
-#include "db/import_column_family_job.h"
-
-#include <cinttypes>
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#include "db/version_edit.h"
-#include "file/file_util.h"
-#include "table/merging_iterator.h"
-#include "table/scoped_arena_iterator.h"
-#include "table/sst_file_writer_collectors.h"
-#include "table/table_builder.h"
-#include "util/file_reader_writer.h"
-#include "util/stop_watch.h"
-
-namespace rocksdb {
-
-Status ImportColumnFamilyJob::Prepare(uint64_t next_file_number,
-                                      SuperVersion* sv) {
-  Status status;
-
-  // Read the information of files we are importing
-  for (const auto& file_metadata : metadata_) {
-    const auto file_path = file_metadata.db_path + "/" + file_metadata.name;
-    IngestedFileInfo file_to_import;
-    status = GetIngestedFileInfo(file_path, &file_to_import, sv);
-    if (!status.ok()) {
-      return status;
-    }
-    files_to_import_.push_back(file_to_import);
-  }
-
-  const auto ucmp = cfd_->internal_comparator().user_comparator();
-  auto num_files = files_to_import_.size();
-  if (num_files == 0) {
-    return Status::InvalidArgument("The list of files is empty");
-  } else if (num_files > 1) {
-    // Verify that passed files don't have overlapping ranges in any particular
-    // level.
-    int min_level = 1;  // Check for overlaps in Level 1 and above.
-    int max_level = -1;
-    for (const auto& file_metadata : metadata_) {
-      if (file_metadata.level > max_level) {
-        max_level = file_metadata.level;
-      }
-    }
-    for (int level = min_level; level <= max_level; ++level) {
-      autovector<const IngestedFileInfo*> sorted_files;
-      for (size_t i = 0; i < num_files; i++) {
-        if (metadata_[i].level == level) {
-          sorted_files.push_back(&files_to_import_[i]);
-        }
-      }
-
-      std::sort(sorted_files.begin(), sorted_files.end(),
-                [&ucmp](const IngestedFileInfo* info1,
-                        const IngestedFileInfo* info2) {
-                  return sstableKeyCompare(ucmp, info1->smallest_internal_key,
-                                           info2->smallest_internal_key) < 0;
-                });
-
-      for (size_t i = 0; i < sorted_files.size() - 1; i++) {
-        if (sstableKeyCompare(ucmp, sorted_files[i]->largest_internal_key,
-                              sorted_files[i + 1]->smallest_internal_key) >= 0) {
-          return Status::InvalidArgument("Files have overlapping ranges");
-        }
-      }
-    }
-  }
-
-  for (const auto& f : files_to_import_) {
-    if (f.num_entries == 0) {
-      return Status::InvalidArgument("File contain no entries");
-    }
-
-    if (!f.smallest_internal_key.Valid() ||
-        !f.largest_internal_key.Valid()) {
-      return Status::Corruption("File has corrupted keys");
-    }
-  }
-
-  // Copy/Move external files into DB
-  auto hardlink_files = import_options_.move_files;
-  for (auto& f : files_to_import_) {
-    f.fd = FileDescriptor(next_file_number++, 0, f.file_size);
-
-    const auto path_outside_db = f.external_file_path;
-    const auto path_inside_db = TableFileName(
-        cfd_->ioptions()->cf_paths, f.fd.GetNumber(), f.fd.GetPathId());
-
-    if (hardlink_files) {
-      status = env_->LinkFile(path_outside_db, path_inside_db);
-      if (status.IsNotSupported()) {
-        // Original file is on a different FS, use copy instead of hard linking
-        hardlink_files = false;
-      }
-    }
-    if (!hardlink_files) {
-      status = CopyFile(env_, path_outside_db, path_inside_db, 0,
-                        db_options_.use_fsync);
-    }
-    if (!status.ok()) {
-      break;
-    }
-    f.copy_file = !hardlink_files;
-    f.internal_file_path = path_inside_db;
-  }
-
-  if (!status.ok()) {
-    // We failed, remove all files that we copied into the db
-    for (const auto& f : files_to_import_) {
-      if (f.internal_file_path.empty()) {
-        break;
-      }
-      const auto s = env_->DeleteFile(f.internal_file_path);
-      if (!s.ok()) {
-        ROCKS_LOG_WARN(db_options_.info_log,
-                       "AddFile() clean up for file %s failed : %s",
-                       f.internal_file_path.c_str(), s.ToString().c_str());
-      }
-    }
-  }
-
-  return status;
-}
-
-// REQUIRES: we have become the only writer by entering both write_thread_ and
-// nonmem_write_thread_
-Status ImportColumnFamilyJob::Run() {
-  Status status;
-  edit_.SetColumnFamily(cfd_->GetID());
-
-  for (size_t i = 0; i < files_to_import_.size(); ++i) {
-    const auto& f = files_to_import_[i];
-    const auto& file_metadata = metadata_[i];
-    edit_.AddFile(file_metadata.level, f.fd.GetNumber(), f.fd.GetPathId(),
-                  f.fd.GetFileSize(), f.smallest_internal_key,
-                  f.largest_internal_key, file_metadata.smallest_seqno,
-                  file_metadata.largest_seqno, false);
-
-    // If incoming sequence number is higher, update local sequence number.
-    if (file_metadata.largest_seqno > versions_->LastSequence()) {
-      versions_->SetLastAllocatedSequence(file_metadata.largest_seqno);
-      versions_->SetLastPublishedSequence(file_metadata.largest_seqno);
-      versions_->SetLastSequence(file_metadata.largest_seqno);
-    }
-  }
-
-  return status;
-}
-
-void ImportColumnFamilyJob::Cleanup(const Status& status) {
-  if (!status.ok()) {
-    // We failed to add files to the database remove all the files we copied.
-    for (const auto& f : files_to_import_) {
-      const auto s = env_->DeleteFile(f.internal_file_path);
-      if (!s.ok()) {
-        ROCKS_LOG_WARN(db_options_.info_log,
-                       "AddFile() clean up for file %s failed : %s",
-                       f.internal_file_path.c_str(), s.ToString().c_str());
-      }
-    }
-  } else if (status.ok() && import_options_.move_files) {
-    // The files were moved and added successfully, remove original file links
-    for (IngestedFileInfo& f : files_to_import_) {
-      const auto s = env_->DeleteFile(f.external_file_path);
-      if (!s.ok()) {
-        ROCKS_LOG_WARN(
-            db_options_.info_log,
-            "%s was added to DB successfully but failed to remove original "
-            "file link : %s",
-            f.external_file_path.c_str(), s.ToString().c_str());
-      }
-    }
-  }
-}
-
-Status ImportColumnFamilyJob::GetIngestedFileInfo(
-    const std::string& external_file, IngestedFileInfo* file_to_import,
-    SuperVersion* sv) {
-  file_to_import->external_file_path = external_file;
-
-  // Get external file size
-  auto status = env_->GetFileSize(external_file, &file_to_import->file_size);
-  if (!status.ok()) {
-    return status;
-  }
-
-  // Create TableReader for external file
-  std::unique_ptr<TableReader> table_reader;
-  std::unique_ptr<RandomAccessFile> sst_file;
-  std::unique_ptr<RandomAccessFileReader> sst_file_reader;
-
-  status = env_->NewRandomAccessFile(external_file, &sst_file, env_options_);
-  if (!status.ok()) {
-    return status;
-  }
-  sst_file_reader.reset(new RandomAccessFileReader(std::move(sst_file),
-                                                   external_file));
-
-  status = cfd_->ioptions()->table_factory->NewTableReader(
-      TableReaderOptions(*cfd_->ioptions(),
-                         sv->mutable_cf_options.prefix_extractor.get(),
-                         env_options_, cfd_->internal_comparator()),
-      std::move(sst_file_reader), file_to_import->file_size, &table_reader);
-  if (!status.ok()) {
-    return status;
-  }
-
-  // Get the external file properties
-  auto props = table_reader->GetTableProperties();
-
-  // Set original_seqno to 0.
-  file_to_import->original_seqno = 0;
-
-  // Get number of entries in table
-  file_to_import->num_entries = props->num_entries;
-
-  ParsedInternalKey key;
-  ReadOptions ro;
-  // During reading the external file we can cache blocks that we read into
-  // the block cache, if we later change the global seqno of this file, we will
-  // have block in cache that will include keys with wrong seqno.
-  // We need to disable fill_cache so that we read from the file without
-  // updating the block cache.
-  ro.fill_cache = false;
-  std::unique_ptr<InternalIterator> iter(table_reader->NewIterator(
-      ro, sv->mutable_cf_options.prefix_extractor.get(), /*arena=*/nullptr,
-      /*skip_filters=*/false, TableReaderCaller::kExternalSSTIngestion));
-
-  // Get first (smallest) key from file
-  iter->SeekToFirst();
-  if (!ParseInternalKey(iter->key(), &key)) {
-    return Status::Corruption("external file have corrupted keys");
-  }
-  file_to_import->smallest_internal_key.SetFrom(key);
-
-  // Get last (largest) key from file
-  iter->SeekToLast();
-  if (!ParseInternalKey(iter->key(), &key)) {
-    return Status::Corruption("external file have corrupted keys");
-  }
-  file_to_import->largest_internal_key.SetFrom(key);
-
-  file_to_import->cf_id = static_cast<uint32_t>(props->column_family_id);
-
-  file_to_import->table_properties = *props;
-
-  return status;
-}
-
-}  // namespace rocksdb
-
-#endif  // !ROCKSDB_LITE
@@ -1,70 +0,0 @@
-#pragma once
-#include <string>
-#include <unordered_set>
-#include <vector>
-
-#include "db/column_family.h"
-#include "db/dbformat.h"
-#include "db/external_sst_file_ingestion_job.h"
-#include "db/snapshot_impl.h"
-#include "options/db_options.h"
-#include "rocksdb/db.h"
-#include "rocksdb/env.h"
-#include "rocksdb/metadata.h"
-#include "rocksdb/sst_file_writer.h"
-#include "util/autovector.h"
-
-namespace rocksdb {
-
-// Imports a set of sst files as is into a new column family. Logic is similar
-// to ExternalSstFileIngestionJob.
-class ImportColumnFamilyJob {
- public:
-  ImportColumnFamilyJob(
-      Env* env, VersionSet* versions, ColumnFamilyData* cfd,
-      const ImmutableDBOptions& db_options, const EnvOptions& env_options,
-      const ImportColumnFamilyOptions& import_options,
-      const std::vector<LiveFileMetaData>& metadata)
-      : env_(env),
-        versions_(versions),
-        cfd_(cfd),
-        db_options_(db_options),
-        env_options_(env_options),
-        import_options_(import_options),
-        metadata_(metadata) {}
-
-  // Prepare the job by copying external files into the DB.
-  Status Prepare(uint64_t next_file_number, SuperVersion* sv);
-
-  // Will execute the import job and prepare edit() to be applied.
-  // REQUIRES: Mutex held
-  Status Run();
-
-  // Cleanup after successful/failed job
-  void Cleanup(const Status& status);
-
-  VersionEdit* edit() { return &edit_; }
-
-  const autovector<IngestedFileInfo>& files_to_import() const {
-    return files_to_import_;
-  }
-
- private:
-  // Open the external file and populate `file_to_import` with all the
-  // external information we need to import this file.
-  Status GetIngestedFileInfo(const std::string& external_file,
-                             IngestedFileInfo* file_to_import,
-                             SuperVersion* sv);
-
-  Env* env_;
-  VersionSet* versions_;
-  ColumnFamilyData* cfd_;
-  const ImmutableDBOptions& db_options_;
-  const EnvOptions& env_options_;
-  autovector<IngestedFileInfo> files_to_import_;
-  VersionEdit edit_;
-  const ImportColumnFamilyOptions& import_options_;
-  std::vector<LiveFileMetaData> metadata_;
-};
-
-}  // namespace rocksdb
@@ -1,569 +0,0 @@
-#ifndef ROCKSDB_LITE
-
-#include <functional>
-#include "db/db_test_util.h"
-#include "port/port.h"
-#include "port/stack_trace.h"
-#include "rocksdb/sst_file_writer.h"
-#include "test_util/testutil.h"
-
-namespace rocksdb {
-
-class ImportColumnFamilyTest : public DBTestBase {
- public:
-  ImportColumnFamilyTest() : DBTestBase("/import_column_family_test") {
-    sst_files_dir_ = dbname_ + "/sst_files/";
-    DestroyAndRecreateExternalSSTFilesDir();
-    export_files_dir_ = test::TmpDir(env_) + "/export";
-    import_cfh_ = nullptr;
-    import_cfh2_ = nullptr;
-    metadata_ptr_ = nullptr;
-  }
-
-  ~ImportColumnFamilyTest() {
-    if (import_cfh_) {
-      db_->DropColumnFamily(import_cfh_);
-      db_->DestroyColumnFamilyHandle(import_cfh_);
-      import_cfh_ = nullptr;
-    }
-    if (import_cfh2_) {
-      db_->DropColumnFamily(import_cfh2_);
-      db_->DestroyColumnFamilyHandle(import_cfh2_);
-      import_cfh2_ = nullptr;
-    }
-    if (metadata_ptr_) {
-      delete metadata_ptr_;
-      metadata_ptr_ = nullptr;
-    }
-    test::DestroyDir(env_, sst_files_dir_);
-    test::DestroyDir(env_, export_files_dir_);
-  }
-
-  void DestroyAndRecreateExternalSSTFilesDir() {
-    test::DestroyDir(env_, sst_files_dir_);
-    env_->CreateDir(sst_files_dir_);
-    test::DestroyDir(env_, export_files_dir_);
-  }
-
-  LiveFileMetaData LiveFileMetaDataInit(std::string name,
-                                        std::string path,
-                                        int level,
-                                        SequenceNumber smallest_seqno,
-                                        SequenceNumber largest_seqno) {
-    LiveFileMetaData metadata;
-    metadata.name = name;
-    metadata.db_path = path;
-    metadata.smallest_seqno = smallest_seqno;
-    metadata.largest_seqno = largest_seqno;
-    metadata.level = level;
-    return metadata;
-  }
-
- protected:
-  std::string sst_files_dir_;
-  std::string export_files_dir_;
-  ColumnFamilyHandle* import_cfh_;
-  ColumnFamilyHandle* import_cfh2_;
-  ExportImportFilesMetaData *metadata_ptr_;
-};
-
-TEST_F(ImportColumnFamilyTest, ImportSSTFileWriterFiles) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"koko"}, options);
-
-  SstFileWriter sfw_cf1(EnvOptions(), options, handles_[1]);
-  SstFileWriter sfw_unknown(EnvOptions(), options);
-
-  // cf1.sst
-  const std::string cf1_sst_name = "cf1.sst";
-  const std::string cf1_sst = sst_files_dir_ + cf1_sst_name;
-  ASSERT_OK(sfw_cf1.Open(cf1_sst));
-  ASSERT_OK(sfw_cf1.Put("K1", "V1"));
-  ASSERT_OK(sfw_cf1.Put("K2", "V2"));
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // cf_unknown.sst
-  const std::string unknown_sst_name = "cf_unknown.sst";
-  const std::string unknown_sst = sst_files_dir_ + unknown_sst_name;
-  ASSERT_OK(sfw_unknown.Open(unknown_sst));
-  ASSERT_OK(sfw_unknown.Put("K3", "V1"));
-  ASSERT_OK(sfw_unknown.Put("K4", "V2"));
-  ASSERT_OK(sfw_unknown.Finish());
-
-  {
-    // Import sst file corresponding to cf1 onto a new cf and verify
-    ExportImportFilesMetaData metadata;
-    metadata.files.push_back(
-        LiveFileMetaDataInit(cf1_sst_name, sst_files_dir_, 0, 10, 19));
-    metadata.db_comparator_name = options.comparator->Name();
-
-    ASSERT_OK(db_->CreateColumnFamilyWithImport(
-        options, "toto", ImportColumnFamilyOptions(), metadata, &import_cfh_));
-    ASSERT_NE(import_cfh_, nullptr);
-
-    std::string value;
-    db_->Get(ReadOptions(), import_cfh_, "K1", &value);
-    ASSERT_EQ(value, "V1");
-    db_->Get(ReadOptions(), import_cfh_, "K2", &value);
-    ASSERT_EQ(value, "V2");
-    ASSERT_OK(db_->DropColumnFamily(import_cfh_));
-    ASSERT_OK(db_->DestroyColumnFamilyHandle(import_cfh_));
-    import_cfh_ = nullptr;
-  }
-
-  {
-    // Import sst file corresponding to unknown cf onto a new cf and verify
-    ExportImportFilesMetaData metadata;
-    metadata.files.push_back(
-        LiveFileMetaDataInit(unknown_sst_name, sst_files_dir_, 0, 20, 29));
-    metadata.db_comparator_name = options.comparator->Name();
-
-    ASSERT_OK(db_->CreateColumnFamilyWithImport(
-        options, "yoyo", ImportColumnFamilyOptions(), metadata, &import_cfh_));
-    ASSERT_NE(import_cfh_, nullptr);
-
-    std::string value;
-    db_->Get(ReadOptions(), import_cfh_, "K3", &value);
-    ASSERT_EQ(value, "V1");
-    db_->Get(ReadOptions(), import_cfh_, "K4", &value);
-    ASSERT_EQ(value, "V2");
-  }
-}
-
-TEST_F(ImportColumnFamilyTest, ImportSSTFileWriterFilesWithOverlap) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"koko"}, options);
-
-  SstFileWriter sfw_cf1(EnvOptions(), options, handles_[1]);
-
-  // file3.sst
-  const std::string file3_sst_name = "file3.sst";
-  const std::string file3_sst = sst_files_dir_ + file3_sst_name;
-  ASSERT_OK(sfw_cf1.Open(file3_sst));
-  for (int i = 0; i < 100; ++i) {
-    sfw_cf1.Put(Key(i), Key(i) + "_val");
-  }
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // file2.sst
-  const std::string file2_sst_name = "file2.sst";
-  const std::string file2_sst = sst_files_dir_ + file2_sst_name;
-  ASSERT_OK(sfw_cf1.Open(file2_sst));
-  for (int i = 0; i < 100; i += 2) {
-    sfw_cf1.Put(Key(i), Key(i) + "_overwrite1");
-  }
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // file1a.sst
-  const std::string file1a_sst_name = "file1a.sst";
-  const std::string file1a_sst = sst_files_dir_ + file1a_sst_name;
-  ASSERT_OK(sfw_cf1.Open(file1a_sst));
-  for (int i = 0; i < 52; i += 4) {
-    sfw_cf1.Put(Key(i), Key(i) + "_overwrite2");
-  }
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // file1b.sst
-  const std::string file1b_sst_name = "file1b.sst";
-  const std::string file1b_sst = sst_files_dir_ + file1b_sst_name;
-  ASSERT_OK(sfw_cf1.Open(file1b_sst));
-  for (int i = 52; i < 100; i += 4) {
-    sfw_cf1.Put(Key(i), Key(i) + "_overwrite2");
-  }
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // file0a.sst
-  const std::string file0a_sst_name = "file0a.sst";
-  const std::string file0a_sst = sst_files_dir_ + file0a_sst_name;
-  ASSERT_OK(sfw_cf1.Open(file0a_sst));
-  for (int i = 0; i < 100; i += 16) {
-    sfw_cf1.Put(Key(i), Key(i) + "_overwrite3");
-  }
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // file0b.sst
-  const std::string file0b_sst_name = "file0b.sst";
-  const std::string file0b_sst = sst_files_dir_ + file0b_sst_name;
-  ASSERT_OK(sfw_cf1.Open(file0b_sst));
-  for (int i = 0; i < 100; i += 16) {
-    sfw_cf1.Put(Key(i), Key(i) + "_overwrite4");
-  }
-  ASSERT_OK(sfw_cf1.Finish());
-
-  // Import sst files and verify
-  ExportImportFilesMetaData metadata;
-  metadata.files.push_back(
-      LiveFileMetaDataInit(file3_sst_name, sst_files_dir_, 3, 10, 19));
-  metadata.files.push_back(
-      LiveFileMetaDataInit(file2_sst_name, sst_files_dir_, 2, 20, 29));
-  metadata.files.push_back(
-      LiveFileMetaDataInit(file1a_sst_name, sst_files_dir_, 1, 30, 34));
-  metadata.files.push_back(
-      LiveFileMetaDataInit(file1b_sst_name, sst_files_dir_, 1, 35, 39));
-  metadata.files.push_back(
-      LiveFileMetaDataInit(file0a_sst_name, sst_files_dir_, 0, 40, 49));
-  metadata.files.push_back(
-      LiveFileMetaDataInit(file0b_sst_name, sst_files_dir_, 0, 50, 59));
-  metadata.db_comparator_name = options.comparator->Name();
-
-  ASSERT_OK(db_->CreateColumnFamilyWithImport(
-      options, "toto", ImportColumnFamilyOptions(), metadata, &import_cfh_));
-  ASSERT_NE(import_cfh_, nullptr);
-
-  for (int i = 0; i < 100; i++) {
-    std::string value;
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value);
-    if (i % 16 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite4");
-    } else if (i % 4 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite2");
-    } else if (i % 2 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite1");
-    } else {
-      ASSERT_EQ(value, Key(i) + "_val");
-    }
-  }
-
-  for (int i = 0; i < 100; i += 5) {
-    ASSERT_OK(
-        db_->Put(WriteOptions(), import_cfh_, Key(i), Key(i) + "_overwrite5"));
-  }
-
-  // Flush and check again
-  ASSERT_OK(db_->Flush(FlushOptions(), import_cfh_));
-  for (int i = 0; i < 100; i++) {
-    std::string value;
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value);
-    if (i % 5 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite5");
-    } else if (i % 16 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite4");
-    } else if (i % 4 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite2");
-    } else if (i % 2 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite1");
-    } else {
-      ASSERT_EQ(value, Key(i) + "_val");
-    }
-  }
-
-  // Compact and check again.
-  ASSERT_OK(
-      db_->CompactRange(CompactRangeOptions(), import_cfh_, nullptr, nullptr));
-  for (int i = 0; i < 100; i++) {
-    std::string value;
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value);
-    if (i % 5 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite5");
-    } else if (i % 16 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite4");
-    } else if (i % 4 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite2");
-    } else if (i % 2 == 0) {
-      ASSERT_EQ(value, Key(i) + "_overwrite1");
-    } else {
-      ASSERT_EQ(value, Key(i) + "_val");
-    }
-  }
-}
-
-TEST_F(ImportColumnFamilyTest, ImportExportedSSTFromAnotherCF) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"koko"}, options);
-
-  for (int i = 0; i < 100; ++i) {
-    Put(1, Key(i), Key(i) + "_val");
-  }
-  ASSERT_OK(Flush(1));
-
-  ASSERT_OK(
-      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr));
-
-  // Overwrite the value in the same set of keys.
-  for (int i = 0; i < 100; ++i) {
-    Put(1, Key(i), Key(i) + "_overwrite");
-  }
-
-  // Flush to create L0 file.
-  ASSERT_OK(Flush(1));
-  for (int i = 0; i < 100; ++i) {
-    Put(1, Key(i), Key(i) + "_overwrite2");
-  }
-
-  // Flush again to create another L0 file. It should have higher sequencer.
-  ASSERT_OK(Flush(1));
-
-  Checkpoint* checkpoint;
-  ASSERT_OK(Checkpoint::Create(db_, &checkpoint));
-  ASSERT_OK(checkpoint->ExportColumnFamily(handles_[1], export_files_dir_,
-                                           &metadata_ptr_));
-  ASSERT_NE(metadata_ptr_, nullptr);
-  delete checkpoint;
-
-  ImportColumnFamilyOptions import_options;
-  import_options.move_files = false;
-  ASSERT_OK(db_->CreateColumnFamilyWithImport(options, "toto", import_options,
-                                              *metadata_ptr_, &import_cfh_));
-  ASSERT_NE(import_cfh_, nullptr);
-
-  import_options.move_files = true;
-  ASSERT_OK(db_->CreateColumnFamilyWithImport(options, "yoyo", import_options,
-                                              *metadata_ptr_, &import_cfh2_));
-  ASSERT_NE(import_cfh2_, nullptr);
-  delete metadata_ptr_;
-  metadata_ptr_ = NULL;
-
-  std::string value1, value2;
-
-  for (int i = 0; i < 100; ++i) {
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value1);
-    ASSERT_EQ(Get(1, Key(i)), value1);
-  }
-
-  for (int i = 0; i < 100; ++i) {
-    db_->Get(ReadOptions(), import_cfh2_, Key(i), &value2);
-    ASSERT_EQ(Get(1, Key(i)), value2);
-  }
-
-  // Modify keys in cf1 and verify.
-  for (int i = 0; i < 25; i++) {
-    ASSERT_OK(db_->Delete(WriteOptions(), import_cfh_, Key(i)));
-  }
-  for (int i = 25; i < 50; i++) {
-    ASSERT_OK(
-        db_->Put(WriteOptions(), import_cfh_, Key(i), Key(i) + "_overwrite3"));
-  }
-  for (int i = 0; i < 25; ++i) {
-    ASSERT_TRUE(
-        db_->Get(ReadOptions(), import_cfh_, Key(i), &value1).IsNotFound());
-  }
-  for (int i = 25; i < 50; ++i) {
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value1);
-    ASSERT_EQ(Key(i) + "_overwrite3", value1);
-  }
-  for (int i = 50; i < 100; ++i) {
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value1);
-    ASSERT_EQ(Key(i) + "_overwrite2", value1);
-  }
-
-  for (int i = 0; i < 100; ++i) {
-    db_->Get(ReadOptions(), import_cfh2_, Key(i), &value2);
-    ASSERT_EQ(Get(1, Key(i)), value2);
-  }
-
-  // Compact and check again.
-  ASSERT_OK(db_->Flush(FlushOptions(), import_cfh_));
-  ASSERT_OK(
-      db_->CompactRange(CompactRangeOptions(), import_cfh_, nullptr, nullptr));
-
-  for (int i = 0; i < 25; ++i) {
-    ASSERT_TRUE(
-        db_->Get(ReadOptions(), import_cfh_, Key(i), &value1).IsNotFound());
-  }
-  for (int i = 25; i < 50; ++i) {
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value1);
-    ASSERT_EQ(Key(i) + "_overwrite3", value1);
-  }
-  for (int i = 50; i < 100; ++i) {
-    db_->Get(ReadOptions(), import_cfh_, Key(i), &value1);
-    ASSERT_EQ(Key(i) + "_overwrite2", value1);
-  }
-
-  for (int i = 0; i < 100; ++i) {
-    db_->Get(ReadOptions(), import_cfh2_, Key(i), &value2);
-    ASSERT_EQ(Get(1, Key(i)), value2);
-  }
-}
-
-TEST_F(ImportColumnFamilyTest, ImportExportedSSTFromAnotherDB) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"koko"}, options);
-
-  for (int i = 0; i < 100; ++i) {
-    Put(1, Key(i), Key(i) + "_val");
-  }
-  ASSERT_OK(Flush(1));
-
-  // Compact to create a L1 file.
-  ASSERT_OK(
-      db_->CompactRange(CompactRangeOptions(), handles_[1], nullptr, nullptr));
-
-  // Overwrite the value in the same set of keys.
-  for (int i = 0; i < 50; ++i) {
-    Put(1, Key(i), Key(i) + "_overwrite");
-  }
-
-  // Flush to create L0 file.
-  ASSERT_OK(Flush(1));
-
-  for (int i = 0; i < 25; ++i) {
-    Put(1, Key(i), Key(i) + "_overwrite2");
-  }
-
-  // Flush again to create another L0 file. It should have higher sequencer.
-  ASSERT_OK(Flush(1));
-
-  Checkpoint* checkpoint;
-  ASSERT_OK(Checkpoint::Create(db_, &checkpoint));
-  ASSERT_OK(checkpoint->ExportColumnFamily(handles_[1], export_files_dir_,
-                                           &metadata_ptr_));
-  ASSERT_NE(metadata_ptr_, nullptr);
-  delete checkpoint;
-
-  // Create a new db and import the files.
-  DB* db_copy;
-  test::DestroyDir(env_, dbname_ + "/db_copy");
-  ASSERT_OK(DB::Open(options, dbname_ + "/db_copy", &db_copy));
-  ColumnFamilyHandle* cfh = nullptr;
-  ASSERT_OK(db_copy->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                                  ImportColumnFamilyOptions(),
-                                                  *metadata_ptr_, &cfh));
-  ASSERT_NE(cfh, nullptr);
-
-  for (int i = 0; i < 100; ++i) {
-    std::string value;
-    db_copy->Get(ReadOptions(), cfh, Key(i), &value);
-    ASSERT_EQ(Get(1, Key(i)), value);
-  }
-  db_copy->DropColumnFamily(cfh);
-  db_copy->DestroyColumnFamilyHandle(cfh);
-  delete db_copy;
-  test::DestroyDir(env_, dbname_ + "/db_copy");
-}
-
-TEST_F(ImportColumnFamilyTest, ImportColumnFamilyNegativeTest) {
-  Options options = CurrentOptions();
-  CreateAndReopenWithCF({"koko"}, options);
-
-  {
-    // Create column family with existing cf name.
-    ExportImportFilesMetaData metadata;
-
-    ASSERT_EQ(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "koko",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_),
-              Status::InvalidArgument("Column family already exists"));
-    ASSERT_EQ(import_cfh_, nullptr);
-  }
-
-  {
-    // Import with no files specified.
-    ExportImportFilesMetaData metadata;
-
-    ASSERT_EQ(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_),
-              Status::InvalidArgument("The list of files is empty"));
-    ASSERT_EQ(import_cfh_, nullptr);
-  }
-
-  {
-    // Import with overlapping keys in sst files.
-    ExportImportFilesMetaData metadata;
-    SstFileWriter sfw_cf1(EnvOptions(), options, handles_[1]);
-    const std::string file1_sst_name = "file1.sst";
-    const std::string file1_sst = sst_files_dir_ + file1_sst_name;
-    ASSERT_OK(sfw_cf1.Open(file1_sst));
-    ASSERT_OK(sfw_cf1.Put("K1", "V1"));
-    ASSERT_OK(sfw_cf1.Put("K2", "V2"));
-    ASSERT_OK(sfw_cf1.Finish());
-    const std::string file2_sst_name = "file2.sst";
-    const std::string file2_sst = sst_files_dir_ + file2_sst_name;
-    ASSERT_OK(sfw_cf1.Open(file2_sst));
-    ASSERT_OK(sfw_cf1.Put("K2", "V2"));
-    ASSERT_OK(sfw_cf1.Put("K3", "V3"));
-    ASSERT_OK(sfw_cf1.Finish());
-
-    metadata.files.push_back(
-        LiveFileMetaDataInit(file1_sst_name, sst_files_dir_, 1, 10, 19));
-    metadata.files.push_back(
-        LiveFileMetaDataInit(file2_sst_name, sst_files_dir_, 1, 10, 19));
-    metadata.db_comparator_name = options.comparator->Name();
-
-    ASSERT_EQ(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_),
-              Status::InvalidArgument("Files have overlapping ranges"));
-    ASSERT_EQ(import_cfh_, nullptr);
-  }
-
-  {
-    // Import with a mismatching comparator, should fail with appropriate error.
-    ExportImportFilesMetaData metadata;
-    Options mismatch_options = CurrentOptions();
-    mismatch_options.comparator = ReverseBytewiseComparator();
-    SstFileWriter sfw_cf1(EnvOptions(), mismatch_options, handles_[1]);
-    const std::string file1_sst_name = "file1.sst";
-    const std::string file1_sst = sst_files_dir_ + file1_sst_name;
-    ASSERT_OK(sfw_cf1.Open(file1_sst));
-    ASSERT_OK(sfw_cf1.Put("K2", "V2"));
-    ASSERT_OK(sfw_cf1.Put("K1", "V1"));
-    ASSERT_OK(sfw_cf1.Finish());
-
-    metadata.files.push_back(
-        LiveFileMetaDataInit(file1_sst_name, sst_files_dir_, 1, 10, 19));
-    metadata.db_comparator_name = mismatch_options.comparator->Name();
-
-    ASSERT_EQ(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "coco",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_),
-              Status::InvalidArgument("Comparator name mismatch"));
-    ASSERT_EQ(import_cfh_, nullptr);
-  }
-
-  {
-    // Import with non existent sst file should fail with appropriate error
-    ExportImportFilesMetaData metadata;
-    SstFileWriter sfw_cf1(EnvOptions(), options, handles_[1]);
-    const std::string file1_sst_name = "file1.sst";
-    const std::string file1_sst = sst_files_dir_ + file1_sst_name;
-    ASSERT_OK(sfw_cf1.Open(file1_sst));
-    ASSERT_OK(sfw_cf1.Put("K1", "V1"));
-    ASSERT_OK(sfw_cf1.Put("K2", "V2"));
-    ASSERT_OK(sfw_cf1.Finish());
-    const std::string file3_sst_name = "file3.sst";
-
-    metadata.files.push_back(
-        LiveFileMetaDataInit(file1_sst_name, sst_files_dir_, 1, 10, 19));
-    metadata.files.push_back(
-        LiveFileMetaDataInit(file3_sst_name, sst_files_dir_, 1, 10, 19));
-    metadata.db_comparator_name = options.comparator->Name();
-
-    ASSERT_EQ(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_),
-              Status::IOError("No such file or directory"));
-    ASSERT_EQ(import_cfh_, nullptr);
-
-    // Test successful import after a failure with the same CF name. Ensures
-    // there is no side effect with CF when there is a failed import
-    metadata.files.pop_back();
-    metadata.db_comparator_name = options.comparator->Name();
-
-    ASSERT_OK(db_->CreateColumnFamilyWithImport(ColumnFamilyOptions(), "yoyo",
-                                                ImportColumnFamilyOptions(),
-                                                metadata, &import_cfh_));
-    ASSERT_NE(import_cfh_, nullptr);
-  }
-
-}
-
-}  // namespace rocksdb
-
-int main(int argc, char** argv) {
-  rocksdb::port::InstallStackTraceHandler();
-  ::testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}
-
-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr,
-          "SKIPPED as External SST File Writer and Import are not supported "
-          "in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE
@@ -954,17 +954,14 @@ void InternalStats::DumpDBStats(std::string* value) {
           seconds_up, interval_seconds_up);
  value->append(buf);
  // Cumulative
-  uint64_t user_bytes_written =
-      GetDBStats(InternalStats::kIntStatsBytesWritten);
-  uint64_t num_keys_written =
-      GetDBStats(InternalStats::kIntStatsNumKeysWritten);
-  uint64_t write_other = GetDBStats(InternalStats::kIntStatsWriteDoneByOther);
-  uint64_t write_self = GetDBStats(InternalStats::kIntStatsWriteDoneBySelf);
-  uint64_t wal_bytes = GetDBStats(InternalStats::kIntStatsWalFileBytes);
-  uint64_t wal_synced = GetDBStats(InternalStats::kIntStatsWalFileSynced);
-  uint64_t write_with_wal = GetDBStats(InternalStats::kIntStatsWriteWithWal);
-  uint64_t write_stall_micros =
-      GetDBStats(InternalStats::kIntStatsWriteStallMicros);
+  uint64_t user_bytes_written = GetDBStats(InternalStats::BYTES_WRITTEN);
+  uint64_t num_keys_written = GetDBStats(InternalStats::NUMBER_KEYS_WRITTEN);
+  uint64_t write_other = GetDBStats(InternalStats::WRITE_DONE_BY_OTHER);
+  uint64_t write_self = GetDBStats(InternalStats::WRITE_DONE_BY_SELF);
+  uint64_t wal_bytes = GetDBStats(InternalStats::WAL_FILE_BYTES);
+  uint64_t wal_synced = GetDBStats(InternalStats::WAL_FILE_SYNCED);
+  uint64_t write_with_wal = GetDBStats(InternalStats::WRITE_WITH_WAL);
+  uint64_t write_stall_micros = GetDBStats(InternalStats::WRITE_STALL_MICROS);

  const int kHumanMicrosLen = 32;
  char human_micros[kHumanMicrosLen];
@@ -109,15 +109,15 @@ class InternalStats {
  };

  enum InternalDBStatsType {
-    kIntStatsWalFileBytes,
-    kIntStatsWalFileSynced,
-    kIntStatsBytesWritten,
-    kIntStatsNumKeysWritten,
-    kIntStatsWriteDoneByOther,
-    kIntStatsWriteDoneBySelf,
-    kIntStatsWriteWithWal,
-    kIntStatsWriteStallMicros,
-    kIntStatsNumMax,
+    WAL_FILE_BYTES,
+    WAL_FILE_SYNCED,
+    BYTES_WRITTEN,
+    NUMBER_KEYS_WRITTEN,
+    WRITE_DONE_BY_OTHER,
+    WRITE_DONE_BY_SELF,
+    WRITE_WITH_WAL,
+    WRITE_STALL_MICROS,
+    INTERNAL_DB_STATS_ENUM_MAX,
  };

  InternalStats(int num_levels, Env* env, ColumnFamilyData* cfd)
@@ -237,28 +237,6 @@ class InternalStats {
      }
    }

-    CompactionStats& operator=(const CompactionStats& c) {
-      micros = c.micros;
-      cpu_micros = c.cpu_micros;
-      bytes_read_non_output_levels = c.bytes_read_non_output_levels;
-      bytes_read_output_level = c.bytes_read_output_level;
-      bytes_written = c.bytes_written;
-      bytes_moved = c.bytes_moved;
-      num_input_files_in_non_output_levels =
-          c.num_input_files_in_non_output_levels;
-      num_input_files_in_output_level = c.num_input_files_in_output_level;
-      num_output_files = c.num_output_files;
-      num_input_records = c.num_input_records;
-      num_dropped_records = c.num_dropped_records;
-      count = c.count;
-
-      int num_of_reasons = static_cast<int>(CompactionReason::kNumOfReasons);
-      for (int i = 0; i < num_of_reasons; i++) {
-        counts[i] = c.counts[i];
-      }
-      return *this;
-    }
-
    void Clear() {
      this->micros = 0;
      this->cpu_micros = 0;
@@ -322,7 +300,7 @@ class InternalStats {
  };

  void Clear() {
-    for (int i = 0; i < kIntStatsNumMax; i++) {
+    for (int i = 0; i < INTERNAL_DB_STATS_ENUM_MAX; i++) {
      db_stats_[i].store(0);
    }
    for (int i = 0; i < INTERNAL_CF_STATS_ENUM_MAX; i++) {
@@ -416,7 +394,7 @@ class InternalStats {
  bool HandleBlockCacheStat(Cache** block_cache);

  // Per-DB stats
-  std::atomic<uint64_t> db_stats_[kIntStatsNumMax];
+  std::atomic<uint64_t> db_stats_[INTERNAL_DB_STATS_ENUM_MAX];
  // Per-ColumnFamily stats
  uint64_t cf_stats_value_[INTERNAL_CF_STATS_ENUM_MAX];
  uint64_t cf_stats_count_[INTERNAL_CF_STATS_ENUM_MAX];
@@ -615,15 +593,15 @@ class InternalStats {
  };

  enum InternalDBStatsType {
-    kIntStatsWalFileBytes,
-    kIntStatsWalFileSynced,
-    kIntStatsBytesWritten,
-    kIntStatsNumKeysWritten,
-    kIntStatsWriteDoneByOther,
-    kIntStatsWriteDoneBySelf,
-    kIntStatsWriteWithWal,
-    kIntStatsWriteStallMicros,
-    kIntStatsNumMax,
+    WAL_FILE_BYTES,
+    WAL_FILE_SYNCED,
+    BYTES_WRITTEN,
+    NUMBER_KEYS_WRITTEN,
+    WRITE_DONE_BY_OTHER,
+    WRITE_DONE_BY_SELF,
+    WRITE_WITH_WAL,
+    WRITE_STALL_MICROS,
+    INTERNAL_DB_STATS_ENUM_MAX,
  };

  InternalStats(int /*num_levels*/, Env* /*env*/, ColumnFamilyData* /*cfd*/) {}
@@ -53,9 +53,6 @@ class Reader {
         // @lint-ignore TXT2 T25377293 Grandfathered in
         std::unique_ptr<SequentialFileReader>&& file, Reporter* reporter,
         bool checksum, uint64_t log_num);
-  // No copying allowed
-  Reader(const Reader&) = delete;
-  void operator=(const Reader&) = delete;

  virtual ~Reader();

@@ -151,6 +148,11 @@ class Reader {
  // buffer_ must be updated to remove the dropped bytes prior to invocation.
  void ReportCorruption(size_t bytes, const char* reason);
  void ReportDrop(size_t bytes, const Status& reason);
+
+ private:
+  // No copying allowed
+  Reader(const Reader&);
+  void operator=(const Reader&);
 };

 class FragmentBufferedReader : public Reader {
@@ -73,10 +73,6 @@ class Writer {
  explicit Writer(std::unique_ptr<WritableFileWriter>&& dest,
                  uint64_t log_number, bool recycle_log_files,
                  bool manual_flush = false);
-  // No copying allowed
-  Writer(const Writer&) = delete;
-  void operator=(const Writer&) = delete;
-
  ~Writer();

  Status AddRecord(const Slice& slice);
@@ -108,6 +104,10 @@ class Writer {
  // If true, it does not flush after each write. Instead it relies on the upper
  // layer to manually does the flush by calling ::WriteBuffer()
  bool manual_flush_;
+
+  // No copying allowed
+  Writer(const Writer&);
+  void operator=(const Writer&);
 };

 }  // namespace log
@@ -21,8 +21,7 @@ class LookupKey {
 public:
  // Initialize *this for looking up user_key at a snapshot with
  // the specified sequence number.
-  LookupKey(const Slice& _user_key, SequenceNumber sequence,
-            const Slice* ts = nullptr);
+  LookupKey(const Slice& _user_key, SequenceNumber sequence);

  ~LookupKey();

@@ -20,6 +20,10 @@ namespace rocksdb {

 #ifdef ROCKSDB_JEMALLOC

+#ifdef JEMALLOC_NO_RENAME
+#define malloc_stats_print je_malloc_stats_print
+#endif
+
 typedef struct {
  char* cur;
  char* end;
@@ -105,8 +105,7 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
      insert_with_hint_prefix_extractor_(
          ioptions.memtable_insert_with_hint_prefix_extractor),
      oldest_key_time_(std::numeric_limits<uint64_t>::max()),
-      atomic_flush_seqno_(kMaxSequenceNumber),
-      approximate_memory_usage_(0) {
+      atomic_flush_seqno_(kMaxSequenceNumber) {
  UpdateFlushState();
  // something went wrong if we need to flush before inserting anything
  assert(!ShouldScheduleFlush());
@@ -116,7 +115,7 @@ MemTable::MemTable(const InternalKeyComparator& cmp,
      moptions_.memtable_prefix_bloom_bits > 0) {
    bloom_filter_.reset(
        new DynamicBloom(&arena_, moptions_.memtable_prefix_bloom_bits,
-                         6 /* hard coded 6 probes */,
+                         ioptions.bloom_locality, 6 /* hard coded 6 probes */,
                         moptions_.memtable_huge_page_size, ioptions.info_log));
  }
 }
@@ -140,12 +139,11 @@ size_t MemTable::ApproximateMemoryUsage() {
    }
    total_usage += usage;
  }
-  approximate_memory_usage_.store(total_usage, std::memory_order_relaxed);
  // otherwise, return the actual usage
  return total_usage;
 }

-bool MemTable::ShouldFlushNow() {
+bool MemTable::ShouldFlushNow() const {
  size_t write_buffer_size = write_buffer_size_.load(std::memory_order_relaxed);
  // In a lot of times, we cannot allocate arena blocks that exactly matches the
  // buffer size. Thus we have to decide if we should over-allocate or
@@ -161,8 +159,6 @@ bool MemTable::ShouldFlushNow() {
                          range_del_table_->ApproximateMemoryUsage() +
                          arena_.MemoryAllocatedBytes();

-  approximate_memory_usage_.store(allocated_memory, std::memory_order_relaxed);
-
  // if we can still allocate one more block without exceeding the
  // over-allocation ratio, then we should not flush.
  if (allocated_memory + kArenaBlockSize <
@@ -295,9 +291,6 @@ class MemTableIterator : public InternalIterator {
      iter_ = mem.table_->GetIterator(arena);
    }
  }
-  // No copying allowed
-  MemTableIterator(const MemTableIterator&) = delete;
-  void operator=(const MemTableIterator&) = delete;

  ~MemTableIterator() override {
 #ifndef NDEBUG
@@ -411,6 +404,10 @@ class MemTableIterator : public InternalIterator {
  bool valid_;
  bool arena_mode_;
  bool value_pinned_;
+
+  // No copying allowed
+  MemTableIterator(const MemTableIterator&);
+  void operator=(const MemTableIterator&);
 };

 InternalIterator* MemTable::NewIterator(const ReadOptions& read_options,
@@ -469,7 +466,7 @@ MemTable::MemTableStats MemTable::ApproximateStats(const Slice& start_ikey,
 bool MemTable::Add(SequenceNumber s, ValueType type,
                   const Slice& key, /* user key */
                   const Slice& value, bool allow_concurrent,
-                   MemTablePostProcessInfo* post_process_info, void** hint) {
+                   MemTablePostProcessInfo* post_process_info) {
  // Format of an entry is concatenation of:
  //  key_size     : varint32 of internal_key.size()
  //  key bytes    : char[internal_key.size()]
@@ -547,9 +544,7 @@ bool MemTable::Add(SequenceNumber s, ValueType type,
    assert(post_process_info == nullptr);
    UpdateFlushState();
  } else {
-    bool res = (hint == nullptr)
-                   ? table->InsertKeyConcurrently(handle)
-                   : table->InsertKeyWithHintConcurrently(handle, hint);
+    bool res = table->InsertKeyConcurrently(handle);
    if (UNLIKELY(!res)) {
      return res;
    }
@@ -606,7 +601,6 @@ struct Saver {
  Logger* logger;
  Statistics* statistics;
  bool inplace_update_support;
-  bool do_merge;
  Env* env_;
  ReadCallback* callback_;
  bool* is_blob_index;
@@ -633,7 +627,7 @@ static bool SaveValue(void* arg, const char* entry) {
  //    klength  varint32
  //    userkey  char[klength-8]
  //    tag      uint64
-  //    vlength  varint32f
+  //    vlength  varint32
  //    value    char[vlength]
  // Check that it belongs to same user key.  We do not check the
  // sequence number since the Seek() call above should have skipped
@@ -683,24 +677,12 @@ static bool SaveValue(void* arg, const char* entry) {
        Slice v = GetLengthPrefixedSlice(key_ptr + key_length);
        *(s->status) = Status::OK();
        if (*(s->merge_in_progress)) {
-          if (s->do_merge) {
-            if (s->value != nullptr) {
-              *(s->status) = MergeHelper::TimedFullMerge(
-                  merge_operator, s->key->user_key(), &v,
-                  merge_context->GetOperands(), s->value, s->logger,
-                  s->statistics, s->env_, nullptr /* result_operand */, true);
-            }
-          } else {
-            // Preserve the value with the goal of returning it as part of
-            // raw merge operands to the user
-            merge_context->PushOperand(
-                v, s->inplace_update_support == false /* operand_pinned */);
+          if (s->value != nullptr) {
+            *(s->status) = MergeHelper::TimedFullMerge(
+                merge_operator, s->key->user_key(), &v,
+                merge_context->GetOperands(), s->value, s->logger,
+                s->statistics, s->env_, nullptr /* result_operand */, true);
          }
-        } else if (!s->do_merge) {
-          // Preserve the value with the goal of returning it as part of
-          // raw merge operands to the user
-          merge_context->PushOperand(
-              v, s->inplace_update_support == false /* operand_pinned */);
        } else if (s->value != nullptr) {
          s->value->assign(v.data(), v.size());
        }
@@ -744,8 +726,7 @@ static bool SaveValue(void* arg, const char* entry) {
        *(s->merge_in_progress) = true;
        merge_context->PushOperand(
            v, s->inplace_update_support == false /* operand_pinned */);
-        if (s->do_merge && merge_operator->ShouldMerge(
-                               merge_context->GetOperandsDirectionBackward())) {
+        if (merge_operator->ShouldMerge(merge_context->GetOperandsDirectionBackward())) {
          *(s->status) = MergeHelper::TimedFullMerge(
              merge_operator, s->key->user_key(), nullptr,
              merge_context->GetOperands(), s->value, s->logger, s->statistics,
@@ -769,7 +750,7 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
                   MergeContext* merge_context,
                   SequenceNumber* max_covering_tombstone_seq,
                   SequenceNumber* seq, const ReadOptions& read_opts,
-                   ReadCallback* callback, bool* is_blob_index, bool do_merge) {
+                   ReadCallback* callback, bool* is_blob_index) {
  // The sequence number is updated synchronously in version_set.h
  if (IsEmpty()) {
    // Avoiding recording stats for speed.
@@ -829,8 +810,8 @@ bool MemTable::Get(const LookupKey& key, std::string* value, Status* s,
    saver.env_ = env_;
    saver.callback_ = callback;
    saver.is_blob_index = is_blob_index;
-    saver.do_merge = do_merge;
    table_->Get(key, &saver, SaveValue);
+
    *seq = saver.seq;
  }

@@ -101,9 +101,6 @@ class MemTable {
                    const MutableCFOptions& mutable_cf_options,
                    WriteBufferManager* write_buffer_manager,
                    SequenceNumber earliest_seq, uint32_t column_family_id);
-  // No copying allowed
-  MemTable(const MemTable&) = delete;
-  MemTable& operator=(const MemTable&) = delete;

  // Do not delete this MemTable unless Unref() indicates it not in use.
  ~MemTable();
@@ -133,12 +130,6 @@ class MemTable {
  // operations on the same MemTable (unless this Memtable is immutable).
  size_t ApproximateMemoryUsage();

-  // As a cheap version of `ApproximateMemoryUsage()`, this function doens't
-  // require external synchronization. The value may be less accurate though
-  size_t ApproximateMemoryUsageFast() const {
-    return approximate_memory_usage_.load(std::memory_order_relaxed);
-  }
-
  // This method heuristically determines if the memtable should continue to
  // host more data.
  bool ShouldScheduleFlush() const {
@@ -182,13 +173,8 @@ class MemTable {
  // the <key, seq> already exists.
  bool Add(SequenceNumber seq, ValueType type, const Slice& key,
           const Slice& value, bool allow_concurrent = false,
-           MemTablePostProcessInfo* post_process_info = nullptr,
-           void** hint = nullptr);
+           MemTablePostProcessInfo* post_process_info = nullptr);

-  // Used to Get value associated with key or Get Merge Operands associated
-  // with key.
-  // If do_merge = true the default behavior which is Get value for key is
-  // executed. Expected behavior is described right below.
  // If memtable contains a value for key, store it in *value and return true.
  // If memtable contains a deletion for key, store a NotFound() error
  // in *status and return true.
@@ -202,23 +188,20 @@ class MemTable {
  // returned).  Otherwise, *seq will be set to kMaxSequenceNumber.
  // On success, *s may be set to OK, NotFound, or MergeInProgress.  Any other
  // status returned indicates a corruption or other unexpected error.
-  // If do_merge = false then any Merge Operands encountered for key are simply
-  // stored in merge_context.operands_list and never actually merged to get a
-  // final value. The raw Merge Operands are eventually returned to the user.
  bool Get(const LookupKey& key, std::string* value, Status* s,
           MergeContext* merge_context,
           SequenceNumber* max_covering_tombstone_seq, SequenceNumber* seq,
           const ReadOptions& read_opts, ReadCallback* callback = nullptr,
-           bool* is_blob_index = nullptr, bool do_merge = true);
+           bool* is_blob_index = nullptr);

  bool Get(const LookupKey& key, std::string* value, Status* s,
           MergeContext* merge_context,
           SequenceNumber* max_covering_tombstone_seq,
           const ReadOptions& read_opts, ReadCallback* callback = nullptr,
-           bool* is_blob_index = nullptr, bool do_merge = true) {
+           bool* is_blob_index = nullptr) {
    SequenceNumber seq;
    return Get(key, value, s, merge_context, max_covering_tombstone_seq, &seq,
-               read_opts, callback, is_blob_index, do_merge);
+               read_opts, callback, is_blob_index);
  }

  // Attempts to update the new_value inplace, else does normal Add
@@ -496,17 +479,17 @@ class MemTable {
  // writes with sequence number smaller than seq are flushed.
  SequenceNumber atomic_flush_seqno_;

-  // keep track of memory usage in table_, arena_, and range_del_table_.
-  // Gets refrshed inside `ApproximateMemoryUsage()` or `ShouldFlushNow`
-  std::atomic<uint64_t> approximate_memory_usage_;
-
  // Returns a heuristic flush decision
-  bool ShouldFlushNow();
+  bool ShouldFlushNow() const;

  // Updates flush_state_ using ShouldFlushNow()
  void UpdateFlushState();

  void UpdateOldestKeyTime();
+
+  // No copying allowed
+  MemTable(const MemTable&);
+  MemTable& operator=(const MemTable&);
 };

 extern const char* EncodeKey(std::string* scratch, const Slice& target);
@@ -46,8 +46,6 @@ MemTableListVersion::MemTableListVersion(
    size_t* parent_memtable_list_memory_usage, MemTableListVersion* old)
    : max_write_buffer_number_to_maintain_(
          old->max_write_buffer_number_to_maintain_),
-      max_write_buffer_size_to_maintain_(
-          old->max_write_buffer_size_to_maintain_),
      parent_memtable_list_memory_usage_(parent_memtable_list_memory_usage) {
  if (old != nullptr) {
    memlist_ = old->memlist_;
@@ -64,10 +62,8 @@ MemTableListVersion::MemTableListVersion(

 MemTableListVersion::MemTableListVersion(
    size_t* parent_memtable_list_memory_usage,
-    int max_write_buffer_number_to_maintain,
-    int64_t max_write_buffer_size_to_maintain)
+    int max_write_buffer_number_to_maintain)
    : max_write_buffer_number_to_maintain_(max_write_buffer_number_to_maintain),
-      max_write_buffer_size_to_maintain_(max_write_buffer_size_to_maintain),
      parent_memtable_list_memory_usage_(parent_memtable_list_memory_usage) {}

 void MemTableListVersion::Ref() { ++refs_; }
@@ -113,20 +109,6 @@ bool MemTableListVersion::Get(const LookupKey& key, std::string* value,
                     is_blob_index);
 }

-bool MemTableListVersion::GetMergeOperands(
-    const LookupKey& key, Status* s, MergeContext* merge_context,
-    SequenceNumber* max_covering_tombstone_seq, const ReadOptions& read_opts) {
-  for (MemTable* memtable : memlist_) {
-    bool done = memtable->Get(key, nullptr, s, merge_context,
-                              max_covering_tombstone_seq, read_opts, nullptr,
-                              nullptr, false);
-    if (done) {
-      return true;
-    }
-  }
-  return false;
-}
-
 bool MemTableListVersion::GetFromHistory(
    const LookupKey& key, std::string* value, Status* s,
    MergeContext* merge_context, SequenceNumber* max_covering_tombstone_seq,
@@ -244,7 +226,7 @@ void MemTableListVersion::Add(MemTable* m, autovector<MemTable*>* to_delete) {
  assert(refs_ == 1);  // only when refs_ == 1 is MemTableListVersion mutable
  AddMemTable(m);

-  TrimHistory(to_delete, m->ApproximateMemoryUsage());
+  TrimHistory(to_delete);
 }

 // Removes m from list of memtables not flushed.  Caller should NOT Unref m.
@@ -254,51 +236,19 @@ void MemTableListVersion::Remove(MemTable* m,
  memlist_.remove(m);

  m->MarkFlushed();
-  if (max_write_buffer_size_to_maintain_ > 0 ||
-      max_write_buffer_number_to_maintain_ > 0) {
+  if (max_write_buffer_number_to_maintain_ > 0) {
    memlist_history_.push_front(m);
-    // Unable to get size of mutable memtable at this point, pass 0 to
-    // TrimHistory as a best effort.
-    TrimHistory(to_delete, 0);
+    TrimHistory(to_delete);
  } else {
    UnrefMemTable(to_delete, m);
  }
 }

-// return the total memory usage assuming the oldest flushed memtable is dropped
-size_t MemTableListVersion::ApproximateMemoryUsageExcludingLast() const {
-  size_t total_memtable_size = 0;
-  for (auto& memtable : memlist_) {
-    total_memtable_size += memtable->ApproximateMemoryUsage();
-  }
-  for (auto& memtable : memlist_history_) {
-    total_memtable_size += memtable->ApproximateMemoryUsage();
-  }
-  if (!memlist_history_.empty()) {
-    total_memtable_size -= memlist_history_.back()->ApproximateMemoryUsage();
-  }
-  return total_memtable_size;
-}
-
-bool MemTableListVersion::MemtableLimitExceeded(size_t usage) {
-  if (max_write_buffer_size_to_maintain_ > 0) {
-    // calculate the total memory usage after dropping the oldest flushed
-    // memtable, compare with max_write_buffer_size_to_maintain_ to decide
-    // whether to trim history
-    return ApproximateMemoryUsageExcludingLast() + usage >=
-           static_cast<size_t>(max_write_buffer_size_to_maintain_);
-  } else if (max_write_buffer_number_to_maintain_ > 0) {
-    return memlist_.size() + memlist_history_.size() >
-           static_cast<size_t>(max_write_buffer_number_to_maintain_);
-  } else {
-    return false;
-  }
-}
-
 // Make sure we don't use up too much space in history
-void MemTableListVersion::TrimHistory(autovector<MemTable*>* to_delete,
-                                      size_t usage) {
-  while (MemtableLimitExceeded(usage) && !memlist_history_.empty()) {
+void MemTableListVersion::TrimHistory(autovector<MemTable*>* to_delete) {
+  while (memlist_.size() + memlist_history_.size() >
+             static_cast<size_t>(max_write_buffer_number_to_maintain_) &&
+         !memlist_history_.empty()) {
    MemTable* x = memlist_history_.back();
    memlist_history_.pop_back();

@@ -480,8 +430,6 @@ Status MemTableList::TryInstallMemtableFlushResults(
                           cfd->GetName().c_str(), m->file_number_, mem_id);
          assert(m->file_number_ > 0);
          current_->Remove(m, to_delete);
-          UpdateCachedValuesFromMemTableListVersion();
-          ResetTrimHistoryNeeded();
          ++mem_id;
        }
      } else {
@@ -521,15 +469,6 @@ void MemTableList::Add(MemTable* m, autovector<MemTable*>* to_delete) {
  if (num_flush_not_started_ == 1) {
    imm_flush_needed.store(true, std::memory_order_release);
  }
-  UpdateCachedValuesFromMemTableListVersion();
-  ResetTrimHistoryNeeded();
-}
-
-void MemTableList::TrimHistory(autovector<MemTable*>* to_delete, size_t usage) {
-  InstallNewVersion();
-  current_->TrimHistory(to_delete, usage);
-  UpdateCachedValuesFromMemTableListVersion();
-  ResetTrimHistoryNeeded();
 }

 // Returns an estimate of the number of bytes of data in use.
@@ -543,27 +482,6 @@ size_t MemTableList::ApproximateUnflushedMemTablesMemoryUsage() {

 size_t MemTableList::ApproximateMemoryUsage() { return current_memory_usage_; }

-size_t MemTableList::ApproximateMemoryUsageExcludingLast() const {
-  const size_t usage =
-      current_memory_usage_excluding_last_.load(std::memory_order_relaxed);
-  return usage;
-}
-
-bool MemTableList::HasHistory() const {
-  const bool has_history = current_has_history_.load(std::memory_order_relaxed);
-  return has_history;
-}
-
-void MemTableList::UpdateCachedValuesFromMemTableListVersion() {
-  const size_t total_memtable_size =
-      current_->ApproximateMemoryUsageExcludingLast();
-  current_memory_usage_excluding_last_.store(total_memtable_size,
-                                             std::memory_order_relaxed);
-
-  const bool has_history = current_->HasHistory();
-  current_has_history_.store(has_history, std::memory_order_relaxed);
-}
-
 uint64_t MemTableList::ApproximateOldestKeyTime() const {
  if (!current_->memlist_.empty()) {
    return current_->memlist_.back()->ApproximateOldestKeyTime();
@@ -691,8 +609,6 @@ Status InstallMemtableAtomicFlushResults(
                         cfds[i]->GetName().c_str(), m->GetFileNumber(),
                         mem_id);
        imm->current_->Remove(m, to_delete);
-        imm->UpdateCachedValuesFromMemTableListVersion();
-        imm->ResetTrimHistoryNeeded();
      }
    }
  } else {
@@ -734,9 +650,6 @@ void MemTableList::RemoveOldMemTables(uint64_t log_number,
      imm_flush_needed.store(false, std::memory_order_release);
    }
  }
-
-  UpdateCachedValuesFromMemTableListVersion();
-  ResetTrimHistoryNeeded();
 }

 }  // namespace rocksdb
@@ -44,8 +44,7 @@ class MemTableListVersion {
  explicit MemTableListVersion(size_t* parent_memtable_list_memory_usage,
                               MemTableListVersion* old = nullptr);
  explicit MemTableListVersion(size_t* parent_memtable_list_memory_usage,
-                               int max_write_buffer_number_to_maintain,
-                               int64_t max_write_buffer_size_to_maintain);
+                               int max_write_buffer_number_to_maintain);

  void Ref();
  void Unref(autovector<MemTable*>* to_delete = nullptr);
@@ -72,13 +71,6 @@ class MemTableListVersion {
               read_opts, callback, is_blob_index);
  }

-  // Returns all the merge operands corresponding to the key by searching all
-  // memtables starting from the most recent one.
-  bool GetMergeOperands(const LookupKey& key, Status* s,
-                        MergeContext* merge_context,
-                        SequenceNumber* max_covering_tombstone_seq,
-                        const ReadOptions& read_opts);
-
  // Similar to Get(), but searches the Memtable history of memtables that
  // have already been flushed.  Should only be used from in-memory only
  // queries (such as Transaction validation) as the history may contain
@@ -140,7 +132,7 @@ class MemTableListVersion {
  // REQUIRE: m is an immutable memtable
  void Remove(MemTable* m, autovector<MemTable*>* to_delete);

-  void TrimHistory(autovector<MemTable*>* to_delete, size_t usage);
+  void TrimHistory(autovector<MemTable*>* to_delete);

  bool GetFromList(std::list<MemTable*>* list, const LookupKey& key,
                   std::string* value, Status* s, MergeContext* merge_context,
@@ -153,18 +145,6 @@ class MemTableListVersion {

  void UnrefMemTable(autovector<MemTable*>* to_delete, MemTable* m);

-  // Calculate the total amount of memory used by memlist_ and memlist_history_
-  // excluding the last MemTable in memlist_history_. The reason for excluding
-  // the last MemTable is to see if dropping the last MemTable will keep total
-  // memory usage above or equal to max_write_buffer_size_to_maintain_
-  size_t ApproximateMemoryUsageExcludingLast() const;
-
-  // Whether this version contains flushed memtables that are only kept around
-  // for transaction conflict checking.
-  bool HasHistory() const { return !memlist_history_.empty(); }
-
-  bool MemtableLimitExceeded(size_t usage);
-
  // Immutable MemTables that have not yet been flushed.
  std::list<MemTable*> memlist_;

@@ -173,10 +153,8 @@ class MemTableListVersion {
  std::list<MemTable*> memlist_history_;

  // Maximum number of MemTables to keep in memory (including both flushed
-  const int max_write_buffer_number_to_maintain_;
-  // Maximum size of MemTables to keep in memory (including both flushed
  // and not-yet-flushed tables).
-  const int64_t max_write_buffer_size_to_maintain_;
+  const int max_write_buffer_number_to_maintain_;

  int refs_ = 0;

@@ -191,42 +169,35 @@ class MemTableListVersion {
 // recoverability from a crash.
 //
 //
-// Other than imm_flush_needed and imm_trim_needed, this class is not
-// thread-safe and requires external synchronization (such as holding the db
-// mutex or being on the write thread.)
+// Other than imm_flush_needed, this class is not thread-safe and requires
+// external synchronization (such as holding the db mutex or being on the
+// write thread.)
 class MemTableList {
 public:
  // A list of memtables.
  explicit MemTableList(int min_write_buffer_number_to_merge,
-                        int max_write_buffer_number_to_maintain,
-                        int64_t max_write_buffer_size_to_maintain)
+                        int max_write_buffer_number_to_maintain)
      : imm_flush_needed(false),
-        imm_trim_needed(false),
        min_write_buffer_number_to_merge_(min_write_buffer_number_to_merge),
        current_(new MemTableListVersion(&current_memory_usage_,
-                                         max_write_buffer_number_to_maintain,
-                                         max_write_buffer_size_to_maintain)),
+                                         max_write_buffer_number_to_maintain)),
        num_flush_not_started_(0),
        commit_in_progress_(false),
-        flush_requested_(false),
-        current_memory_usage_(0),
-        current_memory_usage_excluding_last_(0),
-        current_has_history_(false) {
+        flush_requested_(false) {
    current_->Ref();
+    current_memory_usage_ = 0;
  }

  // Should not delete MemTableList without making sure MemTableList::current()
  // is Unref()'d.
  ~MemTableList() {}

-  MemTableListVersion* current() const { return current_; }
+  MemTableListVersion* current() { return current_; }

  // so that background threads can detect non-nullptr pointer to
  // determine whether there is anything more to start flushing.
  std::atomic<bool> imm_flush_needed;

-  std::atomic<bool> imm_trim_needed;
-
  // Returns the total number of memtables in the list that haven't yet
  // been flushed and logged.
  int NumNotFlushed() const;
@@ -265,23 +236,6 @@ class MemTableList {
  // Returns an estimate of the number of bytes of data in use.
  size_t ApproximateMemoryUsage();

-  // Returns the cached current_memory_usage_excluding_last_ value.
-  size_t ApproximateMemoryUsageExcludingLast() const;
-
-  // Returns the cached current_has_history_ value.
-  bool HasHistory() const;
-
-  // Updates current_memory_usage_excluding_last_ and current_has_history_
-  // from MemTableListVersion. Must be called whenever InstallNewVersion is
-  // called.
-  void UpdateCachedValuesFromMemTableListVersion();
-
-  // `usage` is the current size of the mutable Memtable. When
-  // max_write_buffer_size_to_maintain is used, total size of mutable and
-  // immutable memtables is checked against it to decide whether to trim
-  // memtable list.
-  void TrimHistory(autovector<MemTable*>* to_delete, size_t usage);
-
  // Returns an estimate of the number of bytes of data used by
  // the unflushed mem-tables.
  size_t ApproximateUnflushedMemTablesMemoryUsage();
@@ -298,20 +252,6 @@ class MemTableList {

  bool HasFlushRequested() { return flush_requested_; }

-  // Returns true if a trim history should be scheduled and the caller should
-  // be the one to schedule it
-  bool MarkTrimHistoryNeeded() {
-    auto expected = false;
-    return imm_trim_needed.compare_exchange_strong(
-        expected, true, std::memory_order_relaxed, std::memory_order_relaxed);
-  }
-
-  void ResetTrimHistoryNeeded() {
-    auto expected = true;
-    imm_trim_needed.compare_exchange_strong(
-        expected, false, std::memory_order_relaxed, std::memory_order_relaxed);
-  }
-
  // Copying allowed
  // MemTableList(const MemTableList&);
  // void operator=(const MemTableList&);
@@ -391,12 +331,6 @@ class MemTableList {

  // The current memory usage.
  size_t current_memory_usage_;
-
-  // Cached value of current_->ApproximateMemoryUsageExcludingLast().
-  std::atomic<size_t> current_memory_usage_excluding_last_;
-
-  // Cached value of current_->HasHistory().
-  std::atomic<bool> current_has_history_;
 };

 // Installs memtable atomic flush results.
@@ -183,7 +183,7 @@ class MemTableListTest : public testing::Test {

 TEST_F(MemTableListTest, Empty) {
  // Create an empty MemTableList and validate basic functions.
-  MemTableList list(1, 0, 0);
+  MemTableList list(1, 0);

  ASSERT_EQ(0, list.NumNotFlushed());
  ASSERT_FALSE(list.imm_flush_needed.load(std::memory_order_acquire));
@@ -202,10 +202,8 @@ TEST_F(MemTableListTest, GetTest) {
  // Create MemTableList
  int min_write_buffer_number_to_merge = 2;
  int max_write_buffer_number_to_maintain = 0;
-  int64_t max_write_buffer_size_to_maintain = 0;
  MemTableList list(min_write_buffer_number_to_merge,
-                    max_write_buffer_number_to_maintain,
-                    max_write_buffer_size_to_maintain);
+                    max_write_buffer_number_to_maintain);

  SequenceNumber seq = 1;
  std::string value;
@@ -314,10 +312,8 @@ TEST_F(MemTableListTest, GetFromHistoryTest) {
  // Create MemTableList
  int min_write_buffer_number_to_merge = 2;
  int max_write_buffer_number_to_maintain = 2;
-  int64_t max_write_buffer_size_to_maintain = 2000;
  MemTableList list(min_write_buffer_number_to_merge,
-                    max_write_buffer_number_to_maintain,
-                    max_write_buffer_size_to_maintain);
+                    max_write_buffer_number_to_maintain);

  SequenceNumber seq = 1;
  std::string value;
@@ -518,11 +514,8 @@ TEST_F(MemTableListTest, FlushPendingTest) {
  // Create MemTableList
  int min_write_buffer_number_to_merge = 3;
  int max_write_buffer_number_to_maintain = 7;
-  int64_t max_write_buffer_size_to_maintain =
-      7 * static_cast<int>(options.write_buffer_size);
  MemTableList list(min_write_buffer_number_to_merge,
-                    max_write_buffer_number_to_maintain,
-                    max_write_buffer_size_to_maintain);
+                    max_write_buffer_number_to_maintain);

  // Create some MemTables
  uint64_t memtable_id = 0;
@@ -677,9 +670,7 @@ TEST_F(MemTableListTest, FlushPendingTest) {
  // created. So TryInstallMemtableFlushResults will install the first 3 tables
  // in to_flush and stop when it encounters a table not yet flushed.
  ASSERT_EQ(2, list.NumNotFlushed());
-  int num_in_history =
-      std::min(3, static_cast<int>(max_write_buffer_size_to_maintain) /
-                      static_cast<int>(options.write_buffer_size));
+  int num_in_history = std::min(3, max_write_buffer_number_to_maintain);
  ASSERT_EQ(num_in_history, list.NumFlushed());
  ASSERT_EQ(5 - list.NumNotFlushed() - num_in_history, to_delete.size());

@@ -696,9 +687,7 @@ TEST_F(MemTableListTest, FlushPendingTest) {
  // This will actually install 2 tables.  The 1 we told it to flush, and also
  // tables[4] which has been waiting for tables[3] to commit.
  ASSERT_EQ(0, list.NumNotFlushed());
-  num_in_history =
-      std::min(5, static_cast<int>(max_write_buffer_size_to_maintain) /
-                      static_cast<int>(options.write_buffer_size));
+  num_in_history = std::min(5, max_write_buffer_number_to_maintain);
  ASSERT_EQ(num_in_history, list.NumFlushed());
  ASSERT_EQ(5 - list.NumNotFlushed() - num_in_history, to_delete.size());

@@ -741,8 +730,7 @@ TEST_F(MemTableListTest, FlushPendingTest) {

  list.current()->Unref(&to_delete);
  int to_delete_size =
-      std::min(num_tables, static_cast<int>(max_write_buffer_size_to_maintain) /
-                               static_cast<int>(options.write_buffer_size));
+      std::min(num_tables, max_write_buffer_number_to_maintain);
  ASSERT_EQ(to_delete_size, to_delete.size());

  for (const auto& m : to_delete) {
@@ -781,13 +769,10 @@ TEST_F(MemTableListTest, AtomicFlusTest) {
  // Create MemTableLists
  int min_write_buffer_number_to_merge = 3;
  int max_write_buffer_number_to_maintain = 7;
-  int64_t max_write_buffer_size_to_maintain =
-      7 * static_cast<int64_t>(options.write_buffer_size);
  autovector<MemTableList*> lists;
  for (int i = 0; i != num_cfs; ++i) {
    lists.emplace_back(new MemTableList(min_write_buffer_number_to_merge,
-                                        max_write_buffer_number_to_maintain,
-                                        max_write_buffer_size_to_maintain));
+                                        max_write_buffer_number_to_maintain));
  }

  autovector<uint32_t> cf_ids;
@@ -24,8 +24,8 @@
 #include "rocksdb/filter_policy.h"
 #include "rocksdb/slice_transform.h"
 #include "rocksdb/table.h"
+#include "table/bloom_block.h"
 #include "table/meta_blocks.h"
-#include "table/plain/plain_table_bloom.h"
 #include "table/plain/plain_table_factory.h"
 #include "table/plain/plain_table_key_coding.h"
 #include "table/plain/plain_table_reader.h"
@@ -730,65 +730,6 @@ TEST_P(PlainTableDBTest, Iterator) {
  }
 }

-namespace {
-std::string NthKey(size_t n, char filler) {
-  std::string rv(16, filler);
-  rv[0] = n % 10;
-  rv[1] = (n / 10) % 10;
-  rv[2] = (n / 100) % 10;
-  rv[3] = (n / 1000) % 10;
-  return rv;
-}
-}  // anonymous namespace
-
-TEST_P(PlainTableDBTest, BloomSchema) {
-  Options options = CurrentOptions();
-  options.create_if_missing = true;
-  for (int bloom_locality = 0; bloom_locality <= 1; bloom_locality++) {
-   options.bloom_locality = bloom_locality;
-    PlainTableOptions plain_table_options;
-    plain_table_options.user_key_len = 16;
-    plain_table_options.bloom_bits_per_key = 3; // high FP rate for test
-    plain_table_options.hash_table_ratio = 0.75;
-    plain_table_options.index_sparseness = 16;
-    plain_table_options.huge_page_tlb_size = 0;
-    plain_table_options.encoding_type = kPlain;
-
-
-    bool expect_bloom_not_match = false;
-    options.table_factory.reset(new TestPlainTableFactory(
-        &expect_bloom_not_match, plain_table_options,
-        0 /* column_family_id */, kDefaultColumnFamilyName));
-    DestroyAndReopen(&options);
-
-    for (unsigned i = 0; i < 2345; ++i) {
-      ASSERT_OK(Put(NthKey(i, 'y'), "added"));
-    }
-    dbfull()->TEST_FlushMemTable();
-    ASSERT_EQ("added", Get(NthKey(42, 'y')));
-
-    for (unsigned i = 0; i < 32; ++i) {
-      // Known pattern of Bloom filter false positives can detect schema change
-      // with high probability. Known FPs stuffed into bits:
-      uint32_t pattern;
-      if (!bloom_locality) {
-        pattern = 1785868347UL;
-      } else if (CACHE_LINE_SIZE == 64U) {
-        pattern = 2421694657UL;
-      } else if (CACHE_LINE_SIZE == 128U) {
-        pattern = 788710956UL;
-      } else {
-        ASSERT_EQ(CACHE_LINE_SIZE, 256U);
-        pattern = 163905UL;
-      }
-      bool expect_fp = pattern & (1UL << i);
-      //fprintf(stderr, "expect_fp@%u: %d\n", i, (int)expect_fp);
-      expect_bloom_not_match = !expect_fp;
-      ASSERT_EQ("NOT_FOUND", Get(NthKey(i, 'n')));
-    }
-  }
-}
-
 namespace {
 std::string MakeLongKey(size_t length, char c) {
  return std::string(length, c);
@@ -144,8 +144,6 @@ class FragmentedRangeTombstoneIterator : public InternalIterator {
  void Invalidate() {
    pos_ = tombstones_->end();
    seq_pos_ = tombstones_->seq_end();
-    pinned_pos_ = tombstones_->end();
-    pinned_seq_pos_ = tombstones_->seq_end();
  }

  RangeTombstone Tombstone() const {
Author	SHA1	Message	Date
Vijay Nadimpalli	efb42cfa47	Making platform 007 (gcc 7) default in build_detect_platform.sh (#5947 ) Summary: Making platform 007 (gcc 7) default in build_detect_platform.sh. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5947 Differential Revision: D18038837 Pulled By: vjnadimpalli fbshipit-source-id: 9ac2ddaa93bf328a416faec028970e039886378e	2019-10-30 10:30:21 -07:00
Adam Retter	29b8a70a2e	Fixes for building RocksJava releases on arm64v8 Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/5674 Differential Revision: D16870338 fbshipit-source-id: c8dac644b1479fa734b491f3a8d50151772290f7	2019-10-23 15:19:39 -07:00
sdong	d47cdbc188	Bump up version to 6.3.6	2019-10-01 17:04:43 -07:00
sdong	56cb92bec6	Revert "Merging iterator to avoid child iterator reseek for some cases (#5286 )" This reverts commit `9fad3e21eb`.	2019-10-01 16:48:35 -07:00
sdong	fbf178ec68	Bump up the version to 6.3.5	2019-09-17 17:32:10 -07:00
sdong	648b0141fa	Merging iterator to disble reseek optimization in prefix seek (#5815 ) Summary: We are seeing a bug of wrong results with merging iterator's reseek avoidence feature and prefix extractor. Disable this optimization for now. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5815 Test Plan: Validated the same MyRocks case was fixed; run all existing tests. Differential Revision: D17430776 fbshipit-source-id: aef664277ba0ab8a2e68331ff0db6ae682535371	2019-09-17 17:30:56 -07:00
Yanqin Jin	d3f28558e7	Bump patch version to 6.3.4	2019-09-03 13:17:54 -07:00
Yanqin Jin	17a3c25564	Fix a bug in file ingestion (#5760 ) Summary: Before this PR, when the number of column families involved in a file ingestion exceeds 2, a bug in the looping logic prevents correct file number being assigned to each ingestion job. Also skip deleting non-existing hard links during cleanup-after-failure. Test plan (devserver) ``` $COMPILE_WITH_ASAN=1 make all $./external_sst_file_test --gtest_filter=ExternalSSTFileTest/ExternalSSTFileTest.IngestFilesIntoMultipleColumnFamilies_/ $makke check ``` Pull Request resolved: https://github.com/facebook/rocksdb/pull/5760 Differential Revision: D17142982 Pulled By: riversand963 fbshipit-source-id: 06c1847a4e7a402647bcf28d124e70f2a0f9daf6	2019-09-03 13:05:22 -07:00
Maysam Yabandeh	4ff493bb38	Disable snapshot refresh feature when snap_refresh_nanos is 0 (#5724 ) Summary: The comments of snap_refresh_nanos advertise that the snapshot refresh feature will be disabled when the option is set to 0. This contract is however not honored in the code: https://github.com/facebook/rocksdb/pull/5278 The patch fixes that and also adds an assert to ensure that the feature is not used when the option is zero. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5724 Differential Revision: D16918185 Pulled By: maysamyabandeh fbshipit-source-id: fec167287df7d85093e087fc39c0eb243e3bbd7e	2019-08-20 13:20:32 -07:00
Levi Tamasi	0e7d927217	Update HISTORY.md for 6.3.2	2019-08-16 11:26:11 -07:00
Levi Tamasi	bb2ab26b9f	Fix regression affecting partitioned indexes/filters when cache_index_and_filter_blocks is false (#5705 ) Summary: PR https://github.com/facebook/rocksdb/issues/5298 (and subsequent related patches) unintentionally changed the semantics of cache_index_and_filter_blocks: historically, this option only affected the main index/filter block; with the changes, it affects index/filter partitions as well. This can cause performance issues when cache_index_and_filter_blocks is false since in this case, partitions are neither cached nor preloaded (i.e. they are loaded on demand upon each access). The patch reverts to the earlier behavior, that is, partitions are cached similarly to data blocks regardless of the value of the above option. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5705 Test Plan: make check ./db_bench -benchmarks=fillrandom --statistics --stats_interval_seconds=1 --duration=30 --num=500000000 --bloom_bits=20 --partition_index_and_filters=true --cache_index_and_filter_blocks=false ./db_bench -benchmarks=readrandom --use_existing_db --statistics --stats_interval_seconds=1 --duration=10 --num=500000000 --bloom_bits=20 --partition_index_and_filters=true --cache_index_and_filter_blocks=false --cache_size=8000000000 Relevant statistics from the readrandom benchmark with the old code: rocksdb.block.cache.index.miss COUNT : 0 rocksdb.block.cache.index.hit COUNT : 0 rocksdb.block.cache.index.add COUNT : 0 rocksdb.block.cache.index.bytes.insert COUNT : 0 rocksdb.block.cache.index.bytes.evict COUNT : 0 rocksdb.block.cache.filter.miss COUNT : 0 rocksdb.block.cache.filter.hit COUNT : 0 rocksdb.block.cache.filter.add COUNT : 0 rocksdb.block.cache.filter.bytes.insert COUNT : 0 rocksdb.block.cache.filter.bytes.evict COUNT : 0 With the new code: rocksdb.block.cache.index.miss COUNT : 2500 rocksdb.block.cache.index.hit COUNT : 42696 rocksdb.block.cache.index.add COUNT : 2500 rocksdb.block.cache.index.bytes.insert COUNT : 4050048 rocksdb.block.cache.index.bytes.evict COUNT : 0 rocksdb.block.cache.filter.miss COUNT : 2500 rocksdb.block.cache.filter.hit COUNT : 4550493 rocksdb.block.cache.filter.add COUNT : 2500 rocksdb.block.cache.filter.bytes.insert COUNT : 10331040 rocksdb.block.cache.filter.bytes.evict COUNT : 0 Differential Revision: D16817382 Pulled By: ltamasi fbshipit-source-id: 28a516b0da1f041a03313e0b70b28cf5cf205d00	2019-08-15 12:54:34 -07:00
Levi Tamasi	4ce0542eeb	Make the 'block read count' performance counters consistent (#5484 ) Summary: The patch brings the semantics of per-block-type read performance context counters in sync with the generic block_read_count by only incrementing the counter if the block was actually read from the file. It also fixes index_block_read_count, which fell victim to the refactoring in PR https://github.com/facebook/rocksdb/issues/5298. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5484 Test Plan: Extended the unit tests. Differential Revision: D15887431 Pulled By: ltamasi fbshipit-source-id: a3889759d0ac5759d56625d692cd828d1b9207a6	2019-08-15 11:48:40 -07:00
Levi Tamasi	0d3679d0af	Revert to respecting only the read_tier read option for index blocks (#5481 ) Summary: PR https://github.com/facebook/rocksdb/issues/5298 subtly changed how read options are applied to the index block during a Get, MultiGet, or iteration. Earlier, only the read_tier option applied to the index block read; since PR https://github.com/facebook/rocksdb/issues/5298, fill_cache and verify_checksums also have an effect. This patch restores the earlier behavior to prevent surprise memory increases for clients due to the index block not being cached. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5481 Test Plan: make check Differential Revision: D15883082 Pulled By: ltamasi fbshipit-source-id: 9a065ec3a6db5a365cf6dd5e95190a20c5756356	2019-08-15 11:44:23 -07:00
Levi Tamasi	317a78197b	Bump version to 6.3.2	2019-08-15 11:25:42 -07:00
Levi Tamasi	1a523dc802	Fix the changelog for 6.3.0 on the 6.3 branch as well	2019-07-31 10:18:33 -07:00
sdong	5369e08d83	Add HISTORY.md for the bug fix.	2019-07-24 13:01:39 -07:00
sdong	92f04d6c5f	Fix regression bug of Auto rolling logger when handling failures (#5622 ) Summary: Auto roll logger fails to handle file creation error in the correct way, which may expose to seg fault condition to users. Fix it. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5622 Test Plan: Add a unit test on creating file under a non-existing directory. The test fails without the fix. Differential Revision: D16460853 fbshipit-source-id: e96da4bef4f16db171ea04a11b2ec5a9448ddbde	2019-07-24 12:57:07 -07:00
Maysam Yabandeh	8e7a29ca1f	Disable refresh snapshot feature by default (#5606 ) Summary: There are concerns about the correctness of this patch. Disabling by default until the concerns are resolved. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5606 Differential Revision: D16428064 Pulled By: maysamyabandeh fbshipit-source-id: a89280f0ea85796c9c9dfbfd9a8e91dad9b000b3	2019-07-22 20:09:26 -07:00
anand76	eff6e2a549	MultiGet parallel IO (#5464 ) Summary: Enhancement to MultiGet batching to read data blocks required for keys in a batch in parallel from disk. It uses Env::MultiRead() API to read multiple blocks and reduce latency. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5464 Test Plan: 1. make check 2. make asan_check 3. make asan_crash Differential Revision: D15911771 Pulled By: anand1976 fbshipit-source-id: 605036b9af0f90ca0020dc87c3a86b4da6e83394	2019-07-12 15:38:53 -07:00
anand76	b6c329e406	Fix bugs in WAL trash file handling (#5520 ) Summary: 1. Cleanup WAL trash files on open 2. Don't apply deletion rate limit if WAL dir is different from db dir Pull Request resolved: https://github.com/facebook/rocksdb/pull/5520 Test Plan: Add new unit tests and make check Differential Revision: D16096750 Pulled By: anand1976 fbshipit-source-id: 6f07858ad864b754b711db416f0389c45ede599b	2019-07-12 13:58:35 -07:00
Yanqin Jin	3e1a6dd665	Ref and unref cfd before and after calling WaitForFlushMemTables (#5513 ) Summary: This is to prevent bg flush thread from unrefing and deleting the cfd that has been dropped by a concurrent thread. Before RocksDB calls `DBImpl::WaitForFlushMemTables`, we should increase the refcount of each `ColumnFamilyData` so that its ref count will not drop to 0 even if the column family is dropped by another thread. Otherwise the bg flush thread can deref the cfd and deletes it, causing a segfault in `WaitForFlushMemtables` upon accessing `cfd`. Test plan (on devserver): ``` $make clean && COMPILE_WITH_ASAN=1 make -j32 $make check ``` All unit tests must pass. Pull Request resolved: https://github.com/facebook/rocksdb/pull/5513 Differential Revision: D16062898 Pulled By: riversand963 fbshipit-source-id: 37dc511f1dc99f036d0201bbd7f0a8f5677c763d	2019-07-11 23:47:58 -07:00
Yanqin Jin	1dcbe51bdf	Add C binding for secondary instance (#5505 ) Summary: Add C binding for secondary instance as well as unit test. Test plan (on devserver) ``` $make clean && COMPILE_WITH_ASAN=1 make -j20 all $./c_test $make check ``` Pull Request resolved: https://github.com/facebook/rocksdb/pull/5505 Differential Revision: D16000043 Pulled By: riversand963 fbshipit-source-id: 3361ef6bfdf4ce12438cee7290a0ac203b5250bd	2019-07-11 23:47:29 -07:00
haoyuhuang	6d10405754	Block cache tracer: Do not populate block cache trace record when tracing is disabled. (#5510 ) Summary: This PR makes sure that trace record is not populated when tracing is disabled. Before this PR: DB path: [/data/mysql/rocks_regression_tests/OPTIONS-myrocks-40-33-10000000/2019-06-26-13-04-41/db] readwhilewriting : 9.803 micros/op 1550408 ops/sec; 107.9 MB/s (5000000 of 5000000 found) Microseconds per read: Count: 80000000 Average: 9.8045 StdDev: 12.64 Min: 1 Median: 7.5246 Max: 25343 Percentiles: P50: 7.52 P75: 12.10 P99: 37.44 P99.9: 75.07 P99.99: 133.60 After this PR: DB path: [/data/mysql/rocks_regression_tests/OPTIONS-myrocks-40-33-10000000/2019-06-26-14-08-21/db] readwhilewriting : 8.723 micros/op 1662882 ops/sec; 115.8 MB/s (5000000 of 5000000 found) Microseconds per read: Count: 80000000 Average: 8.7236 StdDev: 12.19 Min: 1 Median: 6.7262 Max: 25229 Percentiles: P50: 6.73 P75: 10.50 P99: 31.54 P99.9: 74.81 P99.99: 132.82 Pull Request resolved: https://github.com/facebook/rocksdb/pull/5510 Differential Revision: D16016428 Pulled By: HaoyuHuang fbshipit-source-id: 3b3d11e6accf207d18ec2545b802aa01ee65901f	2019-07-10 12:08:55 -07:00
Vaibhav Gogte	b4f8173984	Export Cache::GetCharge (#5476 ) Summary: Exporting GetCharge to cache.hh Pull Request resolved: https://github.com/facebook/rocksdb/pull/5476 Differential Revision: D15881882 Pulled By: riversand963 fbshipit-source-id: 3d99084d10059b4fcaaaba240606ed50bc23351c	2019-06-24 10:19:31 -07:00
Fosco Marotto	d9aecd909f	Update version to 6.3.0	2019-06-18 13:59:54 -07:00