Fix "*/" outside comment warning in env_hdfs.h

.travis.yml

@@ -20,9 +20,8 @@ addons:
 env:
   - TEST_GROUP=platform_dependent # 16-18 minutes
   - TEST_GROUP=1 # 33-35 minutes
-  - TEST_GROUP=2 # 18-20 minutes
-  - TEST_GROUP=3 # 20-22 minutes
-  - TEST_GROUP=4 # 12-14 minutes
+  - TEST_GROUP=2 # 30-32 minutes
+  - TEST_GROUP=3 # ? minutes - under development
   # Run java tests
   - JOB_NAME=java_test # 4-11 minutes
   # Build ROCKSDB_LITE
@@ -40,8 +39,6 @@ matrix:
     env: TEST_GROUP=2
   - os: osx
     env: TEST_GROUP=3
-  - os: osx
-    env: TEST_GROUP=4
   - os : osx
     env: JOB_NAME=cmake-mingw
   - os : linux
@@ -68,10 +65,9 @@ script:
   - ${CXX} --version
   - if [ `command -v ccache` ]; then ccache -C; fi
   - if [ "${TEST_GROUP}" == 'platform_dependent' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_END=db_block_cache_test make -j4 all_but_some_tests check_some; fi
-  - if [ "${TEST_GROUP}" == '1' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=db_block_cache_test ROCKSDBTESTS_END=full_filter_block_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '2' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=full_filter_block_test ROCKSDBTESTS_END=write_batch_with_index_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '3' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_batch_with_index_test ROCKSDBTESTS_END=write_prepared_transaction_test make -j4 check_some; fi
-  - if [ "${TEST_GROUP}" == '4' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_prepared_transaction_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '1' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=db_block_cache_test ROCKSDBTESTS_END=comparator_db_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '2' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=comparator_db_test ROCKSDBTESTS_END=write_prepared_transaction_test make -j4 check_some; fi
+  - if [ "${TEST_GROUP}" == '3' ]; then OPT=-DTRAVIS V=1 ROCKSDBTESTS_START=write_prepared_transaction_test make -j4 check_some; fi
   - if [ "${JOB_NAME}" == 'java_test' ]; then OPT=-DTRAVIS V=1 make clean jclean && make rocksdbjava jtest; fi
   - if [ "${JOB_NAME}" == 'lite_build' ]; then OPT="-DTRAVIS -DROCKSDB_LITE" V=1 make -j4 static_lib tools; fi
   - if [ "${JOB_NAME}" == 'examples' ]; then OPT=-DTRAVIS V=1 make -j4 static_lib; cd examples; make -j4; fi

CMakeLists.txt

@@ -56,7 +56,7 @@ if(MSVC)
   include(${CMAKE_CURRENT_SOURCE_DIR}/thirdparty.inc)
 else()
   if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
-    # FreeBSD has jemalloc as default malloc
+    # FreeBSD has jemaloc as default malloc
     # but it does not have all the jemalloc files in include/...
     set(WITH_JEMALLOC ON)
   else()
@@ -569,14 +569,12 @@ set(SOURCES
         util/status_message.cc
         util/string_util.cc
         util/sync_point.cc
-        util/sync_point_impl.cc
         util/testutil.cc
         util/thread_local.cc
         util/threadpool_imp.cc
         util/transaction_test_util.cc
         util/xxhash.cc
         utilities/backupable/backupable_db.cc
-        utilities/blob_db/blob_compaction_filter.cc
         utilities/blob_db/blob_db.cc
         utilities/blob_db/blob_db_impl.cc
         utilities/blob_db/blob_dump_tool.cc
@@ -604,7 +602,6 @@ set(SOURCES
         utilities/leveldb_options/leveldb_options.cc
         utilities/lua/rocks_lua_compaction_filter.cc
         utilities/memory/memory_util.cc
-        utilities/merge_operators/bytesxor.cc
         utilities/merge_operators/max.cc
         utilities/merge_operators/put.cc
         utilities/merge_operators/string_append/stringappend.cc

HISTORY.md

@@ -1,30 +1,15 @@
 # Rocksdb Change Log
 ## Unreleased
 ### Public API Change
-
-### New Features
-
-### Bug Fixes
-* Fsync after writing global seq number to the ingestion file in ExternalSstFileIngestionJob.
-
-### Java API Changes
-* Add `BlockBasedTableConfig.setBlockCache` to allow sharing a block cache across DB instances.
-
-## 5.13.0 (3/20/2018)
-### Public API Change
 * RocksDBOptionsParser::Parse()'s `ignore_unknown_options` argument will only be effective if the option file shows it is generated using a higher version of RocksDB than the current version.
 * Remove CompactionEventListener.
 
 ### New Features
-* SstFileManager now can cancel compactions if they will result in max space errors. SstFileManager users can also use SetCompactionBufferSize to specify how much space must be leftover during a compaction for auxiliary file functions such as logging and flushing.
 * Avoid unnecessarily flushing in `CompactRange()` when the range specified by the user does not overlap unflushed memtables.
-* If `ColumnFamilyOptions::max_subcompactions` is set greater than one, we now parallelize large manual level-based compactions.
 * Add "rocksdb.live-sst-files-size" DB property to return total bytes of all SST files belong to the latest LSM tree.
-* NewSstFileManager to add an argument bytes_max_delete_chunk with default 64MB. With this argument, a file larger than 64MB will be ftruncated multiple times based on this size.
 
 ### Bug Fixes
 * Fix a leak in prepared_section_completed_ where the zeroed entries would not removed from the map.
-* Fix WAL corruption caused by race condition between user write thread and backup/checkpoint thread.
 
 ## 5.12.0 (2/14/2018)
 ### Public API Change
@@ -85,7 +70,7 @@
 * `BackupableDBOptions::max_valid_backups_to_open == 0` now means no backups will be opened during BackupEngine initialization. Previously this condition disabled limiting backups opened.
 * `DBOptions::preserve_deletes` is a new option that allows one to specify that DB should not drop tombstones for regular deletes if they have sequence number larger than what was set by the new API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)`. Disabled by default.
 * API call `DB::SetPreserveDeletesSequenceNumber(SequenceNumber seqnum)` was added, users who wish to preserve deletes are expected to periodically call this function to advance the cutoff seqnum (all deletes made before this seqnum can be dropped by DB). It's user responsibility to figure out how to advance the seqnum in the way so the tombstones are kept for the desired period of time, yet are eventually processed in time and don't eat up too much space.
-* `ReadOptions::iter_start_seqnum` was added; if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`.
+* `ReadOptions::iter_start_seqnum` was added; if set to something > 0 user will see 2 changes in iterators behavior 1) only keys written with sequence larger than this parameter would be returned and 2) the `Slice` returned by iter->key() now points to the the memory that keep User-oriented representation of the internal key, rather than user key. New struct `FullKey` was added to represent internal keys, along with a new helper function `ParseFullKey(const Slice& internal_key, FullKey* result);`.
 * Deprecate trash_dir param in NewSstFileManager, right now we will rename deleted files to <name>.trash instead of moving them to trash directory
 * Allow setting a custom trash/DB size ratio limit in the SstFileManager, after which files that are to be scheduled for deletion are deleted immediately, regardless of any delete ratelimit.
 * Return an error on write if write_options.sync = true and write_options.disableWAL = true to warn user of inconsistent options. Previously we will not write to WAL and not respecting the sync options in this case.

INSTALL.md

@@ -141,27 +141,6 @@ to build a portable binary, add `PORTABLE=1` before your make commands, like thi
         export JAVA_HOME=/usr/local/openjdk7
         gmake rocksdbjava
 
-* **OpenBSD** (6.3/-current):
-
-    * As RocksDB is not available in the ports yet you have to build it on your own:
-
-    * Install the dependencies for RocksDB:
-
-        pkg_add gmake gflags snappy bzip2 lz4 zstd git jdk bash findutils gnuwatch 
-
-    * Build RocksDB from source:
-
-        cd ~
-        git clone https://github.com/facebook/rocksdb.git
-        cd rocksdb
-        gmake static_lib
-
-    * Build RocksJava from source (optional):
-
-        cd rocksdb
-        export JAVA_HOME=/usr/local/jdk-1.8.0
-        export PATH=$PATH:/usr/local/jdk-1.8.0/bin
-        gmake rocksdbjava
 
 * **iOS**:
   * Run: `TARGET_OS=IOS make static_lib`. When building the project which uses rocksdb iOS library, make sure to define two important pre-processing macros: `ROCKSDB_LITE` and `IOS_CROSS_COMPILE`.

Makefile

@@ -278,10 +278,6 @@ default: all
 WARNING_FLAGS = -W -Wextra -Wall -Wsign-compare -Wshadow \
   -Wno-unused-parameter
 
-ifeq ($(PLATFORM), OS_OPENBSD)
-	WARNING_FLAGS += -Wno-unused-lambda-capture
-endif
-
 ifndef DISABLE_WARNING_AS_ERROR
 	WARNING_FLAGS += -Werror
 endif
@@ -410,6 +406,7 @@ TESTS = \
 	db_range_del_test \
 	db_sst_test \
 	db_tailing_iter_test \
+	db_universal_compaction_test \
 	db_io_failure_test \
 	db_properties_test \
 	db_table_properties_test \
@@ -511,7 +508,6 @@ TESTS = \
 	repair_test \
 	env_timed_test \
 	write_prepared_transaction_test \
-	db_universal_compaction_test \
 
 PARALLEL_TEST = \
 	backupable_db_test \
@@ -678,7 +674,7 @@ coverage:
 	COVERAGEFLAGS="-fprofile-arcs -ftest-coverage" LDFLAGS+="-lgcov" $(MAKE) J=1 all check
 	cd coverage && ./coverage_test.sh
         # Delete intermediate files
-	$(FIND) . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
+	find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
 
 ifneq (,$(filter check parallel_check,$(MAKECMDGOALS)),)
 # Use /dev/shm if it has the sticky bit set (otherwise, /tmp),
@@ -825,7 +821,7 @@ CLEAN_FILES += t LOG $(TMPD)
 # regardless of their duration. As with any use of "watch", hit ^C to
 # interrupt.
 watch-log:
-	$(WATCH) --interval=0 'sort -k7,7nr -k4,4gr LOG|$(quoted_perl_command)'
+	watch --interval=0 'sort -k7,7nr -k4,4gr LOG|$(quoted_perl_command)'
 
 # If J != 1 and GNU parallel is installed, run the tests in parallel,
 # via the check_0 rule above.  Otherwise, run them sequentially.
@@ -990,14 +986,14 @@ rocksdb.h rocksdb.cc: build_tools/amalgamate.py Makefile $(LIB_SOURCES) unity.cc
 clean:
 	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 {} \;
+	find . -name "*.[oda]" -exec rm -f {} \;
+	find . -type f -regex ".*\.\(\(gcda\)\|\(gcno\)\)" -exec rm {} \;
 	rm -rf bzip2* snappy* zlib* lz4* zstd*
 	cd java; $(MAKE) clean
 
 tags:
-	ctags -R .
-	cscope -b `$(FIND) . -name '*.cc'` `$(FIND) . -name '*.h'` `$(FIND) . -name '*.c'`
+	ctags * -R
+	cscope -b `find . -name '*.cc'` `find . -name '*.h'` `find . -name '*.c'`
 	ctags -e -R -o etags *
 
 format:
@@ -1514,10 +1510,10 @@ uninstall:
 
 install-headers:
 	install -d $(INSTALL_PATH)/lib
-	for header_dir in `$(FIND) "include/rocksdb" -type d`; do \
+	for header_dir in `find "include/rocksdb" -type d`; do \
 		install -d $(INSTALL_PATH)/$$header_dir; \
 	done
-	for header in `$(FIND) "include/rocksdb" -type f -name *.h`; do \
+	for header in `find "include/rocksdb" -type f -name *.h`; do \
 		install -C -m 644 $$header $(INSTALL_PATH)/$$header; \
 	done
 
@@ -1544,12 +1540,6 @@ install: install-static
 JAVA_INCLUDE = -I$(JAVA_HOME)/include/ -I$(JAVA_HOME)/include/linux
 ifeq ($(PLATFORM), OS_SOLARIS)
 	ARCH := $(shell isainfo -b)
-else ifeq ($(PLATFORM), OS_OPENBSD)
-	ifneq (,$(filter $(MACHINE), amd64 arm64 sparc64))
-		ARCH := 64
-	else
-		ARCH := 32
-	endif
 else
 	ARCH := $(shell getconf LONG_BIT)
 endif
@@ -1580,7 +1570,6 @@ LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
 ZSTD_VER ?= 1.3.3
 ZSTD_SHA256 ?= a77c47153ee7de02626c5b2a097005786b71688be61e9fb81806a011f90b297b
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
-CURL_SSL_OPTS ?= --tlsv1
 
 ifeq ($(PLATFORM), OS_MACOSX)
 	ROCKSDBJNILIB = librocksdbjni-osx.jnilib
@@ -1609,11 +1598,6 @@ ifeq ($(PLATFORM), OS_AIX)
 	EXTRACT_SOURCES = gunzip < TAR_GZ | tar xvf -
 	SNAPPY_MAKE_TARGET = libsnappy.la
 endif
-ifeq ($(PLATFORM), OS_OPENBSD)
-        JAVA_INCLUDE = -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/openbsd
-	ROCKSDBJNILIB = librocksdbjni-openbsd$(ARCH).so
-        ROCKSDB_JAR = rocksdbjni-$(ROCKSDB_MAJOR).$(ROCKSDB_MINOR).$(ROCKSDB_PATCH)-openbsd$(ARCH).jar
-endif
 
 libz.a:
 	-rm -rf zlib-$(ZLIB_VER)
@@ -1641,7 +1625,7 @@ libbz2.a:
 
 libsnappy.a:
 	-rm -rf snappy-$(SNAPPY_VER)
-	curl -O -L ${CURL_SSL_OPTS} ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER)/snappy-$(SNAPPY_VER).tar.gz
+	curl -O -L ${SNAPPY_DOWNLOAD_BASE}/$(SNAPPY_VER)/snappy-$(SNAPPY_VER).tar.gz
 	SNAPPY_SHA256_ACTUAL=`$(SHA256_CMD) snappy-$(SNAPPY_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(SNAPPY_SHA256)" != "$$SNAPPY_SHA256_ACTUAL" ]; then \
 		echo snappy-$(SNAPPY_VER).tar.gz checksum mismatch, expected=\"$(SNAPPY_SHA256)\" actual=\"$$SNAPPY_SHA256_ACTUAL\"; \
@@ -1654,7 +1638,7 @@ libsnappy.a:
 
 liblz4.a:
 	-rm -rf lz4-$(LZ4_VER)
-	curl -O -L ${CURL_SSL_OPTS} ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
+	curl -O -L ${LZ4_DOWNLOAD_BASE}/v$(LZ4_VER).tar.gz
 	mv v$(LZ4_VER).tar.gz lz4-$(LZ4_VER).tar.gz
 	LZ4_SHA256_ACTUAL=`$(SHA256_CMD) lz4-$(LZ4_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(LZ4_SHA256)" != "$$LZ4_SHA256_ACTUAL" ]; then \
@@ -1667,7 +1651,7 @@ liblz4.a:
 
 libzstd.a:
 	-rm -rf zstd-$(ZSTD_VER)
-	curl -O -L ${CURL_SSL_OPTS} ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
+	curl -O -L ${ZSTD_DOWNLOAD_BASE}/v$(ZSTD_VER).tar.gz
 	mv v$(ZSTD_VER).tar.gz zstd-$(ZSTD_VER).tar.gz
 	ZSTD_SHA256_ACTUAL=`$(SHA256_CMD) zstd-$(ZSTD_VER).tar.gz | cut -d ' ' -f 1`; \
 	if [ "$(ZSTD_SHA256)" != "$$ZSTD_SHA256_ACTUAL" ]; then \

README.md

@@ -26,7 +26,3 @@ rely on the details of any other header files in this package.  Those
 internal APIs may be changed without warning.
 
 Design discussions are conducted in https://www.facebook.com/groups/rocksdb.dev/
-
-## License
-
-RocksDB is dual-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).  You may select, at your option, one of the above-listed licenses.

ROCKSDB_LITE.md

@@ -5,7 +5,7 @@ RocksDBLite is a project focused on mobile use cases, which don't need a lot of
 Some examples of the features disabled by ROCKSDB_LITE:
 * compiled-in support for LDB tool
 * No backupable DB
-* No support for replication (which we provide in form of TransactionalIterator)
+* No support for replication (which we provide in form of TrasactionalIterator)
 * No advanced monitoring tools
 * No special-purpose memtables that are highly optimized for specific use cases
 * No Transactions

TARGETS

@@ -46,10 +46,7 @@ rocksdb_preprocessor_flags = [
 ]
 
 rocksdb_arch_preprocessor_flags = {
-    "x86_64": [
-        "-DHAVE_SSE42",
-        "-DHAVE_PCLMUL",
-    ],
+    "x86_64": ["-DHAVE_SSE42"],
 }
 
 build_mode = read_config("fbcode", "build_mode")
@@ -215,13 +212,11 @@ cpp_library(
         "util/status_message.cc",
         "util/string_util.cc",
         "util/sync_point.cc",
-        "util/sync_point_impl.cc",
         "util/thread_local.cc",
         "util/threadpool_imp.cc",
         "util/transaction_test_util.cc",
         "util/xxhash.cc",
         "utilities/backupable/backupable_db.cc",
-        "utilities/blob_db/blob_compaction_filter.cc",
         "utilities/blob_db/blob_db.cc",
         "utilities/blob_db/blob_db_impl.cc",
         "utilities/blob_db/blob_dump_tool.cc",
@@ -247,7 +242,6 @@ cpp_library(
         "utilities/leveldb_options/leveldb_options.cc",
         "utilities/lua/rocks_lua_compaction_filter.cc",
         "utilities/memory/memory_util.cc",
-        "utilities/merge_operators/bytesxor.cc",
         "utilities/merge_operators/max.cc",
         "utilities/merge_operators/put.cc",
         "utilities/merge_operators/string_append/stringappend.cc",

buckifier/targets_cfg.py

@@ -50,10 +50,7 @@ rocksdb_preprocessor_flags = [
 ]
 
 rocksdb_arch_preprocessor_flags = {
-    "x86_64": [
-        "-DHAVE_SSE42",
-        "-DHAVE_PCLMUL",
-    ],
+    "x86_64": ["-DHAVE_SSE42"],
 }
 
 build_mode = read_config("fbcode", "build_mode")

build_tools/build_detect_platform

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/sh
 #
 # Detects OS we're compiling on and outputs a file specified by the first
 # argument, which in turn gets read while processing Makefile.
@@ -16,8 +16,6 @@
 #   PLATFORM_CXXFLAGS           C++ compiler flags.  Will contain:
 #   PLATFORM_SHARED_VERSIONED   Set to 'true' if platform supports versioned
 #                               shared libraries, empty otherwise.
-#   FIND			Command for the find utility
-#   WATCH			Command for the watch utility
 #
 # The PLATFORM_CCFLAGS and PLATFORM_CXXFLAGS might include the following:
 #
@@ -66,19 +64,11 @@ rm -f "$OUTPUT"
 touch "$OUTPUT"
 
 if test -z "$CC"; then
-    if [ -x "$(command -v clang)" ]; then
-        CC=clang
-    else
-        CC=cc
-    fi
+   CC=cc
 fi
 
 if test -z "$CXX"; then
-    if [ -x "$(command -v clang++)" ]; then
-        CXX=clang++
-    else
-        CXX=g++
-    fi
+    CXX=g++
 fi
 
 # Detect OS
@@ -95,15 +85,7 @@ if test -z "$CLANG_SCAN_BUILD"; then
 fi
 
 if test -z "$CLANG_ANALYZER"; then
-    CLANG_ANALYZER=$(command -v clang++ 2> /dev/null)
-fi
-
-if test -z "$FIND"; then
-    FIND=find
-fi
-
-if test -z "$WATCH"; then
-    WATCH=watch
+    CLANG_ANALYZER=$(which clang++ 2> /dev/null)
 fi
 
 COMMON_FLAGS="$COMMON_FLAGS ${CFLAGS}"
@@ -172,12 +154,9 @@ case "$TARGET_OS" in
         ;;
     OpenBSD)
         PLATFORM=OS_OPENBSD
-	CXX=clang++
         COMMON_FLAGS="$COMMON_FLAGS -fno-builtin-memcmp -D_REENTRANT -DOS_OPENBSD"
         PLATFORM_LDFLAGS="$PLATFORM_LDFLAGS -pthread"
         # PORT_FILES=port/openbsd/openbsd_specific.cc
-	FIND=gfind
-	WATCH=gnuwatch
         ;;
     DragonFly)
         PLATFORM=OS_DRAGONFLYBSD
@@ -506,9 +485,7 @@ if test -z "$PORTABLE"; then
   elif test -n "`echo $TARGET_ARCHITECTURE | grep ^arm`"; then
     # TODO: Handle this with approprite options.
     COMMON_FLAGS="$COMMON_FLAGS"
-  elif [ "$TARGET_OS" == "IOS" ]; then
-    COMMON_FLAGS="$COMMON_FLAGS"
-  elif [ "$TARGET_OS" != "AIX" ] && [ "$TARGET_OS" != "SunOS" ]; then
+  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"
@@ -596,8 +573,6 @@ echo "ROCKSDB_PATCH=$ROCKSDB_PATCH" >> "$OUTPUT"
 echo "CLANG_SCAN_BUILD=$CLANG_SCAN_BUILD" >> "$OUTPUT"
 echo "CLANG_ANALYZER=$CLANG_ANALYZER" >> "$OUTPUT"
 echo "PROFILING_FLAGS=$PROFILING_FLAGS" >> "$OUTPUT"
-echo "FIND=$FIND" >> "$OUTPUT"
-echo "WATCH=$WATCH" >> "$OUTPUT"
 # This will enable some related identifiers for the preprocessor
 if test -n "$JEMALLOC"; then
   echo "JEMALLOC=1" >> "$OUTPUT"

build_tools/run_ci_db_test.ps1

@@ -336,7 +336,7 @@ $InvokeTestAsync = {
 # Test limiting factor here
 [int]$count = 0
 # Overall status
-[bool]$script:success = $true;
+[bool]$success = $true;
 
 function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
 {
@@ -425,7 +425,7 @@ function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
         $log_content = @(Get-Content $log)
 
         if($completed.State -ne "Completed") {
-            $script:success = $false
+            $success = $false
             Write-Warning $message
             $log_content | Write-Warning
         } else {
@@ -449,7 +449,7 @@ function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
             }
 
             if(!$pass_found) {
-                $script:success = $false;
+                $success = $false;
                 Write-Warning $message
                 $log_content | Write-Warning
             } else {
@@ -473,7 +473,7 @@ New-TimeSpan -Start $StartDate -End $EndDate |
   }
 
 
-if(!$script:success) {
+if(!$success) {
 # This does not succeed killing off jobs quick
 # So we simply exit
 #    Remove-Job -Job $jobs -Force

build_tools/version.sh

@@ -1,4 +1,4 @@
-#/usr/bin/env bash
+#!/bin/sh
 if [ "$#" = "0" ]; then
   echo "Usage: $0 major|minor|patch|full"
   exit 1

db/c.cc

@@ -32,13 +32,11 @@
 #include "rocksdb/universal_compaction.h"
 #include "rocksdb/utilities/backupable_db.h"
 #include "rocksdb/utilities/checkpoint.h"
-#include "rocksdb/utilities/db_ttl.h"
 #include "rocksdb/utilities/optimistic_transaction_db.h"
 #include "rocksdb/utilities/transaction.h"
 #include "rocksdb/utilities/transaction_db.h"
 #include "rocksdb/utilities/write_batch_with_index.h"
 #include "rocksdb/write_batch.h"
-#include "rocksdb/perf_context.h"
 #include "utilities/merge_operators.h"
 
 using rocksdb::BytewiseComparator;
@@ -102,8 +100,6 @@ using rocksdb::OptimisticTransactionDB;
 using rocksdb::OptimisticTransactionOptions;
 using rocksdb::Transaction;
 using rocksdb::Checkpoint;
-using rocksdb::PerfLevel;
-using rocksdb::PerfContext;
 
 using std::shared_ptr;
 
@@ -144,7 +140,6 @@ struct rocksdb_envoptions_t      { EnvOptions        rep; };
 struct rocksdb_ingestexternalfileoptions_t  { IngestExternalFileOptions rep; };
 struct rocksdb_sstfilewriter_t   { SstFileWriter*    rep; };
 struct rocksdb_ratelimiter_t     { RateLimiter*      rep; };
-struct rocksdb_perfcontext_t     { PerfContext*      rep; };
 struct rocksdb_pinnableslice_t {
   PinnableSlice rep;
 };
@@ -482,20 +477,6 @@ rocksdb_t* rocksdb_open(
   return result;
 }
 
-rocksdb_t* rocksdb_open_with_ttl(
-    const rocksdb_options_t* options,
-    const char* name,
-    int ttl,
-    char** errptr) {
-  rocksdb::DBWithTTL* db;
-  if (SaveError(errptr, rocksdb::DBWithTTL::Open(options->rep, std::string(name), &db, ttl))) {
-    return nullptr;
-  }
-  rocksdb_t* result = new rocksdb_t;
-  result->rep = db;
-  return result;
-}
-
 rocksdb_t* rocksdb_open_for_read_only(
     const rocksdb_options_t* options,
     const char* name,
@@ -2556,176 +2537,6 @@ void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t *limiter) {
   delete limiter;
 }
 
-void rocksdb_set_perf_level(int v) {
-  PerfLevel level = static_cast<PerfLevel>(v);
-  SetPerfLevel(level);
-}
-
-rocksdb_perfcontext_t* rocksdb_perfcontext_create() {
-  rocksdb_perfcontext_t* context = new rocksdb_perfcontext_t;
-  context->rep = rocksdb::get_perf_context();
-  return context;
-}
-
-void rocksdb_perfcontext_reset(rocksdb_perfcontext_t* context) {
-  context->rep->Reset();
-}
-
-char* rocksdb_perfcontext_report(rocksdb_perfcontext_t* context,
-    unsigned char exclude_zero_counters) {
-  return strdup(context->rep->ToString(exclude_zero_counters).c_str());
-}
-
-uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
-    int metric) {
-  PerfContext* rep = context->rep;
-  switch (metric) {
-    case rocksdb_user_key_comparison_count:
-      return rep->user_key_comparison_count;
-    case rocksdb_block_cache_hit_count:
-      return rep->block_cache_hit_count;
-    case rocksdb_block_read_count:
-      return rep->block_read_count;
-    case rocksdb_block_read_byte:
-      return rep->block_read_byte;
-    case rocksdb_block_read_time:
-      return rep->block_read_time;
-    case rocksdb_block_checksum_time:
-      return rep->block_checksum_time;
-    case rocksdb_block_decompress_time:
-      return rep->block_decompress_time;
-    case rocksdb_get_read_bytes:
-      return rep->get_read_bytes;
-    case rocksdb_multiget_read_bytes:
-      return rep->multiget_read_bytes;
-    case rocksdb_iter_read_bytes:
-      return rep->iter_read_bytes;
-    case rocksdb_internal_key_skipped_count:
-      return rep->internal_key_skipped_count;
-    case rocksdb_internal_delete_skipped_count:
-      return rep->internal_delete_skipped_count;
-    case rocksdb_internal_recent_skipped_count:
-      return rep->internal_recent_skipped_count;
-    case rocksdb_internal_merge_count:
-      return rep->internal_merge_count;
-    case rocksdb_get_snapshot_time:
-      return rep->get_snapshot_time;
-    case rocksdb_get_from_memtable_time:
-      return rep->get_from_memtable_time;
-    case rocksdb_get_from_memtable_count:
-      return rep->get_from_memtable_count;
-    case rocksdb_get_post_process_time:
-      return rep->get_post_process_time;
-    case rocksdb_get_from_output_files_time:
-      return rep->get_from_output_files_time;
-    case rocksdb_seek_on_memtable_time:
-      return rep->seek_on_memtable_time;
-    case rocksdb_seek_on_memtable_count:
-      return rep->seek_on_memtable_count;
-    case rocksdb_next_on_memtable_count:
-      return rep->next_on_memtable_count;
-    case rocksdb_prev_on_memtable_count:
-      return rep->prev_on_memtable_count;
-    case rocksdb_seek_child_seek_time:
-      return rep->seek_child_seek_time;
-    case rocksdb_seek_child_seek_count:
-      return rep->seek_child_seek_count;
-    case rocksdb_seek_min_heap_time:
-      return rep->seek_min_heap_time;
-    case rocksdb_seek_max_heap_time:
-      return rep->seek_max_heap_time;
-    case rocksdb_seek_internal_seek_time:
-      return rep->seek_internal_seek_time;
-    case rocksdb_find_next_user_entry_time:
-      return rep->find_next_user_entry_time;
-    case rocksdb_write_wal_time:
-      return rep->write_wal_time;
-    case rocksdb_write_memtable_time:
-      return rep->write_memtable_time;
-    case rocksdb_write_delay_time:
-      return rep->write_delay_time;
-    case rocksdb_write_pre_and_post_process_time:
-      return rep->write_pre_and_post_process_time;
-    case rocksdb_db_mutex_lock_nanos:
-      return rep->db_mutex_lock_nanos;
-    case rocksdb_db_condition_wait_nanos:
-      return rep->db_condition_wait_nanos;
-    case rocksdb_merge_operator_time_nanos:
-      return rep->merge_operator_time_nanos;
-    case rocksdb_read_index_block_nanos:
-      return rep->read_index_block_nanos;
-    case rocksdb_read_filter_block_nanos:
-      return rep->read_filter_block_nanos;
-    case rocksdb_new_table_block_iter_nanos:
-      return rep->new_table_block_iter_nanos;
-    case rocksdb_new_table_iterator_nanos:
-      return rep->new_table_iterator_nanos;
-    case rocksdb_block_seek_nanos:
-      return rep->block_seek_nanos;
-    case rocksdb_find_table_nanos:
-      return rep->find_table_nanos;
-    case rocksdb_bloom_memtable_hit_count:
-      return rep->bloom_memtable_hit_count;
-    case rocksdb_bloom_memtable_miss_count:
-      return rep->bloom_memtable_miss_count;
-    case rocksdb_bloom_sst_hit_count:
-      return rep->bloom_sst_hit_count;
-    case rocksdb_bloom_sst_miss_count:
-      return rep->bloom_sst_miss_count;
-    case rocksdb_key_lock_wait_time:
-      return rep->key_lock_wait_time;
-    case rocksdb_key_lock_wait_count:
-      return rep->key_lock_wait_count;
-    case rocksdb_env_new_sequential_file_nanos:
-      return rep->env_new_sequential_file_nanos;
-    case rocksdb_env_new_random_access_file_nanos:
-      return rep->env_new_random_access_file_nanos;
-    case rocksdb_env_new_writable_file_nanos:
-      return rep->env_new_writable_file_nanos;
-    case rocksdb_env_reuse_writable_file_nanos:
-      return rep->env_reuse_writable_file_nanos;
-    case rocksdb_env_new_random_rw_file_nanos:
-      return rep->env_new_random_rw_file_nanos;
-    case rocksdb_env_new_directory_nanos:
-      return rep->env_new_directory_nanos;
-    case rocksdb_env_file_exists_nanos:
-      return rep->env_file_exists_nanos;
-    case rocksdb_env_get_children_nanos:
-      return rep->env_get_children_nanos;
-    case rocksdb_env_get_children_file_attributes_nanos:
-      return rep->env_get_children_file_attributes_nanos;
-    case rocksdb_env_delete_file_nanos:
-      return rep->env_delete_file_nanos;
-    case rocksdb_env_create_dir_nanos:
-      return rep->env_create_dir_nanos;
-    case rocksdb_env_create_dir_if_missing_nanos:
-      return rep->env_create_dir_if_missing_nanos;
-    case rocksdb_env_delete_dir_nanos:
-      return rep->env_delete_dir_nanos;
-    case rocksdb_env_get_file_size_nanos:
-      return rep->env_get_file_size_nanos;
-    case rocksdb_env_get_file_modification_time_nanos:
-      return rep->env_get_file_modification_time_nanos;
-    case rocksdb_env_rename_file_nanos:
-      return rep->env_rename_file_nanos;
-    case rocksdb_env_link_file_nanos:
-      return rep->env_link_file_nanos;
-    case rocksdb_env_lock_file_nanos:
-      return rep->env_lock_file_nanos;
-    case rocksdb_env_unlock_file_nanos:
-      return rep->env_unlock_file_nanos;
-    case rocksdb_env_new_logger_nanos:
-      return rep->env_new_logger_nanos;
-    default:
-      break;
-  }
-  return 0;
-}
-
-void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) {
-  delete context;
-}
-
 /*
 TODO:
 DB::OpenForReadOnly
@@ -3200,7 +3011,7 @@ void rocksdb_sstfilewriter_delete(rocksdb_sstfilewriter_t* writer,
 
 void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer,
                                   char** errptr) {
-  SaveError(errptr, writer->rep->Finish(nullptr));
+  SaveError(errptr, writer->rep->Finish(NULL));
 }
 
 void rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t* writer) {
@@ -3982,7 +3793,7 @@ rocksdb_pinnableslice_t* rocksdb_get_pinned(
     if (!s.IsNotFound()) {
       SaveError(errptr, s);
     }
-    return nullptr;
+    return NULL;
   }
   return v;
 }
@@ -3999,7 +3810,7 @@ rocksdb_pinnableslice_t* rocksdb_get_pinned_cf(
     if (!s.IsNotFound()) {
       SaveError(errptr, s);
     }
-    return nullptr;
+    return NULL;
   }
   return v;
 }
@@ -4010,7 +3821,7 @@ const char* rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t* v,
                                         size_t* vlen) {
   if (!v) {
     *vlen = 0;
-    return nullptr;
+    return NULL;
   }
 
   *vlen = v->rep.size();

db/column_family.cc

@@ -54,9 +54,6 @@ ColumnFamilyHandleImpl::~ColumnFamilyHandleImpl() {
 #endif  // ROCKSDB_LITE
     // Job id == 0 means that this is not our background process, but rather
     // user thread
-    // Need to hold some shared pointers owned by the initial_cf_options
-    // before final cleaning up finishes.
-    ColumnFamilyOptions initial_cf_options_copy = cfd_->initial_cf_options();
     JobContext job_context(0);
     mutex_->Lock();
     if (cfd_->Unref()) {
@@ -386,7 +383,7 @@ ColumnFamilyData::ColumnFamilyData(
       next_(nullptr),
       prev_(nullptr),
       log_number_(0),
-      flush_reason_(FlushReason::kOthers),
+      flush_reason_(FlushReason::kUnknown),
       column_family_set_(column_family_set),
       pending_flush_(false),
       pending_compaction_(false),

db/column_family.h

@@ -370,10 +370,6 @@ class ColumnFamilyData {
 
   bool initialized() const { return initialized_.load(); }
 
-  const ColumnFamilyOptions& initial_cf_options() {
-    return initial_cf_options_;
-  }
-
   Env::WriteLifeTimeHint CalculateSSTWriteHint(int level);
 
  private:

db/column_family_test.cc

@@ -2791,18 +2791,6 @@ TEST_F(ColumnFamilyTest, CompactionSpeedupTwoColumnFamilies) {
   ASSERT_EQ(1, dbfull()->TEST_BGCompactionsAllowed());
 }
 
-TEST_F(ColumnFamilyTest, CreateAndDestoryOptions) {
-  std::unique_ptr<ColumnFamilyOptions> cfo(new ColumnFamilyOptions());
-  ColumnFamilyHandle* cfh;
-  Open();
-  ASSERT_OK(db_->CreateColumnFamily(*(cfo.get()), "yoyo", &cfh));
-  cfo.reset();
-  ASSERT_OK(db_->Put(WriteOptions(), cfh, "foo", "bar"));
-  ASSERT_OK(db_->Flush(FlushOptions(), cfh));
-  ASSERT_OK(db_->DropColumnFamily(cfh));
-  ASSERT_OK(db_->DestroyColumnFamilyHandle(cfh));
-}
-
 #ifndef ROCKSDB_LITE
 TEST_F(ColumnFamilyTest, FlushCloseWALFiles) {
   SpecialEnv env(Env::Default());

db/compaction.cc

@@ -446,8 +446,7 @@ bool Compaction::ShouldFormSubcompactions() const {
     return false;
   }
   if (cfd_->ioptions()->compaction_style == kCompactionStyleLevel) {
-    return (start_level_ == 0 || is_manual_compaction_) && output_level_ > 0 &&
-           !IsOutputLevelEmpty();
+    return start_level_ == 0 && output_level_ > 0 && !IsOutputLevelEmpty();
   } else if (cfd_->ioptions()->compaction_style == kCompactionStyleUniversal) {
     return number_levels_ > 1 && output_level_ > 0;
   } else {

db/compaction_iterator.cc

@@ -167,13 +167,10 @@ void CompactionIterator::InvokeFilterIfNeeded(bool* need_skip,
     CompactionFilter::ValueType value_type =
         ikey_.type == kTypeValue ? CompactionFilter::ValueType::kValue
                                  : CompactionFilter::ValueType::kBlobIndex;
-    // Hack: pass internal key to BlobIndexCompactionFilter since it needs
-    // to get sequence number.
-    Slice& filter_key = ikey_.type == kTypeValue ? ikey_.user_key : key_;
     {
       StopWatchNano timer(env_, true);
       filter = compaction_filter_->FilterV2(
-          compaction_->level(), filter_key, value_type, value_,
+          compaction_->level(), ikey_.user_key, value_type, value_,
           &compaction_filter_value_, compaction_filter_skip_until_.rep());
       iter_stats_.total_filter_time +=
           env_ != nullptr ? timer.ElapsedNanos() : 0;

db/compaction_job.cc

@@ -723,16 +723,14 @@ void CompactionJob::ProcessKeyValueCompaction(SubcompactionState* sub_compact) {
   std::set<size_t> sample_begin_offsets;
   if (bottommost_level_ && kSampleBytes > 0) {
     const size_t kMaxSamples = kSampleBytes >> kSampleLenShift;
-    const size_t kOutFileLen = static_cast<size_t>(
-      mutable_cf_options->MaxFileSizeForLevel(
-        compact_->compaction->output_level()));
+    const size_t kOutFileLen = mutable_cf_options->MaxFileSizeForLevel(
+        compact_->compaction->output_level());
     if (kOutFileLen != port::kMaxSizet) {
       const size_t kOutFileNumSamples = kOutFileLen >> kSampleLenShift;
       Random64 generator{versions_->NewFileNumber()};
       for (size_t i = 0; i < kMaxSamples; ++i) {
-        sample_begin_offsets.insert(
-          static_cast<size_t>(generator.Uniform(kOutFileNumSamples))
-            << kSampleLenShift);
+        sample_begin_offsets.insert(generator.Uniform(kOutFileNumSamples)
+                                    << kSampleLenShift);
       }
     }
   }

db/compaction_picker.cc

@@ -41,7 +41,7 @@ bool FindIntraL0Compaction(const std::vector<FileMetaData*>& level_files,
                            size_t min_files_to_compact,
                            uint64_t max_compact_bytes_per_del_file,
                            CompactionInputFiles* comp_inputs) {
-  size_t compact_bytes = static_cast<size_t>(level_files[0]->fd.file_size);
+  size_t compact_bytes = level_files[0]->fd.file_size;
   size_t compact_bytes_per_del_file = port::kMaxSizet;
   // compaction range will be [0, span_len).
   size_t span_len;

db/db_basic_test.cc

@@ -886,7 +886,7 @@ class TestEnv : public EnvWrapper {
       return Status::OK();
     }
 
-   private:
+  private:
     int close_count;
 };
 
@@ -896,7 +896,7 @@ TEST_F(DBBasicTest, DBClose) {
   ASSERT_OK(DestroyDB(dbname, options));
 
   DB* db = nullptr;
-  TestEnv* env = new TestEnv();
+  TestEnv *env = new TestEnv();
   options.create_if_missing = true;
   options.env = env;
   Status s = DB::Open(options, dbname, &db);

db/db_compaction_filter_test.cc

@@ -109,7 +109,7 @@ class SkipEvenFilter : public CompactionFilter {
     int i = std::stoi(key.ToString());
     if (i / 10 % 2 == 0) {
       char key_str[100];
-      snprintf(key_str, sizeof(key_str), "%010d", i / 10 * 10 + 10);
+      snprintf(key_str, sizeof(key), "%010d", i / 10 * 10 + 10);
       *skip_until = key_str;
       ++cfilter_skips;
       return Decision::kRemoveAndSkipUntil;
@@ -767,7 +767,7 @@ TEST_F(DBTestCompactionFilter, CompactionFilterIgnoreSnapshot) {
       iter->Next();
     }
     ASSERT_EQ(count, 6);
-    read_options.snapshot = nullptr;
+    read_options.snapshot = 0;
     std::unique_ptr<Iterator> iter1(db_->NewIterator(read_options));
     iter1->SeekToFirst();
     count = 0;

db/db_compaction_test.cc

@@ -2751,7 +2751,6 @@ TEST_P(DBCompactionTestWithParam, ForceBottommostLevelCompaction) {
   rocksdb::SyncPoint::GetInstance()->EnableProcessing();
 
   Options options = CurrentOptions();
-  options.target_file_size_base = 100000000;
   options.write_buffer_size = 100000000;
   options.max_subcompactions = max_subcompactions_;
   DestroyAndReopen(options);

db/db_filesnapshot.cc

@@ -74,7 +74,7 @@ Status DBImpl::EnableFileDeletions(bool force) {
 }
 
 int DBImpl::IsFileDeletionsEnabled() const {
-  return !disable_delete_obsolete_files_;
+  return disable_delete_obsolete_files_;
 }
 
 Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,

db/db_impl.cc

@@ -404,7 +404,9 @@ Status DBImpl::CloseHelper() {
   return ret;
 }
 
-Status DBImpl::CloseImpl() { return CloseHelper(); }
+Status DBImpl::CloseImpl() {
+  return CloseHelper();
+}
 
 DBImpl::~DBImpl() {
   if (!closed_) {
@@ -2145,9 +2147,9 @@ Status DBImpl::DeleteFile(std::string name) {
     status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                     &edit, &mutex_, directories_.GetDbDir());
     if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &job_context.superversion_context,
-                                         *cfd->GetLatestMutableCFOptions(),
-                                         FlushReason::kDeleteFiles);
+      InstallSuperVersionAndScheduleWork(
+          cfd, &job_context.superversion_context,
+          *cfd->GetLatestMutableCFOptions());
     }
     FindObsoleteFiles(&job_context, false);
   }  // lock released here
@@ -2229,9 +2231,9 @@ Status DBImpl::DeleteFilesInRanges(ColumnFamilyHandle* column_family,
     status = versions_->LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
                                     &edit, &mutex_, directories_.GetDbDir());
     if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &job_context.superversion_context,
-                                         *cfd->GetLatestMutableCFOptions(),
-                                         FlushReason::kDeleteFiles);
+      InstallSuperVersionAndScheduleWork(
+          cfd, &job_context.superversion_context,
+          *cfd->GetLatestMutableCFOptions());
     }
     for (auto* deleted_file : deleted_files) {
       deleted_file->being_compacted = false;
@@ -2387,13 +2389,10 @@ Snapshot::~Snapshot() {
 }
 
 Status DestroyDB(const std::string& dbname, const Options& options) {
-  ImmutableDBOptions soptions(SanitizeOptions(dbname, options));
+  const ImmutableDBOptions soptions(SanitizeOptions(dbname, options));
   Env* env = soptions.env;
   std::vector<std::string> filenames;
 
-  // Reset the logger because it holds a handle to the
-  // log file and prevents cleanup and directory removal
-  soptions.info_log.reset();
   // Ignore error in case directory does not exist
   env->GetChildren(dbname, &filenames);
 
@@ -2859,8 +2858,8 @@ Status DBImpl::IngestExternalFile(
                                  &mutex_, directories_.GetDbDir());
     }
     if (status.ok()) {
-      InstallSuperVersionAndScheduleWork(cfd, &sv_context, *mutable_cf_options,
-                                         FlushReason::kExternalFileIngestion);
+      InstallSuperVersionAndScheduleWork(cfd, &sv_context,
+                                         *mutable_cf_options);
     }
 
     // Resume writes to the DB

db/db_impl.h

@@ -185,9 +185,7 @@ class DBImpl : public DB {
                               ColumnFamilyHandle* column_family,
                               const std::vector<std::string>& input_file_names,
                               const int output_level,
-                              const int output_path_id = -1,
-                              std::vector<std::string>* const output_file_names
-                              = nullptr) override;
+                              const int output_path_id = -1) override;
 
   virtual Status PauseBackgroundWork() override;
   virtual Status ContinueBackgroundWork() override;
@@ -223,8 +221,6 @@ class DBImpl : public DB {
   virtual Status SyncWAL() override;
 
   virtual SequenceNumber GetLatestSequenceNumber() const override;
-  // REQUIRES: joined the main write queue if two_write_queues is disabled, and
-  // the second write queue otherwise.
   virtual void SetLastPublishedSequence(SequenceNumber seq);
   // Returns LastSequence in last_seq_same_as_publish_seq_
   // mode and LastAllocatedSequence otherwise. This is useful when visiblility
@@ -382,9 +378,7 @@ class DBImpl : public DB {
   Status TEST_WaitForFlushMemTable(ColumnFamilyHandle* column_family = nullptr);
 
   // Wait for any compaction
-  // We add a bool parameter to wait for unscheduledCompactions_ == 0, but this
-  // is only for the special test of CancelledCompactions
-  Status TEST_WaitForCompact(bool waitUnscheduled = false);
+  Status TEST_WaitForCompact();
 
   // Return the maximum overlapping data (in bytes) at next level for any
   // file at a level >= 1.
@@ -473,7 +467,7 @@ class DBImpl : public DB {
                          bool no_full_scan = false);
 
   // Diffs the files listed in filenames and those that do not
-  // belong to live files are possibly removed. Also, removes all the
+  // belong to live files are posibly removed. Also, removes all the
   // files in sst_delete_files and log_delete_files.
   // It is not necessary to hold the mutex when invoking this method.
   // If FindObsoleteFiles() was run, we need to also run
@@ -556,18 +550,9 @@ class DBImpl : public DB {
     WriteBatch* batch_;
     // The seq number of the first key in the batch
     SequenceNumber seq_;
-    // Number of sub-batched. A new sub-batch is created if we txn attempts to
-    // inserts a duplicate key,seq to memtable. This is currently used in
-    // WritePrparedTxn
-    size_t batch_cnt_;
     explicit RecoveredTransaction(const uint64_t log, const std::string& name,
-                                  WriteBatch* batch, SequenceNumber seq,
-                                  size_t batch_cnt)
-        : log_number_(log),
-          name_(name),
-          batch_(batch),
-          seq_(seq),
-          batch_cnt_(batch_cnt) {}
+                                  WriteBatch* batch, SequenceNumber seq)
+        : log_number_(log), name_(name), batch_(batch), seq_(seq) {}
 
     ~RecoveredTransaction() { delete batch_; }
   };
@@ -589,10 +574,9 @@ class DBImpl : public DB {
   }
 
   void InsertRecoveredTransaction(const uint64_t log, const std::string& name,
-                                  WriteBatch* batch, SequenceNumber seq,
-                                  size_t batch_cnt) {
+                                  WriteBatch* batch, SequenceNumber seq) {
     recovered_transactions_[name] =
-        new RecoveredTransaction(log, name, batch, seq, batch_cnt);
+        new RecoveredTransaction(log, name, batch, seq);
     MarkLogAsContainingPrepSection(log);
   }
 
@@ -835,8 +819,7 @@ class DBImpl : public DB {
 
   Status ScheduleFlushes(WriteContext* context);
 
-  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
-                        FlushReason flush_reason = FlushReason::kOthers);
+  Status SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context);
 
   // Force current memtable contents to be flushed.
   Status FlushMemTable(ColumnFamilyData* cfd, const FlushOptions& options,
@@ -876,7 +859,7 @@ class DBImpl : public DB {
                               size_t seq_inc);
 
   // Used by WriteImpl to update bg_error_ if paranoid check is enabled.
-  void WriteStatusCheck(const Status& status);
+  void WriteCallbackStatusCheck(const Status& status);
 
   // Used by WriteImpl to update bg_error_ in case of memtable insert error.
   void MemTableInsertStatusCheck(const Status& memtable_insert_status);
@@ -886,7 +869,6 @@ class DBImpl : public DB {
   Status CompactFilesImpl(const CompactionOptions& compact_options,
                           ColumnFamilyData* cfd, Version* version,
                           const std::vector<std::string>& input_file_names,
-                          std::vector<std::string>* const output_file_names,
                           const int output_level, int output_path_id,
                           JobContext* job_context, LogBuffer* log_buffer);
 
@@ -1362,8 +1344,7 @@ class DBImpl : public DB {
   // state needs flush or compaction.
   void InstallSuperVersionAndScheduleWork(
       ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-      const MutableCFOptions& mutable_cf_options,
-      FlushReason flush_reason = FlushReason::kOthers);
+      const MutableCFOptions& mutable_cf_options);
 
 #ifndef ROCKSDB_LITE
   using DB::GetPropertiesOfAllTables;

db/db_impl_compaction_flush.cc

@@ -461,8 +461,7 @@ Status DBImpl::CompactFiles(
     const CompactionOptions& compact_options,
     ColumnFamilyHandle* column_family,
     const std::vector<std::string>& input_file_names,
-    const int output_level, const int output_path_id,
-    std::vector<std::string>* const output_file_names) {
+    const int output_level, const int output_path_id) {
 #ifdef ROCKSDB_LITE
     // not supported in lite version
   return Status::NotSupported("Not supported in ROCKSDB LITE");
@@ -489,7 +488,7 @@ Status DBImpl::CompactFiles(
     WaitForIngestFile();
 
     s = CompactFilesImpl(compact_options, cfd, sv->current,
-                         input_file_names, output_file_names, output_level,
+                         input_file_names, output_level,
                          output_path_id, &job_context, &log_buffer);
   }
   if (sv->Unref()) {
@@ -533,7 +532,6 @@ Status DBImpl::CompactFiles(
 Status DBImpl::CompactFilesImpl(
     const CompactionOptions& compact_options, ColumnFamilyData* cfd,
     Version* version, const std::vector<std::string>& input_file_names,
-    std::vector<std::string>* const output_file_names,
     const int output_level, int output_path_id, JobContext* job_context,
     LogBuffer* log_buffer) {
   mutex_.AssertHeld();
@@ -655,7 +653,7 @@ Status DBImpl::CompactFilesImpl(
   if (status.ok()) {
     InstallSuperVersionAndScheduleWork(
         c->column_family_data(), &job_context->superversion_context,
-        *c->mutable_cf_options(), FlushReason::kManualCompaction);
+       *c->mutable_cf_options());
   }
   c->ReleaseCompactionFiles(s);
 
@@ -682,14 +680,6 @@ Status DBImpl::CompactFilesImpl(
     }
   }
 
-  if (output_file_names != nullptr) {
-    for (const auto newf : c->edit()->GetNewFiles()) {
-      (*output_file_names).push_back(TableFileName(
-              immutable_db_options_.db_paths, newf.second.fd.GetNumber(),
-              newf.second.fd.GetPathId()) );
-    }
-  }
-
   c.reset();
 
   bg_compaction_scheduled_--;
@@ -891,7 +881,7 @@ Status DBImpl::Flush(const FlushOptions& flush_options,
   ROCKS_LOG_INFO(immutable_db_options_.info_log, "[%s] Manual flush start.",
                  cfh->GetName().c_str());
   Status s =
-      FlushMemTable(cfh->cfd(), flush_options, FlushReason::kManualFlush);
+      FlushMemTable(cfh->cfd(), flush_options, FlushReason::kManualCompaction);
   ROCKS_LOG_INFO(immutable_db_options_.info_log,
                  "[%s] Manual flush finished, status: %s\n",
                  cfh->GetName().c_str(), s.ToString().c_str());
@@ -1513,7 +1503,7 @@ void DBImpl::BackgroundCallCompaction(PrepickedCompaction* prepicked_compaction,
     if (made_progress ||
         (bg_compaction_scheduled_ == 0 &&
          bg_bottom_compaction_scheduled_ == 0) ||
-        HasPendingManualCompaction() || unscheduled_compactions_ == 0) {
+        HasPendingManualCompaction()) {
       // signal if
       // * made_progress -- need to wakeup DelayWrite
       // * bg_{bottom,}_compaction_scheduled_ == 0 -- need to wakeup ~DBImpl
@@ -1576,9 +1566,6 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
 
   // InternalKey manual_end_storage;
   // InternalKey* manual_end = &manual_end_storage;
-#ifndef ROCKSDB_LITE
-  bool sfm_bookkeeping = false;
-#endif  // ROCKSDB_LITE
   if (is_manual) {
     ManualCompactionState* m = manual_compaction;
     assert(m->in_progress);
@@ -1641,66 +1628,27 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
       TEST_SYNC_POINT("DBImpl::BackgroundCompaction():BeforePickCompaction");
       c.reset(cfd->PickCompaction(*mutable_cf_options, log_buffer));
       TEST_SYNC_POINT("DBImpl::BackgroundCompaction():AfterPickCompaction");
-
-      bool enough_room = true;
       if (c != nullptr) {
-#ifndef ROCKSDB_LITE
-        auto sfm = static_cast<SstFileManagerImpl*>(
-            immutable_db_options_.sst_file_manager.get());
-        if (sfm) {
-          enough_room = sfm->EnoughRoomForCompaction(c.get());
-          if (enough_room) {
-            sfm_bookkeeping = true;
-          }
-        }
-#endif  // ROCKSDB_LITE
-        if (!enough_room) {
-          // Just in case tests want to change the value of enough_room
-          TEST_SYNC_POINT_CALLBACK(
-              "DBImpl::BackgroundCompaction():CancelledCompaction",
-              &enough_room);
-        }
-        if (!enough_room) {
-          // Then don't do the compaction
-          c->ReleaseCompactionFiles(status);
-          c->column_family_data()
-              ->current()
-              ->storage_info()
-              ->ComputeCompactionScore(*(c->immutable_cf_options()),
-                                       *(c->mutable_cf_options()));
-
-          ROCKS_LOG_BUFFER(log_buffer,
-                           "Cancelled compaction because not enough room");
+        // update statistics
+        MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
+                    c->inputs(0)->size());
+        // There are three things that can change compaction score:
+        // 1) When flush or compaction finish. This case is covered by
+        // InstallSuperVersionAndScheduleWork
+        // 2) When MutableCFOptions changes. This case is also covered by
+        // InstallSuperVersionAndScheduleWork, because this is when the new
+        // options take effect.
+        // 3) When we Pick a new compaction, we "remove" those files being
+        // compacted from the calculation, which then influences compaction
+        // score. Here we check if we need the new compaction even without the
+        // files that are currently being compacted. If we need another
+        // compaction, we might be able to execute it in parallel, so we add it
+        // to the queue and schedule a new thread.
+        if (cfd->NeedsCompaction()) {
+          // Yes, we need more compactions!
           AddToCompactionQueue(cfd);
           ++unscheduled_compactions_;
-
-          c.reset();
-          // Don't need to sleep here, because BackgroundCallCompaction
-          // will sleep if !s.ok()
-          status = Status::CompactionTooLarge();
-          RecordTick(stats_, COMPACTION_CANCELLED, 1);
-        } else {
-          // update statistics
-          MeasureTime(stats_, NUM_FILES_IN_SINGLE_COMPACTION,
-                      c->inputs(0)->size());
-          // There are three things that can change compaction score:
-          // 1) When flush or compaction finish. This case is covered by
-          // InstallSuperVersionAndScheduleWork
-          // 2) When MutableCFOptions changes. This case is also covered by
-          // InstallSuperVersionAndScheduleWork, because this is when the new
-          // options take effect.
-          // 3) When we Pick a new compaction, we "remove" those files being
-          // compacted from the calculation, which then influences compaction
-          // score. Here we check if we need the new compaction even without the
-          // files that are currently being compacted. If we need another
-          // compaction, we might be able to execute it in parallel, so we add
-          // it to the queue and schedule a new thread.
-          if (cfd->NeedsCompaction()) {
-            // Yes, we need more compactions!
-            AddToCompactionQueue(cfd);
-            ++unscheduled_compactions_;
-            MaybeScheduleFlushOrCompaction();
-          }
+          MaybeScheduleFlushOrCompaction();
         }
       }
     }
@@ -1727,7 +1675,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
                                     &mutex_, directories_.GetDbDir());
     InstallSuperVersionAndScheduleWork(
         c->column_family_data(), &job_context->superversion_context,
-        *c->mutable_cf_options(), FlushReason::kAutoCompaction);
+        *c->mutable_cf_options());
     ROCKS_LOG_BUFFER(log_buffer, "[%s] Deleted %d files\n",
                      c->column_family_data()->GetName().c_str(),
                      c->num_input_files(0));
@@ -1774,7 +1722,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
     // Use latest MutableCFOptions
     InstallSuperVersionAndScheduleWork(
         c->column_family_data(), &job_context->superversion_context,
-        *c->mutable_cf_options(), FlushReason::kAutoCompaction);
+        *c->mutable_cf_options());
 
     VersionStorageInfo::LevelSummaryStorage tmp;
     c->column_family_data()->internal_stats()->IncBytesMoved(c->output_level(),
@@ -1853,23 +1801,13 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
     if (status.ok()) {
       InstallSuperVersionAndScheduleWork(
           c->column_family_data(), &job_context->superversion_context,
-          *c->mutable_cf_options(), FlushReason::kAutoCompaction);
+          *c->mutable_cf_options());
     }
     *made_progress = true;
   }
   if (c != nullptr) {
     c->ReleaseCompactionFiles(status);
     *made_progress = true;
-
-#ifndef ROCKSDB_LITE
-    // Need to make sure SstFileManager does its bookkeeping
-    auto sfm = static_cast<SstFileManagerImpl*>(
-        immutable_db_options_.sst_file_manager.get());
-    if (sfm && sfm_bookkeeping) {
-      sfm->OnCompactionCompletion(c.get());
-    }
-#endif  // ROCKSDB_LITE
-
     NotifyOnCompactionCompleted(
         c->column_family_data(), c.get(), status,
         compaction_job_stats, job_context->job_id);
@@ -1877,7 +1815,7 @@ Status DBImpl::BackgroundCompaction(bool* made_progress,
   // this will unref its input_version and column_family_data
   c.reset();
 
-  if (status.ok() || status.IsCompactionTooLarge()) {
+  if (status.ok()) {
     // Done
   } else if (status.IsShutdownInProgress()) {
     // Ignore compaction errors found during shutting down
@@ -2044,7 +1982,7 @@ bool DBImpl::MCOverlap(ManualCompactionState* m, ManualCompactionState* m1) {
 
 void DBImpl::InstallSuperVersionAndScheduleWork(
     ColumnFamilyData* cfd, SuperVersionContext* sv_context,
-    const MutableCFOptions& mutable_cf_options, FlushReason flush_reason) {
+    const MutableCFOptions& mutable_cf_options) {
   mutex_.AssertHeld();
 
   // Update max_total_in_memory_state_
@@ -2063,7 +2001,7 @@ void DBImpl::InstallSuperVersionAndScheduleWork(
 
   // Whenever we install new SuperVersion, we might need to issue new flushes or
   // compactions.
-  SchedulePendingFlush(cfd, flush_reason);
+  SchedulePendingFlush(cfd, FlushReason::kSuperVersionChange);
   SchedulePendingCompaction(cfd);
   MaybeScheduleFlushOrCompaction();
 

db/db_impl_debug.cc

@@ -117,7 +117,7 @@ Status DBImpl::TEST_WaitForFlushMemTable(ColumnFamilyHandle* column_family) {
   return WaitForFlushMemTable(cfd);
 }
 
-Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) {
+Status DBImpl::TEST_WaitForCompact() {
   // Wait until the compaction completes
 
   // TODO: a bug here. This function actually does not necessarily
@@ -126,8 +126,7 @@ Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) {
 
   InstrumentedMutexLock l(&mutex_);
   while ((bg_bottom_compaction_scheduled_ || bg_compaction_scheduled_ ||
-          bg_flush_scheduled_ ||
-          (wait_unscheduled && unscheduled_compactions_)) &&
+          bg_flush_scheduled_) &&
          bg_error_.ok()) {
     bg_cv_.Wait();
   }

db/db_impl_files.cc

@@ -65,7 +65,7 @@ void DBImpl::MarkLogAsContainingPrepSection(uint64_t log) {
 
   auto rit = logs_with_prep_.rbegin();
   bool updated = false;
-  // Most probably the last log is the one that is being marked for
+  // Most probabely the last log is the one that is being marked for
   // having a prepare section; so search from the end.
   for (; rit != logs_with_prep_.rend() && rit->log >= log; ++rit) {
     if (rit->log == log) {
@@ -97,7 +97,7 @@ uint64_t DBImpl::FindMinLogContainingOutstandingPrep() {
              completed_it->second == it->cnt);
       prepared_section_completed_.erase(completed_it);
     }
-    // erase from beginning in vector is not efficient but this function is not
+    // erase from beigning in vector is not efficient but this function is not
     // on the fast path.
     it = logs_with_prep_.erase(it);
   }
@@ -113,11 +113,11 @@ uint64_t DBImpl::MinLogNumberToKeep() {
     // sections of outstanding transactions.
     //
     // We must check min logs with outstanding prep before we check
-    // logs references by memtables because a log referenced by the
+    // logs referneces by memtables because a log referenced by the
     // first data structure could transition to the second under us.
     //
     // TODO(horuff): iterating over all column families under db mutex.
-    // should find more optimal solution
+    // should find more optimial solution
     auto min_log_in_prep_heap = FindMinLogContainingOutstandingPrep();
 
     if (min_log_in_prep_heap != 0 && min_log_in_prep_heap < log_number) {
@@ -153,7 +153,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
 
   bool doing_the_full_scan = false;
 
-  // logic for figuring out if we're doing the full scan
+  // logic for figurint out if we're doing the full scan
   if (no_full_scan) {
     doing_the_full_scan = false;
   } else if (force ||
@@ -173,7 +173,7 @@ void DBImpl::FindObsoleteFiles(JobContext* job_context, bool force,
   // threads
   // Since job_context->min_pending_output is set, until file scan finishes,
   // mutex_ cannot be released. Otherwise, we might see no min_pending_output
-  // here but later find newer generated unfinalized files while scanning.
+  // here but later find newer generated unfinalized files while scannint.
   if (!pending_outputs_.empty()) {
     job_context->min_pending_output = *pending_outputs_.begin();
   } else {
@@ -344,7 +344,7 @@ void DBImpl::DeleteObsoleteFileImpl(int job_id, const std::string& fname,
 }
 
 // Diffs the files listed in filenames and those that do not
-// belong to live files are possibly removed. Also, removes all the
+// belong to live files are posibly removed. Also, removes all the
 // files in sst_delete_files and log_delete_files.
 // It is not necessary to hold the mutex when invoking this method.
 void DBImpl::PurgeObsoleteFiles(const JobContext& state, bool schedule_only) {

db/db_impl_readonly.h

@@ -76,9 +76,7 @@ class DBImplReadOnly : public DBImpl {
       const CompactionOptions& /*compact_options*/,
       ColumnFamilyHandle* /*column_family*/,
       const std::vector<std::string>& /*input_file_names*/,
-      const int /*output_level*/, const int /*output_path_id*/ = -1,
-      std::vector<std::string>* const /*output_file_names*/ = nullptr
-      ) override {
+      const int /*output_level*/, const int /*output_path_id*/ = -1) override {
     return Status::NotSupported("Not supported operation in read only mode.");
   }
 

db/db_impl_write.cc

@@ -133,8 +133,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
       for (auto* writer : *(w.write_group)) {
         if (!writer->CallbackFailed() && writer->pre_release_callback) {
           assert(writer->sequence != kMaxSequenceNumber);
-          Status ws = writer->pre_release_callback->Callback(writer->sequence,
-                                                             disable_memtable);
+          Status ws = writer->pre_release_callback->Callback(writer->sequence);
           if (!ws.ok()) {
             status = ws;
             break;
@@ -215,7 +214,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
                     write_group.size > 1;
     size_t total_count = 0;
     size_t valid_batches = 0;
-    size_t total_byte_size = 0;
+    uint64_t total_byte_size = 0;
     for (auto* writer : write_group) {
       if (writer->CheckCallback(this)) {
         valid_batches += writer->batch_cnt;
@@ -340,7 +339,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
   PERF_TIMER_START(write_pre_and_post_process_time);
 
   if (!w.CallbackFailed()) {
-    WriteStatusCheck(status);
+    WriteCallbackStatusCheck(status);
   }
 
   if (need_log_sync) {
@@ -369,8 +368,7 @@ Status DBImpl::WriteImpl(const WriteOptions& write_options,
       for (auto* writer : write_group) {
         if (!writer->CallbackFailed() && writer->pre_release_callback) {
           assert(writer->sequence != kMaxSequenceNumber);
-          Status ws = writer->pre_release_callback->Callback(writer->sequence,
-                                                             disable_memtable);
+          Status ws = writer->pre_release_callback->Callback(writer->sequence);
           if (!ws.ok()) {
             status = ws;
             break;
@@ -464,7 +462,7 @@ Status DBImpl::PipelinedWriteImpl(const WriteOptions& write_options,
     }
 
     if (!w.CallbackFailed()) {
-      WriteStatusCheck(w.status);
+      WriteCallbackStatusCheck(w.status);
     }
 
     if (need_log_sync) {
@@ -552,7 +550,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
   // Note: no need to update last_batch_group_size_ here since the batch writes
   // to WAL only
 
-  size_t total_byte_size = 0;
+  uint64_t total_byte_size = 0;
   for (auto* writer : write_group) {
     if (writer->CheckCallback(this)) {
       total_byte_size = WriteBatchInternal::AppendedByteSize(
@@ -625,15 +623,13 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
   PERF_TIMER_START(write_pre_and_post_process_time);
 
   if (!w.CallbackFailed()) {
-    WriteStatusCheck(status);
+    WriteCallbackStatusCheck(status);
   }
   if (status.ok()) {
     for (auto* writer : write_group) {
       if (!writer->CallbackFailed() && writer->pre_release_callback) {
         assert(writer->sequence != kMaxSequenceNumber);
-        const bool DISABLE_MEMTABLE = true;
-        Status ws = writer->pre_release_callback->Callback(writer->sequence,
-                                                           DISABLE_MEMTABLE);
+        Status ws = writer->pre_release_callback->Callback(writer->sequence);
         if (!ws.ok()) {
           status = ws;
           break;
@@ -651,7 +647,7 @@ Status DBImpl::WriteImplWALOnly(const WriteOptions& write_options,
   return status;
 }
 
-void DBImpl::WriteStatusCheck(const Status& status) {
+void DBImpl::WriteCallbackStatusCheck(const Status& status) {
   // Is setting bg_error_ enough here?  This will at least stop
   // compaction and fail any further writes.
   if (immutable_db_options_.paranoid_checks && !status.ok() &&
@@ -1066,8 +1062,7 @@ Status DBImpl::HandleWriteBufferFull(WriteContext* write_context) {
     }
   }
   if (cfd_picked != nullptr) {
-    status = SwitchMemtable(cfd_picked, write_context,
-                            FlushReason::kWriteBufferFull);
+    status = SwitchMemtable(cfd_picked, write_context);
     if (status.ok()) {
       cfd_picked->imm()->FlushRequested();
       SchedulePendingFlush(cfd_picked, FlushReason::kWriteBufferFull);
@@ -1168,7 +1163,7 @@ Status DBImpl::ThrottleLowPriWritesIfNeeded(const WriteOptions& write_options,
 Status DBImpl::ScheduleFlushes(WriteContext* context) {
   ColumnFamilyData* cfd;
   while ((cfd = flush_scheduler_.TakeNextColumnFamily()) != nullptr) {
-    auto status = SwitchMemtable(cfd, context, FlushReason::kWriteBufferFull);
+    auto status = SwitchMemtable(cfd, context);
     if (cfd->Unref()) {
       delete cfd;
     }
@@ -1197,8 +1192,7 @@ void DBImpl::NotifyOnMemTableSealed(ColumnFamilyData* /*cfd*/,
 
 // REQUIRES: mutex_ is held
 // REQUIRES: this thread is currently at the front of the writer queue
-Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
-                              FlushReason flush_reason) {
+Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context) {
   mutex_.AssertHeld();
   WriteThread::Writer nonmem_w;
   if (two_write_queues_) {
@@ -1366,7 +1360,7 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
   new_mem->Ref();
   cfd->SetMemtable(new_mem);
   InstallSuperVersionAndScheduleWork(cfd, &context->superversion_context,
-                                     mutable_cf_options, flush_reason);
+                                     mutable_cf_options);
   if (two_write_queues_) {
     nonmem_write_thread_.ExitUnbatched(&nonmem_w);
   }
@@ -1375,13 +1369,11 @@ Status DBImpl::SwitchMemtable(ColumnFamilyData* cfd, WriteContext* context,
 
 size_t DBImpl::GetWalPreallocateBlockSize(uint64_t write_buffer_size) const {
   mutex_.AssertHeld();
-  size_t bsize = static_cast<size_t>(
-    write_buffer_size / 10 + write_buffer_size);
+  size_t bsize = write_buffer_size / 10 + write_buffer_size;
   // Some users might set very high write_buffer_size and rely on
   // max_total_wal_size or other parameters to control the WAL size.
   if (mutable_db_options_.max_total_wal_size > 0) {
-    bsize = std::min<size_t>(bsize, static_cast<size_t>(
-      mutable_db_options_.max_total_wal_size));
+    bsize = std::min<size_t>(bsize, mutable_db_options_.max_total_wal_size);
   }
   if (immutable_db_options_.db_write_buffer_size > 0) {
     bsize = std::min<size_t>(bsize, immutable_db_options_.db_write_buffer_size);

db/db_merge_operator_test.cc

@@ -284,7 +284,7 @@ TEST_P(MergeOperatorPinningTest, Randomized) {
     Random rnd(301);
     std::map<std::string, std::string> true_data;
 
-    const int kTotalMerges = 5000;
+    const int kTotalMerges = 10000;
     // Every key gets ~10 operands
     const int kKeyRange = kTotalMerges / 10;
     const int kOperandSize = 20;

db/db_properties_test.cc

@@ -69,27 +69,27 @@ TEST_F(DBPropertiesTest, Empty) {
     ASSERT_OK(db_->DisableFileDeletions());
     ASSERT_TRUE(
         dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("1", num);
 
     ASSERT_OK(db_->DisableFileDeletions());
     ASSERT_TRUE(
         dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("2", num);
 
     ASSERT_OK(db_->DisableFileDeletions());
     ASSERT_TRUE(
         dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("3", num);
 
     ASSERT_OK(db_->EnableFileDeletions(false));
     ASSERT_TRUE(
         dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("0", num);
+    ASSERT_EQ("2", num);
 
     ASSERT_OK(db_->EnableFileDeletions());
     ASSERT_TRUE(
         dbfull()->GetProperty("rocksdb.is-file-deletions-enabled", &num));
-    ASSERT_EQ("1", num);
+    ASSERT_EQ("0", num);
   } while (ChangeOptions());
 }
 

db/db_sst_test.cc

@@ -409,11 +409,6 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "DeleteScheduler::DeleteTrashFile:DeleteFile",
       [&](void* arg) { bg_delete_file++; });
-  // The deletion scheduler sometimes skips marking file as trash according to
-  // a heuristic. In that case the deletion will go through the below SyncPoint.
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DeleteScheduler::DeleteFile",
-      [&](void* arg) { bg_delete_file++; });
   rocksdb::SyncPoint::GetInstance()->EnableProcessing();
 
   Options options = CurrentOptions();
@@ -466,15 +461,13 @@ TEST_F(DBSSTTest, DeleteSchedulerMultipleDBPaths) {
   sfm->WaitForEmptyTrash();
   ASSERT_EQ(bg_delete_file, 8);
 
-  // Compaction will delete both files and regenerate a file in L1 in second
-  // db path. The deleted files should still be cleaned up via delete scheduler.
   compact_options.bottommost_level_compaction =
       BottommostLevelCompaction::kForce;
   ASSERT_OK(db_->CompactRange(compact_options, nullptr, nullptr));
   ASSERT_EQ("0,1", FilesPerLevel(0));
 
   sfm->WaitForEmptyTrash();
-  ASSERT_EQ(bg_delete_file, 10);
+  ASSERT_EQ(bg_delete_file, 8);
 
   rocksdb::SyncPoint::GetInstance()->DisableProcessing();
 }
@@ -545,52 +538,6 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowed) {
   ASSERT_NOK(Flush());
 }
 
-TEST_F(DBSSTTest, CancellingCompactionsWorks) {
-  std::shared_ptr<SstFileManager> sst_file_manager(NewSstFileManager(env_));
-  auto sfm = static_cast<SstFileManagerImpl*>(sst_file_manager.get());
-
-  Options options = CurrentOptions();
-  options.sst_file_manager = sst_file_manager;
-  options.level0_file_num_compaction_trigger = 2;
-  options.statistics = CreateDBStatistics();
-  DestroyAndReopen(options);
-
-  int completed_compactions = 0;
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction():CancelledCompaction", [&](void* arg) {
-        sfm->SetMaxAllowedSpaceUsage(0);
-      });
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction:NonTrivial:AfterRun",
-      [&](void* arg) { completed_compactions++; });
-  rocksdb::SyncPoint::GetInstance()->EnableProcessing();
-
-  Random rnd(301);
-
-  // Generate a file containing 10 keys.
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 50)));
-  }
-  ASSERT_OK(Flush());
-  uint64_t total_file_size = 0;
-  auto files_in_db = GetAllSSTFiles(&total_file_size);
-  // Set the maximum allowed space usage to the current total size
-  sfm->SetMaxAllowedSpaceUsage(2 * total_file_size + 1);
-
-  // Generate another file to trigger compaction.
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put(Key(i), RandomString(&rnd, 50)));
-  }
-  ASSERT_OK(Flush());
-  dbfull()->TEST_WaitForCompact(true);
-
-  ASSERT_GT(completed_compactions, 0);
-  ASSERT_EQ(sfm->GetCompactionsReservedSize(), 0);
-  // Make sure the stat is bumped
-  ASSERT_GT(dbfull()->immutable_db_options().statistics.get()->getTickerCount(COMPACTION_CANCELLED), 0);
-  rocksdb::SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {
   // This test will set a maximum allowed space for the DB, then it will
   // keep filling the DB until the limit is reached and bg_error_ is set.
@@ -619,12 +566,6 @@ TEST_F(DBSSTTest, DBWithMaxSpaceAllowedRandomized) {
         estimate_multiplier++;  // used in the main loop assert
       });
 
-  rocksdb::SyncPoint::GetInstance()->SetCallBack(
-      "DBImpl::BackgroundCompaction():CancelledCompaction", [&](void* arg) {
-        bool* enough_room = static_cast<bool*>(arg);
-        *enough_room = true;
-      });
-
   rocksdb::SyncPoint::GetInstance()->SetCallBack(
       "CompactionJob::FinishCompactionOutputFile:MaxAllowedSpaceReached",
       [&](void* arg) {

db/db_tailing_iter_test.cc

@@ -214,9 +214,9 @@ TEST_F(DBTestTailingIterator, TailingIteratorTrimSeekToNext) {
   }
   ASSERT_TRUE(file_iters_renewed_null);
   ASSERT_TRUE(file_iters_renewed_copy);
-  iter = nullptr;
-  itern = nullptr;
-  iterh = nullptr;
+  iter = 0;
+  itern = 0;
+  iterh = 0;
   BlockBasedTableOptions table_options;
   table_options.no_block_cache = true;
   table_options.block_cache_compressed = nullptr;
@@ -229,7 +229,7 @@ TEST_F(DBTestTailingIterator, TailingIteratorTrimSeekToNext) {
   Slice target1(buf5, 20);
   iteri->Seek(target1);
   ASSERT_TRUE(iteri->status().IsIncomplete());
-  iteri = nullptr;
+  iteri = 0;
 
   read_options.read_tier = kReadAllTier;
   options.table_factory.reset(NewBlockBasedTableFactory());

db/db_test.cc

@@ -2411,9 +2411,7 @@ class ModelDB : public DB {
       const CompactionOptions& /*compact_options*/,
       ColumnFamilyHandle* /*column_family*/,
       const std::vector<std::string>& /*input_file_names*/,
-      const int /*output_level*/, const int /*output_path_id*/ = -1,
-      std::vector<std::string>* const /*output_file_names*/ = nullptr
-      ) override {
+      const int /*output_level*/, const int /*output_path_id*/ = -1) override {
     return Status::NotSupported("Not supported operation.");
   }
 
@@ -5155,7 +5153,7 @@ TEST_F(DBTest, AutomaticConflictsWithManualCompaction) {
     }
     ASSERT_OK(Flush());
   }
-  port::Thread manual_compaction_thread([this]() {
+  std::thread manual_compaction_thread([this]() {
     CompactRangeOptions croptions;
     croptions.exclusive_manual_compaction = true;
     ASSERT_OK(db_->CompactRange(croptions, nullptr, nullptr));
@@ -5395,42 +5393,18 @@ TEST_F(DBTest, HardLimit) {
 #ifndef ROCKSDB_LITE
 class WriteStallListener : public EventListener {
  public:
-  WriteStallListener() : cond_(&mutex_), 
-    condition_(WriteStallCondition::kNormal),
-    expected_(WriteStallCondition::kNormal),
-    expected_set_(false) 
-  {}
+  WriteStallListener() : condition_(WriteStallCondition::kNormal) {}
   void OnStallConditionsChanged(const WriteStallInfo& info) override {
     MutexLock l(&mutex_);
     condition_ = info.condition.cur;
-    if (expected_set_ && 
-      condition_ == expected_) {
-        cond_.Signal();
-        expected_set_ = false;
-    }
   }
   bool CheckCondition(WriteStallCondition expected) {
     MutexLock l(&mutex_);
-    if (expected != condition_) {
-      expected_ = expected;
-      expected_set_ = true;
-      while (expected != condition_) {
-        // We bail out on timeout 500 milliseconds
-        const uint64_t timeout_us = 500000;
-        if (cond_.TimedWait(timeout_us)) {
-          expected_set_ = false;
-          return false;
-        }
-      }
-    }
-    return true;
+    return expected == condition_;
   }
  private:
-  port::Mutex   mutex_;
-  port::CondVar cond_;
+  port::Mutex mutex_;
   WriteStallCondition condition_;
-  WriteStallCondition expected_;
-  bool                expected_set_;
 };
 
 TEST_F(DBTest, SoftLimit) {
@@ -5769,7 +5743,7 @@ TEST_F(DBTest, ThreadLocalPtrDeadlock) {
     return flushes_done.load() > 10;
   };
 
-  port::Thread flushing_thread([&] {
+  std::thread flushing_thread([&] {
     for (int i = 0; !done(); ++i) {
       ASSERT_OK(db_->Put(WriteOptions(), Slice("hi"),
                          Slice(std::to_string(i).c_str())));
@@ -5779,12 +5753,12 @@ TEST_F(DBTest, ThreadLocalPtrDeadlock) {
     }
   });
 
-  std::vector<port::Thread> thread_spawning_threads(10);
+  std::vector<std::thread> thread_spawning_threads(10);
   for (auto& t: thread_spawning_threads) {
-    t = port::Thread([&] {
+    t = std::thread([&] {
       while (!done()) {
         {
-          port::Thread tmp_thread([&] {
+          std::thread tmp_thread([&] {
             auto it = db_->NewIterator(ReadOptions());
             delete it;
           });

db/db_test2.cc

@@ -1822,26 +1822,14 @@ TEST_F(DBTest2, ReadAmpBitmapLiveInCacheAfterDBClose) {
   {
     const int kIdBufLen = 100;
     char id_buf[kIdBufLen];
-#ifndef OS_WIN
-    // You can't open a directory on windows using random access file
     std::unique_ptr<RandomAccessFile> file;
-    ASSERT_OK(env_->NewRandomAccessFile(dbname_, &file, EnvOptions()));
+    env_->NewRandomAccessFile(dbname_, &file, EnvOptions());
     if (file->GetUniqueId(id_buf, kIdBufLen) == 0) {
       // fs holding db directory doesn't support getting a unique file id,
       // this means that running this test will fail because lru_cache will load
       // the blocks again regardless of them being already in the cache
       return;
     }
-#else
-    std::unique_ptr<Directory> dir;
-    ASSERT_OK(env_->NewDirectory(dbname_, &dir));
-    if (dir->GetUniqueId(id_buf, kIdBufLen) == 0) {
-      // fs holding db directory doesn't support getting a unique file id,
-      // this means that running this test will fail because lru_cache will load
-      // the blocks again regardless of them being already in the cache
-      return;
-    }
-#endif
   }
   uint32_t bytes_per_bit[2] = {1, 16};
   for (size_t k = 0; k < 2; k++) {

db/db_write_test.cc

@@ -80,22 +80,6 @@ TEST_P(DBWriteTest, IOErrorOnWALWritePropagateToWriteThreadFollower) {
   Close();
 }
 
-TEST_P(DBWriteTest, IOErrorOnWALWriteTriggersReadOnlyMode) {
-  std::unique_ptr<FaultInjectionTestEnv> mock_env(
-      new FaultInjectionTestEnv(Env::Default()));
-  Options options = GetOptions();
-  options.env = mock_env.get();
-  Reopen(options);
-  for (int i = 0; i < 2; i++) {
-    // Forcibly fail WAL write for the first Put only. Subsequent Puts should
-    // fail due to read-only mode
-    mock_env->SetFilesystemActive(i != 0);
-    ASSERT_FALSE(Put("key" + ToString(i), "value").ok());
-  }
-  // Close before mock_env destruct.
-  Close();
-}
-
 INSTANTIATE_TEST_CASE_P(DBWriteTestInstance, DBWriteTest,
                         testing::Values(DBTestBase::kDefault,
                                         DBTestBase::kConcurrentWALWrites,

db/dbformat.cc

@@ -106,6 +106,45 @@ const char* InternalKeyComparator::Name() const {
   return name_.c_str();
 }
 
+int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
+  // Order by:
+  //    increasing user key (according to user-supplied comparator)
+  //    decreasing sequence number
+  //    decreasing type (though sequence# should be enough to disambiguate)
+  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
+  if (r == 0) {
+    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
+    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
+    if (anum > bnum) {
+      r = -1;
+    } else if (anum < bnum) {
+      r = +1;
+    }
+  }
+  return r;
+}
+
+int InternalKeyComparator::CompareKeySeq(const Slice& akey,
+                                         const Slice& bkey) const {
+  // Order by:
+  //    increasing user key (according to user-supplied comparator)
+  //    decreasing sequence number
+  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
+  PERF_COUNTER_ADD(user_key_comparison_count, 1);
+  if (r == 0) {
+    // Shift the number to exclude the last byte which contains the value type
+    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8) >> 8;
+    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8) >> 8;
+    if (anum > bnum) {
+      r = -1;
+    } else if (anum < bnum) {
+      r = +1;
+    }
+  }
+  return r;
+}
+
 int InternalKeyComparator::Compare(const ParsedInternalKey& a,
                                    const ParsedInternalKey& b) const {
   // Order by:

db/dbformat.h

@@ -11,7 +11,6 @@
 #include <stdio.h>
 #include <string>
 #include <utility>
-#include "monitoring/perf_context_imp.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/db.h"
 #include "rocksdb/filter_policy.h"
@@ -608,46 +607,4 @@ struct RangeTombstone {
   }
 };
 
-inline
-int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
-  // Order by:
-  //    increasing user key (according to user-supplied comparator)
-  //    decreasing sequence number
-  //    decreasing type (though sequence# should be enough to disambiguate)
-  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
-  PERF_COUNTER_ADD(user_key_comparison_count, 1);
-  if (r == 0) {
-    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
-    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
-    if (anum > bnum) {
-      r = -1;
-    } else if (anum < bnum) {
-      r = +1;
-    }
-  }
-  return r;
-}
-
-inline
-int InternalKeyComparator::CompareKeySeq(const Slice& akey,
-                                         const Slice& bkey) const {
-  // Order by:
-  //    increasing user key (according to user-supplied comparator)
-  //    decreasing sequence number
-  int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
-  PERF_COUNTER_ADD(user_key_comparison_count, 1);
-  if (r == 0) {
-    // Shift the number to exclude the last byte which contains the value type
-    const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8) >> 8;
-    const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8) >> 8;
-    if (anum > bnum) {
-      r = -1;
-    } else if (anum < bnum) {
-      r = +1;
-    }
-  }
-  return r;
-}
-
-
 }  // namespace rocksdb

db/deletefile_test.cc

@@ -228,7 +228,7 @@ TEST_F(DeleteFileTest, PurgeObsoleteFilesTest) {
 
   // this time, we keep an iterator alive
   ReopenDB(true);
-  Iterator *itr = nullptr;
+  Iterator *itr = 0;
   CreateTwoLevels();
   itr = db_->NewIterator(ReadOptions());
   db_->CompactRange(compact_options, &first_slice, &last_slice);
@@ -249,7 +249,7 @@ TEST_F(DeleteFileTest, BackgroundPurgeTest) {
   Slice first_slice(first), last_slice(last);
 
   // We keep an iterator alive
-  Iterator* itr = nullptr;
+  Iterator* itr = 0;
   CreateTwoLevels();
   ReadOptions options;
   options.background_purge_on_iterator_cleanup = true;
@@ -289,7 +289,7 @@ TEST_F(DeleteFileTest, BackgroundPurgeCopyOptions) {
   Slice first_slice(first), last_slice(last);
 
   // We keep an iterator alive
-  Iterator* itr = nullptr;
+  Iterator* itr = 0;
   CreateTwoLevels();
   ReadOptions* options = new ReadOptions();
   options->background_purge_on_iterator_cleanup = true;

db/external_sst_file_ingestion_job.cc

@@ -407,9 +407,8 @@ Status ExternalSstFileIngestionJob::AssignLevelAndSeqnoForIngestedFile(
 
     if (vstorage->NumLevelFiles(lvl) > 0) {
       bool overlap_with_level = false;
-      status = sv->current->OverlapWithLevelIterator(ro, env_options_,
-          file_to_ingest->smallest_user_key, file_to_ingest->largest_user_key,
-          lvl, &overlap_with_level);
+      status = IngestedFileOverlapWithLevel(sv, file_to_ingest, lvl,
+        &overlap_with_level);
       if (!status.ok()) {
         return status;
       }
@@ -510,15 +509,40 @@ 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()) {
-    status = rwfile->Fsync();
-  }
   if (status.ok()) {
     file_to_ingest->assigned_seqno = seqno;
   }
   return status;
 }
 
+Status ExternalSstFileIngestionJob::IngestedFileOverlapWithIteratorRange(
+    const IngestedFileInfo* file_to_ingest, InternalIterator* iter,
+    bool* overlap) {
+  auto* vstorage = cfd_->current()->storage_info();
+  auto* ucmp = vstorage->InternalComparator()->user_comparator();
+  InternalKey range_start(file_to_ingest->smallest_user_key, kMaxSequenceNumber,
+                          kValueTypeForSeek);
+  iter->Seek(range_start.Encode());
+  if (!iter->status().ok()) {
+    return iter->status();
+  }
+
+  *overlap = false;
+  if (iter->Valid()) {
+    ParsedInternalKey seek_result;
+    if (!ParseInternalKey(iter->key(), &seek_result)) {
+      return Status::Corruption("DB have corrupted keys");
+    }
+
+    if (ucmp->Compare(seek_result.user_key, file_to_ingest->largest_user_key) <=
+        0) {
+      *overlap = true;
+    }
+  }
+
+  return iter->status();
+}
+
 bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
     const IngestedFileInfo* file_to_ingest, int level) {
   if (level == 0) {
@@ -547,6 +571,38 @@ bool ExternalSstFileIngestionJob::IngestedFileFitInLevel(
   return true;
 }
 
+Status ExternalSstFileIngestionJob::IngestedFileOverlapWithLevel(
+    SuperVersion* sv, IngestedFileInfo* file_to_ingest, int lvl,
+    bool* overlap_with_level) {
+  Arena arena;
+  ReadOptions ro;
+  ro.total_order_seek = true;
+  MergeIteratorBuilder merge_iter_builder(&cfd_->internal_comparator(),
+                                          &arena);
+  // Files are opened lazily when the iterator needs them, thus range deletions
+  // are also added lazily to the aggregator. We need to check for range
+  // deletion overlap only in the case where there's no point-key overlap. Then,
+  // we've already opened the file with range containing the ingested file's
+  // begin key, and iterated through all files until the one containing the
+  // ingested file's end key. So any files maybe containing range deletions
+  // overlapping the ingested file must have been opened and had their range
+  // deletions added to the aggregator.
+  RangeDelAggregator range_del_agg(cfd_->internal_comparator(),
+                                   {} /* snapshots */,
+                                   false /* collapse_deletions */);
+  sv->current->AddIteratorsForLevel(ro, env_options_, &merge_iter_builder, lvl,
+                                    &range_del_agg);
+  ScopedArenaIterator level_iter(merge_iter_builder.Finish());
+  Status status = IngestedFileOverlapWithIteratorRange(
+      file_to_ingest, level_iter.get(), overlap_with_level);
+  if (status.ok() && *overlap_with_level == false &&
+      range_del_agg.IsRangeOverlapped(file_to_ingest->smallest_user_key,
+                                      file_to_ingest->largest_user_key)) {
+    *overlap_with_level = true;
+  }
+  return status;
+}
+
 }  // namespace rocksdb
 
 #endif  // !ROCKSDB_LITE

db/external_sst_file_ingestion_job.h

@@ -133,6 +133,17 @@ class ExternalSstFileIngestionJob {
   Status AssignGlobalSeqnoForIngestedFile(IngestedFileInfo* file_to_ingest,
                                           SequenceNumber seqno);
 
+  // Check if `file_to_ingest` key range overlap with the range `iter` represent
+  // REQUIRES: Mutex held
+  Status IngestedFileOverlapWithIteratorRange(
+      const IngestedFileInfo* file_to_ingest, InternalIterator* iter,
+      bool* overlap);
+
+  // Check if `file_to_ingest` key range overlap with level
+  // REQUIRES: Mutex held
+  Status IngestedFileOverlapWithLevel(SuperVersion* sv,
+    IngestedFileInfo* file_to_ingest, int lvl, bool* overlap_with_level);
+
   // Check if `file_to_ingest` can fit in level `level`
   // REQUIRES: Mutex held
   bool IngestedFileFitInLevel(const IngestedFileInfo* file_to_ingest,

db/fault_injection_test.cc

@@ -76,8 +76,8 @@ class FaultInjectionTest : public testing::Test,
         sync_use_wal_(false),
         sync_use_compact_(true),
         base_env_(nullptr),
-        env_(nullptr),
-        db_(nullptr) {
+        env_(NULL),
+        db_(NULL) {
   }
 
   ~FaultInjectionTest() {
@@ -139,9 +139,9 @@ class FaultInjectionTest : public testing::Test,
   }
 
   Status NewDB() {
-    assert(db_ == nullptr);
+    assert(db_ == NULL);
     assert(tiny_cache_ == nullptr);
-    assert(env_ == nullptr);
+    assert(env_ == NULL);
 
     env_ =
         new FaultInjectionTestEnv(base_env_ ? base_env_.get() : Env::Default());
@@ -176,7 +176,7 @@ class FaultInjectionTest : public testing::Test,
     Status s = DestroyDB(dbname_, options_);
 
     delete env_;
-    env_ = nullptr;
+    env_ = NULL;
 
     tiny_cache_.reset();
 

db/flush_job.cc

@@ -56,8 +56,8 @@ namespace rocksdb {
 
 const char* GetFlushReasonString (FlushReason flush_reason) {
   switch (flush_reason) {
-    case FlushReason::kOthers:
-      return "Other Reasons";
+    case FlushReason::kUnknown:
+      return "Unknown";
     case FlushReason::kGetLiveFiles:
       return "Get Live Files";
     case FlushReason::kShutDown:
@@ -72,12 +72,8 @@ const char* GetFlushReasonString (FlushReason flush_reason) {
       return "Write Buffer Full";
     case FlushReason::kTest:
       return "Test";
-    case FlushReason::kDeleteFiles:
-      return "Delete Files";
-    case FlushReason::kAutoCompaction:
-      return "Auto Compaction";
-    case FlushReason::kManualFlush:
-      return "Manual Flush";
+    case FlushReason::kSuperVersionChange:
+      return "SuperVersion Change";
     default:
       return "Invalid";
   }

db/log_test.cc

@@ -163,7 +163,7 @@ class LogTest : public ::testing::TestWithParam<int> {
         source_holder_(
             test::GetSequentialFileReader(new StringSource(reader_contents_))),
         writer_(std::move(dest_holder_), 123, GetParam()),
-        reader_(nullptr, std::move(source_holder_), &report_, true /*checksum*/,
+        reader_(NULL, std::move(source_holder_), &report_, true /*checksum*/,
                 0 /*initial_offset*/, 123) {
     int header_size = GetParam() ? kRecyclableHeaderSize : kHeaderSize;
     initial_offset_last_record_offsets_[0] = 0;
@@ -271,7 +271,7 @@ class LogTest : public ::testing::TestWithParam<int> {
     unique_ptr<SequentialFileReader> file_reader(
         test::GetSequentialFileReader(new StringSource(reader_contents_)));
     unique_ptr<Reader> offset_reader(
-        new Reader(nullptr, std::move(file_reader), &report_,
+        new Reader(NULL, std::move(file_reader), &report_,
                    true /*checksum*/, WrittenBytes() + offset_past_end, 123));
     Slice record;
     std::string scratch;
@@ -284,7 +284,7 @@ class LogTest : public ::testing::TestWithParam<int> {
     unique_ptr<SequentialFileReader> file_reader(
         test::GetSequentialFileReader(new StringSource(reader_contents_)));
     unique_ptr<Reader> offset_reader(
-        new Reader(nullptr, std::move(file_reader), &report_,
+        new Reader(NULL, std::move(file_reader), &report_,
                    true /*checksum*/, initial_offset, 123));
     Slice record;
     std::string scratch;

db/log_writer.cc

@@ -58,8 +58,7 @@ Status Writer::AddRecord(const Slice& slice) {
         // kRecyclableHeaderSize being <= 11)
         assert(header_size <= 11);
         dest_->Append(
-            Slice("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
-                  static_cast<size_t>(leftover)));
+            Slice("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", leftover));
       }
       block_offset_ = 0;
     }

db/log_writer.h

@@ -49,7 +49,7 @@ namespace log {
  * |CRC (4B) | Size (2B) | Type (1B) | Payload   |
  * +---------+-----------+-----------+--- ... ---+
  *
- * CRC = 32bit hash computed over the record type and payload using CRC
+ * CRC = 32bit hash computed over the payload using CRC
  * Size = Length of the payload data
  * Type = Type of record
  *        (kZeroType, kFullType, kFirstType, kLastType, kMiddleType )

db/malloc_stats.cc

@@ -54,5 +54,6 @@ void DumpMallocStats(std::string* stats) {
 #else
 void DumpMallocStats(std::string*) {}
 #endif  // ROCKSDB_JEMALLOC
+
 }
 #endif  // !ROCKSDB_LITE

db/memtable.cc

@@ -229,7 +229,7 @@ int MemTable::KeyComparator::operator()(const char* prefix_len_key1,
 }
 
 int MemTable::KeyComparator::operator()(const char* prefix_len_key,
-                                        const KeyComparator::DecodedType& key)
+                                        const Slice& key)
     const {
   // Internal keys are encoded as length-prefixed strings.
   Slice a = GetLengthPrefixedSlice(prefix_len_key);

db/memtable.h

@@ -64,7 +64,7 @@ struct MemTablePostProcessInfo {
 };
 
 // Note:  Many of the methods in this class have comments indicating that
-// external synchronization is required as these methods are not thread-safe.
+// external synchromization is required as these methods are not thread-safe.
 // It is up to higher layers of code to decide how to prevent concurrent
 // invokation of these methods.  This is usually done by acquiring either
 // the db mutex or the single writer thread.
@@ -84,7 +84,7 @@ class MemTable {
     virtual int operator()(const char* prefix_len_key1,
                            const char* prefix_len_key2) const override;
     virtual int operator()(const char* prefix_len_key,
-                           const DecodedType& key) const override;
+                           const Slice& key) const override;
   };
 
   // MemTables are reference counted.  The initial reference count

db/pre_release_callback.h

@@ -24,9 +24,7 @@ class PreReleaseCallback {
   // propagated to all the writers in the write group.
   // seq is the sequence number that is used for this write and will be
   // released.
-  // is_mem_disabled is currently used for debugging purposes to assert that
-  // the callback is done from the right write queue.
-  virtual Status Callback(SequenceNumber seq, const bool is_mem_disabled) = 0;
+  virtual Status Callback(SequenceNumber seq) = 0;
 };
 
 }  //  namespace rocksdb

db/range_del_aggregator.cc

@@ -536,11 +536,4 @@ bool RangeDelAggregator::IsEmpty() {
   return true;
 }
 
-bool RangeDelAggregator::AddFile(uint64_t file_number) {
-  if (added_files_ == nullptr) {
-    added_files_.reset(new std::set<uint64_t>());
-  }
-  return added_files_->emplace(file_number).second;
-}
-
 }  // namespace rocksdb

db/range_del_aggregator.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include <map>
-#include <set>
 #include <string>
 #include <vector>
 
@@ -141,7 +140,6 @@ class RangeDelAggregator {
                     CompactionIterationStats* range_del_out_stats = nullptr,
                     bool bottommost_level = false);
   bool IsEmpty();
-  bool AddFile(uint64_t file_number);
 
  private:
   // Maps tombstone user start key -> tombstone object
@@ -182,10 +180,6 @@ class RangeDelAggregator {
   const InternalKeyComparator& icmp_;
   // collapse range deletions so they're binary searchable
   const bool collapse_deletions_;
-
-  // Record files whose tombstones have been added, to avoid duplicate adding.
-  // Same as rep_, we initializes it lazily.
-  std::unique_ptr<std::set<uint64_t>> added_files_;
 };
 
 }  // namespace rocksdb

db/table_cache.cc

@@ -247,15 +247,13 @@ InternalIterator* TableCache::NewIterator(
     }
   }
   if (s.ok() && range_del_agg != nullptr && !options.ignore_range_deletions) {
-    if (range_del_agg->AddFile(fd.GetNumber())) {
-      std::unique_ptr<InternalIterator> range_del_iter(
-          table_reader->NewRangeTombstoneIterator(options));
-      if (range_del_iter != nullptr) {
-        s = range_del_iter->status();
-      }
-      if (s.ok()) {
-        s = range_del_agg->AddTombstones(std::move(range_del_iter));
-      }
+    std::unique_ptr<InternalIterator> range_del_iter(
+        table_reader->NewRangeTombstoneIterator(options));
+    if (range_del_iter != nullptr) {
+      s = range_del_iter->status();
+    }
+    if (s.ok()) {
+      s = range_del_agg->AddTombstones(std::move(range_del_iter));
     }
   }
 

db/version_builder.cc

@@ -420,7 +420,7 @@ class VersionBuilder::Rep {
 
   void MaybeAddFile(VersionStorageInfo* vstorage, int level, FileMetaData* f) {
     if (levels_[level].deleted_files.count(f->fd.GetNumber()) > 0) {
-      // f is to-be-deleted table file
+      // f is to-be-delected table file
       vstorage->RemoveCurrentStats(f);
     } else {
       vstorage->AddFile(level, f, info_log_);

db/version_set.cc

@@ -78,33 +78,6 @@ int FindFileInRange(const InternalKeyComparator& icmp,
   return right;
 }
 
-Status OverlapWithIterator(const Comparator* ucmp,
-    const Slice& smallest_user_key,
-    const Slice& largest_user_key,
-    InternalIterator* iter,
-    bool* overlap) {
-  InternalKey range_start(smallest_user_key, kMaxSequenceNumber,
-                          kValueTypeForSeek);
-  iter->Seek(range_start.Encode());
-  if (!iter->status().ok()) {
-    return iter->status();
-  }
-
-  *overlap = false;
-  if (iter->Valid()) {
-    ParsedInternalKey seek_result;
-    if (!ParseInternalKey(iter->key(), &seek_result)) {
-      return Status::Corruption("DB have corrupted keys");
-    }
-
-    if (ucmp->Compare(seek_result.user_key, largest_user_key) <= 0) {
-      *overlap = true;
-    }
-  }
-
-  return iter->status();
-}
-
 // Class to help choose the next file to search for the particular key.
 // Searches and returns files level by level.
 // We can search level-by-level since entries never hop across
@@ -1037,59 +1010,6 @@ void Version::AddIteratorsForLevel(const ReadOptions& read_options,
   }
 }
 
-Status Version::OverlapWithLevelIterator(const ReadOptions& read_options,
-                                         const EnvOptions& env_options,
-                                         const Slice& smallest_user_key,
-                                         const Slice& largest_user_key,
-                                         int level, bool* overlap) {
-  assert(storage_info_.finalized_);
-
-  auto icmp = cfd_->internal_comparator();
-  auto ucmp = icmp.user_comparator();
-
-  Arena arena;
-  Status status;
-  RangeDelAggregator range_del_agg(icmp, {}, false);
-
-  *overlap = false;
-
-  if (level == 0) {
-    for (size_t i = 0; i < storage_info_.LevelFilesBrief(0).num_files; i++) {
-      const auto file = &storage_info_.LevelFilesBrief(0).files[i];
-      if (AfterFile(ucmp, &smallest_user_key, file) ||
-          BeforeFile(ucmp, &largest_user_key, file)) {
-        continue;
-      }
-      ScopedArenaIterator iter(cfd_->table_cache()->NewIterator(
-          read_options, env_options, cfd_->internal_comparator(), file->fd,
-          &range_del_agg, nullptr, cfd_->internal_stats()->GetFileReadHist(0),
-          false, &arena, false /* skip_filters */, 0 /* level */));
-      status = OverlapWithIterator(
-          ucmp, smallest_user_key, largest_user_key, iter.get(), overlap);
-      if (!status.ok() || *overlap) {
-        break;
-      }
-    }
-  } else if (storage_info_.LevelFilesBrief(level).num_files > 0) {
-    auto mem = arena.AllocateAligned(sizeof(LevelIterator));
-    ScopedArenaIterator iter(new (mem) LevelIterator(
-        cfd_->table_cache(), read_options, env_options,
-        cfd_->internal_comparator(), &storage_info_.LevelFilesBrief(level),
-        should_sample_file_read(),
-        cfd_->internal_stats()->GetFileReadHist(level),
-        false /* for_compaction */, IsFilterSkipped(level), level,
-        &range_del_agg));
-    status = OverlapWithIterator(
-        ucmp, smallest_user_key, largest_user_key, iter.get(), overlap);
-  }
-
-  if (status.ok() && *overlap == false &&
-      range_del_agg.IsRangeOverlapped(smallest_user_key, largest_user_key)) {
-    *overlap = true;
-  }
-  return status;
-}
-
 VersionStorageInfo::VersionStorageInfo(
     const InternalKeyComparator* internal_comparator,
     const Comparator* user_comparator, int levels,
@@ -1834,8 +1754,7 @@ void SortFileByOverlappingRatio(
 
 void VersionStorageInfo::UpdateFilesByCompactionPri(
     CompactionPri compaction_pri) {
-  if (compaction_style_ == kCompactionStyleNone ||
-      compaction_style_ == kCompactionStyleFIFO ||
+  if (compaction_style_ == kCompactionStyleFIFO ||
       compaction_style_ == kCompactionStyleUniversal) {
     // don't need this
     return;
@@ -3096,7 +3015,7 @@ Status VersionSet::Recover(
   {
     VersionSet::LogReporter reporter;
     reporter.status = &s;
-    log::Reader reader(nullptr, std::move(manifest_file_reader), &reporter,
+    log::Reader reader(NULL, std::move(manifest_file_reader), &reporter,
                        true /*checksum*/, 0 /*initial_offset*/, 0);
     Slice record;
     std::string scratch;
@@ -3365,7 +3284,7 @@ Status VersionSet::ListColumnFamilies(std::vector<std::string>* column_families,
   column_family_names.insert({0, kDefaultColumnFamilyName});
   VersionSet::LogReporter reporter;
   reporter.status = &s;
-  log::Reader reader(nullptr, std::move(file_reader), &reporter, true /*checksum*/,
+  log::Reader reader(NULL, std::move(file_reader), &reporter, true /*checksum*/,
                      0 /*initial_offset*/, 0);
   Slice record;
   std::string scratch;
@@ -3525,7 +3444,7 @@ Status VersionSet::DumpManifest(Options& options, std::string& dscname,
   {
     VersionSet::LogReporter reporter;
     reporter.status = &s;
-    log::Reader reader(nullptr, std::move(file_reader), &reporter,
+    log::Reader reader(NULL, std::move(file_reader), &reporter,
                        true /*checksum*/, 0 /*initial_offset*/, 0);
     Slice record;
     std::string scratch;

db/version_set.h

@@ -115,7 +115,7 @@ class VersionStorageInfo {
   // Update the accumulated stats from a file-meta.
   void UpdateAccumulatedStats(FileMetaData* file_meta);
 
-  // Decrease the current stat from a to-be-deleted file-meta
+  // Decrease the current stat form a to-be-delected file-meta
   void RemoveCurrentStats(FileMetaData* file_meta);
 
   void ComputeCompensatedSizes();
@@ -491,7 +491,7 @@ class VersionStorageInfo {
   uint64_t accumulated_num_deletions_;
   // current number of non_deletion entries
   uint64_t current_num_non_deletions_;
-  // current number of deletion entries
+  // current number of delection entries
   uint64_t current_num_deletions_;
   // current number of file samples
   uint64_t current_num_samples_;
@@ -525,11 +525,6 @@ class Version {
                             MergeIteratorBuilder* merger_iter_builder,
                             int level, RangeDelAggregator* range_del_agg);
 
-  Status OverlapWithLevelIterator(const ReadOptions&, const EnvOptions&,
-                                  const Slice& smallest_user_key,
-                                  const Slice& largest_user_key,
-                                  int level, bool* overlap);
-
   // Lookup the value for key.  If found, store it in *val and
   // return OK.  Else return a non-OK status.
   // Uses *operands to store merge_operator operations to apply later.
@@ -570,13 +565,13 @@ class Version {
   // Return a human readable string that describes this version's contents.
   std::string DebugString(bool hex = false, bool print_stats = false) const;
 
-  // Returns the version number of this version
+  // Returns the version nuber of this version
   uint64_t GetVersionNumber() const { return version_number_; }
 
   // REQUIRES: lock is held
   // On success, "tp" will contains the table properties of the file
   // specified in "file_meta".  If the file name of "file_meta" is
-  // known ahead, passing it by a non-null "fname" can save a
+  // known ahread, passing it by a non-null "fname" can save a
   // file-name conversion.
   Status GetTableProperties(std::shared_ptr<const TableProperties>* tp,
                             const FileMetaData* file_meta,
@@ -585,14 +580,14 @@ class Version {
   // REQUIRES: lock is held
   // On success, *props will be populated with all SSTables' table properties.
   // The keys of `props` are the sst file name, the values of `props` are the
-  // tables' properties, represented as shared_ptr.
+  // tables' propertis, represented as shared_ptr.
   Status GetPropertiesOfAllTables(TablePropertiesCollection* props);
   Status GetPropertiesOfAllTables(TablePropertiesCollection* props, int level);
   Status GetPropertiesOfTablesInRange(const Range* range, std::size_t n,
                                       TablePropertiesCollection* props) const;
 
   // REQUIRES: lock is held
-  // On success, "tp" will contains the aggregated table property among
+  // On success, "tp" will contains the aggregated table property amoug
   // the table properties of all sst files in this version.
   Status GetAggregatedTableProperties(
       std::shared_ptr<const TableProperties>* tp, int level = -1);
@@ -642,7 +637,7 @@ class Version {
   bool IsFilterSkipped(int level, bool is_file_last_in_level = false);
 
   // The helper function of UpdateAccumulatedStats, which may fill the missing
-  // fields of file_meta from its associated TableProperties.
+  // fields of file_mata from its associated TableProperties.
   // Returns true if it does initialize FileMetaData.
   bool MaybeInitializeFileMetaData(FileMetaData* file_meta);
 
@@ -780,7 +775,7 @@ class VersionSet {
   // Set the last sequence number to s.
   void SetLastSequence(uint64_t s) {
     assert(s >= last_sequence_);
-    // Last visible sequence must always be less than last written seq
+    // Last visible seqeunce must always be less than last written seq
     assert(!db_options_->two_write_queues || s <= last_allocated_sequence_);
     last_sequence_.store(s, std::memory_order_release);
   }
@@ -918,7 +913,7 @@ class VersionSet {
   // The last allocated sequence that is also published to the readers. This is
   // applicable only when last_seq_same_as_publish_seq_ is not set. Otherwise
   // last_sequence_ also indicates the last published seq.
-  // We have last_sequence <= last_published_sequence_ <=
+  // We have last_sequence <= last_published_seqeunce_ <=
   // last_allocated_sequence_
   std::atomic<uint64_t> last_published_sequence_;
   uint64_t prev_log_number_;  // 0 or backing store for memtable being compacted

db/write_batch.cc

@@ -52,7 +52,6 @@
 #include "monitoring/statistics.h"
 #include "rocksdb/merge_operator.h"
 #include "util/coding.h"
-#include "util/duplicate_detector.h"
 #include "util/string_util.h"
 
 namespace rocksdb {
@@ -397,7 +396,7 @@ Status WriteBatch::Iterate(Handler* handler) const {
   input.remove_prefix(WriteBatchInternal::kHeader);
   Slice key, value, blob, xid;
   // Sometimes a sub-batch starts with a Noop. We want to exclude such Noops as
-  // the batch boundary symbols otherwise we would mis-count the number of
+  // the batch boundry sybmols otherwise we would mis-count the number of
   // batches. We do that by checking whether the accumulated batch is empty
   // before seeing the next Noop.
   bool empty_batch = true;
@@ -1009,9 +1008,6 @@ class MemTableInserter : public WriteBatch::Handler {
   bool seq_per_batch_;
   // Whether the memtable write will be done only after the commit
   bool write_after_commit_;
-  using DupDetector = std::aligned_storage<sizeof(DuplicateDetector)>::type;
-  DupDetector       duplicate_detector_;
-  bool              dup_dectector_on_;
 
   MemPostInfoMap& GetPostMap() {
     assert(concurrent_memtable_writes_);
@@ -1022,17 +1018,6 @@ class MemTableInserter : public WriteBatch::Handler {
     return *reinterpret_cast<MemPostInfoMap*>(&mem_post_info_map_);
   }
 
-  bool IsDuplicateKeySeq(uint32_t column_family_id, const Slice& key) {
-    assert(!write_after_commit_);
-    assert(rebuilding_trx_ != nullptr);
-    if (!dup_dectector_on_) {
-      new (&duplicate_detector_) DuplicateDetector(db_);
-      dup_dectector_on_ = true;
-    }
-    return reinterpret_cast<DuplicateDetector*>
-      (&duplicate_detector_)->IsDuplicateKeySeq(column_family_id, key, sequence_);
-  }
-
  protected:
   virtual bool WriteAfterCommit() const override { return write_after_commit_; }
 
@@ -1060,17 +1045,11 @@ class MemTableInserter : public WriteBatch::Handler {
         // Write after commit currently uses one seq per key (instead of per
         // batch). So seq_per_batch being false indicates write_after_commit
         // approach.
-        write_after_commit_(!seq_per_batch),
-        duplicate_detector_(),
-        dup_dectector_on_(false) {
+        write_after_commit_(!seq_per_batch) {
     assert(cf_mems_);
   }
 
   ~MemTableInserter() {
-    if (dup_dectector_on_) {
-      reinterpret_cast<DuplicateDetector*>
-        (&duplicate_detector_)->~DuplicateDetector();
-    }
     if (post_info_created_) {
       reinterpret_cast<MemPostInfoMap*>
         (&mem_post_info_map_)->~MemPostInfoMap();
@@ -1088,11 +1067,11 @@ class MemTableInserter : public WriteBatch::Handler {
   // is set when a batch, which is tagged with seq, is read from the WAL.
   // Within a sequenced batch, which could be a merge of multiple batches, we
   // have two policies to advance the seq: i) seq_per_key (default) and ii)
-  // seq_per_batch. To implement the latter we need to mark the boundary between
+  // seq_per_batch. To implement the latter we need to mark the boundry between
   // the individual batches. The approach is this: 1) Use the terminating
-  // markers to indicate the boundary (kTypeEndPrepareXID, kTypeCommitXID,
-  // kTypeRollbackXID) 2) Terminate a batch with kTypeNoop in the absence of a
-  // natural boundary marker.
+  // markers to indicate the boundry (kTypeEndPrepareXID, kTypeCommitXID,
+  // kTypeRollbackXID) 2) Terminate a batch with kTypeNoop in the absense of a
+  // natural boundy marker.
   void MaybeAdvanceSeq(bool batch_boundry = false) {
     if (batch_boundry == seq_per_batch_) {
       sequence_++;
@@ -1156,24 +1135,17 @@ class MemTableInserter : public WriteBatch::Handler {
 
   Status PutCFImpl(uint32_t column_family_id, const Slice& key,
                    const Slice& value, ValueType value_type) {
-    // optimize for non-recovery mode
-    if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
+    if (rebuilding_trx_ != nullptr) {
       WriteBatchInternal::Put(rebuilding_trx_, column_family_id, key, value);
-      return Status::OK();
+      if (write_after_commit_) {
+        return Status::OK();
+      }
       // else insert the values to the memtable right away
     }
 
     Status seek_status;
-    if (UNLIKELY(!SeekToColumnFamily(column_family_id, &seek_status))) {
-      bool batch_boundry = false;
-      if (rebuilding_trx_ != nullptr) {
-        assert(!write_after_commit_);
-        // The CF is probably flushed and hence no need for insert but we still
-        // need to keep track of the keys for upcoming rollback/commit.
-        WriteBatchInternal::Put(rebuilding_trx_, column_family_id, key, value);
-        batch_boundry = IsDuplicateKeySeq(column_family_id, key);
-      }
-      MaybeAdvanceSeq(batch_boundry);
+    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
+      MaybeAdvanceSeq();
       return seek_status;
     }
     Status ret_status;
@@ -1243,14 +1215,7 @@ class MemTableInserter : public WriteBatch::Handler {
         }
       }
     }
-    // optimize for non-recovery mode
-    if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) {
-      assert(!write_after_commit_);
-      // If the ret_status is TryAgain then let the next try to add the ky to
-      // the rebuilding transaction object.
-      WriteBatchInternal::Put(rebuilding_trx_, column_family_id, key, value);
-    }
-    // Since all Puts are logged in transaction logs (if enabled), always bump
+    // Since all Puts are logged in trasaction logs (if enabled), always bump
     // sequence number. Even if the update eventually fails and does not result
     // in memtable add/update.
     MaybeAdvanceSeq();
@@ -1283,99 +1248,57 @@ class MemTableInserter : public WriteBatch::Handler {
 
   virtual Status DeleteCF(uint32_t column_family_id,
                           const Slice& key) override {
-    // optimize for non-recovery mode
-    if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
+    if (rebuilding_trx_ != nullptr) {
       WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
-      return Status::OK();
+      if (write_after_commit_) {
+        return Status::OK();
+      }
       // else insert the values to the memtable right away
     }
 
     Status seek_status;
-    if (UNLIKELY(!SeekToColumnFamily(column_family_id, &seek_status))) {
-      bool batch_boundry = false;
-      if (rebuilding_trx_ != nullptr) {
-        assert(!write_after_commit_);
-        // The CF is probably flushed and hence no need for insert but we still
-        // need to keep track of the keys for upcoming rollback/commit.
-        WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
-        batch_boundry = IsDuplicateKeySeq(column_family_id, key);
-      }
-      MaybeAdvanceSeq(batch_boundry);
+    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
+      MaybeAdvanceSeq();
       return seek_status;
     }
 
-    auto ret_status = DeleteImpl(column_family_id, key, Slice(), kTypeDeletion);
-    // optimize for non-recovery mode
-    if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) {
-      assert(!write_after_commit_);
-      // If the ret_status is TryAgain then let the next try to add the ky to
-      // the rebuilding transaction object.
-      WriteBatchInternal::Delete(rebuilding_trx_, column_family_id, key);
-    }
-    return ret_status;
+    return DeleteImpl(column_family_id, key, Slice(), kTypeDeletion);
   }
 
   virtual Status SingleDeleteCF(uint32_t column_family_id,
                                 const Slice& key) override {
-    // optimize for non-recovery mode
-    if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
+    if (rebuilding_trx_ != nullptr) {
       WriteBatchInternal::SingleDelete(rebuilding_trx_, column_family_id, key);
-      return Status::OK();
+      if (write_after_commit_) {
+        return Status::OK();
+      }
       // else insert the values to the memtable right away
     }
 
     Status seek_status;
-    if (UNLIKELY(!SeekToColumnFamily(column_family_id, &seek_status))) {
-      bool batch_boundry = false;
-      if (rebuilding_trx_ != nullptr) {
-        assert(!write_after_commit_);
-        // The CF is probably flushed and hence no need for insert but we still
-        // need to keep track of the keys for upcoming rollback/commit.
-        WriteBatchInternal::SingleDelete(rebuilding_trx_, column_family_id,
-                                         key);
-        batch_boundry = IsDuplicateKeySeq(column_family_id, key);
-      }
-      MaybeAdvanceSeq(batch_boundry);
+    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
+      MaybeAdvanceSeq();
       return seek_status;
     }
 
-    auto ret_status =
-        DeleteImpl(column_family_id, key, Slice(), kTypeSingleDeletion);
-    // optimize for non-recovery mode
-    if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) {
-      assert(!write_after_commit_);
-      // If the ret_status is TryAgain then let the next try to add the ky to
-      // the rebuilding transaction object.
-      WriteBatchInternal::SingleDelete(rebuilding_trx_, column_family_id, key);
-    }
-    return ret_status;
+    return DeleteImpl(column_family_id, key, Slice(), kTypeSingleDeletion);
   }
 
   virtual Status DeleteRangeCF(uint32_t column_family_id,
                                const Slice& begin_key,
                                const Slice& end_key) override {
-    // optimize for non-recovery mode
-    if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
+    if (rebuilding_trx_ != nullptr) {
       WriteBatchInternal::DeleteRange(rebuilding_trx_, column_family_id,
                                       begin_key, end_key);
-      return Status::OK();
+      if (write_after_commit_) {
+        return Status::OK();
+      }
       // else insert the values to the memtable right away
     }
 
     Status seek_status;
-    if (UNLIKELY(!SeekToColumnFamily(column_family_id, &seek_status))) {
-      bool batch_boundry = false;
-      if (rebuilding_trx_ != nullptr) {
-        assert(!write_after_commit_);
-        // The CF is probably flushed and hence no need for insert but we still
-        // need to keep track of the keys for upcoming rollback/commit.
-        WriteBatchInternal::DeleteRange(rebuilding_trx_, column_family_id,
-                                        begin_key, end_key);
-        // TODO(myabandeh): when transactional DeleteRange support is added,
-        // check if end_key must also be added.
-        batch_boundry = IsDuplicateKeySeq(column_family_id, begin_key);
-      }
-      MaybeAdvanceSeq(batch_boundry);
+    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
+      MaybeAdvanceSeq();
       return seek_status;
     }
     if (db_ != nullptr) {
@@ -1392,41 +1315,23 @@ class MemTableInserter : public WriteBatch::Handler {
       }
     }
 
-    auto ret_status =
-        DeleteImpl(column_family_id, begin_key, end_key, kTypeRangeDeletion);
-    // optimize for non-recovery mode
-    if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) {
-      assert(!write_after_commit_);
-      // If the ret_status is TryAgain then let the next try to add the ky to
-      // the rebuilding transaction object.
-      WriteBatchInternal::DeleteRange(rebuilding_trx_, column_family_id,
-                                      begin_key, end_key);
-    }
-    return ret_status;
+    return DeleteImpl(column_family_id, begin_key, end_key, kTypeRangeDeletion);
   }
 
   virtual Status MergeCF(uint32_t column_family_id, const Slice& key,
                          const Slice& value) override {
     assert(!concurrent_memtable_writes_);
-    // optimize for non-recovery mode
-    if (UNLIKELY(write_after_commit_ && rebuilding_trx_ != nullptr)) {
+    if (rebuilding_trx_ != nullptr) {
       WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, key, value);
-      return Status::OK();
+      if (write_after_commit_) {
+        return Status::OK();
+      }
       // else insert the values to the memtable right away
     }
 
     Status seek_status;
-    if (UNLIKELY(!SeekToColumnFamily(column_family_id, &seek_status))) {
-      bool batch_boundry = false;
-      if (rebuilding_trx_ != nullptr) {
-        assert(!write_after_commit_);
-        // The CF is probably flushed and hence no need for insert but we still
-        // need to keep track of the keys for upcoming rollback/commit.
-        WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, key,
-                                  value);
-        batch_boundry = IsDuplicateKeySeq(column_family_id, key);
-      }
-      MaybeAdvanceSeq(batch_boundry);
+    if (!SeekToColumnFamily(column_family_id, &seek_status)) {
+      MaybeAdvanceSeq();
       return seek_status;
     }
 
@@ -1507,13 +1412,6 @@ class MemTableInserter : public WriteBatch::Handler {
       }
     }
 
-    // optimize for non-recovery mode
-    if (UNLIKELY(!ret_status.IsTryAgain() && rebuilding_trx_ != nullptr)) {
-      assert(!write_after_commit_);
-      // If the ret_status is TryAgain then let the next try to add the ky to
-      // the rebuilding transaction object.
-      WriteBatchInternal::Merge(rebuilding_trx_, column_family_id, key, value);
-    }
     MaybeAdvanceSeq();
     CheckMemtableFull();
     return ret_status;
@@ -1568,13 +1466,8 @@ class MemTableInserter : public WriteBatch::Handler {
 
     if (recovering_log_number_ != 0) {
       assert(db_->allow_2pc());
-      size_t batch_cnt =
-          write_after_commit_
-              ? 0  // 0 will disable further checks
-              : static_cast<size_t>(sequence_ - rebuilding_trx_seq_ + 1);
       db_->InsertRecoveredTransaction(recovering_log_number_, name.ToString(),
-                                      rebuilding_trx_, rebuilding_trx_seq_,
-                                      batch_cnt);
+                                      rebuilding_trx_, rebuilding_trx_seq_);
       rebuilding_trx_ = nullptr;
     } else {
       assert(rebuilding_trx_ == nullptr);
@@ -1609,7 +1502,7 @@ class MemTableInserter : public WriteBatch::Handler {
       // and commit.
       auto trx = db_->GetRecoveredTransaction(name.ToString());
 
-      // the log containing the prepared section may have
+      // the log contaiting the prepared section may have
       // been released in the last incarnation because the
       // data was flushed to L0
       if (trx != nullptr) {
@@ -1617,7 +1510,7 @@ class MemTableInserter : public WriteBatch::Handler {
         // duplicate re-insertion of values.
         assert(log_number_ref_ == 0);
         if (write_after_commit_) {
-          // all inserts must reference this trx log number
+          // all insertes must reference this trx log number
           log_number_ref_ = trx->log_number_;
           s = trx->batch_->Iterate(this);
           log_number_ref_ = 0;

db/write_batch_internal.h

@@ -117,10 +117,10 @@ class WriteBatchInternal {
   // Set the count for the number of entries in the batch.
   static void SetCount(WriteBatch* batch, int n);
 
-  // Return the sequence number for the start of this batch.
+  // Return the seqeunce number for the start of this batch.
   static SequenceNumber Sequence(const WriteBatch* batch);
 
-  // Store the specified number as the sequence number for the start of
+  // Store the specified number as the seqeunce number for the start of
   // this batch.
   static void SetSequence(WriteBatch* batch, SequenceNumber seq);
 
@@ -168,7 +168,7 @@ class WriteBatchInternal {
                            bool seq_per_batch = false);
 
   // Convenience form of InsertInto when you have only one batch
-  // next_seq returns the seq after last sequence number used in MemTable insert
+  // next_seq returns the seq after last sequnce number used in MemTable insert
   static Status InsertInto(const WriteBatch* batch,
                            ColumnFamilyMemTables* memtables,
                            FlushScheduler* flush_scheduler,

db/write_callback_test.cc

@@ -294,8 +294,7 @@ TEST_F(WriteCallbackTest, WriteWithCallbackTest) {
                    public:
                     PublishSeqCallback(DBImpl* db_impl_in)
                         : db_impl_(db_impl_in) {}
-                    virtual Status Callback(SequenceNumber last_seq,
-                                            const bool /*not used*/) override {
+                    virtual Status Callback(SequenceNumber last_seq) {
                       db_impl_->SetLastPublishedSequence(last_seq);
                       return Status::OK();
                     }

env/env.cc

@@ -73,7 +73,7 @@ RandomAccessFile::~RandomAccessFile() {
 WritableFile::~WritableFile() {
 }
 
-Logger::~Logger() {}
+Logger::~Logger() { }
 
 Status Logger::Close() {
   if (!closed_) {

env/env_encryption.cc

@@ -150,7 +150,7 @@ class EncryptedRandomAccessFile : public RandomAccessFile {
   // may not have been modified.
   //
   // This function guarantees, for IDs from a given environment, two unique ids
-  // cannot be made equal to each other by adding arbitrary bytes to one of
+  // cannot be made equal to eachother by adding arbitrary bytes to one of
   // them. That is, no unique ID is the prefix of another.
   //
   // This function guarantees that the returned ID will not be interpretable as
@@ -584,7 +584,7 @@ class EncryptedEnv : public EnvWrapper {
     return Status::OK();
   }
 
-  // Open `fname` for random read and write, if file doesn't exist the file
+  // Open `fname` for random read and write, if file dont exist the file
   // will be created.  On success, stores a pointer to the new file in
   // *result and returns OK.  On failure returns non-OK.
   //
@@ -828,7 +828,7 @@ Status CTRCipherStream::DecryptBlock(uint64_t blockIndex, char *data, char* scra
 // GetPrefixLength returns the length of the prefix that is added to every file
 // and used for storing encryption options.
 // For optimal performance, the prefix length should be a multiple of 
-// the page size.
+// the a page size.
 size_t CTREncryptionProvider::GetPrefixLength() {
   return defaultPrefixLength;
 }

env/env_hdfs.cc

@@ -288,7 +288,9 @@ class HdfsLogger : public Logger {
   }
 
  protected:
-  virtual Status CloseImpl() override { return HdfsCloseHelper(); }
+  virtual Status CloseImpl() override {
+    return HdfsCloseHelper();
+  }
 
  public:
   HdfsLogger(HdfsWritableFile* f, uint64_t (*gettid)())

env/env_posix.cc

@@ -647,7 +647,7 @@ class PosixEnv : public Env {
 
   virtual void Schedule(void (*function)(void* arg1), void* arg,
                         Priority pri = LOW, void* tag = nullptr,
-                        void (*unschedFunction)(void* arg) = nullptr) override;
+                        void (*unschedFunction)(void* arg) = 0) override;
 
   virtual int UnSchedule(void* arg, Priority pri) override;
 

env/env_test.cc

@@ -135,37 +135,6 @@ TEST_F(EnvPosixTest, RunImmediately) {
   }
 }
 
-#ifdef OS_WIN
-TEST_F(EnvPosixTest, AreFilesSame) {
-  {
-    bool tmp;
-    if (env_->AreFilesSame("", "", &tmp).IsNotSupported()) {
-      fprintf(stderr,
-              "skipping EnvBasicTestWithParam.AreFilesSame due to "
-              "unsupported Env::AreFilesSame\n");
-      return;
-    }
-  }
-
-  const EnvOptions soptions;
-  auto* env = Env::Default();
-  std::string same_file_name = test::TmpDir(env) + "/same_file";
-  std::string same_file_link_name = same_file_name + "_link";
-
-  std::unique_ptr<WritableFile> same_file;
-  ASSERT_OK(env->NewWritableFile(same_file_name,
-    &same_file, soptions));
-  same_file->Append("random_data");
-  ASSERT_OK(same_file->Flush());
-  same_file.reset();
-
-  ASSERT_OK(env->LinkFile(same_file_name, same_file_link_name));
-  bool result = false;
-  ASSERT_OK(env->AreFilesSame(same_file_name, same_file_link_name, &result));
-  ASSERT_TRUE(result);
-}
-#endif
-
 TEST_P(EnvPosixTestWithParam, UnSchedule) {
   std::atomic<bool> called(false);
   env_->SetBackgroundThreads(1, Env::LOW);
@@ -1174,7 +1143,7 @@ TEST_P(EnvPosixTestWithParam, Preallocation) {
     unique_ptr<WritableFile> srcfile;
     EnvOptions soptions;
     soptions.use_direct_reads = soptions.use_direct_writes = direct_io_;
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX) && !defined(OS_OPENBSD) && !defined(OS_FREEBSD)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX) && !defined(OS_OPENBSD)
     if (soptions.use_direct_writes) {
       rocksdb::SyncPoint::GetInstance()->SetCallBack(
           "NewWritableFile:O_DIRECT", [&](void* arg) {
@@ -1236,7 +1205,7 @@ TEST_P(EnvPosixTestWithParam, ConsistentChildrenAttributes) {
       oss << test::TmpDir(env_) << "/testfile_" << i;
       const std::string path = oss.str();
       unique_ptr<WritableFile> file;
-#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX) && !defined(OS_OPENBSD) && !defined(OS_FREEBSD)
+#if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(OS_SOLARIS) && !defined(OS_AIX) && !defined(OS_OPENBSD)
       if (soptions.use_direct_writes) {
         rocksdb::SyncPoint::GetInstance()->SetCallBack(
             "NewWritableFile:O_DIRECT", [&](void* arg) {
@@ -1514,46 +1483,48 @@ class TestEnv : public EnvWrapper {
     explicit TestEnv() : EnvWrapper(Env::Default()),
                 close_count(0) { }
 
-  class TestLogger : public Logger {
-   public:
-    using Logger::Logv;
-    TestLogger(TestEnv* env_ptr) : Logger() { env = env_ptr; }
-    ~TestLogger() {
-      if (!closed_) {
-        CloseHelper();
-      }
-    }
-    virtual void Logv(const char* format, va_list ap) override{};
+    class TestLogger : public Logger {
+      public:
+        using Logger::Logv;
+        TestLogger(TestEnv *env_ptr) : Logger() { env = env_ptr; }
+        ~TestLogger() {
+          if (!closed_) {
+            CloseHelper();
+          }
+        }
+        virtual void Logv(const char* /*format*/, va_list /*ap*/) override{};
 
-   protected:
-    virtual Status CloseImpl() override { return CloseHelper(); }
+       protected:
+        virtual Status CloseImpl() override {
+          return CloseHelper();
+        }
+      private:
+        Status CloseHelper() {
+          env->CloseCountInc();;
+          return Status::OK();
+        }
+        TestEnv *env;
+    };
 
-   private:
-    Status CloseHelper() {
-      env->CloseCountInc();;
+    void CloseCountInc() { close_count++; }
+
+    int GetCloseCount() { return close_count; }
+
+    virtual Status NewLogger(const std::string& /*fname*/,
+                             shared_ptr<Logger>* result) {
+      result->reset(new TestLogger(this));
       return Status::OK();
     }
-    TestEnv* env;
-  };
 
-  void CloseCountInc() { close_count++; }
-
-  int GetCloseCount() { return close_count; }
-
-  virtual Status NewLogger(const std::string& fname,
-                           shared_ptr<Logger>* result) {
-    result->reset(new TestLogger(this));
-    return Status::OK();
-  }
-
- private:
-  int close_count;
+  private:
+    int close_count;
 };
 
-class EnvTest : public testing::Test {};
+class EnvTest : public testing::Test {
+};
 
 TEST_F(EnvTest, Close) {
-  TestEnv* env = new TestEnv();
+  TestEnv *env = new TestEnv();
   std::shared_ptr<Logger> logger;
   Status s;
 
@@ -1575,6 +1546,7 @@ TEST_F(EnvTest, Close) {
   delete env;
 }
 
+
 INSTANTIATE_TEST_CASE_P(DefaultEnvWithoutDirectIO, EnvPosixTestWithParam,
                         ::testing::Values(std::pair<Env*, bool>(Env::Default(),
                                                                 false)));

env/mock_env.cc

@@ -94,37 +94,35 @@ class MemFile {
     uint64_t end = std::min(start + 512, size_.load());
     MutexLock lock(&mutex_);
     for (uint64_t pos = start; pos < end; ++pos) {
-      data_[static_cast<size_t>(pos)] = static_cast<char>(rnd_.Uniform(256));
+      data_[pos] = static_cast<char>(rnd_.Uniform(256));
     }
   }
 
   Status Read(uint64_t offset, size_t n, Slice* result, char* scratch) const {
     MutexLock lock(&mutex_);
     const uint64_t available = Size() - std::min(Size(), offset);
-    size_t offset_ = static_cast<size_t>(offset);
     if (n > available) {
-      n = static_cast<size_t>(available);
+      n = available;
     }
     if (n == 0) {
       *result = Slice();
       return Status::OK();
     }
     if (scratch) {
-      memcpy(scratch, &(data_[offset_]), n);
+      memcpy(scratch, &(data_[offset]), n);
       *result = Slice(scratch, n);
     } else {
-      *result = Slice(&(data_[offset_]), n);
+      *result = Slice(&(data_[offset]), n);
     }
     return Status::OK();
   }
 
   Status Write(uint64_t offset, const Slice& data) {
     MutexLock lock(&mutex_);
-    size_t offset_ = static_cast<size_t>(offset);
     if (offset + data.size() > data_.size()) {
-      data_.resize(offset_ + data.size());
+      data_.resize(offset + data.size());
     }
-    data_.replace(offset_, data.size(), data.data(), data.size());
+    data_.replace(offset, data.size(), data.data(), data.size());
     size_ = data_.size();
     modified_time_ = Now();
     return Status::OK();
@@ -205,7 +203,7 @@ class MockSequentialFile : public SequentialFile {
     if (pos_ > file_->Size()) {
       return Status::IOError("pos_ > file_->Size()");
     }
-    const uint64_t available = file_->Size() - pos_;
+    const size_t available = file_->Size() - pos_;
     if (n > available) {
       n = available;
     }
@@ -275,7 +273,7 @@ class MockWritableFile : public WritableFile {
   }
 
   virtual Status Append(const Slice& data) override {
-    size_t bytes_written = 0;
+    uint64_t bytes_written = 0;
     while (bytes_written < data.size()) {
       auto bytes = RequestToken(data.size() - bytes_written);
       Status s = file_->Append(Slice(data.data() + bytes_written, bytes));
@@ -287,7 +285,7 @@ class MockWritableFile : public WritableFile {
     return Status::OK();
   }
   virtual Status Truncate(uint64_t size) override {
-    file_->Truncate(static_cast<size_t>(size));
+    file_->Truncate(size);
     return Status::OK();
   }
   virtual Status Close() override { return file_->Fsync(); }
@@ -454,7 +452,7 @@ Status MockEnv::NewSequentialFile(const std::string& fname,
   auto fn = NormalizePath(fname);
   MutexLock lock(&mutex_);
   if (file_map_.find(fn) == file_map_.end()) {
-    *result = nullptr;
+    *result = NULL;
     return Status::IOError(fn, "File not found");
   }
   auto* f = file_map_[fn];
@@ -471,7 +469,7 @@ Status MockEnv::NewRandomAccessFile(const std::string& fname,
   auto fn = NormalizePath(fname);
   MutexLock lock(&mutex_);
   if (file_map_.find(fn) == file_map_.end()) {
-    *result = nullptr;
+    *result = NULL;
     return Status::IOError(fn, "File not found");
   }
   auto* f = file_map_[fn];
@@ -488,7 +486,7 @@ Status MockEnv::NewRandomRWFile(const std::string& fname,
   auto fn = NormalizePath(fname);
   MutexLock lock(&mutex_);
   if (file_map_.find(fn) == file_map_.end()) {
-    *result = nullptr;
+    *result = NULL;
     return Status::IOError(fn, "File not found");
   }
   auto* f = file_map_[fn];

env/posix_logger.h

@@ -52,7 +52,9 @@ class PosixLogger : public Logger {
   std::atomic<bool> flush_pending_;
 
  protected:
-  virtual Status CloseImpl() override { return PosixCloseHelper(); }
+  virtual Status CloseImpl() override {
+    return PosixCloseHelper();
+  }
 
  public:
   PosixLogger(FILE* f, uint64_t (*gettid)(), Env* env,

include/rocksdb/advanced_options.h

@@ -253,7 +253,7 @@ struct AdvancedColumnFamilyOptions {
   // if prefix_extractor is set and memtable_prefix_bloom_size_ratio is not 0,
   // create prefix bloom for memtable with the size of
   // write_buffer_size * memtable_prefix_bloom_size_ratio.
-  // If it is larger than 0.25, it is sanitized to 0.25.
+  // If it is larger than 0.25, it is santinized to 0.25.
   //
   // Default: 0 (disable)
   //
@@ -560,7 +560,7 @@ struct AdvancedColumnFamilyOptions {
   // Default: false
   bool paranoid_file_checks = false;
 
-  // In debug mode, RocksDB run consistency checks on the LSM every time the LSM
+  // In debug mode, RocksDB run consistency checks on the LSM everytime the LSM
   // change (Flush, Compaction, AddFile). These checks are disabled in release
   // mode, use this option to enable them in release mode as well.
   // Default: false

include/rocksdb/c.h

@@ -113,7 +113,6 @@ typedef struct rocksdb_envoptions_t      rocksdb_envoptions_t;
 typedef struct rocksdb_ingestexternalfileoptions_t rocksdb_ingestexternalfileoptions_t;
 typedef struct rocksdb_sstfilewriter_t   rocksdb_sstfilewriter_t;
 typedef struct rocksdb_ratelimiter_t     rocksdb_ratelimiter_t;
-typedef struct rocksdb_perfcontext_t     rocksdb_perfcontext_t;
 typedef struct rocksdb_pinnableslice_t rocksdb_pinnableslice_t;
 typedef struct rocksdb_transactiondb_options_t rocksdb_transactiondb_options_t;
 typedef struct rocksdb_transactiondb_t rocksdb_transactiondb_t;
@@ -130,9 +129,6 @@ typedef struct rocksdb_checkpoint_t rocksdb_checkpoint_t;
 extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open(
     const rocksdb_options_t* options, const char* name, char** errptr);
 
-extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_with_ttl(
-    const rocksdb_options_t* options, const char* name, int ttl, char** errptr);
-
 extern ROCKSDB_LIBRARY_API rocksdb_t* rocksdb_open_for_read_only(
     const rocksdb_options_t* options, const char* name,
     unsigned char error_if_log_file_exist, char** errptr);
@@ -970,97 +966,6 @@ extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
     int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness);
 extern ROCKSDB_LIBRARY_API void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t*);
 
-/* PerfContext */
-enum {
-  rocksdb_uninitialized = 0,
-  rocksdb_disable = 1,
-  rocksdb_enable_count = 2,
-  rocksdb_enable_time_except_for_mutex = 3,
-  rocksdb_enable_time = 4,
-  rocksdb_out_of_bounds = 5
-};
-
-enum {
-  rocksdb_user_key_comparison_count = 0,
-  rocksdb_block_cache_hit_count,
-  rocksdb_block_read_count,
-  rocksdb_block_read_byte,
-  rocksdb_block_read_time,
-  rocksdb_block_checksum_time,
-  rocksdb_block_decompress_time,
-  rocksdb_get_read_bytes,
-  rocksdb_multiget_read_bytes,
-  rocksdb_iter_read_bytes,
-  rocksdb_internal_key_skipped_count,
-  rocksdb_internal_delete_skipped_count,
-  rocksdb_internal_recent_skipped_count,
-  rocksdb_internal_merge_count,
-  rocksdb_get_snapshot_time,
-  rocksdb_get_from_memtable_time,
-  rocksdb_get_from_memtable_count,
-  rocksdb_get_post_process_time,
-  rocksdb_get_from_output_files_time,
-  rocksdb_seek_on_memtable_time,
-  rocksdb_seek_on_memtable_count,
-  rocksdb_next_on_memtable_count,
-  rocksdb_prev_on_memtable_count,
-  rocksdb_seek_child_seek_time,
-  rocksdb_seek_child_seek_count,
-  rocksdb_seek_min_heap_time,
-  rocksdb_seek_max_heap_time,
-  rocksdb_seek_internal_seek_time,
-  rocksdb_find_next_user_entry_time,
-  rocksdb_write_wal_time,
-  rocksdb_write_memtable_time,
-  rocksdb_write_delay_time,
-  rocksdb_write_pre_and_post_process_time,
-  rocksdb_db_mutex_lock_nanos,
-  rocksdb_db_condition_wait_nanos,
-  rocksdb_merge_operator_time_nanos,
-  rocksdb_read_index_block_nanos,
-  rocksdb_read_filter_block_nanos,
-  rocksdb_new_table_block_iter_nanos,
-  rocksdb_new_table_iterator_nanos,
-  rocksdb_block_seek_nanos,
-  rocksdb_find_table_nanos,
-  rocksdb_bloom_memtable_hit_count,
-  rocksdb_bloom_memtable_miss_count,
-  rocksdb_bloom_sst_hit_count,
-  rocksdb_bloom_sst_miss_count,
-  rocksdb_key_lock_wait_time,
-  rocksdb_key_lock_wait_count,
-  rocksdb_env_new_sequential_file_nanos,
-  rocksdb_env_new_random_access_file_nanos,
-  rocksdb_env_new_writable_file_nanos,
-  rocksdb_env_reuse_writable_file_nanos,
-  rocksdb_env_new_random_rw_file_nanos,
-  rocksdb_env_new_directory_nanos,
-  rocksdb_env_file_exists_nanos,
-  rocksdb_env_get_children_nanos,
-  rocksdb_env_get_children_file_attributes_nanos,
-  rocksdb_env_delete_file_nanos,
-  rocksdb_env_create_dir_nanos,
-  rocksdb_env_create_dir_if_missing_nanos,
-  rocksdb_env_delete_dir_nanos,
-  rocksdb_env_get_file_size_nanos,
-  rocksdb_env_get_file_modification_time_nanos,
-  rocksdb_env_rename_file_nanos,
-  rocksdb_env_link_file_nanos,
-  rocksdb_env_lock_file_nanos,
-  rocksdb_env_unlock_file_nanos,
-  rocksdb_env_new_logger_nanos,
-  rocksdb_total_metric_count = 68
-};
-
-extern ROCKSDB_LIBRARY_API void rocksdb_set_perf_level(int);
-extern ROCKSDB_LIBRARY_API rocksdb_perfcontext_t* rocksdb_perfcontext_create();
-extern ROCKSDB_LIBRARY_API void rocksdb_perfcontext_reset(
-    rocksdb_perfcontext_t* context);
-extern ROCKSDB_LIBRARY_API char* rocksdb_perfcontext_report(
-    rocksdb_perfcontext_t* context, unsigned char exclude_zero_counters);
-extern ROCKSDB_LIBRARY_API uint64_t rocksdb_perfcontext_metric(
-    rocksdb_perfcontext_t* context, int metric);
-
 /* Compaction Filter */
 
 extern ROCKSDB_LIBRARY_API rocksdb_compactionfilter_t*

include/rocksdb/cleanable.h

@@ -30,7 +30,7 @@ class Cleanable {
   Cleanable(Cleanable&) = delete;
   Cleanable& operator=(Cleanable&) = delete;
 
-  // Move constructor and move assignment is allowed.
+  // Move consturctor and move assignment is allowed.
   Cleanable(Cleanable&&);
   Cleanable& operator=(Cleanable&&);
 

include/rocksdb/compaction_job_stats.h

@@ -72,7 +72,7 @@ struct CompactionJobStats {
   // Time spent on file fsync.
   uint64_t file_fsync_nanos;
 
-  // Time spent on preparing file write (fallocate, etc)
+  // Time spent on preparing file write (falocate, etc)
   uint64_t file_prepare_write_nanos;
 
   // 0-terminated strings storing the first 8 bytes of the smallest and

include/rocksdb/db.h

@@ -172,7 +172,7 @@ class DB {
                      std::vector<ColumnFamilyHandle*>* handles, DB** dbptr);
 
   // Close the DB by releasing resources, closing files etc. This should be
-  // called before calling the destructor so that the caller can get back a
+  // called before calling the desctructor so that the caller can get back a
   // status in case there are any errors. This will not fsync the WAL files.
   // If syncing is required, the caller must first call SyncWAL(), or Write()
   // using an empty write batch with WriteOptions.sync=true.
@@ -814,22 +814,19 @@ class DB {
       const CompactionOptions& compact_options,
       ColumnFamilyHandle* column_family,
       const std::vector<std::string>& input_file_names,
-      const int output_level, const int output_path_id = -1,
-      std::vector<std::string>* const output_file_names = nullptr) = 0;
+      const int output_level, const int output_path_id = -1) = 0;
 
   virtual Status CompactFiles(
       const CompactionOptions& compact_options,
       const std::vector<std::string>& input_file_names,
-      const int output_level, const int output_path_id = -1,
-      std::vector<std::string>* const output_file_names = nullptr) {
+      const int output_level, const int output_path_id = -1) {
     return CompactFiles(compact_options, DefaultColumnFamily(),
-                        input_file_names, output_level, output_path_id,
-                        output_file_names);
+                        input_file_names, output_level, output_path_id);
   }
 
   // This function will wait until all currently running background processes
   // finish. After it returns, no background process will be run until
-  // ContinueBackgroundWork is called
+  // UnblockBackgroundWork is called
   virtual Status PauseBackgroundWork() = 0;
   virtual Status ContinueBackgroundWork() = 0;
 

include/rocksdb/db_dump_tool.h

@@ -17,7 +17,7 @@ struct DumpOptions {
   std::string db_path;
   // File location that will contain dump output
   std::string dump_location;
-  // Don't include db information header in the dump
+  // Dont include db information header in the dump
   bool anonymous = false;
 };
 

include/rocksdb/env.h

@@ -321,7 +321,7 @@ class Env {
   // registered at the time of Schedule is invoked with arg as a parameter.
   virtual void Schedule(void (*function)(void* arg), void* arg,
                         Priority pri = LOW, void* tag = nullptr,
-                        void (*unschedFunction)(void* arg) = nullptr) = 0;
+                        void (*unschedFunction)(void* arg) = 0) = 0;
 
   // Arrange to remove jobs for given arg from the queue_ if they are not
   // already scheduled. Caller is expected to have exclusive lock on arg.
@@ -363,7 +363,7 @@ class Env {
     return NowMicros() * 1000;
   }
 
-  // Sleep/delay the thread for the prescribed number of micro-seconds.
+  // Sleep/delay the thread for the perscribed number of micro-seconds.
   virtual void SleepForMicroseconds(int micros) = 0;
 
   // Get the current host name.
@@ -802,10 +802,6 @@ class Directory {
   virtual ~Directory() {}
   // Fsync directory. Can be called concurrently from multiple threads.
   virtual Status Fsync() = 0;
-
-  virtual size_t GetUniqueId(char* id, size_t max_size) const {
-    return 0;
-  }
 };
 
 enum InfoLogLevel : unsigned char {
@@ -1029,7 +1025,7 @@ class EnvWrapper : public Env {
   Status UnlockFile(FileLock* l) override { return target_->UnlockFile(l); }
 
   void Schedule(void (*f)(void* arg), void* a, Priority pri,
-                void* tag = nullptr, void (*u)(void* arg) = nullptr) override {
+                void* tag = nullptr, void (*u)(void* arg) = 0) override {
     return target_->Schedule(f, a, pri, tag, u);
   }
 

include/rocksdb/env_encryption.h

@@ -133,7 +133,7 @@ class EncryptionProvider {
     // GetPrefixLength returns the length of the prefix that is added to every file
     // and used for storing encryption options.
     // For optimal performance, the prefix length should be a multiple of 
-    // the page size.
+    // the a page size.
     virtual size_t GetPrefixLength() = 0;
 
     // CreateNewPrefix initialized an allocated block of prefix memory 
@@ -165,7 +165,7 @@ class CTREncryptionProvider : public EncryptionProvider {
     // GetPrefixLength returns the length of the prefix that is added to every file
     // and used for storing encryption options.
     // For optimal performance, the prefix length should be a multiple of 
-    // the page size.
+    // the a page size.
     virtual size_t GetPrefixLength() override;
 
     // CreateNewPrefix initialized an allocated block of prefix memory 

include/rocksdb/listener.h

@@ -83,7 +83,7 @@ enum class CompactionReason {
 };
 
 enum class FlushReason : int {
-  kOthers = 0x00,
+  kUnknown = 0x00,
   kGetLiveFiles = 0x01,
   kShutDown = 0x02,
   kExternalFileIngestion = 0x03,
@@ -91,9 +91,7 @@ enum class FlushReason : int {
   kWriteBufferManager = 0x05,
   kWriteBufferFull = 0x06,
   kTest = 0x07,
-  kDeleteFiles = 0x08,
-  kAutoCompaction = 0x09,
-  kManualFlush = 0x0a,
+  kSuperVersionChange = 0x08,
 };
 
 enum class BackgroundErrorReason {

include/rocksdb/memtablerep.h

@@ -39,34 +39,24 @@
 #include <stdexcept>
 #include <stdint.h>
 #include <stdlib.h>
-#include <rocksdb/slice.h>
 
 namespace rocksdb {
 
 class Arena;
 class Allocator;
 class LookupKey;
+class Slice;
 class SliceTransform;
 class Logger;
 
 typedef void* KeyHandle;
 
-extern Slice GetLengthPrefixedSlice(const char* data);
-
 class MemTableRep {
  public:
   // KeyComparator provides a means to compare keys, which are internal keys
   // concatenated with values.
   class KeyComparator {
    public:
-    typedef rocksdb::Slice DecodedType;
-
-    virtual DecodedType decode_key(const char* key) const {
-      // The format of key is frozen and can be terated as a part of the API
-      // contract. Refer to MemTable::Add for details.
-      return GetLengthPrefixedSlice(key);
-    }
-
     // Compare a and b. Return a negative value if a is less than b, 0 if they
     // are equal, and a positive value if a is greater than b
     virtual int operator()(const char* prefix_len_key1,
@@ -356,7 +346,7 @@ extern MemTableRepFactory* NewHashLinkListRepFactory(
 
 // This factory creates a cuckoo-hashing based mem-table representation.
 // Cuckoo-hash is a closed-hash strategy, in which all key/value pairs
-// are stored in the bucket array itself instead of in some data structures
+// are stored in the bucket array itself intead of in some data structures
 // external to the bucket array.  In addition, each key in cuckoo hash
 // has a constant number of possible buckets in the bucket array.  These
 // two properties together makes cuckoo hash more memory efficient and

include/rocksdb/merge_operator.h

@@ -87,7 +87,7 @@ class MergeOperator {
     // The key associated with the merge operation.
     const Slice& key;
     // The existing value of the current key, nullptr means that the
-    // value doesn't exist.
+    // value dont exist.
     const Slice* existing_value;
     // A list of operands to apply.
     const std::vector<Slice>& operand_list;

include/rocksdb/slice.h

@@ -121,7 +121,7 @@ class Slice {
 /**
  * A Slice that can be pinned with some cleanup tasks, which will be run upon
  * ::Reset() or object destruction, whichever is invoked first. This can be used
- * to avoid memcpy by having the PinnableSlice object referring to the data
+ * to avoid memcpy by having the PinnsableSlice object referring to the data
  * that is locked in the memory and release them after the data is consumed.
  */
 class PinnableSlice : public Slice, public Cleanable {

include/rocksdb/slice_transform.h

@@ -22,7 +22,7 @@ namespace rocksdb {
 class Slice;
 
 /*
- * A SliceTransform is a generic pluggable way of transforming one string
+ * A SliceTranform is a generic pluggable way of transforming one string
  * to another. Its primary use-case is in configuring rocksdb
  * to store prefix blooms by setting prefix_extractor in
  * ColumnFamilyOptions.
@@ -72,7 +72,7 @@ class SliceTransform {
   // by setting ReadOptions.total_order_seek = true.
   //
   // Here is an example: Suppose we implement a slice transform that returns
-  // the first part of the string after splitting it using delimiter ",":
+  // the first part of the string after spliting it using delimiter ",":
   // 1. SameResultWhenAppended("abc,") should return true. If applying prefix
   //    bloom filter using it, all slices matching "abc:.*" will be extracted
   //    to "abc,", so any SST file or memtable containing any of those key

include/rocksdb/sst_file_manager.h

@@ -35,22 +35,12 @@ class SstFileManager {
   // thread-safe.
   virtual void SetMaxAllowedSpaceUsage(uint64_t max_allowed_space) = 0;
 
-  // Set the amount of buffer room each compaction should be able to leave.
-  // In other words, at its maximum disk space consumption, the compaction
-  // should still leave compaction_buffer_size available on the disk so that
-  // other background functions may continue, such as logging and flushing.
-  virtual void SetCompactionBufferSize(uint64_t compaction_buffer_size) = 0;
-
   // Return true if the total size of SST files exceeded the maximum allowed
   // space usage.
   //
   // thread-safe.
   virtual bool IsMaxAllowedSpaceReached() = 0;
 
-  // Returns true if the total size of SST files as well as estimated size
-  // of ongoing compactions exceeds the maximums allowed space usage.
-  virtual bool IsMaxAllowedSpaceReachedIncludingCompactions() = 0;
-
   // Return the total size of all tracked files.
   // thread-safe
   virtual uint64_t GetTotalSize() = 0;
@@ -96,14 +86,10 @@ class SstFileManager {
 // @param max_trash_db_ratio: If the trash size constitutes for more than this
 //    fraction of the total DB size we will start deleting new files passed to
 //    DeleteScheduler immediately
-// @param bytes_max_delete_chunk: if a single file is larger than delete chunk,
-//    ftruncate the file by this size each time, rather than dropping the whole
-//    file. 0 means to always delete the whole file.
 extern SstFileManager* NewSstFileManager(
     Env* env, std::shared_ptr<Logger> info_log = nullptr,
     std::string trash_dir = "", int64_t rate_bytes_per_sec = 0,
     bool delete_existing_trash = true, Status* status = nullptr,
-    double max_trash_db_ratio = 0.25,
-    uint64_t bytes_max_delete_chunk = 64 * 1024 * 1024);
+    double max_trash_db_ratio = 0.25);
 
 }  // namespace rocksdb

include/rocksdb/sst_file_writer.h

@@ -67,7 +67,7 @@ class SstFileWriter {
   // be ingested into this column_family, note that passing nullptr means that
   // the column_family is unknown.
   // If invalidate_page_cache is set to true, SstFileWriter will give the OS a
-  // hint that this file pages is not needed every time we write 1MB to the file.
+  // hint that this file pages is not needed everytime we write 1MB to the file.
   // To use the rate limiter an io_priority smaller than IO_TOTAL can be passed.
   SstFileWriter(const EnvOptions& env_options, const Options& options,
                 ColumnFamilyHandle* column_family = nullptr,

include/rocksdb/statistics.h

@@ -108,8 +108,6 @@ enum Tickers : uint32_t {
   COMPACTION_RANGE_DEL_DROP_OBSOLETE,  // all keys in range were deleted.
   // Deletions obsoleted before bottom level due to file gap optimization.
   COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE,
-  // If a compaction was cancelled in sfm to prevent ENOSPC
-  COMPACTION_CANCELLED,
 
   // Number of keys written to the database via the Put and Write call's
   NUMBER_KEYS_WRITTEN,
@@ -267,16 +265,7 @@ enum Tickers : uint32_t {
   BLOB_DB_BLOB_FILE_SYNCED,
   // # of blob index evicted from base DB by BlobDB compaction filter because
   // of expiration.
-  BLOB_DB_BLOB_INDEX_EXPIRED_COUNT,
-  // size of blob index evicted from base DB by BlobDB compaction filter
-  // because of expiration.
-  BLOB_DB_BLOB_INDEX_EXPIRED_SIZE,
-  // # of blob index evicted from base DB by BlobDB compaction filter because
-  // of corresponding file deleted.
-  BLOB_DB_BLOB_INDEX_EVICTED_COUNT,
-  // size of blob index evicted from base DB by BlobDB compaction filter
-  // because of corresponding file deleted.
-  BLOB_DB_BLOB_INDEX_EVICTED_SIZE,
+  BLOB_DB_BLOB_INDEX_EXPIRED,
   // # of blob files being garbage collected.
   BLOB_DB_GC_NUM_FILES,
   // # of blob files generated by garbage collection.
@@ -349,8 +338,6 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
      "rocksdb.compaction.range_del.drop.obsolete"},
     {COMPACTION_OPTIMIZED_DEL_DROP_OBSOLETE,
      "rocksdb.compaction.optimized.del.drop.obsolete"},
-    {COMPACTION_CANCELLED,
-     "rocksdb.compaction.cancelled"},
     {NUMBER_KEYS_WRITTEN, "rocksdb.number.keys.written"},
     {NUMBER_KEYS_READ, "rocksdb.number.keys.read"},
     {NUMBER_KEYS_UPDATED, "rocksdb.number.keys.updated"},
@@ -430,12 +417,7 @@ const std::vector<std::pair<Tickers, std::string>> TickersNameMap = {
     {BLOB_DB_BLOB_FILE_BYTES_WRITTEN, "rocksdb.blobdb.blob.file.bytes.written"},
     {BLOB_DB_BLOB_FILE_BYTES_READ, "rocksdb.blobdb.blob.file.bytes.read"},
     {BLOB_DB_BLOB_FILE_SYNCED, "rocksdb.blobdb.blob.file.synced"},
-    {BLOB_DB_BLOB_INDEX_EXPIRED_COUNT,
-     "rocksdb.blobdb.blob.index.expired.count"},
-    {BLOB_DB_BLOB_INDEX_EXPIRED_SIZE, "rocksdb.blobdb.blob.index.expired.size"},
-    {BLOB_DB_BLOB_INDEX_EVICTED_COUNT,
-     "rocksdb.blobdb.blob.index.evicted.count"},
-    {BLOB_DB_BLOB_INDEX_EVICTED_SIZE, "rocksdb.blobdb.blob.index.evicted.size"},
+    {BLOB_DB_BLOB_INDEX_EXPIRED, "rocksdb.blobdb.blob.index.expired"},
     {BLOB_DB_GC_NUM_FILES, "rocksdb.blobdb.gc.num.files"},
     {BLOB_DB_GC_NUM_NEW_FILES, "rocksdb.blobdb.gc.num.new.files"},
     {BLOB_DB_GC_FAILURES, "rocksdb.blobdb.gc.failures"},

include/rocksdb/status.h

@@ -58,8 +58,7 @@ class Status {
     kAborted = 10,
     kBusy = 11,
     kExpired = 12,
-    kTryAgain = 13,
-    kCompactionTooLarge = 14
+    kTryAgain = 13
   };
 
   Code code() const { return code_; }
@@ -163,14 +162,6 @@ class Status {
     return Status(kTryAgain, msg, msg2);
   }
 
-  static Status CompactionTooLarge(SubCode msg = kNone) {
-    return Status(kCompactionTooLarge, msg);
-  }
-  static Status CompactionTooLarge(const Slice& msg,
-                                   const Slice& msg2 = Slice()) {
-    return Status(kCompactionTooLarge, msg, msg2);
-  }
-
   static Status NoSpace() { return Status(kIOError, kNoSpace); }
   static Status NoSpace(const Slice& msg, const Slice& msg2 = Slice()) {
     return Status(kIOError, kNoSpace, msg, msg2);
@@ -230,9 +221,6 @@ class Status {
   // re-attempted.
   bool IsTryAgain() const { return code() == kTryAgain; }
 
-  // Returns true iff the status indicates the proposed compaction is too large
-  bool IsCompactionTooLarge() const { return code() == kCompactionTooLarge; }
-
   // Returns true iff the status indicates a NoSpace error
   // This is caused by an I/O error returning the specific "out of space"
   // error condition. Stricto sensu, an NoSpace error is an I/O error

include/rocksdb/table.h

@@ -156,7 +156,7 @@ struct BlockBasedTableOptions {
   // well.
   // TODO(myabandeh): remove the note above once the limitation is lifted
   // Use partitioned full filters for each SST file. This option is
-  // incompatible with block-based filters.
+  // incompatibile with block-based filters.
   bool partition_filters = false;
 
   // Use delta encoding to compress keys in blocks.
@@ -214,7 +214,7 @@ struct BlockBasedTableOptions {
   // encode compressed blocks with LZ4, BZip2 and Zlib compression. If you
   // don't plan to run RocksDB before version 3.10, you should probably use
   // this.
-  // This option only affects newly written tables. When reading existing tables,
+  // This option only affects newly written tables. When reading exising tables,
   // the information about version is read from the footer.
   uint32_t format_version = 2;
 
@@ -226,7 +226,7 @@ struct BlockBasedTableOptions {
 
 // Table Properties that are specific to block-based table properties.
 struct BlockBasedTablePropertyNames {
-  // value of this properties is a fixed int32 number.
+  // value of this propertis is a fixed int32 number.
   static const std::string kIndexType;
   // value is "1" for true and "0" for false.
   static const std::string kWholeKeyFiltering;
@@ -319,7 +319,7 @@ struct PlainTableOptions {
 };
 
 // -- Plain Table with prefix-only seek
-// For this factory, you need to set Options.prefix_extractor properly to make it
+// For this factory, you need to set Options.prefix_extrator properly to make it
 // work. Look-up will starts with prefix hash lookup for key prefix. Inside the
 // hash bucket found, a binary search is executed for hash conflicts. Finally,
 // a linear search is used.
@@ -382,7 +382,7 @@ struct CuckooTableOptions {
   bool identity_as_first_hash = false;
   // If this option is set to true, module is used during hash calculation.
   // This often yields better space efficiency at the cost of performance.
-  // If this option is set to false, # of entries in table is constrained to be
+  // If this optino is set to false, # of entries in table is constrained to be
   // power of two, and bit and is used to calculate hash, which is faster in
   // general.
   bool use_module_hash = true;

include/rocksdb/table_properties.h

@@ -15,7 +15,7 @@ namespace rocksdb {
 // Other than basic table properties, each table may also have the user
 // collected properties.
 // The value of the user-collected properties are encoded as raw bytes --
-// users have to interpret these values by themselves.
+// users have to interprete these values by themselves.
 // Note: To do prefix seek/scan in `UserCollectedProperties`, you can do
 // something similar to:
 //
@@ -59,7 +59,7 @@ extern const std::string kRangeDelBlock;
 // `TablePropertiesCollector` provides the mechanism for users to collect
 // their own properties that they are interested in. This class is essentially
 // a collection of callback functions that will be invoked during table
-// building. It is constructed with TablePropertiesCollectorFactory. The methods
+// building. It is construced with TablePropertiesCollectorFactory. The methods
 // don't need to be thread-safe, as we will create exactly one
 // TablePropertiesCollector object per table and then call it sequentially
 class TablePropertiesCollector {

include/rocksdb/utilities/stackable_db.h

@@ -219,11 +219,10 @@ class StackableDB : public DB {
       const CompactionOptions& compact_options,
       ColumnFamilyHandle* column_family,
       const std::vector<std::string>& input_file_names,
-      const int output_level, const int output_path_id = -1,
-      std::vector<std::string>* const output_file_names = nullptr) override {
+      const int output_level, const int output_path_id = -1) override {
     return db_->CompactFiles(
         compact_options, column_family, input_file_names,
-        output_level, output_path_id, output_file_names);
+        output_level, output_path_id);
   }
 
   virtual Status PauseBackgroundWork() override {

include/rocksdb/utilities/transaction.h

@@ -118,7 +118,7 @@ class Transaction {
   // longer be valid and should be discarded after a call to ClearSnapshot().
   virtual void ClearSnapshot() = 0;
 
-  // Prepare the current transaction for 2PC
+  // Prepare the current transation for 2PC
   virtual Status Prepare() = 0;
 
   // Write all batched keys to the db atomically.
@@ -169,8 +169,8 @@ class Transaction {
                      ColumnFamilyHandle* column_family, const Slice& key,
                      std::string* value) = 0;
 
-  // An overload of the above method that receives a PinnableSlice
-  // For backward compatibility a default implementation is provided
+  // An overload of the the above method that receives a PinnableSlice
+  // For backward compatiblity a default implementation is provided
   virtual Status Get(const ReadOptions& options,
                      ColumnFamilyHandle* column_family, const Slice& key,
                      PinnableSlice* pinnable_val) {
@@ -230,8 +230,8 @@ class Transaction {
                               const Slice& key, std::string* value,
                               bool exclusive = true) = 0;
 
-  // An overload of the above method that receives a PinnableSlice
-  // For backward compatibility a default implementation is provided
+  // An overload of the the above method that receives a PinnableSlice
+  // For backward compatiblity a default implementation is provided
   virtual Status GetForUpdate(const ReadOptions& options,
                               ColumnFamilyHandle* /*column_family*/,
                               const Slice& key, PinnableSlice* pinnable_val,
@@ -368,7 +368,7 @@ class Transaction {
   virtual void EnableIndexing() = 0;
 
   // Returns the number of distinct Keys being tracked by this transaction.
-  // If this transaction was created by a TransactionDB, this is the number of
+  // If this transaction was created by a TransactinDB, this is the number of
   // keys that are currently locked by this transaction.
   // If this transaction was created by an OptimisticTransactionDB, this is the
   // number of keys that need to be checked for conflicts at commit time.

include/rocksdb/utilities/transaction_db.h

@@ -75,7 +75,7 @@ struct TransactionDBOptions {
   // expiration set.
   int64_t default_lock_timeout = 1000;  // 1 second
 
-  // If set, the TransactionDB will use this implementation of a mutex and
+  // If set, the TransactionDB will use this implemenation of a mutex and
   // condition variable for all transaction locking instead of the default
   // mutex/condvar implementation.
   std::shared_ptr<TransactionDBMutexFactory> custom_mutex_factory;
@@ -100,7 +100,7 @@ struct TransactionOptions {
   // If set, it states that the CommitTimeWriteBatch represents the latest state
   // of the application and meant to be used later during recovery. It enables
   // an optimization to postpone updating the memtable with CommitTimeWriteBatch
-  // to only SwitchMemtable or recovery.
+  // to only SwithcMamtable or recovery.
   bool use_only_the_last_commit_time_batch_for_recovery = false;
 
   // TODO(agiardullo): TransactionDB does not yet support comparators that allow
@@ -131,15 +131,15 @@ struct TransactionOptions {
 };
 
 // The per-write optimizations that do not involve transactions. TransactionDB
-// implementation might or might not make use of the specified optimizations.
+// implemenation might or might not make use of the specified optimizations.
 struct TransactionDBWriteOptimizations {
-  // If it is true it means that the application guarantees that the
+  // If it is true it means that the applicatinn guratnees that the
   // key-set in the write batch do not conflict with any concurrent transaction
   // and hence the concurrency control mechanism could be skipped for this
   // write.
   bool skip_concurrency_control = false;
   // If true, the application guarantees that there is no duplicate <column
-  // family, key> in the write batch and any employed mechanism to handle
+  // family, key> in the write batch and any employed mechanism to hanlde
   // duplicate keys could be skipped.
   bool skip_duplicate_key_check = false;
 };

include/rocksdb/utilities/write_batch_with_index.h

@@ -188,7 +188,7 @@ class WriteBatchWithIndex : public WriteBatchBase {
   Status GetFromBatchAndDB(DB* db, const ReadOptions& read_options,
                            const Slice& key, std::string* value);
 
-  // An overload of the above method that receives a PinnableSlice
+  // An overload of the the above method that receives a PinnableSlice
   Status GetFromBatchAndDB(DB* db, const ReadOptions& read_options,
                            const Slice& key, PinnableSlice* value);
 
@@ -196,7 +196,7 @@ class WriteBatchWithIndex : public WriteBatchBase {
                            ColumnFamilyHandle* column_family, const Slice& key,
                            std::string* value);
 
-  // An overload of the above method that receives a PinnableSlice
+  // An overload of the the above method that receives a PinnableSlice
   Status GetFromBatchAndDB(DB* db, const ReadOptions& read_options,
                            ColumnFamilyHandle* column_family, const Slice& key,
                            PinnableSlice* value);
@@ -227,7 +227,6 @@ class WriteBatchWithIndex : public WriteBatchBase {
   void SetMaxBytes(size_t max_bytes) override;
 
  private:
-  friend class PessimisticTransactionDB;
   friend class WritePreparedTxn;
   friend class WriteBatchWithIndex_SubBatchCnt_Test;
   // Returns the number of sub-batches inside the write batch. A sub-batch

include/rocksdb/version.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #define ROCKSDB_MAJOR 5
-#define ROCKSDB_MINOR 13
+#define ROCKSDB_MINOR 10
 #define ROCKSDB_PATCH 0
 
 // Do not use these. We made the mistake of declaring macros starting with

include/rocksdb/write_batch.h

@@ -334,7 +334,7 @@ class WriteBatch : public WriteBatchBase {
   friend class WriteBatchInternal;
   friend class LocalSavePoint;
   // TODO(myabandeh): this is needed for a hack to collapse the write batch and
-  // remove duplicate keys. Remove it when the hack is replaced with a proper
+  // remove duplicate keys. Remove it when the hack is replaced with a propper
   // solution.
   friend class WriteBatchWithIndex;
   SavePoints* save_points_;

include/rocksdb/write_batch_base.h

@@ -20,7 +20,7 @@ struct SliceParts;
 
 // Abstract base class that defines the basic interface for a write batch.
 // See WriteBatch for a basic implementation and WrithBatchWithIndex for an
-// indexed implementation.
+// indexed implemenation.
 class WriteBatchBase {
  public:
   virtual ~WriteBatchBase() {}

java/CMakeLists.txt

@@ -24,7 +24,6 @@ set(JNI_NATIVE_SOURCES
         rocksjni/lru_cache.cc
         rocksjni/memtablejni.cc
         rocksjni/merge_operator.cc
-        rocksjni/native_comparator_wrapper_test.cc
         rocksjni/options.cc
         rocksjni/options_util.cc
         rocksjni/ratelimiterjni.cc
@@ -88,8 +87,6 @@ set(NATIVE_JAVA_CLASSES
         org.rocksdb.LRUCache
         org.rocksdb.MemTableConfig
         org.rocksdb.MergeOperator
-        org.rocksdb.NativeComparatorWrapper
-        org.rocksdb.NativeComparatorWrapperTest.NativeStringComparatorWrapper
         org.rocksdb.NativeLibraryLoader
         org.rocksdb.Options
         org.rocksdb.OptionsUtil
@@ -125,8 +122,6 @@ set(NATIVE_JAVA_CLASSES
         org.rocksdb.WriteBatchTestInternalHelper
         org.rocksdb.WriteBatchWithIndex
         org.rocksdb.WriteOptions
-        org.rocksdb.util.CapturingWriteBatchHandler
-        org.rocksdb.util.WriteBatchGetter
 )
 
 include(FindJava)
@@ -182,7 +177,6 @@ add_jar(
   src/main/java/org/rocksdb/CompactionStyle.java
   src/main/java/org/rocksdb/Comparator.java
   src/main/java/org/rocksdb/ComparatorOptions.java
-  src/main/java/org/rocksdb/ComparatorType.java
   src/main/java/org/rocksdb/CompressionOptions.java
   src/main/java/org/rocksdb/CompressionType.java
   src/main/java/org/rocksdb/DBOptions.java
@@ -209,7 +203,6 @@ add_jar(
   src/main/java/org/rocksdb/MergeOperator.java
   src/main/java/org/rocksdb/MutableColumnFamilyOptions.java
   src/main/java/org/rocksdb/MutableColumnFamilyOptionsInterface.java
-  src/main/java/org/rocksdb/NativeComparatorWrapper.java
   src/main/java/org/rocksdb/NativeLibraryLoader.java
   src/main/java/org/rocksdb/Options.java
   src/main/java/org/rocksdb/OptionsUtil.java
@@ -251,14 +244,11 @@ add_jar(
   src/main/java/org/rocksdb/WriteOptions.java
   src/test/java/org/rocksdb/BackupEngineTest.java
   src/test/java/org/rocksdb/IngestExternalFileOptionsTest.java
-  src/test/java/org/rocksdb/NativeComparatorWrapperTest.java
   src/test/java/org/rocksdb/PlatformRandomHelper.java
   src/test/java/org/rocksdb/RocksDBExceptionTest.java
   src/test/java/org/rocksdb/RocksMemoryResource.java
   src/test/java/org/rocksdb/SnapshotTest.java
   src/test/java/org/rocksdb/WriteBatchTest.java
-  src/test/java/org/rocksdb/util/CapturingWriteBatchHandler.java
-  src/test/java/org/rocksdb/util/WriteBatchGetter.java
   INCLUDE_JARS ${JAVA_TESTCLASSPATH}
 )
 

java/Makefile

@@ -30,7 +30,6 @@ NATIVE_JAVA_CLASSES = org.rocksdb.AbstractCompactionFilter\
 	org.rocksdb.Logger\
 	org.rocksdb.LRUCache\
 	org.rocksdb.MergeOperator\
-	org.rocksdb.NativeComparatorWrapper\
 	org.rocksdb.OptimisticTransactionDB\
 	org.rocksdb.OptimisticTransactionOptions\
 	org.rocksdb.Options\
@@ -65,7 +64,6 @@ NATIVE_JAVA_CLASSES = org.rocksdb.AbstractCompactionFilter\
 	org.rocksdb.WBWIRocksIterator
 
 NATIVE_JAVA_TEST_CLASSES = org.rocksdb.RocksDBExceptionTest\
-    org.rocksdb.NativeComparatorWrapperTest.NativeStringComparatorWrapper\
     org.rocksdb.WriteBatchTest\
     org.rocksdb.WriteBatchTestInternalHelper
 
@@ -113,7 +111,6 @@ JAVA_TESTS = org.rocksdb.BackupableDBOptionsTest\
 	org.rocksdb.MergeTest\
 	org.rocksdb.MixedOptionsTest\
 	org.rocksdb.MutableColumnFamilyOptionsTest\
-	org.rocksdb.NativeComparatorWrapperTest\
 	org.rocksdb.NativeLibraryLoaderTest\
 	org.rocksdb.OptimisticTransactionTest\
 	org.rocksdb.OptimisticTransactionDBTest\

java/rocksjni/comparator.cc

@@ -14,7 +14,6 @@
 
 #include "include/org_rocksdb_Comparator.h"
 #include "include/org_rocksdb_DirectComparator.h"
-#include "include/org_rocksdb_NativeComparatorWrapper.h"
 #include "rocksjni/comparatorjnicallback.h"
 #include "rocksjni/portal.h"
 
@@ -50,16 +49,4 @@ jlong Java_org_rocksdb_DirectComparator_createNewDirectComparator0(
       new rocksdb::DirectComparatorJniCallback(env, jobj, copt);
   return reinterpret_cast<jlong>(c);
 }
-
-/*
- * Class:     org_rocksdb_NativeComparatorWrapper
- * Method:    disposeInternal
- * Signature: (J)V
- */
-void Java_org_rocksdb_NativeComparatorWrapper_disposeInternal(
-    JNIEnv* env, jobject jobj, jlong jcomparator_handle) {
-  auto* comparator =
-      reinterpret_cast<rocksdb::Comparator*>(jcomparator_handle);
-  delete comparator;
-}
 // </editor-fold>

java/rocksjni/merge_operator.cc

@@ -26,12 +26,12 @@
 /*
  * Class:     org_rocksdb_StringAppendOperator
  * Method:    newSharedStringAppendOperator
- * Signature: (C)J
+ * Signature: ()J
  */
 jlong Java_org_rocksdb_StringAppendOperator_newSharedStringAppendOperator
-(JNIEnv* env, jclass jclazz, jchar jdelim) {
+(JNIEnv* env, jclass jclazz) {
   auto* sptr_string_append_op = new std::shared_ptr<rocksdb::MergeOperator>(
-    rocksdb::MergeOperators::CreateStringAppendOperator((char) jdelim));
+    rocksdb::MergeOperators::CreateFromStringId("stringappend"));
   return reinterpret_cast<jlong>(sptr_string_append_op);
 }
 

java/rocksjni/native_comparator_wrapper_test.cc

@@ -1,50 +0,0 @@
-// Copyright (c) 2011-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 <jni.h>
-#include <string>
-
-#include "rocksdb/comparator.h"
-#include "rocksdb/slice.h"
-
-#include "include/org_rocksdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper.h"
-
-namespace rocksdb {
-
-class NativeComparatorWrapperTestStringComparator
-    : public Comparator {
-
-  const char* Name() const {
-    return "NativeComparatorWrapperTestStringComparator";
-  }
-
-  int Compare(
-      const Slice& a, const Slice& b) const {
-    return a.ToString().compare(b.ToString());
-  }
-
-  void FindShortestSeparator(
-      std::string* start, const Slice& limit) const {
-    return;
-  }
-
-  void FindShortSuccessor(
-      std::string* key) const {
-    return;
-  }
-};
-}  // end of rocksdb namespace
-
-/*
- * Class:     org_rocksdb_NativeComparatorWrapperTest_NativeStringComparatorWrapper
- * Method:    newStringComparator
- * Signature: ()J
- */
-jlong Java_org_rocksdb_NativeComparatorWrapperTest_00024NativeStringComparatorWrapper_newStringComparator(
-    JNIEnv* env , jobject jobj) {
-  auto* comparator =
-      new rocksdb::NativeComparatorWrapperTestStringComparator();
-  return reinterpret_cast<jlong>(comparator);
-}

java/rocksjni/options.cc

@@ -158,33 +158,19 @@ void Java_org_rocksdb_Options_setComparatorHandle__JI(
 /*
  * Class:     org_rocksdb_Options
  * Method:    setComparatorHandle
- * Signature: (JJB)V
+ * Signature: (JJZ)V
  */
-void Java_org_rocksdb_Options_setComparatorHandle__JJB(
+void Java_org_rocksdb_Options_setComparatorHandle__JJZ(
     JNIEnv* env, jobject jobj, jlong jopt_handle, jlong jcomparator_handle,
-    jbyte jcomparator_type) {
-  rocksdb::Comparator *comparator = nullptr;
-  switch(jcomparator_type) {
-      // JAVA_COMPARATOR
-      case 0x0:
-        comparator =
-            reinterpret_cast<rocksdb::ComparatorJniCallback*>(jcomparator_handle);
-        break;
-
-      // JAVA_DIRECT_COMPARATOR
-      case 0x1:
-        comparator =
-            reinterpret_cast<rocksdb::DirectComparatorJniCallback*>(jcomparator_handle);
-        break;
-
-      // JAVA_NATIVE_COMPARATOR_WRAPPER
-      case 0x2:
-        comparator =
-            reinterpret_cast<rocksdb::Comparator*>(jcomparator_handle);
-        break;
-  }
+    jboolean is_direct) {
   auto* opt = reinterpret_cast<rocksdb::Options*>(jopt_handle);
-  opt->comparator = comparator;
+  if(is_direct) {
+    opt->comparator =
+        reinterpret_cast<rocksdb::DirectComparatorJniCallback*>(jcomparator_handle);
+  } else {
+    opt->comparator =
+        reinterpret_cast<rocksdb::ComparatorJniCallback*>(jcomparator_handle);
+  }
 }
 
 /*
@@ -2998,33 +2984,19 @@ void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JI(
 /*
  * Class:     org_rocksdb_ColumnFamilyOptions
  * Method:    setComparatorHandle
- * Signature: (JJB)V
+ * Signature: (JJZ)V
  */
-void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJB(
+void Java_org_rocksdb_ColumnFamilyOptions_setComparatorHandle__JJZ(
     JNIEnv* env, jobject jobj, jlong jopt_handle, jlong jcomparator_handle,
-    jbyte jcomparator_type) {
-  rocksdb::Comparator *comparator = nullptr;
-  switch(jcomparator_type) {
-      // JAVA_COMPARATOR
-      case 0x0:
-        comparator =
-            reinterpret_cast<rocksdb::ComparatorJniCallback*>(jcomparator_handle);
-        break;
-
-      // JAVA_DIRECT_COMPARATOR
-      case 0x1:
-        comparator =
-            reinterpret_cast<rocksdb::DirectComparatorJniCallback*>(jcomparator_handle);
-        break;
-
-      // JAVA_NATIVE_COMPARATOR_WRAPPER
-      case 0x2:
-        comparator =
-            reinterpret_cast<rocksdb::Comparator*>(jcomparator_handle);
-        break;
-  }
+    jboolean is_direct) {
   auto* opt = reinterpret_cast<rocksdb::ColumnFamilyOptions*>(jopt_handle);
-  opt->comparator = comparator;
+  if(is_direct) {
+    opt->comparator =
+        reinterpret_cast<rocksdb::DirectComparatorJniCallback*>(jcomparator_handle);
+  } else {
+    opt->comparator =
+        reinterpret_cast<rocksdb::ComparatorJniCallback*>(jcomparator_handle);
+  }
 }
 
 /*